proof of concept fractal animation generation

//This paste contains two files. Fraktale.java and BildBerechnung.java. The whole file is for testing purposes only and does not show "clean code" in any way. Goal of this proof of concept is to test ExecutorService to generate .png files which show a animation of "fractals".

import javax.swing.JFrame;
import javax.swing.Timer;
import javax.swing.WindowConstants;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Fraktale extends JFrame implements ActionListener {

    public static int K = 2;
    public static int WIDTH = 960 * K;
    public static int HEIGHT = 540 * K;

    double cX = -0.6, cY = 0.6; // Julia Menge

    public static int GENAUIGKEIT = 100;
    int fps = 62;
    int ani_zeit = 10;
    double varphi = 0;
    double Loading_Bar = 0;

    int frames = fps * ani_zeit;
    double wvelo = (2 * Math.PI) / frames;
    double n = 3;


    double millis = 0;
    double secs = 0;
    int indi = 0;

    private Timer timer = new Timer(15, this);

    public static void main(String[] args) throws Exception {
       new Fraktale();
    }

    public Fraktale() throws Exception {

        ExecutorService executor = Executors.newFixedThreadPool(16);

        setTitle("Fraktale Mengen");
        setSize(1080, 150);
        setResizable(true);
        setBackground(Color.WHITE);
        setLocationRelativeTo(null);
        setVisible(true);
        setLayout(new FlowLayout());
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        String qualitaet = getQualitaet();

        double dt = 0;
        double t_akt = 0;
        double verbeibende_spalten = frames * WIDTH;

        for (double u = 1; u <= frames; u++) {
            BildBerechnung bildBerechnung = new BildBerechnung(timer, millis, varphi, dt, t_akt, verbeibende_spalten, u);
            executor.execute(bildBerechnung);

            varphi += wvelo;

//            Loading_Bar = ((u / frames) * 980);
//            repaint(); // Loading_Bar

//            System.out.print('\u000C');
//            System.out.println("Animation Info: " + WIDTH + "x" + HEIGHT + "px" + "(" + K + "K)");
//            System.out.println("Qualität: " + qualitaet);
//            System.out.println("Farbtiefe: 24bit");
//            System.out.println("Fps: " + fps);
//            System.out.println("Frames (Anzahl): " + frames);
//            System.out.println("Länge: " + ani_zeit + "s");
//            System.out.println("Verbeleibende Frames:");
//            System.out.println(frames - u);
        }
        dispose();
        executor.shutdown();
        while (!executor.isTerminated()) {
            Thread.sleep(10000);
            System.out.println("Wait on all threads to finish them.");
        }
        System.out.println("All threads finished");

    }

    private String getQualitaet() {
        String qua = "";
        if (GENAUIGKEIT > 0 && GENAUIGKEIT < 6) {
            qua = "sehr schlecht";
        } else if (GENAUIGKEIT > 5 && GENAUIGKEIT < 15) {
            qua = "schlecht";
        } else if (GENAUIGKEIT > 14 && GENAUIGKEIT < 30) {
            qua = "mittel";
        } else if (GENAUIGKEIT > 29 && GENAUIGKEIT < 50) {
            qua = "hoch";
        } else if (GENAUIGKEIT > 49 && GENAUIGKEIT < 100) {
            qua = "sehr hoch";
        } else if (GENAUIGKEIT > 99 && GENAUIGKEIT < 1000) {
            qua = "Ultra hoch";
        } else {
            qua = "EXTREM Hoch";
        }
        return qua;
    }


    public void paint(Graphics g) {

        g.setColor(Color.GRAY);                   // Loading_Bar
        g.drawRect(50, 75, 980, 15);
        g.setColor(Color.GREEN);
        g.fillRect(50, 75, (int) Loading_Bar, 15);

    }


    public void actionPerformed(ActionEvent e) {
        millis += 15;
    }
}





import javax.imageio.ImageIO;
import javax.swing.Timer;
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import static de.appsonoid.playground.fractal.Fraktale.GENAUIGKEIT;
import static de.appsonoid.playground.fractal.Fraktale.HEIGHT;
import static de.appsonoid.playground.fractal.Fraktale.WIDTH;

public class BildBerechnung implements Runnable {
    private final double millis;
    private double varphi;
    private double dt;
    private double t_akt;
    private double verbeibende_spalten;
    private double u;
    private int indi = 0;

    private final int a = 200;
    private final double[] fraktal = new double[2];


    private Timer timer;
    private double verbleibend_mil = 0;

    public BildBerechnung(Timer timer, double millis, double varphi, double dt, double t_akt, double verbeibende_spalten, double u) {
        this.timer = timer;
        this.millis = millis;
        this.varphi = varphi;
        this.dt = dt;
        this.t_akt = t_akt;
        this.verbeibende_spalten = verbeibende_spalten;
        this.u = u;
    }

    @Override
    public void run() {
        try {
            this.invoke();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public double getDt() {
        return dt;
    }

    public double getT_akt() {
        return t_akt;
    }

    public double getVerbeibende_spalten() {
        return verbeibende_spalten;
    }

    private BildBerechnung invoke() throws IOException {
        timer.start();

        BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);

        for (int x = 0; x < WIDTH; x++) {                     // Frame berechnung
            for (int y = 0; y < HEIGHT; y++) {
                int dotcolor = punkt(GENAUIGKEIT, WIDTH, HEIGHT, x, y);
                image.setRGB(x, y, dotcolor);

                if (x % a == 0 && y == 0) {
                    indi++;
                    dt = millis - t_akt + dt;
                    double dtt = dt / indi;
                    t_akt = millis;
                    verbleibend_mil = (dtt * verbeibende_spalten) / a;

                    int j = SEC_To_HMS(verbleibend_mil, "j");
                    int m = SEC_To_HMS(verbleibend_mil, "mo");
                    int t = SEC_To_HMS(verbleibend_mil, "t");
                    int h = SEC_To_HMS(verbleibend_mil, "h");
                    int min = SEC_To_HMS(verbleibend_mil, "m");
                    int sec = SEC_To_HMS(verbleibend_mil, "s");


                    verbeibende_spalten -= a;
                }

            }
        }



        ImageIO.write(image, "png", new File("Mandelbrot_" + u + ".png"));  // Bild als .png schreiben

        return this;
    }

    private int punkt(int iter, int width, int height, int xcoor, int ycoor) {

        double moveX = 0, moveY = 0, zoom = 0.64;

        double a = 1.5 * (xcoor - width / 2) / (0.5 * zoom * width) + moveX;//(xcoor - width/2)*4.0/width;
        double b = (ycoor - height / 2) / (0.5 * zoom * height) + moveY;//(ycoor - height/2)*4.0/width;

        double x = 0, y = 0;
        int actual_iter = 0;


        while (actual_iter < iter && a * a + b * b < 4) {

            double cX = Math.cos(varphi);
            double cY = Math.sin(varphi);
            fraktal[0] = (a * a) - (b * b) + cX; // Fraktal 0: f(z) = z² + c
            fraktal[1] = (2 * a * b) + cY;

            double x_new;

            x_new = fraktal[0];
            b = fraktal[1];
            a = x_new;

            actual_iter++;
        }

        if (actual_iter < iter) {
            return farbverteilung(actual_iter);
        }

        return 0;
    }

    private int SEC_To_HMS(double secinput, String einheit) {
        int secinpu = (int) (secinput / 1000);
        int sec = secinpu % 60;
        int h = (int) Math.floor(secinpu / 3600);
        int min = (secinpu - (3600 * h) - sec) / 60;
        int t = (int) Math.floor(h / 24);
        h = h % 24;
        int m = (int) Math.floor(t / 30);
        t = t % 30;
        int j = (int) Math.floor(m / 12);
        m = m % 12;

        if (einheit == "h") {
            return h;
        } else if (einheit == "m") {
            return min;
        } else if (einheit == "j") {
            return j;
        } else if (einheit == "mo") {
            return m;
        } else if (einheit == "t") {
            return t;
        } else if (einheit == "s") {
            return sec;
        }
        return 0;
    }

    private int farbverteilung(int index) {

        int colors[] = new int[GENAUIGKEIT];

        for (int i = 0; i < GENAUIGKEIT; i++) {
            colors[i] = Color.HSBtoRGB(i / 256f, 1, i / (i + 8f)); //farbverteilung nach HSB Prinzip und der maximalen Iterationen
        }

        return colors[index];
    }


}