Hochschulprojekte/CG2_Tasks
0
0
Fork 0
Code Issues Pull Requests Activity
d809149668
CG2_Tasks/imageviewer-qt4.cpp

1428 lines
53 KiB
C++
Raw Blame History

/****************************************************************************
**
** 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)));
}
Reference in New Issue View Git Blame Copy Permalink