interface GradientOpmimizer {

    void init();

    Point[] optimize(double[] values, int maxPoints, double maxStandardDeviation);

}

N = 10
Standard Deviation = 1.0; //  (подбирается экспериментом)
F = [0.0029, 0.0027..... ] 

Polyline = [ (0.0, 0.002), (33.0, 0.002) ...... ]

(x,y,color) = (0,0,#878377)
(x,y,color) = (0,108,#868475)
(x,y,color) = (0,216,#858273)
(x,y,color) = (0,324,#7E7B6C)
(x,y,color) = (0,432,#8496AA)
(x,y,color) = (0,540,#BFC7D4)
(x,y,color) = (0,648,#E2D7C3)
(x,y,color) = (0,756,#C8B998)
(x,y,color) = (0,864,#F2E3CC)
(x,y,color) = (0,972,#E4D9BD)

double[] r;
double[] g;
double[] b;

// 14-Aug, 2021 - mayton

public class YUVDecomposer {

    static Logger logger = LoggerFactory.getLogger(YUVDecomposer.class);

    public static void main(String[] args) throws IOException {
        // Convert from RGB to floating points quaternions
        String sourcePath = args[0];

        BufferedImage source = ImageIO.read(new FileInputStream(sourcePath));
        int W = source.getWidth();
        int H = source.getHeight();
        int PIXELS = W * H;

        logger.info("W = {}, H = {}, colorModel = {}", W, H, source.getColorModel());

        // 4 * sizeOf(float) = 4 * 32bit = 128bit. This is the same as single XMM register.

        float[] rgbSourceFloat = new float[PIXELS * 4];
        logger.info("rgbSourceFloat size = {}", rgbSourceFloat.length);

        // RGB ratios plane
        float[] yuvRatios = new float[PIXELS * 4];
        int i = 0;
        for (int j = 0; j < PIXELS; j++) {
            yuvRatios[i++] = (float) Constants.RK;
            yuvRatios[i++] = (float) Constants.GK;
            yuvRatios[i++] = (float) Constants.BK;
            yuvRatios[i++] = 0.0f; // Placeholder to be aligned
        }

        i = 0;
        int color = 0;
        for (int y = 0; y < H; y++) {
            for (int x = 0; x < W; x++) {
                color = source.getRGB(x, y);
                rgbSourceFloat[i++] = ImageUtils.getRPixel(color) / 255.0f; // Normalize to [0..1] range
                rgbSourceFloat[i++] = ImageUtils.getGPixel(color) / 255.0f;
                rgbSourceFloat[i++] = ImageUtils.getBPixel(color) / 255.0f;
                i++;
            }
        }

        // YUV-Plane
        float yval = 0.0f;
        float[] yPlane = new float[PIXELS];
        //float[] uPlane = new float[W * H];
        //float[] vPlane = new float[W * H];
        StopWatch renderYPlaneStopWatcher = StopWatch.createStarted();
        int j = 0;
        i = 0;
        // #pragma force jvm vectorization :)
        while (i < yuvRatios.length) {
            float yPlaneVal = 0.0f;
            // assumed mulps xmm0, xmm1 ... will be used
            yPlaneVal += yuvRatios[i] * rgbSourceFloat[i]; // Ri * RK
            i++;
            yPlaneVal += yuvRatios[i] * rgbSourceFloat[i]; // Gi * GK
            i++;
            yPlaneVal += yuvRatios[i] * rgbSourceFloat[i]; // Bi * Bk
            i++;
            yPlaneVal += yuvRatios[i] * rgbSourceFloat[i]; // Placeholder
            i++;
            yPlane[j] = yPlaneVal;
            j++;
        }
        renderYPlaneStopWatcher.stop();
        logger.info("renderYPlane : {} ms", renderYPlaneStopWatcher.getTime(TimeUnit.MILLISECONDS));
        // TODO: Render U, V
        
        // TODO: Generate U, V images

        // Export YUV planes as 4 split-screen images to be clear
        BufferedImage dest = new BufferedImage(W * 2, H * 2, BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = (Graphics2D) dest.getGraphics();
        ImageObserver imageObserver = new YUVImageObserver(); // TODO: WTF? How to sync with fucken image observer?
        g2d.drawImage(source, 0, 0, imageObserver);
        sleep(5 * 1000);
        
        // TODO: Place Y, U, V images into 2,3,4x splits

        ImageIO.write(dest, "PNG", new FileOutputStream(FileUtils.trimExtension(sourcePath) + "-YUV-4x-split.png"));



    }