creyD/intelliphoto
1
0
Fork 0
mirror of https://github.com/creyD/intelliphoto.git synced 2026-04-12 19:40:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' into dev_PolygonTool

Browse Source
This commit is contained in:
Conrad
2019-12-19 11:31:34 +01:00
parent 89b9e44677 3eff7d73eb
commit d52dd552f3
12 changed files with 179 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/GUI/IntelliPhotoGui.cpp
View File

@@ -17,7 +17,6 @@ IntelliPhotoGui::IntelliPhotoGui(){
createMenus();
//set style of the gui
setIntelliStyle();
// Size the app
resize(600,600);
showMaximized();
@@ -31,7 +30,6 @@ void IntelliPhotoGui::closeEvent(QCloseEvent *event){
if (maybeSave()) {
event->accept();
} else {
// If there have been changes ignore the event
event->ignore();
}
@@ -48,7 +46,7 @@ void IntelliPhotoGui::slotOpen(){
// tr sets the window title to Open File
// QDir opens the current dirctory
QString fileName = QFileDialog::getOpenFileName(this,
tr("Open File"), QDir::currentPath());
tr("Open File"), QDir::currentPath(), nullptr, nullptr, QFileDialog::DontUseNativeDialog);
// If we have a file name load the image and place
// it in the paintingArea
@@ -229,7 +227,7 @@ void IntelliPhotoGui::slotCreateLineTool(){
void IntelliPhotoGui::slotAboutDialog(){
// Window title and text to display
QMessageBox::about(this, tr("About Painting"),
tr("<p><b>IntelliPhoto</b> Some nice ass looking software</p>"));
tr("<p><b>IntelliPhoto</b>Pretty basic editor.</p>"));
}
// Define menu actions that call functions
@@ -271,6 +269,7 @@ void IntelliPhotoGui::createActions(){
// Create New Layer action and tie to IntelliPhotoGui::newLayer()
actionCreateNewLayer = new QAction(tr("&New Layer..."), this);
actionCreateNewLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N));
connect(actionCreateNewLayer, SIGNAL(triggered()), this, SLOT(slotCreateNewLayer()));
// Delete New Layer action and tie to IntelliPhotoGui::deleteLayer()
@@ -457,7 +456,7 @@ bool IntelliPhotoGui::saveFile(const QByteArray &fileFormat){
initialPath,
tr("%1 Files (*.%2);;All Files (*)")
.arg(QString::fromLatin1(fileFormat.toUpper()))
.arg(QString::fromLatin1(fileFormat)));
.arg(QString::fromLatin1(fileFormat)), nullptr, QFileDialog::DontUseNativeDialog);
// If no file do nothing
if (fileName.isEmpty()) {

23
src/Image/IntelliShapedImage.cpp
View File

@@ -35,26 +35,18 @@ void IntelliShapedImage::calculateVisiblity(){
}
return;
}
QPoint A = polygonData[0];
QColor clr;
for(int y=0; y<imageData.height(); y++){
for(int x=0; x<imageData.width(); x++){
int cutNumeber=0;
for(int i=1; i<static_cast<int>(polygonData.size()-1); i++){
QPoint B = polygonData[static_cast<size_t>(i)];
QPoint C = polygonData[static_cast<size_t>(i+1)];
QPoint P(x,y);
cutNumeber+=IntelliHelper::isInTriangle(A,B,C,P);
}
if(cutNumeber%2==0){
clr = imageData.pixelColor(x,y);
clr.setAlpha(0);
imageData.setPixelColor(x,y,clr);
}else{
clr = imageData.pixelColor(x,y);
QPoint ptr(x,y);
clr = imageData.pixelColor(x,y);
bool isInPolygon = IntelliHelper::isInPolygon(triangles, ptr);
if(isInPolygon){
clr.setAlpha(std::min(255, clr.alpha()));
imageData.setPixelColor(x,y,clr);
}else{
clr.setAlpha(0);
}
imageData.setPixelColor(x,y,clr);
}
}
}
@@ -79,6 +71,7 @@ void IntelliShapedImage::setPolygon(const std::vector<QPoint>& polygonData){
for(auto element:polygonData){
this->polygonData.push_back(QPoint(element.x(), element.y()));
}
triangles = IntelliHelper::calculateTriangles(polygonData);
}
calculateVisiblity();
return;

4
src/Image/IntelliShapedImage.h
View File

@@ -2,9 +2,13 @@
#define INTELLISHAPE_H
#include"Image/IntelliRasterImage.h"
#include<vector>
#include"IntelliHelper/IntelliHelper.h"
class IntelliShapedImage : public IntelliRasterImage{
friend IntelliTool;
private:
std::vector<Triangle> triangles;
protected:
std::vector<QPoint> polygonData;

121
src/IntelliHelper/IntelliHelper.cpp
View File

@@ -1,2 +1,123 @@
#include"IntelliHelper.h"
#include<algorithm>
#include<queue>
#include<cmath>
std::vector<Triangle> IntelliHelper::calculateTriangles(std::vector<QPoint> polyPoints){
//helper for managing the triangle vertices and their state
struct TriangleHelper{
QPoint vertex;
float interiorAngle;
int index;
bool isTip;
};
//calculates the inner angle of 'point'
auto calculateInner = [](QPoint& point, QPoint& prev, QPoint& post){
QPoint AP(point.x()-prev.x(), point.y()-prev.y());
QPoint BP(point.x()-post.x(), point.y()-post.y());
float topSclar = AP.x()*BP.x()+AP.y()*BP.y();
float absolute = sqrt(pow(AP.x(),2.)+pow(AP.y(),2.))*sqrt(pow(BP.x(),2.)+pow(BP.y(),2.));
return acos(topSclar/absolute);
};
//gets the first element of vec for which element.isTip == true holds
auto getTip= [](const std::vector<TriangleHelper>& vec){
for(auto element:vec){
if(element.isTip){
return element;
}
}
return vec[0];
};
//get the vertex Index bevor index in relation to the container length
auto getPrev = [](int index, int length){
return (index-1)>0?(index-1):(length-1);
};
//get the vertex Index after index in relation to the container lenght
auto getPost = [](int index, int length){
return (index+1)%length;
};
//return if the vertex is a tip
auto isTip = [](float angle){
return angle<180.f;
};
std::vector<TriangleHelper> Vertices;
std::vector<Triangle> Triangles;
//set up all vertices and calculate intirior angle
for(int i=0; i<static_cast<int>(polyPoints.size()); i++){
TriangleHelper helper;
int prev = getPrev(i, static_cast<int>(polyPoints.size()));
int post = getPost(i, static_cast<int>(polyPoints.size()));
helper.vertex = polyPoints[static_cast<size_t>(i)];
helper.index = i;
helper.interiorAngle = calculateInner(polyPoints[static_cast<size_t>(i)],
polyPoints[static_cast<size_t>(prev)],
polyPoints[static_cast<size_t>(post)]);
helper.isTip = isTip(helper.interiorAngle);
Vertices.push_back(helper);
}
//search triangles based on the intirior angles of each vertey
while(Triangles.size() != polyPoints.size()-2){
Triangle tri;
TriangleHelper smallest = getTip(Vertices);
int prev = getPrev(smallest.index, static_cast<int>(Vertices.size()));
int post = getPost(smallest.index, static_cast<int>(Vertices.size()));
//set triangle and push it
tri.A = Vertices[static_cast<size_t>(prev)].vertex;
tri.B = Vertices[static_cast<size_t>(smallest.index)].vertex;
tri.C = Vertices[static_cast<size_t>(post)].vertex;
Triangles.push_back(tri);
//update Vertice array
Vertices.erase(Vertices.begin()+smallest.index);
for(size_t i=static_cast<size_t>(smallest.index); i<Vertices.size(); i++){
Vertices[i].index-=1;
}
//update post und prev index
post = post-1;
prev = prev<smallest.index?prev:(prev-1);
//calcultae neighboors of prev and post to calculate new interior angles
int prevOfPrev = getPrev(prev, static_cast<int>(Vertices.size()));
int postOfPrev = getPost(prev, static_cast<int>(Vertices.size()));
int prevOfPost = getPrev(post, static_cast<int>(Vertices.size()));
int postOfPost = getPost(post, static_cast<int>(Vertices.size()));
//update vertices with interior angles
//updtae prev
Vertices[static_cast<size_t>(prev)].interiorAngle = calculateInner(Vertices[static_cast<size_t>(prev)].vertex,
Vertices[static_cast<size_t>(prevOfPrev)].vertex,
Vertices[static_cast<size_t>(postOfPrev)].vertex);
Vertices[static_cast<size_t>(prev)].isTip = isTip(Vertices[static_cast<size_t>(prev)].interiorAngle);
//update post
Vertices[static_cast<size_t>(post)].interiorAngle = calculateInner(Vertices[static_cast<size_t>(post)].vertex,
Vertices[static_cast<size_t>(prevOfPost)].vertex,
Vertices[static_cast<size_t>(postOfPost)].vertex);
Vertices[static_cast<size_t>(post)].isTip = isTip(Vertices[static_cast<size_t>(post)].interiorAngle);
}
return Triangles;
}
bool IntelliHelper::isInPolygon(std::vector<Triangle> &triangles, QPoint &point){
for(auto triangle : triangles){
if(IntelliHelper::isInTriangle(triangle.A ,triangle.B, triangle.C, point)){
return true;
}
}
return false;
}

22
src/IntelliHelper/IntelliHelper.h
View File

@@ -2,17 +2,20 @@
#define INTELLIHELPER_H
#include<QPoint>
#include<vector>
struct Triangle{
QPoint A,B,C;
};
namespace IntelliHelper {
class IntelliHelper{
public:
static inline float sign(QPoint& p1, QPoint& p2, QPoint& p3){
inline float sign(QPoint& p1, QPoint& p2, QPoint& p3){
return (p1.x()-p3.x())*(p2.y()-p3.y())-(p2.x()-p3.x())*(p1.y()-p3.y());
}
static inline bool isInTriangle(QPoint& A, QPoint& B, QPoint& C, QPoint& P){
inline bool isInTriangle(QPoint& A, QPoint& B, QPoint& C, QPoint& P){
float val1, val2, val3;
bool neg, pos;
@@ -25,6 +28,11 @@ public:
return !(neg && pos);
}
};
std::vector<Triangle> calculateTriangles(std::vector<QPoint> polyPoints);
bool isInPolygon(std::vector<Triangle> &triangles, QPoint &point);
}
#endif

4
src/IntelliPhoto.pro
View File

@@ -29,7 +29,7 @@ SOURCES += \
Tool/IntelliToolPen.cpp \
Tool/IntelliToolPlain.cpp \
Tool/IntelliToolPolygon.cpp \
Tool/IntelliToolRechteck.cpp \
Tool/IntelliToolRectangle.cpp \
main.cpp
HEADERS += \
@@ -46,7 +46,7 @@ HEADERS += \
Tool/IntelliToolPen.h \
Tool/IntelliToolPlain.h \
Tool/IntelliToolPolygon.h \
Tool/IntelliToolRechteck.h
Tool/IntelliToolRectangle.h
FORMS += \
mainwindow.ui

6
src/Layer/PaintingArea.cpp
View File

@@ -14,7 +14,7 @@
#include "Tool/IntelliToolPlain.h"
#include "Tool/IntelliToolLine.h"
#include "Tool/IntelliToolCircle.h"
#include "Tool/IntelliToolRechteck.h"
#include "Tool/IntelliToolRectangle.h"
#include "Tool/IntelliToolPolygon.h"
PaintingArea::PaintingArea(int maxWidth, int maxHeight, QWidget *parent)
@@ -165,12 +165,12 @@ void PaintingArea::slotActivateLayer(int a){
}
void PaintingArea::colorPickerSetFirstColor(){
QColor clr = QColorDialog::getColor(colorPicker.getFirstColor(), nullptr, "Main Color");
QColor clr = QColorDialog::getColor(colorPicker.getFirstColor(), nullptr, "Main Color", QColorDialog::DontUseNativeDialog);
this->colorPicker.setFirstColor(clr);
}
void PaintingArea::colorPickerSetSecondColor(){
QColor clr = QColorDialog::getColor(colorPicker.getSecondColor(), nullptr, "Secondary Color");
QColor clr = QColorDialog::getColor(colorPicker.getSecondColor(), nullptr, "Secondary Color", QColorDialog::DontUseNativeDialog);
this->colorPicker.setSecondColor(clr);
}

4
src/Layer/PaintingArea.h
View File

@@ -21,8 +21,6 @@ struct LayerObject{
int widthOffset;
int hightOffset;
int alpha=255;
};
class PaintingArea : public QWidget
@@ -87,7 +85,6 @@ private:
void activateUpperLayer();
void activateLowerLayer();
QImage* Canvas;
int maxWidth;
int maxHeight;
@@ -108,4 +105,3 @@ private:
};
#endif

24
src/Tool/IntelliToolRechteck.cpp → src/Tool/IntelliToolRectangle.cpp
View File

@@ -1,18 +1,18 @@
#include"IntelliToolRechteck.h"
#include"IntelliToolRectangle.h"
#include "Layer/PaintingArea.h"
#include "QInputDialog"
IntelliToolRechteck::IntelliToolRechteck(PaintingArea* Area, IntelliColorPicker* colorPicker)
IntelliToolRectangle::IntelliToolRectangle(PaintingArea* Area, IntelliColorPicker* colorPicker)
:IntelliTool(Area, colorPicker){
this->alphaInner = QInputDialog::getInt(nullptr,"Inner Alpha Value", "Value:", 0,0,255,1);
this->edgeWidth = QInputDialog::getInt(nullptr,"Outer edge width", "Value:", 0,1,255,1);
}
IntelliToolRechteck::~IntelliToolRechteck(){
IntelliToolRectangle::~IntelliToolRectangle(){
}
void IntelliToolRechteck::drawRechteck(QPoint otherCornor){
void IntelliToolRectangle::drawRectangle(QPoint otherCornor){
int xMin = std::min(originCornor.x(), otherCornor.x());
int xMax = std::max(originCornor.x(), otherCornor.x());
@@ -30,36 +30,36 @@ void IntelliToolRechteck::drawRechteck(QPoint otherCornor){
this->Canvas->image->drawLine(QPoint(xMax, yMax),QPoint(xMax, yMin), this->colorPicker->getFirstColor(), edgeWidth);
}
void IntelliToolRechteck::onMouseRightPressed(int x, int y){
void IntelliToolRectangle::onMouseRightPressed(int x, int y){
IntelliTool::onMouseRightPressed(x,y);
}
void IntelliToolRechteck::onMouseRightReleased(int x, int y){
void IntelliToolRectangle::onMouseRightReleased(int x, int y){
IntelliTool::onMouseRightReleased(x,y);
}
void IntelliToolRechteck::onMouseLeftPressed(int x, int y){
void IntelliToolRectangle::onMouseLeftPressed(int x, int y){
IntelliTool::onMouseLeftPressed(x,y);
this->originCornor=QPoint(x,y);
drawRechteck(originCornor);
drawRectangle(originCornor);
Canvas->image->calculateVisiblity();
}
void IntelliToolRechteck::onMouseLeftReleased(int x, int y){
void IntelliToolRectangle::onMouseLeftReleased(int x, int y){
IntelliTool::onMouseLeftReleased(x,y);
}
void IntelliToolRechteck::onMouseMoved(int x, int y){
void IntelliToolRectangle::onMouseMoved(int x, int y){
IntelliTool::onMouseMoved(x,y);
if(this->drawing){
this->Canvas->image->drawPlain(Qt::transparent);
QPoint next(x,y);
drawRechteck(next);
drawRectangle(next);
}
IntelliTool::onMouseMoved(x,y);
}
void IntelliToolRechteck::onWheelScrolled(int value){
void IntelliToolRectangle::onWheelScrolled(int value){
IntelliTool::onWheelScrolled(value);
this->edgeWidth+=value;
if(this->edgeWidth<=0){

14
src/Tool/IntelliToolRechteck.h → src/Tool/IntelliToolRectangle.h
View File

@@ -1,20 +1,20 @@
#ifndef INTELLIRECHTECKTOOL_H
#define INTELLIRECHTECKTOOL_H
#ifndef INTELLIRECTANGLETOOL_H
#define INTELLIRECTANGLETOOL_H
#include "IntelliTool.h"
#include "QColor"
#include "QPoint"
class IntelliToolRechteck : public IntelliTool{
void drawRechteck(QPoint otherCornor);
class IntelliToolRectangle : public IntelliTool{
void drawRectangle(QPoint otherCornor);
QPoint originCornor;
int alphaInner;
int edgeWidth;
public:
IntelliToolRechteck(PaintingArea* Area, IntelliColorPicker* colorPicker);
virtual ~IntelliToolRechteck() override;
IntelliToolRectangle(PaintingArea* Area, IntelliColorPicker* colorPicker);
virtual ~IntelliToolRectangle() override;
virtual void onMouseRightPressed(int x, int y) override;
virtual void onMouseRightReleased(int x, int y) override;
@@ -26,4 +26,4 @@ public:
virtual void onMouseMoved(int x, int y) override;
};
#endif // INTELLIRECHTECKTOOL_H
#endif // INTELLIRECTANGLETOOL_H

2
src/main.cpp
View File

@@ -1,6 +1,8 @@
#include "GUI/IntelliPhotoGui.h"
#include <QApplication>
#include <QDebug>
#include "IntelliHelper/IntelliHelper.h"
#include<vector>
int main(int argc, char *argv[]){
// The main application