132 lines
3 KiB
C++
132 lines
3 KiB
C++
|
|
|
|
#include "texception.h"
|
|
#include "tfxparam.h"
|
|
|
|
#include "stdfx.h"
|
|
|
|
namespace
|
|
{
|
|
template <typename T, typename PIXEL>
|
|
void prepare_lut(double max, int edge, vector<T> &lut)
|
|
{
|
|
double aux = (double)PIXEL::maxChannelValue;
|
|
int i = 0;
|
|
for (i = 0; i <= edge; i++) {
|
|
lut[i] = (int)((max / edge) * i);
|
|
}
|
|
for (i = edge + 1; i < PIXEL::maxChannelValue + 1; i++) {
|
|
lut[i] = (int)((max / (edge - aux)) * (i - aux));
|
|
}
|
|
}
|
|
}
|
|
|
|
//===================================================================
|
|
|
|
class SolarizeFx : public TStandardRasterFx
|
|
{
|
|
FX_PLUGIN_DECLARATION(SolarizeFx)
|
|
|
|
TRasterFxPort m_input;
|
|
TDoubleParamP m_maximum;
|
|
TDoubleParamP m_edge;
|
|
|
|
public:
|
|
SolarizeFx()
|
|
: m_maximum(1.0), m_edge(128.0)
|
|
{
|
|
bindParam(this, "maximum", m_maximum);
|
|
bindParam(this, "peak_edge", m_edge);
|
|
addInputPort("Source", m_input);
|
|
//m_value->setValueRange(0, std::numeric_limits<double>::max());
|
|
m_maximum->setValueRange(0.0, 10.0);
|
|
m_edge->setValueRange(0.0, 255.0);
|
|
}
|
|
|
|
~SolarizeFx(){};
|
|
|
|
bool 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;
|
|
}
|
|
}
|
|
|
|
void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
|
|
|
|
bool canHandle(const TRenderSettings &info, double frame) { return true; }
|
|
};
|
|
namespace
|
|
{
|
|
template <typename T>
|
|
void update_param(T ¶m, TRaster32P ras)
|
|
{
|
|
return;
|
|
}
|
|
|
|
template <typename T>
|
|
void update_param(T ¶m, TRaster64P ras)
|
|
{
|
|
param = param * 257;
|
|
return;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <typename PIXEL, typename CHANNEL_TYPE>
|
|
void doSolarize(TRasterPT<PIXEL> ras, double max, int edge)
|
|
{
|
|
vector<CHANNEL_TYPE> solarize_lut(PIXEL::maxChannelValue + 1);
|
|
|
|
update_param(max, ras);
|
|
update_param(edge, ras);
|
|
|
|
prepare_lut<CHANNEL_TYPE, PIXEL>(max, edge, solarize_lut);
|
|
int j;
|
|
ras->lock();
|
|
for (j = 0; j < ras->getLy(); j++) {
|
|
PIXEL *pix = ras->pixels(j);
|
|
PIXEL *endPix = pix + ras->getLx();
|
|
while (pix < endPix) {
|
|
pix->r = (CHANNEL_TYPE)(solarize_lut[(int)(pix->r)]);
|
|
pix->g = (CHANNEL_TYPE)(solarize_lut[(int)(pix->g)]);
|
|
pix->b = (CHANNEL_TYPE)(solarize_lut[(int)(pix->b)]);
|
|
*pix++;
|
|
}
|
|
}
|
|
ras->unlock();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void SolarizeFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
|
|
{
|
|
if (!m_input.isConnected())
|
|
return;
|
|
|
|
m_input->compute(tile, frame, ri);
|
|
|
|
double min, max, step;
|
|
m_maximum->getValueRange(min, max, step);
|
|
double maxValue = 128 * tcrop(m_maximum->getValue(frame), min, max);
|
|
m_edge->getValueRange(min, max, step);
|
|
int edge = (int)tcrop(m_edge->getValue(frame), min, max);
|
|
|
|
TRaster32P raster32 = tile.getRaster();
|
|
if (raster32)
|
|
doSolarize<TPixel32, UCHAR>(raster32, maxValue, edge);
|
|
else {
|
|
TRaster64P raster64 = tile.getRaster();
|
|
if (raster64)
|
|
doSolarize<TPixel64, USHORT>(raster64, maxValue, edge);
|
|
else
|
|
throw TException("SolarizeFx: unsupported Pixel Type");
|
|
}
|
|
}
|
|
|
|
FX_PLUGIN_IDENTIFIER(SolarizeFx, "solarizeFx");
|