20 using namespace UT::Literal;
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"_sh;
138 myAddRepairedPolyAttrib =
true;
139 myRepairedPolyAttribName =
"repaired_poly"_sh;
140 myAddValidPtsAttrib =
true;
141 myValidPtsAttribName =
"valid_pt"_sh;
142 myAddModifiedPtsAttrib =
true;
143 myModifiedPtsAttribName =
"modified_pt"_sh;
144 myCreateGroups =
false;
145 myVisualizeInvalidPts =
false;
147 myVisualizeRepairedPts =
false;
149 myVisualizeInvalidPolys =
false;
151 myVisualizeRepairedPolys =
false;
162 if (myGroup != src.myGroup)
return false;
163 if (myMaxPasses != src.myMaxPasses)
return false;
164 if (myRandomSeed != src.myRandomSeed)
return false;
165 if (myIllFormedAction != src.myIllFormedAction)
return false;
166 if (myManyEdgesAction != src.myManyEdgesAction)
return false;
167 if (myNonConvexAction != src.myNonConvexAction)
return false;
168 if (myOverlappingAction != src.myOverlappingAction)
return false;
169 if (myPairOverlaps != src.myPairOverlaps)
return false;
170 if (mySelfIntersectingAction != src.mySelfIntersectingAction)
return false;
171 if (myThickness != src.myThickness)
return false;
172 if (myGloballySmallAreasAction != src.myGloballySmallAreasAction)
return false;
173 if (myGlobalAreaThreshold != src.myGlobalAreaThreshold)
return false;
174 if (myLocallySmallAreasAction != src.myLocallySmallAreasAction)
return false;
175 if (myLocalAreaThreshold != src.myLocalAreaThreshold)
return false;
176 if (myNonUniformAction != src.myNonUniformAction)
return false;
177 if (myUniformityThreshold != src.myUniformityThreshold)
return false;
178 if (myGloballySmallEdgesAction != src.myGloballySmallEdgesAction)
return false;
179 if (myGlobalEdgeThreshold != src.myGlobalEdgeThreshold)
return false;
180 if (myLocallySmallEdgesAction != src.myLocallySmallEdgesAction)
return false;
181 if (myLocalEdgeThreshold != src.myLocalEdgeThreshold)
return false;
182 if (myDisconnectedPointsAction != src.myDisconnectedPointsAction)
return false;
183 if (myNonManifoldPointsAction != src.myNonManifoldPointsAction)
return false;
184 if (myIgnoreWindings != src.myIgnoreWindings)
return false;
185 if (myPreferLargeAngles != src.myPreferLargeAngles)
return false;
186 if (myVisualizeMaxManifold != src.myVisualizeMaxManifold)
return false;
187 if (myExportManifoldNumbers != src.myExportManifoldNumbers)
return false;
188 if (myFixWindings != src.myFixWindings)
return false;
189 if (myDeleteSmallManifolds != src.myDeleteSmallManifolds)
return false;
190 if (mySmallManifoldSize != src.mySmallManifoldSize)
return false;
191 if (myAddValidPolyAttrib != src.myAddValidPolyAttrib)
return false;
192 if (myValidPolyAttribName != src.myValidPolyAttribName)
return false;
193 if (myAddRepairedPolyAttrib != src.myAddRepairedPolyAttrib)
return false;
194 if (myRepairedPolyAttribName != src.myRepairedPolyAttribName)
return false;
195 if (myAddValidPtsAttrib != src.myAddValidPtsAttrib)
return false;
196 if (myValidPtsAttribName != src.myValidPtsAttribName)
return false;
197 if (myAddModifiedPtsAttrib != src.myAddModifiedPtsAttrib)
return false;
198 if (myModifiedPtsAttribName != src.myModifiedPtsAttribName)
return false;
199 if (myCreateGroups != src.myCreateGroups)
return false;
200 if (myVisualizeInvalidPts != src.myVisualizeInvalidPts)
return false;
201 if (myInvalidPtsColor != src.myInvalidPtsColor)
return false;
202 if (myVisualizeRepairedPts != src.myVisualizeRepairedPts)
return false;
203 if (myRepairedPtsColor != src.myRepairedPtsColor)
return false;
204 if (myVisualizeInvalidPolys != src.myVisualizeInvalidPolys)
return false;
205 if (myInvalidPolysColor != src.myInvalidPolysColor)
return false;
206 if (myVisualizeRepairedPolys != src.myVisualizeRepairedPolys)
return false;
207 if (myRepairedPolysColor != src.myRepairedPolysColor)
return false;
234 graph->
evalOpParm(myGroup, nodeidx,
"group", time, 0);
237 graph->
evalOpParm(myMaxPasses, nodeidx,
"maxpasses", time, 0);
240 graph->
evalOpParm(myRandomSeed, nodeidx,
"randomseed", time, 0);
241 myIllFormedAction = 2;
243 graph->
evalOpParm(myIllFormedAction, nodeidx,
"illformed", time, 0);
244 myManyEdgesAction = 2;
245 if (
true && ( (!(((
int64(getIllFormedAction())==0)))) ) )
246 graph->
evalOpParm(myManyEdgesAction, nodeidx,
"manyedges", time, 0);
247 myNonConvexAction = 2;
248 if (
true && ( (!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0)))) ) )
249 graph->
evalOpParm(myNonConvexAction, nodeidx,
"nonconvex", time, 0);
250 myOverlappingAction = 2;
251 if (
true && ( (!(((
int64(getIllFormedAction())==0)))) ) )
252 graph->
evalOpParm(myOverlappingAction, nodeidx,
"overlapping", time, 0);
253 myPairOverlaps =
false;
254 if (
true && ( (!(((
int64(getIllFormedAction())==0))||((
int64(getOverlappingAction())==0)))) ) )
255 graph->
evalOpParm(myPairOverlaps, nodeidx,
"pairoverlaps", time, 0);
256 mySelfIntersectingAction = 1;
257 if (
true && ( (!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
258 graph->
evalOpParm(mySelfIntersectingAction, nodeidx,
"intersect", time, 0);
259 myThickness = 0.0001;
260 if (
true && ( (!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
261 graph->
evalOpParm(myThickness, nodeidx,
"thickness", time, 0);
262 myGloballySmallAreasAction = 0;
263 if (
true && ( (!(((
int64(getIllFormedAction())==0)))) ) )
264 graph->
evalOpParm(myGloballySmallAreasAction, nodeidx,
"glosmallarea", time, 0);
265 myGlobalAreaThreshold = 1e-06;
266 if (
true && ( (!(((
int64(getIllFormedAction())==0)))) ) )
267 graph->
evalOpParm(myGlobalAreaThreshold, nodeidx,
"gloareathres", time, 0);
268 myLocallySmallAreasAction = 0;
269 if (
true && ( (!(((
int64(getIllFormedAction())==0)))) ) )
270 graph->
evalOpParm(myLocallySmallAreasAction, nodeidx,
"locsmallarea", time, 0);
271 myLocalAreaThreshold = 0.01;
272 if (
true && ( (!(((
int64(getIllFormedAction())==0)))) ) )
273 graph->
evalOpParm(myLocalAreaThreshold, nodeidx,
"locareathres", time, 0);
274 myNonUniformAction = 0;
275 if (
true && ( (!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
276 graph->
evalOpParm(myNonUniformAction, nodeidx,
"nonuni", time, 0);
277 myUniformityThreshold = 0.01;
278 if (
true && ( (!(((
int64(getIllFormedAction())==0))||((
int64(getManyEdgesAction())==0))||((
int64(getNonConvexAction())==0)))) ) )
279 graph->
evalOpParm(myUniformityThreshold, nodeidx,
"unithres", time, 0);
280 myGloballySmallEdgesAction = 0;
282 graph->
evalOpParm(myGloballySmallEdgesAction, nodeidx,
"glosmalledge", time, 0);
283 myGlobalEdgeThreshold = 0.001;
285 graph->
evalOpParm(myGlobalEdgeThreshold, nodeidx,
"gloedgethres", time, 0);
286 myLocallySmallEdgesAction = 0;
288 graph->
evalOpParm(myLocallySmallEdgesAction, nodeidx,
"locsmalledge", time, 0);
289 myLocalEdgeThreshold = 0.3;
291 graph->
evalOpParm(myLocalEdgeThreshold, nodeidx,
"locedgethres", time, 0);
292 myDisconnectedPointsAction = 0;
294 graph->
evalOpParm(myDisconnectedPointsAction, nodeidx,
"disconnectpt", time, 0);
295 myNonManifoldPointsAction = 0;
297 graph->
evalOpParm(myNonManifoldPointsAction, nodeidx,
"nonmanifoldpt", time, 0);
298 myIgnoreWindings =
true;
300 graph->
evalOpParm(myIgnoreWindings, nodeidx,
"ignorewindings", time, 0);
301 myPreferLargeAngles =
false;
302 if (
true && ( (!(((
int64(getNonManifoldPointsAction())!=2)))) ) )
303 graph->
evalOpParm(myPreferLargeAngles, nodeidx,
"preferlargeangles", time, 0);
304 myVisualizeMaxManifold =
false;
306 graph->
evalOpParm(myVisualizeMaxManifold, nodeidx,
"vismaxmanifold", time, 0);
307 myExportManifoldNumbers =
false;
309 graph->
evalOpParm(myExportManifoldNumbers, nodeidx,
"exportmanifoldnumbers", time, 0);
310 myFixWindings =
false;
312 graph->
evalOpParm(myFixWindings, nodeidx,
"fixwindings", time, 0);
313 myDeleteSmallManifolds =
false;
315 graph->
evalOpParm(myDeleteSmallManifolds, nodeidx,
"deletesmallmanifolds", time, 0);
316 mySmallManifoldSize = 0;
317 if (
true && ( (!(((getDeleteSmallManifolds()==0)))) ) )
318 graph->
evalOpParm(mySmallManifoldSize, nodeidx,
"smallmanifoldsize", time, 0);
319 myAddValidPolyAttrib =
true;
321 graph->
evalOpParm(myAddValidPolyAttrib, nodeidx,
"usevalidpoly", time, 0);
322 myValidPolyAttribName =
"valid_poly"_sh;
324 graph->
evalOpParm(myValidPolyAttribName, nodeidx,
"validpoly", time, 0);
325 myAddRepairedPolyAttrib =
true;
327 graph->
evalOpParm(myAddRepairedPolyAttrib, nodeidx,
"userepairedpoly", time, 0);
328 myRepairedPolyAttribName =
"repaired_poly"_sh;
330 graph->
evalOpParm(myRepairedPolyAttribName, nodeidx,
"repairedpoly", time, 0);
331 myAddValidPtsAttrib =
true;
333 graph->
evalOpParm(myAddValidPtsAttrib, nodeidx,
"usevalidpts", time, 0);
334 myValidPtsAttribName =
"valid_pt"_sh;
336 graph->
evalOpParm(myValidPtsAttribName, nodeidx,
"validpts", time, 0);
337 myAddModifiedPtsAttrib =
true;
339 graph->
evalOpParm(myAddModifiedPtsAttrib, nodeidx,
"usemodifiedpts", time, 0);
340 myModifiedPtsAttribName =
"modified_pt"_sh;
342 graph->
evalOpParm(myModifiedPtsAttribName, nodeidx,
"modifiedpts", time, 0);
343 myCreateGroups =
false;
345 graph->
evalOpParm(myCreateGroups, nodeidx,
"creategrps", time, 0);
346 myVisualizeInvalidPts =
false;
348 graph->
evalOpParm(myVisualizeInvalidPts, nodeidx,
"visinvalidpts", time, 0);
350 if (
true && ( (!(((getVisualizeInvalidPts()==0)))) ) )
351 graph->
evalOpParm(myInvalidPtsColor, nodeidx,
"visinvalidptsfg", time, 0);
352 myVisualizeRepairedPts =
false;
354 graph->
evalOpParm(myVisualizeRepairedPts, nodeidx,
"visrepairedpts", time, 0);
356 if (
true && ( (!(((getVisualizeRepairedPts()==0)))) ) )
357 graph->
evalOpParm(myRepairedPtsColor, nodeidx,
"visrepairedptsfg", time, 0);
358 myVisualizeInvalidPolys =
false;
360 graph->
evalOpParm(myVisualizeInvalidPolys, nodeidx,
"visinvalidpolys", time, 0);
362 if (
true && ( (!(((getVisualizeInvalidPolys()==0)))) ) )
363 graph->
evalOpParm(myInvalidPolysColor, nodeidx,
"visinvalidpolysfg", time, 0);
364 myVisualizeRepairedPolys =
false;
366 graph->
evalOpParm(myVisualizeRepairedPolys, nodeidx,
"visrepairedpolys", time, 0);
368 if (
true && ( (!(((getVisualizeRepairedPolys()==0)))) ) )
369 graph->
evalOpParm(myRepairedPolysColor, nodeidx,
"visrepairedpolysfg", time, 0);
385 template <
typename T>
392 if (idx.
size() != instance.
size()+1)
397 coerceValue(value, myGroup);
400 coerceValue(value, myMaxPasses);
403 coerceValue(value, myRandomSeed);
406 coerceValue(value, myIllFormedAction);
409 coerceValue(value, myManyEdgesAction);
412 coerceValue(value, myNonConvexAction);
415 coerceValue(value, myOverlappingAction);
418 coerceValue(value, myPairOverlaps);
421 coerceValue(value, mySelfIntersectingAction);
424 coerceValue(value, myThickness);
427 coerceValue(value, myGloballySmallAreasAction);
430 coerceValue(value, myGlobalAreaThreshold);
433 coerceValue(value, myLocallySmallAreasAction);
436 coerceValue(value, myLocalAreaThreshold);
439 coerceValue(value, myNonUniformAction);
442 coerceValue(value, myUniformityThreshold);
445 coerceValue(value, myGloballySmallEdgesAction);
448 coerceValue(value, myGlobalEdgeThreshold);
451 coerceValue(value, myLocallySmallEdgesAction);
454 coerceValue(value, myLocalEdgeThreshold);
457 coerceValue(value, myDisconnectedPointsAction);
460 coerceValue(value, myNonManifoldPointsAction);
463 coerceValue(value, myIgnoreWindings);
466 coerceValue(value, myPreferLargeAngles);
469 coerceValue(value, myVisualizeMaxManifold);
472 coerceValue(value, myExportManifoldNumbers);
475 coerceValue(value, myFixWindings);
478 coerceValue(value, myDeleteSmallManifolds);
481 coerceValue(value, mySmallManifoldSize);
484 coerceValue(value, myAddValidPolyAttrib);
487 coerceValue(value, myValidPolyAttribName);
490 coerceValue(value, myAddRepairedPolyAttrib);
493 coerceValue(value, myRepairedPolyAttribName);
496 coerceValue(value, myAddValidPtsAttrib);
499 coerceValue(value, myValidPtsAttribName);
502 coerceValue(value, myAddModifiedPtsAttrib);
505 coerceValue(value, myModifiedPtsAttribName);
508 coerceValue(value, myCreateGroups);
511 coerceValue(value, myVisualizeInvalidPts);
514 coerceValue(value, myInvalidPtsColor);
517 coerceValue(value, myVisualizeRepairedPts);
520 coerceValue(value, myRepairedPtsColor);
523 coerceValue(value, myVisualizeInvalidPolys);
526 coerceValue(value, myInvalidPolysColor);
529 coerceValue(value, myVisualizeRepairedPolys);
532 coerceValue(value, myRepairedPolysColor);
539 { doGetParmValue(idx, instance, value); }
541 { doGetParmValue(idx, instance, value); }
543 { doGetParmValue(idx, instance, value); }
545 { doGetParmValue(idx, instance, value); }
547 { doGetParmValue(idx, instance, value); }
549 { doGetParmValue(idx, instance, value); }
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 template <
typename T>
568 if (idx.
size() != instance.
size()+1)
573 coerceValue(myGroup, value);
576 coerceValue(myMaxPasses, value);
579 coerceValue(myRandomSeed, value);
582 coerceValue(myIllFormedAction, value);
585 coerceValue(myManyEdgesAction, value);
588 coerceValue(myNonConvexAction, value);
591 coerceValue(myOverlappingAction, value);
594 coerceValue(myPairOverlaps, value);
597 coerceValue(mySelfIntersectingAction, value);
600 coerceValue(myThickness, value);
603 coerceValue(myGloballySmallAreasAction, value);
606 coerceValue(myGlobalAreaThreshold, value);
609 coerceValue(myLocallySmallAreasAction, value);
612 coerceValue(myLocalAreaThreshold, value);
615 coerceValue(myNonUniformAction, value);
618 coerceValue(myUniformityThreshold, value);
621 coerceValue(myGloballySmallEdgesAction, value);
624 coerceValue(myGlobalEdgeThreshold, value);
627 coerceValue(myLocallySmallEdgesAction, value);
630 coerceValue(myLocalEdgeThreshold, value);
633 coerceValue(myDisconnectedPointsAction, value);
636 coerceValue(myNonManifoldPointsAction, value);
639 coerceValue(myIgnoreWindings, value);
642 coerceValue(myPreferLargeAngles, value);
645 coerceValue(myVisualizeMaxManifold, value);
648 coerceValue(myExportManifoldNumbers, value);
651 coerceValue(myFixWindings, value);
654 coerceValue(myDeleteSmallManifolds, value);
657 coerceValue(mySmallManifoldSize, value);
660 coerceValue(myAddValidPolyAttrib, value);
663 coerceValue(myValidPolyAttribName, value);
666 coerceValue(myAddRepairedPolyAttrib, value);
669 coerceValue(myRepairedPolyAttribName, value);
672 coerceValue(myAddValidPtsAttrib, value);
675 coerceValue(myValidPtsAttribName, value);
678 coerceValue(myAddModifiedPtsAttrib, value);
681 coerceValue(myModifiedPtsAttribName, value);
684 coerceValue(myCreateGroups, value);
687 coerceValue(myVisualizeInvalidPts, value);
690 coerceValue(myInvalidPtsColor, value);
693 coerceValue(myVisualizeRepairedPts, value);
696 coerceValue(myRepairedPtsColor, value);
699 coerceValue(myVisualizeInvalidPolys, value);
702 coerceValue(myInvalidPolysColor, value);
705 coerceValue(myVisualizeRepairedPolys, value);
708 coerceValue(myRepairedPolysColor, value);
715 { doSetParmValue(idx, instance, value); }
717 { doSetParmValue(idx, instance, value); }
719 { doSetParmValue(idx, instance, value); }
721 { doSetParmValue(idx, instance, value); }
723 { doSetParmValue(idx, instance, value); }
725 { doSetParmValue(idx, instance, 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); }
751 if (fieldnum.
size() < 1)
768 return "overlapping";
770 return "pairoverlaps";
776 return "glosmallarea";
778 return "gloareathres";
780 return "locsmallarea";
782 return "locareathres";
788 return "glosmalledge";
790 return "gloedgethres";
792 return "locsmalledge";
794 return "locedgethres";
796 return "disconnectpt";
798 return "nonmanifoldpt";
800 return "ignorewindings";
802 return "preferlargeangles";
804 return "vismaxmanifold";
806 return "exportmanifoldnumbers";
808 return "fixwindings";
810 return "deletesmallmanifolds";
812 return "smallmanifoldsize";
814 return "usevalidpoly";
818 return "userepairedpoly";
820 return "repairedpoly";
822 return "usevalidpts";
826 return "usemodifiedpts";
828 return "modifiedpts";
832 return "visinvalidpts";
834 return "visinvalidptsfg";
836 return "visrepairedpts";
838 return "visrepairedptsfg";
840 return "visinvalidpolys";
842 return "visinvalidpolysfg";
844 return "visrepairedpolys";
846 return "visrepairedpolysfg";
854 if (fieldnum.
size() < 1)
855 return PARM_UNSUPPORTED;
952 return PARM_UNSUPPORTED;
988 loadData(is, rampdata);
1006 int typelen = colon - data.
buffer();
1018 { UTwrite(os, &v); }
1020 {
int64 iv =
v; UTwrite(os, &iv); }
1022 { UTwrite<fpreal64>(os, &
v); }
1024 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
1026 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1027 UTwrite<fpreal64>(os, &v.
z()); }
1029 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
1030 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
1042 if (s) s->save(ostr);
1043 result = ostr.
str();
1044 saveData(os, result);
1051 ostr << s->getDataTypeToken();
1053 s->saveBinary(ostr);
1055 result = ostr.
str();
1056 saveData(os, result);
1064 saveData(os, myGroup);
1065 saveData(os, myMaxPasses);
1066 saveData(os, myRandomSeed);
1067 saveData(os, myIllFormedAction);
1068 saveData(os, myManyEdgesAction);
1069 saveData(os, myNonConvexAction);
1070 saveData(os, myOverlappingAction);
1071 saveData(os, myPairOverlaps);
1072 saveData(os, mySelfIntersectingAction);
1073 saveData(os, myThickness);
1074 saveData(os, myGloballySmallAreasAction);
1075 saveData(os, myGlobalAreaThreshold);
1076 saveData(os, myLocallySmallAreasAction);
1077 saveData(os, myLocalAreaThreshold);
1078 saveData(os, myNonUniformAction);
1079 saveData(os, myUniformityThreshold);
1080 saveData(os, myGloballySmallEdgesAction);
1081 saveData(os, myGlobalEdgeThreshold);
1082 saveData(os, myLocallySmallEdgesAction);
1083 saveData(os, myLocalEdgeThreshold);
1084 saveData(os, myDisconnectedPointsAction);
1085 saveData(os, myNonManifoldPointsAction);
1086 saveData(os, myIgnoreWindings);
1087 saveData(os, myPreferLargeAngles);
1088 saveData(os, myVisualizeMaxManifold);
1089 saveData(os, myExportManifoldNumbers);
1090 saveData(os, myFixWindings);
1091 saveData(os, myDeleteSmallManifolds);
1092 saveData(os, mySmallManifoldSize);
1093 saveData(os, myAddValidPolyAttrib);
1094 saveData(os, myValidPolyAttribName);
1095 saveData(os, myAddRepairedPolyAttrib);
1096 saveData(os, myRepairedPolyAttribName);
1097 saveData(os, myAddValidPtsAttrib);
1098 saveData(os, myValidPtsAttribName);
1099 saveData(os, myAddModifiedPtsAttrib);
1100 saveData(os, myModifiedPtsAttribName);
1101 saveData(os, myCreateGroups);
1102 saveData(os, myVisualizeInvalidPts);
1103 saveData(os, myInvalidPtsColor);
1104 saveData(os, myVisualizeRepairedPts);
1105 saveData(os, myRepairedPtsColor);
1106 saveData(os, myVisualizeInvalidPolys);
1107 saveData(os, myInvalidPolysColor);
1108 saveData(os, myVisualizeRepairedPolys);
1109 saveData(os, myRepairedPolysColor);
1122 loadData(is, myGroup);
1123 loadData(is, myMaxPasses);
1124 loadData(is, myRandomSeed);
1125 loadData(is, myIllFormedAction);
1126 loadData(is, myManyEdgesAction);
1127 loadData(is, myNonConvexAction);
1128 loadData(is, myOverlappingAction);
1129 loadData(is, myPairOverlaps);
1130 loadData(is, mySelfIntersectingAction);
1131 loadData(is, myThickness);
1132 loadData(is, myGloballySmallAreasAction);
1133 loadData(is, myGlobalAreaThreshold);
1134 loadData(is, myLocallySmallAreasAction);
1135 loadData(is, myLocalAreaThreshold);
1136 loadData(is, myNonUniformAction);
1137 loadData(is, myUniformityThreshold);
1138 loadData(is, myGloballySmallEdgesAction);
1139 loadData(is, myGlobalEdgeThreshold);
1140 loadData(is, myLocallySmallEdgesAction);
1141 loadData(is, myLocalEdgeThreshold);
1142 loadData(is, myDisconnectedPointsAction);
1143 loadData(is, myNonManifoldPointsAction);
1144 loadData(is, myIgnoreWindings);
1145 loadData(is, myPreferLargeAngles);
1146 loadData(is, myVisualizeMaxManifold);
1147 loadData(is, myExportManifoldNumbers);
1148 loadData(is, myFixWindings);
1149 loadData(is, myDeleteSmallManifolds);
1150 loadData(is, mySmallManifoldSize);
1151 loadData(is, myAddValidPolyAttrib);
1152 loadData(is, myValidPolyAttribName);
1153 loadData(is, myAddRepairedPolyAttrib);
1154 loadData(is, myRepairedPolyAttribName);
1155 loadData(is, myAddValidPtsAttrib);
1156 loadData(is, myValidPtsAttribName);
1157 loadData(is, myAddModifiedPtsAttrib);
1158 loadData(is, myModifiedPtsAttribName);
1159 loadData(is, myCreateGroups);
1160 loadData(is, myVisualizeInvalidPts);
1161 loadData(is, myInvalidPtsColor);
1162 loadData(is, myVisualizeRepairedPts);
1163 loadData(is, myRepairedPtsColor);
1164 loadData(is, myVisualizeInvalidPolys);
1165 loadData(is, myInvalidPolysColor);
1166 loadData(is, myVisualizeRepairedPolys);
1167 loadData(is, myRepairedPolysColor);
1177 if (!thissop)
return getGroup();
1179 OP_Utils::evalOpParm(result, thissop,
"group", cookparms.
getCookTime(), 0);
1187 if (!thissop)
return getMaxPasses();
1189 OP_Utils::evalOpParm(result, thissop,
"maxpasses", cookparms.
getCookTime(), 0);
1197 if (!thissop)
return getRandomSeed();
1199 OP_Utils::evalOpParm(result, thissop,
"randomseed", cookparms.
getCookTime(), 0);
1207 if (!thissop)
return getIllFormedAction();
1209 OP_Utils::evalOpParm(result, thissop,
"illformed", cookparms.
getCookTime(), 0);
1217 if (!thissop)
return getManyEdgesAction();
1219 OP_Utils::evalOpParm(result, thissop,
"manyedges", cookparms.
getCookTime(), 0);
1227 if (!thissop)
return getNonConvexAction();
1229 OP_Utils::evalOpParm(result, thissop,
"nonconvex", cookparms.
getCookTime(), 0);
1237 if (!thissop)
return getOverlappingAction();
1239 OP_Utils::evalOpParm(result, thissop,
"overlapping", cookparms.
getCookTime(), 0);
1247 if (!thissop)
return getPairOverlaps();
1249 OP_Utils::evalOpParm(result, thissop,
"pairoverlaps", cookparms.
getCookTime(), 0);
1257 if (!thissop)
return getSelfIntersectingAction();
1259 OP_Utils::evalOpParm(result, thissop,
"intersect", cookparms.
getCookTime(), 0);
1267 if (!thissop)
return getThickness();
1269 OP_Utils::evalOpParm(result, thissop,
"thickness", cookparms.
getCookTime(), 0);
1277 if (!thissop)
return getGloballySmallAreasAction();
1279 OP_Utils::evalOpParm(result, thissop,
"glosmallarea", cookparms.
getCookTime(), 0);
1287 if (!thissop)
return getGlobalAreaThreshold();
1289 OP_Utils::evalOpParm(result, thissop,
"gloareathres", cookparms.
getCookTime(), 0);
1297 if (!thissop)
return getLocallySmallAreasAction();
1299 OP_Utils::evalOpParm(result, thissop,
"locsmallarea", cookparms.
getCookTime(), 0);
1307 if (!thissop)
return getLocalAreaThreshold();
1309 OP_Utils::evalOpParm(result, thissop,
"locareathres", cookparms.
getCookTime(), 0);
1317 if (!thissop)
return getNonUniformAction();
1319 OP_Utils::evalOpParm(result, thissop,
"nonuni", cookparms.
getCookTime(), 0);
1327 if (!thissop)
return getUniformityThreshold();
1329 OP_Utils::evalOpParm(result, thissop,
"unithres", cookparms.
getCookTime(), 0);
1337 if (!thissop)
return getGloballySmallEdgesAction();
1339 OP_Utils::evalOpParm(result, thissop,
"glosmalledge", cookparms.
getCookTime(), 0);
1347 if (!thissop)
return getGlobalEdgeThreshold();
1349 OP_Utils::evalOpParm(result, thissop,
"gloedgethres", cookparms.
getCookTime(), 0);
1357 if (!thissop)
return getLocallySmallEdgesAction();
1359 OP_Utils::evalOpParm(result, thissop,
"locsmalledge", cookparms.
getCookTime(), 0);
1367 if (!thissop)
return getLocalEdgeThreshold();
1369 OP_Utils::evalOpParm(result, thissop,
"locedgethres", cookparms.
getCookTime(), 0);
1377 if (!thissop)
return getDisconnectedPointsAction();
1379 OP_Utils::evalOpParm(result, thissop,
"disconnectpt", cookparms.
getCookTime(), 0);
1387 if (!thissop)
return getNonManifoldPointsAction();
1389 OP_Utils::evalOpParm(result, thissop,
"nonmanifoldpt", cookparms.
getCookTime(), 0);
1397 if (!thissop)
return getIgnoreWindings();
1399 OP_Utils::evalOpParm(result, thissop,
"ignorewindings", cookparms.
getCookTime(), 0);
1407 if (!thissop)
return getPreferLargeAngles();
1409 OP_Utils::evalOpParm(result, thissop,
"preferlargeangles", cookparms.
getCookTime(), 0);
1417 if (!thissop)
return getVisualizeMaxManifold();
1419 OP_Utils::evalOpParm(result, thissop,
"vismaxmanifold", cookparms.
getCookTime(), 0);
1427 if (!thissop)
return getExportManifoldNumbers();
1429 OP_Utils::evalOpParm(result, thissop,
"exportmanifoldnumbers", cookparms.
getCookTime(), 0);
1437 if (!thissop)
return getFixWindings();
1439 OP_Utils::evalOpParm(result, thissop,
"fixwindings", cookparms.
getCookTime(), 0);
1447 if (!thissop)
return getDeleteSmallManifolds();
1449 OP_Utils::evalOpParm(result, thissop,
"deletesmallmanifolds", cookparms.
getCookTime(), 0);
1457 if (!thissop)
return getSmallManifoldSize();
1459 OP_Utils::evalOpParm(result, thissop,
"smallmanifoldsize", cookparms.
getCookTime(), 0);
1467 if (!thissop)
return getAddValidPolyAttrib();
1469 OP_Utils::evalOpParm(result, thissop,
"usevalidpoly", cookparms.
getCookTime(), 0);
1477 if (!thissop)
return getValidPolyAttribName();
1479 OP_Utils::evalOpParm(result, thissop,
"validpoly", cookparms.
getCookTime(), 0);
1487 if (!thissop)
return getAddRepairedPolyAttrib();
1489 OP_Utils::evalOpParm(result, thissop,
"userepairedpoly", cookparms.
getCookTime(), 0);
1497 if (!thissop)
return getRepairedPolyAttribName();
1499 OP_Utils::evalOpParm(result, thissop,
"repairedpoly", cookparms.
getCookTime(), 0);
1507 if (!thissop)
return getAddValidPtsAttrib();
1509 OP_Utils::evalOpParm(result, thissop,
"usevalidpts", cookparms.
getCookTime(), 0);
1517 if (!thissop)
return getValidPtsAttribName();
1519 OP_Utils::evalOpParm(result, thissop,
"validpts", cookparms.
getCookTime(), 0);
1527 if (!thissop)
return getAddModifiedPtsAttrib();
1529 OP_Utils::evalOpParm(result, thissop,
"usemodifiedpts", cookparms.
getCookTime(), 0);
1537 if (!thissop)
return getModifiedPtsAttribName();
1539 OP_Utils::evalOpParm(result, thissop,
"modifiedpts", cookparms.
getCookTime(), 0);
1547 if (!thissop)
return getCreateGroups();
1549 OP_Utils::evalOpParm(result, thissop,
"creategrps", cookparms.
getCookTime(), 0);
1557 if (!thissop)
return getVisualizeInvalidPts();
1559 OP_Utils::evalOpParm(result, thissop,
"visinvalidpts", cookparms.
getCookTime(), 0);
1567 if (!thissop)
return getInvalidPtsColor();
1569 OP_Utils::evalOpParm(result, thissop,
"visinvalidptsfg", cookparms.
getCookTime(), 0);
1577 if (!thissop)
return getVisualizeRepairedPts();
1579 OP_Utils::evalOpParm(result, thissop,
"visrepairedpts", cookparms.
getCookTime(), 0);
1587 if (!thissop)
return getRepairedPtsColor();
1589 OP_Utils::evalOpParm(result, thissop,
"visrepairedptsfg", cookparms.
getCookTime(), 0);
1597 if (!thissop)
return getVisualizeInvalidPolys();
1599 OP_Utils::evalOpParm(result, thissop,
"visinvalidpolys", cookparms.
getCookTime(), 0);
1607 if (!thissop)
return getInvalidPolysColor();
1609 OP_Utils::evalOpParm(result, thissop,
"visinvalidpolysfg", cookparms.
getCookTime(), 0);
1617 if (!thissop)
return getVisualizeRepairedPolys();
1619 OP_Utils::evalOpParm(result, thissop,
"visrepairedpolys", cookparms.
getCookTime(), 0);
1627 if (!thissop)
return getRepairedPolysColor();
1629 OP_Utils::evalOpParm(result, thissop,
"visrepairedpolysfg", cookparms.
getCookTime(), 0);
1637 int64 myIllFormedAction;
1638 int64 myManyEdgesAction;
1639 int64 myNonConvexAction;
1640 int64 myOverlappingAction;
1641 bool myPairOverlaps;
1642 int64 mySelfIntersectingAction;
1644 int64 myGloballySmallAreasAction;
1646 int64 myLocallySmallAreasAction;
1648 int64 myNonUniformAction;
1650 int64 myGloballySmallEdgesAction;
1652 int64 myLocallySmallEdgesAction;
1654 int64 myDisconnectedPointsAction;
1655 int64 myNonManifoldPointsAction;
1656 bool myIgnoreWindings;
1657 bool myPreferLargeAngles;
1658 bool myVisualizeMaxManifold;
1659 bool myExportManifoldNumbers;
1661 bool myDeleteSmallManifolds;
1662 int64 mySmallManifoldSize;
1663 bool myAddValidPolyAttrib;
1665 bool myAddRepairedPolyAttrib;
1667 bool myAddValidPtsAttrib;
1669 bool myAddModifiedPtsAttrib;
1671 bool myCreateGroups;
1672 bool myVisualizeInvalidPts;
1674 bool myVisualizeRepairedPts;
1676 bool myVisualizeInvalidPolys;
1678 bool myVisualizeRepairedPolys;
void copyFrom(const SOP_NodeParms *src) override
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
void setFixWindings(bool val)
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
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
GLuint const GLfloat * val
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)
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)
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
const SOP_GraphProxy * graph() 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)
static void loadData(UT_IStream &is, fpreal64 &v)
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
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
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
GLint GLenum GLsizei GLint GLsizei const void * data
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
~SOP_PolyDoctorParms() override
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
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)
DEP_MicroNode * depnode() const
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 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
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
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)
int64 getSmallManifoldSize() const
GLdouble GLdouble GLdouble r
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)
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
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
DisconnectedPointsAction getDisconnectedPointsAction() const
UT_Vector3D opInvalidPolysColor(const SOP_NodeVerb::CookParms &cookparms) const
LocallySmallEdgesAction getLocallySmallEdgesAction() const
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)
GLsizei const GLfloat * value
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
const OP_Context & context() const
SelfIntersectingAction getSelfIntersectingAction() const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
exint getNestNumParms(TempIndex idx) const override
void setGroup(const UT_StringHolder &val)
bool opAddRepairedPolyAttrib(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
bool opAddValidPtsAttrib(const SOP_NodeVerb::CookParms &cookparms) const
void setLocalEdgeThreshold(fpreal64 val)
bool opAddValidPolyAttrib(const SOP_NodeVerb::CookParms &cookparms) const