255 lines
6.6 KiB
C++
255 lines
6.6 KiB
C++
|
|
|
|
#include "texception.h"
|
|
#include "tfxparam.h"
|
|
#include "stdfx.h"
|
|
|
|
#include "tparamset.h"
|
|
|
|
static void OLDRGB2HSV(double r, double g, double b, double *h, double *s,
|
|
double *v) {
|
|
double max, min;
|
|
double delta;
|
|
|
|
max = std::max({r, g, b});
|
|
min = std::min({r, g, b});
|
|
|
|
*v = max;
|
|
|
|
if (max != 0)
|
|
*s = (max - min) / max;
|
|
else
|
|
*s = 0;
|
|
|
|
if (*s == 0)
|
|
*h = 0;
|
|
else {
|
|
delta = max - min;
|
|
|
|
if (r == max)
|
|
*h = (g - b) / delta;
|
|
else if (g == max)
|
|
*h = 2 + (b - r) / delta;
|
|
else if (b == max)
|
|
*h = 4 + (r - g) / delta;
|
|
*h = *h * 60;
|
|
if (*h < 0) *h += 360;
|
|
}
|
|
}
|
|
|
|
static void OLDHSV2RGB(double hue, double sat, double value, double *red,
|
|
double *green, double *blue) {
|
|
int i;
|
|
double p, q, t, f;
|
|
|
|
// if (hue > 360 || hue < 0)
|
|
// hue=0;
|
|
if (hue > 360) hue -= 360;
|
|
if (hue < 0) hue += 360;
|
|
if (sat < 0) sat = 0;
|
|
if (sat > 1) sat = 1;
|
|
if (value < 0) value = 0;
|
|
if (value > 1) value = 1;
|
|
if (sat == 0) {
|
|
*red = value;
|
|
*green = value;
|
|
*blue = value;
|
|
} else {
|
|
if (hue == 360) hue = 0;
|
|
|
|
hue = hue / 60;
|
|
i = (int)hue;
|
|
f = hue - i;
|
|
p = value * (1 - sat);
|
|
q = value * (1 - (sat * f));
|
|
t = value * (1 - (sat * (1 - f)));
|
|
|
|
switch (i) {
|
|
case 0:
|
|
*red = value;
|
|
*green = t;
|
|
*blue = p;
|
|
break;
|
|
case 1:
|
|
*red = q;
|
|
*green = value;
|
|
*blue = p;
|
|
break;
|
|
case 2:
|
|
*red = p;
|
|
*green = value;
|
|
*blue = t;
|
|
break;
|
|
case 3:
|
|
*red = p;
|
|
*green = q;
|
|
*blue = value;
|
|
break;
|
|
case 4:
|
|
*red = t;
|
|
*green = p;
|
|
*blue = value;
|
|
break;
|
|
case 5:
|
|
*red = value;
|
|
*green = p;
|
|
*blue = q;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
class ChangeColorFx final : public TStandardRasterFx {
|
|
FX_PLUGIN_DECLARATION(ChangeColorFx)
|
|
TRasterFxPort m_input;
|
|
TPixelParamP m_from_color;
|
|
TPixelParamP m_to_color;
|
|
TDoubleParamP m_range;
|
|
TDoubleParamP m_falloff;
|
|
|
|
public:
|
|
ChangeColorFx()
|
|
: m_from_color(TPixel32::Red)
|
|
, m_to_color(TPixel32::Blue)
|
|
, m_range(0.0)
|
|
, m_falloff(0.0) {
|
|
addInputPort("Source", m_input);
|
|
bindParam(this, "range", m_range);
|
|
bindParam(this, "falloff", m_falloff);
|
|
bindParam(this, "from_color", m_from_color);
|
|
bindParam(this, "to_color", m_to_color);
|
|
m_range->setValueRange(0, 100);
|
|
m_falloff->setValueRange(0, 100);
|
|
}
|
|
~ChangeColorFx(){};
|
|
|
|
bool doGetBBox(double frame, TRectD &bBox,
|
|
const TRenderSettings &info) override {
|
|
if (m_input.isConnected()) return m_input->doGetBBox(frame, bBox, info);
|
|
{
|
|
bBox = TRectD();
|
|
return false;
|
|
}
|
|
};
|
|
|
|
void doCompute(TTile &tile, double frame, const TRenderSettings &ri) override;
|
|
};
|
|
|
|
static double normalize_h(double h) {
|
|
if (h < 0) h += 360;
|
|
if (h > 360) h -= 360;
|
|
return h;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
void ChangeColorFx::doCompute(TTile &tile, double frame,
|
|
const TRenderSettings &ri) {
|
|
if (!m_input.isConnected()) return;
|
|
|
|
m_input->compute(tile, frame, ri);
|
|
|
|
double from_h, from_s, from_v, to_h, to_s, to_v;
|
|
bool swaprange = false, swapfallmin = false, swapfallmax;
|
|
TPixel32 from_color = m_from_color->getPremultipliedValue(frame);
|
|
TPixel32 to_color = m_to_color->getPremultipliedValue(frame);
|
|
double range = m_range->getValue(frame) / 100;
|
|
double falloff = m_falloff->getValue(frame) / 100;
|
|
|
|
OLDRGB2HSV(from_color.r / 255.0, from_color.g / 255.0, from_color.b / 255.0,
|
|
&from_h, &from_s, &from_v);
|
|
OLDRGB2HSV(to_color.r / 255.0, to_color.g / 255.0, to_color.b / 255.0, &to_h,
|
|
&to_s, &to_v);
|
|
/*
|
|
int from_hsv[3];
|
|
int to_hsv[3];
|
|
rgb2hsv(from_hsv, from_color);
|
|
rgb2hsv(to_hsv, to_color);
|
|
|
|
/////////////// verificare ///////
|
|
from_h =((double)from_hsv[0]/255.)*360.;
|
|
from_s =from_hsv[1]/255.;
|
|
from_v =from_hsv[2]/255.;
|
|
to_h =((double)to_hsv[0]/255.)*360.;
|
|
to_s =to_hsv[1]/255.;
|
|
to_v =to_hsv[2]/255.;
|
|
*/
|
|
////////////////////////
|
|
TRaster32P raster32 = tile.getRaster();
|
|
assert(raster32); // per ora gestisco solo i Raster32
|
|
|
|
double hmin = from_h - range * 180;
|
|
hmin = normalize_h(hmin);
|
|
double hmax = from_h + range * 180;
|
|
hmax = normalize_h(hmax);
|
|
if (hmax <= hmin) {
|
|
std::swap(hmin, hmax);
|
|
swaprange = true;
|
|
}
|
|
double smin = from_s - range;
|
|
double smax = from_s + range;
|
|
double vmin = from_v - range;
|
|
double vmax = from_v + range;
|
|
double hfallmin = hmin - falloff * 180;
|
|
double hfallmax = hmax + falloff * 180;
|
|
hfallmin = normalize_h(hfallmin);
|
|
hfallmax = normalize_h(hfallmax);
|
|
if (hfallmin > hmin) {
|
|
swapfallmin = true;
|
|
}
|
|
if (hfallmax < hmax) {
|
|
swapfallmax = true;
|
|
}
|
|
double sfallmin = smin - falloff;
|
|
double sfallmax = smax + falloff;
|
|
double vfallmin = vmin - falloff;
|
|
double vfallmax = vmax + falloff;
|
|
|
|
int j;
|
|
raster32->lock();
|
|
for (j = 0; j < raster32->getLy(); j++) {
|
|
TPixel32 *pix = raster32->pixels(j);
|
|
TPixel32 *endPix = pix + raster32->getLx();
|
|
while (pix < endPix) {
|
|
double r, g, b, h, s, v;
|
|
r = pix->r / 255.0;
|
|
g = pix->g / 255.0;
|
|
b = pix->b / 255.0;
|
|
// int hsv[3];
|
|
OLDRGB2HSV(r, g, b, &h, &s, &v);
|
|
int hflag = (h <= hmax && h >= hmin);
|
|
if (swaprange) hflag = !hflag;
|
|
if (hflag && s <= smax && s >= smin && v <= vmax && v >= vmin)
|
|
*pix = to_color;
|
|
else {
|
|
double hcorr = 0;
|
|
double scorr = 0;
|
|
double vcorr = 0;
|
|
int hfallminflag = (h <= hmin && h >= hfallmin);
|
|
if (hfallminflag) hcorr = h - hmin;
|
|
int hfallmaxflag = (h >= hmax && h <= hfallmax);
|
|
if (hfallmaxflag) hcorr = h - hmax;
|
|
if (hcorr) {
|
|
if (s <= smin && s >= sfallmin) scorr = s - smin;
|
|
if (s >= smax && s <= sfallmax) scorr = s - smax;
|
|
if (v <= vmin && v >= vfallmin) vcorr = v - vmin;
|
|
if (v >= vmax && v <= vfallmax) vcorr = v - vmax;
|
|
if (s < smin && s > sfallmin) scorr = s - smin;
|
|
if (s > smax && s < sfallmax) scorr = s - smax;
|
|
h = to_h + hcorr;
|
|
if (h < 0) h += 360;
|
|
if (h > 360) h -= 360;
|
|
OLDHSV2RGB(h, s, v, &r, &g, &b);
|
|
|
|
pix->r = (UCHAR)(r * 255);
|
|
pix->g = (UCHAR)(g * 255);
|
|
pix->b = (UCHAR)(b * 255);
|
|
}
|
|
}
|
|
// premultiply(*pix);
|
|
pix++;
|
|
}
|
|
}
|
|
raster32->unlock();
|
|
}
|
|
|
|
// FX_PLUGIN_IDENTIFIER(ChangeColorFx , "changeColorFx")
|