std::pair<ImagePtr, RectD>
TrackMarker::getMarkerImage(TimeValue time,
const RectD& roi) const
{
assert( !roi.isNull() );
NodePtr node = getModel()->getNode();
NodePtr input = node->getInput(0);
if (!input) {
return std::make_pair(ImagePtr(), roi);
}
TreeRender::CtorArgsPtr args(new TreeRender::CtorArgs);
{
args->treeRootEffect = input->getEffectInstance();
args->time = time;
args->view = ViewIdx(0);
// Render default plane
args->plane = 0;
args->mipMapLevel = 0;
args->proxyScale = RenderScale(1.);
args->canonicalRoI = &roi;
args->draftMode = false;
args->playback = false;
args->byPassCache = false;
}
TreeRenderPtr render = TreeRender::create(args);
FrameViewRequestPtr outputRequest;
ActionRetCodeEnum stat = render->launchRender(&outputRequest);
if (isFailureRetCode(stat)) {
return std::make_pair(ImagePtr(), roi);
}
ImagePtr sourceImage = outputRequest->getRequestedScaleImagePlane();
// Make sure the Natron image rendered is RGBA full rect and on CPU, we don't support other formats
if (sourceImage->getStorageMode() != eStorageModeRAM) {
Image::InitStorageArgs initArgs;
initArgs.bounds = sourceImage->getBounds();
initArgs.plane = sourceImage->getLayer();
initArgs.bufferFormat = eImageBufferLayoutRGBAPackedFullRect;
initArgs.storage = eStorageModeRAM;
initArgs.bitdepth = sourceImage->getBitDepth();
ImagePtr tmpImage = Image::create(initArgs);
if (!tmpImage) {
return std::make_pair(ImagePtr(), roi);
}
Image::CopyPixelsArgs cpyArgs;
cpyArgs.roi = initArgs.bounds;
tmpImage->copyPixels(*sourceImage, cpyArgs);
sourceImage = tmpImage;
}
return std::make_pair(sourceImage, roi);
} // TrackMarker::getMarkerImage
void
AnimationModuleViewPrivate::keyFramesWithinRect(const RectD& canonicalRect, AnimItemDimViewKeyFramesMap* keys) const
{
// always running in the main thread
assert( qApp && qApp->thread() == QThread::currentThread() );
if (canonicalRect.isNull()) {
return;
}
std::vector<CurveGuiPtr> curves = getVisibleCurves();
for (std::vector<CurveGuiPtr>::const_iterator it = curves.begin(); it != curves.end(); ++it) {
KeyFrameSet set = (*it)->getKeyFrames();
if ( set.empty() ) {
continue;
}
AnimItemDimViewIndexID curveID = (*it)->getCurveID();
StringAnimationManagerPtr stringAnim = curveID.item->getInternalAnimItem()->getStringAnimation();
KeyFrameWithStringSet outKeys;
for ( KeyFrameSet::const_iterator it2 = set.begin(); it2 != set.end(); ++it2) {
double y = it2->getValue();
double x = it2->getTime();
if ( (x <= canonicalRect.x2) && (x >= canonicalRect.x1) && (y <= canonicalRect.y2) && (y >= canonicalRect.y1) ) {
//KeyPtr newSelectedKey( new SelectedKey(*it, *it2, hasPrev, prevKey, hasNext, nextKey) );
KeyFrameWithString k;
k.key = *it2;
if (stringAnim) {
stringAnim->stringFromInterpolatedIndex(it2->getValue(), curveID.view, &k.string);
}
outKeys.insert(k);
}
}
if (!outKeys.empty()) {
(*keys)[curveID] = outKeys;
}
}
} // CurveWidgetPrivate::keyFramesWithinRect
void
CurveGui::drawCurve(int curveIndex,
int curvesCount)
{
// always running in the main thread
assert( qApp && qApp->thread() == QThread::currentThread() );
AnimItemBasePtr item = _imp->item.lock();
if (!item) {
return;
}
std::vector<float> vertices, exprVertices;
const double widgetWidth = _imp->curveWidget->width();
KeyFrameSet keyframes;
bool hasDrawnExpr = false;
if (item->hasExpression(_imp->dimension, _imp->view)) {
//we have no choice but to evaluate the expression at each time
for (int i = 0; i < widgetWidth; ++i) {
double x = _imp->curveWidget->toZoomCoordinates(i, 0).x();
double y = evaluate(true /*useExpr*/, x);
exprVertices.push_back(x);
exprVertices.push_back(y);
}
hasDrawnExpr = true;
}
QPointF btmLeft = _imp->curveWidget->toZoomCoordinates(0, _imp->curveWidget->height() - 1);
QPointF topRight = _imp->curveWidget->toZoomCoordinates(_imp->curveWidget->width() - 1, 0);
bool isPeriodic = false;
std::pair<double,double> parametricRange = std::make_pair(-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity());
keyframes = getInternalCurve()->getKeyFrames_mt_safe();
isPeriodic = getInternalCurve()->isCurvePeriodic();
parametricRange = getInternalCurve()->getXRange();
if ( keyframes.empty() ) {
// Add a horizontal line for constant knobs, except string knobs.
KnobIPtr isKnob = boost::dynamic_pointer_cast<KnobI>(item->getInternalAnimItem());
if (isKnob) {
KnobStringBasePtr isString = boost::dynamic_pointer_cast<KnobStringBase>(isKnob);
if (!isString) {
double value = evaluate(false, 0);
vertices.push_back(btmLeft.x() + 1);
vertices.push_back(value);
vertices.push_back(topRight.x() - 1);
vertices.push_back(value);
}
}
} else {
try {
double x1 = 0;
double x2;
bool isX1AKey = false;
KeyFrame x1Key;
KeyFrameSet::const_iterator lastUpperIt = keyframes.end();
while ( x1 < (widgetWidth - 1) ) {
double x, y;
if (!isX1AKey) {
x = _imp->curveWidget->toZoomCoordinates(x1, 0).x();
y = evaluate(false, x);
} else {
x = x1Key.getTime();
y = x1Key.getValue();
}
vertices.push_back( (float)x );
vertices.push_back( (float)y );
nextPointForSegment(x, keyframes, isPeriodic, parametricRange.first, parametricRange.second, &lastUpperIt, &x2, &x1Key, &isX1AKey);
x1 = x2;
}
//also add the last point
{
double x = _imp->curveWidget->toZoomCoordinates(x1, 0).x();
double y = evaluate(false, x);
vertices.push_back( (float)x );
vertices.push_back( (float)y );
}
} catch (...) {
}
}
// No Expr curve or no vertices for the curve, don't draw anything else
if (exprVertices.empty() && vertices.empty()) {
return;
}
AnimationModuleSelectionModelPtr selectionModel = item->getModel()->getSelectionModel();
assert(selectionModel);
const AnimItemDimViewKeyFramesMap& selectedKeys = selectionModel->getCurrentKeyFramesSelection();
const KeyFrameWithStringSet* foundThisCurveSelectedKeys = 0;
{
AnimItemDimViewIndexID k;
k.item = item;
k.dim = _imp->dimension;
k.view = _imp->view;
AnimItemDimViewKeyFramesMap::const_iterator foundDimView = selectedKeys.find(k);
if (foundDimView != selectedKeys.end()) {
foundThisCurveSelectedKeys = &foundDimView->second;
}
}
{
GLProtectAttrib<GL_GPU> a(GL_HINT_BIT | GL_ENABLE_BIT | GL_LINE_BIT | GL_COLOR_BUFFER_BIT | GL_POINT_BIT | GL_CURRENT_BIT);
// If this is the only curve selected, draw min/max
if (foundThisCurveSelectedKeys && selectedKeys.size()) {
// Draw y min/max axis so the user understands why the value is clamped
Curve::YRange curveYRange = getCurveYRange();
if (curveYRange.min != INT_MIN &&
curveYRange.min != -std::numeric_limits<double>::infinity() &&
curveYRange.max != INT_MAX &&
curveYRange.max != std::numeric_limits<double>::infinity() ) {
QColor minMaxColor;
minMaxColor.setRgbF(0.398979, 0.398979, 0.398979);
GL_GPU::Color4d(minMaxColor.redF(), minMaxColor.greenF(), minMaxColor.blueF(), 1.);
GL_GPU::Begin(GL_LINES);
GL_GPU::Vertex2d(btmLeft.x(), curveYRange.min);
GL_GPU::Vertex2d(topRight.x(), curveYRange.min);
GL_GPU::Vertex2d(btmLeft.x(), curveYRange.max);
GL_GPU::Vertex2d(topRight.x(), curveYRange.max);
GL_GPU::End();
GL_GPU::Color4d(1., 1., 1., 1.);
double xText = _imp->curveWidget->toZoomCoordinates(10, 0).x();
_imp->curveWidget->renderText( xText, curveYRange.min, tr("min").toStdString(), minMaxColor.redF(), minMaxColor.greenF(), minMaxColor.blueF(), minMaxColor.alphaF());
_imp->curveWidget->renderText( xText, curveYRange.max, tr("max").toStdString(), minMaxColor.redF(), minMaxColor.greenF(), minMaxColor.blueF(), minMaxColor.alphaF());
}
}
GL_GPU::Color4f(_imp->color[0], _imp->color[1], _imp->color[2], _imp->color[3]);
GL_GPU::PointSize(_imp->lineWidth);
GL_GPU::Enable(GL_BLEND);
GL_GPU::BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GL_GPU::Enable(GL_LINE_SMOOTH);
GL_GPU::Hint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
GL_GPU::LineWidth(1.5);
glCheckError(GL_GPU);
if (hasDrawnExpr) {
drawLineStrip(exprVertices, btmLeft, topRight);
GL_GPU::LineStipple(2, 0xAAAA);
GL_GPU::Enable(GL_LINE_STIPPLE);
}
drawLineStrip(vertices, btmLeft, topRight);
if (hasDrawnExpr) {
GL_GPU::Disable(GL_LINE_STIPPLE);
}
glCheckErrorIgnoreOSXBug(GL_GPU);
//render the name of the curve
GL_GPU::Color4f(1.f, 1.f, 1.f, 1.f);
double interval = ( topRight.x() - btmLeft.x() ) / (double)curvesCount;
double textX = _imp->curveWidget->toZoomCoordinates(15, 0).x() + interval * (double)curveIndex;
double textY;
CurvePtr internalCurve = _imp->internalCurve.lock();
QString curveName = getName();
QColor thisColor;
thisColor.setRgbF(Image::clamp(_imp->color[0], 0., 1.),
Image::clamp(_imp->color[1], 0., 1.),
Image::clamp(_imp->color[2], 0., 1.));
try {
// Use expression to place the text if the curve is not animated
textY = evaluate(internalCurve && !internalCurve->isAnimated(), textX);
} catch (...) {
// if it fails attempt without expression, this will most likely return a constant value
textY = evaluate(false /*useExpression*/, textX);
}
if ( ( textX >= btmLeft.x() ) && ( textX <= topRight.x() ) && ( textY >= btmLeft.y() ) && ( textY <= topRight.y() ) ) {
_imp->curveWidget->renderText( textX, textY, curveName.toStdString(), thisColor.redF(), thisColor.greenF(), thisColor.blueF(), thisColor.alphaF());
}
GL_GPU::Color4f(_imp->color[0], _imp->color[1], _imp->color[2], _imp->color[3]);
//draw keyframes
GL_GPU::PointSize(7.f);
GL_GPU::Enable(GL_POINT_SMOOTH);
KeyFrameWithStringSet::const_iterator foundSelectedKey;
if (foundThisCurveSelectedKeys) {
foundSelectedKey = foundThisCurveSelectedKeys->end();
}
for (KeyFrameSet::const_iterator k = keyframes.begin(); k != keyframes.end(); ++k) {
const KeyFrame & key = (*k);
// Do not draw keyframes out of range
if ( ( key.getTime() < btmLeft.x() ) || ( key.getTime() > topRight.x() ) || ( key.getValue() < btmLeft.y() ) || ( key.getValue() > topRight.y() ) ) {
continue;
}
GL_GPU::Color4f(_imp->color[0], _imp->color[1], _imp->color[2], _imp->color[3]);
bool drawKeySelected = false;
if (foundThisCurveSelectedKeys) {
KeyFrameWithStringSet::const_iterator start = foundSelectedKey == foundThisCurveSelectedKeys->end() ? foundThisCurveSelectedKeys->begin() : foundSelectedKey;
foundSelectedKey = std::find_if(start, foundThisCurveSelectedKeys->end(), KeyFrameWithStringTimePredicate(key.getTime()));
drawKeySelected = foundSelectedKey != foundThisCurveSelectedKeys->end();
if (!drawKeySelected) {
// Also draw the keyframe as selected if it is inside the selection rectangle (but not yet selected)
RectD selectionRect = _imp->curveWidget->getSelectionRectangle();
drawKeySelected |= _imp->curveWidget->_imp->eventTriggeredFromCurveEditor && (!selectionRect.isNull() && selectionRect.contains(key.getTime(), key.getValue()));
}
}
// If the key is selected change its color
if (drawKeySelected) {
GL_GPU::Color4f(0.8f, 0.8f, 0.8f, 1.f);
}
RectD keyframeBbox = _imp->curveWidget->_imp->getKeyFrameBoundingRectCanonical(_imp->curveWidget->_imp->curveEditorZoomContext, key.getTime(), key.getValue());
// draw texture of the keyframe
{
AnimationModuleViewPrivate::KeyframeTexture texType = AnimationModuleViewPrivate::kfTextureFromKeyframeType( key.getInterpolation(), drawKeySelected);
if (texType != AnimationModuleViewPrivate::kfTextureNone) {
_imp->curveWidget->_imp->drawTexturedKeyframe(texType, keyframeBbox, false /*drawdimed*/);
}
}
// Draw tangents if not constant
bool drawTangents = drawKeySelected && internalCurve->isYComponentMovable() && (key.getInterpolation() != eKeyframeTypeConstant);
if (drawTangents) {
QFontMetrics m( _imp->curveWidget->font());
// If interpolation is not free and not broken display with dashes the tangents lines
if ( (key.getInterpolation() != eKeyframeTypeFree) && (key.getInterpolation() != eKeyframeTypeBroken) ) {
GL_GPU::LineStipple(2, 0xAAAA);
GL_GPU::Enable(GL_LINE_STIPPLE);
}
QPointF leftTanPos, rightTanPos;
_imp->curveWidget->getKeyTangentPoints(k, keyframes, &leftTanPos, &rightTanPos);
// Draw the derivatives lines
GL_GPU::Begin(GL_LINES);
GL_GPU::Color4f(1., 0.35, 0.35, 1.);
GL_GPU::Vertex2f( leftTanPos.x(), leftTanPos.y() );
GL_GPU::Vertex2f(key.getTime(), key.getValue());
GL_GPU::Vertex2f(key.getTime(), key.getValue());
GL_GPU::Vertex2f( rightTanPos.x(), rightTanPos.y());
GL_GPU::End();
if ( (key.getInterpolation() != eKeyframeTypeFree) && (key.getInterpolation() != eKeyframeTypeBroken) ) {
GL_GPU::Disable(GL_LINE_STIPPLE);
}
// Draw the tangents handles
GL_GPU::Begin(GL_POINTS);
GL_GPU::Vertex2f( leftTanPos.x(), leftTanPos.y() );
GL_GPU::Vertex2f( rightTanPos.x(), rightTanPos.y());
GL_GPU::End();
// If only one keyframe is selected, also draw the coordinates
if (selectedKeys.size() == 1 && foundThisCurveSelectedKeys && foundThisCurveSelectedKeys->size() == 1) {
double rounding = std::pow(10., CURVEWIDGET_DERIVATIVE_ROUND_PRECISION);
QString leftDerivStr = QString::fromUtf8("l: %1").arg(std::floor( (key.getLeftDerivative() * rounding) + 0.5 ) / rounding);
QString rightDerivStr = QString::fromUtf8("r: %1").arg(std::floor( (key.getRightDerivative() * rounding) + 0.5 ) / rounding);
double yLeftWidgetCoord = _imp->curveWidget->toWidgetCoordinates(0, leftTanPos.y()).y();
yLeftWidgetCoord += (m.height() + 4);
double yRightWidgetCoord = _imp->curveWidget->toWidgetCoordinates(0, rightTanPos.y()).y();
yRightWidgetCoord += (m.height() + 4);
GL_GPU::Color4f(1., 1., 1., 1.);
glCheckFramebufferError(GL_GPU);
_imp->curveWidget->renderText( leftTanPos.x(), _imp->curveWidget->toZoomCoordinates(0, yLeftWidgetCoord).y(),
leftDerivStr.toStdString(), 0.9, 0.9, 0.9, 1.);
_imp->curveWidget->renderText( rightTanPos.x(), _imp->curveWidget->toZoomCoordinates(0, yRightWidgetCoord).y(),
rightDerivStr.toStdString(), 0.9, 0.9, 0.9, 1.);
QString coordStr = QString::fromUtf8("x: %1, y: %2");
coordStr = coordStr.arg(key.getTime()).arg(key.getValue());
double yWidgetCoord = _imp->curveWidget->toWidgetCoordinates( 0, key.getValue() ).y();
yWidgetCoord += (m.height() + 4);
GL_GPU::Color4f(1., 1., 1., 1.);
glCheckFramebufferError(GL_GPU);
_imp->curveWidget->renderText( key.getTime(), _imp->curveWidget->toZoomCoordinates(0, yWidgetCoord).y(),
coordStr.toStdString(), 0.9, 0.9, 0.9, 1.);
}
} // drawTangents
} // for (KeyFrameSet::const_iterator k = keyframes.begin(); k != keyframes.end(); ++k) {
} // GLProtectAttrib(GL_HINT_BIT | GL_ENABLE_BIT | GL_LINE_BIT | GL_COLOR_BUFFER_BIT | GL_POINT_BIT | GL_CURRENT_BIT);
glCheckError(GL_GPU);
} // drawCurve
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
ViewerRenderFrameSubResult::onTreeRenderFinished(int inputIndex)
{
PerViewerInputRenderData& inputData = perInputsData[inputIndex];
if (inputIndex == 1 && copyInputBFromA) {
inputData = perInputsData[0];
return;
}
FrameViewRequestPtr outputRequest;
if (inputData.render) {
inputData.retCode = inputData.render->getStatus();
outputRequest = inputData.render->getOutputRequest();
}
if (outputRequest) {
inputData.viewerProcessImage = outputRequest->getRequestedScaleImagePlane();
}
// There might be no output image if the RoI that was passed to render is outside of the RoD of the effect
if (isFailureRetCode(inputData.retCode) || !inputData.viewerProcessImage) {
inputData.viewerProcessImage.reset();
inputData.render.reset();
return;
}
// Find the key of the image and store it so that in the gui
// we can later on re-use this key to check the cache for the timeline's cache line
ImageCacheEntryPtr cacheEntry = inputData.viewerProcessImage->getCacheEntry();
if (cacheEntry) {
inputData.viewerProcessImageKey = cacheEntry->getCacheKey();
}
// Convert the image to a format that can be uploaded to a OpenGL texture
RectI imageConvertRoI;
RectD ctorCanonicalRoI = inputData.render->getCtorRoI();
if (inputData.render && !ctorCanonicalRoI.isNull()) {
RenderScale scale = EffectInstance::getCombinedScale(inputData.viewerProcessImage->getMipMapLevel(), inputData.viewerProcessImage->getProxyScale());
double par = inputData.viewerProcessNode->getEffectInstance()->getAspectRatio(-1);
ctorCanonicalRoI.toPixelEnclosing(scale, par, &imageConvertRoI);
} else {
imageConvertRoI = inputData.viewerProcessImage->getBounds();
}
// If we are drawing with the RotoPaint node, only update the texture portion
if (textureTransferType == OpenGLViewerI::TextureTransferArgs::eTextureTransferTypeModify) {
RectI strokeArea;
bool strokeAreaSet = inputData.render->getRotoPaintActiveStrokeUpdateArea(&strokeArea);
if (strokeAreaSet) {
imageConvertRoI = strokeArea;
}
}
// The viewer-process node may not have rendered a 4 channel image, but this is required but the OpenGL viewer
// which only draws RGBA images.
// If we are in accumulation, force a copy of the image because another render thread might modify it in a future render whilst it may
// still be read from the main-thread when updating the ViewerGL texture.
// If texture transfer is eTextureTransferTypeOverlay, we want to upload the texture to exactly what was requested
const bool forceOutputImageCopy = (inputData.viewerProcessImage == inputData.viewerProcessNode->getEffectInstance()->getAccumBuffer(inputData.viewerProcessImage->getLayer()) ||
(textureTransferType == OpenGLViewerI::TextureTransferArgs::eTextureTransferTypeOverlay && inputData.viewerProcessImage->getBounds() != imageConvertRoI));
inputData.viewerProcessImage = convertImageForViewerDisplay(imageConvertRoI, forceOutputImageCopy, true /*the texture must have 4 channels*/, inputData.viewerProcessImage);
// Extra color-picker images as-well.
if (inputData.colorPickerNode) {
{
FrameViewRequestPtr req = inputData.render->getExtraRequestedResultsForNode(inputData.colorPickerNode);
if (req) {
inputData.colorPickerImage = req->getRequestedScaleImagePlane();
if (inputData.colorPickerImage) {
inputData.colorPickerImage = convertImageForViewerDisplay(inputData.colorPickerImage->getBounds(), false, false /*the picker can accept non 4-channel image*/, inputData.colorPickerImage);
}
}
}
if (inputData.colorPickerInputNode) {
FrameViewRequestPtr req = inputData.render->getExtraRequestedResultsForNode(inputData.colorPickerInputNode);
if (req) {
inputData.colorPickerInputImage = req->getRequestedScaleImagePlane();
if (inputData.colorPickerInputImage) {
inputData.colorPickerInputImage = convertImageForViewerDisplay(inputData.colorPickerInputImage->getBounds(), false, false /*the picker can accept non 4-channel image*/, inputData.colorPickerInputImage);
}
}
}
}
inputData.render.reset();
} // onTreeRenderFinished
