Merge branch 'dev-stupidrenderer' into 'Helper_Variablen'

Dev stupidrenderer

See merge request creyd/intelliphoto!28

src/Image/IntelliImage.cpp

@@ -2,9 +2,16 @@
 #include <QSize>
 #include <QPainter>
 
-IntelliImage::IntelliImage(int weight, int height)
+IntelliImage::IntelliImage(int width, int height, bool fastRendererOn)
-		: imageData(QSize(weight, height), QImage::Format_ARGB32){
+        : imageData(QSize(width, height), fastRendererOn ? QImage::Format_Indexed8 : QImage::Format_ARGB32){
-		imageData.fill(QColor(255,255,255,255));
+        if(fastRendererOn){
+            imageData = imageData.convertToFormat(QImage::Format_ARGB32);
+        }
+        imageData.fill(QColor(255,255,255,255));
+        if(fastRendererOn){
+            imageData = imageData.convertToFormat(QImage::Format_Indexed8);
+        }
+        this->fastRenderer = fastRendererOn;
 
 }
 
@@ -23,7 +30,7 @@ bool IntelliImage::loadImage(const QString &filePath){
 		// scaled Image to size of Layer
 		loadedImage = loadedImage.scaled(imageData.size(),Qt::IgnoreAspectRatio);
 
-		imageData = loadedImage.convertToFormat(QImage::Format_ARGB32);
+        imageData = loadedImage.convertToFormat(fastRenderer ? QImage::Format_Indexed8 : QImage::Format_ARGB32);
 		return true;
 }
 
@@ -33,17 +40,23 @@ void IntelliImage::resizeImage(QImage*image, const QSize &newSize){
 				return;
 
 		// Create a new image to display and fill it with white
-		QImage newImage(newSize, QImage::Format_ARGB32);
+        QImage newImage(newSize, QImage::Format_ARGB32);
 		newImage.fill(qRgb(255, 255, 255));
 
 		// Draw the image
 		QPainter painter(&newImage);
 		painter.drawImage(QPoint(0, 0), *image);
 		*image = newImage;
+        if(fastRenderer){
+               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 void IntelliImage::drawPixel(const QPoint &p1, const QColor& color){
-		// Used to draw on the widget
+        if(fastRenderer){
+                this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
+        }
+        // Used to draw on the widget
 		QPainter painter(&imageData);
 
 		// Set the current settings for the pen
@@ -51,20 +64,32 @@ void IntelliImage::drawPixel(const QPoint &p1, const QColor& color){
 
 		// Draw a line from the last registered point to the current
 		painter.drawPoint(p1);
+        if(fastRenderer){
+               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 void IntelliImage::drawPoint(const QPoint &p1, const QColor& color, const int& penWidth){
-		// Used to draw on the widget
+        if(fastRenderer){
+                 this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
+        }
+        // Used to draw on the widget
 		QPainter painter(&imageData);
 
 		// Set the current settings for the pen
 		painter.setPen(QPen(color, penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 		// Draw a line from the last registered point to the current
 		painter.drawPoint(p1);
+        if(fastRenderer){
+               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 void IntelliImage::drawLine(const QPoint &p1, const QPoint& p2, const QColor& color, const int& penWidth){
-		// Used to draw on the widget
+        if(fastRenderer){
+                 this->imageData =  this->imageData.convertToFormat(QImage::Format_ARGB32);
+        }
+        // Used to draw on the widget
 		QPainter painter(&imageData);
 
 		// Set the current settings for the pen
@@ -72,12 +97,30 @@ void IntelliImage::drawLine(const QPoint &p1, const QPoint& p2, const QColor& co
 
 		// Draw a line from the last registered point to the current
 		painter.drawLine(p1, p2);
+        if(fastRenderer){
+               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 void IntelliImage::drawPlain(const QColor& color){
-		imageData.fill(color);
+        if(fastRenderer){
+               this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
+        }
+        imageData.fill(color);
+        if(fastRenderer){
+               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 QColor IntelliImage::getPixelColor(QPoint& point){
-		return imageData.pixelColor(point);
+    if(fastRenderer){
+           QImage copy = this->imageData.convertToFormat(QImage::Format_ARGB32);
+           return copy.pixelColor(point);
+    }
+    return imageData.pixelColor(point);
+}
+
+void IntelliImage::updateRendererSetting(bool fastRendererOn){
+        this->fastRenderer = fastRendererOn;
+        this->imageData =  this->imageData.convertToFormat(fastRenderer ? QImage::Format_Indexed8 : QImage::Format_ARGB32);
 }

src/Image/IntelliImage.h

@@ -8,7 +8,11 @@
 #include <QWidget>
 #include <vector>
 
+<<<<<<< src/Image/IntelliImage.h
+#include "IntelliHelper/IntelliRenderSettings.h"
+=======
 #include "IntelliHelper/IntelliTriangulation.h"
+>>>>>>> src/Image/IntelliImage.h
 
 class IntelliTool;
 
@@ -39,13 +43,20 @@ QImage imageData;
  * \brief The Type, an Image is.
  */
 ImageType TypeOfImage;
+
+/*!
+ * \brief fastRenderer is the flag that represents the usage of 8bit pictures.
+ */
+bool fastRenderer;
+
 public:
 /*!
  * \brief The Construcor of the IntelliImage. Given the Image dimensions.
  * \param width    - The width of the Image.
  * \param height    - The height of the Image.
+ * \param fastRendererOn    - Represents the flag for 8bit picture handelling.
  */
-IntelliImage(int width, int height);
+IntelliImage(int width, int height, bool fastRendererOn);
 
 /*!
  * \brief An Abstract Destructor.
@@ -140,6 +151,13 @@ virtual bool loadImage(const QString &filePath);
  * \return The color of the Pixel as QColor.
  */
 virtual QColor getPixelColor(QPoint& point);
+
+/*!
+ * \brief updateRendererSetting updates the existing image format to the new format.
+ * \param fastRendererOn flag for the 8bit image handeling.
+ */
+virtual void updateRendererSetting(bool fastRendererOn);
+
 };
 
 #endif

src/Image/IntelliRasterImage.cpp

@@ -3,9 +3,10 @@
 #include <QRect>
 #include <QDebug>
 
-IntelliRasterImage::IntelliRasterImage(int weight, int height)
+IntelliRasterImage::IntelliRasterImage(int width, int height, bool fastRendererOn)
-		: IntelliImage(weight, height){
+        : IntelliImage(width, height, fastRendererOn){
         TypeOfImage = IntelliImage::ImageType::Raster_Image;
+        this->fastRenderer = fastRendererOn;
 }
 
 IntelliRasterImage::~IntelliRasterImage(){
@@ -13,7 +14,7 @@ IntelliRasterImage::~IntelliRasterImage(){
 }
 
 IntelliImage* IntelliRasterImage::getDeepCopy(){
-		IntelliRasterImage* raster = new IntelliRasterImage(imageData.width(), imageData.height());
+        IntelliRasterImage* raster = new IntelliRasterImage(imageData.width(), imageData.height(), false);
 		raster->imageData.fill(Qt::transparent);
         raster->TypeOfImage = IntelliImage::ImageType::Raster_Image;
 		return raster;
@@ -29,6 +30,9 @@ QImage IntelliRasterImage::getDisplayable(int alpha){
 
 QImage IntelliRasterImage::getDisplayable(const QSize& displaySize, int alpha){
 		QImage copy = imageData;
+        if(fastRenderer){
+            copy = copy.convertToFormat(QImage::Format_ARGB32);
+        }
 		for(int y = 0; y<copy.height(); y++) {
 				for(int x = 0; x<copy.width(); x++) {
 						QColor clr = copy.pixelColor(x,y);
@@ -36,6 +40,9 @@ QImage IntelliRasterImage::getDisplayable(const QSize& displaySize, int alpha){
 						copy.setPixelColor(x,y, clr);
 				}
 		}
+        if(fastRenderer){
+            copy = copy.convertToFormat(QImage::Format_Indexed8);
+        }
 		return copy.scaled(displaySize,Qt::IgnoreAspectRatio);
 }
 

src/Image/IntelliRasterImage.h

@@ -18,8 +18,9 @@ public:
  * \brief The Construcor of the IntelliRasterImage. Given the Image dimensions.
  * \param width    - The width of the Image.
  * \param height    - The height of the Image.
+ * \param fastRendererOn    - Represents the flag for 8bit picture handelling.
  */
-IntelliRasterImage(int width, int height);
+IntelliRasterImage(int width, int height, bool fastRendererOn);
 
 /*!
  * \brief An Destructor.

src/Image/IntelliShapedImage.cpp

@@ -4,9 +4,10 @@
 #include <QRect>
 #include <QDebug>
 
-IntelliShapedImage::IntelliShapedImage(int weight, int height)
+IntelliShapedImage::IntelliShapedImage(int width, int height, bool fastRendererOn)
-		: IntelliRasterImage(weight, height){
+        : IntelliRasterImage(width, height, fastRendererOn){
         TypeOfImage = IntelliImage::ImageType::Shaped_Image;
+        this->fastRenderer = fastRendererOn;
 }
 
 IntelliShapedImage::~IntelliShapedImage(){
@@ -18,7 +19,7 @@ QImage IntelliShapedImage::getDisplayable(int alpha){
 }
 
 IntelliImage* IntelliShapedImage::getDeepCopy(){
-		IntelliShapedImage* shaped = new IntelliShapedImage(imageData.width(), imageData.height());
+        IntelliShapedImage* shaped = new IntelliShapedImage(imageData.width(), imageData.height(), false);
 		shaped->setPolygon(this->polygonData);
 		shaped->imageData.fill(Qt::transparent);
         shaped->TypeOfImage = IntelliImage::ImageType::Shaped_Image;
@@ -26,7 +27,11 @@ IntelliImage* IntelliShapedImage::getDeepCopy(){
 }
 
 void IntelliShapedImage::calculateVisiblity(){
-		if(polygonData.size()<=2) {
+        if(fastRenderer){
+            this->imageData = imageData.convertToFormat(QImage::Format_ARGB32);
+        }
+
+        if(polygonData.size()<=2) {
 				QColor clr;
 				for(int y=0; y<imageData.height(); y++) {
 						for(int x=0; x<imageData.width(); x++) {
@@ -35,6 +40,9 @@ void IntelliShapedImage::calculateVisiblity(){
 								imageData.setPixelColor(x,y,clr);
 						}
 				}
+                if(fastRenderer){
+                     this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+                }
 				return;
 		}
 		QColor clr;
@@ -51,10 +59,16 @@ void IntelliShapedImage::calculateVisiblity(){
 						imageData.setPixelColor(x,y,clr);
 				}
 		}
+        if(fastRenderer){
+             this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 QImage IntelliShapedImage::getDisplayable(const QSize& displaySize, int alpha){
 		QImage copy = imageData;
+        if(fastRenderer){
+             copy = copy.convertToFormat(QImage::Format_ARGB32);
+        }
 		for(int y = 0; y<copy.height(); y++) {
 				for(int x = 0; x<copy.width(); x++) {
 						QColor clr = copy.pixelColor(x,y);
@@ -62,6 +76,9 @@ QImage IntelliShapedImage::getDisplayable(const QSize& displaySize, int alpha){
 						copy.setPixelColor(x,y, clr);
 				}
 		}
+        if(fastRenderer){
+             copy = copy.convertToFormat(QImage::Format_Indexed8);
+        }
 		return copy.scaled(displaySize,Qt::IgnoreAspectRatio);
 }
 

src/Image/IntelliShapedImage.h

@@ -30,8 +30,9 @@ public:
  * \brief The Construcor of the IntelliShapedImage. Given the Image dimensions.
  * \param width    - The width of the Image.
  * \param height    - The height of the Image.
+ * \param fastRendererOn    - Represents the flag for 8bit picture handelling.
  */
-IntelliShapedImage(int width, int height);
+IntelliShapedImage(int width, int height, bool fastRendererOn);
 
 /*!
  * \brief An Destructor.

src/IntelliHelper/IntelliRenderSettings.cpp

@@ -0,0 +1,10 @@
+#include "IntelliRenderSettings.h"
+
+IntelliRenderSettings::IntelliRenderSettings()
+{
+
+}
+
+bool IntelliRenderSettings::getFastRenderer(){
+    return fastRenderer;
+}

src/IntelliHelper/IntelliRenderSettings.h

@@ -0,0 +1,20 @@
+#ifndef INTELLIRENDERSETTINGS_H
+#define INTELLIRENDERSETTINGS_H
+
+
+class IntelliRenderSettings
+{
+public:
+    IntelliRenderSettings();
+
+    /*!
+     * \brief The getfastRenderer gets the value of the flag for the fastRenderer setting.
+     * \return Returns true if fastRenderer is active else false
+     */
+    bool getFastRenderer();
+
+private:
+    bool fastRenderer = true;
+};
+
+#endif // INTELLIRENDERSETTINGS_H

src/IntelliPhoto.pro

@@ -21,8 +21,12 @@ SOURCES += \
     Image/IntelliRasterImage.cpp \
     Image/IntelliShapedImage.cpp \
     IntelliHelper/IntelliColorPicker.cpp \
+<<<<<<< src/IntelliPhoto.pro
+    IntelliHelper/IntelliRenderSettings.cpp \
+=======
     IntelliHelper/IntelliToolsettings.cpp \
     IntelliHelper/IntelliTriangulation.cpp \
+>>>>>>> src/IntelliPhoto.pro
     Layer/PaintingArea.cpp \
     Tool/IntelliTool.cpp \
     Tool/IntelliToolCircle.cpp \
@@ -40,8 +44,13 @@ HEADERS += \
     Image/IntelliRasterImage.h \
     Image/IntelliShapedImage.h \
     IntelliHelper/IntelliColorPicker.h \
+<<<<<<< src/IntelliPhoto.pro
+    IntelliHelper/IntelliHelper.h \
+    IntelliHelper/IntelliRenderSettings.h \
+=======
     IntelliHelper/IntelliToolsettings.h \
     IntelliHelper/IntelliTriangulation.h \
+>>>>>>> src/IntelliPhoto.pro
     Layer/PaintingArea.h \
     Tool/IntelliTool.h \
     Tool/IntelliToolCircle.h \

src/Layer/PaintingArea.cpp

@@ -21,6 +21,7 @@
 PaintingArea::PaintingArea(int maxWidth, int maxHeight, QWidget*parent)
 		: QWidget(parent){
         this->Tool = nullptr;
+        this->renderSettings = IntelliRenderSettings();
         this->setLayerDimensions(maxWidth, maxHeight);
         this->addLayer(200,200,0,0,IntelliImage::ImageType::Shaped_Image);
 		layerBundle[0].image->drawPlain(QColor(0,0,255,255));
@@ -36,6 +37,7 @@ PaintingArea::PaintingArea(int maxWidth, int maxHeight, QWidget*parent)
 		layerBundle[1].alpha=200;
 
 		activeLayer=0;
+
 }
 
 PaintingArea::~PaintingArea(){
@@ -46,7 +48,8 @@ void PaintingArea::setLayerDimensions(int maxWidth, int maxHeight){
 		//set standart parameter
 		this->maxWidth = maxWidth;
 		this->maxHeight = maxHeight;
-		Canvas = new QImage(maxWidth,maxHeight, QImage::Format_ARGB32);
+        if(renderSettings.getFastRenderer()) Canvas = new QImage(maxWidth,maxHeight, QImage::Format_Indexed8);
+        else Canvas = new QImage(maxWidth,maxHeight, QImage::Format_ARGB32);
 
 		// Roots the widget to the top left even if resized
 		setAttribute(Qt::WA_StaticContents);
@@ -60,11 +63,14 @@ int PaintingArea::addLayer(int width, int height, int widthOffset, int heightOff
 		newLayer.widthOffset = widthOffset;
 		newLayer.heightOffset = heightOffset;
         if(type==IntelliImage::ImageType::Raster_Image) {
-				newLayer.image = new IntelliRasterImage(width,height);
+                newLayer.image = new IntelliRasterImage(width,height,renderSettings.getFastRenderer());
         }else if(type==IntelliImage::ImageType::Shaped_Image) {
-				newLayer.image = new IntelliShapedImage(width, height);
+                newLayer.image = new IntelliShapedImage(width, height, renderSettings.getFastRenderer());
 		}
-		newLayer.alpha = 255;
+
+        newLayer.alpha = 255;
+
+
 		this->layerBundle.push_back(newLayer);
 		return static_cast<int>(layerBundle.size())-1;
 }
@@ -118,7 +124,7 @@ bool PaintingArea::save(const QString &filePath, const char*fileFormat){
         this->drawLayers(true);
 
 		if(!strcmp(fileFormat,"PNG")) {
-				QImage visibleImage = Canvas->convertToFormat(QImage::Format_Indexed8);
+                QImage visibleImage = Canvas->convertToFormat(QImage::Format_Indexed8);
 				fileFormat = "png";
                 if (visibleImage.save(filePath, fileFormat)) {
 						return true;
@@ -145,21 +151,25 @@ void PaintingArea::floodFill(int r, int g, int b, int a){
 }
 
 void PaintingArea::movePositionActive(int x, int y){
-        if(Tool->getIsDrawing()){
+        if(Tool!=nullptr){
-            IntelliTool* temp = copyActiveTool();
+            if(Tool->getIsDrawing()){
-            delete this->Tool;
+                IntelliTool* temp = copyActiveTool();
-            this->Tool = temp;
+                delete this->Tool;
+                this->Tool = temp;
+            }
         }
         layerBundle[static_cast<size_t>(activeLayer)].widthOffset += x;
 		layerBundle[static_cast<size_t>(activeLayer)].heightOffset += y;
 }
 
 void PaintingArea::moveActiveLayer(int idx){
-        if(Tool->getIsDrawing()){
+          if(Tool!=nullptr){
-            IntelliTool* temp = copyActiveTool();
+              if(Tool->getIsDrawing()){
-            delete this->Tool;
+                  IntelliTool* temp = copyActiveTool();
-            this->Tool = temp;
+                  delete this->Tool;
-        }
+                  this->Tool = temp;
+              }
+          }
 		if(idx==1) {
 				this->selectLayerUp();
 		}else if(idx==-1) {
@@ -168,11 +178,13 @@ void PaintingArea::moveActiveLayer(int idx){
 }
 
 void PaintingArea::slotActivateLayer(int a){
+    if(Tool!=nullptr){
         if(Tool->getIsDrawing()){
             IntelliTool* temp = copyActiveTool();
             delete this->Tool;
             this->Tool = temp;
         }
+    }
 		if(a>=0 && a < static_cast<int>(layerBundle.size())) {
 				this->setLayerActive(a);
 		}
@@ -302,7 +314,7 @@ void PaintingArea::paintEvent(QPaintEvent*event){
 
 		QPainter painter(this);
 		QRect dirtyRec = event->rect();
-		painter.drawImage(dirtyRec, *Canvas, dirtyRec);
+        painter.drawImage(dirtyRec, *Canvas, dirtyRec);
 		update();
 }
 
@@ -333,13 +345,17 @@ void PaintingArea::selectLayerDown(){
 
 void PaintingArea::drawLayers(bool forSaving){
 		if(forSaving) {
-				Canvas->fill(Qt::GlobalColor::transparent);
+                Canvas->fill(Qt::GlobalColor::transparent);
 		}else{
-				Canvas->fill(Qt::GlobalColor::black);
+                Canvas->fill(Qt::GlobalColor::black);
 		}
 		for(size_t i=0; i<layerBundle.size(); i++) {
 				LayerObject layer = layerBundle[i];
 				QImage cpy = layer.image->getDisplayable(layer.alpha);
+                if(renderSettings.getFastRenderer()){
+                    cpy = cpy.convertToFormat(QImage::Format_ARGB32);
+                    *Canvas = Canvas->convertToFormat(QImage::Format_ARGB32);
+                }
 				QColor clr_0;
 				QColor clr_1;
 				for(int y=0; y<layer.height; y++) {
@@ -348,7 +364,7 @@ void PaintingArea::drawLayers(bool forSaving){
 						for(int x=0; x<layer.width; x++) {
 								if(layer.widthOffset+x<0) continue;
 								if(layer.widthOffset+x>=maxWidth) break;
-								clr_0=Canvas->pixelColor(layer.widthOffset+x, layer.heightOffset+y);
+                                clr_0=Canvas->pixelColor(layer.widthOffset+x, layer.heightOffset+y);
 								clr_1=cpy.pixelColor(x,y);
 								float t = static_cast<float>(clr_1.alpha())/255.f;
 								int r =static_cast<int>(static_cast<float>(clr_1.red())*(t)+static_cast<float>(clr_0.red())*(1.f-t)+0.5f);
@@ -364,6 +380,9 @@ void PaintingArea::drawLayers(bool forSaving){
 						}
 				}
 		}
+        if(renderSettings.getFastRenderer()){
+            *Canvas = Canvas->convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 void PaintingArea::createTempTopLayer(int idx){

src/Layer/PaintingArea.h

@@ -12,6 +12,7 @@
 #include "Image/IntelliShapedImage.h"
 #include "Tool/IntelliTool.h"
 #include "IntelliHelper/IntelliColorPicker.h"
+#include "IntelliHelper/IntelliRenderSettings.h"
 
 /*!
  * \brief The LayerObject struct holds all the information needed to construct a layer
@@ -203,6 +204,10 @@ private:
     int maxWidth;
     int maxHeight;
 
+<<<<<<< src/Layer/PaintingArea.h
+    IntelliRenderSettings renderSettings;
+=======
+>>>>>>> src/Layer/PaintingArea.h
     IntelliTool* Tool;
 
     std::vector<LayerObject> layerBundle;

src/Tool/IntelliTool.cpp

@@ -57,6 +57,9 @@ void IntelliTool::createToolLayer(){
 void IntelliTool::mergeToolLayer(){
 		QColor clr_0;
 		QColor clr_1;
+        if(Area->renderSettings.getFastRenderer()){
+             activeLayer->image->imageData = activeLayer->image->imageData.convertToFormat(QImage::Format_ARGB32);
+        }
 		for(int y=0; y<activeLayer->height; y++) {
 				for(int x=0; x<activeLayer->width; x++) {
 						clr_0=activeLayer->image->imageData.pixelColor(x,y);
@@ -74,6 +77,9 @@ void IntelliTool::mergeToolLayer(){
 						activeLayer->image->imageData.setPixelColor(x, y, clr_0);
 				}
 		}
+        if(Area->renderSettings.getFastRenderer()){
+            activeLayer->image->imageData = activeLayer->image->imageData.convertToFormat(QImage::Format_Indexed8);
+        }
 }
 
 void IntelliTool::deleteToolLayer(){