Merge branch 'dev-Gradient' into 'dev'

Dev gradient

See merge request creyd/intelliphoto!59

knownBugs.txt

@@ -1 +1,4 @@
-history tool doesnt load polygon data on undo iff project was loaded
+history tool doesnt load polygon data on undo iff project was loaded
+history tool doesnt save delete Layer
+Gradient breaks Heap Size, when big Witdh and Height (appeared on 1280x720)
+Heap block at 0000000025422990 modified at 0000000025422A28 past requested size of 88

src/GUI/IntelliPhotoGui.cpp

@@ -20,6 +20,7 @@ IntelliPhotoGui::IntelliPhotoGui(){
 		setIntelliStyle();
 		// Size the app
 		resize(600,600);
+        showMaximized();
 		setDefaultValues();
 }
 
@@ -241,11 +242,13 @@ void IntelliPhotoGui::slotSetActiveLayer(){
 
 void IntelliPhotoGui::slotUpdateRenderSettingsOn(){
 		paintingArea->setRenderSettings(true);
+        FastRendererLabel->setText("Fast Render: On");
 		UpdateGui();
 }
 
 void IntelliPhotoGui::slotUpdateRenderSettingsOff(){
 		paintingArea->setRenderSettings(false);
+        FastRendererLabel->setText("Fast Render: Off");
 		UpdateGui();
 }
 
@@ -299,6 +302,11 @@ void IntelliPhotoGui::slotCreateFloodFillTool(){
 		paintingArea->createFloodFillTool();
 }
 
+void IntelliPhotoGui::slotCreateGradientTool(){
+        GradientButton->setChecked(true);
+        paintingArea->createGradientTool();
+}
+
 // Open an about dialog
 void IntelliPhotoGui::slotAboutDialog(){
 		// Window title and text to display
@@ -520,6 +528,10 @@ void IntelliPhotoGui::createActions(){
 		connect(actionCreateFloodFillTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreateFloodFillTool, SIGNAL(triggered()), this, SLOT(slotCreateFloodFillTool()));
 
+        actionCreateGradientTool = new QAction(tr("&Gradient"),this);
+        connect(actionCreateGradientTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
+        connect(actionCreateGradientTool, SIGNAL(triggered()), this, SLOT(slotCreateGradientTool()));
+
 		// Create about action and tie to IntelliPhotoGui::about()
 		actionAboutDialog = new QAction(tr("&About"), this);
 		actionAboutDialog->setShortcut(Qt::Key_F2);
@@ -539,6 +551,9 @@ void IntelliPhotoGui::createActions(){
 		connect(FloodFillButton,SIGNAL(pressed()), this, SLOT(slotResetTools()));
 		connect(FloodFillButton, SIGNAL(clicked()), this, SLOT(slotCreateFloodFillTool()));
 
+        connect(GradientButton, SIGNAL(pressed()), this, SLOT(slotResetTools()));
+        connect(GradientButton, SIGNAL(clicked()), this, SLOT(slotCreateGradientTool()));
+
 		connect(LineButton,SIGNAL(pressed()), this, SLOT(slotResetTools()));
 		connect(LineButton, SIGNAL(clicked()), this, SLOT(slotCreateLineTool()));
 
@@ -621,7 +636,8 @@ void IntelliPhotoGui::createMenus(){
 		//Attach all Tool Creation Actions
 		toolCreationMenu = new QMenu(tr("&Drawingtools"), this);
 		toolCreationMenu->addAction(actionCreateCircleTool);
-		toolCreationMenu->addAction(actionCreateFloodFillTool);
+        toolCreationMenu->addAction(actionCreateFloodFillTool);
+        toolCreationMenu->addAction(actionCreateGradientTool);
 		toolCreationMenu->addAction(actionCreateLineTool);
 		toolCreationMenu->addAction(actionCreatePenTool);
 		toolCreationMenu->addAction(actionCreatePlainTool);
@@ -689,6 +705,13 @@ void IntelliPhotoGui::createGui(){
 		FloodFillButton->setIconSize(Buttonsize);
 		FloodFillButton->setCheckable(true);
 
+        preview = QPixmap(":/Icons/Buttons/icons/icon.png");
+        GradientButton = new QPushButton();
+        GradientButton->setFixedSize(Buttonsize);
+        GradientButton->setIcon(preview);
+        GradientButton->setIconSize(Buttonsize);
+        GradientButton->setCheckable(true);
+
 		preview = QPixmap(":/Icons/Buttons/icons/line-tool.svg");
 		LineButton = new QPushButton();
 		LineButton->setFixedSize(Buttonsize);
@@ -787,6 +810,10 @@ void IntelliPhotoGui::createGui(){
 		QString String = QString("%1x%2").arg(paintingArea->Canvas->width()).arg(paintingArea->Canvas->height());
 		dimCanvas->setText(String);
 
+        FastRendererLabel = new QLabel();
+        FastRendererLabel->setFixedSize(Buttonsize.width() * 2 + 15,(Buttonsize.height() * 2) / 3);
+        FastRendererLabel->setText("Fast Render: On");
+
 		ScrollArea = new QScrollArea(this);
 		ScrollArea->setBackgroundRole(QPalette::Dark);
 		ScrollArea->setWidget(paintingArea);
@@ -802,6 +829,7 @@ void IntelliPhotoGui::createGui(){
 		mainLayout->addWidget(PlainButton,3,2,1,1);
 		mainLayout->addWidget(PolygonButton,3,3,1,1);
 		mainLayout->addWidget(RectangleButton,4,2,1,1);
+        mainLayout->addWidget(GradientButton,4,3,1,1);
 		mainLayout->addWidget(WidthLine,5,2,1,2);
 		mainLayout->addWidget(EditLineWidth,6,2,1,2);
 		mainLayout->addWidget(innerAlphaLine,7,2,1,2);
@@ -813,6 +841,7 @@ void IntelliPhotoGui::createGui(){
 		mainLayout->addWidget(ActiveLayerImageLabel,12,2,1,2);
 		mainLayout->addWidget(dimActive,13,2,1,2);
 		mainLayout->addWidget(dimCanvas,14,2,1,2);
+        mainLayout->addWidget(FastRendererLabel,15,2,1,2);
 		mainLayout->setHorizontalSpacing(0);
 
 }

src/GUI/IntelliPhotoGui.h

@@ -85,6 +85,7 @@ void slotCreateRectangleTool();
 void slotCreateCircleTool();
 void slotCreatePolygonTool();
 void slotCreateFloodFillTool();
+void slotCreateGradientTool();
 
 void slotAboutDialog();
 
@@ -128,6 +129,7 @@ const QSize Buttonsize = QSize(35,35);
 //buttons used for gui
 QPushButton* CircleButton;
 QPushButton* FloodFillButton;
+QPushButton* GradientButton;
 QPushButton* LineButton;
 QPushButton* PenButton;
 QPushButton* PlainButton;
@@ -144,6 +146,7 @@ QLabel* WidthLine;
 QLabel* innerAlphaLine;
 QLabel* ActiveLayerLine;
 QLabel* ActiveLayerImageLabel;
+QLabel* FastRendererLabel;
 
 //scroll area to display canvas
 QScrollArea* ScrollArea;
@@ -192,6 +195,7 @@ QAction* actionCreateRectangleTool;
 QAction* actionCreateCircleTool;
 QAction* actionCreatePolygonTool;
 QAction* actionCreateFloodFillTool;
+QAction* actionCreateGradientTool;
 
 // dimension actions
 QAction* actionChangeDim;

src/IntelliPhoto.pro

@@ -30,6 +30,7 @@ SOURCES += \
     Tool/IntelliTool.cpp \
     Tool/IntelliToolCircle.cpp \
     Tool/IntelliToolFloodFill.cpp \
+    Tool/IntelliToolGradient.cpp \
     Tool/IntelliToolLine.cpp \
     Tool/IntelliToolPen.cpp \
     Tool/IntelliToolPlain.cpp \
@@ -52,6 +53,7 @@ HEADERS += \
     Tool/IntelliTool.h \
     Tool/IntelliToolCircle.h \
     Tool/IntelliToolFloodFill.h \
+    Tool/IntelliToolGradient.h \
     Tool/IntelliToolLine.h \
     Tool/IntelliToolPen.h \
     Tool/IntelliToolPlain.h \

src/Layer/PaintingArea.cpp

@@ -17,6 +17,7 @@
 #include "Tool/IntelliToolRectangle.h"
 #include "Tool/IntelliToolFloodFill.h"
 #include "Tool/IntelliToolPolygon.h"
+#include "Tool/IntelliToolGradient.h"
 #include "GUI/IntelliPhotoGui.h"
 
 LayerObject::LayerObject(){
@@ -38,9 +39,8 @@ LayerObject::LayerObject(const LayerObject& layer){
 
 PaintingArea::PaintingArea(int maxWidth, int maxHeight, QWidget*parent)
 		: QLabel(parent){
-		this->Tool = nullptr;
+        this->Tool = nullptr;
 		this->setLayerDimensions(maxWidth, maxHeight);
-
 		activeLayer = -1;
 }
 
@@ -275,6 +275,11 @@ void PaintingArea::createFloodFillTool(){
 		Tool = new IntelliToolFloodFill(this, &colorPicker, &Toolsettings);
 }
 
+void PaintingArea::createGradientTool(){
+        delete this->Tool;
+        Tool = new IntelliToolGradient(this, &colorPicker, &Toolsettings);
+}
+
 int PaintingArea::getWidthOfActive(){
 		return this->layerBundle[static_cast<size_t>(activeLayer)].width;
 }

src/Layer/PaintingArea.h

@@ -183,6 +183,7 @@ void createRectangleTool();
 void createCircleTool();
 void createPolygonTool();
 void createFloodFillTool();
+void createGradientTool();
 
 /*!
  * \brief The getWidthOfActive gets the horizontal dimensions of the active layer

src/Tool/IntelliToolGradient.cpp

@@ -0,0 +1,130 @@
+#include "IntelliToolGradient.h"
+#include "Layer/PaintingArea.h"
+#include "math.h"
+#include <QDebug>
+
+IntelliToolGradient::IntelliToolGradient(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings)
+        : IntelliTool(Area, colorPicker, Toolsettings){
+        this->LineColor = QColor(0,0,0,255);
+        this->hasMoved = false;
+}
+
+IntelliToolGradient::~IntelliToolGradient(){
+        IntelliTool::onMouseRightPressed(0,0);
+}
+
+void IntelliToolGradient::onMouseLeftPressed(int x, int y){
+        IntelliTool::onMouseLeftPressed(x,y);
+        doubleA[0] = static_cast<double>(x);
+        doubleA[1] = static_cast<double>(y);
+        A = QPoint(x,y);
+        B = QPoint(x,y);
+        VectorAB[0] = 0;
+        VectorAB[1] = 0;
+        Canvas->image->drawPixel(A,LineColor);
+}
+
+void IntelliToolGradient::onMouseRightPressed(int x, int y){
+        IntelliTool::onMouseRightPressed(x,y);
+}
+
+void IntelliToolGradient::onMouseLeftReleased(int x, int y){
+        if(hasMoved && this->isDrawing){
+            computeGradientLayer();
+            IntelliTool::onMouseLeftReleased(x,y);
+        }
+}
+
+void IntelliToolGradient::onMouseRightReleased(int x, int y){
+        IntelliTool::onMouseRightReleased(x,y);
+}
+
+void IntelliToolGradient::onMouseMoved(int x, int y){
+        if(this->isDrawing){
+            hasMoved = true;
+            B = QPoint(x,y);
+            VectorAB[0] = static_cast<float>(B.x() - A.x());
+            VectorAB[1] = static_cast<float>(B.y() - A.y());
+            NormalVector[0] = VectorAB[1];
+            NormalVector[1] = (-1*VectorAB[0]);
+            NormalDotNormal = dotProduct(NormalVector,NormalVector);
+            this->Canvas->image->drawPlain(Qt::transparent);
+            computeGradientLayer();
+            Canvas->image->drawLine(A,B,LineColor,1);
+        }
+        IntelliTool::onMouseMoved(x,y);
+}
+
+void IntelliToolGradient::onWheelScrolled(int value){
+        IntelliTool::onWheelScrolled(value);
+}
+
+void IntelliToolGradient::computePixelColor(QPoint Point){
+        double doublePoint[2];
+        doublePoint[0] = static_cast<double>(Point.x());
+        doublePoint[1] = static_cast<double>(Point.y());
+        double doublePointSubA[2];
+        doublePointSubA[0] = doublePoint[0] - doubleA[0];
+        doublePointSubA[1] = doublePoint[1] - doubleA[1];
+        double Perpendicular[2];
+        double PointSubADotNormal = dotProduct(doublePointSubA,NormalVector);
+        Perpendicular[0] = doublePoint[0] - (PointSubADotNormal / NormalDotNormal) * NormalVector[0];
+        Perpendicular[1] = doublePoint[1] - (PointSubADotNormal / NormalDotNormal) * NormalVector[1];
+        double VectorAPoint[2];
+        VectorAPoint[0] = static_cast<double>(Perpendicular[0] - doubleA[0]);
+        VectorAPoint[1] = static_cast<double>(Perpendicular[1] - doubleA[1]);
+        double ratio;
+        if(((VectorAPoint[0] < 0 && VectorAB[0] < 0) || (VectorAPoint[0] > 0 && VectorAB[0] > 0)) && ((VectorAPoint[1] < 0 && VectorAB[1] < 0) || (VectorAPoint[1] > 0 && VectorAB[1] > 0)))
+               ratio = lenghtVector(VectorAPoint)/lenghtVector(VectorAB);
+        else{
+               ratio = -1;
+        }
+        QColor computedColor;
+        if(ratio < 0){
+            computedColor = colorPicker->getFirstColor();
+        }
+        else if(ratio > 1){
+            computedColor = colorPicker->getSecondColor();
+        }
+        else{
+            int red;
+            int green;
+            int blue;
+            int alpha;
+            int red2;
+            int green2;
+            int blue2;
+            int alpha2;
+            colorPicker->getFirstColor().getRgb(&red,&green,&blue,&alpha);
+            colorPicker->getSecondColor().getRgb(&red2,&green2,&blue2,&alpha2);
+            computedColor.setRed(static_cast<int>(ratio * red2 + (1 - ratio) * red));
+            computedColor.setGreen(static_cast<int>(ratio * green2 + (1 - ratio) * green));
+            computedColor.setBlue(static_cast<int>(ratio * blue2 + (1 - ratio) * blue));
+            computedColor.setAlpha(static_cast<int>(ratio * alpha2 + (1 - ratio) * alpha));
+        }
+        Canvas->image->drawPixel(Point,computedColor);
+}
+
+double IntelliToolGradient::dotProduct(double Vector1[2], double Vector2[2]){
+        return static_cast<double>(Vector1[0]*Vector2[0]+Vector1[1]*Vector2[1]);
+}
+
+double IntelliToolGradient::lenghtVector(double Vector[2]){
+        return static_cast<double>((std::sqrt(Vector[0] * Vector[0] + Vector[1] * Vector[1])));
+}
+
+void IntelliToolGradient::computeGradientLayer(){
+    bool switched = false;
+    if(Canvas->image->isFastRendering()){
+        switched = true;
+        Canvas->image->updateRendererSetting(false);
+    }
+    for(int i = 0; i < activeLayer->height; i++){
+        for(int j = 0; j < activeLayer->width; j++){
+            computePixelColor(QPoint(j,i));
+        }
+    }
+    if(switched){
+        Canvas->image->updateRendererSetting(true);
+    }
+}

src/Tool/IntelliToolGradient.h

@@ -0,0 +1,72 @@
+#ifndef INTELLITOOLGRADIENT_H
+#define INTELLITOOLGRADIENT_H
+#include "IntelliTool.h"
+
+class IntelliToolGradient : public IntelliTool{
+
+public:
+    IntelliToolGradient(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings);
+
+    virtual ~IntelliToolGradient() override;
+
+    /*!
+     * \brief A function managing the right click Pressed of a Mouse. Constructing the Canvas to draw on. Call this in child classes!
+     * \param x - The x coordinate relative to the active/canvas layer.
+     * \param y - The y coordinate relative to the active/canvas layer.
+     */
+    virtual void onMouseRightPressed(int x, int y) override;
+
+    /*!
+     * \brief A function managing the right click Released of a Mouse. Merging the Canvas to Active. Call this in child classes!
+     * \param x - The x coordinate relative to the active/canvas layer.
+     * \param y - The y coordinate relative to the active/canvas layer.
+     */
+    virtual void onMouseRightReleased(int x, int y) override;
+
+    /*!
+     * \brief A function managing the left click Pressed of a Mouse. Resetting the current draw. Call this in child classes!
+     * \param x - The x coordinate relative to the active/canvas layer.
+     * \param y - The y coordinate relative to the active/canvas layer.
+     */
+    virtual void onMouseLeftPressed(int x, int y) override;
+
+    /*!
+     * \brief A function managing the left click Released of a Mouse. Call this in child classes!
+     * \param x - The x coordinate relative to the active/canvas layer.
+     * \param y - The y coordinate relative to the active/canvas layer.
+     */
+    virtual void onMouseLeftReleased(int x, int y) override;
+
+    /*!
+     * \brief A function managing the scroll event. A positive value means scrolling outwards. Call this in child classes!
+     * \param value - The absolute the scroll has changed.
+     */
+    virtual void onWheelScrolled(int value) override;
+
+    /*!
+     * \brief A function managing the mouse moved event. Call this in child classes!
+     * \param x - The x coordinate of the new mouse position.
+     * \param y - The y coordinate of the new mouse position.
+     */
+    virtual void onMouseMoved(int x, int y) override;
+
+private:
+    QPoint A;
+    QPoint B;
+    double doubleA[2];
+    double VectorAB[2];
+    double NormalVector[2];
+    double NormalDotNormal;
+    QColor LineColor;
+    bool hasMoved;
+
+    void computePixelColor(QPoint Point);
+
+    double dotProduct(double Vector1[2], double Vector2[2]);
+
+    double lenghtVector(double Vector[2]);
+
+    void computeGradientLayer();
+};
+
+#endif // INTELLITOOLGRADIENT_H