Iniciando o repositório

quadtree.cpp

+#include <iostream>
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+#include <string.h>
+#include <cmath>
+
+using namespace std;
+
+#define WINDOW_WIDTH 900
+#define WINDOW_HEIGHT 514
+
+float RANGE = 2.0f;
+bool showBox = false;
+bool imprimirCompactado = false;
+int nivelCompacto = 5;
+int frameTime;
+int countPixel;
+
+TTF_Font* fonte;
+//uint32 pixelFormat;
+
+
+void GetPixelColor(const SDL_Surface* pSurface, const int X, const int Y, Uint8 &R, Uint8 &G, Uint8 &B) {
+  // Bytes per pixel
+  const Uint8 Bpp = pSurface->format->BytesPerPixel;
+
+  Uint8* pPixel = (Uint8*)pSurface->pixels + Y * pSurface->pitch + X * Bpp;
+
+  Uint32 PixelData = *(Uint32*)pPixel;
+
+  SDL_GetRGB(PixelData, pSurface->format, &R, &G, &B);
+}
+
+class quadtree {
+
+    public:
+
+        quadtree* noroeste;
+        quadtree* nordeste;
+        quadtree* sudoeste;
+        quadtree* sudeste;
+
+        ~quadtree() {
+            delete noroeste;
+            delete nordeste;
+            delete sudoeste;
+            delete sudeste;
+        }
+
+        
+        int x;
+        int y;
+
+        int nivel;
+
+        Uint8 r = 0;
+        Uint8 g = 0;
+        Uint8 b = 0;
+
+        int x1 = 0;
+        int y1 = 0;
+        int x2 = 0;
+        int y2 = 0;
+
+    float range = 0;
+
+    float rangeRed() {
+        // return pow((nordeste->r - sudoeste->r) + (noroeste->r - sudeste->r),2);
+        float ro = (nordeste->r - sudoeste->r);
+        float rl =  (noroeste->r - sudeste->r);
+        if (ro < 0)
+            ro *= -1;
+        if (rl < 0)
+            rl *= -1;
+
+        return pow(ro + rl, 2);
+
+    }
+
+    float rangeBlue() {
+        // return pow((nordeste->b - sudoeste->b) + (noroeste->b - sudeste->b),2);
+        float bo = (nordeste->b - sudoeste->b);
+        float bl =  (noroeste->b - sudeste->b);
+        if (bo < 0)
+            bo *= -1;
+        if (bl < 0)
+            bl *= -1;
+
+        return pow(bo + bl, 2);
+    }
+    float rangeGreen() {
+        // return pow((nordeste->g - sudoeste->g) + (noroeste->g - sudeste->g),2);
+        float go = (nordeste->g - sudoeste->g);
+        float gl =  (noroeste->g - sudeste->g);
+        if (go < 0)
+            go *= -1;
+        if (gl < 0)
+            gl *= -1;
+
+        return pow(go + gl, 2);
+    }
+
+
+
+    float getRed() {
+        return ((nordeste->r + noroeste->r) + (sudoeste->r + sudeste->r)) / 4;
+    }
+    float getGreen() {
+        return (nordeste->g + noroeste->g + sudoeste->g + sudeste->g) /4;
+    }
+
+    float getBlue() {
+        return (nordeste->b + noroeste->b + sudoeste->b + sudeste->b) /4;
+    }
+
+    static quadtree* create(SDL_Surface* img, int x1, int x2, int y1, int y2, int nivel) {
+        int xt = x2 / 2;
+        int yt =  y2 / 2;
+        quadtree* qt = new quadtree();
+
+        qt->x1 = x1;
+        qt->y1 = y1;
+        qt->x2 = x2;
+        qt->y2 = y2;
+        qt->nivel = nivel;
+        nivel++;
+        
+        if (xt > 1) {
+            
+            qt->noroeste = create(img, x1,xt , y1, yt, nivel);
+            qt->nordeste = create(img, x1 + xt , xt  , y1, yt, nivel);
+
+            qt->sudoeste = create(img, x1, xt, y1 + yt , yt, nivel);
+            qt->sudeste = create(img, x1 + xt , xt, y1 + yt, yt, nivel);
+
+
+            qt->r =  qt->getRed();
+            qt->g =  qt->getGreen();
+            qt->b =  qt->getBlue();
+
+        } else {
+            qt->noroeste = new quadtree();
+            GetPixelColor(img, x1 , y1, qt->noroeste->r, qt->noroeste->g, qt->noroeste->b );
+            qt->noroeste->x = x1;
+            qt->noroeste->y = y1;
+            qt->noroeste->nivel = nivel;
+
+            qt->nordeste = new quadtree();
+            GetPixelColor(img, x1+1, y1, qt->nordeste->r, qt->nordeste->g, qt->nordeste->b);
+            qt->nordeste->x = x1+1;
+            qt->nordeste->y = y1;
+            qt->nordeste->nivel = nivel;
+
+            qt->sudoeste = new quadtree();
+            GetPixelColor(img, x1, y1 + 1, qt->sudoeste->r, qt->sudoeste->g, qt->sudoeste->b);
+            qt->sudoeste->x = x1;
+            qt->sudoeste->y = y1+1;
+            qt->sudoeste->nivel = nivel;
+            
+            qt->sudeste = new quadtree();
+            GetPixelColor(img, x1 + 1, y1 +1, qt->sudeste->r, qt->sudeste->g, qt->sudeste->b);
+            qt->sudeste->x = x1 + 1;
+            qt->sudeste->y = y1 + 1;
+            qt->sudeste->nivel = nivel;
+
+            qt->r =  qt->getRed();
+            qt->g =  qt->getGreen();
+            qt->b =  qt->getBlue();
+
+        }
+        return qt;
+    }
+
+    static void makeRange(quadtree* qt) {
+        if (qt->noroeste->noroeste != nullptr) {
+            makeRange(qt->noroeste);
+            makeRange(qt->nordeste);
+            makeRange(qt->sudoeste);
+            makeRange(qt->sudeste);
+            qt->range = qt->noroeste->range + qt->nordeste->range +qt->sudoeste->range +qt->sudeste->range;
+            float  r = sqrt(qt->rangeBlue() + qt->rangeRed() + qt->rangeGreen()); 
+            if (r < 0)
+                r = r * -1;
+            qt->range += r;
+        }
+        else {
+            qt->range = sqrt(qt->rangeBlue() + qt->rangeRed() + qt->rangeGreen());
+            if (qt->range < 0)
+                qt->range = qt->range * -1;
+        }
+        
+    
+    }
+
+};
+
+
+void printar(quadtree* qt, SDL_Surface* img, SDL_Renderer *renderer, int &pixels) {
+    pixels++;
+    if (qt->nordeste != nullptr) {
+        printar(qt->nordeste, img, renderer, pixels);
+        printar(qt->noroeste, img, renderer, pixels);
+        printar(qt->sudoeste, img, renderer, pixels);
+        printar(qt->sudeste, img, renderer, pixels);
+    }
+    else {
+
+        SDL_SetRenderDrawColor(renderer, qt->r, qt->g, qt->b, SDL_ALPHA_TRANSPARENT);
+        SDL_RenderDrawPoint(renderer, qt->x, qt->y);
+    }
+}
+
+void printarRange(quadtree* qt, SDL_Surface* img, SDL_Renderer *renderer, int &pixels) {
+    
+    if ((qt->range < RANGE)) {
+        pixels++;
+        SDL_SetRenderDrawColor(renderer, qt->r, qt->g, qt->b, 255);
+        if (qt->x2 > 0) {
+            SDL_Rect rect;
+            rect.x = qt->x1; rect.y = qt->y1;
+            rect.w = qt->x2 ; rect.h = qt->y2;
+            SDL_RenderFillRect(renderer,&rect);
+        }
+        else
+            SDL_RenderDrawPoint(renderer, qt->x, qt->y);
+
+
+        //Imprimir box
+        if (qt->x2 >= 4 && showBox) {
+            SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_TRANSPARENT);
+            SDL_RenderDrawLine(renderer,qt->x1,qt->y1,qt->x1+qt->x2, qt->y1);
+            SDL_RenderDrawLine(renderer,qt->x1 + qt->x2,qt->y1,qt->x1+qt->x2, qt->y1 + qt->y2);
+            SDL_RenderDrawLine(renderer,qt->x1 + qt->x2,qt->y1 + qt->y2,qt->x1, qt->y1 + qt->y2);
+            SDL_RenderDrawLine(renderer,qt->x1,qt->y1 + qt->y2,qt->x1, qt->y1);
+        }
+        
+    }
+    else {
+        printarRange(qt->nordeste, img, renderer, pixels);
+        printarRange(qt->noroeste, img, renderer, pixels);
+        printarRange(qt->sudoeste, img, renderer, pixels);
+        printarRange(qt->sudeste, img, renderer, pixels);
+    }
+}
+
+void cutRange(quadtree* qt) {
+    if ((qt->range < RANGE)) {
+        delete qt->noroeste;
+        delete qt->nordeste;
+        delete qt->sudoeste;
+        delete qt->sudeste;
+    }
+    else {
+        if (qt->nordeste != nullptr) {
+            cutRange(qt->noroeste);
+            cutRange(qt->nordeste);
+            cutRange(qt->sudoeste);
+            cutRange(qt->sudeste);
+        }
+    }
+}
+
+void printarCompacto(quadtree* qt, SDL_Surface* img, SDL_Renderer *renderer, int &pixels) {
+    pixels++;
+    if (qt->nivel == nivelCompacto ) {
+        SDL_SetRenderDrawColor(renderer, qt->r, qt->g, qt->b, 0);
+        for (int i = qt->x1; i < (qt->x2 + qt->x1); i++) {
+            for (int j = qt->y1; j < (qt->y2 + qt->y1); j++) {
+                
+                SDL_RenderDrawPoint(renderer, i, j);
+            }
+        } 
+        
+    }
+    else {
+        printarCompacto(qt->nordeste, img, renderer, pixels);
+        printarCompacto(qt->noroeste, img, renderer, pixels);
+        printarCompacto(qt->sudoeste, img, renderer, pixels);
+        printarCompacto(qt->sudeste, img, renderer, pixels);
+    }
+    
+}
+
+
+/**
+ * Imprimir a informações de legenda no canto da tela
+ * Range, Frametime e quantidade de pixels 
+ * 
+ * @param renderer 
+ */
+void printarLegendas(SDL_Renderer* renderer) {
+    
+    SDL_Color White = {255, 255, 255};
+    string text = "RANGE(Cima,Baixo): " + to_string(RANGE) +
+    "   Mostrar Box (s): " + to_string(showBox) +
+    "      Pixels na Tela:" + to_string(countPixel) +
+    "      Frametime:" + to_string(frameTime) + "ms";
+    SDL_Surface* surfaceMessage = TTF_RenderText_Blended_Wrapped(fonte,text.c_str(), White, 340); 
+    SDL_Texture* Message = SDL_CreateTextureFromSurface(renderer, surfaceMessage);
+
+    SDL_Rect Message_rect;
+    Message_rect.x = 530;
+    Message_rect.y = 50;
+    Message_rect.w = 340;
+    Message_rect.h = 90;
+    SDL_RenderCopy(renderer, Message, NULL, &Message_rect);
+    SDL_FreeSurface(surfaceMessage);
+    SDL_DestroyTexture(Message);
+}
+
+
+void drawPincel(SDL_Surface *img, int x, int y, SDL_PixelFormat* format) {
+    SDL_Rect rect;
+
+    rect.x = x -10;
+    if (rect.x < 0)
+        rect.x = 0;
+    rect.y = y-10;
+    if (rect.y < 0)
+        rect.y = 0;
+    
+    rect.w = 20;
+    
+    rect.h = 20;
+
+    if (SDL_FillRect(img, &rect,SDL_MapRGB(format,168,32,12) ) < 0)
+        cout << "Erro no FILL RECT" << endl;
+
+}
+
+
+
+int main(int argc, char* argv[]) {
+
+    SDL_Event event;
+    SDL_Renderer *renderer;
+    SDL_Window *window;
+    int i;
+
+    // Iniciando o SDL
+    SDL_Init(SDL_INIT_VIDEO);
+    SDL_CreateWindowAndRenderer(WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer);
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
+    SDL_RenderClear(renderer);
+    
+    
+
+    //Carregando a imagem para a memória
+    SDL_Surface* img = SDL_LoadBMP("img.bmp");
+    int size_y = img->h;
+    int size_x = img->w;
+
+    // Criando a Quadtree e fazendo o calculo da variação da imagem
+    quadtree* qt = quadtree::create(img, 0, size_x , 0, size_y, 1 );
+    quadtree::makeRange(qt);
+
+    cout << "qt->range:" << qt->range << endl;
+    cout << "qt->noroeste:" << qt->range << endl;
+    cout << "qt->nordeste:" << qt->nordeste << endl;
+    cout << "qt->sudoeste:" << qt->sudoeste << endl;
+    cout << "qt->sudeste:" << qt->sudeste << endl;
+
+    //Inicializando o SDL_ttf
+    if(TTF_Init() == -1){
+        std::cout << "Erro ao inicializar SDL2_ttf: " << TTF_GetError() << std::endl; 
+        return -1;
+    }
+    fonte = TTF_OpenFont("./ubuntu.ttf", 24);
+
+    // Inicializando variáveis
+    countPixel = 0;
+    bool sair = false;
+
+    SDL_Surface *dSurface = SDL_CreateRGBSurface(0, 512,512,32, 0,0,0,0);
+    SDL_SetSurfaceBlendMode(dSurface, SDL_BLENDMODE_BLEND);
+    SDL_Rect imgRect;
+    imgRect.x = 0;
+    imgRect.y = 0;
+    imgRect.w = 511;
+    imgRect.h = 511;
+
+    bool drawing = false;
+    while (!sair) {
+        countPixel = 0;
+        int start = SDL_GetTicks();
+        SDL_SetRenderDrawColor(renderer, 60, 60, 60, 0); //Cinza
+        SDL_RenderClear(renderer);
+        while (SDL_PollEvent(&event)) {
+
+            if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
+                drawing = true;
+            }
+            if (event.type == SDL_MOUSEBUTTONUP && event.button.button == SDL_BUTTON_LEFT) {
+                drawing = false;
+            }
+            if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_UP) {
+                if (RANGE < 100.0f) {
+                    RANGE += 0.03f;
+                }
+                if (imprimirCompactado)
+                    if (nivelCompacto < 10)
+                        nivelCompacto++;
+            }
+            if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_DOWN) {
+                if (RANGE > 0.04f)
+                    RANGE -= 0.03f;
+
+                if (imprimirCompactado)
+                    if (nivelCompacto > 2)
+                        nivelCompacto--;
+            }
+            if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_s) {
+                showBox = !showBox;
+            }
+            if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_m) {
+                imprimirCompactado = !imprimirCompactado;
+            }
+            if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_c) {
+                cutRange(qt);
+            }
+            if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE) {
+                sair = true;
+            }
+            if (event.type == SDL_QUIT) {
+                sair = true;
+            }
+        }
+
+        //SDL_BlitSurface(dSurface,&imgRect,img,&imgRect);
+
+        if (drawing) {
+            drawPincel(img, event.button.x, event.button.y, dSurface->format);
+            delete qt;
+            qt = quadtree::create(img, 0, size_x , 0, size_y, 1 );
+            quadtree::makeRange(qt);
+        }
+
+        
+        if (!imprimirCompactado)
+            if (RANGE > 0.04f)
+                printarRange(qt, img, renderer, countPixel);
+            else
+                printar(qt,img, renderer, countPixel);
+        else
+            printarCompacto(qt, img, renderer, countPixel);
+
+        printarLegendas(renderer);
+        SDL_RenderPresent(renderer);
+        frameTime = SDL_GetTicks() - start;
+    }
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}
\ No newline at end of file