palette.cpp

Go to the documentation of this file.

#include <QtGui/qcolor.h>
#include <QtGui/qdialog.h>
#include <QtGui/qevent.h>
#include <QtGui/qpainter.h>
#include <QtGui/qmenu.h>
#include <limits.h>
#include <math.h>
#include "palette.h"
#include "ui_dqtscale.h"
#include "defs.h"

/*-------------------------------------------------------------------------*/
/* Palette des couleurs                                                    */
/*-------------------------------------------------------------------------*/
Palette::Palette(QWidget *parent)
  : QWidget( parent)
{
  m_vMin = 0;
  m_vMax = 8;
  CreatePaletteMenu();
  m_idxPal = BW;
  m_isLogScale = FALSE;
  AdjustScaleFactor();
  setFixedWidth(50);
}

Palette::~Palette()
{
}

void Palette::paintEvent(QPaintEvent *)
{
  QPainter paint(this);
  paintPalette(&paint);
}

void Palette::paintPalette(QPainter *p)
{
  QFontMetrics fm = p->fontMetrics();
  int htText = fm.height();
  int mg = 2;

  QString s;
  s.setNum(m_vMin);
  p->drawText(width() - fm.width(s) - mg, height(), s);

  s.setNum(m_vMax);
  int wMax = fm.width(s);
  p->drawText(width() - wMax - mg, htText, s);

  int y = 0;
  int yPrec = -1;

  QRect rectPal = QRect(0, 0, width() - wMax - 2*mg, height());

  for (unsigned int i = 0; i <= NB_COLORS; i++)
    {
      y = rectPal.height() * i / NB_COLORS;
      p->fillRect(rectPal.left(),
                  y + rectPal.top(),
                  rectPal.width(),
                  y - yPrec + 1,
                  GetColor(GetPalIndex(NB_COLORS-i)));
      yPrec = y;
    }

  int nbTicks = 16;
  bool found = FALSE;
  while (nbTicks > 2 && !found) {
    nbTicks--;
    if ((m_vMax - m_vMin) % nbTicks == 0) {
      found = TRUE;
    }
  }
  if (!found) {
    nbTicks = 10;
  }
  int x1 = rectPal.right();
  int x2 = x1 - rectPal.width()/2;
  
  for (int i = 1; i < nbTicks; i++) {
    int val = (m_vMax - (m_vMax - m_vMin) * i / nbTicks);
    y = rectPal.bottom() - rectPal.height() * (val - m_vMin) / (m_vMax - m_vMin);
    p->drawLine(x1, y, x2, y);
    s.setNum(val);
    p->drawText(width() - fm.width(s) - mg, y + htText/2, s);
  }
}

int Palette::GetPalIndex(int i) const
{
  if (m_isLogScale) {
    return (int)(log ((double)(1 + i)) * UCHAR_MAX / log((double)(1 + UCHAR_MAX)));
  }  
  return i;
}

int Palette::DataToIndex(int val)
{
  if (val > m_vMax) {
    return UCHAR_MAX;
  } else if (val <= m_vMin) {
    return 0;
  } else if (!m_isLogScale) {
    return (int)((val - m_vMin) * m_fact);
  } else {
    return (int)(log ((double)(1 + val - m_vMin)) * m_fact);
  }
}

QColor Palette::GetColor(int i) const 
{
  QColor c;

  switch (m_idxPal)
    {
    case BW :
      if (!i) {
        c = Qt::white;
      }
      else {
        int ind = (NB_COLORS-i)*256/NB_COLORS;
        c.setRgb(ind, ind, ind);
      }
      break;
    case COLOR : // convertFromImage() longer than for BW
      c.setHsv((NB_COLORS-i)*240/NB_COLORS, 255, 255);
      break;
    }
  return c;
}

void Palette::AdjustScaleFactor()
{
  if (m_isLogScale) {
    m_fact = (float)UCHAR_MAX / log(1 + (float)(m_vMax - m_vMin));
  } else {
    m_fact = (float)UCHAR_MAX / (float)(m_vMax - m_vMin);
  }
}

void Palette::CreatePaletteMenu()
{
  m_menuPalette = new QMenu("Display");

  m_menuColors = new QMenu("&Palette");
  m_menuColors->addAction("&Gray scale", this, SLOT(SelectBW()));
  m_menuColors->addAction("&Color", this, SLOT(SelectColor()));
  m_menuPalette->addMenu(m_menuColors);

  m_menuLinLog = new QMenu("&Scale");
  m_menuLinLog->addAction("&Linear", this, SLOT(SelectLinear()));
  m_menuLinLog->addAction("&Logarithmic", this, SLOT(SelectLogarithmic()));
  m_menuPalette->addMenu(m_menuLinLog);         

  QMenu* menuScale = new QMenu("&Adjust scale");
  menuScale->addAction("&Manual", this, SLOT(AdjustScale()));
  menuScale->addAction("&Automatic", this, SLOT(AdjustAutoScale()));
  m_menuPalette->addMenu(menuScale); 
}

void Palette::SelectBW()
{ 
  ChangePalette(BW);
}

void Palette::SelectColor()
{
  ChangePalette(COLOR);
}

void Palette::ChangePalette(int iPal) 
{
  if (iPal == m_idxPal) {
    return;
  }  
  m_idxPal = iPal;
  update();
  emit(PaletteModified());
}

void Palette::SelectLinear()
{
  ChangeLinLog(FALSE);
}
void Palette::SelectLogarithmic()
{
  ChangeLinLog(TRUE);
} 

void Palette::ChangeLinLog(bool type) 
{
  if (type == m_isLogScale) {
    return;
  }
  m_isLogScale = type;
  AdjustScaleFactor();
  update();
  emit(PaletteModified());
}

void Palette::mousePressEvent(QMouseEvent *e)
{
  if (e->button() != Qt::RightButton) {
    return;
  }  
  m_menuPalette->popup(e->globalPos());
}

void Palette::ChangeExtrema(int vMin, int vMax)
{
  if (vMin < vMax) { 
    m_vMin = vMin;
    m_vMax = vMax;
    AdjustScaleFactor();
    repaint();
    emit(PaletteModified());
  }
}

void Palette::ChangeDataMinMax(int min, int max)
{
  ChangeExtrema(min, max);
  m_dataMin = min;
  m_dataMax = max;
}

void Palette::AdjustScale()
{
  QDialog *window = new QDialog;
  Ui::DqtScale dscale;
  dscale.setupUi(window);
  dscale.m_spMin->setValue(m_vMin);
  dscale.m_spMax->setValue(m_vMax);
  if (window->exec()) {
    ChangeExtrema(dscale.m_spMin->value(), dscale.m_spMax->value());
  }
  delete window;
}

void Palette::AdjustAutoScale()
{
  ChangeExtrema(m_dataMin,m_dataMax);
}

int Palette::GetPal() const  {
  return m_idxPal;
}

int Palette::GetMin() const  {
  return m_vMin;
}

int Palette::GetMax() const  {
  return m_vMax;
}

bool Palette::IsLogScale() const  {
  return m_isLogScale;
}

QMenu* Palette::GetMenu() const  {
  return m_menuPalette;
}

---