#include "stdfx.h"
#include "tfxparam.h"
#include "tpixelutils.h"
#include "tparamset.h"
//************************************************************************
// Local namespace
//************************************************************************
namespace {
enum PixelOp { OVER = 0, ADD, SUBTRACT, MULTIPLY, LIGHTEN, DARKEN };
//------------------------------------------------------------------------------
template <typename PIXEL>
int doBlurValue(PIXEL *SRC, int SRC_WRAP, int BLUR) {
unsigned int count = 0;
int h, k;
int blur_val;
PIXEL *pix, *line;
pix = line = (SRC) + (-(BLUR) + 1) * (SRC_WRAP);
for (h = -(BLUR) + 1; h < (BLUR); h++) {
for (k = -(BLUR) + 1; k < (BLUR); k++) count += pix[k].m;
line += SRC_WRAP;
pix = line;
}
blur_val = (int)(count / (4 * (float)(BLUR) * (float)((BLUR)-1) + 1));
return blur_val;
}
//------------------------------------------------------------------------------
template <typename PIXEL, typename CHANNEL_TYPE>
void doBlur(CHANNEL_TYPE *greymap, const TRasterPT<PIXEL> &rin, int blur) {
// Perform a flat mean-convolution filter
// NOTE: This is improved due to separability of convolution kernel, plus
// - since its elements are all the same, only pixels entering and quitting
// the convolution area are added/subtracted from the sums.
// As a result, this yields an O(row*columns) complexity, independently
// from the blur factor.
int i, j;
int blurDiameter = 2 * blur + 1;
unsigned long sum;
int wrapSrc = rin->getWrap();
int wrapOut = rin->getLx();
// First, blur each column independently
// We'll need a temporary col for storing sums
std::unique_ptr<unsigned long[]> tempCol(new unsigned long[rin->getLy()]);
int edge = std::min(blur + 1, rin->getLy());
for (i = 0; i < rin->getLx(); ++i) {
PIXEL *lineSrcPix = rin->pixels(0) + i;
CHANNEL_TYPE *lineOutPix = greymap + i;
PIXEL *pixin = lineSrcPix;
unsigned long *pixsum = tempCol.get();
memset(tempCol.get(), 0, rin->getLy() * sizeof(unsigned long));
// Build up to blur with retro-sums
sum = 0;
for (j = 0; j < edge; ++j, pixin += wrapSrc, ++pixsum) {
sum += pixin->m;
*pixsum = sum;
}
// Fill in after blur
PIXEL *queuepix = lineSrcPix;
for (j = edge; j < rin->getLy();
++j, pixin += wrapSrc, queuepix += wrapSrc, ++pixsum) {
sum += (pixin->m - queuepix->m);
*pixsum = sum;
}
// Now, the same in reverse
lineSrcPix = lineSrcPix + (rin->getLy() - 1) * wrapSrc;
pixin = lineSrcPix;
pixsum = tempCol.get() + rin->getLy() - 1;
sum = 0;
for (j = 0; j < edge; ++j, pixin -= wrapSrc, --pixsum) {
*pixsum += sum;
sum += pixin->m;
}
queuepix = lineSrcPix;
for (j = edge; j < rin->getLy();
++j, pixin -= wrapSrc, queuepix -= wrapSrc, --pixsum) {
sum -= queuepix->m;
*pixsum += sum;
sum += pixin->m;
}
// Finally, transfer sums to the output greymap, divided by the blur.
pixsum = tempCol.get();
CHANNEL_TYPE *pixout = lineOutPix;
for (j = 0; j < rin->getLy(); ++j, pixout += wrapOut, ++pixsum)
*pixout = (*pixsum) / blurDiameter;
}
// Then, the same for all greymap rows
// We'll need a temporary row for sums
std::unique_ptr<unsigned long[]> tempRow(new unsigned long[rin->getLx()]);
edge = std::min(blur + 1, rin->getLx());
for (j = 0; j < rin->getLy(); ++j) {
CHANNEL_TYPE *lineSrcPix = greymap + j * wrapOut;
CHANNEL_TYPE *lineOutPix = lineSrcPix;
unsigned long *pixsum = tempRow.get();
CHANNEL_TYPE *pixin = lineSrcPix;
memset(tempRow.get(), 0, rin->getLx() * sizeof(unsigned long));
// Build up to blur with retro-sums
sum = 0;
for (i = 0; i < edge; ++i, ++pixin, ++pixsum) {
sum += *pixin;
*pixsum = sum;
}
// Fill in after blur
CHANNEL_TYPE *queuepix = lineSrcPix;
for (i = edge; i < rin->getLx(); ++i, ++pixin, ++pixsum, ++queuepix) {
sum += *pixin;
sum -= *queuepix;
*pixsum = sum;
}
// Now, the same in reverse
lineSrcPix = lineSrcPix + rin->getLx() - 1;
pixin = lineSrcPix;
pixsum = tempRow.get() + rin->getLx() - 1;
sum = 0;
for (i = 0; i < edge; ++i, --pixin, --pixsum) {
*pixsum += sum;
sum += *pixin;
}
queuepix = lineSrcPix;
for (i = edge; i < rin->getLx(); ++i, --pixin, --pixsum, --queuepix) {
sum -= *queuepix;
*pixsum += sum;
sum += *pixin;
}
// Finally, transfer sums to the output greymap, divided by the blur.
CHANNEL_TYPE *pixout = lineOutPix;
pixsum = tempRow.get();
for (i = 0; i < rin->getLx(); ++i, ++pixout, ++pixsum)
*pixout = (*pixsum) / blurDiameter;
}
}
//------------------------------------------------------------------------------
template <typename PIXEL>
void myOver(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color) {
pixout = color;
}
//------------------------------------------------------------------------------
template <typename PIXEL>
void myAdd(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color) {
pixout.r = std::min(pixin.r + color.r, PIXEL::maxChannelValue);
pixout.g = std::min(pixin.g + color.g, PIXEL::maxChannelValue);
pixout.b = std::min(pixin.b + color.b, PIXEL::maxChannelValue);
}
//------------------------------------------------------------------------------
template <typename PIXEL>
void mySub(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color) {
pixout.r = std::max(pixin.r - color.r, 0);
pixout.g = std::max(pixin.g - color.g, 0);
pixout.b = std::max(pixin.b - color.b, 0);
}
//------------------------------------------------------------------------------
template <typename PIXEL>
void myMult(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color) {
static const double den = PIXEL::maxChannelValue;
pixout.r = pixin.r * (color.r / den);
pixout.g = pixin.g * (color.g / den);
pixout.b = pixin.b * (color.b / den);
}
//------------------------------------------------------------------------------
template <typename PIXEL>
void myLighten(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color) {
pixout.r = pixin.r > color.r ? pixin.r : color.r;
pixout.g = pixin.g > color.g ? pixin.g : color.g;
pixout.b = pixin.b > color.b ? pixin.b : color.b;
}
//------------------------------------------------------------------------------
template <typename PIXEL>
void myDarken(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color) {
pixout.r = pixin.r < color.r ? pixin.r : color.r;
pixout.g = pixin.g < color.g ? pixin.g : color.g;
pixout.b = pixin.b < color.b ? pixin.b : color.b;
}
//------------------------------------------------------------------------------
template <typename PIXEL, typename CHANNEL>
void doLayerBlending(PIXEL *pixin, PIXEL *pixout, CHANNEL *pixmatte, int inLx,
int outLx, int outLy, int wrapIn, int wrapOut, int dx,
int dy, double transp, PIXEL color,
void (*pixelOp)(PIXEL &, const PIXEL &, const PIXEL &)) {
double CROP_VAL = PIXEL::maxChannelValue;
CHANNEL U_CROP_VAL = PIXEL::maxChannelValue;
int const_transp = CROP_VAL * transp + 0.5;
double val_r, val_g, val_b, val_m;
int blur_val;
PIXEL opColor;
double k, matte;
CHANNEL shadow_matte;
int x, y;
for (y = 0; y < outLy; ++y, pixin += wrapIn - outLx,
pixout += wrapOut - outLx, pixmatte += inLx - outLx)
for (x = 0; x < outLx; ++x, ++pixin, ++pixout, ++pixmatte) {
if (pixin->m != 0) // where the image is transparent, no shadow
{
blur_val = *(pixmatte + dy * inLx + dx);
shadow_matte = (blur_val) ? (int)((CROP_VAL - blur_val) * transp + 0.5)
: const_transp;
k = (double)(CROP_VAL - shadow_matte) / CROP_VAL;
val_r = pixin->r * k + 0.5;
val_g = pixin->g * k + 0.5;
val_b = pixin->b * k + 0.5;
val_m = pixin->m;
pixelOp(opColor, *pixin, color);
matte = (1 - k) * (val_m / CROP_VAL);
val_r += matte * opColor.r;
val_g += matte * opColor.g;
val_b += matte * opColor.b;
pixout->r = (val_r > CROP_VAL) ? U_CROP_VAL
: ((val_r < 0) ? 0 : (CHANNEL)val_r);
pixout->g = (val_g > CROP_VAL) ? U_CROP_VAL
: ((val_g < 0) ? 0 : (CHANNEL)val_g);
pixout->b = (val_b > CROP_VAL) ? U_CROP_VAL
: ((val_b < 0) ? 0 : (CHANNEL)val_b);
pixout->m = (val_m > CROP_VAL) ? U_CROP_VAL
: ((val_m < 0) ? 0 : (CHANNEL)val_m);
} else
*pixout = PIXEL::Transparent;
}
}
//------------------------------------------------------------------------------
template <typename PIXEL>
void doBodyHighlight(const TRasterPT<PIXEL> rout, const TRasterPT<PIXEL> rin,
TRectD rectIn, int rasInLx, int rasInLy, double frame,
int blur, double transp, PIXEL color, TPointD point,
bool invert,
void (*pixelOp)(PIXEL &, const PIXEL &, const PIXEL &),
TRasterFxPort &m_input, const TRenderSettings &ri) {
typedef typename PIXEL::Channel CHANNEL_TYPE;
rin->lock();
rout->lock();
int inLx = rin->getLx(), inLy = rin->getLy(), inWrap = rin->getWrap();
int outLx = rout->getLx(), outLy = rout->getLy(), outWrap = rout->getWrap();
int dx = point.x, dy = point.y;
transp = 1.0 - transp;
PIXEL *src_buf, *dst_buf;
dst_buf = rout->pixels(0);
src_buf = rin->pixels(0) + blur + blur * inWrap;
if (dy < 0) src_buf -= dy * inWrap;
if (dx < 0) src_buf -= dx;
// First, perform an optimized mean-convolution of the interesting part of
// image's matte
int matteLxLy = inLx * inLy;
CHANNEL_TYPE *matteGreymap =
(CHANNEL_TYPE *)malloc(matteLxLy * sizeof(CHANNEL_TYPE));
if (!matteGreymap) return;
memset(matteGreymap, 0, matteLxLy * sizeof(CHANNEL_TYPE));
doBlur<PIXEL, CHANNEL_TYPE>(matteGreymap, rin, blur);
CHANNEL_TYPE U_CROP_VAL = PIXEL::maxChannelValue;
// If specified, invert the matte
if (invert) {
CHANNEL_TYPE *mpix, *end = matteGreymap + matteLxLy;
for (mpix = matteGreymap; mpix < end; ++mpix) *mpix = U_CROP_VAL - *mpix;
}
CHANNEL_TYPE *mattepix = matteGreymap + blur + blur * inLx;
if (dy < 0) mattepix -= dy * inLx;
if (dx < 0) mattepix -= dx;
doLayerBlending(src_buf, dst_buf, mattepix, inLx, outLx, outLy, inWrap,
outWrap, dx, dy, transp, color, pixelOp);
free(matteGreymap);
rin->unlock();
rout->unlock();
}
} // namespace
//************************************************************************
// BodyHighLightFx implementation
//************************************************************************
class BodyHighLightFx final : public TStandardRasterFx {
FX_PLUGIN_DECLARATION(BodyHighLightFx)
TRasterFxPort m_input;
TIntEnumParamP m_mode;
TPointParamP m_point;
TDoubleParamP m_transparency;
TDoubleParamP m_blur;
TPixelParamP m_color;
TBoolParamP m_invert;
public:
BodyHighLightFx()
: m_point(TPointD(10.0, 10.0))
, m_mode(new TIntEnumParam(OVER, "Over"))
, m_transparency(0.5)
, m_blur(2.0)
, m_color(TPixel32::White)
, m_invert(false) {
m_point->getX()->setMeasureName("fxLength");
m_point->getY()->setMeasureName("fxLength");
m_blur->setMeasureName("fxLength");
bindParam(this, "mode", m_mode);
bindParam(this, "point", m_point);
bindParam(this, "transparency", m_transparency);
bindParam(this, "blur", m_blur);
bindParam(this, "color", m_color);
bindParam(this, "invert", m_invert);
addInputPort("Source", m_input);
m_transparency->setValueRange(0.0, 1.0);
m_blur->setValueRange(0, (std::numeric_limits<double>::max)());
m_color->enableMatte(false);
m_mode->addItem(ADD, "Add");
m_mode->addItem(SUBTRACT, "Subtract");
m_mode->addItem(MULTIPLY, "Multiply");
m_mode->addItem(LIGHTEN, "Lighten");
m_mode->addItem(DARKEN, "Darken");
}
~BodyHighLightFx(){};
bool doGetBBox(double frame, TRectD &bBox,
const TRenderSettings &info) override {
if (m_input.isConnected())
return m_input->doGetBBox(frame, bBox, info);
else {
bBox = TRectD();
return false;
}
}
bool canHandle(const TRenderSettings &info, double frame) override {
return true;
}
void doDryCompute(TRectD &rect, double frame,
const TRenderSettings &info) override;
void doCompute(TTile &tile, double frame, const TRenderSettings &) override;
int getMemoryRequirement(const TRectD &rect, double frame,
const TRenderSettings &info) override;
};
//------------------------------------------------------------------------------
void BodyHighLightFx::doDryCompute(TRectD &rect, double frame,
const TRenderSettings &info) {
m_input->dryCompute(rect, frame, info);
double fac = sqrt(fabs(info.m_affine.det()));
int blur = (int)(fac * fabs(m_blur->getValue(frame)));
TPoint point = convert(fac * m_point->getValue(frame));
TRectD rectIn = rect.enlarge(blur);
int rasInLx = tround(rectIn.getLx() + abs(point.x)) + 1;
int rasInLy = tround(rectIn.getLy() + abs(point.y)) + 1;
if (point.x < 0) {
rectIn.x0 += point.x;
}
if (point.y < 0) {
rectIn.y0 += point.y;
}
rectIn = TRectD(rectIn.getP00(), TDimensionD(rasInLx, rasInLy));
m_input->dryCompute(rectIn, frame, info);
}
//------------------------------------------------------------------------------
void BodyHighLightFx::doCompute(TTile &tile, double frame,
const TRenderSettings &ri) {
double fac = sqrt(fabs(ri.m_affine.det()));
if (!m_input.isConnected()) return;
// Compute the effective input tile
m_input->compute(tile, frame, ri);
double transp = m_transparency->getValue(frame);
int blur = (int)(fac * fabs(m_blur->getValue(frame)));
TPoint point = convert(fac * m_point->getValue(frame));
bool invert = m_invert->getValue();
// Build the shadow, blurred tile
TDimension rectSize(tile.getRaster()->getSize());
TRectD rectIn(tile.m_pos, TDimensionD(rectSize.lx, rectSize.ly));
rectIn = rectIn.enlarge(blur);
// Shift rectIn by the input 'point'
int rasInLx = tround(rectIn.getLx() + abs(point.x)) + 1;
int rasInLy = tround(rectIn.getLy() + abs(point.y)) + 1;
if (point.x < 0) {
rectIn.x0 += point.x;
} else {
rectIn.x1 += point.x;
}
if (point.y < 0) {
rectIn.y0 += point.y;
} else {
rectIn.y1 += point.y;
}
const TPixel32 color = m_color->getPremultipliedValue(frame);
TRaster32P raster32 = tile.getRaster();
TRaster64P raster64 = tile.getRaster();
TTile tileIn;
m_input->allocateAndCompute(tileIn, rectIn.getP00(),
TDimension(rasInLx, rasInLy), tile.getRaster(),
frame, ri);
// Select the specified pixel operation
void (*pixelOp32)(TPixel32 &, const TPixel32 &, const TPixel32 &);
void (*pixelOp64)(TPixel64 &, const TPixel64 &, const TPixel64 &);
switch (m_mode->getValue()) {
case OVER: {
pixelOp32 = ::myOver<TPixel32>;
pixelOp64 = ::myOver<TPixel64>;
break;
}
case ADD: {
pixelOp32 = ::myAdd<TPixel32>;
pixelOp64 = ::myAdd<TPixel64>;
break;
}
case SUBTRACT: {
pixelOp32 = ::mySub<TPixel32>;
pixelOp64 = ::mySub<TPixel64>;
break;
}
case MULTIPLY: {
pixelOp32 = ::myMult<TPixel32>;
pixelOp64 = ::myMult<TPixel64>;
break;
}
case LIGHTEN: {
pixelOp32 = ::myLighten<TPixel32>;
pixelOp64 = ::myLighten<TPixel64>;
break;
}
case DARKEN: {
pixelOp32 = ::myDarken<TPixel32>;
pixelOp64 = ::myDarken<TPixel64>;
break;
}
}
TRaster32P rin = tileIn.getRaster();
if (raster32)
doBodyHighlight<TPixel32>(raster32, rin, rectIn, rasInLx, rasInLy, frame,
blur, transp, color, convert(point), invert,
pixelOp32, m_input, ri);
else {
TRaster64P rin = tileIn.getRaster();
if (raster64)
doBodyHighlight<TPixel64>(raster64, rin, rectIn, rasInLx, rasInLy, frame,
blur, transp, toPixel64(color), convert(point),
invert, pixelOp64, m_input, ri);
else
throw TException("Brightness&Contrast: unsupported Pixel Type");
}
}
//------------------------------------------------------------------
int BodyHighLightFx::getMemoryRequirement(const TRectD &rect, double frame,
const TRenderSettings &info) {
int blur =
(int)(sqrt(fabs(info.m_affine.det())) * fabs(m_blur->getValue(frame)));
return TRasterFx::memorySize(rect.enlarge(blur), info.m_bpp);
}
//------------------------------------------------------------------
FX_PLUGIN_IDENTIFIER(BodyHighLightFx, "bodyHighLightFx")