CG2_Tasks/imageviewer-qt4.cpp

/****************************************************************************
 **
 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the examples of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** You may use this file under the terms of the BSD license as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
 **     the names of its contributors may be used to endorse or promote
 **     products derived from this software without specific prior written
 **     permission.
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

#include "imageviewer-qt4.h"

/**
 * Constructor
 * @brief ImageViewer::ImageViewer
 */
ImageViewer::ImageViewer() {
  original_image = NULL;
  image = NULL;
  histogramm = NULL;
  startLogging();
  generateMainGui();
  renewLogging();
  generateControlPanels();
  createActions();
  createMenus();
  resize(1600, 600);
 }

/**
 * Once an image is loaded, automatically perform these operations.
 * 
 * analyze the image
 * allocate brightness map
 * 
 * @brief ImageViewer::initializeImage
 */
void ImageViewer::initializeImage() {
  if(image==NULL) {
    std::cout << "Error! No image provided!" << std::endl;
    return;
  }
  analyzeImage();
}

/**
 * Uses simple weights to calculate intensity of a pixel.
 * Using qRound() to reduce the error of the int cast.
 * 
 * @brief ImageViewer::calcIntensity
 */
int ImageViewer::calcIntensity(int r, int g, int b) {
  return (int) qRound(0.299*r + 0.587*g + 0.114*b);
}

/**
 * In case it is needed, convert the loaded image into grayscale.
 * @brief ImageViewer::convertToMonochrome
 */
void ImageViewer::convertToMonochrome() {
  if(image!=NULL) {
    logFile << "Converting image to monochrome...";
    renewLogging();
    for(int x=0; x<image->width(); x++) {
      for(int y=0; y<image->height(); y++) {
        int r,g,b;
        QColor color = QColor::fromRgb(image->pixel(x, y));
        color.getRgb(&r,&g,&b);
        int intensity = calcIntensity(r, g, b);
        color = QColor::fromRgb(intensity, intensity, intensity);
        image->setPixel(x, y, color.rgba());
        original_image->setPixel(x, y, color.rgba());
      }
    }
    updateImageDisplay();
    logFile << "done." << std::endl;
    renewLogging();
  }
}

/**
 * Draws a simple, black line.
 * @brief ImageViewer::drawBlackLine
 */
void ImageViewer::drawBlackLine() {
  if(image!=NULL) {
    for(int i=0;i<std::min(image->width(),image->height());i++) {
      image->setPixel(i,i,0);
    }
    updateImageDisplay();
    logFile << "Black line drawn." << std::endl;
    renewLogging();
  }
}

/**
 * Draws a diagonal cross from edge to edge.
 * @brief ImageViewer::drawDiagonalCross
 */
void ImageViewer::drawDiagonalCross() {
  if(image!=NULL) {
    int color = QColor::fromHsl(120,255,125).rgba();
    int width = image->width();
    int height = image->height();
    for(int y=0; y<image->height(); y++) {
      image->setPixel((1.0*y/height)*width,y,color);
      image->setPixel((1.0-(1.0*y/height))*width,y,color);
    }
  }
  updateImageDisplay();
  logFile << "Diagonal edge-to-edge cross drawn." << std::endl;
  renewLogging();
}

/**
 * Proxy method to actual method due to signal param issues.
 * @brief ImageViewer::drawRainbowCross
 */
void ImageViewer::drawRainbowCross() {
  drawRainbowCross(0);
}

/**
 * Draws a diagonal cross with variable width and
 * varying color.
 * Fetches the width from the slider.
 * @brief ImageViewer::drawRainbowCross
 * @param initialHue
 */
void ImageViewer::drawRainbowCross(int initialHue=0) {
  if(image!=NULL) {
    int h = initialHue;
    QColor myColor = QColor::fromHsl(h, 255, 125);
    int image_width = image->width()-1;
    int range = line_slider->value();
    if(range > image->width()-2) range = image->width()-2;
    for(int i=0;i<std::min(image->width(),image->height());i++) {
      int color = myColor.rgba();
      for(int r=0; r<range; r++) {
        image->setPixel(i+r,i,color);
        image->setPixel((image_width-i)-r,i,color);
      }
      h++;
      if(h > 359) h = 0;
      myColor.setHsl(h, 255, 125);
    }
    updateImageDisplay();
  }
}

/**
 * Repeatedly draw the rainbow cross forever.
 * You will need to kill the process manually after triggering this.
 * @brief ImageViewer::acidTrippin
 */
void ImageViewer::acidTrippin() {
  logFile << "There is no stop button yet. Kill the process or keep it." << std::endl;
  renewLogging();
  int h = 0;
  while(true) {
    drawRainbowCross(h);
    h += 20;
    if(h > 359) h = 0;
    qApp->processEvents();
  }
}

/**
 * Analyze the image, get average luminance
 * Also fill grayscale_absolute_histogramm
 * @brief ImageViewer::analyzeImage
 */
void ImageViewer::analyzeImage() {
  if(image!=NULL) {
    //Zero existing histogramm data first
    for(int i=0; i<256; i++) {
      grayscale_absolute_histogramm[i] = 0;
      grayscale_relative_histogramm[i] = 0;
    }
    
    logFile << "Analyzing image ...";
    renewLogging();
    for(int x=0; x<image->width(); x++) {
      for(int y=0; y<image->height(); y++) {
        int r,g,b;
        QColor color = QColor::fromRgb(image->pixel(x, y));
        color.getRgb(&r,&g,&b);
        int intensity = calcIntensity(r, g, b);
        grayscale_absolute_histogramm[intensity] += 1;
      }
    }
    
    int pixels = image->width()*image->height();
    for(int i=0; i<256; i++) {
      grayscale_relative_histogramm[i] = (((double) grayscale_absolute_histogramm[i])/((double) pixels));
    }
    
    logFile << "done" << std::endl;
    renewLogging();

    QString result = QString("Intensity: Average: %1, Variance: %2").arg(getAverageIntensity()).arg(getIntensityVariance());
    stats->setText(result);

    updateHistogramm();
  }
}

/**
 * Use histogramm to retrieve the average intensity.
 * @brief ImageViewer::getAverageIntensity
 */
int ImageViewer::getAverageIntensity() {
  double sumIntensity = 0;
  for(int i=0; i<256;i++) {
    sumIntensity += (i*grayscale_relative_histogramm[i]);
  }
  return (int) qRound(sumIntensity);
}

/**
 * Retrieve the intensity variance from the image.
 * @brief ImageViewer::getVarianceIntensity
 */
int ImageViewer::getIntensityVariance() {
  int average_intensity = getAverageIntensity();
  int sumDifference = 0;
  for(int x=0; x<image->width(); x++) {
    for(int y=0; y<image->height(); y++) {
      QColor color = QColor::fromRgb(image->pixel(x, y));
      int r,g,b;
      color.getRgb(&r,&g,&b);
      int intensity = calcIntensity(r, g, b);
      int diff = std::abs(intensity - average_intensity);
      sumDifference += diff;
    }
  }
  return (int) (sumDifference/(image->width()*image->height()));
}

/**
 * Builds up the image for the histogramm.
 * @brief ImageViewer::updateHistogramm
 */
void ImageViewer::updateHistogramm() {
  if(histogramm != NULL) {
    delete histogramm;
    histogramm = NULL;
  }
  //Find biggest value in histogramm data
  double max = 0;
  for(int i=0; i<256; i++) {
    if(grayscale_relative_histogramm[i] > max) max = grayscale_relative_histogramm[i];
  }
  
  histogramm = new QImage(256, 100, QImage::Format_RGB32);
  histogramm->fill(QColor::fromRgb(200,200,200));
  int black = QColor::fromRgb(0,0,0).rgba();
  for(int x=0; x<256; x++) {
    int k_max = (int) qRound((100*grayscale_relative_histogramm[x])/max);
    for(int y=0; y<k_max; y++) {
      histogramm->setPixel(x, (100-y)-1, black);
    }
  }
  logFile << "Histogramm done." << std::endl;
  renewLogging();
  histogramm_label->setPixmap(QPixmap::fromImage(*histogramm));
}

/**
 * Fired by the brightness_slider, this one adjusts the brightness on image.
 * @brief ImageViewer::adjustBrightness
 */
void ImageViewer::adjustBrightness(int b) {
  int h, s, old_l;
  int new_l = 0;
  int delta = b - 255;
  for(int x=0; x<image->width(); x++) {
    for(int y=0; y<image->height(); y++) {
      QColor color = QColor::fromRgb(original_image->pixel(x, y));
      color.getHsl(&h, &s, &old_l);
      new_l = old_l + delta;
      if(new_l > 255) new_l = 255;
      if(new_l < 0) new_l = 0;
      color.setHsl(h, s, new_l);
      image->setPixel(x, y, color.rgba());
    }
  }
  updateImageDisplay();
  logFile << "Brightness adjusted to: " << old_l << " + " << delta << " -> (" << h << ", " << s << ", " << new_l << ")" << std::endl;
  renewLogging();
}

/**
 * Fired by the constrast_slider, this one adjusts the contrast on image.
 * @brief ImageViewer::adjustContrast
 */
void ImageViewer::adjustContrast(int c) {
  int h, s, old_l;
  int new_l = 0;
  double alpha = c / 255.0;
  int average_intensity = getAverageIntensity();
  for(int x=0; x<image->width(); x++) {
    for(int y=0; y<image->height(); y++) {
      QColor color = QColor::fromRgb(original_image->pixel(x, y));
      color.getHsl(&h, &s, &old_l);
      new_l = average_intensity + ((int) round((old_l - average_intensity) * alpha));
      if(new_l > 255) new_l = 255;
      if(new_l < 0) new_l = 0;
      color.setHsl(h, s, new_l);
      image->setPixel(x, y, color.rgba());
    }
  }
  updateImageDisplay();
  logFile << "Contrast adjusted to: " << old_l << " * " << alpha << " -> (" << h << ", " << s << ", " << new_l << ")" << std::endl;
  renewLogging();
}


/**************************************************************************************** 
*   
*  GUI elements related to the tasks are set up here.
*
*****************************************************************************************/

void ImageViewer::generateControlPanels() {
  // Tab for first task
  task_tab_widget1 = new QWidget();
  task_tab1 = new QVBoxLayout();
  task_tab_widget1->setLayout(task_tab1);

  monochrome = new QPushButton();
  monochrome->setText("Convert to monochrome");
  QObject::connect(monochrome, SIGNAL(clicked()), this, SLOT (convertToMonochrome()));
  
  draw_black_line = new QPushButton();
  draw_black_line->setText("Draw a black line");
  QObject::connect(draw_black_line, SIGNAL(clicked()), this, SLOT (drawBlackLine()));

  draw_rainbow_cross = new QPushButton();
  draw_rainbow_cross->setText("Draw a rainbow cross");
  QObject::connect(draw_rainbow_cross, SIGNAL(clicked()), this, SLOT (drawRainbowCross()));

  acid_trip = new QPushButton();
  acid_trip->setText("Start the neverending acid trip!");
  QObject::connect(acid_trip, SIGNAL(clicked()), this, SLOT (acidTrippin()));

  diagonal_cross = new QPushButton();
  diagonal_cross->setText("Draw a diagonal cross");
  QObject::connect(diagonal_cross, SIGNAL(clicked()), this, SLOT (drawDiagonalCross()));

  line_slider = new QSlider(Qt::Horizontal);
  line_slider->setMinimum(1);
  line_slider->setMaximum(150);
  line_slider->setValue(3);
  //QObject::connect(lineSlider, SIGNAL(valueChanged(int)), this, SLOT (drawRainbowCross()));
 
  task_tab1->addWidget(monochrome);
  task_tab1->addWidget(new QLabel("Let's draw something!"));
  task_tab1->addWidget(draw_black_line);
  task_tab1->addWidget(draw_rainbow_cross);
  task_tab1->addWidget(acid_trip);
  task_tab1->addWidget(diagonal_cross);
  task_tab1->addWidget(new QLabel("This will not stop unless process is killed."));
  task_tab1->addWidget(line_slider);
  task_tab1->addWidget(new QLabel("Sets the width of the cross."));

  tabWidget->addTab(task_tab_widget1, "Task #1");


  //Tab for second task
  task_tab_widget2 = new QWidget();
  task_tab2 = new QVBoxLayout();
  task_tab_widget2->setLayout(task_tab2);
 
  histogramm_label = new QLabel();
  histogramm_label->setBackgroundRole(QPalette::Base);
  histogramm_label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
  histogramm_label->setScaledContents(false);

  stats = new QLabel();
  stats->setText("Intensity will be shown here.");
  
  analyze_image = new QPushButton();
  analyze_image->setText("Analyze image");
  QObject::connect(analyze_image, SIGNAL(clicked()), this, SLOT(analyzeImage()));

  brightness_slider = new QSlider(Qt::Horizontal);
  brightness_slider->setMinimum(0);
  brightness_slider->setMaximum(510);
  brightness_slider->setValue(255);
  QObject::connect(brightness_slider, SIGNAL(valueChanged(int)), this, SLOT (adjustBrightness(int)));
  
  contrast_slider = new QSlider(Qt::Horizontal);
  contrast_slider->setMinimum(0);
  contrast_slider->setMaximum(510);
  contrast_slider->setValue(255);
  QObject::connect(contrast_slider, SIGNAL(valueChanged(int)), this, SLOT (adjustContrast(int)));

  task_tab2->addWidget(stats);
  task_tab2->addWidget(new QLabel("Histogramm"));
  task_tab2->addWidget(histogramm_label);
  task_tab2->addWidget(analyze_image);
  task_tab2->addWidget(new QLabel("Brightness"));
  task_tab2->addWidget(brightness_slider);
  task_tab2->addWidget(new QLabel("Contrast"));
  task_tab2->addWidget(contrast_slider);

  tabWidget->addTab(task_tab_widget2, "Task #2");
  
  //Tab for third task
  task_tab_widget3 = new QWidget();
  task_tab3 = new QVBoxLayout();
  task_tab_widget3->setLayout(task_tab3);

  
  tabWidget->addTab(task_tab_widget3, "Task #3");
  
  //Show it  
  tabWidget->show();

}


/**************************************************************************************** 
*
* The following methods are about the adjustBrightness(int)generic image viewer application and do not contain
* any special graphics logic.
*
*****************************************************************************************/

void ImageViewer::startLogging()
{
  //LogFile
  logFile.open("log.txt", std::ios::out);
  logFile << "Logging: \n" << std::endl;
}

void ImageViewer::renewLogging()
{
  QFile file("log.txt"); // Create a file handle for the file named
  QString line;
  file.open(QIODevice::ReadOnly); // Open the file

  QTextStream stream(&file); // Set the stream to read from myFile
  logBrowser->clear();
  while(!stream.atEnd()) {
    line = stream.readLine(); // this reads a line (QString) from the file
    logBrowser->append(line);
  }
}

void ImageViewer::updateImageDisplay() {
  imageLabel->setPixmap(QPixmap::fromImage(*image));
}


void ImageViewer::generateMainGui() {
  /* Tab widget */
  tabWidget = new QTabWidget(this);
  tabWidget->setObjectName("tabWidget");

  /* Center widget */
  centralwidget = new QWidget(this);
  centralwidget->setObjectName("centralwidget");
  //centralwidget->setFixedSize(200,200);
  //setCentralWidget(centralwidget);

  imageLabel = new QLabel;
  imageLabel->setBackgroundRole(QPalette::Base);
  imageLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
  imageLabel->setScaledContents(true);

  /* Center widget */
  scrollArea = new QScrollArea;
  scrollArea->setBackgroundRole(QPalette::Dark);
  scrollArea->setWidget(imageLabel);
  setCentralWidget(scrollArea);

  /* HBox layout */
  QGridLayout* gLayout = new QGridLayout(centralwidget);
  gLayout->setObjectName("hboxLayout");
  gLayout->addWidget(new QLabel(),1,1);
  gLayout->setVerticalSpacing(50);
  gLayout->addWidget(tabWidget,2,1);
  gLayout->addWidget(scrollArea,2,2);

  logBrowser= new QTextEdit(this);
  logBrowser->setMinimumHeight(100);
  logBrowser->setMaximumHeight(200);
  logBrowser->setMinimumWidth(width());
  logBrowser->setMaximumWidth(width());
  gLayout->addWidget(logBrowser,3,1,1,2);
  gLayout->setVerticalSpacing(50);
}

void ImageViewer::print() {
  Q_ASSERT(imageLabel->pixmap());
  #if !defined(QT_NO_PRINTER) && !defined(QT_NO_PRINTDIALOG)
  QPrintDialog dialog(&printer, this);
  if (dialog.exec()) {
    QPainter painter(&printer);
    QRect rect = painter.viewport();
    QSize size = imageLabel->pixmap()->size();
    size.scale(rect.size(), Qt::KeepAspectRatio);
    painter.setViewport(rect.x(), rect.y(), size.width(), size.height());
    painter.setWindow(imageLabel->pixmap()->rect());
    painter.drawPixmap(0, 0, *imageLabel->pixmap());
  }
  #endif
}

void ImageViewer::open() {
  if(image != NULL) {
    delete image;
    image = NULL;
  }
  if(original_image!=NULL) {
    delete original_image;
    original_image = NULL;
  }
  QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QDir::currentPath());
  if(!fileName.isEmpty()) {
    image = new QImage(fileName);
    original_image = new QImage(fileName);
    if(image->isNull()) {
      QMessageBox::information(this, tr("Image Viewer"), tr("Cannot load %1.").arg(fileName));
      return;
    }
    scaleFactor = 1.0;
    updateImageDisplay();
    printAct->setEnabled(true);
    fitToWindowAct->setEnabled(true);
    updateActions();
    if(!fitToWindowAct->isChecked()) imageLabel->adjustSize();
    setWindowFilePath(fileName);
    logFile << "geladen: " << fileName.toStdString().c_str()  << std::endl;
    renewLogging();
    initializeImage(); //Now hook to prepare certain datastructures after loading.
  }
}

void ImageViewer::resizeEvent(QResizeEvent* event) {
  QMainWindow::resizeEvent(event);
  centralwidget->setMinimumWidth(width());
  centralwidget->setMinimumHeight(height());
  centralwidget->setMaximumWidth(width());
  centralwidget->setMaximumHeight(height());
  logBrowser->setMinimumWidth(width()-40);
  logBrowser->setMaximumWidth(width()-40);
}

void ImageViewer::zoomIn() {
  scaleImage(1.25);
}

void ImageViewer::zoomOut() {
  scaleImage(0.8);
}

void ImageViewer::normalSize() {
  imageLabel->adjustSize();
  scaleFactor = 1.0;
}

void ImageViewer::fitToWindow() {
  bool fitToWindow = fitToWindowAct->isChecked();
  scrollArea->setWidgetResizable(fitToWindow);
  if(!fitToWindow) {
    normalSize();
  }
  updateActions();
}

void ImageViewer::about() {
  QMessageBox::about(this, tr("About Image Viewer"),
    tr("<p>The <b>Image Viewer</b> example shows how to combine QLabel "
      "and QScrollArea to display an image. QLabel is typically used "
      "for displaying a text, but it can also display an image. "
      "QScrollArea provides a scrolling view around another widget. "
      "If the child widget exceeds the size of the frame, QScrollArea "
      "automatically provides scroll bars. </p><p>The example "
      "demonstrates how QLabel's ability to scale its contents "
      "(QLabel::scaledContents), and QScrollArea's ability to "
      "automatically resize its contents "
      "(QScrollArea::widgetResizable), can be used to implement "
      "zooming and scaling features. </p><p>In addition the example "
      "shows how to use QPainter to print an image.</p>"));
}

void ImageViewer::createActions() {
  openAct = new QAction(tr("&Open..."), this);
  openAct->setShortcut(tr("Ctrl+O"));
  connect(openAct, SIGNAL(triggered()), this, SLOT(open()));

  printAct = new QAction(tr("&Print..."), this);
  printAct->setShortcut(tr("Ctrl+P"));
  printAct->setEnabled(false);
  connect(printAct, SIGNAL(triggered()), this, SLOT(print()));

  exitAct = new QAction(tr("E&xit"), this);
  exitAct->setShortcut(tr("Ctrl+Q"));
  connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));

  zoomInAct = new QAction(tr("Zoom &In (25%)"), this);
  zoomInAct->setShortcut(tr("Ctrl++"));
  zoomInAct->setEnabled(false);
  connect(zoomInAct, SIGNAL(triggered()), this, SLOT(zoomIn()));

  zoomOutAct = new QAction(tr("Zoom &Out (25%)"), this);
  zoomOutAct->setShortcut(tr("Ctrl+-"));
  zoomOutAct->setEnabled(false);
  connect(zoomOutAct, SIGNAL(triggered()), this, SLOT(zoomOut()));

  normalSizeAct = new QAction(tr("&Normal Size"), this);
  normalSizeAct->setShortcut(tr("Ctrl+S"));
  normalSizeAct->setEnabled(false);
  connect(normalSizeAct, SIGNAL(triggered()), this, SLOT(normalSize()));

  fitToWindowAct = new QAction(tr("&Fit to Window"), this);
  fitToWindowAct->setEnabled(false);
  fitToWindowAct->setCheckable(true);
  fitToWindowAct->setShortcut(tr("Ctrl+F"));
  connect(fitToWindowAct, SIGNAL(triggered()), this, SLOT(fitToWindow()));

  aboutAct = new QAction(tr("&About"), this);
  connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));

  aboutQtAct = new QAction(tr("About &Qt"), this);
  connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
}

void ImageViewer::createMenus() {
  fileMenu = new QMenu(tr("&File"), this);
  fileMenu->addAction(openAct);
  fileMenu->addAction(printAct);
  fileMenu->addSeparator();
  fileMenu->addAction(exitAct);

  viewMenu = new QMenu(tr("&View"), this);
  viewMenu->addAction(zoomInAct);
  viewMenu->addAction(zoomOutAct);
  viewMenu->addAction(normalSizeAct);
  viewMenu->addSeparator();
  viewMenu->addAction(fitToWindowAct);

  helpMenu = new QMenu(tr("&Help"), this);
  helpMenu->addAction(aboutAct);
  helpMenu->addAction(aboutQtAct);

  menuBar()->addMenu(fileMenu);
  menuBar()->addMenu(viewMenu);
  menuBar()->addMenu(helpMenu);
}

void ImageViewer::updateActions() {
  zoomInAct->setEnabled(!fitToWindowAct->isChecked());
  zoomOutAct->setEnabled(!fitToWindowAct->isChecked());
  normalSizeAct->setEnabled(!fitToWindowAct->isChecked());
}

void ImageViewer::scaleImage(double factor) {
  Q_ASSERT(imageLabel->pixmap());
  scaleFactor *= factor;
  imageLabel->resize(scaleFactor * imageLabel->pixmap()->size());

  adjustScrollBar(scrollArea->horizontalScrollBar(), factor);
  adjustScrollBar(scrollArea->verticalScrollBar(), factor);

  zoomInAct->setEnabled(scaleFactor < 3.0);
  zoomOutAct->setEnabled(scaleFactor > 0.333);
}

void ImageViewer::adjustScrollBar(QScrollBar* scrollBar, double factor) {
  scrollBar->setValue(int(factor * scrollBar->value() + ((factor - 1) * scrollBar->pageStep()/2)));
}