236 lines
6.2 KiB
C++
236 lines
6.2 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>
|
|
|
|
#define PI 3.1415
|
|
|
|
|
|
|
|
// 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);
|
|
}
|
|
|
|
// 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_r_valueChanged(int val){
|
|
DrawR(val);
|
|
}
|
|
|
|
void MyWindow::on_slider_g_valueChanged(int val){
|
|
DrawG(val);
|
|
}
|
|
|
|
void MyWindow::on_slider_b_valueChanged(int val){
|
|
DrawB(val);
|
|
}
|
|
|
|
|
|
void MyWindow::on_slider_h_valueChanged(int val){
|
|
DrawH(val/100.0f);
|
|
}
|
|
|
|
void MyWindow::on_slider_s_valueChanged(int val){
|
|
DrawS(val/100.0f);
|
|
}
|
|
|
|
void MyWindow::on_slider_v_valueChanged(int val){
|
|
DrawV(val/100.0f);
|
|
}
|
|
|
|
// Funkcja "odmalowujaca" komponent
|
|
void MyWindow::paintEvent(QPaintEvent*)
|
|
{
|
|
// Obiekt klasy QPainter pozwala nam rysowac na komponentach
|
|
QPainter p(this);
|
|
|
|
// Rysuje obrazek "img" w punkcie (poczX,poczY)
|
|
// (tu bedzie lewy gorny naroznik)
|
|
p.drawImage(poczX,poczY,*img);
|
|
}
|
|
|
|
|
|
QColor HSVtoRGB(float H, float S, float V){
|
|
float C = V * S;
|
|
float HP = (H * 360)/60.0f;
|
|
float X = C*(1.0f - abs( fmod(HP, 2.0f)-1.0f));
|
|
float M = V - C;
|
|
float red = 0, green = 0, blue = 0;
|
|
if(HP >=0 && HP <=1){
|
|
red=C;
|
|
green=X;
|
|
}else if(HP >1 && HP <=2){
|
|
red=X;
|
|
green=C;
|
|
}else if(HP >2 && HP <=3){
|
|
green=C;
|
|
blue=X;
|
|
}else if(HP >3 && HP <=4){
|
|
green=X;
|
|
blue=C;
|
|
}else if(HP >4 && HP <=5){
|
|
red=X;
|
|
blue=C;
|
|
}else if(HP >5 && HP <=6){
|
|
red=C;
|
|
blue=X;
|
|
}
|
|
red+=M;
|
|
green+=M;
|
|
blue+=M;
|
|
|
|
return QColor((int)(red*255.0f), (int)(green*255.0f), (int)(blue*255.0f));
|
|
}
|
|
|
|
|
|
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::DrawR(int r){
|
|
unsigned char* ptr = img->bits();
|
|
for(int i = 0; i < img->width(); i++){
|
|
for(int j = 0; j < img->height(); j++){
|
|
int b = ((float) i / img->width()) * 255.0f;
|
|
int g = ((float) j / img->height()) * 255.0f;
|
|
DrawPixel(img, i, j, QColor(r, g, b));
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
void MyWindow::DrawG(int g){
|
|
unsigned char* ptr = img->bits();
|
|
for(int i = 0; i < img->width(); i++){
|
|
for(int j = 0; j < img->height(); j++){
|
|
int b = ((float) i / img->width()) * 255.0f;
|
|
int r = ((float) j / img->height()) * 255.0f;
|
|
DrawPixel(img, i, j, QColor(r, g, b));
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
void MyWindow::DrawB(int b){
|
|
unsigned char* ptr = img->bits();
|
|
for(int i = 0; i < img->width(); i++){
|
|
for(int j = 0; j < img->height(); j++){
|
|
int g = ((float) i / img->width()) * 255.0f;
|
|
int r = ((float) j / img->height()) * 255.0f;
|
|
DrawPixel(img, i, j, QColor(r, g, b));
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
|
|
void MyWindow::DrawH(float h){
|
|
unsigned char* ptr = img->bits();
|
|
for(int i = 0; i < img->width(); i++){
|
|
for(int j = 0; j < img->height(); j++){
|
|
float s = ((float) i / img->width());
|
|
float v = ((float) j / img->height());
|
|
DrawPixel(img, i, j, HSVtoRGB(h, s, v));
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
void MyWindow::DrawS(float s){
|
|
unsigned char* ptr = img->bits();
|
|
for(int i = 0; i < img->width(); i++){
|
|
for(int j = 0; j < img->height(); j++){
|
|
float h = ((float) i / img->width());
|
|
float v = ((float) j / img->height());
|
|
DrawPixel(img, i, j, HSVtoRGB(h, s, v));
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
void MyWindow::DrawV(float v){
|
|
unsigned char* ptr = img->bits();
|
|
for(int i = 0; i < img->width(); i++){
|
|
for(int j = 0; j < img->height(); j++){
|
|
float h = ((float) i / img->width());
|
|
float s = ((float) j / img->height());
|
|
DrawPixel(img, i, j, HSVtoRGB(h, s, v));
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|