453 lines
15 KiB
C++
453 lines
15 KiB
C++
|
|
|
|
#include "stdfx.h"
|
|
#include "tfxparam.h"
|
|
#include "tpixelutils.h"
|
|
#include "trop.h"
|
|
#include "tparamset.h"
|
|
|
|
//****************************************************************************
|
|
// Local namespace stuff
|
|
//****************************************************************************
|
|
|
|
namespace
|
|
{
|
|
inline void pixelConvert(TPixel32 &dst, const TPixel32 &src) { dst = src; }
|
|
inline void pixelConvert(TPixel64 &dst, const TPixel32 &src) { dst = toPixel64(src); }
|
|
|
|
inline TRect gridAlign(const TRect &rect, TPoint origin, double step)
|
|
{
|
|
TRect result(rect);
|
|
result -= origin;
|
|
|
|
result.x0 = step * tfloor(result.x0 / step);
|
|
result.y0 = step * tfloor(result.y0 / step);
|
|
result.x1 = step * tceil((result.x1 + 1) / step) - 1;
|
|
result.y1 = step * tceil((result.y1 + 1) / step) - 1;
|
|
|
|
result += origin;
|
|
return result;
|
|
}
|
|
|
|
inline TRectD gridAlign(const TRectD &rect, TPointD origin, double step)
|
|
{
|
|
TRectD result(rect);
|
|
result -= origin;
|
|
|
|
result.x0 = step * tfloor(result.x0 / step);
|
|
result.y0 = step * tfloor(result.y0 / step);
|
|
result.x1 = step * tceil(result.x1 / step);
|
|
result.y1 = step * tceil(result.y1 / step);
|
|
|
|
result += origin;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//****************************************************************************
|
|
// Mosaic Namespace
|
|
//****************************************************************************
|
|
|
|
namespace mosaic
|
|
{
|
|
/*!
|
|
The mosaic::CellBuilder class is the virtual base class used by MosaicFx
|
|
to render a Mosaic cell with supplied colors.
|
|
*/
|
|
template <typename PIXEL>
|
|
class CellBuilder
|
|
{
|
|
protected:
|
|
int m_lx, m_ly;
|
|
double m_radius;
|
|
int m_wrap;
|
|
|
|
public:
|
|
CellBuilder(int cellLx, int cellLy, double radius, int wrap)
|
|
: m_lx(cellLx), m_ly(cellLy), m_radius(radius), m_wrap(wrap) {}
|
|
virtual ~CellBuilder() {}
|
|
|
|
virtual void doCell(
|
|
PIXEL *cellBuffer, const PIXEL &cellColor, const PIXEL &bgColor,
|
|
int x0, int y0, int x1, int y1) = 0;
|
|
};
|
|
|
|
} //namespace mosaic
|
|
|
|
//****************************************************************************
|
|
// CellBuilder implementations
|
|
//****************************************************************************
|
|
|
|
namespace mosaic
|
|
{
|
|
|
|
template <typename PIXEL, typename GRAY>
|
|
class MaskCellBuilder : public CellBuilder<PIXEL>
|
|
{
|
|
protected:
|
|
TRasterPT<GRAY> m_mask;
|
|
|
|
public:
|
|
MaskCellBuilder(int cellLx, int cellLy, double radius, int wrap)
|
|
: CellBuilder<PIXEL>(cellLx, cellLy, radius, wrap) {}
|
|
|
|
void doCell(
|
|
PIXEL *cellBuffer, const PIXEL &cellColor, const PIXEL &bgColor,
|
|
int x0, int y0, int x1, int y1)
|
|
{
|
|
//Apply the mask to the cell. 0 pixels are bgColored, GRAY::maxChannelValue
|
|
//ones are cellColored.
|
|
PIXEL *pix, *line = cellBuffer, *lineEnd;
|
|
GRAY *grPix, *grLine = m_mask->pixels(y0) + x0, *grLineEnd;
|
|
int x, y, grWrap = m_mask->getWrap(), lx = x1 - x0;
|
|
for (y = y0; y < y1; ++y, line += this->m_wrap, grLine += grWrap) {
|
|
lineEnd = line + lx;
|
|
grLineEnd = grLine + lx;
|
|
for (x = x0, pix = line, grPix = grLine; x < x1; ++x, ++pix, ++grPix)
|
|
*pix = blend(bgColor, cellColor, grPix->value / (double)GRAY::maxChannelValue);
|
|
}
|
|
}
|
|
};
|
|
|
|
template <typename PIXEL, typename GRAY>
|
|
class SquareBuilder : public MaskCellBuilder<PIXEL, GRAY>
|
|
{
|
|
public:
|
|
SquareBuilder(int cellLx, int cellLy, double radius, int wrap)
|
|
: MaskCellBuilder<PIXEL, GRAY>(cellLx, cellLy, radius, wrap)
|
|
{
|
|
//Build the mask corresponding to a square of passed radius
|
|
GRAY *pix, *pixRev, *line, *lineEnd, *lineRev;
|
|
this->m_mask = TRasterPT<GRAY>(cellLx, cellLy);
|
|
|
|
//For each pixel in the lower-left quadrant, fill in the corresponding mask value.
|
|
//The other ones are filled by mirroring.
|
|
int i, j;
|
|
double lxHalf = 0.5 * cellLx, lyHalf = 0.5 * cellLy;
|
|
int lxHalfI = tceil(lxHalf), lyHalfI = tceil(lyHalf);
|
|
double val, addValX = radius - lxHalf + 1, addValY = radius - lyHalf + 1;
|
|
|
|
for (i = 0; i < lyHalfI; ++i) {
|
|
line = this->m_mask->pixels(i), lineRev = this->m_mask->pixels(cellLy - i - 1);
|
|
lineEnd = line + cellLx;
|
|
for (j = 0, pix = line, pixRev = lineEnd - 1; j < lxHalfI; ++j, ++pix, --pixRev) {
|
|
val = tcrop(addValX + i, 0.0, 1.0) * tcrop(addValY + j, 0.0, 1.0);
|
|
*pix = *pixRev = val * GRAY::maxChannelValue;
|
|
}
|
|
|
|
memcpy(lineRev, line, cellLx * sizeof(GRAY));
|
|
}
|
|
}
|
|
};
|
|
|
|
template <typename PIXEL, typename GRAY>
|
|
class CircleBuilder : public MaskCellBuilder<PIXEL, GRAY>
|
|
{
|
|
public:
|
|
CircleBuilder(int cellLx, int cellLy, double radius, int wrap)
|
|
: MaskCellBuilder<PIXEL, GRAY>(cellLx, cellLy, radius, wrap)
|
|
{
|
|
//Build the mask corresponding to a square of passed radius
|
|
GRAY *pix, *pixRev, *line, *lineEnd, *lineRev;
|
|
this->m_mask = TRasterPT<GRAY>(cellLx, cellLy);
|
|
|
|
//For each pixel in the lower-left quadrant, fill in the corresponding mask value.
|
|
//The other ones are filled by mirroring.
|
|
int i, j;
|
|
double lxHalf = 0.5 * cellLx, lyHalf = 0.5 * cellLy;
|
|
int lxHalfI = tceil(lxHalf), lyHalfI = tceil(lyHalf);
|
|
double val, addValX = 0.5 - lxHalf, addValY = 0.5 - lyHalf;
|
|
|
|
for (i = 0; i < lyHalfI; ++i) {
|
|
line = this->m_mask->pixels(i), lineRev = this->m_mask->pixels(cellLy - i - 1);
|
|
lineEnd = line + cellLx;
|
|
for (j = 0, pix = line, pixRev = lineEnd - 1; j < lxHalfI; ++j, ++pix, --pixRev) {
|
|
val = tcrop(radius - sqrt(sq(i + addValX) + sq(j + addValY)), 0.0, 1.0);
|
|
*pix = *pixRev = val * GRAY::maxChannelValue;
|
|
}
|
|
|
|
memcpy(lineRev, line, cellLx * sizeof(GRAY));
|
|
}
|
|
}
|
|
};
|
|
|
|
} //namespace mosaic
|
|
|
|
//****************************************************************************
|
|
// Mosaic Fx
|
|
//****************************************************************************
|
|
|
|
class MosaicFx : public TStandardRasterFx
|
|
{
|
|
FX_PLUGIN_DECLARATION(MosaicFx)
|
|
|
|
TRasterFxPort m_input;
|
|
TDoubleParamP m_size;
|
|
TDoubleParamP m_distance;
|
|
TPixelParamP m_bgcolor;
|
|
TIntEnumParamP m_shape;
|
|
|
|
public:
|
|
MosaicFx()
|
|
: m_size(10.0), m_distance(10.0), m_bgcolor(TPixel32::Transparent), m_shape(new TIntEnumParam(0, "Square"))
|
|
{
|
|
m_size->setMeasureName("fxLength");
|
|
m_distance->setMeasureName("fxLength");
|
|
bindParam(this, "size", m_size);
|
|
bindParam(this, "distance", m_distance);
|
|
bindParam(this, "bg_color", m_bgcolor);
|
|
bindParam(this, "shape", m_shape);
|
|
addInputPort("Source", m_input);
|
|
m_size->setValueRange(0.0, (std::numeric_limits<double>::max)());
|
|
m_distance->setValueRange(0.0, (std::numeric_limits<double>::max)());
|
|
m_shape->addItem(1, "Round");
|
|
}
|
|
|
|
~MosaicFx(){};
|
|
|
|
bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info);
|
|
|
|
void doDryCompute(TRectD &rect, double frame, const TRenderSettings &ri);
|
|
void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
|
|
int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info);
|
|
|
|
bool canHandle(const TRenderSettings &info, double frame)
|
|
{
|
|
//We'll return the handled affine only through handledAffine().
|
|
if ((m_size->getValue(frame) + m_distance->getValue(frame)) == 0.0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
TAffine handledAffine(const TRenderSettings &info, double frame)
|
|
{
|
|
//Return the default implementation: only the scale part of the affine
|
|
//can be handled. Rotations and other distortions would need us have to
|
|
//implement diagonal grid lines - and we don't want to!
|
|
//Also, no translational component will be dealt for the same reason.
|
|
TAffine scalePart(TRasterFx::handledAffine(info, frame));
|
|
|
|
//Plus, we want to avoid dealing with antialiases even on plain orthogonal
|
|
//lines! So, we ensure that the step size will be flattened to integer.
|
|
double stepSize = m_size->getValue(frame) + m_distance->getValue(frame);
|
|
double scale = tceil(stepSize * scalePart.a11) / stepSize;
|
|
|
|
return TScale(scale, scale);
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename PIXEL>
|
|
void doMosaic(TRasterPT<PIXEL> ras, TRasterPT<PIXEL> cellsRas, int step, const TPoint &pos,
|
|
TPixel32 bgcolor, mosaic::CellBuilder<PIXEL> &cellBuilder)
|
|
{
|
|
//Perform the mosaic's flattening operation on each grid cell.
|
|
//Cells are identified directly as we traverse the raster.
|
|
|
|
int lx = ras->getLx(), ly = ras->getLy();
|
|
int wrap = ras->getWrap();
|
|
|
|
int cellLx = cellsRas->getLx(), cellLy = cellsRas->getLy(), cellWrap = cellsRas->getWrap();
|
|
int cellX, cellY;
|
|
int x0, y0, x1, y1;
|
|
|
|
PIXEL actualBgColor;
|
|
pixelConvert(actualBgColor, bgcolor);
|
|
|
|
ras->lock();
|
|
cellsRas->lock();
|
|
|
|
PIXEL *buffer = ras->pixels(0);
|
|
PIXEL *cellsBuf = cellsRas->pixels(0);
|
|
for (cellY = 0; cellY < cellLy; ++cellY)
|
|
for (cellX = 0; cellX < cellLx; ++cellX) {
|
|
//Build the cell geometry
|
|
x0 = pos.x + cellX * step, y0 = pos.y + cellY * step;
|
|
x1 = x0 + step, y1 = y0 + step;
|
|
|
|
//Retrieve the cell buffer position and its eventual adjustment
|
|
int u0 = tmax(x0, 0), v0 = tmax(y0, 0);
|
|
int u1 = tmin(x1, lx), v1 = tmin(y1, ly);
|
|
|
|
PIXEL *cb = buffer + u0 + v0 * wrap;
|
|
|
|
u0 -= x0, v0 -= y0, u1 -= x0, v1 -= y0;
|
|
|
|
//Retrieve the cell color
|
|
PIXEL *color = cellsBuf + cellX + cellY * cellWrap;
|
|
|
|
PIXEL cellBGColor = actualBgColor;
|
|
double mFactor = color->m / (double)PIXEL::maxChannelValue;
|
|
cellBGColor.r *= mFactor;
|
|
cellBGColor.g *= mFactor;
|
|
cellBGColor.b *= mFactor;
|
|
cellBGColor.m *= mFactor;
|
|
|
|
cellBuilder.doCell(cb, *color, cellBGColor, u0, v0, u1, v1);
|
|
}
|
|
|
|
cellsRas->unlock();
|
|
ras->unlock();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
bool MosaicFx::doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
|
|
{
|
|
//Remember: info.m_affine MUST NOT BE CONSIDERED in doGetBBox's implementation
|
|
|
|
//Retrieve the input bbox without applied affines.
|
|
|
|
if (!(m_input.getFx() && m_input->doGetBBox(frame, bBox, info)))
|
|
return false;
|
|
|
|
//Now, the grid has a given step size; the fx result is almost the same,
|
|
//except that it must be ceiled to the grid step.
|
|
double step = m_size->getValue(frame) + m_distance->getValue(frame);
|
|
if (!step)
|
|
return true;
|
|
bBox = ::gridAlign(bBox, TPointD(), step);
|
|
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void MosaicFx::doDryCompute(TRectD &rect, double frame, const TRenderSettings &ri)
|
|
{
|
|
if (!m_input.isConnected())
|
|
return;
|
|
|
|
double scale = ri.m_affine.a11; //Legitimate due to handledAffine's implementation
|
|
|
|
double stepD = (m_size->getValue(frame) + m_distance->getValue(frame)) * scale;
|
|
int step = tround(stepD);
|
|
if (step <= 0)
|
|
return;
|
|
|
|
TRectD bboxD;
|
|
m_input->getBBox(frame, bboxD, ri);
|
|
|
|
TRectD tileBoxD(::gridAlign(rect * bboxD, TPointD(), stepD));
|
|
|
|
TRectD srcRectD(
|
|
tround(tileBoxD.x0 / stepD), tround(tileBoxD.y0 / stepD),
|
|
tround(tileBoxD.x1 / stepD), tround(tileBoxD.y1 / stepD));
|
|
|
|
int enlargement =
|
|
(ri.m_quality == TRenderSettings::StandardResampleQuality) ? 1.0 : (ri.m_quality == TRenderSettings::ImprovedResampleQuality) ? 2.0 : (ri.m_quality == TRenderSettings::HighResampleQuality) ? 3.0 : 0.0;
|
|
|
|
srcRectD = srcRectD.enlarge(enlargement);
|
|
|
|
TRenderSettings riLow(ri);
|
|
riLow.m_affine = TScale(1.0 / stepD) * ri.m_affine;
|
|
|
|
m_input->dryCompute(srcRectD, frame, riLow);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void MosaicFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
|
|
{
|
|
if (!m_input.isConnected())
|
|
return;
|
|
|
|
//ri's affine is the one that has already been carried due to upstream geom fxs.
|
|
//It is handled; so, we can transfer geometrical data directly.
|
|
|
|
double scale = ri.m_affine.a11; //Legitimate due to handledAffine's implementation
|
|
|
|
double stepD = (m_size->getValue(frame) + m_distance->getValue(frame)) * scale;
|
|
int step = stepD = tround(stepD);
|
|
if (step <= 0) {
|
|
//No blur will be done. The underlying fx may pass by.
|
|
m_input->compute(tile, frame, ri);
|
|
return;
|
|
}
|
|
|
|
double radius = 0.5 * tcrop(m_size->getValue(frame) * scale, 0.0, stepD);
|
|
|
|
TPixel32 bgcolor = m_bgcolor->getPremultipliedValue(frame);
|
|
|
|
//Build the tile rect.
|
|
TDimension tileSize(tile.getRaster()->getSize());
|
|
TRectD tileRectD(tile.m_pos, TDimensionD(tileSize.lx, tileSize.ly));
|
|
|
|
//Observe that TRasterFx's documentation ensures
|
|
//that passed tile's position is always integer, even if it's double-defined.
|
|
|
|
//Retrieve the input bbox
|
|
TRectD bboxD;
|
|
m_input->getBBox(frame, bboxD, ri);
|
|
|
|
//Build the grid geometry. We require that the source tile is enlarged to cover
|
|
//a full grid step.
|
|
TRectD tileBoxD(::gridAlign(tileRectD * bboxD, TPointD(), stepD));
|
|
|
|
//Now, we'll extract cell colors by computing tileBox with a res-reducing affine.
|
|
//So, the source tile will be
|
|
TRect srcRect(
|
|
tround(tileBoxD.x0 / stepD), tround(tileBoxD.y0 / stepD),
|
|
tround(tileBoxD.x1 / stepD) - 1, tround(tileBoxD.y1 / stepD) - 1);
|
|
|
|
//The calculated source rect must be enlarged by a small amount, since the
|
|
//resample algrotihms add some transparency to the edges.
|
|
int enlargement =
|
|
(ri.m_quality == TRenderSettings::StandardResampleQuality) ? 1 : (ri.m_quality == TRenderSettings::ImprovedResampleQuality) ? 2 : (ri.m_quality == TRenderSettings::HighResampleQuality) ? 3 : 0;
|
|
assert(enlargement > 0);
|
|
|
|
srcRect = srcRect.enlarge(enlargement);
|
|
|
|
TRenderSettings riLow(ri);
|
|
riLow.m_affine = TScale(1.0 / stepD) * ri.m_affine;
|
|
|
|
//Compute the input tile.
|
|
TRasterP srcRas(tile.getRaster()->create(srcRect.getLx(), srcRect.getLy()));
|
|
TTile inTile(srcRas, TPointD(srcRect.x0, srcRect.y0));
|
|
|
|
m_input->compute(inTile, frame, riLow);
|
|
|
|
//Eliminate the enlargement performed above
|
|
TRect r(enlargement, enlargement, srcRas->getLx() - 1 - enlargement, srcRas->getLy() - 1 - enlargement);
|
|
srcRas = srcRas->extract(r);
|
|
|
|
//Now, discriminate the tile's pixel size
|
|
TRaster32P srcRas32(srcRas);
|
|
TRaster64P srcRas64(srcRas);
|
|
|
|
TPoint pos(tround(tileBoxD.x0 - tileRectD.x0), tround(tileBoxD.y0 - tileRectD.y0));
|
|
if (srcRas32) {
|
|
typedef mosaic::CellBuilder<TPixel32> cb;
|
|
cb *cellsBuilder = (m_shape->getValue() == 0) ? (cb *)new mosaic::SquareBuilder<TPixel32, TPixelGR8>(step, step, radius, tile.getRaster()->getWrap()) : (cb *)new mosaic::CircleBuilder<TPixel32, TPixelGR8>(step, step, radius, tile.getRaster()->getWrap());
|
|
|
|
doMosaic<TPixel32>(tile.getRaster(), srcRas32, step, pos, bgcolor, *cellsBuilder);
|
|
|
|
delete cellsBuilder;
|
|
} else if (srcRas64) {
|
|
typedef mosaic::CellBuilder<TPixel64> cb;
|
|
cb *cellsBuilder = (m_shape->getValue() == 0) ? (cb *)new mosaic::SquareBuilder<TPixel64, TPixelGR16>(step, step, radius, tile.getRaster()->getWrap()) : (cb *)new mosaic::CircleBuilder<TPixel64, TPixelGR16>(step, step, radius, tile.getRaster()->getWrap());
|
|
|
|
doMosaic<TPixel64>(tile.getRaster(), srcRas64, step, pos, bgcolor, *cellsBuilder);
|
|
|
|
delete cellsBuilder;
|
|
} else
|
|
assert(false);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
int MosaicFx::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)
|
|
{
|
|
double scale = info.m_affine.a11;
|
|
double stepD = (m_size->getValue(frame) + m_distance->getValue(frame)) * scale;
|
|
|
|
TRectD srcRect(rect.x0 / stepD, rect.y0 / stepD,
|
|
rect.x1 / stepD, rect.y1 / stepD);
|
|
|
|
return TRasterFx::memorySize(srcRect, info.m_bpp);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
FX_PLUGIN_IDENTIFIER(MosaicFx, "mosaicFx");
|