photoEditWidget.cpp

Go to the documentation of this file.

//==============================================
//  copyright            : (C) 2003 by Will Stokes
//==============================================
//  This program is free software; you can redistribute it 
//  and/or modify it under the terms of the GNU General 
//  Public License as published by the Free Software 
//  Foundation; either version 2 of the License, or  
//  (at your option) any later version.         
//
//  As a special exception, Will Stokes gives permission to 
//  link this program with Qt non-commercial edition, and 
//  distribute the resulting executable, without including the 
//  source code for the Qt non-commercial edition in the 
//  source distribution. 
//==============================================

//Systemwide includes
#include <qlayout.h>
#include <qlabel.h>
#include <qfont.h>
#include <qframe.h>
#include <qtoolbutton.h>
#include <qpixmap.h>
#include <qimage.h>
#include <qlineedit.h>
#include <qcursor.h>
#include <qapplication.h>
#include <math.h>
#include <qtooltip.h>

//Projectwide includes
#include "photoEditWidget.h"
#include "photoViewWidget.h"
#include "questionDialog.h"
#include "../backend/photo.h"
#include "layoutWidget.h"
#include "../config.h"
#include "../backend/imageTools.h"

#include <iostream>

//==============================================
PhotoEditWidget::PhotoEditWidget(QWidget *parent, 
                                                const char* name ) : 
                                                QWidget(parent,name)
{
  //set photo pointer to null by default
  photo = NULL;
  
  //backup image null by default
  originalImage = NULL;
  
  //store layout pointer
  layout = (LayoutWidget*)parent;
  
  //create photo description labels
  photoDescription = new QLabel( this );
  photoDescription->setText( tr("Photo Description:") );
  photoDescription->setFont( QFont( "Times", 12, QFont::Bold ) );
  photoDescriptionVal = new QLineEdit( this );
  photoDescriptionVal->setFont( QFont( "Times", 12, QFont::Bold ) );
  connect( photoDescriptionVal, SIGNAL(textChanged(const QString&)),
           SLOT(updateDescription(const QString&)) );

  //create photo label
  photoView = new PhotoViewWidget( this, "photo view" );
  
  //create buttons  
  buttons = new QFrame(this);
  QFont buttonFont( qApp->font() );
  buttonFont.setBold(true);
  buttonFont.setPointSize( 11 );
  
  adjExposureButton = new QToolButton( buttons );
  adjExposureButton->setTextLabel(tr("Adj. Exposure"));
  adjExposureButton->setIconSet( QPixmap(QString(IMAGE_PATH)+"adjExposure.png") );
  adjExposureButton->setTextPosition(QToolButton::Right);
  adjExposureButton->setFont( buttonFont );
  adjExposureButton->setUsesTextLabel( true );
  QToolTip::add( adjExposureButton, tr("Auto-adjust exposure") );
  connect( adjExposureButton, SIGNAL(clicked()), SLOT(adjustExposure()) );  
    
  cropButton = new QToolButton( buttons );
  cropButton->setTextLabel(tr("Crop"));
  cropButton->setIconSet( QPixmap(QString(IMAGE_PATH)+"crop.png") );
  cropButton->setTextPosition(QToolButton::Right);
  cropButton->setFont( buttonFont );
  cropButton->setUsesTextLabel( true );
  QToolTip::add( cropButton, tr("Crop to selected region") );
  connect( cropButton, SIGNAL(clicked()), SLOT(cropToRegion()) );  
  
  invertButton = new QToolButton( buttons );
  invertButton->setTextLabel(tr("Invert"));
  invertButton->setIconSet( QPixmap(QString(IMAGE_PATH)+"invert.png") );
  invertButton->setTextPosition(QToolButton::Right);
  invertButton->setFont( buttonFont );
  invertButton->setUsesTextLabel( true );
  QToolTip::add( invertButton, tr("Invert selected region") );
  connect( invertButton, SIGNAL(clicked()), SLOT(invertSelection()) );  
    
  grayscaleButton = new QToolButton( buttons );
  grayscaleButton->setTextLabel(tr("Grayscale"));
  grayscaleButton->setIconSet( QPixmap(QString(IMAGE_PATH)+"grayscale.png") );
  grayscaleButton->setTextPosition(QToolButton::Right);
  grayscaleButton->setFont( buttonFont );
  grayscaleButton->setUsesTextLabel( true );
  QToolTip::add( grayscaleButton, tr("Grayscale selected region") );
  connect( grayscaleButton, SIGNAL(clicked()), SLOT(grayscaleSelection()) );  
    
  /*
  redEyeButton = new QToolButton( buttons );
  redEyeButton->setTextLabel(tr("Red Eye"));
  redEyeButton->setIconSet( QPixmap(QString(IMAGE_PATH)+"removeRedEye.png") );
  redEyeButton->setTextPosition(QToolButton::Right);
  redEyeButton->setFont( buttonFont );
  redEyeButton->setUsesTextLabel( true );
  QToolTip::add( redEyeButton, tr("Remove redeye") );
  connect( redEyeButton, SIGNAL(clicked()), SLOT(reduceRedeye()) );  
  */
    
  resetButton = new QToolButton( buttons );
  resetButton->setTextLabel(tr("Reset"));
  resetButton->setIconSet( QPixmap(QString(IMAGE_PATH)+"reset.png") );
  resetButton->setTextPosition(QToolButton::Right);
  resetButton->setFont( buttonFont );
  resetButton->setUsesTextLabel( true );
  QToolTip::add( resetButton, tr("Undo all modifications") );
  connect( resetButton, SIGNAL(clicked()), SLOT(resetImageAction()) );  
      
  returnButton = new QToolButton( buttons );
  returnButton->setTextLabel(tr("Return"));
  returnButton->setIconSet( QPixmap(QString(IMAGE_PATH)+"return.png") );
  returnButton->setTextPosition(QToolButton::Right);
  returnButton->setFont( buttonFont );
  returnButton->setUsesTextLabel( true );
  QToolTip::add( returnButton, tr("Return to subalbum layout") );
  connect( returnButton, SIGNAL(clicked()), SLOT(returnFromEdit()) );  
    
  //place all items in grid layout
  grid = new QGridLayout( this, 3, 3, 0 );
  grid->addWidget( photoDescription, 0, 0, Qt::AlignLeft );
  grid->addWidget( photoDescriptionVal, 0, 1 );
  grid->addMultiCellWidget( photoView, 1, 1, 0, 2, Qt::AlignCenter );

  int numButtons = 6;
  grid2 = new QGridLayout( buttons, 1, numButtons+2, 0 );
     
  int buttonNum = 1;
  grid2->addWidget( adjExposureButton,    0, buttonNum++, Qt::AlignLeft );
  grid2->addWidget( cropButton,               0, buttonNum++, Qt::AlignLeft );
  grid2->addWidget( invertButton,              0, buttonNum++, Qt::AlignLeft );
  grid2->addWidget( grayscaleButton,        0, buttonNum++, Qt::AlignLeft );
//  grid2->addWidget( redEyeButton, 0, buttonNum++, Qt::AlignLeft );
  grid2->addWidget( resetButton,               0, buttonNum++, Qt::AlignLeft );
  grid2->addWidget( returnButton,              0, buttonNum++, Qt::AlignLeft );
  
  //set first and last column of button grid to take up remaining space
  grid2->setColStretch( 0, 1 );
  grid2->setColStretch( 7, 1 );
  grid->addMultiCellWidget( buttons, 2, 2, 0, 2 );
  
  //set the last column to stretch to fill any blank space
  grid->setColStretch( 2, 1 );

  //set photo row to stretch to fill any blank space
  grid->setRowStretch( 1, 1 );
   
  //Set the second column, the actual photo description
  //to have a minimum width
  grid->addColSpacing(1, 300 );
  
  //set the background of the widget to be white
  setPaletteBackgroundColor( QColor(255, 255, 255) );
}
//==============================================
PhotoEditWidget::~PhotoEditWidget()
{
  delete originalImage;
  originalImage = NULL;
}
//==============================================
void PhotoEditWidget::setPhoto(Photo* photo)
{
  //store photo object handle
  this->photo = photo;
  
  //delete old original photo
  delete originalImage;
  originalImage = NULL;
  
  //set description
  photoDescriptionVal->setText( photo->getDescription() );

  //update view of photo
  photoView->setPhoto(photo);

  //check to see if slideshow dimensions are known, 
  //if not load image now and compute size, set
  //dimensions in photo object for future use
  if(photo->actualSlideshowWidth() == -1)
  {
    QImage *backendImage = new QImage( photo->getImageFilename() );
    
    int w, h;   
    resizeImage( backendImage->width(), backendImage->height(),
                      SLIDESHOW_WIDTH, SLIDESHOW_HEIGHT,
                      w, h);
    photo->setActualSlideshowDimensions( w, h);    
    delete backendImage;
    backendImage = NULL;
  }
}
//==============================================
void PhotoEditWidget::updateDescription( const QString& val )
{
  if(photo != NULL)
    photo->setDescription(val);
}
//==============================================
void PhotoEditWidget::adjustExposure() 
{ 
  //---------------------------------        
  //load the full image
  QImage *fullImage = new QImage( photo->getImageFilename() );
    
  //determine selected portion of the image, if no region selected use entire image
  QPoint topLeft, bottomRight;
  if( ! findScaledSelection(topLeft, bottomRight) )
  {
    topLeft.setX(0); 
    topLeft.setY(0);
    bottomRight.setX(photo->actualSlideshowWidth()-1);
    bottomRight.setY(photo->actualSlideshowHeight()-1);
  }
  //otherwise scale the selection to the full size
  else { findActualSelection(topLeft, bottomRight, fullImage); }    
  //---------------------------------        
  int redBuckets[256];
  int greenBuckets[256];
  int blueBuckets[256];
  int i;
  
  //zero out buckets
  for(i=0; i<256; i++)
  {
    redBuckets[i] = 0;
    greenBuckets[i] = 0;
    blueBuckets[i] = 0;
  }
  
  //fill buckets
  int x, y;  
  for(x=0; x<fullImage->width(); x++)
  {
    for(y=0; y<fullImage->height(); y++)
    {      
        QRgb pixelVal = fullImage->pixel( x, y );
        redBuckets[qRed(pixelVal)]++;
        greenBuckets[qGreen(pixelVal)]++;
        blueBuckets[qBlue(pixelVal)]++;
    }
  }
  
  //find median index for each channel
  double goalSum = ((double) (fullImage->width() * fullImage->height()) ) / 2;
  int redSum = 0;
  int greenSum = 0;
  int blueSum = 0;
  int redIndex = -1;
  int greenIndex = -1;
  int blueIndex = -1;
  
  int minRed, minGreen, minBlue;
  int maxRed, maxGreen, maxBlue;
  minRed = -1; minGreen = -1; minBlue = -1;  
  maxRed = 0; maxGreen = 0; maxBlue = 0;
  
  for(i=0; i<256; i++)
  {
    if(redSum < goalSum)
      redSum +=redBuckets[i];
    else if(redIndex == -1)
      redIndex = i;
    if(greenSum < goalSum)
      greenSum +=greenBuckets[i];
    else if(greenIndex == -1)
      greenIndex = i;
    if(blueSum < goalSum)
      blueSum +=blueBuckets[i];
    else if(blueIndex == -1)
      blueIndex = i;
      
    if(redBuckets[i] != 0)
    {
      maxRed = i;
      if(minRed == -1)
        minRed = i;
    }
    if(greenBuckets[i] != 0)
    {
      maxGreen = i;
      if(minGreen == -1)
        minGreen = i;
    }
    if(blueBuckets[i] != 0)
    {
      maxBlue = i;
      if(minBlue == -1)
        minBlue = i;
    }
  }
  
  //rescale each pixel
  QImage* editedImage = new QImage(fullImage->width(), fullImage->height(), fullImage->depth());
  for(x=0; x<fullImage->width(); x++)
  {
    for(y=0; y<fullImage->height(); y++)
    {
      QRgb val = fullImage->pixel( x, y );
      int adjRed, adjGreen, adjBlue;
      
      if(qRed(val) < redIndex)
        adjRed = (int) (127 * ((double)(qRed(val) - minRed)) / (redIndex - minRed) + 0.5f);
      else
        adjRed = 127 + (int) ((((double) (127 * (qRed(val) - redIndex))) / (maxRed - redIndex)) + 0.5f);
      
      if(qGreen(val) < greenIndex)
        adjGreen = (int) (127 * ((double)(qGreen(val) - minGreen)) / (greenIndex - minGreen) +0.5f);
      else
        adjGreen = 127 + (int) ( (((double) (127 * (qGreen(val) - greenIndex))) / (maxGreen - greenIndex)) + 0.5f);

      if(qBlue(val) < blueIndex)
        adjBlue = (int) (127 * ((double)(qBlue(val) - minBlue)) / (blueIndex - minBlue) +0.5f);
      else
        adjBlue = 127 + (int) ( (((double) (127 * (qBlue(val) - blueIndex))) / (maxBlue - blueIndex)) + 0.5f);
        
      val = qRgb( adjRed, adjGreen, adjBlue );
      editedImage->setPixel( x, y, val );
    }
  }
  //---------------------------------        
  /*
  //find min and max gray values
  int grayMin, grayMax, x, y;
  grayMin = -1; grayMax = -1;
  for(x=0; x<fullImage->width(); x++)
  {
    for(y=0; y<fullImage->height(); y++)
    {      
        int grayVal = qGray( fullImage->pixel( x, y ) );
        
        //set first values if first pixel
        if(x == 0 && y == 0)
        {
          grayMin = grayVal;
          grayMax = grayVal;
        }
        
        //otherwise compare against best
        if(grayVal < grayMin) { grayMin = grayVal; }
        if(grayVal > grayMax) { grayMax = grayVal; }
    }
  }
  //---------------------------------        
  //rescale pixels
  QImage* editedImage = new QImage(fullImage->width(), fullImage->height(), fullImage->depth());
  float scaleFactor = 255.0f / (grayMax - grayMin);  
  for(x=0; x<fullImage->width(); x++)
  {
    for(y=0; y<fullImage->height(); y++)
    {
      //find new shifted gray value
      float grayVal = qGray( fullImage->pixel( x, y ) );
      float newGrayVal = (grayVal - grayMin) * scaleFactor;
      float shift = newGrayVal / grayVal;
      
      //scale original pixel color to match gray shift
      QRgb val = fullImage->pixel( x, y );
      val = qRgb( (int) (shift*qRed(val)), (int)(shift*qGreen(val)), (int)(shift*qBlue(val)) );
      editedImage->setPixel( x, y, val );
    }
  }
  */
  //---------------------------------
  //backup original if this is first modification, update photo object
  applyImageUpdate( fullImage, editedImage );
  //---------------------------------
}
//==============================================
void PhotoEditWidget::cropToRegion()
{
  //---------------------------------        
  //determine selected portion of the image, if no region selected then return
  QPoint topLeft, bottomRight;
  if( ! findScaledSelection(topLeft, bottomRight) )
    return;
 
  //load the full image
  QImage *fullImage = new QImage( photo->getImageFilename() ); 
     
  //scale the selection to the full size
  findActualSelection(topLeft, bottomRight, fullImage);
  //---------------------------------        
  //crop image
  QImage* editedImage = new QImage(bottomRight.x() - topLeft.x() + 1,
                                                      bottomRight.y() - topLeft.y() + 1,
                                                      fullImage->depth());
  int newX, newY, x, y;
  newX = 0;  
  for(x=topLeft.x(); x<= bottomRight.x(); x++)
  {
    newY = 0;
    for(y=topLeft.y(); y<= bottomRight.y(); y++)
    {
      editedImage->setPixel( newX, newY, fullImage->pixel(x, y) );
      newY++;
    }
    newX++;
  }
  //---------------------------------
  //backup original if this is first modification, update photo object
  applyImageUpdate( fullImage, editedImage );
  //---------------------------------
}
//==============================================
void PhotoEditWidget::invertSelection()
{
  //---------------------------------        
  //load the full image
  QImage *fullImage = new QImage( photo->getImageFilename() );
    
  //determine selected portion of the image, if no region selected use entire image
  QPoint topLeft, bottomRight;
  if( ! findScaledSelection(topLeft, bottomRight) )
  {
    topLeft.setX(0); 
    topLeft.setY(0);
    bottomRight.setX(photo->actualSlideshowWidth()-1);
    bottomRight.setY(photo->actualSlideshowHeight()-1);
  }
  //otherwise scale the selection to the full size
  else { findActualSelection(topLeft, bottomRight, fullImage); }    
  //---------------------------------        
  //invert image
  QImage* editedImage = new QImage(fullImage->width(), fullImage->height(), fullImage->depth());
  int x, y;
  for(x=0; x<fullImage->width(); x++)
  {
    for(y=0; y<fullImage->height(); y++)
    {
      //if within selected region invert color
      if( x >= topLeft.x() && x <= bottomRight.x() && y >= topLeft.y() && y <= bottomRight.y())
      {
        QRgb val = fullImage->pixel( x, y );
        val = qRgb( 255 - qRed(val), 255 - qGreen(val), 255 - qBlue(val) );
        editedImage->setPixel( x, y, val );
      }
      //otherwise copy color
      else {  editedImage->setPixel( x, y, fullImage->pixel(x, y) );  }
    }
  }
  //---------------------------------
  //backup original if this is first modification, update photo object
  applyImageUpdate( fullImage, editedImage );
  //---------------------------------
}
//==============================================
void PhotoEditWidget::grayscaleSelection()
{
  //---------------------------------        
  //load the full image
  QImage *fullImage = new QImage( photo->getImageFilename() );
    
  //determine selected portion of the image, if no region selected use entire image
  QPoint topLeft, bottomRight;
  if( ! findScaledSelection(topLeft, bottomRight) )
  {
    topLeft.setX(0); 
    topLeft.setY(0);
    bottomRight.setX(photo->actualSlideshowWidth()-1);
    bottomRight.setY(photo->actualSlideshowHeight()-1);
  }
  //otherwise scale the selection to the full size
  else { findActualSelection(topLeft, bottomRight, fullImage); }    
  //---------------------------------        
  //grayscale selection
  QImage* editedImage = new QImage(fullImage->width(), fullImage->height(), fullImage->depth());
  int x, y;
  for(x=0; x<fullImage->width(); x++)
  {
    for(y=0; y<fullImage->height(); y++)
    {
      //if within selected region grayscale color
      if( x >= topLeft.x() && x <= bottomRight.x() && y >= topLeft.y() && y <= bottomRight.y())
      {
        QRgb val = fullImage->pixel( x, y );
        int gVal = qGray(val);
        editedImage->setPixel( x, y, qRgb( gVal, gVal, gVal ) );
      }
      //otherwise copy color
      else 
      {  editedImage->setPixel( x, y, fullImage->pixel(x, y) );  }
    }
  }
  //---------------------------------
  //backup original if this is first modification, update photo object
  applyImageUpdate( fullImage, editedImage );
  //---------------------------------
}
//==============================================
void PhotoEditWidget::reduceRedeye()
{

}
//==============================================
void PhotoEditWidget::resetImageAction()
{
  //if previous state saved revert all changes
  if(originalImage != NULL)
  {
    photo->setImage(originalImage);
  
    //set image function deletes object once done so remove pointer to memory
    //we don't own any more
    originalImage = NULL;
  
    photoView->setPhoto( photo );
  } 
}
//==============================================
void PhotoEditWidget::returnFromEdit()
{
  //no changes? then just exit
  if(originalImage == NULL)
  {
    layout->stopEdit(true);
    return;
  }
  
  //otherwise ask user if they are sure they want to permantly scare their photo :)
  QuestionDialog sure( tr("Keep changes?"),
                       tr("Once applied alterations cannot be undone."),
                       "warning.png",
                       this );
  //apply changes and exit
  if(sure.exec())  
  {
    layout->stopEdit(true);
  }
  //revert before exiting
  else
  {
    resetImageAction();
    layout->stopEdit(true);
  }
}
//==============================================
bool PhotoEditWidget::findScaledSelection(QPoint& topLeft, QPoint& bottomRight)
{  
  //get raw selection
  photoView->getSelection(topLeft, bottomRight);
  
  //if selection has no width or height then bail immediately
  if(bottomRight.x() - topLeft.x() == 0 ||
     bottomRight.y() - topLeft.y() == 0)
     return false;
  else
    return true;
}
//==============================================
void PhotoEditWidget::findActualSelection(QPoint& topLeft, QPoint& bottomRight, QImage* fullImage)
{  
  //scale the selected coordinates up into actual full size coordinates
  float widthRatio = (1.0f * fullImage->width()) / photo->actualSlideshowWidth();
  float heightRatio = (1.0f * fullImage->height()) / photo->actualSlideshowHeight();

  topLeft.setX( (int) (topLeft.x() * widthRatio) );
  topLeft.setY( (int) (topLeft.y() * heightRatio) ); 
     
  //if user selected to end of photo fix selection to end rather
  //then scale and get numerical error which prevents selection
  //from running to edge ot photo
  if(bottomRight.x() == (photo->actualSlideshowWidth() - 1))
    bottomRight.setX( fullImage->width() - 1 );
  else
    bottomRight.setX( (int) (bottomRight.x() * widthRatio) );
  
  if(bottomRight.y() == (photo->actualSlideshowHeight() - 1))
    bottomRight.setY( fullImage->height() - 1 );
  else
    bottomRight.setY( (int) (bottomRight.y() * heightRatio) );
}
//==============================================
void PhotoEditWidget::applyImageUpdate(QImage* fullImage, QImage* editedImage)
{
  //If this is first manipulation to image then backup original, otherwise delete intermediate object
  if(originalImage == NULL) {  originalImage = fullImage; }
  else { delete fullImage; }
  
  photo->setImage(editedImage);
  
  photoView->setPhoto( photo );
}
//==============================================

---