src/GradientEditor.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2005-2007 Trolltech ASA. All rights reserved.
**
** This file is part of the demonstration applications of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** In addition, as a special exception, Trolltech gives you certain
** additional rights. These rights are described in the Trolltech GPL
** Exception version 1.0, which can be found at
** http://www.trolltech.com/products/qt/gplexception/ and in the file
** GPL_EXCEPTION.txt in this package.
**
** In addition, as a special exception, Trolltech, as the sole copyright
** holder for Qt Designer, grants users of the Qt/Eclipse Integration
** plug-in the right for the Qt/Eclipse Integration to link to
** functionality provided by Qt Designer and its related libraries.
**
** Trolltech reserves all rights not expressly granted herein.
** 
** Trolltech ASA (c) 2007
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "GradientEditor.h"
#include "HoverPoints.h"
#include <fstream>
#include <QWidget>

static int start = 0;

GradientEditor::GradientEditor(QWidget *parent, Qt::WindowFlags flags)
    : QWidget(parent, flags)
{
    printf("creating GradientEditor\n");
    
    setWindowTitle("Transferfunktion");
    m_parent = parent;

    vbox = new QVBoxLayout(this);
    vbox->setSpacing(1);
    vbox->setMargin(1);

    m_red_shade   = new ShadeWidget(ShadeWidget::RedShade,   this, "red"   );
    m_green_shade = new ShadeWidget(ShadeWidget::GreenShade, this, "green" );
    m_blue_shade  = new ShadeWidget(ShadeWidget::BlueShade,  this, "blue"  );
    m_alpha_shade = new ShadeWidget(ShadeWidget::ARGBShade,  this, "alpha" );

    vbox->addWidget( m_red_shade   );
    vbox->addWidget( m_green_shade );
    vbox->addWidget( m_blue_shade  );
    vbox->addWidget( m_alpha_shade, 3 );

    connect(m_red_shade,   SIGNAL( colorsChanged() ), this, SLOT( pointsUpdated() ));
    connect(m_green_shade, SIGNAL( colorsChanged() ), this, SLOT( pointsUpdated() ));
    connect(m_blue_shade,  SIGNAL( colorsChanged() ), this, SLOT( pointsUpdated() ));
    connect(m_alpha_shade, SIGNAL( colorsChanged() ), this, SLOT( pointsUpdated() ));

    if(start++)
      show();
}

//void GradientEditor::setRenderer(GradientRenderer* renderer)
//{
//  vbox->addWidget(renderer, 1);
//}

inline static bool x_less_than(const QPointF &p1, const QPointF &p2)
{
    return p1.x() < p2.x();
}



void GradientEditor::pointsUpdated()
{
    double w = m_alpha_shade->width();

    QGradientStops stops;

    QPolygonF points;

    points += m_red_shade->points();
    points += m_green_shade->points();
    points += m_blue_shade->points();
    points += m_alpha_shade->points();

    qSort(points.begin(), points.end(), x_less_than);

    for (int i=0; i<points.size(); ++i) 
    {
        double x = int( points.at(i).x() );

        if ( i < points.size()-1 && x == points.at(i+1).x() )
            continue;

        // ??
        QColor color((0x00ff0000 & m_red_shade->colorAt(int(x))) >> 16,
                     (0x0000ff00 & m_green_shade->colorAt(int(x))) >> 8,
                     (0x000000ff & m_blue_shade->colorAt(int(x))),
                     (0xff000000 & m_alpha_shade->colorAt(int(x))) >> 24);
/*
            std::cout << "color: " <<
              ", R: " << color.red()   <<
              ", G: " << color.green() <<
              ", B: " << color.blue()  <<
              ", A: " << color.alpha() << std::endl;
*/

        if (x / w > 1)
            return;

        stops << QGradientStop(x / w, color);
    }

    m_alpha_shade->setGradientStops(stops);

    emit gradientStopsChanged(stops);
}

void GradientEditor::showHistogram(const int *density)
{
  m_alpha_shade->setHistogram(density);
  this->update();
}

void GradientEditor::clearHistogram()
{
  m_alpha_shade->clearHistogram();
  this->update();

}


static void set_shade_points(const QPolygonF &points, ShadeWidget *shade)
{
    shade->hoverPoints()->setPoints(points);
    shade->hoverPoints()->setPointLock(0, HoverPoints::LockToLeft);
    shade->hoverPoints()->setPointLock(points.size() - 1, HoverPoints::LockToRight);
    shade->update();
}

void GradientEditor::setGradientStops(const QGradientStops &stops)
{
    QPolygonF pts_red, pts_green, pts_blue, pts_alpha;

    double h_red = m_red_shade->height();
    double h_green = m_green_shade->height();
    double h_blue = m_blue_shade->height();
    double h_alpha = m_alpha_shade->height();

    for (int i=0; i<stops.size(); ++i) {
        double pos = stops.at(i).first;
        QRgb color = stops.at(i).second.rgba();
        pts_red << QPointF(pos * m_red_shade->width(), h_red - qRed(color) * h_red / 255);
        pts_green << QPointF(pos * m_green_shade->width(), h_green - qGreen(color) * h_green / 255);
        pts_blue << QPointF(pos * m_blue_shade->width(), h_blue - qBlue(color) * h_blue / 255);
        pts_alpha << QPointF(pos * m_alpha_shade->width(), h_alpha - qAlpha(color) * h_alpha / 255);
    }

    set_shade_points(pts_red, m_red_shade);
    set_shade_points(pts_green, m_green_shade);
    set_shade_points(pts_blue, m_blue_shade);
    set_shade_points(pts_alpha, m_alpha_shade);
}

void GradientEditor::loadTransferFunction( std::string filename )
{
  ShadeWidget* shades[SHADES_COUNT] = { m_red_shade, m_green_shade, m_blue_shade, m_alpha_shade };
  QPolygonF pts;
  QGradientStops stops;
  int shadeIndex = -1;
  float px, py;
  std::string line, num;

  // Load file
  std::ifstream in(filename.c_str());

  if(!in)
    std::cerr << "- Error opening file!" << std::endl << std::endl;

  while(std::getline(in, line))
  {
    // find name of shade channel
    for(int s = 0; s < SHADES_COUNT; s++)
    {
      if(!line.compare(shades[s]->getName()))
      {
        if(shadeIndex != -1)
        {
          shades[shadeIndex]->setPoints(pts);
          shades[shadeIndex]->update();
          pts.clear();
        }

        // set current channel
        shadeIndex = s;
        break;
      }
    } // for

    if(isdigit(line.at(0)))
    {
      sscanf_s(line.c_str(), "%f %f\n", &px, &py);
      pts << QPointF(px, py);
    }

  } // while

  // set alpha value and update widget
  shades[ALPHA]->setPoints(pts);
  pointsUpdated();
}

void GradientEditor::saveTransferFunction( std::string filename )
{
  ShadeWidget* shades[SHADES_COUNT] = { m_red_shade, m_green_shade, m_blue_shade, m_alpha_shade };
  QGradientStops stops;
  QPolygonF pts;  
  int px, py;

  FILE *fp = NULL;
        fopen_s( &fp, filename.c_str(), "w" );

  if(!fp)
    std::cerr << "- Error saving file!" << std::endl << std::endl;

  // Write TF to file
  for( int s = 0; s < SHADES_COUNT; s++ )
  {
    // Set name in file 
    fprintf(fp, "%s\n", shades[s]->getName().c_str());
    
    pts = shades[s]->points();
    stops = shades[s]->getGradientStops();
   
    // save control points
    for( int i = 0; i < pts.size(); i++ )
    {
      px = (int) pts.at(i).x();
      py = (int) pts.at(i).y();
      fprintf(fp, "%d %d\n", px, py);
    }
  }

  fclose(fp);
}

---