HSBCorrection

/**
 * Класс коррекции HSB-палитры
 * Добавлена нормализация, общий класс HSB-палитры и оптимизирован alpha-канал.
 * Добавлен параметр для тонировки изображений.
 * @author aNNiMON
 */
public class eHSBCorrection extends Effect {

    Amount getAmount() {
        return new Amount(
                new int[] {0,   -100, -100, 0},
                new int[] {360, 100, 100,   1},
                new int[] {45,  0,   0,     0});
    }

    void applyEffect() {
        HSB hsbColor;
        super.progressMax = pix.length;
        boolean tone = (am.cur[3] == 1); //тонировка
        for (int io = 0; io < pix.length; io++) {
            super.progress = io;
            int qr = (pix[io] >> 16) & 0xff;
            int qg = (pix[io] >> 8) & 0xff;
            int qb = pix[io] & 0xff;
            hsbColor = RGBtoHSB(qr, qg, qb, tone);
            hsbColor.changeChannels(am.cur[0], am.cur[1], am.cur[2]);
            hsbColor.normalize();
            pix[io] = (pix[io] & 0xff000000) | HSBtoRGB(hsbColor);
        }
    }

    private int HSBtoRGB(HSB hsb) {
        float hue = hsb.hue;
        float saturation = hsb.saturation / 100f;
        float brightness = hsb.brightness / 100f;

        float qr = 0, qg = 0, qb = 0;
        int r = 0, g = 0, b = 0;
        if(saturation <= 0) {
            r = (int) (brightness * 255);
            if(r > 255) r = 255;
            return (r << 16) | (r << 8) | r;
        } else if (brightness <= 0) {
            return 0;
        }
        qr = (hue / 60f); // временно для расчета h / 60
        int Hi = (int) (qr % 6);
        float f = (float) (qr - Math.floor(qr));
        float p = brightness * (1.0f - saturation);
        float q = brightness * (1.0f - (f * saturation));
        float t = brightness * (1.0f - (saturation * (1.0f-f)));
        switch(Hi) {
            case 0: qr = brightness; qg = t; qb = p; break;
            case 1: qr = q; qg = brightness; qb = p; break;
            case 2: qr = p; qg = brightness; qb = t; break;
            case 3: qr = p; qg = q; qb = brightness; break;
            case 4: qr = t; qg = p; qb = brightness; break;
            case 5: qr = brightness; qg = p; qb = q; break;
        }
        r = (int) (255 * qr);
        g = (int) (255 * qg);
        b = (int) (255 * qb);

        if(r > 255) r = 255;
        if(g > 255) g = 255;
        if(b > 255) b = 255;

        return (r << 16) | (g << 8) | b;
    }

    private HSB RGBtoHSB(int Red, int Green, int Blue, boolean tone) {
        int MaxRGB = (Red > Green) ? Red : Green;
        if (Blue > MaxRGB) MaxRGB = Blue;
        int MinRGB = (Red < Green) ? Red : Green;
        if (Blue < MinRGB) MinRGB = Blue;

        float hue, saturation, brightness;
        if(tone) {
            hue = 0.0f;
            float Delta = MaxRGB - MinRGB;
            brightness = MaxRGB / 255f;
            if (MaxRGB != 0.0f) {
                saturation = Delta / MaxRGB;
            } else {
                saturation = 0.0f;
            }
            if (saturation != 0.0) {
                if (Red == MaxRGB) {
                    hue = (Green - Blue) / Delta;
                } else if (Green == MaxRGB) {
                    hue = 2.0f + (Blue - Red) / Delta;
                } else if (Blue == MaxRGB) {
                    hue = 4.0f + (Red - Green) / Delta;
                }
            } else {
                hue = -60.0f;
            }
            if (hue < 0) {
                hue = hue + 360.0f;
            }
            return new HSB(
                    (int) hue,
                    (int) (saturation * 100f),
                    (int) (brightness * 100f));
        } else {
            brightness = ((float) MaxRGB) / 255.0f;
            if (MaxRGB != 0)  {
                saturation = ((float) (MaxRGB - MinRGB)) / ((float) MaxRGB);
            } else {
                saturation = 0.0f;
            }

            if (saturation == 0.0f) {
                hue = -1.0f;
            } else {
                float redc = ((float) (MaxRGB - Red)) / ((float) (MaxRGB - MinRGB));
                float greenc = ((float) (MaxRGB - Green)) / ((float) (MaxRGB - MinRGB));
                float bluec = ((float) (MaxRGB - Blue)) / ((float) (MaxRGB - MinRGB));
                if (Red == MaxRGB)
                    hue = bluec - greenc;
                else if (Green == MaxRGB)
                    hue = 2.0f + redc - bluec;
                else
                    hue = 4.0f + greenc - redc;
                hue = hue / 6.0f;

            }
            if (hue < 0.0f)
                hue = hue + 1.0f;
            // Приведение значений к удобным диапазонам
            hue = hue * 360.0f;
            saturation = saturation * 100f;
            brightness = brightness * 100f;
            return new HSB(
                    (int) hue,
                    (int) saturation,
                    (int) brightness);
        }
    }

    /**
     * Класс цветовой модели HSB
     */
    private class HSB {

        /** Цветовой тон 0..360 */
        private int hue;
        /** Насыщенность 0..100 */
        private int saturation;
        /** Яркость 0..100 */
        private int brightness;

        private HSB(int h, int s, int b) {
            hue = h;
            saturation = s;
            brightness = b;
        }

        /**
         * Изменение значение каналов на заданную величину
         * @param h тон
         * @param s насыщенность
         * @param b яркость
         */
        private void changeChannels(int h, int s, int b) {
            hue = hue + h;
            saturation = saturation + s;
            brightness = brightness + b;
        }

        /**
         * Нормализация значений
         */
        private void normalize() {
            if(hue > 360) hue = hue - 360;

            if(saturation > 100) saturation = 100;
            else if(saturation < 0) saturation = 0;

            if(brightness > 100) brightness = 100;
            else if(brightness < 0) brightness = 0;
        }

    }
}