Merge branch 'dev' into dev_PolygonTool

.gitignore

@@ -1,5 +1,5 @@
 # Build folders
-/build-*/
+build-*/
 
 # QT Creator Files
 *.creator.user*

src/GUI/IntelliPhotoGui.cpp

@@ -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()) {

src/Image/IntelliShapedImage.cpp

@@ -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;
+            QPoint ptr(x,y);
-            for(int i=1; i<static_cast<int>(polygonData.size()-1); i++){
+            clr = imageData.pixelColor(x,y);
-                QPoint B = polygonData[static_cast<size_t>(i)];
+            bool isInPolygon = IntelliHelper::isInPolygon(triangles, ptr);
-                QPoint C = polygonData[static_cast<size_t>(i+1)];
+            if(isInPolygon){
-                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);
                 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;

src/Image/IntelliShapedImage.h

@@ -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;

src/IntelliHelper/IntelliHelper.cpp

@@ -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;
+}

src/IntelliHelper/IntelliHelper.h

@@ -2,17 +2,20 @@
 #define INTELLIHELPER_H
 
 #include<QPoint>
+#include<vector>
+
+struct Triangle{
+    QPoint A,B,C;
+};
+
+namespace IntelliHelper {
 
 
-class IntelliHelper{
+    inline float sign(QPoint& p1, QPoint& p2, QPoint& p3){
-
-public:
-
-    static 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

src/IntelliPhoto.pro

@@ -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

src/Layer/PaintingArea.cpp

@@ -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);
 }
 

src/Layer/PaintingArea.h

@@ -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
-

src/Tool/IntelliToolRectangle.cpp

@@ -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){

src/Tool/IntelliToolRectangle.h

@@ -1,20 +1,20 @@
-#ifndef INTELLIRECHTECKTOOL_H
+#ifndef INTELLIRECTANGLETOOL_H
-#define INTELLIRECHTECKTOOL_H
+#define INTELLIRECTANGLETOOL_H
 
 #include "IntelliTool.h"
 
 #include "QColor"
 #include "QPoint"
 
-class IntelliToolRechteck : public IntelliTool{
+class IntelliToolRectangle : public IntelliTool{
-    void drawRechteck(QPoint otherCornor);
+    void drawRectangle(QPoint otherCornor);
 
     QPoint originCornor;
     int alphaInner;
     int edgeWidth;
 public:
-    IntelliToolRechteck(PaintingArea* Area, IntelliColorPicker* colorPicker);
+    IntelliToolRectangle(PaintingArea* Area, IntelliColorPicker* colorPicker);
-    virtual ~IntelliToolRechteck() override;
+    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

src/main.cpp

@@ -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