fixed stupid bugs in habitat, kinda stable, still not great but this might be as good as it gets with no overlapping

508312 · 508312 · commit 91b18b466229 · 2023-11-23T19:22:32.000-08:00
diff --git a/main.cpp b/main.cpp
@@ -38,21 +38,23 @@ int main( int argc, char* args[] ) {
 
     std::vector<SrcImage> src_images;
     load_images("hemtai", src_images);
-    SrcImage reconstructed = src_images[src_images.size()-1];
-    src_images.pop_back();
+    int recInd = src_images.size()-4;
+    SrcImage reconstructed = src_images[recInd];
+    std::cout << "RECONSTRUCTING " << reconstructed.path << std::endl;
+    src_images.erase(src_images.begin() + recInd);
     Habitat hbsim = Habitat(&reconstructed, &src_images);
 
     Timer t;
     t.start();
     for (int i = 0; i < 100000000; i++) {
         hbsim.step();
-
-        if (i % 10 == 0) {
-            while (SDL_PollEvent(&event)) {
-                }
+        while (SDL_PollEvent(&event)) {
+        }
+        if (i % 500 == 0) {
             sdl_draw(renderer, reconstructed, (void*)hbsim.getBestGroup().pastedData);
-            std::cout << "currently at " << i << " 100 gens took " << t.get() <<
-             "\n" << "sad is " << hbsim.getBestGroup().fitness << "\n";
+            std::cout << "currently at " << i << " 500 gens took " << t.get() <<
+             "\n" << "sad is " << hbsim.getBestGroup().fitness <<
+              " num images :" << hbsim.getBestGroup().individuals.size() << "\n";
 
             t.start();
         }
@@ -91,6 +93,7 @@ void sdl_draw(SDL_Renderer* renderer, const SrcImage& img, void* data) {
                                 SDL_TEXTUREACCESS_STREAMING, img.width, img.height);
     SDL_UpdateTexture(intermediate, NULL, data, img.pitch);
 
+    SDL_SetRenderDrawColor(renderer, 88, 88, 88, 255);
     SDL_RenderClear(renderer);
 	SDL_RenderCopy(renderer, intermediate, NULL, NULL);
 	SDL_RenderPresent(renderer);
diff --git a/main_pure_random.cpp b/main_pure_random.cpp
@@ -0,0 +1,140 @@
+#include <SDL.h>
+#include <SDL_image.h>
+
+#include <iostream>
+#include <cmath>
+
+#include <windows.h>
+#include <winuser.h>
+
+#include <random>
+
+#include "Timer.h"
+#include <rotate.h>
+#include <math.h>
+#include <execution>
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/core/matx.hpp>
+#include <opencv2/core/mat.hpp>
+#include "opencv2/opencv.hpp"
+#include <opencv2/imgcodecs.hpp>
+
+#include "utils.h"
+
+bool init_sdl(SDL_Window** window_ptr, SDL_Surface** surface_ptr, SDL_Renderer** renderer_ptr,
+                   int x_win_res, int y_win_res);
+void sdl_draw(SDL_Renderer* renderer, const SrcImage& img);
+
+int main( int argc, char* args[] ) {
+    SDL_Window* window = NULL;
+    SDL_Surface* screenSurface = NULL;
+    SDL_Renderer* renderer = NULL;
+    SDL_Event event;
+    init_sdl(&window, &screenSurface, &renderer, 400, 400);
+    IMG_Init(IMG_INIT_PNG);
+
+    std::vector<SrcImage> src_images;
+    load_images("imgsimple", src_images);
+    int recInd = src_images.size()-1;
+    SrcImage reconstructed = src_images[recInd];
+    reconstructed.data = new uint8_t[reconstructed.width * reconstructed.height * 4];
+    memset(reconstructed.data, 0xFFFFFF00, reconstructed.width * reconstructed.height*4);
+    RotatePixel_t *pPstBase = static_cast<RotatePixel_t*>((void*)reconstructed.data);
+    RotatePixel_t *pDstBase = static_cast<RotatePixel_t*>((void*)src_images[recInd].data);
+
+    Timer t;
+    t.start();
+    for (int i = 0; i < 100000000; i++) {
+        int index = rand()%(src_images.size());
+        if (index == recInd) {
+            continue;
+        }
+        RotatePixel_t *pSrcBase = static_cast<RotatePixel_t*>((void*)src_images[index].data);
+        int best_sad = INT_MAX;
+        int bestX;
+        int bestY;
+        float bestA;
+        float bestS;
+        for (int j = 0; j < 100; j++) {
+            int fDstCX = rand()%(src_images[recInd].width);
+            int fDstCY = rand()%(src_images[recInd].height);
+            float fAngle = rand()%(314) / 100.0;
+            float fScale = (rand()%(1500) + 1) / 1000.0;
+            sadPair genQuality = RotateDrawClipSad(
+                    pDstBase, src_images[recInd].width, src_images[recInd].height, src_images[recInd].pitch,
+                    pSrcBase, src_images[index].width, src_images[index].height, src_images[index].pitch,
+                    pPstBase,
+                    fDstCX, fDstCY,
+                    0, 0,
+                    fAngle, fScale );
+            if (genQuality.sad1 < genQuality.sad2 && genQuality.sad1 < best_sad) {
+                best_sad = genQuality.sad1;
+                bestX = fDstCX;
+                bestY = fDstCY;
+                bestA = fAngle;
+                bestS = fScale;
+            }
+        }
+
+        if (best_sad != INT_MAX) {
+            RotateDrawClip(
+                    pPstBase, src_images[recInd].width, src_images[recInd].height, src_images[recInd].pitch,
+                    pSrcBase, src_images[index].width, src_images[index].height, src_images[index].pitch,
+                    bestX, bestY,
+                    0, 0,
+                    bestA, bestS );
+        }
+        if (i % 100 == 0) {
+            while (SDL_PollEvent(&event)) {
+                }
+            sdl_draw(renderer, reconstructed);
+            std::cout << "currently at " << i << " 100 gens took " << t.get() <<
+             "\n" << "sad is " << compute_sad(src_images[0].data,
+                                                    reconstructed.data,
+                                                    reconstructed.width * reconstructed.height * 4) << "\n";
+
+            t.start();
+        }
+    }
+
+    return 0;
+}
+
+
+bool init_sdl(SDL_Window** window_ptr, SDL_Surface** surface_ptr, SDL_Renderer** renderer_ptr,
+            int x_win_res, int y_win_res) {
+    if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
+        printf( "SDL could not initialize! SDL_Error: %s\n", SDL_GetError() );
+        return false;
+    }
+
+    *window_ptr = SDL_CreateWindow( "imageVimage", SDL_WINDOWPOS_UNDEFINED,
+                               SDL_WINDOWPOS_UNDEFINED, x_win_res,
+                                y_win_res, SDL_WINDOW_SHOWN );
+    if( *window_ptr == NULL ) {
+        printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
+        return false;
+    }
+
+    *renderer_ptr = SDL_CreateRenderer( *window_ptr, -1, SDL_RENDERER_ACCELERATED );
+
+    SDL_SetRenderDrawColor( *renderer_ptr, 0xFF, 0xFF, 0xFF, 0xFF );
+
+    *surface_ptr = SDL_GetWindowSurface( *window_ptr );
+
+    return true;
+}
+
+void sdl_draw(SDL_Renderer* renderer, const SrcImage& img) {
+    SDL_Texture *intermediate = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
+                                SDL_TEXTUREACCESS_STREAMING, img.width, img.height);
+    SDL_UpdateTexture(intermediate, NULL, (void*)img.data, 4 * img.width);
+
+    SDL_RenderClear(renderer);
+	SDL_RenderCopy(renderer, intermediate, NULL, NULL);
+	SDL_RenderPresent(renderer);
+
+    SDL_Delay(0);
+    SDL_DestroyTexture(intermediate);
+}
diff --git a/src/Habitat.cpp b/src/Habitat.cpp
@@ -5,6 +5,7 @@
 #include <random>
 #include <math.h>
 #include <execution>
+#include <iostream>
 
 bool cmp(const PopulationGroup& a, const PopulationGroup& b) {
 	return a.fitness < b.fitness;
@@ -19,25 +20,34 @@ Habitat::Habitat(const SrcImage* reconstructionImage, const std::vector<SrcImage
     mReconstructionImage = reconstructionImage;
     mSettings = settings;
     init_pop();
+
+    /*
+    std::vector<int> indexes;
+    for(int i=0; i<mSettings.popSize; i++) {
+        indexes.push_back(i);
+    }
+
+    std::for_each(std::execution::par_unseq, indexes.begin(), indexes.end(), [&](int i) {
+        drawComputeFit(mPopulation[i]);
+    }); */
 }
 
 void Habitat::step() {
     std::sort(mPopulation.begin(), mPopulation.end(), cmp);
 
     std::vector<int> indexes;
     for(int i=0; i<mSettings.popSize; i++) {
-		if(i>mSettings.popSize - ceil(mSettings.popSize * mSettings.reroll)) {
+		if(i>(mSettings.popSize - ceil(mSettings.popSize * mSettings.reroll) - 1)) {
             indexes.push_back(i);
-    }
+        }
     }
 
     std::for_each(std::execution::par_unseq, indexes.begin(), indexes.end(), [&](int i) {
         if(rand()%100 < mSettings.crossoverChance) {
-            int ind1 = rand() % mSettings.popSize;
-            int ind2 = rand() % mSettings.popSize;
+            int ind1 = rand() % (int)(mSettings.popSize - ceil(mSettings.popSize * mSettings.reroll) - 1);
+            int ind2 = rand() % (int)(mSettings.popSize - ceil(mSettings.popSize * mSettings.reroll) - 1);
             crossover(mPopulation[ind1], mPopulation[ind2], mPopulation[i]);
-        }
-        else {
+        } else {
             mutate(mPopulation[i]);
         }
 
@@ -53,7 +63,7 @@ void Habitat::init_pop() {
     mPopulation.clear();
     for (int i = 0; i < mSettings.popSize; i++) {
         mPopulation.push_back(PopulationGroup{});
-        mPopulation[i].pastedData = new uint8_t[mReconstructionImage->pitch*mReconstructionImage->height];
+        mPopulation[i].pastedData = new uint8_t[mReconstructionImage->width*mReconstructionImage->height*4];
         mPopulation[i].fitness = UINT32_MAX;
         for (int j = 0; j < mSettings.imgCount; j++) {
             mPopulation[i].individuals.push_back(random_individual());
@@ -62,11 +72,11 @@ void Habitat::init_pop() {
 }
 
 void Habitat::drawComputeFit(PopulationGroup& grp) {
-    memset(grp.pastedData, 0xFFFFFF00, mReconstructionImage->width*mReconstructionImage->height);
+    memset(grp.pastedData, 0xFF, mReconstructionImage->width*mReconstructionImage->height*4);
 
     RotatePixel_t *pDstBase = static_cast<RotatePixel_t*>((void*)grp.pastedData);
 
-    for (int i = 0; i < mSettings.imgCount; i++) {
+    for (int i = 0; i < grp.individuals.size(); i++) {
         const SrcImage* pImg = grp.individuals[i].img;
         RotatePixel_t *pSrcBase = static_cast<RotatePixel_t*>((void*)pImg->data);
         RotateDrawClip(pDstBase, mReconstructionImage->width, mReconstructionImage->height, mReconstructionImage->pitch,
@@ -77,27 +87,56 @@ void Habitat::drawComputeFit(PopulationGroup& grp) {
     }
 
     grp.fitness = compute_sad(grp.pastedData, mReconstructionImage->data,
-                               mReconstructionImage->pitch*mReconstructionImage->height);
+                               mReconstructionImage->width*mReconstructionImage->height*4);
 }
 
 void Habitat::crossover(const PopulationGroup& grpA, const PopulationGroup& grpB, PopulationGroup& grpC) {
-    for (int i = 0; i < mSettings.imgCount; i++) {
+    grpC.individuals.clear();
+    for (int i = 0; i < std::min(grpA.individuals.size(),
+                                grpB.individuals.size()); i++) {
         if (rand()%2) {
-            grpC.individuals[i] = grpA.individuals[i];
+            grpC.individuals.push_back(grpA.individuals[i]);
         } else {
-            grpC.individuals[i] = grpB.individuals[i];
+            grpC.individuals.push_back(grpB.individuals[i]);
         }
     }
 }
 
 void Habitat::mutate(PopulationGroup& grp) {
-    for (int i = 0; i < mSettings.imgCount; i++) {
-        grp.individuals[i].angle += rand()%50 / 100.0;
+    int roll = rand()%100;
+    if (roll < 60) {
+        mutateAdjust(grp);
+    } else if (roll < 85) {
+        mutateAdd(grp);
+    } else {
+        mutateRemove(grp);
+    }
+}
+
+void Habitat::mutateAdd(PopulationGroup& grp) {
+    grp.individuals.push_back(random_individual());
+}
+
+void Habitat::mutateRemove(PopulationGroup& grp) {
+    if (grp.individuals.size() == 0)
+        return;
+
+    int ind = rand()%grp.individuals.size();
+    grp.individuals.erase(grp.individuals.begin() + ind);
+}
+
+void Habitat::mutateAdjust(PopulationGroup& grp) {
+    //for (int i = 0; i < grp.individuals.size(); i++) {
+    {
+        int i = rand()%grp.individuals.size();
+        // ADD CLOSEST IMAGES
+
+        grp.individuals[i].angle += rand()%50 / 100.0 * std::pow(-1, rand()%2);
         grp.individuals[i].x += rand()%(mReconstructionImage->width) * 0.1 * std::pow(-1, rand()%2);
         grp.individuals[i].y += rand()%(mReconstructionImage->height) * 0.1 * std::pow(-1, rand()%2);
-        float randScale = (rand()%((int)(100*mSettings.maxScale - 100*mSettings.minScale))
-                                                + (100*mSettings.minScale)) / 100.0;
-        grp.individuals[i].scale += randScale * 0.3 * std::pow(-1, rand()%2);
+        float randScale = (rand()%((int)(1000*mSettings.maxScale - 1000*mSettings.minScale))
+                                                + (1000*mSettings.minScale)) / 1000.0;
+        grp.individuals[i].scale += randScale * 0.1 * std::pow(-1, rand()%2);
         if (grp.individuals[i].scale < mSettings.minScale) {
             grp.individuals[i].scale = mSettings.minScale;
         } else if (grp.individuals[i].scale > mSettings.maxScale) {
@@ -116,14 +155,15 @@ Individual Habitat::random_individual() {
     float angle;
     float scale;
 
-    newIndiv.imgID = rand()%mRefImages->size();
+    newIndiv.imgID = rand()%(mRefImages->size());
     newIndiv.img = &(*mRefImages)[newIndiv.imgID];
 
-    newIndiv.x = rand()%(mReconstructionImage->width - 10) + 5;
-    newIndiv.y = rand()%(mReconstructionImage->height - 10) + 5;
+    newIndiv.x = rand()%(mReconstructionImage->width);
+    newIndiv.y = rand()%(mReconstructionImage->height);
     newIndiv.angle = rand()%(314) / 100.0;
-    newIndiv.scale = (rand()%((int)(100*mSettings.maxScale - 100*mSettings.minScale))
-                                                + (100*mSettings.minScale)) / 100.0;
+    newIndiv.scale = (rand()%((int)(1000*mSettings.maxScale - 1000*mSettings.minScale))
+                                                + (1000*mSettings.minScale)) / 1000.0;
+    //newIndiv.scale = mSettings.minScale;
 
     return newIndiv;
 
diff --git a/src/Habitat.h b/src/Habitat.h
@@ -4,7 +4,7 @@
 #include "utils.h"
 #include "vector"
 
-#define SETTINGS_DEFAULT Settings{200, 20, 0.75, 90, 0.2, 2}
+#define SETTINGS_DEFAULT Settings{12, 30, 0.7, 70, 0.001, 1}
 
 struct Individual {
     const SrcImage* img;
@@ -53,6 +53,9 @@ class Habitat
         void crossover(const PopulationGroup& grpA, const PopulationGroup& grpB, PopulationGroup& grpC);
         void drawComputeFit(PopulationGroup& grp);
         void mutate(PopulationGroup& grp);
+        void mutateAdjust(PopulationGroup& grp);
+        void mutateAdd(PopulationGroup& grp);
+        void mutateRemove(PopulationGroup& grp);
 };
 
 #endif // HABITAT_H
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -86,6 +86,17 @@ int compute_sad(uint8_t* image, uint8_t* target, size_t num_bytes) {
     return sum;
 }
 
+int compute_sse_naive(uint8_t* image, uint8_t* target, size_t num_bytes) {
+    int sum = 0;
+
+    for (int i = 0; i < num_bytes; i++) {
+        int dif = image[i] - target[i];
+        sum += dif * dif;
+    }
+
+    return sum;
+}
+
 void simd_memcpy(uint8_t* dst, uint8_t* src, size_t num_bytes) {
     // should i convert this to uint32_t ?
     // I think benchmarks did not show significant improvement
diff --git a/src/utils.h b/src/utils.h
@@ -5,7 +5,7 @@
 #include <vector>
 
 //TODO: do this better
-#define PIXELS_PER_IMAGE 50000.0
+#define PIXELS_PER_IMAGE 30000.0
 
 /* Img utils */
 typedef struct SrcImage {
@@ -22,6 +22,7 @@ void load_images(std::string path, std::vector<SrcImage>&images);
 /* Math utils */
 int compute_sad(uint8_t* image, uint8_t* target, size_t num_bytes);
 int compute_sad_naive(uint8_t* image, uint8_t* target, size_t num_bytes);
+int compute_sse_naive(uint8_t* image, uint8_t* target, size_t num_bytes);
 void simd_memcpy(uint8_t* dst, uint8_t* src, size_t num_bytes);
 
 #endif // UTILS_H
