/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void TimeShiftPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
switch( context )
{
case OFX::eContextRetimer:
{
OFX::DoubleParamDescriptor* retimerParam = desc.defineDoubleParam( kOfxImageEffectRetimerParamName );
retimerParam->setLabel( "Source Time" );
retimerParam->setDefault( 0.0 );
break;
}
default:
{
OFX::DoubleParamDescriptor* offset = desc.defineDoubleParam( kParamOffset );
offset->setLabel( "Offset" );
offset->setDefault( 0.0 );
offset->setDisplayRange( -10, 10 );
break;
}
}
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void TextPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( kSupportTiles );
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
OFX::StringParamDescriptor* text = desc.defineStringParam( kText );
text->setLabel( "Text" );
text->setStringType( OFX::eStringTypeMultiLine );
OFX::StringParamDescriptor* font = desc.defineStringParam( kFont );
font->setLabel( "Font file" );
font->setStringType( OFX::eStringTypeFilePath );
font->setDefault( "/usr/share/fonts/truetype/msttcorefonts/arial.ttf" );
OFX::IntParamDescriptor* size = desc.defineIntParam( kSize );
size->setLabel( "Size" );
size->setDefault( 18 );
size->setRange( 0, std::numeric_limits<int>::max() );
size->setDisplayRange( 0, 60 );
OFX::DoubleParamDescriptor* ratio = desc.defineDoubleParam( kRatio );
ratio->setLabel( "Ratio" );
ratio->setRange( 0.0, std::numeric_limits<double>::max() );
ratio->setDisplayRange( 0.0, 2.0 );
ratio->setDefault( 1.0 );
OFX::RGBAParamDescriptor* color = desc.defineRGBAParam( kColor );
color->setLabel( "Color" );
color->setDefault( 1.0, 1.0, 1.0, 1.0 );
OFX::Double2DParamDescriptor* position = desc.defineDouble2DParam( kPosition );
position->setLabel( "Position" );
position->setDefault( 0.0, 0.0 );
OFX::DoubleParamDescriptor* letterSpacing = desc.defineDoubleParam( kLetterSpacing );
letterSpacing->setLabel( "Letter spacing" );
letterSpacing->setDisplayRange( -10.0, 10.0 );
letterSpacing->setDefault( 0.0 );
OFX::BooleanParamDescriptor* verticalFlip = desc.defineBooleanParam( kVerticalFlip );
verticalFlip->setLabel( "Vertical flip" );
verticalFlip->setDefault( false );
verticalFlip->setAnimates( false );
verticalFlip->setHint( "Some hosts use inverted images, so you can correct this problem using this flag." );
}
void
OFX::shutterDescribeInContext(OFX::ImageEffectDescriptor &desc,
OFX::ContextEnum /*context*/,
OFX::PageParamDescriptor* page)
{
// shutter
{
DoubleParamDescriptor* param = desc.defineDoubleParam(kParamShutter);
param->setLabel(kParamShutterLabel);
param->setHint(kParamShutterHint);
param->setDefault(0.5);
param->setRange(0., 2.);
param->setIncrement(0.01);
param->setDisplayRange(0., 2.);
if (page) {
page->addChild(*param);
}
}
// shutteroffset
{
ChoiceParamDescriptor* param = desc.defineChoiceParam(kParamShutterOffset);
param->setLabel(kParamShutterOffsetLabel);
param->setHint(kParamShutterOffsetHint);
assert(param->getNOptions() == eShutterOffsetCentered);
param->appendOption(kParamShutterOffsetOptionCentered, kParamShutterOffsetOptionCenteredHint);
assert(param->getNOptions() == eShutterOffsetStart);
param->appendOption(kParamShutterOffsetOptionStart, kParamShutterOffsetOptionStartHint);
assert(param->getNOptions() == eShutterOffsetEnd);
param->appendOption(kParamShutterOffsetOptionEnd, kParamShutterOffsetOptionEndHint);
assert(param->getNOptions() == eShutterOffsetCustom);
param->appendOption(kParamShutterOffsetOptionCustom, kParamShutterOffsetOptionCustomHint);
param->setAnimates(true);
param->setDefault(eShutterOffsetStart);
if (page) {
page->addChild(*param);
}
}
// shuttercustomoffset
{
DoubleParamDescriptor* param = desc.defineDoubleParam(kParamShutterCustomOffset);
param->setLabel(kParamShutterCustomOffsetLabel);
param->setHint(kParamShutterCustomOffsetHint);
param->setDefault(0.);
param->setRange(-1., 1.);
param->setIncrement(0.1);
param->setDisplayRange(-1., 1.);
if (page) {
page->addChild(*param);
}
}
} // shutterDescribeInContext
void CrossFadeExamplePluginFactory::describeInContext(OFX::ImageEffectDescriptor &desc, ContextEnum /*context*/)
{
// we are a transition, so define the sourceFrom input clip
ClipDescriptor *fromClip = desc.defineClip(kOfxImageEffectTransitionSourceFromClipName);
fromClip->addSupportedComponent(ePixelComponentRGBA);
fromClip->addSupportedComponent(ePixelComponentAlpha);
fromClip->setTemporalClipAccess(false);
fromClip->setSupportsTiles(true);
// we are a transition, so define the sourceTo input clip
ClipDescriptor *toClip = desc.defineClip(kOfxImageEffectTransitionSourceToClipName);
toClip->addSupportedComponent(ePixelComponentRGBA);
toClip->addSupportedComponent(ePixelComponentAlpha);
toClip->setTemporalClipAccess(false);
toClip->setSupportsTiles(true);
// create the mandated output clip
ClipDescriptor *dstClip = desc.defineClip(kOfxImageEffectOutputClipName);
dstClip->addSupportedComponent(ePixelComponentRGBA);
dstClip->addSupportedComponent(ePixelComponentAlpha);
dstClip->setSupportsTiles(true);
// Define the mandated "Transition" param, note that we don't do anything with this other than.
// describe it. It is not a true param but how the host indicates to the plug-in how far through
// the transition it is. It appears on no plug-in side UI, it is purely the hosts to manage.
DoubleParamDescriptor *param = desc.defineDoubleParam("Transition");
(void)param;
}
/** @brief describe a double param */
void describeDoubleParam(OFX::ImageEffectDescriptor &desc, const std::string &name, DoubleTypeEnum doubleType,
double min, double max, PageParamDescriptor *page)
{
DoubleParamDescriptor *param = desc.defineDoubleParam(name);
param->setLabels(name, name, name);
param->setScriptName(name);
param->setHint("A double parameter");
param->setDefault(0);
param->setRange(min, max);
param->setDisplayRange(min, max);
param->setDoubleType(doubleType);
page->addChild(*param);
}
void NoiseExamplePluginFactory::describeInContext(OFX::ImageEffectDescriptor &desc, ContextEnum context)
{
ClipDescriptor *dstClip = desc.defineClip("Output");
dstClip->addSupportedComponent(ePixelComponentRGBA);
dstClip->addSupportedComponent(ePixelComponentAlpha);
dstClip->setSupportsTiles(true);
dstClip->setFieldExtraction(eFieldExtractSingle);
DoubleParamDescriptor *param = desc.defineDoubleParam("Noise");
param->setLabels("noise", "noise", "noise");
param->setScriptName("noise");
param->setHint("How much noise to make.");
param->setDefault(0.2);
param->setRange(0, 10);
param->setIncrement(0.1);
param->setDisplayRange(0, 1);
param->setAnimates(true); // can animate
param->setDoubleType(eDoubleTypeScale);
PageParamDescriptor *page = desc.definePageParam("Controls");
page->addChild(*param);
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void ConvolutionPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( kSupportTiles );
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
OFX::Int2DParamDescriptor* size = desc.defineInt2DParam( kParamSize );
size->setLabel( "Size" );
size->setDefault( 3, 3 );
// size->setIncrement( 2, 2 );
size->setRange( 3, 3, kParamSizeMax, kParamSizeMax );
OFX::ChoiceParamDescriptor* border = desc.defineChoiceParam( kParamBorder );
border->setLabel( "Border" );
border->appendOption( kParamBorderMirror );
border->appendOption( kParamBorderConstant );
border->appendOption( kParamBorderBlack );
border->appendOption( kParamBorderPadded );
for( unsigned int y = 0; y < kParamSizeMax; ++y )
{
for( unsigned int x = 0; x < kParamSizeMax; ++x )
{
const std::string name( getCoefName( y, x ) );
OFX::DoubleParamDescriptor* coef = desc.defineDoubleParam( name );
coef->setLabel( name );
coef->setDisplayRange( -10.0, 10.0 );
coef->setDefault( 0.0 );
}
}
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void ColorTransferPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
// srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( true );
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
// dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( true );
OFX::ClipDescriptor* srcRefClip = desc.defineClip( kClipSrcRef );
srcRefClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcRefClip->addSupportedComponent( OFX::ePixelComponentRGB );
// srcRefClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcRefClip->setSupportsTiles( false );
srcRefClip->setOptional( true );
OFX::ClipDescriptor* dstRefClip = desc.defineClip( kClipDstRef );
dstRefClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstRefClip->addSupportedComponent( OFX::ePixelComponentRGB );
// dstRefClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstRefClip->setSupportsTiles( false );
OFX::ChoiceParamDescriptor* colorspace = desc.defineChoiceParam( kParamColorspace );
colorspace->setLabel( "Transformation colorspace" );
colorspace->setHint( "Select colorspace in which to apply the transformation" );
colorspace->appendOption( kParamColorspaceNone, "without colorspace transformation" );
colorspace->appendOption( kParamColorspaceLMS, "apply correction in LMS colorspace" );
colorspace->appendOption( kParamColorspaceLab, "apply correction in L(alpha)(beta) colorspace" );
colorspace->setDefault( eColorspaceLab );
OFX::DoubleParamDescriptor* averageCoef = desc.defineDoubleParam( kParamAverageCoef );
averageCoef->setLabel( "Average color coef" );
averageCoef->setDisplayRange( 0.0, 1.0 );
averageCoef->setDefault( 0.8 );
averageCoef->setHint(
"Percentage of correction of the average color.\n"
"It is often advantageous to reduce this ratio, "
"especially if the two images are very different. "
"Typical values are between 0.5 and 0.8."
);
OFX::DoubleParamDescriptor* dynamicCoef = desc.defineDoubleParam( kParamDynamicCoef );
dynamicCoef->setLabel( "Dynamic coef" );
dynamicCoef->setDisplayRange( 0.0, 1.0 );
dynamicCoef->setDefault( 1.0 );
dynamicCoef->setHint(
"Percentage of correction of the standard deviation."
);
// // output region
// OFX::Double2DParamDescriptor* regionA = desc.defineDouble2DParam( kParamRegionA );
// regionA->setLabel( "Region" );
// regionA->setDefault( -0.5, -0.5 );
// regionA->setIsSecret( true ); ///< @todo
// OFX::Double2DParamDescriptor* regionB = desc.defineDouble2DParam( kParamRegionB );
// regionB->setLabel( "" );
// regionB->setDefault( 0.5, 0.5 );
// regionB->setIsSecret( true ); ///< @todo
//
// // same region
// OFX::BooleanParamDescriptor* sameRegion = desc.defineBooleanParam( kParamSameRegion );
// sameRegion->setDefault( true );
// sameRegion->setIsSecret( true ); ///< @todo
//
// // input region
// OFX::Double2DParamDescriptor* inputRegionA = desc.defineDouble2DParam( kParamInputRegionA );
// inputRegionA->setLabel( "Input region" );
// inputRegionA->setDefault( -0.5, -0.5 );
// inputRegionA->setIsSecret( true ); ///< @todo
// OFX::Double2DParamDescriptor* inputRegionB = desc.defineDouble2DParam( kParamInputRegionB );
// inputRegionB->setLabel( "" );
// inputRegionB->setDefault( 0.5, 0.5 );
// inputRegionB->setIsSecret( true ); ///< @todo
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void TextPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( kSupportTiles );
srcClip->setOptional(true);
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
OFX::StringParamDescriptor* text = desc.defineStringParam( kParamText );
text->setLabel( "Text" );
text->setStringType( OFX::eStringTypeMultiLine );
OFX::BooleanParamDescriptor* isExpression = desc.defineBooleanParam( kParamIsExpression );
isExpression->setLabel( "Expression" );
isExpression->setHint( "If you check this parameter the text must be a python code.\n"
"The final result must be in a variable with the name of the parameter.\n"
"Example:\n"
"from math import *\n"
//+ kParamText +
"text = 'At frame '+str(time)+', value is ' + str( sin(time) )\n" );
isExpression->setDefault( false );
OFX::StringParamDescriptor* font = desc.defineStringParam( kParamFont );
font->setLabel( "Font file" );
font->setStringType( OFX::eStringTypeFilePath );
font->setDefault( "/usr/share/fonts/truetype/msttcorefonts/arial.ttf" );
OFX::IntParamDescriptor* size = desc.defineIntParam( kParamSize );
size->setLabel( "Size" );
size->setDefault( 18 );
size->setRange( 0, std::numeric_limits<int>::max() );
size->setDisplayRange( 0, 60 );
OFX::DoubleParamDescriptor* ratio = desc.defineDoubleParam( kParamRatio );
ratio->setLabel( "Ratio" );
ratio->setRange( 0.0, std::numeric_limits<double>::max() );
ratio->setDisplayRange( 0.0, 2.0 );
ratio->setDefault( 1.0 );
OFX::RGBAParamDescriptor* color = desc.defineRGBAParam( kParamColor );
color->setLabel( "Color" );
color->setDefault( 1.0, 1.0, 1.0, 1.0 );
OFX::Double2DParamDescriptor* position = desc.defineDouble2DParam( kParamPosition );
position->setLabel( "Position" );
position->setDefault( 0.0, 0.0 );
OFX::DoubleParamDescriptor* letterSpacing = desc.defineDoubleParam( kParamLetterSpacing );
letterSpacing->setLabel( "Letter spacing" );
letterSpacing->setDisplayRange( -10.0, 10.0 );
letterSpacing->setDefault( 0.0 );
OFX::ChoiceParamDescriptor* vAlign = desc.defineChoiceParam( kParamVAlign );
vAlign->setLabel( "Vertically align" );
vAlign->appendOption( kParamVAlignTop );
vAlign->appendOption( kParamVAlignCenter );
vAlign->appendOption( kParamVAlignBottom );
vAlign->setDefault( eParamVAlignCenter );
OFX::ChoiceParamDescriptor* hAlign = desc.defineChoiceParam( kParamHAlign );
hAlign->setLabel( "Horizontally align" );
hAlign->appendOption( kParamHAlignLeft );
hAlign->appendOption( kParamHAlignCenter );
hAlign->appendOption( kParamHAlignRight );
hAlign->setDefault( eParamHAlignCenter );
OFX::BooleanParamDescriptor* verticalFlip = desc.defineBooleanParam( kParamVerticalFlip );
verticalFlip->setLabel( "Vertical flip" );
verticalFlip->setDefault( false );
verticalFlip->setAnimates( false );
verticalFlip->setHint( "Some hosts use inverted images, so you can correct this problem using this flag." );
}
void LensCalibrationPluginFactory::describeInContext(OFX::ImageEffectDescriptor& desc, OFX::ContextEnum context)
{
//Input Clip
OFX::ClipDescriptor *srcClip = desc.defineClip(kOfxImageEffectSimpleSourceClipName);
srcClip->addSupportedComponent(OFX::ePixelComponentRGBA);
srcClip->setTemporalClipAccess(false);
srcClip->setSupportsTiles(false);
srcClip->setIsMask(false);
srcClip->setOptional(false);
//Output clip
OFX::ClipDescriptor *dstClip = desc.defineClip(kOfxImageEffectOutputClipName);
dstClip->addSupportedComponent(OFX::ePixelComponentRGBA);
dstClip->setSupportsTiles(false);
//Calibration Group
{
OFX::GroupParamDescriptor *groupCalibration = desc.defineGroupParam(kParamGroupCalibration);
groupCalibration->setLabel("Calibration");
groupCalibration->setAsTab();
{
OFX::Int2DParamDescriptor *param = desc.defineInt2DParam(kParamImageSize);
param->setLabel("Image Size");
param->setHint("Input image size used to calibrate the optics. Obviously, all images should have the same size.");
param->setDefault(0, 0);
param->setDisplayRange(0, 0, 10000, 10000);
param->setAnimates(false);
param->setParent(*groupCalibration);
param->setEnabled(false); // should not be edited by the user
}
{
OFX::BooleanParamDescriptor *param = desc.defineBooleanParam(kParamInputImageIsGray);
param->setLabel("Input image is gray");
param->setHint("Input image is gray");
param->setParent(*groupCalibration);
}
{
OFX::ChoiceParamDescriptor *param = desc.defineChoiceParam(kParamPatternType);
param->setLabel("Pattern Type");
param->setHint("Type of pattern to detect");
param->appendOptions(kStringParamPatternType);
param->setDefault(eParamPatternTypeChessboard);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::Int2DParamDescriptor *param = desc.defineInt2DParam(kParamPatternSize);
param->setLabel("Pattern Size");
param->setHint("Number of inner corners per one of board dimension Width Height");
param->setDefault(10, 7);
param->setRange(2, 2, kOfxFlagInfiniteMax, kOfxFlagInfiniteMax);
param->setDisplayRange(2, 2, 15, 15);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamSquareSize);
param->setLabel("Square Size");
param->setHint("Define the size of the grid's square cells (mm)");
param->setDisplayRange(0, 100);
param->setDefault(1);
param->setAnimates(false);
param->setParent(*groupCalibration);
param->setLayoutHint(OFX::eLayoutHintDivider);
}
{
OFX::IntParamDescriptor *param = desc.defineIntParam(kParamNbRadialCoef);
param->setLabel("Nb Radial Coef");
param->setHint("Number of radial coefficient.");
param->setRange(0, 6);
param->setDisplayRange(0, 6);
param->setDefault(3);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::IntParamDescriptor *param = desc.defineIntParam(kParamMaxFrames);
param->setLabel("Max Frames");
param->setHint("Maximal number of frames to extract from the video file.");
param->setRange(0, kOfxFlagInfiniteMax);
param->setDisplayRange(0, 1000);
param->setDefault(0);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::IntParamDescriptor *param = desc.defineIntParam(kParamMaxCalibFrames);
param->setLabel("Max Calibration Frames");
param->setHint("Maximal number of frames to use to calibrate from the selected frames.");
param->setRange(0, kOfxFlagInfiniteMax);
param->setDisplayRange(0, 1000);
param->setDefault(100);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::IntParamDescriptor *param = desc.defineIntParam(kParamCalibGridSize);
param->setLabel("Max Calibration Grid Size");
param->setHint("Define the number of cells per edge.");
param->setRange(0, kOfxFlagInfiniteMax);
param->setDisplayRange(0, 100);
param->setDefault(10);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::IntParamDescriptor *param = desc.defineIntParam(kParamMinInputFrames);
param->setLabel("Min Input Frames");
param->setHint("Minimal number of frames to limit the calibration refinement loop.");
param->setRange(0, kOfxFlagInfiniteMax);
param->setDisplayRange(0, 1000);
param->setDefault(10);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamMaxTotalAvgErr);
param->setLabel("Max Total Average Error");
param->setHint("Maximal limit of the total average error");
param->setRange(0, 1);
param->setDisplayRange(0, 1);
param->setDefault(0.1);
param->setAnimates(false);
param->setParent(*groupCalibration);
}
{
OFX::PushButtonParamDescriptor *param = desc.definePushButtonParam(kParamCalibrate);
param->setLabel("Calibrate");
param->setHint("calibrate");
param->setParent(*groupCalibration);
}
}
//Output Group
{
OFX::GroupParamDescriptor *groupOutput = desc.defineGroupParam(kParamGroupOutput);
groupOutput->setLabel("Output");
groupOutput->setAsTab();
{
OFX::BooleanParamDescriptor *param = desc.defineBooleanParam(kParamOutputIsCalibrated);
param->setLabel("Is calibrated");
param->setHint("Is calibrated");
param->setParent(*groupOutput);
}
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamOutputAvgReprojErr);
param->setLabel("Average Reprojection Error");
param->setDisplayRange(0, 10);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(true);
param->setParent(*groupOutput);
param->setLayoutHint(OFX::eLayoutHintDivider);
}
{
OFX::GroupParamDescriptor *groupCamera = desc.defineGroupParam(kParamOutputCameraGroup);
groupCamera->setLabel("Intrinsics Camera Parameters");
groupCamera->setParent(*groupOutput);
groupCamera->setOpen(true);
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamOutputFocalLenght);
param->setLabel("Focal Length");
param->setDisplayRange(1, 100);
param->setAnimates(true);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(false);
param->setParent(*groupCamera);
}
{
OFX::Double2DParamDescriptor *param = desc.defineDouble2DParam(kParamOutputPrincipalPointOffset);
param->setLabel("Principal Point");
param->setAnimates(true);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(false);
param->setParent(*groupCamera);
}
}
{
OFX::GroupParamDescriptor *groupLensDistortion = desc.defineGroupParam(kParamOutputLensDistortionGroup);
groupLensDistortion->setLabel("Lens Distortion Coefficients");
groupLensDistortion->setParent(*groupOutput);
groupLensDistortion->setOpen(true);
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamOutputRadialCoef1);
param->setLabel("Radial Coef1");
param->setDisplayRange(0, 10);
param->setAnimates(true);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(false);
param->setParent(*groupLensDistortion);
}
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamOutputRadialCoef2);
param->setLabel("Radial Coef2");
param->setDisplayRange(0, 10);
param->setAnimates(true);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(false);
param->setParent(*groupLensDistortion);
}
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamOutputRadialCoef3);
param->setLabel("Radial Coef3");
param->setDisplayRange(0, 10);
param->setAnimates(true);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(false);
param->setParent(*groupLensDistortion);
}
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamOutputTangentialCoef1);
param->setLabel("Tangential Coef1");
param->setDisplayRange(0, 10);
param->setAnimates(true);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(false);
param->setParent(*groupLensDistortion);
}
{
OFX::DoubleParamDescriptor *param = desc.defineDoubleParam(kParamOutputTangentialCoef2);
param->setLabel("Tangential Coef2");
param->setDisplayRange(0, 10);
param->setAnimates(true);
param->setEvaluateOnChange(false);
param->setEnabled(false);
param->setAnimates(false);
param->setParent(*groupLensDistortion);
param->setLayoutHint(OFX::eLayoutHintDivider);
}
}
{
OFX::PushButtonParamDescriptor *param = desc.definePushButtonParam(kParamOutputClear);
param->setLabel("Clear");
param->setHint("clear");
param->setEnabled(false);
param->setParent(*groupOutput);
}
}
//Debug Group
{
OFX::GroupParamDescriptor *groupDebug = desc.defineGroupParam(kParamGroupDebug);
groupDebug->setLabel("Debug");
groupDebug->setAsTab();
{
OFX::BooleanParamDescriptor *param = desc.defineBooleanParam(kParamDebugEnable);
param->setLabel("Enable Debug");
param->setHint("Would you want to export undistorted images?");
param->setParent(*groupDebug);
}
{
OFX::StringParamDescriptor *param = desc.defineStringParam(kParamDebugRejectedImgFolder);
param->setLabel("Rejected Frames");
param->setHint("Folder to export delete images during the calibration refinement loop.");
param->setStringType(OFX::eStringTypeDirectoryPath);
param->setFilePathExists(true);
param->setParent(*groupDebug);
}
{
OFX::StringParamDescriptor *param = desc.defineStringParam(kParamDebugSelectedImgFolder);
param->setLabel("Selected Frames");
param->setHint("Folder to export debug images.");
param->setStringType(OFX::eStringTypeDirectoryPath);
param->setFilePathExists(true);
param->setParent(*groupDebug);
}
}
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void SobelPluginFactory::describeInContext(OFX::ImageEffectDescriptor& desc, OFX::EContext context)
{
OFX::ClipDescriptor* srcClip = desc.defineClip(kOfxImageEffectSimpleSourceClipName);
srcClip->addSupportedComponent(OFX::ePixelComponentRGBA);
srcClip->addSupportedComponent(OFX::ePixelComponentRGB);
srcClip->addSupportedComponent(OFX::ePixelComponentAlpha);
srcClip->setSupportsTiles(kSupportTiles);
OFX::ClipDescriptor* dstClip = desc.defineClip(kOfxImageEffectOutputClipName);
dstClip->addSupportedComponent(OFX::ePixelComponentRGBA);
dstClip->addSupportedComponent(OFX::ePixelComponentRGB);
dstClip->setSupportsTiles(kSupportTiles);
OFX::Double2DParamDescriptor* size = desc.defineDouble2DParam(kParamSize);
size->setLabel("Size");
size->setDefault(1.0, 1.0);
size->setRange(0.0, 0.0, std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
size->setDisplayRange(0, 0, 10, 10);
size->setDoubleType(OFX::eDoubleTypeScale);
OFX::GroupParamDescriptor* advanced = desc.defineGroupParam(kParamGroupAdvanced);
advanced->setLabel("Advanced");
OFX::BooleanParamDescriptor* unidimensional = desc.defineBooleanParam(kParamUnidimensional);
unidimensional->setLabel("Unidimensional");
unidimensional->setHint("Instead of using a square convolution matrix, use 1D kernels.");
unidimensional->setDefault(false);
unidimensional->setParent(advanced);
OFX::BooleanParamDescriptor* reverseKernel = desc.defineBooleanParam(kParamReverseKernel);
reverseKernel->setLabel("Reverse");
reverseKernel->setHint("Reverse the kernel (convolution or correlation).");
reverseKernel->setDefault(false);
reverseKernel->setParent(advanced);
OFX::BooleanParamDescriptor* normalizedKernel = desc.defineBooleanParam(kParamNormalizedKernel);
normalizedKernel->setLabel("Normalized kernel");
normalizedKernel->setHint("Use a normalized kernel to compute the gradient.");
normalizedKernel->setDefault(true);
normalizedKernel->setParent(advanced);
OFX::DoubleParamDescriptor* kernelEpsilon = desc.defineDoubleParam(kParamKernelEpsilon);
kernelEpsilon->setLabel("Kernel espilon value");
kernelEpsilon->setHint("Threshold at which we no longer consider the values of the function.");
kernelEpsilon->setDefault(0.01);
kernelEpsilon->setRange(std::numeric_limits<double>::epsilon(), 1);
kernelEpsilon->setDisplayRange(0, 0.01);
kernelEpsilon->setParent(advanced);
OFX::ChoiceParamDescriptor* pass = desc.defineChoiceParam(kParamPass);
pass->setLabel("Pass");
pass->setHint("The sobel filter is computed using a 2D separable filter. So it consists in 2 passes.\n"
"By default we compute the 2 passes, but with this option you can separate each pass.");
pass->appendOption(kParamPassFull);
pass->appendOption(kParamPass1);
pass->appendOption(kParamPass2);
pass->setDefault(0);
pass->setParent(advanced);
OFX::ChoiceParamDescriptor* border = desc.defineChoiceParam(kParamBorder);
border->setLabel("Gradient border");
border->setHint("Border method for gradient computation.");
border->appendOption(kParamBorderMirror);
border->appendOption(kParamBorderConstant);
border->appendOption(kParamBorderBlack);
border->appendOption(kParamBorderPadded);
OFX::BooleanParamDescriptor* computeNorm = desc.defineBooleanParam(kParamComputeGradientNorm);
computeNorm->setLabel("Compute norm");
computeNorm->setHint("To disable the norm computation, if you don't need it.");
computeNorm->setDefault(true);
OFX::BooleanParamDescriptor* normManhattan = desc.defineBooleanParam(kParamGradientNormManhattan);
normManhattan->setLabel("Use the manhattan norm");
normManhattan->setHint("Use manhattan norm instead of standard one.");
normManhattan->setDefault(false);
OFX::BooleanParamDescriptor* computeGradientDirection = desc.defineBooleanParam(kParamComputeGradientDirection);
computeGradientDirection->setLabel("Gradient direction");
computeGradientDirection->setHint("To disable the gradient direction computation, if you don't need it.");
computeGradientDirection->setDefault(false);
OFX::BooleanParamDescriptor* gradientDirectionAbs = desc.defineBooleanParam(kParamGradientDirectionAbs);
gradientDirectionAbs->setLabel("Angle between 0 and PI");
gradientDirectionAbs->setHint("Limit gradient direction between 0 and PI.");
gradientDirectionAbs->setDefault(true);
OFX::PushButtonParamDescriptor* infosButton = desc.definePushButtonParam(kParamInfos);
infosButton->setLabel("Infos");
OFX::ChoiceParamDescriptor* outputComponent = desc.defineChoiceParam(kParamOutputComponent);
outputComponent->setLabel("Output component");
outputComponent->appendOption(OFX::getImageEffectHostDescription()->supportsPixelComponent(OFX::ePixelComponentRGB)
? kParamOutputComponentRGB
: "---");
outputComponent->appendOption(OFX::getImageEffectHostDescription()->supportsPixelComponent(OFX::ePixelComponentRGBA)
? kParamOutputComponentRGBA
: "---");
outputComponent->setDefault(0);
outputComponent->setIsSecret(OFX::getImageEffectHostDescription()->_supportedComponents.size() == 1);
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void ColorSpacePluginFactory::describeInContext(OFX::ImageEffectDescriptor& desc, OFX::EContext context)
{
OFX::ClipDescriptor* srcClip = desc.defineClip(kOfxImageEffectSimpleSourceClipName);
srcClip->addSupportedComponent(OFX::ePixelComponentRGBA);
srcClip->addSupportedComponent(OFX::ePixelComponentRGB);
srcClip->addSupportedComponent(OFX::ePixelComponentAlpha);
srcClip->setSupportsTiles(kSupportTiles);
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip(kOfxImageEffectOutputClipName);
dstClip->addSupportedComponent(OFX::ePixelComponentRGBA);
dstClip->addSupportedComponent(OFX::ePixelComponentRGB);
dstClip->addSupportedComponent(OFX::ePixelComponentAlpha);
dstClip->setSupportsTiles(kSupportTiles);
/* ----------------------- INPUT PARAMETERS -------------------------- */
OFX::GroupParamDescriptor* inGroup = desc.defineGroupParam(kColorSpaceIn);
inGroup->setLabel("Input configuration");
OFX::ChoiceParamDescriptor* inReferenceSpace = desc.defineChoiceParam(kColorSpaceReferenceSpaceIn);
inReferenceSpace->setLabel("Reference Space");
inReferenceSpace->setParent(inGroup);
OFX::GroupParamDescriptor* inCustom = desc.defineGroupParam(kColorSpaceCustomizedIn);
inCustom->setLabel("Custom");
inCustom->setOpen(false);
inCustom->setParent(inGroup);
OFX::ChoiceParamDescriptor* inGradationLaw = desc.defineChoiceParam(kColorSpaceGradationLawIn);
inGradationLaw->setLabel("Gradation Law");
inGradationLaw->setParent(inCustom);
OFX::DoubleParamDescriptor* inGammaValue = desc.defineDoubleParam(kColorSpaceInGammaValue);
inGammaValue->setLabel("Gamma");
inGammaValue->setDefault(1.0);
inGammaValue->setRange(0.0, std::numeric_limits<double>::max());
inGammaValue->setDisplayRange(0.0, 5.0);
inGammaValue->setHint("Adjust the Gamma.");
inGammaValue->setParent(inCustom);
OFX::DoubleParamDescriptor* inBlackPoint = desc.defineDoubleParam(kColorSpaceInBlackPoint);
inBlackPoint->setLabel("Black Point");
inBlackPoint->setDefault(0.0);
inBlackPoint->setRange(0.0, 1.0);
inBlackPoint->setDisplayRange(0.0, 1.0);
inBlackPoint->setHint("Adjust the Black Point.");
inBlackPoint->setParent(inCustom);
OFX::DoubleParamDescriptor* inWhitePoint = desc.defineDoubleParam(kColorSpaceInWhitePoint);
inWhitePoint->setLabel("White Point");
inWhitePoint->setDefault(1.0);
inWhitePoint->setRange(0.0, 1.0);
inWhitePoint->setDisplayRange(0.0, 1.0);
inWhitePoint->setHint("Adjust the White Point.");
inWhitePoint->setParent(inCustom);
OFX::DoubleParamDescriptor* inGammaSensito = desc.defineDoubleParam(kColorSpaceInGammaSensito);
inGammaSensito->setLabel("Gamma Sensito");
inGammaSensito->setDefault(1.0);
inGammaSensito->setRange(0.0, std::numeric_limits<double>::max());
inGammaSensito->setDisplayRange(0.0, 5.0);
inGammaSensito->setHint("Adjust the Gamma Sensito.");
inGammaSensito->setParent(inCustom);
OFX::ChoiceParamDescriptor* inLayout = desc.defineChoiceParam(kColorSpaceLayoutIn);
inLayout->setLabel("Layout");
inLayout->setParent(inCustom);
OFX::ChoiceParamDescriptor* inTempColor = desc.defineChoiceParam(kColorSpaceTempColorIn);
inTempColor->setLabel("Color Temperature");
inTempColor->setHint("Select the color temperature.");
inTempColor->setParent(inCustom);
OFX::GroupParamDescriptor* inPrimaries = desc.defineGroupParam(kColorSpacePrimariesIn);
inPrimaries->setLabel("Primaries color");
inPrimaries->setOpen(false);
inPrimaries->setParent(inCustom);
OFX::DoubleParamDescriptor* inXr = desc.defineDoubleParam(kColorSpaceXrIn);
inXr->setLabel("X red");
inXr->setDefault(1.0);
inXr->setRange(0.0, 1.0);
inXr->setDisplayRange(0.0, 1.0);
inXr->setHint("Adjust the X red primary color.");
inXr->setParent(inPrimaries);
OFX::DoubleParamDescriptor* inYr = desc.defineDoubleParam(kColorSpaceYrIn);
inYr->setLabel("Y red");
inYr->setDefault(1.0);
inYr->setRange(0.0, 1.0);
inYr->setDisplayRange(0.0, 1.0);
inYr->setHint("Adjust the Y red primary color.");
inYr->setParent(inPrimaries);
OFX::DoubleParamDescriptor* inXg = desc.defineDoubleParam(kColorSpaceXgIn);
inXg->setLabel("X green");
inXg->setDefault(1.0);
inXg->setRange(0.0, 1.0);
inXg->setDisplayRange(0.0, 1.0);
inXg->setHint("Adjust the X green primary color.");
inXg->setParent(inPrimaries);
OFX::DoubleParamDescriptor* inYg = desc.defineDoubleParam(kColorSpaceYgIn);
inYg->setLabel("Y green");
inYg->setDefault(1.0);
inYg->setRange(0.0, 1.0);
inYg->setDisplayRange(0.0, 1.0);
inYg->setHint("Adjust the Y green primary color.");
inYg->setParent(inPrimaries);
OFX::DoubleParamDescriptor* inXb = desc.defineDoubleParam(kColorSpaceXbIn);
inXb->setLabel("X blue");
inXb->setDefault(1.0);
inXb->setRange(0.0, 1.0);
inXb->setDisplayRange(0.0, 1.0);
inXb->setHint("Adjust the X blue primary color.");
inXb->setParent(inPrimaries);
OFX::DoubleParamDescriptor* inYb = desc.defineDoubleParam(kColorSpaceYbIn);
inYb->setLabel("Y blue");
inYb->setDefault(1.0);
inYb->setRange(0.0, 1.0);
inYb->setDisplayRange(0.0, 1.0);
inYb->setHint("Adjust the Y blue primary color.");
inYb->setParent(inPrimaries);
/* ----------------------- OUTPUT PARAMETERS -------------------------- */
OFX::GroupParamDescriptor* outGroup = desc.defineGroupParam(kColorSpaceOut);
outGroup->setLabel("Output configuration");
OFX::ChoiceParamDescriptor* outReferenceSpace = desc.defineChoiceParam(kColorSpaceReferenceSpaceOut);
outReferenceSpace->setLabel("Reference Space");
outReferenceSpace->setParent(outGroup);
OFX::GroupParamDescriptor* outCustom = desc.defineGroupParam(kColorSpaceCustomizedOut);
outCustom->setLabel("Custom");
outCustom->setOpen(false);
outCustom->setParent(outGroup);
OFX::ChoiceParamDescriptor* outGradationLaw = desc.defineChoiceParam(kColorSpaceGradationLawOut);
outGradationLaw->setLabel("Gradation Law");
outGradationLaw->setParent(outCustom);
OFX::DoubleParamDescriptor* outGammaValue = desc.defineDoubleParam(kColorSpaceOutGammaValue);
outGammaValue->setLabel("Gamma");
outGammaValue->setDefault(1.0);
outGammaValue->setRange(0.0, std::numeric_limits<double>::max());
outGammaValue->setDisplayRange(0.0, 5.0);
outGammaValue->setHint("Adjust the Gamma.");
outGammaValue->setParent(outCustom);
OFX::DoubleParamDescriptor* outBlackPoint = desc.defineDoubleParam(kColorSpaceOutBlackPoint);
outBlackPoint->setLabel("Black Point");
outBlackPoint->setDefault(0.0);
outBlackPoint->setRange(0.0, 1.0);
outBlackPoint->setDisplayRange(0.0, 1.0);
outBlackPoint->setHint("Adjust the Black Point.");
outBlackPoint->setParent(outCustom);
OFX::DoubleParamDescriptor* outWhitePoint = desc.defineDoubleParam(kColorSpaceOutWhitePoint);
outWhitePoint->setLabel("White Point");
outWhitePoint->setDefault(1.0);
outWhitePoint->setRange(0.0, 1.0);
outWhitePoint->setDisplayRange(0.0, 1.0);
outWhitePoint->setHint("Adjust the White Point.");
outWhitePoint->setParent(outCustom);
OFX::DoubleParamDescriptor* outGammaSensito = desc.defineDoubleParam(kColorSpaceOutGammaSensito);
outGammaSensito->setLabel("Gamma Sensito");
outGammaSensito->setDefault(1.0);
outGammaSensito->setRange(0.0, std::numeric_limits<double>::max());
outGammaSensito->setDisplayRange(0.0, 5.0);
outGammaSensito->setHint("Adjust the Gamma Sensito.");
outGammaSensito->setParent(outCustom);
OFX::ChoiceParamDescriptor* outLayout = desc.defineChoiceParam(kColorSpaceLayoutOut);
outLayout->setLabel("Layout");
outLayout->setParent(outCustom);
OFX::ChoiceParamDescriptor* outTempColor = desc.defineChoiceParam(kColorSpaceTempColorOut);
outTempColor->setLabel("Color Temperature");
outTempColor->setHint("Select the color temperature.");
outTempColor->setParent(outCustom);
OFX::GroupParamDescriptor* outPrimaries = desc.defineGroupParam(kColorSpacePrimariesOut);
outPrimaries->setLabel("Primaries color");
outPrimaries->setOpen(false);
outPrimaries->setParent(outCustom);
OFX::DoubleParamDescriptor* outXr = desc.defineDoubleParam(kColorSpaceXrOut);
outXr->setLabel("X red");
outXr->setDefault(1.0);
outXr->setRange(0.0, 1.0);
outXr->setDisplayRange(0.0, 1.0);
outXr->setHint("Adjust the X red primary color.");
outXr->setParent(outPrimaries);
OFX::DoubleParamDescriptor* outYr = desc.defineDoubleParam(kColorSpaceYrOut);
outYr->setLabel("Y red");
outYr->setDefault(1.0);
outYr->setRange(0.0, 1.0);
outYr->setDisplayRange(0.0, 1.0);
outYr->setHint("Adjust the Y red primary color.");
outYr->setParent(outPrimaries);
OFX::DoubleParamDescriptor* outXg = desc.defineDoubleParam(kColorSpaceXgOut);
outXg->setLabel("X green");
outXg->setDefault(1.0);
outXg->setRange(0.0, 1.0);
outXg->setDisplayRange(0.0, 1.0);
outXg->setHint("Adjust the X green primary color.");
outXg->setParent(outPrimaries);
OFX::DoubleParamDescriptor* outYg = desc.defineDoubleParam(kColorSpaceYgOut);
outYg->setLabel("Y green");
outYg->setDefault(1.0);
outYg->setRange(0.0, 1.0);
outYg->setDisplayRange(0.0, 1.0);
outYg->setHint("Adjust the Y green primary color.");
outYg->setParent(outPrimaries);
OFX::DoubleParamDescriptor* outXb = desc.defineDoubleParam(kColorSpaceXbOut);
outXb->setLabel("X blue");
outXb->setDefault(1.0);
outXb->setRange(0.0, 1.0);
outXb->setDisplayRange(0.0, 1.0);
outXb->setHint("Adjust the X blue primary color.");
outXb->setParent(outPrimaries);
OFX::DoubleParamDescriptor* outYb = desc.defineDoubleParam(kColorSpaceYbOut);
outYb->setLabel("Y blue");
outYb->setDefault(1.0);
outYb->setRange(0.0, 1.0);
outYb->setDisplayRange(0.0, 1.0);
outYb->setHint("Adjust the Y blue primary color.");
outYb->setParent(outPrimaries);
/* -------------- ENUMS FILLING ----------------*/
ttlc::ColorSpaceMaps csMaps;
ttlc::ColorSpaceMap mapReferenceSpace = csMaps.getMapReferenceSpaces();
ttlc::ColorSpaceMap mapGradationLaw = csMaps.getMapGradationLaw();
ttlc::ColorSpaceMap mapLayout = csMaps.getMapLayout();
ttlc::ColorSpaceMap mapColourTemp = csMaps.getMapColourTemp();
ttlc::ColorSpaceMap::iterator it;
ttlc::ColorSpacePair highest;
/* Reference Space */
highest = *mapReferenceSpace.rbegin(); // last element
it = mapReferenceSpace.begin();
do
{
inReferenceSpace->appendOption((*it).second);
outReferenceSpace->appendOption((*it).second);
} while(mapReferenceSpace.value_comp()(*it++, highest));
it = mapReferenceSpace.begin();
inReferenceSpace->setDefault((*it).first);
outReferenceSpace->setDefault((*it).first);
/* Gradation */
highest = *mapGradationLaw.rbegin();
it = mapGradationLaw.begin();
do
{
inGradationLaw->appendOption((*it).second);
outGradationLaw->appendOption((*it).second);
} while(mapGradationLaw.value_comp()(*it++, highest));
it = mapGradationLaw.begin();
inGradationLaw->setDefault((*it).first);
outGradationLaw->setDefault((*it).first);
/* Layout */
highest = *mapLayout.rbegin();
it = mapLayout.begin();
do
{
inLayout->appendOption((*it).second);
outLayout->appendOption((*it).second);
} while(mapLayout.value_comp()(*it++, highest));
it = mapLayout.begin();
inLayout->setDefault((*it).first);
outLayout->setDefault((*it).first);
/* Colour temperature */
highest = *mapColourTemp.rbegin();
it = mapColourTemp.begin();
do
{
inTempColor->appendOption((*it).second);
outTempColor->appendOption((*it).second);
} while(mapColourTemp.value_comp()(*it++, highest));
it = mapColourTemp.begin();
inTempColor->setDefault((*it).first);
outTempColor->setDefault((*it).first);
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void CropPluginFactory::describeInContext(OFX::ImageEffectDescriptor& desc, OFX::EContext context)
{
OFX::ClipDescriptor* srcClip = desc.defineClip(kOfxImageEffectSimpleSourceClipName);
srcClip->addSupportedComponent(OFX::ePixelComponentRGBA);
srcClip->addSupportedComponent(OFX::ePixelComponentRGB);
srcClip->addSupportedComponent(OFX::ePixelComponentAlpha);
srcClip->setSupportsTiles(kSupportTiles);
OFX::ClipDescriptor* dstClip = desc.defineClip(kOfxImageEffectOutputClipName);
dstClip->addSupportedComponent(OFX::ePixelComponentRGBA);
dstClip->addSupportedComponent(OFX::ePixelComponentRGB);
dstClip->addSupportedComponent(OFX::ePixelComponentAlpha);
dstClip->setSupportsTiles(kSupportTiles);
OFX::ChoiceParamDescriptor* mode = desc.defineChoiceParam(kParamMode);
mode->setLabel("Mode");
mode->appendOption(kParamModeCrop);
mode->appendOption(kParamModeFillColor);
// mode->appendOption( kParamModeResize ); // good idea or not?
mode->setDefault(eParamModeCrop);
OFX::RGBAParamDescriptor* fillColor = desc.defineRGBAParam(kParamFillColor);
fillColor->setLabel("Color");
fillColor->setHint("Color to fill bands");
fillColor->setDefault(0.0, 0.0, 0.0, 1.0);
OFX::ChoiceParamDescriptor* axis = desc.defineChoiceParam(kParamAxis);
axis->setLabel("Axis");
axis->appendOption(kParamAxisXY);
axis->appendOption(kParamAxisX);
axis->appendOption(kParamAxisY);
axis->setDefault(eParamAxisY);
axis->setEvaluateOnChange(false);
OFX::ChoiceParamDescriptor* symmetric = desc.defineChoiceParam(kParamSymmetric);
symmetric->setLabel("Symmetric");
symmetric->appendOption(kParamSymmetricNone);
symmetric->appendOption(kParamSymmetricXY);
symmetric->appendOption(kParamSymmetricX);
symmetric->appendOption(kParamSymmetricY);
symmetric->setHint("Is the crop region symmetric around image center?");
symmetric->setDefault(true);
symmetric->setEvaluateOnChange(false);
OFX::BooleanParamDescriptor* fixedRatio = desc.defineBooleanParam(kParamFixedRatio);
fixedRatio->setLabel("Fixed ratio");
fixedRatio->setHint("Constrain the cropped region to this ratio.");
fixedRatio->setDefault(true);
fixedRatio->setEvaluateOnChange(false);
OFX::ChoiceParamDescriptor* preset = desc.defineChoiceParam(kParamPreset);
preset->setLabel("Preset");
preset->appendOption(kParamPreset_custom);
preset->appendOption(kParamPreset_1_33);
preset->appendOption(kParamPreset_1_77);
preset->appendOption(kParamPreset_1_85);
preset->appendOption(kParamPreset_2_35);
preset->appendOption(kParamPreset_2_40);
preset->setDefault(0);
preset->setEvaluateOnChange(false);
OFX::DoubleParamDescriptor* ratio = desc.defineDoubleParam(kParamRatio);
ratio->setLabel("Ratio");
ratio->setRange(0, std::numeric_limits<double>::max());
ratio->setDisplayRange(0, 3);
ratio->setDefault(2.0);
ratio->setHint("Ratio X/Y of the cropped region.");
OFX::BooleanParamDescriptor* overlay = desc.defineBooleanParam(kParamOverlay);
overlay->setLabel("Overlay");
overlay->setHint("Display overlay rectangle");
overlay->setDefault(false);
overlay->setEvaluateOnChange(false);
OFX::GroupParamDescriptor* cropRegion = desc.defineGroupParam(kParamGroupCropRegion);
OFX::IntParamDescriptor* xMin = desc.defineIntParam(kParamXMin);
xMin->setLabel("X min");
// xMin->setRange( 0, std::numeric_limits<int>::max() );
xMin->setDisplayRange(0, 3000);
xMin->setDefault(0);
xMin->setParent(*cropRegion);
OFX::IntParamDescriptor* yMin = desc.defineIntParam(kParamYMin);
yMin->setLabel("Y min");
// yMin->setRange( 0, std::numeric_limits<int>::max() );
yMin->setDisplayRange(0, 3000);
yMin->setDefault(0);
yMin->setParent(*cropRegion);
OFX::IntParamDescriptor* xMax = desc.defineIntParam(kParamXMax);
xMax->setLabel("X max");
// xMax->setRange( 0, std::numeric_limits<int>::max() );
xMax->setDisplayRange(0, 3000);
xMax->setDefault(0);
xMax->setParent(*cropRegion);
OFX::IntParamDescriptor* yMax = desc.defineIntParam(kParamYMax);
yMax->setLabel("Y max");
// yMax->setRange( 0, std::numeric_limits<int>::max() );
yMax->setDisplayRange(0, 3000);
yMax->setDefault(0);
yMax->setParent(*cropRegion);
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void LensDistortPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc, OFX::EContext context )
{
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( true );
// create the mandated source clip
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( true );
// declare an optional clip reference for RoD
OFX::ClipDescriptor* srcRefClip = desc.defineClip( kClipOptionalSourceRef );
srcRefClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcRefClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcRefClip->setSupportsTiles( true );
srcRefClip->setOptional( true );
srcRefClip->setLabel( "ref" );
OFX::BooleanParamDescriptor* reverse = desc.defineBooleanParam( kParamReverse );
reverse->setLabel( "Reverse" );
reverse->setDefault( false );
reverse->setHint( "Invert the effect.\n"
"Distort becomes undistort, and vice versa." );
// Controls
OFX::BooleanParamDescriptor* displaySource = desc.defineBooleanParam( kParamDisplaySource );
displaySource->setLabel( "displaySource" );
displaySource->setDefault( false );
displaySource->setHint( "Display the image source (usefull to parameter the distortion with lines overlays on the source image)." );
OFX::ChoiceParamDescriptor* lensType = desc.defineChoiceParam( kParamLensType );
lensType->setLabel( "Lens type" );
lensType->appendOption( kParamLensTypeStandard );
#ifndef TUTTLE_PRODUCTION
lensType->appendOption( kParamLensTypeFishEye ); // not implemented yet...
lensType->appendOption( kParamLensTypeAdvanced ); // not implemented yet...
lensType->setIsSecret( true );
#endif
lensType->setDefault( 0 );
OFX::DoubleParamDescriptor* coef1 = desc.defineDoubleParam( kParamCoef1 );
coef1->setScriptName( "Main" );
coef1->setDefault( 0.1 );
coef1->setDisplayRange( -1.0, 1.0 );
coef1->setHint( "Main distortion coeffecient\n"
">0 : Barrel distortion\n"
"<0 : Pincushion distortion\n"
);
OFX::DoubleParamDescriptor* coef2 = desc.defineDoubleParam( kParamCoef2 );
coef2->setLabel( "Secondary" );
coef2->setDefault( 0.0 );
coef2->setDisplayRange( -1.0, 1.0 );
coef2->setHint( "Secondary distortion coeffecient (usefull for fisheyes only)\n"
">0 : Barrel distortion\n"
"<0 : Pincushion distortion\n"
);
#ifdef TUTTLE_PRODUCTION
coef2->setIsSecret( true );
#endif
OFX::DoubleParamDescriptor* squeeze = desc.defineDoubleParam( kParamSqueeze );
squeeze->setLabel( "Squeeze" );
#ifdef TUTTLE_PRODUCTION
squeeze->setIsSecret( true );
#endif
// squeeze->setDoubleType( eDoubleTypeNormalisedX );
squeeze->setDefault( 1.0 );
squeeze->setRange( 0.00001, 1.0 );
squeeze->setDisplayRange( 0.01, 1.0 );
squeeze->setHint( "Squeeze distortion coeffecient (usefull for bad quality lens...)" );
OFX::Double2DParamDescriptor* asymmetric = desc.defineDouble2DParam( kParamAsymmetric );
asymmetric->setLabel( "Asymmetric" );
#ifdef TUTTLE_PRODUCTION
asymmetric->setIsSecret( true );
#endif
// asymmetric->setDoubleType( eDoubleTypeNormalisedXY );
asymmetric->setDefault( 0.0, 0.0 );
asymmetric->setRange( 0.0, 0.0, 1.0, 1.0 );
asymmetric->setDisplayRange( 0.0, 0.0, 1.0, 1.0 );
asymmetric->setHint( "asymmetric distortion coeffecient (usefull for bad quality lens...)" );
OFX::Double2DParamDescriptor* center = desc.defineDouble2DParam( kParamCenter );
center->setLabel( "Center" );
center->setDoubleType( OFX::eDoubleTypePlain );
center->setDefault( 0.0, 0.0 );
center->setDisplayRange( -1.0, -1.0, 1.0, 1.0 );
center->setHint( "Center parameter allows you to shift the center of distortion." );
OFX::BooleanParamDescriptor* centerOverlay = desc.defineBooleanParam( kParamCenterOverlay );
centerOverlay->setLabel( "Display distortion center" );
centerOverlay->setDefault( false );
centerOverlay->setEvaluateOnChange( false );
centerOverlay->setHint( "Active distortion center point overlay." );
OFX::ChoiceParamDescriptor* centerType = desc.defineChoiceParam( kParamCenterType );
centerType->setLabel( "Center type" );
#ifdef TUTTLE_PRODUCTION
centerType->setIsSecret( true );
#endif
centerType->appendOption( kParamCenterTypeSource );
centerType->appendOption( kParamCenterTypeRoW );
centerType->setDefault( 0 );
centerType->setHint( "Centered on source or output image." );
OFX::DoubleParamDescriptor* preScale = desc.defineDoubleParam( kParamPreScale );
preScale->setLabel( "Pre-scale" );
// preScale->setDoubleType( eDoubleTypeNormalisedXY );
preScale->setDefault( 1.0 );
preScale->setRange( 0.00001, std::numeric_limits<double>::max() );
preScale->setDisplayRange( 0.0, 2.5 );
preScale->setHint( "If the transformation of optics is high, you may need to change the scale of the result to be globally closer to the source image or preserve a good resolution." );
OFX::DoubleParamDescriptor* postScale = desc.defineDoubleParam( kParamPostScale );
postScale->setLabel( "Post-scale" );
// scale->setDoubleType( eDoubleTypeNormalisedXY );
postScale->setDefault( 1.0 );
postScale->setRange( 0.00001, std::numeric_limits<double>::max() );
postScale->setDisplayRange( 0.0, 2.5 );
postScale->setHint( "If the transformation of optics is high, you may need to change the scale of the result to be globally closer to the source image or preserve a good resolution." );
OFX::ChoiceParamDescriptor* interpolation = desc.defineChoiceParam( kParamInterpolation );
interpolation->setLabel( "Interpolation" );
interpolation->appendOption( kParamInterpolationNearest );
interpolation->appendOption( kParamInterpolationBilinear );
interpolation->setDefault( 1 );
interpolation->setHint( "Interpolation method" );
OFX::ChoiceParamDescriptor* resizeRod = desc.defineChoiceParam( kParamResizeRod );
resizeRod->setLabel( "Resize RoD" );
resizeRod->appendOption( kParamResizeRodNo );
resizeRod->appendOption( kParamResizeRodSourceRef );
resizeRod->appendOption( kParamResizeRodMin );
resizeRod->appendOption( kParamResizeRodMax );
resizeRod->appendOption( kParamResizeRodManual );
resizeRod->setDefault( 0 );
resizeRod->setHint( "Resize output RoD" );
OFX::DoubleParamDescriptor* scaleRod = desc.defineDoubleParam( kParamResizeRodManualScale );
scaleRod->setLabel( "Scale RoD" );
// scaleRod->setDoubleType( eDoubleTypeNormalisedXY );
// scaleRod->setIsSecret( true );
// scaleRod->setEnabled( false );
scaleRod->setDefault( 1.0 );
scaleRod->setRange( 0.0, std::numeric_limits<double>::max() );
scaleRod->setDisplayRange( 0, 2.5 );
scaleRod->setHint( "Adjust the output RoD." );
OFX::GroupParamDescriptor* displayOptions = desc.defineGroupParam( kParamDisplayOptions );
displayOptions->setLabel( "Display options" );
displayOptions->setHint( "Display options (change nothing on the image)" );
OFX::BooleanParamDescriptor* displayGrid = desc.defineBooleanParam( kParamGridOverlay );
displayGrid->setLabel( "Display grid" );
displayGrid->setParent( *displayOptions );
displayGrid->setDefault( false );
displayGrid->setEvaluateOnChange( false );
displayGrid->setHint( "Display the grid" );
OFX::Double2DParamDescriptor* gridCenter = desc.defineDouble2DParam( kParamGridCenter );
gridCenter->setLabel( "Grid center" );
gridCenter->setDoubleType( OFX::eDoubleTypePlain );
gridCenter->setParent( *displayOptions );
gridCenter->setDefault( 0.0, 0.0 );
gridCenter->setDisplayRange( -1.0, -1.0, 1.0, 1.0 );
gridCenter->setEvaluateOnChange( false );
gridCenter->setHint( "Allows you to shift the center of the display grid." );
OFX::BooleanParamDescriptor* gridCenterOverlay = desc.defineBooleanParam( kParamGridCenterOverlay );
gridCenterOverlay->setLabel( "Display grid center" );
gridCenterOverlay->setParent( *displayOptions );
gridCenterOverlay->setDefault( false );
gridCenterOverlay->setEvaluateOnChange( false );
gridCenterOverlay->setHint( "Active grid center point overlay." );
OFX::Double2DParamDescriptor* gridScale = desc.defineDouble2DParam( kParamGridScale );
gridScale->setLabel( "Grid scale" );
gridScale->setDoubleType( OFX::eDoubleTypePlain );
gridScale->setParent( *displayOptions );
gridScale->setDefault( 1.0, 1.0 );
gridScale->setDisplayRange( -10.0, -10.0, 10.0, 10.0 );
gridScale->setEvaluateOnChange( false );
gridScale->setHint( "Allows you to scale the display grid." );
OFX::GroupParamDescriptor* debugOptions = desc.defineGroupParam( kParamDebugOptions );
debugOptions->setLabel( "Debug options" );
debugOptions->setHint( "Debug options" );
debugOptions->setParent( *displayOptions );
#ifdef TUTTLE_PRODUCTION
debugOptions->setIsSecret( true );
#endif
OFX::BooleanParamDescriptor* debugDisplayRoi = desc.defineBooleanParam( kParamDebugDisplayRoi );
debugDisplayRoi->setLabel( "Display RoI" );
#ifdef TUTTLE_PRODUCTION
debugDisplayRoi->setIsSecret( true );
#endif
debugDisplayRoi->setParent( *debugOptions );
debugDisplayRoi->setDefault( false );
debugDisplayRoi->setEvaluateOnChange( false );
debugDisplayRoi->setHint( "Display RoI" );
OFX::PushButtonParamDescriptor* helpButton = desc.definePushButtonParam( kParamHelp );
helpButton->setLabel( "Help" );
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void HistogramKeyerPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( kSupportTiles );
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
//global display
OFX::BooleanParamDescriptor* boolGLOBAL = desc.defineBooleanParam(kGlobalDisplay);
boolGLOBAL->setHint("Display global overlay on screen.");
boolGLOBAL->setDefault(true);
// if parametric parameters are supported
if( OFX::getImageEffectHostDescription()->supportsParametricParameter )
{
OFX::ParametricParamDescriptor* curvesRGB = desc.defineParametricParam( kParamRGBColorSelection );
OFX::ParametricParamDescriptor* curvesHSL = desc.defineParametricParam( kParamHSLColorSelection );
//Group Param (RGB & HSL)
OFX::GroupParamDescriptor *groupRGB = desc.defineGroupParam(kGroupRGB);
groupRGB->setLabel(kGroupRGBLabel);
OFX::GroupParamDescriptor *groupHSL = desc.defineGroupParam(kGroupHSL);
groupHSL->setLabel(kGroupHSLLabel);
//define the graphic aspect
curvesRGB->setRange( 0.0, 1.0 ); //set range on RGB curve
curvesHSL->setRange( 0.0, 1.0 ); //set range on HSL curve
curvesRGB->setDimension(nbCurvesRGB); //3 curves on RGB
curvesHSL->setDimension(nbCurvesHSL); //3 curves on HSL
//Add curves RGB
curvesRGB->setDimensionLabel( kParamColorSelectionRed, 0 ); // 0 on RGB is red
curvesRGB->setDimensionLabel( kParamColorSelectionGreen, 1 ); // 1 on RGB is green
curvesRGB->setDimensionLabel( kParamColorSelectionBlue, 2 ); // 2 on RGB is blue
//Add curves HSL
curvesHSL->setDimensionLabel( kParamColorSelectionHue, 0 ); // 0 on HSL is hue
curvesHSL->setDimensionLabel( kParamColorSelectionSaturation, 1 ); // 1 on HSL is saturation
curvesHSL->setDimensionLabel( kParamColorSelectionLightness, 2 ); // 2 on HSK is lightness
//define curves color RGB
curvesRGB->setHint( "Color selection" );
static const OfxRGBColourD red = {1,0,0}; //set red color to red curve
static const OfxRGBColourD green = {0,1,0}; //set green color to green curve
static const OfxRGBColourD blue = {0,0,1}; //set blue color to blue curve
curvesRGB->setUIColour( 0, red );
curvesRGB->setUIColour( 1, green );
curvesRGB->setUIColour( 2, blue );
//define curves color HSL
curvesHSL->setHint( "Color selection" );
curvesHSL->setUIColour( 0, red ); //set red color on hue curve
curvesHSL->setUIColour( 1, green ); //set green color on saturation curve
curvesHSL->setUIColour( 2, blue ); //set lightness color on saturation curve
curvesRGB->setInteractDescriptor( new OFX::DefaultParamInteractWrap<RGBParamOverlayDescriptor>() ); //attach parametric curve to RGBOverlay
curvesHSL->setInteractDescriptor( new OFX::DefaultParamInteractWrap<HSLParamOverlayDescriptor>() ); //attach parametric curve to HSLOverlay
//add curves to their groups
curvesRGB->setParent(groupRGB); //add RGB curves to RGB group
curvesHSL->setParent(groupHSL); //add HSL curves to HSL group
//Set each curves to initial value
curvesRGB->setIdentity();
curvesHSL->setIdentity();
//add 2 control points (0,1) and (1,1) for each channel
for(unsigned int i=0; i< nbCurvesRGB; ++i)
{
//curvesRGB->addControlPoint( i, 0.0, 0.0, 1.0, false );
curvesRGB->addControlPoint( i, 0.0, 1.0, 1.0, false );
}
for(unsigned int i=0; i< nbCurvesHSL; ++i)
{
//curvesHSL->addControlPoint( i, 0.0, 0.0, 1.0, false );
curvesHSL->addControlPoint( i, 0.0, 1.0, 1.0, false );
}
//Channels checkboxes (RGB)
OFX::BooleanParamDescriptor* boolR = desc.defineBooleanParam(kBoolRed);
boolR->setDefault(false); //red channel is not selected by default
boolR->setHint("Activate Red channel");
boolR->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolR->setParent(groupRGB);
//red multiplier
OFX::DoubleParamDescriptor* redMultiplier = desc.defineDoubleParam(kMultiplierRed);
redMultiplier->setLabel(kMultiplierLabel);
redMultiplier->setHint("Determinate curve from selection precision.");
redMultiplier->setRange(1, 1000);
redMultiplier->setDisplayRange(0,5);
redMultiplier->setDefault(1);
redMultiplier->setParent(groupRGB);
OFX::BooleanParamDescriptor* boolG = desc.defineBooleanParam(kBoolGreen);
boolG->setDefault(false); //green channel is not selected by default
boolG->setHint("Activate Green channel");
boolG->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolG->setParent(groupRGB);
//green multiplier
OFX::DoubleParamDescriptor* greenMultiplier = desc.defineDoubleParam(kMultiplierGreen);
greenMultiplier->setLabel(kMultiplierLabel);
greenMultiplier->setHint("Determinate curve from selection precision.");
greenMultiplier->setRange(1, 1000);
greenMultiplier->setDisplayRange(0,5);
greenMultiplier->setDefault(1);
greenMultiplier->setParent(groupRGB);
OFX::BooleanParamDescriptor* boolB = desc.defineBooleanParam(kBoolBlue);
boolB->setHint("Activate Blue channel");
boolB->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolB->setDefault(false); //blue channel is not selected by default
boolB->setParent(groupRGB);
//blue multiplier
OFX::DoubleParamDescriptor* blueMultiplier = desc.defineDoubleParam(kMultiplierBlue);
blueMultiplier->setLabel(kMultiplierLabel);
blueMultiplier->setHint("Determinate curve from selection precision.");
blueMultiplier->setRange(1, 1000);
blueMultiplier->setDisplayRange(0,5);
blueMultiplier->setDefault(1);
blueMultiplier->setParent(groupRGB);
//Channels check box (HSL)
OFX::BooleanParamDescriptor* boolH = desc.defineBooleanParam(kBoolHue);
boolH->setDefault(false);
boolH->setHint("Activate Hue channel");
boolH->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolH->setParent(groupHSL);
//Hue multiplier
OFX::DoubleParamDescriptor* hueMultiplier = desc.defineDoubleParam(kMultiplierHue);
hueMultiplier->setLabel(kMultiplierLabel);
hueMultiplier->setHint("Determinate curve from selection precision.");
hueMultiplier->setRange(1, 1000);
hueMultiplier->setDisplayRange(0,5);
hueMultiplier->setDefault(1);
hueMultiplier->setParent(groupHSL);
OFX::BooleanParamDescriptor* boolS = desc.defineBooleanParam(kBoolSaturation);
boolS->setDefault(false);
boolS->setHint("Activate Saturation channel");
boolS->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolS->setParent(groupHSL);
//Saturation multiplier
OFX::DoubleParamDescriptor* saturationMultiplier = desc.defineDoubleParam(kMultiplierSaturation);
saturationMultiplier->setLabel(kMultiplierLabel);
saturationMultiplier->setHint("Determinate curve from selection precision.");
saturationMultiplier->setRange(1, 1000);
saturationMultiplier->setDisplayRange(0,5);
saturationMultiplier->setDefault(1);
saturationMultiplier->setParent(groupHSL);
OFX::BooleanParamDescriptor* boolL = desc.defineBooleanParam(kBoolLightness);
boolL->setHint("Activate Lightness channel");
boolL->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolL->setDefault(false);
boolL->setParent(groupHSL);
//Lightness multiplier
OFX::DoubleParamDescriptor* lightnessMultiplier = desc.defineDoubleParam(kMultiplierLightness);
lightnessMultiplier->setLabel(kMultiplierLabel);
lightnessMultiplier->setHint("Determinate curve from selection precision.");
lightnessMultiplier->setRange(1, 1000);
lightnessMultiplier->setDisplayRange(0,5);
lightnessMultiplier->setDefault(1);
lightnessMultiplier->setParent(groupHSL);
//Clean Button (RGB)
OFX::PushButtonParamDescriptor* resetButtonRGB = desc.definePushButtonParam(kButtonResetRGB);
resetButtonRGB->setLabel(kButtonResetRGBLabel);
resetButtonRGB->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
resetButtonRGB->setHint("Reset the selected RGB curves. \n Warning : the curves may not be refreshed click on overlay to refresh.");
resetButtonRGB->setParent(groupRGB);
//Selection To Curves Button (RGB)
OFX::PushButtonParamDescriptor* selectionToCurveButtonRGB = desc.definePushButtonParam(kButtonSelectionToCurveRGB);
selectionToCurveButtonRGB->setLabel(kButtonSelectionToCurveRGBLabel);
selectionToCurveButtonRGB->setHint("Load selected RGB curves with selection data. \n Warning : the curves may not be refreshed click on overlay to refresh.");
selectionToCurveButtonRGB->setParent(groupRGB);
//Append selection to curves button (RGB)
OFX::PushButtonParamDescriptor* appendSelectionToCurveRGB = desc.definePushButtonParam(kButtonAppendSelectionToCurveRGB);
appendSelectionToCurveRGB->setLabel(kButtonAppendSelectionToCurveRGBLabel); //add label
appendSelectionToCurveRGB->setHint("Append current selection to selected RGB channels");//help
appendSelectionToCurveRGB->setParent(groupRGB); //add to RGB group
//Clean Button (HSL)
OFX::PushButtonParamDescriptor* resetButtonHSL = desc.definePushButtonParam(kButtonResetHSL);
resetButtonHSL->setLabel(kButtonResetHSLLabel);
resetButtonHSL->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
resetButtonHSL->setHint("Reset the selected HSL curves \n Warning : the curves may not be refreshed click on overlay to refresh.");
resetButtonHSL->setParent(groupHSL);
//Selection To Curves Button (HSL)
OFX::PushButtonParamDescriptor* selectionToCurveButtonHSL = desc.definePushButtonParam(kButtonSelectionToCurveHSL);
selectionToCurveButtonHSL->setLabel(kButtonSelectionToCurveHSLLabel);
selectionToCurveButtonHSL->setHint("Load selected HSL curves with selection data. \n Warning : the curves may not be refreshed click on overlay to refresh.");
selectionToCurveButtonHSL->setParent(groupHSL);
//Append selection to curves button (HSL)
OFX::PushButtonParamDescriptor* appendSelectionToCurveHSL = desc.definePushButtonParam(kButtonAppendSelectionToCurveHSL);
appendSelectionToCurveHSL->setLabel(kButtonAppendSelectionToCurveHSLLabel); //add label
appendSelectionToCurveHSL->setHint("Append current selection to selected HSL channels");//help
appendSelectionToCurveHSL->setParent(groupHSL); //add to HSL group
//Close RGB group (group states by default on screen)
groupRGB->setOpen(false);
groupHSL->setOpen(true);
}
//Selection group
{
OFX::GroupParamDescriptor *groupSelection = desc.defineGroupParam(kGroupSelection);
groupSelection->setLabel(kGroupSelectionLabel);
groupSelection->setOpen(false);
groupSelection->setAsTab();
//display selection
OFX::BooleanParamDescriptor* boolDisplaySelection = desc.defineBooleanParam(kBoolSelection);
boolDisplaySelection->setDefault(true);
boolDisplaySelection->setEvaluateOnChange(false);// don't need to recompute on change
boolDisplaySelection->setHint("Display the selected zone on screen.");
boolDisplaySelection->setParent(groupSelection);
//clear selection
OFX::PushButtonParamDescriptor* resetSelectionButton = desc.definePushButtonParam(kButtonResetSelection);
resetSelectionButton->setLabel(kButtonResetSelectionLabel);
resetSelectionButton->setHint("Reset user's selection.");
resetSelectionButton->setParent(groupSelection);
//selection mode
OFX::ChoiceParamDescriptor* selectionMode = desc.defineChoiceParam(kSelectionModeListParamLabel);
selectionMode->setLabel(kSelectionModeListParamLabel);
selectionMode->setHint( "Selection mode \n - unique : reset past selection before selection \n - additive : add pixels to current selection \n -subtractive : remote pixel from current selection");
selectionMode->appendOption(kSelectionModeListParamOpt2);
selectionMode->appendOption(kSelectionModeListParamOpt1);
selectionMode->appendOption(kSelectionModeListParamOpt3);
selectionMode->setParent(groupSelection);
//Precision of selection to curve
OFX::IntParamDescriptor* precisionSelectionToCurve = desc.defineIntParam(kprecisionCurveFromSelection);
precisionSelectionToCurve->setLabel(kprecisionCurveFromSelectionLabel);
precisionSelectionToCurve->setHint("Determinate curve from selection precision.");
precisionSelectionToCurve->setRange(1, 1000);
precisionSelectionToCurve->setDisplayRange(1, 300.0 );
precisionSelectionToCurve->setDefault(curveFromSelection);
precisionSelectionToCurve->setEvaluateOnChange(false); // don't need to recompute on change
precisionSelectionToCurve->setParent(groupSelection);
}
//Histogram overlay group
{
OFX::GroupParamDescriptor *groupHistogramOverlay = desc.defineGroupParam(kGroupHistogramOverlay);
groupHistogramOverlay->setLabel(kGroupHistogramOverlayLabel);
groupHistogramOverlay->setOpen(true);
groupHistogramOverlay->setAsTab();
//Histogram display settings
OFX::ChoiceParamDescriptor* gammaType = desc.defineChoiceParam(kHistoDisplayListParamLabel);
gammaType->setLabel(kHistoDisplayListParamLabel);
gammaType->setEvaluateOnChange(false); // don't need to recompute on change
gammaType->setHint("Histogram display \n -global : normalize all of channels \n -by channel : keep proportions between channels");
gammaType->appendOption(kHistoDisplayListParamOpt2);
gammaType->appendOption(kHistoDisplayListParamOpt1);
gammaType->setParent(groupHistogramOverlay);
//Clean all Button
OFX::PushButtonParamDescriptor* resetButtonAll = desc.definePushButtonParam(kButtonResetAll);
resetButtonAll->setLabel(kButtonResetAllLabel);
resetButtonAll->setHint("Reset all curves. \n Waring : the curves may not be refreshed click on overlay to refresh.");
resetButtonAll->setParent(groupHistogramOverlay);
}
///Advanced group
{
OFX::GroupParamDescriptor *groupAdvanced = desc.defineGroupParam(kGroupAdvanced);
groupAdvanced->setLabel(kGroupAdvancedLabel);
groupAdvanced->setOpen(false);
groupAdvanced->setAsTab();
//nbOfstep (advanced group)
OFX::IntParamDescriptor* nbStepRange = desc.defineIntParam(knbStepRange);
nbStepRange->setLabel(knbStepRangeLabel);
nbStepRange->setHint("Determinate histogram overlay precision.");
nbStepRange->setRange(1, 1000);
nbStepRange->setDisplayRange(1, 600.0 );
nbStepRange->setDefault(255);
nbStepRange->setEvaluateOnChange(false); // don't need to recompute on change
nbStepRange->setParent(groupAdvanced);
//selection multiplier (advanced group)
OFX::DoubleParamDescriptor* selectionMultiplier = desc.defineDoubleParam(kselectionMultiplier);
selectionMultiplier->setLabel(kselectionMultiplierLabel);
selectionMultiplier->setHint("With high values, small selection are more visible.");
selectionMultiplier->setRange(0.001,1000.0);
selectionMultiplier->setDisplayRange(0.0, 100.0 );
selectionMultiplier->setDefault(2.0);
selectionMultiplier->setEvaluateOnChange(false); // don't need to recompute on change
selectionMultiplier->setParent(groupAdvanced);
//Refresh histograms overlay Button
OFX::PushButtonParamDescriptor* refreshOverlayButton = desc.definePushButtonParam(kButtonRefreshOverlay);
refreshOverlayButton->setLabel(kButtonRefreshOverlayLabel);
refreshOverlayButton->setHint("Refresh histogram overlay.");
refreshOverlayButton->setParent(groupAdvanced);
//clamp values to 0 and 1
OFX::BooleanParamDescriptor* clampCurveValues = desc.defineBooleanParam(kBoolClampValues);
clampCurveValues->setHint("Clamp curve value : values superior to 1 or inferior to 0 will be clamp in process.");
clampCurveValues->setDefault(true);
clampCurveValues->setParent(groupAdvanced);
}
//Output settings
OFX::ChoiceParamDescriptor* outputType = desc.defineChoiceParam(kOutputListParamLabel);
outputType->setLabel(kOutputListParamLabel);
outputType->setHint( "Output type \n Alpha channel or Black and White");
outputType->appendOption(kOutputListParamOpt1);
outputType->appendOption(kOutputListParamOpt2);
outputType->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
//Reverse mask
OFX::BooleanParamDescriptor* boolReverseMask = desc.defineBooleanParam(kBoolReverseMask);
boolReverseMask->setDefault(false);
boolReverseMask->setHint("Revert alpha mask");
}
void describeGeneratorParamsInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
/* to activate this
// Create the mandated optional input clip
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( kSupportTiles );
srcClip->setOptional(true);
*/
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
OFX::ChoiceParamDescriptor* explicitConversion = desc.defineChoiceParam( kParamGeneratorExplicitConversion );
explicitConversion->setLabel( "Explicit conversion" );
explicitConversion->appendOption( kTuttlePluginBitDepthAuto );
explicitConversion->appendOption( kTuttlePluginBitDepth8 );
explicitConversion->appendOption( kTuttlePluginBitDepth16 );
explicitConversion->appendOption( kTuttlePluginBitDepth32f );
explicitConversion->setCacheInvalidation( OFX::eCacheInvalidateValueAll );
explicitConversion->setAnimates( false );
desc.addClipPreferencesSlaveParam( *explicitConversion );
if( OFX::getImageEffectHostDescription()->supportsMultipleClipDepths )
{
explicitConversion->setDefault( 0 );
}
else
{
explicitConversion->setIsSecret( true );
explicitConversion->setDefault( static_cast<int>( OFX::getImageEffectHostDescription()->getPixelDepth() ) );
}
OFX::ChoiceParamDescriptor* method = desc.defineChoiceParam( kParamMode );
method->setLabel ( "Mode" );
method->appendOption( kParamModeFormat );
method->appendOption( kParamModeSize );
method->setDefault ( eParamModeFormat );
OFX::ChoiceParamDescriptor* format = desc.defineChoiceParam( kParamFormat );
format->setLabel( "Format" );
format->appendOption( kParamFormatPCVideo );
format->appendOption( kParamFormatNTSC );
format->appendOption( kParamFormatPAL );
format->appendOption( kParamFormatHD );
format->appendOption( kParamFormatNTSC169 );
format->appendOption( kParamFormatPAL169 );
format->appendOption( kParamFormat1kSuper35 );
format->appendOption( kParamFormat1kCinemascope );
format->appendOption( kParamFormat2kSuper35 );
format->appendOption( kParamFormat2kCinemascope );
format->appendOption( kParamFormat4kSuper35 );
format->appendOption( kParamFormat4kCinemascope );
format->appendOption( kParamFormatSquare256 );
format->appendOption( kParamFormatSquare512 );
format->appendOption( kParamFormatSquare1k );
format->appendOption( kParamFormatSquare2k );
format->setDefault( eParamFormat2kCinemascope );
OFX::BooleanParamDescriptor* specificRatio = desc.defineBooleanParam( kParamSizeSpecificRatio );
specificRatio->setLabel( "Specific ratio" );
specificRatio->setDefault( false );
specificRatio->setHint( "Specific input image ratio." );
OFX::Int2DParamDescriptor* size = desc.defineInt2DParam( kParamSize );
size->setLabel( "Size" );
size->setDefault( 200, 200 );
size->setRange( 1, 1, std::numeric_limits<int>::max(), std::numeric_limits<int>::max() );
size->setHint( "Set the output size (width, height)." );
OFX::ChoiceParamDescriptor* direction = desc.defineChoiceParam( kParamSizeOrientation );
direction->setLabel( "Orientation" );
direction->appendOption( kParamSizeOrientationX );
direction->appendOption( kParamSizeOrientationY );
direction->setDefault( eParamSizeOrientationX );
OFX::DoubleParamDescriptor* ratioValue = desc.defineDoubleParam( kParamSizeRatioValue );
ratioValue->setLabel( "Ratio Value" );
ratioValue->setDefault( 1.0 );
ratioValue->setRange( 1, std::numeric_limits<int>::max() );
ratioValue->setDisplayRange( 0, 50 );
ratioValue->setHint( "Set the ratio." );
OFX::IntParamDescriptor* width = desc.defineIntParam( kParamSizeWidth );
width->setLabel( "Width" );
width->setDefault( 200 );
width->setRange( 1, std::numeric_limits<int>::max() );
width->setDisplayRange( 0, 3000 );
width->setHint( "Set the width in pixels and specify the ratio." );
OFX::IntParamDescriptor* height = desc.defineIntParam( kParamSizeHeight );
height->setLabel( "Height" );
height->setDefault( 200 );
height->setRange( 1, std::numeric_limits<int>::max() );
height->setDisplayRange( 0, 3000 );
height->setHint( "Set the height in pixels and specify the ratio." );
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void PushPixelPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
// no tiles on src clip, because it depends on the mask content so we can't
// define the maximal bounding box needed...
srcClip->setSupportsTiles( false );
OFX::ClipDescriptor* maskClip = desc.defineClip( kClipMask );
maskClip->addSupportedComponent( OFX::ePixelComponentRGBA );
maskClip->addSupportedComponent( OFX::ePixelComponentAlpha );
maskClip->setIsMask( true );
maskClip->setOptional( true );
maskClip->setSupportsTiles( true );
OFX::ChoiceParamDescriptor* output = desc.defineChoiceParam( kParamOutput );
output->setLabel( "Output" );
output->appendOption( kParamOutputMotionVectors );
output->appendOption( kParamOutputPushPixel );
output->setDefault( 1 );
OFX::DoubleParamDescriptor* size = desc.defineDoubleParam( kParamSize );
size->setLabel( "Size" );
size->setHint( "Size of the gradient window." );
size->setRange( 0.0, std::numeric_limits<double>::max() );
size->setDisplayRange( 1.0, 10.0 );
size->setDefault( 2.0 );
OFX::BooleanParamDescriptor* normalizedKernel = desc.defineBooleanParam( kParamNormalizedKernel );
normalizedKernel->setLabel( "Normalized kernel" );
normalizedKernel->setHint( "Use a normalized kernel to compute the gradient." );
normalizedKernel->setDefault( true );
//#ifndef TUTTLE_PRODUCTION
normalizedKernel->setIsSecret( true );
//#endif
OFX::DoubleParamDescriptor* intensity = desc.defineDoubleParam( kParamIntensity );
intensity->setLabel( "Intensity" );
intensity->setHint( "Scale motion vectors." );
intensity->setDisplayRange( 0.0, 2.0 );
intensity->setDefault( 0.75 );
OFX::DoubleParamDescriptor* angle = desc.defineDoubleParam( kParamAngle );
angle->setLabel( "Angle" );
angle->setHint( "Rotation on the gradient." );
angle->setDisplayRange(-180, 180);
angle->setDoubleType( OFX::eDoubleTypeAngle );
angle->setDefault( 0.0 );
OFX::ChoiceParamDescriptor* interpolation = desc.defineChoiceParam( kParamInterpolation );
interpolation->setLabel( "Interpolation" );
interpolation->setHint( "Interpolation method." );
interpolation->appendOption( kParamInterpolationNearest );
interpolation->appendOption( kParamInterpolationBilinear );
interpolation->setDefault( 1 );
OFX::ChoiceParamDescriptor* border = desc.defineChoiceParam( kParamBorder );
border->setLabel( "Gradient border" );
border->setHint( "Border method for gradient computation." );
border->appendOption( kParamBorderMirror );
border->appendOption( kParamBorderConstant );
border->appendOption( kParamBorderBlack );
border->appendOption( kParamBorderPadded );
}
void GenericTestExamplePluginFactory::describeInContext(OFX::ImageEffectDescriptor &desc, OFX::ContextEnum /*context*/)
{
ClipDescriptor *srcClip = desc.defineClip(kOfxImageEffectSimpleSourceClipName);
srcClip->addSupportedComponent(ePixelComponentRGBA);
srcClip->addSupportedComponent(ePixelComponentAlpha);
srcClip->setTemporalClipAccess(false);
srcClip->setSupportsTiles(true);
srcClip->setIsMask(false);
ClipDescriptor *dstClip = desc.defineClip(kOfxImageEffectOutputClipName);
dstClip->addSupportedComponent(ePixelComponentRGBA);
dstClip->addSupportedComponent(ePixelComponentAlpha);
dstClip->setSupportsTiles(true);
DoubleParamDescriptor *param1 = desc.defineDoubleParam("MinMaxTest");
param1->setLabels("Min/Max Test", "Min/Max Test", "Min/Max Test");
param1->setScriptName("minMaxTest");
param1->setHint("A double parameter to illustrate visual min/max.");
param1->setDefault(50.0);
param1->setRange(-1000, 1000);
param1->setDisplayRange(-1000, 1000);
param1->setDoubleType(eDoubleTypePlain);
ChoiceParamDescriptor* param2 = desc.defineChoiceParam("enableTest");
param2->setLabels("Enabler", "Enabler", "Enabler");
param2->appendOption("Enable parameter", "Enable parameter");
param2->appendOption("Disable parameter", "Disable parameter");
DoubleParamDescriptor *param3 = desc.defineDoubleParam("enableDbl");
param3->setLabels("Enabled by Enabler", "Enabled by Enabler", "Enabled by Enabler");
BooleanParamDescriptor* bparam = desc.defineBooleanParam("Insignificant");
bparam->setLabels("Insignificant", "Insignificant", "Insignificant");
bparam->setHint("Shouldn't cause a re-render.");
bparam->setEvaluateOnChange(false);
BooleanParamDescriptor* bparam2 = desc.defineBooleanParam("secretTest");
bparam2->setLabels("SECRET!", "SECRET!", "SECRET!");
bparam2->setIsSecret(true);
bparam2->setHint("Shouldn't be shown in the user interface.");
BooleanParamDescriptor* bparam3 = desc.defineBooleanParam("nonPersistent");
bparam3->setLabels("Non-persistent", "Non-persistent", "Non-persistent");
bparam3->setHint("Shouldn't be saved in the plugin description.");
bparam3->setIsPersistent(false);
DoubleParamDescriptor *param5 = desc.defineDoubleParam("animateDbl");
param5->setLabels("No Animation", "No Animation", "No Animation");
param5->setAnimates(false);
DoubleParamDescriptor *param6 = desc.defineDoubleParam("angleTest");
param6->setLabels("Angle?", "Angle?", "Angle?");
param6->setRange(-180.0, 180.0);
param6->setHint("An angle parameter.");
param6->setDoubleType(eDoubleTypeAngle);
PushButtonParamDescriptor* pb = desc.definePushButtonParam("pbButton");
pb->setLabels("Push Me", "Push Me", "Push Me");
PushButtonParamDescriptor* pb2 = desc.definePushButtonParam("analyseButton");
pb2->setLabels("Analyse", "Analyse", "Analyse");
DoubleParamDescriptor *param7 = desc.defineDoubleParam("analysisParam");
param7->setLabels("Analysis Slave", "Analysis Slave", "Analysis Slave");
Double2DParamDescriptor* widgetPos = desc.defineDouble2DParam("widgetPos");
widgetPos->setLabels("Widget Position", "Widget Position", "Widget Position");
widgetPos->setDoubleType(OFX::eDoubleTypeXYAbsolute);
widgetPos->setDefaultCoordinateSystem(eCoordinatesNormalised);
widgetPos->setDimensionLabels("X Position", "Y Position");
widgetPos->setDefault(0.5, 0.5);
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void HistogramPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( kSupportTiles );
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
//global display
OFX::BooleanParamDescriptor* boolGLOBAL = desc.defineBooleanParam(kGlobalDisplay);
boolGLOBAL->setHint("Display global overlay on screen.");
boolGLOBAL->setDefault(true);
// RGB / HSL
{
//Group Param (RGB & HSL)
OFX::GroupParamDescriptor *groupRGB = desc.defineGroupParam(kGroupRGB);
groupRGB->setLabel(kGroupRGBLabel);
OFX::GroupParamDescriptor *groupHSL = desc.defineGroupParam(kGroupHSL);
groupHSL->setLabel(kGroupHSLLabel);
//Channels checkboxes (RGB)
OFX::BooleanParamDescriptor* boolR = desc.defineBooleanParam(kBoolRed);
boolR->setDefault(true); //red channel is not selected by default
boolR->setHint("Activate Red channel");
boolR->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolR->setParent(groupRGB);
//red multiplier
OFX::DoubleParamDescriptor* redMultiplier = desc.defineDoubleParam(kMultiplierRed);
redMultiplier->setLabel(kMultiplierLabel);
redMultiplier->setHint("Determinate curve from selection precision.");
redMultiplier->setRange(1, 1000);
redMultiplier->setDisplayRange(0,5);
redMultiplier->setDefault(1);
redMultiplier->setParent(groupRGB);
OFX::BooleanParamDescriptor* boolG = desc.defineBooleanParam(kBoolGreen);
boolG->setDefault(true); //green channel is not selected by default
boolG->setHint("Activate Green channel");
boolG->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolG->setParent(groupRGB);
//green multiplier
OFX::DoubleParamDescriptor* greenMultiplier = desc.defineDoubleParam(kMultiplierGreen);
greenMultiplier->setLabel(kMultiplierLabel);
greenMultiplier->setHint("Determinate curve from selection precision.");
greenMultiplier->setRange(1, 1000);
greenMultiplier->setDisplayRange(0,5);
greenMultiplier->setDefault(1);
greenMultiplier->setParent(groupRGB);
OFX::BooleanParamDescriptor* boolB = desc.defineBooleanParam(kBoolBlue);
boolB->setHint("Activate Blue channel");
boolB->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolB->setDefault(true); //blue channel is not selected by default
boolB->setParent(groupRGB);
//blue multiplier
OFX::DoubleParamDescriptor* blueMultiplier = desc.defineDoubleParam(kMultiplierBlue);
blueMultiplier->setLabel(kMultiplierLabel);
blueMultiplier->setHint("Determinate curve from selection precision.");
blueMultiplier->setRange(1, 1000);
blueMultiplier->setDisplayRange(0,5);
blueMultiplier->setDefault(1);
blueMultiplier->setParent(groupRGB);
//Channels check box (HSL)
OFX::BooleanParamDescriptor* boolH = desc.defineBooleanParam(kBoolHue);
boolH->setDefault(true);
boolH->setHint("Activate Hue channel");
boolH->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolH->setParent(groupHSL);
//Hue multiplier
OFX::DoubleParamDescriptor* hueMultiplier = desc.defineDoubleParam(kMultiplierHue);
hueMultiplier->setLabel(kMultiplierLabel);
hueMultiplier->setHint("Determinate curve from selection precision.");
hueMultiplier->setRange(1, 1000);
hueMultiplier->setDisplayRange(0,5);
hueMultiplier->setDefault(1);
hueMultiplier->setParent(groupHSL);
OFX::BooleanParamDescriptor* boolS = desc.defineBooleanParam(kBoolSaturation);
boolS->setDefault(true);
boolS->setHint("Activate Saturation channel");
boolS->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolS->setParent(groupHSL);
//Saturation multiplier
OFX::DoubleParamDescriptor* saturationMultiplier = desc.defineDoubleParam(kMultiplierSaturation);
saturationMultiplier->setLabel(kMultiplierLabel);
saturationMultiplier->setHint("Determinate curve from selection precision.");
saturationMultiplier->setRange(1, 1000);
saturationMultiplier->setDisplayRange(0,5);
saturationMultiplier->setDefault(1);
saturationMultiplier->setParent(groupHSL);
OFX::BooleanParamDescriptor* boolL = desc.defineBooleanParam(kBoolLightness);
boolL->setHint("Activate Lightness channel");
boolL->setLayoutHint( OFX::eLayoutHintNoNewLine ); //line is not finished
boolL->setDefault(true);
boolL->setParent(groupHSL);
//Lightness multiplier
OFX::DoubleParamDescriptor* lightnessMultiplier = desc.defineDoubleParam(kMultiplierLightness);
lightnessMultiplier->setLabel(kMultiplierLabel);
lightnessMultiplier->setHint("Determinate curve from selection precision.");
lightnessMultiplier->setRange(1, 1000);
lightnessMultiplier->setDisplayRange(0,5);
lightnessMultiplier->setDefault(1);
lightnessMultiplier->setParent(groupHSL);
//Close RGB group (group states by default on screen)
groupRGB->setOpen(true);
groupHSL->setOpen(true);
}
//Histogram overlay group
{
OFX::GroupParamDescriptor *groupHistogramOverlay = desc.defineGroupParam(kGroupHistogramOverlay);
groupHistogramOverlay->setLabel(kGroupHistogramOverlayLabel);
groupHistogramOverlay->setOpen(true);
// groupHistogramOverlay->setAsTab();
//Histogram display settings
OFX::ChoiceParamDescriptor* gammaType = desc.defineChoiceParam(kHistoDisplayListParamLabel);
gammaType->setLabel(kHistoDisplayListParamLabel);
gammaType->setEvaluateOnChange(false); // don't need to recompute on change
gammaType->setHint("Histogram display \n -global : normalize all of channels \n -by channel : keep proportions between channels");
gammaType->appendOption(kHistoDisplayListParamOpt2);
gammaType->appendOption(kHistoDisplayListParamOpt1);
gammaType->setParent(groupHistogramOverlay);
//nbOfstep (advanced group)
OFX::IntParamDescriptor* nbStepRange = desc.defineIntParam(knbStepRange);
nbStepRange->setLabel(knbStepRangeLabel);
nbStepRange->setHint("Determinate histogram overlay precision.");
nbStepRange->setRange(1, 1000);
nbStepRange->setDisplayRange(1, 600.0 );
nbStepRange->setDefault(255);
nbStepRange->setEvaluateOnChange(false); // don't need to recompute on change
nbStepRange->setParent(groupHistogramOverlay);
//selection multiplier (advanced group)
OFX::DoubleParamDescriptor* selectionMultiplier = desc.defineDoubleParam(kselectionMultiplier);
selectionMultiplier->setLabel(kselectionMultiplierLabel);
selectionMultiplier->setHint("With high values, small selection are more visible.");
selectionMultiplier->setRange(0.001,1000.0);
selectionMultiplier->setDisplayRange(0.0, 100.0 );
selectionMultiplier->setDefault(2.0);
selectionMultiplier->setEvaluateOnChange(false); // don't need to recompute on change
selectionMultiplier->setParent(groupHistogramOverlay);
//Refresh histograms overlay Button
OFX::PushButtonParamDescriptor* refreshOverlayButton = desc.definePushButtonParam(kButtonRefreshOverlay);
refreshOverlayButton->setLabel(kButtonRefreshOverlayLabel);
refreshOverlayButton->setHint("Refresh histogram overlay.");
refreshOverlayButton->setParent(groupHistogramOverlay);
}
//Selection group
{
OFX::GroupParamDescriptor *groupSelection = desc.defineGroupParam(kGroupSelection);
groupSelection->setLabel(kGroupSelectionLabel);
groupSelection->setOpen(false);
// groupSelection->setAsTab();
//display selection
OFX::BooleanParamDescriptor* boolDisplaySelection = desc.defineBooleanParam(kBoolSelection);
boolDisplaySelection->setDefault(true);
boolDisplaySelection->setEvaluateOnChange(false);// don't need to recompute on change
boolDisplaySelection->setHint("Display the selected zone on screen.");
boolDisplaySelection->setParent(groupSelection);
//clear selection
OFX::PushButtonParamDescriptor* resetSelectionButton = desc.definePushButtonParam(kButtonResetSelection);
resetSelectionButton->setLabel(kButtonResetSelectionLabel);
resetSelectionButton->setHint("Reset user's selection.");
resetSelectionButton->setParent(groupSelection);
//selection mode
OFX::ChoiceParamDescriptor* selectionMode = desc.defineChoiceParam(kSelectionModeListParamLabel);
selectionMode->setLabel(kSelectionModeListParamLabel);
selectionMode->setHint( "Selection mode \n - unique : reset past selection before selection \n - additive : add pixels to current selection \n -subtractive : remote pixel from current selection");
selectionMode->appendOption(kSelectionModeListParamOpt2);
selectionMode->appendOption(kSelectionModeListParamOpt1);
selectionMode->appendOption(kSelectionModeListParamOpt3);
selectionMode->setParent(groupSelection);
}
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void AVReaderPluginFactory::describeInContext(OFX::ImageEffectDescriptor& desc, OFX::EContext context)
{
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip(kOfxImageEffectOutputClipName);
dstClip->addSupportedComponent(OFX::ePixelComponentRGBA);
dstClip->addSupportedComponent(OFX::ePixelComponentRGB);
dstClip->addSupportedComponent(OFX::ePixelComponentAlpha);
dstClip->setSupportsTiles(kSupportTiles);
describeReaderParamsInContext(desc, context);
// Groups
OFX::GroupParamDescriptor* formatGroup = desc.defineGroupParam(kParamFormatGroup);
OFX::GroupParamDescriptor* videoGroup = desc.defineGroupParam(kParamVideoGroup);
OFX::GroupParamDescriptor* metaGroup = desc.defineGroupParam(kParamMetaGroup);
formatGroup->setLabel("Format");
videoGroup->setLabel("Video");
metaGroup->setLabel("Metadata");
formatGroup->setAsTab();
videoGroup->setAsTab();
metaGroup->setAsTab();
/// FORMAT PARAMETERS
avtranscoder::FormatContext formatContext(AV_OPT_FLAG_DECODING_PARAM);
avtranscoder::OptionArray formatOptions = formatContext.getOptions();
common::addOptionsToGroup(desc, formatGroup, formatOptions, common::kPrefixFormat);
OFX::GroupParamDescriptor* formatDetailedGroup = desc.defineGroupParam(kParamFormatDetailedGroup);
formatDetailedGroup->setLabel("Detailed");
formatDetailedGroup->setAsTab();
formatDetailedGroup->setParent(formatGroup);
avtranscoder::OptionArrayMap formatDetailedGroupOptions = avtranscoder::getAvailableOptionsPerOutputFormat();
common::addOptionsToGroup(desc, formatDetailedGroup, formatDetailedGroupOptions, common::kPrefixFormat);
/// VIDEO PARAMETERS
AVCodecContext* videoContext = avcodec_alloc_context3(NULL);
avtranscoder::OptionArray videoOptions;
avtranscoder::loadOptions(videoOptions, videoContext, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM);
common::addOptionsToGroup(desc, videoGroup, videoOptions, common::kPrefixVideo);
av_free(videoContext);
OFX::BooleanParamDescriptor* useCustomSAR = desc.defineBooleanParam(kParamUseCustomSAR);
useCustomSAR->setLabel("Override SAR");
useCustomSAR->setDefault(false);
useCustomSAR->setHint("Override the file SAR (Storage Aspect Ratio) with a custom SAR value.");
useCustomSAR->setParent(videoGroup);
OFX::DoubleParamDescriptor* customSAR = desc.defineDoubleParam(kParamCustomSAR);
customSAR->setLabel("Custom SAR");
customSAR->setDefault(1.0);
customSAR->setDisplayRange(0., 3.);
customSAR->setRange(0., 10.);
customSAR->setHint("Choose a custom value to override the file SAR (Storage Aspect Ratio). Maximum value: 10.");
customSAR->setParent(videoGroup);
OFX::IntParamDescriptor* streamIndex = desc.defineIntParam(kParamVideoStreamIndex);
streamIndex->setLabel(kParamVideoStreamIndexLabel);
streamIndex->setDefault(0);
streamIndex->setDisplayRange(0., 16.);
streamIndex->setRange(0., 100.);
streamIndex->setHint("Choose a custom value to decode the video stream you want. Maximum value: 100.");
streamIndex->setParent(videoGroup);
OFX::GroupParamDescriptor* videoDetailedGroup = desc.defineGroupParam(kParamVideoDetailedGroup);
videoDetailedGroup->setLabel("Detailed");
videoDetailedGroup->setAsTab();
videoDetailedGroup->setParent(videoGroup);
avtranscoder::OptionArrayMap videoDetailedGroupOptions = avtranscoder::getAvailableOptionsPerVideoCodec();
common::addOptionsToGroup(desc, videoDetailedGroup, videoDetailedGroupOptions, common::kPrefixVideo);
/// METADATA PARAMETERS
AVCodecContext* metaDataContext = avcodec_alloc_context3(NULL);
avtranscoder::OptionArray metaDataOptions;
avtranscoder::loadOptions(metaDataOptions, metaDataContext, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_METADATA);
common::addOptionsToGroup(desc, metaGroup, metaDataOptions, common::kPrefixMetaData);
av_free(metaDataContext);
OFX::StringParamDescriptor* metaDataWrapper = desc.defineStringParam(kParamMetaDataWrapper);
metaDataWrapper->setLabel(kParamMetaDataWrapperLabel);
metaDataWrapper->setEnabled(false);
metaDataWrapper->setStringType(OFX::eStringTypeMultiLine);
metaDataWrapper->setParent(metaGroup);
OFX::StringParamDescriptor* metaDataVideo = desc.defineStringParam(kParamMetaDataVideo);
metaDataVideo->setLabel(kParamMetaDataVideoLabel);
metaDataVideo->setEnabled(false);
metaDataVideo->setStringType(OFX::eStringTypeMultiLine);
metaDataVideo->setParent(metaGroup);
OFX::StringParamDescriptor* metaDataAudio = desc.defineStringParam(kParamMetaDataAudio);
metaDataAudio->setLabel(kParamMetaDataAudioLabel);
metaDataAudio->setEnabled(false);
metaDataAudio->setStringType(OFX::eStringTypeMultiLine);
metaDataAudio->setParent(metaGroup);
OFX::StringParamDescriptor* metaDataData = desc.defineStringParam(kParamMetaDataData);
metaDataData->setLabel(kParamMetaDataDataLabel);
metaDataData->setEnabled(false);
metaDataData->setStringType(OFX::eStringTypeMultiLine);
metaDataData->setParent(metaGroup);
OFX::StringParamDescriptor* metaDataSubtitle = desc.defineStringParam(kParamMetaDataSubtitle);
metaDataSubtitle->setLabel(kParamMetaDataSubtitleLabel);
metaDataSubtitle->setEnabled(false);
metaDataSubtitle->setStringType(OFX::eStringTypeMultiLine);
metaDataSubtitle->setParent(metaGroup);
OFX::StringParamDescriptor* metaDataAttachement = desc.defineStringParam(kParamMetaDataAttachement);
metaDataAttachement->setLabel(kParamMetaDataAttachementLabel);
metaDataAttachement->setEnabled(false);
metaDataAttachement->setStringType(OFX::eStringTypeMultiLine);
metaDataAttachement->setParent(metaGroup);
OFX::StringParamDescriptor* metaDataUnknown = desc.defineStringParam(kParamMetaDataUnknown);
metaDataUnknown->setLabel(kParamMetaDataUnknownLabel);
metaDataUnknown->setEnabled(false);
metaDataUnknown->setStringType(OFX::eStringTypeMultiLine);
metaDataUnknown->setParent(metaGroup);
/// VERBOSE
OFX::BooleanParamDescriptor* useVerbose = desc.defineBooleanParam(kParamVerbose);
useVerbose->setLabel("Set to verbose");
useVerbose->setDefault(false);
useVerbose->setHint("Set plugin to verbose to get debug informations.");
}
/**
* @brief Function called to describe the plugin controls and features.
* @param[in, out] desc Effect descriptor
* @param[in] context Application context
*/
void ColorTransformPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
OFX::EContext context )
{
OFX::ClipDescriptor* srcClip = desc.defineClip( kOfxImageEffectSimpleSourceClipName );
srcClip->addSupportedComponent( OFX::ePixelComponentRGBA );
srcClip->addSupportedComponent( OFX::ePixelComponentRGB );
srcClip->addSupportedComponent( OFX::ePixelComponentAlpha );
srcClip->setSupportsTiles( kSupportTiles );
// Create the mandated output clip
OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
dstClip->setSupportsTiles( kSupportTiles );
OFX::DoubleParamDescriptor* paramHueShift = desc.defineDoubleParam( kParamHueShift );
paramHueShift->setLabel( "Hue Shift" );
paramHueShift->setDefault( 0.0 );
paramHueShift->setDisplayRange( 0.0, 1.0 );
OFX::DoubleParamDescriptor* paramSaturation = desc.defineDoubleParam( kParamSaturation );
paramSaturation->setLabel( "Saturation" );
paramSaturation->setDefault( 0.0 );
paramSaturation->setDisplayRange( 0.0, 1.0 );
OFX::DoubleParamDescriptor* paramBrightnessRGB = desc.defineDoubleParam( kParamBrightnessRGB );
paramBrightnessRGB->setLabel( "Global Brightness RGB" );
paramBrightnessRGB->setHint( "Global manipulation of RGB brightness." );
paramBrightnessRGB->setDefault( 1.0 );
paramBrightnessRGB->setDisplayRange( 0.0, 1.0 );
OFX::RGBAParamDescriptor* paramBrightness = desc.defineRGBAParam( kParamBrightness );
paramBrightness->setLabel( "Brightness" );
paramBrightness->setDefault( 1.0, 1.0, 1.0, 1.0 );
OFX::DoubleParamDescriptor* paramPivotRGB = desc.defineDoubleParam( kParamPivotRGB );
paramPivotRGB->setLabel( "Global Pivot RGB" );
paramPivotRGB->setHint( "Global manipulation of RGB pivot." );
paramPivotRGB->setDefault( 0.0 );
paramPivotRGB->setDisplayRange( 0.0, 1.0 );
OFX::RGBAParamDescriptor* paramPivot = desc.defineRGBAParam( kParamPivot );
paramPivot->setLabel( "Pivot" );
paramPivot->setDefault( 0.0, 0.0, 0.0, 0.0 );
OFX::DoubleParamDescriptor* paramContrastRGB = desc.defineDoubleParam( kParamContrastRGB );
paramContrastRGB->setLabel( "Global Contrast RGB" );
paramContrastRGB->setHint( "Global manipulation of RGB contrast." );
paramContrastRGB->setDefault( 1.0 );
paramContrastRGB->setDisplayRange( 0.0, 1.0 );
OFX::RGBAParamDescriptor* paramContrast = desc.defineRGBAParam( kParamContrast );
paramContrast->setLabel( "Contrast" );
paramContrast->setDefault( 1.0, 1.0, 1.0, 1.0 );
OFX::DoubleParamDescriptor* paramOffsetRGB = desc.defineDoubleParam( kParamOffsetRGB );
paramOffsetRGB->setLabel( "Global Offset RGB" );
paramOffsetRGB->setHint( "Global manipulation of RGB offset." );
paramOffsetRGB->setDefault( 0.0 );
paramOffsetRGB->setDisplayRange( 0.0, 1.0 );
OFX::RGBAParamDescriptor* paramOffset = desc.defineRGBAParam( kParamOffset );
paramOffset->setLabel( "Offset" );
paramOffset->setDefault( 0.0, 0.0, 0.0, 0.0 );
}