23 namespace SOP_PolyDoctorEnums
110 myIllFormedAction = 2;
111 myManyEdgesAction = 2;
112 myNonConvexAction = 2;
113 myOverlappingAction = 2;
114 myPairOverlaps =
false;
115 mySelfIntersectingAction = 1;
116 myThickness = 0.0001;
117 myGloballySmallAreasAction = 0;
118 myGlobalAreaThreshold = 1e-06;
119 myLocallySmallAreasAction = 0;
120 myLocalAreaThreshold = 0.01;
121 myNonUniformAction = 0;
122 myUniformityThreshold = 0.01;
123 myGloballySmallEdgesAction = 0;
124 myGlobalEdgeThreshold = 0.001;
125 myLocallySmallEdgesAction = 0;
126 myLocalEdgeThreshold = 0.3;
127 myDisconnectedPointsAction = 0;
128 myNonManifoldPointsAction = 0;
129 myIgnoreWindings =
true;
130 myPreferLargeAngles =
false;
131 myVisualizeMaxManifold =
false;
132 myExportManifoldNumbers =
false;
133 myFixWindings =
false;
134 myDeleteSmallManifolds =
false;
135 mySmallManifoldSize = 0;
136 myAddValidPolyAttrib =
true;
137 myValidPolyAttribName =
"valid_poly"_UTsh;
138 myAddRepairedPolyAttrib =
true;
139 myRepairedPolyAttribName =
"repaired_poly"_UTsh;
140 myAddValidPtsAttrib =
true;
141 myValidPtsAttribName =
"valid_pt"_UTsh;
142 myAddModifiedPtsAttrib =
true;
143 myModifiedPtsAttribName =
"modified_pt"_UTsh;
144 myCreateGroups =
false;
145 myVisualizeInvalidPts =
false;
147 myVisualizeRepairedPts =
false;
149 myVisualizeInvalidPolys =
false;
151 myVisualizeRepairedPolys =
false;
165 if (myGroup != src.myGroup)
return false;
166 if (myMaxPasses != src.myMaxPasses)
return false;
167 if (myRandomSeed != src.myRandomSeed)
return false;
168 if (myIllFormedAction != src.myIllFormedAction)
return false;
169 if (myManyEdgesAction != src.myManyEdgesAction)
return false;
170 if (myNonConvexAction != src.myNonConvexAction)
return false;
171 if (myOverlappingAction != src.myOverlappingAction)
return false;
172 if (myPairOverlaps != src.myPairOverlaps)
return false;
173 if (mySelfIntersectingAction != src.mySelfIntersectingAction)
return false;
174 if (myThickness != src.myThickness)
return false;
175 if (myGloballySmallAreasAction != src.myGloballySmallAreasAction)
return false;
176 if (myGlobalAreaThreshold != src.myGlobalAreaThreshold)
return false;
177 if (myLocallySmallAreasAction != src.myLocallySmallAreasAction)
return false;
178 if (myLocalAreaThreshold != src.myLocalAreaThreshold)
return false;
179 if (myNonUniformAction != src.myNonUniformAction)
return false;
180 if (myUniformityThreshold != src.myUniformityThreshold)
return false;
181 if (myGloballySmallEdgesAction != src.myGloballySmallEdgesAction)
return false;
182 if (myGlobalEdgeThreshold != src.myGlobalEdgeThreshold)
return false;
183 if (myLocallySmallEdgesAction != src.myLocallySmallEdgesAction)
return false;
184 if (myLocalEdgeThreshold != src.myLocalEdgeThreshold)
return false;
185 if (myDisconnectedPointsAction != src.myDisconnectedPointsAction)
return false;
186 if (myNonManifoldPointsAction != src.myNonManifoldPointsAction)
return false;
187 if (myIgnoreWindings != src.myIgnoreWindings)
return false;
188 if (myPreferLargeAngles != src.myPreferLargeAngles)
return false;
189 if (myVisualizeMaxManifold != src.myVisualizeMaxManifold)
return false;
190 if (myExportManifoldNumbers != src.myExportManifoldNumbers)
return false;
191 if (myFixWindings != src.myFixWindings)
return false;
192 if (myDeleteSmallManifolds != src.myDeleteSmallManifolds)
return false;
193 if (mySmallManifoldSize != src.mySmallManifoldSize)
return false;
194 if (myAddValidPolyAttrib != src.myAddValidPolyAttrib)
return false;
195 if (myValidPolyAttribName != src.myValidPolyAttribName)
return false;
196 if (myAddRepairedPolyAttrib != src.myAddRepairedPolyAttrib)
return false;
197 if (myRepairedPolyAttribName != src.myRepairedPolyAttribName)
return false;
198 if (myAddValidPtsAttrib != src.myAddValidPtsAttrib)
return false;
199 if (myValidPtsAttribName != src.myValidPtsAttribName)
return false;
200 if (myAddModifiedPtsAttrib != src.myAddModifiedPtsAttrib)
return false;
201 if (myModifiedPtsAttribName != src.myModifiedPtsAttribName)
return false;
202 if (myCreateGroups != src.myCreateGroups)
return false;
203 if (myVisualizeInvalidPts != src.myVisualizeInvalidPts)
return false;
204 if (myInvalidPtsColor != src.myInvalidPtsColor)
return false;
205 if (myVisualizeRepairedPts != src.myVisualizeRepairedPts)
return false;
206 if (myRepairedPtsColor != src.myRepairedPtsColor)
return false;
207 if (myVisualizeInvalidPolys != src.myVisualizeInvalidPolys)
return false;
208 if (myInvalidPolysColor != src.myInvalidPolysColor)
return false;
209 if (myVisualizeRepairedPolys != src.myVisualizeRepairedPolys)
return false;
210 if (myRepairedPolysColor != src.myRepairedPolysColor)
return false;
237 graph->
evalOpParm(myGroup, nodeidx,
"group", time, 0);
240 graph->
evalOpParm(myMaxPasses, nodeidx,
"maxpasses", time, 0);
243 graph->
evalOpParm(myRandomSeed, nodeidx,
"randomseed", time, 0);
244 myIllFormedAction = 2;
246 graph->
evalOpParm(myIllFormedAction, nodeidx,
"illformed", time, 0);
247 myManyEdgesAction = 2;
248 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0)))) ) )
249 graph->
evalOpParm(myManyEdgesAction, nodeidx,
"manyedges", time, 0);
250 myNonConvexAction = 2;
251 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0)))) ) )
252 graph->
evalOpParm(myNonConvexAction, nodeidx,
"nonconvex", time, 0);
253 myOverlappingAction = 2;
254 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0)))) ) )
255 graph->
evalOpParm(myOverlappingAction, nodeidx,
"overlapping", time, 0);
256 myPairOverlaps =
false;
257 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0))||((
int64(getOverlappingAction())==0)))) ) )
258 graph->
evalOpParm(myPairOverlaps, nodeidx,
"pairoverlaps", time, 0);
259 mySelfIntersectingAction = 1;
260 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
261 graph->
evalOpParm(mySelfIntersectingAction, nodeidx,
"intersect", time, 0);
262 myThickness = 0.0001;
263 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
264 graph->
evalOpParm(myThickness, nodeidx,
"thickness", time, 0);
265 myGloballySmallAreasAction = 0;
266 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0)))) ) )
267 graph->
evalOpParm(myGloballySmallAreasAction, nodeidx,
"glosmallarea", time, 0);
268 myGlobalAreaThreshold = 1e-06;
269 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0)))) ) )
270 graph->
evalOpParm(myGlobalAreaThreshold, nodeidx,
"gloareathres", time, 0);
271 myLocallySmallAreasAction = 0;
272 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0)))) ) )
273 graph->
evalOpParm(myLocallySmallAreasAction, nodeidx,
"locsmallarea", time, 0);
274 myLocalAreaThreshold = 0.01;
275 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0)))) ) )
276 graph->
evalOpParm(myLocalAreaThreshold, nodeidx,
"locareathres", time, 0);
277 myNonUniformAction = 0;
278 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
279 graph->
evalOpParm(myNonUniformAction, nodeidx,
"nonuni", time, 0);
280 myUniformityThreshold = 0.01;
281 if (
true && ( (
true&&!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
282 graph->
evalOpParm(myUniformityThreshold, nodeidx,
"unithres", time, 0);
283 myGloballySmallEdgesAction = 0;
285 graph->
evalOpParm(myGloballySmallEdgesAction, nodeidx,
"glosmalledge", time, 0);
286 myGlobalEdgeThreshold = 0.001;
288 graph->
evalOpParm(myGlobalEdgeThreshold, nodeidx,
"gloedgethres", time, 0);
289 myLocallySmallEdgesAction = 0;
291 graph->
evalOpParm(myLocallySmallEdgesAction, nodeidx,
"locsmalledge", time, 0);
292 myLocalEdgeThreshold = 0.3;
294 graph->
evalOpParm(myLocalEdgeThreshold, nodeidx,
"locedgethres", time, 0);
295 myDisconnectedPointsAction = 0;
297 graph->
evalOpParm(myDisconnectedPointsAction, nodeidx,
"disconnectpt", time, 0);
298 myNonManifoldPointsAction = 0;
300 graph->
evalOpParm(myNonManifoldPointsAction, nodeidx,
"nonmanifoldpt", time, 0);
301 myIgnoreWindings =
true;
303 graph->
evalOpParm(myIgnoreWindings, nodeidx,
"ignorewindings", time, 0);
304 myPreferLargeAngles =
false;
305 if (
true && ( (
true&&!(((
int64(getNonManifoldPointsAction())!=2)))) ) )
306 graph->
evalOpParm(myPreferLargeAngles, nodeidx,
"preferlargeangles", time, 0);
307 myVisualizeMaxManifold =
false;
309 graph->
evalOpParm(myVisualizeMaxManifold, nodeidx,
"vismaxmanifold", time, 0);
310 myExportManifoldNumbers =
false;
312 graph->
evalOpParm(myExportManifoldNumbers, nodeidx,
"exportmanifoldnumbers", time, 0);
313 myFixWindings =
false;
315 graph->
evalOpParm(myFixWindings, nodeidx,
"fixwindings", time, 0);
316 myDeleteSmallManifolds =
false;
318 graph->
evalOpParm(myDeleteSmallManifolds, nodeidx,
"deletesmallmanifolds", time, 0);
319 mySmallManifoldSize = 0;
320 if (
true && ( (
true&&!(((getDeleteSmallManifolds()==0)))) ) )
321 graph->
evalOpParm(mySmallManifoldSize, nodeidx,
"smallmanifoldsize", time, 0);
322 myAddValidPolyAttrib =
true;
324 graph->
evalOpParm(myAddValidPolyAttrib, nodeidx,
"usevalidpoly", time, 0);
325 myValidPolyAttribName =
"valid_poly"_UTsh;
327 graph->
evalOpParm(myValidPolyAttribName, nodeidx,
"validpoly", time, 0);
328 myAddRepairedPolyAttrib =
true;
330 graph->
evalOpParm(myAddRepairedPolyAttrib, nodeidx,
"userepairedpoly", time, 0);
331 myRepairedPolyAttribName =
"repaired_poly"_UTsh;
333 graph->
evalOpParm(myRepairedPolyAttribName, nodeidx,
"repairedpoly", time, 0);
334 myAddValidPtsAttrib =
true;
336 graph->
evalOpParm(myAddValidPtsAttrib, nodeidx,
"usevalidpts", time, 0);
337 myValidPtsAttribName =
"valid_pt"_UTsh;
339 graph->
evalOpParm(myValidPtsAttribName, nodeidx,
"validpts", time, 0);
340 myAddModifiedPtsAttrib =
true;
342 graph->
evalOpParm(myAddModifiedPtsAttrib, nodeidx,
"usemodifiedpts", time, 0);
343 myModifiedPtsAttribName =
"modified_pt"_UTsh;
345 graph->
evalOpParm(myModifiedPtsAttribName, nodeidx,
"modifiedpts", time, 0);
346 myCreateGroups =
false;
348 graph->
evalOpParm(myCreateGroups, nodeidx,
"creategrps", time, 0);
349 myVisualizeInvalidPts =
false;
351 graph->
evalOpParm(myVisualizeInvalidPts, nodeidx,
"visinvalidpts", time, 0);
353 if (
true && ( (
true&&!(((getVisualizeInvalidPts()==0)))) ) )
354 graph->
evalOpParm(myInvalidPtsColor, nodeidx,
"visinvalidptsfg", time, 0);
355 myVisualizeRepairedPts =
false;
357 graph->
evalOpParm(myVisualizeRepairedPts, nodeidx,
"visrepairedpts", time, 0);
359 if (
true && ( (
true&&!(((getVisualizeRepairedPts()==0)))) ) )
360 graph->
evalOpParm(myRepairedPtsColor, nodeidx,
"visrepairedptsfg", time, 0);
361 myVisualizeInvalidPolys =
false;
363 graph->
evalOpParm(myVisualizeInvalidPolys, nodeidx,
"visinvalidpolys", time, 0);
365 if (
true && ( (
true&&!(((getVisualizeInvalidPolys()==0)))) ) )
366 graph->
evalOpParm(myInvalidPolysColor, nodeidx,
"visinvalidpolysfg", time, 0);
367 myVisualizeRepairedPolys =
false;
369 graph->
evalOpParm(myVisualizeRepairedPolys, nodeidx,
"visrepairedpolys", time, 0);
371 if (
true && ( (
true&&!(((getVisualizeRepairedPolys()==0)))) ) )
372 graph->
evalOpParm(myRepairedPolysColor, nodeidx,
"visrepairedpolysfg", time, 0);
388 template <
typename T>
395 if (idx.
size() != instance.
size()+1)
551 { doGetParmValue(idx, instance, value); }
553 { doGetParmValue(idx, instance, value); }
555 { doGetParmValue(idx, instance, value); }
557 { doGetParmValue(idx, instance, value); }
559 { doGetParmValue(idx, instance, value); }
561 { doGetParmValue(idx, instance, value); }
563 { doGetParmValue(idx, instance, value); }
565 { doGetParmValue(idx, instance, value); }
567 { doGetParmValue(idx, instance, value); }
569 { doGetParmValue(idx, instance, value); }
571 { doGetParmValue(idx, instance, value); }
573 template <
typename T>
580 if (idx.
size() != instance.
size()+1)
657 coerceValue(myVisualizeMaxManifold, ( ( value ) ));
660 coerceValue(myExportManifoldNumbers, ( ( value ) ));
666 coerceValue(myDeleteSmallManifolds, ( ( value ) ));
678 coerceValue(myAddRepairedPolyAttrib, ( ( value ) ));
681 coerceValue(myRepairedPolyAttribName, ( ( value ) ));
690 coerceValue(myAddModifiedPtsAttrib, ( ( value ) ));
693 coerceValue(myModifiedPtsAttribName, ( ( value ) ));
705 coerceValue(myVisualizeRepairedPts, ( ( value ) ));
711 coerceValue(myVisualizeInvalidPolys, ( ( value ) ));
717 coerceValue(myVisualizeRepairedPolys, ( ( value ) ));
727 { doSetParmValue(idx, instance, value); }
729 { doSetParmValue(idx, instance, value); }
731 { doSetParmValue(idx, instance, value); }
733 { doSetParmValue(idx, instance, value); }
735 { doSetParmValue(idx, instance, value); }
737 { doSetParmValue(idx, instance, value); }
739 { doSetParmValue(idx, instance, value); }
741 { doSetParmValue(idx, instance, value); }
743 { doSetParmValue(idx, instance, value); }
745 { doSetParmValue(idx, instance, value); }
747 { doSetParmValue(idx, instance, value); }
763 if (fieldnum.
size() < 1)
780 return "overlapping";
782 return "pairoverlaps";
788 return "glosmallarea";
790 return "gloareathres";
792 return "locsmallarea";
794 return "locareathres";
800 return "glosmalledge";
802 return "gloedgethres";
804 return "locsmalledge";
806 return "locedgethres";
808 return "disconnectpt";
810 return "nonmanifoldpt";
812 return "ignorewindings";
814 return "preferlargeangles";
816 return "vismaxmanifold";
818 return "exportmanifoldnumbers";
820 return "fixwindings";
822 return "deletesmallmanifolds";
824 return "smallmanifoldsize";
826 return "usevalidpoly";
830 return "userepairedpoly";
832 return "repairedpoly";
834 return "usevalidpts";
838 return "usemodifiedpts";
840 return "modifiedpts";
844 return "visinvalidpts";
846 return "visinvalidptsfg";
848 return "visrepairedpts";
850 return "visrepairedptsfg";
852 return "visinvalidpolys";
854 return "visinvalidpolysfg";
856 return "visrepairedpolys";
858 return "visrepairedpolysfg";
866 if (fieldnum.
size() < 1)
867 return PARM_UNSUPPORTED;
983 {
for (
int r = 0;
r < 2;
r++)
for (
int c = 0; c < 2; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
985 {
for (
int r = 0;
r < 3;
r++)
for (
int c = 0; c < 3; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
987 {
for (
int r = 0;
r < 4;
r++)
for (
int c = 0; c < 4; c++) is.
bread<
fpreal64>(&v(
r, c), 1); }
1000 loadData(is, rampdata);
1018 int typelen = colon - data.
buffer();
1030 { UTwrite(os, &v); }
1032 {
int64 iv =
v; UTwrite(os, &iv); }
1034 { UTwrite<fpreal64>(os, &
v); }
1036 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
1038 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1039 UTwrite<fpreal64>(os, &v.
z()); }
1041 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1042 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
1054 if (s) s->save(ostr);
1055 result = ostr.
str();
1056 saveData(os, result);
1063 ostr << s->getDataTypeToken();
1065 s->saveBinary(ostr);
1067 result = ostr.
str();
1068 saveData(os, result);
1076 saveData(os, myGroup);
1077 saveData(os, myMaxPasses);
1078 saveData(os, myRandomSeed);
1079 saveData(os, myIllFormedAction);
1080 saveData(os, myManyEdgesAction);
1081 saveData(os, myNonConvexAction);
1082 saveData(os, myOverlappingAction);
1083 saveData(os, myPairOverlaps);
1084 saveData(os, mySelfIntersectingAction);
1085 saveData(os, myThickness);
1086 saveData(os, myGloballySmallAreasAction);
1087 saveData(os, myGlobalAreaThreshold);
1088 saveData(os, myLocallySmallAreasAction);
1089 saveData(os, myLocalAreaThreshold);
1090 saveData(os, myNonUniformAction);
1091 saveData(os, myUniformityThreshold);
1092 saveData(os, myGloballySmallEdgesAction);
1093 saveData(os, myGlobalEdgeThreshold);
1094 saveData(os, myLocallySmallEdgesAction);
1095 saveData(os, myLocalEdgeThreshold);
1096 saveData(os, myDisconnectedPointsAction);
1097 saveData(os, myNonManifoldPointsAction);
1098 saveData(os, myIgnoreWindings);
1099 saveData(os, myPreferLargeAngles);
1100 saveData(os, myVisualizeMaxManifold);
1101 saveData(os, myExportManifoldNumbers);
1102 saveData(os, myFixWindings);
1103 saveData(os, myDeleteSmallManifolds);
1104 saveData(os, mySmallManifoldSize);
1105 saveData(os, myAddValidPolyAttrib);
1106 saveData(os, myValidPolyAttribName);
1107 saveData(os, myAddRepairedPolyAttrib);
1108 saveData(os, myRepairedPolyAttribName);
1109 saveData(os, myAddValidPtsAttrib);
1110 saveData(os, myValidPtsAttribName);
1111 saveData(os, myAddModifiedPtsAttrib);
1112 saveData(os, myModifiedPtsAttribName);
1113 saveData(os, myCreateGroups);
1114 saveData(os, myVisualizeInvalidPts);
1115 saveData(os, myInvalidPtsColor);
1116 saveData(os, myVisualizeRepairedPts);
1117 saveData(os, myRepairedPtsColor);
1118 saveData(os, myVisualizeInvalidPolys);
1119 saveData(os, myInvalidPolysColor);
1120 saveData(os, myVisualizeRepairedPolys);
1121 saveData(os, myRepairedPolysColor);
1134 loadData(is, myGroup);
1135 loadData(is, myMaxPasses);
1136 loadData(is, myRandomSeed);
1137 loadData(is, myIllFormedAction);
1138 loadData(is, myManyEdgesAction);
1139 loadData(is, myNonConvexAction);
1140 loadData(is, myOverlappingAction);
1141 loadData(is, myPairOverlaps);
1142 loadData(is, mySelfIntersectingAction);
1143 loadData(is, myThickness);
1144 loadData(is, myGloballySmallAreasAction);
1145 loadData(is, myGlobalAreaThreshold);
1146 loadData(is, myLocallySmallAreasAction);
1147 loadData(is, myLocalAreaThreshold);
1148 loadData(is, myNonUniformAction);
1149 loadData(is, myUniformityThreshold);
1150 loadData(is, myGloballySmallEdgesAction);
1151 loadData(is, myGlobalEdgeThreshold);
1152 loadData(is, myLocallySmallEdgesAction);
1153 loadData(is, myLocalEdgeThreshold);
1154 loadData(is, myDisconnectedPointsAction);
1155 loadData(is, myNonManifoldPointsAction);
1156 loadData(is, myIgnoreWindings);
1157 loadData(is, myPreferLargeAngles);
1158 loadData(is, myVisualizeMaxManifold);
1159 loadData(is, myExportManifoldNumbers);
1160 loadData(is, myFixWindings);
1161 loadData(is, myDeleteSmallManifolds);
1162 loadData(is, mySmallManifoldSize);
1163 loadData(is, myAddValidPolyAttrib);
1164 loadData(is, myValidPolyAttribName);
1165 loadData(is, myAddRepairedPolyAttrib);
1166 loadData(is, myRepairedPolyAttribName);
1167 loadData(is, myAddValidPtsAttrib);
1168 loadData(is, myValidPtsAttribName);
1169 loadData(is, myAddModifiedPtsAttrib);
1170 loadData(is, myModifiedPtsAttribName);
1171 loadData(is, myCreateGroups);
1172 loadData(is, myVisualizeInvalidPts);
1173 loadData(is, myInvalidPtsColor);
1174 loadData(is, myVisualizeRepairedPts);
1175 loadData(is, myRepairedPtsColor);
1176 loadData(is, myVisualizeInvalidPolys);
1177 loadData(is, myInvalidPolysColor);
1178 loadData(is, myVisualizeRepairedPolys);
1179 loadData(is, myRepairedPolysColor);
1189 if (!thissop)
return getGroup();
1191 OP_Utils::evalOpParm(result, thissop,
"group", cookparms.
getCookTime(), 0);
1199 if (!thissop)
return getMaxPasses();
1201 OP_Utils::evalOpParm(result, thissop,
"maxpasses", cookparms.
getCookTime(), 0);
1209 if (!thissop)
return getRandomSeed();
1211 OP_Utils::evalOpParm(result, thissop,
"randomseed", cookparms.
getCookTime(), 0);
1219 if (!thissop)
return getIllFormedAction();
1221 OP_Utils::evalOpParm(result, thissop,
"illformed", cookparms.
getCookTime(), 0);
1229 if (!thissop)
return getManyEdgesAction();
1231 OP_Utils::evalOpParm(result, thissop,
"manyedges", cookparms.
getCookTime(), 0);
1239 if (!thissop)
return getNonConvexAction();
1241 OP_Utils::evalOpParm(result, thissop,
"nonconvex", cookparms.
getCookTime(), 0);
1249 if (!thissop)
return getOverlappingAction();
1251 OP_Utils::evalOpParm(result, thissop,
"overlapping", cookparms.
getCookTime(), 0);
1259 if (!thissop)
return getPairOverlaps();
1261 OP_Utils::evalOpParm(result, thissop,
"pairoverlaps", cookparms.
getCookTime(), 0);
1269 if (!thissop)
return getSelfIntersectingAction();
1271 OP_Utils::evalOpParm(result, thissop,
"intersect", cookparms.
getCookTime(), 0);
1279 if (!thissop)
return getThickness();
1281 OP_Utils::evalOpParm(result, thissop,
"thickness", cookparms.
getCookTime(), 0);
1289 if (!thissop)
return getGloballySmallAreasAction();
1291 OP_Utils::evalOpParm(result, thissop,
"glosmallarea", cookparms.
getCookTime(), 0);
1299 if (!thissop)
return getGlobalAreaThreshold();
1301 OP_Utils::evalOpParm(result, thissop,
"gloareathres", cookparms.
getCookTime(), 0);
1309 if (!thissop)
return getLocallySmallAreasAction();
1311 OP_Utils::evalOpParm(result, thissop,
"locsmallarea", cookparms.
getCookTime(), 0);
1319 if (!thissop)
return getLocalAreaThreshold();
1321 OP_Utils::evalOpParm(result, thissop,
"locareathres", cookparms.
getCookTime(), 0);
1329 if (!thissop)
return getNonUniformAction();
1331 OP_Utils::evalOpParm(result, thissop,
"nonuni", cookparms.
getCookTime(), 0);
1339 if (!thissop)
return getUniformityThreshold();
1341 OP_Utils::evalOpParm(result, thissop,
"unithres", cookparms.
getCookTime(), 0);
1349 if (!thissop)
return getGloballySmallEdgesAction();
1351 OP_Utils::evalOpParm(result, thissop,
"glosmalledge", cookparms.
getCookTime(), 0);
1359 if (!thissop)
return getGlobalEdgeThreshold();
1361 OP_Utils::evalOpParm(result, thissop,
"gloedgethres", cookparms.
getCookTime(), 0);
1369 if (!thissop)
return getLocallySmallEdgesAction();
1371 OP_Utils::evalOpParm(result, thissop,
"locsmalledge", cookparms.
getCookTime(), 0);
1379 if (!thissop)
return getLocalEdgeThreshold();
1381 OP_Utils::evalOpParm(result, thissop,
"locedgethres", cookparms.
getCookTime(), 0);
1389 if (!thissop)
return getDisconnectedPointsAction();
1391 OP_Utils::evalOpParm(result, thissop,
"disconnectpt", cookparms.
getCookTime(), 0);
1399 if (!thissop)
return getNonManifoldPointsAction();
1401 OP_Utils::evalOpParm(result, thissop,
"nonmanifoldpt", cookparms.
getCookTime(), 0);
1409 if (!thissop)
return getIgnoreWindings();
1411 OP_Utils::evalOpParm(result, thissop,
"ignorewindings", cookparms.
getCookTime(), 0);
1419 if (!thissop)
return getPreferLargeAngles();
1421 OP_Utils::evalOpParm(result, thissop,
"preferlargeangles", cookparms.
getCookTime(), 0);
1429 if (!thissop)
return getVisualizeMaxManifold();
1431 OP_Utils::evalOpParm(result, thissop,
"vismaxmanifold", cookparms.
getCookTime(), 0);
1439 if (!thissop)
return getExportManifoldNumbers();
1441 OP_Utils::evalOpParm(result, thissop,
"exportmanifoldnumbers", cookparms.
getCookTime(), 0);
1449 if (!thissop)
return getFixWindings();
1451 OP_Utils::evalOpParm(result, thissop,
"fixwindings", cookparms.
getCookTime(), 0);
1459 if (!thissop)
return getDeleteSmallManifolds();
1461 OP_Utils::evalOpParm(result, thissop,
"deletesmallmanifolds", cookparms.
getCookTime(), 0);
1469 if (!thissop)
return getSmallManifoldSize();
1471 OP_Utils::evalOpParm(result, thissop,
"smallmanifoldsize", cookparms.
getCookTime(), 0);
1479 if (!thissop)
return getAddValidPolyAttrib();
1481 OP_Utils::evalOpParm(result, thissop,
"usevalidpoly", cookparms.
getCookTime(), 0);
1489 if (!thissop)
return getValidPolyAttribName();
1491 OP_Utils::evalOpParm(result, thissop,
"validpoly", cookparms.
getCookTime(), 0);
1499 if (!thissop)
return getAddRepairedPolyAttrib();
1501 OP_Utils::evalOpParm(result, thissop,
"userepairedpoly", cookparms.
getCookTime(), 0);
1509 if (!thissop)
return getRepairedPolyAttribName();
1511 OP_Utils::evalOpParm(result, thissop,
"repairedpoly", cookparms.
getCookTime(), 0);
1519 if (!thissop)
return getAddValidPtsAttrib();
1521 OP_Utils::evalOpParm(result, thissop,
"usevalidpts", cookparms.
getCookTime(), 0);
1529 if (!thissop)
return getValidPtsAttribName();
1531 OP_Utils::evalOpParm(result, thissop,
"validpts", cookparms.
getCookTime(), 0);
1539 if (!thissop)
return getAddModifiedPtsAttrib();
1541 OP_Utils::evalOpParm(result, thissop,
"usemodifiedpts", cookparms.
getCookTime(), 0);
1549 if (!thissop)
return getModifiedPtsAttribName();
1551 OP_Utils::evalOpParm(result, thissop,
"modifiedpts", cookparms.
getCookTime(), 0);
1559 if (!thissop)
return getCreateGroups();
1561 OP_Utils::evalOpParm(result, thissop,
"creategrps", cookparms.
getCookTime(), 0);
1569 if (!thissop)
return getVisualizeInvalidPts();
1571 OP_Utils::evalOpParm(result, thissop,
"visinvalidpts", cookparms.
getCookTime(), 0);
1579 if (!thissop)
return getInvalidPtsColor();
1581 OP_Utils::evalOpParm(result, thissop,
"visinvalidptsfg", cookparms.
getCookTime(), 0);
1589 if (!thissop)
return getVisualizeRepairedPts();
1591 OP_Utils::evalOpParm(result, thissop,
"visrepairedpts", cookparms.
getCookTime(), 0);
1599 if (!thissop)
return getRepairedPtsColor();
1601 OP_Utils::evalOpParm(result, thissop,
"visrepairedptsfg", cookparms.
getCookTime(), 0);
1609 if (!thissop)
return getVisualizeInvalidPolys();
1611 OP_Utils::evalOpParm(result, thissop,
"visinvalidpolys", cookparms.
getCookTime(), 0);
1619 if (!thissop)
return getInvalidPolysColor();
1621 OP_Utils::evalOpParm(result, thissop,
"visinvalidpolysfg", cookparms.
getCookTime(), 0);
1629 if (!thissop)
return getVisualizeRepairedPolys();
1631 OP_Utils::evalOpParm(result, thissop,
"visrepairedpolys", cookparms.
getCookTime(), 0);
1639 if (!thissop)
return getRepairedPolysColor();
1641 OP_Utils::evalOpParm(result, thissop,
"visrepairedpolysfg", cookparms.
getCookTime(), 0);
1649 int64 myIllFormedAction;
1650 int64 myManyEdgesAction;
1651 int64 myNonConvexAction;
1652 int64 myOverlappingAction;
1653 bool myPairOverlaps;
1654 int64 mySelfIntersectingAction;
1656 int64 myGloballySmallAreasAction;
1658 int64 myLocallySmallAreasAction;
1660 int64 myNonUniformAction;
1662 int64 myGloballySmallEdgesAction;
1664 int64 myLocallySmallEdgesAction;
1666 int64 myDisconnectedPointsAction;
1667 int64 myNonManifoldPointsAction;
1668 bool myIgnoreWindings;
1669 bool myPreferLargeAngles;
1670 bool myVisualizeMaxManifold;
1671 bool myExportManifoldNumbers;
1673 bool myDeleteSmallManifolds;
1674 int64 mySmallManifoldSize;
1675 bool myAddValidPolyAttrib;
1677 bool myAddRepairedPolyAttrib;
1679 bool myAddValidPtsAttrib;
1681 bool myAddModifiedPtsAttrib;
1683 bool myCreateGroups;
1684 bool myVisualizeInvalidPts;
1686 bool myVisualizeRepairedPts;
1688 bool myVisualizeInvalidPolys;
1690 bool myVisualizeRepairedPolys;
bool getVisualizeInvalidPts() const
UT_StringHolder opModifiedPtsAttribName(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 getLocalEdgeThreshold() const
const UT_StringHolder & getValidPolyAttribName() const
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
void setRepairedPtsColor(UT_Vector3D val)
const UT_StringHolder & getModifiedPtsAttribName() const
GloballySmallEdgesAction opGloballySmallEdgesAction(const SOP_NodeVerb::CookParms &cookparms) const
ManyEdgesAction opManyEdgesAction(const SOP_NodeVerb::CookParms &cookparms) const
NonUniformAction opNonUniformAction(const SOP_NodeVerb::CookParms &cookparms) const
void setGlobalAreaThreshold(fpreal64 val)
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
SOP_Node * getNode() const
fpreal64 getGlobalEdgeThreshold() const
bool opVisualizeRepairedPts(const SOP_NodeVerb::CookParms &cookparms) const
bool load(UT_IStream &is)
SelfIntersectingAction opSelfIntersectingAction(const SOP_NodeVerb::CookParms &cookparms) const
bool isParmColorRamp(exint idx) const override
void setFixWindings(bool val)
T clampMaxValue(fpreal maxvalue, const T &src) const
static void loadData(UT_IStream &is, UT_Vector3D &v)
LocallySmallAreasAction getLocallySmallAreasAction() const
const char * getNestParmName(TempIndex fieldnum) const override
int64 opRandomSeed(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix2D v)
fpreal64 opUniformityThreshold(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
fpreal64 opLocalEdgeThreshold(const SOP_NodeVerb::CookParms &cookparms) const
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
constexpr SYS_FORCE_INLINE T & y() noexcept
bool opVisualizeRepairedPolys(const SOP_NodeVerb::CookParms &cookparms) const
void setVisualizeMaxManifold(bool val)
bool opCreateGroups(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
LocallySmallAreasAction opLocallySmallAreasAction(const SOP_NodeVerb::CookParms &cookparms) const
int64 opMaxPasses(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
void setAddRepairedPolyAttrib(bool val)
void setManyEdgesAction(ManyEdgesAction val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
static void loadData(UT_IStream &is, int64 &v)
const UT_StringHolder & getValidPtsAttribName() const
void setInvalidPtsColor(UT_Vector3D val)
const OP_Context & context() const
static void saveData(std::ostream &os, fpreal64 v)
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
void setSmallManifoldSize(int64 val)
constexpr SYS_FORCE_INLINE T & z() noexcept
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setGlobalEdgeThreshold(fpreal64 val)
SYS_FORCE_INLINE const char * buffer() const
DisconnectedPointsAction opDisconnectedPointsAction(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, bool v)
bool opIgnoreWindings(const SOP_NodeVerb::CookParms &cookparms) const
void setThickness(fpreal64 val)
An output stream object that owns its own string buffer storage.
fpreal64 getGlobalAreaThreshold() const
static void loadData(UT_IStream &is, UT_StringHolder &v)
void setMaxPasses(int64 val)
**But if you need a result
void copyFrom(const OP_NodeParms *src) override
static void loadData(UT_IStream &is, fpreal64 &v)
T clampMinValue(fpreal minvalue, const T &src) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
void setCreateGroups(bool val)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
bool getAddValidPtsAttrib() const
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
void setGloballySmallAreasAction(GloballySmallAreasAction val)
bool getVisualizeRepairedPolys() const
GloballySmallAreasAction opGloballySmallAreasAction(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, int64 v)
bool opVisualizeInvalidPts(const SOP_NodeVerb::CookParms &cookparms) const
void setExportManifoldNumbers(bool val)
NonManifoldPointsAction opNonManifoldPointsAction(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & x() noexcept
const UT_StringHolder & getRepairedPolyAttribName() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
void setDeleteSmallManifolds(bool val)
void setVisualizeRepairedPolys(bool val)
void setNonConvexAction(NonConvexAction val)
fpreal64 opGlobalAreaThreshold(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getInvalidPtsColor() const
bool opAddModifiedPtsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & x() noexcept
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
static void loadData(UT_IStream &is, UT_Vector2I &v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
UT_Vector3D getRepairedPolysColor() const
bool opPreferLargeAngles(const SOP_NodeVerb::CookParms &cookparms) const
bool getCreateGroups() const
void setNonManifoldPointsAction(NonManifoldPointsAction val)
bool getExportManifoldNumbers() const
bool opExportManifoldNumbers(const SOP_NodeVerb::CookParms &cookparms) const
bool getAddValidPolyAttrib() const
NonUniformAction getNonUniformAction() const
ParmType getNestParmType(TempIndex fieldnum) const override
bool opDeleteSmallManifolds(const SOP_NodeVerb::CookParms &cookparms) const
void setPreferLargeAngles(bool val)
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
constexpr SYS_FORCE_INLINE T & z() noexcept
const OP_GraphProxy * graph() const
void setDisconnectedPointsAction(DisconnectedPointsAction val)
NonManifoldPointsAction getNonManifoldPointsAction() const
void setVisualizeInvalidPolys(bool val)
fpreal64 opGlobalEdgeThreshold(const SOP_NodeVerb::CookParms &cookparms) const
void setUniformityThreshold(fpreal64 val)
static void loadData(UT_IStream &is, UT_Vector4D &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
static void saveData(std::ostream &os, UT_Matrix3D v)
void loadFromOpSubclass(const LoadParms &loadparms) override
NonConvexAction opNonConvexAction(const SOP_NodeVerb::CookParms &cookparms) const
void setValidPolyAttribName(const UT_StringHolder &val)
OverlappingAction opOverlappingAction(const SOP_NodeVerb::CookParms &cookparms) const
bool getVisualizeInvalidPolys() const
fpreal64 getLocalAreaThreshold() const
static void loadData(UT_IStream &is, UT_Vector3I &v)
const UT_StringHolder & getGroup() const
UT_Vector3T< fpreal64 > UT_Vector3D
void setVisualizeRepairedPts(bool val)
void setOverlappingAction(OverlappingAction val)
fpreal64 getThickness() const
bool operator!=(const SOP_PolyDoctorParms &src) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
void setModifiedPtsAttribName(const UT_StringHolder &val)
bool getAddModifiedPtsAttrib() const
bool getVisualizeMaxManifold() const
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
int64 opSmallManifoldSize(const SOP_NodeVerb::CookParms &cookparms) const
IllFormedAction getIllFormedAction() const
void save(std::ostream &os) const
void setAddValidPolyAttrib(bool val)
bool getPreferLargeAngles() const
void setLocallySmallEdgesAction(LocallySmallEdgesAction val)
void saveBinary(std::ostream &os) const
Save string to binary stream.
IllFormedAction opIllFormedAction(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D getRepairedPtsColor() const
void setLocalAreaThreshold(fpreal64 val)
GT_API const UT_StringHolder version
void setLocallySmallAreasAction(LocallySmallAreasAction val)
bool getPairOverlaps() const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
int64 getMaxPasses() const
static void saveData(std::ostream &os, UT_StringHolder s)
void setAddModifiedPtsAttrib(bool val)
bool opFixWindings(const SOP_NodeVerb::CookParms &cookparms) const
void setVisualizeInvalidPts(bool val)
void setSelfIntersectingAction(SelfIntersectingAction val)
UT_Vector3D getInvalidPolysColor() const
void setGloballySmallEdgesAction(GloballySmallEdgesAction val)
void coerceValue(T &result, const S &src) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
bool getDeleteSmallManifolds() const
static void saveData(std::ostream &os, UT_Vector2D v)
GloballySmallAreasAction getGloballySmallAreasAction() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void setRepairedPolyAttribName(const UT_StringHolder &val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
fpreal64 opLocalAreaThreshold(const SOP_NodeVerb::CookParms &cookparms) const
int64 getRandomSeed() const
DEP_MicroNode * depnode() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
bool getIgnoreWindings() const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
Utility class for containing a color ramp.
void setIllFormedAction(IllFormedAction val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
static void loadData(UT_IStream &is, UT_Matrix4D &v)
constexpr SYS_FORCE_INLINE T & w() noexcept
int64 getSmallManifoldSize() const
void setValidPtsAttribName(const UT_StringHolder &val)
static void saveData(std::ostream &os, UT_Vector3D v)
bool getAddRepairedPolyAttrib() const
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
void setNonUniformAction(NonUniformAction val)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
UT_Vector3D opRepairedPolysColor(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector3D opInvalidPtsColor(const SOP_NodeVerb::CookParms &cookparms) const
NonConvexAction getNonConvexAction() const
fpreal64 getUniformityThreshold() const
bool getFixWindings() const
void setInvalidPolysColor(UT_Vector3D val)
fpreal getCookTime() const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
bool opPairOverlaps(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector4D v)
bool opVisualizeInvalidPolys(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opValidPtsAttribName(const SOP_NodeVerb::CookParms &cookparms) const
void setPairOverlaps(bool val)
static void loadData(UT_IStream &is, bool &v)
bool operator==(const SOP_PolyDoctorParms &src) const
const char * findChar(int c) const
GloballySmallEdgesAction getGloballySmallEdgesAction() const
void setIgnoreWindings(bool val)
bool opVisualizeMaxManifold(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
LocallySmallEdgesAction opLocallySmallEdgesAction(const SOP_NodeVerb::CookParms &cookparms) const
ManyEdgesAction getManyEdgesAction() const
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
DisconnectedPointsAction getDisconnectedPointsAction() const
UT_Vector3D opInvalidPolysColor(const SOP_NodeVerb::CookParms &cookparms) const
LocallySmallEdgesAction getLocallySmallEdgesAction() const
constexpr SYS_FORCE_INLINE T & y() noexcept
bool getVisualizeRepairedPts() const
fpreal64 opThickness(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix4D v)
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
UT_Vector3D opRepairedPtsColor(const SOP_NodeVerb::CookParms &cookparms) const
void setAddValidPtsAttrib(bool val)
OverlappingAction getOverlappingAction() const
void setRandomSeed(int64 val)
void setRepairedPolysColor(UT_Vector3D val)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
UT_StringHolder opRepairedPolyAttribName(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opValidPolyAttribName(const SOP_NodeVerb::CookParms &cookparms) const
SelfIntersectingAction getSelfIntersectingAction() const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
exint getNestNumParms(TempIndex idx) const override
void setGroup(const UT_StringHolder &val)
constexpr SYS_FORCE_INLINE T & y() noexcept
bool opAddRepairedPolyAttrib(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
OP_NodeParms & operator=(const OP_NodeParms &)=default
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
bool opAddValidPtsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setLocalEdgeThreshold(fpreal64 val)
constexpr SYS_FORCE_INLINE T & x() noexcept
bool opAddValidPolyAttrib(const SOP_NodeVerb::CookParms &cookparms) const