GK/QT/alpha-blending/mywindow.cpp
2023-05-14 10:14:50 +02:00

311 lines
9.1 KiB
C++

// Dolaczamy plik naglowkowy naszej klasy MyWindow
#include "mywindow.h"
// Dolaczamy plik naglowkowy zawierajacy definicje GUI
// Plik ten jest generowany automatycznie
// z pliku XML "mywindow.ui"
#include "ui_mywindow.h"
#include <cmath>
#include <QColor>
#include <QDebug>
#include <QColorDialog>
#include <iostream>
#include <float.h> // for float,double macros
#include <string.h>
#include <stack>
#include <vector>
#define PI 3.1415
std::vector<float> matrixMul(std::vector<float> p, std::vector<float> m)
{
std::vector<float> res(3);
for(int i = 0; i < 3; i++)
{
res.push_back(0);
for(int j = 0; j < 3; j++)
{
res[i] += m[i * 3 + j] * p[j];
}
}
return res;
}
std::vector<float> matrixMul3x3(std::vector<float> m1, std::vector<float> m2)
{
std::vector<float> res(9, 0);
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 3; j++)
{
for(int k = 0; k < 3; k++)
{
res[i * 3 + j] += m1[i * 3 + k] * m2[k * 3 + j];
}
}
}
return res;
}
QColor mul(float v, QColor c){
int red = (int)(c.red() * v);
if(red > 255) red = 255;
int green = (int)(c.green() * v);
if(green > 255) green = 255;
int blue = (int)(c.blue() * v);
if(blue > 255) blue = 255;
int alpha = (int)(c.alpha() * v);
if(alpha > 255) alpha = 255;
return QColor(red, green, blue, alpha);
}
QColor add(QColor c1, QColor c2){
int red = (int)(c1.red() + c2.red());
if(red > 255) red = 255;
int green = (int)(c1.green() + c2.green());
if(green > 255) green = 255;
int blue = (int)(c1.blue() + c2.blue());
if(blue > 255) blue = 255;
int alpha = (int)(c1.alpha() + c2.alpha());
if(alpha > 255) alpha = 255;
return QColor(red, green, blue, alpha);
}
// Definicja konstruktora, wywolujemy najpierw
// konstruktor klasy nadrzednej, nastepnie tworzymy
// obiekt klasy Ui_MyWindow reprezentujacy GUI
MyWindow::MyWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MyWindow)
{
// Wywolujemy funkcje tworzaca elementy GUI
// Jej definicja znajduje sie w pliku "ui_mywindow.h"
ui->setupUi(this);
// Pobieramy wymiary i wspolrzedne lewego gornego naroznika ramki
// i ustawiamy wartosci odpowiednich pol
// Uwaga: ramke "rysujFrame" wykorzystujemy tylko do
// wygodnego ustaiwenia tych wymiarow. Rysunek bedziemy wyswietlac
// bezposrednio w glownym oknie aplikacji.
szer = ui->rysujFrame->width();
wys = ui->rysujFrame->height();
poczX = ui->rysujFrame->x();
poczY = ui->rysujFrame->y();
// Tworzymy obiekt klasy QImage, o odpowiedniej szerokosci
// i wysokosci. Ustawiamy format bitmapy na 32 bitowe RGB
// (0xffRRGGBB).
img = new QImage(szer,wys,QImage::Format_RGB32);
// loaded_img1 = new QImage("/Users/dawidpietrykowski/Desktop/projects/umk/GK/QT/alpha-blending/p.png");
// loaded_img2 = new QImage("/Users/dawidpietrykowski/Desktop/projects/umk/GK/QT/alpha-blending/f.png");
loaded_img1 = new QImage("/Users/dawidpietrykowski/Desktop/projects/umk/GK/QT/alpha-blending/l0.png");
loaded_img2 = new QImage("/Users/dawidpietrykowski/Desktop/projects/umk/GK/QT/alpha-blending/l1.png");
rotation_angle = 0;
alpha = 0;
UpdateImage();
}
// Definicja destruktora
MyWindow::~MyWindow()
{
delete ui;
}
// Funkcja (slot) wywolywana po nacisnieciu przycisku "Wyjscie" (exitButton)
// Uwaga: polaczenie tej funkcji z sygnalem "clicked"
// emitowanym przez przycisk jest realizowane
// za pomoca funkcji QMetaObject::connectSlotsByName(MyWindow)
// znajdujacej sie w automatycznie generowanym pliku "ui_mywindow.h"
// Nie musimy wiec sami wywolywac funkcji "connect"
void MyWindow::on_exitButton_clicked()
{
// qApp to globalny wskaznik do obiektu reprezentujacego aplikacje
// quit() to funkcja (slot) powodujaca zakonczenie aplikacji z kodem 0 (brak bledu)
qApp->quit();
}
void MyWindow::on_slider_mode_valueChanged(int val){
mode = val;
}
void MyWindow::on_slider_a_valueChanged(int val){
alpha = (float) val / 100.0f;
}
QColor Normal(QColor c1, QColor c2){
return c2;
}
QColor Multiply(QColor c1, QColor c2){
return QColor(
(c1.red() * c2.red()) >> 8,
(c1.green() * c2.green()) >> 8,
(c1.blue() * c2.blue()) >> 8,
(c1.alpha() * c2.alpha()) >> 8);
}
QColor Screen(QColor c1, QColor c2){
return QColor(
255 - (((255 - c1.red()) * (255 - c2.red())) >> 8),
255 - (((255 - c1.green()) * (255 - c2.green())) >> 8),
255 - (((255 - c1.blue()) * (255 - c2.blue())) >> 8),
255 - (((255 - c1.alpha()) * (255 - c2.alpha())) >> 8));
}
QColor Overlay(QColor c1, QColor c2){
int r = c1.red() < 128 ? (c1.red() * c2.red()) >> 7 : 255 - (((255 - c1.red()) * (255 - c2.red())) >> 7);
int g = c1.green() < 128 ? (c1.green() * c2.green()) >> 7 : 255 - (((255 - c1.green()) * (255 - c2.green())) >> 7);
int b = c1.blue() < 128 ? (c1.blue() * c2.blue()) >> 7 : 255 - (((255 - c1.blue()) * (255 - c2.blue())) >> 7);
int a = c1.alpha() < 128 ? (c1.alpha() * c2.alpha()) >> 7 : 255 - (((255 - c1.alpha()) * (255 - c2.alpha())) >> 7);
return QColor(r, g, b, a);
}
QColor Darken(QColor c1, QColor c2){
int r = c1.red() < c2.red() ? c1.red() : c2.red();
int g = c1.green() < c2.green() ? c1.green() : c2.green();
int b = c1.blue() < c2.blue() ? c1.blue() : c2.blue();
int a = c1.alpha() < c2.alpha() ? c1.alpha() : c2.alpha();
return QColor(r, g, b, a);
}
QColor Lighten(QColor c1, QColor c2){
int r = c1.red() > c2.red() ? c1.red() : c2.red();
int g = c1.green() > c2.green() ? c1.green() : c2.green();
int b = c1.blue() > c2.blue() ? c1.blue() : c2.blue();
int a = c1.alpha() > c2.alpha() ? c1.alpha() : c2.alpha();
return QColor(r, g, b, a);
}
QColor Blend(QColor c1, QColor c2, float a, int p){
switch (p) {
case 0:
return add(mul(a, Normal(c1, c2)), mul((1.0f - a), c1));
break;
case 1:
return add(mul(a, Multiply(c1, c2)), mul((1.0f - a), c1));
break;
case 2:
return add(mul(a, Screen(c1, c2)), mul((1.0f - a), c1));
break;
case 3:
return add(mul(a, Overlay(c1, c2)), mul((1.0f - a), c1));
break;
case 4:
return add(mul(a, Darken(c1, c2)), mul((1.0f - a), c1));
break;
case 5:
return add(mul(a, Lighten(c1, c2)), mul((1.0f - a), c1));
break;
default:
break;
}
}
void MyWindow::UpdateImage(){
for(int x = 0; x < szer; x++)
for(int y = 0; y < wys; y++){
float xw = (float) x / (float)szer;
float yh = (float) y / (float) wys;
DrawPixel(img, x, y,
Blend(GetInterpolatedColor(loaded_img1, xw, yh),
GetInterpolatedColor(loaded_img2, xw, yh), alpha, mode));
}
update();
}
QColor MyWindow::GetPixel(QImage* img, int x, int y){
QColor res;
int width = img->width();
int height = img->height();
if(x >= width || y >= height || x < 0 || y < 0)
return res;
unsigned char* ptr = img->bits();
res.setBlue(ptr[width*4*y + 4*x]);
res.setGreen(ptr[width*4*y + 4*x + 1]);
res.setRed(ptr[width*4*y + 4*x + 2]);
res.setAlpha(ptr[width*4*y + 4*x + 3]);
return res;
}
QColor MyWindow::GetInterpolatedColor(QImage* img, float x, float y){
float width = img->width();
float height = img->height();
float xw = (x * width);
float yw = (y * height);
int x_f = (int) (x * width);
int y_f = (int) (y * height);
int x_c = ceil(x * width);
int y_c = ceil(y * height);
float a = (xw - (float) x_f);
float b = ((yw) - (float) y_f);
QColor P1 = GetPixel(img, x_f, y_c);
QColor P2 = GetPixel(img, x_c, y_c);
QColor P3 = GetPixel(img, x_c, y_f);
QColor P4 = GetPixel(img, x_f, y_f);
QColor v1 = mul(1.0f - a, P1);
QColor v2 = mul(a, P2);
QColor v3 = mul(a, P3);
QColor v4 = mul(1.0f - a, P4);
QColor top = add(v1, v2);
QColor bottom = add(v3, v4);
QColor btop = mul(b, top);
QColor bbottom = mul(1.0f - b, bottom);
QColor res = add(btop, bbottom);
return res;
}
// Funkcja "odmalowujaca" komponent
void MyWindow::paintEvent(QPaintEvent*)
{
// Obiekt klasy QPainter pozwala nam rysowac na komponentach
QPainter p(this);
UpdateImage();
// Rysuje obrazek "img" w punkcie (poczX,poczY)
// (tu bedzie lewy gorny naroznik)
p.drawImage(poczX,poczY,*img);
}
void MyWindow::DrawPixel(QImage* img, int x, int y, QColor color){
if(x >= szer || y >= wys || x < 0 || y < 0)
return;
unsigned char* ptr = img->bits();
ptr[szer*4*y + 4*x] = color.blue();
ptr[szer*4*y + 4*x + 1] = color.green();
ptr[szer*4*y + 4*x + 2] = color.red();
ptr[szer*4*y + 4*x + 3] = color.alpha();
}
void MyWindow::ClearImage(QImage *img){
unsigned char* empty_val = (unsigned char*)malloc(4);
empty_val[0] = 0;
empty_val[1] = 0;
empty_val[2] = 0;
empty_val[3] = 255;
unsigned char* ptr = img->bits();
for(int i = 0; i < img->width(); i++){
for(int j = 0; j < img->height(); j++){
memcpy(ptr + 4 * (i + j * img->width()), empty_val, 4);
}
}
}