#include "tfxparam.h"
#include "tparamset.h"
#include "stdfx.h"
#include "time.h"
#include "trop.h"
#include "trasterfx.h"
#include "ttzpimagefx.h"
#include "toonz/tdistort.h"
#include "texturefxP.h"
//==============================================================================
namespace
{
inline bool myIsEmpty(const TRectD &r)
{
return r.x0 >= r.x1 || r.y0 >= r.y1;
}
}
//==============================================================================
class CornerPinFx : public TStandardRasterFx
{
FX_PLUGIN_DECLARATION(CornerPinFx)
enum { PERSPECTIVE,
BILINEAR };
public:
CornerPinFx();
~CornerPinFx();
bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info);
void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
void doDryCompute(TRectD &rect, double frame, const TRenderSettings &info);
int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info);
void onPortConnected(TFxPort *port);
bool canHandle(const TRenderSettings &info, double frame) { return true; }
bool allowUserCacheOnPort(int port) { return port != 0; }
void transform(double frame,
int port,
const TRectD &rectOnOutput,
const TRenderSettings &infoOnOutput,
TRectD &rectOnInput,
TRenderSettings &infoOnInput);
void safeTransform(
double frame,
int port,
const TRectD &rectOnOutput,
const TRenderSettings &infoOnOutput,
TRectD &rectOnInput,
TRenderSettings &infoOnInput,
TRectD &inBBox);
private:
TRasterFxPort m_input;
TRasterFxPort m_texture;
TIntEnumParamP m_distortType;
TPointParamP m_p00_a;
TPointParamP m_p00_b;
TPointParamP m_p01_a;
TPointParamP m_p01_b;
TPointParamP m_p11_a;
TPointParamP m_p11_b;
TPointParamP m_p10_a;
TPointParamP m_p10_b;
TBoolParamP m_deactivate;
TStringParamP m_string;
TIntEnumParamP m_mode;
TIntEnumParamP m_keep;
TDoubleParamP m_value;
TAffine getPort1Affine(double frame) const;
};
//==============================================================================
CornerPinFx::CornerPinFx()
: m_distortType(new TIntEnumParam(PERSPECTIVE, "Perspective")), m_deactivate(false), m_string(L"1,2,3"), m_mode(new TIntEnumParam(SUBSTITUTE, "Texture")), m_keep(new TIntEnumParam(0, "Delete")), m_value(100)
{
double ext = 400.;
double inn = 400.;
m_p00_a = TPointD(-ext, -ext);
m_p00_b = TPointD(-inn, -inn);
m_p01_a = TPointD(-ext, ext);
m_p01_b = TPointD(-inn, inn);
m_p11_a = TPointD(ext, ext);
m_p11_b = TPointD(inn, inn);
m_p10_a = TPointD(ext, -ext);
m_p10_b = TPointD(inn, -inn);
m_p00_b->getX()->setMeasureName("fxLength");
m_p00_b->getY()->setMeasureName("fxLength");
m_p10_b->getX()->setMeasureName("fxLength");
m_p10_b->getY()->setMeasureName("fxLength");
m_p01_b->getX()->setMeasureName("fxLength");
m_p01_b->getY()->setMeasureName("fxLength");
m_p11_b->getX()->setMeasureName("fxLength");
m_p11_b->getY()->setMeasureName("fxLength");
m_p00_a->getX()->setMeasureName("fxLength");
m_p00_a->getY()->setMeasureName("fxLength");
m_p10_a->getX()->setMeasureName("fxLength");
m_p10_a->getY()->setMeasureName("fxLength");
m_p01_a->getX()->setMeasureName("fxLength");
m_p01_a->getY()->setMeasureName("fxLength");
m_p11_a->getX()->setMeasureName("fxLength");
m_p11_a->getY()->setMeasureName("fxLength");
bindParam(this, "distort_type", m_distortType);
bindParam(this, "bottom_left_b", m_p00_b);
bindParam(this, "bottom_right_b", m_p10_b);
bindParam(this, "top_left_b", m_p01_b);
bindParam(this, "top_right_b", m_p11_b);
bindParam(this, "bottom_left_a", m_p00_a);
bindParam(this, "bottom_right_a", m_p10_a);
bindParam(this, "top_left_a", m_p01_a);
bindParam(this, "top_right_a", m_p11_a);
bindParam(this, "deactivate", m_deactivate);
bindParam(this, "indexes", m_string);
bindParam(this, "mode", m_mode);
bindParam(this, "keep", m_keep);
bindParam(this, "value", m_value);
addInputPort("source", m_input);
addInputPort("Texture", m_texture);
m_value->setValueRange(0, 100);
m_keep->addItem(1, "Keep");
m_mode->addItem(PATTERNTYPE, "Pattern");
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");
m_p00_a->getX()->setValueRange(-1000, 1000);
m_p00_b->getX()->setValueRange(-1000, 1000);
m_p00_a->getY()->setValueRange(-1000, 1000);
m_p00_b->getY()->setValueRange(-1000, 1000);
m_p01_a->getX()->setValueRange(-1000, 1000);
m_p01_b->getX()->setValueRange(-1000, 1000);
m_p01_a->getY()->setValueRange(-1000, 1000);
m_p01_b->getY()->setValueRange(-1000, 1000);
m_p11_a->getX()->setValueRange(-1000, 1000);
m_p11_b->getX()->setValueRange(-1000, 1000);
m_p11_a->getY()->setValueRange(-1000, 1000);
m_p11_b->getY()->setValueRange(-1000, 1000);
m_p10_a->getX()->setValueRange(-1000, 1000);
m_p10_b->getX()->setValueRange(-1000, 1000);
m_p10_a->getY()->setValueRange(-1000, 1000);
m_p10_b->getY()->setValueRange(-1000, 1000);
m_distortType->addItem(BILINEAR, "Bilinear");
}
// ------------------------------------------------------------------------
CornerPinFx::~CornerPinFx()
{
}
// ------------------------------------------------------------------------
bool CornerPinFx::doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
{
if (m_input.isConnected()) {
bool ret = m_input->doGetBBox(frame, bBox, info);
return ret;
} else {
bBox = TRectD();
return false;
}
}
// ------------------------------------------------------------------------
TAffine CornerPinFx::getPort1Affine(double frame) const
{
//Explanation: Fxs tree decomposition on n-ary fxs (n>1) works the following way.
//Fxs on port 0 are considered 'column representants' - so affines found on them
//must be passed throughout the tree hierarchy. Therefore, their inverses are multiplied
//just below the other input ports in order to push the former affine above.
//In other words:
// port 0: A -| ---|
// +-- => + A --
// port >0: B -| B - (Ainv) -|
//Retrieve the affine that lies just below texture's port.
TGeometryFx *AinvFx = dynamic_cast<TGeometryFx *>(m_texture.getFx());
if (!AinvFx)
return TAffine();
TGeometryFx *BFx = dynamic_cast<TGeometryFx *>(AinvFx->getInputPort(0)->getFx());
if (!BFx)
return AinvFx->getPlacement(frame);
return AinvFx->getPlacement(frame) * BFx->getPlacement(frame);
}
// ------------------------------------------------------------------------
void CornerPinFx::transform(
double frame,
int port,
const TRectD &rectOnOutput,
const TRenderSettings &infoOnOutput,
TRectD &rectOnInput,
TRenderSettings &infoOnInput)
{
//Build the input affine
infoOnInput = infoOnOutput;
TPointD p00_b = m_p00_b->getValue(frame);
TPointD p10_b = m_p10_b->getValue(frame);
TPointD p01_b = m_p01_b->getValue(frame);
TPointD p11_b = m_p11_b->getValue(frame);
TPointD p00_a = m_p00_a->getValue(frame);
TPointD p10_a = m_p10_a->getValue(frame);
TPointD p01_a = m_p01_a->getValue(frame);
TPointD p11_a = m_p11_a->getValue(frame);
//NOTE 1: An appropriate scale factor is sent below in the schematic, depending
//on the image distortion. For example, if the distortion brings a 2 scale factor,
//we want the same factor applied on image levels, so that their detail is appropriate
//(especially for vector images).
double scale = 0;
scale = tmax(scale, norm(p10_a - p00_a) / norm(p10_b - p00_b));
scale = tmax(scale, norm(p01_a - p00_a) / norm(p01_b - p00_b));
scale = tmax(scale, norm(p11_a - p10_a) / norm(p11_b - p10_b));
scale = tmax(scale, norm(p11_a - p01_a) / norm(p11_b - p01_b));
TAffine A_1B(getPort1Affine(frame));
TAffine B(infoOnOutput.m_affine * A_1B);
scale *= sqrt(fabs(B.det()));
if (infoOnOutput.m_isSwatch) {
//Swatch viewers work out a lite version of the distort: only contractions
//are passed below in the schematic - so that input memory load is always at minimum.
//This is allowed in order to make fx adjusts the less frustrating as possible.
if (scale > 1)
scale = 1;
}
//NOTE 2: We further include A_1B.inv() to be applied on the level. This is done to
//counter the presence of A_1B just below this node - since it is preferable to place A_1B
//directly in the distort.
infoOnInput.m_affine = TScale(scale) * A_1B.inv();
//rectOnInput = (TScale(scale) * B.inv()) * rectOnOutput;
//NOTE 3: The original distortion points are intended on the source port *before* applying A.
//But we want to have them on texture port *before* applying B; so, the following ref change arises:
// p_b = (TScale(scale) * A_1B.inv()) * p_b == infoOnInput.m_aff * p_b;
// p_a = (B * A_1B.inv()) * p_a == infoOnOutput.m_aff * p_a;
//Observe that scale and B are here due to NOTES 1 and 2.
//Build rectOnInput
p00_a = infoOnOutput.m_affine * p00_a;
p10_a = infoOnOutput.m_affine * p10_a;
p01_a = infoOnOutput.m_affine * p01_a;
p11_a = infoOnOutput.m_affine * p11_a;
p00_b = infoOnInput.m_affine * p00_b;
p10_b = infoOnInput.m_affine * p10_b;
p01_b = infoOnInput.m_affine * p01_b;
p11_b = infoOnInput.m_affine * p11_b;
if (m_distortType->getValue() == PERSPECTIVE) {
PerspectiveDistorter pd(
p00_b, p10_b, p01_b, p11_b,
p00_a, p10_a, p01_a, p11_a);
rectOnInput = ((TQuadDistorter *)&pd)->invMap(rectOnOutput);
} else {
BilinearDistorter bd(
p00_b, p10_b, p01_b, p11_b,
p00_a, p10_a, p01_a, p11_a);
rectOnInput = ((TQuadDistorter *)&bd)->invMap(rectOnOutput);
}
if (rectOnInput.x0 != TConsts::infiniteRectD.x0)
rectOnInput.x0 = tfloor(rectOnInput.x0);
if (rectOnInput.y0 != TConsts::infiniteRectD.y0)
rectOnInput.y0 = tfloor(rectOnInput.y0);
if (rectOnInput.x1 != TConsts::infiniteRectD.x1)
rectOnInput.x1 = tceil(rectOnInput.x1);
if (rectOnInput.y1 != TConsts::infiniteRectD.y1)
rectOnInput.y1 = tceil(rectOnInput.y1);
}
// ------------------------------------------------------------------------
void CornerPinFx::safeTransform(
double frame,
int port,
const TRectD &rectOnOutput,
const TRenderSettings &infoOnOutput,
TRectD &rectOnInput,
TRenderSettings &infoOnInput,
TRectD &inBBox)
{
assert(port == 1 && m_texture.isConnected());
if (m_deactivate->getValue()) {
infoOnInput = infoOnOutput;
rectOnInput = rectOnOutput;
m_texture->getBBox(frame, inBBox, infoOnInput);
return;
}
//Avoid the singular matrix cases
if (fabs(infoOnOutput.m_affine.det()) < 1.e-3) {
infoOnInput = infoOnOutput;
rectOnInput.empty();
m_texture->getBBox(frame, inBBox, infoOnInput);
return;
}
transform(frame, port, rectOnOutput, infoOnOutput, rectOnInput, infoOnInput);
m_texture->getBBox(frame, inBBox, infoOnInput);
//In case inBBox is infinite, such as with gradients, also intersect with the input quadrilateral's bbox
if (inBBox == TConsts::infiniteRectD) {
TPointD affP00_b(infoOnInput.m_affine * m_p00_b->getValue(frame));
TPointD affP10_b(infoOnInput.m_affine * m_p10_b->getValue(frame));
TPointD affP01_b(infoOnInput.m_affine * m_p01_b->getValue(frame));
TPointD affP11_b(infoOnInput.m_affine * m_p11_b->getValue(frame));
TRectD source;
source.x0 = tmin(affP00_b.x, affP10_b.x, affP01_b.x, affP11_b.x);
source.y0 = tmin(affP00_b.y, affP10_b.y, affP01_b.y, affP11_b.y);
source.x1 = tmax(affP00_b.x, affP10_b.x, affP01_b.x, affP11_b.x);
source.y1 = tmax(affP00_b.y, affP10_b.y, affP01_b.y, affP11_b.y);
rectOnInput *= source;
}
}
// ------------------------------------------------------------------------
void CornerPinFx::doDryCompute(TRectD &rect, double frame, const TRenderSettings &ri)
{
if (!m_input.isConnected())
return;
vector<string> items;
string indexes = toString(m_string->getValue());
parseIndexes(indexes, items);
TRenderSettings ri2(ri);
PaletteFilterFxRenderData *PaletteFilterData = new PaletteFilterFxRenderData;
TRasterFxRenderDataP smartP(PaletteFilterData);
insertIndexes(items, PaletteFilterData);
PaletteFilterData->m_keep = (m_keep->getValue() == 1);
ri2.m_data.push_back(PaletteFilterData);
ri2.m_userCachable = false;
//First child compute: part of output that IS NOT texturized
m_input->dryCompute(rect, frame, ri2);
if (!m_texture.isConnected())
return;
bool isSwatch = ri2.m_isSwatch;
if (isSwatch)
ri2.m_isSwatch = false;
PaletteFilterData->m_keep = !(m_keep->getValue() == 1);
//Second child compute: part of output that IS to be texturized
m_input->dryCompute(rect, frame, ri2);
//Deal with the texture
if (m_deactivate->getValue())
m_texture->dryCompute(rect, frame, ri);
else {
TRectD inRect;
TRenderSettings riNew;
TRectD inBBox;
safeTransform(frame, 1, rect, ri, inRect, riNew, inBBox);
inRect *= inBBox;
if (myIsEmpty(inRect))
return;
m_texture->dryCompute(inRect, frame, riNew);
}
}
// ------------------------------------------------------------------------
void CornerPinFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
if (!m_input.isConnected()) {
tile.getRaster()->clear();
return;
}
TTile invertMaskTile;
//carico il vettore items con gli indici dei colori
vector<string> items;
string indexes = toString(m_string->getValue());
parseIndexes(indexes, items);
//genero il tile il cui raster contiene l'immagine in input a cui sono stati tolti i pixel
//colorati con gli indici contenuti nel vettore items
TRenderSettings ri2(ri);
PaletteFilterFxRenderData *PaletteFilterData = new PaletteFilterFxRenderData;
TRasterFxRenderDataP smartP(PaletteFilterData);
insertIndexes(items, PaletteFilterData);
PaletteFilterData->m_keep = (m_keep->getValue() == 1);
ri2.m_data.push_back(PaletteFilterData);
ri2.m_userCachable = false;
m_input->allocateAndCompute(invertMaskTile, tile.m_pos, tile.getRaster()->getSize(), tile.getRaster(), frame, ri2);
if (!m_texture.isConnected()) {
tile.getRaster()->copy(invertMaskTile.getRaster());
return;
}
//genero il tile il cui raster contiene l'immagine in input a cui sono stati tolti i pixel
//colorati con indici diversi da quelli contenuti nel vettore items
bool isSwatch = ri2.m_isSwatch;
if (isSwatch)
ri2.m_isSwatch = false;
PaletteFilterData->m_keep = !(m_keep->getValue() == 1);
m_input->compute(tile, frame, ri2);
if (isSwatch)
ri2.m_isSwatch = true;
//controllo se ho ottenuto quaclosa su cui si possa lavorare.
TRect saveBox;
TRop::computeBBox(tile.getRaster(), saveBox);
if (saveBox.isEmpty()) {
//I guess that this case should be wiped out...
m_input->compute(tile, frame, ri); //Could the invertMask be copied??
return;
}
//Then, generate the texture tile and make its distortion
TTile textureTile;
if (m_deactivate->getValue()) {
TDimension size = tile.getRaster()->getSize();
TPointD pos = tile.m_pos;
m_texture->allocateAndCompute(textureTile, pos, size, tile.getRaster(), frame, ri);
} else {
//Build the interesting texture region
TRasterP tileRas(tile.getRaster());
TRectD tileRect(convert(tileRas->getBounds()) + tile.m_pos);
TRectD inRect;
TRenderSettings riNew;
TRectD inBBox;
safeTransform(frame, 1, tileRect, ri, inRect, riNew, inBBox);
inRect *= inBBox;
if (myIsEmpty(inRect))
return;
TDimension inRectSize(tceil(inRect.getLx()), tceil(inRect.getLy()));
TTile inTile;
m_texture->allocateAndCompute(inTile, inRect.getP00(), inRectSize, tileRas, frame, riNew);
//Get the source quad
TPointD p00_b = m_p00_b->getValue(frame);
TPointD p10_b = m_p10_b->getValue(frame);
TPointD p01_b = m_p01_b->getValue(frame);
TPointD p11_b = m_p11_b->getValue(frame);
//Get destination quad
TPointD p00_a = m_p00_a->getValue(frame);
TPointD p10_a = m_p10_a->getValue(frame);
TPointD p01_a = m_p01_a->getValue(frame);
TPointD p11_a = m_p11_a->getValue(frame);
double scale = 0;
scale = tmax(scale, norm(p10_a - p00_a) / norm(p10_b - p00_b));
scale = tmax(scale, norm(p01_a - p00_a) / norm(p01_b - p00_b));
scale = tmax(scale, norm(p11_a - p10_a) / norm(p11_b - p10_b));
scale = tmax(scale, norm(p11_a - p01_a) / norm(p11_b - p01_b));
TAffine A_1B(getPort1Affine(frame));
TAffine B(ri.m_affine * A_1B);
scale *= sqrt(fabs(B.det()));
if (ri.m_isSwatch)
if (scale > 1)
scale = 1;
p00_b = riNew.m_affine * p00_b;
p10_b = riNew.m_affine * p10_b;
p01_b = riNew.m_affine * p01_b;
p11_b = riNew.m_affine * p11_b;
p00_a = ri.m_affine * p00_a;
p10_a = ri.m_affine * p10_a;
p01_a = ri.m_affine * p01_a;
p11_a = ri.m_affine * p11_a;
PerspectiveDistorter perpDistorter(
p00_b - inTile.m_pos, p10_b - inTile.m_pos, p01_b - inTile.m_pos, p11_b - inTile.m_pos,
p00_a, p10_a, p01_a, p11_a);
BilinearDistorter bilDistorter(
p00_b - inTile.m_pos, p10_b - inTile.m_pos, p01_b - inTile.m_pos, p11_b - inTile.m_pos,
p00_a, p10_a, p01_a, p11_a);
TDistorter *distorter;
if (m_distortType->getValue() == PERSPECTIVE)
distorter = &perpDistorter;
else if (m_distortType->getValue() == BILINEAR)
distorter = &bilDistorter;
else
assert(0);
TRasterP textureRas(tileRas->create(tileRas->getLx(), tileRas->getLy()));
distort(textureRas, inTile.getRaster(), *distorter, convert(tile.m_pos), TRop::Bilinear);
textureTile.m_pos = tile.m_pos;
textureTile.setRaster(textureRas);
}
//Then, apply the texture
double v = m_value->getValue(frame);
if (ri.m_bpp == 32) {
TRaster32P witheCard;
myOver32(tile.getRaster(), invertMaskTile.getRaster(), &makeOpaque<TPixel32>, v);
switch (m_mode->getValue()) {
case SUBSTITUTE:
myOver32(tile.getRaster(), textureTile.getRaster(), &substitute<TPixel32>, v);
CASE PATTERNTYPE : witheCard = TRaster32P(textureTile.getRaster()->getSize());
witheCard->fill(TPixel32::White);
TRop::over(textureTile.getRaster(), witheCard, textureTile.getRaster());
myOver32(tile.getRaster(), textureTile.getRaster(), &pattern32, v);
CASE ADD : myOver32(tile.getRaster(), textureTile.getRaster(), &textureAdd<TPixel32>, v / 100.0);
CASE SUBTRACT : myOver32(tile.getRaster(), textureTile.getRaster(), &textureSub<TPixel32>, v / 100.0);
CASE MULTIPLY : myOver32(tile.getRaster(), textureTile.getRaster(), &textureMult<TPixel32>, v);
CASE DARKEN : myOver32(tile.getRaster(), textureTile.getRaster(), &textureDarken<TPixel32>, v);
CASE LIGHTEN : myOver32(tile.getRaster(), textureTile.getRaster(), &textureLighten<TPixel32>, v);
DEFAULT:
assert(0);
}
} else {
TRaster64P witheCard;
myOver64(tile.getRaster(), invertMaskTile.getRaster(), &makeOpaque<TPixel64>, v);
switch (m_mode->getValue()) {
case SUBSTITUTE:
myOver64(tile.getRaster(), textureTile.getRaster(), &substitute<TPixel64>, v);
CASE PATTERNTYPE : witheCard = TRaster64P(textureTile.getRaster()->getSize());
witheCard->fill(TPixel64::White);
TRop::over(textureTile.getRaster(), witheCard, textureTile.getRaster());
myOver64(tile.getRaster(), textureTile.getRaster(), &pattern64, v);
CASE ADD : myOver64(tile.getRaster(), textureTile.getRaster(), &textureAdd<TPixel64>, v / 100.0);
CASE SUBTRACT : myOver64(tile.getRaster(), textureTile.getRaster(), &textureSub<TPixel64>, v / 100.0);
CASE MULTIPLY : myOver64(tile.getRaster(), textureTile.getRaster(), &textureMult<TPixel64>, v);
CASE DARKEN : myOver64(tile.getRaster(), textureTile.getRaster(), &textureDarken<TPixel64>, v);
CASE LIGHTEN : myOver64(tile.getRaster(), textureTile.getRaster(), &textureLighten<TPixel64>, v);
DEFAULT:
assert(0);
}
}
TRop::over(tile.getRaster(), invertMaskTile.getRaster());
}
//-------------------------------------------------------------------------
int CornerPinFx::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)
{
if (!m_texture.isConnected())
return TRasterFx::memorySize(rect, info.m_bpp);
TRectD inRect;
TRenderSettings riNew;
TRectD inBBox;
safeTransform(frame, 1, rect, info, inRect, riNew, inBBox);
inRect *= inBBox;
return tmax(TRasterFx::memorySize(rect, info.m_bpp), TRasterFx::memorySize(inRect, riNew.m_bpp));
}
//-------------------------------------------------------------------------
/*
TRectD CornerPinFx::getContainingBox(const FourPoints &points)
{
if(points.m_p00==points.m_p01 && points.m_p01==points.m_p10 && points.m_p10==points.m_p11)
return TRectD(points.m_p00,points.m_p00);
double xMax=tmax(points.m_p00.x,points.m_p01.x,points.m_p10.x,points.m_p11.x);
double yMax=tmax(points.m_p00.y,points.m_p01.y,points.m_p10.y,points.m_p11.y);
double xMin=tmin(points.m_p00.x,points.m_p01.x,points.m_p10.x,points.m_p11.x);
double yMin=tmin(points.m_p00.y,points.m_p01.y,points.m_p10.y,points.m_p11.y);
return TRectD(xMin,yMin,xMax, yMax);
}
*/
// ------------------------------------------------------------------------
FX_PLUGIN_IDENTIFIER(CornerPinFx, "cornerPinFx");