Optimize computeFitness further

Author: tux3

main.cpp

@@ -64,4 +64,27 @@ int main(int argc, char *argv[])
  * It's probably faster to use one hueg contiguous array rather than a multidimentional, for each color.
  * We'll just use i*width+j with i*width computed out of the inner loop.
  *
+ * Maybe in computeFitness we could convert everything to RGB instead of RGBA, so we'd always have 0xFF for the A
+ * And then blindly compute our difference of uint8_t, this way we might get vector instructions and unrolling.
+ *
+ * Stuff from EvoLisa :
+ * Can add new polygons at a random zindex instead of always on top
+ * Insert a new point in the middle of two points (then we could optimize the new point)
+ * Remove a point
+ * Can do multiple mutations at the same time. Can do no mutation at all.
+ * Maybe try to do this too, but we should avoid empty mutation loops if possible.
+ * Make it likely that we'll always have at least one mutation every loop.
+ * His probabilities of adding/removing points are per poly, so when you have a lot of polys
+ * the polys mutation loop is the only thing running, and it almost never adds/removes/moves polys, just mutate.
+ * And each poly mutated also has a point mutation loop. So it'd end up taking all the damn time with our polys.
+ * We should make it per mutation loop instead. Since we can have up to 10k polys without problem it seems better.
+ * He has separate mutation rates for everything.
+ * He has a min/max poly count and min/max point count.
+ * When mutating, accept <= changes in fitness. We accept +fitnessThreshold< currently
+ * Maybe keep the +fitnessThreshold< for adding the initial polys (until we reach minPolys)
+ * Then start mutating using <=. We shouldn't be able to get stuck doing/undoing in a loop,
+ * since the mutation process is mostly random, not optimizations.
+ * When we add a completely new poly, we'll still want to optimize its color/shape.
+ * But in the normal mutations we don't optimize the shape/color of random polys.
+ *
  */

widget.cpp

@@ -15,6 +15,7 @@
 
 unsigned Widget::height;
 unsigned Widget::width;
+QImage Widget::pic;
 
 using namespace std;
 
@@ -64,7 +65,7 @@ Widget::~Widget()
     exit(0);
 }
 
-int Widget::computeFitness(QImage& target, QRect box)
+int Widget::computeFitness(const QImage& target, const QRect box)
 {
     unsigned minx, maxx, miny, maxy;
     if (box.isNull())
@@ -81,33 +82,39 @@ int Widget::computeFitness(QImage& target, QRect box)
         maxy = miny + box.height();
     }
 
-    QVector<QRgb*> originalLines;
-    QVector<QRgb*> targetLines;
+    static QVector<QRgb*> originalLines;
+    originalLines.resize(maxy-miny);
     for (unsigned i=miny; i<maxy; i++)
-        originalLines.append((QRgb*)pic.scanLine(i));
+        originalLines[i] = ((QRgb*)pic.scanLine(i));
+    static QVector<QRgb*> targetLines;
+    targetLines.resize(maxy-miny);
     for (unsigned i=miny; i<maxy; i++)
-        targetLines.append((QRgb*)target.scanLine(i));
+        targetLines[i] = ((QRgb*)target.scanLine(i));
 
-    auto computeSlice = [&](unsigned start, unsigned end)
+    auto computeSlice = [&](const unsigned start, const unsigned end)
     {
         unsigned partFitness=0;
         for (unsigned i=start-miny; i<end-miny; i++)
         {
             // Sum of the differences of each pixel's color
             for (unsigned j=minx; j<maxx; j++)
             {
-                QRgb ocolor = originalLines.at(i)[j];
-                int oR=qRed(ocolor), oG=qGreen(ocolor), oB=qBlue(ocolor);
-                QRgb tcolor = targetLines.at(i)[j];
-                int tR=qRed(tcolor), tG=qGreen(tcolor), tB=qBlue(tcolor);
+                unsigned ocolor = originalLines.at(i)[j];
+                int oR=(ocolor>>16), oG=(ocolor>>8)&0xFF, oB=(ocolor&0xFF);
+                unsigned tcolor = targetLines.at(i)[j];
+                int tR=(tcolor>>16), tG=(tcolor>>8)&0xFF, tB=(tcolor&0xFF);
                 partFitness += abs(tR-oR)+abs(tG-oG)+abs(tB-oB);
             }
         }
         return partFitness;
     };
-    QFuture<unsigned> firstSlice = QtConcurrent::run(computeSlice, miny, maxy/2);
-    unsigned fitness = computeSlice(maxy/2, maxy);
-    fitness += firstSlice.result();
+    QFuture<unsigned> slice1 = QtConcurrent::run(computeSlice, miny, maxy/4);
+    QFuture<unsigned> slice2 = QtConcurrent::run(computeSlice, maxy/4, 2*maxy/4);
+    QFuture<unsigned> slice3 = QtConcurrent::run(computeSlice, 2*maxy/4, 3*maxy/4);
+    unsigned fitness = computeSlice(3*maxy/4, maxy);
+    fitness += slice1.result();
+    fitness += slice2.result();
+    fitness += slice3.result();
 
     return fitness;
 }

widget.h

@@ -5,6 +5,7 @@
 #include <QImage>
 #include <QVector>
 #include <QMenuBar>
+#include <stdint.h>
 
 #include "poly.h"
 
@@ -22,7 +23,7 @@ class Widget : public QWidget
 public:
     explicit Widget();
     ~Widget();
-    int computeFitness(QImage& target, QRect box=QRect());
+    static int computeFitness(const QImage& target, const QRect box=QRect());
     Poly genPoly(); // Creates a new random polygon
     static void drawPoly(QImage& target, Poly& poly);
     static void drawPoly(QImage& target, Poly& poly, QPainter& painter);
@@ -55,7 +56,7 @@ private slots:
     Ui::Widget *ui;
     QMenuBar *menuBar;
     QAction* startStopAction, *openAction, *cleanAction, *optimizeAction;
-    QImage pic;
+    static QImage pic;
     QImage generated;
     bool running;
     QVector<Poly> polys;