void
TrackerNodePrivate::computeTransformParamsFromTracksEnd(double refTime,
double maxFittingError,
const QList<TransformData>& results)
{
QList<TransformData> validResults;
for (QList<TransformData>::const_iterator it = results.begin(); it != results.end(); ++it) {
if (it->valid) {
validResults.push_back(*it);
}
}
KnobIntPtr smoothKnob = smoothTransform.lock();
int smoothTJitter, smoothRJitter, smoothSJitter;
smoothTJitter = smoothKnob->getValue(DimIdx(0));
smoothRJitter = smoothKnob->getValue(DimIdx(1));
smoothSJitter = smoothKnob->getValue(DimIdx(2));
KnobDoublePtr translationKnob = translate.lock();
KnobDoublePtr scaleKnob = scale.lock();
KnobDoublePtr rotationKnob = rotate.lock();
KnobDoublePtr fittingErrorKnob = fittingError.lock();
KnobStringPtr fittingWarningKnob = fittingErrorWarning.lock();
int halfTJitter = smoothTJitter / 2;
int halfRJitter = smoothRJitter / 2;
int halfSJitter = smoothSJitter / 2;
translationKnob->blockValueChanges();
scaleKnob->blockValueChanges();
rotationKnob->blockValueChanges();
fittingErrorKnob->blockValueChanges();
std::list<KnobIPtr> animatedKnobsChanged;
animatedKnobsChanged.push_back(translationKnob);
animatedKnobsChanged.push_back(scaleKnob);
animatedKnobsChanged.push_back(rotationKnob);
animatedKnobsChanged.push_back(fittingErrorKnob);
Curve tmpTXCurve, tmpTYCurve, tmpRotateCurve, tmpScaleCurve, tmpFittingErrorCurve;
bool mustShowFittingWarn = false;
for (QList<TransformData>::const_iterator itResults = validResults.begin(); itResults != validResults.end(); ++itResults) {
const TransformData& dataAtTime = *itResults;
{
KeyFrame kf(dataAtTime.time, dataAtTime.rms);
if (dataAtTime.rms >= maxFittingError) {
mustShowFittingWarn = true;
}
tmpFittingErrorCurve.setOrAddKeyframe(kf);
}
if (!dataAtTime.hasRotationAndScale) {
// no rotation or scale: simply extract the translation
Point translation;
if (smoothTJitter > 1) {
TranslateData avgT;
averageDataFunctor<QList<TransformData>::const_iterator, void, TranslateData>(validResults.begin(), validResults.end(), itResults, halfTJitter, 0, &avgT, 0);
translation.x = avgT.p.x;
translation.y = avgT.p.y;
} else {
translation.x = dataAtTime.translation.x;
translation.y = dataAtTime.translation.y;
}
{
KeyFrame kx(dataAtTime.time, translation.x);
KeyFrame ky(dataAtTime.time, translation.y);
tmpTXCurve.setOrAddKeyframe(kx);
tmpTYCurve.setOrAddKeyframe(ky);
}
} else {
double rot = 0;
if (smoothRJitter > 1) {
RotateData avgR;
averageDataFunctor<QList<TransformData>::const_iterator, void, RotateData>(validResults.begin(), validResults.end(), itResults, halfRJitter, 0, &avgR, 0);
rot = avgR.r;
} else {
rot = dataAtTime.rotation;
}
{
KeyFrame k(dataAtTime.time, rot);
tmpRotateCurve.setOrAddKeyframe(k);
}
double scale;
if (smoothSJitter > 1) {
ScaleData avgR;
averageDataFunctor<QList<TransformData>::const_iterator, void, ScaleData>(validResults.begin(), validResults.end(), itResults, halfSJitter, 0, &avgR, 0);
scale = avgR.s;
} else {
scale = dataAtTime.scale;
}
{
KeyFrame k(dataAtTime.time, scale);
tmpScaleCurve.setOrAddKeyframe(k);
}
Point translation;
if (smoothTJitter > 1) {
TranslateData avgT;
averageDataFunctor<QList<TransformData>::const_iterator, void, TranslateData>(validResults.begin(), validResults.end(), itResults, halfTJitter, 0, &avgT, 0);
translation.x = avgT.p.x;
translation.y = avgT.p.y;
} else {
translation.x = dataAtTime.translation.x;
translation.y = dataAtTime.translation.y;
}
{
KeyFrame kx(dataAtTime.time, translation.x);
KeyFrame ky(dataAtTime.time, translation.y);
tmpTXCurve.setOrAddKeyframe(kx);
tmpTYCurve.setOrAddKeyframe(ky);
}
}
} // for all samples
fittingWarningKnob->setSecret(!mustShowFittingWarn);
fittingErrorKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpFittingErrorCurve, 0 /*offset*/, 0 /*range*/);
translationKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpTXCurve, 0 /*offset*/, 0 /*range*/);
translationKnob->cloneCurve(ViewIdx(0), DimIdx(1), tmpTYCurve, 0 /*offset*/, 0 /*range*/);
rotationKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpRotateCurve, 0 /*offset*/, 0 /*range*/);
scaleKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpScaleCurve, 0 /*offset*/, 0 /*range*/);
scaleKnob->cloneCurve(ViewIdx(0), DimIdx(1), tmpScaleCurve, 0 /*offset*/, 0 /*range*/);
for (std::list<KnobIPtr>::iterator it = animatedKnobsChanged.begin(); it != animatedKnobsChanged.end(); ++it) {
(*it)->unblockValueChanges();
(*it)->evaluateValueChange(DimSpec::all(), TimeValue(refTime), ViewSetSpec::all(), eValueChangedReasonUserEdited);
}
endSolve();
} // TrackerNodePrivate::computeTransformParamsFromTracksEnd
void
TrackerNodePrivate::computeCornerParamsFromTracksEnd(double refTime,
double maxFittingError,
const QList<CornerPinData>& results)
{
// Make sure we get only valid results
QList<CornerPinData> validResults;
for (QList<CornerPinData>::const_iterator it = results.begin(); it != results.end(); ++it) {
if (it->valid) {
validResults.push_back(*it);
}
}
// Get all knobs that we are going to write to and block any value changes on them
KnobIntPtr smoothCornerPinKnob = smoothCornerPin.lock();
int smoothJitter = smoothCornerPinKnob->getValue();
int halfJitter = smoothJitter / 2;
KnobDoublePtr fittingErrorKnob = fittingError.lock();
KnobDoublePtr fromPointsKnob[4];
KnobDoublePtr toPointsKnob[4];
KnobBoolPtr enabledPointsKnob[4];
KnobStringPtr fittingWarningKnob = fittingErrorWarning.lock();
for (int i = 0; i < 4; ++i) {
fromPointsKnob[i] = fromPoints[i].lock();
toPointsKnob[i] = toPoints[i].lock();
enabledPointsKnob[i] = enableToPoint[i].lock();
}
std::list<KnobIPtr> animatedKnobsChanged;
fittingErrorKnob->blockValueChanges();
animatedKnobsChanged.push_back(fittingErrorKnob);
for (int i = 0; i < 4; ++i) {
toPointsKnob[i]->blockValueChanges();
animatedKnobsChanged.push_back(toPointsKnob[i]);
}
// Get reference corner pin
CornerPinPoints refFrom;
for (int c = 0; c < 4; ++c) {
refFrom.pts[c].x = fromPointsKnob[c]->getValueAtTime(TimeValue(refTime));
refFrom.pts[c].y = fromPointsKnob[c]->getValueAtTime(TimeValue(refTime), DimIdx(1));
}
// Create temporary curves and clone the toPoint internal curves at once because setValueAtTime will be slow since it emits
// signals to create keyframes in keyframeSet
Curve tmpToPointsCurveX[4], tmpToPointsCurveY[4];
Curve tmpFittingErrorCurve;
bool mustShowFittingWarn = false;
for (QList<CornerPinData>::const_iterator itResults = validResults.begin(); itResults != validResults.end(); ++itResults) {
const CornerPinData& dataAtTime = *itResults;
// Add the error to the curve and check if we need to turn on the RMS warning
{
KeyFrame kf(dataAtTime.time, dataAtTime.rms);
if (dataAtTime.rms >= maxFittingError) {
mustShowFittingWarn = true;
}
tmpFittingErrorCurve.setOrAddKeyframe(kf);
}
if (smoothJitter <= 1) {
for (int c = 0; c < 4; ++c) {
Point toPoint;
toPoint = TrackerHelper::applyHomography(refFrom.pts[c], dataAtTime.h);
KeyFrame kx(dataAtTime.time, toPoint.x);
KeyFrame ky(dataAtTime.time, toPoint.y);
tmpToPointsCurveX[c].setOrAddKeyframe(kx);
tmpToPointsCurveY[c].setOrAddKeyframe(ky);
//toPoints[c]->setValuesAtTime(dataAtTime[i].time, toPoint.x, toPoint.y, ViewSpec::all(), eValueChangedReasonUserEdited);
}
} else {
// Average to points before and after if using jitter
CornerPinPoints avgTos;
averageDataFunctor<QList<CornerPinData>::const_iterator, CornerPinPoints, CornerPinPoints>(validResults.begin(), validResults.end(), itResults, halfJitter, &refFrom, &avgTos, 0);
for (int c = 0; c < 4; ++c) {
KeyFrame kx(dataAtTime.time, avgTos.pts[c].x);
KeyFrame ky(dataAtTime.time, avgTos.pts[c].y);
tmpToPointsCurveX[c].setOrAddKeyframe(kx);
tmpToPointsCurveY[c].setOrAddKeyframe(ky);
}
} // use jitter
} // for each result
// If user wants a post-smooth, apply it
if (smoothJitter > 1) {
int halfSmoothJitter = smoothJitter / 2;
KeyFrameSet xSet[4], ySet[4];
KeyFrameSet newXSet[4], newYSet[4];
for (int c = 0; c < 4; ++c) {
xSet[c] = tmpToPointsCurveX[c].getKeyFrames_mt_safe();
ySet[c] = tmpToPointsCurveY[c].getKeyFrames_mt_safe();
}
for (int c = 0; c < 4; ++c) {
for (KeyFrameSet::const_iterator it = xSet[c].begin(); it != xSet[c].end(); ++it) {
double avg;
averageDataFunctor<KeyFrameSet::const_iterator, void, double>(xSet[c].begin(), xSet[c].end(), it, halfSmoothJitter, 0, &avg, 0);
KeyFrame k(*it);
k.setValue(avg);
newXSet[c].insert(k);
}
for (KeyFrameSet::const_iterator it = ySet[c].begin(); it != ySet[c].end(); ++it) {
double avg;
averageDataFunctor<KeyFrameSet::const_iterator, void, double>(ySet[c].begin(), ySet[c].end(), it, halfSmoothJitter, 0, &avg, 0);
KeyFrame k(*it);
k.setValue(avg);
newYSet[c].insert(k);
}
}
for (int c = 0; c < 4; ++c) {
tmpToPointsCurveX[c].setKeyframes(newXSet[c], true);
tmpToPointsCurveY[c].setKeyframes(newYSet[c], true);
}
}
fittingWarningKnob->setSecret(!mustShowFittingWarn);
fittingErrorKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpFittingErrorCurve, 0 /*offset*/, 0 /*range*/);
for (int c = 0; c < 4; ++c) {
toPointsKnob[c]->cloneCurve(ViewIdx(0), DimIdx(0), tmpToPointsCurveX[c], 0 /*offset*/, 0 /*range*/);
toPointsKnob[c]->cloneCurve(ViewIdx(0), DimIdx(1), tmpToPointsCurveY[c], 0 /*offset*/, 0 /*range*/);
}
for (std::list<KnobIPtr>::iterator it = animatedKnobsChanged.begin(); it != animatedKnobsChanged.end(); ++it) {
(*it)->unblockValueChanges();
(*it)->evaluateValueChange(DimSpec::all(), TimeValue(refTime), ViewSetSpec::all(), eValueChangedReasonUserEdited);
}
endSolve();
} // TrackerNodePrivate::computeCornerParamsFromTracksEnd
ActionRetCodeEnum
RotoShapeRenderNode::getTimeInvariantMetadata(NodeMetadata& metadata)
{
assert(_imp->renderType.lock());
RotoShapeRenderTypeEnum type = (RotoShapeRenderTypeEnum)_imp->renderType.lock()->getValue();
int nComps;
if (type == eRotoShapeRenderTypeSolid) {
// If there's an input to the RotoShapeRender node, pass-through the meta-data number of components so that downstream nodes
// have a good default color plane.
// E.g: if we have Constant--> RotoShapeRender --> Merge, we want the Merge to have the number of components of the Constant
EffectInstancePtr inputEffect = getInputRenderEffectAtAnyTimeView(0);
if (inputEffect) {
ImagePlaneDesc inputPlane, paireInputPlane;
inputEffect->getMetadataComponents(-1, &inputPlane, &paireInputPlane);
nComps = inputPlane.getNumComponents();
} else {
nComps = 1;
}
} else {
nComps = 4;
}
metadata.setColorPlaneNComps(-1, nComps);
metadata.setColorPlaneNComps(0, nComps);
// The roto can be sampled at any non integer time
metadata.setIsContinuous(true);
RotoPaintOutputRoDTypeEnum rodType = (RotoPaintOutputRoDTypeEnum)_imp->outputRoDTypeKnob.lock()->getValue();
switch (rodType) {
case eRotoPaintOutputRoDTypeDefault:
// No format is set
break;
case eRotoPaintOutputRoDTypeFormat: {
KnobIntPtr sizeKnob = _imp->outputFormatSizeKnob.lock();
int w = sizeKnob->getValue(DimIdx(0));
int h = _imp->outputFormatSizeKnob.lock()->getValue(DimIdx(1));
double par = _imp->outputFormatParKnob.lock()->getValue();
RectI pixelFormat;
pixelFormat.x1 = pixelFormat.y1 = 0;
pixelFormat.x2 = w;
pixelFormat.y2 = h;
metadata.setPixelAspectRatio(-1, par);
metadata.setOutputFormat(pixelFormat);
} break;
case eRotoPaintOutputRoDTypeProject: {
Format f;
getApp()->getProject()->getProjectDefaultFormat(&f);
metadata.setPixelAspectRatio(-1, f.getPixelAspectRatio());
metadata.setOutputFormat(f);
} break;
}
return eActionStatusOK;
}
ActionRetCodeEnum
RotoShapeRenderNode::getRegionOfDefinition(TimeValue time, const RenderScale& scale, ViewIdx view, RectD* rod)
{
RotoDrawableItemPtr item = getAttachedRotoItem();
assert(item);
assert((isRenderClone() && item->isRenderClone()) ||
(!isRenderClone() && !item->isRenderClone()));
const bool isPainting = isDuringPaintStrokeCreation();
RectD shapeRoD;
getRoDFromItem(item, time, view, isPainting, &shapeRoD);
bool clipToFormat = _imp->clipToFormatKnob.lock()->getValue();
RotoShapeRenderTypeEnum type = (RotoShapeRenderTypeEnum)_imp->renderType.lock()->getValue();
switch (type) {
case eRotoShapeRenderTypeSmear: {
RectD defaultRod;
ActionRetCodeEnum stat = EffectInstance::getRegionOfDefinition(time, scale, view, &defaultRod);
if (isFailureRetCode(stat)) {
return stat;
}
if (!defaultRod.isNull()) {
*rod = shapeRoD;
rod->merge(defaultRod);
}
} break;
case eRotoShapeRenderTypeSolid: {
RotoPaintOutputRoDTypeEnum rodType = (RotoPaintOutputRoDTypeEnum)_imp->outputRoDTypeKnob.lock()->getValue();
switch (rodType) {
case eRotoPaintOutputRoDTypeDefault: {
*rod = shapeRoD;
// No format is set, use the format from the input
if (clipToFormat) {
EffectInstancePtr inputEffect = getInputRenderEffectAtAnyTimeView(0);
if (inputEffect) {
RectI outputFormat = inputEffect->getOutputFormat();
RectD outputFormatCanonical;
outputFormat.toCanonical_noClipping(scale, inputEffect->getAspectRatio(-1), &outputFormatCanonical);
rod->intersect(outputFormatCanonical, rod);
}
}
} break;
case eRotoPaintOutputRoDTypeFormat: {
KnobIntPtr sizeKnob = _imp->outputFormatSizeKnob.lock();
int w = sizeKnob->getValue(DimIdx(0));
int h = _imp->outputFormatSizeKnob.lock()->getValue(DimIdx(1));
double par = _imp->outputFormatParKnob.lock()->getValue();
RectI pixelFormat;
pixelFormat.x1 = pixelFormat.y1 = 0;
pixelFormat.x2 = w;
pixelFormat.y2 = h;
RenderScale renderScale(1.);
pixelFormat.toCanonical_noClipping(renderScale, par, rod);
if (!clipToFormat) {
rod->merge(shapeRoD);
}
} break;
case eRotoPaintOutputRoDTypeProject: {
Format f;
getApp()->getProject()->getProjectDefaultFormat(&f);
f.toCanonical_noClipping(RenderScale(1.), f.getPixelAspectRatio(), rod);
if (!clipToFormat) {
rod->merge(shapeRoD);
}
} break;
}
} break;
}
return eActionStatusOK;
}
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
