⊟
836 KB
/srv/reproducible-results/rbuild-debian/r-b-build.vFjRiwjl/b1/python-opencascade-pywrap_0.0~git20250714210719.b608b60-3_arm64.changes vs.
/srv/reproducible-results/rbuild-debian/r-b-build.vFjRiwjl/b2/python-opencascade-pywrap_0.0~git20250714210719.b608b60-3_arm64.changes
⊟
280 B
Files
    
Offset 1, 2 lines modifiedOffset 1, 2 lines modified
  
1 ·f262608d1c302ad81470bb25feef83ee·1908392·python·optional·python3-opencascade-pywrap_0.0~git20250714210719.b608b60-3_all.deb1 ·7eb4016ed510bd1db6f21d1551d059d5·1908488·python·optional·python3-opencascade-pywrap_0.0~git20250714210719.b608b60-3_all.deb
⊟
835 KB
python3-opencascade-pywrap_0.0~git20250714210719.b608b60-3_all.deb
⊟
452 B
file list
    
Offset 1, 3 lines modifiedOffset 1, 3 lines modified
1 -rw-r--r--···0········0········0········4·2025-08-02·01:34:12.000000·debian-binary1 -rw-r--r--···0········0········0········4·2025-08-02·01:34:12.000000·debian-binary
2 -rw-r--r--···0········0········0····21260·2025-08-02·01:34:12.000000·control.tar.xz2 -rw-r--r--···0········0········0····21292·2025-08-02·01:34:12.000000·control.tar.xz
3 -rw-r--r--···0········0········0··1886940·2025-08-02·01:34:12.000000·data.tar.xz3 -rw-r--r--···0········0········0··1887004·2025-08-02·01:34:12.000000·data.tar.xz
⊟
98.0 B
control.tar.xz
⊟
70.0 B
control.tar
⊟
48.0 B
./md5sums
⊟
30.0 B
./md5sums
Files differ
⊟
835 KB
data.tar.xz
⊟
835 KB
data.tar
⊟
18.9 KB
./usr/share/libocp/OCP/AIS_pre.cpp
Ordering differences only
    
Offset 193, 54 lines modifiedOffset 193, 118 lines modified
  
193 //·add·namespaces·as·submodules193 //·add·namespaces·as·submodules
  
194 //·user-defined·inclusion·per·module·in·the·body194 //·user-defined·inclusion·per·module·in·the·body
195 py::class_<AIS_Manipulator::OptionsForAttach>(m,"AIS_Manipulator_OptionsForAttach");195 py::class_<AIS_Manipulator::OptionsForAttach>(m,"AIS_Manipulator_OptionsForAttach");
  
196 //·enums196 //·enums
197 ····py::enum_<AIS_SelectStatus>(m,·"AIS_SelectStatus",R"#()#") 
198 ········.value("AIS_SS_Added",AIS_SelectStatus::AIS_SS_Added) 
199 ········.value("AIS_SS_Removed",AIS_SelectStatus::AIS_SS_Removed) 
200 ········.value("AIS_SS_NotDone",AIS_SelectStatus::AIS_SS_NotDone).export_values(); 
201 ····py::enum_<AIS_RotationMode>(m,·"AIS_RotationMode",R"#(Camera·rotation·mode.)#")197 ····py::enum_<AIS_RotationMode>(m,·"AIS_RotationMode",R"#(Camera·rotation·mode.)#")
202 ········.value("AIS_RotationMode_BndBoxActive",AIS_RotationMode::AIS_RotationMode_BndBoxActive)198 ········.value("AIS_RotationMode_BndBoxActive",AIS_RotationMode::AIS_RotationMode_BndBoxActive)
203 ········.value("AIS_RotationMode_PickLast",AIS_RotationMode::AIS_RotationMode_PickLast)199 ········.value("AIS_RotationMode_PickLast",AIS_RotationMode::AIS_RotationMode_PickLast)
204 ········.value("AIS_RotationMode_PickCenter",AIS_RotationMode::AIS_RotationMode_PickCenter)200 ········.value("AIS_RotationMode_PickCenter",AIS_RotationMode::AIS_RotationMode_PickCenter)
205 ········.value("AIS_RotationMode_CameraAt",AIS_RotationMode::AIS_RotationMode_CameraAt)201 ········.value("AIS_RotationMode_CameraAt",AIS_RotationMode::AIS_RotationMode_CameraAt)
206 ········.value("AIS_RotationMode_BndBoxScene",AIS_RotationMode::AIS_RotationMode_BndBoxScene).export_values();202 ········.value("AIS_RotationMode_BndBoxScene",AIS_RotationMode::AIS_RotationMode_BndBoxScene).export_values();
207 ····m.attr("AIS_RotationMode_LOWER")·=·py::cast(int(AIS_RotationMode_LOWER));203 ····m.attr("AIS_RotationMode_LOWER")·=·py::cast(int(AIS_RotationMode_LOWER));
208 ····m.attr("AIS_RotationMode_UPPER")·=·py::cast(int(AIS_RotationMode_UPPER));204 ····m.attr("AIS_RotationMode_UPPER")·=·py::cast(int(AIS_RotationMode_UPPER));
 205 ····py::enum_<AIS_StatusOfPick>(m,·"AIS_StatusOfPick",R"#()#")
 206 ········.value("AIS_SOP_Error",AIS_StatusOfPick::AIS_SOP_Error)
 207 ········.value("AIS_SOP_NothingSelected",AIS_StatusOfPick::AIS_SOP_NothingSelected)
 208 ········.value("AIS_SOP_Removed",AIS_StatusOfPick::AIS_SOP_Removed)
 209 ········.value("AIS_SOP_OneSelected",AIS_StatusOfPick::AIS_SOP_OneSelected)
 210 ········.value("AIS_SOP_SeveralSelected",AIS_StatusOfPick::AIS_SOP_SeveralSelected).export_values();
 211 ····py::enum_<AIS_MouseGesture>(m,·"AIS_MouseGesture",R"#(Mouse·gesture·-·only·one·can·be·active·at·one·moment.)#")
 212 ········.value("AIS_MouseGesture_NONE",AIS_MouseGesture::AIS_MouseGesture_NONE)
 213 ········.value("AIS_MouseGesture_SelectRectangle",AIS_MouseGesture::AIS_MouseGesture_SelectRectangle)
 214 ········.value("AIS_MouseGesture_SelectLasso",AIS_MouseGesture::AIS_MouseGesture_SelectLasso)
 215 ········.value("AIS_MouseGesture_Zoom",AIS_MouseGesture::AIS_MouseGesture_Zoom)
 216 ········.value("AIS_MouseGesture_ZoomWindow",AIS_MouseGesture::AIS_MouseGesture_ZoomWindow)
 217 ········.value("AIS_MouseGesture_Pan",AIS_MouseGesture::AIS_MouseGesture_Pan)
 218 ········.value("AIS_MouseGesture_RotateOrbit",AIS_MouseGesture::AIS_MouseGesture_RotateOrbit)
 219 ········.value("AIS_MouseGesture_RotateView",AIS_MouseGesture::AIS_MouseGesture_RotateView)
 220 ········.value("AIS_MouseGesture_Drag",AIS_MouseGesture::AIS_MouseGesture_Drag).export_values();
 221 ····py::enum_<AIS_SelectionModesConcurrency>(m,·"AIS_SelectionModesConcurrency",R"#(The·mode·specifying·how·multiple·active·Selection·Modes·should·be·treated·during·activation·of·new·one.)#")
 222 ········.value("AIS_SelectionModesConcurrency_Single",AIS_SelectionModesConcurrency::AIS_SelectionModesConcurrency_Single)
 223 ········.value("AIS_SelectionModesConcurrency_GlobalOrLocal",AIS_SelectionModesConcurrency::AIS_SelectionModesConcurrency_GlobalOrLocal)
 224 ········.value("AIS_SelectionModesConcurrency_Multiple",AIS_SelectionModesConcurrency::AIS_SelectionModesConcurrency_Multiple).export_values();
 225 ····py::enum_<AIS_TypeOfIso>(m,·"AIS_TypeOfIso",R"#(Declares·the·type·of·isoparameter·displayed.)#")
 226 ········.value("AIS_TOI_IsoU",AIS_TypeOfIso::AIS_TOI_IsoU)
 227 ········.value("AIS_TOI_IsoV",AIS_TypeOfIso::AIS_TOI_IsoV)
 228 ········.value("AIS_TOI_Both",AIS_TypeOfIso::AIS_TOI_Both).export_values();
209 ····py::enum_<AIS_ViewSelectionTool>(m,·"AIS_ViewSelectionTool",R"#(Selection·mode)#")229 ····py::enum_<AIS_ViewSelectionTool>(m,·"AIS_ViewSelectionTool",R"#(Selection·mode)#")
210 ········.value("AIS_ViewSelectionTool_Picking",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Picking)230 ········.value("AIS_ViewSelectionTool_Picking",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Picking)
211 ········.value("AIS_ViewSelectionTool_RubberBand",AIS_ViewSelectionTool::AIS_ViewSelectionTool_RubberBand)231 ········.value("AIS_ViewSelectionTool_RubberBand",AIS_ViewSelectionTool::AIS_ViewSelectionTool_RubberBand)
212 ········.value("AIS_ViewSelectionTool_Polygon",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Polygon)232 ········.value("AIS_ViewSelectionTool_Polygon",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Polygon)
213 ········.value("AIS_ViewSelectionTool_ZoomWindow",AIS_ViewSelectionTool::AIS_ViewSelectionTool_ZoomWindow).export_values();233 ········.value("AIS_ViewSelectionTool_ZoomWindow",AIS_ViewSelectionTool::AIS_ViewSelectionTool_ZoomWindow).export_values();
214 ····py::enum_<AIS_ViewInputBufferType>(m,·"AIS_ViewInputBufferType",R"#(Input·buffer·type.)#")234 ····py::enum_<AIS_ViewInputBufferType>(m,·"AIS_ViewInputBufferType",R"#(Input·buffer·type.)#")
215 ········.value("AIS_ViewInputBufferType_UI",AIS_ViewInputBufferType::AIS_ViewInputBufferType_UI)235 ········.value("AIS_ViewInputBufferType_UI",AIS_ViewInputBufferType::AIS_ViewInputBufferType_UI)
216 ········.value("AIS_ViewInputBufferType_GL",AIS_ViewInputBufferType::AIS_ViewInputBufferType_GL).export_values();236 ········.value("AIS_ViewInputBufferType_GL",AIS_ViewInputBufferType::AIS_ViewInputBufferType_GL).export_values();
217 ····py::enum_<AIS_StatusOfPick>(m,·"AIS_StatusOfPick",R"#()#") 
218 ········.value("AIS_SOP_Error",AIS_StatusOfPick::AIS_SOP_Error) 
219 ········.value("AIS_SOP_NothingSelected",AIS_StatusOfPick::AIS_SOP_NothingSelected) 
220 ········.value("AIS_SOP_Removed",AIS_StatusOfPick::AIS_SOP_Removed) 
221 ········.value("AIS_SOP_OneSelected",AIS_StatusOfPick::AIS_SOP_OneSelected) 
222 ········.value("AIS_SOP_SeveralSelected",AIS_StatusOfPick::AIS_SOP_SeveralSelected).export_values();237 ····py::enum_<AIS_WalkTranslation>(m,·"AIS_WalkTranslation",R"#(Walking·translation·components.)#")
 238 ········.value("AIS_WalkTranslation_Forward",AIS_WalkTranslation::AIS_WalkTranslation_Forward)
 239 ········.value("AIS_WalkTranslation_Side",AIS_WalkTranslation::AIS_WalkTranslation_Side)
 240 ········.value("AIS_WalkTranslation_Up",AIS_WalkTranslation::AIS_WalkTranslation_Up).export_values();
 241 ····py::enum_<AIS_WalkRotation>(m,·"AIS_WalkRotation",R"#(Walking·rotation·components.)#")
 242 ········.value("AIS_WalkRotation_Yaw",AIS_WalkRotation::AIS_WalkRotation_Yaw)
 243 ········.value("AIS_WalkRotation_Pitch",AIS_WalkRotation::AIS_WalkRotation_Pitch)
 244 ········.value("AIS_WalkRotation_Roll",AIS_WalkRotation::AIS_WalkRotation_Roll).export_values();
 245 ····py::enum_<AIS_DragAction>(m,·"AIS_DragAction",R"#(Dragging·action.)#")
 246 ········.value("AIS_DragAction_Start",AIS_DragAction::AIS_DragAction_Start)
 247 ········.value("AIS_DragAction_Confirmed",AIS_DragAction::AIS_DragAction_Confirmed)
 248 ········.value("AIS_DragAction_Update",AIS_DragAction::AIS_DragAction_Update)
 249 ········.value("AIS_DragAction_Stop",AIS_DragAction::AIS_DragAction_Stop)
 250 ········.value("AIS_DragAction_Abort",AIS_DragAction::AIS_DragAction_Abort).export_values();
 251 ····py::enum_<AIS_TrihedronSelectionMode>(m,·"AIS_TrihedronSelectionMode",R"#(Enumeration·defining·selection·modes·supported·by·AIS_Trihedron.)#")
 252 ········.value("AIS_TrihedronSelectionMode_EntireObject",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_EntireObject)
 253 ········.value("AIS_TrihedronSelectionMode_Origin",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_Origin)
 254 ········.value("AIS_TrihedronSelectionMode_Axes",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_Axes)
 255 ········.value("AIS_TrihedronSelectionMode_MainPlanes",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_MainPlanes).export_values();
 256 ····py::enum_<AIS_TypeOfAxis>(m,·"AIS_TypeOfAxis",R"#(Declares·the·type·of·axis.)#")
 257 ········.value("AIS_TOAX_Unknown",AIS_TypeOfAxis::AIS_TOAX_Unknown)
 258 ········.value("AIS_TOAX_XAxis",AIS_TypeOfAxis::AIS_TOAX_XAxis)
 259 ········.value("AIS_TOAX_YAxis",AIS_TypeOfAxis::AIS_TOAX_YAxis)
 260 ········.value("AIS_TOAX_ZAxis",AIS_TypeOfAxis::AIS_TOAX_ZAxis).export_values();
 261 ····py::enum_<AIS_KindOfInteractive>(m,·"AIS_KindOfInteractive",R"#(Declares·the·type·of·Interactive·Object.·This·type·can·be·used·for·fast·pre-filtering·of·objects·of·specific·group.)#")
 262 ········.value("AIS_KindOfInteractive_None",AIS_KindOfInteractive::AIS_KindOfInteractive_None)
 263 ········.value("AIS_KindOfInteractive_Datum",AIS_KindOfInteractive::AIS_KindOfInteractive_Datum)
 264 ········.value("AIS_KindOfInteractive_Shape",AIS_KindOfInteractive::AIS_KindOfInteractive_Shape)
 265 ········.value("AIS_KindOfInteractive_Object",AIS_KindOfInteractive::AIS_KindOfInteractive_Object)
 266 ········.value("AIS_KindOfInteractive_Relation",AIS_KindOfInteractive::AIS_KindOfInteractive_Relation)
 267 ········.value("AIS_KindOfInteractive_Dimension",AIS_KindOfInteractive::AIS_KindOfInteractive_Dimension)
 268 ········.value("AIS_KindOfInteractive_LightSource",AIS_KindOfInteractive::AIS_KindOfInteractive_LightSource)
 269 ········.value("AIS_KOI_None",AIS_KindOfInteractive::AIS_KOI_None)
 270 ········.value("AIS_KOI_Datum",AIS_KindOfInteractive::AIS_KOI_Datum)
 271 ········.value("AIS_KOI_Shape",AIS_KindOfInteractive::AIS_KOI_Shape)
 272 ········.value("AIS_KOI_Object",AIS_KindOfInteractive::AIS_KOI_Object)
 273 ········.value("AIS_KOI_Relation",AIS_KindOfInteractive::AIS_KOI_Relation)
 274 ········.value("AIS_KOI_Dimension",AIS_KindOfInteractive::AIS_KOI_Dimension).export_values();
223 ····py::enum_<AIS_StatusOfDetection>(m,·"AIS_StatusOfDetection",R"#()#")275 ····py::enum_<AIS_StatusOfDetection>(m,·"AIS_StatusOfDetection",R"#()#")
224 ········.value("AIS_SOD_Error",AIS_StatusOfDetection::AIS_SOD_Error)276 ········.value("AIS_SOD_Error",AIS_StatusOfDetection::AIS_SOD_Error)
225 ········.value("AIS_SOD_Nothing",AIS_StatusOfDetection::AIS_SOD_Nothing)277 ········.value("AIS_SOD_Nothing",AIS_StatusOfDetection::AIS_SOD_Nothing)
226 ········.value("AIS_SOD_AllBad",AIS_StatusOfDetection::AIS_SOD_AllBad)278 ········.value("AIS_SOD_AllBad",AIS_StatusOfDetection::AIS_SOD_AllBad)
227 ········.value("AIS_SOD_Selected",AIS_StatusOfDetection::AIS_SOD_Selected)279 ········.value("AIS_SOD_Selected",AIS_StatusOfDetection::AIS_SOD_Selected)
228 ········.value("AIS_SOD_OnlyOneDetected",AIS_StatusOfDetection::AIS_SOD_OnlyOneDetected)280 ········.value("AIS_SOD_OnlyOneDetected",AIS_StatusOfDetection::AIS_SOD_OnlyOneDetected)
229 ········.value("AIS_SOD_OnlyOneGood",AIS_StatusOfDetection::AIS_SOD_OnlyOneGood)281 ········.value("AIS_SOD_OnlyOneGood",AIS_StatusOfDetection::AIS_SOD_OnlyOneGood)
230 ········.value("AIS_SOD_SeveralGood",AIS_StatusOfDetection::AIS_SOD_SeveralGood).export_values();282 ········.value("AIS_SOD_SeveralGood",AIS_StatusOfDetection::AIS_SOD_SeveralGood).export_values();
231 ····py::enum_<AIS_NavigationMode>(m,·"AIS_NavigationMode",R"#(Camera·navigation·mode.)#")283 ····py::enum_<AIS_NavigationMode>(m,·"AIS_NavigationMode",R"#(Camera·navigation·mode.)#")
232 ········.value("AIS_NavigationMode_Orbit",AIS_NavigationMode::AIS_NavigationMode_Orbit)284 ········.value("AIS_NavigationMode_Orbit",AIS_NavigationMode::AIS_NavigationMode_Orbit)
233 ········.value("AIS_NavigationMode_FirstPersonFlight",AIS_NavigationMode::AIS_NavigationMode_FirstPersonFlight)285 ········.value("AIS_NavigationMode_FirstPersonFlight",AIS_NavigationMode::AIS_NavigationMode_FirstPersonFlight)
234 ········.value("AIS_NavigationMode_FirstPersonWalk",AIS_NavigationMode::AIS_NavigationMode_FirstPersonWalk).export_values();286 ········.value("AIS_NavigationMode_FirstPersonWalk",AIS_NavigationMode::AIS_NavigationMode_FirstPersonWalk).export_values();
235 ····m.attr("AIS_NavigationMode_LOWER")·=·py::cast(int(AIS_NavigationMode_LOWER));287 ····m.attr("AIS_NavigationMode_LOWER")·=·py::cast(int(AIS_NavigationMode_LOWER));
236 ····m.attr("AIS_NavigationMode_UPPER")·=·py::cast(int(AIS_NavigationMode_UPPER));288 ····m.attr("AIS_NavigationMode_UPPER")·=·py::cast(int(AIS_NavigationMode_UPPER));
 289 ····py::enum_<AIS_TypeOfPlane>(m,·"AIS_TypeOfPlane",R"#(Declares·the·type·of·plane.)#")
 290 ········.value("AIS_TOPL_Unknown",AIS_TypeOfPlane::AIS_TOPL_Unknown)
 291 ········.value("AIS_TOPL_XYPlane",AIS_TypeOfPlane::AIS_TOPL_XYPlane)
 292 ········.value("AIS_TOPL_XZPlane",AIS_TypeOfPlane::AIS_TOPL_XZPlane)
 293 ········.value("AIS_TOPL_YZPlane",AIS_TypeOfPlane::AIS_TOPL_YZPlane).export_values();
 294 ····py::enum_<AIS_DisplayMode>(m,·"AIS_DisplayMode",R"#(Sets·display·modes·other·than·neutral·point·ones,·for·interactive·objects.·The·possibilities·include:·-·wireframe,·-·shaded,)#")
 295 ········.value("AIS_WireFrame",AIS_DisplayMode::AIS_WireFrame)
 296 ········.value("AIS_Shaded",AIS_DisplayMode::AIS_Shaded).export_values();
 297 ····py::enum_<AIS_SelectStatus>(m,·"AIS_SelectStatus",R"#()#")
 298 ········.value("AIS_SS_Added",AIS_SelectStatus::AIS_SS_Added)
 299 ········.value("AIS_SS_Removed",AIS_SelectStatus::AIS_SS_Removed)
 300 ········.value("AIS_SS_NotDone",AIS_SelectStatus::AIS_SS_NotDone).export_values();
237 ····py::enum_<AIS_TypeOfAttribute>(m,·"AIS_TypeOfAttribute",R"#()#")301 ····py::enum_<AIS_TypeOfAttribute>(m,·"AIS_TypeOfAttribute",R"#()#")
238 ········.value("AIS_TOA_Line",AIS_TypeOfAttribute::AIS_TOA_Line)302 ········.value("AIS_TOA_Line",AIS_TypeOfAttribute::AIS_TOA_Line)
239 ········.value("AIS_TOA_Dimension",AIS_TypeOfAttribute::AIS_TOA_Dimension)303 ········.value("AIS_TOA_Dimension",AIS_TypeOfAttribute::AIS_TOA_Dimension)
240 ········.value("AIS_TOA_Wire",AIS_TypeOfAttribute::AIS_TOA_Wire)304 ········.value("AIS_TOA_Wire",AIS_TypeOfAttribute::AIS_TOA_Wire)
241 ········.value("AIS_TOA_Plane",AIS_TypeOfAttribute::AIS_TOA_Plane)305 ········.value("AIS_TOA_Plane",AIS_TypeOfAttribute::AIS_TOA_Plane)
242 ········.value("AIS_TOA_Vector",AIS_TypeOfAttribute::AIS_TOA_Vector)306 ········.value("AIS_TOA_Vector",AIS_TypeOfAttribute::AIS_TOA_Vector)
243 ········.value("AIS_TOA_UIso",AIS_TypeOfAttribute::AIS_TOA_UIso)307 ········.value("AIS_TOA_UIso",AIS_TypeOfAttribute::AIS_TOA_UIso)
Max diff block lines reached; 8175/19279 bytes (42.40%) of diff not shown.
⊟
1.94 KB
./usr/share/libocp/OCP/AdvApp2Var_pre.cpp
Ordering differences only
    
Offset 72, 20 lines modifiedOffset 72, 20 lines modified
72 py::module·m·=·main_module.def_submodule("AdvApp2Var",·R"#()#");72 py::module·m·=·main_module.def_submodule("AdvApp2Var",·R"#()#");
  
73 //·add·namespaces·as·submodules73 //·add·namespaces·as·submodules
  
74 //·user-defined·inclusion·per·module·in·the·body74 //·user-defined·inclusion·per·module·in·the·body
  
75 //·enums75 //·enums
76 ····py::enum_<AdvApp2Var_CriterionType>(m,·"AdvApp2Var_CriterionType",R"#(influency·of·the·criterion·on·cutting·process//!·cutting·when·criterion·is·not·satisfied·desactivation·of·the·compute·of·the·error·max//!·cutting·when·error·max·is·not·good·or·if·error·max·is·good·and·criterion·is·not·satisfied)#") 
77 ········.value("AdvApp2Var_Absolute",AdvApp2Var_CriterionType::AdvApp2Var_Absolute) 
78 ········.value("AdvApp2Var_Relative",AdvApp2Var_CriterionType::AdvApp2Var_Relative).export_values(); 
79 ····py::enum_<AdvApp2Var_CriterionRepartition>(m,·"AdvApp2Var_CriterionRepartition",R"#(way·of·cutting·process//!·all·new·cutting·points·at·each·step·of·cutting·process·:·(a+i(b-a)/N)i·at·step·N,·(a+i(b-a)/(N+1))i·at·step·N+1,...·where·(a,b)·is·the·global·interval//!·add·one·new·cutting·point·at·each·step·of·cutting·process)#")76 ····py::enum_<AdvApp2Var_CriterionRepartition>(m,·"AdvApp2Var_CriterionRepartition",R"#(way·of·cutting·process//!·all·new·cutting·points·at·each·step·of·cutting·process·:·(a+i(b-a)/N)i·at·step·N,·(a+i(b-a)/(N+1))i·at·step·N+1,...·where·(a,b)·is·the·global·interval//!·add·one·new·cutting·point·at·each·step·of·cutting·process)#")
80 ········.value("AdvApp2Var_Regular",AdvApp2Var_CriterionRepartition::AdvApp2Var_Regular)77 ········.value("AdvApp2Var_Regular",AdvApp2Var_CriterionRepartition::AdvApp2Var_Regular)
81 ········.value("AdvApp2Var_Incremental",AdvApp2Var_CriterionRepartition::AdvApp2Var_Incremental).export_values();78 ········.value("AdvApp2Var_Incremental",AdvApp2Var_CriterionRepartition::AdvApp2Var_Incremental).export_values();
 79 ····py::enum_<AdvApp2Var_CriterionType>(m,·"AdvApp2Var_CriterionType",R"#(influency·of·the·criterion·on·cutting·process//!·cutting·when·criterion·is·not·satisfied·desactivation·of·the·compute·of·the·error·max//!·cutting·when·error·max·is·not·good·or·if·error·max·is·good·and·criterion·is·not·satisfied)#")
 80 ········.value("AdvApp2Var_Absolute",AdvApp2Var_CriterionType::AdvApp2Var_Absolute)
 81 ········.value("AdvApp2Var_Relative",AdvApp2Var_CriterionType::AdvApp2Var_Relative).export_values();
  
82 //Python·trampoline·classes82 //Python·trampoline·classes
83 ····class·Py_AdvApp2Var_Criterion·:·public·AdvApp2Var_Criterion{83 ····class·Py_AdvApp2Var_Criterion·:·public·AdvApp2Var_Criterion{
84 ····public:84 ····public:
85 ········using·AdvApp2Var_Criterion::AdvApp2Var_Criterion;85 ········using·AdvApp2Var_Criterion::AdvApp2Var_Criterion;
  
  
⊟
1.5 KB
./usr/share/libocp/OCP/Approx_pre.cpp
Ordering differences only
    
Offset 61, 22 lines modifiedOffset 61, 22 lines modified
61 py::module·m·=·main_module.def_submodule("Approx",·R"#()#");61 py::module·m·=·main_module.def_submodule("Approx",·R"#()#");
  
62 //·add·namespaces·as·submodules62 //·add·namespaces·as·submodules
  
63 //·user-defined·inclusion·per·module·in·the·body63 //·user-defined·inclusion·per·module·in·the·body
  
64 //·enums64 //·enums
65 ····py::enum_<Approx_Status>(m,·"Approx_Status",R"#(It·is·an·auxiliary·flag·being·used·in·inner·computations)#") 
66 ········.value("Approx_PointsAdded",Approx_Status::Approx_PointsAdded) 
67 ········.value("Approx_NoPointsAdded",Approx_Status::Approx_NoPointsAdded) 
68 ········.value("Approx_NoApproximation",Approx_Status::Approx_NoApproximation).export_values(); 
69 ····py::enum_<Approx_ParametrizationType>(m,·"Approx_ParametrizationType",R"#()#")65 ····py::enum_<Approx_ParametrizationType>(m,·"Approx_ParametrizationType",R"#()#")
70 ········.value("Approx_ChordLength",Approx_ParametrizationType::Approx_ChordLength)66 ········.value("Approx_ChordLength",Approx_ParametrizationType::Approx_ChordLength)
71 ········.value("Approx_Centripetal",Approx_ParametrizationType::Approx_Centripetal)67 ········.value("Approx_Centripetal",Approx_ParametrizationType::Approx_Centripetal)
72 ········.value("Approx_IsoParametric",Approx_ParametrizationType::Approx_IsoParametric).export_values();68 ········.value("Approx_IsoParametric",Approx_ParametrizationType::Approx_IsoParametric).export_values();
 69 ····py::enum_<Approx_Status>(m,·"Approx_Status",R"#(It·is·an·auxiliary·flag·being·used·in·inner·computations)#")
 70 ········.value("Approx_PointsAdded",Approx_Status::Approx_PointsAdded)
 71 ········.value("Approx_NoPointsAdded",Approx_Status::Approx_NoPointsAdded)
 72 ········.value("Approx_NoApproximation",Approx_Status::Approx_NoApproximation).export_values();
  
73 //Python·trampoline·classes73 //Python·trampoline·classes
74 ····class·Py_Approx_SweepFunction·:·public·Approx_SweepFunction{74 ····class·Py_Approx_SweepFunction·:·public·Approx_SweepFunction{
75 ····public:75 ····public:
76 ········using·Approx_SweepFunction::Approx_SweepFunction;76 ········using·Approx_SweepFunction::Approx_SweepFunction;
  
  
⊟
31.2 KB
./usr/share/libocp/OCP/Aspect_pre.cpp
Ordering differences only
    
Offset 113, 101 lines modifiedOffset 113, 41 lines modified
113 py::module·m·=·main_module.def_submodule("Aspect",·R"#()#");113 py::module·m·=·main_module.def_submodule("Aspect",·R"#()#");
  
114 //·add·namespaces·as·submodules114 //·add·namespaces·as·submodules
  
115 //·user-defined·inclusion·per·module·in·the·body115 //·user-defined·inclusion·per·module·in·the·body
  
116 //·enums116 //·enums
117 ····py::enum_<Aspect_GraphicsLibrary>(m,·"Aspect_GraphicsLibrary",R"#(Graphics·API·enumeration.)#") 
118 ········.value("Aspect_GraphicsLibrary_OpenGL",Aspect_GraphicsLibrary::Aspect_GraphicsLibrary_OpenGL) 
119 ········.value("Aspect_GraphicsLibrary_OpenGLES",Aspect_GraphicsLibrary::Aspect_GraphicsLibrary_OpenGLES).export_values(); 
120 ····py::enum_<Aspect_TypeOfResize>(m,·"Aspect_TypeOfResize",R"#(Defines·the·type·of·Resize·Window·method·applied·by·the·user.)#") 
121 ········.value("Aspect_TOR_UNKNOWN",Aspect_TypeOfResize::Aspect_TOR_UNKNOWN) 
122 ········.value("Aspect_TOR_NO_BORDER",Aspect_TypeOfResize::Aspect_TOR_NO_BORDER) 
123 ········.value("Aspect_TOR_TOP_BORDER",Aspect_TypeOfResize::Aspect_TOR_TOP_BORDER) 
124 ········.value("Aspect_TOR_RIGHT_BORDER",Aspect_TypeOfResize::Aspect_TOR_RIGHT_BORDER) 
125 ········.value("Aspect_TOR_BOTTOM_BORDER",Aspect_TypeOfResize::Aspect_TOR_BOTTOM_BORDER) 
126 ········.value("Aspect_TOR_LEFT_BORDER",Aspect_TypeOfResize::Aspect_TOR_LEFT_BORDER) 
127 ········.value("Aspect_TOR_TOP_AND_RIGHT_BORDER",Aspect_TypeOfResize::Aspect_TOR_TOP_AND_RIGHT_BORDER) 
128 ········.value("Aspect_TOR_RIGHT_AND_BOTTOM_BORDER",Aspect_TypeOfResize::Aspect_TOR_RIGHT_AND_BOTTOM_BORDER) 
129 ········.value("Aspect_TOR_BOTTOM_AND_LEFT_BORDER",Aspect_TypeOfResize::Aspect_TOR_BOTTOM_AND_LEFT_BORDER) 
130 ········.value("Aspect_TOR_LEFT_AND_TOP_BORDER",Aspect_TypeOfResize::Aspect_TOR_LEFT_AND_TOP_BORDER).export_values(); 
131 ····py::enum_<Aspect_Eye>(m,·"Aspect_Eye",R"#(Camera·eye·index·within·stereoscopic·pair.)#") 
132 ········.value("Aspect_Eye_Left",Aspect_Eye::Aspect_Eye_Left) 
133 ········.value("Aspect_Eye_Right",Aspect_Eye::Aspect_Eye_Right).export_values(); 
134 ····py::enum_<Aspect_FillMethod>(m,·"Aspect_FillMethod",R"#(Defines·the·fill·methods·to·write·bitmaps·in·a·window.)#") 
135 ········.value("Aspect_FM_NONE",Aspect_FillMethod::Aspect_FM_NONE) 
136 ········.value("Aspect_FM_CENTERED",Aspect_FillMethod::Aspect_FM_CENTERED) 
137 ········.value("Aspect_FM_TILED",Aspect_FillMethod::Aspect_FM_TILED) 
138 ········.value("Aspect_FM_STRETCH",Aspect_FillMethod::Aspect_FM_STRETCH).export_values(); 
139 ····py::enum_<Aspect_PolygonOffsetMode>(m,·"Aspect_PolygonOffsetMode",R"#()#")117 ····py::enum_<Aspect_PolygonOffsetMode>(m,·"Aspect_PolygonOffsetMode",R"#()#")
140 ········.value("Aspect_POM_Off",Aspect_PolygonOffsetMode::Aspect_POM_Off)118 ········.value("Aspect_POM_Off",Aspect_PolygonOffsetMode::Aspect_POM_Off)
141 ········.value("Aspect_POM_Fill",Aspect_PolygonOffsetMode::Aspect_POM_Fill)119 ········.value("Aspect_POM_Fill",Aspect_PolygonOffsetMode::Aspect_POM_Fill)
142 ········.value("Aspect_POM_Line",Aspect_PolygonOffsetMode::Aspect_POM_Line)120 ········.value("Aspect_POM_Line",Aspect_PolygonOffsetMode::Aspect_POM_Line)
143 ········.value("Aspect_POM_Point",Aspect_PolygonOffsetMode::Aspect_POM_Point)121 ········.value("Aspect_POM_Point",Aspect_PolygonOffsetMode::Aspect_POM_Point)
144 ········.value("Aspect_POM_All",Aspect_PolygonOffsetMode::Aspect_POM_All)122 ········.value("Aspect_POM_All",Aspect_PolygonOffsetMode::Aspect_POM_All)
145 ········.value("Aspect_POM_None",Aspect_PolygonOffsetMode::Aspect_POM_None)123 ········.value("Aspect_POM_None",Aspect_PolygonOffsetMode::Aspect_POM_None)
146 ········.value("Aspect_POM_Mask",Aspect_PolygonOffsetMode::Aspect_POM_Mask).export_values();124 ········.value("Aspect_POM_Mask",Aspect_PolygonOffsetMode::Aspect_POM_Mask).export_values();
147 ····py::enum_<Aspect_TypeOfStyleText>(m,·"Aspect_TypeOfStyleText",R"#(Define·the·style·of·the·text.)#") 
148 ········.value("Aspect_TOST_NORMAL",Aspect_TypeOfStyleText::Aspect_TOST_NORMAL) 
149 ········.value("Aspect_TOST_ANNOTATION",Aspect_TypeOfStyleText::Aspect_TOST_ANNOTATION).export_values(); 
150 ····py::enum_<Aspect_XRActionType>(m,·"Aspect_XRActionType",R"#(XR·action·type.)#")125 ····py::enum_<Aspect_XRGenericAction>(m,·"Aspect_XRGenericAction",R"#(Generic·XR·action.)#")
151 ········.value("Aspect_XRActionType_InputDigital",Aspect_XRActionType::Aspect_XRActionType_InputDigital)126 ········.value("Aspect_XRGenericAction_IsHeadsetOn",Aspect_XRGenericAction::Aspect_XRGenericAction_IsHeadsetOn)
152 ········.value("Aspect_XRActionType_InputAnalog",Aspect_XRActionType::Aspect_XRActionType_InputAnalog)127 ········.value("Aspect_XRGenericAction_InputAppMenu",Aspect_XRGenericAction::Aspect_XRGenericAction_InputAppMenu)
 128 ········.value("Aspect_XRGenericAction_InputSysMenu",Aspect_XRGenericAction::Aspect_XRGenericAction_InputSysMenu)
 129 ········.value("Aspect_XRGenericAction_InputTriggerPull",Aspect_XRGenericAction::Aspect_XRGenericAction_InputTriggerPull)
 130 ········.value("Aspect_XRGenericAction_InputTriggerClick",Aspect_XRGenericAction::Aspect_XRGenericAction_InputTriggerClick)
 131 ········.value("Aspect_XRGenericAction_InputGripClick",Aspect_XRGenericAction::Aspect_XRGenericAction_InputGripClick)
 132 ········.value("Aspect_XRGenericAction_InputTrackPadPosition",Aspect_XRGenericAction::Aspect_XRGenericAction_InputTrackPadPosition)
 133 ········.value("Aspect_XRGenericAction_InputTrackPadTouch",Aspect_XRGenericAction::Aspect_XRGenericAction_InputTrackPadTouch)
 134 ········.value("Aspect_XRGenericAction_InputTrackPadClick",Aspect_XRGenericAction::Aspect_XRGenericAction_InputTrackPadClick)
 135 ········.value("Aspect_XRGenericAction_InputThumbstickPosition",Aspect_XRGenericAction::Aspect_XRGenericAction_InputThumbstickPosition)
 136 ········.value("Aspect_XRGenericAction_InputThumbstickTouch",Aspect_XRGenericAction::Aspect_XRGenericAction_InputThumbstickTouch)
 137 ········.value("Aspect_XRGenericAction_InputThumbstickClick",Aspect_XRGenericAction::Aspect_XRGenericAction_InputThumbstickClick)
153 ········.value("Aspect_XRActionType_InputPose",Aspect_XRActionType::Aspect_XRActionType_InputPose)138 ········.value("Aspect_XRGenericAction_InputPoseBase",Aspect_XRGenericAction::Aspect_XRGenericAction_InputPoseBase)
154 ········.value("Aspect_XRActionType_InputSkeletal",Aspect_XRActionType::Aspect_XRActionType_InputSkeletal)139 ········.value("Aspect_XRGenericAction_InputPoseFront",Aspect_XRGenericAction::Aspect_XRGenericAction_InputPoseFront)
 140 ········.value("Aspect_XRGenericAction_InputPoseHandGrip",Aspect_XRGenericAction::Aspect_XRGenericAction_InputPoseHandGrip)
 141 ········.value("Aspect_XRGenericAction_InputPoseFingerTip",Aspect_XRGenericAction::Aspect_XRGenericAction_InputPoseFingerTip)
155 ········.value("Aspect_XRActionType_OutputHaptic",Aspect_XRActionType::Aspect_XRActionType_OutputHaptic).export_values();142 ········.value("Aspect_XRGenericAction_OutputHaptic",Aspect_XRGenericAction::Aspect_XRGenericAction_OutputHaptic).export_values();
 143 ····m.attr("Aspect_XRGenericAction_NB")·=·py::cast(int(Aspect_XRGenericAction_NB));
156 ····py::enum_<Aspect_XRTrackedDeviceRole>(m,·"Aspect_XRTrackedDeviceRole",R"#(Predefined·tracked·devices.)#") 
157 ········.value("Aspect_XRTrackedDeviceRole_Head",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_Head) 
158 ········.value("Aspect_XRTrackedDeviceRole_LeftHand",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_LeftHand) 
159 ········.value("Aspect_XRTrackedDeviceRole_RightHand",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_RightHand) 
160 ········.value("Aspect_XRTrackedDeviceRole_Other",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_Other).export_values(); 
161 ····m.attr("Aspect_XRTrackedDeviceRole_NB")·=·py::cast(int(Aspect_XRTrackedDeviceRole_NB)); 
162 ····py::enum_<Aspect_ColorSpace>(m,·"Aspect_ColorSpace",R"#(Texture·color·spaces·accepted·by·XR·composer.)#") 
163 ········.value("Aspect_ColorSpace_sRGB",Aspect_ColorSpace::Aspect_ColorSpace_sRGB) 
164 ········.value("Aspect_ColorSpace_Linear",Aspect_ColorSpace::Aspect_ColorSpace_Linear).export_values(); 
165 ····py::enum_<Aspect_GridType>(m,·"Aspect_GridType",R"#(Defines·the·grid·type·:·Rectangular·or·Circular.)#") 
166 ········.value("Aspect_GT_Rectangular",Aspect_GridType::Aspect_GT_Rectangular) 
167 ········.value("Aspect_GT_Circular",Aspect_GridType::Aspect_GT_Circular).export_values(); 
168 ····py::enum_<Aspect_WidthOfLine>(m,·"Aspect_WidthOfLine",R"#(Definition·of·line·types)#") 
169 ········.value("Aspect_WOL_THIN",Aspect_WidthOfLine::Aspect_WOL_THIN) 
170 ········.value("Aspect_WOL_MEDIUM",Aspect_WidthOfLine::Aspect_WOL_MEDIUM) 
171 ········.value("Aspect_WOL_THICK",Aspect_WidthOfLine::Aspect_WOL_THICK) 
172 ········.value("Aspect_WOL_VERYTHICK",Aspect_WidthOfLine::Aspect_WOL_VERYTHICK) 
173 ········.value("Aspect_WOL_USERDEFINED",Aspect_WidthOfLine::Aspect_WOL_USERDEFINED).export_values(); 
174 ····py::enum_<Aspect_TypeOfTriedronPosition>(m,·"Aspect_TypeOfTriedronPosition",R"#(Definition·of·the·Trihedron·position·in·the·views.·It·is·defined·as·a·bitmask·to·simplify·handling·vertical·and·horizontal·alignment·independently.)#") 
175 ········.value("Aspect_TOTP_CENTER",Aspect_TypeOfTriedronPosition::Aspect_TOTP_CENTER) 
176 ········.value("Aspect_TOTP_TOP",Aspect_TypeOfTriedronPosition::Aspect_TOTP_TOP) 
177 ········.value("Aspect_TOTP_BOTTOM",Aspect_TypeOfTriedronPosition::Aspect_TOTP_BOTTOM) 
178 ········.value("Aspect_TOTP_LEFT",Aspect_TypeOfTriedronPosition::Aspect_TOTP_LEFT) 
179 ········.value("Aspect_TOTP_RIGHT",Aspect_TypeOfTriedronPosition::Aspect_TOTP_RIGHT) 
180 ········.value("Aspect_TOTP_LEFT_LOWER",Aspect_TypeOfTriedronPosition::Aspect_TOTP_LEFT_LOWER) 
181 ········.value("Aspect_TOTP_LEFT_UPPER",Aspect_TypeOfTriedronPosition::Aspect_TOTP_LEFT_UPPER) 
182 ········.value("Aspect_TOTP_RIGHT_LOWER",Aspect_TypeOfTriedronPosition::Aspect_TOTP_RIGHT_LOWER) 
183 ········.value("Aspect_TOTP_RIGHT_UPPER",Aspect_TypeOfTriedronPosition::Aspect_TOTP_RIGHT_UPPER).export_values(); 
184 ····m.attr("Aspect_VKeyFlags_NONE")·=·py::cast(int(Aspect_VKeyFlags_NONE)); 
185 ····m.attr("Aspect_VKeyFlags_SHIFT")·=·py::cast(int(Aspect_VKeyFlags_SHIFT)); 
186 ····m.attr("Aspect_VKeyFlags_CTRL")·=·py::cast(int(Aspect_VKeyFlags_CTRL)); 
187 ····m.attr("Aspect_VKeyFlags_ALT")·=·py::cast(int(Aspect_VKeyFlags_ALT)); 
188 ····m.attr("Aspect_VKeyFlags_MENU")·=·py::cast(int(Aspect_VKeyFlags_MENU)); 
189 ····m.attr("Aspect_VKeyFlags_META")·=·py::cast(int(Aspect_VKeyFlags_META)); 
190 ····m.attr("Aspect_VKeyFlags_ALL")·=·py::cast(int(Aspect_VKeyFlags_ALL)); 
191 ····m.attr("Aspect_VKeyMouse_NONE")·=·py::cast(int(Aspect_VKeyMouse_NONE)); 
192 ····m.attr("Aspect_VKeyMouse_LeftButton")·=·py::cast(int(Aspect_VKeyMouse_LeftButton)); 
193 ····m.attr("Aspect_VKeyMouse_MiddleButton")·=·py::cast(int(Aspect_VKeyMouse_MiddleButton)); 
194 ····m.attr("Aspect_VKeyMouse_RightButton")·=·py::cast(int(Aspect_VKeyMouse_RightButton)); 
195 ····m.attr("Aspect_VKeyMouse_MainButtons")·=·py::cast(int(Aspect_VKeyMouse_MainButtons)); 
196 ····py::enum_<Aspect_TypeOfColorScalePosition>(m,·"Aspect_TypeOfColorScalePosition",R"#(Defines·the·type·of·position·for·color·scale·labels)#") 
197 ········.value("Aspect_TOCSP_NONE",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_NONE) 
198 ········.value("Aspect_TOCSP_LEFT",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_LEFT) 
199 ········.value("Aspect_TOCSP_RIGHT",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_RIGHT) 
200 ········.value("Aspect_TOCSP_CENTER",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_CENTER).export_values(); 
201 ····py::enum_<Aspect_TypeOfHighlightMethod>(m,·"Aspect_TypeOfHighlightMethod",R"#(Definition·of·a·highlight·method)#") 
202 ········.value("Aspect_TOHM_COLOR",Aspect_TypeOfHighlightMethod::Aspect_TOHM_COLOR) 
203 ········.value("Aspect_TOHM_BOUNDBOX",Aspect_TypeOfHighlightMethod::Aspect_TOHM_BOUNDBOX).export_values(); 
204 ····py::enum_<Aspect_TypeOfMarker>(m,·"Aspect_TypeOfMarker",R"#(Definition·of·types·of·markers)#")144 ····py::enum_<Aspect_TypeOfMarker>(m,·"Aspect_TypeOfMarker",R"#(Definition·of·types·of·markers)#")
205 ········.value("Aspect_TOM_EMPTY",Aspect_TypeOfMarker::Aspect_TOM_EMPTY)145 ········.value("Aspect_TOM_EMPTY",Aspect_TypeOfMarker::Aspect_TOM_EMPTY)
206 ········.value("Aspect_TOM_POINT",Aspect_TypeOfMarker::Aspect_TOM_POINT)146 ········.value("Aspect_TOM_POINT",Aspect_TypeOfMarker::Aspect_TOM_POINT)
207 ········.value("Aspect_TOM_PLUS",Aspect_TypeOfMarker::Aspect_TOM_PLUS)147 ········.value("Aspect_TOM_PLUS",Aspect_TypeOfMarker::Aspect_TOM_PLUS)
208 ········.value("Aspect_TOM_STAR",Aspect_TypeOfMarker::Aspect_TOM_STAR)148 ········.value("Aspect_TOM_STAR",Aspect_TypeOfMarker::Aspect_TOM_STAR)
209 ········.value("Aspect_TOM_X",Aspect_TypeOfMarker::Aspect_TOM_X)149 ········.value("Aspect_TOM_X",Aspect_TypeOfMarker::Aspect_TOM_X)
210 ········.value("Aspect_TOM_O",Aspect_TypeOfMarker::Aspect_TOM_O)150 ········.value("Aspect_TOM_O",Aspect_TypeOfMarker::Aspect_TOM_O)
Offset 216, 41 lines modifiedOffset 156, 29 lines modified
216 ········.value("Aspect_TOM_O_STAR",Aspect_TypeOfMarker::Aspect_TOM_O_STAR)156 ········.value("Aspect_TOM_O_STAR",Aspect_TypeOfMarker::Aspect_TOM_O_STAR)
217 ········.value("Aspect_TOM_O_X",Aspect_TypeOfMarker::Aspect_TOM_O_X)157 ········.value("Aspect_TOM_O_X",Aspect_TypeOfMarker::Aspect_TOM_O_X)
218 ········.value("Aspect_TOM_RING1",Aspect_TypeOfMarker::Aspect_TOM_RING1)158 ········.value("Aspect_TOM_RING1",Aspect_TypeOfMarker::Aspect_TOM_RING1)
219 ········.value("Aspect_TOM_RING2",Aspect_TypeOfMarker::Aspect_TOM_RING2)159 ········.value("Aspect_TOM_RING2",Aspect_TypeOfMarker::Aspect_TOM_RING2)
220 ········.value("Aspect_TOM_RING3",Aspect_TypeOfMarker::Aspect_TOM_RING3)160 ········.value("Aspect_TOM_RING3",Aspect_TypeOfMarker::Aspect_TOM_RING3)
221 ········.value("Aspect_TOM_BALL",Aspect_TypeOfMarker::Aspect_TOM_BALL)161 ········.value("Aspect_TOM_BALL",Aspect_TypeOfMarker::Aspect_TOM_BALL)
222 ········.value("Aspect_TOM_USERDEFINED",Aspect_TypeOfMarker::Aspect_TOM_USERDEFINED).export_values();162 ········.value("Aspect_TOM_USERDEFINED",Aspect_TypeOfMarker::Aspect_TOM_USERDEFINED).export_values();
 163 ····py::enum_<Aspect_Eye>(m,·"Aspect_Eye",R"#(Camera·eye·index·within·stereoscopic·pair.)#")
 164 ········.value("Aspect_Eye_Left",Aspect_Eye::Aspect_Eye_Left)
 165 ········.value("Aspect_Eye_Right",Aspect_Eye::Aspect_Eye_Right).export_values();
 166 ····py::enum_<Aspect_TypeOfColorScalePosition>(m,·"Aspect_TypeOfColorScalePosition",R"#(Defines·the·type·of·position·for·color·scale·labels)#")
 167 ········.value("Aspect_TOCSP_NONE",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_NONE)
Max diff block lines reached; 19085/31822 bytes (59.97%) of diff not shown.
⊟
12.0 KB
./usr/share/libocp/OCP/BRepBuilderAPI_pre.cpp
Ordering differences only
    
Offset 106, 53 lines modifiedOffset 106, 53 lines modified
106 py::module·m·=·main_module.def_submodule("BRepBuilderAPI",·R"#()#");106 py::module·m·=·main_module.def_submodule("BRepBuilderAPI",·R"#()#");
  
107 //·add·namespaces·as·submodules107 //·add·namespaces·as·submodules
  
108 //·user-defined·inclusion·per·module·in·the·body108 //·user-defined·inclusion·per·module·in·the·body
  
109 //·enums109 //·enums
 110 ····py::enum_<BRepBuilderAPI_ShapeModification>(m,·"BRepBuilderAPI_ShapeModification",R"#(Lists·the·possible·types·of·modification·to·a·shape·following·a·topological·operation:·Preserved,·Deleted,·Trimmed,·Merged·or·BoundaryModified.·This·enumeration·enables·you·to·assign·a·"state"·to·the·different·shapes·that·are·on·the·list·of·operands·for·each·API·function.·The·MakeShape·class·then·uses·this·to·determine·what·has·happened·to·the·shapes·which·constitute·the·list·of·operands.)#")
 111 ········.value("BRepBuilderAPI_Preserved",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Preserved)
 112 ········.value("BRepBuilderAPI_Deleted",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Deleted)
 113 ········.value("BRepBuilderAPI_Trimmed",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Trimmed)
 114 ········.value("BRepBuilderAPI_Merged",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Merged)
 115 ········.value("BRepBuilderAPI_BoundaryModified",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_BoundaryModified).export_values();
110 ····py::enum_<BRepBuilderAPI_FaceError>(m,·"BRepBuilderAPI_FaceError",R"#(Indicates·the·outcome·of·the·construction·of·a·face,·i.e.·whether·it·has·been·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_FaceDone·No·error·occurred.·The·face·is·correctly·built.·-·BRepBuilderAPI_NoFace·No·initialization·of·the·algorithm;·only·an·empty·constructor·was·used.·-·BRepBuilderAPI_NotPlanar·No·surface·was·given·and·the·wire·was·not·planar.·-·BRepBuilderAPI_CurveProjectionFailed·Not·used·so·far.·-·BRepBuilderAPI_ParametersOutOfRange·The·parameters·given·to·limit·the·surface·are·out·of·its·bounds.)#")116 ····py::enum_<BRepBuilderAPI_FaceError>(m,·"BRepBuilderAPI_FaceError",R"#(Indicates·the·outcome·of·the·construction·of·a·face,·i.e.·whether·it·has·been·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_FaceDone·No·error·occurred.·The·face·is·correctly·built.·-·BRepBuilderAPI_NoFace·No·initialization·of·the·algorithm;·only·an·empty·constructor·was·used.·-·BRepBuilderAPI_NotPlanar·No·surface·was·given·and·the·wire·was·not·planar.·-·BRepBuilderAPI_CurveProjectionFailed·Not·used·so·far.·-·BRepBuilderAPI_ParametersOutOfRange·The·parameters·given·to·limit·the·surface·are·out·of·its·bounds.)#")
111 ········.value("BRepBuilderAPI_FaceDone",BRepBuilderAPI_FaceError::BRepBuilderAPI_FaceDone)117 ········.value("BRepBuilderAPI_FaceDone",BRepBuilderAPI_FaceError::BRepBuilderAPI_FaceDone)
112 ········.value("BRepBuilderAPI_NoFace",BRepBuilderAPI_FaceError::BRepBuilderAPI_NoFace)118 ········.value("BRepBuilderAPI_NoFace",BRepBuilderAPI_FaceError::BRepBuilderAPI_NoFace)
113 ········.value("BRepBuilderAPI_NotPlanar",BRepBuilderAPI_FaceError::BRepBuilderAPI_NotPlanar)119 ········.value("BRepBuilderAPI_NotPlanar",BRepBuilderAPI_FaceError::BRepBuilderAPI_NotPlanar)
114 ········.value("BRepBuilderAPI_CurveProjectionFailed",BRepBuilderAPI_FaceError::BRepBuilderAPI_CurveProjectionFailed)120 ········.value("BRepBuilderAPI_CurveProjectionFailed",BRepBuilderAPI_FaceError::BRepBuilderAPI_CurveProjectionFailed)
115 ········.value("BRepBuilderAPI_ParametersOutOfRange",BRepBuilderAPI_FaceError::BRepBuilderAPI_ParametersOutOfRange).export_values();121 ········.value("BRepBuilderAPI_ParametersOutOfRange",BRepBuilderAPI_FaceError::BRepBuilderAPI_ParametersOutOfRange).export_values();
116 ····py::enum_<BRepBuilderAPI_EdgeError>(m,·"BRepBuilderAPI_EdgeError",R"#(Indicates·the·outcome·of·the·construction·of·an·edge,·i.e.·whether·it·has·been·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_EdgeDone·No·error·occurred;·The·edge·is·correctly·built.·-·BRepBuilderAPI_Po[·...·truncated·by·diffoscope;·len:·980,·SHA:·7b7b001d994dcc74990ac43b96363c5d245d584e5c0e6971ec4bb815c19aac1d·...·].)#")122 ····py::enum_<BRepBuilderAPI_PipeError>(m,·"BRepBuilderAPI_PipeError",R"#(Errors·that·can·occur·at·(shell)pipe·construction.)#")
117 ········.value("BRepBuilderAPI_EdgeDone",BRepBuilderAPI_EdgeError::BRepBuilderAPI_EdgeDone)123 ········.value("BRepBuilderAPI_PipeDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeDone)
118 ········.value("BRepBuilderAPI_PointProjectionFailed",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointProjectionFailed)124 ········.value("BRepBuilderAPI_PipeNotDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeNotDone)
119 ········.value("BRepBuilderAPI_ParameterOutOfRange",BRepBuilderAPI_EdgeError::BRepBuilderAPI_ParameterOutOfRange)125 ········.value("BRepBuilderAPI_PlaneNotIntersectGuide",BRepBuilderAPI_PipeError::BRepBuilderAPI_PlaneNotIntersectGuide)
120 ········.value("BRepBuilderAPI_DifferentPointsOnClosedCurve",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentPointsOnClosedCurve) 
121 ········.value("BRepBuilderAPI_PointWithInfiniteParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointWithInfiniteParameter) 
122 ········.value("BRepBuilderAPI_DifferentsPointAndParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentsPointAndParameter) 
123 ········.value("BRepBuilderAPI_LineThroughIdenticPoints",BRepBuilderAPI_EdgeError::BRepBuilderAPI_LineThroughIdenticPoints).export_values();126 ········.value("BRepBuilderAPI_ImpossibleContact",BRepBuilderAPI_PipeError::BRepBuilderAPI_ImpossibleContact).export_values();
124 ····py::enum_<BRepBuilderAPI_ShellError>(m,·"BRepBuilderAPI_ShellError",R"#(Indicates·the·outcome·of·the·construction·of·a·face,·i.e.·whether·it·is·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_ShellDone·No·error·occurred.·The·shell·is·correctly·built.·-·BRepBuilderAPI_EmptyShell·No·initialization·of·the·algorithm:·only·an·empty·constructor·was·used.·-·BRepBuilderAPI_DisconnectedShell·not·yet·used·-·BRepBuilderAPI_ShellParametersOutOfRange·The·parameters·given·to·limit·the·surface·are·out·of·its·bounds.)#")127 ····py::enum_<BRepBuilderAPI_ShellError>(m,·"BRepBuilderAPI_ShellError",R"#(Indicates·the·outcome·of·the·construction·of·a·face,·i.e.·whether·it·is·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_ShellDone·No·error·occurred.·The·shell·is·correctly·built.·-·BRepBuilderAPI_EmptyShell·No·initialization·of·the·algorithm:·only·an·empty·constructor·was·used.·-·BRepBuilderAPI_DisconnectedShell·not·yet·used·-·BRepBuilderAPI_ShellParametersOutOfRange·The·parameters·given·to·limit·the·surface·are·out·of·its·bounds.)#")
125 ········.value("BRepBuilderAPI_ShellDone",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellDone)128 ········.value("BRepBuilderAPI_ShellDone",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellDone)
126 ········.value("BRepBuilderAPI_EmptyShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_EmptyShell)129 ········.value("BRepBuilderAPI_EmptyShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_EmptyShell)
127 ········.value("BRepBuilderAPI_DisconnectedShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_DisconnectedShell)130 ········.value("BRepBuilderAPI_DisconnectedShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_DisconnectedShell)
128 ········.value("BRepBuilderAPI_ShellParametersOutOfRange",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellParametersOutOfRange).export_values();131 ········.value("BRepBuilderAPI_ShellParametersOutOfRange",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellParametersOutOfRange).export_values();
 132 ····py::enum_<BRepBuilderAPI_TransitionMode>(m,·"BRepBuilderAPI_TransitionMode",R"#(Option·to·manage·discontinuities·in·Sweep)#")
129 ····py::enum_<BRepBuilderAPI_ShapeModification>(m,·"BRepBuilderAPI_ShapeModification",R"#(Lists·the·possible·types·of·modification·to·a·shape·following·a·topological·operation:·Preserved,·Deleted,·Trimmed,·Merged·or·BoundaryModified.·This·enumeration·enables·you·to·assign·a·"state"·to·the·different·shapes·that·are·on·the·list·of·operands·for·each·API·function.·The·MakeShape·class·then·uses·this·to·determine·what·has·happened·to·the·shapes·which·constitute·the·list·of·operands.)#") 
130 ········.value("BRepBuilderAPI_Preserved",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Preserved) 
131 ········.value("BRepBuilderAPI_Deleted",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Deleted) 
132 ········.value("BRepBuilderAPI_Trimmed",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Trimmed)133 ········.value("BRepBuilderAPI_Transformed",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_Transformed)
133 ········.value("BRepBuilderAPI_Merged",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Merged)134 ········.value("BRepBuilderAPI_RightCorner",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_RightCorner)
134 ········.value("BRepBuilderAPI_BoundaryModified",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_BoundaryModified).export_values();135 ········.value("BRepBuilderAPI_RoundCorner",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_RoundCorner).export_values();
135 ····py::enum_<BRepBuilderAPI_WireError>(m,·"BRepBuilderAPI_WireError",R"#(Indicates·the·outcome·of·wire·construction,·i.e.·whether·it·is·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_WireDone·No·error·occurred.·The·wire·is·correctly·built.·-·BRepBuilderAPI_EmptyWire·No·initialization·of·the·algorithm.·Only·an·empty·constructor·was·used.·-·BRepBuilderAPI_DisconnectedWire·The·last·edge·which·you·attempted·to·add·was·not·connected·to·the·wire.·-·BRepBuilderAPI_NonManifoldWire·The·wire·with·some·singularity.)#")136 ····py::enum_<BRepBuilderAPI_WireError>(m,·"BRepBuilderAPI_WireError",R"#(Indicates·the·outcome·of·wire·construction,·i.e.·whether·it·is·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_WireDone·No·error·occurred.·The·wire·is·correctly·built.·-·BRepBuilderAPI_EmptyWire·No·initialization·of·the·algorithm.·Only·an·empty·constructor·was·used.·-·BRepBuilderAPI_DisconnectedWire·The·last·edge·which·you·attempted·to·add·was·not·connected·to·the·wire.·-·BRepBuilderAPI_NonManifoldWire·The·wire·with·some·singularity.)#")
136 ········.value("BRepBuilderAPI_WireDone",BRepBuilderAPI_WireError::BRepBuilderAPI_WireDone)137 ········.value("BRepBuilderAPI_WireDone",BRepBuilderAPI_WireError::BRepBuilderAPI_WireDone)
137 ········.value("BRepBuilderAPI_EmptyWire",BRepBuilderAPI_WireError::BRepBuilderAPI_EmptyWire)138 ········.value("BRepBuilderAPI_EmptyWire",BRepBuilderAPI_WireError::BRepBuilderAPI_EmptyWire)
138 ········.value("BRepBuilderAPI_DisconnectedWire",BRepBuilderAPI_WireError::BRepBuilderAPI_DisconnectedWire)139 ········.value("BRepBuilderAPI_DisconnectedWire",BRepBuilderAPI_WireError::BRepBuilderAPI_DisconnectedWire)
139 ········.value("BRepBuilderAPI_NonManifoldWire",BRepBuilderAPI_WireError::BRepBuilderAPI_NonManifoldWire).export_values();140 ········.value("BRepBuilderAPI_NonManifoldWire",BRepBuilderAPI_WireError::BRepBuilderAPI_NonManifoldWire).export_values();
140 ····py::enum_<BRepBuilderAPI_PipeError>(m,·"BRepBuilderAPI_PipeError",R"#(Errors·that·can·occur·at·(shell)pipe·construction.)#")141 ····py::enum_<BRepBuilderAPI_EdgeError>(m,·"BRepBuilderAPI_EdgeError",R"#(Indicates·the·outcome·of·the·construction·of·an·edge,·i.e.·whether·it·has·been·successful·or·not,·as·explained·below:·-·BRepBuilderAPI_EdgeDone·No·error·occurred;·The·edge·is·correctly·built.·-·BRepBuilderAPI_Po[·...·truncated·by·diffoscope;·len:·980,·SHA:·7b7b001d994dcc74990ac43b96363c5d245d584e5c0e6971ec4bb815c19aac1d·...·].)#")
141 ········.value("BRepBuilderAPI_PipeDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeDone)142 ········.value("BRepBuilderAPI_EdgeDone",BRepBuilderAPI_EdgeError::BRepBuilderAPI_EdgeDone)
142 ········.value("BRepBuilderAPI_PipeNotDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeNotDone)143 ········.value("BRepBuilderAPI_PointProjectionFailed",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointProjectionFailed)
143 ········.value("BRepBuilderAPI_PlaneNotIntersectGuide",BRepBuilderAPI_PipeError::BRepBuilderAPI_PlaneNotIntersectGuide)144 ········.value("BRepBuilderAPI_ParameterOutOfRange",BRepBuilderAPI_EdgeError::BRepBuilderAPI_ParameterOutOfRange)
 145 ········.value("BRepBuilderAPI_DifferentPointsOnClosedCurve",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentPointsOnClosedCurve)
 146 ········.value("BRepBuilderAPI_PointWithInfiniteParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointWithInfiniteParameter)
 147 ········.value("BRepBuilderAPI_DifferentsPointAndParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentsPointAndParameter)
144 ········.value("BRepBuilderAPI_ImpossibleContact",BRepBuilderAPI_PipeError::BRepBuilderAPI_ImpossibleContact).export_values();148 ········.value("BRepBuilderAPI_LineThroughIdenticPoints",BRepBuilderAPI_EdgeError::BRepBuilderAPI_LineThroughIdenticPoints).export_values();
145 ····py::enum_<BRepBuilderAPI_TransitionMode>(m,·"BRepBuilderAPI_TransitionMode",R"#(Option·to·manage·discontinuities·in·Sweep)#") 
146 ········.value("BRepBuilderAPI_Transformed",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_Transformed) 
147 ········.value("BRepBuilderAPI_RightCorner",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_RightCorner) 
148 ········.value("BRepBuilderAPI_RoundCorner",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_RoundCorner).export_values(); 
  
149 //Python·trampoline·classes149 //Python·trampoline·classes
  
150 //·pre-register·typdefs+classes·(topologically·sorted)150 //·pre-register·typdefs+classes·(topologically·sorted)
151 ····py::class_<BRepBuilderAPI·,·shared_ptr<BRepBuilderAPI>··>(m,"BRepBuilderAPI",R"#(The·BRepBuilderAPI·package·provides·an·Application·Programming·Interface·for·the·BRep·topology·data·structure.)#");151 ····py::class_<BRepBuilderAPI·,·shared_ptr<BRepBuilderAPI>··>(m,"BRepBuilderAPI",R"#(The·BRepBuilderAPI·package·provides·an·Application·Programming·Interface·for·the·BRep·topology·data·structure.)#");
152 ····py::class_<BRepBuilderAPI_Collect·,·shared_ptr<BRepBuilderAPI_Collect>··>(m,"BRepBuilderAPI_Collect",R"#()#");152 ····py::class_<BRepBuilderAPI_Collect·,·shared_ptr<BRepBuilderAPI_Collect>··>(m,"BRepBuilderAPI_Collect",R"#()#");
153 ····py::class_<BRepBuilderAPI_Command·,·shared_ptr<BRepBuilderAPI_Command>··>(m,"BRepBuilderAPI_Command",R"#(Root·class·for·all·commands·in·BRepBuilderAPI.)#");153 ····py::class_<BRepBuilderAPI_Command·,·shared_ptr<BRepBuilderAPI_Command>··>(m,"BRepBuilderAPI_Command",R"#(Root·class·for·all·commands·in·BRepBuilderAPI.)#");
⊟
2.39 KB
./usr/share/libocp/OCP/BRepFeat_pre.cpp
Ordering differences only
    
Offset 105, 24 lines modifiedOffset 105, 24 lines modified
105 ········.value("BRepFeat_NoParts",BRepFeat_StatusError::BRepFeat_NoParts)105 ········.value("BRepFeat_NoParts",BRepFeat_StatusError::BRepFeat_NoParts)
106 ········.value("BRepFeat_NoProjPt",BRepFeat_StatusError::BRepFeat_NoProjPt)106 ········.value("BRepFeat_NoProjPt",BRepFeat_StatusError::BRepFeat_NoProjPt)
107 ········.value("BRepFeat_NotInitialized",BRepFeat_StatusError::BRepFeat_NotInitialized)107 ········.value("BRepFeat_NotInitialized",BRepFeat_StatusError::BRepFeat_NotInitialized)
108 ········.value("BRepFeat_NotYetImplemented",BRepFeat_StatusError::BRepFeat_NotYetImplemented)108 ········.value("BRepFeat_NotYetImplemented",BRepFeat_StatusError::BRepFeat_NotYetImplemented)
109 ········.value("BRepFeat_NullRealTool",BRepFeat_StatusError::BRepFeat_NullRealTool)109 ········.value("BRepFeat_NullRealTool",BRepFeat_StatusError::BRepFeat_NullRealTool)
110 ········.value("BRepFeat_NullToolF",BRepFeat_StatusError::BRepFeat_NullToolF)110 ········.value("BRepFeat_NullToolF",BRepFeat_StatusError::BRepFeat_NullToolF)
111 ········.value("BRepFeat_NullToolU",BRepFeat_StatusError::BRepFeat_NullToolU).export_values();111 ········.value("BRepFeat_NullToolU",BRepFeat_StatusError::BRepFeat_NullToolU).export_values();
112 ····py::enum_<BRepFeat_Status>(m,·"BRepFeat_Status",R"#()#") 
113 ········.value("BRepFeat_NoError",BRepFeat_Status::BRepFeat_NoError) 
114 ········.value("BRepFeat_InvalidPlacement",BRepFeat_Status::BRepFeat_InvalidPlacement) 
115 ········.value("BRepFeat_HoleTooLong",BRepFeat_Status::BRepFeat_HoleTooLong).export_values(); 
116 ····py::enum_<BRepFeat_PerfSelection>(m,·"BRepFeat_PerfSelection",R"#(To·declare·the·type·of·selection·semantics·for·local·operation·Perform·methods·-·NoSelection·-·SelectionFU·-·selection·of·a·face·up·to·which·a·local·operation·will·be·performed·-·SelectionU·-·selection·of·a·point·up·to·which·a·local·operation·will·be·performed·-·SelectionSh·-·selection·of·a·shape·on·which·a·local·operation·will·be·performed·-·SelectionShU·-·selection·of·a·shape·up·to·which·a·local·operation·will·be·performed.)#")112 ····py::enum_<BRepFeat_PerfSelection>(m,·"BRepFeat_PerfSelection",R"#(To·declare·the·type·of·selection·semantics·for·local·operation·Perform·methods·-·NoSelection·-·SelectionFU·-·selection·of·a·face·up·to·which·a·local·operation·will·be·performed·-·SelectionU·-·selection·of·a·point·up·to·which·a·local·operation·will·be·performed·-·SelectionSh·-·selection·of·a·shape·on·which·a·local·operation·will·be·performed·-·SelectionShU·-·selection·of·a·shape·up·to·which·a·local·operation·will·be·performed.)#")
117 ········.value("BRepFeat_NoSelection",BRepFeat_PerfSelection::BRepFeat_NoSelection)113 ········.value("BRepFeat_NoSelection",BRepFeat_PerfSelection::BRepFeat_NoSelection)
118 ········.value("BRepFeat_SelectionFU",BRepFeat_PerfSelection::BRepFeat_SelectionFU)114 ········.value("BRepFeat_SelectionFU",BRepFeat_PerfSelection::BRepFeat_SelectionFU)
119 ········.value("BRepFeat_SelectionU",BRepFeat_PerfSelection::BRepFeat_SelectionU)115 ········.value("BRepFeat_SelectionU",BRepFeat_PerfSelection::BRepFeat_SelectionU)
120 ········.value("BRepFeat_SelectionSh",BRepFeat_PerfSelection::BRepFeat_SelectionSh)116 ········.value("BRepFeat_SelectionSh",BRepFeat_PerfSelection::BRepFeat_SelectionSh)
121 ········.value("BRepFeat_SelectionShU",BRepFeat_PerfSelection::BRepFeat_SelectionShU).export_values();117 ········.value("BRepFeat_SelectionShU",BRepFeat_PerfSelection::BRepFeat_SelectionShU).export_values();
 118 ····py::enum_<BRepFeat_Status>(m,·"BRepFeat_Status",R"#()#")
 119 ········.value("BRepFeat_NoError",BRepFeat_Status::BRepFeat_NoError)
 120 ········.value("BRepFeat_InvalidPlacement",BRepFeat_Status::BRepFeat_InvalidPlacement)
 121 ········.value("BRepFeat_HoleTooLong",BRepFeat_Status::BRepFeat_HoleTooLong).export_values();
  
122 //Python·trampoline·classes122 //Python·trampoline·classes
123 ····class·Py_BRepFeat_Form·:·public·BRepFeat_Form{123 ····class·Py_BRepFeat_Form·:·public·BRepFeat_Form{
124 ····public:124 ····public:
125 ········using·BRepFeat_Form::BRepFeat_Form;125 ········using·BRepFeat_Form::BRepFeat_Form;
  
  
⊟
2.49 KB
./usr/share/libocp/OCP/BRepFill_pre.cpp
Ordering differences only
    
Offset 160, 26 lines modifiedOffset 160, 26 lines modified
160 py::module·m·=·main_module.def_submodule("BRepFill",·R"#()#");160 py::module·m·=·main_module.def_submodule("BRepFill",·R"#()#");
  
161 //·add·namespaces·as·submodules161 //·add·namespaces·as·submodules
  
162 //·user-defined·inclusion·per·module·in·the·body162 //·user-defined·inclusion·per·module·in·the·body
  
163 //·enums163 //·enums
164 ····py::enum_<BRepFill_TransitionStyle>(m,·"BRepFill_TransitionStyle",R"#()#") 
165 ········.value("BRepFill_Modified",BRepFill_TransitionStyle::BRepFill_Modified) 
166 ········.value("BRepFill_Right",BRepFill_TransitionStyle::BRepFill_Right) 
167 ········.value("BRepFill_Round",BRepFill_TransitionStyle::BRepFill_Round).export_values(); 
168 ····py::enum_<BRepFill_ThruSectionErrorStatus>(m,·"BRepFill_ThruSectionErrorStatus",R"#(Errors·that·can·occur·at·thrusection·algorithm.)#")164 ····py::enum_<BRepFill_ThruSectionErrorStatus>(m,·"BRepFill_ThruSectionErrorStatus",R"#(Errors·that·can·occur·at·thrusection·algorithm.)#")
169 ········.value("BRepFill_ThruSectionErrorStatus_Done",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Done)165 ········.value("BRepFill_ThruSectionErrorStatus_Done",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Done)
170 ········.value("BRepFill_ThruSectionErrorStatus_NotDone",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotDone)166 ········.value("BRepFill_ThruSectionErrorStatus_NotDone",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotDone)
171 ········.value("BRepFill_ThruSectionErrorStatus_NotSameTopology",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotSameTopology)167 ········.value("BRepFill_ThruSectionErrorStatus_NotSameTopology",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotSameTopology)
172 ········.value("BRepFill_ThruSectionErrorStatus_ProfilesInconsistent",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_ProfilesInconsistent)168 ········.value("BRepFill_ThruSectionErrorStatus_ProfilesInconsistent",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_ProfilesInconsistent)
173 ········.value("BRepFill_ThruSectionErrorStatus_WrongUsage",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_WrongUsage)169 ········.value("BRepFill_ThruSectionErrorStatus_WrongUsage",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_WrongUsage)
174 ········.value("BRepFill_ThruSectionErrorStatus_Null3DCurve",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Null3DCurve)170 ········.value("BRepFill_ThruSectionErrorStatus_Null3DCurve",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Null3DCurve)
175 ········.value("BRepFill_ThruSectionErrorStatus_Failed",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Failed).export_values();171 ········.value("BRepFill_ThruSectionErrorStatus_Failed",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Failed).export_values();
 172 ····py::enum_<BRepFill_TransitionStyle>(m,·"BRepFill_TransitionStyle",R"#()#")
 173 ········.value("BRepFill_Modified",BRepFill_TransitionStyle::BRepFill_Modified)
 174 ········.value("BRepFill_Right",BRepFill_TransitionStyle::BRepFill_Right)
 175 ········.value("BRepFill_Round",BRepFill_TransitionStyle::BRepFill_Round).export_values();
176 ····py::enum_<BRepFill_TypeOfContact>(m,·"BRepFill_TypeOfContact",R"#(A·pair·of·bound·shapes·with·the·result.)#")176 ····py::enum_<BRepFill_TypeOfContact>(m,·"BRepFill_TypeOfContact",R"#(A·pair·of·bound·shapes·with·the·result.)#")
177 ········.value("BRepFill_NoContact",BRepFill_TypeOfContact::BRepFill_NoContact)177 ········.value("BRepFill_NoContact",BRepFill_TypeOfContact::BRepFill_NoContact)
178 ········.value("BRepFill_Contact",BRepFill_TypeOfContact::BRepFill_Contact)178 ········.value("BRepFill_Contact",BRepFill_TypeOfContact::BRepFill_Contact)
179 ········.value("BRepFill_ContactOnBorder",BRepFill_TypeOfContact::BRepFill_ContactOnBorder).export_values();179 ········.value("BRepFill_ContactOnBorder",BRepFill_TypeOfContact::BRepFill_ContactOnBorder).export_values();
  
180 //Python·trampoline·classes180 //Python·trampoline·classes
181 ····class·Py_BRepFill_SectionLaw·:·public·BRepFill_SectionLaw{181 ····class·Py_BRepFill_SectionLaw·:·public·BRepFill_SectionLaw{
⊟
4.28 KB
./usr/share/libocp/OCP/BRepLib_pre.cpp
Ordering differences only
    
Offset 100, 44 lines modifiedOffset 100, 44 lines modified
100 py::module·m·=·main_module.def_submodule("BRepLib",·R"#()#");100 py::module·m·=·main_module.def_submodule("BRepLib",·R"#()#");
  
101 //·add·namespaces·as·submodules101 //·add·namespaces·as·submodules
  
102 //·user-defined·inclusion·per·module·in·the·body102 //·user-defined·inclusion·per·module·in·the·body
  
103 //·enums103 //·enums
 104 ····py::enum_<BRepLib_ShellError>(m,·"BRepLib_ShellError",R"#(Errors·that·can·occur·at·shell·construction.)#")
 105 ········.value("BRepLib_ShellDone",BRepLib_ShellError::BRepLib_ShellDone)
 106 ········.value("BRepLib_EmptyShell",BRepLib_ShellError::BRepLib_EmptyShell)
 107 ········.value("BRepLib_DisconnectedShell",BRepLib_ShellError::BRepLib_DisconnectedShell)
 108 ········.value("BRepLib_ShellParametersOutOfRange",BRepLib_ShellError::BRepLib_ShellParametersOutOfRange).export_values();
104 ····py::enum_<BRepLib_ShapeModification>(m,·"BRepLib_ShapeModification",R"#(Modification·type·after·a·topologic·operation.)#") 
105 ········.value("BRepLib_Preserved",BRepLib_ShapeModification::BRepLib_Preserved) 
106 ········.value("BRepLib_Deleted",BRepLib_ShapeModification::BRepLib_Deleted) 
107 ········.value("BRepLib_Trimmed",BRepLib_ShapeModification::BRepLib_Trimmed) 
108 ········.value("BRepLib_Merged",BRepLib_ShapeModification::BRepLib_Merged) 
109 ········.value("BRepLib_BoundaryModified",BRepLib_ShapeModification::BRepLib_BoundaryModified).export_values(); 
110 ····py::enum_<BRepLib_WireError>(m,·"BRepLib_WireError",R"#(Errors·that·can·occur·at·wire·construction.·no·error)#")109 ····py::enum_<BRepLib_WireError>(m,·"BRepLib_WireError",R"#(Errors·that·can·occur·at·wire·construction.·no·error)#")
111 ········.value("BRepLib_WireDone",BRepLib_WireError::BRepLib_WireDone)110 ········.value("BRepLib_WireDone",BRepLib_WireError::BRepLib_WireDone)
112 ········.value("BRepLib_EmptyWire",BRepLib_WireError::BRepLib_EmptyWire)111 ········.value("BRepLib_EmptyWire",BRepLib_WireError::BRepLib_EmptyWire)
113 ········.value("BRepLib_DisconnectedWire",BRepLib_WireError::BRepLib_DisconnectedWire)112 ········.value("BRepLib_DisconnectedWire",BRepLib_WireError::BRepLib_DisconnectedWire)
114 ········.value("BRepLib_NonManifoldWire",BRepLib_WireError::BRepLib_NonManifoldWire).export_values();113 ········.value("BRepLib_NonManifoldWire",BRepLib_WireError::BRepLib_NonManifoldWire).export_values();
115 ····py::enum_<BRepLib_EdgeError>(m,·"BRepLib_EdgeError",R"#(Errors·that·can·occur·at·edge·construction.·no·error)#")114 ····py::enum_<BRepLib_EdgeError>(m,·"BRepLib_EdgeError",R"#(Errors·that·can·occur·at·edge·construction.·no·error)#")
116 ········.value("BRepLib_EdgeDone",BRepLib_EdgeError::BRepLib_EdgeDone)115 ········.value("BRepLib_EdgeDone",BRepLib_EdgeError::BRepLib_EdgeDone)
117 ········.value("BRepLib_PointProjectionFailed",BRepLib_EdgeError::BRepLib_PointProjectionFailed)116 ········.value("BRepLib_PointProjectionFailed",BRepLib_EdgeError::BRepLib_PointProjectionFailed)
118 ········.value("BRepLib_ParameterOutOfRange",BRepLib_EdgeError::BRepLib_ParameterOutOfRange)117 ········.value("BRepLib_ParameterOutOfRange",BRepLib_EdgeError::BRepLib_ParameterOutOfRange)
119 ········.value("BRepLib_DifferentPointsOnClosedCurve",BRepLib_EdgeError::BRepLib_DifferentPointsOnClosedCurve)118 ········.value("BRepLib_DifferentPointsOnClosedCurve",BRepLib_EdgeError::BRepLib_DifferentPointsOnClosedCurve)
120 ········.value("BRepLib_PointWithInfiniteParameter",BRepLib_EdgeError::BRepLib_PointWithInfiniteParameter)119 ········.value("BRepLib_PointWithInfiniteParameter",BRepLib_EdgeError::BRepLib_PointWithInfiniteParameter)
121 ········.value("BRepLib_DifferentsPointAndParameter",BRepLib_EdgeError::BRepLib_DifferentsPointAndParameter)120 ········.value("BRepLib_DifferentsPointAndParameter",BRepLib_EdgeError::BRepLib_DifferentsPointAndParameter)
122 ········.value("BRepLib_LineThroughIdenticPoints",BRepLib_EdgeError::BRepLib_LineThroughIdenticPoints).export_values();121 ········.value("BRepLib_LineThroughIdenticPoints",BRepLib_EdgeError::BRepLib_LineThroughIdenticPoints).export_values();
123 ····py::enum_<BRepLib_ShellError>(m,·"BRepLib_ShellError",R"#(Errors·that·can·occur·at·shell·construction.)#") 
124 ········.value("BRepLib_ShellDone",BRepLib_ShellError::BRepLib_ShellDone) 
125 ········.value("BRepLib_EmptyShell",BRepLib_ShellError::BRepLib_EmptyShell) 
126 ········.value("BRepLib_DisconnectedShell",BRepLib_ShellError::BRepLib_DisconnectedShell) 
127 ········.value("BRepLib_ShellParametersOutOfRange",BRepLib_ShellError::BRepLib_ShellParametersOutOfRange).export_values(); 
128 ····py::enum_<BRepLib_FaceError>(m,·"BRepLib_FaceError",R"#(Errors·that·can·occur·at·face·construction.·no·error·not·initialised)#")122 ····py::enum_<BRepLib_FaceError>(m,·"BRepLib_FaceError",R"#(Errors·that·can·occur·at·face·construction.·no·error·not·initialised)#")
129 ········.value("BRepLib_FaceDone",BRepLib_FaceError::BRepLib_FaceDone)123 ········.value("BRepLib_FaceDone",BRepLib_FaceError::BRepLib_FaceDone)
130 ········.value("BRepLib_NoFace",BRepLib_FaceError::BRepLib_NoFace)124 ········.value("BRepLib_NoFace",BRepLib_FaceError::BRepLib_NoFace)
131 ········.value("BRepLib_NotPlanar",BRepLib_FaceError::BRepLib_NotPlanar)125 ········.value("BRepLib_NotPlanar",BRepLib_FaceError::BRepLib_NotPlanar)
132 ········.value("BRepLib_CurveProjectionFailed",BRepLib_FaceError::BRepLib_CurveProjectionFailed)126 ········.value("BRepLib_CurveProjectionFailed",BRepLib_FaceError::BRepLib_CurveProjectionFailed)
133 ········.value("BRepLib_ParametersOutOfRange",BRepLib_FaceError::BRepLib_ParametersOutOfRange).export_values();127 ········.value("BRepLib_ParametersOutOfRange",BRepLib_FaceError::BRepLib_ParametersOutOfRange).export_values();
 128 ····py::enum_<BRepLib_ShapeModification>(m,·"BRepLib_ShapeModification",R"#(Modification·type·after·a·topologic·operation.)#")
 129 ········.value("BRepLib_Preserved",BRepLib_ShapeModification::BRepLib_Preserved)
 130 ········.value("BRepLib_Deleted",BRepLib_ShapeModification::BRepLib_Deleted)
 131 ········.value("BRepLib_Trimmed",BRepLib_ShapeModification::BRepLib_Trimmed)
 132 ········.value("BRepLib_Merged",BRepLib_ShapeModification::BRepLib_Merged)
 133 ········.value("BRepLib_BoundaryModified",BRepLib_ShapeModification::BRepLib_BoundaryModified).export_values();
  
134 //Python·trampoline·classes134 //Python·trampoline·classes
135 ····class·Py_BRepLib_PointCloudShape·:·public·BRepLib_PointCloudShape{135 ····class·Py_BRepLib_PointCloudShape·:·public·BRepLib_PointCloudShape{
136 ····public:136 ····public:
137 ········using·BRepLib_PointCloudShape::BRepLib_PointCloudShape;137 ········using·BRepLib_PointCloudShape::BRepLib_PointCloudShape;
  
  
⊟
5.14 KB
./usr/share/libocp/OCP/BRepOffset_pre.cpp
Ordering differences only
    
Offset 90, 42 lines modifiedOffset 90, 42 lines modified
90 py::module·m·=·main_module.def_submodule("BRepOffset",·R"#()#");90 py::module·m·=·main_module.def_submodule("BRepOffset",·R"#()#");
  
91 //·add·namespaces·as·submodules91 //·add·namespaces·as·submodules
  
92 //·user-defined·inclusion·per·module·in·the·body92 //·user-defined·inclusion·per·module·in·the·body
  
93 //·enums93 //·enums
 94 ····py::enum_<BRepOffset_Status>(m,·"BRepOffset_Status",R"#(status·of·an·offset·face·Good·:·Reversed·:·e.g.·Offset·>·Radius·of·a·cylinder·Degenerated·:·e.g.·Offset·=·Radius·of·a·cylinder·Unknown·:·e.g.·for·a·Beziersurf)#")
 95 ········.value("BRepOffset_Good",BRepOffset_Status::BRepOffset_Good)
 96 ········.value("BRepOffset_Reversed",BRepOffset_Status::BRepOffset_Reversed)
 97 ········.value("BRepOffset_Degenerated",BRepOffset_Status::BRepOffset_Degenerated)
 98 ········.value("BRepOffset_Unknown",BRepOffset_Status::BRepOffset_Unknown).export_values();
94 ····py::enum_<BRepOffset_Mode>(m,·"BRepOffset_Mode",R"#(Lists·the·offset·modes.·These·are·the·following:·-·BRepOffset_Skin·which·describes·the·offset·along·the·surface·of·a·solid,·used·to·obtain·a·manifold·topological·space,·-·BRepOffset_Pipe·which·describes·the·offset·of·a·curve,·used·to·obtain·a·pre-surface,·-·BRepOffset_RectoVerso·which·describes·the·offset·of·a·given·surface·shell·along·both·sides·of·the·surface.)#")99 ····py::enum_<BRepOffset_Mode>(m,·"BRepOffset_Mode",R"#(Lists·the·offset·modes.·These·are·the·following:·-·BRepOffset_Skin·which·describes·the·offset·along·the·surface·of·a·solid,·used·to·obtain·a·manifold·topological·space,·-·BRepOffset_Pipe·which·describes·the·offset·of·a·curve,·used·to·obtain·a·pre-surface,·-·BRepOffset_RectoVerso·which·describes·the·offset·of·a·given·surface·shell·along·both·sides·of·the·surface.)#")
95 ········.value("BRepOffset_Skin",BRepOffset_Mode::BRepOffset_Skin)100 ········.value("BRepOffset_Skin",BRepOffset_Mode::BRepOffset_Skin)
96 ········.value("BRepOffset_Pipe",BRepOffset_Mode::BRepOffset_Pipe)101 ········.value("BRepOffset_Pipe",BRepOffset_Mode::BRepOffset_Pipe)
97 ········.value("BRepOffset_RectoVerso",BRepOffset_Mode::BRepOffset_RectoVerso).export_values();102 ········.value("BRepOffset_RectoVerso",BRepOffset_Mode::BRepOffset_RectoVerso).export_values();
98 ····py::enum_<BRepOffsetSimple_Status>(m,·"BRepOffsetSimple_Status",R"#()#") 
99 ········.value("BRepOffsetSimple_OK",BRepOffsetSimple_Status::BRepOffsetSimple_OK) 
100 ········.value("BRepOffsetSimple_NullInputShape",BRepOffsetSimple_Status::BRepOffsetSimple_NullInputShape) 
101 ········.value("BRepOffsetSimple_ErrorOffsetComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorOffsetComputation) 
102 ········.value("BRepOffsetSimple_ErrorWallFaceComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorWallFaceComputation) 
103 ········.value("BRepOffsetSimple_ErrorInvalidNbShells",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorInvalidNbShells) 
104 ········.value("BRepOffsetSimple_ErrorNonClosedShell",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorNonClosedShell).export_values(); 
105 ····py::enum_<BRepOffset_Error>(m,·"BRepOffset_Error",R"#()#")103 ····py::enum_<BRepOffset_Error>(m,·"BRepOffset_Error",R"#()#")
106 ········.value("BRepOffset_NoError",BRepOffset_Error::BRepOffset_NoError)104 ········.value("BRepOffset_NoError",BRepOffset_Error::BRepOffset_NoError)
107 ········.value("BRepOffset_UnknownError",BRepOffset_Error::BRepOffset_UnknownError)105 ········.value("BRepOffset_UnknownError",BRepOffset_Error::BRepOffset_UnknownError)
108 ········.value("BRepOffset_BadNormalsOnGeometry",BRepOffset_Error::BRepOffset_BadNormalsOnGeometry)106 ········.value("BRepOffset_BadNormalsOnGeometry",BRepOffset_Error::BRepOffset_BadNormalsOnGeometry)
109 ········.value("BRepOffset_C0Geometry",BRepOffset_Error::BRepOffset_C0Geometry)107 ········.value("BRepOffset_C0Geometry",BRepOffset_Error::BRepOffset_C0Geometry)
110 ········.value("BRepOffset_NullOffset",BRepOffset_Error::BRepOffset_NullOffset)108 ········.value("BRepOffset_NullOffset",BRepOffset_Error::BRepOffset_NullOffset)
111 ········.value("BRepOffset_NotConnectedShell",BRepOffset_Error::BRepOffset_NotConnectedShell)109 ········.value("BRepOffset_NotConnectedShell",BRepOffset_Error::BRepOffset_NotConnectedShell)
112 ········.value("BRepOffset_CannotTrimEdges",BRepOffset_Error::BRepOffset_CannotTrimEdges)110 ········.value("BRepOffset_CannotTrimEdges",BRepOffset_Error::BRepOffset_CannotTrimEdges)
113 ········.value("BRepOffset_CannotFuseVertices",BRepOffset_Error::BRepOffset_CannotFuseVertices)111 ········.value("BRepOffset_CannotFuseVertices",BRepOffset_Error::BRepOffset_CannotFuseVertices)
114 ········.value("BRepOffset_CannotExtentEdge",BRepOffset_Error::BRepOffset_CannotExtentEdge)112 ········.value("BRepOffset_CannotExtentEdge",BRepOffset_Error::BRepOffset_CannotExtentEdge)
115 ········.value("BRepOffset_UserBreak",BRepOffset_Error::BRepOffset_UserBreak)113 ········.value("BRepOffset_UserBreak",BRepOffset_Error::BRepOffset_UserBreak)
116 ········.value("BRepOffset_MixedConnectivity",BRepOffset_Error::BRepOffset_MixedConnectivity).export_values();114 ········.value("BRepOffset_MixedConnectivity",BRepOffset_Error::BRepOffset_MixedConnectivity).export_values();
117 ····py::enum_<BRepOffset_Status>(m,·"BRepOffset_Status",R"#(status·of·an·offset·face·Good·:·Reversed·:·e.g.·Offset·>·Radius·of·a·cylinder·Degenerated·:·e.g.·Offset·=·Radius·of·a·cylinder·Unknown·:·e.g.·for·a·Beziersurf)#")115 ····py::enum_<BRepOffsetSimple_Status>(m,·"BRepOffsetSimple_Status",R"#()#")
118 ········.value("BRepOffset_Good",BRepOffset_Status::BRepOffset_Good)116 ········.value("BRepOffsetSimple_OK",BRepOffsetSimple_Status::BRepOffsetSimple_OK)
119 ········.value("BRepOffset_Reversed",BRepOffset_Status::BRepOffset_Reversed) 
120 ········.value("BRepOffset_Degenerated",BRepOffset_Status::BRepOffset_Degenerated) 
121 ········.value("BRepOffset_Unknown",BRepOffset_Status::BRepOffset_Unknown).export_values();117 ········.value("BRepOffsetSimple_NullInputShape",BRepOffsetSimple_Status::BRepOffsetSimple_NullInputShape)
 118 ········.value("BRepOffsetSimple_ErrorOffsetComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorOffsetComputation)
 119 ········.value("BRepOffsetSimple_ErrorWallFaceComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorWallFaceComputation)
 120 ········.value("BRepOffsetSimple_ErrorInvalidNbShells",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorInvalidNbShells)
 121 ········.value("BRepOffsetSimple_ErrorNonClosedShell",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorNonClosedShell).export_values();
  
122 //Python·trampoline·classes122 //Python·trampoline·classes
  
123 //·pre-register·typdefs+classes·(topologically·sorted)123 //·pre-register·typdefs+classes·(topologically·sorted)
124 ····py::class_<BRepOffset·,·shared_ptr<BRepOffset>··>(m,"BRepOffset",R"#(Auxiliary·tools·for·offset·algorithms)#");124 ····py::class_<BRepOffset·,·shared_ptr<BRepOffset>··>(m,"BRepOffset",R"#(Auxiliary·tools·for·offset·algorithms)#");
125 ····py::class_<BRepOffset_Analyse·,·shared_ptr<BRepOffset_Analyse>··>(m,"BRepOffset_Analyse",R"#(Analyses·the·shape·to·find·the·parts·of·edges·connecting·the·convex,·concave·or·tangent·faces.)#");125 ····py::class_<BRepOffset_Analyse·,·shared_ptr<BRepOffset_Analyse>··>(m,"BRepOffset_Analyse",R"#(Analyses·the·shape·to·find·the·parts·of·edges·connecting·the·convex,·concave·or·tangent·faces.)#");
126 ····py::class_<BRepOffset_Inter2d·,·shared_ptr<BRepOffset_Inter2d>··>(m,"BRepOffset_Inter2d",R"#(Computes·the·intersections·between·edges·on·a·face·stores·result·is·SD·as·AsDes·from·BRepOffset.)#");126 ····py::class_<BRepOffset_Inter2d·,·shared_ptr<BRepOffset_Inter2d>··>(m,"BRepOffset_Inter2d",R"#(Computes·the·intersections·between·edges·on·a·face·stores·result·is·SD·as·AsDes·from·BRepOffset.)#");
⊟
99.5 KB
./usr/share/libocp/OCP/BVH_tmpl.hxx
Ordering differences only
    
Offset 47, 278 lines modifiedOffset 47, 14 lines modified
  
47 //·user-defined·pre47 //·user-defined·pre
48 #include·"OCP_specific.inc"48 #include·"OCP_specific.inc"
  
49 //·Class·template·handling·functions49 //·Class·template·handling·functions
  
50 template·<typename·T,int·N>50 template·<typename·T,int·N>
51 void·preregister_template_BVH_ObjectSet(py::object·&m,·const·char·*name){ 
52 ····py::class_<BVH_ObjectSet<T,N>·,·shared_ptr<BVH_ObjectSet<T,N>>·>(m,name,R"#(Array·of·abstract·entities·(bounded·by·BVH·boxes)·to·built·BVH.)#"); 
53 } 
  
54 template·<typename·T,int·N> 
55 void·register_template_BVH_ObjectSet(py::object·&m,·const·char·*name){ 
56 ····static_cast<py::class_<BVH_ObjectSet<T,N>·,·shared_ptr<BVH_ObjectSet<T,N>>·>>(m.attr(name)) 
57 ········.def(py::init<··>()··) 
58 ········.def("Clear", 
59 ·············(void·(BVH_ObjectSet<T,N>::*)()·)·&BVH_ObjectSet<T,N>::Clear, 
60 ·············R"#(Removes·all·geometric·objects.)#"·) 
61 ········.def("Objects", 
62 ·············(typename·BVH_ObjectSet<T,·N>::BVH_ObjectList·&·(BVH_ObjectSet<T,N>::*)()·)·&BVH_ObjectSet<T,N>::Objects, 
63 ·············R"#(Returns·reference·to·the·array·of·geometric·objects.)#"·) 
64 ········.def("Objects", 
65 ·············(·const·typename·BVH_ObjectSet<T,·N>::BVH_ObjectList·&·(BVH_ObjectSet<T,N>::*)()·const)·&BVH_ObjectSet<T,N>::Objects, 
66 ·············R"#(Returns·reference·to·the·array·of·geometric·objects.)#"·) 
67 ········.def("Size", 
68 ·············(Standard_Integer·(BVH_ObjectSet<T,N>::*)()·const)·&BVH_ObjectSet<T,N>::Size, 
69 ·············R"#(Return·total·number·of·objects.)#"·) 
70 ········.def("Box", 
71 ·············(BVH_Box<T,·N>·(BVH_ObjectSet<T,N>::*)(··const·Standard_Integer··)·const)·&BVH_ObjectSet<T,N>::Box, 
72 ·············R"#(Returns·AABB·of·the·given·object.)#"·,py::arg("theIndex")) 
73 ········.def("Center", 
74 ·············(T·(BVH_ObjectSet<T,N>::*)(··const·Standard_Integer·,···const·Standard_Integer··)·const)·&BVH_ObjectSet<T,N>::Center, 
75 ·············R"#(Returns·centroid·position·along·the·given·axis.)#"·,py::arg("theIndex"),·py::arg("theAxis")) 
76 ········.def("Swap", 
77 ·············(void·(BVH_ObjectSet<T,N>::*)(··const·Standard_Integer·,···const·Standard_Integer··)·)·&BVH_ObjectSet<T,N>::Swap, 
78 ·············R"#(Performs·transposing·the·two·given·objects·in·the·set.)#"·,py::arg("theIndex1"),·py::arg("theIndex2")) 
79 ········.def("__len__",[](const·BVH_ObjectSet<T,N>·&self) 
80 ·············{·return·self.Size();·} 
81 ·············) 
82 ····; 
83 }; 
  
84 template·<typename·NumType,int·Dimension,typename·DataType=Standard_Integer> 
85 void·preregister_template_BVH_BoxSet(py::object·&m,·const·char·*name){ 
86 ····py::class_<BVH_BoxSet<NumType,Dimension,DataType>·,·shared_ptr<BVH_BoxSet<NumType,Dimension,DataType>>·>(m,name,R"#(Implements·easy·to·use·interfaces·for·adding·the·elements·into·BVH·tree·and·its·following·construction.·To·make·it·more·effective·it·is·better·to·set·the·number·of·elements·that·are·going·to·be·added·into·BVH·tree.·For·better·efficiency·on·heavy·data·types·it·is·recommended·to·use·either·BHV_IndexedBoxSet·which·uses·indirect·indexing·for·accessing·the·elements·and·their·boxes·or·set·the·element·to·be·an·index·of·the·real·element·in·the·application's·internal·data·structures.)#"); 
87 } 
  
88 template·<typename·NumType,int·Dimension,typename·DataType=Standard_Integer> 
89 void·register_template_BVH_BoxSet(py::object·&m,·const·char·*name){ 
90 ····static_cast<py::class_<BVH_BoxSet<NumType,Dimension,DataType>·,·shared_ptr<BVH_BoxSet<NumType,Dimension,DataType>>·>>(m.attr(name)) 
91 ········.def(py::init<··>()··) 
92 ········.def(py::init<··const·handle<BVH_Builder<NumType,·Dimension>>·&·>()·,py::arg("theBuilder")·) 
93 ········.def("SetSize", 
94 ·············(void·(BVH_BoxSet<NumType,Dimension,DataType>::*)(··const·Standard_Size··)·)·&BVH_BoxSet<NumType,Dimension,DataType>::SetSize, 
95 ·············R"#(Sets·the·expected·size·of·BVH·tree)#"·,py::arg("theSize")) 
96 ········.def("Add", 
97 ·············(void·(BVH_BoxSet<NumType,Dimension,DataType>::*)(··const·DataType·&·,···const·BVH_Box<NumType,·Dimension>·&··)·)·&BVH_BoxSet<NumType,Dimension,DataType>::Add, 
98 ·············R"#(Adds·the·element·into·BVH)#"·,py::arg("theElement"),·py::arg("theBox")) 
99 ········.def("Build", 
100 ·············(void·(BVH_BoxSet<NumType,Dimension,DataType>::*)()·)·&BVH_BoxSet<NumType,Dimension,DataType>::Build, 
101 ·············R"#(BVH·construction)#"·) 
102 ········.def("Clear", 
103 ·············(void·(BVH_BoxSet<NumType,Dimension,DataType>::*)()·)·&BVH_BoxSet<NumType,Dimension,DataType>::Clear, 
104 ·············R"#(Clears·the·vectors·of·elements·and·boxes)#"·) 
105 ········.def("Box", 
106 ·············(BVH_Box<NumType,·Dimension>·(BVH_BoxSet<NumType,Dimension,DataType>::*)(··const·Standard_Integer··)·const)·&BVH_BoxSet<NumType,Dimension,DataType>::Box, 
107 ·············R"#(Returns·the·bounding·box·with·the·given·index.)#"·,py::arg("theIndex")) 
108 ········.def("Center", 
109 ·············(Standard_Real·(BVH_BoxSet<NumType,Dimension,DataType>::*)(··const·Standard_Integer·,···const·Standard_Integer··)·const)·&BVH_BoxSet<NumType,Dimension,DataType>::Center, 
110 ·············R"#(Returns·centroid·position·along·specified·axis.)#"·,py::arg("theIndex"),·py::arg("theAxis")) 
111 ········.def("Size", 
112 ·············(Standard_Integer·(BVH_BoxSet<NumType,Dimension,DataType>::*)()·const)·&BVH_BoxSet<NumType,Dimension,DataType>::Size, 
113 ·············R"#(Returns·the·number·of·boxes.)#"·) 
114 ········.def("Swap", 
115 ·············(void·(BVH_BoxSet<NumType,Dimension,DataType>::*)(··const·Standard_Integer·,···const·Standard_Integer··)·)·&BVH_BoxSet<NumType,Dimension,DataType>::Swap, 
116 ·············R"#(Swaps·indices·of·two·specified·boxes.)#"·,py::arg("theIndex1"),·py::arg("theIndex2")) 
117 ········.def("Element", 
118 ·············(DataType·(BVH_BoxSet<NumType,Dimension,DataType>::*)(··const·Standard_Integer··)·const)·&BVH_BoxSet<NumType,Dimension,DataType>::Element, 
119 ·············R"#(Returns·the·Element·with·the·index·theIndex.)#"·,py::arg("theIndex")) 
120 ········.def("__len__",[](const·BVH_BoxSet<NumType,Dimension,DataType>·&self) 
121 ·············{·return·self.Size();·} 
122 ·············) 
123 ····; 
124 }; 
  
125 template·<typename·T,int·N> 
126 void·preregister_template_BVH_Set(py::object·&m,·const·char·*name){ 
127 ····py::class_<BVH_Set<T,N>·,·shared_ptr<BVH_Set<T,N>>·>(m,name,R"#(Set·of·abstract·entities·(bounded·by·BVH·boxes).·This·is·the·minimal·geometry·interface·needed·to·construct·BVH.)#"); 
128 } 
  
129 template·<typename·T,int·N> 
130 void·register_template_BVH_Set(py::object·&m,·const·char·*name){ 
131 ····static_cast<py::class_<BVH_Set<T,N>·,·shared_ptr<BVH_Set<T,N>>·>>(m.attr(name)) 
132 ········.def(py::init<··>()··) 
133 ········.def("Box", 
134 ·············(BVH_Box<T,·N>·(BVH_Set<T,N>::*)()·const)·&BVH_Set<T,N>::Box, 
135 ·············R"#(Returns·AABB·of·the·entire·set·of·objects.)#"·) 
136 ········.def("Size", 
137 ·············(Standard_Integer·(BVH_Set<T,N>::*)()·const)·&BVH_Set<T,N>::Size, 
138 ·············R"#(Returns·total·number·of·objects.)#"·) 
139 ········.def("Box", 
140 ·············(BVH_Box<T,·N>·(BVH_Set<T,N>::*)(··const·Standard_Integer··)·const)·&BVH_Set<T,N>::Box, 
141 ·············R"#(Returns·AABB·of·the·given·object.)#"·,py::arg("theIndex")) 
142 ········.def("Center", 
143 ·············(T·(BVH_Set<T,N>::*)(··const·Standard_Integer·,···const·Standard_Integer··)·const)·&BVH_Set<T,N>::Center, 
144 ·············R"#(Returns·centroid·position·along·the·given·axis.)#"·,py::arg("theIndex"),·py::arg("theAxis")) 
145 ········.def("Swap", 
146 ·············(void·(BVH_Set<T,N>::*)(··const·Standard_Integer·,···const·Standard_Integer··)·)·&BVH_Set<T,N>::Swap, 
147 ·············R"#(Performs·transposing·the·two·given·objects·in·the·set.)#"·,py::arg("theIndex1"),·py::arg("theIndex2")) 
148 ········.def("__len__",[](const·BVH_Set<T,N>·&self) 
149 ·············{·return·self.Size();·} 
150 ·············) 
151 ····; 
152 }; 
  
153 template·<typename·T,int·N> 
154 void·preregister_template_BVH_Object(py::object·&m,·const·char·*name){ 
155 ····py::class_<BVH_Object<T,N>·,·opencascade::handle<BVH_Object<T,N>>·,·BVH_ObjectTransient·>(m,name,R"#(Abstract·geometric·object·bounded·by·BVH·box.)#"); 
156 } 
  
157 template·<typename·T,int·N> 
158 void·register_template_BVH_Object(py::object·&m,·const·char·*name){ 
159 ····static_cast<py::class_<BVH_Object<T,N>·,·opencascade::handle<BVH_Object<T,N>>·,·BVH_ObjectTransient·>>(m.attr(name)) 
160 ········.def(py::init<··>()··) 
161 ········.def("Box", 
162 ·············(BVH_Box<T,·N>·(BVH_Object<T,N>::*)()·const)·&BVH_Object<T,N>::Box, 
163 ·············R"#(Returns·AABB·of·the·geometric·object.)#"·) 
Max diff block lines reached; 81983/101778 bytes (80.55%) of diff not shown.
⊟
2.6 KB
./usr/share/libocp/OCP/CDF_pre.cpp
Ordering differences only
    
Offset 62, 32 lines modifiedOffset 62, 32 lines modified
62 py::module·m·=·main_module.def_submodule("CDF",·R"#()#");62 py::module·m·=·main_module.def_submodule("CDF",·R"#()#");
  
63 //·add·namespaces·as·submodules63 //·add·namespaces·as·submodules
  
64 //·user-defined·inclusion·per·module·in·the·body64 //·user-defined·inclusion·per·module·in·the·body
  
65 //·enums65 //·enums
66 ····py::enum_<CDF_TryStoreStatus>(m,·"CDF_TryStoreStatus",R"#()#") 
67 ········.value("CDF_TS_OK",CDF_TryStoreStatus::CDF_TS_OK) 
68 ········.value("CDF_TS_NoCurrentDocument",CDF_TryStoreStatus::CDF_TS_NoCurrentDocument) 
69 ········.value("CDF_TS_NoDriver",CDF_TryStoreStatus::CDF_TS_NoDriver) 
70 ········.value("CDF_TS_NoSubComponentDriver",CDF_TryStoreStatus::CDF_TS_NoSubComponentDriver).export_values(); 
71 ····py::enum_<CDF_TypeOfActivation>(m,·"CDF_TypeOfActivation",R"#()#")66 ····py::enum_<CDF_TypeOfActivation>(m,·"CDF_TypeOfActivation",R"#()#")
72 ········.value("CDF_TOA_New",CDF_TypeOfActivation::CDF_TOA_New)67 ········.value("CDF_TOA_New",CDF_TypeOfActivation::CDF_TOA_New)
73 ········.value("CDF_TOA_Modified",CDF_TypeOfActivation::CDF_TOA_Modified)68 ········.value("CDF_TOA_Modified",CDF_TypeOfActivation::CDF_TOA_Modified)
74 ········.value("CDF_TOA_Unchanged",CDF_TypeOfActivation::CDF_TOA_Unchanged).export_values();69 ········.value("CDF_TOA_Unchanged",CDF_TypeOfActivation::CDF_TOA_Unchanged).export_values();
75 ····py::enum_<CDF_StoreSetNameStatus>(m,·"CDF_StoreSetNameStatus",R"#()#") 
76 ········.value("CDF_SSNS_OK",CDF_StoreSetNameStatus::CDF_SSNS_OK) 
77 ········.value("CDF_SSNS_ReplacingAnExistentDocument",CDF_StoreSetNameStatus::CDF_SSNS_ReplacingAnExistentDocument) 
78 ········.value("CDF_SSNS_OpenDocument",CDF_StoreSetNameStatus::CDF_SSNS_OpenDocument).export_values(); 
79 ····py::enum_<CDF_SubComponentStatus>(m,·"CDF_SubComponentStatus",R"#()#")70 ····py::enum_<CDF_SubComponentStatus>(m,·"CDF_SubComponentStatus",R"#()#")
80 ········.value("CDF_SCS_Consistent",CDF_SubComponentStatus::CDF_SCS_Consistent)71 ········.value("CDF_SCS_Consistent",CDF_SubComponentStatus::CDF_SCS_Consistent)
81 ········.value("CDF_SCS_Unconsistent",CDF_SubComponentStatus::CDF_SCS_Unconsistent)72 ········.value("CDF_SCS_Unconsistent",CDF_SubComponentStatus::CDF_SCS_Unconsistent)
82 ········.value("CDF_SCS_Stored",CDF_SubComponentStatus::CDF_SCS_Stored)73 ········.value("CDF_SCS_Stored",CDF_SubComponentStatus::CDF_SCS_Stored)
83 ········.value("CDF_SCS_Modified",CDF_SubComponentStatus::CDF_SCS_Modified).export_values();74 ········.value("CDF_SCS_Modified",CDF_SubComponentStatus::CDF_SCS_Modified).export_values();
 75 ····py::enum_<CDF_StoreSetNameStatus>(m,·"CDF_StoreSetNameStatus",R"#()#")
 76 ········.value("CDF_SSNS_OK",CDF_StoreSetNameStatus::CDF_SSNS_OK)
 77 ········.value("CDF_SSNS_ReplacingAnExistentDocument",CDF_StoreSetNameStatus::CDF_SSNS_ReplacingAnExistentDocument)
 78 ········.value("CDF_SSNS_OpenDocument",CDF_StoreSetNameStatus::CDF_SSNS_OpenDocument).export_values();
 79 ····py::enum_<CDF_TryStoreStatus>(m,·"CDF_TryStoreStatus",R"#()#")
 80 ········.value("CDF_TS_OK",CDF_TryStoreStatus::CDF_TS_OK)
 81 ········.value("CDF_TS_NoCurrentDocument",CDF_TryStoreStatus::CDF_TS_NoCurrentDocument)
 82 ········.value("CDF_TS_NoDriver",CDF_TryStoreStatus::CDF_TS_NoDriver)
 83 ········.value("CDF_TS_NoSubComponentDriver",CDF_TryStoreStatus::CDF_TS_NoSubComponentDriver).export_values();
  
84 //Python·trampoline·classes84 //Python·trampoline·classes
85 ····class·Py_CDF_Application·:·public·CDF_Application{85 ····class·Py_CDF_Application·:·public·CDF_Application{
86 ····public:86 ····public:
87 ········using·CDF_Application::CDF_Application;87 ········using·CDF_Application::CDF_Application;
  
  
⊟
4.81 KB
./usr/share/libocp/OCP/ChFiDS_pre.cpp
Ordering differences only
    
Offset 85, 43 lines modifiedOffset 85, 43 lines modified
85 py::module·m·=·main_module.def_submodule("ChFiDS",·R"#()#");85 py::module·m·=·main_module.def_submodule("ChFiDS",·R"#()#");
  
86 //·add·namespaces·as·submodules86 //·add·namespaces·as·submodules
  
87 //·user-defined·inclusion·per·module·in·the·body87 //·user-defined·inclusion·per·module·in·the·body
  
88 //·enums88 //·enums
89 ····py::enum_<ChFiDS_State>(m,·"ChFiDS_State",R"#(This·enum·describe·the·different·kinds·of·extremities·of·a·fillet.·OnSame,·Ondiff·and·AllSame·are·particular·cases·of·BreakPoint·for·a·corner·with·3·edges·and·three·faces·:·-·AllSame·means·that·the·three·concavities·are·on·the·same·side·of·the·Shape,·-·OnDiff·means·that·the·edge·of·the·fillet·has·a·concave·side·different·than·the·two·other·edges,·-·OnSame·means·that·the·edge·of·the·fillet·has·a·concave·side·different·than·one·of·the·two·other·edges·and·identical·to·the·third·edge.)#") 
90 ········.value("ChFiDS_OnSame",ChFiDS_State::ChFiDS_OnSame) 
91 ········.value("ChFiDS_OnDiff",ChFiDS_State::ChFiDS_OnDiff) 
92 ········.value("ChFiDS_AllSame",ChFiDS_State::ChFiDS_AllSame) 
93 ········.value("ChFiDS_BreakPoint",ChFiDS_State::ChFiDS_BreakPoint) 
94 ········.value("ChFiDS_FreeBoundary",ChFiDS_State::ChFiDS_FreeBoundary) 
95 ········.value("ChFiDS_Closed",ChFiDS_State::ChFiDS_Closed) 
96 ········.value("ChFiDS_Tangent",ChFiDS_State::ChFiDS_Tangent).export_values(); 
97 ····py::enum_<ChFiDS_ErrorStatus>(m,·"ChFiDS_ErrorStatus",R"#(---·Purpose·statuts·concernant·la·cause·de·l'erreur)#")89 ····py::enum_<ChFiDS_ErrorStatus>(m,·"ChFiDS_ErrorStatus",R"#(---·Purpose·statuts·concernant·la·cause·de·l'erreur)#")
98 ········.value("ChFiDS_Ok",ChFiDS_ErrorStatus::ChFiDS_Ok)90 ········.value("ChFiDS_Ok",ChFiDS_ErrorStatus::ChFiDS_Ok)
99 ········.value("ChFiDS_Error",ChFiDS_ErrorStatus::ChFiDS_Error)91 ········.value("ChFiDS_Error",ChFiDS_ErrorStatus::ChFiDS_Error)
100 ········.value("ChFiDS_WalkingFailure",ChFiDS_ErrorStatus::ChFiDS_WalkingFailure)92 ········.value("ChFiDS_WalkingFailure",ChFiDS_ErrorStatus::ChFiDS_WalkingFailure)
101 ········.value("ChFiDS_StartsolFailure",ChFiDS_ErrorStatus::ChFiDS_StartsolFailure)93 ········.value("ChFiDS_StartsolFailure",ChFiDS_ErrorStatus::ChFiDS_StartsolFailure)
102 ········.value("ChFiDS_TwistedSurface",ChFiDS_ErrorStatus::ChFiDS_TwistedSurface).export_values();94 ········.value("ChFiDS_TwistedSurface",ChFiDS_ErrorStatus::ChFiDS_TwistedSurface).export_values();
103 ····py::enum_<ChFiDS_ChamfMethod>(m,·"ChFiDS_ChamfMethod",R"#()#") 
104 ········.value("ChFiDS_Sym",ChFiDS_ChamfMethod::ChFiDS_Sym) 
105 ········.value("ChFiDS_TwoDist",ChFiDS_ChamfMethod::ChFiDS_TwoDist) 
106 ········.value("ChFiDS_DistAngle",ChFiDS_ChamfMethod::ChFiDS_DistAngle).export_values(); 
107 ····py::enum_<ChFiDS_TypeOfConcavity>(m,·"ChFiDS_TypeOfConcavity",R"#()#")95 ····py::enum_<ChFiDS_TypeOfConcavity>(m,·"ChFiDS_TypeOfConcavity",R"#()#")
108 ········.value("ChFiDS_Concave",ChFiDS_TypeOfConcavity::ChFiDS_Concave)96 ········.value("ChFiDS_Concave",ChFiDS_TypeOfConcavity::ChFiDS_Concave)
109 ········.value("ChFiDS_Convex",ChFiDS_TypeOfConcavity::ChFiDS_Convex)97 ········.value("ChFiDS_Convex",ChFiDS_TypeOfConcavity::ChFiDS_Convex)
110 ········.value("ChFiDS_Tangential",ChFiDS_TypeOfConcavity::ChFiDS_Tangential)98 ········.value("ChFiDS_Tangential",ChFiDS_TypeOfConcavity::ChFiDS_Tangential)
111 ········.value("ChFiDS_FreeBound",ChFiDS_TypeOfConcavity::ChFiDS_FreeBound)99 ········.value("ChFiDS_FreeBound",ChFiDS_TypeOfConcavity::ChFiDS_FreeBound)
112 ········.value("ChFiDS_Other",ChFiDS_TypeOfConcavity::ChFiDS_Other)100 ········.value("ChFiDS_Other",ChFiDS_TypeOfConcavity::ChFiDS_Other)
113 ········.value("ChFiDS_Mixed",ChFiDS_TypeOfConcavity::ChFiDS_Mixed).export_values();101 ········.value("ChFiDS_Mixed",ChFiDS_TypeOfConcavity::ChFiDS_Mixed).export_values();
114 ····py::enum_<ChFiDS_ChamfMode>(m,·"ChFiDS_ChamfMode",R"#(this·enumeration·defines·several·modes·of·chamfer)#")102 ····py::enum_<ChFiDS_ChamfMode>(m,·"ChFiDS_ChamfMode",R"#(this·enumeration·defines·several·modes·of·chamfer)#")
115 ········.value("ChFiDS_ClassicChamfer",ChFiDS_ChamfMode::ChFiDS_ClassicChamfer)103 ········.value("ChFiDS_ClassicChamfer",ChFiDS_ChamfMode::ChFiDS_ClassicChamfer)
116 ········.value("ChFiDS_ConstThroatChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatChamfer)104 ········.value("ChFiDS_ConstThroatChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatChamfer)
117 ········.value("ChFiDS_ConstThroatWithPenetrationChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatWithPenetrationChamfer).export_values();105 ········.value("ChFiDS_ConstThroatWithPenetrationChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatWithPenetrationChamfer).export_values();
 106 ····py::enum_<ChFiDS_ChamfMethod>(m,·"ChFiDS_ChamfMethod",R"#()#")
 107 ········.value("ChFiDS_Sym",ChFiDS_ChamfMethod::ChFiDS_Sym)
 108 ········.value("ChFiDS_TwoDist",ChFiDS_ChamfMethod::ChFiDS_TwoDist)
 109 ········.value("ChFiDS_DistAngle",ChFiDS_ChamfMethod::ChFiDS_DistAngle).export_values();
 110 ····py::enum_<ChFiDS_State>(m,·"ChFiDS_State",R"#(This·enum·describe·the·different·kinds·of·extremities·of·a·fillet.·OnSame,·Ondiff·and·AllSame·are·particular·cases·of·BreakPoint·for·a·corner·with·3·edges·and·three·faces·:·-·AllSame·means·that·the·three·concavities·are·on·the·same·side·of·the·Shape,·-·OnDiff·means·that·the·edge·of·the·fillet·has·a·concave·side·different·than·the·two·other·edges,·-·OnSame·means·that·the·edge·of·the·fillet·has·a·concave·side·different·than·one·of·the·two·other·edges·and·identical·to·the·third·edge.)#")
 111 ········.value("ChFiDS_OnSame",ChFiDS_State::ChFiDS_OnSame)
 112 ········.value("ChFiDS_OnDiff",ChFiDS_State::ChFiDS_OnDiff)
 113 ········.value("ChFiDS_AllSame",ChFiDS_State::ChFiDS_AllSame)
 114 ········.value("ChFiDS_BreakPoint",ChFiDS_State::ChFiDS_BreakPoint)
 115 ········.value("ChFiDS_FreeBoundary",ChFiDS_State::ChFiDS_FreeBoundary)
 116 ········.value("ChFiDS_Closed",ChFiDS_State::ChFiDS_Closed)
 117 ········.value("ChFiDS_Tangent",ChFiDS_State::ChFiDS_Tangent).export_values();
  
118 //Python·trampoline·classes118 //Python·trampoline·classes
  
119 //·pre-register·typdefs+classes·(topologically·sorted)119 //·pre-register·typdefs+classes·(topologically·sorted)
120 ····py::class_<ChFiDS_CircSection·,·shared_ptr<ChFiDS_CircSection>··>(m,"ChFiDS_CircSection",R"#(A·Section·of·fillet.)#");120 ····py::class_<ChFiDS_CircSection·,·shared_ptr<ChFiDS_CircSection>··>(m,"ChFiDS_CircSection",R"#(A·Section·of·fillet.)#");
121 ····py::class_<ChFiDS_CommonPoint·,·shared_ptr<ChFiDS_CommonPoint>··>(m,"ChFiDS_CommonPoint",R"#(point·start/end·of·fillet·common·to·2·adjacent·filets·and·to·an·edge·on·one·of·2·faces·participating·in·the·construction·of·the·fillet)#");121 ····py::class_<ChFiDS_CommonPoint·,·shared_ptr<ChFiDS_CommonPoint>··>(m,"ChFiDS_CommonPoint",R"#(point·start/end·of·fillet·common·to·2·adjacent·filets·and·to·an·edge·on·one·of·2·faces·participating·in·the·construction·of·the·fillet)#");
122 ····py::class_<ChFiDS_FaceInterference·,·shared_ptr<ChFiDS_FaceInterference>··>(m,"ChFiDS_FaceInterference",R"#(interference·face/fillet)#");122 ····py::class_<ChFiDS_FaceInterference·,·shared_ptr<ChFiDS_FaceInterference>··>(m,"ChFiDS_FaceInterference",R"#(interference·face/fillet)#");
⊟
1.9 KB
./usr/share/libocp/OCP/Extrema_pre.cpp
Ordering differences only
    
Offset 265, 26 lines modifiedOffset 265, 26 lines modified
265 py::module·m·=·main_module.def_submodule("Extrema",·R"#()#");265 py::module·m·=·main_module.def_submodule("Extrema",·R"#()#");
  
266 //·add·namespaces·as·submodules266 //·add·namespaces·as·submodules
  
267 //·user-defined·inclusion·per·module·in·the·body267 //·user-defined·inclusion·per·module·in·the·body
  
268 //·enums268 //·enums
269 ····py::enum_<Extrema_ElementType>(m,·"Extrema_ElementType",R"#()#") 
270 ········.value("Extrema_Node",Extrema_ElementType::Extrema_Node) 
271 ········.value("Extrema_UIsoEdge",Extrema_ElementType::Extrema_UIsoEdge) 
272 ········.value("Extrema_VIsoEdge",Extrema_ElementType::Extrema_VIsoEdge) 
273 ········.value("Extrema_Face",Extrema_ElementType::Extrema_Face).export_values(); 
274 ····py::enum_<Extrema_ExtAlgo>(m,·"Extrema_ExtAlgo",R"#()#")269 ····py::enum_<Extrema_ExtAlgo>(m,·"Extrema_ExtAlgo",R"#()#")
275 ········.value("Extrema_ExtAlgo_Grad",Extrema_ExtAlgo::Extrema_ExtAlgo_Grad)270 ········.value("Extrema_ExtAlgo_Grad",Extrema_ExtAlgo::Extrema_ExtAlgo_Grad)
276 ········.value("Extrema_ExtAlgo_Tree",Extrema_ExtAlgo::Extrema_ExtAlgo_Tree).export_values();271 ········.value("Extrema_ExtAlgo_Tree",Extrema_ExtAlgo::Extrema_ExtAlgo_Tree).export_values();
277 ····py::enum_<Extrema_ExtFlag>(m,·"Extrema_ExtFlag",R"#()#")272 ····py::enum_<Extrema_ExtFlag>(m,·"Extrema_ExtFlag",R"#()#")
278 ········.value("Extrema_ExtFlag_MIN",Extrema_ExtFlag::Extrema_ExtFlag_MIN)273 ········.value("Extrema_ExtFlag_MIN",Extrema_ExtFlag::Extrema_ExtFlag_MIN)
279 ········.value("Extrema_ExtFlag_MAX",Extrema_ExtFlag::Extrema_ExtFlag_MAX)274 ········.value("Extrema_ExtFlag_MAX",Extrema_ExtFlag::Extrema_ExtFlag_MAX)
280 ········.value("Extrema_ExtFlag_MINMAX",Extrema_ExtFlag::Extrema_ExtFlag_MINMAX).export_values();275 ········.value("Extrema_ExtFlag_MINMAX",Extrema_ExtFlag::Extrema_ExtFlag_MINMAX).export_values();
 276 ····py::enum_<Extrema_ElementType>(m,·"Extrema_ElementType",R"#()#")
 277 ········.value("Extrema_Node",Extrema_ElementType::Extrema_Node)
 278 ········.value("Extrema_UIsoEdge",Extrema_ElementType::Extrema_UIsoEdge)
 279 ········.value("Extrema_VIsoEdge",Extrema_ElementType::Extrema_VIsoEdge)
 280 ········.value("Extrema_Face",Extrema_ElementType::Extrema_Face).export_values();
  
281 //Python·trampoline·classes281 //Python·trampoline·classes
  
282 //·pre-register·typdefs+classes·(topologically·sorted)282 //·pre-register·typdefs+classes·(topologically·sorted)
283 ····py::class_<Extrema_Curve2dTool·,·shared_ptr<Extrema_Curve2dTool>··>(m,"Extrema_Curve2dTool",R"#()#");283 ····py::class_<Extrema_Curve2dTool·,·shared_ptr<Extrema_Curve2dTool>··>(m,"Extrema_Curve2dTool",R"#()#");
284 ····py::class_<Extrema_CurveTool·,·shared_ptr<Extrema_CurveTool>··>(m,"Extrema_CurveTool",R"#()#");284 ····py::class_<Extrema_CurveTool·,·shared_ptr<Extrema_CurveTool>··>(m,"Extrema_CurveTool",R"#()#");
285 ····py::class_<Extrema_ECC·,·shared_ptr<Extrema_ECC>··>(m,"Extrema_ECC",R"#()#");285 ····py::class_<Extrema_ECC·,·shared_ptr<Extrema_ECC>··>(m,"Extrema_ECC",R"#()#");
⊟
2.79 KB
./usr/share/libocp/OCP/FilletSurf_pre.cpp
Ordering differences only
    
Offset 39, 29 lines modifiedOffset 39, 29 lines modified
39 py::module·m·=·main_module.def_submodule("FilletSurf",·R"#()#");39 py::module·m·=·main_module.def_submodule("FilletSurf",·R"#()#");
  
40 //·add·namespaces·as·submodules40 //·add·namespaces·as·submodules
  
41 //·user-defined·inclusion·per·module·in·the·body41 //·user-defined·inclusion·per·module·in·the·body
  
42 //·enums42 //·enums
 43 ····py::enum_<FilletSurf_StatusType>(m,·"FilletSurf_StatusType",R"#()#")
 44 ········.value("FilletSurf_TwoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_TwoExtremityOnEdge)
 45 ········.value("FilletSurf_OneExtremityOnEdge",FilletSurf_StatusType::FilletSurf_OneExtremityOnEdge)
 46 ········.value("FilletSurf_NoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_NoExtremityOnEdge).export_values();
43 ····py::enum_<FilletSurf_ErrorTypeStatus>(m,·"FilletSurf_ErrorTypeStatus",R"#()#")47 ····py::enum_<FilletSurf_ErrorTypeStatus>(m,·"FilletSurf_ErrorTypeStatus",R"#()#")
44 ········.value("FilletSurf_EmptyList",FilletSurf_ErrorTypeStatus::FilletSurf_EmptyList)48 ········.value("FilletSurf_EmptyList",FilletSurf_ErrorTypeStatus::FilletSurf_EmptyList)
45 ········.value("FilletSurf_EdgeNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotG1)49 ········.value("FilletSurf_EdgeNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotG1)
46 ········.value("FilletSurf_FacesNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_FacesNotG1)50 ········.value("FilletSurf_FacesNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_FacesNotG1)
47 ········.value("FilletSurf_EdgeNotOnShape",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotOnShape)51 ········.value("FilletSurf_EdgeNotOnShape",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotOnShape)
48 ········.value("FilletSurf_NotSharpEdge",FilletSurf_ErrorTypeStatus::FilletSurf_NotSharpEdge)52 ········.value("FilletSurf_NotSharpEdge",FilletSurf_ErrorTypeStatus::FilletSurf_NotSharpEdge)
49 ········.value("FilletSurf_PbFilletCompute",FilletSurf_ErrorTypeStatus::FilletSurf_PbFilletCompute).export_values();53 ········.value("FilletSurf_PbFilletCompute",FilletSurf_ErrorTypeStatus::FilletSurf_PbFilletCompute).export_values();
50 ····py::enum_<FilletSurf_StatusDone>(m,·"FilletSurf_StatusDone",R"#()#")54 ····py::enum_<FilletSurf_StatusDone>(m,·"FilletSurf_StatusDone",R"#()#")
51 ········.value("FilletSurf_IsOk",FilletSurf_StatusDone::FilletSurf_IsOk)55 ········.value("FilletSurf_IsOk",FilletSurf_StatusDone::FilletSurf_IsOk)
52 ········.value("FilletSurf_IsNotOk",FilletSurf_StatusDone::FilletSurf_IsNotOk)56 ········.value("FilletSurf_IsNotOk",FilletSurf_StatusDone::FilletSurf_IsNotOk)
53 ········.value("FilletSurf_IsPartial",FilletSurf_StatusDone::FilletSurf_IsPartial).export_values();57 ········.value("FilletSurf_IsPartial",FilletSurf_StatusDone::FilletSurf_IsPartial).export_values();
54 ····py::enum_<FilletSurf_StatusType>(m,·"FilletSurf_StatusType",R"#()#") 
55 ········.value("FilletSurf_TwoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_TwoExtremityOnEdge) 
56 ········.value("FilletSurf_OneExtremityOnEdge",FilletSurf_StatusType::FilletSurf_OneExtremityOnEdge) 
57 ········.value("FilletSurf_NoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_NoExtremityOnEdge).export_values(); 
  
58 //Python·trampoline·classes58 //Python·trampoline·classes
  
59 //·pre-register·typdefs+classes·(topologically·sorted)59 //·pre-register·typdefs+classes·(topologically·sorted)
60 ····py::class_<FilletSurf_Builder·,·shared_ptr<FilletSurf_Builder>··>(m,"FilletSurf_Builder",R"#(API·giving·the·following·geometric·information·about·fillets·list·of·corresponding·NUBS·surfaces·for·each·surface:·the·2·support·faces·on·each·face:·the·3d·curve·and·the·corresponding·2d·curve·the·2d·curves·on·the·fillet·status·of·start·and·end·section·of·the·fillet·first·and·last·parameter·on·edge·of·the·fillet.)#");60 ····py::class_<FilletSurf_Builder·,·shared_ptr<FilletSurf_Builder>··>(m,"FilletSurf_Builder",R"#(API·giving·the·following·geometric·information·about·fillets·list·of·corresponding·NUBS·surfaces·for·each·surface:·the·2·support·faces·on·each·face:·the·3d·curve·and·the·corresponding·2d·curve·the·2d·curves·on·the·fillet·status·of·start·and·end·section·of·the·fillet·first·and·last·parameter·on·edge·of·the·fillet.)#");
61 ····py::class_<FilletSurf_InternalBuilder·,·shared_ptr<FilletSurf_InternalBuilder>··,·ChFi3d_FilBuilder·>(m,"FilletSurf_InternalBuilder",R"#(This·class·is·private.·It·is·used·by·the·class·Builder·from·FilletSurf.·It·computes·geometric·information·about·fillets.)#");61 ····py::class_<FilletSurf_InternalBuilder·,·shared_ptr<FilletSurf_InternalBuilder>··,·ChFi3d_FilBuilder·>(m,"FilletSurf_InternalBuilder",R"#(This·class·is·private.·It·is·used·by·the·class·Builder·from·FilletSurf.·It·computes·geometric·information·about·fillets.)#");
  
⊟
3.41 KB
./usr/share/libocp/OCP/Font_pre.cpp
Ordering differences only
    
Offset 51, 36 lines modifiedOffset 51, 36 lines modified
  
51 //·add·namespaces·as·submodules51 //·add·namespaces·as·submodules
52 m.def_submodule("std");52 m.def_submodule("std");
  
53 //·user-defined·inclusion·per·module·in·the·body53 //·user-defined·inclusion·per·module·in·the·body
  
54 //·enums54 //·enums
 55 ····py::enum_<Font_Hinting>(m,·"Font_Hinting",R"#(Enumeration·defining·font·hinting·options.)#")
 56 ········.value("Font_Hinting_Off",Font_Hinting::Font_Hinting_Off)
 57 ········.value("Font_Hinting_Normal",Font_Hinting::Font_Hinting_Normal)
 58 ········.value("Font_Hinting_Light",Font_Hinting::Font_Hinting_Light)
 59 ········.value("Font_Hinting_ForceAutohint",Font_Hinting::Font_Hinting_ForceAutohint)
 60 ········.value("Font_Hinting_NoAutohint",Font_Hinting::Font_Hinting_NoAutohint).export_values();
 61 ····py::enum_<Font_StrictLevel>(m,·"Font_StrictLevel",R"#(Enumeration·defining·font·search·restrictions.)#")
 62 ········.value("Font_StrictLevel_Strict",Font_StrictLevel::Font_StrictLevel_Strict)
 63 ········.value("Font_StrictLevel_Aliases",Font_StrictLevel::Font_StrictLevel_Aliases)
 64 ········.value("Font_StrictLevel_Any",Font_StrictLevel::Font_StrictLevel_Any).export_values();
55 ····py::enum_<Font_FontAspect>(m,·"Font_FontAspect",R"#(Specifies·aspect·of·system·font.)#")65 ····py::enum_<Font_FontAspect>(m,·"Font_FontAspect",R"#(Specifies·aspect·of·system·font.)#")
56 ········.value("Font_FontAspect_UNDEFINED",Font_FontAspect::Font_FontAspect_UNDEFINED)66 ········.value("Font_FontAspect_UNDEFINED",Font_FontAspect::Font_FontAspect_UNDEFINED)
57 ········.value("Font_FontAspect_Regular",Font_FontAspect::Font_FontAspect_Regular)67 ········.value("Font_FontAspect_Regular",Font_FontAspect::Font_FontAspect_Regular)
58 ········.value("Font_FontAspect_Bold",Font_FontAspect::Font_FontAspect_Bold)68 ········.value("Font_FontAspect_Bold",Font_FontAspect::Font_FontAspect_Bold)
59 ········.value("Font_FontAspect_Italic",Font_FontAspect::Font_FontAspect_Italic)69 ········.value("Font_FontAspect_Italic",Font_FontAspect::Font_FontAspect_Italic)
60 ········.value("Font_FontAspect_BoldItalic",Font_FontAspect::Font_FontAspect_BoldItalic)70 ········.value("Font_FontAspect_BoldItalic",Font_FontAspect::Font_FontAspect_BoldItalic)
61 ········.value("Font_FA_Undefined",Font_FontAspect::Font_FA_Undefined)71 ········.value("Font_FA_Undefined",Font_FontAspect::Font_FA_Undefined)
62 ········.value("Font_FA_Regular",Font_FontAspect::Font_FA_Regular)72 ········.value("Font_FA_Regular",Font_FontAspect::Font_FA_Regular)
63 ········.value("Font_FA_Bold",Font_FontAspect::Font_FA_Bold)73 ········.value("Font_FA_Bold",Font_FontAspect::Font_FA_Bold)
64 ········.value("Font_FA_Italic",Font_FontAspect::Font_FA_Italic)74 ········.value("Font_FA_Italic",Font_FontAspect::Font_FA_Italic)
65 ········.value("Font_FA_BoldItalic",Font_FontAspect::Font_FA_BoldItalic).export_values();75 ········.value("Font_FA_BoldItalic",Font_FontAspect::Font_FA_BoldItalic).export_values();
66 ····m.attr("Font_FontAspect_NB")·=·py::cast(int(Font_FontAspect_NB));76 ····m.attr("Font_FontAspect_NB")·=·py::cast(int(Font_FontAspect_NB));
67 ····py::enum_<Font_Hinting>(m,·"Font_Hinting",R"#(Enumeration·defining·font·hinting·options.)#") 
68 ········.value("Font_Hinting_Off",Font_Hinting::Font_Hinting_Off) 
69 ········.value("Font_Hinting_Normal",Font_Hinting::Font_Hinting_Normal) 
70 ········.value("Font_Hinting_Light",Font_Hinting::Font_Hinting_Light) 
71 ········.value("Font_Hinting_ForceAutohint",Font_Hinting::Font_Hinting_ForceAutohint) 
72 ········.value("Font_Hinting_NoAutohint",Font_Hinting::Font_Hinting_NoAutohint).export_values(); 
73 ····py::enum_<Font_StrictLevel>(m,·"Font_StrictLevel",R"#(Enumeration·defining·font·search·restrictions.)#") 
74 ········.value("Font_StrictLevel_Strict",Font_StrictLevel::Font_StrictLevel_Strict) 
75 ········.value("Font_StrictLevel_Aliases",Font_StrictLevel::Font_StrictLevel_Aliases) 
76 ········.value("Font_StrictLevel_Any",Font_StrictLevel::Font_StrictLevel_Any).export_values(); 
77 ····py::enum_<Font_UnicodeSubset>(m,·"Font_UnicodeSubset",R"#(Enumeration·defining·Unicode·subsets.)#")77 ····py::enum_<Font_UnicodeSubset>(m,·"Font_UnicodeSubset",R"#(Enumeration·defining·Unicode·subsets.)#")
78 ········.value("Font_UnicodeSubset_Western",Font_UnicodeSubset::Font_UnicodeSubset_Western)78 ········.value("Font_UnicodeSubset_Western",Font_UnicodeSubset::Font_UnicodeSubset_Western)
79 ········.value("Font_UnicodeSubset_Korean",Font_UnicodeSubset::Font_UnicodeSubset_Korean)79 ········.value("Font_UnicodeSubset_Korean",Font_UnicodeSubset::Font_UnicodeSubset_Korean)
80 ········.value("Font_UnicodeSubset_CJK",Font_UnicodeSubset::Font_UnicodeSubset_CJK)80 ········.value("Font_UnicodeSubset_CJK",Font_UnicodeSubset::Font_UnicodeSubset_CJK)
81 ········.value("Font_UnicodeSubset_Arabic",Font_UnicodeSubset::Font_UnicodeSubset_Arabic).export_values();81 ········.value("Font_UnicodeSubset_Arabic",Font_UnicodeSubset::Font_UnicodeSubset_Arabic).export_values();
82 ····m.attr("Font_UnicodeSubset_NB")·=·py::cast(int(Font_UnicodeSubset_NB));82 ····m.attr("Font_UnicodeSubset_NB")·=·py::cast(int(Font_UnicodeSubset_NB));
  
⊟
2.79 KB
./usr/share/libocp/OCP/GCPnts_pre.cpp
Ordering differences only
    
Offset 51, 23 lines modifiedOffset 51, 23 lines modified
51 py::module·m·=·main_module.def_submodule("GCPnts",·R"#()#");51 py::module·m·=·main_module.def_submodule("GCPnts",·R"#()#");
  
52 //·add·namespaces·as·submodules52 //·add·namespaces·as·submodules
  
53 //·user-defined·inclusion·per·module·in·the·body53 //·user-defined·inclusion·per·module·in·the·body
  
54 //·enums54 //·enums
 55 ····py::enum_<GCPnts_AbscissaType>(m,·"GCPnts_AbscissaType",R"#()#")
 56 ········.value("GCPnts_LengthParametrized",GCPnts_AbscissaType::GCPnts_LengthParametrized)
 57 ········.value("GCPnts_Parametrized",GCPnts_AbscissaType::GCPnts_Parametrized)
 58 ········.value("GCPnts_AbsComposite",GCPnts_AbscissaType::GCPnts_AbsComposite).export_values();
55 ····py::enum_<GCPnts_DeflectionType>(m,·"GCPnts_DeflectionType",R"#()#")59 ····py::enum_<GCPnts_DeflectionType>(m,·"GCPnts_DeflectionType",R"#()#")
56 ········.value("GCPnts_Linear",GCPnts_DeflectionType::GCPnts_Linear)60 ········.value("GCPnts_Linear",GCPnts_DeflectionType::GCPnts_Linear)
57 ········.value("GCPnts_Circular",GCPnts_DeflectionType::GCPnts_Circular)61 ········.value("GCPnts_Circular",GCPnts_DeflectionType::GCPnts_Circular)
58 ········.value("GCPnts_Curved",GCPnts_DeflectionType::GCPnts_Curved)62 ········.value("GCPnts_Curved",GCPnts_DeflectionType::GCPnts_Curved)
59 ········.value("GCPnts_DefComposite",GCPnts_DeflectionType::GCPnts_DefComposite).export_values();63 ········.value("GCPnts_DefComposite",GCPnts_DeflectionType::GCPnts_DefComposite).export_values();
60 ····py::enum_<GCPnts_AbscissaType>(m,·"GCPnts_AbscissaType",R"#()#") 
61 ········.value("GCPnts_LengthParametrized",GCPnts_AbscissaType::GCPnts_LengthParametrized) 
62 ········.value("GCPnts_Parametrized",GCPnts_AbscissaType::GCPnts_Parametrized) 
63 ········.value("GCPnts_AbsComposite",GCPnts_AbscissaType::GCPnts_AbsComposite).export_values(); 
  
64 //Python·trampoline·classes64 //Python·trampoline·classes
  
65 //·pre-register·typdefs+classes·(topologically·sorted)65 //·pre-register·typdefs+classes·(topologically·sorted)
66 ····py::class_<GCPnts_AbscissaPoint·,·shared_ptr<GCPnts_AbscissaPoint>··>(m,"GCPnts_AbscissaPoint",R"#(Provides·an·algorithm·to·compute·a·point·on·a·curve·situated·at·a·given·distance·from·another·point·on·the·curve,·the·distance·being·measured·along·the·curve·(curvilinear·abscissa·on·the·curve).·This·algorithm·is·also·used·to·compute·the·length·of·a·curve.·An·AbscissaPoint·object·provides·a·framework·for:·-·defining·the·point·to·compute·-·implementing·the·construction·algorithm·-·consulting·the·result.)#");66 ····py::class_<GCPnts_AbscissaPoint·,·shared_ptr<GCPnts_AbscissaPoint>··>(m,"GCPnts_AbscissaPoint",R"#(Provides·an·algorithm·to·compute·a·point·on·a·curve·situated·at·a·given·distance·from·another·point·on·the·curve,·the·distance·being·measured·along·the·curve·(curvilinear·abscissa·on·the·curve).·This·algorithm·is·also·used·to·compute·the·length·of·a·curve.·An·AbscissaPoint·object·provides·a·framework·for:·-·defining·the·point·to·compute·-·implementing·the·construction·algorithm·-·consulting·the·result.)#");
67 ····py::class_<GCPnts_QuasiUniformAbscissa·,·shared_ptr<GCPnts_QuasiUniformAbscissa>··>(m,"GCPnts_QuasiUniformAbscissa",R"#(This·class·provides·an·algorithm·to·compute·a·uniform·abscissa·distribution·of·points·on·a·curve,·i.e.·a·sequence·of·equidistant·points.·The·distance·between·two·consecutive·points·is·measured·along·the·curve.)#");67 ····py::class_<GCPnts_QuasiUniformAbscissa·,·shared_ptr<GCPnts_QuasiUniformAbscissa>··>(m,"GCPnts_QuasiUniformAbscissa",R"#(This·class·provides·an·algorithm·to·compute·a·uniform·abscissa·distribution·of·points·on·a·curve,·i.e.·a·sequence·of·equidistant·points.·The·distance·between·two·consecutive·points·is·measured·along·the·curve.)#");
68 ····py::class_<GCPnts_QuasiUniformDeflection·,·shared_ptr<GCPnts_QuasiUniformDeflection>··>(m,"GCPnts_QuasiUniformDeflection",R"#(This·class·computes·a·distribution·of·points·on·a·curve.·The·points·may·respect·the·deflection.·The·algorithm·is·not·based·on·the·classical·prediction·(with·second·derivative·of·curve),·but·either·on·the·evaluation·of·the·distance·between·the·mid·point·and·the·point·of·mid·parameter·of·the·two·points,·or·the·distance·between·the·mid·point·and·the·point·at·parameter·0.5·on·the·cubic·interpolation·of·the·two·points·and·their·tangents.)#");68 ····py::class_<GCPnts_QuasiUniformDeflection·,·shared_ptr<GCPnts_QuasiUniformDeflection>··>(m,"GCPnts_QuasiUniformDeflection",R"#(This·class·computes·a·distribution·of·points·on·a·curve.·The·points·may·respect·the·deflection.·The·algorithm·is·not·based·on·the·classical·prediction·(with·second·derivative·of·curve),·but·either·on·the·evaluation·of·the·distance·between·the·mid·point·and·the·point·of·mid·parameter·of·the·two·points,·or·the·distance·between·the·mid·point·and·the·point·at·parameter·0.5·on·the·cubic·interpolation·of·the·two·points·and·their·tangents.)#");
⊟
2.99 KB
./usr/share/libocp/OCP/GProp_pre.cpp
Ordering differences only
    
Offset 57, 32 lines modifiedOffset 57, 32 lines modified
57 py::module·m·=·main_module.def_submodule("GProp",·R"#()#");57 py::module·m·=·main_module.def_submodule("GProp",·R"#()#");
  
58 //·add·namespaces·as·submodules58 //·add·namespaces·as·submodules
  
59 //·user-defined·inclusion·per·module·in·the·body59 //·user-defined·inclusion·per·module·in·the·body
  
60 //·enums60 //·enums
61 ····py::enum_<GProp_EquaType>(m,·"GProp_EquaType",R"#()#") 
62 ········.value("GProp_Plane",GProp_EquaType::GProp_Plane) 
63 ········.value("GProp_Line",GProp_EquaType::GProp_Line) 
64 ········.value("GProp_Point",GProp_EquaType::GProp_Point) 
65 ········.value("GProp_Space",GProp_EquaType::GProp_Space) 
66 ········.value("GProp_None",GProp_EquaType::GProp_None).export_values(); 
67 ····py::enum_<GProp_ValueType>(m,·"GProp_ValueType",R"#(Algorithmes·:)#")61 ····py::enum_<GProp_ValueType>(m,·"GProp_ValueType",R"#(Algorithmes·:)#")
68 ········.value("GProp_Mass",GProp_ValueType::GProp_Mass)62 ········.value("GProp_Mass",GProp_ValueType::GProp_Mass)
69 ········.value("GProp_CenterMassX",GProp_ValueType::GProp_CenterMassX)63 ········.value("GProp_CenterMassX",GProp_ValueType::GProp_CenterMassX)
70 ········.value("GProp_CenterMassY",GProp_ValueType::GProp_CenterMassY)64 ········.value("GProp_CenterMassY",GProp_ValueType::GProp_CenterMassY)
71 ········.value("GProp_CenterMassZ",GProp_ValueType::GProp_CenterMassZ)65 ········.value("GProp_CenterMassZ",GProp_ValueType::GProp_CenterMassZ)
72 ········.value("GProp_InertiaXX",GProp_ValueType::GProp_InertiaXX)66 ········.value("GProp_InertiaXX",GProp_ValueType::GProp_InertiaXX)
73 ········.value("GProp_InertiaYY",GProp_ValueType::GProp_InertiaYY)67 ········.value("GProp_InertiaYY",GProp_ValueType::GProp_InertiaYY)
74 ········.value("GProp_InertiaZZ",GProp_ValueType::GProp_InertiaZZ)68 ········.value("GProp_InertiaZZ",GProp_ValueType::GProp_InertiaZZ)
75 ········.value("GProp_InertiaXY",GProp_ValueType::GProp_InertiaXY)69 ········.value("GProp_InertiaXY",GProp_ValueType::GProp_InertiaXY)
76 ········.value("GProp_InertiaXZ",GProp_ValueType::GProp_InertiaXZ)70 ········.value("GProp_InertiaXZ",GProp_ValueType::GProp_InertiaXZ)
77 ········.value("GProp_InertiaYZ",GProp_ValueType::GProp_InertiaYZ)71 ········.value("GProp_InertiaYZ",GProp_ValueType::GProp_InertiaYZ)
78 ········.value("GProp_Unknown",GProp_ValueType::GProp_Unknown).export_values();72 ········.value("GProp_Unknown",GProp_ValueType::GProp_Unknown).export_values();
 73 ····py::enum_<GProp_EquaType>(m,·"GProp_EquaType",R"#()#")
 74 ········.value("GProp_Plane",GProp_EquaType::GProp_Plane)
 75 ········.value("GProp_Line",GProp_EquaType::GProp_Line)
 76 ········.value("GProp_Point",GProp_EquaType::GProp_Point)
 77 ········.value("GProp_Space",GProp_EquaType::GProp_Space)
 78 ········.value("GProp_None",GProp_EquaType::GProp_None).export_values();
  
79 //Python·trampoline·classes79 //Python·trampoline·classes
  
80 //·pre-register·typdefs+classes·(topologically·sorted)80 //·pre-register·typdefs+classes·(topologically·sorted)
81 ····py::class_<GProp·,·shared_ptr<GProp>··>(m,"GProp",R"#(This·package·defines·algorithms·to·compute·the·global·properties·of·a·set·of·points,·a·curve,·a·surface,·a·solid·(non·infinite·region·of·space·delimited·with·geometric·entities),·a·compound·geometric·system·(heterogeneous·composition·of·the·previous·entities).)#");81 ····py::class_<GProp·,·shared_ptr<GProp>··>(m,"GProp",R"#(This·package·defines·algorithms·to·compute·the·global·properties·of·a·set·of·points,·a·curve,·a·surface,·a·solid·(non·infinite·region·of·space·delimited·with·geometric·entities),·a·compound·geometric·system·(heterogeneous·composition·of·the·previous·entities).)#");
82 ····py::class_<GProp_GProps·,·shared_ptr<GProp_GProps>··>(m,"GProp_GProps",R"#(Implements·a·general·mechanism·to·compute·the·global·properties·of·a·"compound·geometric·system"·in·3d·space·by·composition·of·the·global·properties·of·"elementary·geometric·entities"·such·as·(curve,·surface,·solid,·set·of·points).·It·is·possible·to·compose·the·properties·of·several·"compound·geometric·systems"·too.)#");82 ····py::class_<GProp_GProps·,·shared_ptr<GProp_GProps>··>(m,"GProp_GProps",R"#(Implements·a·general·mechanism·to·compute·the·global·properties·of·a·"compound·geometric·system"·in·3d·space·by·composition·of·the·global·properties·of·"elementary·geometric·entities"·such·as·(curve,·surface,·solid,·set·of·points).·It·is·possible·to·compose·the·properties·of·several·"compound·geometric·systems"·too.)#");
83 ····py::class_<GProp_PEquation·,·shared_ptr<GProp_PEquation>··>(m,"GProp_PEquation",R"#(A·framework·to·analyze·a·collection·-·or·cloud·-·of·points·and·to·verify·if·they·are·coincident,·collinear·or·coplanar·within·a·given·precision.·If·so,·it·also·computes·the·mean·point,·the·mean·line·or·the·mean·plane·of·the·points.·If·not,·it·computes·the·minimal·box·which·includes·all·the·points.)#");83 ····py::class_<GProp_PEquation·,·shared_ptr<GProp_PEquation>··>(m,"GProp_PEquation",R"#(A·framework·to·analyze·a·collection·-·or·cloud·-·of·points·and·to·verify·if·they·are·coincident,·collinear·or·coplanar·within·a·given·precision.·If·so,·it·also·computes·the·mean·point,·the·mean·line·or·the·mean·plane·of·the·points.·If·not,·it·computes·the·minimal·box·which·includes·all·the·points.)#");
⊟
7.96 KB
./usr/share/libocp/OCP/GeomAbs_pre.cpp
Ordering differences only
    
Offset 36, 57 lines modifiedOffset 36, 57 lines modified
36 py::module·m·=·main_module.def_submodule("GeomAbs",·R"#()#");36 py::module·m·=·main_module.def_submodule("GeomAbs",·R"#()#");
  
37 //·add·namespaces·as·submodules37 //·add·namespaces·as·submodules
  
38 //·user-defined·inclusion·per·module·in·the·body38 //·user-defined·inclusion·per·module·in·the·body
  
39 //·enums39 //·enums
40 ····py::enum_<GeomAbs_JoinType>(m,·"GeomAbs_JoinType",R"#(Characterizes·the·type·of·a·join,·built·by·an·algorithm·for·constructing·parallel·curves,·between·two·consecutive·arcs·of·a·contour·parallel·to·a·given·contour.)#") 
41 ········.value("GeomAbs_Arc",GeomAbs_JoinType::GeomAbs_Arc) 
42 ········.value("GeomAbs_Tangent",GeomAbs_JoinType::GeomAbs_Tangent) 
43 ········.value("GeomAbs_Intersection",GeomAbs_JoinType::GeomAbs_Intersection).export_values(); 
44 ····py::enum_<GeomAbs_CurveType>(m,·"GeomAbs_CurveType",R"#(Identifies·the·type·of·a·curve.)#")40 ····py::enum_<GeomAbs_CurveType>(m,·"GeomAbs_CurveType",R"#(Identifies·the·type·of·a·curve.)#")
45 ········.value("GeomAbs_Line",GeomAbs_CurveType::GeomAbs_Line)41 ········.value("GeomAbs_Line",GeomAbs_CurveType::GeomAbs_Line)
46 ········.value("GeomAbs_Circle",GeomAbs_CurveType::GeomAbs_Circle)42 ········.value("GeomAbs_Circle",GeomAbs_CurveType::GeomAbs_Circle)
47 ········.value("GeomAbs_Ellipse",GeomAbs_CurveType::GeomAbs_Ellipse)43 ········.value("GeomAbs_Ellipse",GeomAbs_CurveType::GeomAbs_Ellipse)
48 ········.value("GeomAbs_Hyperbola",GeomAbs_CurveType::GeomAbs_Hyperbola)44 ········.value("GeomAbs_Hyperbola",GeomAbs_CurveType::GeomAbs_Hyperbola)
49 ········.value("GeomAbs_Parabola",GeomAbs_CurveType::GeomAbs_Parabola)45 ········.value("GeomAbs_Parabola",GeomAbs_CurveType::GeomAbs_Parabola)
50 ········.value("GeomAbs_BezierCurve",GeomAbs_CurveType::GeomAbs_BezierCurve)46 ········.value("GeomAbs_BezierCurve",GeomAbs_CurveType::GeomAbs_BezierCurve)
51 ········.value("GeomAbs_BSplineCurve",GeomAbs_CurveType::GeomAbs_BSplineCurve)47 ········.value("GeomAbs_BSplineCurve",GeomAbs_CurveType::GeomAbs_BSplineCurve)
52 ········.value("GeomAbs_OffsetCurve",GeomAbs_CurveType::GeomAbs_OffsetCurve)48 ········.value("GeomAbs_OffsetCurve",GeomAbs_CurveType::GeomAbs_OffsetCurve)
53 ········.value("GeomAbs_OtherCurve",GeomAbs_CurveType::GeomAbs_OtherCurve).export_values();49 ········.value("GeomAbs_OtherCurve",GeomAbs_CurveType::GeomAbs_OtherCurve).export_values();
54 ····py::enum_<GeomAbs_Shape>(m,·"GeomAbs_Shape",R"#(Provides·information·about·the·continuity·of·a·curve:·-·C0:·only·geometric·continuity.·-·G1:·for·each·point·on·the·curve,·the·tangent·vectors·"on·the·right"·and·"on·the·left"·are·collinear·with·the·same·orientation.·-·C1:·cont[·...·truncated·by·diffoscope;·len:·1212,·SHA:·ec5216ec5d5bc4aa191b5386e46f2c38410b954309d78ac380c26b462ac30a2f·...·])#")50 ····py::enum_<GeomAbs_IsoType>(m,·"GeomAbs_IsoType",R"#(this·enumeration·describes·if·a·curve·is·an·U·isoparaetric·or·V·isoparametric)#")
55 ········.value("GeomAbs_C0",GeomAbs_Shape::GeomAbs_C0)51 ········.value("GeomAbs_IsoU",GeomAbs_IsoType::GeomAbs_IsoU)
56 ········.value("GeomAbs_G1",GeomAbs_Shape::GeomAbs_G1)52 ········.value("GeomAbs_IsoV",GeomAbs_IsoType::GeomAbs_IsoV)
57 ········.value("GeomAbs_C1",GeomAbs_Shape::GeomAbs_C1) 
58 ········.value("GeomAbs_G2",GeomAbs_Shape::GeomAbs_G2) 
59 ········.value("GeomAbs_C2",GeomAbs_Shape::GeomAbs_C2) 
60 ········.value("GeomAbs_C3",GeomAbs_Shape::GeomAbs_C3) 
61 ········.value("GeomAbs_CN",GeomAbs_Shape::GeomAbs_CN).export_values();53 ········.value("GeomAbs_NoneIso",GeomAbs_IsoType::GeomAbs_NoneIso).export_values();
62 ····py::enum_<GeomAbs_SurfaceType>(m,·"GeomAbs_SurfaceType",R"#()#")54 ····py::enum_<GeomAbs_SurfaceType>(m,·"GeomAbs_SurfaceType",R"#()#")
63 ········.value("GeomAbs_Plane",GeomAbs_SurfaceType::GeomAbs_Plane)55 ········.value("GeomAbs_Plane",GeomAbs_SurfaceType::GeomAbs_Plane)
64 ········.value("GeomAbs_Cylinder",GeomAbs_SurfaceType::GeomAbs_Cylinder)56 ········.value("GeomAbs_Cylinder",GeomAbs_SurfaceType::GeomAbs_Cylinder)
65 ········.value("GeomAbs_Cone",GeomAbs_SurfaceType::GeomAbs_Cone)57 ········.value("GeomAbs_Cone",GeomAbs_SurfaceType::GeomAbs_Cone)
66 ········.value("GeomAbs_Sphere",GeomAbs_SurfaceType::GeomAbs_Sphere)58 ········.value("GeomAbs_Sphere",GeomAbs_SurfaceType::GeomAbs_Sphere)
67 ········.value("GeomAbs_Torus",GeomAbs_SurfaceType::GeomAbs_Torus)59 ········.value("GeomAbs_Torus",GeomAbs_SurfaceType::GeomAbs_Torus)
68 ········.value("GeomAbs_BezierSurface",GeomAbs_SurfaceType::GeomAbs_BezierSurface)60 ········.value("GeomAbs_BezierSurface",GeomAbs_SurfaceType::GeomAbs_BezierSurface)
69 ········.value("GeomAbs_BSplineSurface",GeomAbs_SurfaceType::GeomAbs_BSplineSurface)61 ········.value("GeomAbs_BSplineSurface",GeomAbs_SurfaceType::GeomAbs_BSplineSurface)
70 ········.value("GeomAbs_SurfaceOfRevolution",GeomAbs_SurfaceType::GeomAbs_SurfaceOfRevolution)62 ········.value("GeomAbs_SurfaceOfRevolution",GeomAbs_SurfaceType::GeomAbs_SurfaceOfRevolution)
71 ········.value("GeomAbs_SurfaceOfExtrusion",GeomAbs_SurfaceType::GeomAbs_SurfaceOfExtrusion)63 ········.value("GeomAbs_SurfaceOfExtrusion",GeomAbs_SurfaceType::GeomAbs_SurfaceOfExtrusion)
72 ········.value("GeomAbs_OffsetSurface",GeomAbs_SurfaceType::GeomAbs_OffsetSurface)64 ········.value("GeomAbs_OffsetSurface",GeomAbs_SurfaceType::GeomAbs_OffsetSurface)
73 ········.value("GeomAbs_OtherSurface",GeomAbs_SurfaceType::GeomAbs_OtherSurface).export_values();65 ········.value("GeomAbs_OtherSurface",GeomAbs_SurfaceType::GeomAbs_OtherSurface).export_values();
74 ····py::enum_<GeomAbs_IsoType>(m,·"GeomAbs_IsoType",R"#(this·enumeration·describes·if·a·curve·is·an·U·isoparaetric·or·V·isoparametric)#") 
75 ········.value("GeomAbs_IsoU",GeomAbs_IsoType::GeomAbs_IsoU) 
76 ········.value("GeomAbs_IsoV",GeomAbs_IsoType::GeomAbs_IsoV) 
77 ········.value("GeomAbs_NoneIso",GeomAbs_IsoType::GeomAbs_NoneIso).export_values(); 
78 ····py::enum_<GeomAbs_BSplKnotDistribution>(m,·"GeomAbs_BSplKnotDistribution",R"#(This·enumeration·is·used·in·the·classes·BSplineCurve·and·BSplineSurface·to·describe·the·repartition·of·set·of·knots.·(comments·in·classes·BSplineCurve·and·BSplineSurface))#")66 ····py::enum_<GeomAbs_BSplKnotDistribution>(m,·"GeomAbs_BSplKnotDistribution",R"#(This·enumeration·is·used·in·the·classes·BSplineCurve·and·BSplineSurface·to·describe·the·repartition·of·set·of·knots.·(comments·in·classes·BSplineCurve·and·BSplineSurface))#")
79 ········.value("GeomAbs_NonUniform",GeomAbs_BSplKnotDistribution::GeomAbs_NonUniform)67 ········.value("GeomAbs_NonUniform",GeomAbs_BSplKnotDistribution::GeomAbs_NonUniform)
80 ········.value("GeomAbs_Uniform",GeomAbs_BSplKnotDistribution::GeomAbs_Uniform)68 ········.value("GeomAbs_Uniform",GeomAbs_BSplKnotDistribution::GeomAbs_Uniform)
81 ········.value("GeomAbs_QuasiUniform",GeomAbs_BSplKnotDistribution::GeomAbs_QuasiUniform)69 ········.value("GeomAbs_QuasiUniform",GeomAbs_BSplKnotDistribution::GeomAbs_QuasiUniform)
82 ········.value("GeomAbs_PiecewiseBezier",GeomAbs_BSplKnotDistribution::GeomAbs_PiecewiseBezier).export_values();70 ········.value("GeomAbs_PiecewiseBezier",GeomAbs_BSplKnotDistribution::GeomAbs_PiecewiseBezier).export_values();
 71 ····py::enum_<GeomAbs_Shape>(m,·"GeomAbs_Shape",R"#(Provides·information·about·the·continuity·of·a·curve:·-·C0:·only·geometric·continuity.·-·G1:·for·each·point·on·the·curve,·the·tangent·vectors·"on·the·right"·and·"on·the·left"·are·collinear·with·the·same·orientation.·-·C1:·continuity·of·the·first·derivative.·The·"C1"·curve·is·also·"G1"·but,·in·addition,·the·tangent·vectors·"·on·the·right"·and·"on·the·left"·are·equal.·-·G2:·for·each·point·on·the·curve,·the·normalized·normal·vectors·"on·the·right"·and·"on·the·left"·are·equal.·-·C2:·continuity·of·the·second·derivative.·-·C3:·continuity·of·the·third·derivative.·-·CN:·continuity·of·the·N-th·derivative,·whatever·is·the·value·given·for·N·(infinite·order·of·continuity).·Also·provides·information·about·the·continuity·of·a·surface:·-·C0:·only·geometric·continuity.·-·C1:·continuity·of·the·first·derivatives;·any·isoparametric·(in·U·or·V)·of·a·surface·"C1"·is·also·"C1".·-·G2:·for·BSpline·curves·only;·"on·the·right"·and·"on·the·left"·of·a·knot·the·computation·of·the·"main·curvature·radii"·and·the·"main·directions"·(when·they·exist)·gives·the·same·result.·-·C2:·continuity·of·the·second·derivative.·-·C3:·continuity·of·the·third·derivative.·-·CN:·continuity·of·any·N-th·derivative,·whatever·is·the·value·given·for·N·(infinite·order·of·continuity).·We·may·also·say·that·a·surface·is·"Ci"·in·u,·and·"Cj"·in·v·to·indicate·the·continuity·of·its·derivatives·up·to·the·order·i·in·the·u·parametric·direction,·and·j·in·the·v·parametric·direction.)#")
 72 ········.value("GeomAbs_C0",GeomAbs_Shape::GeomAbs_C0)
 73 ········.value("GeomAbs_G1",GeomAbs_Shape::GeomAbs_G1)
 74 ········.value("GeomAbs_C1",GeomAbs_Shape::GeomAbs_C1)
 75 ········.value("GeomAbs_G2",GeomAbs_Shape::GeomAbs_G2)
 76 ········.value("GeomAbs_C2",GeomAbs_Shape::GeomAbs_C2)
 77 ········.value("GeomAbs_C3",GeomAbs_Shape::GeomAbs_C3)
 78 ········.value("GeomAbs_CN",GeomAbs_Shape::GeomAbs_CN).export_values();
 79 ····py::enum_<GeomAbs_JoinType>(m,·"GeomAbs_JoinType",R"#(Characterizes·the·type·of·a·join,·built·by·an·algorithm·for·constructing·parallel·curves,·between·two·consecutive·arcs·of·a·contour·parallel·to·a·given·contour.)#")
 80 ········.value("GeomAbs_Arc",GeomAbs_JoinType::GeomAbs_Arc)
 81 ········.value("GeomAbs_Tangent",GeomAbs_JoinType::GeomAbs_Tangent)
 82 ········.value("GeomAbs_Intersection",GeomAbs_JoinType::GeomAbs_Intersection).export_values();
  
83 //Python·trampoline·classes83 //Python·trampoline·classes
  
84 //·pre-register·typdefs+classes·(topologically·sorted)84 //·pre-register·typdefs+classes·(topologically·sorted)
  
85 };85 };
  
⊟
2.47 KB
./usr/share/libocp/OCP/GeomFill_pre.cpp
Ordering differences only
    
Offset 173, 28 lines modifiedOffset 173, 28 lines modified
173 py::module·m·=·main_module.def_submodule("GeomFill",·R"#()#");173 py::module·m·=·main_module.def_submodule("GeomFill",·R"#()#");
  
174 //·add·namespaces·as·submodules174 //·add·namespaces·as·submodules
  
175 //·user-defined·inclusion·per·module·in·the·body175 //·user-defined·inclusion·per·module·in·the·body
  
176 //·enums176 //·enums
177 ····py::enum_<GeomFill_ApproxStyle>(m,·"GeomFill_ApproxStyle",R"#()#") 
178 ········.value("GeomFill_Section",GeomFill_ApproxStyle::GeomFill_Section) 
179 ········.value("GeomFill_Location",GeomFill_ApproxStyle::GeomFill_Location).export_values(); 
180 ····py::enum_<GeomFill_Trihedron>(m,·"GeomFill_Trihedron",R"#()#")177 ····py::enum_<GeomFill_Trihedron>(m,·"GeomFill_Trihedron",R"#()#")
181 ········.value("GeomFill_IsCorrectedFrenet",GeomFill_Trihedron::GeomFill_IsCorrectedFrenet)178 ········.value("GeomFill_IsCorrectedFrenet",GeomFill_Trihedron::GeomFill_IsCorrectedFrenet)
182 ········.value("GeomFill_IsFixed",GeomFill_Trihedron::GeomFill_IsFixed)179 ········.value("GeomFill_IsFixed",GeomFill_Trihedron::GeomFill_IsFixed)
183 ········.value("GeomFill_IsFrenet",GeomFill_Trihedron::GeomFill_IsFrenet)180 ········.value("GeomFill_IsFrenet",GeomFill_Trihedron::GeomFill_IsFrenet)
184 ········.value("GeomFill_IsConstantNormal",GeomFill_Trihedron::GeomFill_IsConstantNormal)181 ········.value("GeomFill_IsConstantNormal",GeomFill_Trihedron::GeomFill_IsConstantNormal)
185 ········.value("GeomFill_IsDarboux",GeomFill_Trihedron::GeomFill_IsDarboux)182 ········.value("GeomFill_IsDarboux",GeomFill_Trihedron::GeomFill_IsDarboux)
186 ········.value("GeomFill_IsGuideAC",GeomFill_Trihedron::GeomFill_IsGuideAC)183 ········.value("GeomFill_IsGuideAC",GeomFill_Trihedron::GeomFill_IsGuideAC)
187 ········.value("GeomFill_IsGuidePlan",GeomFill_Trihedron::GeomFill_IsGuidePlan)184 ········.value("GeomFill_IsGuidePlan",GeomFill_Trihedron::GeomFill_IsGuidePlan)
188 ········.value("GeomFill_IsGuideACWithContact",GeomFill_Trihedron::GeomFill_IsGuideACWithContact)185 ········.value("GeomFill_IsGuideACWithContact",GeomFill_Trihedron::GeomFill_IsGuideACWithContact)
189 ········.value("GeomFill_IsGuidePlanWithContact",GeomFill_Trihedron::GeomFill_IsGuidePlanWithContact)186 ········.value("GeomFill_IsGuidePlanWithContact",GeomFill_Trihedron::GeomFill_IsGuidePlanWithContact)
190 ········.value("GeomFill_IsDiscreteTrihedron",GeomFill_Trihedron::GeomFill_IsDiscreteTrihedron).export_values();187 ········.value("GeomFill_IsDiscreteTrihedron",GeomFill_Trihedron::GeomFill_IsDiscreteTrihedron).export_values();
 188 ····py::enum_<GeomFill_ApproxStyle>(m,·"GeomFill_ApproxStyle",R"#()#")
 189 ········.value("GeomFill_Section",GeomFill_ApproxStyle::GeomFill_Section)
 190 ········.value("GeomFill_Location",GeomFill_ApproxStyle::GeomFill_Location).export_values();
191 ····py::enum_<GeomFill_FillingStyle>(m,·"GeomFill_FillingStyle",R"#(Defines·the·three·filling·styles·used·in·this·package·-·GeomFill_Stretch·-·the·style·with·the·flattest·patches·-·GeomFill_Coons·-·a·rounded·style·of·patch·with·less·depth·than·those·of·Curved·-·GeomFill_Curved·-·the·style·with·the·most·rounded·patches.)#")191 ····py::enum_<GeomFill_FillingStyle>(m,·"GeomFill_FillingStyle",R"#(Defines·the·three·filling·styles·used·in·this·package·-·GeomFill_Stretch·-·the·style·with·the·flattest·patches·-·GeomFill_Coons·-·a·rounded·style·of·patch·with·less·depth·than·those·of·Curved·-·GeomFill_Curved·-·the·style·with·the·most·rounded·patches.)#")
192 ········.value("GeomFill_StretchStyle",GeomFill_FillingStyle::GeomFill_StretchStyle)192 ········.value("GeomFill_StretchStyle",GeomFill_FillingStyle::GeomFill_StretchStyle)
193 ········.value("GeomFill_CoonsStyle",GeomFill_FillingStyle::GeomFill_CoonsStyle)193 ········.value("GeomFill_CoonsStyle",GeomFill_FillingStyle::GeomFill_CoonsStyle)
194 ········.value("GeomFill_CurvedStyle",GeomFill_FillingStyle::GeomFill_CurvedStyle).export_values();194 ········.value("GeomFill_CurvedStyle",GeomFill_FillingStyle::GeomFill_CurvedStyle).export_values();
195 ····py::enum_<GeomFill_PipeError>(m,·"GeomFill_PipeError",R"#()#")195 ····py::enum_<GeomFill_PipeError>(m,·"GeomFill_PipeError",R"#()#")
196 ········.value("GeomFill_PipeOk",GeomFill_PipeError::GeomFill_PipeOk)196 ········.value("GeomFill_PipeOk",GeomFill_PipeError::GeomFill_PipeOk)
197 ········.value("GeomFill_PipeNotOk",GeomFill_PipeError::GeomFill_PipeNotOk)197 ········.value("GeomFill_PipeNotOk",GeomFill_PipeError::GeomFill_PipeNotOk)
⊟
78.4 KB
./usr/share/libocp/OCP/Graphic3d_pre.cpp
Ordering differences only
    
Offset 284, 83 lines modifiedOffset 284, 58 lines modified
  
284 //·add·namespaces·as·submodules284 //·add·namespaces·as·submodules
285 m.def_submodule("Graphic3d_TransformUtils");285 m.def_submodule("Graphic3d_TransformUtils");
  
286 //·user-defined·inclusion·per·module·in·the·body286 //·user-defined·inclusion·per·module·in·the·body
  
287 //·enums287 //·enums
 288 ····m.attr("Graphic3d_ArrayFlags_None")·=·py::cast(int(Graphic3d_ArrayFlags_None));
 289 ····m.attr("Graphic3d_ArrayFlags_VertexNormal")·=·py::cast(int(Graphic3d_ArrayFlags_VertexNormal));
 290 ····m.attr("Graphic3d_ArrayFlags_VertexColor")·=·py::cast(int(Graphic3d_ArrayFlags_VertexColor));
 291 ····m.attr("Graphic3d_ArrayFlags_VertexTexel")·=·py::cast(int(Graphic3d_ArrayFlags_VertexTexel));
 292 ····m.attr("Graphic3d_ArrayFlags_BoundColor")·=·py::cast(int(Graphic3d_ArrayFlags_BoundColor));
 293 ····m.attr("Graphic3d_ArrayFlags_AttribsMutable")·=·py::cast(int(Graphic3d_ArrayFlags_AttribsMutable));
 294 ····m.attr("Graphic3d_ArrayFlags_AttribsDeinterleaved")·=·py::cast(int(Graphic3d_ArrayFlags_AttribsDeinterleaved));
 295 ····m.attr("Graphic3d_ArrayFlags_IndexesMutable")·=·py::cast(int(Graphic3d_ArrayFlags_IndexesMutable));
 296 ····py::enum_<Graphic3d_FresnelModel>(m,·"Graphic3d_FresnelModel",R"#(Type·of·the·Fresnel·model.)#")
 297 ········.value("Graphic3d_FM_SCHLICK",Graphic3d_FresnelModel::Graphic3d_FM_SCHLICK)
 298 ········.value("Graphic3d_FM_CONSTANT",Graphic3d_FresnelModel::Graphic3d_FM_CONSTANT)
 299 ········.value("Graphic3d_FM_CONDUCTOR",Graphic3d_FresnelModel::Graphic3d_FM_CONDUCTOR)
 300 ········.value("Graphic3d_FM_DIELECTRIC",Graphic3d_FresnelModel::Graphic3d_FM_DIELECTRIC).export_values();
 301 ····py::enum_<Graphic3d_RenderingMode>(m,·"Graphic3d_RenderingMode",R"#(Describes·rendering·modes.·-·RM_RASTERIZATION:·enables·OpenGL·rasterization·mode;·-·RM_RAYTRACING:·enables·GPU·ray-tracing·mode.)#")
 302 ········.value("Graphic3d_RM_RASTERIZATION",Graphic3d_RenderingMode::Graphic3d_RM_RASTERIZATION)
 303 ········.value("Graphic3d_RM_RAYTRACING",Graphic3d_RenderingMode::Graphic3d_RM_RAYTRACING).export_values();
 304 ····py::enum_<Graphic3d_VerticalTextAlignment>(m,·"Graphic3d_VerticalTextAlignment",R"#(Defines·the·vertical·position·of·the·text·relative·to·its·anchor.)#")
 305 ········.value("Graphic3d_VTA_BOTTOM",Graphic3d_VerticalTextAlignment::Graphic3d_VTA_BOTTOM)
 306 ········.value("Graphic3d_VTA_CENTER",Graphic3d_VerticalTextAlignment::Graphic3d_VTA_CENTER)
 307 ········.value("Graphic3d_VTA_TOP",Graphic3d_VerticalTextAlignment::Graphic3d_VTA_TOP)
 308 ········.value("Graphic3d_VTA_TOPFIRSTLINE",Graphic3d_VerticalTextAlignment::Graphic3d_VTA_TOPFIRSTLINE).export_values();
288 ····py::enum_<Graphic3d_AlphaMode>(m,·"Graphic3d_AlphaMode",R"#(Defines·how·alpha·value·of·base·color·/·texture·should·be·treated.)#")309 ····py::enum_<Graphic3d_AlphaMode>(m,·"Graphic3d_AlphaMode",R"#(Defines·how·alpha·value·of·base·color·/·texture·should·be·treated.)#")
289 ········.value("Graphic3d_AlphaMode_Opaque",Graphic3d_AlphaMode::Graphic3d_AlphaMode_Opaque)310 ········.value("Graphic3d_AlphaMode_Opaque",Graphic3d_AlphaMode::Graphic3d_AlphaMode_Opaque)
290 ········.value("Graphic3d_AlphaMode_Mask",Graphic3d_AlphaMode::Graphic3d_AlphaMode_Mask)311 ········.value("Graphic3d_AlphaMode_Mask",Graphic3d_AlphaMode::Graphic3d_AlphaMode_Mask)
291 ········.value("Graphic3d_AlphaMode_Blend",Graphic3d_AlphaMode::Graphic3d_AlphaMode_Blend)312 ········.value("Graphic3d_AlphaMode_Blend",Graphic3d_AlphaMode::Graphic3d_AlphaMode_Blend)
292 ········.value("Graphic3d_AlphaMode_MaskBlend",Graphic3d_AlphaMode::Graphic3d_AlphaMode_MaskBlend)313 ········.value("Graphic3d_AlphaMode_MaskBlend",Graphic3d_AlphaMode::Graphic3d_AlphaMode_MaskBlend)
293 ········.value("Graphic3d_AlphaMode_BlendAuto",Graphic3d_AlphaMode::Graphic3d_AlphaMode_BlendAuto).export_values();314 ········.value("Graphic3d_AlphaMode_BlendAuto",Graphic3d_AlphaMode::Graphic3d_AlphaMode_BlendAuto).export_values();
 315 ····py::enum_<Graphic3d_ToneMappingMethod>(m,·"Graphic3d_ToneMappingMethod",R"#(Enumerates·tone·mapping·methods.)#")
 316 ········.value("Graphic3d_ToneMappingMethod_Disabled",Graphic3d_ToneMappingMethod::Graphic3d_ToneMappingMethod_Disabled)
 317 ········.value("Graphic3d_ToneMappingMethod_Filmic",Graphic3d_ToneMappingMethod::Graphic3d_ToneMappingMethod_Filmic).export_values();
294 ····py::enum_<Graphic3d_FresnelModel>(m,·"Graphic3d_FresnelModel",R"#(Type·of·the·Fresnel·model.)#") 
295 ········.value("Graphic3d_FM_SCHLICK",Graphic3d_FresnelModel::Graphic3d_FM_SCHLICK) 
296 ········.value("Graphic3d_FM_CONSTANT",Graphic3d_FresnelModel::Graphic3d_FM_CONSTANT) 
297 ········.value("Graphic3d_FM_CONDUCTOR",Graphic3d_FresnelModel::Graphic3d_FM_CONDUCTOR) 
298 ········.value("Graphic3d_FM_DIELECTRIC",Graphic3d_FresnelModel::Graphic3d_FM_DIELECTRIC).export_values(); 
299 ····py::enum_<Graphic3d_TypeOfReflection>(m,·"Graphic3d_TypeOfReflection",R"#(Nature·of·the·reflection·of·a·material.)#") 
300 ········.value("Graphic3d_TOR_AMBIENT",Graphic3d_TypeOfReflection::Graphic3d_TOR_AMBIENT) 
301 ········.value("Graphic3d_TOR_DIFFUSE",Graphic3d_TypeOfReflection::Graphic3d_TOR_DIFFUSE) 
302 ········.value("Graphic3d_TOR_SPECULAR",Graphic3d_TypeOfReflection::Graphic3d_TOR_SPECULAR) 
303 ········.value("Graphic3d_TOR_EMISSION",Graphic3d_TypeOfReflection::Graphic3d_TOR_EMISSION).export_values(); 
304 ····m.attr("Graphic3d_TypeOfReflection_NB")·=·py::cast(int(Graphic3d_TypeOfReflection_NB)); 
305 ····py::enum_<Graphic3d_ClipState>(m,·"Graphic3d_ClipState",R"#(Clipping·state.)#") 
306 ········.value("Graphic3d_ClipState_Out",Graphic3d_ClipState::Graphic3d_ClipState_Out) 
307 ········.value("Graphic3d_ClipState_In",Graphic3d_ClipState::Graphic3d_ClipState_In) 
308 ········.value("Graphic3d_ClipState_On",Graphic3d_ClipState::Graphic3d_ClipState_On).export_values(); 
309 ····py::enum_<Graphic3d_HorizontalTextAlignment>(m,·"Graphic3d_HorizontalTextAlignment",R"#(Defines·the·horizontal·position·of·the·text·relative·to·its·anchor.)#") 
310 ········.value("Graphic3d_HTA_LEFT",Graphic3d_HorizontalTextAlignment::Graphic3d_HTA_LEFT) 
311 ········.value("Graphic3d_HTA_CENTER",Graphic3d_HorizontalTextAlignment::Graphic3d_HTA_CENTER) 
312 ········.value("Graphic3d_HTA_RIGHT",Graphic3d_HorizontalTextAlignment::Graphic3d_HTA_RIGHT).export_values(); 
313 ····py::enum_<Graphic3d_TypeOfLightSource>(m,·"Graphic3d_TypeOfLightSource",R"#(Definition·of·all·the·type·of·light·source.)#")318 ····py::enum_<Graphic3d_TypeOfLightSource>(m,·"Graphic3d_TypeOfLightSource",R"#(Definition·of·all·the·type·of·light·source.)#")
314 ········.value("Graphic3d_TypeOfLightSource_Ambient",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Ambient)319 ········.value("Graphic3d_TypeOfLightSource_Ambient",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Ambient)
315 ········.value("Graphic3d_TypeOfLightSource_Directional",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Directional)320 ········.value("Graphic3d_TypeOfLightSource_Directional",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Directional)
316 ········.value("Graphic3d_TypeOfLightSource_Positional",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Positional)321 ········.value("Graphic3d_TypeOfLightSource_Positional",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Positional)
317 ········.value("Graphic3d_TypeOfLightSource_Spot",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Spot)322 ········.value("Graphic3d_TypeOfLightSource_Spot",Graphic3d_TypeOfLightSource::Graphic3d_TypeOfLightSource_Spot)
318 ········.value("Graphic3d_TOLS_AMBIENT",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_AMBIENT)323 ········.value("Graphic3d_TOLS_AMBIENT",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_AMBIENT)
319 ········.value("Graphic3d_TOLS_DIRECTIONAL",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_DIRECTIONAL)324 ········.value("Graphic3d_TOLS_DIRECTIONAL",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_DIRECTIONAL)
320 ········.value("Graphic3d_TOLS_POSITIONAL",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_POSITIONAL)325 ········.value("Graphic3d_TOLS_POSITIONAL",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_POSITIONAL)
321 ········.value("Graphic3d_TOLS_SPOT",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_SPOT)326 ········.value("Graphic3d_TOLS_SPOT",Graphic3d_TypeOfLightSource::Graphic3d_TOLS_SPOT)
322 ········.value("V3d_AMBIENT",Graphic3d_TypeOfLightSource::V3d_AMBIENT)327 ········.value("V3d_AMBIENT",Graphic3d_TypeOfLightSource::V3d_AMBIENT)
323 ········.value("V3d_DIRECTIONAL",Graphic3d_TypeOfLightSource::V3d_DIRECTIONAL)328 ········.value("V3d_DIRECTIONAL",Graphic3d_TypeOfLightSource::V3d_DIRECTIONAL)
324 ········.value("V3d_POSITIONAL",Graphic3d_TypeOfLightSource::V3d_POSITIONAL)329 ········.value("V3d_POSITIONAL",Graphic3d_TypeOfLightSource::V3d_POSITIONAL)
325 ········.value("V3d_SPOT",Graphic3d_TypeOfLightSource::V3d_SPOT).export_values();330 ········.value("V3d_SPOT",Graphic3d_TypeOfLightSource::V3d_SPOT).export_values();
326 ····m.attr("Graphic3d_TypeOfLightSource_NB")·=·py::cast(int(Graphic3d_TypeOfLightSource_NB));331 ····m.attr("Graphic3d_TypeOfLightSource_NB")·=·py::cast(int(Graphic3d_TypeOfLightSource_NB));
327 ····py::enum_<Graphic3d_NameOfTexturePlane>(m,·"Graphic3d_NameOfTexturePlane",R"#(Type·of·the·texture·projection·plane·for·both·S·and·T·texture·coordinate.)#") 
328 ········.value("Graphic3d_NOTP_XY",Graphic3d_NameOfTexturePlane::Graphic3d_NOTP_XY) 
329 ········.value("Graphic3d_NOTP_YZ",Graphic3d_NameOfTexturePlane::Graphic3d_NOTP_YZ) 
330 ········.value("Graphic3d_NOTP_ZX",Graphic3d_NameOfTexturePlane::Graphic3d_NOTP_ZX) 
331 ········.value("Graphic3d_NOTP_UNKNOWN",Graphic3d_NameOfTexturePlane::Graphic3d_NOTP_UNKNOWN).export_values(); 
332 ····py::enum_<Graphic3d_TypeOfPrimitiveArray>(m,·"Graphic3d_TypeOfPrimitiveArray",R"#(The·type·of·primitive·array·in·a·group·in·a·structure.)#") 
333 ········.value("Graphic3d_TOPA_UNDEFINED",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_UNDEFINED) 
334 ········.value("Graphic3d_TOPA_POINTS",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_POINTS) 
335 ········.value("Graphic3d_TOPA_SEGMENTS",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_SEGMENTS) 
336 ········.value("Graphic3d_TOPA_POLYLINES",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_POLYLINES) 
337 ········.value("Graphic3d_TOPA_TRIANGLES",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_TRIANGLES) 
338 ········.value("Graphic3d_TOPA_TRIANGLESTRIPS",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_TRIANGLESTRIPS) 
339 ········.value("Graphic3d_TOPA_TRIANGLEFANS",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_TRIANGLEFANS) 
340 ········.value("Graphic3d_TOPA_LINES_ADJACENCY",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_LINES_ADJACENCY) 
341 ········.value("Graphic3d_TOPA_LINE_STRIP_ADJACENCY",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_LINE_STRIP_ADJACENCY) 
342 ········.value("Graphic3d_TOPA_TRIANGLES_ADJACENCY",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_TRIANGLES_ADJACENCY) 
343 ········.value("Graphic3d_TOPA_TRIANGLE_STRIP_ADJACENCY",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_TRIANGLE_STRIP_ADJACENCY) 
344 ········.value("Graphic3d_TOPA_QUADRANGLES",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_QUADRANGLES) 
345 ········.value("Graphic3d_TOPA_QUADRANGLESTRIPS",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_QUADRANGLESTRIPS) 
346 ········.value("Graphic3d_TOPA_POLYGONS",Graphic3d_TypeOfPrimitiveArray::Graphic3d_TOPA_POLYGONS).export_values(); 
347 ····py::enum_<Graphic3d_DiagnosticInfo>(m,·"Graphic3d_DiagnosticInfo",R"#(Diagnostic·info·categories·bit·flags.)#") 
348 ········.value("Graphic3d_DiagnosticInfo_Device",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_Device) 
349 ········.value("Graphic3d_DiagnosticInfo_FrameBuffer",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_FrameBuffer) 
350 ········.value("Graphic3d_DiagnosticInfo_Limits",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_Limits) 
351 ········.value("Graphic3d_DiagnosticInfo_Memory",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_Memory) 
352 ········.value("Graphic3d_DiagnosticInfo_NativePlatform",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_NativePlatform) 
353 ········.value("Graphic3d_DiagnosticInfo_Extensions",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_Extensions) 
354 ········.value("Graphic3d_DiagnosticInfo_Short",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_Short) 
355 ········.value("Graphic3d_DiagnosticInfo_Basic",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_Basic) 
356 ········.value("Graphic3d_DiagnosticInfo_Complete",Graphic3d_DiagnosticInfo::Graphic3d_DiagnosticInfo_Complete).export_values(); 
357 ····py::enum_<Graphic3d_NameOfTexture2D>(m,·"Graphic3d_NameOfTexture2D",R"#(Types·of·standard·textures.)#")332 ····py::enum_<Graphic3d_NameOfTexture2D>(m,·"Graphic3d_NameOfTexture2D",R"#(Types·of·standard·textures.)#")
358 ········.value("Graphic3d_NOT_2D_MATRA",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MATRA)333 ········.value("Graphic3d_NOT_2D_MATRA",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MATRA)
359 ········.value("Graphic3d_NOT_2D_ALIENSKIN",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_ALIENSKIN)334 ········.value("Graphic3d_NOT_2D_ALIENSKIN",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_ALIENSKIN)
360 ········.value("Graphic3d_NOT_2D_BLUE_ROCK",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BLUE_ROCK)335 ········.value("Graphic3d_NOT_2D_BLUE_ROCK",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BLUE_ROCK)
361 ········.value("Graphic3d_NOT_2D_BLUEWHITE_PAPER",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BLUEWHITE_PAPER)336 ········.value("Graphic3d_NOT_2D_BLUEWHITE_PAPER",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BLUEWHITE_PAPER)
362 ········.value("Graphic3d_NOT_2D_BRUSHED",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BRUSHED)337 ········.value("Graphic3d_NOT_2D_BRUSHED",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BRUSHED)
363 ········.value("Graphic3d_NOT_2D_BUBBLES",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BUBBLES)338 ········.value("Graphic3d_NOT_2D_BUBBLES",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_BUBBLES)
Offset 377, 34 lines modifiedOffset 352, 201 lines modified
377 ········.value("Graphic3d_NOT_2D_KNURL",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_KNURL)352 ········.value("Graphic3d_NOT_2D_KNURL",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_KNURL)
378 ········.value("Graphic3d_NOT_2D_MAPLE",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MAPLE)353 ········.value("Graphic3d_NOT_2D_MAPLE",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MAPLE)
379 ········.value("Graphic3d_NOT_2D_MARBLE",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MARBLE)354 ········.value("Graphic3d_NOT_2D_MARBLE",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MARBLE)
380 ········.value("Graphic3d_NOT_2D_MOTTLED",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MOTTLED)355 ········.value("Graphic3d_NOT_2D_MOTTLED",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_MOTTLED)
381 ········.value("Graphic3d_NOT_2D_RAIN",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_RAIN)356 ········.value("Graphic3d_NOT_2D_RAIN",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_RAIN)
382 ········.value("Graphic3d_NOT_2D_CHESS",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_CHESS)357 ········.value("Graphic3d_NOT_2D_CHESS",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_CHESS)
383 ········.value("Graphic3d_NOT_2D_UNKNOWN",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_UNKNOWN).export_values();358 ········.value("Graphic3d_NOT_2D_UNKNOWN",Graphic3d_NameOfTexture2D::Graphic3d_NOT_2D_UNKNOWN).export_values();
384 ····py::enum_<Graphic3d_TextureSetBits>(m,·"Graphic3d_TextureSetBits",R"#(Standard·texture·units·combination·bits.)#") 
385 ········.value("Graphic3d_TextureSetBits_NONE",Graphic3d_TextureSetBits::Graphic3d_TextureSetBits_NONE) 
386 ········.value("Graphic3d_TextureSetBits_BaseColor",Graphic3d_TextureSetBits::Graphic3d_TextureSetBits_BaseColor) 
387 ········.value("Graphic3d_TextureSetBits_Emissive",Graphic3d_TextureSetBits::Graphic3d_TextureSetBits_Emissive) 
388 ········.value("Graphic3d_TextureSetBits_Occlusion",Graphic3d_TextureSetBits::Graphic3d_TextureSetBits_Occlusion) 
389 ········.value("Graphic3d_TextureSetBits_Normal",Graphic3d_TextureSetBits::Graphic3d_TextureSetBits_Normal) 
390 ········.value("Graphic3d_TextureSetBits_MetallicRoughness",Graphic3d_TextureSetBits::Graphic3d_TextureSetBits_MetallicRoughness).export_values();359 ····py::enum_<Graphic3d_ClipState>(m,·"Graphic3d_ClipState",R"#(Clipping·state.)#")
 360 ········.value("Graphic3d_ClipState_Out",Graphic3d_ClipState::Graphic3d_ClipState_Out)
 361 ········.value("Graphic3d_ClipState_In",Graphic3d_ClipState::Graphic3d_ClipState_In)
 362 ········.value("Graphic3d_ClipState_On",Graphic3d_ClipState::Graphic3d_ClipState_On).export_values();
 363 ····py::enum_<Graphic3d_TextPath>(m,·"Graphic3d_TextPath",R"#(Direction·in·which·text·is·displayed.)#")
 364 ········.value("Graphic3d_TP_UP",Graphic3d_TextPath::Graphic3d_TP_UP)
Max diff block lines reached; 50241/80208 bytes (62.64%) of diff not shown.
⊟
7.18 KB
./usr/share/libocp/OCP/IFSelect_pre.cpp
Ordering differences only
    
Offset 367, 45 lines modifiedOffset 367, 45 lines modified
367 py::module·m·=·main_module.def_submodule("IFSelect",·R"#()#");367 py::module·m·=·main_module.def_submodule("IFSelect",·R"#()#");
  
368 //·add·namespaces·as·submodules368 //·add·namespaces·as·submodules
  
369 //·user-defined·inclusion·per·module·in·the·body369 //·user-defined·inclusion·per·module·in·the·body
  
370 //·enums370 //·enums
 371 ····py::enum_<IFSelect_PrintFail>(m,·"IFSelect_PrintFail",R"#(Indicates·whether·there·will·be·information·on·warnings·as·well·as·on·failures.·The·terms·of·this·enumeration·have·the·following·semantics:·-·IFSelect_FailOnly·gives·information·on·failures·only·-·IFSelect_FailAndWarn·gives·information·on·both·failures·and·warnings.·used·to·pilot·PrintCheckList)#")
 372 ········.value("IFSelect_FailOnly",IFSelect_PrintFail::IFSelect_FailOnly)
 373 ········.value("IFSelect_FailAndWarn",IFSelect_PrintFail::IFSelect_FailAndWarn).export_values();
 374 ····py::enum_<IFSelect_EditValue>(m,·"IFSelect_EditValue",R"#(Controls·access·on·Values·by·an·Editor·EditOptional·:·normal·access,·in·addition·may·be·removed·Editable·:·normal·access,·must·be·present·EditProtected·:·access·must·be·validated·EditComputed·:·why·write·it·?·it·will·be·recomputed·EditRead·:·no·way·to·write·it,·only·for·read·EditDynamic·:·not·a·field,·only·to·be·displayed)#")
 375 ········.value("IFSelect_Optional",IFSelect_EditValue::IFSelect_Optional)
 376 ········.value("IFSelect_Editable",IFSelect_EditValue::IFSelect_Editable)
 377 ········.value("IFSelect_EditProtected",IFSelect_EditValue::IFSelect_EditProtected)
 378 ········.value("IFSelect_EditComputed",IFSelect_EditValue::IFSelect_EditComputed)
 379 ········.value("IFSelect_EditRead",IFSelect_EditValue::IFSelect_EditRead)
 380 ········.value("IFSelect_EditDynamic",IFSelect_EditValue::IFSelect_EditDynamic).export_values();
371 ····py::enum_<IFSelect_RemainMode>(m,·"IFSelect_RemainMode",R"#()#")381 ····py::enum_<IFSelect_RemainMode>(m,·"IFSelect_RemainMode",R"#()#")
372 ········.value("IFSelect_RemainForget",IFSelect_RemainMode::IFSelect_RemainForget)382 ········.value("IFSelect_RemainForget",IFSelect_RemainMode::IFSelect_RemainForget)
373 ········.value("IFSelect_RemainCompute",IFSelect_RemainMode::IFSelect_RemainCompute)383 ········.value("IFSelect_RemainCompute",IFSelect_RemainMode::IFSelect_RemainCompute)
374 ········.value("IFSelect_RemainDisplay",IFSelect_RemainMode::IFSelect_RemainDisplay)384 ········.value("IFSelect_RemainDisplay",IFSelect_RemainMode::IFSelect_RemainDisplay)
375 ········.value("IFSelect_RemainUndo",IFSelect_RemainMode::IFSelect_RemainUndo).export_values();385 ········.value("IFSelect_RemainUndo",IFSelect_RemainMode::IFSelect_RemainUndo).export_values();
376 ····py::enum_<IFSelect_PrintFail>(m,·"IFSelect_PrintFail",R"#(Indicates·whether·there·will·be·information·on·warnings·as·well·as·on·failures.·The·terms·of·this·enumeration·have·the·following·semantics:·-·IFSelect_FailOnly·gives·information·on·failures·only·-·IFSelect_FailAndWarn·gives·information·on·both·failures·and·warnings.·used·to·pilot·PrintCheckList)#") 
377 ········.value("IFSelect_FailOnly",IFSelect_PrintFail::IFSelect_FailOnly) 
378 ········.value("IFSelect_FailAndWarn",IFSelect_PrintFail::IFSelect_FailAndWarn).export_values(); 
379 ····py::enum_<IFSelect_ReturnStatus>(m,·"IFSelect_ReturnStatus",R"#(Qualifies·an·execution·status·:·RetVoid·:·normal·execution·which·created·nothing,·or·no·data·to·process·RetDone·:·normal·execution·with·a·result·RetError·:·error·in·command·or·input·data,·no·execution·RetFail·:·execution·was·run·and·has·failed·RetStop·:·indicates·end·or·stop·(such·as·Raise))#") 
380 ········.value("IFSelect_RetVoid",IFSelect_ReturnStatus::IFSelect_RetVoid) 
381 ········.value("IFSelect_RetDone",IFSelect_ReturnStatus::IFSelect_RetDone) 
382 ········.value("IFSelect_RetError",IFSelect_ReturnStatus::IFSelect_RetError) 
383 ········.value("IFSelect_RetFail",IFSelect_ReturnStatus::IFSelect_RetFail) 
384 ········.value("IFSelect_RetStop",IFSelect_ReturnStatus::IFSelect_RetStop).export_values(); 
385 ····py::enum_<IFSelect_PrintCount>(m,·"IFSelect_PrintCount",R"#(Lets·you·choose·the·manner·in·which·you·want·to·analyze·an·IGES·or·STEP·file.·Your·analysis·can·be·either·message-oriented·or·entity-oriented.·The·specific·values·are·as·follows:·-·ItemsByEntity·is·a·sequential·list·of·all·messages·per·entity·of·the·defined·type·-·CountByItem·is·the·number·of·entities·of·the·defined·type,·with·their·rank·number·per·message·-·ShortByItem·is·the·number·of·entities·of·the·defined·type,·with·their·types·per·message;·displays·the·rank·numbers·of·the·first·five·entities·of·the·defined·type·per·message·-·ListByItem·is·the·number·of·entities·of·the·defined·type·per·message·and·the·numbers·of·the·entities·-·EntitiesByItem·is·the·number·of·entities·of·the·defined·type,·with·their·types,·rank·numbers·and·Directory·Entry·numbers·per·message·-·GeneralInfo·is·general·information·on·transfer·such·as:·-·number·of·entities·-·number·of·roots·-·number·of·resulting·Open·CASCADE·shapes·-·number·of·warnings·and·failures·-·CountSummary·summary·statistics·for·counters·and·signatures·-·ResultCount·information·that·contains·the·number·of·roots·in·the·IGES·file·and·the·number·of·resulting·Open·CASCADE·shapes.·-·Mapping·of·the·IGES·root·entities·to·the·resulting·Open·CASCADE·shape·(including·type·and·form·of·the·IGES·entity·and·type·of·the·resulting·shape).)#")386 ····py::enum_<IFSelect_PrintCount>(m,·"IFSelect_PrintCount",R"#(Lets·you·choose·the·manner·in·which·you·want·to·analyze·an·IGES·or·STEP·file.·Your·analysis·can·be·either·message-oriented·or·entity-oriented.·The·specific·values·are·as·follows:·-·ItemsByEntity·is·a·sequential·list·of·all·messages·per·entity·of·the·defined·type·-·CountByItem·is·the·number·of·entities·of·the·defined·type,·with·their·rank·number·per·message·-·ShortByItem·is·the·number·of·entities·of·the·defined·type,·with·their·types·per·message;·displays·the·rank·numbers·of·the·first·five·entities·of·the·defined·type·per·message·-·ListByItem·is·the·number·of·entities·of·the·defined·type·per·message·and·the·numbers·of·the·entities·-·EntitiesByItem·is·the·number·of·entities·of·the·defined·type,·with·their·types,·rank·numbers·and·Directory·Entry·numbers·per·message·-·GeneralInfo·is·general·information·on·transfer·such·as:·-·number·of·entities·-·number·of·roots·-·number·of·resulting·Open·CASCADE·shapes·-·number·of·warnings·and·failures·-·CountSummary·summary·statistics·for·counters·and·signatures·-·ResultCount·information·that·contains·the·number·of·roots·in·the·IGES·file·and·the·number·of·resulting·Open·CASCADE·shapes.·-·Mapping·of·the·IGES·root·entities·to·the·resulting·Open·CASCADE·shape·(including·type·and·form·of·the·IGES·entity·and·type·of·the·resulting·shape).)#")
386 ········.value("IFSelect_ItemsByEntity",IFSelect_PrintCount::IFSelect_ItemsByEntity)387 ········.value("IFSelect_ItemsByEntity",IFSelect_PrintCount::IFSelect_ItemsByEntity)
387 ········.value("IFSelect_CountByItem",IFSelect_PrintCount::IFSelect_CountByItem)388 ········.value("IFSelect_CountByItem",IFSelect_PrintCount::IFSelect_CountByItem)
388 ········.value("IFSelect_ShortByItem",IFSelect_PrintCount::IFSelect_ShortByItem)389 ········.value("IFSelect_ShortByItem",IFSelect_PrintCount::IFSelect_ShortByItem)
389 ········.value("IFSelect_ListByItem",IFSelect_PrintCount::IFSelect_ListByItem)390 ········.value("IFSelect_ListByItem",IFSelect_PrintCount::IFSelect_ListByItem)
390 ········.value("IFSelect_EntitiesByItem",IFSelect_PrintCount::IFSelect_EntitiesByItem)391 ········.value("IFSelect_EntitiesByItem",IFSelect_PrintCount::IFSelect_EntitiesByItem)
391 ········.value("IFSelect_CountSummary",IFSelect_PrintCount::IFSelect_CountSummary)392 ········.value("IFSelect_CountSummary",IFSelect_PrintCount::IFSelect_CountSummary)
392 ········.value("IFSelect_GeneralInfo",IFSelect_PrintCount::IFSelect_GeneralInfo)393 ········.value("IFSelect_GeneralInfo",IFSelect_PrintCount::IFSelect_GeneralInfo)
393 ········.value("IFSelect_Mapping",IFSelect_PrintCount::IFSelect_Mapping)394 ········.value("IFSelect_Mapping",IFSelect_PrintCount::IFSelect_Mapping)
394 ········.value("IFSelect_ResultCount",IFSelect_PrintCount::IFSelect_ResultCount).export_values();395 ········.value("IFSelect_ResultCount",IFSelect_PrintCount::IFSelect_ResultCount).export_values();
 396 ····py::enum_<IFSelect_ReturnStatus>(m,·"IFSelect_ReturnStatus",R"#(Qualifies·an·execution·status·:·RetVoid·:·normal·execution·which·created·nothing,·or·no·data·to·process·RetDone·:·normal·execution·with·a·result·RetError·:·error·in·command·or·input·data,·no·execution·RetFail·:·execution·was·run·and·has·failed·RetStop·:·indicates·end·or·stop·(such·as·Raise))#")
395 ····py::enum_<IFSelect_EditValue>(m,·"IFSelect_EditValue",R"#(Controls·access·on·Values·by·an·Editor·EditOptional·:·normal·access,·in·addition·may·be·removed·Editable·:·normal·access,·must·be·present·EditProtected·:·access·must·be·validated·EditComputed·:·why·write·it·?·it·will·be·recomputed·EditRead·:·no·way·to·write·it,·only·for·read·EditDynamic·:·not·a·field,·only·to·be·displayed)#") 
396 ········.value("IFSelect_Optional",IFSelect_EditValue::IFSelect_Optional) 
397 ········.value("IFSelect_Editable",IFSelect_EditValue::IFSelect_Editable) 
398 ········.value("IFSelect_EditProtected",IFSelect_EditValue::IFSelect_EditProtected) 
399 ········.value("IFSelect_EditComputed",IFSelect_EditValue::IFSelect_EditComputed) 
400 ········.value("IFSelect_EditRead",IFSelect_EditValue::IFSelect_EditRead)397 ········.value("IFSelect_RetVoid",IFSelect_ReturnStatus::IFSelect_RetVoid)
401 ········.value("IFSelect_EditDynamic",IFSelect_EditValue::IFSelect_EditDynamic).export_values();398 ········.value("IFSelect_RetDone",IFSelect_ReturnStatus::IFSelect_RetDone)
 399 ········.value("IFSelect_RetError",IFSelect_ReturnStatus::IFSelect_RetError)
 400 ········.value("IFSelect_RetFail",IFSelect_ReturnStatus::IFSelect_RetFail)
 401 ········.value("IFSelect_RetStop",IFSelect_ReturnStatus::IFSelect_RetStop).export_values();
  
402 //Python·trampoline·classes402 //Python·trampoline·classes
403 ····class·Py_IFSelect_Activator·:·public·IFSelect_Activator{403 ····class·Py_IFSelect_Activator·:·public·IFSelect_Activator{
404 ····public:404 ····public:
405 ········using·IFSelect_Activator::IFSelect_Activator;405 ········using·IFSelect_Activator::IFSelect_Activator;
  
  
⊟
5.76 KB
./usr/share/libocp/OCP/IGESData_pre.cpp
Ordering differences only
    
Offset 206, 38 lines modifiedOffset 206, 38 lines modified
206 py::module·m·=·main_module.def_submodule("IGESData",·R"#()#");206 py::module·m·=·main_module.def_submodule("IGESData",·R"#()#");
  
207 //·add·namespaces·as·submodules207 //·add·namespaces·as·submodules
  
208 //·user-defined·inclusion·per·module·in·the·body208 //·user-defined·inclusion·per·module·in·the·body
  
209 //·enums209 //·enums
210 ····py::enum_<IGESData_ReadStage>(m,·"IGESData_ReadStage",R"#(gives·successive·stages·of·reading·an·entity·(see·ParamReader))#") 
211 ········.value("IGESData_ReadDir",IGESData_ReadStage::IGESData_ReadDir)210 ····py::enum_<IGESData_DefList>(m,·"IGESData_DefList",R"#(Some·fields·of·an·IGES·entity·may·be·-·Undefined·-·Defined·as·a·single·item·-·Defined·as·a·list·of·items.·A·typical·example,·which·presents·this·kind·of·variation,·is·a·level·number.·This·enumeration·al[·...·truncated·by·diffoscope;·len:·486,·SHA:·6158ee2709cb8f365daf75266d5f2ae5868fc758f4dbc5091f42f826b0853840·...·])
 211 ········.value("IGESData_DefNone",IGESData_DefList::IGESData_DefNone)
212 ········.value("IGESData_ReadOwn",IGESData_ReadStage::IGESData_ReadOwn)212 ········.value("IGESData_DefOne",IGESData_DefList::IGESData_DefOne)
213 ········.value("IGESData_ReadAssocs",IGESData_ReadStage::IGESData_ReadAssocs)213 ········.value("IGESData_DefSeveral",IGESData_DefList::IGESData_DefSeveral)
 214 ········.value("IGESData_ErrorOne",IGESData_DefList::IGESData_ErrorOne)
 215 ········.value("IGESData_ErrorSeveral",IGESData_DefList::IGESData_ErrorSeveral).export_values();
 216 ····py::enum_<IGESData_Status>(m,·"IGESData_Status",R"#()#")
 217 ········.value("IGESData_EntityOK",IGESData_Status::IGESData_EntityOK)
 218 ········.value("IGESData_EntityError",IGESData_Status::IGESData_EntityError)
214 ········.value("IGESData_ReadProps",IGESData_ReadStage::IGESData_ReadProps)219 ········.value("IGESData_ReferenceError",IGESData_Status::IGESData_ReferenceError)
215 ········.value("IGESData_ReadEnd",IGESData_ReadStage::IGESData_ReadEnd).export_values();220 ········.value("IGESData_TypeError",IGESData_Status::IGESData_TypeError).export_values();
216 ····py::enum_<IGESData_DefType>(m,·"IGESData_DefType",R"#(Some·fields·of·an·IGES·entity·may·be·-·Undefined·-·Defined·as·a·positive·integer·-·Defined·as·a·reference·to·a·specialized·entity.·A·typical·example·of·this·kind·of·variation·is·color.·This·enumeration·allows·you·to·identify·which·of·the·above·is·the·case.·The·semantics·of·the·terms·are·as·follows:·-·DefVoid·indicates·that·the·item·contained·in·the·field·is·undefined·-·DefValue·indicates·that·the·item·is·defined·as·an·immediate·positive·integer·value·(i.e.·not·a·pointer)·-·DefReference·indicates·that·the·item·is·defined·as·an·entity·-·DefAny·indicates·the·item·could·not·be·determined·-·ErrorVal·indicates·that·the·item·is·defined·as·an·integer·but·its·value·is·incorrect·(it·could·be·out·of·range,·for·example)·-·ErrorRef·indicates·that·the·item·is·defined·as·an·entity·but·is·not·of·the·required·type.)#")221 ····py::enum_<IGESData_DefType>(m,·"IGESData_DefType",R"#(Some·fields·of·an·IGES·entity·may·be·-·Undefined·-·Defined·as·a·positive·integer·-·Defined·as·a·reference·to·a·specialized·entity.·A·typical·example·of·this·kind·of·variation·is·color.·This·enumeration·allows·you·to·identify·which·of·the·above·is·the·case.·The·semantics·of·the·terms·are·as·follows:·-·DefVoid·indicates·that·the·item·contained·in·the·field·is·undefined·-·DefValue·indicates·that·the·item·is·defined·as·an·immediate·positive·integer·value·(i.e.·not·a·pointer)·-·DefReference·indicates·that·the·item·is·defined·as·an·entity·-·DefAny·indicates·the·item·could·not·be·determined·-·ErrorVal·indicates·that·the·item·is·defined·as·an·integer·but·its·value·is·incorrect·(it·could·be·out·of·range,·for·example)·-·ErrorRef·indicates·that·the·item·is·defined·as·an·entity·but·is·not·of·the·required·type.)#")
217 ········.value("IGESData_DefVoid",IGESData_DefType::IGESData_DefVoid)222 ········.value("IGESData_DefVoid",IGESData_DefType::IGESData_DefVoid)
218 ········.value("IGESData_DefValue",IGESData_DefType::IGESData_DefValue)223 ········.value("IGESData_DefValue",IGESData_DefType::IGESData_DefValue)
219 ········.value("IGESData_DefReference",IGESData_DefType::IGESData_DefReference)224 ········.value("IGESData_DefReference",IGESData_DefType::IGESData_DefReference)
220 ········.value("IGESData_DefAny",IGESData_DefType::IGESData_DefAny)225 ········.value("IGESData_DefAny",IGESData_DefType::IGESData_DefAny)
221 ········.value("IGESData_ErrorVal",IGESData_DefType::IGESData_ErrorVal)226 ········.value("IGESData_ErrorVal",IGESData_DefType::IGESData_ErrorVal)
222 ········.value("IGESData_ErrorRef",IGESData_DefType::IGESData_ErrorRef).export_values();227 ········.value("IGESData_ErrorRef",IGESData_DefType::IGESData_ErrorRef).export_values();
223 ····py::enum_<IGESData_Status>(m,·"IGESData_Status",R"#()#")228 ····py::enum_<IGESData_ReadStage>(m,·"IGESData_ReadStage",R"#(gives·successive·stages·of·reading·an·entity·(see·ParamReader))#")
224 ········.value("IGESData_EntityOK",IGESData_Status::IGESData_EntityOK)229 ········.value("IGESData_ReadDir",IGESData_ReadStage::IGESData_ReadDir)
225 ········.value("IGESData_EntityError",IGESData_Status::IGESData_EntityError)230 ········.value("IGESData_ReadOwn",IGESData_ReadStage::IGESData_ReadOwn)
 231 ········.value("IGESData_ReadAssocs",IGESData_ReadStage::IGESData_ReadAssocs)
226 ········.value("IGESData_ReferenceError",IGESData_Status::IGESData_ReferenceError)232 ········.value("IGESData_ReadProps",IGESData_ReadStage::IGESData_ReadProps)
227 ········.value("IGESData_TypeError",IGESData_Status::IGESData_TypeError).export_values();233 ········.value("IGESData_ReadEnd",IGESData_ReadStage::IGESData_ReadEnd).export_values();
228 ····py::enum_<IGESData_DefList>(m,·"IGESData_DefList",R"#(Some·fields·of·an·IGES·entity·may·be·-·Undefined·-·Defined·as·a·single·item·-·Defined·as·a·list·of·items.·A·typical·example,·which·presents·this·kind·of·variation,·is·a·level·number.·This·enumeration·allows·you·to·identify·which·of·the·above·is·the·case.·The·semantics·of·the·terms·is·as·follows:·-·DefNone·indicates·that·the·list·is·empty·(there·is·not·even·a·single·item).·-·DefOne·indicates·that·the·list·contains·a·single·item.·-·DefSeveral·indicates·that·the·list·contains·several·items.·-·ErrorOne·indicates·that·the·list·contains·one·item,·but·that·this·item·is·incorrect·-·ErrorSeveral·indicates·that·the·list·contains·several·items,·but·that·at·least·one·of·them·is·incorrect.)#") 
229 ········.value("IGESData_DefNone",IGESData_DefList::IGESData_DefNone) 
230 ········.value("IGESData_DefOne",IGESData_DefList::IGESData_DefOne) 
231 ········.value("IGESData_DefSeveral",IGESData_DefList::IGESData_DefSeveral) 
232 ········.value("IGESData_ErrorOne",IGESData_DefList::IGESData_ErrorOne) 
233 ········.value("IGESData_ErrorSeveral",IGESData_DefList::IGESData_ErrorSeveral).export_values(); 
  
234 //Python·trampoline·classes234 //Python·trampoline·classes
235 ····class·Py_IGESData_FileRecognizer·:·public·IGESData_FileRecognizer{235 ····class·Py_IGESData_FileRecognizer·:·public·IGESData_FileRecognizer{
236 ····public:236 ····public:
237 ········using·IGESData_FileRecognizer::IGESData_FileRecognizer;237 ········using·IGESData_FileRecognizer::IGESData_FileRecognizer;
  
  
⊟
1.51 KB
./usr/share/libocp/OCP/IntRes2d_pre.cpp
Ordering differences only
    
Offset 44, 22 lines modifiedOffset 44, 22 lines modified
44 py::module·m·=·main_module.def_submodule("IntRes2d",·R"#()#");44 py::module·m·=·main_module.def_submodule("IntRes2d",·R"#()#");
  
45 //·add·namespaces·as·submodules45 //·add·namespaces·as·submodules
  
46 //·user-defined·inclusion·per·module·in·the·body46 //·user-defined·inclusion·per·module·in·the·body
  
47 //·enums47 //·enums
48 ····py::enum_<IntRes2d_Position>(m,·"IntRes2d_Position",R"#()#") 
49 ········.value("IntRes2d_Head",IntRes2d_Position::IntRes2d_Head) 
50 ········.value("IntRes2d_Middle",IntRes2d_Position::IntRes2d_Middle) 
51 ········.value("IntRes2d_End",IntRes2d_Position::IntRes2d_End).export_values(); 
52 ····py::enum_<IntRes2d_Situation>(m,·"IntRes2d_Situation",R"#()#")48 ····py::enum_<IntRes2d_Situation>(m,·"IntRes2d_Situation",R"#()#")
53 ········.value("IntRes2d_Inside",IntRes2d_Situation::IntRes2d_Inside)49 ········.value("IntRes2d_Inside",IntRes2d_Situation::IntRes2d_Inside)
54 ········.value("IntRes2d_Outside",IntRes2d_Situation::IntRes2d_Outside)50 ········.value("IntRes2d_Outside",IntRes2d_Situation::IntRes2d_Outside)
55 ········.value("IntRes2d_Unknown",IntRes2d_Situation::IntRes2d_Unknown).export_values();51 ········.value("IntRes2d_Unknown",IntRes2d_Situation::IntRes2d_Unknown).export_values();
 52 ····py::enum_<IntRes2d_Position>(m,·"IntRes2d_Position",R"#()#")
 53 ········.value("IntRes2d_Head",IntRes2d_Position::IntRes2d_Head)
 54 ········.value("IntRes2d_Middle",IntRes2d_Position::IntRes2d_Middle)
 55 ········.value("IntRes2d_End",IntRes2d_Position::IntRes2d_End).export_values();
56 ····py::enum_<IntRes2d_TypeTrans>(m,·"IntRes2d_TypeTrans",R"#()#")56 ····py::enum_<IntRes2d_TypeTrans>(m,·"IntRes2d_TypeTrans",R"#()#")
57 ········.value("IntRes2d_In",IntRes2d_TypeTrans::IntRes2d_In)57 ········.value("IntRes2d_In",IntRes2d_TypeTrans::IntRes2d_In)
58 ········.value("IntRes2d_Out",IntRes2d_TypeTrans::IntRes2d_Out)58 ········.value("IntRes2d_Out",IntRes2d_TypeTrans::IntRes2d_Out)
59 ········.value("IntRes2d_Touch",IntRes2d_TypeTrans::IntRes2d_Touch)59 ········.value("IntRes2d_Touch",IntRes2d_TypeTrans::IntRes2d_Touch)
60 ········.value("IntRes2d_Undecided",IntRes2d_TypeTrans::IntRes2d_Undecided).export_values();60 ········.value("IntRes2d_Undecided",IntRes2d_TypeTrans::IntRes2d_Undecided).export_values();
  
61 //Python·trampoline·classes61 //Python·trampoline·classes
⊟
4.28 KB
./usr/share/libocp/OCP/Interface_pre.cpp
Ordering differences only
    
Offset 221, 41 lines modifiedOffset 221, 41 lines modified
221 py::module·m·=·main_module.def_submodule("Interface",·R"#()#");221 py::module·m·=·main_module.def_submodule("Interface",·R"#()#");
  
222 //·add·namespaces·as·submodules222 //·add·namespaces·as·submodules
  
223 //·user-defined·inclusion·per·module·in·the·body223 //·user-defined·inclusion·per·module·in·the·body
  
224 //·enums224 //·enums
225 ····py::enum_<Interface_DataState>(m,·"Interface_DataState",R"#(validity·state·of·anentity's·content·(see·InterfaceModel))#") 
226 ········.value("Interface_StateOK",Interface_DataState::Interface_StateOK) 
227 ········.value("Interface_LoadWarning",Interface_DataState::Interface_LoadWarning) 
228 ········.value("Interface_LoadFail",Interface_DataState::Interface_LoadFail) 
229 ········.value("Interface_DataWarning",Interface_DataState::Interface_DataWarning) 
230 ········.value("Interface_DataFail",Interface_DataState::Interface_DataFail) 
231 ········.value("Interface_StateUnloaded",Interface_DataState::Interface_StateUnloaded) 
232 ········.value("Interface_StateUnknown",Interface_DataState::Interface_StateUnknown).export_values(); 
233 ····py::enum_<Interface_CheckStatus>(m,·"Interface_CheckStatus",R"#(Classifies·checks·OK·:·check·is·empty·Warning·:·Warning,·no·Fail·Fail·:·Fail·Others·to·query·:·Any·:·any·status·Message·:·Warning/Fail·NoFail·:·Warning/OK)#") 
234 ········.value("Interface_CheckOK",Interface_CheckStatus::Interface_CheckOK) 
235 ········.value("Interface_CheckWarning",Interface_CheckStatus::Interface_CheckWarning) 
236 ········.value("Interface_CheckFail",Interface_CheckStatus::Interface_CheckFail) 
237 ········.value("Interface_CheckAny",Interface_CheckStatus::Interface_CheckAny) 
238 ········.value("Interface_CheckMessage",Interface_CheckStatus::Interface_CheckMessage) 
239 ········.value("Interface_CheckNoFail",Interface_CheckStatus::Interface_CheckNoFail).export_values(); 
240 ····py::enum_<Interface_ParamType>(m,·"Interface_ParamType",R"#()#")225 ····py::enum_<Interface_ParamType>(m,·"Interface_ParamType",R"#()#")
241 ········.value("Interface_ParamMisc",Interface_ParamType::Interface_ParamMisc)226 ········.value("Interface_ParamMisc",Interface_ParamType::Interface_ParamMisc)
242 ········.value("Interface_ParamInteger",Interface_ParamType::Interface_ParamInteger)227 ········.value("Interface_ParamInteger",Interface_ParamType::Interface_ParamInteger)
243 ········.value("Interface_ParamReal",Interface_ParamType::Interface_ParamReal)228 ········.value("Interface_ParamReal",Interface_ParamType::Interface_ParamReal)
244 ········.value("Interface_ParamIdent",Interface_ParamType::Interface_ParamIdent)229 ········.value("Interface_ParamIdent",Interface_ParamType::Interface_ParamIdent)
245 ········.value("Interface_ParamVoid",Interface_ParamType::Interface_ParamVoid)230 ········.value("Interface_ParamVoid",Interface_ParamType::Interface_ParamVoid)
246 ········.value("Interface_ParamText",Interface_ParamType::Interface_ParamText)231 ········.value("Interface_ParamText",Interface_ParamType::Interface_ParamText)
247 ········.value("Interface_ParamEnum",Interface_ParamType::Interface_ParamEnum)232 ········.value("Interface_ParamEnum",Interface_ParamType::Interface_ParamEnum)
248 ········.value("Interface_ParamLogical",Interface_ParamType::Interface_ParamLogical)233 ········.value("Interface_ParamLogical",Interface_ParamType::Interface_ParamLogical)
249 ········.value("Interface_ParamSub",Interface_ParamType::Interface_ParamSub)234 ········.value("Interface_ParamSub",Interface_ParamType::Interface_ParamSub)
250 ········.value("Interface_ParamHexa",Interface_ParamType::Interface_ParamHexa)235 ········.value("Interface_ParamHexa",Interface_ParamType::Interface_ParamHexa)
251 ········.value("Interface_ParamBinary",Interface_ParamType::Interface_ParamBinary).export_values();236 ········.value("Interface_ParamBinary",Interface_ParamType::Interface_ParamBinary).export_values();
 237 ····py::enum_<Interface_CheckStatus>(m,·"Interface_CheckStatus",R"#(Classifies·checks·OK·:·check·is·empty·Warning·:·Warning,·no·Fail·Fail·:·Fail·Others·to·query·:·Any·:·any·status·Message·:·Warning/Fail·NoFail·:·Warning/OK)#")
 238 ········.value("Interface_CheckOK",Interface_CheckStatus::Interface_CheckOK)
 239 ········.value("Interface_CheckWarning",Interface_CheckStatus::Interface_CheckWarning)
 240 ········.value("Interface_CheckFail",Interface_CheckStatus::Interface_CheckFail)
 241 ········.value("Interface_CheckAny",Interface_CheckStatus::Interface_CheckAny)
 242 ········.value("Interface_CheckMessage",Interface_CheckStatus::Interface_CheckMessage)
 243 ········.value("Interface_CheckNoFail",Interface_CheckStatus::Interface_CheckNoFail).export_values();
 244 ····py::enum_<Interface_DataState>(m,·"Interface_DataState",R"#(validity·state·of·anentity's·content·(see·InterfaceModel))#")
 245 ········.value("Interface_StateOK",Interface_DataState::Interface_StateOK)
 246 ········.value("Interface_LoadWarning",Interface_DataState::Interface_LoadWarning)
 247 ········.value("Interface_LoadFail",Interface_DataState::Interface_LoadFail)
 248 ········.value("Interface_DataWarning",Interface_DataState::Interface_DataWarning)
 249 ········.value("Interface_DataFail",Interface_DataState::Interface_DataFail)
 250 ········.value("Interface_StateUnloaded",Interface_DataState::Interface_StateUnloaded)
 251 ········.value("Interface_StateUnknown",Interface_DataState::Interface_StateUnknown).export_values();
  
252 //Python·trampoline·classes252 //Python·trampoline·classes
253 ····class·Py_Interface_CopyControl·:·public·Interface_CopyControl{253 ····class·Py_Interface_CopyControl·:·public·Interface_CopyControl{
254 ····public:254 ····public:
255 ········using·Interface_CopyControl::Interface_CopyControl;255 ········using·Interface_CopyControl::Interface_CopyControl;
  
  
⊟
2.01 KB
./usr/share/libocp/OCP/LProp_pre.cpp
Ordering differences only
    
Offset 40, 23 lines modifiedOffset 40, 23 lines modified
40 py::module·m·=·main_module.def_submodule("LProp",·R"#()#");40 py::module·m·=·main_module.def_submodule("LProp",·R"#()#");
  
41 //·add·namespaces·as·submodules41 //·add·namespaces·as·submodules
  
42 //·user-defined·inclusion·per·module·in·the·body42 //·user-defined·inclusion·per·module·in·the·body
  
43 //·enums43 //·enums
 44 ····py::enum_<LProp_CIType>(m,·"LProp_CIType",R"#(Identifies·the·type·of·a·particular·point·on·a·curve:·-·LProp_Inflection:·a·point·of·inflection·-·LProp_MinCur:·a·minimum·of·curvature·-·LProp_MaxCur:·a·maximum·of·curvature.)#")
 45 ········.value("LProp_Inflection",LProp_CIType::LProp_Inflection)
 46 ········.value("LProp_MinCur",LProp_CIType::LProp_MinCur)
 47 ········.value("LProp_MaxCur",LProp_CIType::LProp_MaxCur).export_values();
44 ····py::enum_<LProp_Status>(m,·"LProp_Status",R"#()#")48 ····py::enum_<LProp_Status>(m,·"LProp_Status",R"#()#")
45 ········.value("LProp_Undecided",LProp_Status::LProp_Undecided)49 ········.value("LProp_Undecided",LProp_Status::LProp_Undecided)
46 ········.value("LProp_Undefined",LProp_Status::LProp_Undefined)50 ········.value("LProp_Undefined",LProp_Status::LProp_Undefined)
47 ········.value("LProp_Defined",LProp_Status::LProp_Defined)51 ········.value("LProp_Defined",LProp_Status::LProp_Defined)
48 ········.value("LProp_Computed",LProp_Status::LProp_Computed).export_values();52 ········.value("LProp_Computed",LProp_Status::LProp_Computed).export_values();
49 ····py::enum_<LProp_CIType>(m,·"LProp_CIType",R"#(Identifies·the·type·of·a·particular·point·on·a·curve:·-·LProp_Inflection:·a·point·of·inflection·-·LProp_MinCur:·a·minimum·of·curvature·-·LProp_MaxCur:·a·maximum·of·curvature.)#") 
50 ········.value("LProp_Inflection",LProp_CIType::LProp_Inflection) 
51 ········.value("LProp_MinCur",LProp_CIType::LProp_MinCur) 
52 ········.value("LProp_MaxCur",LProp_CIType::LProp_MaxCur).export_values(); 
  
53 //Python·trampoline·classes53 //Python·trampoline·classes
  
54 //·pre-register·typdefs+classes·(topologically·sorted)54 //·pre-register·typdefs+classes·(topologically·sorted)
55 ····py::class_<LProp_AnalyticCurInf·,·shared_ptr<LProp_AnalyticCurInf>··>(m,"LProp_AnalyticCurInf",R"#(Computes·the·locals·extremas·of·curvature·of·a·gp·curve·Remark·:·a·gp·curve·has·not·inflection.)#");55 ····py::class_<LProp_AnalyticCurInf·,·shared_ptr<LProp_AnalyticCurInf>··>(m,"LProp_AnalyticCurInf",R"#(Computes·the·locals·extremas·of·curvature·of·a·gp·curve·Remark·:·a·gp·curve·has·not·inflection.)#");
56 ····py::class_<LProp_CurAndInf·,·shared_ptr<LProp_CurAndInf>··>(m,"LProp_CurAndInf",R"#(Stores·the·parameters·of·a·curve·2d·or·3d·corresponding·to·the·curvature's·extremas·and·the·Inflection's·Points.)#");56 ····py::class_<LProp_CurAndInf·,·shared_ptr<LProp_CurAndInf>··>(m,"LProp_CurAndInf",R"#(Stores·the·parameters·of·a·curve·2d·or·3d·corresponding·to·the·curvature's·extremas·and·the·Inflection's·Points.)#");
57 ····preregister_template_NCollection_Sequence<LProp_CIType>(m,"LProp_SequenceOfCIType");57 ····preregister_template_NCollection_Sequence<LProp_CIType>(m,"LProp_SequenceOfCIType");
⊟
6.08 KB
./usr/share/libocp/OCP/MeshVS_pre.cpp
Ordering differences only
    
Offset 153, 14 lines modifiedOffset 153, 18 lines modified
  
153 //·add·namespaces·as·submodules153 //·add·namespaces·as·submodules
154 m.def_submodule("std");154 m.def_submodule("std");
  
155 //·user-defined·inclusion·per·module·in·the·body155 //·user-defined·inclusion·per·module·in·the·body
  
156 //·enums156 //·enums
 157 ····py::enum_<MeshVS_MeshSelectionMethod>(m,·"MeshVS_MeshSelectionMethod",R"#(this·enumeration·describe·what·type·of·sensitive·entity·will·be·built·in·0-th·selection·mode·(it·means·that·whole·mesh·is·selected·))#")
 158 ········.value("MeshVS_MSM_PRECISE",MeshVS_MeshSelectionMethod::MeshVS_MSM_PRECISE)
 159 ········.value("MeshVS_MSM_NODES",MeshVS_MeshSelectionMethod::MeshVS_MSM_NODES)
 160 ········.value("MeshVS_MSM_BOX",MeshVS_MeshSelectionMethod::MeshVS_MSM_BOX).export_values();
157 ····py::enum_<MeshVS_EntityType>(m,·"MeshVS_EntityType",R"#()#")161 ····py::enum_<MeshVS_EntityType>(m,·"MeshVS_EntityType",R"#()#")
158 ········.value("MeshVS_ET_NONE",MeshVS_EntityType::MeshVS_ET_NONE)162 ········.value("MeshVS_ET_NONE",MeshVS_EntityType::MeshVS_ET_NONE)
159 ········.value("MeshVS_ET_Node",MeshVS_EntityType::MeshVS_ET_Node)163 ········.value("MeshVS_ET_Node",MeshVS_EntityType::MeshVS_ET_Node)
160 ········.value("MeshVS_ET_0D",MeshVS_EntityType::MeshVS_ET_0D)164 ········.value("MeshVS_ET_0D",MeshVS_EntityType::MeshVS_ET_0D)
161 ········.value("MeshVS_ET_Link",MeshVS_EntityType::MeshVS_ET_Link)165 ········.value("MeshVS_ET_Link",MeshVS_EntityType::MeshVS_ET_Link)
162 ········.value("MeshVS_ET_Face",MeshVS_EntityType::MeshVS_ET_Face)166 ········.value("MeshVS_ET_Face",MeshVS_EntityType::MeshVS_ET_Face)
163 ········.value("MeshVS_ET_Volume",MeshVS_EntityType::MeshVS_ET_Volume)167 ········.value("MeshVS_ET_Volume",MeshVS_EntityType::MeshVS_ET_Volume)
Offset 203, 25 lines modifiedOffset 207, 24 lines modified
203 ········.value("MeshVS_DA_ComputeSelectionTime",MeshVS_DrawerAttribute::MeshVS_DA_ComputeSelectionTime)207 ········.value("MeshVS_DA_ComputeSelectionTime",MeshVS_DrawerAttribute::MeshVS_DA_ComputeSelectionTime)
204 ········.value("MeshVS_DA_DisplayNodes",MeshVS_DrawerAttribute::MeshVS_DA_DisplayNodes)208 ········.value("MeshVS_DA_DisplayNodes",MeshVS_DrawerAttribute::MeshVS_DA_DisplayNodes)
205 ········.value("MeshVS_DA_SelectableAuto",MeshVS_DrawerAttribute::MeshVS_DA_SelectableAuto)209 ········.value("MeshVS_DA_SelectableAuto",MeshVS_DrawerAttribute::MeshVS_DA_SelectableAuto)
206 ········.value("MeshVS_DA_ShowEdges",MeshVS_DrawerAttribute::MeshVS_DA_ShowEdges)210 ········.value("MeshVS_DA_ShowEdges",MeshVS_DrawerAttribute::MeshVS_DA_ShowEdges)
207 ········.value("MeshVS_DA_SmoothShading",MeshVS_DrawerAttribute::MeshVS_DA_SmoothShading)211 ········.value("MeshVS_DA_SmoothShading",MeshVS_DrawerAttribute::MeshVS_DA_SmoothShading)
208 ········.value("MeshVS_DA_SupressBackFaces",MeshVS_DrawerAttribute::MeshVS_DA_SupressBackFaces)212 ········.value("MeshVS_DA_SupressBackFaces",MeshVS_DrawerAttribute::MeshVS_DA_SupressBackFaces)
209 ········.value("MeshVS_DA_User",MeshVS_DrawerAttribute::MeshVS_DA_User).export_values();213 ········.value("MeshVS_DA_User",MeshVS_DrawerAttribute::MeshVS_DA_User).export_values();
210 ····py::enum_<MeshVS_MeshSelectionMethod>(m,·"MeshVS_MeshSelectionMethod",R"#(this·enumeration·describe·what·type·of·sensitive·entity·will·be·built·in·0-th·selection·mode·(it·means·that·whole·mesh·is·selected·))#")214 ····py::enum_<MeshVS_SelectionModeFlags>(m,·"MeshVS_SelectionModeFlags",R"#()#")
211 ········.value("MeshVS_MSM_PRECISE",MeshVS_MeshSelectionMethod::MeshVS_MSM_PRECISE)215 ········.value("MeshVS_SMF_Mesh",MeshVS_SelectionModeFlags::MeshVS_SMF_Mesh)
 216 ········.value("MeshVS_SMF_Node",MeshVS_SelectionModeFlags::MeshVS_SMF_Node)
212 ········.value("MeshVS_MSM_NODES",MeshVS_MeshSelectionMethod::MeshVS_MSM_NODES)217 ········.value("MeshVS_SMF_0D",MeshVS_SelectionModeFlags::MeshVS_SMF_0D)
 218 ········.value("MeshVS_SMF_Link",MeshVS_SelectionModeFlags::MeshVS_SMF_Link)
 219 ········.value("MeshVS_SMF_Face",MeshVS_SelectionModeFlags::MeshVS_SMF_Face)
 220 ········.value("MeshVS_SMF_Volume",MeshVS_SelectionModeFlags::MeshVS_SMF_Volume)
 221 ········.value("MeshVS_SMF_Element",MeshVS_SelectionModeFlags::MeshVS_SMF_Element)
 222 ········.value("MeshVS_SMF_All",MeshVS_SelectionModeFlags::MeshVS_SMF_All)
213 ········.value("MeshVS_MSM_BOX",MeshVS_MeshSelectionMethod::MeshVS_MSM_BOX).export_values();223 ········.value("MeshVS_SMF_Group",MeshVS_SelectionModeFlags::MeshVS_SMF_Group).export_values();
214 ····m.attr("MeshVS_BP_Mesh")·=·py::cast(int(MeshVS_BP_Mesh)); 
215 ····m.attr("MeshVS_BP_NodalColor")·=·py::cast(int(MeshVS_BP_NodalColor)); 
216 ····m.attr("MeshVS_BP_ElemColor")·=·py::cast(int(MeshVS_BP_ElemColor)); 
217 ····m.attr("MeshVS_BP_Text")·=·py::cast(int(MeshVS_BP_Text)); 
218 ····m.attr("MeshVS_BP_Vector")·=·py::cast(int(MeshVS_BP_Vector)); 
219 ····m.attr("MeshVS_BP_User")·=·py::cast(int(MeshVS_BP_User)); 
220 ····m.attr("MeshVS_BP_Default")·=·py::cast(int(MeshVS_BP_Default)); 
221 ····m.attr("MeshVS_DMF_WireFrame")·=·py::cast(int(MeshVS_DMF_WireFrame));224 ····m.attr("MeshVS_DMF_WireFrame")·=·py::cast(int(MeshVS_DMF_WireFrame));
222 ····m.attr("MeshVS_DMF_Shading")·=·py::cast(int(MeshVS_DMF_Shading));225 ····m.attr("MeshVS_DMF_Shading")·=·py::cast(int(MeshVS_DMF_Shading));
223 ····m.attr("MeshVS_DMF_Shrink")·=·py::cast(int(MeshVS_DMF_Shrink));226 ····m.attr("MeshVS_DMF_Shrink")·=·py::cast(int(MeshVS_DMF_Shrink));
224 ····m.attr("MeshVS_DMF_OCCMask")·=·py::cast(int(MeshVS_DMF_OCCMask));227 ····m.attr("MeshVS_DMF_OCCMask")·=·py::cast(int(MeshVS_DMF_OCCMask));
225 ····m.attr("MeshVS_DMF_VectorDataPrs")·=·py::cast(int(MeshVS_DMF_VectorDataPrs));228 ····m.attr("MeshVS_DMF_VectorDataPrs")·=·py::cast(int(MeshVS_DMF_VectorDataPrs));
226 ····m.attr("MeshVS_DMF_NodalColorDataPrs")·=·py::cast(int(MeshVS_DMF_NodalColorDataPrs));229 ····m.attr("MeshVS_DMF_NodalColorDataPrs")·=·py::cast(int(MeshVS_DMF_NodalColorDataPrs));
227 ····m.attr("MeshVS_DMF_ElementalColorDataPrs")·=·py::cast(int(MeshVS_DMF_ElementalColorDataPrs));230 ····m.attr("MeshVS_DMF_ElementalColorDataPrs")·=·py::cast(int(MeshVS_DMF_ElementalColorDataPrs));
Offset 230, 24 lines modifiedOffset 233, 21 lines modified
230 ····m.attr("MeshVS_DMF_DeformedPrsWireFrame")·=·py::cast(int(MeshVS_DMF_DeformedPrsWireFrame));233 ····m.attr("MeshVS_DMF_DeformedPrsWireFrame")·=·py::cast(int(MeshVS_DMF_DeformedPrsWireFrame));
231 ····m.attr("MeshVS_DMF_DeformedPrsShading")·=·py::cast(int(MeshVS_DMF_DeformedPrsShading));234 ····m.attr("MeshVS_DMF_DeformedPrsShading")·=·py::cast(int(MeshVS_DMF_DeformedPrsShading));
232 ····m.attr("MeshVS_DMF_DeformedPrsShrink")·=·py::cast(int(MeshVS_DMF_DeformedPrsShrink));235 ····m.attr("MeshVS_DMF_DeformedPrsShrink")·=·py::cast(int(MeshVS_DMF_DeformedPrsShrink));
233 ····m.attr("MeshVS_DMF_DeformedMask")·=·py::cast(int(MeshVS_DMF_DeformedMask));236 ····m.attr("MeshVS_DMF_DeformedMask")·=·py::cast(int(MeshVS_DMF_DeformedMask));
234 ····m.attr("MeshVS_DMF_SelectionPrs")·=·py::cast(int(MeshVS_DMF_SelectionPrs));237 ····m.attr("MeshVS_DMF_SelectionPrs")·=·py::cast(int(MeshVS_DMF_SelectionPrs));
235 ····m.attr("MeshVS_DMF_HilightPrs")·=·py::cast(int(MeshVS_DMF_HilightPrs));238 ····m.attr("MeshVS_DMF_HilightPrs")·=·py::cast(int(MeshVS_DMF_HilightPrs));
236 ····m.attr("MeshVS_DMF_User")·=·py::cast(int(MeshVS_DMF_User));239 ····m.attr("MeshVS_DMF_User")·=·py::cast(int(MeshVS_DMF_User));
 240 ····m.attr("MeshVS_BP_Mesh")·=·py::cast(int(MeshVS_BP_Mesh));
 241 ····m.attr("MeshVS_BP_NodalColor")·=·py::cast(int(MeshVS_BP_NodalColor));
 242 ····m.attr("MeshVS_BP_ElemColor")·=·py::cast(int(MeshVS_BP_ElemColor));
 243 ····m.attr("MeshVS_BP_Text")·=·py::cast(int(MeshVS_BP_Text));
 244 ····m.attr("MeshVS_BP_Vector")·=·py::cast(int(MeshVS_BP_Vector));
 245 ····m.attr("MeshVS_BP_User")·=·py::cast(int(MeshVS_BP_User));
 246 ····m.attr("MeshVS_BP_Default")·=·py::cast(int(MeshVS_BP_Default));
237 ····py::enum_<MeshVS_SelectionModeFlags>(m,·"MeshVS_SelectionModeFlags",R"#()#") 
238 ········.value("MeshVS_SMF_Mesh",MeshVS_SelectionModeFlags::MeshVS_SMF_Mesh) 
239 ········.value("MeshVS_SMF_Node",MeshVS_SelectionModeFlags::MeshVS_SMF_Node) 
240 ········.value("MeshVS_SMF_0D",MeshVS_SelectionModeFlags::MeshVS_SMF_0D) 
241 ········.value("MeshVS_SMF_Link",MeshVS_SelectionModeFlags::MeshVS_SMF_Link) 
242 ········.value("MeshVS_SMF_Face",MeshVS_SelectionModeFlags::MeshVS_SMF_Face) 
243 ········.value("MeshVS_SMF_Volume",MeshVS_SelectionModeFlags::MeshVS_SMF_Volume) 
244 ········.value("MeshVS_SMF_Element",MeshVS_SelectionModeFlags::MeshVS_SMF_Element) 
245 ········.value("MeshVS_SMF_All",MeshVS_SelectionModeFlags::MeshVS_SMF_All) 
246 ········.value("MeshVS_SMF_Group",MeshVS_SelectionModeFlags::MeshVS_SMF_Group).export_values(); 
  
247 //Python·trampoline·classes247 //Python·trampoline·classes
248 ····class·Py_MeshVS_DataSource·:·public·MeshVS_DataSource{248 ····class·Py_MeshVS_DataSource·:·public·MeshVS_DataSource{
249 ····public:249 ····public:
250 ········using·MeshVS_DataSource::MeshVS_DataSource;250 ········using·MeshVS_DataSource::MeshVS_DataSource;
  
  
⊟
7.45 KB
./usr/share/libocp/OCP/Message_pre.cpp
Ordering differences only
    
Offset 85, 30 lines modifiedOffset 85, 43 lines modified
85 py::module·m·=·main_module.def_submodule("Message",·R"#()#");85 py::module·m·=·main_module.def_submodule("Message",·R"#()#");
  
86 //·add·namespaces·as·submodules86 //·add·namespaces·as·submodules
  
87 //·user-defined·inclusion·per·module·in·the·body87 //·user-defined·inclusion·per·module·in·the·body
  
88 //·enums88 //·enums
 89 ····py::enum_<Message_StatusType>(m,·"Message_StatusType",R"#(Definition·of·types·of·execution·status·supported·by·the·class·Message_ExecStatus)#")
 90 ········.value("Message_DONE",Message_StatusType::Message_DONE)
 91 ········.value("Message_WARN",Message_StatusType::Message_WARN)
 92 ········.value("Message_ALARM",Message_StatusType::Message_ALARM)
 93 ········.value("Message_FAIL",Message_StatusType::Message_FAIL).export_values();
 94 ····py::enum_<Message_MetricType>(m,·"Message_MetricType",R"#(Specifies·kind·of·report·information·to·collect)#")
 95 ········.value("Message_MetricType_None",Message_MetricType::Message_MetricType_None)
 96 ········.value("Message_MetricType_ThreadCPUUserTime",Message_MetricType::Message_MetricType_ThreadCPUUserTime)
 97 ········.value("Message_MetricType_ThreadCPUSystemTime",Message_MetricType::Message_MetricType_ThreadCPUSystemTime)
 98 ········.value("Message_MetricType_ProcessCPUUserTime",Message_MetricType::Message_MetricType_ProcessCPUUserTime)
 99 ········.value("Message_MetricType_ProcessCPUSystemTime",Message_MetricType::Message_MetricType_ProcessCPUSystemTime)
 100 ········.value("Message_MetricType_WallClock",Message_MetricType::Message_MetricType_WallClock)
 101 ········.value("Message_MetricType_MemPrivate",Message_MetricType::Message_MetricType_MemPrivate)
 102 ········.value("Message_MetricType_MemVirtual",Message_MetricType::Message_MetricType_MemVirtual)
 103 ········.value("Message_MetricType_MemWorkingSet",Message_MetricType::Message_MetricType_MemWorkingSet)
 104 ········.value("Message_MetricType_MemWorkingSetPeak",Message_MetricType::Message_MetricType_MemWorkingSetPeak)
 105 ········.value("Message_MetricType_MemSwapUsage",Message_MetricType::Message_MetricType_MemSwapUsage)
 106 ········.value("Message_MetricType_MemSwapUsagePeak",Message_MetricType::Message_MetricType_MemSwapUsagePeak)
 107 ········.value("Message_MetricType_MemHeapUsage",Message_MetricType::Message_MetricType_MemHeapUsage).export_values();
89 ····py::enum_<Message_ConsoleColor>(m,·"Message_ConsoleColor",R"#(Color·definition·for·console/terminal·output·(limited·palette).)#")108 ····py::enum_<Message_ConsoleColor>(m,·"Message_ConsoleColor",R"#(Color·definition·for·console/terminal·output·(limited·palette).)#")
90 ········.value("Message_ConsoleColor_Default",Message_ConsoleColor::Message_ConsoleColor_Default)109 ········.value("Message_ConsoleColor_Default",Message_ConsoleColor::Message_ConsoleColor_Default)
91 ········.value("Message_ConsoleColor_Black",Message_ConsoleColor::Message_ConsoleColor_Black)110 ········.value("Message_ConsoleColor_Black",Message_ConsoleColor::Message_ConsoleColor_Black)
92 ········.value("Message_ConsoleColor_White",Message_ConsoleColor::Message_ConsoleColor_White)111 ········.value("Message_ConsoleColor_White",Message_ConsoleColor::Message_ConsoleColor_White)
93 ········.value("Message_ConsoleColor_Red",Message_ConsoleColor::Message_ConsoleColor_Red)112 ········.value("Message_ConsoleColor_Red",Message_ConsoleColor::Message_ConsoleColor_Red)
94 ········.value("Message_ConsoleColor_Blue",Message_ConsoleColor::Message_ConsoleColor_Blue)113 ········.value("Message_ConsoleColor_Blue",Message_ConsoleColor::Message_ConsoleColor_Blue)
95 ········.value("Message_ConsoleColor_Green",Message_ConsoleColor::Message_ConsoleColor_Green)114 ········.value("Message_ConsoleColor_Green",Message_ConsoleColor::Message_ConsoleColor_Green)
96 ········.value("Message_ConsoleColor_Yellow",Message_ConsoleColor::Message_ConsoleColor_Yellow)115 ········.value("Message_ConsoleColor_Yellow",Message_ConsoleColor::Message_ConsoleColor_Yellow)
97 ········.value("Message_ConsoleColor_Cyan",Message_ConsoleColor::Message_ConsoleColor_Cyan)116 ········.value("Message_ConsoleColor_Cyan",Message_ConsoleColor::Message_ConsoleColor_Cyan)
98 ········.value("Message_ConsoleColor_Magenta",Message_ConsoleColor::Message_ConsoleColor_Magenta).export_values();117 ········.value("Message_ConsoleColor_Magenta",Message_ConsoleColor::Message_ConsoleColor_Magenta).export_values();
99 ····py::enum_<Message_Gravity>(m,·"Message_Gravity",R"#(Defines·gravity·level·of·messages·-·Trace:·low-level·details·on·algorithm·execution·(usually·for·debug·purposes)·-·Info:·informative·message·-·Warning:·warning·message·-·Alarm:·non-critical·error·-·Fail:·fatal·error)#") 
100 ········.value("Message_Trace",Message_Gravity::Message_Trace) 
101 ········.value("Message_Info",Message_Gravity::Message_Info) 
102 ········.value("Message_Warning",Message_Gravity::Message_Warning) 
103 ········.value("Message_Alarm",Message_Gravity::Message_Alarm) 
104 ········.value("Message_Fail",Message_Gravity::Message_Fail).export_values(); 
105 ····py::enum_<Message_Status>(m,·"Message_Status",R"#(Enumeration·covering·all·execution·statuses·supported·by·the·class·Message_ExecStatus:·32·statuses·per·each·of·4·types·(DONE,·WARN,·ALARM,·FAIL))#")118 ····py::enum_<Message_Status>(m,·"Message_Status",R"#(Enumeration·covering·all·execution·statuses·supported·by·the·class·Message_ExecStatus:·32·statuses·per·each·of·4·types·(DONE,·WARN,·ALARM,·FAIL))#")
106 ········.value("Message_None",Message_Status::Message_None)119 ········.value("Message_None",Message_Status::Message_None)
107 ········.value("Message_Done1",Message_Status::Message_Done1)120 ········.value("Message_Done1",Message_Status::Message_Done1)
108 ········.value("Message_Done2",Message_Status::Message_Done2)121 ········.value("Message_Done2",Message_Status::Message_Done2)
109 ········.value("Message_Done3",Message_Status::Message_Done3)122 ········.value("Message_Done3",Message_Status::Message_Done3)
110 ········.value("Message_Done4",Message_Status::Message_Done4)123 ········.value("Message_Done4",Message_Status::Message_Done4)
111 ········.value("Message_Done5",Message_Status::Message_Done5)124 ········.value("Message_Done5",Message_Status::Message_Done5)
Offset 231, 33 lines modifiedOffset 244, 20 lines modified
231 ········.value("Message_Fail26",Message_Status::Message_Fail26)244 ········.value("Message_Fail26",Message_Status::Message_Fail26)
232 ········.value("Message_Fail27",Message_Status::Message_Fail27)245 ········.value("Message_Fail27",Message_Status::Message_Fail27)
233 ········.value("Message_Fail28",Message_Status::Message_Fail28)246 ········.value("Message_Fail28",Message_Status::Message_Fail28)
234 ········.value("Message_Fail29",Message_Status::Message_Fail29)247 ········.value("Message_Fail29",Message_Status::Message_Fail29)
235 ········.value("Message_Fail30",Message_Status::Message_Fail30)248 ········.value("Message_Fail30",Message_Status::Message_Fail30)
236 ········.value("Message_Fail31",Message_Status::Message_Fail31)249 ········.value("Message_Fail31",Message_Status::Message_Fail31)
237 ········.value("Message_Fail32",Message_Status::Message_Fail32).export_values();250 ········.value("Message_Fail32",Message_Status::Message_Fail32).export_values();
238 ····py::enum_<Message_StatusType>(m,·"Message_StatusType",R"#(Definition·of·types·of·execution·status·supported·by·the·class·Message_ExecStatus)#")251 ····py::enum_<Message_Gravity>(m,·"Message_Gravity",R"#(Defines·gravity·level·of·messages·-·Trace:·low-level·details·on·algorithm·execution·(usually·for·debug·purposes)·-·Info:·informative·message·-·Warning:·warning·message·-·Alarm:·non-critical·error·-·Fail:·fatal·error)#")
 252 ········.value("Message_Trace",Message_Gravity::Message_Trace)
239 ········.value("Message_DONE",Message_StatusType::Message_DONE)253 ········.value("Message_Info",Message_Gravity::Message_Info)
 254 ········.value("Message_Warning",Message_Gravity::Message_Warning)
240 ········.value("Message_WARN",Message_StatusType::Message_WARN)255 ········.value("Message_Alarm",Message_Gravity::Message_Alarm)
241 ········.value("Message_ALARM",Message_StatusType::Message_ALARM) 
242 ········.value("Message_FAIL",Message_StatusType::Message_FAIL).export_values();256 ········.value("Message_Fail",Message_Gravity::Message_Fail).export_values();
243 ····py::enum_<Message_MetricType>(m,·"Message_MetricType",R"#(Specifies·kind·of·report·information·to·collect)#") 
244 ········.value("Message_MetricType_None",Message_MetricType::Message_MetricType_None) 
245 ········.value("Message_MetricType_ThreadCPUUserTime",Message_MetricType::Message_MetricType_ThreadCPUUserTime) 
246 ········.value("Message_MetricType_ThreadCPUSystemTime",Message_MetricType::Message_MetricType_ThreadCPUSystemTime) 
247 ········.value("Message_MetricType_ProcessCPUUserTime",Message_MetricType::Message_MetricType_ProcessCPUUserTime) 
248 ········.value("Message_MetricType_ProcessCPUSystemTime",Message_MetricType::Message_MetricType_ProcessCPUSystemTime) 
249 ········.value("Message_MetricType_WallClock",Message_MetricType::Message_MetricType_WallClock) 
250 ········.value("Message_MetricType_MemPrivate",Message_MetricType::Message_MetricType_MemPrivate) 
251 ········.value("Message_MetricType_MemVirtual",Message_MetricType::Message_MetricType_MemVirtual) 
252 ········.value("Message_MetricType_MemWorkingSet",Message_MetricType::Message_MetricType_MemWorkingSet) 
253 ········.value("Message_MetricType_MemWorkingSetPeak",Message_MetricType::Message_MetricType_MemWorkingSetPeak) 
254 ········.value("Message_MetricType_MemSwapUsage",Message_MetricType::Message_MetricType_MemSwapUsage) 
255 ········.value("Message_MetricType_MemSwapUsagePeak",Message_MetricType::Message_MetricType_MemSwapUsagePeak) 
256 ········.value("Message_MetricType_MemHeapUsage",Message_MetricType::Message_MetricType_MemHeapUsage).export_values(); 
  
257 //Python·trampoline·classes257 //Python·trampoline·classes
258 ····class·Py_Message_Printer·:·public·Message_Printer{258 ····class·Py_Message_Printer·:·public·Message_Printer{
259 ····public:259 ····public:
260 ········using·Message_Printer::Message_Printer;260 ········using·Message_Printer::Message_Printer;
  
  
⊟
322 KB
./usr/share/libocp/OCP/NCollection_tmpl.hxx
Ordering differences only
    
Offset 78, 482 lines modifiedOffset 78, 97 lines modified
  
78 //·user-defined·pre78 //·user-defined·pre
79 #include·"OCP_specific.inc"79 #include·"OCP_specific.inc"
  
80 //·Class·template·handling·functions80 //·Class·template·handling·functions
  
81 template·<typename·TheItemType>81 template·<typename·TheItemType>
82 void·preregister_template_NCollection_TListIterator(py::object·&m,·const·char·*name){82 void·preregister_template_NCollection_List(py::object·&m,·const·char·*name){
83 ····py::class_<NCollection_TListIterator<TheItemType>·,·shared_ptr<NCollection_TListIterator<TheItemType>>·>(m,name,R"#(Purpose:·This·Iterator·class·iterates·on·BaseList·of·TListNode·and·is·instantiated·in·List/Set/Queue/Stack·Remark:·TListIterator·is·internal·class)#");83 ····py::class_<NCollection_List<TheItemType>·,·shared_ptr<NCollection_List<TheItemType>>·,·NCollection_BaseList·>(m,name,R"#(Purpose:·Simple·list·to·link·items·together·keeping·the·first·and·the·last·one.·Inherits·BaseList,·adding·the·data·item·to·each·node.)#");
84 }84 }
  
85 template·<typename·TheItemType>85 template·<typename·TheItemType>
86 void·register_template_NCollection_TListIterator(py::object·&m,·const·char·*name){ 
87 ····static_cast<py::class_<NCollection_TListIterator<TheItemType>·,·shared_ptr<NCollection_TListIterator<TheItemType>>·>>(m.attr(name)) 
88 ········.def(py::init<··>()··) 
89 ········.def(py::init<··const·NCollection_BaseList·&·>()·,py::arg("theList")·) 
90 ········.def("More", 
91 ·············(Standard_Boolean·(NCollection_TListIterator<TheItemType>::*)()·const)·&NCollection_TListIterator<TheItemType>::More, 
92 ·············R"#(Check·end)#"·) 
93 ········.def("Next", 
94 ·············(void·(NCollection_TListIterator<TheItemType>::*)()·)·&NCollection_TListIterator<TheItemType>::Next, 
95 ·············R"#(Make·step)#"·) 
96 ········.def("Value", 
97 ·············(·const·TheItemType·&·(NCollection_TListIterator<TheItemType>::*)()·const)·&NCollection_TListIterator<TheItemType>::Value, 
98 ·············R"#(Constant·Value·access)#"·) 
99 ········.def("Value", 
100 ·············(TheItemType·&·(NCollection_TListIterator<TheItemType>::*)()·)·&NCollection_TListIterator<TheItemType>::Value, 
101 ·············R"#(Non-const·Value·access)#"·) 
102 ········.def("ChangeValue", 
103 ·············(TheItemType·&·(NCollection_TListIterator<TheItemType>::*)()·const)·&NCollection_TListIterator<TheItemType>::ChangeValue, 
104 ·············R"#(Non-const·Value·access)#"·) 
105 ····; 
106 }; 
  
107 template·<typename·ItemType> 
108 void·preregister_template_NCollection_Allocator(py::object·&m,·const·char·*name){ 
109 ····py::class_<NCollection_Allocator<ItemType>·,·shared_ptr<NCollection_Allocator<ItemType>>·>(m,name,R"#(Implements·allocator·requirements·as·defined·in·ISO·C++·Standard·2003,·section·20.1.5.·The·allocator·uses·a·standard·OCCT·mechanism·for·memory·allocation·and·deallocation.·It·can·be·used·with·standard·containers·(std::vector,·std::map,·etc.)·to·take·advantage·of·OCCT·memory·optimizations.)#"); 
110 } 
  
111 template·<typename·ItemType> 
112 void·register_template_NCollection_Allocator(py::object·&m,·const·char·*name){ 
113 ····static_cast<py::class_<NCollection_Allocator<ItemType>·,·shared_ptr<NCollection_Allocator<ItemType>>·>>(m.attr(name)) 
114 ········.def(py::init<··>()··) 
115 ········.def(py::init<··const·handle<NCollection_BaseAllocator>·&·>()·,py::arg("arg")·) 
116 ········.def("address", 
117 ·············(typename·NCollection_Allocator<ItemType>::pointer·(NCollection_Allocator<ItemType>::*)(·typename·NCollection_Allocator<ItemType>::reference··)·const)·&NCollection_Allocator<ItemType>::address, 
118 ·············R"#(Returns·an·object·address.)#"·,py::arg("theItem")) 
119 ········.def("address", 
120 ·············(typename·NCollection_Allocator<ItemType>::const_pointer·(NCollection_Allocator<ItemType>::*)(·typename·NCollection_Allocator<ItemType>::const_reference··)·const)·&NCollection_Allocator<ItemType>::address, 
121 ·············R"#(Returns·an·object·address.)#"·,py::arg("theItem")) 
122 ········.def("destroy", 
123 ·············(void·(NCollection_Allocator<ItemType>::*)(·typename·NCollection_Allocator<ItemType>::pointer··)·)·&NCollection_Allocator<ItemType>::destroy, 
124 ·············R"#(Destroys·the·object.·Uses·the·object·destructor.)#"·,py::arg("thePnt")) 
125 ····; 
126 }; 
  
127 template·<typename·Container> 
128 void·preregister_template_NCollection_Iterator(py::object·&m,·const·char·*name){ 
129 ····py::class_<NCollection_Iterator<Container>·,·shared_ptr<NCollection_Iterator<Container>>·>(m,name,R"#(Helper·class·that·allows·to·use·NCollection·iterators·as·STL·iterators.·NCollection·iterator·can·be·extended·to·STL·iterator·of·any·category·by·adding·necessary·methods:·STL·forward·iterator·requires·IsEqual·method,·STL·bidirectional·iterator·requires·Previous·method,·and·STL·random·access·iterator·requires·Offset·and·Differ·methods.·See·NCollection_Vector·as·example·of·declaring·custom·STL·iterators.)#"); 
130 } 
  
131 template·<typename·Container> 
132 void·register_template_NCollection_Iterator(py::object·&m,·const·char·*name){ 
133 ····static_cast<py::class_<NCollection_Iterator<Container>·,·shared_ptr<NCollection_Iterator<Container>>·>>(m.attr(name)) 
134 ········.def(py::init<··>()··) 
135 ········.def(py::init<··const·NCollection_Iterator<Container>·&·>()·,py::arg("theOther")·) 
136 ········.def(py::init<··const·Container·&·>()·,py::arg("theList")·) 
137 ········.def(py::init<··const·Container·&,·const·typename·Container::iterator·&·>()·,py::arg("theList"),·py::arg("theOther")·) 
138 ········.def("Init", 
139 ·············(void·(NCollection_Iterator<Container>::*)(·Container·&··)·)·&NCollection_Iterator<Container>::Init, 
140 ·············R"#()#"·,py::arg("theList")) 
141 ········.def("Init", 
142 ·············(void·(NCollection_Iterator<Container>::*)(··const·Container·&··)·)·&NCollection_Iterator<Container>::Init, 
143 ·············R"#()#"·,py::arg("theList")) 
144 ········.def("More", 
145 ·············(bool·(NCollection_Iterator<Container>::*)()·const)·&NCollection_Iterator<Container>::More, 
146 ·············R"#()#"·) 
147 ········.def("Initialize", 
148 ·············(void·(NCollection_Iterator<Container>::*)(·Container·&··)·)·&NCollection_Iterator<Container>::Initialize, 
149 ·············R"#()#"·,py::arg("theList")) 
150 ········.def("Initialize", 
151 ·············(void·(NCollection_Iterator<Container>::*)(··const·Container·&··)·)·&NCollection_Iterator<Container>::Initialize, 
152 ·············R"#()#"·,py::arg("theList")) 
153 ········.def("ValueIter", 
154 ·············(·const·typename·Container::iterator·&·(NCollection_Iterator<Container>::*)()·const)·&NCollection_Iterator<Container>::ValueIter, 
155 ·············R"#()#"·) 
156 ········.def("ChangeValueIter", 
157 ·············(typename·Container::iterator·&·(NCollection_Iterator<Container>::*)()·)·&NCollection_Iterator<Container>::ChangeValueIter, 
158 ·············R"#()#"·) 
159 ········.def("EndIter", 
160 ·············(·const·typename·Container::iterator·&·(NCollection_Iterator<Container>::*)()·const)·&NCollection_Iterator<Container>::EndIter, 
161 ·············R"#()#"·) 
162 ········.def("ChangeEndIter", 
163 ·············(typename·Container::iterator·&·(NCollection_Iterator<Container>::*)()·)·&NCollection_Iterator<Container>::ChangeEndIter, 
164 ·············R"#()#"·) 
165 ········.def("Next", 
166 ·············(void·(NCollection_Iterator<Container>::*)()·)·&NCollection_Iterator<Container>::Next, 
167 ·············R"#()#"·) 
168 ········.def("Value", 
169 ·············(·const·typename·Container::const_reference·(NCollection_Iterator<Container>::*)()·const)·&NCollection_Iterator<Container>::Value, 
170 ·············R"#()#"·) 
171 ········.def("ChangeValue", 
172 ·············(·const·typename·Container::reference·(NCollection_Iterator<Container>::*)()·)·&NCollection_Iterator<Container>::ChangeValue, 
173 ·············R"#()#"·) 
174 ····; 
175 }; 
  
176 template·<typename·TheKey1Type,typename·TheKey2Type,typename·Hasher1=NCollection_DefaultHasher<TheKey1Type>,typename·Hasher2=NCollection_DefaultHasher<TheKey2Type>> 
177 void·preregister_template_NCollection_DoubleMap(py::object·&m,·const·char·*name){ 
178 ····py::class_<NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>·,·shared_ptr<NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>>·,·NCollection_BaseMap·>(m,name,R"#(Purpose:·The·DoubleMap·is·used·to·bind·pairs·(Key1,Key2)·and·retrieve·them·in·linear·time.)#"); 
179 } 
  
180 template·<typename·TheKey1Type,typename·TheKey2Type,typename·Hasher1=NCollection_DefaultHasher<TheKey1Type>,typename·Hasher2=NCollection_DefaultHasher<TheKey2Type>> 
181 void·register_template_NCollection_DoubleMap(py::object·&m,·const·char·*name){ 
182 ····static_cast<py::class_<NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>·,·shared_ptr<NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>>·,·NCollection_BaseMap·>>(m.attr(name)) 
183 ········.def(py::init<··>()··) 
184 ········.def(py::init<··const·Standard_Integer,·const·handle<NCollection_BaseAllocator>·&·>()·,py::arg("theNbBuckets"),·py::arg("theAllocator")=static_cast<·const·handle<NCollection_BaseAllocator>·&>(0L)·) 
185 ········.def(py::init<··const·NCollection_DoubleMap<TheKey1Type,·TheKey2Type,·Hasher1,·Hasher2>·&·>()·,py::arg("theOther")·) 
186 ········.def("Exchange", 
187 ·············(void·(NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>::*)(·NCollection_DoubleMap<TheKey1Type,·TheKey2Type,·Hasher1,·Hasher2>·&··)·)·&NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>::Exchange, 
188 ·············R"#(Exchange·the·content·of·two·maps·without·re-allocations.·Notice·that·allocators·will·be·swapped·as·well!)#"·,py::arg("theOther")) 
189 ········.def("Assign", 
190 ·············(NCollection_DoubleMap<TheKey1Type,·TheKey2Type,·Hasher1,·Hasher2>·&·(NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>::*)(··const·NCollection_DoubleMap<TheKey1Type,·TheKey2Type,·Hasher1,·Hasher2>·&··)·)·&NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>::Assign, 
191 ·············R"#(Assignment.·This·method·does·not·change·the·internal·allocator.)#"·,py::arg("theOther")) 
192 ········.def("ReSize", 
193 ·············(void·(NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>::*)(··const·Standard_Integer··)·)·&NCollection_DoubleMap<TheKey1Type,TheKey2Type,Hasher1,Hasher2>::ReSize, 
194 ·············R"#(ReSize)#"·,py::arg("N")) 
Max diff block lines reached; 297369/329379 bytes (90.28%) of diff not shown.
⊟
8.35 KB
./usr/share/libocp/OCP/OSD_pre.cpp
Ordering differences only
    
Offset 110, 34 lines modifiedOffset 110, 14 lines modified
  
110 //·enums110 //·enums
111 ····py::enum_<OSD_SignalMode>(m,·"OSD_SignalMode",R"#(Mode·of·operation·for·OSD::SetSignal()·function)#")111 ····py::enum_<OSD_SignalMode>(m,·"OSD_SignalMode",R"#(Mode·of·operation·for·OSD::SetSignal()·function)#")
112 ········.value("OSD_SignalMode_AsIs",OSD_SignalMode::OSD_SignalMode_AsIs)112 ········.value("OSD_SignalMode_AsIs",OSD_SignalMode::OSD_SignalMode_AsIs)
113 ········.value("OSD_SignalMode_Set",OSD_SignalMode::OSD_SignalMode_Set)113 ········.value("OSD_SignalMode_Set",OSD_SignalMode::OSD_SignalMode_Set)
114 ········.value("OSD_SignalMode_SetUnhandled",OSD_SignalMode::OSD_SignalMode_SetUnhandled)114 ········.value("OSD_SignalMode_SetUnhandled",OSD_SignalMode::OSD_SignalMode_SetUnhandled)
115 ········.value("OSD_SignalMode_Unset",OSD_SignalMode::OSD_SignalMode_Unset).export_values();115 ········.value("OSD_SignalMode_Unset",OSD_SignalMode::OSD_SignalMode_Unset).export_values();
116 ····py::enum_<OSD_LoadMode>(m,·"OSD_LoadMode",R"#(This·enumeration·is·used·to·load·shareable·libraries.)#") 
117 ········.value("OSD_RTLD_LAZY",OSD_LoadMode::OSD_RTLD_LAZY) 
118 ········.value("OSD_RTLD_NOW",OSD_LoadMode::OSD_RTLD_NOW).export_values(); 
119 ····py::enum_<OSD_OEMType>(m,·"OSD_OEMType",R"#(This·is·set·of·possible·machine·types·used·in·OSD_Host::MachineType)#") 
120 ········.value("OSD_Unavailable",OSD_OEMType::OSD_Unavailable) 
121 ········.value("OSD_SUN",OSD_OEMType::OSD_SUN) 
122 ········.value("OSD_DEC",OSD_OEMType::OSD_DEC) 
123 ········.value("OSD_SGI",OSD_OEMType::OSD_SGI) 
124 ········.value("OSD_NEC",OSD_OEMType::OSD_NEC) 
125 ········.value("OSD_MAC",OSD_OEMType::OSD_MAC) 
126 ········.value("OSD_PC",OSD_OEMType::OSD_PC) 
127 ········.value("OSD_HP",OSD_OEMType::OSD_HP) 
128 ········.value("OSD_IBM",OSD_OEMType::OSD_IBM) 
129 ········.value("OSD_VAX",OSD_OEMType::OSD_VAX) 
130 ········.value("OSD_LIN",OSD_OEMType::OSD_LIN) 
131 ········.value("OSD_AIX",OSD_OEMType::OSD_AIX).export_values(); 
132 ····py::enum_<OSD_OpenMode>(m,·"OSD_OpenMode",R"#(Specifies·the·file·open·mode.)#") 
133 ········.value("OSD_ReadOnly",OSD_OpenMode::OSD_ReadOnly) 
134 ········.value("OSD_WriteOnly",OSD_OpenMode::OSD_WriteOnly) 
135 ········.value("OSD_ReadWrite",OSD_OpenMode::OSD_ReadWrite).export_values(); 
136 ····py::enum_<OSD_WhoAmI>(m,·"OSD_WhoAmI",R"#(Allows·great·accuracy·for·error·management.·This·is·private.)#")116 ····py::enum_<OSD_WhoAmI>(m,·"OSD_WhoAmI",R"#(Allows·great·accuracy·for·error·management.·This·is·private.)#")
137 ········.value("OSD_WDirectory",OSD_WhoAmI::OSD_WDirectory)117 ········.value("OSD_WDirectory",OSD_WhoAmI::OSD_WDirectory)
138 ········.value("OSD_WDirectoryIterator",OSD_WhoAmI::OSD_WDirectoryIterator)118 ········.value("OSD_WDirectoryIterator",OSD_WhoAmI::OSD_WDirectoryIterator)
139 ········.value("OSD_WEnvironment",OSD_WhoAmI::OSD_WEnvironment)119 ········.value("OSD_WEnvironment",OSD_WhoAmI::OSD_WEnvironment)
140 ········.value("OSD_WFile",OSD_WhoAmI::OSD_WFile)120 ········.value("OSD_WFile",OSD_WhoAmI::OSD_WFile)
141 ········.value("OSD_WFileNode",OSD_WhoAmI::OSD_WFileNode)121 ········.value("OSD_WFileNode",OSD_WhoAmI::OSD_WFileNode)
142 ········.value("OSD_WFileIterator",OSD_WhoAmI::OSD_WFileIterator)122 ········.value("OSD_WFileIterator",OSD_WhoAmI::OSD_WFileIterator)
Offset 146, 31 lines modifiedOffset 126, 35 lines modified
146 ········.value("OSD_WProtection",OSD_WhoAmI::OSD_WProtection)126 ········.value("OSD_WProtection",OSD_WhoAmI::OSD_WProtection)
147 ········.value("OSD_WHost",OSD_WhoAmI::OSD_WHost)127 ········.value("OSD_WHost",OSD_WhoAmI::OSD_WHost)
148 ········.value("OSD_WDisk",OSD_WhoAmI::OSD_WDisk)128 ········.value("OSD_WDisk",OSD_WhoAmI::OSD_WDisk)
149 ········.value("OSD_WChronometer",OSD_WhoAmI::OSD_WChronometer)129 ········.value("OSD_WChronometer",OSD_WhoAmI::OSD_WChronometer)
150 ········.value("OSD_WTimer",OSD_WhoAmI::OSD_WTimer)130 ········.value("OSD_WTimer",OSD_WhoAmI::OSD_WTimer)
151 ········.value("OSD_WPackage",OSD_WhoAmI::OSD_WPackage)131 ········.value("OSD_WPackage",OSD_WhoAmI::OSD_WPackage)
152 ········.value("OSD_WEnvironmentIterator",OSD_WhoAmI::OSD_WEnvironmentIterator).export_values();132 ········.value("OSD_WEnvironmentIterator",OSD_WhoAmI::OSD_WEnvironmentIterator).export_values();
 133 ····py::enum_<OSD_LoadMode>(m,·"OSD_LoadMode",R"#(This·enumeration·is·used·to·load·shareable·libraries.)#")
 134 ········.value("OSD_RTLD_LAZY",OSD_LoadMode::OSD_RTLD_LAZY)
 135 ········.value("OSD_RTLD_NOW",OSD_LoadMode::OSD_RTLD_NOW).export_values();
 136 ····py::enum_<OSD_OEMType>(m,·"OSD_OEMType",R"#(This·is·set·of·possible·machine·types·used·in·OSD_Host::MachineType)#")
 137 ········.value("OSD_Unavailable",OSD_OEMType::OSD_Unavailable)
 138 ········.value("OSD_SUN",OSD_OEMType::OSD_SUN)
 139 ········.value("OSD_DEC",OSD_OEMType::OSD_DEC)
 140 ········.value("OSD_SGI",OSD_OEMType::OSD_SGI)
 141 ········.value("OSD_NEC",OSD_OEMType::OSD_NEC)
 142 ········.value("OSD_MAC",OSD_OEMType::OSD_MAC)
 143 ········.value("OSD_PC",OSD_OEMType::OSD_PC)
 144 ········.value("OSD_HP",OSD_OEMType::OSD_HP)
 145 ········.value("OSD_IBM",OSD_OEMType::OSD_IBM)
 146 ········.value("OSD_VAX",OSD_OEMType::OSD_VAX)
 147 ········.value("OSD_LIN",OSD_OEMType::OSD_LIN)
153 ····py::enum_<OSD_SingleProtection>(m,·"OSD_SingleProtection",R"#(Access·rights·for·files.·R·means·Read,·W·means·Write,·X·means·eXecute·and·D·means·Delete.·On·UNIX,·the·right·to·Delete·is·combined·with·Write·access.·So·if·"W"rite·is·not·set·and·"D"elete·is,·"W"rite·will·be·set·and·if·"W"·is·set,·"D"·will·be·too.)#") 
154 ········.value("OSD_None",OSD_SingleProtection::OSD_None) 
155 ········.value("OSD_R",OSD_SingleProtection::OSD_R) 
156 ········.value("OSD_W",OSD_SingleProtection::OSD_W) 
157 ········.value("OSD_RW",OSD_SingleProtection::OSD_RW) 
158 ········.value("OSD_X",OSD_SingleProtection::OSD_X) 
159 ········.value("OSD_RX",OSD_SingleProtection::OSD_RX) 
160 ········.value("OSD_WX",OSD_SingleProtection::OSD_WX) 
161 ········.value("OSD_RWX",OSD_SingleProtection::OSD_RWX) 
162 ········.value("OSD_D",OSD_SingleProtection::OSD_D) 
163 ········.value("OSD_RD",OSD_SingleProtection::OSD_RD) 
164 ········.value("OSD_WD",OSD_SingleProtection::OSD_WD) 
165 ········.value("OSD_RWD",OSD_SingleProtection::OSD_RWD) 
166 ········.value("OSD_XD",OSD_SingleProtection::OSD_XD) 
167 ········.value("OSD_RXD",OSD_SingleProtection::OSD_RXD) 
168 ········.value("OSD_WXD",OSD_SingleProtection::OSD_WXD) 
169 ········.value("OSD_RWXD",OSD_SingleProtection::OSD_RWXD).export_values();148 ········.value("OSD_AIX",OSD_OEMType::OSD_AIX).export_values();
 149 ····py::enum_<OSD_LockType>(m,·"OSD_LockType",R"#(locks·for·files.·NoLock·is·the·default·value·when·opening·a·file.)#")
 150 ········.value("OSD_NoLock",OSD_LockType::OSD_NoLock)
 151 ········.value("OSD_ReadLock",OSD_LockType::OSD_ReadLock)
 152 ········.value("OSD_WriteLock",OSD_LockType::OSD_WriteLock)
 153 ········.value("OSD_ExclusiveLock",OSD_LockType::OSD_ExclusiveLock).export_values();
170 ····py::enum_<OSD_SysType>(m,·"OSD_SysType",R"#(Thisd·is·a·set·of·possible·system·types.·'Default'·means·SysType·of·machine·operating·this·process.·This·can·be·used·with·the·Path·class.·All·UNIX-like·are·grouped·under·"UnixBSD"·or·"UnixSystemV".·Such·systems·are·Solaris,·NexTOS·...·A·category·of·systems·accept·MSDOS-like·path·such·as·WindowsNT·and·OS2.)#")154 ····py::enum_<OSD_SysType>(m,·"OSD_SysType",R"#(Thisd·is·a·set·of·possible·system·types.·'Default'·means·SysType·of·machine·operating·this·process.·This·can·be·used·with·the·Path·class.·All·UNIX-like·are·grouped·under·"UnixBSD"·or·"UnixSystemV".·Such·systems·are·Solaris,·NexTOS·...·A·category·of·systems·accept·MSDOS-like·path·such·as·WindowsNT·and·OS2.)#")
171 ········.value("OSD_Unknown",OSD_SysType::OSD_Unknown)155 ········.value("OSD_Unknown",OSD_SysType::OSD_Unknown)
172 ········.value("OSD_Default",OSD_SysType::OSD_Default)156 ········.value("OSD_Default",OSD_SysType::OSD_Default)
173 ········.value("OSD_UnixBSD",OSD_SysType::OSD_UnixBSD)157 ········.value("OSD_UnixBSD",OSD_SysType::OSD_UnixBSD)
174 ········.value("OSD_UnixSystemV",OSD_SysType::OSD_UnixSystemV)158 ········.value("OSD_UnixSystemV",OSD_SysType::OSD_UnixSystemV)
175 ········.value("OSD_VMS",OSD_SysType::OSD_VMS)159 ········.value("OSD_VMS",OSD_SysType::OSD_VMS)
176 ········.value("OSD_OS2",OSD_SysType::OSD_OS2)160 ········.value("OSD_OS2",OSD_SysType::OSD_OS2)
Offset 186, 19 lines modifiedOffset 170, 35 lines modified
186 ········.value("OSD_FromEnd",OSD_FromWhere::OSD_FromEnd).export_values();170 ········.value("OSD_FromEnd",OSD_FromWhere::OSD_FromEnd).export_values();
187 ····py::enum_<OSD_KindFile>(m,·"OSD_KindFile",R"#(Specifies·the·type·of·files.)#")171 ····py::enum_<OSD_KindFile>(m,·"OSD_KindFile",R"#(Specifies·the·type·of·files.)#")
188 ········.value("OSD_FILE",OSD_KindFile::OSD_FILE)172 ········.value("OSD_FILE",OSD_KindFile::OSD_FILE)
189 ········.value("OSD_DIRECTORY",OSD_KindFile::OSD_DIRECTORY)173 ········.value("OSD_DIRECTORY",OSD_KindFile::OSD_DIRECTORY)
190 ········.value("OSD_LINK",OSD_KindFile::OSD_LINK)174 ········.value("OSD_LINK",OSD_KindFile::OSD_LINK)
191 ········.value("OSD_SOCKET",OSD_KindFile::OSD_SOCKET)175 ········.value("OSD_SOCKET",OSD_KindFile::OSD_SOCKET)
192 ········.value("OSD_UNKNOWN",OSD_KindFile::OSD_UNKNOWN).export_values();176 ········.value("OSD_UNKNOWN",OSD_KindFile::OSD_UNKNOWN).export_values();
 177 ····py::enum_<OSD_OpenMode>(m,·"OSD_OpenMode",R"#(Specifies·the·file·open·mode.)#")
193 ····py::enum_<OSD_LockType>(m,·"OSD_LockType",R"#(locks·for·files.·NoLock·is·the·default·value·when·opening·a·file.)#") 
194 ········.value("OSD_NoLock",OSD_LockType::OSD_NoLock) 
195 ········.value("OSD_ReadLock",OSD_LockType::OSD_ReadLock)178 ········.value("OSD_ReadOnly",OSD_OpenMode::OSD_ReadOnly)
196 ········.value("OSD_WriteLock",OSD_LockType::OSD_WriteLock)179 ········.value("OSD_WriteOnly",OSD_OpenMode::OSD_WriteOnly)
197 ········.value("OSD_ExclusiveLock",OSD_LockType::OSD_ExclusiveLock).export_values();180 ········.value("OSD_ReadWrite",OSD_OpenMode::OSD_ReadWrite).export_values();
 181 ····py::enum_<OSD_SingleProtection>(m,·"OSD_SingleProtection",R"#(Access·rights·for·files.·R·means·Read,·W·means·Write,·X·means·eXecute·and·D·means·Delete.·On·UNIX,·the·right·to·Delete·is·combined·with·Write·access.·So·if·"W"rite·is·not·set·and·"D"elete·is,·"W"rite·will·be·set·and·if·"W"·is·set,·"D"·will·be·too.)#")
 182 ········.value("OSD_None",OSD_SingleProtection::OSD_None)
 183 ········.value("OSD_R",OSD_SingleProtection::OSD_R)
 184 ········.value("OSD_W",OSD_SingleProtection::OSD_W)
 185 ········.value("OSD_RW",OSD_SingleProtection::OSD_RW)
 186 ········.value("OSD_X",OSD_SingleProtection::OSD_X)
 187 ········.value("OSD_RX",OSD_SingleProtection::OSD_RX)
 188 ········.value("OSD_WX",OSD_SingleProtection::OSD_WX)
 189 ········.value("OSD_RWX",OSD_SingleProtection::OSD_RWX)
 190 ········.value("OSD_D",OSD_SingleProtection::OSD_D)
 191 ········.value("OSD_RD",OSD_SingleProtection::OSD_RD)
 192 ········.value("OSD_WD",OSD_SingleProtection::OSD_WD)
 193 ········.value("OSD_RWD",OSD_SingleProtection::OSD_RWD)
 194 ········.value("OSD_XD",OSD_SingleProtection::OSD_XD)
 195 ········.value("OSD_RXD",OSD_SingleProtection::OSD_RXD)
 196 ········.value("OSD_WXD",OSD_SingleProtection::OSD_WXD)
 197 ········.value("OSD_RWXD",OSD_SingleProtection::OSD_RWXD).export_values();
  
198 //Python·trampoline·classes198 //Python·trampoline·classes
199 ····class·Py_OSD_FileSystem·:·public·OSD_FileSystem{199 ····class·Py_OSD_FileSystem·:·public·OSD_FileSystem{
200 ····public:200 ····public:
201 ········using·OSD_FileSystem::OSD_FileSystem;201 ········using·OSD_FileSystem::OSD_FileSystem;
  
  
⊟
999 B
./usr/share/libocp/OCP/OpenGl.cpp
Ordering differences only
    
Offset 6632, 17 lines modifiedOffset 6632, 17 lines modified
6632 ·············(·const·handle<Standard_Type>·&·(OpenGl_PointSprite::*)()·const)·static_cast<·const·handle<Standard_Type>·&·(OpenGl_PointSprite::*)()·const>(&OpenGl_PointSprite::DynamicType),6632 ·············(·const·handle<Standard_Type>·&·(OpenGl_PointSprite::*)()·const)·static_cast<·const·handle<Standard_Type>·&·(OpenGl_PointSprite::*)()·const>(&OpenGl_PointSprite::DynamicType),
6633 ·············R"#()#"6633 ·············R"#()#"
6634 ·············6634 ·············
6635 ·········)6635 ·········)
6636 ;6636 ;
  
6637 //·functions6637 //·functions
 6638 auto·mOpenGl_Raytrace·=·static_cast<py::module>(m.attr("OpenGl_Raytrace"));
6638 auto·mopencascade·=·static_cast<py::module>(m.attr("opencascade"));6639 auto·mopencascade·=·static_cast<py::module>(m.attr("opencascade"));
6639 auto·mOpenGl·=·static_cast<py::module>(m.attr("OpenGl"));6640 auto·mOpenGl·=·static_cast<py::module>(m.attr("OpenGl"));
6640 auto·mOpenGl_Raytrace·=·static_cast<py::module>(m.attr("OpenGl_Raytrace")); 
6641 auto·mOpenGl_HashMapInitializer·=·static_cast<py::module>(m.attr("OpenGl_HashMapInitializer"));6641 auto·mOpenGl_HashMapInitializer·=·static_cast<py::module>(m.attr("OpenGl_HashMapInitializer"));
  
6642 //·/usr/include/opencascade/OpenGl_ArbDbg.hxx6642 //·/usr/include/opencascade/OpenGl_ArbDbg.hxx
6643 //·/usr/include/opencascade/OpenGl_ArbFBO.hxx6643 //·/usr/include/opencascade/OpenGl_ArbFBO.hxx
6644 //·/usr/include/opencascade/OpenGl_ArbIns.hxx6644 //·/usr/include/opencascade/OpenGl_ArbIns.hxx
6645 //·/usr/include/opencascade/OpenGl_ArbSamplerObject.hxx6645 //·/usr/include/opencascade/OpenGl_ArbSamplerObject.hxx
6646 //·/usr/include/opencascade/OpenGl_ArbTBO.hxx6646 //·/usr/include/opencascade/OpenGl_ArbTBO.hxx
⊟
6.86 KB
./usr/share/libocp/OCP/OpenGl_pre.cpp
Ordering differences only
    
Offset 238, 30 lines modifiedOffset 238, 39 lines modified
238 //·Module·definiiton238 //·Module·definiiton
239 void·register_OpenGl_enums(py::module·&main_module)·{239 void·register_OpenGl_enums(py::module·&main_module)·{
  
  
240 py::module·m·=·main_module.def_submodule("OpenGl",·R"#()#");240 py::module·m·=·main_module.def_submodule("OpenGl",·R"#()#");
  
241 //·add·namespaces·as·submodules241 //·add·namespaces·as·submodules
 242 m.def_submodule("OpenGl_Raytrace");
242 m.def_submodule("opencascade");243 m.def_submodule("opencascade");
243 m.def_submodule("OpenGl");244 m.def_submodule("OpenGl");
244 m.def_submodule("OpenGl_Raytrace"); 
245 m.def_submodule("OpenGl_HashMapInitializer");245 m.def_submodule("OpenGl_HashMapInitializer");
  
246 //·user-defined·inclusion·per·module·in·the·body246 //·user-defined·inclusion·per·module·in·the·body
247 py::class_<NSOpenGLContext>(m,·"NSOpenGLContext");247 py::class_<NSOpenGLContext>(m,·"NSOpenGLContext");
  
248 //·enums248 //·enums
249 ····py::enum_<OpenGl_RenderFilter>(m,·"OpenGl_RenderFilter",R"#(Filter·for·rendering·elements.)#") 
250 ········.value("OpenGl_RenderFilter_Empty",OpenGl_RenderFilter::OpenGl_RenderFilter_Empty) 
251 ········.value("OpenGl_RenderFilter_OpaqueOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_OpaqueOnly) 
252 ········.value("OpenGl_RenderFilter_TransparentOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_TransparentOnly) 
253 ········.value("OpenGl_RenderFilter_NonRaytraceableOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_NonRaytraceableOnly) 
254 ········.value("OpenGl_RenderFilter_FillModeOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_FillModeOnly) 
255 ········.value("OpenGl_RenderFilter_SkipTrsfPersistence",OpenGl_RenderFilter::OpenGl_RenderFilter_SkipTrsfPersistence).export_values();249 ····py::enum_<OpenGl_ShaderProgramDumpLevel>(m,·"OpenGl_ShaderProgramDumpLevel",R"#(Definition·of·shader·programs·source·code·dump·levels.)#")
 250 ········.value("OpenGl_ShaderProgramDumpLevel_Off",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Off)
 251 ········.value("OpenGl_ShaderProgramDumpLevel_Short",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Short)
 252 ········.value("OpenGl_ShaderProgramDumpLevel_Full",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Full).export_values();
 253 ····py::enum_<OpenGl_MaterialFlag>(m,·"OpenGl_MaterialFlag",R"#(Material·flag)#")
 254 ········.value("OpenGl_MaterialFlag_Front",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Front)
 255 ········.value("OpenGl_MaterialFlag_Back",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Back).export_values();
 256 ····py::enum_<OpenGl_LayerFilter>(m,·"OpenGl_LayerFilter",R"#(Tool·object·to·specify·processed·OpenGL·layers·for·intermixed·rendering·of·raytracable·and·non-raytracable·layers.)#")
 257 ········.value("OpenGl_LF_All",OpenGl_LayerFilter::OpenGl_LF_All)
 258 ········.value("OpenGl_LF_Upper",OpenGl_LayerFilter::OpenGl_LF_Upper)
 259 ········.value("OpenGl_LF_Bottom",OpenGl_LayerFilter::OpenGl_LF_Bottom)
 260 ········.value("OpenGl_LF_RayTracable",OpenGl_LayerFilter::OpenGl_LF_RayTracable).export_values();
 261 ····py::enum_<OpenGl_FeatureFlag>(m,·"OpenGl_FeatureFlag",R"#()#")
 262 ········.value("OpenGl_FeatureNotAvailable",OpenGl_FeatureFlag::OpenGl_FeatureNotAvailable)
 263 ········.value("OpenGl_FeatureInExtensions",OpenGl_FeatureFlag::OpenGl_FeatureInExtensions)
 264 ········.value("OpenGl_FeatureInCore",OpenGl_FeatureFlag::OpenGl_FeatureInCore).export_values();
256 ····py::enum_<OpenGl_StateVariable>(m,·"OpenGl_StateVariable",R"#(The·enumeration·of·OCCT-specific·OpenGL/GLSL·variables.)#")265 ····py::enum_<OpenGl_StateVariable>(m,·"OpenGl_StateVariable",R"#(The·enumeration·of·OCCT-specific·OpenGL/GLSL·variables.)#")
257 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX)266 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX)
258 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX)267 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX)
259 ········.value("OpenGl_OCC_PROJECTION_MATRIX",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX)268 ········.value("OpenGl_OCC_PROJECTION_MATRIX",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX)
260 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE)269 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE)
261 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE)270 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE)
262 ········.value("OpenGl_OCC_PROJECTION_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX_INVERSE)271 ········.value("OpenGl_OCC_PROJECTION_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX_INVERSE)
Offset 308, 30 lines modifiedOffset 317, 21 lines modified
308 ········.value("OpenGl_MODEL_WORLD_STATE",OpenGl_UniformStateType::OpenGl_MODEL_WORLD_STATE)317 ········.value("OpenGl_MODEL_WORLD_STATE",OpenGl_UniformStateType::OpenGl_MODEL_WORLD_STATE)
309 ········.value("OpenGl_WORLD_VIEW_STATE",OpenGl_UniformStateType::OpenGl_WORLD_VIEW_STATE)318 ········.value("OpenGl_WORLD_VIEW_STATE",OpenGl_UniformStateType::OpenGl_WORLD_VIEW_STATE)
310 ········.value("OpenGl_PROJECTION_STATE",OpenGl_UniformStateType::OpenGl_PROJECTION_STATE)319 ········.value("OpenGl_PROJECTION_STATE",OpenGl_UniformStateType::OpenGl_PROJECTION_STATE)
311 ········.value("OpenGl_MATERIAL_STATE",OpenGl_UniformStateType::OpenGl_MATERIAL_STATE)320 ········.value("OpenGl_MATERIAL_STATE",OpenGl_UniformStateType::OpenGl_MATERIAL_STATE)
312 ········.value("OpenGl_SURF_DETAIL_STATE",OpenGl_UniformStateType::OpenGl_SURF_DETAIL_STATE)321 ········.value("OpenGl_SURF_DETAIL_STATE",OpenGl_UniformStateType::OpenGl_SURF_DETAIL_STATE)
313 ········.value("OpenGL_OIT_STATE",OpenGl_UniformStateType::OpenGL_OIT_STATE)322 ········.value("OpenGL_OIT_STATE",OpenGl_UniformStateType::OpenGL_OIT_STATE)
314 ········.value("OpenGl_UniformStateType_NB",OpenGl_UniformStateType::OpenGl_UniformStateType_NB).export_values();323 ········.value("OpenGl_UniformStateType_NB",OpenGl_UniformStateType::OpenGl_UniformStateType_NB).export_values();
 324 ····py::enum_<OpenGl_RenderFilter>(m,·"OpenGl_RenderFilter",R"#(Filter·for·rendering·elements.)#")
 325 ········.value("OpenGl_RenderFilter_Empty",OpenGl_RenderFilter::OpenGl_RenderFilter_Empty)
 326 ········.value("OpenGl_RenderFilter_OpaqueOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_OpaqueOnly)
 327 ········.value("OpenGl_RenderFilter_TransparentOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_TransparentOnly)
 328 ········.value("OpenGl_RenderFilter_NonRaytraceableOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_NonRaytraceableOnly)
 329 ········.value("OpenGl_RenderFilter_FillModeOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_FillModeOnly)
 330 ········.value("OpenGl_RenderFilter_SkipTrsfPersistence",OpenGl_RenderFilter::OpenGl_RenderFilter_SkipTrsfPersistence).export_values();
315 ····py::enum_<OpenGl_ShaderProgramDumpLevel>(m,·"OpenGl_ShaderProgramDumpLevel",R"#(Definition·of·shader·programs·source·code·dump·levels.)#") 
316 ········.value("OpenGl_ShaderProgramDumpLevel_Off",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Off) 
317 ········.value("OpenGl_ShaderProgramDumpLevel_Short",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Short) 
318 ········.value("OpenGl_ShaderProgramDumpLevel_Full",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Full).export_values(); 
319 ····py::enum_<OpenGl_LayerFilter>(m,·"OpenGl_LayerFilter",R"#(Tool·object·to·specify·processed·OpenGL·layers·for·intermixed·rendering·of·raytracable·and·non-raytracable·layers.)#") 
320 ········.value("OpenGl_LF_All",OpenGl_LayerFilter::OpenGl_LF_All) 
321 ········.value("OpenGl_LF_Upper",OpenGl_LayerFilter::OpenGl_LF_Upper) 
322 ········.value("OpenGl_LF_Bottom",OpenGl_LayerFilter::OpenGl_LF_Bottom) 
323 ········.value("OpenGl_LF_RayTracable",OpenGl_LayerFilter::OpenGl_LF_RayTracable).export_values(); 
324 ····py::enum_<OpenGl_MaterialFlag>(m,·"OpenGl_MaterialFlag",R"#(Material·flag)#") 
325 ········.value("OpenGl_MaterialFlag_Front",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Front) 
326 ········.value("OpenGl_MaterialFlag_Back",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Back).export_values(); 
327 ····py::enum_<OpenGl_FeatureFlag>(m,·"OpenGl_FeatureFlag",R"#()#") 
328 ········.value("OpenGl_FeatureNotAvailable",OpenGl_FeatureFlag::OpenGl_FeatureNotAvailable) 
329 ········.value("OpenGl_FeatureInExtensions",OpenGl_FeatureFlag::OpenGl_FeatureInExtensions) 
330 ········.value("OpenGl_FeatureInCore",OpenGl_FeatureFlag::OpenGl_FeatureInCore).export_values(); 
  
331 //Python·trampoline·classes331 //Python·trampoline·classes
332 ····class·Py_OpenGl_Element·:·public·OpenGl_Element{332 ····class·Py_OpenGl_Element·:·public·OpenGl_Element{
333 ····public:333 ····public:
334 ········using·OpenGl_Element::OpenGl_Element;334 ········using·OpenGl_Element::OpenGl_Element;
  
  
⊟
6.7 KB
./usr/share/libocp/OCP/OpenGl_tmpl.hxx
Ordering differences only
    
Offset 212, 14 lines modifiedOffset 212, 47 lines modified
212 #include·<OpenGl_Workspace.hxx>212 #include·<OpenGl_Workspace.hxx>
  
213 //·user-defined·pre213 //·user-defined·pre
214 #include·"OCP_specific.inc"214 #include·"OCP_specific.inc"
  
215 //·Class·template·handling·functions215 //·Class·template·handling·functions
  
 216 template·<typename·T>
 217 void·preregister_template_OpenGl_MatrixState(py::object·&m,·const·char·*name){
 218 ····py::class_<OpenGl_MatrixState<T>·,·shared_ptr<OpenGl_MatrixState<T>>·>(m,name,R"#(Software·implementation·for·OpenGL·matrix·stack.)#");
 219 }
  
 220 template·<typename·T>
 221 void·register_template_OpenGl_MatrixState(py::object·&m,·const·char·*name){
 222 ····static_cast<py::class_<OpenGl_MatrixState<T>·,·shared_ptr<OpenGl_MatrixState<T>>·>>(m.attr(name))
 223 ········.def(py::init<··>()··)
 224 ········.def("Push",
 225 ·············(void·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::Push,
 226 ·············R"#(Pushes·current·matrix·into·stack.)#"·)
 227 ········.def("Pop",
 228 ·············(void·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::Pop,
 229 ·············R"#(Pops·matrix·from·stack·to·current.)#"·)
 230 ········.def("Current",
 231 ·············(·const·typename·OpenGl::MatrixType<T>::Mat4·&·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::Current,
 232 ·············R"#(Returns·current·matrix.)#"·)
 233 ········.def("SetCurrent",
 234 ·············(void·(OpenGl_MatrixState<T>::*)(··const·typename·OpenGl::MatrixType<T>::Mat4·&··)·)·&OpenGl_MatrixState<T>::SetCurrent,
 235 ·············R"#(Sets·given·matrix·as·current.)#"·,py::arg("theNewCurrent"))
 236 ········.def("ChangeCurrent",
 237 ·············(typename·OpenGl::MatrixType<T>::Mat4·&·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::ChangeCurrent,
 238 ·············R"#(Change·current·matrix.)#"·)
 239 ········.def("SetIdentity",
 240 ·············(void·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::SetIdentity,
 241 ·············R"#(Sets·current·matrix·to·identity.)#"·)
 242 ········.def("DumpJson",
 243 ·············(void·(OpenGl_MatrixState<T>::*)(·Standard_OStream·&·,··Standard_Integer··)·const)·&OpenGl_MatrixState<T>::DumpJson,
 244 ·············R"#(Dumps·the·content·of·me·into·the·stream)#"·,py::arg("theOStream"),·py::arg("theDepth")=static_cast<Standard_Integer>(-·1))
 245 ····;
 246 };
  
216 template·<typename·BaseBufferT>247 template·<typename·BaseBufferT>
217 void·preregister_template_OpenGl_BufferCompatT(py::object·&m,·const·char·*name){248 void·preregister_template_OpenGl_BufferCompatT(py::object·&m,·const·char·*name){
218 ····py::class_<OpenGl_BufferCompatT<BaseBufferT>·,·shared_ptr<OpenGl_BufferCompatT<BaseBufferT>>·>(m,name,R"#(Compatibility·layer·for·old·OpenGL·without·VBO.·Make·sure·to·pass·pointer·from·GetDataOffset()·instead·of·NULL.·Method·GetDataOffset()·returns·pointer·to·real·data·in·this·class·(while·base·class·OpenGl_VertexBuffer·always·return·NULL).)#");249 ····py::class_<OpenGl_BufferCompatT<BaseBufferT>·,·shared_ptr<OpenGl_BufferCompatT<BaseBufferT>>·>(m,name,R"#(Compatibility·layer·for·old·OpenGL·without·VBO.·Make·sure·to·pass·pointer·from·GetDataOffset()·instead·of·NULL.·Method·GetDataOffset()·returns·pointer·to·real·data·in·this·class·(while·base·class·OpenGl_VertexBuffer·always·return·NULL).)#");
219 }250 }
  
220 template·<typename·BaseBufferT>251 template·<typename·BaseBufferT>
221 void·register_template_OpenGl_BufferCompatT(py::object·&m,·const·char·*name){252 void·register_template_OpenGl_BufferCompatT(py::object·&m,·const·char·*name){
Offset 252, 25 lines modifiedOffset 285, 14 lines modified
252 ········.def("getSubData",285 ········.def("getSubData",
253 ·············(bool·(OpenGl_BufferCompatT<BaseBufferT>::*)(··const·handle<OpenGl_Context>·&·,···const·Standard_Integer·,···const·Standard_Integer·,··void·*·,···const·unsigned·int··)·)·&OpenGl_BufferCompatT<BaseBufferT>::getSubData,286 ·············(bool·(OpenGl_BufferCompatT<BaseBufferT>::*)(··const·handle<OpenGl_Context>·&·,···const·Standard_Integer·,···const·Standard_Integer·,··void·*·,···const·unsigned·int··)·)·&OpenGl_BufferCompatT<BaseBufferT>::getSubData,
254 ·············R"#(Read·back·buffer·sub-range.)#"·,py::arg("theGlCtx"),·py::arg("theElemFrom"),·py::arg("theElemsNb"),·py::arg("theData"),·py::arg("theDataType"))287 ·············R"#(Read·back·buffer·sub-range.)#"·,py::arg("theGlCtx"),·py::arg("theElemFrom"),·py::arg("theElemsNb"),·py::arg("theData"),·py::arg("theDataType"))
255 ····;288 ····;
256 };289 };
  
257 template·<typename·T>290 template·<typename·T>
258 void·preregister_template_OpenGl_TextureFormatSelector(py::object·&m,·const·char·*name){ 
259 ····py::class_<OpenGl_TextureFormatSelector<T>·,·shared_ptr<OpenGl_TextureFormatSelector<T>>·>(m,name,R"#(Selects·preferable·texture·format·for·specified·parameters.)#"); 
260 } 
  
261 template·<typename·T> 
262 void·register_template_OpenGl_TextureFormatSelector(py::object·&m,·const·char·*name){ 
263 ····static_cast<py::class_<OpenGl_TextureFormatSelector<T>·,·shared_ptr<OpenGl_TextureFormatSelector<T>>·>>(m.attr(name)) 
264 ····; 
265 }; 
  
266 template·<typename·T> 
267 void·preregister_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){291 void·preregister_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){
268 ····py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>(m,name,R"#()#");292 ····py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>(m,name,R"#()#");
269 }293 }
  
270 template·<typename·T>294 template·<typename·T>
271 void·register_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){295 void·register_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){
272 ····static_cast<py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>>(m.attr(name))296 ····static_cast<py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>>(m.attr(name))
Offset 339, 42 lines modifiedOffset 361, 20 lines modified
339 template·<typename·T>361 template·<typename·T>
340 void·register_template_MatrixType(py::object·&m,·const·char·*name){362 void·register_template_MatrixType(py::object·&m,·const·char·*name){
341 ····static_cast<py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>>(m.attr(name))363 ····static_cast<py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>>(m.attr(name))
342 ····;364 ····;
343 };365 };
  
344 template·<typename·T>366 template·<typename·T>
345 void·preregister_template_OpenGl_MatrixState(py::object·&m,·const·char·*name){367 void·preregister_template_OpenGl_TextureFormatSelector(py::object·&m,·const·char·*name){
346 ····py::class_<OpenGl_MatrixState<T>·,·shared_ptr<OpenGl_MatrixState<T>>·>(m,name,R"#(Software·implementation·for·OpenGL·matrix·stack.)#");368 ····py::class_<OpenGl_TextureFormatSelector<T>·,·shared_ptr<OpenGl_TextureFormatSelector<T>>·>(m,name,R"#(Selects·preferable·texture·format·for·specified·parameters.)#");
347 }369 }
  
348 template·<typename·T>370 template·<typename·T>
349 void·register_template_OpenGl_MatrixState(py::object·&m,·const·char·*name){371 void·register_template_OpenGl_TextureFormatSelector(py::object·&m,·const·char·*name){
350 ····static_cast<py::class_<OpenGl_MatrixState<T>·,·shared_ptr<OpenGl_MatrixState<T>>·>>(m.attr(name))372 ····static_cast<py::class_<OpenGl_TextureFormatSelector<T>·,·shared_ptr<OpenGl_TextureFormatSelector<T>>·>>(m.attr(name))
351 ········.def(py::init<··>()··) 
352 ········.def("Push", 
353 ·············(void·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::Push, 
354 ·············R"#(Pushes·current·matrix·into·stack.)#"·) 
355 ········.def("Pop", 
356 ·············(void·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::Pop, 
357 ·············R"#(Pops·matrix·from·stack·to·current.)#"·) 
358 ········.def("Current", 
359 ·············(·const·typename·OpenGl::MatrixType<T>::Mat4·&·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::Current, 
360 ·············R"#(Returns·current·matrix.)#"·) 
361 ········.def("SetCurrent", 
362 ·············(void·(OpenGl_MatrixState<T>::*)(··const·typename·OpenGl::MatrixType<T>::Mat4·&··)·)·&OpenGl_MatrixState<T>::SetCurrent, 
363 ·············R"#(Sets·given·matrix·as·current.)#"·,py::arg("theNewCurrent")) 
364 ········.def("ChangeCurrent", 
365 ·············(typename·OpenGl::MatrixType<T>::Mat4·&·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::ChangeCurrent, 
366 ·············R"#(Change·current·matrix.)#"·) 
367 ········.def("SetIdentity", 
368 ·············(void·(OpenGl_MatrixState<T>::*)()·)·&OpenGl_MatrixState<T>::SetIdentity, 
369 ·············R"#(Sets·current·matrix·to·identity.)#"·) 
370 ········.def("DumpJson", 
371 ·············(void·(OpenGl_MatrixState<T>::*)(·Standard_OStream·&·,··Standard_Integer··)·const)·&OpenGl_MatrixState<T>::DumpJson, 
372 ·············R"#(Dumps·the·content·of·me·into·the·stream)#"·,py::arg("theOStream"),·py::arg("theDepth")=static_cast<Standard_Integer>(-·1)) 
373 ····;373 ····;
374 };374 };
  
  
375 //·user-defined·post375 //·user-defined·post
  
⊟
4.85 KB
./usr/share/libocp/OCP/PCDM_pre.cpp
Ordering differences only
    
Offset 73, 14 lines modifiedOffset 73, 24 lines modified
73 py::module·m·=·main_module.def_submodule("PCDM",·R"#()#");73 py::module·m·=·main_module.def_submodule("PCDM",·R"#()#");
  
74 //·add·namespaces·as·submodules74 //·add·namespaces·as·submodules
  
75 //·user-defined·inclusion·per·module·in·the·body75 //·user-defined·inclusion·per·module·in·the·body
  
76 //·enums76 //·enums
 77 ····py::enum_<PCDM_StoreStatus>(m,·"PCDM_StoreStatus",R"#(Status·of·storage·of·a·document·on·disk.·If·it·is·PCDM_SS_OK,·the·document·is·successfully·saved·on·disk.·Else·-·there·is·an·error.)#")
 78 ········.value("PCDM_SS_OK",PCDM_StoreStatus::PCDM_SS_OK)
 79 ········.value("PCDM_SS_DriverFailure",PCDM_StoreStatus::PCDM_SS_DriverFailure)
 80 ········.value("PCDM_SS_WriteFailure",PCDM_StoreStatus::PCDM_SS_WriteFailure)
 81 ········.value("PCDM_SS_Failure",PCDM_StoreStatus::PCDM_SS_Failure)
 82 ········.value("PCDM_SS_Doc_IsNull",PCDM_StoreStatus::PCDM_SS_Doc_IsNull)
 83 ········.value("PCDM_SS_No_Obj",PCDM_StoreStatus::PCDM_SS_No_Obj)
 84 ········.value("PCDM_SS_Info_Section_Error",PCDM_StoreStatus::PCDM_SS_Info_Section_Error)
 85 ········.value("PCDM_SS_UserBreak",PCDM_StoreStatus::PCDM_SS_UserBreak)
 86 ········.value("PCDM_SS_UnrecognizedFormat",PCDM_StoreStatus::PCDM_SS_UnrecognizedFormat).export_values();
77 ····py::enum_<PCDM_ReaderStatus>(m,·"PCDM_ReaderStatus",R"#(Status·of·reading·of·a·document.·The·following·values·are·accessible:·-·PCDM_RS_OK:·the·document·was·successfully·read;·-·PCDM_RS_NoDriver:·driver·is·not·found·for·the·defined·file·format;·-·PCDM_RS_UnknownFileDriver:·check·of·the·file·failed·(file·doesn't·exist,·for·example);·-·PCDM_RS_OpenError:·attempt·to·open·the·file·failed;·-·PCDM_RS_NoVersion:·document·version·of·the·file·is·out·of·scope;·-·PCDM_RS_NoSchema:·NOT·USED;·-·PCDM_RS_NoDocument:·document·is·empty·(failed·to·be·read·correctly);·-·PCDM_RS_ExtensionFailure:·NOT·USED;·-·PCDM_RS_WrongStreamMode:·file·is·not·open·for·reading·(a·mistaken·mode);·-·PCDM_RS_FormatFailure:·mistake·in·document·data·structure;·-·PCDM_RS_TypeFailure:·data·type·is·unknown;·-·PCDM_RS_TypeNotFoundInSchema:·data·type·is·not·found·in·schema·(STD·file·format);·-·PCDM_RS_UnrecognizedFileFormat:·document·data·structure·is·wrong·(binary·file·format);·-·PCDM_RS_MakeFailure:·conversion·of·data·from·persistent·to·transient·attributes·failed·(XML·file·format);·-·PCDM_RS_PermissionDenied:·file·can't·be·opened·because·permission·is·denied;·-·PCDM_RS_DriverFailure:·something·went·wrong·(a·general·mistake·of·reading·of·a·document);·-·PCDM_RS_AlreadyRetrievedAndModified:·document·is·already·retrieved·and·modified·in·current·session;·-·PCDM_RS_AlreadyRetrieved:·document·is·already·in·current·session·(already·retrieved);·-·PCDM_RS_UnknownDocument:·file·doesn't·exist·on·disk;·-·PCDM_RS_WrongResource:·wrong·resource·file·(.RetrievalPlugin);·-·PCDM_RS_ReaderException:·no·shape·section·in·the·document·file·(binary·file·format);·-·PCDM_RS_NoModel:·NOT·USED;·-·PCDM_RS_UserBreak:·user·stopped·reading·of·the·document;)#")87 ····py::enum_<PCDM_ReaderStatus>(m,·"PCDM_ReaderStatus",R"#(Status·of·reading·of·a·document.·The·following·values·are·accessible:·-·PCDM_RS_OK:·the·document·was·successfully·read;·-·PCDM_RS_NoDriver:·driver·is·not·found·for·the·defined·file·format;·-·PCDM_RS_UnknownFileDriver:·check·of·the·file·failed·(file·doesn't·exist,·for·example);·-·PCDM_RS_OpenError:·attempt·to·open·the·file·failed;·-·PCDM_RS_NoVersion:·document·version·of·the·file·is·out·of·scope;·-·PCDM_RS_NoSchema:·NOT·USED;·-·PCDM_RS_NoDocument:·document·is·empty·(failed·to·be·read·correctly);·-·PCDM_RS_ExtensionFailure:·NOT·USED;·-·PCDM_RS_WrongStreamMode:·file·is·not·open·for·reading·(a·mistaken·mode);·-·PCDM_RS_FormatFailure:·mistake·in·document·data·structure;·-·PCDM_RS_TypeFailure:·data·type·is·unknown;·-·PCDM_RS_TypeNotFoundInSchema:·data·type·is·not·found·in·schema·(STD·file·format);·-·PCDM_RS_UnrecognizedFileFormat:·document·data·structure·is·wrong·(binary·file·format);·-·PCDM_RS_MakeFailure:·conversion·of·data·from·persistent·to·transient·attributes·failed·(XML·file·format);·-·PCDM_RS_PermissionDenied:·file·can't·be·opened·because·permission·is·denied;·-·PCDM_RS_DriverFailure:·something·went·wrong·(a·general·mistake·of·reading·of·a·document);·-·PCDM_RS_AlreadyRetrievedAndModified:·document·is·already·retrieved·and·modified·in·current·session;·-·PCDM_RS_AlreadyRetrieved:·document·is·already·in·current·session·(already·retrieved);·-·PCDM_RS_UnknownDocument:·file·doesn't·exist·on·disk;·-·PCDM_RS_WrongResource:·wrong·resource·file·(.RetrievalPlugin);·-·PCDM_RS_ReaderException:·no·shape·section·in·the·document·file·(binary·file·format);·-·PCDM_RS_NoModel:·NOT·USED;·-·PCDM_RS_UserBreak:·user·stopped·reading·of·the·document;)#")
78 ········.value("PCDM_RS_OK",PCDM_ReaderStatus::PCDM_RS_OK)88 ········.value("PCDM_RS_OK",PCDM_ReaderStatus::PCDM_RS_OK)
79 ········.value("PCDM_RS_NoDriver",PCDM_ReaderStatus::PCDM_RS_NoDriver)89 ········.value("PCDM_RS_NoDriver",PCDM_ReaderStatus::PCDM_RS_NoDriver)
80 ········.value("PCDM_RS_UnknownFileDriver",PCDM_ReaderStatus::PCDM_RS_UnknownFileDriver)90 ········.value("PCDM_RS_UnknownFileDriver",PCDM_ReaderStatus::PCDM_RS_UnknownFileDriver)
81 ········.value("PCDM_RS_OpenError",PCDM_ReaderStatus::PCDM_RS_OpenError)91 ········.value("PCDM_RS_OpenError",PCDM_ReaderStatus::PCDM_RS_OpenError)
82 ········.value("PCDM_RS_NoVersion",PCDM_ReaderStatus::PCDM_RS_NoVersion)92 ········.value("PCDM_RS_NoVersion",PCDM_ReaderStatus::PCDM_RS_NoVersion)
83 ········.value("PCDM_RS_NoSchema",PCDM_ReaderStatus::PCDM_RS_NoSchema)93 ········.value("PCDM_RS_NoSchema",PCDM_ReaderStatus::PCDM_RS_NoSchema)
Offset 102, 24 lines modifiedOffset 112, 14 lines modified
102 ········.value("PCDM_RS_NoModel",PCDM_ReaderStatus::PCDM_RS_NoModel)112 ········.value("PCDM_RS_NoModel",PCDM_ReaderStatus::PCDM_RS_NoModel)
103 ········.value("PCDM_RS_UserBreak",PCDM_ReaderStatus::PCDM_RS_UserBreak).export_values();113 ········.value("PCDM_RS_UserBreak",PCDM_ReaderStatus::PCDM_RS_UserBreak).export_values();
104 ····py::enum_<PCDM_TypeOfFileDriver>(m,·"PCDM_TypeOfFileDriver",R"#()#")114 ····py::enum_<PCDM_TypeOfFileDriver>(m,·"PCDM_TypeOfFileDriver",R"#()#")
105 ········.value("PCDM_TOFD_File",PCDM_TypeOfFileDriver::PCDM_TOFD_File)115 ········.value("PCDM_TOFD_File",PCDM_TypeOfFileDriver::PCDM_TOFD_File)
106 ········.value("PCDM_TOFD_CmpFile",PCDM_TypeOfFileDriver::PCDM_TOFD_CmpFile)116 ········.value("PCDM_TOFD_CmpFile",PCDM_TypeOfFileDriver::PCDM_TOFD_CmpFile)
107 ········.value("PCDM_TOFD_XmlFile",PCDM_TypeOfFileDriver::PCDM_TOFD_XmlFile)117 ········.value("PCDM_TOFD_XmlFile",PCDM_TypeOfFileDriver::PCDM_TOFD_XmlFile)
108 ········.value("PCDM_TOFD_Unknown",PCDM_TypeOfFileDriver::PCDM_TOFD_Unknown).export_values();118 ········.value("PCDM_TOFD_Unknown",PCDM_TypeOfFileDriver::PCDM_TOFD_Unknown).export_values();
109 ····py::enum_<PCDM_StoreStatus>(m,·"PCDM_StoreStatus",R"#(Status·of·storage·of·a·document·on·disk.·If·it·is·PCDM_SS_OK,·the·document·is·successfully·saved·on·disk.·Else·-·there·is·an·error.)#") 
110 ········.value("PCDM_SS_OK",PCDM_StoreStatus::PCDM_SS_OK) 
111 ········.value("PCDM_SS_DriverFailure",PCDM_StoreStatus::PCDM_SS_DriverFailure) 
112 ········.value("PCDM_SS_WriteFailure",PCDM_StoreStatus::PCDM_SS_WriteFailure) 
113 ········.value("PCDM_SS_Failure",PCDM_StoreStatus::PCDM_SS_Failure) 
114 ········.value("PCDM_SS_Doc_IsNull",PCDM_StoreStatus::PCDM_SS_Doc_IsNull) 
115 ········.value("PCDM_SS_No_Obj",PCDM_StoreStatus::PCDM_SS_No_Obj) 
116 ········.value("PCDM_SS_Info_Section_Error",PCDM_StoreStatus::PCDM_SS_Info_Section_Error) 
117 ········.value("PCDM_SS_UserBreak",PCDM_StoreStatus::PCDM_SS_UserBreak) 
118 ········.value("PCDM_SS_UnrecognizedFormat",PCDM_StoreStatus::PCDM_SS_UnrecognizedFormat).export_values(); 
  
119 //Python·trampoline·classes119 //Python·trampoline·classes
120 ····class·Py_PCDM_ReadWriter·:·public·PCDM_ReadWriter{120 ····class·Py_PCDM_ReadWriter·:·public·PCDM_ReadWriter{
121 ····public:121 ····public:
122 ········using·PCDM_ReadWriter::PCDM_ReadWriter;122 ········using·PCDM_ReadWriter::PCDM_ReadWriter;
  
  
⊟
15.9 KB
./usr/share/libocp/OCP/Prs3d_pre.cpp
Ordering differences only
    
Offset 84, 19 lines modifiedOffset 84, 49 lines modified
84 py::module·m·=·main_module.def_submodule("Prs3d",·R"#()#");84 py::module·m·=·main_module.def_submodule("Prs3d",·R"#()#");
  
85 //·add·namespaces·as·submodules85 //·add·namespaces·as·submodules
  
86 //·user-defined·inclusion·per·module·in·the·body86 //·user-defined·inclusion·per·module·in·the·body
  
87 //·enums87 //·enums
88 ····py::enum_<Prs3d_DimensionTextHorizontalPosition>(m,·"Prs3d_DimensionTextHorizontalPosition",R"#(Specifies·options·for·positioning·dimension·value·label·in·horizontal·direction.·DTHP_Left·-·value·label·located·at·left·side·on·dimension·extension.·DTHP_Right·-·value·label·located·at·right·side·on·dimension·extension.·DTHP_Center·-·value·label·located·at·center·of·dimension·line.·DTHP_Fit·-·value·label·located·automatically·at·left·side·if·does·not·fits·the·dimension·space,·otherwise·the·value·label·is·placed·at·center.)#") 
89 ········.value("Prs3d_DTHP_Left",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Left) 
90 ········.value("Prs3d_DTHP_Right",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Right) 
91 ········.value("Prs3d_DTHP_Center",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Center) 
92 ········.value("Prs3d_DTHP_Fit",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Fit).export_values();88 ····py::enum_<Prs3d_TypeOfLinePicking>(m,·"Prs3d_TypeOfLinePicking",R"#()#")
 89 ········.value("Prs3d_TOLP_Point",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Point)
 90 ········.value("Prs3d_TOLP_Segment",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Segment).export_values();
 91 ····py::enum_<Prs3d_DatumParts>(m,·"Prs3d_DatumParts",R"#(Enumeration·defining·a·part·of·datum·aspect,·see·Prs3d_Datum.)#")
 92 ········.value("Prs3d_DatumParts_Origin",Prs3d_DatumParts::Prs3d_DatumParts_Origin)
 93 ········.value("Prs3d_DatumParts_XAxis",Prs3d_DatumParts::Prs3d_DatumParts_XAxis)
 94 ········.value("Prs3d_DatumParts_YAxis",Prs3d_DatumParts::Prs3d_DatumParts_YAxis)
 95 ········.value("Prs3d_DatumParts_ZAxis",Prs3d_DatumParts::Prs3d_DatumParts_ZAxis)
 96 ········.value("Prs3d_DatumParts_XArrow",Prs3d_DatumParts::Prs3d_DatumParts_XArrow)
 97 ········.value("Prs3d_DatumParts_YArrow",Prs3d_DatumParts::Prs3d_DatumParts_YArrow)
 98 ········.value("Prs3d_DatumParts_ZArrow",Prs3d_DatumParts::Prs3d_DatumParts_ZArrow)
 99 ········.value("Prs3d_DatumParts_XOYAxis",Prs3d_DatumParts::Prs3d_DatumParts_XOYAxis)
 100 ········.value("Prs3d_DatumParts_YOZAxis",Prs3d_DatumParts::Prs3d_DatumParts_YOZAxis)
 101 ········.value("Prs3d_DatumParts_XOZAxis",Prs3d_DatumParts::Prs3d_DatumParts_XOZAxis)
 102 ········.value("Prs3d_DatumParts_None",Prs3d_DatumParts::Prs3d_DatumParts_None)
 103 ········.value("Prs3d_DP_Origin",Prs3d_DatumParts::Prs3d_DP_Origin)
 104 ········.value("Prs3d_DP_XAxis",Prs3d_DatumParts::Prs3d_DP_XAxis)
 105 ········.value("Prs3d_DP_YAxis",Prs3d_DatumParts::Prs3d_DP_YAxis)
 106 ········.value("Prs3d_DP_ZAxis",Prs3d_DatumParts::Prs3d_DP_ZAxis)
 107 ········.value("Prs3d_DP_XArrow",Prs3d_DatumParts::Prs3d_DP_XArrow)
 108 ········.value("Prs3d_DP_YArrow",Prs3d_DatumParts::Prs3d_DP_YArrow)
 109 ········.value("Prs3d_DP_ZArrow",Prs3d_DatumParts::Prs3d_DP_ZArrow)
 110 ········.value("Prs3d_DP_XOYAxis",Prs3d_DatumParts::Prs3d_DP_XOYAxis)
 111 ········.value("Prs3d_DP_YOZAxis",Prs3d_DatumParts::Prs3d_DP_YOZAxis)
 112 ········.value("Prs3d_DP_XOZAxis",Prs3d_DatumParts::Prs3d_DP_XOZAxis)
 113 ········.value("Prs3d_DP_None",Prs3d_DatumParts::Prs3d_DP_None).export_values();
 114 ····m.attr("Prs3d_DatumParts_NB")·=·py::cast(int(Prs3d_DatumParts_NB));
 115 ····py::enum_<Prs3d_TypeOfHighlight>(m,·"Prs3d_TypeOfHighlight",R"#(Type·of·highlighting·to·apply·specific·style.)#")
 116 ········.value("Prs3d_TypeOfHighlight_None",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_None)
 117 ········.value("Prs3d_TypeOfHighlight_Selected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Selected)
 118 ········.value("Prs3d_TypeOfHighlight_Dynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Dynamic)
 119 ········.value("Prs3d_TypeOfHighlight_LocalSelected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalSelected)
 120 ········.value("Prs3d_TypeOfHighlight_LocalDynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalDynamic)
 121 ········.value("Prs3d_TypeOfHighlight_SubIntensity",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_SubIntensity)
 122 ········.value("Prs3d_TypeOfHighlight_NB",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_NB).export_values();
93 ····py::enum_<Prs3d_DatumAxes>(m,·"Prs3d_DatumAxes",R"#(Enumeration·defining·axes·used·in·datum·aspect,·see·Prs3d_Datum.)#")123 ····py::enum_<Prs3d_DatumAxes>(m,·"Prs3d_DatumAxes",R"#(Enumeration·defining·axes·used·in·datum·aspect,·see·Prs3d_Datum.)#")
94 ········.value("Prs3d_DatumAxes_XAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_XAxis)124 ········.value("Prs3d_DatumAxes_XAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_XAxis)
95 ········.value("Prs3d_DatumAxes_YAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_YAxis)125 ········.value("Prs3d_DatumAxes_YAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_YAxis)
96 ········.value("Prs3d_DatumAxes_ZAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_ZAxis)126 ········.value("Prs3d_DatumAxes_ZAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_ZAxis)
97 ········.value("Prs3d_DatumAxes_XYAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XYAxes)127 ········.value("Prs3d_DatumAxes_XYAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XYAxes)
98 ········.value("Prs3d_DatumAxes_YZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_YZAxes)128 ········.value("Prs3d_DatumAxes_YZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_YZAxes)
99 ········.value("Prs3d_DatumAxes_XZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XZAxes)129 ········.value("Prs3d_DatumAxes_XZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XZAxes)
Offset 104, 44 lines modifiedOffset 134, 18 lines modified
104 ········.value("Prs3d_DA_XAxis",Prs3d_DatumAxes::Prs3d_DA_XAxis)134 ········.value("Prs3d_DA_XAxis",Prs3d_DatumAxes::Prs3d_DA_XAxis)
105 ········.value("Prs3d_DA_YAxis",Prs3d_DatumAxes::Prs3d_DA_YAxis)135 ········.value("Prs3d_DA_YAxis",Prs3d_DatumAxes::Prs3d_DA_YAxis)
106 ········.value("Prs3d_DA_ZAxis",Prs3d_DatumAxes::Prs3d_DA_ZAxis)136 ········.value("Prs3d_DA_ZAxis",Prs3d_DatumAxes::Prs3d_DA_ZAxis)
107 ········.value("Prs3d_DA_XYAxis",Prs3d_DatumAxes::Prs3d_DA_XYAxis)137 ········.value("Prs3d_DA_XYAxis",Prs3d_DatumAxes::Prs3d_DA_XYAxis)
108 ········.value("Prs3d_DA_YZAxis",Prs3d_DatumAxes::Prs3d_DA_YZAxis)138 ········.value("Prs3d_DA_YZAxis",Prs3d_DatumAxes::Prs3d_DA_YZAxis)
109 ········.value("Prs3d_DA_XZAxis",Prs3d_DatumAxes::Prs3d_DA_XZAxis)139 ········.value("Prs3d_DA_XZAxis",Prs3d_DatumAxes::Prs3d_DA_XZAxis)
110 ········.value("Prs3d_DA_XYZAxis",Prs3d_DatumAxes::Prs3d_DA_XYZAxis).export_values();140 ········.value("Prs3d_DA_XYZAxis",Prs3d_DatumAxes::Prs3d_DA_XYZAxis).export_values();
111 ····py::enum_<Prs3d_TypeOfLinePicking>(m,·"Prs3d_TypeOfLinePicking",R"#()#") 
112 ········.value("Prs3d_TOLP_Point",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Point) 
113 ········.value("Prs3d_TOLP_Segment",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Segment).export_values(); 
114 ····py::enum_<Prs3d_DimensionTextVerticalPosition>(m,·"Prs3d_DimensionTextVerticalPosition",R"#(Specifies·options·for·positioning·dimension·value·label·in·vertical·direction·with·respect·to·dimension·(extension)·line.·DTVP_Above·-·text·label·is·located·above·the·dimension·or·extension·line.·DTVP_Below·-·text·label·is·located·below·the·dimension·or·extension·line.·DTVP_Center·-·the·text·label·middle-point·is·in·line·with·dimension·or·extension·line.)#") 
115 ········.value("Prs3d_DTVP_Above",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Above) 
116 ········.value("Prs3d_DTVP_Below",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Below) 
117 ········.value("Prs3d_DTVP_Center",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Center).export_values(); 
118 ····py::enum_<Prs3d_DatumMode>(m,·"Prs3d_DatumMode",R"#(Enumeration·defining·a·mode·of·datum·graphic·presentation,·see·Prs3d_Datum.)#") 
119 ········.value("Prs3d_DM_WireFrame",Prs3d_DatumMode::Prs3d_DM_WireFrame) 
120 ········.value("Prs3d_DM_Shaded",Prs3d_DatumMode::Prs3d_DM_Shaded).export_values(); 
121 ····py::enum_<Prs3d_TypeOfHLR>(m,·"Prs3d_TypeOfHLR",R"#(Declares·types·of·hidden·line·removal·algorithm.·TOH_Algo·enables·using·of·exact·HLR·algorithm.·TOH_PolyAlgo·enables·using·of·polygonal·HLR·algorithm.·TOH_NotSet·is·used·by·Prs3d_Drawer·class,·it·means·that·the·drawer·should·return·the·global·value.·For·more·details·see·Prs3d_Drawer·class,·AIS_Shape::Compute()·method·and·HLRAlgo·package·from·TKHLR·toolkit.)#") 
122 ········.value("Prs3d_TOH_NotSet",Prs3d_TypeOfHLR::Prs3d_TOH_NotSet) 
123 ········.value("Prs3d_TOH_PolyAlgo",Prs3d_TypeOfHLR::Prs3d_TOH_PolyAlgo) 
124 ········.value("Prs3d_TOH_Algo",Prs3d_TypeOfHLR::Prs3d_TOH_Algo).export_values(); 
125 ····py::enum_<Prs3d_TypeOfHighlight>(m,·"Prs3d_TypeOfHighlight",R"#(Type·of·highlighting·to·apply·specific·style.)#") 
126 ········.value("Prs3d_TypeOfHighlight_None",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_None) 
127 ········.value("Prs3d_TypeOfHighlight_Selected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Selected) 
128 ········.value("Prs3d_TypeOfHighlight_Dynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Dynamic) 
129 ········.value("Prs3d_TypeOfHighlight_LocalSelected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalSelected) 
130 ········.value("Prs3d_TypeOfHighlight_LocalDynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalDynamic) 
131 ········.value("Prs3d_TypeOfHighlight_SubIntensity",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_SubIntensity) 
132 ········.value("Prs3d_TypeOfHighlight_NB",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_NB).export_values(); 
133 ····py::enum_<Prs3d_DimensionArrowOrientation>(m,·"Prs3d_DimensionArrowOrientation",R"#(Specifies·dimension·arrow·location·and·orientation.·DAO_Internal·-·arrows·"inside",·pointing·outwards.·DAO_External·-·arrows·"outside",·pointing·inwards.·DAO_Fit·-·arrows·oriented·inside·if·value·label·with·arrowtips·fit·the·dimension·line,·otherwise·-·externally)#")141 ····py::enum_<Prs3d_DimensionArrowOrientation>(m,·"Prs3d_DimensionArrowOrientation",R"#(Specifies·dimension·arrow·location·and·orientation.·DAO_Internal·-·arrows·"inside",·pointing·outwards.·DAO_External·-·arrows·"outside",·pointing·inwards.·DAO_Fit·-·arrows·oriented·inside·if·value·label·with·arrowtips·fit·the·dimension·line,·otherwise·-·externally)#")
134 ········.value("Prs3d_DAO_Internal",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Internal)142 ········.value("Prs3d_DAO_Internal",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Internal)
135 ········.value("Prs3d_DAO_External",Prs3d_DimensionArrowOrientation::Prs3d_DAO_External)143 ········.value("Prs3d_DAO_External",Prs3d_DimensionArrowOrientation::Prs3d_DAO_External)
136 ········.value("Prs3d_DAO_Fit",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Fit).export_values();144 ········.value("Prs3d_DAO_Fit",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Fit).export_values();
137 ····py::enum_<Prs3d_VertexDrawMode>(m,·"Prs3d_VertexDrawMode",R"#(Describes·supported·modes·of·visualization·of·the·shape's·vertices:·VDM_Isolated·-·only·isolated·vertices·(not·belonging·to·a·face)·are·displayed.·VDM_All·-·all·vertices·of·the·shape·are·displayed.·VDM_Inherited·-·the·global·settings·are·inherited·and·applied·to·the·shape's·presentation.)#") 
138 ········.value("Prs3d_VDM_Isolated",Prs3d_VertexDrawMode::Prs3d_VDM_Isolated) 
139 ········.value("Prs3d_VDM_All",Prs3d_VertexDrawMode::Prs3d_VDM_All) 
140 ········.value("Prs3d_VDM_Inherited",Prs3d_VertexDrawMode::Prs3d_VDM_Inherited).export_values(); 
141 ····py::enum_<Prs3d_DatumAttribute>(m,·"Prs3d_DatumAttribute",R"#(Enumeration·defining·a·datum·attribute,·see·Prs3d_Datum.)#")145 ····py::enum_<Prs3d_DatumAttribute>(m,·"Prs3d_DatumAttribute",R"#(Enumeration·defining·a·datum·attribute,·see·Prs3d_Datum.)#")
142 ········.value("Prs3d_DatumAttribute_XAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_XAxisLength)146 ········.value("Prs3d_DatumAttribute_XAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_XAxisLength)
143 ········.value("Prs3d_DatumAttribute_YAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_YAxisLength)147 ········.value("Prs3d_DatumAttribute_YAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_YAxisLength)
144 ········.value("Prs3d_DatumAttribute_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ZAxisLength)148 ········.value("Prs3d_DatumAttribute_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ZAxisLength)
145 ········.value("Prs3d_DatumAttribute_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingTubeRadiusPercent)149 ········.value("Prs3d_DatumAttribute_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingTubeRadiusPercent)
146 ········.value("Prs3d_DatumAttribute_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeRadiusPercent)150 ········.value("Prs3d_DatumAttribute_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeRadiusPercent)
147 ········.value("Prs3d_DatumAttribute_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeLengthPercent)151 ········.value("Prs3d_DatumAttribute_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeLengthPercent)
Offset 152, 38 lines modifiedOffset 156, 34 lines modified
152 ········.value("Prs3d_DA_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DA_ZAxisLength)156 ········.value("Prs3d_DA_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DA_ZAxisLength)
153 ········.value("Prs3d_DP_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingTubeRadiusPercent)157 ········.value("Prs3d_DP_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingTubeRadiusPercent)
154 ········.value("Prs3d_DP_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeRadiusPercent)158 ········.value("Prs3d_DP_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeRadiusPercent)
155 ········.value("Prs3d_DP_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeLengthPercent)159 ········.value("Prs3d_DP_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeLengthPercent)
156 ········.value("Prs3d_DP_ShadingOriginRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingOriginRadiusPercent)160 ········.value("Prs3d_DP_ShadingOriginRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingOriginRadiusPercent)
157 ········.value("Prs3d_DP_ShadingNumberOfFacettes",Prs3d_DatumAttribute::Prs3d_DP_ShadingNumberOfFacettes).export_values();161 ········.value("Prs3d_DP_ShadingNumberOfFacettes",Prs3d_DatumAttribute::Prs3d_DP_ShadingNumberOfFacettes).export_values();
158 ····m.attr("Prs3d_DatumAttribute_NB")·=·py::cast(int(Prs3d_DatumAttribute_NB));162 ····m.attr("Prs3d_DatumAttribute_NB")·=·py::cast(int(Prs3d_DatumAttribute_NB));
 163 ····py::enum_<Prs3d_DimensionTextVerticalPosition>(m,·"Prs3d_DimensionTextVerticalPosition",R"#(Specifies·options·for·positioning·dimension·value·label·in·vertical·direction·with·respect·to·dimension·(extension)·line.·DTVP_Above·-·text·label·is·located·above·the·dimension·or·extension·line.·DTVP_Below·-·text·label·is·located·below·the·dimension·or·extension·line.·DTVP_Center·-·the·text·label·middle-point·is·in·line·with·dimension·or·extension·line.)#")
 164 ········.value("Prs3d_DTVP_Above",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Above)
 165 ········.value("Prs3d_DTVP_Below",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Below)
 166 ········.value("Prs3d_DTVP_Center",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Center).export_values();
 167 ····py::enum_<Prs3d_TypeOfHLR>(m,·"Prs3d_TypeOfHLR",R"#(Declares·types·of·hidden·line·removal·algorithm.·TOH_Algo·enables·using·of·exact·HLR·algorithm.·TOH_PolyAlgo·enables·using·of·polygonal·HLR·algorithm.·TOH_NotSet·is·used·by·Prs3d_Drawer·class,·it·means·that·the·drawer·should·return·the·global·value.·For·more·details·see·Prs3d_Drawer·class,·AIS_Shape::Compute()·method·and·HLRAlgo·package·from·TKHLR·toolkit.)#")
 168 ········.value("Prs3d_TOH_NotSet",Prs3d_TypeOfHLR::Prs3d_TOH_NotSet)
 169 ········.value("Prs3d_TOH_PolyAlgo",Prs3d_TypeOfHLR::Prs3d_TOH_PolyAlgo)
 170 ········.value("Prs3d_TOH_Algo",Prs3d_TypeOfHLR::Prs3d_TOH_Algo).export_values();
 171 ····py::enum_<Prs3d_DimensionTextHorizontalPosition>(m,·"Prs3d_DimensionTextHorizontalPosition",R"#(Specifies·options·for·positioning·dimension·value·label·in·horizontal·direction.·DTHP_Left·-·value·label·located·at·left·side·on·dimension·extension.·DTHP_Right·-·value·label·located·at·right·side·on·dimension·extension.·DTHP_Center·-·value·label·located·at·center·of·dimension·line.·DTHP_Fit·-·value·label·located·automatically·at·left·side·if·does·not·fits·the·dimension·space,·otherwise·the·value·label·is·placed·at·center.)#")
 172 ········.value("Prs3d_DTHP_Left",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Left)
 173 ········.value("Prs3d_DTHP_Right",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Right)
 174 ········.value("Prs3d_DTHP_Center",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Center)
 175 ········.value("Prs3d_DTHP_Fit",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Fit).export_values();
 176 ····py::enum_<Prs3d_VertexDrawMode>(m,·"Prs3d_VertexDrawMode",R"#(Describes·supported·modes·of·visualization·of·the·shape's·vertices:·VDM_Isolated·-·only·isolated·vertices·(not·belonging·to·a·face)·are·displayed.·VDM_All·-·all·vertices·of·the·shape·are·displayed.·VDM_Inherited·-·the·global·settings·are·inherited·and·applied·to·the·shape's·presentation.)#")
 177 ········.value("Prs3d_VDM_Isolated",Prs3d_VertexDrawMode::Prs3d_VDM_Isolated)
 178 ········.value("Prs3d_VDM_All",Prs3d_VertexDrawMode::Prs3d_VDM_All)
 179 ········.value("Prs3d_VDM_Inherited",Prs3d_VertexDrawMode::Prs3d_VDM_Inherited).export_values();
159 ····py::enum_<Prs3d_DatumParts>(m,·"Prs3d_DatumParts",R"#(Enumeration·defining·a·part·of·datum·aspect,·see·Prs3d_Datum.)#")180 ····py::enum_<Prs3d_DatumMode>(m,·"Prs3d_DatumMode",R"#(Enumeration·defining·a·mode·of·datum·graphic·presentation,·see·Prs3d_Datum.)#")
 181 ········.value("Prs3d_DM_WireFrame",Prs3d_DatumMode::Prs3d_DM_WireFrame)
160 ········.value("Prs3d_DatumParts_Origin",Prs3d_DatumParts::Prs3d_DatumParts_Origin) 
161 ········.value("Prs3d_DatumParts_XAxis",Prs3d_DatumParts::Prs3d_DatumParts_XAxis) 
Max diff block lines reached; 159/16162 bytes (0.98%) of diff not shown.
⊟
1.71 KB
./usr/share/libocp/OCP/PrsMgr_pre.cpp
Ordering differences only
    
Offset 56, 24 lines modifiedOffset 56, 24 lines modified
56 py::module·m·=·main_module.def_submodule("PrsMgr",·R"#()#");56 py::module·m·=·main_module.def_submodule("PrsMgr",·R"#()#");
  
57 //·add·namespaces·as·submodules57 //·add·namespaces·as·submodules
  
58 //·user-defined·inclusion·per·module·in·the·body58 //·user-defined·inclusion·per·module·in·the·body
  
59 //·enums59 //·enums
60 ····py::enum_<PrsMgr_TypeOfPresentation3d>(m,·"PrsMgr_TypeOfPresentation3d",R"#(The·type·of·presentation.)#") 
61 ········.value("PrsMgr_TOP_AllView",PrsMgr_TypeOfPresentation3d::PrsMgr_TOP_AllView) 
62 ········.value("PrsMgr_TOP_ProjectorDependent",PrsMgr_TypeOfPresentation3d::PrsMgr_TOP_ProjectorDependent).export_values(); 
63 ····py::enum_<PrsMgr_DisplayStatus>(m,·"PrsMgr_DisplayStatus",R"#(To·give·the·display·status·of·an·Interactive·Object.)#")60 ····py::enum_<PrsMgr_DisplayStatus>(m,·"PrsMgr_DisplayStatus",R"#(To·give·the·display·status·of·an·Interactive·Object.)#")
64 ········.value("PrsMgr_DisplayStatus_Displayed",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Displayed)61 ········.value("PrsMgr_DisplayStatus_Displayed",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Displayed)
65 ········.value("PrsMgr_DisplayStatus_Erased",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Erased)62 ········.value("PrsMgr_DisplayStatus_Erased",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Erased)
66 ········.value("PrsMgr_DisplayStatus_None",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_None)63 ········.value("PrsMgr_DisplayStatus_None",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_None)
67 ········.value("AIS_DS_Displayed",PrsMgr_DisplayStatus::AIS_DS_Displayed)64 ········.value("AIS_DS_Displayed",PrsMgr_DisplayStatus::AIS_DS_Displayed)
68 ········.value("AIS_DS_Erased",PrsMgr_DisplayStatus::AIS_DS_Erased)65 ········.value("AIS_DS_Erased",PrsMgr_DisplayStatus::AIS_DS_Erased)
69 ········.value("AIS_DS_None",PrsMgr_DisplayStatus::AIS_DS_None).export_values();66 ········.value("AIS_DS_None",PrsMgr_DisplayStatus::AIS_DS_None).export_values();
 67 ····py::enum_<PrsMgr_TypeOfPresentation3d>(m,·"PrsMgr_TypeOfPresentation3d",R"#(The·type·of·presentation.)#")
 68 ········.value("PrsMgr_TOP_AllView",PrsMgr_TypeOfPresentation3d::PrsMgr_TOP_AllView)
 69 ········.value("PrsMgr_TOP_ProjectorDependent",PrsMgr_TypeOfPresentation3d::PrsMgr_TOP_ProjectorDependent).export_values();
  
70 //Python·trampoline·classes70 //Python·trampoline·classes
71 ····class·Py_PrsMgr_PresentableObject·:·public·PrsMgr_PresentableObject{71 ····class·Py_PrsMgr_PresentableObject·:·public·PrsMgr_PresentableObject{
72 ····public:72 ····public:
73 ········using·PrsMgr_PresentableObject::PrsMgr_PresentableObject;73 ········using·PrsMgr_PresentableObject::PrsMgr_PresentableObject;
  
  
⊟
3.47 KB
./usr/share/libocp/OCP/Quantity_pre.cpp
Ordering differences only
    
Offset 44, 20 lines modifiedOffset 44, 14 lines modified
  
44 //·add·namespaces·as·submodules44 //·add·namespaces·as·submodules
45 m.def_submodule("std");45 m.def_submodule("std");
  
46 //·user-defined·inclusion·per·module·in·the·body46 //·user-defined·inclusion·per·module·in·the·body
  
47 //·enums47 //·enums
48 ····py::enum_<Quantity_TypeOfColor>(m,·"Quantity_TypeOfColor",R"#(Identifies·color·definition·systems.)#") 
49 ········.value("Quantity_TOC_RGB",Quantity_TypeOfColor::Quantity_TOC_RGB) 
50 ········.value("Quantity_TOC_sRGB",Quantity_TypeOfColor::Quantity_TOC_sRGB) 
51 ········.value("Quantity_TOC_HLS",Quantity_TypeOfColor::Quantity_TOC_HLS) 
52 ········.value("Quantity_TOC_CIELab",Quantity_TypeOfColor::Quantity_TOC_CIELab) 
53 ········.value("Quantity_TOC_CIELch",Quantity_TypeOfColor::Quantity_TOC_CIELch).export_values(); 
54 ····py::enum_<Quantity_NameOfColor>(m,·"Quantity_NameOfColor",R"#(Definition·of·names·of·known·colors.·The·names·come·(mostly)·from·the·X11·specification.)#")48 ····py::enum_<Quantity_NameOfColor>(m,·"Quantity_NameOfColor",R"#(Definition·of·names·of·known·colors.·The·names·come·(mostly)·from·the·X11·specification.)#")
55 ········.value("Quantity_NOC_BLACK",Quantity_NameOfColor::Quantity_NOC_BLACK)49 ········.value("Quantity_NOC_BLACK",Quantity_NameOfColor::Quantity_NOC_BLACK)
56 ········.value("Quantity_NOC_MATRABLUE",Quantity_NameOfColor::Quantity_NOC_MATRABLUE)50 ········.value("Quantity_NOC_MATRABLUE",Quantity_NameOfColor::Quantity_NOC_MATRABLUE)
57 ········.value("Quantity_NOC_MATRAGRAY",Quantity_NameOfColor::Quantity_NOC_MATRAGRAY)51 ········.value("Quantity_NOC_MATRAGRAY",Quantity_NameOfColor::Quantity_NOC_MATRAGRAY)
58 ········.value("Quantity_NOC_ALICEBLUE",Quantity_NameOfColor::Quantity_NOC_ALICEBLUE)52 ········.value("Quantity_NOC_ALICEBLUE",Quantity_NameOfColor::Quantity_NOC_ALICEBLUE)
59 ········.value("Quantity_NOC_ANTIQUEWHITE",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE)53 ········.value("Quantity_NOC_ANTIQUEWHITE",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE)
60 ········.value("Quantity_NOC_ANTIQUEWHITE1",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE1)54 ········.value("Quantity_NOC_ANTIQUEWHITE1",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE1)
Offset 572, 14 lines modifiedOffset 566, 20 lines modified
572 ········.value("Quantity_NOC_YELLOW",Quantity_NameOfColor::Quantity_NOC_YELLOW)566 ········.value("Quantity_NOC_YELLOW",Quantity_NameOfColor::Quantity_NOC_YELLOW)
573 ········.value("Quantity_NOC_YELLOW1",Quantity_NameOfColor::Quantity_NOC_YELLOW1)567 ········.value("Quantity_NOC_YELLOW1",Quantity_NameOfColor::Quantity_NOC_YELLOW1)
574 ········.value("Quantity_NOC_YELLOW2",Quantity_NameOfColor::Quantity_NOC_YELLOW2)568 ········.value("Quantity_NOC_YELLOW2",Quantity_NameOfColor::Quantity_NOC_YELLOW2)
575 ········.value("Quantity_NOC_YELLOW3",Quantity_NameOfColor::Quantity_NOC_YELLOW3)569 ········.value("Quantity_NOC_YELLOW3",Quantity_NameOfColor::Quantity_NOC_YELLOW3)
576 ········.value("Quantity_NOC_YELLOW4",Quantity_NameOfColor::Quantity_NOC_YELLOW4)570 ········.value("Quantity_NOC_YELLOW4",Quantity_NameOfColor::Quantity_NOC_YELLOW4)
577 ········.value("Quantity_NOC_YELLOWGREEN",Quantity_NameOfColor::Quantity_NOC_YELLOWGREEN)571 ········.value("Quantity_NOC_YELLOWGREEN",Quantity_NameOfColor::Quantity_NOC_YELLOWGREEN)
578 ········.value("Quantity_NOC_WHITE",Quantity_NameOfColor::Quantity_NOC_WHITE).export_values();572 ········.value("Quantity_NOC_WHITE",Quantity_NameOfColor::Quantity_NOC_WHITE).export_values();
 573 ····py::enum_<Quantity_TypeOfColor>(m,·"Quantity_TypeOfColor",R"#(Identifies·color·definition·systems.)#")
 574 ········.value("Quantity_TOC_RGB",Quantity_TypeOfColor::Quantity_TOC_RGB)
 575 ········.value("Quantity_TOC_sRGB",Quantity_TypeOfColor::Quantity_TOC_sRGB)
 576 ········.value("Quantity_TOC_HLS",Quantity_TypeOfColor::Quantity_TOC_HLS)
 577 ········.value("Quantity_TOC_CIELab",Quantity_TypeOfColor::Quantity_TOC_CIELab)
 578 ········.value("Quantity_TOC_CIELch",Quantity_TypeOfColor::Quantity_TOC_CIELch).export_values();
  
579 //Python·trampoline·classes579 //Python·trampoline·classes
  
580 //·pre-register·typdefs+classes·(topologically·sorted)580 //·pre-register·typdefs+classes·(topologically·sorted)
581 ····py::class_<Quantity_Color·,·shared_ptr<Quantity_Color>··>(m,"Quantity_Color",R"#(This·class·allows·the·definition·of·an·RGB·color·as·triplet·of·3·normalized·floating·point·values·(red,·green,·blue).)#");581 ····py::class_<Quantity_Color·,·shared_ptr<Quantity_Color>··>(m,"Quantity_Color",R"#(This·class·allows·the·definition·of·an·RGB·color·as·triplet·of·3·normalized·floating·point·values·(red,·green,·blue).)#");
582 ····py::class_<Quantity_ColorRGBA·,·shared_ptr<Quantity_ColorRGBA>··>(m,"Quantity_ColorRGBA",R"#(The·pair·of·Quantity_Color·and·Alpha·component·(1.0·opaque,·0.0·transparent).)#");582 ····py::class_<Quantity_ColorRGBA·,·shared_ptr<Quantity_ColorRGBA>··>(m,"Quantity_ColorRGBA",R"#(The·pair·of·Quantity_Color·and·Alpha·component·(1.0·opaque,·0.0·transparent).)#");
583 ····py::class_<Quantity_Date·,·shared_ptr<Quantity_Date>··>(m,"Quantity_Date",R"#(This·class·provides·services·to·manage·date·information.·A·date·represents·the·following·time·intervals:·year,·month,·day,·hour,·minute,·second,·millisecond·and·microsecond.·Current·time·is·expressed·in·elapsed·seconds·and·microseconds·beginning·from·00:00·GMT,·January·1,·1979·(zero·hour).·The·valid·date·can·only·be·later·than·this·one.·Note:·a·Period·object·gives·the·interval·between·two·dates.)#");583 ····py::class_<Quantity_Date·,·shared_ptr<Quantity_Date>··>(m,"Quantity_Date",R"#(This·class·provides·services·to·manage·date·information.·A·date·represents·the·following·time·intervals:·year,·month,·day,·hour,·minute,·second,·millisecond·and·microsecond.·Current·time·is·expressed·in·elapsed·seconds·and·microseconds·beginning·from·00:00·GMT,·January·1,·1979·(zero·hour).·The·valid·date·can·only·be·later·than·this·one.·Note:·a·Period·object·gives·the·interval·between·two·dates.)#");
⊟
6.46 KB
./usr/share/libocp/OCP/SelectMgr_pre.cpp
Ordering differences only
    
Offset 107, 44 lines modifiedOffset 107, 44 lines modified
  
107 //·add·namespaces·as·submodules107 //·add·namespaces·as·submodules
108 m.def_submodule("SelectMgr_MatOp");108 m.def_submodule("SelectMgr_MatOp");
  
109 //·user-defined·inclusion·per·module·in·the·body109 //·user-defined·inclusion·per·module·in·the·body
  
110 //·enums110 //·enums
111 ····py::enum_<SelectMgr_TypeOfUpdate>(m,·"SelectMgr_TypeOfUpdate",R"#(Provides·values·for·types·of·update,·including·-·full·-·partial·-·none.)#") 
112 ········.value("SelectMgr_TOU_Full",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Full) 
113 ········.value("SelectMgr_TOU_Partial",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Partial) 
114 ········.value("SelectMgr_TOU_None",SelectMgr_TypeOfUpdate::SelectMgr_TOU_None).export_values();111 ····py::enum_<SelectMgr_PickingStrategy>(m,·"SelectMgr_PickingStrategy",R"#(Enumeration·defines·picking·strategy·-·which·entities·detected·by·picking·line·will·be·accepted,·considering·selection·filters.)#")
 112 ········.value("SelectMgr_PickingStrategy_FirstAcceptable",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_FirstAcceptable)
 113 ········.value("SelectMgr_PickingStrategy_OnlyTopmost",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_OnlyTopmost).export_values();
 114 ····py::enum_<SelectMgr_TypeOfDepthTolerance>(m,·"SelectMgr_TypeOfDepthTolerance",R"#(Define·the·type·of·depth·tolerance·for·considering·picked·entities·to·lie·on·the·same·depth·(distance·from·eye·to·entity).)#")
 115 ········.value("SelectMgr_TypeOfDepthTolerance_Uniform",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_Uniform)
 116 ········.value("SelectMgr_TypeOfDepthTolerance_UniformPixels",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_UniformPixels)
 117 ········.value("SelectMgr_TypeOfDepthTolerance_SensitivityFactor",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_SensitivityFactor).export_values();
115 ····py::enum_<SelectMgr_StateOfSelection>(m,·"SelectMgr_StateOfSelection",R"#(different·state·of·a·Selection·in·a·ViewerSelector...)#")118 ····py::enum_<SelectMgr_StateOfSelection>(m,·"SelectMgr_StateOfSelection",R"#(different·state·of·a·Selection·in·a·ViewerSelector...)#")
116 ········.value("SelectMgr_SOS_Any",SelectMgr_StateOfSelection::SelectMgr_SOS_Any)119 ········.value("SelectMgr_SOS_Any",SelectMgr_StateOfSelection::SelectMgr_SOS_Any)
117 ········.value("SelectMgr_SOS_Unknown",SelectMgr_StateOfSelection::SelectMgr_SOS_Unknown)120 ········.value("SelectMgr_SOS_Unknown",SelectMgr_StateOfSelection::SelectMgr_SOS_Unknown)
118 ········.value("SelectMgr_SOS_Deactivated",SelectMgr_StateOfSelection::SelectMgr_SOS_Deactivated)121 ········.value("SelectMgr_SOS_Deactivated",SelectMgr_StateOfSelection::SelectMgr_SOS_Deactivated)
119 ········.value("SelectMgr_SOS_Activated",SelectMgr_StateOfSelection::SelectMgr_SOS_Activated).export_values();122 ········.value("SelectMgr_SOS_Activated",SelectMgr_StateOfSelection::SelectMgr_SOS_Activated).export_values();
 123 ····py::enum_<SelectMgr_SelectionType>(m,·"SelectMgr_SelectionType",R"#(Possible·selection·types)#")
 124 ········.value("SelectMgr_SelectionType_Unknown",SelectMgr_SelectionType::SelectMgr_SelectionType_Unknown)
 125 ········.value("SelectMgr_SelectionType_Point",SelectMgr_SelectionType::SelectMgr_SelectionType_Point)
 126 ········.value("SelectMgr_SelectionType_Box",SelectMgr_SelectionType::SelectMgr_SelectionType_Box)
 127 ········.value("SelectMgr_SelectionType_Polyline",SelectMgr_SelectionType::SelectMgr_SelectionType_Polyline).export_values();
120 ····py::enum_<SelectMgr_FilterType>(m,·"SelectMgr_FilterType",R"#(Enumeration·defines·the·filter·type.)#")128 ····py::enum_<SelectMgr_FilterType>(m,·"SelectMgr_FilterType",R"#(Enumeration·defines·the·filter·type.)#")
121 ········.value("SelectMgr_FilterType_AND",SelectMgr_FilterType::SelectMgr_FilterType_AND)129 ········.value("SelectMgr_FilterType_AND",SelectMgr_FilterType::SelectMgr_FilterType_AND)
122 ········.value("SelectMgr_FilterType_OR",SelectMgr_FilterType::SelectMgr_FilterType_OR).export_values();130 ········.value("SelectMgr_FilterType_OR",SelectMgr_FilterType::SelectMgr_FilterType_OR).export_values();
 131 ····py::enum_<SelectMgr_TypeOfUpdate>(m,·"SelectMgr_TypeOfUpdate",R"#(Provides·values·for·types·of·update,·including·-·full·-·partial·-·none.)#")
 132 ········.value("SelectMgr_TOU_Full",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Full)
 133 ········.value("SelectMgr_TOU_Partial",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Partial)
 134 ········.value("SelectMgr_TOU_None",SelectMgr_TypeOfUpdate::SelectMgr_TOU_None).export_values();
123 ····py::enum_<SelectMgr_TypeOfBVHUpdate>(m,·"SelectMgr_TypeOfBVHUpdate",R"#(Keeps·track·for·BVH·update·state·for·each·SelectMgr_Selection·entity·in·a·following·way:·-·Add·:·2nd·level·BVH·does·not·contain·any·of·the·selection's·sensitive·entities·and·they·must·be·added;·-·Remove·:·all·sensitive·entities·of·the·selection·must·be·removed·from·2nd·level·BVH;·-·Renew·:·2nd·level·BVH·already·contains·sensitives·of·the·selection,·but·the·its·complete·update·and·removal·is·required.·Therefore,·sensitives·of·the·selection·with·this·type·of·update·must·be·removed·from·2nd·level·BVH·and·added·after·recomputation.·-·Invalidate·:·the·2nd·level·BVH·needs·to·be·rebuilt;·-·None·:·entities·of·the·selection·are·up·to·date.)#")135 ····py::enum_<SelectMgr_TypeOfBVHUpdate>(m,·"SelectMgr_TypeOfBVHUpdate",R"#(Keeps·track·for·BVH·update·state·for·each·SelectMgr_Selection·entity·in·a·following·way:·-·Add·:·2nd·level·BVH·does·not·contain·any·of·the·selection's·sensitive·entities·and·they·must·be·added;·-·Remove·:·all·sensitive·entities·of·the·selection·must·be·removed·from·2nd·level·BVH;·-·Renew·:·2nd·level·BVH·already·contains·sensitives·of·the·selection,·but·the·its·complete·update·and·removal·is·required.·Therefore,·sensitives·of·the·selection·with·this·type·of·update·must·be·removed·from·2nd·level·BVH·and·added·after·recomputation.·-·Invalidate·:·the·2nd·level·BVH·needs·to·be·rebuilt;·-·None·:·entities·of·the·selection·are·up·to·date.)#")
124 ········.value("SelectMgr_TBU_Add",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Add)136 ········.value("SelectMgr_TBU_Add",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Add)
125 ········.value("SelectMgr_TBU_Remove",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Remove)137 ········.value("SelectMgr_TBU_Remove",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Remove)
126 ········.value("SelectMgr_TBU_Renew",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Renew)138 ········.value("SelectMgr_TBU_Renew",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Renew)
127 ········.value("SelectMgr_TBU_Invalidate",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Invalidate)139 ········.value("SelectMgr_TBU_Invalidate",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Invalidate)
128 ········.value("SelectMgr_TBU_None",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_None).export_values();140 ········.value("SelectMgr_TBU_None",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_None).export_values();
129 ····py::enum_<SelectMgr_TypeOfDepthTolerance>(m,·"SelectMgr_TypeOfDepthTolerance",R"#(Define·the·type·of·depth·tolerance·for·considering·picked·entities·to·lie·on·the·same·depth·(distance·from·eye·to·entity).)#") 
130 ········.value("SelectMgr_TypeOfDepthTolerance_Uniform",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_Uniform) 
131 ········.value("SelectMgr_TypeOfDepthTolerance_UniformPixels",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_UniformPixels) 
132 ········.value("SelectMgr_TypeOfDepthTolerance_SensitivityFactor",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_SensitivityFactor).export_values(); 
133 ····py::enum_<SelectMgr_SelectionType>(m,·"SelectMgr_SelectionType",R"#(Possible·selection·types)#") 
134 ········.value("SelectMgr_SelectionType_Unknown",SelectMgr_SelectionType::SelectMgr_SelectionType_Unknown) 
135 ········.value("SelectMgr_SelectionType_Point",SelectMgr_SelectionType::SelectMgr_SelectionType_Point) 
136 ········.value("SelectMgr_SelectionType_Box",SelectMgr_SelectionType::SelectMgr_SelectionType_Box) 
137 ········.value("SelectMgr_SelectionType_Polyline",SelectMgr_SelectionType::SelectMgr_SelectionType_Polyline).export_values(); 
138 ····py::enum_<SelectMgr_PickingStrategy>(m,·"SelectMgr_PickingStrategy",R"#(Enumeration·defines·picking·strategy·-·which·entities·detected·by·picking·line·will·be·accepted,·considering·selection·filters.)#") 
139 ········.value("SelectMgr_PickingStrategy_FirstAcceptable",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_FirstAcceptable) 
140 ········.value("SelectMgr_PickingStrategy_OnlyTopmost",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_OnlyTopmost).export_values(); 
  
141 //Python·trampoline·classes141 //Python·trampoline·classes
142 ····class·Py_SelectMgr_BaseIntersector·:·public·SelectMgr_BaseIntersector{142 ····class·Py_SelectMgr_BaseIntersector·:·public·SelectMgr_BaseIntersector{
143 ····public:143 ····public:
144 ········using·SelectMgr_BaseIntersector::SelectMgr_BaseIntersector;144 ········using·SelectMgr_BaseIntersector::SelectMgr_BaseIntersector;
  
  
⊟
4.13 KB
./usr/share/libocp/OCP/ShapeExtend_pre.cpp
Ordering differences only
    
Offset 60, 14 lines modifiedOffset 60, 18 lines modified
60 py::module·m·=·main_module.def_submodule("ShapeExtend",·R"#()#");60 py::module·m·=·main_module.def_submodule("ShapeExtend",·R"#()#");
  
61 //·add·namespaces·as·submodules61 //·add·namespaces·as·submodules
  
62 //·user-defined·inclusion·per·module·in·the·body62 //·user-defined·inclusion·per·module·in·the·body
  
63 //·enums63 //·enums
 64 ····py::enum_<ShapeExtend_Parametrisation>(m,·"ShapeExtend_Parametrisation",R"#(Defines·kind·of·global·parametrisation·on·the·composite·surface·each·patch·of·the·1st·row·and·column·adds·its·range,·Ui+1·=·Ui·+·URange(i,1),·etc.·each·patch·gives·range·1.:·Ui·=·i-1,·Vj·=·j-1·uniform·parametrisation·with·global·range·[0,1])#")
 65 ········.value("ShapeExtend_Natural",ShapeExtend_Parametrisation::ShapeExtend_Natural)
 66 ········.value("ShapeExtend_Uniform",ShapeExtend_Parametrisation::ShapeExtend_Uniform)
 67 ········.value("ShapeExtend_Unitary",ShapeExtend_Parametrisation::ShapeExtend_Unitary).export_values();
64 ····py::enum_<ShapeExtend_Status>(m,·"ShapeExtend_Status",R"#(This·enumeration·is·used·in·ShapeHealing·toolkit·for·representing·flags·in·the·return·statuses·of·class·methods.·The·status·is·a·field·of·the·class·which·is·set·by·one·or·several·methods·of·that·class.·It·is·used·for·reporting·about·errors·and·other·situations·encountered·during·execution·of·the·method.·There·are·defined·8·values·for·DONE·and·8·for·FAIL·flags:·ShapeExtend_DONE1·...·ShapeExtend_DONE8,·ShapeExtend_FAIL1·...·ShapeExtend_FAIL8·and·also·enumerations·for·representing·combinations·of·flags:·ShapeExtend_OK·-·no·flags·at·all,·ShapeExtend_DONE·-·any·of·flags·DONEi,·ShapeExtend_FAIL·-·any·of·flags·FAILi.·The·class·that·uses·statuses·provides·a·method(s)·which·answers·whether·the·flag·corresponding·to·a·given·enumerative·value·is·(are)·set:·Standard_Boolean·Status(const·ShapeExtend_Status·test);·Note·that·status·can·have·several·flags·set·simultaneously.·Status(ShapeExtend_OK)·gives·True·when·no·flags·are·set.·Nothing·done,·everything·OK·Something·was·done,·case·1·Something·was·done,·case·2·Something·was·done,·case·3·Something·was·done,·case·4·Something·was·done,·case·5·Something·was·done,·case·6·Something·was·done,·case·7·Something·was·done,·case·8·Something·was·done·(any·of·DONE#)·The·method·failed,·case·1·The·method·failed,·case·2·The·method·failed,·case·3·The·method·failed,·case·4·The·method·failed,·case·5·The·method·failed,·case·6·The·method·failed,·case·7·The·method·failed,·case·8·The·method·failed·(any·of·FAIL#·occurred))#")68 ····py::enum_<ShapeExtend_Status>(m,·"ShapeExtend_Status",R"#(This·enumeration·is·used·in·ShapeHealing·toolkit·for·representing·flags·in·the·return·statuses·of·class·methods.·The·status·is·a·field·of·the·class·which·is·set·by·one·or·several·methods·of·that·class.·It·is·used·for·reporting·about·errors·and·other·situations·encountered·during·execution·of·the·method.·There·are·defined·8·values·for·DONE·and·8·for·FAIL·flags:·ShapeExtend_DONE1·...·ShapeExtend_DONE8,·ShapeExtend_FAIL1·...·ShapeExtend_FAIL8·and·also·enumerations·for·representing·combinations·of·flags:·ShapeExtend_OK·-·no·flags·at·all,·ShapeExtend_DONE·-·any·of·flags·DONEi,·ShapeExtend_FAIL·-·any·of·flags·FAILi.·The·class·that·uses·statuses·provides·a·method(s)·which·answers·whether·the·flag·corresponding·to·a·given·enumerative·value·is·(are)·set:·Standard_Boolean·Status(const·ShapeExtend_Status·test);·Note·that·status·can·have·several·flags·set·simultaneously.·Status(ShapeExtend_OK)·gives·True·when·no·flags·are·set.·Nothing·done,·everything·OK·Something·was·done,·case·1·Something·was·done,·case·2·Something·was·done,·case·3·Something·was·done,·case·4·Something·was·done,·case·5·Something·was·done,·case·6·Something·was·done,·case·7·Something·was·done,·case·8·Something·was·done·(any·of·DONE#)·The·method·failed,·case·1·The·method·failed,·case·2·The·method·failed,·case·3·The·method·failed,·case·4·The·method·failed,·case·5·The·method·failed,·case·6·The·method·failed,·case·7·The·method·failed,·case·8·The·method·failed·(any·of·FAIL#·occurred))#")
65 ········.value("ShapeExtend_OK",ShapeExtend_Status::ShapeExtend_OK)69 ········.value("ShapeExtend_OK",ShapeExtend_Status::ShapeExtend_OK)
66 ········.value("ShapeExtend_DONE1",ShapeExtend_Status::ShapeExtend_DONE1)70 ········.value("ShapeExtend_DONE1",ShapeExtend_Status::ShapeExtend_DONE1)
67 ········.value("ShapeExtend_DONE2",ShapeExtend_Status::ShapeExtend_DONE2)71 ········.value("ShapeExtend_DONE2",ShapeExtend_Status::ShapeExtend_DONE2)
68 ········.value("ShapeExtend_DONE3",ShapeExtend_Status::ShapeExtend_DONE3)72 ········.value("ShapeExtend_DONE3",ShapeExtend_Status::ShapeExtend_DONE3)
69 ········.value("ShapeExtend_DONE4",ShapeExtend_Status::ShapeExtend_DONE4)73 ········.value("ShapeExtend_DONE4",ShapeExtend_Status::ShapeExtend_DONE4)
70 ········.value("ShapeExtend_DONE5",ShapeExtend_Status::ShapeExtend_DONE5)74 ········.value("ShapeExtend_DONE5",ShapeExtend_Status::ShapeExtend_DONE5)
Offset 80, 18 lines modifiedOffset 84, 14 lines modified
80 ········.value("ShapeExtend_FAIL3",ShapeExtend_Status::ShapeExtend_FAIL3)84 ········.value("ShapeExtend_FAIL3",ShapeExtend_Status::ShapeExtend_FAIL3)
81 ········.value("ShapeExtend_FAIL4",ShapeExtend_Status::ShapeExtend_FAIL4)85 ········.value("ShapeExtend_FAIL4",ShapeExtend_Status::ShapeExtend_FAIL4)
82 ········.value("ShapeExtend_FAIL5",ShapeExtend_Status::ShapeExtend_FAIL5)86 ········.value("ShapeExtend_FAIL5",ShapeExtend_Status::ShapeExtend_FAIL5)
83 ········.value("ShapeExtend_FAIL6",ShapeExtend_Status::ShapeExtend_FAIL6)87 ········.value("ShapeExtend_FAIL6",ShapeExtend_Status::ShapeExtend_FAIL6)
84 ········.value("ShapeExtend_FAIL7",ShapeExtend_Status::ShapeExtend_FAIL7)88 ········.value("ShapeExtend_FAIL7",ShapeExtend_Status::ShapeExtend_FAIL7)
85 ········.value("ShapeExtend_FAIL8",ShapeExtend_Status::ShapeExtend_FAIL8)89 ········.value("ShapeExtend_FAIL8",ShapeExtend_Status::ShapeExtend_FAIL8)
86 ········.value("ShapeExtend_FAIL",ShapeExtend_Status::ShapeExtend_FAIL).export_values();90 ········.value("ShapeExtend_FAIL",ShapeExtend_Status::ShapeExtend_FAIL).export_values();
87 ····py::enum_<ShapeExtend_Parametrisation>(m,·"ShapeExtend_Parametrisation",R"#(Defines·kind·of·global·parametrisation·on·the·composite·surface·each·patch·of·the·1st·row·and·column·adds·its·range,·Ui+1·=·Ui·+·URange(i,1),·etc.·each·patch·gives·range·1.:·Ui·=·i-1,·Vj·=·j-1·uniform·parametrisation·with·global·range·[0,1])#") 
88 ········.value("ShapeExtend_Natural",ShapeExtend_Parametrisation::ShapeExtend_Natural) 
89 ········.value("ShapeExtend_Uniform",ShapeExtend_Parametrisation::ShapeExtend_Uniform) 
90 ········.value("ShapeExtend_Unitary",ShapeExtend_Parametrisation::ShapeExtend_Unitary).export_values(); 
  
91 //Python·trampoline·classes91 //Python·trampoline·classes
92 ····class·Py_ShapeExtend_ComplexCurve·:·public·ShapeExtend_ComplexCurve{92 ····class·Py_ShapeExtend_ComplexCurve·:·public·ShapeExtend_ComplexCurve{
93 ····public:93 ····public:
94 ········using·ShapeExtend_ComplexCurve::ShapeExtend_ComplexCurve;94 ········using·ShapeExtend_ComplexCurve::ShapeExtend_ComplexCurve;
  
  
⊟
1.12 KB
./usr/share/libocp/OCP/Standard.cpp
Ordering differences only
    
Offset 905, 19 lines modifiedOffset 905, 19 lines modified
905 ·············(·const·handle<Standard_Type>·&·(Standard_Type::*)()·const)·static_cast<·const·handle<Standard_Type>·&·(Standard_Type::*)()·const>(&Standard_Type::DynamicType),905 ·············(·const·handle<Standard_Type>·&·(Standard_Type::*)()·const)·static_cast<·const·handle<Standard_Type>·&·(Standard_Type::*)()·const>(&Standard_Type::DynamicType),
906 ·············R"#()#"906 ·············R"#()#"
907 ·············907 ·············
908 ·········)908 ·········)
909 ;909 ;
  
910 //·functions910 //·functions
911 auto·mopencascade·=·static_cast<py::module>(m.attr("opencascade")); 
912 auto·mMurmurHashUtils·=·static_cast<py::module>(m.attr("MurmurHashUtils"));911 auto·mMurmurHashUtils·=·static_cast<py::module>(m.attr("MurmurHashUtils"));
 912 auto·mstd·=·static_cast<py::module>(m.attr("std"));
913 auto·mMurmurHash·=·static_cast<py::module>(m.attr("MurmurHash"));913 auto·mMurmurHash·=·static_cast<py::module>(m.attr("MurmurHash"));
 914 auto·mopencascade·=·static_cast<py::module>(m.attr("opencascade"));
914 auto·mFNVHash·=·static_cast<py::module>(m.attr("FNVHash"));915 auto·mFNVHash·=·static_cast<py::module>(m.attr("FNVHash"));
915 auto·mstd·=·static_cast<py::module>(m.attr("std")); 
  
916 //·/usr/include/opencascade/Standard.hxx916 //·/usr/include/opencascade/Standard.hxx
917 //·/usr/include/opencascade/Standard_AbortiveTransaction.hxx917 //·/usr/include/opencascade/Standard_AbortiveTransaction.hxx
918 //·/usr/include/opencascade/Standard_ArrayStreamBuffer.hxx918 //·/usr/include/opencascade/Standard_ArrayStreamBuffer.hxx
919 //·/usr/include/opencascade/Standard_Assert.hxx919 //·/usr/include/opencascade/Standard_Assert.hxx
920 ····m.def("Standard_ASSERT_DO_NOTHING",920 ····m.def("Standard_ASSERT_DO_NOTHING",
921 ··········(void·(*)())··static_cast<void·(*)()>(&Standard_ASSERT_DO_NOTHING),921 ··········(void·(*)())··static_cast<void·(*)()>(&Standard_ASSERT_DO_NOTHING),
⊟
835 B
./usr/share/libocp/OCP/Standard_pre.cpp
Ordering differences only
    
Offset 107, 19 lines modifiedOffset 107, 19 lines modified
107 //·Module·definiiton107 //·Module·definiiton
108 void·register_Standard_enums(py::module·&main_module)·{108 void·register_Standard_enums(py::module·&main_module)·{
  
  
109 py::module·m·=·main_module.def_submodule("Standard",·R"#()#");109 py::module·m·=·main_module.def_submodule("Standard",·R"#()#");
  
110 //·add·namespaces·as·submodules110 //·add·namespaces·as·submodules
111 m.def_submodule("opencascade"); 
112 m.def_submodule("MurmurHashUtils");111 m.def_submodule("MurmurHashUtils");
 112 m.def_submodule("std");
113 m.def_submodule("MurmurHash");113 m.def_submodule("MurmurHash");
 114 m.def_submodule("opencascade");
114 m.def_submodule("FNVHash");115 m.def_submodule("FNVHash");
115 m.def_submodule("std"); 
  
116 //·user-defined·inclusion·per·module·in·the·body116 //·user-defined·inclusion·per·module·in·the·body
  
117 //·enums117 //·enums
118 ····py::enum_<Standard_HandlerStatus>(m,·"Standard_HandlerStatus",R"#()#")118 ····py::enum_<Standard_HandlerStatus>(m,·"Standard_HandlerStatus",R"#()#")
119 ········.value("Standard_HandlerVoid",Standard_HandlerStatus::Standard_HandlerVoid)119 ········.value("Standard_HandlerVoid",Standard_HandlerStatus::Standard_HandlerVoid)
120 ········.value("Standard_HandlerJumped",Standard_HandlerStatus::Standard_HandlerJumped)120 ········.value("Standard_HandlerJumped",Standard_HandlerStatus::Standard_HandlerJumped)
⊟
5.23 KB
./usr/share/libocp/OCP/StdSelect_pre.cpp
Ordering differences only
    
Offset 51, 32 lines modifiedOffset 51, 32 lines modified
51 //·user-defined·inclusion·per·module·in·the·body51 //·user-defined·inclusion·per·module·in·the·body
  
52 //·enums52 //·enums
53 ····py::enum_<StdSelect_TypeOfEdge>(m,·"StdSelect_TypeOfEdge",R"#(Provides·values·for·different·types·of·edges.·These·values·are·used·to·filter·edges·in·frameworks·inheriting·StdSelect_EdgeFilter.)#")53 ····py::enum_<StdSelect_TypeOfEdge>(m,·"StdSelect_TypeOfEdge",R"#(Provides·values·for·different·types·of·edges.·These·values·are·used·to·filter·edges·in·frameworks·inheriting·StdSelect_EdgeFilter.)#")
54 ········.value("StdSelect_AnyEdge",StdSelect_TypeOfEdge::StdSelect_AnyEdge)54 ········.value("StdSelect_AnyEdge",StdSelect_TypeOfEdge::StdSelect_AnyEdge)
55 ········.value("StdSelect_Line",StdSelect_TypeOfEdge::StdSelect_Line)55 ········.value("StdSelect_Line",StdSelect_TypeOfEdge::StdSelect_Line)
56 ········.value("StdSelect_Circle",StdSelect_TypeOfEdge::StdSelect_Circle).export_values();56 ········.value("StdSelect_Circle",StdSelect_TypeOfEdge::StdSelect_Circle).export_values();
57 ····py::enum_<StdSelect_TypeOfFace>(m,·"StdSelect_TypeOfFace",R"#(Provides·values·for·different·types·of·faces.·These·values·are·used·to·filter·faces·in·frameworks·inheriting·StdSelect_FaceFilter.)#") 
58 ········.value("StdSelect_AnyFace",StdSelect_TypeOfFace::StdSelect_AnyFace) 
59 ········.value("StdSelect_Plane",StdSelect_TypeOfFace::StdSelect_Plane) 
60 ········.value("StdSelect_Cylinder",StdSelect_TypeOfFace::StdSelect_Cylinder) 
61 ········.value("StdSelect_Sphere",StdSelect_TypeOfFace::StdSelect_Sphere) 
62 ········.value("StdSelect_Torus",StdSelect_TypeOfFace::StdSelect_Torus) 
63 ········.value("StdSelect_Revol",StdSelect_TypeOfFace::StdSelect_Revol) 
64 ········.value("StdSelect_Cone",StdSelect_TypeOfFace::StdSelect_Cone).export_values(); 
65 ····py::enum_<StdSelect_TypeOfSelectionImage>(m,·"StdSelect_TypeOfSelectionImage",R"#(Type·of·output·selection·image.)#")57 ····py::enum_<StdSelect_TypeOfSelectionImage>(m,·"StdSelect_TypeOfSelectionImage",R"#(Type·of·output·selection·image.)#")
66 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepth)58 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepth)
67 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepthInverted",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepthInverted)59 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepthInverted",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepthInverted)
68 ········.value("StdSelect_TypeOfSelectionImage_UnnormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_UnnormalizedDepth)60 ········.value("StdSelect_TypeOfSelectionImage_UnnormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_UnnormalizedDepth)
69 ········.value("StdSelect_TypeOfSelectionImage_ColoredDetectedObject",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredDetectedObject)61 ········.value("StdSelect_TypeOfSelectionImage_ColoredDetectedObject",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredDetectedObject)
70 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntity",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntity)62 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntity",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntity)
71 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntityType",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntityType)63 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntityType",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntityType)
72 ········.value("StdSelect_TypeOfSelectionImage_ColoredOwner",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredOwner)64 ········.value("StdSelect_TypeOfSelectionImage_ColoredOwner",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredOwner)
73 ········.value("StdSelect_TypeOfSelectionImage_ColoredSelectionMode",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredSelectionMode)65 ········.value("StdSelect_TypeOfSelectionImage_ColoredSelectionMode",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredSelectionMode)
74 ········.value("StdSelect_TypeOfSelectionImage_SurfaceNormal",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_SurfaceNormal).export_values();66 ········.value("StdSelect_TypeOfSelectionImage_SurfaceNormal",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_SurfaceNormal).export_values();
 67 ····py::enum_<StdSelect_TypeOfFace>(m,·"StdSelect_TypeOfFace",R"#(Provides·values·for·different·types·of·faces.·These·values·are·used·to·filter·faces·in·frameworks·inheriting·StdSelect_FaceFilter.)#")
 68 ········.value("StdSelect_AnyFace",StdSelect_TypeOfFace::StdSelect_AnyFace)
 69 ········.value("StdSelect_Plane",StdSelect_TypeOfFace::StdSelect_Plane)
 70 ········.value("StdSelect_Cylinder",StdSelect_TypeOfFace::StdSelect_Cylinder)
 71 ········.value("StdSelect_Sphere",StdSelect_TypeOfFace::StdSelect_Sphere)
 72 ········.value("StdSelect_Torus",StdSelect_TypeOfFace::StdSelect_Torus)
 73 ········.value("StdSelect_Revol",StdSelect_TypeOfFace::StdSelect_Revol)
 74 ········.value("StdSelect_Cone",StdSelect_TypeOfFace::StdSelect_Cone).export_values();
  
75 //Python·trampoline·classes75 //Python·trampoline·classes
  
76 //·pre-register·typdefs+classes·(topologically·sorted)76 //·pre-register·typdefs+classes·(topologically·sorted)
77 ····py::class_<StdSelect·,·shared_ptr<StdSelect>··>(m,"StdSelect",R"#(The·StdSelect·package·provides·the·following·services·-·the·definition·of·selection·modes·for·topological·shapes·-·the·definition·of·several·concrete·filtertandard·Selection2d.ap·classes·-·2D·and·3D·viewer·selectors.·Note·that·each·new·Interactive·Object·must·have·all·its·selection·modes·defined.·Standard·Classes·is·useful·to·build·3D·Selectable·Objects,·and·to·process·3D·Selections:)#");77 ····py::class_<StdSelect·,·shared_ptr<StdSelect>··>(m,"StdSelect",R"#(The·StdSelect·package·provides·the·following·services·-·the·definition·of·selection·modes·for·topological·shapes·-·the·definition·of·several·concrete·filtertandard·Selection2d.ap·classes·-·2D·and·3D·viewer·selectors.·Note·that·each·new·Interactive·Object·must·have·all·its·selection·modes·defined.·Standard·Classes·is·useful·to·build·3D·Selectable·Objects,·and·to·process·3D·Selections:)#");
78 ····py::class_<StdSelect_BRepSelectionTool·,·shared_ptr<StdSelect_BRepSelectionTool>··>(m,"StdSelect_BRepSelectionTool",R"#(Tool·to·create·specific·selections·(sets·of·primitives)·for·Shapes·from·Topology.·These·Selections·may·be·used·in·dynamic·selection·Mechanism·Given·a·Shape·and·a·mode·of·selection·(selection·of·vertices,·edges,faces·...)·,·This·Tool·Computes·corresponding·sensitive·primitives,·puts·them·in·an·entity·called·Selection·(see·package·SelectMgr)·and·returns·it.)#");78 ····py::class_<StdSelect_BRepSelectionTool·,·shared_ptr<StdSelect_BRepSelectionTool>··>(m,"StdSelect_BRepSelectionTool",R"#(Tool·to·create·specific·selections·(sets·of·primitives)·for·Shapes·from·Topology.·These·Selections·may·be·used·in·dynamic·selection·Mechanism·Given·a·Shape·and·a·mode·of·selection·(selection·of·vertices,·edges,faces·...)·,·This·Tool·Computes·corresponding·sensitive·primitives,·puts·them·in·an·entity·called·Selection·(see·package·SelectMgr)·and·returns·it.)#");
79 ····py::class_<StdSelect_BRepOwner·,opencascade::handle<StdSelect_BRepOwner>··,·SelectMgr_EntityOwner·>(m,"StdSelect_BRepOwner",R"#(Defines·Specific·Owners·for·Sensitive·Primitives·(Sensitive·Segments,Circles...).·Used·in·Dynamic·Selection·Mechanism.·A·BRepOwner·has·an·Owner·(the·shape·it·represents)·and·Users·(One·or·More·Transient·entities).·The·highlight-unhighlight·methods·are·empty·and·must·be·redefined·by·each·User.Defines·Specific·Owners·for·Sensitive·Primitives·(Sensitive·Segments,Circles...).·Used·in·Dynamic·Selection·Mechanism.·A·BRepOwner·has·an·Owner·(the·shape·it·represents)·and·Users·(One·or·More·Transient·entities).·The·highlight-unhighlight·methods·are·empty·and·must·be·redefined·by·each·User.)#");79 ····py::class_<StdSelect_BRepOwner·,opencascade::handle<StdSelect_BRepOwner>··,·SelectMgr_EntityOwner·>(m,"StdSelect_BRepOwner",R"#(Defines·Specific·Owners·for·Sensitive·Primitives·(Sensitive·Segments,Circles...).·Used·in·Dynamic·Selection·Mechanism.·A·BRepOwner·has·an·Owner·(the·shape·it·represents)·and·Users·(One·or·More·Transient·entities).·The·highlight-unhighlight·methods·are·empty·and·must·be·redefined·by·each·User.Defines·Specific·Owners·for·Sensitive·Primitives·(Sensitive·Segments,Circles...).·Used·in·Dynamic·Selection·Mechanism.·A·BRepOwner·has·an·Owner·(the·shape·it·represents)·and·Users·(One·or·More·Transient·entities).·The·highlight-unhighlight·methods·are·empty·and·must·be·redefined·by·each·User.)#");
⊟
5.57 KB
./usr/share/libocp/OCP/StepBasic_pre.cpp
Ordering differences only
    
Offset 411, 35 lines modifiedOffset 411, 14 lines modified
411 //·user-defined·inclusion·per·module·in·the·body411 //·user-defined·inclusion·per·module·in·the·body
  
412 //·enums412 //·enums
413 ····py::enum_<StepBasic_AheadOrBehind>(m,·"StepBasic_AheadOrBehind",R"#()#")413 ····py::enum_<StepBasic_AheadOrBehind>(m,·"StepBasic_AheadOrBehind",R"#()#")
414 ········.value("StepBasic_aobAhead",StepBasic_AheadOrBehind::StepBasic_aobAhead)414 ········.value("StepBasic_aobAhead",StepBasic_AheadOrBehind::StepBasic_aobAhead)
415 ········.value("StepBasic_aobExact",StepBasic_AheadOrBehind::StepBasic_aobExact)415 ········.value("StepBasic_aobExact",StepBasic_AheadOrBehind::StepBasic_aobExact)
416 ········.value("StepBasic_aobBehind",StepBasic_AheadOrBehind::StepBasic_aobBehind).export_values();416 ········.value("StepBasic_aobBehind",StepBasic_AheadOrBehind::StepBasic_aobBehind).export_values();
417 ····py::enum_<StepBasic_Source>(m,·"StepBasic_Source",R"#()#") 
418 ········.value("StepBasic_sMade",StepBasic_Source::StepBasic_sMade) 
419 ········.value("StepBasic_sBought",StepBasic_Source::StepBasic_sBought) 
420 ········.value("StepBasic_sNotKnown",StepBasic_Source::StepBasic_sNotKnown).export_values(); 
421 ····py::enum_<StepBasic_SiPrefix>(m,·"StepBasic_SiPrefix",R"#()#") 
422 ········.value("StepBasic_spExa",StepBasic_SiPrefix::StepBasic_spExa) 
423 ········.value("StepBasic_spPeta",StepBasic_SiPrefix::StepBasic_spPeta) 
424 ········.value("StepBasic_spTera",StepBasic_SiPrefix::StepBasic_spTera) 
425 ········.value("StepBasic_spGiga",StepBasic_SiPrefix::StepBasic_spGiga) 
426 ········.value("StepBasic_spMega",StepBasic_SiPrefix::StepBasic_spMega) 
427 ········.value("StepBasic_spKilo",StepBasic_SiPrefix::StepBasic_spKilo) 
428 ········.value("StepBasic_spHecto",StepBasic_SiPrefix::StepBasic_spHecto) 
429 ········.value("StepBasic_spDeca",StepBasic_SiPrefix::StepBasic_spDeca) 
430 ········.value("StepBasic_spDeci",StepBasic_SiPrefix::StepBasic_spDeci) 
431 ········.value("StepBasic_spCenti",StepBasic_SiPrefix::StepBasic_spCenti) 
432 ········.value("StepBasic_spMilli",StepBasic_SiPrefix::StepBasic_spMilli) 
433 ········.value("StepBasic_spMicro",StepBasic_SiPrefix::StepBasic_spMicro) 
434 ········.value("StepBasic_spNano",StepBasic_SiPrefix::StepBasic_spNano) 
435 ········.value("StepBasic_spPico",StepBasic_SiPrefix::StepBasic_spPico) 
436 ········.value("StepBasic_spFemto",StepBasic_SiPrefix::StepBasic_spFemto) 
437 ········.value("StepBasic_spAtto",StepBasic_SiPrefix::StepBasic_spAtto).export_values(); 
438 ····py::enum_<StepBasic_SiUnitName>(m,·"StepBasic_SiUnitName",R"#()#")417 ····py::enum_<StepBasic_SiUnitName>(m,·"StepBasic_SiUnitName",R"#()#")
439 ········.value("StepBasic_sunMetre",StepBasic_SiUnitName::StepBasic_sunMetre)418 ········.value("StepBasic_sunMetre",StepBasic_SiUnitName::StepBasic_sunMetre)
440 ········.value("StepBasic_sunGram",StepBasic_SiUnitName::StepBasic_sunGram)419 ········.value("StepBasic_sunGram",StepBasic_SiUnitName::StepBasic_sunGram)
441 ········.value("StepBasic_sunSecond",StepBasic_SiUnitName::StepBasic_sunSecond)420 ········.value("StepBasic_sunSecond",StepBasic_SiUnitName::StepBasic_sunSecond)
442 ········.value("StepBasic_sunAmpere",StepBasic_SiUnitName::StepBasic_sunAmpere)421 ········.value("StepBasic_sunAmpere",StepBasic_SiUnitName::StepBasic_sunAmpere)
443 ········.value("StepBasic_sunKelvin",StepBasic_SiUnitName::StepBasic_sunKelvin)422 ········.value("StepBasic_sunKelvin",StepBasic_SiUnitName::StepBasic_sunKelvin)
444 ········.value("StepBasic_sunMole",StepBasic_SiUnitName::StepBasic_sunMole)423 ········.value("StepBasic_sunMole",StepBasic_SiUnitName::StepBasic_sunMole)
Offset 461, 14 lines modifiedOffset 440, 35 lines modified
461 ········.value("StepBasic_sunHenry",StepBasic_SiUnitName::StepBasic_sunHenry)440 ········.value("StepBasic_sunHenry",StepBasic_SiUnitName::StepBasic_sunHenry)
462 ········.value("StepBasic_sunDegreeCelsius",StepBasic_SiUnitName::StepBasic_sunDegreeCelsius)441 ········.value("StepBasic_sunDegreeCelsius",StepBasic_SiUnitName::StepBasic_sunDegreeCelsius)
463 ········.value("StepBasic_sunLumen",StepBasic_SiUnitName::StepBasic_sunLumen)442 ········.value("StepBasic_sunLumen",StepBasic_SiUnitName::StepBasic_sunLumen)
464 ········.value("StepBasic_sunLux",StepBasic_SiUnitName::StepBasic_sunLux)443 ········.value("StepBasic_sunLux",StepBasic_SiUnitName::StepBasic_sunLux)
465 ········.value("StepBasic_sunBecquerel",StepBasic_SiUnitName::StepBasic_sunBecquerel)444 ········.value("StepBasic_sunBecquerel",StepBasic_SiUnitName::StepBasic_sunBecquerel)
466 ········.value("StepBasic_sunGray",StepBasic_SiUnitName::StepBasic_sunGray)445 ········.value("StepBasic_sunGray",StepBasic_SiUnitName::StepBasic_sunGray)
467 ········.value("StepBasic_sunSievert",StepBasic_SiUnitName::StepBasic_sunSievert).export_values();446 ········.value("StepBasic_sunSievert",StepBasic_SiUnitName::StepBasic_sunSievert).export_values();
 447 ····py::enum_<StepBasic_Source>(m,·"StepBasic_Source",R"#()#")
 448 ········.value("StepBasic_sMade",StepBasic_Source::StepBasic_sMade)
 449 ········.value("StepBasic_sBought",StepBasic_Source::StepBasic_sBought)
 450 ········.value("StepBasic_sNotKnown",StepBasic_Source::StepBasic_sNotKnown).export_values();
 451 ····py::enum_<StepBasic_SiPrefix>(m,·"StepBasic_SiPrefix",R"#()#")
 452 ········.value("StepBasic_spExa",StepBasic_SiPrefix::StepBasic_spExa)
 453 ········.value("StepBasic_spPeta",StepBasic_SiPrefix::StepBasic_spPeta)
 454 ········.value("StepBasic_spTera",StepBasic_SiPrefix::StepBasic_spTera)
 455 ········.value("StepBasic_spGiga",StepBasic_SiPrefix::StepBasic_spGiga)
 456 ········.value("StepBasic_spMega",StepBasic_SiPrefix::StepBasic_spMega)
 457 ········.value("StepBasic_spKilo",StepBasic_SiPrefix::StepBasic_spKilo)
 458 ········.value("StepBasic_spHecto",StepBasic_SiPrefix::StepBasic_spHecto)
 459 ········.value("StepBasic_spDeca",StepBasic_SiPrefix::StepBasic_spDeca)
 460 ········.value("StepBasic_spDeci",StepBasic_SiPrefix::StepBasic_spDeci)
 461 ········.value("StepBasic_spCenti",StepBasic_SiPrefix::StepBasic_spCenti)
 462 ········.value("StepBasic_spMilli",StepBasic_SiPrefix::StepBasic_spMilli)
 463 ········.value("StepBasic_spMicro",StepBasic_SiPrefix::StepBasic_spMicro)
 464 ········.value("StepBasic_spNano",StepBasic_SiPrefix::StepBasic_spNano)
 465 ········.value("StepBasic_spPico",StepBasic_SiPrefix::StepBasic_spPico)
 466 ········.value("StepBasic_spFemto",StepBasic_SiPrefix::StepBasic_spFemto)
 467 ········.value("StepBasic_spAtto",StepBasic_SiPrefix::StepBasic_spAtto).export_values();
  
468 //Python·trampoline·classes468 //Python·trampoline·classes
  
469 //·pre-register·typdefs+classes·(topologically·sorted)469 //·pre-register·typdefs+classes·(topologically·sorted)
470 ····py::class_<StepBasic_Action·,opencascade::handle<StepBasic_Action>··,·Standard_Transient·>(m,"StepBasic_Action",R"#(Representation·of·STEP·entity·ActionRepresentation·of·STEP·entity·ActionRepresentation·of·STEP·entity·Action)#");470 ····py::class_<StepBasic_Action·,opencascade::handle<StepBasic_Action>··,·Standard_Transient·>(m,"StepBasic_Action",R"#(Representation·of·STEP·entity·ActionRepresentation·of·STEP·entity·ActionRepresentation·of·STEP·entity·Action)#");
471 ····py::class_<StepBasic_ActionAssignment·,opencascade::handle<StepBasic_ActionAssignment>··,·Standard_Transient·>(m,"StepBasic_ActionAssignment",R"#(Representation·of·STEP·entity·ActionAssignmentRepresentation·of·STEP·entity·ActionAssignmentRepresentation·of·STEP·entity·ActionAssignment)#");471 ····py::class_<StepBasic_ActionAssignment·,opencascade::handle<StepBasic_ActionAssignment>··,·Standard_Transient·>(m,"StepBasic_ActionAssignment",R"#(Representation·of·STEP·entity·ActionAssignmentRepresentation·of·STEP·entity·ActionAssignmentRepresentation·of·STEP·entity·ActionAssignment)#");
472 ····py::class_<StepBasic_ActionMethod·,opencascade::handle<StepBasic_ActionMethod>··,·Standard_Transient·>(m,"StepBasic_ActionMethod",R"#(Representation·of·STEP·entity·ActionMethodRepresentation·of·STEP·entity·ActionMethodRepresentation·of·STEP·entity·ActionMethod)#");472 ····py::class_<StepBasic_ActionMethod·,opencascade::handle<StepBasic_ActionMethod>··,·Standard_Transient·>(m,"StepBasic_ActionMethod",R"#(Representation·of·STEP·entity·ActionMethodRepresentation·of·STEP·entity·ActionMethodRepresentation·of·STEP·entity·ActionMethod)#");
⊟
10.6 KB
./usr/share/libocp/OCP/StepDimTol_pre.cpp
Ordering differences only
    
Offset 199, 43 lines modifiedOffset 199, 14 lines modified
199 py::module·m·=·main_module.def_submodule("StepDimTol",·R"#()#");199 py::module·m·=·main_module.def_submodule("StepDimTol",·R"#()#");
  
200 //·add·namespaces·as·submodules200 //·add·namespaces·as·submodules
  
201 //·user-defined·inclusion·per·module·in·the·body201 //·user-defined·inclusion·per·module·in·the·body
  
202 //·enums202 //·enums
203 ····py::enum_<StepDimTol_GeometricToleranceType>(m,·"StepDimTol_GeometricToleranceType",R"#()#") 
204 ········.value("StepDimTol_GTTAngularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTAngularityTolerance) 
205 ········.value("StepDimTol_GTTCircularRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCircularRunoutTolerance) 
206 ········.value("StepDimTol_GTTCoaxialityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCoaxialityTolerance) 
207 ········.value("StepDimTol_GTTConcentricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTConcentricityTolerance) 
208 ········.value("StepDimTol_GTTCylindricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCylindricityTolerance) 
209 ········.value("StepDimTol_GTTFlatnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTFlatnessTolerance) 
210 ········.value("StepDimTol_GTTLineProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTLineProfileTolerance) 
211 ········.value("StepDimTol_GTTParallelismTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTParallelismTolerance) 
212 ········.value("StepDimTol_GTTPerpendicularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPerpendicularityTolerance) 
213 ········.value("StepDimTol_GTTPositionTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPositionTolerance) 
214 ········.value("StepDimTol_GTTRoundnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTRoundnessTolerance) 
215 ········.value("StepDimTol_GTTStraightnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTStraightnessTolerance) 
216 ········.value("StepDimTol_GTTSurfaceProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSurfaceProfileTolerance) 
217 ········.value("StepDimTol_GTTSymmetryTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSymmetryTolerance) 
218 ········.value("StepDimTol_GTTTotalRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTTotalRunoutTolerance).export_values(); 
219 ····py::enum_<StepDimTol_AreaUnitType>(m,·"StepDimTol_AreaUnitType",R"#()#") 
220 ········.value("StepDimTol_Circular",StepDimTol_AreaUnitType::StepDimTol_Circular) 
221 ········.value("StepDimTol_Rectangular",StepDimTol_AreaUnitType::StepDimTol_Rectangular) 
222 ········.value("StepDimTol_Square",StepDimTol_AreaUnitType::StepDimTol_Square).export_values(); 
223 ····py::enum_<StepDimTol_DatumReferenceModifierType>(m,·"StepDimTol_DatumReferenceModifierType",R"#()#") 
224 ········.value("StepDimTol_CircularOrCylindrical",StepDimTol_DatumReferenceModifierType::StepDimTol_CircularOrCylindrical) 
225 ········.value("StepDimTol_Distance",StepDimTol_DatumReferenceModifierType::StepDimTol_Distance) 
226 ········.value("StepDimTol_Projected",StepDimTol_DatumReferenceModifierType::StepDimTol_Projected) 
227 ········.value("StepDimTol_Spherical",StepDimTol_DatumReferenceModifierType::StepDimTol_Spherical).export_values(); 
228 ····py::enum_<StepDimTol_LimitCondition>(m,·"StepDimTol_LimitCondition",R"#()#") 
229 ········.value("StepDimTol_MaximumMaterialCondition",StepDimTol_LimitCondition::StepDimTol_MaximumMaterialCondition) 
230 ········.value("StepDimTol_LeastMaterialCondition",StepDimTol_LimitCondition::StepDimTol_LeastMaterialCondition) 
231 ········.value("StepDimTol_RegardlessOfFeatureSize",StepDimTol_LimitCondition::StepDimTol_RegardlessOfFeatureSize).export_values(); 
232 ····py::enum_<StepDimTol_SimpleDatumReferenceModifier>(m,·"StepDimTol_SimpleDatumReferenceModifier",R"#()#")203 ····py::enum_<StepDimTol_SimpleDatumReferenceModifier>(m,·"StepDimTol_SimpleDatumReferenceModifier",R"#()#")
233 ········.value("StepDimTol_SDRMAnyCrossSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyCrossSection)204 ········.value("StepDimTol_SDRMAnyCrossSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyCrossSection)
234 ········.value("StepDimTol_SDRMAnyLongitudinalSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyLongitudinalSection)205 ········.value("StepDimTol_SDRMAnyLongitudinalSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyLongitudinalSection)
235 ········.value("StepDimTol_SDRMBasic",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMBasic)206 ········.value("StepDimTol_SDRMBasic",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMBasic)
236 ········.value("StepDimTol_SDRMContactingFeature",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMContactingFeature)207 ········.value("StepDimTol_SDRMContactingFeature",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMContactingFeature)
237 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintU",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintU)208 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintU",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintU)
238 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintV",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintV)209 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintV",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintV)
Offset 251, 14 lines modifiedOffset 222, 19 lines modified
251 ········.value("StepDimTol_SDRMMaximumMaterialRequirement",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMaximumMaterialRequirement)222 ········.value("StepDimTol_SDRMMaximumMaterialRequirement",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMaximumMaterialRequirement)
252 ········.value("StepDimTol_SDRMMinorDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMinorDiameter)223 ········.value("StepDimTol_SDRMMinorDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMinorDiameter)
253 ········.value("StepDimTol_SDRMOrientation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMOrientation)224 ········.value("StepDimTol_SDRMOrientation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMOrientation)
254 ········.value("StepDimTol_SDRMPitchDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPitchDiameter)225 ········.value("StepDimTol_SDRMPitchDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPitchDiameter)
255 ········.value("StepDimTol_SDRMPlane",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPlane)226 ········.value("StepDimTol_SDRMPlane",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPlane)
256 ········.value("StepDimTol_SDRMPoint",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPoint)227 ········.value("StepDimTol_SDRMPoint",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPoint)
257 ········.value("StepDimTol_SDRMTranslation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMTranslation).export_values();228 ········.value("StepDimTol_SDRMTranslation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMTranslation).export_values();
 229 ····py::enum_<StepDimTol_DatumReferenceModifierType>(m,·"StepDimTol_DatumReferenceModifierType",R"#()#")
 230 ········.value("StepDimTol_CircularOrCylindrical",StepDimTol_DatumReferenceModifierType::StepDimTol_CircularOrCylindrical)
 231 ········.value("StepDimTol_Distance",StepDimTol_DatumReferenceModifierType::StepDimTol_Distance)
 232 ········.value("StepDimTol_Projected",StepDimTol_DatumReferenceModifierType::StepDimTol_Projected)
 233 ········.value("StepDimTol_Spherical",StepDimTol_DatumReferenceModifierType::StepDimTol_Spherical).export_values();
258 ····py::enum_<StepDimTol_GeometricToleranceModifier>(m,·"StepDimTol_GeometricToleranceModifier",R"#()#")234 ····py::enum_<StepDimTol_GeometricToleranceModifier>(m,·"StepDimTol_GeometricToleranceModifier",R"#()#")
259 ········.value("StepDimTol_GTMAnyCrossSection",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMAnyCrossSection)235 ········.value("StepDimTol_GTMAnyCrossSection",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMAnyCrossSection)
260 ········.value("StepDimTol_GTMCommonZone",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMCommonZone)236 ········.value("StepDimTol_GTMCommonZone",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMCommonZone)
261 ········.value("StepDimTol_GTMEachRadialElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMEachRadialElement)237 ········.value("StepDimTol_GTMEachRadialElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMEachRadialElement)
262 ········.value("StepDimTol_GTMFreeState",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMFreeState)238 ········.value("StepDimTol_GTMFreeState",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMFreeState)
263 ········.value("StepDimTol_GTMLeastMaterialRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLeastMaterialRequirement)239 ········.value("StepDimTol_GTMLeastMaterialRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLeastMaterialRequirement)
264 ········.value("StepDimTol_GTMLineElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLineElement)240 ········.value("StepDimTol_GTMLineElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLineElement)
Offset 267, 14 lines modifiedOffset 243, 38 lines modified
267 ········.value("StepDimTol_GTMMinorDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMinorDiameter)243 ········.value("StepDimTol_GTMMinorDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMinorDiameter)
268 ········.value("StepDimTol_GTMNotConvex",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMNotConvex)244 ········.value("StepDimTol_GTMNotConvex",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMNotConvex)
269 ········.value("StepDimTol_GTMPitchDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMPitchDiameter)245 ········.value("StepDimTol_GTMPitchDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMPitchDiameter)
270 ········.value("StepDimTol_GTMReciprocityRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMReciprocityRequirement)246 ········.value("StepDimTol_GTMReciprocityRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMReciprocityRequirement)
271 ········.value("StepDimTol_GTMSeparateRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMSeparateRequirement)247 ········.value("StepDimTol_GTMSeparateRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMSeparateRequirement)
272 ········.value("StepDimTol_GTMStatisticalTolerance",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMStatisticalTolerance)248 ········.value("StepDimTol_GTMStatisticalTolerance",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMStatisticalTolerance)
273 ········.value("StepDimTol_GTMTangentPlane",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMTangentPlane).export_values();249 ········.value("StepDimTol_GTMTangentPlane",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMTangentPlane).export_values();
 250 ····py::enum_<StepDimTol_AreaUnitType>(m,·"StepDimTol_AreaUnitType",R"#()#")
 251 ········.value("StepDimTol_Circular",StepDimTol_AreaUnitType::StepDimTol_Circular)
 252 ········.value("StepDimTol_Rectangular",StepDimTol_AreaUnitType::StepDimTol_Rectangular)
 253 ········.value("StepDimTol_Square",StepDimTol_AreaUnitType::StepDimTol_Square).export_values();
 254 ····py::enum_<StepDimTol_GeometricToleranceType>(m,·"StepDimTol_GeometricToleranceType",R"#()#")
 255 ········.value("StepDimTol_GTTAngularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTAngularityTolerance)
 256 ········.value("StepDimTol_GTTCircularRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCircularRunoutTolerance)
 257 ········.value("StepDimTol_GTTCoaxialityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCoaxialityTolerance)
 258 ········.value("StepDimTol_GTTConcentricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTConcentricityTolerance)
 259 ········.value("StepDimTol_GTTCylindricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCylindricityTolerance)
 260 ········.value("StepDimTol_GTTFlatnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTFlatnessTolerance)
 261 ········.value("StepDimTol_GTTLineProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTLineProfileTolerance)
 262 ········.value("StepDimTol_GTTParallelismTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTParallelismTolerance)
 263 ········.value("StepDimTol_GTTPerpendicularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPerpendicularityTolerance)
 264 ········.value("StepDimTol_GTTPositionTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPositionTolerance)
 265 ········.value("StepDimTol_GTTRoundnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTRoundnessTolerance)
 266 ········.value("StepDimTol_GTTStraightnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTStraightnessTolerance)
 267 ········.value("StepDimTol_GTTSurfaceProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSurfaceProfileTolerance)
 268 ········.value("StepDimTol_GTTSymmetryTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSymmetryTolerance)
 269 ········.value("StepDimTol_GTTTotalRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTTotalRunoutTolerance).export_values();
 270 ····py::enum_<StepDimTol_LimitCondition>(m,·"StepDimTol_LimitCondition",R"#()#")
 271 ········.value("StepDimTol_MaximumMaterialCondition",StepDimTol_LimitCondition::StepDimTol_MaximumMaterialCondition)
 272 ········.value("StepDimTol_LeastMaterialCondition",StepDimTol_LimitCondition::StepDimTol_LeastMaterialCondition)
 273 ········.value("StepDimTol_RegardlessOfFeatureSize",StepDimTol_LimitCondition::StepDimTol_RegardlessOfFeatureSize).export_values();
  
274 //Python·trampoline·classes274 //Python·trampoline·classes
  
275 //·pre-register·typdefs+classes·(topologically·sorted)275 //·pre-register·typdefs+classes·(topologically·sorted)
276 ····preregister_template_NCollection_Array1<opencascade::handle<StepDimTol_DatumReference>>(m,"StepDimTol_Array1OfDatumReference");276 ····preregister_template_NCollection_Array1<opencascade::handle<StepDimTol_DatumReference>>(m,"StepDimTol_Array1OfDatumReference");
277 ····preregister_template_NCollection_Array1<opencascade::handle<StepDimTol_DatumReferenceCompartment>>(m,"StepDimTol_Array1OfDatumReferenceCompartment");277 ····preregister_template_NCollection_Array1<opencascade::handle<StepDimTol_DatumReferenceCompartment>>(m,"StepDimTol_Array1OfDatumReferenceCompartment");
278 ····preregister_template_NCollection_Array1<opencascade::handle<StepDimTol_DatumReferenceElement>>(m,"StepDimTol_Array1OfDatumReferenceElement");278 ····preregister_template_NCollection_Array1<opencascade::handle<StepDimTol_DatumReferenceElement>>(m,"StepDimTol_Array1OfDatumReferenceElement");
⊟
8.7 KB
./usr/share/libocp/OCP/StepElement_pre.cpp
Ordering differences only
    
Offset 150, 57 lines modifiedOffset 150, 57 lines modified
150 py::module·m·=·main_module.def_submodule("StepElement",·R"#()#");150 py::module·m·=·main_module.def_submodule("StepElement",·R"#()#");
  
151 //·add·namespaces·as·submodules151 //·add·namespaces·as·submodules
  
152 //·user-defined·inclusion·per·module·in·the·body152 //·user-defined·inclusion·per·module·in·the·body
  
153 //·enums153 //·enums
154 ····py::enum_<StepElement_EnumeratedCurveElementFreedom>(m,·"StepElement_EnumeratedCurveElementFreedom",R"#()#") 
155 ········.value("StepElement_XTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_XTranslation) 
156 ········.value("StepElement_YTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_YTranslation) 
157 ········.value("StepElement_ZTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZTranslation) 
158 ········.value("StepElement_XRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_XRotation) 
159 ········.value("StepElement_YRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_YRotation) 
160 ········.value("StepElement_ZRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZRotation) 
161 ········.value("StepElement_Warp",StepElement_EnumeratedCurveElementFreedom::StepElement_Warp) 
162 ········.value("StepElement_None",StepElement_EnumeratedCurveElementFreedom::StepElement_None).export_values(); 
163 ····py::enum_<StepElement_EnumeratedSurfaceElementPurpose>(m,·"StepElement_EnumeratedSurfaceElementPurpose",R"#()#") 
164 ········.value("StepElement_MembraneDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneDirect) 
165 ········.value("StepElement_MembraneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneShear) 
166 ········.value("StepElement_BendingDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingDirect) 
167 ········.value("StepElement_BendingTorsion",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingTorsion) 
168 ········.value("StepElement_NormalToPlaneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_NormalToPlaneShear).export_values(); 
169 ····py::enum_<StepElement_UnspecifiedValue>(m,·"StepElement_UnspecifiedValue",R"#()#")154 ····py::enum_<StepElement_UnspecifiedValue>(m,·"StepElement_UnspecifiedValue",R"#()#")
170 ········.value("StepElement_Unspecified",StepElement_UnspecifiedValue::StepElement_Unspecified).export_values();155 ········.value("StepElement_Unspecified",StepElement_UnspecifiedValue::StepElement_Unspecified).export_values();
171 ····py::enum_<StepElement_Element2dShape>(m,·"StepElement_Element2dShape",R"#()#")156 ····py::enum_<StepElement_ElementOrder>(m,·"StepElement_ElementOrder",R"#()#")
 157 ········.value("StepElement_Linear",StepElement_ElementOrder::StepElement_Linear)
172 ········.value("StepElement_Quadrilateral",StepElement_Element2dShape::StepElement_Quadrilateral)158 ········.value("StepElement_Quadratic",StepElement_ElementOrder::StepElement_Quadratic)
173 ········.value("StepElement_Triangle",StepElement_Element2dShape::StepElement_Triangle).export_values(); 
174 ····py::enum_<StepElement_ElementVolume>(m,·"StepElement_ElementVolume",R"#()#") 
175 ········.value("StepElement_Volume",StepElement_ElementVolume::StepElement_Volume).export_values();159 ········.value("StepElement_Cubic",StepElement_ElementOrder::StepElement_Cubic).export_values();
 160 ····py::enum_<StepElement_EnumeratedVolumeElementPurpose>(m,·"StepElement_EnumeratedVolumeElementPurpose",R"#()#")
 161 ········.value("StepElement_StressDisplacement",StepElement_EnumeratedVolumeElementPurpose::StepElement_StressDisplacement).export_values();
 162 ····py::enum_<StepElement_Volume3dElementShape>(m,·"StepElement_Volume3dElementShape",R"#()#")
 163 ········.value("StepElement_Hexahedron",StepElement_Volume3dElementShape::StepElement_Hexahedron)
 164 ········.value("StepElement_Wedge",StepElement_Volume3dElementShape::StepElement_Wedge)
 165 ········.value("StepElement_Tetrahedron",StepElement_Volume3dElementShape::StepElement_Tetrahedron)
 166 ········.value("StepElement_Pyramid",StepElement_Volume3dElementShape::StepElement_Pyramid).export_values();
176 ····py::enum_<StepElement_EnumeratedCurveElementPurpose>(m,·"StepElement_EnumeratedCurveElementPurpose",R"#()#")167 ····py::enum_<StepElement_EnumeratedCurveElementPurpose>(m,·"StepElement_EnumeratedCurveElementPurpose",R"#()#")
177 ········.value("StepElement_Axial",StepElement_EnumeratedCurveElementPurpose::StepElement_Axial)168 ········.value("StepElement_Axial",StepElement_EnumeratedCurveElementPurpose::StepElement_Axial)
178 ········.value("StepElement_YYBending",StepElement_EnumeratedCurveElementPurpose::StepElement_YYBending)169 ········.value("StepElement_YYBending",StepElement_EnumeratedCurveElementPurpose::StepElement_YYBending)
179 ········.value("StepElement_ZZBending",StepElement_EnumeratedCurveElementPurpose::StepElement_ZZBending)170 ········.value("StepElement_ZZBending",StepElement_EnumeratedCurveElementPurpose::StepElement_ZZBending)
180 ········.value("StepElement_Torsion",StepElement_EnumeratedCurveElementPurpose::StepElement_Torsion)171 ········.value("StepElement_Torsion",StepElement_EnumeratedCurveElementPurpose::StepElement_Torsion)
181 ········.value("StepElement_XYShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XYShear)172 ········.value("StepElement_XYShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XYShear)
182 ········.value("StepElement_XZShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XZShear)173 ········.value("StepElement_XZShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XZShear)
183 ········.value("StepElement_Warping",StepElement_EnumeratedCurveElementPurpose::StepElement_Warping).export_values();174 ········.value("StepElement_Warping",StepElement_EnumeratedCurveElementPurpose::StepElement_Warping).export_values();
184 ····py::enum_<StepElement_Volume3dElementShape>(m,·"StepElement_Volume3dElementShape",R"#()#") 
185 ········.value("StepElement_Hexahedron",StepElement_Volume3dElementShape::StepElement_Hexahedron) 
186 ········.value("StepElement_Wedge",StepElement_Volume3dElementShape::StepElement_Wedge) 
187 ········.value("StepElement_Tetrahedron",StepElement_Volume3dElementShape::StepElement_Tetrahedron) 
188 ········.value("StepElement_Pyramid",StepElement_Volume3dElementShape::StepElement_Pyramid).export_values(); 
189 ····py::enum_<StepElement_EnumeratedVolumeElementPurpose>(m,·"StepElement_EnumeratedVolumeElementPurpose",R"#()#")175 ····py::enum_<StepElement_EnumeratedSurfaceElementPurpose>(m,·"StepElement_EnumeratedSurfaceElementPurpose",R"#()#")
 176 ········.value("StepElement_MembraneDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneDirect)
 177 ········.value("StepElement_MembraneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneShear)
 178 ········.value("StepElement_BendingDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingDirect)
 179 ········.value("StepElement_BendingTorsion",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingTorsion)
190 ········.value("StepElement_StressDisplacement",StepElement_EnumeratedVolumeElementPurpose::StepElement_StressDisplacement).export_values();180 ········.value("StepElement_NormalToPlaneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_NormalToPlaneShear).export_values();
191 ····py::enum_<StepElement_ElementOrder>(m,·"StepElement_ElementOrder",R"#()#")181 ····py::enum_<StepElement_ElementVolume>(m,·"StepElement_ElementVolume",R"#()#")
192 ········.value("StepElement_Linear",StepElement_ElementOrder::StepElement_Linear) 
193 ········.value("StepElement_Quadratic",StepElement_ElementOrder::StepElement_Quadratic) 
194 ········.value("StepElement_Cubic",StepElement_ElementOrder::StepElement_Cubic).export_values();182 ········.value("StepElement_Volume",StepElement_ElementVolume::StepElement_Volume).export_values();
 183 ····py::enum_<StepElement_EnumeratedCurveElementFreedom>(m,·"StepElement_EnumeratedCurveElementFreedom",R"#()#")
 184 ········.value("StepElement_XTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_XTranslation)
 185 ········.value("StepElement_YTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_YTranslation)
 186 ········.value("StepElement_ZTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZTranslation)
 187 ········.value("StepElement_XRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_XRotation)
 188 ········.value("StepElement_YRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_YRotation)
 189 ········.value("StepElement_ZRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZRotation)
 190 ········.value("StepElement_Warp",StepElement_EnumeratedCurveElementFreedom::StepElement_Warp)
 191 ········.value("StepElement_None",StepElement_EnumeratedCurveElementFreedom::StepElement_None).export_values();
195 ····py::enum_<StepElement_CurveEdge>(m,·"StepElement_CurveEdge",R"#()#")192 ····py::enum_<StepElement_CurveEdge>(m,·"StepElement_CurveEdge",R"#()#")
196 ········.value("StepElement_ElementEdge",StepElement_CurveEdge::StepElement_ElementEdge).export_values();193 ········.value("StepElement_ElementEdge",StepElement_CurveEdge::StepElement_ElementEdge).export_values();
 194 ····py::enum_<StepElement_Element2dShape>(m,·"StepElement_Element2dShape",R"#()#")
 195 ········.value("StepElement_Quadrilateral",StepElement_Element2dShape::StepElement_Quadrilateral)
 196 ········.value("StepElement_Triangle",StepElement_Element2dShape::StepElement_Triangle).export_values();
  
197 //Python·trampoline·classes197 //Python·trampoline·classes
  
198 //·pre-register·typdefs+classes·(topologically·sorted)198 //·pre-register·typdefs+classes·(topologically·sorted)
199 ····py::class_<StepElement_AnalysisItemWithinRepresentation·,opencascade::handle<StepElement_AnalysisItemWithinRepresentation>··,·Standard_Transient·>(m,"StepElement_AnalysisItemWithinRepresentation",R"#(Representation·of·STEP·entity·AnalysisItemWithinRepresentationRepresentation·of·STEP·entity·AnalysisItemWithinRepresentationRepresentation·of·STEP·entity·AnalysisItemWithinRepresentation)#");199 ····py::class_<StepElement_AnalysisItemWithinRepresentation·,opencascade::handle<StepElement_AnalysisItemWithinRepresentation>··,·Standard_Transient·>(m,"StepElement_AnalysisItemWithinRepresentation",R"#(Representation·of·STEP·entity·AnalysisItemWithinRepresentationRepresentation·of·STEP·entity·AnalysisItemWithinRepresentationRepresentation·of·STEP·entity·AnalysisItemWithinRepresentation)#");
200 ····preregister_template_NCollection_Array1<opencascade::handle<StepElement_CurveElementEndReleasePacket>>(m,"StepElement_Array1OfCurveElementEndReleasePacket");200 ····preregister_template_NCollection_Array1<opencascade::handle<StepElement_CurveElementEndReleasePacket>>(m,"StepElement_Array1OfCurveElementEndReleasePacket");
201 ····preregister_template_NCollection_Array1<opencascade::handle<StepElement_CurveElementSectionDefinition>>(m,"StepElement_Array1OfCurveElementSectionDefinition");201 ····preregister_template_NCollection_Array1<opencascade::handle<StepElement_CurveElementSectionDefinition>>(m,"StepElement_Array1OfCurveElementSectionDefinition");
⊟
1.77 KB
./usr/share/libocp/OCP/StepFEA_pre.cpp
Ordering differences only
    
Offset 225, 18 lines modifiedOffset 225, 18 lines modified
225 ········.value("StepFEA_XTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XTranslation)225 ········.value("StepFEA_XTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XTranslation)
226 ········.value("StepFEA_YTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YTranslation)226 ········.value("StepFEA_YTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YTranslation)
227 ········.value("StepFEA_ZTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZTranslation)227 ········.value("StepFEA_ZTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZTranslation)
228 ········.value("StepFEA_XRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XRotation)228 ········.value("StepFEA_XRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XRotation)
229 ········.value("StepFEA_YRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YRotation)229 ········.value("StepFEA_YRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YRotation)
230 ········.value("StepFEA_ZRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZRotation)230 ········.value("StepFEA_ZRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZRotation)
231 ········.value("StepFEA_Warp",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_Warp).export_values();231 ········.value("StepFEA_Warp",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_Warp).export_values();
232 ····py::enum_<StepFEA_CurveEdge>(m,·"StepFEA_CurveEdge",R"#()#") 
233 ········.value("StepFEA_ElementEdge",StepFEA_CurveEdge::StepFEA_ElementEdge).export_values(); 
234 ····py::enum_<StepFEA_ElementVolume>(m,·"StepFEA_ElementVolume",R"#()#")232 ····py::enum_<StepFEA_ElementVolume>(m,·"StepFEA_ElementVolume",R"#()#")
235 ········.value("StepFEA_Volume",StepFEA_ElementVolume::StepFEA_Volume).export_values();233 ········.value("StepFEA_Volume",StepFEA_ElementVolume::StepFEA_Volume).export_values();
 234 ····py::enum_<StepFEA_CurveEdge>(m,·"StepFEA_CurveEdge",R"#()#")
 235 ········.value("StepFEA_ElementEdge",StepFEA_CurveEdge::StepFEA_ElementEdge).export_values();
236 ····py::enum_<StepFEA_UnspecifiedValue>(m,·"StepFEA_UnspecifiedValue",R"#()#")236 ····py::enum_<StepFEA_UnspecifiedValue>(m,·"StepFEA_UnspecifiedValue",R"#()#")
237 ········.value("StepFEA_Unspecified",StepFEA_UnspecifiedValue::StepFEA_Unspecified).export_values();237 ········.value("StepFEA_Unspecified",StepFEA_UnspecifiedValue::StepFEA_Unspecified).export_values();
238 ····py::enum_<StepFEA_CoordinateSystemType>(m,·"StepFEA_CoordinateSystemType",R"#()#")238 ····py::enum_<StepFEA_CoordinateSystemType>(m,·"StepFEA_CoordinateSystemType",R"#()#")
239 ········.value("StepFEA_Cartesian",StepFEA_CoordinateSystemType::StepFEA_Cartesian)239 ········.value("StepFEA_Cartesian",StepFEA_CoordinateSystemType::StepFEA_Cartesian)
240 ········.value("StepFEA_Cylindrical",StepFEA_CoordinateSystemType::StepFEA_Cylindrical)240 ········.value("StepFEA_Cylindrical",StepFEA_CoordinateSystemType::StepFEA_Cylindrical)
241 ········.value("StepFEA_Spherical",StepFEA_CoordinateSystemType::StepFEA_Spherical).export_values();241 ········.value("StepFEA_Spherical",StepFEA_CoordinateSystemType::StepFEA_Spherical).export_values();
  
⊟
4.95 KB
./usr/share/libocp/OCP/StepGeom_pre.cpp
Ordering differences only
    
Offset 305, 21 lines modifiedOffset 305, 30 lines modified
305 //·user-defined·inclusion·per·module·in·the·body305 //·user-defined·inclusion·per·module·in·the·body
  
306 //·enums306 //·enums
307 ····py::enum_<StepGeom_TrimmingPreference>(m,·"StepGeom_TrimmingPreference",R"#()#")307 ····py::enum_<StepGeom_TrimmingPreference>(m,·"StepGeom_TrimmingPreference",R"#()#")
308 ········.value("StepGeom_tpCartesian",StepGeom_TrimmingPreference::StepGeom_tpCartesian)308 ········.value("StepGeom_tpCartesian",StepGeom_TrimmingPreference::StepGeom_tpCartesian)
309 ········.value("StepGeom_tpParameter",StepGeom_TrimmingPreference::StepGeom_tpParameter)309 ········.value("StepGeom_tpParameter",StepGeom_TrimmingPreference::StepGeom_tpParameter)
310 ········.value("StepGeom_tpUnspecified",StepGeom_TrimmingPreference::StepGeom_tpUnspecified).export_values();310 ········.value("StepGeom_tpUnspecified",StepGeom_TrimmingPreference::StepGeom_tpUnspecified).export_values();
 311 ····py::enum_<StepGeom_PreferredSurfaceCurveRepresentation>(m,·"StepGeom_PreferredSurfaceCurveRepresentation",R"#()#")
 312 ········.value("StepGeom_pscrCurve3d",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrCurve3d)
 313 ········.value("StepGeom_pscrPcurveS1",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS1)
 314 ········.value("StepGeom_pscrPcurveS2",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS2).export_values();
311 ····py::enum_<StepGeom_BSplineCurveForm>(m,·"StepGeom_BSplineCurveForm",R"#()#")315 ····py::enum_<StepGeom_BSplineCurveForm>(m,·"StepGeom_BSplineCurveForm",R"#()#")
312 ········.value("StepGeom_bscfPolylineForm",StepGeom_BSplineCurveForm::StepGeom_bscfPolylineForm)316 ········.value("StepGeom_bscfPolylineForm",StepGeom_BSplineCurveForm::StepGeom_bscfPolylineForm)
313 ········.value("StepGeom_bscfCircularArc",StepGeom_BSplineCurveForm::StepGeom_bscfCircularArc)317 ········.value("StepGeom_bscfCircularArc",StepGeom_BSplineCurveForm::StepGeom_bscfCircularArc)
314 ········.value("StepGeom_bscfEllipticArc",StepGeom_BSplineCurveForm::StepGeom_bscfEllipticArc)318 ········.value("StepGeom_bscfEllipticArc",StepGeom_BSplineCurveForm::StepGeom_bscfEllipticArc)
315 ········.value("StepGeom_bscfParabolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfParabolicArc)319 ········.value("StepGeom_bscfParabolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfParabolicArc)
316 ········.value("StepGeom_bscfHyperbolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfHyperbolicArc)320 ········.value("StepGeom_bscfHyperbolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfHyperbolicArc)
317 ········.value("StepGeom_bscfUnspecified",StepGeom_BSplineCurveForm::StepGeom_bscfUnspecified).export_values();321 ········.value("StepGeom_bscfUnspecified",StepGeom_BSplineCurveForm::StepGeom_bscfUnspecified).export_values();
 322 ····py::enum_<StepGeom_TransitionCode>(m,·"StepGeom_TransitionCode",R"#()#")
 323 ········.value("StepGeom_tcDiscontinuous",StepGeom_TransitionCode::StepGeom_tcDiscontinuous)
 324 ········.value("StepGeom_tcContinuous",StepGeom_TransitionCode::StepGeom_tcContinuous)
 325 ········.value("StepGeom_tcContSameGradient",StepGeom_TransitionCode::StepGeom_tcContSameGradient)
 326 ········.value("StepGeom_tcContSameGradientSameCurvature",StepGeom_TransitionCode::StepGeom_tcContSameGradientSameCurvature).export_values();
318 ····py::enum_<StepGeom_BSplineSurfaceForm>(m,·"StepGeom_BSplineSurfaceForm",R"#()#")327 ····py::enum_<StepGeom_BSplineSurfaceForm>(m,·"StepGeom_BSplineSurfaceForm",R"#()#")
319 ········.value("StepGeom_bssfPlaneSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfPlaneSurf)328 ········.value("StepGeom_bssfPlaneSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfPlaneSurf)
320 ········.value("StepGeom_bssfCylindricalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfCylindricalSurf)329 ········.value("StepGeom_bssfCylindricalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfCylindricalSurf)
321 ········.value("StepGeom_bssfConicalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfConicalSurf)330 ········.value("StepGeom_bssfConicalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfConicalSurf)
322 ········.value("StepGeom_bssfSphericalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfSphericalSurf)331 ········.value("StepGeom_bssfSphericalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfSphericalSurf)
323 ········.value("StepGeom_bssfToroidalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfToroidalSurf)332 ········.value("StepGeom_bssfToroidalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfToroidalSurf)
324 ········.value("StepGeom_bssfSurfOfRevolution",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfRevolution)333 ········.value("StepGeom_bssfSurfOfRevolution",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfRevolution)
Offset 329, 23 lines modifiedOffset 338, 14 lines modified
329 ········.value("StepGeom_bssfSurfOfLinearExtrusion",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfLinearExtrusion)338 ········.value("StepGeom_bssfSurfOfLinearExtrusion",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfLinearExtrusion)
330 ········.value("StepGeom_bssfUnspecified",StepGeom_BSplineSurfaceForm::StepGeom_bssfUnspecified).export_values();339 ········.value("StepGeom_bssfUnspecified",StepGeom_BSplineSurfaceForm::StepGeom_bssfUnspecified).export_values();
331 ····py::enum_<StepGeom_KnotType>(m,·"StepGeom_KnotType",R"#()#")340 ····py::enum_<StepGeom_KnotType>(m,·"StepGeom_KnotType",R"#()#")
332 ········.value("StepGeom_ktUniformKnots",StepGeom_KnotType::StepGeom_ktUniformKnots)341 ········.value("StepGeom_ktUniformKnots",StepGeom_KnotType::StepGeom_ktUniformKnots)
333 ········.value("StepGeom_ktUnspecified",StepGeom_KnotType::StepGeom_ktUnspecified)342 ········.value("StepGeom_ktUnspecified",StepGeom_KnotType::StepGeom_ktUnspecified)
334 ········.value("StepGeom_ktQuasiUniformKnots",StepGeom_KnotType::StepGeom_ktQuasiUniformKnots)343 ········.value("StepGeom_ktQuasiUniformKnots",StepGeom_KnotType::StepGeom_ktQuasiUniformKnots)
335 ········.value("StepGeom_ktPiecewiseBezierKnots",StepGeom_KnotType::StepGeom_ktPiecewiseBezierKnots).export_values();344 ········.value("StepGeom_ktPiecewiseBezierKnots",StepGeom_KnotType::StepGeom_ktPiecewiseBezierKnots).export_values();
336 ····py::enum_<StepGeom_PreferredSurfaceCurveRepresentation>(m,·"StepGeom_PreferredSurfaceCurveRepresentation",R"#()#") 
337 ········.value("StepGeom_pscrCurve3d",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrCurve3d) 
338 ········.value("StepGeom_pscrPcurveS1",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS1) 
339 ········.value("StepGeom_pscrPcurveS2",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS2).export_values(); 
340 ····py::enum_<StepGeom_TransitionCode>(m,·"StepGeom_TransitionCode",R"#()#") 
341 ········.value("StepGeom_tcDiscontinuous",StepGeom_TransitionCode::StepGeom_tcDiscontinuous) 
342 ········.value("StepGeom_tcContinuous",StepGeom_TransitionCode::StepGeom_tcContinuous) 
343 ········.value("StepGeom_tcContSameGradient",StepGeom_TransitionCode::StepGeom_tcContSameGradient) 
344 ········.value("StepGeom_tcContSameGradientSameCurvature",StepGeom_TransitionCode::StepGeom_tcContSameGradientSameCurvature).export_values(); 
  
345 //Python·trampoline·classes345 //Python·trampoline·classes
  
346 //·pre-register·typdefs+classes·(topologically·sorted)346 //·pre-register·typdefs+classes·(topologically·sorted)
347 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_BoundaryCurve>>(m,"StepGeom_Array1OfBoundaryCurve");347 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_BoundaryCurve>>(m,"StepGeom_Array1OfBoundaryCurve");
348 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CartesianPoint>>(m,"StepGeom_Array1OfCartesianPoint");348 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CartesianPoint>>(m,"StepGeom_Array1OfCartesianPoint");
349 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CompositeCurveSegment>>(m,"StepGeom_Array1OfCompositeCurveSegment");349 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CompositeCurveSegment>>(m,"StepGeom_Array1OfCompositeCurveSegment");
⊟
1.76 KB
./usr/share/libocp/OCP/StepShape_pre.cpp
Ordering differences only
    
Offset 315, 22 lines modifiedOffset 315, 22 lines modified
315 py::module·m·=·main_module.def_submodule("StepShape",·R"#()#");315 py::module·m·=·main_module.def_submodule("StepShape",·R"#()#");
  
316 //·add·namespaces·as·submodules316 //·add·namespaces·as·submodules
  
317 //·user-defined·inclusion·per·module·in·the·body317 //·user-defined·inclusion·per·module·in·the·body
  
318 //·enums318 //·enums
319 ····py::enum_<StepShape_BooleanOperator>(m,·"StepShape_BooleanOperator",R"#()#") 
320 ········.value("StepShape_boDifference",StepShape_BooleanOperator::StepShape_boDifference) 
321 ········.value("StepShape_boIntersection",StepShape_BooleanOperator::StepShape_boIntersection) 
322 ········.value("StepShape_boUnion",StepShape_BooleanOperator::StepShape_boUnion).export_values(); 
323 ····py::enum_<StepShape_AngleRelator>(m,·"StepShape_AngleRelator",R"#()#")319 ····py::enum_<StepShape_AngleRelator>(m,·"StepShape_AngleRelator",R"#()#")
324 ········.value("StepShape_Equal",StepShape_AngleRelator::StepShape_Equal)320 ········.value("StepShape_Equal",StepShape_AngleRelator::StepShape_Equal)
325 ········.value("StepShape_Large",StepShape_AngleRelator::StepShape_Large)321 ········.value("StepShape_Large",StepShape_AngleRelator::StepShape_Large)
326 ········.value("StepShape_Small",StepShape_AngleRelator::StepShape_Small).export_values();322 ········.value("StepShape_Small",StepShape_AngleRelator::StepShape_Small).export_values();
 323 ····py::enum_<StepShape_BooleanOperator>(m,·"StepShape_BooleanOperator",R"#()#")
 324 ········.value("StepShape_boDifference",StepShape_BooleanOperator::StepShape_boDifference)
 325 ········.value("StepShape_boIntersection",StepShape_BooleanOperator::StepShape_boIntersection)
 326 ········.value("StepShape_boUnion",StepShape_BooleanOperator::StepShape_boUnion).export_values();
  
327 //Python·trampoline·classes327 //Python·trampoline·classes
  
328 //·pre-register·typdefs+classes·(topologically·sorted)328 //·pre-register·typdefs+classes·(topologically·sorted)
329 ····py::class_<StepShape_BooleanOperand·,·shared_ptr<StepShape_BooleanOperand>··>(m,"StepShape_BooleanOperand",R"#()#");329 ····py::class_<StepShape_BooleanOperand·,·shared_ptr<StepShape_BooleanOperand>··>(m,"StepShape_BooleanOperand",R"#()#");
330 ····py::class_<StepShape_CsgSelect·,·shared_ptr<StepShape_CsgSelect>··>(m,"StepShape_CsgSelect",R"#()#");330 ····py::class_<StepShape_CsgSelect·,·shared_ptr<StepShape_CsgSelect>··>(m,"StepShape_CsgSelect",R"#()#");
331 ····preregister_template_NCollection_Array1<opencascade::handle<StepShape_ConnectedEdgeSet>>(m,"StepShape_Array1OfConnectedEdgeSet");331 ····preregister_template_NCollection_Array1<opencascade::handle<StepShape_ConnectedEdgeSet>>(m,"StepShape_Array1OfConnectedEdgeSet");
⊟
7.11 KB
./usr/share/libocp/OCP/StepToTopoDS_pre.cpp
Ordering differences only
    
Offset 168, 48 lines modifiedOffset 168, 48 lines modified
  
168 //·add·namespaces·as·submodules168 //·add·namespaces·as·submodules
169 m.def_submodule("std");169 m.def_submodule("std");
  
170 //·user-defined·inclusion·per·module·in·the·body170 //·user-defined·inclusion·per·module·in·the·body
  
171 //·enums171 //·enums
172 ····py::enum_<StepToTopoDS_TranslateEdgeLoopError>(m,·"StepToTopoDS_TranslateEdgeLoopError",R"#()#") 
173 ········.value("StepToTopoDS_TranslateEdgeLoopDone",StepToTopoDS_TranslateEdgeLoopError::StepToTopoDS_TranslateEdgeLoopDone) 
174 ········.value("StepToTopoDS_TranslateEdgeLoopOther",StepToTopoDS_TranslateEdgeLoopError::StepToTopoDS_TranslateEdgeLoopOther).export_values(); 
175 ····py::enum_<StepToTopoDS_GeometricToolError>(m,·"StepToTopoDS_GeometricToolError",R"#()#") 
176 ········.value("StepToTopoDS_GeometricToolDone",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolDone) 
177 ········.value("StepToTopoDS_GeometricToolIsDegenerated",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolIsDegenerated) 
178 ········.value("StepToTopoDS_GeometricToolHasNoPCurve",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolHasNoPCurve) 
179 ········.value("StepToTopoDS_GeometricToolWrong3dParameters",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolWrong3dParameters) 
180 ········.value("StepToTopoDS_GeometricToolNoProjectiOnCurve",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolNoProjectiOnCurve) 
181 ········.value("StepToTopoDS_GeometricToolOther",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolOther).export_values(); 
182 ····py::enum_<StepToTopoDS_TranslateVertexLoopError>(m,·"StepToTopoDS_TranslateVertexLoopError",R"#()#")172 ····py::enum_<StepToTopoDS_TranslateVertexLoopError>(m,·"StepToTopoDS_TranslateVertexLoopError",R"#()#")
183 ········.value("StepToTopoDS_TranslateVertexLoopDone",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopDone)173 ········.value("StepToTopoDS_TranslateVertexLoopDone",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopDone)
184 ········.value("StepToTopoDS_TranslateVertexLoopOther",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopOther).export_values();174 ········.value("StepToTopoDS_TranslateVertexLoopOther",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopOther).export_values();
185 ····py::enum_<StepToTopoDS_BuilderError>(m,·"StepToTopoDS_BuilderError",R"#()#") 
186 ········.value("StepToTopoDS_BuilderDone",StepToTopoDS_BuilderError::StepToTopoDS_BuilderDone) 
187 ········.value("StepToTopoDS_BuilderOther",StepToTopoDS_BuilderError::StepToTopoDS_BuilderOther).export_values(); 
188 ····py::enum_<StepToTopoDS_TranslateShellError>(m,·"StepToTopoDS_TranslateShellError",R"#()#") 
189 ········.value("StepToTopoDS_TranslateShellDone",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellDone) 
190 ········.value("StepToTopoDS_TranslateShellOther",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellOther).export_values(); 
191 ····py::enum_<StepToTopoDS_TranslateFaceError>(m,·"StepToTopoDS_TranslateFaceError",R"#()#")175 ····py::enum_<StepToTopoDS_TranslateFaceError>(m,·"StepToTopoDS_TranslateFaceError",R"#()#")
192 ········.value("StepToTopoDS_TranslateFaceDone",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceDone)176 ········.value("StepToTopoDS_TranslateFaceDone",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceDone)
193 ········.value("StepToTopoDS_TranslateFaceOther",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceOther).export_values();177 ········.value("StepToTopoDS_TranslateFaceOther",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceOther).export_values();
194 ····py::enum_<StepToTopoDS_TranslateVertexError>(m,·"StepToTopoDS_TranslateVertexError",R"#()#")178 ····py::enum_<StepToTopoDS_BuilderError>(m,·"StepToTopoDS_BuilderError",R"#()#")
195 ········.value("StepToTopoDS_TranslateVertexDone",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexDone)179 ········.value("StepToTopoDS_BuilderDone",StepToTopoDS_BuilderError::StepToTopoDS_BuilderDone)
196 ········.value("StepToTopoDS_TranslateVertexOther",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexOther).export_values();180 ········.value("StepToTopoDS_BuilderOther",StepToTopoDS_BuilderError::StepToTopoDS_BuilderOther).export_values();
197 ····py::enum_<StepToTopoDS_TranslateSolidError>(m,·"StepToTopoDS_TranslateSolidError",R"#()#")181 ····py::enum_<StepToTopoDS_TranslateSolidError>(m,·"StepToTopoDS_TranslateSolidError",R"#()#")
198 ········.value("StepToTopoDS_TranslateSolidDone",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidDone)182 ········.value("StepToTopoDS_TranslateSolidDone",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidDone)
199 ········.value("StepToTopoDS_TranslateSolidOther",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidOther).export_values();183 ········.value("StepToTopoDS_TranslateSolidOther",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidOther).export_values();
 184 ····py::enum_<StepToTopoDS_TranslateVertexError>(m,·"StepToTopoDS_TranslateVertexError",R"#()#")
 185 ········.value("StepToTopoDS_TranslateVertexDone",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexDone)
 186 ········.value("StepToTopoDS_TranslateVertexOther",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexOther).export_values();
200 ····py::enum_<StepToTopoDS_TranslateEdgeError>(m,·"StepToTopoDS_TranslateEdgeError",R"#()#")187 ····py::enum_<StepToTopoDS_TranslateEdgeError>(m,·"StepToTopoDS_TranslateEdgeError",R"#()#")
201 ········.value("StepToTopoDS_TranslateEdgeDone",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeDone)188 ········.value("StepToTopoDS_TranslateEdgeDone",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeDone)
202 ········.value("StepToTopoDS_TranslateEdgeOther",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeOther).export_values();189 ········.value("StepToTopoDS_TranslateEdgeOther",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeOther).export_values();
 190 ····py::enum_<StepToTopoDS_TranslateShellError>(m,·"StepToTopoDS_TranslateShellError",R"#()#")
 191 ········.value("StepToTopoDS_TranslateShellDone",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellDone)
 192 ········.value("StepToTopoDS_TranslateShellOther",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellOther).export_values();
 193 ····py::enum_<StepToTopoDS_TranslateEdgeLoopError>(m,·"StepToTopoDS_TranslateEdgeLoopError",R"#()#")
 194 ········.value("StepToTopoDS_TranslateEdgeLoopDone",StepToTopoDS_TranslateEdgeLoopError::StepToTopoDS_TranslateEdgeLoopDone)
 195 ········.value("StepToTopoDS_TranslateEdgeLoopOther",StepToTopoDS_TranslateEdgeLoopError::StepToTopoDS_TranslateEdgeLoopOther).export_values();
203 ····py::enum_<StepToTopoDS_TranslatePolyLoopError>(m,·"StepToTopoDS_TranslatePolyLoopError",R"#()#")196 ····py::enum_<StepToTopoDS_TranslatePolyLoopError>(m,·"StepToTopoDS_TranslatePolyLoopError",R"#()#")
204 ········.value("StepToTopoDS_TranslatePolyLoopDone",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopDone)197 ········.value("StepToTopoDS_TranslatePolyLoopDone",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopDone)
205 ········.value("StepToTopoDS_TranslatePolyLoopOther",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopOther).export_values();198 ········.value("StepToTopoDS_TranslatePolyLoopOther",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopOther).export_values();
 199 ····py::enum_<StepToTopoDS_GeometricToolError>(m,·"StepToTopoDS_GeometricToolError",R"#()#")
 200 ········.value("StepToTopoDS_GeometricToolDone",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolDone)
 201 ········.value("StepToTopoDS_GeometricToolIsDegenerated",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolIsDegenerated)
 202 ········.value("StepToTopoDS_GeometricToolHasNoPCurve",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolHasNoPCurve)
 203 ········.value("StepToTopoDS_GeometricToolWrong3dParameters",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolWrong3dParameters)
 204 ········.value("StepToTopoDS_GeometricToolNoProjectiOnCurve",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolNoProjectiOnCurve)
 205 ········.value("StepToTopoDS_GeometricToolOther",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolOther).export_values();
  
206 //Python·trampoline·classes206 //Python·trampoline·classes
  
207 //·pre-register·typdefs+classes·(topologically·sorted)207 //·pre-register·typdefs+classes·(topologically·sorted)
208 ····py::class_<StepToTopoDS·,·shared_ptr<StepToTopoDS>··>(m,"StepToTopoDS",R"#(This·package·implements·the·mapping·between·AP214·Shape·representation·and·CAS.CAD·Shape·Representation.·The·source·schema·is·Part42·(which·is·included·in·AP214))#");208 ····py::class_<StepToTopoDS·,·shared_ptr<StepToTopoDS>··>(m,"StepToTopoDS",R"#(This·package·implements·the·mapping·between·AP214·Shape·representation·and·CAS.CAD·Shape·Representation.·The·source·schema·is·Part42·(which·is·included·in·AP214))#");
209 ····py::class_<StepToTopoDS_GeometricTool·,·shared_ptr<StepToTopoDS_GeometricTool>··>(m,"StepToTopoDS_GeometricTool",R"#(This·class·contains·some·algorithmic·services·specific·to·the·mapping·STEP·to·CAS.CADE)#");209 ····py::class_<StepToTopoDS_GeometricTool·,·shared_ptr<StepToTopoDS_GeometricTool>··>(m,"StepToTopoDS_GeometricTool",R"#(This·class·contains·some·algorithmic·services·specific·to·the·mapping·STEP·to·CAS.CADE)#");
210 ····py::class_<StepToTopoDS_NMTool·,·shared_ptr<StepToTopoDS_NMTool>··>(m,"StepToTopoDS_NMTool",R"#(Provides·data·to·process·non-manifold·topology·when·reading·from·STEP.)#");210 ····py::class_<StepToTopoDS_NMTool·,·shared_ptr<StepToTopoDS_NMTool>··>(m,"StepToTopoDS_NMTool",R"#(Provides·data·to·process·non-manifold·topology·when·reading·from·STEP.)#");
⊟
3.32 KB
./usr/share/libocp/OCP/StepVisual_pre.cpp
Ordering differences only
    
Offset 371, 32 lines modifiedOffset 371, 32 lines modified
  
371 //·enums371 //·enums
372 ····py::enum_<StepVisual_ShadingSurfaceMethod>(m,·"StepVisual_ShadingSurfaceMethod",R"#()#")372 ····py::enum_<StepVisual_ShadingSurfaceMethod>(m,·"StepVisual_ShadingSurfaceMethod",R"#()#")
373 ········.value("StepVisual_ssmConstantShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmConstantShading)373 ········.value("StepVisual_ssmConstantShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmConstantShading)
374 ········.value("StepVisual_ssmColourShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmColourShading)374 ········.value("StepVisual_ssmColourShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmColourShading)
375 ········.value("StepVisual_ssmDotShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmDotShading)375 ········.value("StepVisual_ssmDotShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmDotShading)
376 ········.value("StepVisual_ssmNormalShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmNormalShading).export_values();376 ········.value("StepVisual_ssmNormalShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmNormalShading).export_values();
 377 ····py::enum_<StepVisual_NullStyle>(m,·"StepVisual_NullStyle",R"#()#")
 378 ········.value("StepVisual_Null",StepVisual_NullStyle::StepVisual_Null).export_values();
 379 ····py::enum_<StepVisual_CentralOrParallel>(m,·"StepVisual_CentralOrParallel",R"#()#")
 380 ········.value("StepVisual_copCentral",StepVisual_CentralOrParallel::StepVisual_copCentral)
 381 ········.value("StepVisual_copParallel",StepVisual_CentralOrParallel::StepVisual_copParallel).export_values();
 382 ····py::enum_<StepVisual_TextPath>(m,·"StepVisual_TextPath",R"#()#")
 383 ········.value("StepVisual_tpUp",StepVisual_TextPath::StepVisual_tpUp)
 384 ········.value("StepVisual_tpRight",StepVisual_TextPath::StepVisual_tpRight)
 385 ········.value("StepVisual_tpDown",StepVisual_TextPath::StepVisual_tpDown)
 386 ········.value("StepVisual_tpLeft",StepVisual_TextPath::StepVisual_tpLeft).export_values();
377 ····py::enum_<StepVisual_MarkerType>(m,·"StepVisual_MarkerType",R"#()#")387 ····py::enum_<StepVisual_MarkerType>(m,·"StepVisual_MarkerType",R"#()#")
378 ········.value("StepVisual_mtDot",StepVisual_MarkerType::StepVisual_mtDot)388 ········.value("StepVisual_mtDot",StepVisual_MarkerType::StepVisual_mtDot)
379 ········.value("StepVisual_mtX",StepVisual_MarkerType::StepVisual_mtX)389 ········.value("StepVisual_mtX",StepVisual_MarkerType::StepVisual_mtX)
380 ········.value("StepVisual_mtPlus",StepVisual_MarkerType::StepVisual_mtPlus)390 ········.value("StepVisual_mtPlus",StepVisual_MarkerType::StepVisual_mtPlus)
381 ········.value("StepVisual_mtAsterisk",StepVisual_MarkerType::StepVisual_mtAsterisk)391 ········.value("StepVisual_mtAsterisk",StepVisual_MarkerType::StepVisual_mtAsterisk)
382 ········.value("StepVisual_mtRing",StepVisual_MarkerType::StepVisual_mtRing)392 ········.value("StepVisual_mtRing",StepVisual_MarkerType::StepVisual_mtRing)
383 ········.value("StepVisual_mtSquare",StepVisual_MarkerType::StepVisual_mtSquare)393 ········.value("StepVisual_mtSquare",StepVisual_MarkerType::StepVisual_mtSquare)
384 ········.value("StepVisual_mtTriangle",StepVisual_MarkerType::StepVisual_mtTriangle).export_values();394 ········.value("StepVisual_mtTriangle",StepVisual_MarkerType::StepVisual_mtTriangle).export_values();
385 ····py::enum_<StepVisual_NullStyle>(m,·"StepVisual_NullStyle",R"#()#") 
386 ········.value("StepVisual_Null",StepVisual_NullStyle::StepVisual_Null).export_values(); 
387 ····py::enum_<StepVisual_TextPath>(m,·"StepVisual_TextPath",R"#()#") 
388 ········.value("StepVisual_tpUp",StepVisual_TextPath::StepVisual_tpUp) 
389 ········.value("StepVisual_tpRight",StepVisual_TextPath::StepVisual_tpRight) 
390 ········.value("StepVisual_tpDown",StepVisual_TextPath::StepVisual_tpDown) 
391 ········.value("StepVisual_tpLeft",StepVisual_TextPath::StepVisual_tpLeft).export_values(); 
392 ····py::enum_<StepVisual_CentralOrParallel>(m,·"StepVisual_CentralOrParallel",R"#()#") 
393 ········.value("StepVisual_copCentral",StepVisual_CentralOrParallel::StepVisual_copCentral) 
394 ········.value("StepVisual_copParallel",StepVisual_CentralOrParallel::StepVisual_copParallel).export_values(); 
395 ····py::enum_<StepVisual_SurfaceSide>(m,·"StepVisual_SurfaceSide",R"#()#")395 ····py::enum_<StepVisual_SurfaceSide>(m,·"StepVisual_SurfaceSide",R"#()#")
396 ········.value("StepVisual_ssNegative",StepVisual_SurfaceSide::StepVisual_ssNegative)396 ········.value("StepVisual_ssNegative",StepVisual_SurfaceSide::StepVisual_ssNegative)
397 ········.value("StepVisual_ssPositive",StepVisual_SurfaceSide::StepVisual_ssPositive)397 ········.value("StepVisual_ssPositive",StepVisual_SurfaceSide::StepVisual_ssPositive)
398 ········.value("StepVisual_ssBoth",StepVisual_SurfaceSide::StepVisual_ssBoth).export_values();398 ········.value("StepVisual_ssBoth",StepVisual_SurfaceSide::StepVisual_ssBoth).export_values();
  
399 //Python·trampoline·classes399 //Python·trampoline·classes
  
⊟
3.5 KB
./usr/share/libocp/OCP/Storage_pre.cpp
Ordering differences only
    
Offset 104, 18 lines modifiedOffset 104, 14 lines modified
  
104 //·enums104 //·enums
105 ····py::enum_<Storage_OpenMode>(m,·"Storage_OpenMode",R"#(Specifies·opening·modes·for·a·file:·-·Storage_VSNone·:·no·mode·is·specified·-·Storage_VSRead·:·the·file·is·open·for·reading·operations·-·Storage_VSWrite·:·the·file·is·open·for·writing·operations·-·Storage_VSReadWrite·:·the·file·is·open·for·both·reading·and·writing·operations.)#")105 ····py::enum_<Storage_OpenMode>(m,·"Storage_OpenMode",R"#(Specifies·opening·modes·for·a·file:·-·Storage_VSNone·:·no·mode·is·specified·-·Storage_VSRead·:·the·file·is·open·for·reading·operations·-·Storage_VSWrite·:·the·file·is·open·for·writing·operations·-·Storage_VSReadWrite·:·the·file·is·open·for·both·reading·and·writing·operations.)#")
106 ········.value("Storage_VSNone",Storage_OpenMode::Storage_VSNone)106 ········.value("Storage_VSNone",Storage_OpenMode::Storage_VSNone)
107 ········.value("Storage_VSRead",Storage_OpenMode::Storage_VSRead)107 ········.value("Storage_VSRead",Storage_OpenMode::Storage_VSRead)
108 ········.value("Storage_VSWrite",Storage_OpenMode::Storage_VSWrite)108 ········.value("Storage_VSWrite",Storage_OpenMode::Storage_VSWrite)
109 ········.value("Storage_VSReadWrite",Storage_OpenMode::Storage_VSReadWrite).export_values();109 ········.value("Storage_VSReadWrite",Storage_OpenMode::Storage_VSReadWrite).export_values();
110 ····py::enum_<Storage_SolveMode>(m,·"Storage_SolveMode",R"#()#") 
111 ········.value("Storage_AddSolve",Storage_SolveMode::Storage_AddSolve) 
112 ········.value("Storage_WriteSolve",Storage_SolveMode::Storage_WriteSolve) 
113 ········.value("Storage_ReadSolve",Storage_SolveMode::Storage_ReadSolve).export_values(); 
114 ····py::enum_<Storage_Error>(m,·"Storage_Error",R"#(Error·codes·returned·by·the·ErrorStatus·function·on·a·Storage_Data·set·of·data·during·a·storage·or·retrieval·operation·:·-·Storage_VSOk·:·no·problem·has·been·detected·-·Storage_VSOpenError·:·an·error·has·occurred·when·opening·the·driver·-·Storage_VSModeError·:·the·driver·has·not·been·opened·in·the·correct·mode·-·Storage_VSCloseError·:·an·error·has·occurred·when·closing·the·driver·-·Storage_VSAlreadyOpen·:·the·driver·is·already·open·-·Storage_VSNotOpen·:·the·driver·is·not·open·-·Storage_VSSectionNotFound·:·a·section·has·not·been·found·in·the·driver·-·Storage_VSWriteError·:·an·error·occurred·when·writing·the·driver·-·Storage_VSFormatError·:·the·file·format·is·wrong·-·Storage_VSUnknownType·:·a·type·is·not·known·from·the·schema·-·Storage_VSTypeMismatch·:·trying·to·read·a·wrong·type·-·Storage_VSInternalError·:·an·internal·error·has·been·detected·-·Storage_VSExtCharParityError·:·an·error·has·occurred·while·reading·16·bit·character)#")110 ····py::enum_<Storage_Error>(m,·"Storage_Error",R"#(Error·codes·returned·by·the·ErrorStatus·function·on·a·Storage_Data·set·of·data·during·a·storage·or·retrieval·operation·:·-·Storage_VSOk·:·no·problem·has·been·detected·-·Storage_VSOpenError·:·an·error·has·occurred·when·opening·the·driver·-·Storage_VSModeError·:·the·driver·has·not·been·opened·in·the·correct·mode·-·Storage_VSCloseError·:·an·error·has·occurred·when·closing·the·driver·-·Storage_VSAlreadyOpen·:·the·driver·is·already·open·-·Storage_VSNotOpen·:·the·driver·is·not·open·-·Storage_VSSectionNotFound·:·a·section·has·not·been·found·in·the·driver·-·Storage_VSWriteError·:·an·error·occurred·when·writing·the·driver·-·Storage_VSFormatError·:·the·file·format·is·wrong·-·Storage_VSUnknownType·:·a·type·is·not·known·from·the·schema·-·Storage_VSTypeMismatch·:·trying·to·read·a·wrong·type·-·Storage_VSInternalError·:·an·internal·error·has·been·detected·-·Storage_VSExtCharParityError·:·an·error·has·occurred·while·reading·16·bit·character)#")
115 ········.value("Storage_VSOk",Storage_Error::Storage_VSOk)111 ········.value("Storage_VSOk",Storage_Error::Storage_VSOk)
116 ········.value("Storage_VSOpenError",Storage_Error::Storage_VSOpenError)112 ········.value("Storage_VSOpenError",Storage_Error::Storage_VSOpenError)
117 ········.value("Storage_VSModeError",Storage_Error::Storage_VSModeError)113 ········.value("Storage_VSModeError",Storage_Error::Storage_VSModeError)
118 ········.value("Storage_VSCloseError",Storage_Error::Storage_VSCloseError)114 ········.value("Storage_VSCloseError",Storage_Error::Storage_VSCloseError)
119 ········.value("Storage_VSAlreadyOpen",Storage_Error::Storage_VSAlreadyOpen)115 ········.value("Storage_VSAlreadyOpen",Storage_Error::Storage_VSAlreadyOpen)
120 ········.value("Storage_VSNotOpen",Storage_Error::Storage_VSNotOpen)116 ········.value("Storage_VSNotOpen",Storage_Error::Storage_VSNotOpen)
Offset 123, 14 lines modifiedOffset 119, 18 lines modified
123 ········.value("Storage_VSWriteError",Storage_Error::Storage_VSWriteError)119 ········.value("Storage_VSWriteError",Storage_Error::Storage_VSWriteError)
124 ········.value("Storage_VSFormatError",Storage_Error::Storage_VSFormatError)120 ········.value("Storage_VSFormatError",Storage_Error::Storage_VSFormatError)
125 ········.value("Storage_VSUnknownType",Storage_Error::Storage_VSUnknownType)121 ········.value("Storage_VSUnknownType",Storage_Error::Storage_VSUnknownType)
126 ········.value("Storage_VSTypeMismatch",Storage_Error::Storage_VSTypeMismatch)122 ········.value("Storage_VSTypeMismatch",Storage_Error::Storage_VSTypeMismatch)
127 ········.value("Storage_VSInternalError",Storage_Error::Storage_VSInternalError)123 ········.value("Storage_VSInternalError",Storage_Error::Storage_VSInternalError)
128 ········.value("Storage_VSExtCharParityError",Storage_Error::Storage_VSExtCharParityError)124 ········.value("Storage_VSExtCharParityError",Storage_Error::Storage_VSExtCharParityError)
129 ········.value("Storage_VSWrongFileDriver",Storage_Error::Storage_VSWrongFileDriver).export_values();125 ········.value("Storage_VSWrongFileDriver",Storage_Error::Storage_VSWrongFileDriver).export_values();
 126 ····py::enum_<Storage_SolveMode>(m,·"Storage_SolveMode",R"#()#")
 127 ········.value("Storage_AddSolve",Storage_SolveMode::Storage_AddSolve)
 128 ········.value("Storage_WriteSolve",Storage_SolveMode::Storage_WriteSolve)
 129 ········.value("Storage_ReadSolve",Storage_SolveMode::Storage_ReadSolve).export_values();
  
130 //Python·trampoline·classes130 //Python·trampoline·classes
131 ····class·Py_Storage_BaseDriver·:·public·Storage_BaseDriver{131 ····class·Py_Storage_BaseDriver·:·public·Storage_BaseDriver{
132 ····public:132 ····public:
133 ········using·Storage_BaseDriver::Storage_BaseDriver;133 ········using·Storage_BaseDriver::Storage_BaseDriver;
  
  
⊟
3.15 KB
./usr/share/libocp/OCP/TDataXtd_pre.cpp
Ordering differences only
    
Offset 90, 23 lines modifiedOffset 90, 14 lines modified
90 py::module·m·=·main_module.def_submodule("TDataXtd",·R"#()#");90 py::module·m·=·main_module.def_submodule("TDataXtd",·R"#()#");
  
91 //·add·namespaces·as·submodules91 //·add·namespaces·as·submodules
  
92 //·user-defined·inclusion·per·module·in·the·body92 //·user-defined·inclusion·per·module·in·the·body
  
93 //·enums93 //·enums
94 ····py::enum_<TDataXtd_GeometryEnum>(m,·"TDataXtd_GeometryEnum",R"#(The·terms·of·this·enumeration·define·the·types·of·geometric·shapes·available.)#") 
95 ········.value("TDataXtd_ANY_GEOM",TDataXtd_GeometryEnum::TDataXtd_ANY_GEOM) 
96 ········.value("TDataXtd_POINT",TDataXtd_GeometryEnum::TDataXtd_POINT) 
97 ········.value("TDataXtd_LINE",TDataXtd_GeometryEnum::TDataXtd_LINE) 
98 ········.value("TDataXtd_CIRCLE",TDataXtd_GeometryEnum::TDataXtd_CIRCLE) 
99 ········.value("TDataXtd_ELLIPSE",TDataXtd_GeometryEnum::TDataXtd_ELLIPSE) 
100 ········.value("TDataXtd_SPLINE",TDataXtd_GeometryEnum::TDataXtd_SPLINE) 
101 ········.value("TDataXtd_PLANE",TDataXtd_GeometryEnum::TDataXtd_PLANE) 
102 ········.value("TDataXtd_CYLINDER",TDataXtd_GeometryEnum::TDataXtd_CYLINDER).export_values(); 
103 ····py::enum_<TDataXtd_ConstraintEnum>(m,·"TDataXtd_ConstraintEnum",R"#(The·terms·of·this·enumeration·define·the·types·of·available·constraint.·==================)#")94 ····py::enum_<TDataXtd_ConstraintEnum>(m,·"TDataXtd_ConstraintEnum",R"#(The·terms·of·this·enumeration·define·the·types·of·available·constraint.·==================)#")
104 ········.value("TDataXtd_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_RADIUS)95 ········.value("TDataXtd_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_RADIUS)
105 ········.value("TDataXtd_DIAMETER",TDataXtd_ConstraintEnum::TDataXtd_DIAMETER)96 ········.value("TDataXtd_DIAMETER",TDataXtd_ConstraintEnum::TDataXtd_DIAMETER)
106 ········.value("TDataXtd_MINOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MINOR_RADIUS)97 ········.value("TDataXtd_MINOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MINOR_RADIUS)
107 ········.value("TDataXtd_MAJOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MAJOR_RADIUS)98 ········.value("TDataXtd_MAJOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MAJOR_RADIUS)
108 ········.value("TDataXtd_TANGENT",TDataXtd_ConstraintEnum::TDataXtd_TANGENT)99 ········.value("TDataXtd_TANGENT",TDataXtd_ConstraintEnum::TDataXtd_TANGENT)
109 ········.value("TDataXtd_PARALLEL",TDataXtd_ConstraintEnum::TDataXtd_PARALLEL)100 ········.value("TDataXtd_PARALLEL",TDataXtd_ConstraintEnum::TDataXtd_PARALLEL)
Offset 126, 14 lines modifiedOffset 117, 23 lines modified
126 ········.value("TDataXtd_MATE",TDataXtd_ConstraintEnum::TDataXtd_MATE)117 ········.value("TDataXtd_MATE",TDataXtd_ConstraintEnum::TDataXtd_MATE)
127 ········.value("TDataXtd_ALIGN_FACES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_FACES)118 ········.value("TDataXtd_ALIGN_FACES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_FACES)
128 ········.value("TDataXtd_ALIGN_AXES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_AXES)119 ········.value("TDataXtd_ALIGN_AXES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_AXES)
129 ········.value("TDataXtd_AXES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_AXES_ANGLE)120 ········.value("TDataXtd_AXES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_AXES_ANGLE)
130 ········.value("TDataXtd_FACES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_FACES_ANGLE)121 ········.value("TDataXtd_FACES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_FACES_ANGLE)
131 ········.value("TDataXtd_ROUND",TDataXtd_ConstraintEnum::TDataXtd_ROUND)122 ········.value("TDataXtd_ROUND",TDataXtd_ConstraintEnum::TDataXtd_ROUND)
132 ········.value("TDataXtd_OFFSET",TDataXtd_ConstraintEnum::TDataXtd_OFFSET).export_values();123 ········.value("TDataXtd_OFFSET",TDataXtd_ConstraintEnum::TDataXtd_OFFSET).export_values();
 124 ····py::enum_<TDataXtd_GeometryEnum>(m,·"TDataXtd_GeometryEnum",R"#(The·terms·of·this·enumeration·define·the·types·of·geometric·shapes·available.)#")
 125 ········.value("TDataXtd_ANY_GEOM",TDataXtd_GeometryEnum::TDataXtd_ANY_GEOM)
 126 ········.value("TDataXtd_POINT",TDataXtd_GeometryEnum::TDataXtd_POINT)
 127 ········.value("TDataXtd_LINE",TDataXtd_GeometryEnum::TDataXtd_LINE)
 128 ········.value("TDataXtd_CIRCLE",TDataXtd_GeometryEnum::TDataXtd_CIRCLE)
 129 ········.value("TDataXtd_ELLIPSE",TDataXtd_GeometryEnum::TDataXtd_ELLIPSE)
 130 ········.value("TDataXtd_SPLINE",TDataXtd_GeometryEnum::TDataXtd_SPLINE)
 131 ········.value("TDataXtd_PLANE",TDataXtd_GeometryEnum::TDataXtd_PLANE)
 132 ········.value("TDataXtd_CYLINDER",TDataXtd_GeometryEnum::TDataXtd_CYLINDER).export_values();
  
133 //Python·trampoline·classes133 //Python·trampoline·classes
134 ····class·Py_TDataXtd_Pattern·:·public·TDataXtd_Pattern{134 ····class·Py_TDataXtd_Pattern·:·public·TDataXtd_Pattern{
135 ····public:135 ····public:
136 ········using·TDataXtd_Pattern::TDataXtd_Pattern;136 ········using·TDataXtd_Pattern::TDataXtd_Pattern;
  
  
⊟
7.15 KB
./usr/share/libocp/OCP/TNaming_pre.cpp
Ordering differences only
    
Offset 166, 34 lines modifiedOffset 166, 34 lines modified
166 py::module·m·=·main_module.def_submodule("TNaming",·R"#()#");166 py::module·m·=·main_module.def_submodule("TNaming",·R"#()#");
  
167 //·add·namespaces·as·submodules167 //·add·namespaces·as·submodules
  
168 //·user-defined·inclusion·per·module·in·the·body168 //·user-defined·inclusion·per·module·in·the·body
  
169 //·enums169 //·enums
170 ····py::enum_<TNaming_Evolution>(m,·"TNaming_Evolution",R"#(Defines·the·type·of·evolution·in·old·shape·-·new·shape·pairs.·The·definitions·-·in·the·form·of·the·terms·of·the·enumeration·-·are·needed·by·the·TNaming_NamedShape·attribute·and·indicate·what·entities·this·attribute·records·as·follows:·-·PRIMITIVE·-·New·entities;·in·each·pair,·old·shape·is·a·null·shape·and·new·shape·is·a·created·entity.·-·GENERATED·-·Entities·created·from·other·entities;·in·each·pair,·old·shape·is·the·generator·and·new·shape·is·the·created·entity.·-·MODIFY·-·Split·or·merged·entities,·in·each·pair,·old·shape·is·the·entity·before·the·operation·and·new·shape·is·the·new·entity·after·the·operation.·-·DELETE·-·Deletion·of·entities;·in·each·pair,·old·shape·is·a·deleted·entity·and·new·shape·is·null.·-·SELECTED·-·Named·topological·entities;·in·each·pair,·the·new·shape·is·a·named·entity·and·the·old·shape·is·not·used.)#") 
171 ········.value("TNaming_PRIMITIVE",TNaming_Evolution::TNaming_PRIMITIVE) 
172 ········.value("TNaming_GENERATED",TNaming_Evolution::TNaming_GENERATED) 
173 ········.value("TNaming_MODIFY",TNaming_Evolution::TNaming_MODIFY) 
174 ········.value("TNaming_DELETE",TNaming_Evolution::TNaming_DELETE) 
175 ········.value("TNaming_REPLACE",TNaming_Evolution::TNaming_REPLACE) 
176 ········.value("TNaming_SELECTED",TNaming_Evolution::TNaming_SELECTED).export_values(); 
177 ····py::enum_<TNaming_NameType>(m,·"TNaming_NameType",R"#(to·store·naming·characteristcs)#")170 ····py::enum_<TNaming_NameType>(m,·"TNaming_NameType",R"#(to·store·naming·characteristcs)#")
178 ········.value("TNaming_UNKNOWN",TNaming_NameType::TNaming_UNKNOWN)171 ········.value("TNaming_UNKNOWN",TNaming_NameType::TNaming_UNKNOWN)
179 ········.value("TNaming_IDENTITY",TNaming_NameType::TNaming_IDENTITY)172 ········.value("TNaming_IDENTITY",TNaming_NameType::TNaming_IDENTITY)
180 ········.value("TNaming_MODIFUNTIL",TNaming_NameType::TNaming_MODIFUNTIL)173 ········.value("TNaming_MODIFUNTIL",TNaming_NameType::TNaming_MODIFUNTIL)
181 ········.value("TNaming_GENERATION",TNaming_NameType::TNaming_GENERATION)174 ········.value("TNaming_GENERATION",TNaming_NameType::TNaming_GENERATION)
182 ········.value("TNaming_INTERSECTION",TNaming_NameType::TNaming_INTERSECTION)175 ········.value("TNaming_INTERSECTION",TNaming_NameType::TNaming_INTERSECTION)
183 ········.value("TNaming_UNION",TNaming_NameType::TNaming_UNION)176 ········.value("TNaming_UNION",TNaming_NameType::TNaming_UNION)
184 ········.value("TNaming_SUBSTRACTION",TNaming_NameType::TNaming_SUBSTRACTION)177 ········.value("TNaming_SUBSTRACTION",TNaming_NameType::TNaming_SUBSTRACTION)
185 ········.value("TNaming_CONSTSHAPE",TNaming_NameType::TNaming_CONSTSHAPE)178 ········.value("TNaming_CONSTSHAPE",TNaming_NameType::TNaming_CONSTSHAPE)
186 ········.value("TNaming_FILTERBYNEIGHBOURGS",TNaming_NameType::TNaming_FILTERBYNEIGHBOURGS)179 ········.value("TNaming_FILTERBYNEIGHBOURGS",TNaming_NameType::TNaming_FILTERBYNEIGHBOURGS)
187 ········.value("TNaming_ORIENTATION",TNaming_NameType::TNaming_ORIENTATION)180 ········.value("TNaming_ORIENTATION",TNaming_NameType::TNaming_ORIENTATION)
188 ········.value("TNaming_WIREIN",TNaming_NameType::TNaming_WIREIN)181 ········.value("TNaming_WIREIN",TNaming_NameType::TNaming_WIREIN)
189 ········.value("TNaming_SHELLIN",TNaming_NameType::TNaming_SHELLIN).export_values();182 ········.value("TNaming_SHELLIN",TNaming_NameType::TNaming_SHELLIN).export_values();
 183 ····py::enum_<TNaming_Evolution>(m,·"TNaming_Evolution",R"#(Defines·the·type·of·evolution·in·old·shape·-·new·shape·pairs.·The·definitions·-·in·the·form·of·the·terms·of·the·enumeration·-·are·needed·by·the·TNaming_NamedShape·attribute·and·indicate·what·entities·this·attribute·records·as·follows:·-·PRIMITIVE·-·New·entities;·in·each·pair,·old·shape·is·a·null·shape·and·new·shape·is·a·created·entity.·-·GENERATED·-·Entities·created·from·other·entities;·in·each·pair,·old·shape·is·the·generator·and·new·shape·is·the·created·entity.·-·MODIFY·-·Split·or·merged·entities,·in·each·pair,·old·shape·is·the·entity·before·the·operation·and·new·shape·is·the·new·entity·after·the·operation.·-·DELETE·-·Deletion·of·entities;·in·each·pair,·old·shape·is·a·deleted·entity·and·new·shape·is·null.·-·SELECTED·-·Named·topological·entities;·in·each·pair,·the·new·shape·is·a·named·entity·and·the·old·shape·is·not·used.)#")
 184 ········.value("TNaming_PRIMITIVE",TNaming_Evolution::TNaming_PRIMITIVE)
 185 ········.value("TNaming_GENERATED",TNaming_Evolution::TNaming_GENERATED)
 186 ········.value("TNaming_MODIFY",TNaming_Evolution::TNaming_MODIFY)
 187 ········.value("TNaming_DELETE",TNaming_Evolution::TNaming_DELETE)
 188 ········.value("TNaming_REPLACE",TNaming_Evolution::TNaming_REPLACE)
 189 ········.value("TNaming_SELECTED",TNaming_Evolution::TNaming_SELECTED).export_values();
  
190 //Python·trampoline·classes190 //Python·trampoline·classes
  
191 //·pre-register·typdefs+classes·(topologically·sorted)191 //·pre-register·typdefs+classes·(topologically·sorted)
192 ····py::class_<TNaming·,·shared_ptr<TNaming>··>(m,"TNaming",R"#(A·topological·attribute·can·be·seen·as·a·hook·into·the·topological·structure.·To·this·hook,·data·can·be·attached·and·references·defined.·It·is·used·for·keeping·and·access·to·topological·objects·and·their·evolution.·All·topological·objects·are·stored·in·the·one·user-protected·TNaming_UsedShapes·attribute·at·the·root·label·of·the·data·framework.·This·attribute·contains·map·with·all·topological·shapes,·used·in·this·document.·To·all·other·labels·TNaming_NamedShape·attribute·can·be·added.·This·attribute·contains·references·(hooks)·to·shapes·from·the·TNaming_UsedShapes·attribute·and·evolution·of·these·shapes.·TNaming_NamedShape·attribute·contains·a·set·of·pairs·of·hooks:·old·shape·and·new·shape·(see·the·figure·below).·It·allows·not·only·get·the·topological·shapes·by·the·labels,·but·also·trace·evolution·of·the·shapes·and·correctly·resolve·dependent·shapes·by·the·changed·one.·If·shape·is·just-created,·then·the·old·shape·for·accorded·named·shape·is·an·empty·shape.·If·a·shape·is·deleted,·then·the·new·shape·in·this·named·shape·is·empty.·Different·algorithms·may·dispose·sub-shapes·of·the·result·shape·at·the·individual·label·depending·on·necessity:·-·If·a·sub-shape·must·have·some·extra·attributes·(material·of·each·face·or·color·of·each·edge).·In·this·case·a·specific·sub-shape·is·placed·to·the·separate·label·(usually,·sub-label·of·the·result·shape·label)·with·all·attributes·of·this·sub-shape.·-·If·topological·naming·is·needed,·a·necessary·and·sufficient·(for·selected·sub-shapes·identification)·set·of·sub-shapes·is·placed·to·the·child·labels·of·the·result·shape·label.·As·usual,·as·far·as·basic·solids·and·closed·shells·are·concerned,·all·faces·of·the·shape·are·disposed.·Edges·and·vertices·sub-shapes·can·be·identified·as·intersection·of·contiguous·faces.·Modified/generated·shapes·may·be·placed·to·one·named·shape·and·identified·as·this·named·shape·and·source·named·shape·that·also·can·be·identified·with·used·algorithms.·TNaming_NamedShape·may·contain·a·few·pairs·of·hooks·with·the·same·evolution.·In·this·case·topology·shape,·which·belongs·to·the·named·shape,·is·a·compound·of·new·shapes.·The·data·model·contains·both·the·topology·and·the·hooks,·and·functions·handle·both·topological·entities·and·hooks.·Consider·the·case·of·a·box·function,·which·creates·a·solid·with·six·faces·and·six·hooks.·Each·hook·is·attached·to·a·face.·If·you·want,·you·can·also·have·this·function·create·hooks·for·edges·and·vertices·as·well·as·for·faces.·For·the·sake·of·simplicity·though,·let's·limit·the·example.·Not·all·functions·can·define·explicit·hooks·for·all·topological·entities·they·create,·but·all·topological·entities·can·be·turned·into·hooks·when·necessary.·This·is·where·topological·naming·is·necessary.)#");192 ····py::class_<TNaming·,·shared_ptr<TNaming>··>(m,"TNaming",R"#(A·topological·attribute·can·be·seen·as·a·hook·into·the·topological·structure.·To·this·hook,·data·can·be·attached·and·references·defined.·It·is·used·for·keeping·and·access·to·topological·objects·and·their·evolution.·All·topological·objects·are·stored·in·the·one·user-protected·TNaming_UsedShapes·attribute·at·the·root·label·of·the·data·framework.·This·attribute·contains·map·with·all·topological·shapes,·used·in·this·document.·To·all·other·labels·TNaming_NamedShape·attribute·can·be·added.·This·attribute·contains·references·(hooks)·to·shapes·from·the·TNaming_UsedShapes·attribute·and·evolution·of·these·shapes.·TNaming_NamedShape·attribute·contains·a·set·of·pairs·of·hooks:·old·shape·and·new·shape·(see·the·figure·below).·It·allows·not·only·get·the·topological·shapes·by·the·labels,·but·also·trace·evolution·of·the·shapes·and·correctly·resolve·dependent·shapes·by·the·changed·one.·If·shape·is·just-created,·then·the·old·shape·for·accorded·named·shape·is·an·empty·shape.·If·a·shape·is·deleted,·then·the·new·shape·in·this·named·shape·is·empty.·Different·algorithms·may·dispose·sub-shapes·of·the·result·shape·at·the·individual·label·depending·on·necessity:·-·If·a·sub-shape·must·have·some·extra·attributes·(material·of·each·face·or·color·of·each·edge).·In·this·case·a·specific·sub-shape·is·placed·to·the·separate·label·(usually,·sub-label·of·the·result·shape·label)·with·all·attributes·of·this·sub-shape.·-·If·topological·naming·is·needed,·a·necessary·and·sufficient·(for·selected·sub-shapes·identification)·set·of·sub-shapes·is·placed·to·the·child·labels·of·the·result·shape·label.·As·usual,·as·far·as·basic·solids·and·closed·shells·are·concerned,·all·faces·of·the·shape·are·disposed.·Edges·and·vertices·sub-shapes·can·be·identified·as·intersection·of·contiguous·faces.·Modified/generated·shapes·may·be·placed·to·one·named·shape·and·identified·as·this·named·shape·and·source·named·shape·that·also·can·be·identified·with·used·algorithms.·TNaming_NamedShape·may·contain·a·few·pairs·of·hooks·with·the·same·evolution.·In·this·case·topology·shape,·which·belongs·to·the·named·shape,·is·a·compound·of·new·shapes.·The·data·model·contains·both·the·topology·and·the·hooks,·and·functions·handle·both·topological·entities·and·hooks.·Consider·the·case·of·a·box·function,·which·creates·a·solid·with·six·faces·and·six·hooks.·Each·hook·is·attached·to·a·face.·If·you·want,·you·can·also·have·this·function·create·hooks·for·edges·and·vertices·as·well·as·for·faces.·For·the·sake·of·simplicity·though,·let's·limit·the·example.·Not·all·functions·can·define·explicit·hooks·for·all·topological·entities·they·create,·but·all·topological·entities·can·be·turned·into·hooks·when·necessary.·This·is·where·topological·naming·is·necessary.)#");
193 ····py::class_<TNaming_Builder·,·shared_ptr<TNaming_Builder>··>(m,"TNaming_Builder",R"#(A·tool·to·create·and·maintain·topological·attributes.·Constructor·creates·an·empty·TNaming_NamedShape·attribute·at·the·given·label.·It·allows·adding·"old·shape"·and·"new·shape"·pairs·with·the·specified·evolution·to·this·named·shape.·One·evolution·type·per·one·builder·must·be·used.)#");193 ····py::class_<TNaming_Builder·,·shared_ptr<TNaming_Builder>··>(m,"TNaming_Builder",R"#(A·tool·to·create·and·maintain·topological·attributes.·Constructor·creates·an·empty·TNaming_NamedShape·attribute·at·the·given·label.·It·allows·adding·"old·shape"·and·"new·shape"·pairs·with·the·specified·evolution·to·this·named·shape.·One·evolution·type·per·one·builder·must·be·used.)#");
194 ····py::class_<TNaming_CopyShape·,·shared_ptr<TNaming_CopyShape>··>(m,"TNaming_CopyShape",R"#()#");194 ····py::class_<TNaming_CopyShape·,·shared_ptr<TNaming_CopyShape>··>(m,"TNaming_CopyShape",R"#()#");
⊟
4.71 KB
./usr/share/libocp/OCP/TopAbs_pre.cpp
Ordering differences only
    
Offset 34, 14 lines modifiedOffset 34, 19 lines modified
34 py::module·m·=·main_module.def_submodule("TopAbs",·R"#()#");34 py::module·m·=·main_module.def_submodule("TopAbs",·R"#()#");
  
35 //·add·namespaces·as·submodules35 //·add·namespaces·as·submodules
  
36 //·user-defined·inclusion·per·module·in·the·body36 //·user-defined·inclusion·per·module·in·the·body
  
37 //·enums37 //·enums
 38 ····py::enum_<TopAbs_State>(m,·"TopAbs_State",R"#(Identifies·the·position·of·a·vertex·or·a·set·of·vertices·relative·to·a·region·of·a·shape.·The·figure·shown·above·illustrates·the·states·of·vertices·found·in·various·parts·of·the·edge·relative·to·the·face·which·it·intersects.)#")
 39 ········.value("TopAbs_IN",TopAbs_State::TopAbs_IN)
 40 ········.value("TopAbs_OUT",TopAbs_State::TopAbs_OUT)
 41 ········.value("TopAbs_ON",TopAbs_State::TopAbs_ON)
 42 ········.value("TopAbs_UNKNOWN",TopAbs_State::TopAbs_UNKNOWN).export_values();
38 ····py::enum_<TopAbs_Orientation>(m,·"TopAbs_Orientation",R"#(Identifies·the·orientation·of·a·topological·shape.·Orientation·can·represent·a·relation·between·two·entities,·or·it·can·apply·to·a·shape·in·its·own·right.·When·used·to·describe·a·relation·between·two·shapes,·orientation·allows·you·to·use·the·underlying·entity·in·either·direction.·For·example·on·a·curve·which·is·oriented·FORWARD·(say·from·left·to·right)·you·can·have·both·a·FORWARD·and·a·REVERSED·edge.·The·FORWARD·edge·will·be·oriented·from·left·to·right,·and·the·REVERSED·edge·from·right·to·left.·In·this·way,·you·share·the·underlying·entity.·In·other·words,·two·faces·of·a·cube·can·share·an·edge,·and·can·also·be·used·to·build·compound·shapes.·For·each·case·in·which·an·element·is·used·as·the·boundary·of·a·geometric·domain·of·a·higher·dimension,·this·element·defines·two·local·regions·of·which·one·is·arbitrarily·considered·as·the·default·region.·A·change·in·orientation·implies·a·switch·of·default·region.·This·allows·you·to·apply·changes·of·orientation·to·the·shape·as·a·whole.)#")43 ····py::enum_<TopAbs_Orientation>(m,·"TopAbs_Orientation",R"#(Identifies·the·orientation·of·a·topological·shape.·Orientation·can·represent·a·relation·between·two·entities,·or·it·can·apply·to·a·shape·in·its·own·right.·When·used·to·describe·a·relation·between·two·shapes,·orientation·allows·you·to·use·the·underlying·entity·in·either·direction.·For·example·on·a·curve·which·is·oriented·FORWARD·(say·from·left·to·right)·you·can·have·both·a·FORWARD·and·a·REVERSED·edge.·The·FORWARD·edge·will·be·oriented·from·left·to·right,·and·the·REVERSED·edge·from·right·to·left.·In·this·way,·you·share·the·underlying·entity.·In·other·words,·two·faces·of·a·cube·can·share·an·edge,·and·can·also·be·used·to·build·compound·shapes.·For·each·case·in·which·an·element·is·used·as·the·boundary·of·a·geometric·domain·of·a·higher·dimension,·this·element·defines·two·local·regions·of·which·one·is·arbitrarily·considered·as·the·default·region.·A·change·in·orientation·implies·a·switch·of·default·region.·This·allows·you·to·apply·changes·of·orientation·to·the·shape·as·a·whole.)#")
39 ········.value("TopAbs_FORWARD",TopAbs_Orientation::TopAbs_FORWARD)44 ········.value("TopAbs_FORWARD",TopAbs_Orientation::TopAbs_FORWARD)
40 ········.value("TopAbs_REVERSED",TopAbs_Orientation::TopAbs_REVERSED)45 ········.value("TopAbs_REVERSED",TopAbs_Orientation::TopAbs_REVERSED)
41 ········.value("TopAbs_INTERNAL",TopAbs_Orientation::TopAbs_INTERNAL)46 ········.value("TopAbs_INTERNAL",TopAbs_Orientation::TopAbs_INTERNAL)
42 ········.value("TopAbs_EXTERNAL",TopAbs_Orientation::TopAbs_EXTERNAL).export_values();47 ········.value("TopAbs_EXTERNAL",TopAbs_Orientation::TopAbs_EXTERNAL).export_values();
43 ····py::enum_<TopAbs_ShapeEnum>(m,·"TopAbs_ShapeEnum",R"#(Identifies·various·topological·shapes.·This·enumeration·allows·you·to·use·dynamic·typing·of·shapes.·The·values·are·listed·in·order·of·complexity,·from·the·most·complex·to·the·most·simple·i.e.·COMPOUND·>·COMPSOLID·>·SOLID·>·....·>·VERTEX·>·SHAPE.·Any·shape·can·contain·simpler·shapes·in·its·definition.·Abstract·topological·data·structure·describes·a·basic·entity,·the·shape·(present·in·this·enumeration·as·the·SHAPE·value),·which·can·be·divided·into·the·following·component·topologies:·-·COMPOUND:·A·group·of·any·of·the·shapes·below.·-·COMPSOLID:·A·set·of·solids·connected·by·their·faces.·This·expands·the·notions·of·WIRE·and·SHELL·to·solids.·-·SOLID:·A·part·of·3D·space·bounded·by·shells.·-·SHELL:·A·set·of·faces·connected·by·some·of·the·edges·of·their·wire·boundaries.·A·shell·can·be·open·or·closed.·-·FACE:·Part·of·a·plane·(in·2D·geometry)·or·a·surface·(in·3D·geometry)·bounded·by·a·closed·wire.·Its·geometry·is·constrained·(trimmed)·by·contours.·-·WIRE:·A·sequence·of·edges·connected·by·their·vertices.·It·can·be·open·or·closed·depending·on·whether·the·edges·are·linked·or·not.·-·EDGE:·A·single·dimensional·shape·corresponding·to·a·curve,·and·bound·by·a·vertex·at·each·extremity.·-·VERTEX:·A·zero-dimensional·shape·corresponding·to·a·point·in·geometry.)#")48 ····py::enum_<TopAbs_ShapeEnum>(m,·"TopAbs_ShapeEnum",R"#(Identifies·various·topological·shapes.·This·enumeration·allows·you·to·use·dynamic·typing·of·shapes.·The·values·are·listed·in·order·of·complexity,·from·the·most·complex·to·the·most·simple·i.e.·COMPOUND·>·COMPSOLID·>·SOLID·>·....·>·VERTEX·>·SHAPE.·Any·shape·can·contain·simpler·shapes·in·its·definition.·Abstract·topological·data·structure·describes·a·basic·entity,·the·shape·(present·in·this·enumeration·as·the·SHAPE·value),·which·can·be·divided·into·the·following·component·topologies:·-·COMPOUND:·A·group·of·any·of·the·shapes·below.·-·COMPSOLID:·A·set·of·solids·connected·by·their·faces.·This·expands·the·notions·of·WIRE·and·SHELL·to·solids.·-·SOLID:·A·part·of·3D·space·bounded·by·shells.·-·SHELL:·A·set·of·faces·connected·by·some·of·the·edges·of·their·wire·boundaries.·A·shell·can·be·open·or·closed.·-·FACE:·Part·of·a·plane·(in·2D·geometry)·or·a·surface·(in·3D·geometry)·bounded·by·a·closed·wire.·Its·geometry·is·constrained·(trimmed)·by·contours.·-·WIRE:·A·sequence·of·edges·connected·by·their·vertices.·It·can·be·open·or·closed·depending·on·whether·the·edges·are·linked·or·not.·-·EDGE:·A·single·dimensional·shape·corresponding·to·a·curve,·and·bound·by·a·vertex·at·each·extremity.·-·VERTEX:·A·zero-dimensional·shape·corresponding·to·a·point·in·geometry.)#")
44 ········.value("TopAbs_COMPOUND",TopAbs_ShapeEnum::TopAbs_COMPOUND)49 ········.value("TopAbs_COMPOUND",TopAbs_ShapeEnum::TopAbs_COMPOUND)
Offset 49, 19 lines modifiedOffset 54, 14 lines modified
49 ········.value("TopAbs_SOLID",TopAbs_ShapeEnum::TopAbs_SOLID)54 ········.value("TopAbs_SOLID",TopAbs_ShapeEnum::TopAbs_SOLID)
50 ········.value("TopAbs_SHELL",TopAbs_ShapeEnum::TopAbs_SHELL)55 ········.value("TopAbs_SHELL",TopAbs_ShapeEnum::TopAbs_SHELL)
51 ········.value("TopAbs_FACE",TopAbs_ShapeEnum::TopAbs_FACE)56 ········.value("TopAbs_FACE",TopAbs_ShapeEnum::TopAbs_FACE)
52 ········.value("TopAbs_WIRE",TopAbs_ShapeEnum::TopAbs_WIRE)57 ········.value("TopAbs_WIRE",TopAbs_ShapeEnum::TopAbs_WIRE)
53 ········.value("TopAbs_EDGE",TopAbs_ShapeEnum::TopAbs_EDGE)58 ········.value("TopAbs_EDGE",TopAbs_ShapeEnum::TopAbs_EDGE)
54 ········.value("TopAbs_VERTEX",TopAbs_ShapeEnum::TopAbs_VERTEX)59 ········.value("TopAbs_VERTEX",TopAbs_ShapeEnum::TopAbs_VERTEX)
55 ········.value("TopAbs_SHAPE",TopAbs_ShapeEnum::TopAbs_SHAPE).export_values();60 ········.value("TopAbs_SHAPE",TopAbs_ShapeEnum::TopAbs_SHAPE).export_values();
56 ····py::enum_<TopAbs_State>(m,·"TopAbs_State",R"#(Identifies·the·position·of·a·vertex·or·a·set·of·vertices·relative·to·a·region·of·a·shape.·The·figure·shown·above·illustrates·the·states·of·vertices·found·in·various·parts·of·the·edge·relative·to·the·face·which·it·intersects.)#") 
57 ········.value("TopAbs_IN",TopAbs_State::TopAbs_IN) 
58 ········.value("TopAbs_OUT",TopAbs_State::TopAbs_OUT) 
59 ········.value("TopAbs_ON",TopAbs_State::TopAbs_ON) 
60 ········.value("TopAbs_UNKNOWN",TopAbs_State::TopAbs_UNKNOWN).export_values(); 
  
61 //Python·trampoline·classes61 //Python·trampoline·classes
  
62 //·pre-register·typdefs+classes·(topologically·sorted)62 //·pre-register·typdefs+classes·(topologically·sorted)
63 ····py::class_<TopAbs·,·shared_ptr<TopAbs>··>(m,"TopAbs",R"#(This·package·gives·resources·for·Topology·oriented·applications·such·as·:·Topological·Data·Structure,·Topological·Algorithms.)#");63 ····py::class_<TopAbs·,·shared_ptr<TopAbs>··>(m,"TopAbs",R"#(This·package·gives·resources·for·Topology·oriented·applications·such·as·:·Topological·Data·Structure,·Topological·Algorithms.)#");
  
64 };64 };
⊟
2.59 KB
./usr/share/libocp/OCP/TopOpeBRepDS_pre.cpp
Ordering differences only
    
Offset 202, 17 lines modifiedOffset 202, 14 lines modified
202 py::module·m·=·main_module.def_submodule("TopOpeBRepDS",·R"#()#");202 py::module·m·=·main_module.def_submodule("TopOpeBRepDS",·R"#()#");
  
203 //·add·namespaces·as·submodules203 //·add·namespaces·as·submodules
  
204 //·user-defined·inclusion·per·module·in·the·body204 //·user-defined·inclusion·per·module·in·the·body
  
205 //·enums205 //·enums
206 ····py::enum_<TopOpeBRepDS_CheckStatus>(m,·"TopOpeBRepDS_CheckStatus",R"#()#") 
207 ········.value("TopOpeBRepDS_OK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_OK) 
208 ········.value("TopOpeBRepDS_NOK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_NOK).export_values(); 
209 ····py::enum_<TopOpeBRepDS_Kind>(m,·"TopOpeBRepDS_Kind",R"#(different·types·of·objects·in·DataStructure)#")206 ····py::enum_<TopOpeBRepDS_Kind>(m,·"TopOpeBRepDS_Kind",R"#(different·types·of·objects·in·DataStructure)#")
210 ········.value("TopOpeBRepDS_POINT",TopOpeBRepDS_Kind::TopOpeBRepDS_POINT)207 ········.value("TopOpeBRepDS_POINT",TopOpeBRepDS_Kind::TopOpeBRepDS_POINT)
211 ········.value("TopOpeBRepDS_CURVE",TopOpeBRepDS_Kind::TopOpeBRepDS_CURVE)208 ········.value("TopOpeBRepDS_CURVE",TopOpeBRepDS_Kind::TopOpeBRepDS_CURVE)
212 ········.value("TopOpeBRepDS_SURFACE",TopOpeBRepDS_Kind::TopOpeBRepDS_SURFACE)209 ········.value("TopOpeBRepDS_SURFACE",TopOpeBRepDS_Kind::TopOpeBRepDS_SURFACE)
213 ········.value("TopOpeBRepDS_VERTEX",TopOpeBRepDS_Kind::TopOpeBRepDS_VERTEX)210 ········.value("TopOpeBRepDS_VERTEX",TopOpeBRepDS_Kind::TopOpeBRepDS_VERTEX)
214 ········.value("TopOpeBRepDS_EDGE",TopOpeBRepDS_Kind::TopOpeBRepDS_EDGE)211 ········.value("TopOpeBRepDS_EDGE",TopOpeBRepDS_Kind::TopOpeBRepDS_EDGE)
215 ········.value("TopOpeBRepDS_WIRE",TopOpeBRepDS_Kind::TopOpeBRepDS_WIRE)212 ········.value("TopOpeBRepDS_WIRE",TopOpeBRepDS_Kind::TopOpeBRepDS_WIRE)
Offset 222, 14 lines modifiedOffset 219, 17 lines modified
222 ········.value("TopOpeBRepDS_COMPSOLID",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPSOLID)219 ········.value("TopOpeBRepDS_COMPSOLID",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPSOLID)
223 ········.value("TopOpeBRepDS_COMPOUND",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPOUND)220 ········.value("TopOpeBRepDS_COMPOUND",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPOUND)
224 ········.value("TopOpeBRepDS_UNKNOWN",TopOpeBRepDS_Kind::TopOpeBRepDS_UNKNOWN).export_values();221 ········.value("TopOpeBRepDS_UNKNOWN",TopOpeBRepDS_Kind::TopOpeBRepDS_UNKNOWN).export_values();
225 ····py::enum_<TopOpeBRepDS_Config>(m,·"TopOpeBRepDS_Config",R"#()#")222 ····py::enum_<TopOpeBRepDS_Config>(m,·"TopOpeBRepDS_Config",R"#()#")
226 ········.value("TopOpeBRepDS_UNSHGEOMETRY",TopOpeBRepDS_Config::TopOpeBRepDS_UNSHGEOMETRY)223 ········.value("TopOpeBRepDS_UNSHGEOMETRY",TopOpeBRepDS_Config::TopOpeBRepDS_UNSHGEOMETRY)
227 ········.value("TopOpeBRepDS_SAMEORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_SAMEORIENTED)224 ········.value("TopOpeBRepDS_SAMEORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_SAMEORIENTED)
228 ········.value("TopOpeBRepDS_DIFFORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_DIFFORIENTED).export_values();225 ········.value("TopOpeBRepDS_DIFFORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_DIFFORIENTED).export_values();
 226 ····py::enum_<TopOpeBRepDS_CheckStatus>(m,·"TopOpeBRepDS_CheckStatus",R"#()#")
 227 ········.value("TopOpeBRepDS_OK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_OK)
 228 ········.value("TopOpeBRepDS_NOK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_NOK).export_values();
  
229 //Python·trampoline·classes229 //Python·trampoline·classes
  
230 //·pre-register·typdefs+classes·(topologically·sorted)230 //·pre-register·typdefs+classes·(topologically·sorted)
231 ····py::class_<TopOpeBRepDS·,·shared_ptr<TopOpeBRepDS>··>(m,"TopOpeBRepDS",R"#(This·package·provides·services·used·by·the·TopOpeBRepBuild·package·performing·topological·operations·on·the·BRep·data·structure.)#");231 ····py::class_<TopOpeBRepDS·,·shared_ptr<TopOpeBRepDS>··>(m,"TopOpeBRepDS",R"#(This·package·provides·services·used·by·the·TopOpeBRepBuild·package·performing·topological·operations·on·the·BRep·data·structure.)#");
232 ····py::class_<TopOpeBRepDS_BuildTool·,·shared_ptr<TopOpeBRepDS_BuildTool>··>(m,"TopOpeBRepDS_BuildTool",R"#(Provides·a·Tool·to·build·topologies.·Used·to·instantiate·the·Builder·algorithm.)#");232 ····py::class_<TopOpeBRepDS_BuildTool·,·shared_ptr<TopOpeBRepDS_BuildTool>··>(m,"TopOpeBRepDS_BuildTool",R"#(Provides·a·Tool·to·build·topologies.·Used·to·instantiate·the·Builder·algorithm.)#");
233 ····py::class_<TopOpeBRepDS_Curve·,·shared_ptr<TopOpeBRepDS_Curve>··>(m,"TopOpeBRepDS_Curve",R"#(A·Geom·curve·and·a·tolerance.)#");233 ····py::class_<TopOpeBRepDS_Curve·,·shared_ptr<TopOpeBRepDS_Curve>··>(m,"TopOpeBRepDS_Curve",R"#(A·Geom·curve·and·a·tolerance.)#");
⊟
2.57 KB
./usr/share/libocp/OCP/TopOpeBRep_pre.cpp
Ordering differences only
    
Offset 146, 30 lines modifiedOffset 146, 30 lines modified
146 py::module·m·=·main_module.def_submodule("TopOpeBRep",·R"#()#");146 py::module·m·=·main_module.def_submodule("TopOpeBRep",·R"#()#");
  
147 //·add·namespaces·as·submodules147 //·add·namespaces·as·submodules
  
148 //·user-defined·inclusion·per·module·in·the·body148 //·user-defined·inclusion·per·module·in·the·body
  
149 //·enums149 //·enums
 150 ····py::enum_<TopOpeBRep_P2Dstatus>(m,·"TopOpeBRep_P2Dstatus",R"#()#")
 151 ········.value("TopOpeBRep_P2DUNK",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DUNK)
 152 ········.value("TopOpeBRep_P2DINT",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DINT)
 153 ········.value("TopOpeBRep_P2DSGF",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DSGF)
 154 ········.value("TopOpeBRep_P2DSGL",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DSGL)
 155 ········.value("TopOpeBRep_P2DNEW",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DNEW).export_values();
150 ····py::enum_<TopOpeBRep_TypeLineCurve>(m,·"TopOpeBRep_TypeLineCurve",R"#()#")156 ····py::enum_<TopOpeBRep_TypeLineCurve>(m,·"TopOpeBRep_TypeLineCurve",R"#()#")
151 ········.value("TopOpeBRep_ANALYTIC",TopOpeBRep_TypeLineCurve::TopOpeBRep_ANALYTIC)157 ········.value("TopOpeBRep_ANALYTIC",TopOpeBRep_TypeLineCurve::TopOpeBRep_ANALYTIC)
152 ········.value("TopOpeBRep_RESTRICTION",TopOpeBRep_TypeLineCurve::TopOpeBRep_RESTRICTION)158 ········.value("TopOpeBRep_RESTRICTION",TopOpeBRep_TypeLineCurve::TopOpeBRep_RESTRICTION)
153 ········.value("TopOpeBRep_WALKING",TopOpeBRep_TypeLineCurve::TopOpeBRep_WALKING)159 ········.value("TopOpeBRep_WALKING",TopOpeBRep_TypeLineCurve::TopOpeBRep_WALKING)
154 ········.value("TopOpeBRep_LINE",TopOpeBRep_TypeLineCurve::TopOpeBRep_LINE)160 ········.value("TopOpeBRep_LINE",TopOpeBRep_TypeLineCurve::TopOpeBRep_LINE)
155 ········.value("TopOpeBRep_CIRCLE",TopOpeBRep_TypeLineCurve::TopOpeBRep_CIRCLE)161 ········.value("TopOpeBRep_CIRCLE",TopOpeBRep_TypeLineCurve::TopOpeBRep_CIRCLE)
156 ········.value("TopOpeBRep_ELLIPSE",TopOpeBRep_TypeLineCurve::TopOpeBRep_ELLIPSE)162 ········.value("TopOpeBRep_ELLIPSE",TopOpeBRep_TypeLineCurve::TopOpeBRep_ELLIPSE)
157 ········.value("TopOpeBRep_PARABOLA",TopOpeBRep_TypeLineCurve::TopOpeBRep_PARABOLA)163 ········.value("TopOpeBRep_PARABOLA",TopOpeBRep_TypeLineCurve::TopOpeBRep_PARABOLA)
158 ········.value("TopOpeBRep_HYPERBOLA",TopOpeBRep_TypeLineCurve::TopOpeBRep_HYPERBOLA)164 ········.value("TopOpeBRep_HYPERBOLA",TopOpeBRep_TypeLineCurve::TopOpeBRep_HYPERBOLA)
159 ········.value("TopOpeBRep_OTHERTYPE",TopOpeBRep_TypeLineCurve::TopOpeBRep_OTHERTYPE).export_values();165 ········.value("TopOpeBRep_OTHERTYPE",TopOpeBRep_TypeLineCurve::TopOpeBRep_OTHERTYPE).export_values();
160 ····py::enum_<TopOpeBRep_P2Dstatus>(m,·"TopOpeBRep_P2Dstatus",R"#()#") 
161 ········.value("TopOpeBRep_P2DUNK",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DUNK) 
162 ········.value("TopOpeBRep_P2DINT",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DINT) 
163 ········.value("TopOpeBRep_P2DSGF",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DSGF) 
164 ········.value("TopOpeBRep_P2DSGL",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DSGL) 
165 ········.value("TopOpeBRep_P2DNEW",TopOpeBRep_P2Dstatus::TopOpeBRep_P2DNEW).export_values(); 
  
166 //Python·trampoline·classes166 //Python·trampoline·classes
  
167 //·pre-register·typdefs+classes·(topologically·sorted)167 //·pre-register·typdefs+classes·(topologically·sorted)
168 ····py::class_<TopOpeBRep·,·shared_ptr<TopOpeBRep>··>(m,"TopOpeBRep",R"#(This·package·provides·the·topological·operations·on·the·BRep·data·structure.)#");168 ····py::class_<TopOpeBRep·,·shared_ptr<TopOpeBRep>··>(m,"TopOpeBRep",R"#(This·package·provides·the·topological·operations·on·the·BRep·data·structure.)#");
169 ····py::class_<TopOpeBRep_Bipoint·,·shared_ptr<TopOpeBRep_Bipoint>··>(m,"TopOpeBRep_Bipoint",R"#()#");169 ····py::class_<TopOpeBRep_Bipoint·,·shared_ptr<TopOpeBRep_Bipoint>··>(m,"TopOpeBRep_Bipoint",R"#()#");
170 ····py::class_<TopOpeBRep_DSFiller·,·shared_ptr<TopOpeBRep_DSFiller>··>(m,"TopOpeBRep_DSFiller",R"#(Provides·class·methods·to·fill·a·datastructure·with·results·of·intersections.)#");170 ····py::class_<TopOpeBRep_DSFiller·,·shared_ptr<TopOpeBRep_DSFiller>··>(m,"TopOpeBRep_DSFiller",R"#(Provides·class·methods·to·fill·a·datastructure·with·results·of·intersections.)#");
⊟
4.08 KB
./usr/share/libocp/OCP/TopoDSToStep_pre.cpp
Ordering differences only
    
Offset 122, 39 lines modifiedOffset 122, 39 lines modified
122 py::module·m·=·main_module.def_submodule("TopoDSToStep",·R"#()#");122 py::module·m·=·main_module.def_submodule("TopoDSToStep",·R"#()#");
  
123 //·add·namespaces·as·submodules123 //·add·namespaces·as·submodules
  
124 //·user-defined·inclusion·per·module·in·the·body124 //·user-defined·inclusion·per·module·in·the·body
  
125 //·enums125 //·enums
126 ····py::enum_<TopoDSToStep_MakeVertexError>(m,·"TopoDSToStep_MakeVertexError",R"#()#") 
127 ········.value("TopoDSToStep_VertexDone",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexDone) 
128 ········.value("TopoDSToStep_VertexOther",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexOther).export_values(); 
129 ····py::enum_<TopoDSToStep_BuilderError>(m,·"TopoDSToStep_BuilderError",R"#()#")126 ····py::enum_<TopoDSToStep_BuilderError>(m,·"TopoDSToStep_BuilderError",R"#()#")
130 ········.value("TopoDSToStep_BuilderDone",TopoDSToStep_BuilderError::TopoDSToStep_BuilderDone)127 ········.value("TopoDSToStep_BuilderDone",TopoDSToStep_BuilderError::TopoDSToStep_BuilderDone)
131 ········.value("TopoDSToStep_NoFaceMapped",TopoDSToStep_BuilderError::TopoDSToStep_NoFaceMapped)128 ········.value("TopoDSToStep_NoFaceMapped",TopoDSToStep_BuilderError::TopoDSToStep_NoFaceMapped)
132 ········.value("TopoDSToStep_BuilderOther",TopoDSToStep_BuilderError::TopoDSToStep_BuilderOther).export_values();129 ········.value("TopoDSToStep_BuilderOther",TopoDSToStep_BuilderError::TopoDSToStep_BuilderOther).export_values();
 130 ····py::enum_<TopoDSToStep_MakeWireError>(m,·"TopoDSToStep_MakeWireError",R"#()#")
 131 ········.value("TopoDSToStep_WireDone",TopoDSToStep_MakeWireError::TopoDSToStep_WireDone)
 132 ········.value("TopoDSToStep_NonManifoldWire",TopoDSToStep_MakeWireError::TopoDSToStep_NonManifoldWire)
 133 ········.value("TopoDSToStep_WireOther",TopoDSToStep_MakeWireError::TopoDSToStep_WireOther).export_values();
133 ····py::enum_<TopoDSToStep_FacetedError>(m,·"TopoDSToStep_FacetedError",R"#()#")134 ····py::enum_<TopoDSToStep_FacetedError>(m,·"TopoDSToStep_FacetedError",R"#()#")
134 ········.value("TopoDSToStep_FacetedDone",TopoDSToStep_FacetedError::TopoDSToStep_FacetedDone)135 ········.value("TopoDSToStep_FacetedDone",TopoDSToStep_FacetedError::TopoDSToStep_FacetedDone)
135 ········.value("TopoDSToStep_SurfaceNotPlane",TopoDSToStep_FacetedError::TopoDSToStep_SurfaceNotPlane)136 ········.value("TopoDSToStep_SurfaceNotPlane",TopoDSToStep_FacetedError::TopoDSToStep_SurfaceNotPlane)
136 ········.value("TopoDSToStep_PCurveNotLinear",TopoDSToStep_FacetedError::TopoDSToStep_PCurveNotLinear).export_values();137 ········.value("TopoDSToStep_PCurveNotLinear",TopoDSToStep_FacetedError::TopoDSToStep_PCurveNotLinear).export_values();
137 ····py::enum_<TopoDSToStep_MakeFaceError>(m,·"TopoDSToStep_MakeFaceError",R"#()#")138 ····py::enum_<TopoDSToStep_MakeFaceError>(m,·"TopoDSToStep_MakeFaceError",R"#()#")
138 ········.value("TopoDSToStep_FaceDone",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceDone)139 ········.value("TopoDSToStep_FaceDone",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceDone)
139 ········.value("TopoDSToStep_InfiniteFace",TopoDSToStep_MakeFaceError::TopoDSToStep_InfiniteFace)140 ········.value("TopoDSToStep_InfiniteFace",TopoDSToStep_MakeFaceError::TopoDSToStep_InfiniteFace)
140 ········.value("TopoDSToStep_NonManifoldFace",TopoDSToStep_MakeFaceError::TopoDSToStep_NonManifoldFace)141 ········.value("TopoDSToStep_NonManifoldFace",TopoDSToStep_MakeFaceError::TopoDSToStep_NonManifoldFace)
141 ········.value("TopoDSToStep_NoWireMapped",TopoDSToStep_MakeFaceError::TopoDSToStep_NoWireMapped)142 ········.value("TopoDSToStep_NoWireMapped",TopoDSToStep_MakeFaceError::TopoDSToStep_NoWireMapped)
142 ········.value("TopoDSToStep_FaceOther",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceOther).export_values();143 ········.value("TopoDSToStep_FaceOther",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceOther).export_values();
 144 ····py::enum_<TopoDSToStep_MakeVertexError>(m,·"TopoDSToStep_MakeVertexError",R"#()#")
 145 ········.value("TopoDSToStep_VertexDone",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexDone)
 146 ········.value("TopoDSToStep_VertexOther",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexOther).export_values();
143 ····py::enum_<TopoDSToStep_MakeEdgeError>(m,·"TopoDSToStep_MakeEdgeError",R"#()#")147 ····py::enum_<TopoDSToStep_MakeEdgeError>(m,·"TopoDSToStep_MakeEdgeError",R"#()#")
144 ········.value("TopoDSToStep_EdgeDone",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeDone)148 ········.value("TopoDSToStep_EdgeDone",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeDone)
145 ········.value("TopoDSToStep_NonManifoldEdge",TopoDSToStep_MakeEdgeError::TopoDSToStep_NonManifoldEdge)149 ········.value("TopoDSToStep_NonManifoldEdge",TopoDSToStep_MakeEdgeError::TopoDSToStep_NonManifoldEdge)
146 ········.value("TopoDSToStep_EdgeOther",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeOther).export_values();150 ········.value("TopoDSToStep_EdgeOther",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeOther).export_values();
147 ····py::enum_<TopoDSToStep_MakeWireError>(m,·"TopoDSToStep_MakeWireError",R"#()#") 
148 ········.value("TopoDSToStep_WireDone",TopoDSToStep_MakeWireError::TopoDSToStep_WireDone) 
149 ········.value("TopoDSToStep_NonManifoldWire",TopoDSToStep_MakeWireError::TopoDSToStep_NonManifoldWire) 
150 ········.value("TopoDSToStep_WireOther",TopoDSToStep_MakeWireError::TopoDSToStep_WireOther).export_values(); 
  
151 //Python·trampoline·classes151 //Python·trampoline·classes
  
152 //·pre-register·typdefs+classes·(topologically·sorted)152 //·pre-register·typdefs+classes·(topologically·sorted)
153 ····py::class_<TopoDSToStep·,·shared_ptr<TopoDSToStep>··>(m,"TopoDSToStep",R"#(This·package·implements·the·mapping·between·CAS.CAD·Shape·representation·and·AP214·Shape·Representation.·The·target·schema·is·pms_c4·(a·subset·of·AP214))#");153 ····py::class_<TopoDSToStep·,·shared_ptr<TopoDSToStep>··>(m,"TopoDSToStep",R"#(This·package·implements·the·mapping·between·CAS.CAD·Shape·representation·and·AP214·Shape·Representation.·The·target·schema·is·pms_c4·(a·subset·of·AP214))#");
154 ····py::class_<TopoDSToStep_FacetedTool·,·shared_ptr<TopoDSToStep_FacetedTool>··>(m,"TopoDSToStep_FacetedTool",R"#(This·Tool·Class·provides·Information·about·Faceted·Shapes·to·be·mapped·to·STEP.)#");154 ····py::class_<TopoDSToStep_FacetedTool·,·shared_ptr<TopoDSToStep_FacetedTool>··>(m,"TopoDSToStep_FacetedTool",R"#(This·Tool·Class·provides·Information·about·Faceted·Shapes·to·be·mapped·to·STEP.)#");
155 ····py::class_<TopoDSToStep_Root·,·shared_ptr<TopoDSToStep_Root>··>(m,"TopoDSToStep_Root",R"#(This·class·implements·the·common·services·for·all·classes·of·TopoDSToStep·which·report·error.)#");155 ····py::class_<TopoDSToStep_Root·,·shared_ptr<TopoDSToStep_Root>··>(m,"TopoDSToStep_Root",R"#(This·class·implements·the·common·services·for·all·classes·of·TopoDSToStep·which·report·error.)#");
⊟
2.28 KB
./usr/share/libocp/OCP/Transfer_pre.cpp
Ordering differences only
    
Offset 139, 29 lines modifiedOffset 139, 29 lines modified
139 py::module·m·=·main_module.def_submodule("Transfer",·R"#()#");139 py::module·m·=·main_module.def_submodule("Transfer",·R"#()#");
  
140 //·add·namespaces·as·submodules140 //·add·namespaces·as·submodules
  
141 //·user-defined·inclusion·per·module·in·the·body141 //·user-defined·inclusion·per·module·in·the·body
  
142 //·enums142 //·enums
143 ····py::enum_<Transfer_UndefMode>(m,·"Transfer_UndefMode",R"#(used·on·processing·Undefined·Entities·(see·TransferOutput))#") 
144 ········.value("Transfer_UndefIgnore",Transfer_UndefMode::Transfer_UndefIgnore) 
145 ········.value("Transfer_UndefFailure",Transfer_UndefMode::Transfer_UndefFailure) 
146 ········.value("Transfer_UndefContent",Transfer_UndefMode::Transfer_UndefContent) 
147 ········.value("Transfer_UndefUser",Transfer_UndefMode::Transfer_UndefUser).export_values(); 
148 ····py::enum_<Transfer_StatusExec>(m,·"Transfer_StatusExec",R"#(execution·status·of·an·individual·transfer·(see·Transcriptor))#")143 ····py::enum_<Transfer_StatusExec>(m,·"Transfer_StatusExec",R"#(execution·status·of·an·individual·transfer·(see·Transcriptor))#")
149 ········.value("Transfer_StatusInitial",Transfer_StatusExec::Transfer_StatusInitial)144 ········.value("Transfer_StatusInitial",Transfer_StatusExec::Transfer_StatusInitial)
150 ········.value("Transfer_StatusRun",Transfer_StatusExec::Transfer_StatusRun)145 ········.value("Transfer_StatusRun",Transfer_StatusExec::Transfer_StatusRun)
151 ········.value("Transfer_StatusDone",Transfer_StatusExec::Transfer_StatusDone)146 ········.value("Transfer_StatusDone",Transfer_StatusExec::Transfer_StatusDone)
152 ········.value("Transfer_StatusError",Transfer_StatusExec::Transfer_StatusError)147 ········.value("Transfer_StatusError",Transfer_StatusExec::Transfer_StatusError)
153 ········.value("Transfer_StatusLoop",Transfer_StatusExec::Transfer_StatusLoop).export_values();148 ········.value("Transfer_StatusLoop",Transfer_StatusExec::Transfer_StatusLoop).export_values();
154 ····py::enum_<Transfer_StatusResult>(m,·"Transfer_StatusResult",R"#(result·status·of·transferring·an·entity·(see·Transcriptor))#")149 ····py::enum_<Transfer_StatusResult>(m,·"Transfer_StatusResult",R"#(result·status·of·transferring·an·entity·(see·Transcriptor))#")
155 ········.value("Transfer_StatusVoid",Transfer_StatusResult::Transfer_StatusVoid)150 ········.value("Transfer_StatusVoid",Transfer_StatusResult::Transfer_StatusVoid)
156 ········.value("Transfer_StatusDefined",Transfer_StatusResult::Transfer_StatusDefined)151 ········.value("Transfer_StatusDefined",Transfer_StatusResult::Transfer_StatusDefined)
157 ········.value("Transfer_StatusUsed",Transfer_StatusResult::Transfer_StatusUsed).export_values();152 ········.value("Transfer_StatusUsed",Transfer_StatusResult::Transfer_StatusUsed).export_values();
 153 ····py::enum_<Transfer_UndefMode>(m,·"Transfer_UndefMode",R"#(used·on·processing·Undefined·Entities·(see·TransferOutput))#")
 154 ········.value("Transfer_UndefIgnore",Transfer_UndefMode::Transfer_UndefIgnore)
 155 ········.value("Transfer_UndefFailure",Transfer_UndefMode::Transfer_UndefFailure)
 156 ········.value("Transfer_UndefContent",Transfer_UndefMode::Transfer_UndefContent)
 157 ········.value("Transfer_UndefUser",Transfer_UndefMode::Transfer_UndefUser).export_values();
  
158 //Python·trampoline·classes158 //Python·trampoline·classes
159 ····class·Py_Transfer_Binder·:·public·Transfer_Binder{159 ····class·Py_Transfer_Binder·:·public·Transfer_Binder{
160 ····public:160 ····public:
161 ········using·Transfer_Binder::Transfer_Binder;161 ········using·Transfer_Binder::Transfer_Binder;
  
  
⊟
4.45 KB
./usr/share/libocp/OCP/V3d_pre.cpp
Ordering differences only
    
Offset 78, 19 lines modifiedOffset 78, 14 lines modified
78 py::module·m·=·main_module.def_submodule("V3d",·R"#()#");78 py::module·m·=·main_module.def_submodule("V3d",·R"#()#");
  
79 //·add·namespaces·as·submodules79 //·add·namespaces·as·submodules
  
80 //·user-defined·inclusion·per·module·in·the·body80 //·user-defined·inclusion·per·module·in·the·body
  
81 //·enums81 //·enums
82 ····py::enum_<V3d_StereoDumpOptions>(m,·"V3d_StereoDumpOptions",R"#(Options·to·be·used·with·image·dumping.·Notice·that·the·value·will·have·no·effect·with·disabled·stereo·output.)#") 
83 ········.value("V3d_SDO_MONO",V3d_StereoDumpOptions::V3d_SDO_MONO) 
84 ········.value("V3d_SDO_LEFT_EYE",V3d_StereoDumpOptions::V3d_SDO_LEFT_EYE) 
85 ········.value("V3d_SDO_RIGHT_EYE",V3d_StereoDumpOptions::V3d_SDO_RIGHT_EYE) 
86 ········.value("V3d_SDO_BLENDED",V3d_StereoDumpOptions::V3d_SDO_BLENDED).export_values(); 
87 ····py::enum_<V3d_TypeOfOrientation>(m,·"V3d_TypeOfOrientation",R"#(Determines·the·type·of·orientation·as·a·combination·of·standard·DX/DY/DZ·directions.·This·enumeration·defines·a·model·orientation·looking·towards·the·user's·eye,·which·is·an·opposition·to·Camera·main·direction.·For·example,·V3d_Xneg·defines·+X·Camera·main·direction.)#")82 ····py::enum_<V3d_TypeOfOrientation>(m,·"V3d_TypeOfOrientation",R"#(Determines·the·type·of·orientation·as·a·combination·of·standard·DX/DY/DZ·directions.·This·enumeration·defines·a·model·orientation·looking·towards·the·user's·eye,·which·is·an·opposition·to·Camera·main·direction.·For·example,·V3d_Xneg·defines·+X·Camera·main·direction.)#")
88 ········.value("V3d_Xpos",V3d_TypeOfOrientation::V3d_Xpos)83 ········.value("V3d_Xpos",V3d_TypeOfOrientation::V3d_Xpos)
89 ········.value("V3d_Ypos",V3d_TypeOfOrientation::V3d_Ypos)84 ········.value("V3d_Ypos",V3d_TypeOfOrientation::V3d_Ypos)
90 ········.value("V3d_Zpos",V3d_TypeOfOrientation::V3d_Zpos)85 ········.value("V3d_Zpos",V3d_TypeOfOrientation::V3d_Zpos)
91 ········.value("V3d_Xneg",V3d_TypeOfOrientation::V3d_Xneg)86 ········.value("V3d_Xneg",V3d_TypeOfOrientation::V3d_Xneg)
92 ········.value("V3d_Yneg",V3d_TypeOfOrientation::V3d_Yneg)87 ········.value("V3d_Yneg",V3d_TypeOfOrientation::V3d_Yneg)
93 ········.value("V3d_Zneg",V3d_TypeOfOrientation::V3d_Zneg)88 ········.value("V3d_Zneg",V3d_TypeOfOrientation::V3d_Zneg)
Offset 126, 24 lines modifiedOffset 121, 29 lines modified
126 ········.value("V3d_TypeOfOrientation_Yup_AxoRight",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_AxoRight)121 ········.value("V3d_TypeOfOrientation_Yup_AxoRight",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_AxoRight)
127 ········.value("V3d_TypeOfOrientation_Yup_Front",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Front)122 ········.value("V3d_TypeOfOrientation_Yup_Front",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Front)
128 ········.value("V3d_TypeOfOrientation_Yup_Back",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Back)123 ········.value("V3d_TypeOfOrientation_Yup_Back",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Back)
129 ········.value("V3d_TypeOfOrientation_Yup_Top",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Top)124 ········.value("V3d_TypeOfOrientation_Yup_Top",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Top)
130 ········.value("V3d_TypeOfOrientation_Yup_Bottom",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Bottom)125 ········.value("V3d_TypeOfOrientation_Yup_Bottom",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Bottom)
131 ········.value("V3d_TypeOfOrientation_Yup_Left",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Left)126 ········.value("V3d_TypeOfOrientation_Yup_Left",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Left)
132 ········.value("V3d_TypeOfOrientation_Yup_Right",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Right).export_values();127 ········.value("V3d_TypeOfOrientation_Yup_Right",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Right).export_values();
 128 ····py::enum_<V3d_TypeOfAxe>(m,·"V3d_TypeOfAxe",R"#(Determines·the·axis·type·through·the·coordinates·X,·Y,·Z.)#")
 129 ········.value("V3d_X",V3d_TypeOfAxe::V3d_X)
 130 ········.value("V3d_Y",V3d_TypeOfAxe::V3d_Y)
 131 ········.value("V3d_Z",V3d_TypeOfAxe::V3d_Z).export_values();
133 ····py::enum_<V3d_TypeOfView>(m,·"V3d_TypeOfView",R"#(Defines·the·type·of·projection·of·the·view.)#")132 ····py::enum_<V3d_TypeOfView>(m,·"V3d_TypeOfView",R"#(Defines·the·type·of·projection·of·the·view.)#")
134 ········.value("V3d_ORTHOGRAPHIC",V3d_TypeOfView::V3d_ORTHOGRAPHIC)133 ········.value("V3d_ORTHOGRAPHIC",V3d_TypeOfView::V3d_ORTHOGRAPHIC)
135 ········.value("V3d_PERSPECTIVE",V3d_TypeOfView::V3d_PERSPECTIVE).export_values();134 ········.value("V3d_PERSPECTIVE",V3d_TypeOfView::V3d_PERSPECTIVE).export_values();
136 ····py::enum_<V3d_TypeOfVisualization>(m,·"V3d_TypeOfVisualization",R"#(Determines·the·type·of·visualization·in·the·view,·either·WIREFRAME·or·ZBUFFER·(shading).)#")135 ····py::enum_<V3d_TypeOfVisualization>(m,·"V3d_TypeOfVisualization",R"#(Determines·the·type·of·visualization·in·the·view,·either·WIREFRAME·or·ZBUFFER·(shading).)#")
137 ········.value("V3d_WIREFRAME",V3d_TypeOfVisualization::V3d_WIREFRAME)136 ········.value("V3d_WIREFRAME",V3d_TypeOfVisualization::V3d_WIREFRAME)
138 ········.value("V3d_ZBUFFER",V3d_TypeOfVisualization::V3d_ZBUFFER).export_values();137 ········.value("V3d_ZBUFFER",V3d_TypeOfVisualization::V3d_ZBUFFER).export_values();
139 ····py::enum_<V3d_TypeOfAxe>(m,·"V3d_TypeOfAxe",R"#(Determines·the·axis·type·through·the·coordinates·X,·Y,·Z.)#") 
140 ········.value("V3d_X",V3d_TypeOfAxe::V3d_X) 
141 ········.value("V3d_Y",V3d_TypeOfAxe::V3d_Y) 
142 ········.value("V3d_Z",V3d_TypeOfAxe::V3d_Z).export_values();138 ····py::enum_<V3d_StereoDumpOptions>(m,·"V3d_StereoDumpOptions",R"#(Options·to·be·used·with·image·dumping.·Notice·that·the·value·will·have·no·effect·with·disabled·stereo·output.)#")
 139 ········.value("V3d_SDO_MONO",V3d_StereoDumpOptions::V3d_SDO_MONO)
 140 ········.value("V3d_SDO_LEFT_EYE",V3d_StereoDumpOptions::V3d_SDO_LEFT_EYE)
 141 ········.value("V3d_SDO_RIGHT_EYE",V3d_StereoDumpOptions::V3d_SDO_RIGHT_EYE)
 142 ········.value("V3d_SDO_BLENDED",V3d_StereoDumpOptions::V3d_SDO_BLENDED).export_values();
  
143 //Python·trampoline·classes143 //Python·trampoline·classes
  
144 //·pre-register·typdefs+classes·(topologically·sorted)144 //·pre-register·typdefs+classes·(topologically·sorted)
145 ····py::class_<V3d·,·shared_ptr<V3d>··>(m,"V3d",R"#(This·package·contains·the·set·of·commands·and·services·of·the·3D·Viewer.·It·provides·a·set·of·high·level·commands·to·control·the·views·and·viewing·modes.)#");145 ····py::class_<V3d·,·shared_ptr<V3d>··>(m,"V3d",R"#(This·package·contains·the·set·of·commands·and·services·of·the·3D·Viewer.·It·provides·a·set·of·high·level·commands·to·control·the·views·and·viewing·modes.)#");
146 ····py::class_<V3d_ImageDumpOptions·,·shared_ptr<V3d_ImageDumpOptions>··>(m,"V3d_ImageDumpOptions",R"#(The·structure·defines·options·for·image·dump·functionality.)#");146 ····py::class_<V3d_ImageDumpOptions·,·shared_ptr<V3d_ImageDumpOptions>··>(m,"V3d_ImageDumpOptions",R"#(The·structure·defines·options·for·image·dump·functionality.)#");
147 ····py::class_<V3d_AmbientLight·,opencascade::handle<V3d_AmbientLight>··,·Graphic3d_CLight·>(m,"V3d_AmbientLight",R"#(Creation·of·an·ambient·light·source·in·a·viewer.Creation·of·an·ambient·light·source·in·a·viewer.)#");147 ····py::class_<V3d_AmbientLight·,opencascade::handle<V3d_AmbientLight>··,·Graphic3d_CLight·>(m,"V3d_AmbientLight",R"#(Creation·of·an·ambient·light·source·in·a·viewer.Creation·of·an·ambient·light·source·in·a·viewer.)#");
⊟
33.7 KB
./usr/share/libocp/OCP/XCAFDimTolObjects_pre.cpp
Ordering differences only
    
Offset 88, 51 lines modifiedOffset 88, 43 lines modified
88 ········.value("XCAFDimTolObjects_GeomToleranceType_Perpendicularity",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Perpendicularity)88 ········.value("XCAFDimTolObjects_GeomToleranceType_Perpendicularity",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Perpendicularity)
89 ········.value("XCAFDimTolObjects_GeomToleranceType_Position",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Position)89 ········.value("XCAFDimTolObjects_GeomToleranceType_Position",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Position)
90 ········.value("XCAFDimTolObjects_GeomToleranceType_ProfileOfLine",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_ProfileOfLine)90 ········.value("XCAFDimTolObjects_GeomToleranceType_ProfileOfLine",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_ProfileOfLine)
91 ········.value("XCAFDimTolObjects_GeomToleranceType_ProfileOfSurface",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_ProfileOfSurface)91 ········.value("XCAFDimTolObjects_GeomToleranceType_ProfileOfSurface",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_ProfileOfSurface)
92 ········.value("XCAFDimTolObjects_GeomToleranceType_Straightness",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Straightness)92 ········.value("XCAFDimTolObjects_GeomToleranceType_Straightness",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Straightness)
93 ········.value("XCAFDimTolObjects_GeomToleranceType_Symmetry",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Symmetry)93 ········.value("XCAFDimTolObjects_GeomToleranceType_Symmetry",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_Symmetry)
94 ········.value("XCAFDimTolObjects_GeomToleranceType_TotalRunout",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_TotalRunout).export_values();94 ········.value("XCAFDimTolObjects_GeomToleranceType_TotalRunout",XCAFDimTolObjects_GeomToleranceType::XCAFDimTolObjects_GeomToleranceType_TotalRunout).export_values();
 95 ····py::enum_<XCAFDimTolObjects_DatumModifWithValue>(m,·"XCAFDimTolObjects_DatumModifWithValue",R"#(Defines·modifirs)#")
 96 ········.value("XCAFDimTolObjects_DatumModifWithValue_None",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_None)
 97 ········.value("XCAFDimTolObjects_DatumModifWithValue_CircularOrCylindrical",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_CircularOrCylindrical)
 98 ········.value("XCAFDimTolObjects_DatumModifWithValue_Distance",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_Distance)
 99 ········.value("XCAFDimTolObjects_DatumModifWithValue_Projected",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_Projected)
 100 ········.value("XCAFDimTolObjects_DatumModifWithValue_Spherical",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_Spherical).export_values();
95 ····py::enum_<XCAFDimTolObjects_GeomToleranceZoneModif>(m,·"XCAFDimTolObjects_GeomToleranceZoneModif",R"#(Defines·types·of·zone)#") 
96 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_None",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_None) 
97 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_Projected",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_Projected) 
98 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_Runout",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_Runout) 
99 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_NonUniform",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_NonUniform).export_values(); 
100 ····py::enum_<XCAFDimTolObjects_GeomToleranceTypeValue>(m,·"XCAFDimTolObjects_GeomToleranceTypeValue",R"#(Defines·types·of·value·of·tolerane)#") 
101 ········.value("XCAFDimTolObjects_GeomToleranceTypeValue_None",XCAFDimTolObjects_GeomToleranceTypeValue::XCAFDimTolObjects_GeomToleranceTypeValue_None) 
102 ········.value("XCAFDimTolObjects_GeomToleranceTypeValue_Diameter",XCAFDimTolObjects_GeomToleranceTypeValue::XCAFDimTolObjects_GeomToleranceTypeValue_Diameter) 
103 ········.value("XCAFDimTolObjects_GeomToleranceTypeValue_SphericalDiameter",XCAFDimTolObjects_GeomToleranceTypeValue::XCAFDimTolObjects_GeomToleranceTypeValue_SphericalDiameter).export_values(); 
104 ····py::enum_<XCAFDimTolObjects_ToleranceZoneAffectedPlane>(m,·"XCAFDimTolObjects_ToleranceZoneAffectedPlane",R"#(Defines·types·of·tolerance·zone·affected·plane)#") 
105 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_None",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_None) 
106 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_Intersection",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_Intersection) 
107 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_Orientation",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_Orientation).export_values(); 
108 ····py::enum_<XCAFDimTolObjects_GeomToleranceModif>(m,·"XCAFDimTolObjects_GeomToleranceModif",R"#(Defines·modifirs)#")101 ····py::enum_<XCAFDimTolObjects_DatumSingleModif>(m,·"XCAFDimTolObjects_DatumSingleModif",R"#(Defines·modifirs)#")
109 ········.value("XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section)102 ········.value("XCAFDimTolObjects_DatumSingleModif_AnyCrossSection",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_AnyCrossSection)
110 ········.value("XCAFDimTolObjects_GeomToleranceModif_Common_Zone",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Common_Zone) 
111 ········.value("XCAFDimTolObjects_GeomToleranceModif_Each_Radial_Element",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Each_Radial_Element)103 ········.value("XCAFDimTolObjects_DatumSingleModif_Any_LongitudinalSection",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Any_LongitudinalSection)
 104 ········.value("XCAFDimTolObjects_DatumSingleModif_Basic",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Basic)
 105 ········.value("XCAFDimTolObjects_DatumSingleModif_ContactingFeature",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_ContactingFeature)
 106 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintU",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintU)
 107 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintV",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintV)
 108 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintW",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintW)
 109 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintX",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintX)
 110 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintY",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintY)
 111 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintZ",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintZ)
 112 ········.value("XCAFDimTolObjects_DatumSingleModif_DistanceVariable",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DistanceVariable)
112 ········.value("XCAFDimTolObjects_GeomToleranceModif_Free_State",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Free_State)113 ········.value("XCAFDimTolObjects_DatumSingleModif_FreeState",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_FreeState)
113 ········.value("XCAFDimTolObjects_GeomToleranceModif_Least_Material_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Least_Material_Requirement)114 ········.value("XCAFDimTolObjects_DatumSingleModif_LeastMaterialRequirement",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_LeastMaterialRequirement)
114 ········.value("XCAFDimTolObjects_GeomToleranceModif_Line_Element",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Line_Element)115 ········.value("XCAFDimTolObjects_DatumSingleModif_Line",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Line)
115 ········.value("XCAFDimTolObjects_GeomToleranceModif_Major_Diameter",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Major_Diameter)116 ········.value("XCAFDimTolObjects_DatumSingleModif_MajorDiameter",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_MajorDiameter)
116 ········.value("XCAFDimTolObjects_GeomToleranceModif_Maximum_Material_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Maximum_Material_Requirement)117 ········.value("XCAFDimTolObjects_DatumSingleModif_MaximumMaterialRequirement",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_MaximumMaterialRequirement)
117 ········.value("XCAFDimTolObjects_GeomToleranceModif_Minor_Diameter",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Minor_Diameter)118 ········.value("XCAFDimTolObjects_DatumSingleModif_MinorDiameter",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_MinorDiameter)
118 ········.value("XCAFDimTolObjects_GeomToleranceModif_Not_Convex",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Not_Convex)119 ········.value("XCAFDimTolObjects_DatumSingleModif_Orientation",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Orientation)
119 ········.value("XCAFDimTolObjects_GeomToleranceModif_Pitch_Diameter",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Pitch_Diameter)120 ········.value("XCAFDimTolObjects_DatumSingleModif_PitchDiameter",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_PitchDiameter)
120 ········.value("XCAFDimTolObjects_GeomToleranceModif_Reciprocity_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Reciprocity_Requirement) 
121 ········.value("XCAFDimTolObjects_GeomToleranceModif_Separate_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Separate_Requirement) 
122 ········.value("XCAFDimTolObjects_GeomToleranceModif_Statistical_Tolerance",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Statistical_Tolerance) 
123 ········.value("XCAFDimTolObjects_GeomToleranceModif_Tangent_Plane",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Tangent_Plane)121 ········.value("XCAFDimTolObjects_DatumSingleModif_Plane",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Plane)
124 ········.value("XCAFDimTolObjects_GeomToleranceModif_All_Around",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_All_Around) 
125 ········.value("XCAFDimTolObjects_GeomToleranceModif_All_Over",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_All_Over).export_values(); 
126 ····py::enum_<XCAFDimTolObjects_DatumTargetType>(m,·"XCAFDimTolObjects_DatumTargetType",R"#(Defines·types·of·dimension)#") 
127 ········.value("XCAFDimTolObjects_DatumTargetType_Point",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Point)122 ········.value("XCAFDimTolObjects_DatumSingleModif_Point",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Point)
 123 ········.value("XCAFDimTolObjects_DatumSingleModif_Translation",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Translation).export_values();
128 ········.value("XCAFDimTolObjects_DatumTargetType_Line",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Line) 
129 ········.value("XCAFDimTolObjects_DatumTargetType_Rectangle",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Rectangle) 
130 ········.value("XCAFDimTolObjects_DatumTargetType_Circle",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Circle) 
131 ········.value("XCAFDimTolObjects_DatumTargetType_Area",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Area).export_values(); 
132 ····py::enum_<XCAFDimTolObjects_DimensionFormVariance>(m,·"XCAFDimTolObjects_DimensionFormVariance",R"#(Defines·value·of·form·variance)#")124 ····py::enum_<XCAFDimTolObjects_DimensionFormVariance>(m,·"XCAFDimTolObjects_DimensionFormVariance",R"#(Defines·value·of·form·variance)#")
133 ········.value("XCAFDimTolObjects_DimensionFormVariance_None",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_None)125 ········.value("XCAFDimTolObjects_DimensionFormVariance_None",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_None)
134 ········.value("XCAFDimTolObjects_DimensionFormVariance_A",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_A)126 ········.value("XCAFDimTolObjects_DimensionFormVariance_A",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_A)
135 ········.value("XCAFDimTolObjects_DimensionFormVariance_B",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_B)127 ········.value("XCAFDimTolObjects_DimensionFormVariance_B",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_B)
136 ········.value("XCAFDimTolObjects_DimensionFormVariance_C",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_C)128 ········.value("XCAFDimTolObjects_DimensionFormVariance_C",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_C)
137 ········.value("XCAFDimTolObjects_DimensionFormVariance_CD",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_CD)129 ········.value("XCAFDimTolObjects_DimensionFormVariance_CD",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_CD)
138 ········.value("XCAFDimTolObjects_DimensionFormVariance_D",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_D)130 ········.value("XCAFDimTolObjects_DimensionFormVariance_D",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_D)
Offset 155, 29 lines modifiedOffset 147, 14 lines modified
155 ········.value("XCAFDimTolObjects_DimensionFormVariance_V",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_V)147 ········.value("XCAFDimTolObjects_DimensionFormVariance_V",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_V)
156 ········.value("XCAFDimTolObjects_DimensionFormVariance_X",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_X)148 ········.value("XCAFDimTolObjects_DimensionFormVariance_X",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_X)
157 ········.value("XCAFDimTolObjects_DimensionFormVariance_Y",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Y)149 ········.value("XCAFDimTolObjects_DimensionFormVariance_Y",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Y)
158 ········.value("XCAFDimTolObjects_DimensionFormVariance_Z",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Z)150 ········.value("XCAFDimTolObjects_DimensionFormVariance_Z",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Z)
159 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZA",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZA)151 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZA",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZA)
160 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZB",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZB)152 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZB",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZB)
161 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZC",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZC).export_values();153 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZC",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZC).export_values();
162 ····py::enum_<XCAFDimTolObjects_DimensionQualifier>(m,·"XCAFDimTolObjects_DimensionQualifier",R"#(Defines·types·of·qualifier)#") 
163 ········.value("XCAFDimTolObjects_DimensionQualifier_None",XCAFDimTolObjects_DimensionQualifier::XCAFDimTolObjects_DimensionQualifier_None) 
164 ········.value("XCAFDimTolObjects_DimensionQualifier_Min",XCAFDimTolObjects_DimensionQualifier::XCAFDimTolObjects_DimensionQualifier_Min) 
165 ········.value("XCAFDimTolObjects_DimensionQualifier_Max",XCAFDimTolObjects_DimensionQualifier::XCAFDimTolObjects_DimensionQualifier_Max) 
166 ········.value("XCAFDimTolObjects_DimensionQualifier_Avg",XCAFDimTolObjects_DimensionQualifier::XCAFDimTolObjects_DimensionQualifier_Avg).export_values(); 
167 ····py::enum_<XCAFDimTolObjects_GeomToleranceMatReqModif>(m,·"XCAFDimTolObjects_GeomToleranceMatReqModif",R"#(Defines·types·of·material·requirement)#") 
168 ········.value("XCAFDimTolObjects_GeomToleranceMatReqModif_None",XCAFDimTolObjects_GeomToleranceMatReqModif::XCAFDimTolObjects_GeomToleranceMatReqModif_None) 
169 ········.value("XCAFDimTolObjects_GeomToleranceMatReqModif_M",XCAFDimTolObjects_GeomToleranceMatReqModif::XCAFDimTolObjects_GeomToleranceMatReqModif_M) 
170 ········.value("XCAFDimTolObjects_GeomToleranceMatReqModif_L",XCAFDimTolObjects_GeomToleranceMatReqModif::XCAFDimTolObjects_GeomToleranceMatReqModif_L).export_values(); 
171 ····py::enum_<XCAFDimTolObjects_DatumModifWithValue>(m,·"XCAFDimTolObjects_DatumModifWithValue",R"#(Defines·modifirs)#") 
172 ········.value("XCAFDimTolObjects_DatumModifWithValue_None",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_None) 
173 ········.value("XCAFDimTolObjects_DatumModifWithValue_CircularOrCylindrical",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_CircularOrCylindrical) 
174 ········.value("XCAFDimTolObjects_DatumModifWithValue_Distance",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_Distance) 
175 ········.value("XCAFDimTolObjects_DatumModifWithValue_Projected",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_Projected) 
176 ········.value("XCAFDimTolObjects_DatumModifWithValue_Spherical",XCAFDimTolObjects_DatumModifWithValue::XCAFDimTolObjects_DatumModifWithValue_Spherical).export_values(); 
177 ····py::enum_<XCAFDimTolObjects_DimensionModif>(m,·"XCAFDimTolObjects_DimensionModif",R"#(Defines·modifirs)#")154 ····py::enum_<XCAFDimTolObjects_DimensionModif>(m,·"XCAFDimTolObjects_DimensionModif",R"#(Defines·modifirs)#")
178 ········.value("XCAFDimTolObjects_DimensionModif_ControlledRadius",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_ControlledRadius)155 ········.value("XCAFDimTolObjects_DimensionModif_ControlledRadius",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_ControlledRadius)
179 ········.value("XCAFDimTolObjects_DimensionModif_Square",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_Square)156 ········.value("XCAFDimTolObjects_DimensionModif_Square",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_Square)
180 ········.value("XCAFDimTolObjects_DimensionModif_StatisticalTolerance",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_StatisticalTolerance)157 ········.value("XCAFDimTolObjects_DimensionModif_StatisticalTolerance",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_StatisticalTolerance)
181 ········.value("XCAFDimTolObjects_DimensionModif_ContinuousFeature",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_ContinuousFeature)158 ········.value("XCAFDimTolObjects_DimensionModif_ContinuousFeature",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_ContinuousFeature)
182 ········.value("XCAFDimTolObjects_DimensionModif_TwoPointSize",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_TwoPointSize)159 ········.value("XCAFDimTolObjects_DimensionModif_TwoPointSize",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_TwoPointSize)
183 ········.value("XCAFDimTolObjects_DimensionModif_LocalSizeDefinedBySphere",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_LocalSizeDefinedBySphere)160 ········.value("XCAFDimTolObjects_DimensionModif_LocalSizeDefinedBySphere",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_LocalSizeDefinedBySphere)
Offset 195, 14 lines modifiedOffset 172, 18 lines modified
195 ········.value("XCAFDimTolObjects_DimensionModif_RangeOfSizes",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_RangeOfSizes)172 ········.value("XCAFDimTolObjects_DimensionModif_RangeOfSizes",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_RangeOfSizes)
196 ········.value("XCAFDimTolObjects_DimensionModif_AnyRestrictedPortionOfFeature",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_AnyRestrictedPortionOfFeature)173 ········.value("XCAFDimTolObjects_DimensionModif_AnyRestrictedPortionOfFeature",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_AnyRestrictedPortionOfFeature)
197 ········.value("XCAFDimTolObjects_DimensionModif_AnyCrossSection",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_AnyCrossSection)174 ········.value("XCAFDimTolObjects_DimensionModif_AnyCrossSection",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_AnyCrossSection)
198 ········.value("XCAFDimTolObjects_DimensionModif_SpecificFixedCrossSection",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_SpecificFixedCrossSection)175 ········.value("XCAFDimTolObjects_DimensionModif_SpecificFixedCrossSection",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_SpecificFixedCrossSection)
199 ········.value("XCAFDimTolObjects_DimensionModif_CommonTolerance",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_CommonTolerance)176 ········.value("XCAFDimTolObjects_DimensionModif_CommonTolerance",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_CommonTolerance)
200 ········.value("XCAFDimTolObjects_DimensionModif_FreeStateCondition",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_FreeStateCondition)177 ········.value("XCAFDimTolObjects_DimensionModif_FreeStateCondition",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_FreeStateCondition)
201 ········.value("XCAFDimTolObjects_DimensionModif_Between",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_Between).export_values();178 ········.value("XCAFDimTolObjects_DimensionModif_Between",XCAFDimTolObjects_DimensionModif::XCAFDimTolObjects_DimensionModif_Between).export_values();
 179 ····py::enum_<XCAFDimTolObjects_ToleranceZoneAffectedPlane>(m,·"XCAFDimTolObjects_ToleranceZoneAffectedPlane",R"#(Defines·types·of·tolerance·zone·affected·plane)#")
 180 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_None",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_None)
 181 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_Intersection",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_Intersection)
 182 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_Orientation",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_Orientation).export_values();
202 ····py::enum_<XCAFDimTolObjects_DimensionGrade>(m,·"XCAFDimTolObjects_DimensionGrade",R"#(Defines·value·of·grade)#")183 ····py::enum_<XCAFDimTolObjects_DimensionGrade>(m,·"XCAFDimTolObjects_DimensionGrade",R"#(Defines·value·of·grade)#")
203 ········.value("XCAFDimTolObjects_DimensionGrade_IT01",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT01)184 ········.value("XCAFDimTolObjects_DimensionGrade_IT01",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT01)
204 ········.value("XCAFDimTolObjects_DimensionGrade_IT0",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT0)185 ········.value("XCAFDimTolObjects_DimensionGrade_IT0",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT0)
205 ········.value("XCAFDimTolObjects_DimensionGrade_IT1",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT1)186 ········.value("XCAFDimTolObjects_DimensionGrade_IT1",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT1)
206 ········.value("XCAFDimTolObjects_DimensionGrade_IT2",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT2)187 ········.value("XCAFDimTolObjects_DimensionGrade_IT2",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT2)
207 ········.value("XCAFDimTolObjects_DimensionGrade_IT3",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT3)188 ········.value("XCAFDimTolObjects_DimensionGrade_IT3",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT3)
208 ········.value("XCAFDimTolObjects_DimensionGrade_IT4",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT4)189 ········.value("XCAFDimTolObjects_DimensionGrade_IT4",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT4)
Offset 216, 19 lines modifiedOffset 197, 61 lines modified
216 ········.value("XCAFDimTolObjects_DimensionGrade_IT12",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT12)197 ········.value("XCAFDimTolObjects_DimensionGrade_IT12",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT12)
217 ········.value("XCAFDimTolObjects_DimensionGrade_IT13",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT13)198 ········.value("XCAFDimTolObjects_DimensionGrade_IT13",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT13)
218 ········.value("XCAFDimTolObjects_DimensionGrade_IT14",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT14)199 ········.value("XCAFDimTolObjects_DimensionGrade_IT14",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT14)
219 ········.value("XCAFDimTolObjects_DimensionGrade_IT15",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT15)200 ········.value("XCAFDimTolObjects_DimensionGrade_IT15",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT15)
220 ········.value("XCAFDimTolObjects_DimensionGrade_IT16",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT16)201 ········.value("XCAFDimTolObjects_DimensionGrade_IT16",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT16)
221 ········.value("XCAFDimTolObjects_DimensionGrade_IT17",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT17)202 ········.value("XCAFDimTolObjects_DimensionGrade_IT17",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT17)
222 ········.value("XCAFDimTolObjects_DimensionGrade_IT18",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT18).export_values();203 ········.value("XCAFDimTolObjects_DimensionGrade_IT18",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT18).export_values();
 204 ····py::enum_<XCAFDimTolObjects_GeomToleranceModif>(m,·"XCAFDimTolObjects_GeomToleranceModif",R"#(Defines·modifirs)#")
 205 ········.value("XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section)
 206 ········.value("XCAFDimTolObjects_GeomToleranceModif_Common_Zone",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Common_Zone)
Max diff block lines reached; 8638/34420 bytes (25.10%) of diff not shown.
⊟
6.75 KB
./usr/share/libocp/OCP/gp.cpp
Ordering differences only
    
Offset 7607, 77 lines modifiedOffset 7607, 77 lines modified
7607 //·/usr/include/opencascade/gp_XYZ.hxx7607 //·/usr/include/opencascade/gp_XYZ.hxx
  
7608 //·Additional·functions7608 //·Additional·functions
  
  
7609 //·operators7609 //·operators
7610 ····m.def("__mul__",7610 ····m.def("__mul__",
 7611 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*),
 7612 ··········py::is_operator(),
 7613 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D"));
 7614 ····m.def("__rmul__",
 7615 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*),
 7616 ··········py::is_operator(),
 7617 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D"));
 7618 ····m.def("__mul__",
 7619 ··········(gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··))··static_cast<gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··)>(&operator*),
 7620 ··········py::is_operator(),
 7621 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));
 7622 ····m.def("__rmul__",
 7623 ··········(gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··))··static_cast<gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··)>(&operator*),
 7624 ··········py::is_operator(),
 7625 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));
 7626 ····m.def("__mul__",
7611 ··········(gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··))··static_cast<gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··)>(&operator*),7627 ··········(gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··))··static_cast<gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··)>(&operator*),
7612 ··········py::is_operator(),7628 ··········py::is_operator(),
7613 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));7629 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));
7614 ····m.def("__rmul__",7630 ····m.def("__rmul__",
7615 ··········(gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··))··static_cast<gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··)>(&operator*),7631 ··········(gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··))··static_cast<gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··)>(&operator*),
7616 ··········py::is_operator(),7632 ··········py::is_operator(),
7617 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));7633 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));
7618 ····m.def("__mul__",7634 ····m.def("__mul__",
7619 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*),7635 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),
7620 ··········py::is_operator(),7636 ··········py::is_operator(),
7621 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));7637 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
7622 ····m.def("__rmul__",7638 ····m.def("__rmul__",
7623 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*),7639 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),
7624 ··········py::is_operator(),7640 ··········py::is_operator(),
7625 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));7641 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
7626 ····m.def("__mul__",7642 ····m.def("__mul__",
7627 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*),7643 ··········(gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··)>(&operator*),
7628 ··········py::is_operator(),7644 ··········py::is_operator(),
7629 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));7645 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));
7630 ····m.def("__rmul__",7646 ····m.def("__rmul__",
7631 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*),7647 ··········(gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··)>(&operator*),
7632 ··········py::is_operator(),7648 ··········py::is_operator(),
7633 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));7649 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));
7634 ····m.def("__mul__",7650 ····m.def("__mul__",
7635 ··········(gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··))··static_cast<gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··)>(&operator*),7651 ··········(gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··))··static_cast<gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··)>(&operator*),
7636 ··········py::is_operator(),7652 ··········py::is_operator(),
7637 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));7653 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));
7638 ····m.def("__rmul__",7654 ····m.def("__rmul__",
7639 ··········(gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··))··static_cast<gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··)>(&operator*),7655 ··········(gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··))··static_cast<gp_Vec·(*)(··const·Standard_Real·,···const·gp_Vec·&··)>(&operator*),
7640 ··········py::is_operator(),7656 ··········py::is_operator(),
7641 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));7657 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));
7642 ····m.def("__mul__",7658 ····m.def("__mul__",
7643 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*), 
7644 ··········py::is_operator(), 
7645 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D")); 
7646 ····m.def("__rmul__", 
7647 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*), 
7648 ··········py::is_operator(), 
7649 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D")); 
7650 ····m.def("__mul__", 
7651 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),7659 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*),
7652 ··········py::is_operator(),7660 ··········py::is_operator(),
7653 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));7661 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
7654 ····m.def("__rmul__",7662 ····m.def("__rmul__",
7655 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),7663 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*),
7656 ··········py::is_operator(),7664 ··········py::is_operator(),
7657 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));7665 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
7658 ····m.def("__mul__",7666 ····m.def("__mul__",
7659 ··········(gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··)>(&operator*),7667 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*),
7660 ··········py::is_operator(),7668 ··········py::is_operator(),
7661 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));7669 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));
7662 ····m.def("__rmul__",7670 ····m.def("__rmul__",
7663 ··········(gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·Standard_Real·,···const·gp_XYZ·&··)>(&operator*),7671 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*),
7664 ··········py::is_operator(),7672 ··········py::is_operator(),
7665 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));7673 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));
7666 ····m.def("__mul__", 
7667 ··········(gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··))··static_cast<gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··)>(&operator*), 
7668 ··········py::is_operator(), 
7669 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV")); 
7670 ····m.def("__rmul__", 
7671 ··········(gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··))··static_cast<gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··)>(&operator*), 
7672 ··········py::is_operator(), 
7673 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV")); 
  
7674 //·register·typdefs7674 //·register·typdefs
7675 ····register_template_NCollection_Vec2<Standard_ShortReal>(m,"gp_Vec2f");7675 ····register_template_NCollection_Vec2<Standard_ShortReal>(m,"gp_Vec2f");
7676 ····register_template_NCollection_Vec3<Standard_ShortReal>(m,"gp_Vec3f");7676 ····register_template_NCollection_Vec3<Standard_ShortReal>(m,"gp_Vec3f");
  
  
7677 //·exceptions7677 //·exceptions
⊟
3.94 KB
./usr/share/libocp/OCP/gp_pre.cpp
Ordering differences only
    
Offset 99, 14 lines modifiedOffset 99, 24 lines modified
  
99 //·add·namespaces·as·submodules99 //·add·namespaces·as·submodules
100 m.def_submodule("std");100 m.def_submodule("std");
  
101 //·user-defined·inclusion·per·module·in·the·body101 //·user-defined·inclusion·per·module·in·the·body
  
102 //·enums102 //·enums
 103 ····py::enum_<gp_TrsfForm>(m,·"gp_TrsfForm",R"#(Identifies·the·type·of·a·geometric·transformation.)#")
 104 ········.value("gp_Identity",gp_TrsfForm::gp_Identity)
 105 ········.value("gp_Rotation",gp_TrsfForm::gp_Rotation)
 106 ········.value("gp_Translation",gp_TrsfForm::gp_Translation)
 107 ········.value("gp_PntMirror",gp_TrsfForm::gp_PntMirror)
 108 ········.value("gp_Ax1Mirror",gp_TrsfForm::gp_Ax1Mirror)
 109 ········.value("gp_Ax2Mirror",gp_TrsfForm::gp_Ax2Mirror)
 110 ········.value("gp_Scale",gp_TrsfForm::gp_Scale)
 111 ········.value("gp_CompoundTrsf",gp_TrsfForm::gp_CompoundTrsf)
 112 ········.value("gp_Other",gp_TrsfForm::gp_Other).export_values();
103 ····py::enum_<gp_EulerSequence>(m,·"gp_EulerSequence",R"#(Enumerates·all·24·possible·variants·of·generalized·Euler·angles,·defining·general·3d·rotation·by·three·rotations·around·main·axes·of·coordinate·system,·in·different·possible·orders.)#")113 ····py::enum_<gp_EulerSequence>(m,·"gp_EulerSequence",R"#(Enumerates·all·24·possible·variants·of·generalized·Euler·angles,·defining·general·3d·rotation·by·three·rotations·around·main·axes·of·coordinate·system,·in·different·possible·orders.)#")
104 ········.value("gp_EulerAngles",gp_EulerSequence::gp_EulerAngles)114 ········.value("gp_EulerAngles",gp_EulerSequence::gp_EulerAngles)
105 ········.value("gp_YawPitchRoll",gp_EulerSequence::gp_YawPitchRoll)115 ········.value("gp_YawPitchRoll",gp_EulerSequence::gp_YawPitchRoll)
106 ········.value("gp_Extrinsic_XYZ",gp_EulerSequence::gp_Extrinsic_XYZ)116 ········.value("gp_Extrinsic_XYZ",gp_EulerSequence::gp_Extrinsic_XYZ)
107 ········.value("gp_Extrinsic_XZY",gp_EulerSequence::gp_Extrinsic_XZY)117 ········.value("gp_Extrinsic_XZY",gp_EulerSequence::gp_Extrinsic_XZY)
108 ········.value("gp_Extrinsic_YZX",gp_EulerSequence::gp_Extrinsic_YZX)118 ········.value("gp_Extrinsic_YZX",gp_EulerSequence::gp_Extrinsic_YZX)
109 ········.value("gp_Extrinsic_YXZ",gp_EulerSequence::gp_Extrinsic_YXZ)119 ········.value("gp_Extrinsic_YXZ",gp_EulerSequence::gp_Extrinsic_YXZ)
Offset 126, 24 lines modifiedOffset 136, 14 lines modified
126 ········.value("gp_Extrinsic_ZXZ",gp_EulerSequence::gp_Extrinsic_ZXZ)136 ········.value("gp_Extrinsic_ZXZ",gp_EulerSequence::gp_Extrinsic_ZXZ)
127 ········.value("gp_Intrinsic_XYX",gp_EulerSequence::gp_Intrinsic_XYX)137 ········.value("gp_Intrinsic_XYX",gp_EulerSequence::gp_Intrinsic_XYX)
128 ········.value("gp_Intrinsic_XZX",gp_EulerSequence::gp_Intrinsic_XZX)138 ········.value("gp_Intrinsic_XZX",gp_EulerSequence::gp_Intrinsic_XZX)
129 ········.value("gp_Intrinsic_YZY",gp_EulerSequence::gp_Intrinsic_YZY)139 ········.value("gp_Intrinsic_YZY",gp_EulerSequence::gp_Intrinsic_YZY)
130 ········.value("gp_Intrinsic_YXY",gp_EulerSequence::gp_Intrinsic_YXY)140 ········.value("gp_Intrinsic_YXY",gp_EulerSequence::gp_Intrinsic_YXY)
131 ········.value("gp_Intrinsic_ZXZ",gp_EulerSequence::gp_Intrinsic_ZXZ)141 ········.value("gp_Intrinsic_ZXZ",gp_EulerSequence::gp_Intrinsic_ZXZ)
132 ········.value("gp_Intrinsic_ZYZ",gp_EulerSequence::gp_Intrinsic_ZYZ).export_values();142 ········.value("gp_Intrinsic_ZYZ",gp_EulerSequence::gp_Intrinsic_ZYZ).export_values();
133 ····py::enum_<gp_TrsfForm>(m,·"gp_TrsfForm",R"#(Identifies·the·type·of·a·geometric·transformation.)#") 
134 ········.value("gp_Identity",gp_TrsfForm::gp_Identity) 
135 ········.value("gp_Rotation",gp_TrsfForm::gp_Rotation) 
136 ········.value("gp_Translation",gp_TrsfForm::gp_Translation) 
137 ········.value("gp_PntMirror",gp_TrsfForm::gp_PntMirror) 
138 ········.value("gp_Ax1Mirror",gp_TrsfForm::gp_Ax1Mirror) 
139 ········.value("gp_Ax2Mirror",gp_TrsfForm::gp_Ax2Mirror) 
140 ········.value("gp_Scale",gp_TrsfForm::gp_Scale) 
141 ········.value("gp_CompoundTrsf",gp_TrsfForm::gp_CompoundTrsf) 
142 ········.value("gp_Other",gp_TrsfForm::gp_Other).export_values(); 
  
143 //Python·trampoline·classes143 //Python·trampoline·classes
  
144 //·pre-register·typdefs+classes·(topologically·sorted)144 //·pre-register·typdefs+classes·(topologically·sorted)
145 ····py::class_<NCollection_Lerp<gp_Trsf>·,·shared_ptr<NCollection_Lerp<gp_Trsf>>··>(m,"NCollection_Lerp_gp_Trsf",R"#(Linear·interpolation·tool·for·transformation·defined·by·gp_Trsf.)#");145 ····py::class_<NCollection_Lerp<gp_Trsf>·,·shared_ptr<NCollection_Lerp<gp_Trsf>>··>(m,"NCollection_Lerp_gp_Trsf",R"#(Linear·interpolation·tool·for·transformation·defined·by·gp_Trsf.)#");
146 ····py::class_<gp·,·shared_ptr<gp>··>(m,"gp",R"#(The·geometric·processor·package,·called·gp,·provides·an·implementation·of·entities·used·:·.·for·algebraic·calculation·such·as·"XYZ"·coordinates,·"Mat"·matrix·.·for·basis·analytic·geometry·such·as·Transformations,·point,·vector,·line,·plane,·axis·placement,·conics,·and·elementary·surfaces.·These·entities·are·defined·in·2d·and·3d·space.·All·the·classes·of·this·package·are·non-persistent.)#");146 ····py::class_<gp·,·shared_ptr<gp>··>(m,"gp",R"#(The·geometric·processor·package,·called·gp,·provides·an·implementation·of·entities·used·:·.·for·algebraic·calculation·such·as·"XYZ"·coordinates,·"Mat"·matrix·.·for·basis·analytic·geometry·such·as·Transformations,·point,·vector,·line,·plane,·axis·placement,·conics,·and·elementary·surfaces.·These·entities·are·defined·in·2d·and·3d·space.·All·the·classes·of·this·package·are·non-persistent.)#");
147 ····py::class_<gp_Ax1·,·shared_ptr<gp_Ax1>··>(m,"gp_Ax1",R"#(Describes·an·axis·in·3D·space.·An·axis·is·defined·by:·-·its·origin·(also·referred·to·as·its·"Location·point"),·and·-·its·unit·vector·(referred·to·as·its·"Direction"·or·"main·Direction").·An·axis·is·used:·-·to·describe·3D·geometric·entities·(for·example,·the·axis·of·a·revolution·entity).·It·serves·the·same·purpose·as·the·STEP·function·"axis·placement·one·axis",·or·-·to·define·geometric·transformations·(axis·of·symmetry,·axis·of·rotation,·and·so·on).·For·example,·this·entity·can·be·used·to·locate·a·geometric·entity·or·to·define·a·symmetry·axis.)#");147 ····py::class_<gp_Ax1·,·shared_ptr<gp_Ax1>··>(m,"gp_Ax1",R"#(Describes·an·axis·in·3D·space.·An·axis·is·defined·by:·-·its·origin·(also·referred·to·as·its·"Location·point"),·and·-·its·unit·vector·(referred·to·as·its·"Direction"·or·"main·Direction").·An·axis·is·used:·-·to·describe·3D·geometric·entities·(for·example,·the·axis·of·a·revolution·entity).·It·serves·the·same·purpose·as·the·STEP·function·"axis·placement·one·axis",·or·-·to·define·geometric·transformations·(axis·of·symmetry,·axis·of·rotation,·and·so·on).·For·example,·this·entity·can·be·used·to·locate·a·geometric·entity·or·to·define·a·symmetry·axis.)#");
Generated by diffoscope 306