void
TrackMarker::resetTrack()
{
Point curCenter;
KnobDoublePtr knob = getCenterKnob();
curCenter.x = knob->getValue(0);
curCenter.y = knob->getValue(1);
EffectInstancePtr effect = getContext()->getNode()->getEffectInstance();
effect->beginChanges();
const KnobsVec& knobs = getKnobs();
for (KnobsVec::const_iterator it = knobs.begin(); it != knobs.end(); ++it) {
if (*it != knob) {
for (int i = 0; i < (*it)->getDimension(); ++i) {
(*it)->resetToDefaultValue(i);
}
} else {
for (int i = 0; i < (*it)->getDimension(); ++i) {
(*it)->removeAnimation(ViewSpec::current(), i);
}
knob->setValue(curCenter.x, ViewSpec::current(), 0);
knob->setValue(curCenter.y, ViewSpec::current(), 1);
}
}
effect->endChanges();
removeAllUserKeyframes();
}
void
TrackMarker::resetCenter()
{
TrackerContextPtr context = getContext();
assert(context);
NodePtr input = context->getNode()->getInput(0);
if (input) {
SequenceTime time = input->getApp()->getTimeLine()->currentFrame();
RenderScale scale;
scale.x = scale.y = 1;
RectD rod;
bool isProjectFormat;
StatusEnum stat = input->getEffectInstance()->getRegionOfDefinition_public(input->getHashValue(), time, scale, ViewIdx(0), &rod, &isProjectFormat);
Point center;
center.x = 0;
center.y = 0;
if (stat == eStatusOK) {
center.x = (rod.x1 + rod.x2) / 2.;
center.y = (rod.y1 + rod.y2) / 2.;
}
KnobDoublePtr centerKnob = getCenterKnob();
centerKnob->setValue(center.x, ViewSpec::current(), 0);
centerKnob->setValue(center.y, ViewSpec::current(), 1);
}
}
void
TrackMarker::resetCenter()
{
KnobItemsTablePtr model = getModel();
if (!model) {
return;
}
RectD rod;
NodePtr input = model->getNode()->getInput(0);
if (!input) {
Format f;
getApp()->getProject()->getProjectDefaultFormat(&f);
rod = f.toCanonicalFormat();
} else {
TimeValue time(input->getApp()->getTimeLine()->currentFrame());
RenderScale scale(1.);
RectD rod;
{
GetRegionOfDefinitionResultsPtr results;
ActionRetCodeEnum stat = input->getEffectInstance()->getRegionOfDefinition_public(time, scale, ViewIdx(0), &results);
if (!isFailureRetCode(stat)) {
rod = results->getRoD();
}
}
Point center;
center.x = 0;
center.y = 0;
center.x = (rod.x1 + rod.x2) / 2.;
center.y = (rod.y1 + rod.y2) / 2.;
KnobDoublePtr centerKnob = getCenterKnob();
centerKnob->setValue(center.x, ViewSetSpec::all(), DimIdx(0));
centerKnob->setValue(center.y, ViewSetSpec::all(), DimIdx(1));
}
}
TEST_F(BaseTest, SetValues)
{
NodePtr generator = createNode(_generatorPluginID);
assert(generator);
KnobIPtr knob = generator->getKnobByName("noiseZSlope");
KnobDoublePtr radius = boost::dynamic_pointer_cast<KnobDouble>(knob);
EXPECT_TRUE(radius != 0);
if (!radius) {
return;
}
radius->setValue(0.5);
EXPECT_TRUE(radius->getValue() == 0.5);
//Check that linear interpolation is working as intended
KeyFrame kf;
radius->setInterpolationAtTime(eCurveChangeReasonInternal, ViewSpec::all(), 0, 0, eKeyframeTypeLinear, &kf);
radius->setValueAtTime(0, 0., ViewSpec::all(), 0);
radius->setValueAtTime(100, 1., ViewSpec::all(), 0);
for (int i = 0; i <= 100; ++i) {
double v = radius->getValueAtTime(i);
EXPECT_TRUE(std::abs(v - i / 100.) < 1e-6);
}
}
bool
ViewerNodeOverlay::onOverlayPenMotion(TimeValue /*time*/, const RenderScale & /*renderScale*/, ViewIdx /*view*/,
const QPointF & /*viewportPos*/, const QPointF & pos, double /*pressure*/, TimeValue /*timestamp*/)
{
Point pixelScale;
getPixelScale(pixelScale.x, pixelScale.y);
bool userRoIEnabled = _imp->toggleUserRoIButtonKnob.lock()->getValue();
RectD userRoI;
if (userRoIEnabled) {
if (uiState == eViewerNodeInteractMouseStateDraggingRoiBottomEdge ||
uiState == eViewerNodeInteractMouseStateDraggingRoiTopEdge ||
uiState == eViewerNodeInteractMouseStateDraggingRoiLeftEdge ||
uiState == eViewerNodeInteractMouseStateDraggingRoiRightEdge ||
uiState == eViewerNodeInteractMouseStateDraggingRoiCross ||
uiState == eViewerNodeInteractMouseStateDraggingRoiBottomLeft ||
uiState == eViewerNodeInteractMouseStateDraggingRoiBottomRight ||
uiState == eViewerNodeInteractMouseStateDraggingRoiTopLeft ||
uiState == eViewerNodeInteractMouseStateDraggingRoiTopRight) {
userRoI = draggedUserRoI;
} else {
userRoI = _imp->_publicInterface->getUserRoI();
}
}
bool wipeEnabled = (ViewerCompositingOperatorEnum)_imp->blendingModeChoiceKnob.lock()->getValue() != eViewerCompositingOperatorNone;
double wipeAmount = _imp->_publicInterface->getWipeAmount();
double wipeAngle = _imp->_publicInterface->getWipeAngle();
QPointF wipeCenter = _imp->_publicInterface->getWipeCenter();
bool wasHovering = hoverState != eHoverStateNothing;
bool cursorSet = false;
bool overlayCaught = false;
hoverState = eHoverStateNothing;
if ( wipeEnabled && isNearbyWipeCenter(wipeCenter, pos, pixelScale.x, pixelScale.y) ) {
_imp->_publicInterface->setCurrentCursor(eCursorSizeAll);
cursorSet = true;
} else if ( wipeEnabled && isNearbyWipeMixHandle(wipeCenter, wipeAngle, wipeAmount, pos, pixelScale.x, pixelScale.y) ) {
hoverState = eHoverStateWipeMix;
overlayCaught = true;
} else if ( wipeEnabled && isNearbyWipeRotateBar(wipeCenter, wipeAngle, pos, pixelScale.x, pixelScale.y) ) {
hoverState = eHoverStateWipeRotateHandle;
overlayCaught = true;
} else if (userRoIEnabled) {
if ( isNearbyUserRoIBottomEdge(userRoI, pos, pixelScale.x, pixelScale.y)
|| isNearbyUserRoITopEdge(userRoI, pos, pixelScale.x, pixelScale.y)
|| ( uiState == eViewerNodeInteractMouseStateDraggingRoiBottomEdge)
|| ( uiState == eViewerNodeInteractMouseStateDraggingRoiTopEdge) ) {
_imp->_publicInterface->setCurrentCursor(eCursorSizeVer);
cursorSet = true;
} else if ( isNearbyUserRoILeftEdge(userRoI, pos, pixelScale.x, pixelScale.y)
|| isNearbyUserRoIRightEdge(userRoI, pos, pixelScale.x, pixelScale.y)
|| ( uiState == eViewerNodeInteractMouseStateDraggingRoiLeftEdge)
|| ( uiState == eViewerNodeInteractMouseStateDraggingRoiRightEdge) ) {
_imp->_publicInterface->setCurrentCursor(eCursorSizeHor);
cursorSet = true;
} else if ( isNearbyUserRoI( (userRoI.x1 + userRoI.x2) / 2, (userRoI.y1 + userRoI.y2) / 2, pos, pixelScale.x, pixelScale.y )
|| ( uiState == eViewerNodeInteractMouseStateDraggingRoiCross) ) {
_imp->_publicInterface->setCurrentCursor(eCursorSizeAll);
cursorSet = true;
} else if ( isNearbyUserRoI(userRoI.x2, userRoI.y1, pos, pixelScale.x, pixelScale.y) ||
isNearbyUserRoI(userRoI.x1, userRoI.y2, pos, pixelScale.x, pixelScale.y) ||
( uiState == eViewerNodeInteractMouseStateDraggingRoiBottomRight) ||
( uiState == eViewerNodeInteractMouseStateDraggingRoiTopLeft) ) {
_imp->_publicInterface->setCurrentCursor(eCursorFDiag);
cursorSet = true;
} else if ( isNearbyUserRoI(userRoI.x1, userRoI.y1, pos, pixelScale.x, pixelScale.y) ||
isNearbyUserRoI(userRoI.x2, userRoI.y2, pos, pixelScale.x, pixelScale.y) ||
( uiState == eViewerNodeInteractMouseStateDraggingRoiBottomLeft) ||
( uiState == eViewerNodeInteractMouseStateDraggingRoiTopRight) ) {
_imp->_publicInterface->setCurrentCursor(eCursorBDiag);
cursorSet = true;
}
}
if (!cursorSet) {
_imp->_publicInterface->setCurrentCursor(eCursorDefault);
}
if ( (hoverState == eHoverStateNothing) && wasHovering ) {
overlayCaught = true;
}
double dx = pos.x() - lastMousePos.x();
double dy = pos.y() - lastMousePos.y();
switch (uiState) {
case eViewerNodeInteractMouseStateDraggingRoiBottomEdge: {
if ( (draggedUserRoI.y1 + dy) < draggedUserRoI.y2 ) {
draggedUserRoI.y1 += dy;
overlayCaught = true;
}
break;
}
case eViewerNodeInteractMouseStateDraggingRoiLeftEdge: {
if ( (draggedUserRoI.x1 + dx) < draggedUserRoI.x2 ) {
draggedUserRoI.x1 += dx;
overlayCaught = true;
}
break;
}
case eViewerNodeInteractMouseStateDraggingRoiRightEdge: {
if ( (draggedUserRoI.x2 + dx) > draggedUserRoI.x1 ) {
draggedUserRoI.x2 += dx;
overlayCaught = true;
}
break;
}
case eViewerNodeInteractMouseStateDraggingRoiTopEdge: {
if ( (draggedUserRoI.y2 + dy) > draggedUserRoI.y1 ) {
draggedUserRoI.y2 += dy;
overlayCaught = true;
}
break;
}
case eViewerNodeInteractMouseStateDraggingRoiCross: {
draggedUserRoI.translate(dx, dy);
overlayCaught = true;
break;
}
case eViewerNodeInteractMouseStateDraggingRoiTopLeft: {
if ( (draggedUserRoI.y2 + dy) > draggedUserRoI.y1 ) {
draggedUserRoI.y2 += dy;
}
if ( (draggedUserRoI.x1 + dx) < draggedUserRoI.x2 ) {
draggedUserRoI.x1 += dx;
}
overlayCaught = true;
break;
}
case eViewerNodeInteractMouseStateDraggingRoiTopRight: {
if ( (draggedUserRoI.y2 + dy) > draggedUserRoI.y1 ) {
draggedUserRoI.y2 += dy;
}
if ( (draggedUserRoI.x2 + dx) > draggedUserRoI.x1 ) {
draggedUserRoI.x2 += dx;
}
overlayCaught = true;
break;
}
case eViewerNodeInteractMouseStateDraggingRoiBottomRight:
case eViewerNodeInteractMouseStateBuildingUserRoI:{
if ( (draggedUserRoI.x2 + dx) > draggedUserRoI.x1 ) {
draggedUserRoI.x2 += dx;
}
if ( (draggedUserRoI.y1 + dy) < draggedUserRoI.y2 ) {
draggedUserRoI.y1 += dy;
}
overlayCaught = true;
break;
}
case eViewerNodeInteractMouseStateDraggingRoiBottomLeft: {
if ( (draggedUserRoI.y1 + dy) < draggedUserRoI.y2 ) {
draggedUserRoI.y1 += dy;
}
if ( (draggedUserRoI.x1 + dx) < draggedUserRoI.x2 ) {
draggedUserRoI.x1 += dx;
}
overlayCaught = true;
break;
}
case eViewerNodeInteractMouseStateDraggingWipeCenter: {
KnobDoublePtr centerKnob = _imp->wipeCenter.lock();
centerKnob->setValue(centerKnob->getValue() + dx);
centerKnob->setValue(centerKnob->getValue(DimIdx(1)) + dy, ViewSetSpec::all(), DimIdx(1));
overlayCaught = true;
break;
}
case eViewerNodeInteractMouseStateDraggingWipeMixHandle: {
KnobDoublePtr centerKnob = _imp->wipeCenter.lock();
Point center;
center.x = centerKnob->getValue();
center.y = centerKnob->getValue(DimIdx(1));
double angle = std::atan2( pos.y() - center.y, pos.x() - center.x );
double prevAngle = std::atan2( lastMousePos.y() - center.y,
lastMousePos.x() - center.x );
KnobDoublePtr mixKnob = _imp->wipeAmount.lock();
double mixAmount = mixKnob->getValue();
mixAmount -= (angle - prevAngle);
mixAmount = std::max( 0., std::min(mixAmount, 1.) );
mixKnob->setValue(mixAmount);
overlayCaught = true;
break;
}
case eViewerNodeInteractMouseStateRotatingWipeHandle: {
KnobDoublePtr centerKnob = _imp->wipeCenter.lock();
Point center;
center.x = centerKnob->getValue();
center.y = centerKnob->getValue(DimIdx(1));
double angle = std::atan2( pos.y() - center.y, pos.x() - center.x );
KnobDoublePtr angleKnob = _imp->wipeAngle.lock();
double closestPI2 = M_PI_2 * std::floor(angle / M_PI_2 + 0.5);
if (std::fabs(angle - closestPI2) < 0.1) {
// snap to closest multiple of PI / 2.
angle = closestPI2;
}
angleKnob->setValue(angle);
overlayCaught = true;
break;
}
default:
break;
}
lastMousePos = pos;
return overlayCaught;
} // onOverlayPenMotion