private void drawFractalBruteForce(int image_size) {

        double size = fractal.getSize();

        double size_2_x = size * 0.5;
        double size_2_y = (size * height_ratio) * 0.5;
        double temp_size_image_size_x = size / image_size;
        double temp_size_image_size_y = (size * height_ratio) / image_size;

        double temp_xcenter_size = fractal.getXCenter() - size_2_x;
        double temp_ycenter_size = fractal.getYCenter() + size_2_y;

        int pixel_percent = image_size * image_size / 100;

        //Better brute force
        int x, y, loc, counter = 0;

        int condition = image_size * image_size;

        do {

            loc = normal_drawing_algorithm_pixel.getAndIncrement();

            if(loc >= condition) {
                break;
            }

            x = loc % image_size;
            y = loc / image_size;

            image_iterations[loc] = fractal.calculateFractal(new Complex(temp_xcenter_size + temp_size_image_size_x * x, temp_ycenter_size - temp_size_image_size_y * y));
            rgbs[loc] = getColor(image_iterations[loc]);

            drawing_done++;
            counter++;

            if(counter % image_size == 0 && drawing_done / pixel_percent >= 1) {
                update(drawing_done);
                thread_calculated += drawing_done;
                drawing_done = 0;
            }

        } while(true);


        /*int tile = 6;
         int image_size_tile = image_size / tile, tempx, tempy;
         condition = (image_size_tile) * (image_size_tile);
        
         int color, loc2;
        
         do {
        
         loc = normal_drawing_algorithm_pixel.getAndIncrement();
        
         if(loc >= condition) {
         break;
         }      
        
        
         tempx = loc % image_size_tile;
         tempy = loc / image_size_tile;
        
         x = tempx * tile;
         y = tempy * tile;
        
         loc2 = y * image_size + x;
         temp_result = image_iterations[loc2] = fractal.calculateFractal(new Complex(temp_xcenter_size + temp_size_image_size * x, temp_ycenter_size - temp_size_image_size * y));
         color = rgbs[loc2] = getColor(temp_result);
        
         tempx = tempx == image_size_tile - 1 ? image_size : x + tile;
         tempy = tempy == image_size_tile - 1 ? image_size : y + tile;
        
         for(int i = y; i < tempy; i++) {
         for(int j = x, loc3 = i * image_size + j; j < tempx; j++, loc3++) {
         rgbs[loc3] = color; 
         }
         }
        
        
        
         } while(true);*/
        thread_calculated += drawing_done;

        //Brute force
             /*double temp = temp_xcenter_size + temp_size_image_size * FROMx;
         double temp_y0 = temp_ycenter_size - temp_size_image_size * FROMy;
         double temp_x0 = temp;
        
         for(int y = FROMy; y < TOy; y++, temp_y0 += temp_size_image_size) {
         for(int x = FROMx, loc = y * image_size + x; x < TOx; x++, temp_x0 += temp_size_image_size, loc++) {
        
         temp_result = image_iterations[loc] = fractal.calculateFractal(new Complex(temp_x0, temp_y0));
         rgbs[loc] = getColor(temp_result);
        
        
         drawing_done++;
        
         }
        
         if(drawing_done / pixel_percent >= 1) {
         update(drawing_done);
         thread_calculated += drawing_done;
         drawing_done = 0;
         }
        
         temp_x0 = temp;
        
         }
        
         thread_calculated += drawing_done;*/
        if(bump_map || fake_de || rainbow_palette) {
            try {
                post_processing_sync.await();
            }
            catch(InterruptedException ex) {

            }
            catch(BrokenBarrierException ex) {

            }

            applyPostProcessing(image_size);

        }
    }