23 namespace SOP_TextureOpticalFlowEnums
40 mySourceGroup =
""_UTsh;
41 myGoalGroup =
""_UTsh;
42 myOutputName =
"flow"_UTsh;
44 myBlurringWindowRadius = 7;
45 myUseGaussianFilter =
false;
49 myApproximationWindowRadius = 2;
50 mySmoothnessDegree = 3;
54 myGradientDescentIterations = 25;
55 mySmoothnessWeight = 20;
56 myColorConstancyWeight = 5;
57 myGradientConstancyWeight = 10;
58 myVariationalRefinementIterations = 5;
59 myUseMeanNormalization =
true;
60 myUseSpatialPropagation =
true;
73 if (mySourceGroup != src.mySourceGroup)
return false;
74 if (myGoalGroup != src.myGoalGroup)
return false;
75 if (myOutputName != src.myOutputName)
return false;
76 if (myMethod != src.myMethod)
return false;
77 if (myBlurringWindowRadius != src.myBlurringWindowRadius)
return false;
78 if (myUseGaussianFilter != src.myUseGaussianFilter)
return false;
79 if (myPyramidLevels != src.myPyramidLevels)
return false;
80 if (myPyramidScale != src.myPyramidScale)
return false;
81 if (myIterations != src.myIterations)
return false;
82 if (myApproximationWindowRadius != src.myApproximationWindowRadius)
return false;
83 if (mySmoothnessDegree != src.mySmoothnessDegree)
return false;
84 if (myPatchSize != src.myPatchSize)
return false;
85 if (myPatchStride != src.myPatchStride)
return false;
86 if (myFinestScale != src.myFinestScale)
return false;
87 if (myGradientDescentIterations != src.myGradientDescentIterations)
return false;
88 if (mySmoothnessWeight != src.mySmoothnessWeight)
return false;
89 if (myColorConstancyWeight != src.myColorConstancyWeight)
return false;
90 if (myGradientConstancyWeight != src.myGradientConstancyWeight)
return false;
91 if (myVariationalRefinementIterations != src.myVariationalRefinementIterations)
return false;
92 if (myUseMeanNormalization != src.myUseMeanNormalization)
return false;
93 if (myUseSpatialPropagation != src.myUseSpatialPropagation)
return false;
107 mySourceGroup =
""_UTsh;
109 graph->
evalOpParm(mySourceGroup, nodeidx,
"sourcegroup", time, 0);
110 myGoalGroup =
""_UTsh;
112 graph->
evalOpParm(myGoalGroup, nodeidx,
"goalgroup", time, 0);
113 myOutputName =
"flow"_UTsh;
115 graph->
evalOpParm(myOutputName, nodeidx,
"outputname", time, 0);
118 graph->
evalOpParm(myMethod, nodeidx,
"method", time, 0);
119 myBlurringWindowRadius = 7;
120 if (
true && ( (
true&&!(((
int64(getMethod())!=0)))) ) )
121 graph->
evalOpParm(myBlurringWindowRadius, nodeidx,
"blurringwindowradius", time, 0);
122 myUseGaussianFilter =
false;
123 if (
true && ( (
true&&!(((
int64(getMethod())!=0)))) ) )
124 graph->
evalOpParm(myUseGaussianFilter, nodeidx,
"usegaussianfilter", time, 0);
126 if (
true && ( (
true&&!(((
int64(getMethod())!=0)))) ) )
127 graph->
evalOpParm(myPyramidLevels, nodeidx,
"pyramidlevels", time, 0);
128 myPyramidScale = 0.5;
129 if (
true && ( (
true&&!(((
int64(getMethod())!=0)))) ) )
130 graph->
evalOpParm(myPyramidScale, nodeidx,
"pyramidscale", time, 0);
132 if (
true && ( (
true&&!(((
int64(getMethod())!=0)))) ) )
133 graph->
evalOpParm(myIterations, nodeidx,
"iterations", time, 0);
134 myApproximationWindowRadius = 2;
135 if (
true && ( (
true&&!(((
int64(getMethod())!=0)))) ) )
136 graph->
evalOpParm(myApproximationWindowRadius, nodeidx,
"approximationwindowradius", time, 0);
137 mySmoothnessDegree = 3;
138 if (
true && ( (
true&&!(((
int64(getMethod())!=0)))) ) )
139 graph->
evalOpParm(mySmoothnessDegree, nodeidx,
"smoothnessdegree", time, 0);
141 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
142 graph->
evalOpParm(myPatchSize, nodeidx,
"patchsize", time, 0);
144 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
145 graph->
evalOpParm(myPatchStride, nodeidx,
"patchstride", time, 0);
147 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
148 graph->
evalOpParm(myFinestScale, nodeidx,
"finestscale", time, 0);
149 myGradientDescentIterations = 25;
150 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
151 graph->
evalOpParm(myGradientDescentIterations, nodeidx,
"gradientdescentiterations", time, 0);
152 mySmoothnessWeight = 20;
153 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
154 graph->
evalOpParm(mySmoothnessWeight, nodeidx,
"smoothnessweight", time, 0);
155 myColorConstancyWeight = 5;
156 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
157 graph->
evalOpParm(myColorConstancyWeight, nodeidx,
"colorconstancyweight", time, 0);
158 myGradientConstancyWeight = 10;
159 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
160 graph->
evalOpParm(myGradientConstancyWeight, nodeidx,
"gradientconstancyweight", time, 0);
161 myVariationalRefinementIterations = 5;
162 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
163 graph->
evalOpParm(myVariationalRefinementIterations, nodeidx,
"variationalrefinementiterations", time, 0);
164 myUseMeanNormalization =
true;
165 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
166 graph->
evalOpParm(myUseMeanNormalization, nodeidx,
"usemeannormalization", time, 0);
167 myUseSpatialPropagation =
true;
168 if (
true && ( (
true&&!(((
int64(getMethod())!=1)))) ) )
169 graph->
evalOpParm(myUseSpatialPropagation, nodeidx,
"usespatialpropagation", time, 0);
185 template <
typename T>
192 if (idx.
size() != instance.
size()+1)
251 coerceValue(value, myVariationalRefinementIterations);
273 { doGetParmValue(idx, instance, value); }
275 { doGetParmValue(idx, instance, value); }
277 { doGetParmValue(idx, instance, value); }
279 { doGetParmValue(idx, instance, value); }
281 { doGetParmValue(idx, instance, value); }
283 { doGetParmValue(idx, instance, value); }
285 { doGetParmValue(idx, instance, value); }
287 { doGetParmValue(idx, instance, value); }
289 { doGetParmValue(idx, instance, value); }
291 { doGetParmValue(idx, instance, value); }
293 { doGetParmValue(idx, instance, value); }
295 template <
typename T>
302 if (idx.
size() != instance.
size()+1)
364 coerceValue(myUseMeanNormalization, ( ( value ) ));
367 coerceValue(myUseSpatialPropagation, ( ( value ) ));
374 { doSetParmValue(idx, instance, value); }
376 { doSetParmValue(idx, instance, value); }
378 { doSetParmValue(idx, instance, value); }
380 { doSetParmValue(idx, instance, value); }
382 { doSetParmValue(idx, instance, value); }
384 { doSetParmValue(idx, instance, value); }
386 { doSetParmValue(idx, instance, value); }
388 { doSetParmValue(idx, instance, value); }
390 { doSetParmValue(idx, instance, value); }
392 { doSetParmValue(idx, instance, value); }
394 { doSetParmValue(idx, instance, value); }
410 if (fieldnum.
size() < 1)
415 return "sourcegroup";
423 return "blurringwindowradius";
425 return "usegaussianfilter";
427 return "pyramidlevels";
429 return "pyramidscale";
433 return "approximationwindowradius";
435 return "smoothnessdegree";
439 return "patchstride";
441 return "finestscale";
443 return "gradientdescentiterations";
445 return "smoothnessweight";
447 return "colorconstancyweight";
449 return "gradientconstancyweight";
451 return "variationalrefinementiterations";
453 return "usemeannormalization";
455 return "usespatialpropagation";
463 if (fieldnum.
size() < 1)
464 return PARM_UNSUPPORTED;
530 {
for (
int r = 0;
r < 2;
r++)
for (
int c = 0; c < 2; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
532 {
for (
int r = 0;
r < 3;
r++)
for (
int c = 0; c < 3; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
534 {
for (
int r = 0;
r < 4;
r++)
for (
int c = 0; c < 4; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
547 loadData(is, rampdata);
565 int typelen = colon - data.
buffer();
579 {
int64 iv =
v; UTwrite(os, &iv); }
581 { UTwrite<fpreal64>(os, &
v); }
583 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
585 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
586 UTwrite<fpreal64>(os, &v.
z()); }
588 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
589 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
601 if (s) s->save(ostr);
603 saveData(os, result);
610 ostr << s->getDataTypeToken();
615 saveData(os, result);
619 void save(std::ostream &os)
const
623 saveData(os, mySourceGroup);
624 saveData(os, myGoalGroup);
625 saveData(os, myOutputName);
626 saveData(os, myMethod);
627 saveData(os, myBlurringWindowRadius);
628 saveData(os, myUseGaussianFilter);
629 saveData(os, myPyramidLevels);
630 saveData(os, myPyramidScale);
631 saveData(os, myIterations);
632 saveData(os, myApproximationWindowRadius);
633 saveData(os, mySmoothnessDegree);
634 saveData(os, myPatchSize);
635 saveData(os, myPatchStride);
636 saveData(os, myFinestScale);
637 saveData(os, myGradientDescentIterations);
638 saveData(os, mySmoothnessWeight);
639 saveData(os, myColorConstancyWeight);
640 saveData(os, myGradientConstancyWeight);
641 saveData(os, myVariationalRefinementIterations);
642 saveData(os, myUseMeanNormalization);
643 saveData(os, myUseSpatialPropagation);
656 loadData(is, mySourceGroup);
657 loadData(is, myGoalGroup);
658 loadData(is, myOutputName);
659 loadData(is, myMethod);
660 loadData(is, myBlurringWindowRadius);
661 loadData(is, myUseGaussianFilter);
662 loadData(is, myPyramidLevels);
663 loadData(is, myPyramidScale);
664 loadData(is, myIterations);
665 loadData(is, myApproximationWindowRadius);
666 loadData(is, mySmoothnessDegree);
667 loadData(is, myPatchSize);
668 loadData(is, myPatchStride);
669 loadData(is, myFinestScale);
670 loadData(is, myGradientDescentIterations);
671 loadData(is, mySmoothnessWeight);
672 loadData(is, myColorConstancyWeight);
673 loadData(is, myGradientConstancyWeight);
674 loadData(is, myVariationalRefinementIterations);
675 loadData(is, myUseMeanNormalization);
676 loadData(is, myUseSpatialPropagation);
686 if (!thissop)
return getSourceGroup();
688 OP_Utils::evalOpParm(result, thissop,
"sourcegroup", cookparms.
getCookTime(), 0);
696 if (!thissop)
return getGoalGroup();
698 OP_Utils::evalOpParm(result, thissop,
"goalgroup", cookparms.
getCookTime(), 0);
706 if (!thissop)
return getOutputName();
708 OP_Utils::evalOpParm(result, thissop,
"outputname", cookparms.
getCookTime(), 0);
716 if (!thissop)
return getMethod();
718 OP_Utils::evalOpParm(result, thissop,
"method", cookparms.
getCookTime(), 0);
726 if (!thissop)
return getBlurringWindowRadius();
728 OP_Utils::evalOpParm(result, thissop,
"blurringwindowradius", cookparms.
getCookTime(), 0);
736 if (!thissop)
return getUseGaussianFilter();
738 OP_Utils::evalOpParm(result, thissop,
"usegaussianfilter", cookparms.
getCookTime(), 0);
746 if (!thissop)
return getPyramidLevels();
748 OP_Utils::evalOpParm(result, thissop,
"pyramidlevels", cookparms.
getCookTime(), 0);
756 if (!thissop)
return getPyramidScale();
758 OP_Utils::evalOpParm(result, thissop,
"pyramidscale", cookparms.
getCookTime(), 0);
766 if (!thissop)
return getIterations();
768 OP_Utils::evalOpParm(result, thissop,
"iterations", cookparms.
getCookTime(), 0);
776 if (!thissop)
return getApproximationWindowRadius();
778 OP_Utils::evalOpParm(result, thissop,
"approximationwindowradius", cookparms.
getCookTime(), 0);
786 if (!thissop)
return getSmoothnessDegree();
788 OP_Utils::evalOpParm(result, thissop,
"smoothnessdegree", cookparms.
getCookTime(), 0);
796 if (!thissop)
return getPatchSize();
798 OP_Utils::evalOpParm(result, thissop,
"patchsize", cookparms.
getCookTime(), 0);
806 if (!thissop)
return getPatchStride();
808 OP_Utils::evalOpParm(result, thissop,
"patchstride", cookparms.
getCookTime(), 0);
816 if (!thissop)
return getFinestScale();
818 OP_Utils::evalOpParm(result, thissop,
"finestscale", cookparms.
getCookTime(), 0);
826 if (!thissop)
return getGradientDescentIterations();
828 OP_Utils::evalOpParm(result, thissop,
"gradientdescentiterations", cookparms.
getCookTime(), 0);
836 if (!thissop)
return getSmoothnessWeight();
838 OP_Utils::evalOpParm(result, thissop,
"smoothnessweight", cookparms.
getCookTime(), 0);
846 if (!thissop)
return getColorConstancyWeight();
848 OP_Utils::evalOpParm(result, thissop,
"colorconstancyweight", cookparms.
getCookTime(), 0);
856 if (!thissop)
return getGradientConstancyWeight();
858 OP_Utils::evalOpParm(result, thissop,
"gradientconstancyweight", cookparms.
getCookTime(), 0);
866 if (!thissop)
return getVariationalRefinementIterations();
868 OP_Utils::evalOpParm(result, thissop,
"variationalrefinementiterations", cookparms.
getCookTime(), 0);
876 if (!thissop)
return getUseMeanNormalization();
878 OP_Utils::evalOpParm(result, thissop,
"usemeannormalization", cookparms.
getCookTime(), 0);
886 if (!thissop)
return getUseSpatialPropagation();
888 OP_Utils::evalOpParm(result, thissop,
"usespatialpropagation", cookparms.
getCookTime(), 0);
897 int64 myBlurringWindowRadius;
898 bool myUseGaussianFilter;
899 int64 myPyramidLevels;
902 fpreal64 myApproximationWindowRadius;
903 int64 mySmoothnessDegree;
907 int64 myGradientDescentIterations;
911 int64 myVariationalRefinementIterations;
912 bool myUseMeanNormalization;
913 bool myUseSpatialPropagation;
int64 getPatchStride() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
int64 getSmoothnessDegree() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
bool load(UT_IStream &is)
void save(std::ostream &os) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
static void loadData(UT_IStream &is, UT_Vector2D &v)
SOP_Node * getNode() const
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
UT_StringHolder opSourceGroup(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opGradientConstancyWeight(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
T clampMaxValue(fpreal maxvalue, const T &src) const
const UT_StringHolder & getGoalGroup() const
void setBlurringWindowRadius(int64 val)
static void saveData(std::ostream &os, UT_Matrix2D v)
void setMethod(Method val)
exint bread(int32 *buffer, exint asize=1)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
GT_API const UT_StringHolder time
constexpr SYS_FORCE_INLINE T & y() noexcept
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
const OP_Context & context() const
constexpr SYS_FORCE_INLINE T & z() noexcept
void setFinestScale(int64 val)
SYS_FORCE_INLINE const char * buffer() const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
int64 opVariationalRefinementIterations(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
static void loadData(UT_IStream &is, UT_StringHolder &v)
An output stream object that owns its own string buffer storage.
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
static void loadData(UT_IStream &is, UT_Vector3D &v)
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
**But if you need a result
T clampMinValue(fpreal minvalue, const T &src) const
void setGradientConstancyWeight(fpreal64 val)
UT_StringHolder opOutputName(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
static void saveData(std::ostream &os, fpreal64 v)
UT_StringHolder opGoalGroup(const SOP_NodeVerb::CookParms &cookparms) const
void copyFrom(const OP_NodeParms *src) override
constexpr SYS_FORCE_INLINE T & x() noexcept
int64 getFinestScale() const
fpreal64 getPyramidScale() const
fpreal64 getColorConstancyWeight() const
static void loadData(UT_IStream &is, UT_Vector4D &v)
constexpr SYS_FORCE_INLINE T & x() noexcept
int64 opGradientDescentIterations(const SOP_NodeVerb::CookParms &cookparms) const
int64 opPatchSize(const SOP_NodeVerb::CookParms &cookparms) const
int64 opPyramidLevels(const SOP_NodeVerb::CookParms &cookparms) const
bool opUseMeanNormalization(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
int64 getPyramidLevels() const
static void saveData(std::ostream &os, UT_Matrix4D v)
int64 getBlurringWindowRadius() const
static void saveData(std::ostream &os, UT_Vector2D v)
bool operator!=(const SOP_TextureOpticalFlowParms &src) const
void setGradientDescentIterations(int64 val)
bool getUseGaussianFilter() const
fpreal64 opColorConstancyWeight(const SOP_NodeVerb::CookParms &cookparms) const
void setVariationalRefinementIterations(int64 val)
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
static void loadData(UT_IStream &is, UT_Vector3I &v)
constexpr SYS_FORCE_INLINE T & z() noexcept
void setGoalGroup(const UT_StringHolder &val)
static void saveData(std::ostream &os, PRM_DataItemHandle s)
static void saveData(std::ostream &os, UT_StringHolder s)
bool getUseSpatialPropagation() const
const OP_GraphProxy * graph() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
int64 opSmoothnessDegree(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector3D v)
int64 getPatchSize() const
static void loadData(UT_IStream &is, fpreal64 &v)
void setUseSpatialPropagation(bool val)
int64 opPatchStride(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opSmoothnessWeight(const SOP_NodeVerb::CookParms &cookparms) const
void setSourceGroup(const UT_StringHolder &val)
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
static void saveData(std::ostream &os, UT_Vector4D v)
void setColorConstancyWeight(fpreal64 val)
bool getUseMeanNormalization() const
void setIterations(int64 val)
void saveBinary(std::ostream &os) const
Save string to binary stream.
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
fpreal64 getSmoothnessWeight() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
GT_API const UT_StringHolder version
static void saveData(std::ostream &os, int64 v)
int64 getIterations() const
SOP_TextureOpticalFlowParms()
static void saveData(std::ostream &os, bool v)
int64 opBlurringWindowRadius(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
static void loadData(UT_IStream &is, int64 &v)
bool opUseSpatialPropagation(const SOP_NodeVerb::CookParms &cookparms) const
const char * getNestParmName(TempIndex fieldnum) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
void setPatchSize(int64 val)
void setPyramidScale(fpreal64 val)
void coerceValue(T &result, const S &src) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void setSmoothnessWeight(fpreal64 val)
static void loadData(UT_IStream &is, bool &v)
const UT_StringHolder & getSourceGroup() const
DEP_MicroNode * depnode() const
void setPatchStride(int64 val)
Utility class for containing a color ramp.
fpreal64 opPyramidScale(const SOP_NodeVerb::CookParms &cookparms) const
int64 opIterations(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & w() noexcept
int64 getGradientDescentIterations() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
void setOutputName(const UT_StringHolder &val)
fpreal getCookTime() const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
bool isParmColorRamp(exint idx) const override
void setUseMeanNormalization(bool val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
const char * findChar(int c) const
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
fpreal64 getApproximationWindowRadius() const
bool opUseGaussianFilter(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
void loadFromOpSubclass(const LoadParms &loadparms) override
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void setSmoothnessDegree(int64 val)
fpreal64 getGradientConstancyWeight() const
const UT_StringHolder & getOutputName() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
int64 getVariationalRefinementIterations() const
constexpr SYS_FORCE_INLINE T & y() noexcept
fpreal64 opApproximationWindowRadius(const SOP_NodeVerb::CookParms &cookparms) const
void setUseGaussianFilter(bool val)
exint getNestNumParms(TempIndex idx) const override
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
Method opMethod(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
static void saveData(std::ostream &os, UT_Matrix3D v)
constexpr SYS_FORCE_INLINE T & y() noexcept
SYS_FORCE_INLINE bool isstring() const
void setApproximationWindowRadius(fpreal64 val)
OP_NodeParms & operator=(const OP_NodeParms &)=default
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
ParmType getNestParmType(TempIndex fieldnum) const override
int64 opFinestScale(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const SOP_TextureOpticalFlowParms &src) const
constexpr SYS_FORCE_INLINE T & x() noexcept
void setPyramidLevels(int64 val)