void
KnobGuiBool::onLabelChanged()
{
KnobBoolPtr knob = _knob.lock();
if (!knob) {
return;
}
const std::string& label = knob->getLabel();
if ( (label == "R") || (label == "r") || (label == "red") ) {
QColor color;
color.setRgbF(0.851643, 0.196936, 0.196936);
_checkBox->setCustomColor(color, true);
} else if ( (label == "G") || (label == "g") || (label == "green") ) {
QColor color;
color.setRgbF(0, 0.654707, 0);
_checkBox->setCustomColor(color, true);
} else if ( (label == "B") || (label == "b") || (label == "blue") ) {
QColor color;
color.setRgbF(0.345293, 0.345293, 1);
_checkBox->setCustomColor(color, true);
} else if ( (label == "A") || (label == "a") || (label == "alpha") ) {
QColor color;
color.setRgbF(0.398979, 0.398979, 0.398979);
_checkBox->setCustomColor(color, true);
} else {
_checkBox->setCustomColor(Qt::black, false);
}
}
void
KnobGuiBool::onCheckBoxStateChanged(bool b)
{
KnobBoolPtr knob = _knob.lock();
if (!knob) {
return;
}
getKnobGui()->pushUndoCommand( new KnobUndoCommand<bool>(knob, knob->getValue(DimIdx(0), getView()), b, DimIdx(0), getView()) );
}
bool getInteractive() const
{
KnobBoolPtr inter = interactive.lock();
if (inter) {
return inter->getValue();
} else {
return !appPTR->getCurrentSettings()->getRenderOnEditingFinishedOnly();
}
}
bool getInverted(TimeValue time) const
{
KnobBoolPtr knob = invert.lock();
if (!knob) {
return false;
}
return knob->getValueAtTime(time);
}
bool getEnabled(TimeValue time,
int index) const
{
KnobBoolPtr knob = enable[index].lock();
if (!knob) {
return true;
}
return knob->getValueAtTime(time);
}
void
KnobGuiBool::onLabelClicked(bool b)
{
if ( _checkBox->getReadOnly() ) {
return;
}
_checkBox->setChecked(b);
KnobBoolPtr knob = _knob.lock();
getKnobGui()->pushUndoCommand( new KnobUndoCommand<bool>(knob, knob->getValue(DimIdx(0), getView()), b, DimIdx(0), getView()) );
}
void
TrackMarker::setEnabledAtTime(TimeValue time,
bool enabled)
{
KnobBoolPtr knob = _imp->enabled.lock();
if (!knob) {
return;
}
knob->setValueAtTime(time, enabled, ViewSetSpec::all(), DimIdx(0));
}
void
KnobGuiBool::updateGUI()
{
KnobBoolPtr knob = _knob.lock();
if (!knob) {
return;
}
bool checked = knob->getValue(DimIdx(0), getView());
if (_checkBox->isChecked() == checked) {
return;
}
_checkBox->setChecked(checked);
}
void
KnobGuiBool::reflectAnimationLevel(DimIdx /*dimension*/,
AnimationLevelEnum level)
{
int value = (int)level;
if ( value != _checkBox->getAnimation() ) {
KnobBoolPtr knob = _knob.lock();
if (!knob) {
return;
}
bool isEnabled = knob->isEnabled();
_checkBox->setReadOnly(level == eAnimationLevelExpression || !isEnabled);
_checkBox->setAnimation(value);
}
}
void
TrackMarker::setEnabledFromGui(double /*time*/,
bool enabled)
{
KnobBoolPtr knob = _imp->enabled.lock();
if (!knob) {
return;
}
KeyFrame k;
std::pair<int, KnobIPtr> master = knob->getMaster(0);
if (master.second) {
knob->unSlave(0, true);
}
knob->onValueChanged(enabled, ViewSpec::all(), 0, eValueChangedReasonNatronGuiEdited, &k);
if (master.second) {
master.second->cloneAndUpdateGui(knob);
knob->slaveTo(0, master.second, master.first);
}
getContext()->solveTransformParamsIfAutomatic();
}
void
TrackMarkerPM::initializeKnobs()
{
TrackMarker::initializeKnobs();
NodePtr thisNode = getContext()->getNode();
QObject::connect( getContext().get(), SIGNAL(onNodeInputChanged(int)), this, SLOT(onTrackerNodeInputChanged(int)) );
NodePtr node;
{
CreateNodeArgs args( PLUGINID_OFX_TRACKERPM, NodeCollectionPtr() );
args.setProperty<bool>(kCreateNodeArgsPropOutOfProject, true);
args.setProperty<bool>(kCreateNodeArgsPropNoNodeGUI, true);
args.setProperty<std::string>(kCreateNodeArgsPropNodeInitialName, "TrackerPMNode");
node = getContext()->getNode()->getApp()->createNode(args);
if (!node) {
throw std::runtime_error("Couldn't create plug-in " PLUGINID_OFX_TRACKERPM);
}
if (thisNode) {
NodePtr inputNode = thisNode->getInput(0);
if (inputNode) {
node->connectInput(inputNode, 0);
}
}
trackerNode = node;
}
trackPrevButton = getNodeKnob<KnobButton>(node, kTrackerPMParamTrackingPrevious);
trackNextButton = getNodeKnob<KnobButton>(node, kTrackerPMParamTrackingNext);
KnobDoublePtr center = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingCenterPoint);
centerKnob = center;
// Slave the center knob and unslave when tracking
for (int i = 0; i < center->getDimension(); ++i) {
center->slaveTo(i, getCenterKnob(), i);
}
KnobDoublePtr offset = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingOffset);
// Slave the offset knob
for (int i = 0; i < offset->getDimension(); ++i) {
offset->slaveTo(i, getOffsetKnob(), i);
}
offsetKnob = offset;
// Ref frame is set for each
refFrameKnob = getNodeKnob<KnobInt>(node, kTrackerPMParamTrackingReferenceFrame);
// Enable reference frame
KnobBoolPtr enableRefFrameKnob = getNodeKnob<KnobBool>(node, kTrackerPMParamTrackingEnableReferenceFrame);
enableRefFrameKnob->setValue(true);
KnobChoicePtr scoreType = getNodeKnob<KnobChoice>(node, kTrackerPMParamScore);
scoreType->slaveTo(0, getContext()->getCorrelationScoreTypeKnob(), 0);
scoreTypeKnob = scoreType;
KnobDoublePtr correlationScore = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingCorrelationScore);
correlationScoreKnob = correlationScore;
KnobDoublePtr patternBtmLeft = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingPatternBoxBtmLeft);
patternBtmLeftKnob = patternBtmLeft;
// Slave the search window and pattern of the node to the parameters of the marker
for (int i = 0; i < patternBtmLeft->getDimension(); ++i) {
patternBtmLeft->slaveTo(i, getPatternBtmLeftKnob(), i);
}
KnobDoublePtr patternTopRight = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingPatternBoxTopRight);
patternTopRightKnob = patternTopRight;
for (int i = 0; i < patternTopRight->getDimension(); ++i) {
patternTopRight->slaveTo(i, getPatternTopRightKnob(), i);
}
KnobDoublePtr searchWindowBtmLeft = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingSearchBoxBtmLeft);
searchWindowBtmLeftKnob = searchWindowBtmLeft;
for (int i = 0; i < searchWindowBtmLeft->getDimension(); ++i) {
searchWindowBtmLeft->slaveTo(i, getSearchWindowBottomLeftKnob(), i);
}
KnobDoublePtr searchWindowTopRight = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingSearchBoxTopRight);
searchWindowTopRightKnob = searchWindowTopRight;
for (int i = 0; i < searchWindowTopRight->getDimension(); ++i) {
searchWindowTopRight->slaveTo(i, getSearchWindowTopRightKnob(), i);
}
} // TrackMarkerPM::initializeKnobs
void
TrackMarkerPM::initializeKnobs()
{
TrackMarker::initializeKnobs();
NodePtr thisNode = getModel()->getNode();
NodePtr node;
{
CreateNodeArgsPtr args(CreateNodeArgs::create( PLUGINID_OFX_TRACKERPM, NodeCollectionPtr() ));
args->setProperty<bool>(kCreateNodeArgsPropVolatile, true);
args->setProperty<bool>(kCreateNodeArgsPropNoNodeGUI, true);
args->setProperty<std::string>(kCreateNodeArgsPropNodeInitialName, "TrackerPMNode");
node = getApp()->createNode(args);
if (!node) {
throw std::runtime_error("Couldn't create plug-in " PLUGINID_OFX_TRACKERPM);
}
if (thisNode) {
NodePtr inputNode = thisNode->getInput(0);
if (inputNode) {
node->connectInput(inputNode, 0);
}
}
trackerNode = node;
}
KnobItemsTablePtr model = getModel();
EffectInstancePtr effect;
if (model) {
effect = model->getNode()->getEffectInstance();
}
trackPrevButton = getNodeKnob<KnobButton>(node, kTrackerPMParamTrackingPrevious);
trackNextButton = getNodeKnob<KnobButton>(node, kTrackerPMParamTrackingNext);
KnobDoublePtr center = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingCenterPoint);
centerKnob = center;
// Slave the center knob and unslave when tracking
if ( !center->linkTo(getCenterKnob()) ) {
throw std::runtime_error("Could not link center");
}
KnobDoublePtr offset = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingOffset);
// Slave the offset knob
if ( !offset->linkTo( getOffsetKnob() ) ) {
throw std::runtime_error("Could not link offset");
}
offsetKnob = offset;
// Ref frame is set for each
refFrameKnob = getNodeKnob<KnobInt>(node, kTrackerPMParamTrackingReferenceFrame);
// Enable reference frame
KnobBoolPtr enableRefFrameKnob = getNodeKnob<KnobBool>(node, kTrackerPMParamTrackingEnableReferenceFrame);
enableRefFrameKnob->setValue(true);
KnobChoicePtr scoreType = getNodeKnob<KnobChoice>(node, kTrackerPMParamScore);
if (effect) {
#ifdef kTrackerParamPatternMatchingScoreType
KnobIPtr modelKnob = effect->getKnobByName(kTrackerParamPatternMatchingScoreType);
if (modelKnob) {
if ( !scoreType->linkTo(modelKnob) ) {
throw std::runtime_error("Could not link scoreType");
}
}
#endif
}
scoreTypeKnob = scoreType;
KnobDoublePtr correlationScore = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingCorrelationScore);
correlationScoreKnob = correlationScore;
KnobDoublePtr patternBtmLeft = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingPatternBoxBtmLeft);
patternBtmLeftKnob = patternBtmLeft;
// Slave the search window and pattern of the node to the parameters of the marker
(void)patternBtmLeft->linkTo(getPatternBtmLeftKnob());
KnobDoublePtr patternTopRight = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingPatternBoxTopRight);
patternTopRightKnob = patternTopRight;
(void)patternTopRight->linkTo(getPatternTopRightKnob());
KnobDoublePtr searchWindowBtmLeft = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingSearchBoxBtmLeft);
searchWindowBtmLeftKnob = searchWindowBtmLeft;
(void)searchWindowBtmLeft->linkTo(getSearchWindowBottomLeftKnob());
KnobDoublePtr searchWindowTopRight = getNodeKnob<KnobDouble>(node, kTrackerPMParamTrackingSearchBoxTopRight);
searchWindowTopRightKnob = searchWindowTopRight;
(void)searchWindowTopRight->linkTo(getSearchWindowTopRightKnob());
} // TrackMarkerPM::initializeKnobs
void
TrackMarker::initializeKnobs()
{
KnobItemsTablePtr model = getModel();
EffectInstancePtr effect;
if (model) {
effect = model->getNode()->getEffectInstance();
}
KnobIntPtr defPatternSizeKnob, defSearchSizeKnob;
KnobChoicePtr defMotionModelKnob;
defPatternSizeKnob = toKnobInt(effect->getKnobByName(kTrackerUIParamDefaultMarkerPatternWinSize));
defSearchSizeKnob = toKnobInt(effect->getKnobByName(kTrackerUIParamDefaultMarkerSearchWinSize));
defMotionModelKnob = toKnobChoice(effect->getKnobByName(kTrackerUIParamDefaultMotionModel));
double patternHalfSize = defPatternSizeKnob ? defPatternSizeKnob->getValue() / 2. : 21;
double searchHalfSize = defSearchSizeKnob ? defSearchSizeKnob->getValue() / 2. : 71;
int defMotionModel_i = defMotionModelKnob ? defMotionModelKnob->getValue() : 0;
KnobDoublePtr swbbtmLeft = createKnob<KnobDouble>(kTrackerParamSearchWndBtmLeft, 2);
swbbtmLeft->setLabel(tr(kTrackerParamSearchWndBtmLeftLabel));
swbbtmLeft->setDefaultValue(-searchHalfSize, DimIdx(0));
swbbtmLeft->setDefaultValue(-searchHalfSize, DimIdx(1));
swbbtmLeft->setHintToolTip( tr(kTrackerParamSearchWndBtmLeftHint) );
_imp->searchWindowBtmLeft = swbbtmLeft;
KnobDoublePtr swbtRight = createKnob<KnobDouble>(kTrackerParamSearchWndTopRight, 2);
swbtRight->setLabel(tr(kTrackerParamSearchWndTopRightLabel));
swbtRight->setDefaultValue(searchHalfSize, DimIdx(0));
swbtRight->setDefaultValue(searchHalfSize, DimIdx(1));
swbtRight->setHintToolTip( tr(kTrackerParamSearchWndTopRightHint) );
_imp->searchWindowTopRight = swbtRight;
KnobDoublePtr ptLeft = createKnob<KnobDouble>(kTrackerParamPatternTopLeft, 2);
ptLeft->setLabel(tr(kTrackerParamPatternTopLeftLabel));
ptLeft->setDefaultValue(-patternHalfSize, DimIdx(0));
ptLeft->setDefaultValue(patternHalfSize, DimIdx(1));
ptLeft->setHintToolTip( tr(kTrackerParamPatternTopLeftHint) );
_imp->patternTopLeft = ptLeft;
KnobDoublePtr ptRight = createKnob<KnobDouble>(kTrackerParamPatternTopRight, 2);
ptRight->setLabel(tr(kTrackerParamPatternTopRightLabel));
ptRight->setDefaultValue(patternHalfSize, DimIdx(0));
ptRight->setDefaultValue(patternHalfSize, DimIdx(1));
ptRight->setHintToolTip( tr(kTrackerParamPatternTopRightHint) );
_imp->patternTopRight = ptRight;
KnobDoublePtr pBRight = createKnob<KnobDouble>(kTrackerParamPatternBtmRight, 2);
pBRight->setLabel(tr(kTrackerParamPatternBtmRightLabel));
pBRight->setDefaultValue(patternHalfSize, DimIdx(0));
pBRight->setDefaultValue(-patternHalfSize, DimIdx(1));
pBRight->setHintToolTip( tr(kTrackerParamPatternBtmRightHint) );
_imp->patternBtmRight = pBRight;
KnobDoublePtr pBLeft = createKnob<KnobDouble>(kTrackerParamPatternBtmLeft, 2);
pBLeft->setLabel(tr(kTrackerParamPatternBtmLeftLabel));
pBLeft->setDefaultValue(-patternHalfSize, DimIdx(0));
pBLeft->setDefaultValue(-patternHalfSize, DimIdx(1));
pBLeft->setHintToolTip( tr(kTrackerParamPatternBtmLeftHint) );
_imp->patternBtmLeft = pBLeft;
KnobDoublePtr centerKnob = createKnob<KnobDouble>(kTrackerParamCenter, 2);
centerKnob->setLabel(tr(kTrackerParamCenterLabel));
centerKnob->setHintToolTip( tr(kTrackerParamCenterHint) );
_imp->center = centerKnob;
KnobDoublePtr offsetKnob = createKnob<KnobDouble>(kTrackerParamOffset, 2);
offsetKnob->setLabel(tr(kTrackerParamOffsetLabel));
offsetKnob->setHintToolTip( tr(kTrackerParamOffsetHint) );
_imp->offset = offsetKnob;
#ifdef NATRON_TRACK_MARKER_USE_WEIGHT
KnobDoublePtr weightKnob = createKnob<KnobDouble>(kTrackerParamTrackWeight, 1);
weightKnob->setLabel(tr(kTrackerParamTrackWeightLabel));
weightKnob->setHintToolTip( tr(kTrackerParamTrackWeightHint) );
weightKnob->setDefaultValue(1.);
weightKnob->setAnimationEnabled(false);
weightKnob->setRange(0., 1.);
_imp->weight = weightKnob;
#endif
KnobChoicePtr mmodelKnob = createKnob<KnobChoice>(kTrackerParamMotionModel, 1);
mmodelKnob->setHintToolTip( tr(kTrackerParamMotionModelHint) );
mmodelKnob->setLabel(tr(kTrackerParamMotionModelLabel));
{
std::vector<ChoiceOption> choices, helps;
std::map<int, std::string> icons;
TrackerNodePrivate::getMotionModelsAndHelps(true, &choices, &icons);
mmodelKnob->populateChoices(choices);
mmodelKnob->setIcons(icons);
}
mmodelKnob->setDefaultValue(defMotionModel_i);
_imp->motionModel = mmodelKnob;
KnobDoublePtr errKnob = createKnob<KnobDouble>(kTrackerParamError, 1);
errKnob->setLabel(tr(kTrackerParamErrorLabel));
_imp->error = errKnob;
KnobBoolPtr enableKnob = createKnob<KnobBool>(kTrackerParamEnabled, 1);
enableKnob->setLabel(tr(kTrackerParamEnabledLabel));
enableKnob->setHintToolTip( tr(kTrackerParamEnabledHint) );
enableKnob->setAnimationEnabled(true);
enableKnob->setDefaultValue(true);
_imp->enabled = enableKnob;
addColumn(kKnobTableItemColumnLabel, DimIdx(0));
addColumn(kTrackerParamEnabled, DimIdx(0));
addColumn(kTrackerParamMotionModel, DimIdx(0));
addColumn(kTrackerParamCenter, DimIdx(0));
addColumn(kTrackerParamCenter, DimIdx(1));
addColumn(kTrackerParamOffset, DimIdx(0));
addColumn(kTrackerParamOffset, DimIdx(1));
addColumn(kTrackerParamError, DimIdx(0));
} // TrackMarker::initializeKnobs
void
TrackerNodePrivate::exportTrackDataFromExportOptions()
{
//bool transformLink = _imp->exportLink.lock()->getValue();
KnobChoicePtr transformTypeKnob = transformType.lock();
assert(transformTypeKnob);
int transformType_i = transformTypeKnob->getValue();
TrackerTransformNodeEnum transformType = (TrackerTransformNodeEnum)transformType_i;
KnobChoicePtr motionTypeKnob = motionType.lock();
if (!motionTypeKnob) {
return;
}
int motionType_i = motionTypeKnob->getValue();
TrackerMotionTypeEnum mt = (TrackerMotionTypeEnum)motionType_i;
if (mt == eTrackerMotionTypeNone) {
Dialogs::errorDialog( tr("Tracker Export").toStdString(), tr("Please select the export mode with the Motion Type parameter").toStdString() );
return;
}
bool linked = exportLink.lock()->getValue();
QString pluginID;
switch (transformType) {
case eTrackerTransformNodeCornerPin:
pluginID = QString::fromUtf8(PLUGINID_OFX_CORNERPIN);
break;
case eTrackerTransformNodeTransform:
pluginID = QString::fromUtf8(PLUGINID_OFX_TRANSFORM);
break;
}
NodePtr thisNode = publicInterface->getNode();
AppInstancePtr app = thisNode->getApp();
CreateNodeArgsPtr args(CreateNodeArgs::create( pluginID.toStdString(), thisNode->getGroup() ));
args->setProperty<bool>(kCreateNodeArgsPropAutoConnect, false);
args->setProperty<bool>(kCreateNodeArgsPropSettingsOpened, false);
NodePtr createdNode = app->createNode(args);
if (!createdNode) {
return;
}
// Move the new node
double thisNodePos[2];
double thisNodeSize[2];
thisNode->getPosition(&thisNodePos[0], &thisNodePos[1]);
thisNode->getSize(&thisNodeSize[0], &thisNodeSize[1]);
createdNode->setPosition(thisNodePos[0] + thisNodeSize[0] * 2., thisNodePos[1]);
TimeValue timeForFromPoints(referenceFrame.lock()->getValue());
switch (transformType) {
case eTrackerTransformNodeCornerPin: {
KnobDoublePtr cornerPinToPoints[4];
KnobDoublePtr cornerPinFromPoints[4];
for (unsigned int i = 0; i < 4; ++i) {
cornerPinFromPoints[i] = getCornerPinPoint(createdNode, true, i);
assert(cornerPinFromPoints[i]);
for (int j = 0; j < cornerPinFromPoints[i]->getNDimensions(); ++j) {
cornerPinFromPoints[i]->setValue(fromPoints[i].lock()->getValueAtTime(timeForFromPoints, DimIdx(j)), ViewSetSpec::all(), DimIdx(j));
}
cornerPinToPoints[i] = getCornerPinPoint(createdNode, false, i);
assert(cornerPinToPoints[i]);
if (!linked) {
cornerPinToPoints[i]->copyKnob( toPoints[i].lock() );
} else {
bool ok = cornerPinToPoints[i]->linkTo(toPoints[i].lock());
(void)ok;
assert(ok);
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kCornerPinParamMatrix);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(cornerPinMatrix.lock() );
}
}
}
break;
}
case eTrackerTransformNodeTransform: {
KnobIPtr translateKnob = createdNode->getKnobByName(kTransformParamTranslate);
if (translateKnob) {
KnobDoublePtr isDbl = toKnobDouble(translateKnob);
if (isDbl) {
if (!linked) {
isDbl->copyKnob(translate.lock() );
} else {
ignore_result(isDbl->linkTo(translate.lock()));
}
}
}
KnobIPtr scaleKnob = createdNode->getKnobByName(kTransformParamScale);
if (scaleKnob) {
KnobDoublePtr isDbl = toKnobDouble(scaleKnob);
if (isDbl) {
if (!linked) {
isDbl->copyKnob(scale.lock() );
} else {
ignore_result(isDbl->linkTo(scale.lock()));
}
}
}
KnobIPtr rotateKnob = createdNode->getKnobByName(kTransformParamRotate);
if (rotateKnob) {
KnobDoublePtr isDbl = toKnobDouble(rotateKnob);
if (isDbl) {
if (!linked) {
isDbl->copyKnob(rotate.lock());
} else {
ignore_result(isDbl->linkTo(rotate.lock()));
}
}
}
KnobIPtr centerKnob = createdNode->getKnobByName(kTransformParamCenter);
if (centerKnob) {
KnobDoublePtr isDbl = toKnobDouble(centerKnob);
if (isDbl) {
isDbl->copyKnob( center.lock() );
}
}
break;
}
} // switch
KnobIPtr cpInvertKnob = createdNode->getKnobByName(kTransformParamInvert);
if (cpInvertKnob) {
KnobBoolPtr isBool = toKnobBool(cpInvertKnob);
if (isBool) {
if (!linked) {
isBool->copyKnob(invertTransform.lock());
} else {
ignore_result(isBool->linkTo(invertTransform.lock()));
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamMotionBlur);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(motionBlur.lock());
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamShutter);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(shutter.lock());
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamShutterOffset);
if (knob) {
KnobChoicePtr isType = toKnobChoice(knob);
if (isType) {
isType->copyKnob(shutterOffset.lock());
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamCustomShutterOffset);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(customShutterOffset.lock());
}
}
}
} // exportTrackDataFromExportOptions
NATRON_NAMESPACE_ENTER
// those parameters should be ignored (they are always secret in Natron)
#define kOCIOParamInputSpace "ocioInputSpace"
#define kOCIOParamOutputSpace "ocioOutputSpace"
// those parameters should not have their options in the help file if generating markdown,
// because the options are dinamlically constructed at run-time from the OCIO config.
#define kOCIOParamInputSpaceChoice "ocioInputSpaceIndex"
#define kOCIOParamOutputSpaceChoice "ocioOutputSpaceIndex"
#define kOCIODisplayPluginIdentifier "fr.inria.openfx.OCIODisplay"
#define kOCIODisplayParamDisplay "display"
#define kOCIODisplayParamDisplayChoice "displayIndex"
#define kOCIODisplayParamView "view"
#define kOCIODisplayParamViewChoice "viewIndex"
// not yet implemented (see OCIOCDLTransform.cpp)
//#define kOCIOCDLTransformPluginIdentifier "fr.inria.openfx.OCIOCDLTransform"
//#define kOCIOCDLTransformParamCCCID "cccId"
//#define kOCIOCDLTransformParamCCCIDChoice "cccIdIndex"
#define kOCIOFileTransformPluginIdentifier "fr.inria.openfx.OCIOFileTransform"
#define kOCIOFileTransformParamCCCID "cccId"
#define kOCIOFileTransformParamCCCIDChoice "cccIdIndex"
// genHTML: true for live HTML output for the internal web-server, false for markdown output
QString
Node::makeDocumentation(bool genHTML) const
{
QString ret;
QString markdown;
QTextStream ts(&ret);
QTextStream ms(&markdown);
QString pluginID, pluginLabel, pluginDescription, pluginIcon;
int majorVersion = getMajorVersion();
int minorVersion = getMinorVersion();
std::vector<std::string> pluginGroup;
bool pluginDescriptionIsMarkdown = false;
QVector<QStringList> inputs;
QVector<QStringList> items;
{
PluginPtr plugin = getPlugin();
assert(plugin);
pluginID = QString::fromUtf8(plugin->getPluginID().c_str());
pluginLabel = QString::fromUtf8( Plugin::makeLabelWithoutSuffix( plugin->getPluginLabel() ).c_str());
pluginDescription = QString::fromUtf8( plugin->getPropertyUnsafe<std::string>(kNatronPluginPropDescription).c_str() );
pluginIcon = QString::fromUtf8(plugin->getPropertyUnsafe<std::string>(kNatronPluginPropIconFilePath).c_str());
pluginGroup = plugin->getPropertyNUnsafe<std::string>(kNatronPluginPropGrouping);
pluginDescriptionIsMarkdown = plugin->getPropertyUnsafe<bool>(kNatronPluginPropDescriptionIsMarkdown);
for (int i = 0; i < _imp->effect->getNInputs(); ++i) {
QStringList input;
input << convertFromPlainTextToMarkdown( QString::fromStdString( getInputLabel(i) ), genHTML, true );
input << convertFromPlainTextToMarkdown( QString::fromStdString( getInputHint(i) ), genHTML, true );
input << ( isInputOptional(i) ? tr("Yes") : tr("No") );
inputs.push_back(input);
// Don't show more than doc for 4 inputs otherwise it will just clutter the page
if (i == 3) {
break;
}
}
}
// check for plugin icon
QString pluginIconUrl;
if ( !pluginIcon.isEmpty() ) {
QFile iconFile(pluginIcon);
if ( iconFile.exists() ) {
if (genHTML) {
pluginIconUrl.append( QString::fromUtf8("/LOCAL_FILE/") );
pluginIconUrl.append(pluginIcon);
pluginIconUrl.replace( QString::fromUtf8("\\"), QString::fromUtf8("/") );
} else {
pluginIconUrl.append(pluginID);
pluginIconUrl.append(QString::fromUtf8(".png"));
}
}
}
// check for extra markdown file
QString extraMarkdown;
QString pluginMD = pluginIcon;
pluginMD.replace( QString::fromUtf8(".png"), QString::fromUtf8(".md") );
QFile pluginMarkdownFile(pluginMD);
if ( pluginMarkdownFile.exists() ) {
if ( pluginMarkdownFile.open(QIODevice::ReadOnly | QIODevice::Text) ) {
extraMarkdown = QString::fromUtf8( pluginMarkdownFile.readAll() );
pluginMarkdownFile.close();
}
}
// generate knobs info
KnobsVec knobs = getEffectInstance()->getKnobs_mt_safe();
for (KnobsVec::const_iterator it = knobs.begin(); it != knobs.end(); ++it) {
#pragma message WARN("TODO: restore getDefaultIsSecret from RB-2.2")
//if ( (*it)->getDefaultIsSecret() ) {
if ( (*it)->getIsSecret() ) {
continue;
}
if ((*it)->getKnobDeclarationType() != KnobI::eKnobDeclarationTypePlugin) {
continue;
}
// do not escape characters in the scriptName, since it will be put between backquotes
QString knobScriptName = /*NATRON_NAMESPACE::convertFromPlainTextToMarkdown(*/ QString::fromUtf8( (*it)->getName().c_str() )/*, genHTML, true)*/;
QString knobLabel = NATRON_NAMESPACE::convertFromPlainTextToMarkdown( QString::fromUtf8( (*it)->getLabel().c_str() ), genHTML, true);
QString knobHint = NATRON_NAMESPACE::convertFromPlainTextToMarkdown( QString::fromUtf8( (*it)->getHintToolTip().c_str() ), genHTML, true);
// totally ignore the documentation for these parameters (which are always secret in Natron)
if ( knobScriptName.startsWith( QString::fromUtf8("NatronOfxParam") ) ||
knobScriptName == QString::fromUtf8("exportAsPyPlug") ||
knobScriptName == QString::fromUtf8(kOCIOParamInputSpace) ||
knobScriptName == QString::fromUtf8(kOCIOParamOutputSpace) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamDisplay) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamView) ) ) ||
//( ( pluginID == QString::fromUtf8(kOCIOCDLTransformPluginIdentifier) ) &&
// ( knobScriptName == QString::fromUtf8(kOCIOCDLTransformParamCCCID) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIOFileTransformPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIOFileTransformParamCCCID) ) ) ||
false) {
continue;
}
QString defValuesStr, knobType;
std::vector<std::pair<QString, QString> > dimsDefaultValueStr;
KnobIntPtr isInt = toKnobInt(*it);
KnobChoicePtr isChoice = toKnobChoice(*it);
KnobBoolPtr isBool = toKnobBool(*it);
KnobDoublePtr isDbl = toKnobDouble(*it);
KnobStringPtr isString = toKnobString(*it);
bool isLabel = isString && isString->isLabel();
KnobSeparatorPtr isSep = toKnobSeparator(*it);
KnobButtonPtr isBtn = toKnobButton(*it);
KnobParametricPtr isParametric = toKnobParametric(*it);
KnobGroupPtr isGroup = toKnobGroup(*it);
KnobPagePtr isPage = toKnobPage(*it);
KnobColorPtr isColor = toKnobColor(*it);
if (isInt) {
knobType = tr("Integer");
} else if (isChoice) {
knobType = tr("Choice");
} else if (isBool) {
knobType = tr("Boolean");
} else if (isDbl) {
knobType = tr("Double");
} else if (isString) {
if (isLabel) {
knobType = tr("Label");
} else {
knobType = tr("String");
}
} else if (isSep) {
knobType = tr("Separator");
} else if (isBtn) {
knobType = tr("Button");
} else if (isParametric) {
knobType = tr("Parametric");
} else if (isGroup) {
knobType = tr("Group");
} else if (isPage) {
knobType = tr("Page");
} else if (isColor) {
knobType = tr("Color");
} else {
knobType = tr("N/A");
}
if (!isGroup && !isPage) {
for (int i = 0; i < (*it)->getNDimensions(); ++i) {
QString valueStr;
if (!isBtn && !isSep && !isParametric) {
// If this is a ChoiceParam and we are not generating live HTML doc,
// only add the list of entries and their halp if this node should not be
// ignored (eg. OCIO colorspace knobs).
if ( isChoice &&
(genHTML || !( knobScriptName == QString::fromUtf8(kOCIOParamInputSpaceChoice) ||
knobScriptName == QString::fromUtf8(kOCIOParamOutputSpaceChoice) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamDisplayChoice) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamViewChoice) ) ) ||
//( ( pluginID == QString::fromUtf8(kOCIOCDLTransformPluginIdentifier) ) &&
// ( knobScriptName == QString::fromUtf8(kOCIOCDLTransformParamCCCIDChoice) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIOFileTransformPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIOFileTransformParamCCCIDChoice) ) ) ||
( ( pluginID == QString::fromUtf8("net.fxarena.openfx.Text") ) &&
( knobScriptName == QString::fromUtf8("name") ) ) || // font family from Text plugin
( ( pluginID == QString::fromUtf8("net.fxarena.openfx.Polaroid") ) &&
( knobScriptName == QString::fromUtf8("font") ) ) || // font family from Polaroid plugin
( ( pluginID == QString::fromUtf8(PLUGINID_NATRON_PRECOMP) ) &&
( knobScriptName == QString::fromUtf8("writeNode") ) ) ||
( ( pluginID == QString::fromUtf8(PLUGINID_NATRON_ONEVIEW) ) &&
( knobScriptName == QString::fromUtf8("view") ) ) ) ) ) {
// see also KnobChoice::getHintToolTipFull()
int index = isChoice->getDefaultValue(DimIdx(i));
std::vector<ChoiceOption> entries = isChoice->getEntries();
if ( (index >= 0) && ( index < (int)entries.size() ) ) {
valueStr = QString::fromUtf8( entries[index].id.c_str() );
}
bool first = true;
for (size_t i = 0; i < entries.size(); i++) {
QString entryHelp = QString::fromUtf8( entries[i].tooltip.c_str() );
QString entry;
if (entries[i].id != entries[i].label) {
entry = QString::fromUtf8( "%1 (%2)" ).arg(QString::fromUtf8( entries[i].label.c_str() )).arg(QString::fromUtf8( entries[i].id.c_str() ));
} else {
entry = QString::fromUtf8( entries[i].label.c_str() );
}
if (!entry.isEmpty()) {
if (first) {
// empty line before the option descriptions
if (genHTML) {
if ( !knobHint.isEmpty() ) {
knobHint.append( QString::fromUtf8("<br />") );
}
knobHint.append( tr("Possible values:") + QString::fromUtf8("<br />") );
} else {
// we do a hack for multiline elements, because the markdown->rst conversion by pandoc doesn't use the line block syntax.
// what we do here is put a supplementary dot at the beginning of each line, which is then converted to a pipe '|' in the
// genStaticDocs.sh script by a simple sed command after converting to RsT
if ( !knobHint.isEmpty() ) {
if (!knobHint.startsWith( QString::fromUtf8(". ") )) {
knobHint.prepend( QString::fromUtf8(". ") );
}
knobHint.append( QString::fromUtf8("\\\n") );
}
knobHint.append( QString::fromUtf8(". ") + tr("Possible values:") + QString::fromUtf8("\\\n") );
}
first = false;
}
if (genHTML) {
knobHint.append( QString::fromUtf8("<br />") );
} else {
knobHint.append( QString::fromUtf8("\\\n") );
// we do a hack for multiline elements, because the markdown->rst conversion by pandoc doesn't use the line block syntax.
// what we do here is put a supplementary dot at the beginning of each line, which is then converted to a pipe '|' in the
// genStaticDocs.sh script by a simple sed command after converting to RsT
knobHint.append( QString::fromUtf8(". ") );
}
if (entryHelp.isEmpty()) {
knobHint.append( QString::fromUtf8("**%1**").arg( convertFromPlainTextToMarkdown(entry, genHTML, true) ) );
} else {
knobHint.append( QString::fromUtf8("**%1**: %2").arg( convertFromPlainTextToMarkdown(entry, genHTML, true) ).arg( convertFromPlainTextToMarkdown(entryHelp, genHTML, true) ) );
}
}
}
} else if (isInt) {
valueStr = QString::number( isInt->getDefaultValue( DimIdx(i) ) );
} else if (isDbl) {
valueStr = QString::number( isDbl->getDefaultValue( DimIdx(i) ) );
} else if (isBool) {
valueStr = isBool->getDefaultValue( DimIdx(i) ) ? tr("On") : tr("Off");
} else if (isString) {
valueStr = QString::fromUtf8( isString->getDefaultValue( DimIdx(i) ).c_str() );
} else if (isColor) {
valueStr = QString::number( isColor->getDefaultValue( DimIdx(i) ) );
}
}
dimsDefaultValueStr.push_back( std::make_pair(convertFromPlainTextToMarkdown( QString::fromUtf8( (*it)->getDimensionName( DimIdx(i) ).c_str() ), genHTML, true ),
convertFromPlainTextToMarkdown(valueStr, genHTML, true)) );
}
for (std::size_t i = 0; i < dimsDefaultValueStr.size(); ++i) {
if ( !dimsDefaultValueStr[i].second.isEmpty() ) {
if (dimsDefaultValueStr.size() > 1) {
defValuesStr.append(dimsDefaultValueStr[i].first);
defValuesStr.append( QString::fromUtf8(": ") );
}
defValuesStr.append(dimsDefaultValueStr[i].second);
if (i < dimsDefaultValueStr.size() - 1) {
defValuesStr.append( QString::fromUtf8(" ") );
}
}
}
if ( defValuesStr.isEmpty() ) {
defValuesStr = tr("N/A");
}
}
if (!isPage && !isSep && !isGroup && !isLabel) {
QStringList row;
row << knobLabel << knobScriptName << knobType << defValuesStr << knobHint;
items.append(row);
}
} // for (KnobsVec::const_iterator it = knobs.begin(); it!=knobs.end(); ++it) {
// generate plugin info
ms << tr("%1 node").arg(pluginLabel) << "\n==========\n\n";
// a hack to avoid repeating the documentation for the various merge plugins
if ( pluginID.startsWith( QString::fromUtf8("net.sf.openfx.Merge") ) ) {
std::string id = pluginID.toStdString();
std::string op;
if (id == PLUGINID_OFX_MERGE) {
// do nothing
} else if (id == "net.sf.openfx.MergeDifference") {
op = "difference (a.k.a. absminus)";
} else if (id == "net.sf.openfx.MergeIn") {
op = "in";
} else if (id == "net.sf.openfx.MergeMatte") {
op = "matte";
} else if (id == "net.sf.openfx.MergeMax") {
op = "max";
} else if (id == "net.sf.openfx.MergeMin") {
op = "min";
} else if (id == "net.sf.openfx.MergeMultiply") {
op = "multiply";
} else if (id == "net.sf.openfx.MergeOut") {
op = "out";
} else if (id == "net.sf.openfx.MergePlus") {
op = "plus";
} else if (id == "net.sf.openfx.MergeScreen") {
op = "screen";
}
if ( !op.empty() ) {
// we should use the custom link "[Merge node](|http::/plugins/" PLUGINID_OFX_MERGE ".html||rst::net.sf.openfx.MergePlugin|)"
// but pandoc borks it
ms << tr("The *%1* node is a convenience node identical to the %2, except that the operator is set to *%3* by default.")
.arg(pluginLabel)
.arg(genHTML ? QString::fromUtf8("<a href=\"" PLUGINID_OFX_MERGE ".html\">Merge node</a>") :
QString::fromUtf8(":ref:`" PLUGINID_OFX_MERGE "`")
//QString::fromUtf8("[Merge node](http::/plugins/" PLUGINID_OFX_MERGE ".html)")
)
.arg( QString::fromUtf8( op.c_str() ) );
goto OUTPUT;
}
}
if (!pluginIconUrl.isEmpty()) {
// add a nonbreaking space so that pandoc doesn't use the alt-text as a caption
// http://pandoc.org/MANUAL.html#images
ms << "![pluginIcon](" << pluginIconUrl << ")";
if (!genHTML) {
// specify image width for pandoc-generated printed doc
// (for hoedown-generated HTML, this handled by the CSS using the alt=pluginIcon attribute)
// see http://pandoc.org/MANUAL.html#images
// note that only % units are understood both by pandox and sphinx
ms << "{ width=10% }";
}
ms << " \n\n"; // required so that there is no legend when converted to rst by pandoc
}
ms << tr("*This documentation is for version %2.%3 of %1.*").arg(pluginLabel).arg(majorVersion).arg(minorVersion) << "\n\n";
ms << "\n" << tr("Description") << "\n--------------------------------------------------------------------------------\n\n";
if (!pluginDescriptionIsMarkdown) {
if (genHTML) {
pluginDescription = NATRON_NAMESPACE::convertFromPlainText(pluginDescription, NATRON_NAMESPACE::WhiteSpaceNormal);
// replace URLs with links
QRegExp re( QString::fromUtf8("((http|ftp|https)://([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?)") );
pluginDescription.replace( re, QString::fromUtf8("<a href=\"\\1\">\\1</a>") );
} else {
pluginDescription = convertFromPlainTextToMarkdown(pluginDescription, genHTML, false);
}
}
ms << pluginDescription << "\n";
// create markdown table
ms << "\n" << tr("Inputs") << "\n--------------------------------------------------------------------------------\n\n";
ms << tr("Input") << " | " << tr("Description") << " | " << tr("Optional") << "\n";
ms << "--- | --- | ---\n";
if (inputs.size() > 0) {
Q_FOREACH(const QStringList &input, inputs) {
QString inputName = input.at(0);
QString inputDesc = input.at(1);
QString inputOpt = input.at(2);
ms << inputName << " | " << inputDesc << " | " << inputOpt << "\n";
}
bool
RotoShapeRenderNodePrivate::renderStroke_generic(RenderStrokeDataPtr userData,
PFNRenderStrokeBeginRender beginCallback,
PFNRenderStrokeRenderDot renderDotCallback,
PFNRenderStrokeEndRender endCallback,
const std::list<std::list<std::pair<Point, double> > >& strokes,
const double distToNextIn,
const Point& lastCenterPointIn,
const RotoDrawableItemPtr& stroke,
bool doBuildup,
double opacity,
TimeValue time,
ViewIdx /*view*/,
const RenderScale& scale,
double* distToNextOut,
Point* lastCenterPoint)
{
assert(distToNextOut && lastCenterPoint);
*distToNextOut = 0;
double brushSize, brushSizePixelX, brushSizePixelY, brushSpacing, brushHardness, writeOnStart, writeOnEnd;
bool pressureAffectsOpacity, pressureAffectsHardness, pressureAffectsSize;
{
KnobDoublePtr brushSizeKnob = stroke->getBrushSizeKnob();
brushSize = brushSizeKnob->getValueAtTime(time);
KnobDoublePtr brushSpacingKnob = stroke->getBrushSpacingKnob();
brushSpacing = brushSpacingKnob->getValueAtTime(time);
if (brushSpacing == 0.) {
return false;
}
brushSpacing = std::max(brushSpacing, 0.05);
KnobDoublePtr brushHardnessKnob = stroke->getBrushHardnessKnob();
brushHardness = brushHardnessKnob->getValueAtTime(time);
KnobDoublePtr visiblePortionKnob = stroke->getBrushVisiblePortionKnob();
writeOnStart = visiblePortionKnob->getValueAtTime(time);
writeOnEnd = visiblePortionKnob->getValueAtTime(time, DimIdx(1));
if ( (writeOnEnd - writeOnStart) <= 0. ) {
return false;
}
// This function is also used for opened bezier which do not have pressure.
RotoStrokeItemPtr isStroke = toRotoStrokeItem(stroke);
if (!isStroke) {
pressureAffectsOpacity = false;
pressureAffectsSize = false;
pressureAffectsHardness = false;
} else {
KnobBoolPtr pressureOpacityKnob = isStroke->getPressureOpacityKnob();
KnobBoolPtr pressureSizeKnob = isStroke->getPressureSizeKnob();
KnobBoolPtr pressureHardnessKnob = isStroke->getPressureHardnessKnob();
pressureAffectsOpacity = pressureOpacityKnob->getValueAtTime(time);
pressureAffectsSize = pressureSizeKnob->getValueAtTime(time);
pressureAffectsHardness = pressureHardnessKnob->getValueAtTime(time);
}
brushSizePixelX = brushSize;
brushSizePixelY = brushSizePixelX;
brushSizePixelX = std::max( 1., brushSizePixelX * scale.x);
brushSizePixelY = std::max( 1., brushSizePixelY * scale.y);
}
double distToNext = distToNextIn;
bool hasRenderedDot = false;
beginCallback(userData, brushSizePixelX, brushSizePixelY, brushSpacing, brushHardness, pressureAffectsOpacity, pressureAffectsHardness, pressureAffectsSize, doBuildup, opacity);
*lastCenterPoint = lastCenterPointIn;
Point prevCenter = lastCenterPointIn;
for (std::list<std::list<std::pair<Point, double> > >::const_iterator strokeIt = strokes.begin(); strokeIt != strokes.end(); ++strokeIt) {
int firstPoint = (int)std::floor( (strokeIt->size() * writeOnStart) );
int endPoint = (int)std::ceil( (strokeIt->size() * writeOnEnd) );
assert( firstPoint >= 0 && firstPoint < (int)strokeIt->size() && endPoint > firstPoint && endPoint <= (int)strokeIt->size() );
///The visible portion of the paint's stroke with points adjusted to pixel coordinates
std::list<std::pair<Point, double> > visiblePortion;
std::list<std::pair<Point, double> >::const_iterator startingIt = strokeIt->begin();
std::list<std::pair<Point, double> >::const_iterator endingIt = strokeIt->begin();
std::advance(startingIt, firstPoint);
std::advance(endingIt, endPoint);
for (std::list<std::pair<Point, double> >::const_iterator it = startingIt; it != endingIt; ++it) {
visiblePortion.push_back(*it);
}
if ( visiblePortion.empty() ) {
continue;
}
std::list<std::pair<Point, double> >::iterator it = visiblePortion.begin();
if (visiblePortion.size() == 1) {
double spacing;
*lastCenterPoint = it->first;
renderDotCallback(userData, prevCenter, *lastCenterPoint, it->second, &spacing);
distToNext += spacing;
continue;
}
//prevCenter = it->first;
std::list<std::pair<Point, double> >::iterator next = it;
++next;
while ( next != visiblePortion.end() ) {
//Render for each point a dot. Spacing is a percentage of brushSize:
//Spacing at 1 means no dot is overlapping another (so the spacing is in fact brushSize)
//Spacing at 0 we do not render the stroke
double dx = next->first.x - it->first.x;
double dy = next->first.y - it->first.y;
// This is the distance between the current and next discretized points
// Since the distance between each points may vary, we uniformly position a dot along the segments
double dist = std::sqrt(dx * dx + dy * dy);
// while the next point can be drawn on this segment, draw a point and advance
while (distToNext <= dist) {
double a = dist == 0. ? 0. : distToNext / dist;
lastCenterPoint->x = it->first.x * (1 - a) + next->first.x * a;
lastCenterPoint->y = it->first.y * (1 - a) + next->first.y * a;
double pressure = it->second * (1 - a) + next->second * a;
// draw the dot
double spacing;
bool rendered = renderDotCallback(userData, prevCenter, *lastCenterPoint, pressure, &spacing);
hasRenderedDot |= rendered;
prevCenter = *lastCenterPoint;
distToNext += spacing;
/*if (rendered) {
} else {
break;
}*/
}
// go to the next segment
distToNext -= dist;
++next;
++it;
}
}
endCallback(userData);
*distToNextOut = distToNext;
return hasRenderedDot;
}
void
TrackMarker::initializeKnobs()
{
TrackerContextPtr context = _imp->context.lock();
KnobIntPtr defPatternSizeKnob = context->getDefaultMarkerPatternWinSizeKnob();
KnobIntPtr defSearchSizeKnob = context->getDefaultMarkerSearchWinSizeKnob();
double patternHalfSize = defPatternSizeKnob->getValue() / 2.;
double searchHalfSize = defSearchSizeKnob->getValue() / 2.;
KnobDoublePtr swbbtmLeft = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamSearchWndBtmLeftLabel), 2, false);
swbbtmLeft->setName(kTrackerParamSearchWndBtmLeft);
swbbtmLeft->setDefaultValue(-searchHalfSize, 0);
swbbtmLeft->setDefaultValue(-searchHalfSize, 1);
swbbtmLeft->setHintToolTip( tr(kTrackerParamSearchWndBtmLeftHint) );
_imp->searchWindowBtmLeft = swbbtmLeft;
KnobDoublePtr swbtRight = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamSearchWndTopRightLabel), 2, false);
swbtRight->setName(kTrackerParamSearchWndTopRight);
swbtRight->setDefaultValue(searchHalfSize, 0);
swbtRight->setDefaultValue(searchHalfSize, 1);
swbtRight->setHintToolTip( tr(kTrackerParamSearchWndTopRightHint) );
_imp->searchWindowTopRight = swbtRight;
KnobDoublePtr ptLeft = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamPatternTopLeftLabel), 2, false);
ptLeft->setName(kTrackerParamPatternTopLeft);
ptLeft->setDefaultValue(-patternHalfSize, 0);
ptLeft->setDefaultValue(patternHalfSize, 1);
ptLeft->setHintToolTip( tr(kTrackerParamPatternTopLeftHint) );
_imp->patternTopLeft = ptLeft;
KnobDoublePtr ptRight = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamPatternTopRightLabel), 2, false);
ptRight->setName(kTrackerParamPatternTopRight);
ptRight->setDefaultValue(patternHalfSize, 0);
ptRight->setDefaultValue(patternHalfSize, 1);
ptRight->setHintToolTip( tr(kTrackerParamPatternTopRightHint) );
_imp->patternTopRight = ptRight;
KnobDoublePtr pBRight = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamPatternBtmRightLabel), 2, false);
pBRight->setName(kTrackerParamPatternBtmRight);
pBRight->setDefaultValue(patternHalfSize, 0);
pBRight->setDefaultValue(-patternHalfSize, 1);
pBRight->setHintToolTip( tr(kTrackerParamPatternBtmRightHint) );
_imp->patternBtmRight = pBRight;
KnobDoublePtr pBLeft = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamPatternBtmLeftLabel), 2, false);
pBLeft->setName(kTrackerParamPatternBtmLeft);
pBLeft->setDefaultValue(-patternHalfSize, 0);
pBLeft->setDefaultValue(-patternHalfSize, 1);
pBLeft->setHintToolTip( tr(kTrackerParamPatternBtmLeftHint) );
_imp->patternBtmLeft = pBLeft;
KnobDoublePtr centerKnob = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamCenterLabel), 2, false);
centerKnob->setName(kTrackerParamCenter);
centerKnob->setHintToolTip( tr(kTrackerParamCenterHint) );
_imp->center = centerKnob;
KnobDoublePtr offsetKnob = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamOffsetLabel), 2, false);
offsetKnob->setName(kTrackerParamOffset);
offsetKnob->setHintToolTip( tr(kTrackerParamOffsetHint) );
_imp->offset = offsetKnob;
#ifdef NATRON_TRACK_MARKER_USE_WEIGHT
KnobDoublePtr weightKnob = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamTrackWeightLabel), 1, false);
weightKnob->setName(kTrackerParamTrackWeight);
weightKnob->setHintToolTip( tr(kTrackerParamTrackWeightHint) );
weightKnob->setDefaultValue(1.);
weightKnob->setAnimationEnabled(false);
weightKnob->setMinimum(0.);
weightKnob->setMaximum(1.);
_imp->weight = weightKnob;
#endif
KnobChoicePtr mmodelKnob = AppManager::createKnob<KnobChoice>(shared_from_this(), tr(kTrackerParamMotionModelLabel), 1, false);
mmodelKnob->setHintToolTip( tr(kTrackerParamMotionModelHint) );
mmodelKnob->setName(kTrackerParamMotionModel);
{
std::vector<std::string> choices, helps;
TrackerContext::getMotionModelsAndHelps(true, &choices, &helps);
mmodelKnob->populateChoices(choices, helps);
}
mmodelKnob->setDefaultValue(0);
_imp->motionModel = mmodelKnob;
KnobDoublePtr errKnob = AppManager::createKnob<KnobDouble>(shared_from_this(), tr(kTrackerParamErrorLabel), 1, false);
errKnob->setName(kTrackerParamError);
_imp->error = errKnob;
KnobBoolPtr enableKnob = AppManager::createKnob<KnobBool>(shared_from_this(), tr(kTrackerParamEnabledLabel), 1, false);
enableKnob->setName(kTrackerParamEnabled);
enableKnob->setHintToolTip( tr(kTrackerParamEnabledHint) );
enableKnob->setAnimationEnabled(true);
enableKnob->setDefaultValue(true);
_imp->enabled = enableKnob;
QObject::connect( this, SIGNAL(enabledChanged(int)), _imp->context.lock().get(), SLOT(onMarkerEnabledChanged(int)) );
boost::shared_ptr<KnobSignalSlotHandler> handler = _imp->center.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(keyFrameSet(double,ViewSpec,int,int,bool)), this, SLOT(onCenterKeyframeSet(double,ViewSpec,int,int,bool)) );
QObject::connect( handler.get(), SIGNAL(keyFrameRemoved(double,ViewSpec,int,int)), this, SLOT(onCenterKeyframeRemoved(double,ViewSpec,int,int)) );
QObject::connect( handler.get(), SIGNAL(keyFrameMoved(ViewSpec,int,double,double)), this, SLOT(onCenterKeyframeMoved(ViewSpec,int,double,double)) );
QObject::connect( handler.get(), SIGNAL(multipleKeyFramesSet(std::list<double>,ViewSpec,int,int)), this,
SLOT(onCenterKeyframesSet(std::list<double>,ViewSpec,int,int)) );
QObject::connect( handler.get(), SIGNAL(multipleKeyFramesRemoved(std::list<double>,ViewSpec,int,int)), this,
SLOT(onCenterMultipleKeysRemoved(std::list<double>,ViewSpec,int,int)) );
QObject::connect( handler.get(), SIGNAL(animationRemoved(ViewSpec,int)), this, SLOT(onCenterAnimationRemoved(ViewSpec,int)) );
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onCenterKnobValueChanged(ViewSpec,int,int)) );
handler = _imp->offset.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onOffsetKnobValueChanged(ViewSpec,int,int)) );
handler = _imp->error.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onErrorKnobValueChanged(ViewSpec,int,int)) );
#ifdef NATRON_TRACK_MARKER_USE_WEIGHT
handler = _imp->weight.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onWeightKnobValueChanged(ViewSpec,int,int)) );
#endif
handler = _imp->motionModel.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onMotionModelKnobValueChanged(ViewSpec,int,int)) );
/*handler = _imp->patternBtmLeft->getSignalSlotHandler();
QObject::connect(handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onPatternBtmLeftKnobValueChanged(int,int)));
handler = _imp->patternTopLeft->getSignalSlotHandler();
QObject::connect(handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onPatternTopLeftKnobValueChanged(int,int)));
handler = _imp->patternTopRight->getSignalSlotHandler();
QObject::connect(handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onPatternTopRightKnobValueChanged(int,int)));
handler = _imp->patternBtmRight->getSignalSlotHandler();
QObject::connect(handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onPatternBtmRightKnobValueChanged(int,int)));
*/
handler = _imp->searchWindowBtmLeft.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onSearchBtmLeftKnobValueChanged(ViewSpec,int,int)) );
handler = _imp->searchWindowTopRight.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onSearchTopRightKnobValueChanged(ViewSpec,int,int)) );
handler = _imp->enabled.lock()->getSignalSlotHandler();
QObject::connect( handler.get(), SIGNAL(valueChanged(ViewSpec,int,int)), this, SLOT(onEnabledValueChanged(ViewSpec,int,int)) );
} // TrackMarker::initializeKnobs
void
RotoShapeRenderNode::initializeKnobs()
{
assert(!isRenderClone());
KnobPagePtr page = createKnob<KnobPage>("controlsPage");
page->setLabel(tr("Controls"));
{
KnobChoicePtr param = createKnob<KnobChoice>(kRotoShapeRenderNodeParamType);
param->setLabel(tr(kRotoShapeRenderNodeParamTypeLabel));
{
std::vector<ChoiceOption> options;
options.push_back(ChoiceOption(kRotoShapeRenderNodeParamTypeSolid, "", ""));
options.push_back(ChoiceOption(kRotoShapeRenderNodeParamTypeSmear, "", ""));
param->populateChoices(options);
}
param->setIsMetadataSlave(true);
page->addKnob(param);
_imp->renderType = param;
}
{
KnobChoicePtr param = createKnob<KnobChoice>(kRotoOutputRodType);
param->setLabel(tr(kRotoOutputRodTypeLabel));
param->setHintToolTip(tr(kRotoOutputRodTypeHint));
std::vector<ChoiceOption> options;
options.push_back(ChoiceOption(kRotoOutputRodTypeDefaultID, kRotoOutputRodTypeDefaultLabel, tr(kRotoOutputRodTypeDefaultHint).toStdString()));
options.push_back(ChoiceOption(kRotoOutputRodTypeFormatID, kRotoOutputRodTypeFormatLabel, tr(kRotoOutputRodTypeFormatHint).toStdString()));
options.push_back(ChoiceOption(kRotoOutputRodTypeProjectID, kRotoOutputRodTypeProjectLabel, tr(kRotoOutputRodTypeProjectHint).toStdString()));
param->populateChoices(options);
param->setAddNewLine(false);
param->setIsPersistent(false);
page->addKnob(param);
_imp->outputRoDTypeKnob = param;
}
{
KnobChoicePtr param = createKnob<KnobChoice>(kRotoFormatParam);
param->setLabel(tr(kRotoFormatParamLabel));
param->setHintToolTip(tr(kRotoFormatParamHint));
page->addKnob(param);
param->setIsPersistent(false);
_imp->outputFormatKnob = param;
}
{
KnobIntPtr param = createKnob<KnobInt>(kRotoFormatSize, 2);
param->setSecret(true);
page->addKnob(param);
param->setIsPersistent(false);
_imp->outputFormatSizeKnob = param;
}
{
KnobDoublePtr param = createKnob<KnobDouble>(kRotoFormatPar);
param->setSecret(true);
page->addKnob(param);
param->setIsPersistent(false);
_imp->outputFormatParKnob = param;
}
{
KnobBoolPtr param = createKnob<KnobBool>(kRotoClipToFormatParam);
param->setLabel(tr(kRotoClipToFormatParamLabel));
param->setHintToolTip(tr(kRotoClipToFormatParamHint));
param->setDefaultValue(false);
page->addKnob(param);
_imp->clipToFormatKnob = param;
}
}