bool task1(const cv::Mat& image) {
cv::Mat manual, buildIn, diff, tmp;
std::vector<cv::Mat> channels;
scaleImage(image, manual, 2, 100);
image.convertTo(buildIn, -1, 2, 100);
cv::absdiff(manual, buildIn, diff);
cv::split(diff, channels);
std::cout << "Max difference element: ";
for (VMit it = channels.begin(); it != channels.end(); ++it) {
int max = *(std::max_element((*it).begin<uchar>(), (*it).end<uchar>()));
std::cout << max << " ";
}
std::cout << std::endl;
std::vector<cv::Mat> scales(5, cv::Mat());
std::vector<cv::Mat> dst(2, cv::Mat());
for (int i = 0; i < task1c; ++i) {
scaleImage(image, scales[i], task1v[2 * i], task1v[2 * i + 1]);
}
concatImages(scales[0], scales[1], dst[0]);
concatChannels(dst[0], dst[0]);
concatImages(scales[2], scales[3], dst[1]);
concatImages(dst[1], scales[4], dst[1]);
concatChannels(dst[1], dst[1]);
return cv::imwrite(PATH + "Task1Lena01.jpg", dst[0]) && cv::imwrite(PATH + "Task1Lena345.jpg", dst[1]);
}
void ImageWidget::updateImage(bool zoom, const QImage &image, bool valuesPresent[], int values[])
{
if(zoom) {
QImage imageNew = scaleImage(image);
if(imageNew.isNull()) return;
#ifndef QT_NO_CONCURRENT
QFuture<QImage> future = QtConcurrent::run(this, &ImageWidget::scaleImage, image);
imageNew = future.result();
#else
QImage imageNew = scaleImage(image);
#endif
pixmap = QPixmap::fromImage(imageNew);
} else {
pixmap = QPixmap::fromImage(image);
}
for(int i=0; i<4; i++) {
drawValues[i] = valuesPresent[i];
if(drawValues[i]) geoValues[i] = values[i];
else geoValues[i] = 0;
}
update();
}
void main(int argc, char *argv[])
{
char header[512];
unsigned char img[640*480*3], newimg[640*480*3];
int bufflen, hdrlen; unsigned row=0, col=0, chan=0, pix; int i, j, k;
double alpha=1.25; unsigned char beta=25;
if(argc < 2)
{
printf("Use: brighten inputfile\n");
exit(-1);
}
// TEST CASE #0
//
// Basic PPM file read, scaling and bias test, and write-back
//
header[0]='\0';
readppm(img, &bufflen, header, &hdrlen, &row, &col, &chan, argv[1]);
alpha=1.25, beta =25;
scaleImage(img, newimg, row, col, chan, alpha, beta);
writeppm(newimg, bufflen, header, hdrlen, "brighter-1.25-25.ppm");
alpha=1.5, beta =50;
scaleImage(img, newimg, row, col, chan, alpha, beta);
writeppm(newimg, bufflen, header, hdrlen, "brighter-1.5-50.ppm");
//
// END TEST CASE #0
}
void MainWindow::fitToWindow()
{
bool fitToWindow = ui->actionFitToWindow->isChecked();
ui->scrollArea->setWidgetResizable(fitToWindow);
ui->scrollArea->setWidgetResizable(false);
if (!fitToWindow) {
normalSize();
}
else
{
double ssh=sh*scaleFactor;
double ssw=sh*scaleFactor;
double sch=ui->scrollArea->height();
double scw=ui->scrollArea->width();
double mh=sch/ssh;
double mw=scw/ssw;
if (mh<mw)
{
scaleImage(mh);
}
else
{
scaleImage(mw);
}
}
updateActions();
}
void LocMicView::wheelEvent(QWheelEvent* event)
{
//std::cerr << "wheelEvent " << event->delta() << std::endl;
if(event->delta() < 0) {
scaleImage(1.0 / scaleStepFactor);
} else {
scaleImage(scaleStepFactor);
}
//QScrollArea::wheelEvent(event);
}
void ProtoWindow::zoomIn()
{
scaleImage(1.25);
this->imageLabel->update();
updateUI();
}
void ProtoWindow::zoomOut()
{
scaleImage(0.8);
this->imageLabel->update();
updateUI();
}
void ProtoWindow::normalSize()
{
scaleImage(fittingSize("normalSize"));
this->imageLabel->update();
updateUI();
}
bool CameraVideoSurface::present (const QVideoFrame &frame)
{
m_frame = frame;
if (surfaceFormat().pixelFormat() != m_frame.pixelFormat() ||
surfaceFormat().frameSize() != m_frame.size()) {
stop();
return false;
} else {
m_frame.map(QAbstractVideoBuffer::ReadOnly);
frWidth = m_frame.width();
frHeight = m_frame.height();
int line = m_frame.bytesPerLine();
// build QImage from frame
m_completeImage = QImage(
m_frame.bits(),
frWidth, frHeight,
line,
m_frame.imageFormatFromPixelFormat(m_frame.pixelFormat()));
m_frame.unmap();
QImage dstImage = scaleImage(m_completeImage);
m_frame = QVideoFrame(dstImage);
// enlarge faces
m_target->updateVideo();
return true;
}
}
/*
* Aktionen, die ausgeführt werden müssen, wenn der 'zurück'-Knopf gedrückt wurde.
*/
void ProtoWindow::on_backPushButton_clicked()
{
// Daten des "alten" Bildes müssen gespeichert werden.
save();
/*
* Textdatei erstellen, falls nicht vorhanden.
*
* Daten in Textdatei schreiben. Dabei werden die alten Daten für dieses Bild überschrieben.
* Die Daten werden in der folgenden Reihenfolge gespeichert:
* "&"Dateiname(mit Endung)$bildbeschreibung"$"x-Koordinate"%"y-Koordinate"%"Text"$"nächstes Quadrat..."&"
*
* Bis auf Weiteres wird der gesamte Inhalt der Datei neu gespeichert.
*/
// current-Counter eins runterzaehlen, damit das naechste Bild angezeigt wird
if (this->currentIndex-1 < 0) {
this->currentIndex = this->dirVec.size()-1;
} else {
this->currentIndex = (this->currentIndex-1) % (this->dirVec.size());
}
QString fileName = this->dirVec[currentIndex];
showNextImage((this->curDir.absoluteFilePath(fileName)));
scaleImage(fittingSize("on_backPushButton_clicked"));
updateUI();
}
bool RenderThemeSymbian::paintRadio(RenderObject* o, const RenderObject::PaintInfo& i, const IntRect& r)
{
if (!m_radioButtonOn) {
m_radioButtonOn = Image::loadPlatformResource("radioButtonOn");
m_radioButtonOff = Image::loadPlatformResource("radioButtonOff");
}
paintButtonDecorations(o, i, r);
MScrollView* wv = scrollView(i);
// don't scale the checkbox if scalingFactor is 100% or we are in the process of scaling another image
if (wv->scalingFactor() <= 100 || m_bitmapScaler) {
i.context->drawImage(isChecked(o)?m_radioButtonOn:m_radioButtonOff,r);
}
// use the cached scaled image if it has the same scaling factor
else if (wv->scalingFactor() == (isChecked(o) ? m_scalingForRadioOn : m_scalingForRadioOff)) {
i.context->drawImage(isChecked(o) ? m_scaledRadioOn : m_scaledRadioOff, r);
}
// scale
else {
scaleImage(isChecked(o) ? ERadioOn : ERadioOff, wv->scalingFactor());
if (wv->scalingFactor() == (isChecked(o) ? m_scalingForRadioOn : m_scalingForRadioOff)) {
i.context->drawImage(isChecked(o) ? m_scaledRadioOn : m_scaledRadioOff, r);
}
else {
i.context->drawImage(isChecked(o)?m_radioButtonOn:m_radioButtonOff,r);
}
}
return false;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
default_scale = 1;
current_scale = 1;
image.load(":/aliceA.png");
scaled = image;
files_names = QStringList();
pImage_lbl = new QLabel();
pImage_lbl->setAlignment(Qt::AlignCenter);
ui->imageArea->setWidget(pImage_lbl);
ui->imageArea->setBackgroundRole(QPalette::NoRole);
loadListOfFiles();
setAcceptDrops(true);
connect(&interpret, SIGNAL(ready(QImage)), this, SLOT(updateImage(QImage)));
connect(ui->gammaSlider, SIGNAL(sliderReleased()), this, SLOT(refreshGamma()));
connect(ui->zoomSlider, SIGNAL(sliderReleased()), this, SLOT(scaleImage()));
connect(ui->filesList, SIGNAL(itemSelectionChanged()), this, SLOT(restoreDefaultScale()));
connect(ui->filesList, SIGNAL(currentTextChanged(QString)), this, SLOT(updateImage(QString)));
updateImage("aliceA.png");
}
void ScrollRedDotLabel::zoomOut()
{
if(ZoomOutBool)
{
scaleImage(0.8);
}
}
void ScrollRedDotLabel::zoomIn()
{
if(ZoomInBool)
{
scaleImage(1.25);
}
}
void MainWindowView::backSelected()
{
QString newFile = m_parent->copyFile(m_ui->backKurl);
m_ui->backKurl->setText(m_ui->backKurl->url().fileName());
QPixmap image(newFile);
m_ui->pixLabel->setPixmap(scaleImage(image, 100));
emit changed();
}
const QPixmap & CImgButton::image( const QString & name, qint64 & cacheKey ) const
{
if ( m_picsSz.contains( cacheKey ) )
return *m_picsSz[ cacheKey ];
const QPixmap & pm = scaleImage( name );
cacheKey = pm.cacheKey();
return pm;
}
void SmartScrollArea::fitToWindow(bool checked) {
fittingwin=checked;
if (checked)
scaleLabelToFit();
else
// restore to the previous zoom factor
scaleImage(1);
}
void ImageWidget::zoomIn()
{
if(m_scaleFactor > 3)
{
return;
}
scaleImage(1.25);
}
void ProtoWindow::actualSize()
{
this->scaleFactor = 1.0;
scaleImage(1.0);
this->imageLabel->update();
updateUI();
}
void PreviewWidget::wheelEvent(QWheelEvent *event){
if (!preViewer->pixmap()) return;
if(event->modifiers()==Qt::ControlModifier){
float numDegrees = event->delta() / 8.0f;
float numSteps = numDegrees / 15.0f;
scaleImage(pow(1.4,numSteps));
event->accept();
} else QScrollArea::wheelEvent(event);
}
void MainWindow::zoomOut()
{
if( ui->actionFitToWindow->isChecked() == true)
{
ui->actionFitToWindow->setChecked(false);
//fitToWindow();
}
scaleImage(0.95);
}
static QImage prepareSurface(QImage img, int w, int h)
{
img = scaleImage(img, w, h);
// slightly larger, to accomodate for the reflection
int hs = h * 2;
int hofs = h / 3;
// offscreen buffer: black is sweet
QImage result(hs, w, QImage::Format_RGB32);
result.fill(0);
// transpose the image, this is to speed-up the rendering
// because we process one column at a time
// (and much better and faster to work row-wise, i.e in one scanline)
for(int x = 0; x < w; x++)
for(int y = 0; y < h; y++)
result.setPixel(hofs + y, x, img.pixel(x, y));
// create the reflection
int ht = hs - h - hofs;
int hte = ht;
for(int x = 0; x < w; x++)
for(int y = 0; y < ht; y++)
{
QRgb color = img.pixel(x, img.height()-y-1);
int a = qAlpha(color);
int r = qRed(color) * a / 256 * (hte - y) / hte * 3/5;
int g = qGreen(color) * a / 256 * (hte - y) / hte * 3/5;
int b = qBlue(color) * a / 256 * (hte - y) / hte * 3/5;
result.setPixel(h+hofs+y, x, qRgb(r, g, b));
}
#ifdef PICTUREFLOW_BILINEAR_FILTER
int hh = BILINEAR_STRETCH_VER*hs;
int ww = BILINEAR_STRETCH_HOR*w;
result = scaleImage(result, hh, ww);
#endif
return result;
}
void MainWindowView::fileSelected()
{
QString newFile = m_parent->copyFile(m_ui->fileKurl);
m_ui->fileKurl->setText(m_ui->fileKurl->url().fileName());
QPixmap image(newFile);
m_ui->itemLabel->setPixmap(scaleImage(image, 100));
Q_ASSERT(m_ui->treeView->selectionModel()->hasSelection());
QModelIndex idx = m_ui->treeView->selectionModel()->selectedIndexes().first();
QStandardItem* selectedItem = m_model->itemFromIndex(idx);
selectedItem->setData(m_ui->fileKurl->text(),ThemeModel::PathRole);
selectedItem->setText(m_ui->fileKurl->text());
}
void MainWindow::fitToWindow() {
if (!imageLabel->pixmap()) {
return;
}
double factor = qMin(
ui->scrollArea->width()/((double)inputImage->width()),
ui->scrollArea->height()/((double)inputImage->height()));
if (factor > 1) {
factor = 1;
}
scaleImage(factor);
}
void rescalethread::run()
{
//this is the routine that will run when the thread is triggered by start() method in the parent
for(int index=0;index<imageFilesList.count();index++)
{
//call the method to scale image, pass the current filename from the list
scaleImage(QDir::toNativeSeparators(imageFilesList.at(index)), index);
}
//re-implemented finished signal emited when all the image resizing was done succesfully
emit finished();
}
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: loadImage(); break;
case 1: scaleImage(); break;
default: ;
}
_id -= 2;
}
return _id;
}
void ClassifiedViewer::setTestImage(QString imageFile)
{
m_image = QImage(imageFile);
// convert image to grayscale
m_grayscaleImage = QImage(m_image.width(), m_image.height(), m_image.format());
for (int h=0; h<m_image.height(); h++){
for (int w=0; w<m_image.width(); w++){
m_grayscaleImage.setPixel(w, h, toGray(m_image.pixel(w, h)));
}
}
scaleImage();
drawScene();
}
void MainWindowView::setUi(PairsThemeEditor *theme)
{
m_pt = theme;
m_path = m_pt->path();
m_ui->titleEdit->setText(theme->title());
m_ui->authorEdit->setText(theme->author());
m_ui->versionEdit->setText(theme->version());
m_ui->dateEdit->setDate(QDate::fromString(theme->date(),"d/M/yyyy"));
m_ui->maintypeBox->setCurrentIndex(theme->mainType()-1);
m_ui->descriptionEdit->setText(theme->description());
m_ui->backKurl->setText(theme->backImage());
QPixmap image(m_path +'/'+theme->backImage());
m_ui->pixLabel->setPixmap(scaleImage(image, 100));
m_ui->fileKurl->setStartDir(KUrl(theme->path()));
m_ui->backKurl->setStartDir(KUrl(theme->path()));
}
void CvWidget::updateImage(const cv::Mat &image)
{
m_mutex.lock();
m_invalid = image.empty();
if(m_invalid) {
m_image = cv::Mat();
update();
m_mutex.unlock();
return;
}
cv::cvtColor(image, m_image, CV_BGR2RGB);
scaleImage();
update();
m_mutex.unlock();
}
void ImageWin::wheelEvent(QWheelEvent *event)
{
QLabel::wheelEvent(event);
for (EventVec::const_iterator it = _eventvec.begin(); it != _eventvec.end(); it++)
{
if ((*it)->procWheel(this, event))
return;
}
QPoint cursor_pos = QCursor::pos();
QPoint local_original_pos = this->mapFromGlobal(cursor_pos);
int delta = event->delta();
double _delta = 1.0 + delta/1000.0;
scaleImage(_delta);
}
