198 lines
5.4 KiB
C++
198 lines
5.4 KiB
C++
|
|
|
|
#ifdef WIN32
|
|
#define NOMINMAX
|
|
#endif
|
|
|
|
#include "texception.h"
|
|
#include "tfxparam.h"
|
|
#include "trop.h"
|
|
#include "stdfx.h"
|
|
#include "trasterfx.h"
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class BlurFx : public TStandardRasterFx
|
|
{
|
|
FX_PLUGIN_DECLARATION(BlurFx)
|
|
|
|
TRasterFxPort m_input;
|
|
TDoubleParamP m_value;
|
|
TBoolParamP m_useSSE;
|
|
|
|
public:
|
|
BlurFx() : m_value(20), m_useSSE(true)
|
|
{
|
|
m_value->setMeasureName("fxLength");
|
|
bindParam(this, "value", m_value);
|
|
bindParam(this, "useSSE", m_useSSE, true);
|
|
|
|
addInputPort("Source", m_input);
|
|
m_value->setValueRange(0, std::numeric_limits<double>::max());
|
|
}
|
|
|
|
~BlurFx(){};
|
|
|
|
bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
|
|
{
|
|
if (m_input.isConnected()) {
|
|
bool ret = m_input->doGetBBox(frame, bBox, info);
|
|
|
|
double blur = fabs(m_value->getValue(frame));
|
|
int brad = tceil(blur);
|
|
bBox = bBox.enlarge(brad);
|
|
|
|
return ret;
|
|
} else {
|
|
bBox = TRectD();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void enlarge(const TRectD &bbox, TRectD &requestedRect, int blur);
|
|
|
|
void transform(
|
|
double frame,
|
|
int port,
|
|
const TRectD &rectOnOutput,
|
|
const TRenderSettings &infoOnOutput,
|
|
TRectD &rectOnInput,
|
|
TRenderSettings &infoOnInput);
|
|
|
|
void doCompute(TTile &tile, double frame, const TRenderSettings &);
|
|
|
|
int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info);
|
|
|
|
bool canHandle(const TRenderSettings &info, double frame)
|
|
{
|
|
if (m_value->getValue(frame) == 0)
|
|
return true;
|
|
return (isAlmostIsotropic(info.m_affine));
|
|
}
|
|
};
|
|
|
|
FX_PLUGIN_IDENTIFIER(BlurFx, "blurFx")
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
//!Calculates the geometry we need for this node computation, given
|
|
//!the known input data (bbox), the requested output (requestedRect) and the blur factor.
|
|
void BlurFx::enlarge(const TRectD &bbox, TRectD &requestedRect, int blur)
|
|
{
|
|
if (bbox.isEmpty() || requestedRect.isEmpty()) {
|
|
requestedRect.empty();
|
|
return;
|
|
}
|
|
|
|
//We are to find out the geometry that is useful for the fx computation.
|
|
//There are some rules to follow:
|
|
// a) First, the interesting output we can generate is bounded by both
|
|
// the requestedRect and the blurred bbox (i.e. enlarged by the blur radius).
|
|
// b) Pixels contributing to any output are necessarily part of bbox - and only
|
|
// those which are blurrable into the requestedRect are useful to us
|
|
// (i.e. pixels contained in its enlargement by the blur radius).
|
|
|
|
TRectD enlargedBBox(bbox.enlarge(blur));
|
|
TRectD enlargedOut(requestedRect.enlarge(blur));
|
|
|
|
TPointD originalP00(requestedRect.getP00());
|
|
requestedRect = (enlargedOut * bbox) + (enlargedBBox * requestedRect);
|
|
|
|
//Finally, make sure that the result is coherent with the original P00
|
|
requestedRect -= originalP00;
|
|
requestedRect.x0 = tfloor(requestedRect.x0);
|
|
requestedRect.y0 = tfloor(requestedRect.y0);
|
|
requestedRect.x1 = tceil(requestedRect.x1);
|
|
requestedRect.y1 = tceil(requestedRect.y1);
|
|
requestedRect += originalP00;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void BlurFx::transform(
|
|
double frame,
|
|
int port,
|
|
const TRectD &rectOnOutput,
|
|
const TRenderSettings &infoOnOutput,
|
|
TRectD &rectOnInput,
|
|
TRenderSettings &infoOnInput)
|
|
{
|
|
infoOnInput = infoOnOutput;
|
|
rectOnInput = rectOnOutput;
|
|
|
|
double blur = fabs(m_value->getValue(frame) * sqrt(fabs(infoOnOutput.m_affine.det())));
|
|
|
|
if (blur == 0) {
|
|
rectOnInput = rectOnOutput;
|
|
return;
|
|
}
|
|
|
|
int brad = tceil(blur);
|
|
TRectD bbox;
|
|
m_input->getBBox(frame, bbox, infoOnInput);
|
|
enlarge(bbox, rectOnInput, brad);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int BlurFx::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)
|
|
{
|
|
double blurValue = fabs(m_value->getValue(frame) * sqrt(fabs(info.m_affine.det())));
|
|
|
|
if (blurValue == 0.0)
|
|
return 0;
|
|
|
|
int brad = tceil(blurValue);
|
|
|
|
//Trop::blur is quite inefficient at the moment - it has to allocate a whole
|
|
//raster of the same size of the input/output made of FLOAT QUADRUPLES...!
|
|
return TRasterFx::memorySize(rect.enlarge(brad), sizeof(float) << 5);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void BlurFx::doCompute(
|
|
TTile &tile,
|
|
double frame,
|
|
const TRenderSettings &renderSettings)
|
|
{
|
|
if (!m_input.isConnected())
|
|
return;
|
|
|
|
double shrink = 0.5 * (renderSettings.m_shrinkX + renderSettings.m_shrinkY);
|
|
// Note: shrink is obsolete. It should be always = 1
|
|
|
|
double blurValue = fabs(m_value->getValue(frame) * sqrt(fabs(renderSettings.m_affine.det())) / shrink);
|
|
|
|
if (blurValue == 0) {
|
|
//No blur will be done. The underlying fx may pass by.
|
|
m_input->compute(tile, frame, renderSettings);
|
|
return;
|
|
}
|
|
|
|
int brad = tceil(blurValue);
|
|
|
|
//Get the requested tile's geometry
|
|
TRectD rectIn, rectOut;
|
|
rectOut = TRectD(
|
|
tile.m_pos, TDimensionD(tile.getRaster()->getLx(), tile.getRaster()->getLy()));
|
|
|
|
//Retrieve the input interesting geometry - and ensure that something actually has
|
|
//to be computed
|
|
if (!m_input->getBBox(frame, rectIn, renderSettings) || rectOut.isEmpty())
|
|
return;
|
|
|
|
enlarge(rectIn, rectOut, brad);
|
|
|
|
if (rectOut.isEmpty())
|
|
return;
|
|
|
|
//Finally, allocate and compute the blur argument
|
|
TTile tileIn;
|
|
m_input->allocateAndCompute(
|
|
tileIn, rectOut.getP00(), TDimension(rectOut.getLx(), rectOut.getLy()),
|
|
tile.getRaster(), frame, renderSettings);
|
|
|
|
TPointD displacement(rectOut.getP00() - tile.m_pos);
|
|
TRop::blur(tile.getRaster(), tileIn.getRaster(), blurValue, displacement.x, displacement.y, false);
|
|
}
|