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

703 lines
22 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_image = NULL;
image = NULL;
histogramm = NULL;
startLogging();
generateMainGui();
renewLogging();
generateControlPanels();
createActions();
createMenus();
resize(1600, 600);
}
/**
* Once an image is loaded, automatically perform these operations.
*
* analyze the image
* allocate brightness map
*
* @brief ImageViewer::initializeImage
*/
void ImageViewer::initializeImage() {
if(image==NULL) {
std::cout << "Error! No image provided!" << std::endl;
return;
}
analyzeImage();
}
int ImageViewer::calcIntensity(int r, int g, int b) {
return (int) qRound(0.299*r + 0.587*g + 0.114*b);
}
/**
* In case it is needed, convert the loaded image into grayscale.
* @brief ImageViewer::convertToMonochrome
*/
void ImageViewer::convertToMonochrome() {
if(image!=NULL) {
logFile << "Converting image to monochrome...";
renewLogging();
for(int x=0; x<image->width(); x++) {
for(int y=0; y<image->height(); y++) {
int r,g,b;
QColor color = QColor::fromRgb(image->pixel(x, y));
color.getRgb(&r,&g,&b);
int intensity = calcIntensity(r, g, b);
color = QColor::fromRgb(intensity, intensity, intensity);
image->setPixel(x, y, color.rgba());
original_image->setPixel(x, y, color.rgba());
}
}
updateImageDisplay();
logFile << "done." << std::endl;
renewLogging();
}
}
/**
* Draws a simple, black line.
* @brief ImageViewer::drawBlackLine
*/
void ImageViewer::drawBlackLine() {
if(image!=NULL) {
for(int i=0;i<std::min(image->width(),image->height());i++) {
image->setPixel(i,i,0);
}
updateImageDisplay();
logFile << "Black line drawn." << std::endl;
renewLogging();
}
}
/**
* Draws a diagonal cross from edge to edge.
* @brief ImageViewer::drawDiagonalCross
*/
void ImageViewer::drawDiagonalCross() {
if(image!=NULL) {
int color = QColor::fromHsl(120,255,125).rgba();
int width = image->width();
int height = image->height();
for(int y=0; y<image->height(); y++) {
image->setPixel((1.0*y/height)*width,y,color);
image->setPixel((1.0-(1.0*y/height))*width,y,color);
}
}
updateImageDisplay();
logFile << "Diagonal edge-to-edge cross drawn." << std::endl;
renewLogging();
}
/**
* Proxy method to actual method due to signal param issues.
* @brief ImageViewer::drawRainbowCross
*/
void ImageViewer::drawRainbowCross() {
drawRainbowCross(0);
}
/**
* Draws a diagonal cross with variable width and
* varying color.
* Fetches the width from the slider.
* @brief ImageViewer::drawRainbowCross
* @param initialHue
*/
void ImageViewer::drawRainbowCross(int initialHue=0) {
if(image!=NULL) {
int h = initialHue;
QColor myColor = QColor::fromHsl(h, 255, 125);
int image_width = image->width()-1;
int range = line_slider->value();
if(range > image->width()-2) range = image->width()-2;
for(int i=0;i<std::min(image->width(),image->height());i++) {
int color = myColor.rgba();
for(int r=0; r<range; r++) {
image->setPixel(i+r,i,color);
image->setPixel((image_width-i)-r,i,color);
}
h++;
if(h > 359) h = 0;
myColor.setHsl(h, 255, 125);
}
updateImageDisplay();
}
}
/**
* Repeatedly draw the rainbow cross forever.
* You will need to kill the process manually after triggering this.
* @brief ImageViewer::acidTrippin
*/
void ImageViewer::acidTrippin() {
logFile << "There is no stop button yet. Kill the process or keep it." << std::endl;
renewLogging();
int h = 0;
while(true) {
drawRainbowCross(h);
h += 20;
if(h > 359) h = 0;
qApp->processEvents();
}
}
/**
* Analyze the image, get average luminance
* Also fill grayscale_absolute_histogramm
* @brief ImageViewer::analyzeImage
*/
void ImageViewer::analyzeImage() {
if(image!=NULL) {
//Zero existing histogramm data first
for(int i=0; i<256; i++) {
grayscale_absolute_histogramm[i] = 0;
grayscale_relative_histogramm[i] = 0;
}
logFile << "Analyzing image ...";
renewLogging();
for(int x=0; x<image->width(); x++) {
for(int y=0; y<image->height(); y++) {
int r,g,b;
QColor color = QColor::fromRgb(image->pixel(x, y));
color.getRgb(&r,&g,&b);
int intensity = calcIntensity(r, g, b);
grayscale_absolute_histogramm[intensity] += 1;
}
}
int pixels = image->width()*image->height();
for(int i=0; i<256; i++) {
grayscale_relative_histogramm[i] = (((double) grayscale_absolute_histogramm[i])/((double) pixels));
}
logFile << "done" << std::endl;
renewLogging();
QString result = QString("Intensity: Average: %1, Variance: %2").arg(getAverageIntensity()).arg(getIntensityVariance());
stats->setText(result);
updateHistogramm();
}
}
/**
* Use histogramm to retrieve the average intensity.
* @brief ImageViewer::getAverageIntensity
*/
int ImageViewer::getAverageIntensity() {
double sumIntensity = 0;
for(int i=0; i<256;i++) {
sumIntensity += (i*grayscale_relative_histogramm[i]);
}
return (int)sumIntensity;
}
/**
* Retrieve the intensity variance from the image.
* @brief ImageViewer::getVarianceIntensity
*/
int ImageViewer::getIntensityVariance() {
int average_intensity = getAverageIntensity();
int sumDifference = 0;
for(int x=0; x<image->width(); x++) {
for(int y=0; y<image->height(); y++) {
QColor color = QColor::fromRgb(image->pixel(x, y));
int r,g,b;
color.getRgb(&r,&g,&b);
int intensity = calcIntensity(r, g, b);
int diff = std::abs(intensity - average_intensity);
sumDifference += diff;
}
}
return (int) (sumDifference/(image->width()*image->height()));
}
/**
* Builds up the image for the histogramm.
* @brief ImageViewer::updateHistogramm
*/
void ImageViewer::updateHistogramm() {
if(histogramm != NULL) {
delete histogramm;
histogramm = NULL;
}
//Find biggest value in histogramm data
double max = 0;
for(int i=0; i<256; i++) {
if(grayscale_relative_histogramm[i] > max) max = grayscale_relative_histogramm[i];
}
histogramm = new QImage(256, 100, QImage::Format_RGB32);
histogramm->fill(QColor::fromRgb(200,200,200));
int black = QColor::fromRgb(0,0,0).rgba();
for(int x=0; x<256; x++) {
int k_max = (int)((100*grayscale_relative_histogramm[x])/max);
for(int y=0; y<k_max; y++) {
histogramm->setPixel(x, (100-y)-1, black);
}
}
logFile << "Histogramm done." << std::endl;
renewLogging();
histogramm_label->setPixmap(QPixmap::fromImage(*histogramm));
}
/**
* Fired by the brightness_slider, this one adjusts the brightness on image.
* @brief ImageViewer::adjustBrightness
*/
void ImageViewer::adjustBrightness(int b) {
int h, s, old_l;
int new_l = 0;
int delta = b - 255;
for(int x=0; x<image->width(); x++) {
for(int y=0; y<image->height(); y++) {
QColor color = QColor::fromRgb(original_image->pixel(x, y));
color.getHsl(&h, &s, &old_l);
new_l = old_l + delta;
if(new_l > 255) new_l = 255;
if(new_l < 0) new_l = 0;
color.setHsl(h, s, new_l);
image->setPixel(x, y, color.rgba());
}
}
updateImageDisplay();
logFile << "Brightness adjusted to: " << old_l << " + " << delta << " -> (" << h << ", " << s << ", " << new_l << ")" << std::endl;
renewLogging();
}
/**
* Fired by the constrast_slider, this one adjusts the contrast on image.
* @brief ImageViewer::adjustContrast
*/
void ImageViewer::adjustContrast(int c) {
int h, s, old_l;
int new_l = 0;
double alpha = c / 255.0;
int average_intensity = getAverageIntensity();
for(int x=0; x<image->width(); x++) {
for(int y=0; y<image->height(); y++) {
QColor color = QColor::fromRgb(original_image->pixel(x, y));
color.getHsl(&h, &s, &old_l);
new_l = average_intensity + ((int) round((old_l - average_intensity) * alpha));
if(new_l > 255) new_l = 255;
if(new_l < 0) new_l = 0;
color.setHsl(h, s, new_l);
image->setPixel(x, y, color.rgba());
}
}
updateImageDisplay();
logFile << "[TODO!] Contrast adjusted to: " << old_l << " * " << alpha << " -> (" << h << ", " << s << ", " << new_l << ")" << std::endl;
renewLogging();
}
/****************************************************************************************
*
* GUI elements related to the tasks are set up here.
*
*****************************************************************************************/
void ImageViewer::generateControlPanels() {
// Tab for first task
task_tab_widget1 = new QWidget();
task_tab1 = new QVBoxLayout();
task_tab_widget1->setLayout(task_tab1);
monochrome = new QPushButton();
monochrome->setText("Convert to monochrome");
QObject::connect(monochrome, SIGNAL(clicked()), this, SLOT (convertToMonochrome()));
draw_black_line = new QPushButton();
draw_black_line->setText("Draw a black line");
QObject::connect(draw_black_line, SIGNAL(clicked()), this, SLOT (drawBlackLine()));
draw_rainbow_cross = new QPushButton();
draw_rainbow_cross->setText("Draw a rainbow cross");
QObject::connect(draw_rainbow_cross, SIGNAL(clicked()), this, SLOT (drawRainbowCross()));
acid_trip = new QPushButton();
acid_trip->setText("Start the neverending acid trip!");
QObject::connect(acid_trip, SIGNAL(clicked()), this, SLOT (acidTrippin()));
diagonal_cross = new QPushButton();
diagonal_cross->setText("Draw a diagonal cross");
QObject::connect(diagonal_cross, SIGNAL(clicked()), this, SLOT (drawDiagonalCross()));
line_slider = new QSlider(Qt::Horizontal);
line_slider->setMinimum(1);
line_slider->setMaximum(150);
line_slider->setValue(3);
//QObject::connect(lineSlider, SIGNAL(valueChanged(int)), this, SLOT (drawRainbowCross()));
task_tab1->addWidget(monochrome);
task_tab1->addWidget(new QLabel("Let's draw something!"));
task_tab1->addWidget(draw_black_line);
task_tab1->addWidget(draw_rainbow_cross);
task_tab1->addWidget(acid_trip);
task_tab1->addWidget(diagonal_cross);
task_tab1->addWidget(new QLabel("This will not stop unless process is killed."));
task_tab1->addWidget(line_slider);
task_tab1->addWidget(new QLabel("Sets the width of the cross."));
tabWidget->addTab(task_tab_widget1, "Task #1");
//Tab for second task
task_tab_widget2 = new QWidget();
task_tab2 = new QVBoxLayout();
task_tab_widget2->setLayout(task_tab2);
histogramm_label = new QLabel();
histogramm_label->setBackgroundRole(QPalette::Base);
histogramm_label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
histogramm_label->setScaledContents(false);
stats = new QLabel();
stats->setText("Intensity will be shown here.");
analyze_image = new QPushButton();
analyze_image->setText("Analyze image");
QObject::connect(analyze_image, SIGNAL(clicked()), this, SLOT(analyzeImage()));
brightness_slider = new QSlider(Qt::Horizontal);
brightness_slider->setMinimum(0);
brightness_slider->setMaximum(510);
brightness_slider->setValue(255);
QObject::connect(brightness_slider, SIGNAL(valueChanged(int)), this, SLOT (adjustBrightness(int)));
contrast_slider = new QSlider(Qt::Horizontal);
contrast_slider->setMinimum(0);
contrast_slider->setMaximum(510);
contrast_slider->setValue(255);
QObject::connect(contrast_slider, SIGNAL(valueChanged(int)), this, SLOT (adjustContrast(int)));
task_tab2->addWidget(stats);
task_tab2->addWidget(new QLabel("Histogramm"));
task_tab2->addWidget(histogramm_label);
task_tab2->addWidget(analyze_image);
task_tab2->addWidget(new QLabel("Brightness"));
task_tab2->addWidget(brightness_slider);
task_tab2->addWidget(new QLabel("Contrast"));
task_tab2->addWidget(contrast_slider);
tabWidget->addTab(task_tab_widget2, "Task #2");
//Tab for third task
task_tab_widget3 = new QWidget();
task_tab3 = new QVBoxLayout();
task_tab_widget3->setLayout(task_tab3);
tabWidget->addTab(task_tab_widget3, "Task #3");
//Show it
tabWidget->show();
}
/****************************************************************************************
*
* The following methods are about the adjustBrightness(int)generic image viewer application and do not contain
* any special graphics logic.
*
*****************************************************************************************/
void ImageViewer::startLogging()
{
//LogFile
logFile.open("log.txt", std::ios::out);
logFile << "Logging: \n" << std::endl;
}
void ImageViewer::renewLogging()
{
QFile file("log.txt"); // Create a file handle for the file named
QString line;
file.open(QIODevice::ReadOnly); // Open the file
QTextStream stream(&file); // Set the stream to read from myFile
logBrowser->clear();
while(!stream.atEnd()) {
line = stream.readLine(); // this reads a line (QString) from the file
logBrowser->append(line);
}
}
void ImageViewer::updateImageDisplay() {
imageLabel->setPixmap(QPixmap::fromImage(*image));
}
void ImageViewer::generateMainGui() {
/* Tab widget */
tabWidget = new QTabWidget(this);
tabWidget->setObjectName("tabWidget");
/* Center widget */
centralwidget = new QWidget(this);
centralwidget->setObjectName("centralwidget");
//centralwidget->setFixedSize(200,200);
//setCentralWidget(centralwidget);
imageLabel = new QLabel;
imageLabel->setBackgroundRole(QPalette::Base);
imageLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
imageLabel->setScaledContents(true);
/* Center widget */
scrollArea = new QScrollArea;
scrollArea->setBackgroundRole(QPalette::Dark);
scrollArea->setWidget(imageLabel);
setCentralWidget(scrollArea);
/* HBox layout */
QGridLayout* gLayout = new QGridLayout(centralwidget);
gLayout->setObjectName("hboxLayout");
gLayout->addWidget(new QLabel(),1,1);
gLayout->setVerticalSpacing(50);
gLayout->addWidget(tabWidget,2,1);
gLayout->addWidget(scrollArea,2,2);
logBrowser= new QTextEdit(this);
logBrowser->setMinimumHeight(100);
logBrowser->setMaximumHeight(200);
logBrowser->setMinimumWidth(width());
logBrowser->setMaximumWidth(width());
gLayout->addWidget(logBrowser,3,1,1,2);
gLayout->setVerticalSpacing(50);
}
void ImageViewer::print() {
Q_ASSERT(imageLabel->pixmap());
#if !defined(QT_NO_PRINTER) && !defined(QT_NO_PRINTDIALOG)
QPrintDialog dialog(&printer, this);
if (dialog.exec()) {
QPainter painter(&printer);
QRect rect = painter.viewport();
QSize size = imageLabel->pixmap()->size();
size.scale(rect.size(), Qt::KeepAspectRatio);
painter.setViewport(rect.x(), rect.y(), size.width(), size.height());
painter.setWindow(imageLabel->pixmap()->rect());
painter.drawPixmap(0, 0, *imageLabel->pixmap());
}
#endif
}
void ImageViewer::open() {
if(image != NULL) {
delete image;
image = NULL;
}
QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QDir::currentPath());
if(!fileName.isEmpty()) {
image = new QImage(fileName);
if(image->isNull()) {
QMessageBox::information(this, tr("Image Viewer"), tr("Cannot load %1.").arg(fileName));
return;
} else {
if(original_image!=NULL) {
delete original_image;
original_image = NULL;
}
original_image = new QImage(fileName);
}
scaleFactor = 1.0;
updateImageDisplay();
printAct->setEnabled(true);
fitToWindowAct->setEnabled(true);
updateActions();
if(!fitToWindowAct->isChecked()) imageLabel->adjustSize();
setWindowFilePath(fileName);
logFile << "geladen: " << fileName.toStdString().c_str() << std::endl;
renewLogging();
initializeImage(); //Now hook to prepare certain datastructures after loading.
}
}
void ImageViewer::resizeEvent(QResizeEvent* event) {
QMainWindow::resizeEvent(event);
centralwidget->setMinimumWidth(width());
centralwidget->setMinimumHeight(height());
centralwidget->setMaximumWidth(width());
centralwidget->setMaximumHeight(height());
logBrowser->setMinimumWidth(width()-40);
logBrowser->setMaximumWidth(width()-40);
}
void ImageViewer::zoomIn() {
scaleImage(1.25);
}
void ImageViewer::zoomOut() {
scaleImage(0.8);
}
void ImageViewer::normalSize() {
imageLabel->adjustSize();
scaleFactor = 1.0;
}
void ImageViewer::fitToWindow() {
bool fitToWindow = fitToWindowAct->isChecked();
scrollArea->setWidgetResizable(fitToWindow);
if(!fitToWindow) {
normalSize();
}
updateActions();
}
void ImageViewer::about() {
QMessageBox::about(this, tr("About Image Viewer"),
tr("<p>The <b>Image Viewer</b> example shows how to combine QLabel "
"and QScrollArea to display an image. QLabel is typically used "
"for displaying a text, but it can also display an image. "
"QScrollArea provides a scrolling view around another widget. "
"If the child widget exceeds the size of the frame, QScrollArea "
"automatically provides scroll bars. </p><p>The example "
"demonstrates how QLabel's ability to scale its contents "
"(QLabel::scaledContents), and QScrollArea's ability to "
"automatically resize its contents "
"(QScrollArea::widgetResizable), can be used to implement "
"zooming and scaling features. </p><p>In addition the example "
"shows how to use QPainter to print an image.</p>"));
}
void ImageViewer::createActions() {
openAct = new QAction(tr("&Open..."), this);
openAct->setShortcut(tr("Ctrl+O"));
connect(openAct, SIGNAL(triggered()), this, SLOT(open()));
printAct = new QAction(tr("&Print..."), this);
printAct->setShortcut(tr("Ctrl+P"));
printAct->setEnabled(false);
connect(printAct, SIGNAL(triggered()), this, SLOT(print()));
exitAct = new QAction(tr("E&xit"), this);
exitAct->setShortcut(tr("Ctrl+Q"));
connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));
zoomInAct = new QAction(tr("Zoom &In (25%)"), this);
zoomInAct->setShortcut(tr("Ctrl++"));
zoomInAct->setEnabled(false);
connect(zoomInAct, SIGNAL(triggered()), this, SLOT(zoomIn()));
zoomOutAct = new QAction(tr("Zoom &Out (25%)"), this);
zoomOutAct->setShortcut(tr("Ctrl+-"));
zoomOutAct->setEnabled(false);
connect(zoomOutAct, SIGNAL(triggered()), this, SLOT(zoomOut()));
normalSizeAct = new QAction(tr("&Normal Size"), this);
normalSizeAct->setShortcut(tr("Ctrl+S"));
normalSizeAct->setEnabled(false);
connect(normalSizeAct, SIGNAL(triggered()), this, SLOT(normalSize()));
fitToWindowAct = new QAction(tr("&Fit to Window"), this);
fitToWindowAct->setEnabled(false);
fitToWindowAct->setCheckable(true);
fitToWindowAct->setShortcut(tr("Ctrl+F"));
connect(fitToWindowAct, SIGNAL(triggered()), this, SLOT(fitToWindow()));
aboutAct = new QAction(tr("&About"), this);
connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
aboutQtAct = new QAction(tr("About &Qt"), this);
connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
}
void ImageViewer::createMenus() {
fileMenu = new QMenu(tr("&File"), this);
fileMenu->addAction(openAct);
fileMenu->addAction(printAct);
fileMenu->addSeparator();
fileMenu->addAction(exitAct);
viewMenu = new QMenu(tr("&View"), this);
viewMenu->addAction(zoomInAct);
viewMenu->addAction(zoomOutAct);
viewMenu->addAction(normalSizeAct);
viewMenu->addSeparator();
viewMenu->addAction(fitToWindowAct);
helpMenu = new QMenu(tr("&Help"), this);
helpMenu->addAction(aboutAct);
helpMenu->addAction(aboutQtAct);
menuBar()->addMenu(fileMenu);
menuBar()->addMenu(viewMenu);
menuBar()->addMenu(helpMenu);
}
void ImageViewer::updateActions() {
zoomInAct->setEnabled(!fitToWindowAct->isChecked());
zoomOutAct->setEnabled(!fitToWindowAct->isChecked());
normalSizeAct->setEnabled(!fitToWindowAct->isChecked());
}
void ImageViewer::scaleImage(double factor) {
Q_ASSERT(imageLabel->pixmap());
scaleFactor *= factor;
imageLabel->resize(scaleFactor * imageLabel->pixmap()->size());
adjustScrollBar(scrollArea->horizontalScrollBar(), factor);
adjustScrollBar(scrollArea->verticalScrollBar(), factor);
zoomInAct->setEnabled(scaleFactor < 3.0);
zoomOutAct->setEnabled(scaleFactor > 0.333);
}
void ImageViewer::adjustScrollBar(QScrollBar* scrollBar, double factor) {
scrollBar->setValue(int(factor * scrollBar->value() + ((factor - 1) * scrollBar->pageStep()/2)));
}
Reference in New Issue View Git Blame Copy Permalink