private void drawFastJuliaAntialiasedBruteForce(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 x, y, loc;
        int color;

        double temp_result;
        double temp_x0, temp_y0;

        int red, green, blue;

        int condition = image_size * image_size;

        double antialiasing_x[] = {-x_antialiasing_size, x_antialiasing_size, x_antialiasing_size, -x_antialiasing_size,
            -x_antialiasing_size, x_antialiasing_size, 0, 0,
            -x_antialiasing_size_x2, -x_antialiasing_size_x2, -x_antialiasing_size_x2, 0, 0, x_antialiasing_size_x2, x_antialiasing_size_x2, x_antialiasing_size_x2,
            -x_antialiasing_size_x2, -x_antialiasing_size_x2, -x_antialiasing_size, -x_antialiasing_size, x_antialiasing_size, x_antialiasing_size, x_antialiasing_size_x2, x_antialiasing_size_x2};
        double antialiasing_y[] = {-y_antialiasing_size, -y_antialiasing_size, y_antialiasing_size, y_antialiasing_size,
            0, 0, -y_antialiasing_size, y_antialiasing_size,
            -y_antialiasing_size_x2, 0, y_antialiasing_size_x2, -y_antialiasing_size_x2, y_antialiasing_size_x2, -y_antialiasing_size_x2, 0, y_antialiasing_size_x2,
            -y_antialiasing_size, y_antialiasing_size, -y_antialiasing_size_x2, y_antialiasing_size_x2, -y_antialiasing_size_x2, y_antialiasing_size_x2, -y_antialiasing_size, y_antialiasing_size};

        int supersampling_num = (filters_options_vals[MainWindow.ANTIALIASING] == 0 ? 4 : 8 * filters_options_vals[MainWindow.ANTIALIASING]);
        double temp_samples = supersampling_num + 1;

        do {

            loc = normal_drawing_algorithm_pixel.getAndIncrement();

            if(loc >= condition) {
                break;
            }

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

            temp_x0 = temp_xcenter_size + temp_size_image_size_x * x;
            temp_y0 = temp_ycenter_size - temp_size_image_size_y * y;

            image_iterations_fast_julia[loc] = fractal.calculateJulia(new Complex(temp_x0, temp_y0));
            color = getColor(image_iterations_fast_julia[loc]);

            red = (color >> 16) & 0xff;
            green = (color >> 8) & 0xff;
            blue = color & 0xff;

            //Supersampling
            for(int i = 0; i < supersampling_num; i++) {
                temp_result = fractal.calculateJulia(new Complex(temp_x0 + antialiasing_x[i], temp_y0 + antialiasing_y[i]));
                color = getColor(temp_result);

                red += (color >> 16) & 0xff;
                green += (color >> 8) & 0xff;
                blue += color & 0xff;
            }

            rgbs[loc] = 0xff000000 | (((int)(red / temp_samples + 0.5)) << 16) | (((int)(green / temp_samples + 0.5)) << 8) | ((int)(blue / temp_samples + 0.5));

        } while(true);

        if(bump_map || fake_de || rainbow_palette) {
            try {
                post_processing_sync.await();
            }
            catch(InterruptedException ex) {

            }
            catch(BrokenBarrierException ex) {

            }

            applyPostProcessingFastJulia(image_size);
        }
    }