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 = NULL;
  working_copy = NULL;
  histogramm_reference = NULL;
  canny_edge_machine = 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(original->getImage() == NULL) {
    std::cout << "Error! No image provided!" << std::endl;
    return;
  }
  analyzeImage();
}

/**
 * In case it is needed, convert the loaded image into grayscale.
 * 
 * @brief ImageViewer::convertToMonochrome
 */
void ImageViewer::convertToMonochrome() {
  if(original->getImage() != NULL) {
    logFile << "Converting image to monochrome...";
    renewLogging();

    working_copy->convertToMonochrome();

    updateImageDisplay();
    logFile << "done." << std::endl;
    renewLogging();
  }
}

/**
 * No big performance, but simple.
 * Restore the working copy based on the existing original image.
 * 
 * @brief ImageViewer::resetWorkingCopy 
 */
void ImageViewer::resetWorkingCopy() {
  logFile << "Resetting working copy ...";
  renewLogging();
  for(int x=0; x<original->getImage()->width(); x++) {
    for(int y=0; y<original->getImage()->height(); y++) {
      working_copy->getImage()->setPixel(x, y, original->getImage()->pixel(x, y));
    }
  }
  updateImageDisplay();
  logFile << "done." << std::endl;
  renewLogging();
}

/**
 * No big performance, but simple.
 * Save working copy to original image.
 * 
 * @brief ImageViewer::saveToOriginal 
 */
void ImageViewer::saveToOriginal() {
  logFile << "Saving working copy to original ...";
  renewLogging();
  for(int x=0; x<original->getImage()->width(); x++) {
    for(int y=0; y<original->getImage()->height(); y++) {
      original->getImage()->setPixel(x, y, working_copy->getImage()->pixel(x, y));
    }
  }
  updateImageDisplay();
  logFile << "done." << std::endl;
  renewLogging();
}

/**
 * Draws a simple, black line.
 * @brief ImageViewer::drawBlackLine
 */
void ImageViewer::drawBlackLine() {
  if(original->getImage() != NULL) {
    for(int i=0;i<std::min(working_copy->getImage()->width(),working_copy->getImage()->height());i++) {
      working_copy->getImage()->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(original->getImage() != NULL) {
    int color = QColor::fromHsl(120,255,125).rgb();
    int width = working_copy->getImage()->width();
    int height = working_copy->getImage()->height();
    for(int y=0; y<working_copy->getImage()->height(); y++) {
      working_copy->getImage()->setPixel((1.0*y/height)*width,y,color);
      working_copy->getImage()->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(original->getImage() != NULL) {
    int h = initialHue;
    QColor myColor = QColor::fromHsl(h, 255, 125);
    int image_width = working_copy->getImage()->width()-1;
    int range = line_slider->value();
    if(range > working_copy->getImage()->width()-2) range = working_copy->getImage()->width()-2;
    for(int i=0;i<std::min(working_copy->getImage()->width(),working_copy->getImage()->height());i++) {
      int color = myColor.rgb();
      for(int r=0; r<range; r++) {
        working_copy->getImage()->setPixel(i+r,i,color);
        working_copy->getImage()->setPixel((image_width-i)-r,i,color);
      }
      h++;
      if(h > 359) h = 0;
      myColor.setHsl(h, 255, 125);
    }
    updateImageDisplay();
  }
}

/**
 * Analyze the image, get average luminance
 * Also fill grayscale_absolute_histogramm
 * 
 * @brief ImageViewer::analyzeImage
 */
void ImageViewer::analyzeImage() {
  if(original->getImage() != NULL) {
    logFile << "Analyzing image ...";
    renewLogging();
    original->updateStatistics();
    working_copy->updateStatistics();
    logFile << "done" << std::endl;
    renewLogging();
    QString result = QString("Intensity: Average: %1, Variance: %2").arg(original->getIntensityAverage()).arg(original->getIntensityVariance());
    original_stats->setText(result);
    result = QString("Intensity: Average: %1, Variance: %2").arg(working_copy->getIntensityAverage()).arg(working_copy->getIntensityVariance());
    stats->setText(result);
    histogramm_label->setPixmap(QPixmap::fromImage(*(working_copy->getHistogrammNormalImage())));
    original_histogramm_label->setPixmap(QPixmap::fromImage(*(original->getHistogrammNormalImage())));
    histogramm_cumulative_label->setPixmap(QPixmap::fromImage(*(working_copy->getHistogrammCumulativeImage())));
    original_histogramm_cumulative_label->setPixmap(QPixmap::fromImage(*(original->getHistogrammCumulativeImage())));
  }
}

/**
 * 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<working_copy->getImage()->width(); x++) {
    for(int y=0; y<working_copy->getImage()->height(); y++) {
      QColor color = QColor::fromRgb(original->getImage()->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);
      struct yuv yuv = LazyImage::RGBToYUV(color.rgb());
      yuv.y = yuv.y + (delta / 255.0);
      if(yuv.y > 1) yuv.y = 1;
      if(yuv.y < 0) yuv.y = 0;
      color = LazyImage::YUVToRGB(yuv);
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }
  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 = original->getIntensityAverage();
  for(int x=0; x<working_copy->getImage()->width(); x++) {
    for(int y=0; y<working_copy->getImage()->height(); y++) {
      QColor color = QColor::fromRgb(original->getImage()->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);
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }
  updateImageDisplay();
  logFile << "Contrast adjusted to: " << old_l << " * " << alpha << " -> (" << h << ", " << s << ", " << new_l << ")" << std::endl;
  renewLogging();
}

/** 
 * Using the percentile given by the slider, do a robust automatic contrast adaption.
 * 
 * @brief ImageViewer::robustAutomaticContrastAdaption
 */
void ImageViewer::robustAutomaticContrastAdaption(int c_param) {
  double* histogramm = original->getRelativeIntensityHistogramm();
  double limit = c_param / 1000.0;
  logFile << "Doing automatic robust contrast adaption (" << limit << "), hold tight ..." << std::endl;
  renewLogging();
  
  // Determine upper and lower "borders"
  double cursor;
  int lower_border = -1;
  int upper_border = -1;  

  cursor = 0.0;
  for(int i=0; i<256; i++) {
    cursor += histogramm[i];
    if(cursor > limit) {
      lower_border = i-1; // get last value before limit overflow
      if(lower_border < 0) lower_border = 0;
      break;
    }
  }
  
  cursor = 0.0;
  for(int i=255; i>-1; i--) {
    cursor += histogramm[i];
    if(cursor > limit) {
      upper_border = i+1; // get last value before limit overflow
      if(upper_border > 255) upper_border = 255;
      break;
    }
  }
  
  logFile << "lower border: " << lower_border << ", upper border: " << upper_border << "." << std::endl;
  renewLogging();
  
  int h, s, l;
  for(int x=0; x<working_copy->getImage()->width(); x++) {
    for(int y=0; y<working_copy->getImage()->height(); y++) {
      QColor color = QColor::fromRgb(original->getImage()->pixel(x, y));
      color.getHsl(&h, &s, &l);
      
      if(l < lower_border) { 
	l = 0;
      } else if(l > upper_border) {
	l = 255;
      } else {
	l = qRound((l - lower_border) * (255.0/(upper_border-lower_border)));
      }
      
      color.setHsl(h, s, l);
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }
  updateImageDisplay();

  logFile << "done." << std::endl;
  renewLogging();
}

/**
 * Do a very basic, linear histogramm adaption.
 * 
 * @brief ImageViewer::linearHistogrammAdaption
 */
void ImageViewer::linearHistogrammAdaption(void) {
  logFile << "Doing linear histogramm adaption ..." << std::endl;
  renewLogging();
  //int h, s, l;
  int* ach = original->getAbsoluteCumulativeIntensityHistogramm();
  int pixels = working_copy->getImage()->width()*working_copy->getImage()->height();
  for(int x=0; x<working_copy->getImage()->width(); x++) {
    for(int y=0; y<working_copy->getImage()->height(); y++) {
      QColor color = QColor::fromRgb(original->getImage()->pixel(x, y));
      //color.getHsl(&h, &s, &l);
      //l = (int) qFloor(ach[l] * (255.0/pixels));
      //color.setHsl(h, s, l);
      struct yuv yuv = LazyImage::RGBToYUV(color.rgb());
      int l = qRound(yuv.y * 255.0);
      yuv.y = qFloor(ach[l] * (255.0/pixels)) / 255.0;
      color = LazyImage::YUVToRGB(yuv);
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }  
  updateImageDisplay();
  logFile << "done." << std::endl;
  renewLogging();
}

/**
 * Break the reference histogramm into parts, do linear adaption
 * 
 * @brief ImageViewer::partialLinearHistogrammAdaption
 */
void ImageViewer::partialLinearHistogrammAdaption() {
  logFile << "Doing partial linear histogramm adaption ..." << std::endl;
  renewLogging();
  // Get cumulative histogramm from reference image
  double* reference_histogramm = histogramm_reference->getRelativeCumulativeIntensityHistogramm();
  
  // Split [0,255] into n parts (slider)
  // This produces a list of brightness indexes to interpolate in between.
  int number_parts = partial_adaption_pieces_slider->value();
  int* parts = (int*) malloc((number_parts+1)*sizeof(int));
  for(int i=0; i<=number_parts; i++) {
    parts[i] = qRound((255.0/number_parts)*i);
    logFile << "I: " << i << ", intensity: " << parts[i] << std::endl;
  }
  
  // Create histogramm map
  // This represents the new cumulative histogramm built of linear parts
  double* histogramm_map = (double*) malloc(256*sizeof(double));
  for(int i=0; i<=number_parts; i++) {
    int current_n = parts[i];
    if(current_n == 0) continue; // First part is always at zero!
    int last_n = parts[i-1];
    int delta_n = current_n - last_n;
    double delta_i = reference_histogramm[current_n] - reference_histogramm[last_n];
    double m = delta_i / delta_n;
    double offset = histogramm_map[last_n];
    // Calculate the new cumulative values
    for(int j=last_n; j<=current_n; j++) {
      int delta_n = j - last_n;
      histogramm_map[j] = (offset + delta_n*m);
      logFile << j << " -> " << histogramm_map[j] << std::endl;
    }
  }
  
  double* original_histogramm = original->getRelativeCumulativeIntensityHistogramm();
  
  // Build up the brightness map to apply on the image
  // (basically inversing the histogramm map)
  int* brightness_map = (int*) malloc(256*sizeof(int));
  int j=0;
  for(int i=0; i<256; i++) {
    double old_cumulative_brightness = original_histogramm[i];
    while(old_cumulative_brightness > histogramm_map[j]) j++;
    if(j > 255) j = 255;
    brightness_map[i] = j;
  }
  
  for(int i=0; i<256; i++) {
    logFile << i << " -> " << brightness_map[i] << std::endl;
  }
  renewLogging();

  // Apply the brightness map
  //int h, s, l;
  for(int x=0; x<working_copy->getImage()->width(); x++) {
    for(int y=0; y<working_copy->getImage()->height(); y++) {
      QColor color = QColor::fromRgb(original->getImage()->pixel(x, y));
      //color.getHsl(&h, &s, &l);
      //l = brightness_map[l];
      //color.setHsl(h, s, l);
      struct yuv yuv = LazyImage::RGBToYUV(color.rgb());
      int l = qRound(yuv.y * 255.0);
      yuv.y = qFloor(brightness_map[l]) / 255.0;
      color = LazyImage::YUVToRGB(yuv);
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }

  
  // Done.
  free(brightness_map);
  free(histogramm_map);
  free(parts);
  logFile << "done." << std::endl;
  renewLogging();
  updateImageDisplay();
}

/**
 * Do a succeeding histogramm adaption based on a reference image.
 * 
 * @brief Imageviewer::succeedingHistogrammAdaption
 */
void ImageViewer::succeedingHistogrammAdaption() {
  logFile << "Doing succeeding histogramm adaption ..." << std::endl;
  renewLogging();
  if(histogramm_reference == NULL) {
    logFile << "No reference image loaded! Aborting." << std::endl;
    renewLogging();
    return;
  } else {
    // Create an intensity map
    int histogramm_map[256];
    for(int i=0; i<256; i++) histogramm_map[i] = -1;
    int source_cursor = 0;
    double used_space = 0.0;
    double* source_histogramm = original->getRelativeIntensityHistogramm();
    double* target_cummulative_histogramm = histogramm_reference->getRelativeCumulativeIntensityHistogramm();
    for(int i=0; i<256; i++) {
      double free_total_space = target_cummulative_histogramm[i];
      while(source_histogramm[source_cursor] <= (free_total_space - used_space)) {
	histogramm_map[source_cursor] = i;
	used_space += source_histogramm[source_cursor];
	source_cursor++;
      }
      // If there is no more space, just put it to the last value used. :/
      // Otherwise, we don't know what to do with some pixels.
      if(source_histogramm[source_cursor] > (free_total_space - used_space)) {
	histogramm_map[source_cursor] = i;
      }
    }
    
    // Apply the map for each pixel.
    //int h, s, l;
    for(int x=0; x<working_copy->getImage()->width(); x++) {
      for(int y=0; y<working_copy->getImage()->height(); y++) {
 	QColor color = QColor::fromRgb(original->getImage()->pixel(x, y));
	//color.getHsl(&h, &s, &l);
        //l = histogramm_map[l];
        //color.setHsl(h, s, l);
        struct yuv yuv = LazyImage::RGBToYUV(color.rgb());
        int l = qRound(yuv.y * 255.0);
        yuv.y = qFloor(histogramm_map[l]) / 255.0;
        color = LazyImage::YUVToRGB(yuv);
        working_copy->getImage()->setPixel(x, y, color.rgb());
      }
    }
    // Done.
  }
  logFile << "done." << std::endl;
  renewLogging();
  updateImageDisplay();
}

/**
 * No special logic, avoid the borders and apply the filter.
 * 
 * @brief ImageViewer::applyBasicFilter
 */
void ImageViewer::applyBasicFilter() {
  logFile << "Applying basic filter ..." << std::endl;
  renewLogging();
  
  int* data = filter_gui->getData();
  int filter_size = filter_gui->getSize();
  
  // sum up the filter weights
  int filter_sum = 0;
  for(int i=0; i<filter_size; i++) {
    for(int j=0; j<filter_size; j++) {
      int current_data = data[i*filter_size + j];
      filter_sum += abs(current_data); // support for negativ weights using abs()
      logFile << "[" << i << "," << j << "] -> " << current_data << "  ";
    }
    logFile << std::endl;
  }
  logFile << "Beginning calculation ... " << std::endl;
  renewLogging();
  
  int h, s, l;
  // for each pixel
  int filter_offset = ((filter_size+1)/2);
  for(int x=0+filter_offset; x<working_copy->getImage()->width()-filter_offset; x++) {
    for(int y=0+filter_offset; y<working_copy->getImage()->height()-filter_offset; y++) {
      int intensity_sum = 0;
      // sum up weighted intensity for each matrix entry
      for(int fx=0; fx<filter_size; fx++) {
	int dx = fx - (filter_size / 2);
        for(int fy=0; fy<filter_size; fy++) {
	  int dy = fy - (filter_size / 2);
	  QColor color = QColor::fromRgb(original->getImage()->pixel(x+dx, y+dy));
	  color.getHsl(&h, &s, &l);
	  //std::cout << "[" << fx << "," << fy <<"] " << l << " * " << data[fx*filter_size + fy] << " = ";
	  intensity_sum += (l * data[fy*filter_size + fx]);
	  //std::cout << intensity_sum << std::endl;
        }	
      }
      QColor color = QColor::fromRgb(original->getImage()->pixel(x, y));
      color.getHsl(&h, &s, &l);
      //std::cout << "old lightness: " << l << ", filter_sum: " << filter_sum << ", intensity_sum:" << intensity_sum;
      // divide by sum of weights
      l = qRound((intensity_sum*1.0) / filter_sum);
      //optional clamping for exotic stuff like negative values
      if(l > 255) l = 255;
      if(l < 0) l = 0;
      //std::cout << " --> new l: " << l << std::endl;
      color.setHsl(h, s, l);
      // and set it.
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }  
  
  logFile << "done." << std::endl;
  renewLogging();
  updateImageDisplay();
}

/**
 * Basic filter PLUS different overflow modes
 * 
 * @brief ImageViewer::applyBasicFilterWithOverflowHandling
 */
void ImageViewer::applyBasicFilterWithOverflowHandling() {
  QString chosen_mode = filter_mode_combobox->currentText();
  LazyImage::overflowMode overflow_mode = LazyImage::CONSTANT; // default for compiler
  if(chosen_mode == "Zero padding") overflow_mode = LazyImage::ZERO_PADDING;
  else if(chosen_mode == "Constant") overflow_mode = LazyImage::CONSTANT;
  else if(chosen_mode == "Continuous") overflow_mode = LazyImage::CONTINUOUS;
  else if(chosen_mode == "Mirrored") overflow_mode = LazyImage::MIRRORED;
  else {
    logFile << "Could not determine chosen mode, this is a problem!" << std::endl;
  }
  logFile << "Applying basic filter - overflow mode: " << chosen_mode.toStdString() << " -> " << overflow_mode << std::endl;
  renewLogging();
  
  int* data = filter_gui->getData();
  int filter_size = filter_gui->getSize();
  
  // sum up the filter weights
  int filter_sum = 0;
  for(int i=0; i<filter_size; i++) {
    for(int j=0; j<filter_size; j++) {
      int current_data = data[i*filter_size + j];
      filter_sum += abs(current_data); // support for negativ weights using abs()
      logFile << "[" << i << "," << j << "] -> " << current_data << "  ";
    }
    logFile << std::endl;
  }
  logFile << "Beginning calculation ... " << std::endl;
  renewLogging();
  
  int h, s, l;
  // for each pixel
  for(int x=0; x<working_copy->getImage()->width(); x++) {
    for(int y=0; y<working_copy->getImage()->height(); y++) {
      int intensity_sum = 0;
      // sum up weighted intensity for each matrix entry
      for(int fx=0; fx<filter_size; fx++) {
	int dx = fx - (filter_size / 2);
        for(int fy=0; fy<filter_size; fy++) {
	  int dy = fy - (filter_size / 2);
	  QColor color = QColor::fromRgb(original->getPixel(x+dx, y+dy, overflow_mode));
	  color.getHsl(&h, &s, &l);
	  //std::cout << "[" << fx << "," << fy <<"] " << l << " * " << data[fx*filter_size + fy] << " = ";
	  intensity_sum += (l * data[fy*filter_size + fx]);
	  //std::cout << intensity_sum << std::endl;
        }	
      }
      QColor color = QColor::fromRgb(original->getImage()->pixel(x, y));
      color.getHsl(&h, &s, &l);
      //std::cout << "old lightness: " << l << ", filter_sum: " << filter_sum << ", intensity_sum:" << intensity_sum;
      // divide by sum of weights
      l = qRound((intensity_sum*1.0) / filter_sum);
      //optional clamping for exotic stuff like negative values
      if(l > 255) l = 255;
      if(l < 0) l = 0;
      //std::cout << " --> new l: " << l << std::endl;
      color.setHsl(h, s, l);
      // and set it.
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }  
  
  logFile << "done." << std::endl;
  renewLogging();
  updateImageDisplay();
}

/**
 * Does the whole canny edge thing.
 * 
 * @brief ImageViewer::runCannyEdge 
 */
void ImageViewer::runCannyEdge(void) {
  int filter_size = gauss_filter_size->value();
  double filter_sigma = gauss_filter_sigma->value();
  double t_low = t_low_spinbox->value();
  double t_high = t_high_spinbox->value();
  logFile << "Canny-Edge using N*N filter size: " << filter_size << ", filter sigma: " << filter_sigma << ", and thresholds: " << t_low << ", " << t_high << std::endl;
  renewLogging();
  canny_edge_machine->setGaussFilterParams(filter_size, filter_sigma);
  canny_edge_machine->setThresholdValues(t_low, t_high);
  canny_edge_machine->work();
  updateImageDisplay();  
}

/**
 * Does the first step of canny edge.
 * 
 * @brief ImageViewer::runCannyEdgeFirstStep
 */
void ImageViewer::runCannyEdgeFirstStep(void) {
  int filter_size = gauss_filter_size->value();
  double filter_sigma = gauss_filter_sigma->value();
  double t_low = t_low_spinbox->value();
  double t_high = t_high_spinbox->value();
  logFile << "[Step 1] Canny-Edge using N*N filter size: " << filter_size << ", filter sigma: " << filter_sigma << ", and thresholds: " << t_low << ", " << t_high << std::endl;
  renewLogging();
  canny_edge_machine->setGaussFilterParams(filter_size, filter_sigma);
  canny_edge_machine->setThresholdValues(t_low, t_high);
  canny_edge_machine->doFirstStep();
  updateImageDisplay();  
}

/**
 * Does the second step of canny edge.
 * 
 * @brief ImageViewer::runCannyEdgeSecondStep
 */
void ImageViewer::runCannyEdgeSecondStep(void) {
  int filter_size = gauss_filter_size->value();
  double filter_sigma = gauss_filter_sigma->value();
  double t_low = t_low_spinbox->value();
  double t_high = t_high_spinbox->value();
  logFile << "[Step 2] Canny-Edge using N*N filter size: " << filter_size << ", filter sigma: " << filter_sigma << ", and thresholds: " << t_low << ", " << t_high << std::endl;
  renewLogging();
  canny_edge_machine->setGaussFilterParams(filter_size, filter_sigma);
  canny_edge_machine->setThresholdValues(t_low, t_high);
  canny_edge_machine->doSecondStep();
  updateImageDisplay();  
}

/**
 * Does the third step of canny edge.
 * 
 * @brief ImageViewer::runCannyEdgeThirdStep
 */
void ImageViewer::runCannyEdgeThirdStep(void) {
  int filter_size = gauss_filter_size->value();
  double filter_sigma = gauss_filter_sigma->value();
  double t_low = t_low_spinbox->value();
  double t_high = t_high_spinbox->value();
  logFile << "[Step 3] Canny-Edge using N*N filter size: " << filter_size << ", filter sigma: " << filter_sigma << ", and thresholds: " << t_low << ", " << t_high << std::endl;
  renewLogging();
  canny_edge_machine->setGaussFilterParams(filter_size, filter_sigma);
  canny_edge_machine->setThresholdValues(t_low, t_high);
  canny_edge_machine->doThirdStep();
  updateImageDisplay();  
}

/**
 * Do generic usm.
 * 
 * @brief ImageViewer::doUnsharpMasking
 */
void ImageViewer::doUnsharpMasking(void) {
  double alpha = usm_sharpening->value();
  int gauss_width = usm_gauss_width->value();
  double sigma = usm_gauss_sigma->value();  
  logFile << "Doing USM using gauss width of " << gauss_width << ", sigma of " << sigma << ", and alpha of " << alpha << std::endl;
  renewLogging();
  int pixels = original->width() * original->height();
  int* blurred_intensity = (int*) malloc(sizeof(int) * pixels);
  int* mask = (int*) malloc(sizeof(int) * pixels);
  double sum_weights = 0.0;
  double* filter = canny_edge_machine->generateGaussFilter(gauss_width, sigma, sum_weights);
  int h, s, l;
  for(int x=0; x<original->width(); x++) {
    for(int y=0; y<original->height(); y++) {
      // Step 1: Blur the image and store seperately
      double sum_intensity = 0.0;
      for(int fx=0; fx<gauss_width; fx++) {
	int dx = fx - (gauss_width/2);
        for(int fy=0; fy<gauss_width; fy++) {
	  int dy = fy - (gauss_width/2);
	  QColor color = QColor::fromRgb(original->getPixel(x+dx, y+dy, LazyImage::CONSTANT));
	  color.getHsl(&h, &s, &l);
          sum_intensity += l;
        }
      }
      double average_intensity = sum_intensity / sum_weights;
      // Step 2: Subtract blurred image from original -> store as mask
      QColor color = QColor::fromRgb(original->getPixel(x, y, LazyImage::CONSTANT));
      color.getHsl(&h, &s, &l);
      double intensity_mask = l - average_intensity;
      // Step 3: Add weighted mask to original -> sharpening occurs.
      double intensity_result = alpha * intensity_mask + l;
      if(intensity_result > 255) intensity_result = 255;
      if(intensity_result < 0) intensity_result = 0;      
      color.setHsl(h, s, qRound(intensity_result));
      working_copy->getImage()->setPixel(x, y, color.rgb());
    }
  }
  free(filter);
  free(mask);
  free(blurred_intensity);
  updateImageDisplay();
}

/**
 * Do the hough transformation
 * 
 * @brief ImageViewer::runHoughTransformation
 */
void ImageViewer::runHoughTransformation(void) {
  logFile << "Let's run a hough transformation!" << std::endl;
  renewLogging();
  HoughMachine* hm = new HoughMachine(original, working_copy);
  hm->run(250, 250);
  delete hm;
  updateImageDisplay();  
}
/**************************************************************************************** 
*   
*  GUI elements related to the tasks are set up here.
*
*****************************************************************************************/

void ImageViewer::changeFilterSize(int s) {
  filter_gui->setSize(((s+1)*2)+1);
  logFile << "done." << std::endl;
  renewLogging();
}

void ImageViewer::generateControlPanels() {
  // Tab for first task
  task_tab1_widget = new QWidget();
  task_tab1_vboxlayout = new QVBoxLayout();
  task_tab1_widget->setLayout(task_tab1_vboxlayout);
  task_tab1_scrollwidget = new QWidget();
  task_tab1_scrollarea = new QScrollArea();
  task_tab1_scrollarea->setWidgetResizable(true);
  task_tab1_scrollarea->setWidget(task_tab1_scrollwidget);
  task_tab1_vboxlayout->addWidget(task_tab1_scrollarea);
  task_tab1_scrolllayout = new QVBoxLayout();
  task_tab1_scrolllayout->setSizeConstraint(QLayout::SetMaximumSize);
  task_tab1_scrollwidget->setLayout(task_tab1_scrolllayout);

  monochrome = new QPushButton();
  monochrome->setText("Convert to monochrome");
  QObject::connect(monochrome, SIGNAL(clicked()), this, SLOT (convertToMonochrome()));
  
  reset_working_copy = new QPushButton();
  reset_working_copy->setText("Reset working copy");
  QObject::connect(reset_working_copy, SIGNAL(clicked()), this, SLOT (resetWorkingCopy()));
  
  save_to_original = new QPushButton();
  save_to_original->setText("Save working copy to original");
  QObject::connect(save_to_original, SIGNAL(clicked()), this, SLOT (saveToOriginal()));
  
  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()));

  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_scrolllayout->addWidget(reset_working_copy);
  task_tab1_scrolllayout->addWidget(save_to_original);
  task_tab1_scrolllayout->addWidget(monochrome);
  task_tab1_scrolllayout->addWidget(new QLabel("Let's draw something!"));
  task_tab1_scrolllayout->addWidget(draw_black_line);
  task_tab1_scrolllayout->addWidget(draw_rainbow_cross);
  task_tab1_scrolllayout->addWidget(diagonal_cross);
  task_tab1_scrolllayout->addWidget(line_slider);
  task_tab1_scrolllayout->addWidget(new QLabel("Sets the width of the cross."));

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

  // Tab for second task
  task_tab2_widget = new QWidget();
  task_tab2_vboxlayout = new QVBoxLayout();
  task_tab2_widget->setLayout(task_tab2_vboxlayout);
  task_tab2_scrollwidget = new QWidget();
  task_tab2_scrollarea = new QScrollArea();
  task_tab2_scrollarea->setWidgetResizable(true);
  task_tab2_scrollarea->setWidget(task_tab2_scrollwidget);
  task_tab2_vboxlayout->addWidget(task_tab2_scrollarea);
  task_tab2_scrolllayout = new QVBoxLayout();
  task_tab2_scrolllayout->setSizeConstraint(QLayout::SetMaximumSize);
  task_tab2_scrollwidget->setLayout(task_tab2_scrolllayout);
  
  reference_histogramm_label = new QLabel();
  reference_histogramm_label->setBackgroundRole(QPalette::Base);
  reference_histogramm_label->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
  reference_histogramm_label->setScaledContents(false);
  
  reference_stats = new QLabel();
  reference_stats->setText("Stats for reference image will be shown here.");
  
  original_histogramm_label = new QLabel();
  original_histogramm_label->setBackgroundRole(QPalette::Base);
  original_histogramm_label->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
  original_histogramm_label->setScaledContents(false);
  
  histogramm_label = new QLabel();
  histogramm_label->setBackgroundRole(QPalette::Base);
  histogramm_label->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
  histogramm_label->setScaledContents(false);

  original_stats = new QLabel();
  original_stats->setText("Stats for original image will be shown here.");
  
  stats = new QLabel();
  stats->setText("Stats for working copy will be shown here.");
  
  analyze_image = new QPushButton();
  analyze_image->setText("Update image statistics, redraw histogramms.");
  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)));

  contrast_percentile_slider = new QSlider(Qt::Horizontal);
  contrast_percentile_slider->setMinimum(0);
  contrast_percentile_slider->setMaximum(100);
  contrast_percentile_slider->setValue(10);  
  QObject::connect(contrast_percentile_slider, SIGNAL(valueChanged(int)), this, SLOT(robustAutomaticContrastAdaption(int)));

  task_tab2_scrolllayout->addWidget(new QLabel("Reference image"));
  task_tab2_scrolllayout->addWidget(reference_stats);
  task_tab2_scrolllayout->addWidget(reference_histogramm_label);
  task_tab2_scrolllayout->addWidget(new QLabel("Original image"));
  task_tab2_scrolllayout->addWidget(original_stats);
  task_tab2_scrolllayout->addWidget(original_histogramm_label);
  task_tab2_scrolllayout->addWidget(new QLabel("Working copy"));
  task_tab2_scrolllayout->addWidget(stats);
  task_tab2_scrolllayout->addWidget(histogramm_label);
  task_tab2_scrolllayout->addWidget(analyze_image);
  task_tab2_scrolllayout->addWidget(new QLabel("Brightness"));
  task_tab2_scrolllayout->addWidget(brightness_slider);
  task_tab2_scrolllayout->addWidget(new QLabel("Contrast"));
  task_tab2_scrolllayout->addWidget(contrast_slider);
  task_tab2_scrolllayout->addWidget(new QLabel("Automatic Contrast Percentile"));
  task_tab2_scrolllayout->addWidget(contrast_percentile_slider);

  tabWidget->addTab(task_tab2_widget, "Task #2");
  
  
  // Tab for third task
  task_tab3_widget = new QWidget();
  task_tab3_vboxlayout = new QVBoxLayout();
  task_tab3_widget->setLayout(task_tab3_vboxlayout);
  task_tab3_scrollwidget = new QWidget();
  task_tab3_scrollarea = new QScrollArea();
  task_tab3_scrollarea->setWidgetResizable(true);
  task_tab3_scrollarea->setWidget(task_tab3_scrollwidget);
  task_tab3_vboxlayout->addWidget(task_tab3_scrollarea);
  task_tab3_scrolllayout = new QVBoxLayout();
  task_tab3_scrolllayout->setSizeConstraint(QLayout::SetMaximumSize);
  task_tab3_scrollwidget->setLayout(task_tab3_scrolllayout);

  reference_histogramm_cumulative_label = new QLabel();
  reference_histogramm_cumulative_label->setBackgroundRole(QPalette::Base);
  reference_histogramm_cumulative_label->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
  reference_histogramm_cumulative_label->setScaledContents(false);
  
  original_histogramm_cumulative_label = new QLabel();
  original_histogramm_cumulative_label->setBackgroundRole(QPalette::Base);
  original_histogramm_cumulative_label->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
  original_histogramm_cumulative_label->setScaledContents(false);
  
  histogramm_cumulative_label = new QLabel();
  histogramm_cumulative_label->setBackgroundRole(QPalette::Base);
  histogramm_cumulative_label->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
  histogramm_cumulative_label->setScaledContents(false);

  linear_histogramm_adaption = new QPushButton("Do linear histogramm adaption (basic)");
  QObject::connect(linear_histogramm_adaption, SIGNAL(clicked()), this, SLOT(linearHistogrammAdaption()));
  
  partial_adaption_pieces_slider = new QSlider(Qt::Horizontal);
  partial_adaption_pieces_slider->setMinimum(2);
  partial_adaption_pieces_slider->setMaximum(20);
  partial_adaption_pieces_slider->setValue(5);
  //QObject::connect(partial_adaption_pieces_slider, SIGNAL(valueChanged(int)), this, SLOT(robustAutomaticContrastAdaption(int)));
  
  partial_linear_histogramm_adaption = new QPushButton("Do partial, linear histogramm adaption");
  QObject::connect(partial_linear_histogramm_adaption, SIGNAL(clicked()), this, SLOT(partialLinearHistogrammAdaption()));
  
  succeeding_histogramm_adaption = new QPushButton("Do succeeding histogramm adaption");
  QObject::connect(succeeding_histogramm_adaption, SIGNAL(clicked()), this, SLOT(succeedingHistogrammAdaption()));

  task_tab3_scrolllayout->addWidget(new QLabel("Reference image"));
  task_tab3_scrolllayout->addWidget(reference_histogramm_cumulative_label);
  task_tab3_scrolllayout->addWidget(new QLabel("Original image"));
  task_tab3_scrolllayout->addWidget(original_histogramm_cumulative_label);
  task_tab3_scrolllayout->addWidget(new QLabel("Working copy"));
  task_tab3_scrolllayout->addWidget(histogramm_cumulative_label);
  task_tab3_scrolllayout->addWidget(linear_histogramm_adaption);
  task_tab3_scrolllayout->addWidget(partial_adaption_pieces_slider);
  task_tab3_scrolllayout->addWidget(partial_linear_histogramm_adaption);
  task_tab3_scrolllayout->addWidget(succeeding_histogramm_adaption);
  
  tabWidget->addTab(task_tab3_widget, "Task #3");
  
  
  // Tab for fourth task
  task_tab4_widget = new QWidget();
  task_tab4_vboxlayout = new QVBoxLayout();
  task_tab4_widget->setLayout(task_tab4_vboxlayout);
  task_tab4_scrollwidget = new QWidget();
  task_tab4_scrollarea = new QScrollArea();
  task_tab4_scrollarea->setWidgetResizable(true);
  task_tab4_scrollarea->setWidget(task_tab4_scrollwidget);
  task_tab4_vboxlayout->addWidget(task_tab4_scrollarea);
  task_tab4_scrolllayout = new QVBoxLayout();
  task_tab4_scrolllayout->setSizeConstraint(QLayout::SetMaximumSize);
  task_tab4_scrollwidget->setLayout(task_tab4_scrolllayout);
  
  filter_size_slider = new QSlider(Qt::Horizontal);
  filter_size_slider->setMinimum(0);
  filter_size_slider->setMaximum(4);
  filter_size_slider->setValue(0);
  QObject::connect(filter_size_slider, SIGNAL(valueChanged(int)), this, SLOT(changeFilterSize(int)));
  
  filter_gui = new FilterGui();
  
  apply_filter = new QPushButton("Apply filter");
  QObject::connect(apply_filter, SIGNAL(clicked()), this, SLOT(applyBasicFilter()));

  filter_mode_combobox = new QComboBox();
  filter_mode_combobox->addItem("Zero padding");
  filter_mode_combobox->addItem("Constant");
  filter_mode_combobox->addItem("Mirrored");
  filter_mode_combobox->addItem("Continuous");
  
  apply_border_mode_filter = new QPushButton("Apply filter with overflow handling");
  QObject::connect(apply_border_mode_filter, SIGNAL(clicked()), this, SLOT(applyBasicFilterWithOverflowHandling()));
  
  task_tab4_scrolllayout->addWidget(filter_size_slider);
  task_tab4_scrolllayout->addWidget(filter_gui->getWidget());
  task_tab4_scrolllayout->addWidget(apply_filter);
  task_tab4_scrolllayout->addWidget(new QLabel("Choose border overflow mode:"));
  task_tab4_scrolllayout->addWidget(filter_mode_combobox);
  task_tab4_scrolllayout->addWidget(apply_border_mode_filter);
  
  tabWidget->addTab(task_tab4_widget, "Task #4");
  
  
  // Tab for fifth task
  task_tab5_widget = new QWidget();
  task_tab5_vboxlayout = new QVBoxLayout();
  task_tab5_widget->setLayout(task_tab5_vboxlayout);
  task_tab5_scrollwidget = new QWidget();
  task_tab5_scrollarea = new QScrollArea();
  task_tab5_scrollarea->setWidgetResizable(true);
  task_tab5_scrollarea->setWidget(task_tab5_scrollwidget);
  task_tab5_vboxlayout->addWidget(task_tab5_scrollarea);
  task_tab5_scrolllayout = new QVBoxLayout();
  task_tab5_scrolllayout->setSizeConstraint(QLayout::SetMaximumSize);
  task_tab5_scrollwidget->setLayout(task_tab5_scrolllayout);
  
  run_canny_edge = new QPushButton("Run whole canny edge algorithm!");
  QObject::connect(run_canny_edge, SIGNAL(clicked()), this, SLOT(runCannyEdge()));
  
  run_canny_edge_first_step = new QPushButton("Do gaussian blur and do gradiants");
  QObject::connect(run_canny_edge_first_step, SIGNAL(clicked()), this, SLOT(runCannyEdgeFirstStep()));
  
  run_canny_edge_second_step = new QPushButton("Filter local maxima");
  QObject::connect(run_canny_edge_second_step, SIGNAL(clicked()), this, SLOT(runCannyEdgeSecondStep()));
  
  run_canny_edge_third_step = new QPushButton("Work local maxima, show result");
  QObject::connect(run_canny_edge_third_step, SIGNAL(clicked()), this, SLOT(runCannyEdgeThirdStep()));
  
  gauss_filter_size = new QDoubleSpinBox();
  gauss_filter_size->setDecimals(0);
  gauss_filter_size->setMinimum(3);
  gauss_filter_size->setValue(3);
  
  gauss_filter_sigma = new QDoubleSpinBox();
  gauss_filter_sigma->setDecimals(5);
  gauss_filter_sigma->setValue(1.4);
  
  t_low_spinbox = new QDoubleSpinBox();
  t_low_spinbox->setDecimals(5);
  t_low_spinbox->setValue(2.0);

  t_high_spinbox = new QDoubleSpinBox();
  t_high_spinbox->setDecimals(5);
  t_high_spinbox->setValue(4.0);
  
  usm_sharpening = new QDoubleSpinBox();
  usm_sharpening->setDecimals(5);
  usm_sharpening->setValue(1.0);

  usm_gauss_width = new QDoubleSpinBox();
  usm_gauss_width->setDecimals(0);
  usm_gauss_width->setValue(3);

  usm_gauss_sigma = new QDoubleSpinBox();
  usm_gauss_sigma->setDecimals(5);
  usm_gauss_sigma->setValue(4);
  
  run_usm = new QPushButton("Apply unsharp masking!");
  QObject::connect(run_usm, SIGNAL(clicked()), this, SLOT(doUnsharpMasking()));
 
  task_tab5_scrolllayout->addWidget(new QLabel("Gauss filter size (NxN)"));
  task_tab5_scrolllayout->addWidget(gauss_filter_size);
  task_tab5_scrolllayout->addWidget(new QLabel("Gauss filter sigma"));
  task_tab5_scrolllayout->addWidget(gauss_filter_sigma);
  task_tab5_scrolllayout->addWidget(run_canny_edge_first_step);
  task_tab5_scrolllayout->addWidget(new QLabel("Low threshold value"));
  task_tab5_scrolllayout->addWidget(t_low_spinbox);
  task_tab5_scrolllayout->addWidget(run_canny_edge_second_step);
  task_tab5_scrolllayout->addWidget(new QLabel("High threshold value"));
  task_tab5_scrolllayout->addWidget(t_high_spinbox);
  task_tab5_scrolllayout->addWidget(run_canny_edge_third_step);
  task_tab5_scrolllayout->addWidget(run_canny_edge);
  task_tab5_scrolllayout->addWidget(new QLabel(" --- Unsharp masking --- "));
  task_tab5_scrolllayout->addWidget(new QLabel("Sharpening factor alpha"));
  task_tab5_scrolllayout->addWidget(usm_sharpening);
  task_tab5_scrolllayout->addWidget(new QLabel("Gauss filter width and sigma"));
  task_tab5_scrolllayout->addWidget(usm_gauss_width);
  task_tab5_scrolllayout->addWidget(usm_gauss_sigma);
  task_tab5_scrolllayout->addWidget(run_usm);
  
  tabWidget->addTab(task_tab5_widget, "Task #5");
  
  
  // Tab for sixth task
  task_tab6_widget = new QWidget();
  task_tab6_vboxlayout = new QVBoxLayout();
  task_tab6_widget->setLayout(task_tab6_vboxlayout);
  task_tab6_scrollwidget = new QWidget();
  task_tab6_scrollarea = new QScrollArea();
  task_tab6_scrollarea->setWidgetResizable(true);
  task_tab6_scrollarea->setWidget(task_tab6_scrollwidget);
  task_tab6_vboxlayout->addWidget(task_tab6_scrollarea);
  task_tab6_scrolllayout = new QVBoxLayout();
  task_tab6_scrolllayout->setSizeConstraint(QLayout::SetMaximumSize);
  task_tab6_scrollwidget->setLayout(task_tab6_scrolllayout);
  
  run_hough_transformation = new QPushButton("Run hough transformation!");
  QObject::connect(run_hough_transformation, SIGNAL(clicked()), this, SLOT(runHoughTransformation()));
  
  task_tab6_scrolllayout->addWidget(new QLabel("Task #6 and stuff"));
  task_tab6_scrolllayout->addWidget(run_hough_transformation);
  
  tabWidget->addTab(task_tab6_widget, "Task #6");
  
  //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(*(working_copy->getImage())));
}


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(working_copy != NULL) {
    delete working_copy;
    working_copy = NULL;
  }
  if(original != NULL) {
    delete original;
    original = NULL;
  }
  if(canny_edge_machine != NULL) {
    delete canny_edge_machine;
    canny_edge_machine = NULL;
  }
  QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QDir::currentPath());
  if(!fileName.isEmpty()) {
    working_copy = new LazyImage(new QImage(fileName));
    original = new LazyImage(new QImage(fileName));
    if(working_copy->getImage()->isNull()) {
      QMessageBox::information(this, tr("Image Viewer"), tr("Cannot load %1.").arg(fileName));
      return;
    }
    canny_edge_machine = new CannyEdgeMachine(original, working_copy);
    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.
  }
}

/**
 * Simply load another image to provide reference for some operations.
 * @brief ImageViewer::openReference
 */
void ImageViewer::openReference() {
  if(histogramm_reference != NULL) {
    delete histogramm_reference;
    histogramm_reference = NULL;
  }
  QString fileName = QFileDialog::getOpenFileName(this, tr("Open Histogramm Reference File"), QDir::currentPath());
  if(!fileName.isEmpty()) {
    histogramm_reference = new LazyImage(new QImage(fileName));
    if(histogramm_reference->getImage()->isNull()) {
      QMessageBox::information(this, tr("Image Viewer"), tr("Cannot load %1.").arg(fileName));
      return;
    }
    
    if(histogramm_reference->getImage() != NULL) {
      histogramm_reference->updateStatistics();
      QString result = QString("Intensity: Average: %1, Variance: %2").arg(histogramm_reference->getIntensityAverage()).arg(histogramm_reference->getIntensityVariance());
      reference_stats->setText(result);
      reference_histogramm_label->setPixmap(QPixmap::fromImage(*(histogramm_reference->getHistogrammNormalImage())));
      reference_histogramm_cumulative_label->setPixmap(QPixmap::fromImage(*(histogramm_reference->getHistogrammCumulativeImage())));
    }
    
    logFile << "Referenzbild geladen: " << fileName.toStdString().c_str()  << std::endl;
    renewLogging();
  }
}

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()));

  openHistAct = new QAction(tr("Open &Reference..."), this);
  openHistAct->setShortcut(tr("Ctrl+O"));
  connect(openHistAct, SIGNAL(triggered()), this, SLOT(openReference()));
  
  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(openHistAct);
  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)));
}