⊟
856 KB
/srv/reproducible-results/rbuild-debian/r-b-build.h0xsJ8zJ/b1/python-opencascade-pywrap_0.0~git20250714210719.b608b60-3_amd64.changes vs.
/srv/reproducible-results/rbuild-debian/r-b-build.h0xsJ8zJ/b2/python-opencascade-pywrap_0.0~git20250714210719.b608b60-3_amd64.changes
⊟
280 B
Files
    
Offset 1, 2 lines modifiedOffset 1, 2 lines modified
  
1 ·010f570f40ba1dc9f530df73052cbb35·1908456·python·optional·python3-opencascade-pywrap_0.0~git20250714210719.b608b60-3_all.deb1 ·71a4a8a0e423bd576621fe8639580af3·1908356·python·optional·python3-opencascade-pywrap_0.0~git20250714210719.b608b60-3_all.deb
⊟
856 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····21308·2025-08-02·01:34:12.000000·control.tar.xz2 -rw-r--r--···0········0········0····21296·2025-08-02·01:34:12.000000·control.tar.xz
3 -rw-r--r--···0········0········0··1886956·2025-08-02·01:34:12.000000·data.tar.xz3 -rw-r--r--···0········0········0··1886868·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
⊟
855 KB
data.tar.xz
⊟
855 KB
data.tar
⊟
18.3 KB
./usr/share/libocp/OCP/AIS_pre.cpp
Ordering differences only
    
Offset 199, 108 lines modifiedOffset 199, 122 lines modified
199 //·enums199 //·enums
200 ····py::enum_<AIS_StatusOfPick>(m,·"AIS_StatusOfPick",R"#()#")200 ····py::enum_<AIS_StatusOfPick>(m,·"AIS_StatusOfPick",R"#()#")
201 ········.value("AIS_SOP_Error",AIS_StatusOfPick::AIS_SOP_Error)201 ········.value("AIS_SOP_Error",AIS_StatusOfPick::AIS_SOP_Error)
202 ········.value("AIS_SOP_NothingSelected",AIS_StatusOfPick::AIS_SOP_NothingSelected)202 ········.value("AIS_SOP_NothingSelected",AIS_StatusOfPick::AIS_SOP_NothingSelected)
203 ········.value("AIS_SOP_Removed",AIS_StatusOfPick::AIS_SOP_Removed)203 ········.value("AIS_SOP_Removed",AIS_StatusOfPick::AIS_SOP_Removed)
204 ········.value("AIS_SOP_OneSelected",AIS_StatusOfPick::AIS_SOP_OneSelected)204 ········.value("AIS_SOP_OneSelected",AIS_StatusOfPick::AIS_SOP_OneSelected)
205 ········.value("AIS_SOP_SeveralSelected",AIS_StatusOfPick::AIS_SOP_SeveralSelected).export_values();205 ········.value("AIS_SOP_SeveralSelected",AIS_StatusOfPick::AIS_SOP_SeveralSelected).export_values();
206 ····py::enum_<AIS_TypeOfPlane>(m,·"AIS_TypeOfPlane",R"#(Declares·the·type·of·plane.)#")206 ····py::enum_<AIS_TypeOfAxis>(m,·"AIS_TypeOfAxis",R"#(Declares·the·type·of·axis.)#")
207 ········.value("AIS_TOPL_Unknown",AIS_TypeOfPlane::AIS_TOPL_Unknown)207 ········.value("AIS_TOAX_Unknown",AIS_TypeOfAxis::AIS_TOAX_Unknown)
208 ········.value("AIS_TOPL_XYPlane",AIS_TypeOfPlane::AIS_TOPL_XYPlane) 
209 ········.value("AIS_TOPL_XZPlane",AIS_TypeOfPlane::AIS_TOPL_XZPlane)208 ········.value("AIS_TOAX_XAxis",AIS_TypeOfAxis::AIS_TOAX_XAxis)
 209 ········.value("AIS_TOAX_YAxis",AIS_TypeOfAxis::AIS_TOAX_YAxis)
210 ········.value("AIS_TOPL_YZPlane",AIS_TypeOfPlane::AIS_TOPL_YZPlane).export_values();210 ········.value("AIS_TOAX_ZAxis",AIS_TypeOfAxis::AIS_TOAX_ZAxis).export_values();
211 ····py::enum_<AIS_WalkTranslation>(m,·"AIS_WalkTranslation",R"#(Walking·translation·components.)#")211 ····py::enum_<AIS_WalkTranslation>(m,·"AIS_WalkTranslation",R"#(Walking·translation·components.)#")
212 ········.value("AIS_WalkTranslation_Forward",AIS_WalkTranslation::AIS_WalkTranslation_Forward)212 ········.value("AIS_WalkTranslation_Forward",AIS_WalkTranslation::AIS_WalkTranslation_Forward)
213 ········.value("AIS_WalkTranslation_Side",AIS_WalkTranslation::AIS_WalkTranslation_Side)213 ········.value("AIS_WalkTranslation_Side",AIS_WalkTranslation::AIS_WalkTranslation_Side)
214 ········.value("AIS_WalkTranslation_Up",AIS_WalkTranslation::AIS_WalkTranslation_Up).export_values();214 ········.value("AIS_WalkTranslation_Up",AIS_WalkTranslation::AIS_WalkTranslation_Up).export_values();
215 ····py::enum_<AIS_WalkRotation>(m,·"AIS_WalkRotation",R"#(Walking·rotation·components.)#")215 ····py::enum_<AIS_WalkRotation>(m,·"AIS_WalkRotation",R"#(Walking·rotation·components.)#")
216 ········.value("AIS_WalkRotation_Yaw",AIS_WalkRotation::AIS_WalkRotation_Yaw)216 ········.value("AIS_WalkRotation_Yaw",AIS_WalkRotation::AIS_WalkRotation_Yaw)
217 ········.value("AIS_WalkRotation_Pitch",AIS_WalkRotation::AIS_WalkRotation_Pitch)217 ········.value("AIS_WalkRotation_Pitch",AIS_WalkRotation::AIS_WalkRotation_Pitch)
218 ········.value("AIS_WalkRotation_Roll",AIS_WalkRotation::AIS_WalkRotation_Roll).export_values();218 ········.value("AIS_WalkRotation_Roll",AIS_WalkRotation::AIS_WalkRotation_Roll).export_values();
219 ····py::enum_<AIS_SelectionScheme>(m,·"AIS_SelectionScheme",R"#(Sets·selection·schemes·for·interactive·contexts.)#") 
220 ········.value("AIS_SelectionScheme_UNKNOWN",AIS_SelectionScheme::AIS_SelectionScheme_UNKNOWN) 
221 ········.value("AIS_SelectionScheme_Replace",AIS_SelectionScheme::AIS_SelectionScheme_Replace) 
222 ········.value("AIS_SelectionScheme_Add",AIS_SelectionScheme::AIS_SelectionScheme_Add) 
223 ········.value("AIS_SelectionScheme_Remove",AIS_SelectionScheme::AIS_SelectionScheme_Remove) 
224 ········.value("AIS_SelectionScheme_XOR",AIS_SelectionScheme::AIS_SelectionScheme_XOR) 
225 ········.value("AIS_SelectionScheme_Clear",AIS_SelectionScheme::AIS_SelectionScheme_Clear) 
226 ········.value("AIS_SelectionScheme_ReplaceExtra",AIS_SelectionScheme::AIS_SelectionScheme_ReplaceExtra).export_values();219 ····py::enum_<AIS_TrihedronSelectionMode>(m,·"AIS_TrihedronSelectionMode",R"#(Enumeration·defining·selection·modes·supported·by·AIS_Trihedron.)#")
 220 ········.value("AIS_TrihedronSelectionMode_EntireObject",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_EntireObject)
 221 ········.value("AIS_TrihedronSelectionMode_Origin",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_Origin)
 222 ········.value("AIS_TrihedronSelectionMode_Axes",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_Axes)
 223 ········.value("AIS_TrihedronSelectionMode_MainPlanes",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_MainPlanes).export_values();
 224 ····py::enum_<AIS_ViewSelectionTool>(m,·"AIS_ViewSelectionTool",R"#(Selection·mode)#")
 225 ········.value("AIS_ViewSelectionTool_Picking",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Picking)
 226 ········.value("AIS_ViewSelectionTool_RubberBand",AIS_ViewSelectionTool::AIS_ViewSelectionTool_RubberBand)
 227 ········.value("AIS_ViewSelectionTool_Polygon",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Polygon)
 228 ········.value("AIS_ViewSelectionTool_ZoomWindow",AIS_ViewSelectionTool::AIS_ViewSelectionTool_ZoomWindow).export_values();
 229 ····py::enum_<AIS_ViewInputBufferType>(m,·"AIS_ViewInputBufferType",R"#(Input·buffer·type.)#")
 230 ········.value("AIS_ViewInputBufferType_UI",AIS_ViewInputBufferType::AIS_ViewInputBufferType_UI)
 231 ········.value("AIS_ViewInputBufferType_GL",AIS_ViewInputBufferType::AIS_ViewInputBufferType_GL).export_values();
 232 ····py::enum_<AIS_TypeOfIso>(m,·"AIS_TypeOfIso",R"#(Declares·the·type·of·isoparameter·displayed.)#")
 233 ········.value("AIS_TOI_IsoU",AIS_TypeOfIso::AIS_TOI_IsoU)
 234 ········.value("AIS_TOI_IsoV",AIS_TypeOfIso::AIS_TOI_IsoV)
 235 ········.value("AIS_TOI_Both",AIS_TypeOfIso::AIS_TOI_Both).export_values();
 236 ····py::enum_<AIS_DragAction>(m,·"AIS_DragAction",R"#(Dragging·action.)#")
 237 ········.value("AIS_DragAction_Start",AIS_DragAction::AIS_DragAction_Start)
 238 ········.value("AIS_DragAction_Confirmed",AIS_DragAction::AIS_DragAction_Confirmed)
 239 ········.value("AIS_DragAction_Update",AIS_DragAction::AIS_DragAction_Update)
 240 ········.value("AIS_DragAction_Stop",AIS_DragAction::AIS_DragAction_Stop)
 241 ········.value("AIS_DragAction_Abort",AIS_DragAction::AIS_DragAction_Abort).export_values();
 242 ····py::enum_<AIS_DisplayMode>(m,·"AIS_DisplayMode",R"#(Sets·display·modes·other·than·neutral·point·ones,·for·interactive·objects.·The·possibilities·include:·-·wireframe,·-·shaded,)#")
 243 ········.value("AIS_WireFrame",AIS_DisplayMode::AIS_WireFrame)
 244 ········.value("AIS_Shaded",AIS_DisplayMode::AIS_Shaded).export_values();
 245 ····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.)#")
 246 ········.value("AIS_KindOfInteractive_None",AIS_KindOfInteractive::AIS_KindOfInteractive_None)
 247 ········.value("AIS_KindOfInteractive_Datum",AIS_KindOfInteractive::AIS_KindOfInteractive_Datum)
 248 ········.value("AIS_KindOfInteractive_Shape",AIS_KindOfInteractive::AIS_KindOfInteractive_Shape)
 249 ········.value("AIS_KindOfInteractive_Object",AIS_KindOfInteractive::AIS_KindOfInteractive_Object)
 250 ········.value("AIS_KindOfInteractive_Relation",AIS_KindOfInteractive::AIS_KindOfInteractive_Relation)
 251 ········.value("AIS_KindOfInteractive_Dimension",AIS_KindOfInteractive::AIS_KindOfInteractive_Dimension)
 252 ········.value("AIS_KindOfInteractive_LightSource",AIS_KindOfInteractive::AIS_KindOfInteractive_LightSource)
 253 ········.value("AIS_KOI_None",AIS_KindOfInteractive::AIS_KOI_None)
 254 ········.value("AIS_KOI_Datum",AIS_KindOfInteractive::AIS_KOI_Datum)
 255 ········.value("AIS_KOI_Shape",AIS_KindOfInteractive::AIS_KOI_Shape)
 256 ········.value("AIS_KOI_Object",AIS_KindOfInteractive::AIS_KOI_Object)
 257 ········.value("AIS_KOI_Relation",AIS_KindOfInteractive::AIS_KOI_Relation)
 258 ········.value("AIS_KOI_Dimension",AIS_KindOfInteractive::AIS_KOI_Dimension).export_values();
227 ····py::enum_<AIS_StatusOfDetection>(m,·"AIS_StatusOfDetection",R"#()#")259 ····py::enum_<AIS_StatusOfDetection>(m,·"AIS_StatusOfDetection",R"#()#")
228 ········.value("AIS_SOD_Error",AIS_StatusOfDetection::AIS_SOD_Error)260 ········.value("AIS_SOD_Error",AIS_StatusOfDetection::AIS_SOD_Error)
229 ········.value("AIS_SOD_Nothing",AIS_StatusOfDetection::AIS_SOD_Nothing)261 ········.value("AIS_SOD_Nothing",AIS_StatusOfDetection::AIS_SOD_Nothing)
230 ········.value("AIS_SOD_AllBad",AIS_StatusOfDetection::AIS_SOD_AllBad)262 ········.value("AIS_SOD_AllBad",AIS_StatusOfDetection::AIS_SOD_AllBad)
231 ········.value("AIS_SOD_Selected",AIS_StatusOfDetection::AIS_SOD_Selected)263 ········.value("AIS_SOD_Selected",AIS_StatusOfDetection::AIS_SOD_Selected)
232 ········.value("AIS_SOD_OnlyOneDetected",AIS_StatusOfDetection::AIS_SOD_OnlyOneDetected)264 ········.value("AIS_SOD_OnlyOneDetected",AIS_StatusOfDetection::AIS_SOD_OnlyOneDetected)
233 ········.value("AIS_SOD_OnlyOneGood",AIS_StatusOfDetection::AIS_SOD_OnlyOneGood)265 ········.value("AIS_SOD_OnlyOneGood",AIS_StatusOfDetection::AIS_SOD_OnlyOneGood)
234 ········.value("AIS_SOD_SeveralGood",AIS_StatusOfDetection::AIS_SOD_SeveralGood).export_values();266 ········.value("AIS_SOD_SeveralGood",AIS_StatusOfDetection::AIS_SOD_SeveralGood).export_values();
 267 ····py::enum_<AIS_SelectionModesConcurrency>(m,·"AIS_SelectionModesConcurrency",R"#(The·mode·specifying·how·multiple·active·Selection·Modes·should·be·treated·during·activation·of·new·one.)#")
 268 ········.value("AIS_SelectionModesConcurrency_Single",AIS_SelectionModesConcurrency::AIS_SelectionModesConcurrency_Single)
 269 ········.value("AIS_SelectionModesConcurrency_GlobalOrLocal",AIS_SelectionModesConcurrency::AIS_SelectionModesConcurrency_GlobalOrLocal)
 270 ········.value("AIS_SelectionModesConcurrency_Multiple",AIS_SelectionModesConcurrency::AIS_SelectionModesConcurrency_Multiple).export_values();
235 ····py::enum_<AIS_TypeOfAxis>(m,·"AIS_TypeOfAxis",R"#(Declares·the·type·of·axis.)#") 
236 ········.value("AIS_TOAX_Unknown",AIS_TypeOfAxis::AIS_TOAX_Unknown) 
237 ········.value("AIS_TOAX_XAxis",AIS_TypeOfAxis::AIS_TOAX_XAxis) 
238 ········.value("AIS_TOAX_YAxis",AIS_TypeOfAxis::AIS_TOAX_YAxis) 
239 ········.value("AIS_TOAX_ZAxis",AIS_TypeOfAxis::AIS_TOAX_ZAxis).export_values(); 
240 ····py::enum_<AIS_TrihedronSelectionMode>(m,·"AIS_TrihedronSelectionMode",R"#(Enumeration·defining·selection·modes·supported·by·AIS_Trihedron.)#") 
241 ········.value("AIS_TrihedronSelectionMode_EntireObject",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_EntireObject) 
242 ········.value("AIS_TrihedronSelectionMode_Origin",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_Origin) 
243 ········.value("AIS_TrihedronSelectionMode_Axes",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_Axes) 
244 ········.value("AIS_TrihedronSelectionMode_MainPlanes",AIS_TrihedronSelectionMode::AIS_TrihedronSelectionMode_MainPlanes).export_values(); 
245 ····py::enum_<AIS_NavigationMode>(m,·"AIS_NavigationMode",R"#(Camera·navigation·mode.)#") 
246 ········.value("AIS_NavigationMode_Orbit",AIS_NavigationMode::AIS_NavigationMode_Orbit) 
247 ········.value("AIS_NavigationMode_FirstPersonFlight",AIS_NavigationMode::AIS_NavigationMode_FirstPersonFlight) 
248 ········.value("AIS_NavigationMode_FirstPersonWalk",AIS_NavigationMode::AIS_NavigationMode_FirstPersonWalk).export_values(); 
249 ····m.attr("AIS_NavigationMode_LOWER")·=·py::cast(int(AIS_NavigationMode_LOWER)); 
250 ····m.attr("AIS_NavigationMode_UPPER")·=·py::cast(int(AIS_NavigationMode_UPPER)); 
251 ····py::enum_<AIS_RotationMode>(m,·"AIS_RotationMode",R"#(Camera·rotation·mode.)#")271 ····py::enum_<AIS_RotationMode>(m,·"AIS_RotationMode",R"#(Camera·rotation·mode.)#")
252 ········.value("AIS_RotationMode_BndBoxActive",AIS_RotationMode::AIS_RotationMode_BndBoxActive)272 ········.value("AIS_RotationMode_BndBoxActive",AIS_RotationMode::AIS_RotationMode_BndBoxActive)
253 ········.value("AIS_RotationMode_PickLast",AIS_RotationMode::AIS_RotationMode_PickLast)273 ········.value("AIS_RotationMode_PickLast",AIS_RotationMode::AIS_RotationMode_PickLast)
254 ········.value("AIS_RotationMode_PickCenter",AIS_RotationMode::AIS_RotationMode_PickCenter)274 ········.value("AIS_RotationMode_PickCenter",AIS_RotationMode::AIS_RotationMode_PickCenter)
255 ········.value("AIS_RotationMode_CameraAt",AIS_RotationMode::AIS_RotationMode_CameraAt)275 ········.value("AIS_RotationMode_CameraAt",AIS_RotationMode::AIS_RotationMode_CameraAt)
256 ········.value("AIS_RotationMode_BndBoxScene",AIS_RotationMode::AIS_RotationMode_BndBoxScene).export_values();276 ········.value("AIS_RotationMode_BndBoxScene",AIS_RotationMode::AIS_RotationMode_BndBoxScene).export_values();
257 ····m.attr("AIS_RotationMode_LOWER")·=·py::cast(int(AIS_RotationMode_LOWER));277 ····m.attr("AIS_RotationMode_LOWER")·=·py::cast(int(AIS_RotationMode_LOWER));
258 ····m.attr("AIS_RotationMode_UPPER")·=·py::cast(int(AIS_RotationMode_UPPER));278 ····m.attr("AIS_RotationMode_UPPER")·=·py::cast(int(AIS_RotationMode_UPPER));
 279 ····py::enum_<AIS_TypeOfPlane>(m,·"AIS_TypeOfPlane",R"#(Declares·the·type·of·plane.)#")
 280 ········.value("AIS_TOPL_Unknown",AIS_TypeOfPlane::AIS_TOPL_Unknown)
 281 ········.value("AIS_TOPL_XYPlane",AIS_TypeOfPlane::AIS_TOPL_XYPlane)
 282 ········.value("AIS_TOPL_XZPlane",AIS_TypeOfPlane::AIS_TOPL_XZPlane)
 283 ········.value("AIS_TOPL_YZPlane",AIS_TypeOfPlane::AIS_TOPL_YZPlane).export_values();
259 ····py::enum_<AIS_ViewSelectionTool>(m,·"AIS_ViewSelectionTool",R"#(Selection·mode)#") 
260 ········.value("AIS_ViewSelectionTool_Picking",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Picking) 
261 ········.value("AIS_ViewSelectionTool_RubberBand",AIS_ViewSelectionTool::AIS_ViewSelectionTool_RubberBand) 
262 ········.value("AIS_ViewSelectionTool_Polygon",AIS_ViewSelectionTool::AIS_ViewSelectionTool_Polygon) 
263 ········.value("AIS_ViewSelectionTool_ZoomWindow",AIS_ViewSelectionTool::AIS_ViewSelectionTool_ZoomWindow).export_values(); 
264 ····py::enum_<AIS_ViewInputBufferType>(m,·"AIS_ViewInputBufferType",R"#(Input·buffer·type.)#") 
265 ········.value("AIS_ViewInputBufferType_UI",AIS_ViewInputBufferType::AIS_ViewInputBufferType_UI) 
266 ········.value("AIS_ViewInputBufferType_GL",AIS_ViewInputBufferType::AIS_ViewInputBufferType_GL).export_values(); 
267 ····py::enum_<AIS_MouseGesture>(m,·"AIS_MouseGesture",R"#(Mouse·gesture·-·only·one·can·be·active·at·one·moment.)#")284 ····py::enum_<AIS_MouseGesture>(m,·"AIS_MouseGesture",R"#(Mouse·gesture·-·only·one·can·be·active·at·one·moment.)#")
268 ········.value("AIS_MouseGesture_NONE",AIS_MouseGesture::AIS_MouseGesture_NONE)285 ········.value("AIS_MouseGesture_NONE",AIS_MouseGesture::AIS_MouseGesture_NONE)
269 ········.value("AIS_MouseGesture_SelectRectangle",AIS_MouseGesture::AIS_MouseGesture_SelectRectangle)286 ········.value("AIS_MouseGesture_SelectRectangle",AIS_MouseGesture::AIS_MouseGesture_SelectRectangle)
270 ········.value("AIS_MouseGesture_SelectLasso",AIS_MouseGesture::AIS_MouseGesture_SelectLasso)287 ········.value("AIS_MouseGesture_SelectLasso",AIS_MouseGesture::AIS_MouseGesture_SelectLasso)
271 ········.value("AIS_MouseGesture_Zoom",AIS_MouseGesture::AIS_MouseGesture_Zoom)288 ········.value("AIS_MouseGesture_Zoom",AIS_MouseGesture::AIS_MouseGesture_Zoom)
272 ········.value("AIS_MouseGesture_ZoomWindow",AIS_MouseGesture::AIS_MouseGesture_ZoomWindow)289 ········.value("AIS_MouseGesture_ZoomWindow",AIS_MouseGesture::AIS_MouseGesture_ZoomWindow)
273 ········.value("AIS_MouseGesture_Pan",AIS_MouseGesture::AIS_MouseGesture_Pan)290 ········.value("AIS_MouseGesture_Pan",AIS_MouseGesture::AIS_MouseGesture_Pan)
274 ········.value("AIS_MouseGesture_RotateOrbit",AIS_MouseGesture::AIS_MouseGesture_RotateOrbit)291 ········.value("AIS_MouseGesture_RotateOrbit",AIS_MouseGesture::AIS_MouseGesture_RotateOrbit)
275 ········.value("AIS_MouseGesture_RotateView",AIS_MouseGesture::AIS_MouseGesture_RotateView)292 ········.value("AIS_MouseGesture_RotateView",AIS_MouseGesture::AIS_MouseGesture_RotateView)
276 ········.value("AIS_MouseGesture_Drag",AIS_MouseGesture::AIS_MouseGesture_Drag).export_values();293 ········.value("AIS_MouseGesture_Drag",AIS_MouseGesture::AIS_MouseGesture_Drag).export_values();
Max diff block lines reached; 5153/18612 bytes (27.69%) of diff not shown.
⊟
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_ParametrizationType>(m,·"Approx_ParametrizationType",R"#()#") 
66 ········.value("Approx_ChordLength",Approx_ParametrizationType::Approx_ChordLength) 
67 ········.value("Approx_Centripetal",Approx_ParametrizationType::Approx_Centripetal) 
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)#")65 ····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)66 ········.value("Approx_PointsAdded",Approx_Status::Approx_PointsAdded)
71 ········.value("Approx_NoPointsAdded",Approx_Status::Approx_NoPointsAdded)67 ········.value("Approx_NoPointsAdded",Approx_Status::Approx_NoPointsAdded)
72 ········.value("Approx_NoApproximation",Approx_Status::Approx_NoApproximation).export_values();68 ········.value("Approx_NoApproximation",Approx_Status::Approx_NoApproximation).export_values();
 69 ····py::enum_<Approx_ParametrizationType>(m,·"Approx_ParametrizationType",R"#()#")
 70 ········.value("Approx_ChordLength",Approx_ParametrizationType::Approx_ChordLength)
 71 ········.value("Approx_Centripetal",Approx_ParametrizationType::Approx_Centripetal)
 72 ········.value("Approx_IsoParametric",Approx_ParametrizationType::Approx_IsoParametric).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, 104 lines modifiedOffset 113, 45 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_TypeOfDisplayText>(m,·"Aspect_TypeOfDisplayText",R"#(Define·the·display·type·of·the·text.)#") 
121 ········.value("Aspect_TODT_NORMAL",Aspect_TypeOfDisplayText::Aspect_TODT_NORMAL) 
122 ········.value("Aspect_TODT_SUBTITLE",Aspect_TypeOfDisplayText::Aspect_TODT_SUBTITLE) 
123 ········.value("Aspect_TODT_DEKALE",Aspect_TypeOfDisplayText::Aspect_TODT_DEKALE) 
124 ········.value("Aspect_TODT_BLEND",Aspect_TypeOfDisplayText::Aspect_TODT_BLEND) 
125 ········.value("Aspect_TODT_DIMENSION",Aspect_TypeOfDisplayText::Aspect_TODT_DIMENSION) 
126 ········.value("Aspect_TODT_SHADOW",Aspect_TypeOfDisplayText::Aspect_TODT_SHADOW).export_values(); 
127 ····py::enum_<Aspect_TypeOfMarker>(m,·"Aspect_TypeOfMarker",R"#(Definition·of·types·of·markers)#") 
128 ········.value("Aspect_TOM_EMPTY",Aspect_TypeOfMarker::Aspect_TOM_EMPTY) 
129 ········.value("Aspect_TOM_POINT",Aspect_TypeOfMarker::Aspect_TOM_POINT) 
130 ········.value("Aspect_TOM_PLUS",Aspect_TypeOfMarker::Aspect_TOM_PLUS) 
131 ········.value("Aspect_TOM_STAR",Aspect_TypeOfMarker::Aspect_TOM_STAR) 
132 ········.value("Aspect_TOM_X",Aspect_TypeOfMarker::Aspect_TOM_X) 
133 ········.value("Aspect_TOM_O",Aspect_TypeOfMarker::Aspect_TOM_O) 
134 ········.value("Aspect_TOM_O_POINT",Aspect_TypeOfMarker::Aspect_TOM_O_POINT) 
135 ········.value("Aspect_TOM_O_PLUS",Aspect_TypeOfMarker::Aspect_TOM_O_PLUS) 
136 ········.value("Aspect_TOM_O_STAR",Aspect_TypeOfMarker::Aspect_TOM_O_STAR) 
137 ········.value("Aspect_TOM_O_X",Aspect_TypeOfMarker::Aspect_TOM_O_X) 
138 ········.value("Aspect_TOM_RING1",Aspect_TypeOfMarker::Aspect_TOM_RING1) 
139 ········.value("Aspect_TOM_RING2",Aspect_TypeOfMarker::Aspect_TOM_RING2) 
140 ········.value("Aspect_TOM_RING3",Aspect_TypeOfMarker::Aspect_TOM_RING3) 
141 ········.value("Aspect_TOM_BALL",Aspect_TypeOfMarker::Aspect_TOM_BALL) 
142 ········.value("Aspect_TOM_USERDEFINED",Aspect_TypeOfMarker::Aspect_TOM_USERDEFINED).export_values(); 
143 ····py::enum_<Aspect_TypeOfResize>(m,·"Aspect_TypeOfResize",R"#(Defines·the·type·of·Resize·Window·method·applied·by·the·user.)#") 
144 ········.value("Aspect_TOR_UNKNOWN",Aspect_TypeOfResize::Aspect_TOR_UNKNOWN) 
145 ········.value("Aspect_TOR_NO_BORDER",Aspect_TypeOfResize::Aspect_TOR_NO_BORDER) 
146 ········.value("Aspect_TOR_TOP_BORDER",Aspect_TypeOfResize::Aspect_TOR_TOP_BORDER) 
147 ········.value("Aspect_TOR_RIGHT_BORDER",Aspect_TypeOfResize::Aspect_TOR_RIGHT_BORDER) 
148 ········.value("Aspect_TOR_BOTTOM_BORDER",Aspect_TypeOfResize::Aspect_TOR_BOTTOM_BORDER) 
149 ········.value("Aspect_TOR_LEFT_BORDER",Aspect_TypeOfResize::Aspect_TOR_LEFT_BORDER) 
150 ········.value("Aspect_TOR_TOP_AND_RIGHT_BORDER",Aspect_TypeOfResize::Aspect_TOR_TOP_AND_RIGHT_BORDER) 
151 ········.value("Aspect_TOR_RIGHT_AND_BOTTOM_BORDER",Aspect_TypeOfResize::Aspect_TOR_RIGHT_AND_BOTTOM_BORDER) 
152 ········.value("Aspect_TOR_BOTTOM_AND_LEFT_BORDER",Aspect_TypeOfResize::Aspect_TOR_BOTTOM_AND_LEFT_BORDER) 
153 ········.value("Aspect_TOR_LEFT_AND_TOP_BORDER",Aspect_TypeOfResize::Aspect_TOR_LEFT_AND_TOP_BORDER).export_values(); 
154 ····m.attr("Aspect_VKeyFlags_NONE")·=·py::cast(int(Aspect_VKeyFlags_NONE)); 
155 ····m.attr("Aspect_VKeyFlags_SHIFT")·=·py::cast(int(Aspect_VKeyFlags_SHIFT)); 
156 ····m.attr("Aspect_VKeyFlags_CTRL")·=·py::cast(int(Aspect_VKeyFlags_CTRL)); 
157 ····m.attr("Aspect_VKeyFlags_ALT")·=·py::cast(int(Aspect_VKeyFlags_ALT)); 
158 ····m.attr("Aspect_VKeyFlags_MENU")·=·py::cast(int(Aspect_VKeyFlags_MENU)); 
159 ····m.attr("Aspect_VKeyFlags_META")·=·py::cast(int(Aspect_VKeyFlags_META)); 
160 ····m.attr("Aspect_VKeyFlags_ALL")·=·py::cast(int(Aspect_VKeyFlags_ALL)); 
161 ····m.attr("Aspect_VKeyMouse_NONE")·=·py::cast(int(Aspect_VKeyMouse_NONE)); 
162 ····m.attr("Aspect_VKeyMouse_LeftButton")·=·py::cast(int(Aspect_VKeyMouse_LeftButton)); 
163 ····m.attr("Aspect_VKeyMouse_MiddleButton")·=·py::cast(int(Aspect_VKeyMouse_MiddleButton)); 
164 ····m.attr("Aspect_VKeyMouse_RightButton")·=·py::cast(int(Aspect_VKeyMouse_RightButton)); 
165 ····m.attr("Aspect_VKeyMouse_MainButtons")·=·py::cast(int(Aspect_VKeyMouse_MainButtons)); 
166 ····py::enum_<Aspect_PolygonOffsetMode>(m,·"Aspect_PolygonOffsetMode",R"#()#") 
167 ········.value("Aspect_POM_Off",Aspect_PolygonOffsetMode::Aspect_POM_Off) 
168 ········.value("Aspect_POM_Fill",Aspect_PolygonOffsetMode::Aspect_POM_Fill) 
169 ········.value("Aspect_POM_Line",Aspect_PolygonOffsetMode::Aspect_POM_Line) 
170 ········.value("Aspect_POM_Point",Aspect_PolygonOffsetMode::Aspect_POM_Point) 
171 ········.value("Aspect_POM_All",Aspect_PolygonOffsetMode::Aspect_POM_All) 
172 ········.value("Aspect_POM_None",Aspect_PolygonOffsetMode::Aspect_POM_None) 
173 ········.value("Aspect_POM_Mask",Aspect_PolygonOffsetMode::Aspect_POM_Mask).export_values(); 
174 ····py::enum_<Aspect_GridDrawMode>(m,·"Aspect_GridDrawMode",R"#(Defines·the·grid·draw·mode.·The·grid·may·be·drawn·by·using·lines·or·points.)#")117 ····py::enum_<Aspect_GridDrawMode>(m,·"Aspect_GridDrawMode",R"#(Defines·the·grid·draw·mode.·The·grid·may·be·drawn·by·using·lines·or·points.)#")
175 ········.value("Aspect_GDM_Lines",Aspect_GridDrawMode::Aspect_GDM_Lines)118 ········.value("Aspect_GDM_Lines",Aspect_GridDrawMode::Aspect_GDM_Lines)
176 ········.value("Aspect_GDM_Points",Aspect_GridDrawMode::Aspect_GDM_Points)119 ········.value("Aspect_GDM_Points",Aspect_GridDrawMode::Aspect_GDM_Points)
177 ········.value("Aspect_GDM_None",Aspect_GridDrawMode::Aspect_GDM_None).export_values();120 ········.value("Aspect_GDM_None",Aspect_GridDrawMode::Aspect_GDM_None).export_values();
 121 ····py::enum_<Aspect_TypeOfColorScaleData>(m,·"Aspect_TypeOfColorScaleData",R"#(Defines·the·using·type·of·colors·and·labels)#")
 122 ········.value("Aspect_TOCSD_AUTO",Aspect_TypeOfColorScaleData::Aspect_TOCSD_AUTO)
 123 ········.value("Aspect_TOCSD_USER",Aspect_TypeOfColorScaleData::Aspect_TOCSD_USER).export_values();
 124 ····py::enum_<Aspect_TypeOfStyleText>(m,·"Aspect_TypeOfStyleText",R"#(Define·the·style·of·the·text.)#")
 125 ········.value("Aspect_TOST_NORMAL",Aspect_TypeOfStyleText::Aspect_TOST_NORMAL)
 126 ········.value("Aspect_TOST_ANNOTATION",Aspect_TypeOfStyleText::Aspect_TOST_ANNOTATION).export_values();
178 ····py::enum_<Aspect_TypeOfColorScalePosition>(m,·"Aspect_TypeOfColorScalePosition",R"#(Defines·the·type·of·position·for·color·scale·labels)#")127 ····py::enum_<Aspect_TypeOfColorScaleOrientation>(m,·"Aspect_TypeOfColorScaleOrientation",R"#(Defines·the·type·of·color·scale·orientation)#")
179 ········.value("Aspect_TOCSP_NONE",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_NONE)128 ········.value("Aspect_TOCSO_NONE",Aspect_TypeOfColorScaleOrientation::Aspect_TOCSO_NONE)
180 ········.value("Aspect_TOCSP_LEFT",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_LEFT)129 ········.value("Aspect_TOCSO_LEFT",Aspect_TypeOfColorScaleOrientation::Aspect_TOCSO_LEFT)
181 ········.value("Aspect_TOCSP_RIGHT",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_RIGHT)130 ········.value("Aspect_TOCSO_RIGHT",Aspect_TypeOfColorScaleOrientation::Aspect_TOCSO_RIGHT)
182 ········.value("Aspect_TOCSP_CENTER",Aspect_TypeOfColorScalePosition::Aspect_TOCSP_CENTER).export_values();131 ········.value("Aspect_TOCSO_CENTER",Aspect_TypeOfColorScaleOrientation::Aspect_TOCSO_CENTER).export_values();
 132 ····py::enum_<Aspect_FillMethod>(m,·"Aspect_FillMethod",R"#(Defines·the·fill·methods·to·write·bitmaps·in·a·window.)#")
 133 ········.value("Aspect_FM_NONE",Aspect_FillMethod::Aspect_FM_NONE)
 134 ········.value("Aspect_FM_CENTERED",Aspect_FillMethod::Aspect_FM_CENTERED)
 135 ········.value("Aspect_FM_TILED",Aspect_FillMethod::Aspect_FM_TILED)
 136 ········.value("Aspect_FM_STRETCH",Aspect_FillMethod::Aspect_FM_STRETCH).export_values();
183 ····py::enum_<Aspect_InteriorStyle>(m,·"Aspect_InteriorStyle",R"#(Interior·types·for·primitive·faces.)#") 
184 ········.value("Aspect_IS_EMPTY",Aspect_InteriorStyle::Aspect_IS_EMPTY) 
185 ········.value("Aspect_IS_SOLID",Aspect_InteriorStyle::Aspect_IS_SOLID) 
186 ········.value("Aspect_IS_HATCH",Aspect_InteriorStyle::Aspect_IS_HATCH) 
187 ········.value("Aspect_IS_HIDDENLINE",Aspect_InteriorStyle::Aspect_IS_HIDDENLINE) 
188 ········.value("Aspect_IS_POINT",Aspect_InteriorStyle::Aspect_IS_POINT) 
189 ········.value("Aspect_IS_HOLLOW",Aspect_InteriorStyle::Aspect_IS_HOLLOW).export_values(); 
190 ····py::enum_<Aspect_TypeOfDeflection>(m,·"Aspect_TypeOfDeflection",R"#(Defines·if·the·maximal·chordial·deflection·used·when·drawing·an·object·is·absolute·or·relative·to·the·size·of·the·object.)#") 
191 ········.value("Aspect_TOD_RELATIVE",Aspect_TypeOfDeflection::Aspect_TOD_RELATIVE) 
192 ········.value("Aspect_TOD_ABSOLUTE",Aspect_TypeOfDeflection::Aspect_TOD_ABSOLUTE).export_values(); 
193 ····py::enum_<Aspect_XAtom>(m,·"Aspect_XAtom",R"#(Defines·custom·identifiers(atoms)·for·X·window·custom·named·properties)#")137 ····py::enum_<Aspect_XAtom>(m,·"Aspect_XAtom",R"#(Defines·custom·identifiers(atoms)·for·X·window·custom·named·properties)#")
194 ········.value("Aspect_XA_DELETE_WINDOW",Aspect_XAtom::Aspect_XA_DELETE_WINDOW).export_values();138 ········.value("Aspect_XA_DELETE_WINDOW",Aspect_XAtom::Aspect_XA_DELETE_WINDOW).export_values();
195 ····py::enum_<Aspect_WidthOfLine>(m,·"Aspect_WidthOfLine",R"#(Definition·of·line·types)#") 
196 ········.value("Aspect_WOL_THIN",Aspect_WidthOfLine::Aspect_WOL_THIN) 
197 ········.value("Aspect_WOL_MEDIUM",Aspect_WidthOfLine::Aspect_WOL_MEDIUM) 
198 ········.value("Aspect_WOL_THICK",Aspect_WidthOfLine::Aspect_WOL_THICK) 
199 ········.value("Aspect_WOL_VERYTHICK",Aspect_WidthOfLine::Aspect_WOL_VERYTHICK) 
200 ········.value("Aspect_WOL_USERDEFINED",Aspect_WidthOfLine::Aspect_WOL_USERDEFINED).export_values(); 
201 ····py::enum_<Aspect_XRTrackedDeviceRole>(m,·"Aspect_XRTrackedDeviceRole",R"#(Predefined·tracked·devices.)#")139 ····py::enum_<Aspect_XRTrackedDeviceRole>(m,·"Aspect_XRTrackedDeviceRole",R"#(Predefined·tracked·devices.)#")
202 ········.value("Aspect_XRTrackedDeviceRole_Head",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_Head)140 ········.value("Aspect_XRTrackedDeviceRole_Head",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_Head)
203 ········.value("Aspect_XRTrackedDeviceRole_LeftHand",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_LeftHand)141 ········.value("Aspect_XRTrackedDeviceRole_LeftHand",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_LeftHand)
204 ········.value("Aspect_XRTrackedDeviceRole_RightHand",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_RightHand)142 ········.value("Aspect_XRTrackedDeviceRole_RightHand",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_RightHand)
205 ········.value("Aspect_XRTrackedDeviceRole_Other",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_Other).export_values();143 ········.value("Aspect_XRTrackedDeviceRole_Other",Aspect_XRTrackedDeviceRole::Aspect_XRTrackedDeviceRole_Other).export_values();
206 ····m.attr("Aspect_XRTrackedDeviceRole_NB")·=·py::cast(int(Aspect_XRTrackedDeviceRole_NB));144 ····m.attr("Aspect_XRTrackedDeviceRole_NB")·=·py::cast(int(Aspect_XRTrackedDeviceRole_NB));
 145 ····py::enum_<Aspect_GridType>(m,·"Aspect_GridType",R"#(Defines·the·grid·type·:·Rectangular·or·Circular.)#")
 146 ········.value("Aspect_GT_Rectangular",Aspect_GridType::Aspect_GT_Rectangular)
 147 ········.value("Aspect_GT_Circular",Aspect_GridType::Aspect_GT_Circular).export_values();
207 ····py::enum_<Aspect_GradientFillMethod>(m,·"Aspect_GradientFillMethod",R"#(Defines·the·fill·methods·to·write·gradient·background·in·a·window.)#")148 ····py::enum_<Aspect_GradientFillMethod>(m,·"Aspect_GradientFillMethod",R"#(Defines·the·fill·methods·to·write·gradient·background·in·a·window.)#")
208 ········.value("Aspect_GradientFillMethod_None",Aspect_GradientFillMethod::Aspect_GradientFillMethod_None)149 ········.value("Aspect_GradientFillMethod_None",Aspect_GradientFillMethod::Aspect_GradientFillMethod_None)
209 ········.value("Aspect_GradientFillMethod_Horizontal",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Horizontal)150 ········.value("Aspect_GradientFillMethod_Horizontal",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Horizontal)
210 ········.value("Aspect_GradientFillMethod_Vertical",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Vertical)151 ········.value("Aspect_GradientFillMethod_Vertical",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Vertical)
211 ········.value("Aspect_GradientFillMethod_Diagonal1",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Diagonal1)152 ········.value("Aspect_GradientFillMethod_Diagonal1",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Diagonal1)
212 ········.value("Aspect_GradientFillMethod_Diagonal2",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Diagonal2)153 ········.value("Aspect_GradientFillMethod_Diagonal2",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Diagonal2)
213 ········.value("Aspect_GradientFillMethod_Corner1",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Corner1)154 ········.value("Aspect_GradientFillMethod_Corner1",Aspect_GradientFillMethod::Aspect_GradientFillMethod_Corner1)
Offset 223, 14 lines modifiedOffset 164, 43 lines modified
223 ········.value("Aspect_GFM_VER",Aspect_GradientFillMethod::Aspect_GFM_VER)164 ········.value("Aspect_GFM_VER",Aspect_GradientFillMethod::Aspect_GFM_VER)
224 ········.value("Aspect_GFM_DIAG1",Aspect_GradientFillMethod::Aspect_GFM_DIAG1)165 ········.value("Aspect_GFM_DIAG1",Aspect_GradientFillMethod::Aspect_GFM_DIAG1)
225 ········.value("Aspect_GFM_DIAG2",Aspect_GradientFillMethod::Aspect_GFM_DIAG2)166 ········.value("Aspect_GFM_DIAG2",Aspect_GradientFillMethod::Aspect_GFM_DIAG2)
226 ········.value("Aspect_GFM_CORNER1",Aspect_GradientFillMethod::Aspect_GFM_CORNER1)167 ········.value("Aspect_GFM_CORNER1",Aspect_GradientFillMethod::Aspect_GFM_CORNER1)
227 ········.value("Aspect_GFM_CORNER2",Aspect_GradientFillMethod::Aspect_GFM_CORNER2)168 ········.value("Aspect_GFM_CORNER2",Aspect_GradientFillMethod::Aspect_GFM_CORNER2)
228 ········.value("Aspect_GFM_CORNER3",Aspect_GradientFillMethod::Aspect_GFM_CORNER3)169 ········.value("Aspect_GFM_CORNER3",Aspect_GradientFillMethod::Aspect_GFM_CORNER3)
229 ········.value("Aspect_GFM_CORNER4",Aspect_GradientFillMethod::Aspect_GFM_CORNER4).export_values();170 ········.value("Aspect_GFM_CORNER4",Aspect_GradientFillMethod::Aspect_GFM_CORNER4).export_values();
 171 ····py::enum_<Aspect_HatchStyle>(m,·"Aspect_HatchStyle",R"#(Definition·of·all·available·hatch·styles.)#")
Max diff block lines reached; 17316/31823 bytes (54.41%) of diff not shown.
⊟
2.51 KB
./usr/share/libocp/OCP/BOPAlgo_pre.cpp
Ordering differences only
    
Offset 89, 14 lines modifiedOffset 89, 18 lines modified
89 py::module·m·=·main_module.def_submodule("BOPAlgo",·R"#()#");89 py::module·m·=·main_module.def_submodule("BOPAlgo",·R"#()#");
  
90 //·add·namespaces·as·submodules90 //·add·namespaces·as·submodules
  
91 //·user-defined·inclusion·per·module·in·the·body91 //·user-defined·inclusion·per·module·in·the·body
  
92 //·enums92 //·enums
 93 ····py::enum_<BOPAlgo_GlueEnum>(m,·"BOPAlgo_GlueEnum",R"#(The·Enumeration·describes·an·additional·option·for·the·algorithms·in·the·Boolean·Component·such·as·General·Fuse,·Boolean·operations,·Section,·Maker·Volume,·Splitter·and·Cells·Builder·algorithms.)#")
 94 ········.value("BOPAlgo_GlueOff",BOPAlgo_GlueEnum::BOPAlgo_GlueOff)
 95 ········.value("BOPAlgo_GlueShift",BOPAlgo_GlueEnum::BOPAlgo_GlueShift)
 96 ········.value("BOPAlgo_GlueFull",BOPAlgo_GlueEnum::BOPAlgo_GlueFull).export_values();
93 ····py::enum_<BOPAlgo_Operation>(m,·"BOPAlgo_Operation",R"#()#")97 ····py::enum_<BOPAlgo_Operation>(m,·"BOPAlgo_Operation",R"#()#")
94 ········.value("BOPAlgo_COMMON",BOPAlgo_Operation::BOPAlgo_COMMON)98 ········.value("BOPAlgo_COMMON",BOPAlgo_Operation::BOPAlgo_COMMON)
95 ········.value("BOPAlgo_FUSE",BOPAlgo_Operation::BOPAlgo_FUSE)99 ········.value("BOPAlgo_FUSE",BOPAlgo_Operation::BOPAlgo_FUSE)
96 ········.value("BOPAlgo_CUT",BOPAlgo_Operation::BOPAlgo_CUT)100 ········.value("BOPAlgo_CUT",BOPAlgo_Operation::BOPAlgo_CUT)
97 ········.value("BOPAlgo_CUT21",BOPAlgo_Operation::BOPAlgo_CUT21)101 ········.value("BOPAlgo_CUT21",BOPAlgo_Operation::BOPAlgo_CUT21)
98 ········.value("BOPAlgo_SECTION",BOPAlgo_Operation::BOPAlgo_SECTION)102 ········.value("BOPAlgo_SECTION",BOPAlgo_Operation::BOPAlgo_SECTION)
99 ········.value("BOPAlgo_UNKNOWN",BOPAlgo_Operation::BOPAlgo_UNKNOWN).export_values();103 ········.value("BOPAlgo_UNKNOWN",BOPAlgo_Operation::BOPAlgo_UNKNOWN).export_values();
Offset 109, 18 lines modifiedOffset 113, 14 lines modified
109 ········.value("BOPAlgo_IncompatibilityOfVertex",BOPAlgo_CheckStatus::BOPAlgo_IncompatibilityOfVertex)113 ········.value("BOPAlgo_IncompatibilityOfVertex",BOPAlgo_CheckStatus::BOPAlgo_IncompatibilityOfVertex)
110 ········.value("BOPAlgo_IncompatibilityOfEdge",BOPAlgo_CheckStatus::BOPAlgo_IncompatibilityOfEdge)114 ········.value("BOPAlgo_IncompatibilityOfEdge",BOPAlgo_CheckStatus::BOPAlgo_IncompatibilityOfEdge)
111 ········.value("BOPAlgo_IncompatibilityOfFace",BOPAlgo_CheckStatus::BOPAlgo_IncompatibilityOfFace)115 ········.value("BOPAlgo_IncompatibilityOfFace",BOPAlgo_CheckStatus::BOPAlgo_IncompatibilityOfFace)
112 ········.value("BOPAlgo_OperationAborted",BOPAlgo_CheckStatus::BOPAlgo_OperationAborted)116 ········.value("BOPAlgo_OperationAborted",BOPAlgo_CheckStatus::BOPAlgo_OperationAborted)
113 ········.value("BOPAlgo_GeomAbs_C0",BOPAlgo_CheckStatus::BOPAlgo_GeomAbs_C0)117 ········.value("BOPAlgo_GeomAbs_C0",BOPAlgo_CheckStatus::BOPAlgo_GeomAbs_C0)
114 ········.value("BOPAlgo_InvalidCurveOnSurface",BOPAlgo_CheckStatus::BOPAlgo_InvalidCurveOnSurface)118 ········.value("BOPAlgo_InvalidCurveOnSurface",BOPAlgo_CheckStatus::BOPAlgo_InvalidCurveOnSurface)
115 ········.value("BOPAlgo_NotValid",BOPAlgo_CheckStatus::BOPAlgo_NotValid).export_values();119 ········.value("BOPAlgo_NotValid",BOPAlgo_CheckStatus::BOPAlgo_NotValid).export_values();
116 ····py::enum_<BOPAlgo_GlueEnum>(m,·"BOPAlgo_GlueEnum",R"#(The·Enumeration·describes·an·additional·option·for·the·algorithms·in·the·Boolean·Component·such·as·General·Fuse,·Boolean·operations,·Section,·Maker·Volume,·Splitter·and·Cells·Builder·algorithms.)#") 
117 ········.value("BOPAlgo_GlueOff",BOPAlgo_GlueEnum::BOPAlgo_GlueOff) 
118 ········.value("BOPAlgo_GlueShift",BOPAlgo_GlueEnum::BOPAlgo_GlueShift) 
119 ········.value("BOPAlgo_GlueFull",BOPAlgo_GlueEnum::BOPAlgo_GlueFull).export_values(); 
  
120 //Python·trampoline·classes120 //Python·trampoline·classes
121 ····class·Py_BOPAlgo_Algo·:·public·BOPAlgo_Algo{121 ····class·Py_BOPAlgo_Algo·:·public·BOPAlgo_Algo{
122 ····public:122 ····public:
123 ········using·BOPAlgo_Algo::BOPAlgo_Algo;123 ········using·BOPAlgo_Algo::BOPAlgo_Algo;
  
  
⊟
10.3 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_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.)#")
 111 ········.value("BRepBuilderAPI_WireDone",BRepBuilderAPI_WireError::BRepBuilderAPI_WireDone)
 112 ········.value("BRepBuilderAPI_EmptyWire",BRepBuilderAPI_WireError::BRepBuilderAPI_EmptyWire)
 113 ········.value("BRepBuilderAPI_DisconnectedWire",BRepBuilderAPI_WireError::BRepBuilderAPI_DisconnectedWire)
 114 ········.value("BRepBuilderAPI_NonManifoldWire",BRepBuilderAPI_WireError::BRepBuilderAPI_NonManifoldWire).export_values();
 115 ····py::enum_<BRepBuilderAPI_TransitionMode>(m,·"BRepBuilderAPI_TransitionMode",R"#(Option·to·manage·discontinuities·in·Sweep)#")
 116 ········.value("BRepBuilderAPI_Transformed",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_Transformed)
 117 ········.value("BRepBuilderAPI_RightCorner",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_RightCorner)
 118 ········.value("BRepBuilderAPI_RoundCorner",BRepBuilderAPI_TransitionMode::BRepBuilderAPI_RoundCorner).export_values();
110 ····py::enum_<BRepBuilderAPI_PipeError>(m,·"BRepBuilderAPI_PipeError",R"#(Errors·that·can·occur·at·(shell)pipe·construction.)#")119 ····py::enum_<BRepBuilderAPI_PipeError>(m,·"BRepBuilderAPI_PipeError",R"#(Errors·that·can·occur·at·(shell)pipe·construction.)#")
111 ········.value("BRepBuilderAPI_PipeDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeDone)120 ········.value("BRepBuilderAPI_PipeDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeDone)
112 ········.value("BRepBuilderAPI_PipeNotDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeNotDone)121 ········.value("BRepBuilderAPI_PipeNotDone",BRepBuilderAPI_PipeError::BRepBuilderAPI_PipeNotDone)
113 ········.value("BRepBuilderAPI_PlaneNotIntersectGuide",BRepBuilderAPI_PipeError::BRepBuilderAPI_PlaneNotIntersectGuide)122 ········.value("BRepBuilderAPI_PlaneNotIntersectGuide",BRepBuilderAPI_PipeError::BRepBuilderAPI_PlaneNotIntersectGuide)
114 ········.value("BRepBuilderAPI_ImpossibleContact",BRepBuilderAPI_PipeError::BRepBuilderAPI_ImpossibleContact).export_values();123 ········.value("BRepBuilderAPI_ImpossibleContact",BRepBuilderAPI_PipeError::BRepBuilderAPI_ImpossibleContact).export_values();
115 ····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.)#") 
116 ········.value("BRepBuilderAPI_Preserved",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Preserved) 
117 ········.value("BRepBuilderAPI_Deleted",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Deleted) 
118 ········.value("BRepBuilderAPI_Trimmed",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Trimmed) 
119 ········.value("BRepBuilderAPI_Merged",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Merged) 
120 ········.value("BRepBuilderAPI_BoundaryModified",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_BoundaryModified).export_values(); 
121 ····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.)#")124 ····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.)#")
122 ········.value("BRepBuilderAPI_FaceDone",BRepBuilderAPI_FaceError::BRepBuilderAPI_FaceDone)125 ········.value("BRepBuilderAPI_FaceDone",BRepBuilderAPI_FaceError::BRepBuilderAPI_FaceDone)
123 ········.value("BRepBuilderAPI_NoFace",BRepBuilderAPI_FaceError::BRepBuilderAPI_NoFace)126 ········.value("BRepBuilderAPI_NoFace",BRepBuilderAPI_FaceError::BRepBuilderAPI_NoFace)
124 ········.value("BRepBuilderAPI_NotPlanar",BRepBuilderAPI_FaceError::BRepBuilderAPI_NotPlanar)127 ········.value("BRepBuilderAPI_NotPlanar",BRepBuilderAPI_FaceError::BRepBuilderAPI_NotPlanar)
125 ········.value("BRepBuilderAPI_CurveProjectionFailed",BRepBuilderAPI_FaceError::BRepBuilderAPI_CurveProjectionFailed)128 ········.value("BRepBuilderAPI_CurveProjectionFailed",BRepBuilderAPI_FaceError::BRepBuilderAPI_CurveProjectionFailed)
126 ········.value("BRepBuilderAPI_ParametersOutOfRange",BRepBuilderAPI_FaceError::BRepBuilderAPI_ParametersOutOfRange).export_values();129 ········.value("BRepBuilderAPI_ParametersOutOfRange",BRepBuilderAPI_FaceError::BRepBuilderAPI_ParametersOutOfRange).export_values();
127 ····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.)#") 
128 ········.value("BRepBuilderAPI_WireDone",BRepBuilderAPI_WireError::BRepBuilderAPI_WireDone) 
129 ········.value("BRepBuilderAPI_EmptyWire",BRepBuilderAPI_WireError::BRepBuilderAPI_EmptyWire) 
130 ········.value("BRepBuilderAPI_DisconnectedWire",BRepBuilderAPI_WireError::BRepBuilderAPI_DisconnectedWire) 
131 ········.value("BRepBuilderAPI_NonManifoldWire",BRepBuilderAPI_WireError::BRepBuilderAPI_NonManifoldWire).export_values(); 
132 ····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_PointProjectionFailed·No·parameters·were·given·but·the·projection·of·the·3D·points·on·the·curve·failed.·This·happens·when·the·point·distance·to·the·curve·is·greater·than·the·precision·value.·-·BRepBuilderAPI_ParameterOutOfRange·The·given·parameters·are·not·in·the·parametric·range·C->FirstParameter(),·C->LastParameter()·-·BRepBuilderAPI_DifferentPointsOnClosedCurve·The·two·vertices·or·points·are·the·extremities·of·a·closed·curve·but·have·different·locations.·-·BRepBuilderAPI_PointWithInfiniteParameter·A·finite·coordinate·point·was·associated·with·an·infinite·parameter·(see·the·Precision·package·for·a·definition·of·infinite·values).·-·BRepBuilderAPI_DifferentsPointAndParameter·The·distance·between·the·3D·point·and·the·point·evaluated·on·the·curve·with·the·parameter·is·greater·than·the·precision.·-·BRepBuilderAPI_LineThroughIdenticPoints·Two·identical·points·were·given·to·define·a·line·(construction·of·an·edge·without·curve);·gp::Resolution·is·used·for·the·confusion·test.)#")130 ····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_PointProjectionFailed·No·parameters·were·given·but·the·projection·of·the·3D·points·on·the·curve·failed.·This·happens·when·the·point·distance·to·the·curve·is·greater·than·the·precision·value.·-·BRepBuilderAPI_ParameterOutOfRange·The·given·parameters·are·not·in·the·parametric·range·C->FirstParameter(),·C->LastParameter()·-·BRepBuilderAPI_DifferentPointsOnClosedCurve·The·two·vertices·or·points·are·the·extremities·of·a·closed·curve·but·have·different·locations.·-·BRepBuilderAPI_PointWithInfiniteParameter·A·finite·coordinate·point·was·associated·with·an·infinite·parameter·(see·the·Precision·package·for·a·definition·of·infinite·values).·-·BRepBuilderAPI_DifferentsPointAndParameter·The·distance·between·the·3D·point·and·the·point·evaluated·on·the·curve·with·the·parameter·is·greater·than·the·precision.·-·BRepBuilderAPI_LineThroughIdenticPoints·Two·identical·points·were·given·to·define·a·line·(construction·of·an·edge·without·curve);·gp::Resolution·is·used·for·the·confusion·test.)#")
133 ········.value("BRepBuilderAPI_EdgeDone",BRepBuilderAPI_EdgeError::BRepBuilderAPI_EdgeDone)131 ········.value("BRepBuilderAPI_EdgeDone",BRepBuilderAPI_EdgeError::BRepBuilderAPI_EdgeDone)
134 ········.value("BRepBuilderAPI_PointProjectionFailed",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointProjectionFailed)132 ········.value("BRepBuilderAPI_PointProjectionFailed",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointProjectionFailed)
135 ········.value("BRepBuilderAPI_ParameterOutOfRange",BRepBuilderAPI_EdgeError::BRepBuilderAPI_ParameterOutOfRange)133 ········.value("BRepBuilderAPI_ParameterOutOfRange",BRepBuilderAPI_EdgeError::BRepBuilderAPI_ParameterOutOfRange)
136 ········.value("BRepBuilderAPI_DifferentPointsOnClosedCurve",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentPointsOnClosedCurve)134 ········.value("BRepBuilderAPI_DifferentPointsOnClosedCurve",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentPointsOnClosedCurve)
137 ········.value("BRepBuilderAPI_PointWithInfiniteParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointWithInfiniteParameter)135 ········.value("BRepBuilderAPI_PointWithInfiniteParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_PointWithInfiniteParameter)
138 ········.value("BRepBuilderAPI_DifferentsPointAndParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentsPointAndParameter)136 ········.value("BRepBuilderAPI_DifferentsPointAndParameter",BRepBuilderAPI_EdgeError::BRepBuilderAPI_DifferentsPointAndParameter)
139 ········.value("BRepBuilderAPI_LineThroughIdenticPoints",BRepBuilderAPI_EdgeError::BRepBuilderAPI_LineThroughIdenticPoints).export_values();137 ········.value("BRepBuilderAPI_LineThroughIdenticPoints",BRepBuilderAPI_EdgeError::BRepBuilderAPI_LineThroughIdenticPoints).export_values();
 138 ····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.)#")
 139 ········.value("BRepBuilderAPI_Preserved",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Preserved)
 140 ········.value("BRepBuilderAPI_Deleted",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Deleted)
 141 ········.value("BRepBuilderAPI_Trimmed",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Trimmed)
 142 ········.value("BRepBuilderAPI_Merged",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_Merged)
 143 ········.value("BRepBuilderAPI_BoundaryModified",BRepBuilderAPI_ShapeModification::BRepBuilderAPI_BoundaryModified).export_values();
140 ····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.)#")144 ····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.)#")
141 ········.value("BRepBuilderAPI_ShellDone",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellDone)145 ········.value("BRepBuilderAPI_ShellDone",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellDone)
142 ········.value("BRepBuilderAPI_EmptyShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_EmptyShell)146 ········.value("BRepBuilderAPI_EmptyShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_EmptyShell)
143 ········.value("BRepBuilderAPI_DisconnectedShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_DisconnectedShell)147 ········.value("BRepBuilderAPI_DisconnectedShell",BRepBuilderAPI_ShellError::BRepBuilderAPI_DisconnectedShell)
144 ········.value("BRepBuilderAPI_ShellParametersOutOfRange",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellParametersOutOfRange).export_values();148 ········.value("BRepBuilderAPI_ShellParametersOutOfRange",BRepBuilderAPI_ShellError::BRepBuilderAPI_ShellParametersOutOfRange).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.)#");
⊟
3.65 KB
./usr/share/libocp/OCP/BRepFeat_pre.cpp
Ordering differences only
    
Offset 80, 20 lines modifiedOffset 80, 14 lines modified
80 //·user-defined·inclusion·per·module·in·the·body80 //·user-defined·inclusion·per·module·in·the·body
  
81 //·enums81 //·enums
82 ····py::enum_<BRepFeat_Status>(m,·"BRepFeat_Status",R"#()#")82 ····py::enum_<BRepFeat_Status>(m,·"BRepFeat_Status",R"#()#")
83 ········.value("BRepFeat_NoError",BRepFeat_Status::BRepFeat_NoError)83 ········.value("BRepFeat_NoError",BRepFeat_Status::BRepFeat_NoError)
84 ········.value("BRepFeat_InvalidPlacement",BRepFeat_Status::BRepFeat_InvalidPlacement)84 ········.value("BRepFeat_InvalidPlacement",BRepFeat_Status::BRepFeat_InvalidPlacement)
85 ········.value("BRepFeat_HoleTooLong",BRepFeat_Status::BRepFeat_HoleTooLong).export_values();85 ········.value("BRepFeat_HoleTooLong",BRepFeat_Status::BRepFeat_HoleTooLong).export_values();
86 ····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.)#") 
87 ········.value("BRepFeat_NoSelection",BRepFeat_PerfSelection::BRepFeat_NoSelection) 
88 ········.value("BRepFeat_SelectionFU",BRepFeat_PerfSelection::BRepFeat_SelectionFU) 
89 ········.value("BRepFeat_SelectionU",BRepFeat_PerfSelection::BRepFeat_SelectionU) 
90 ········.value("BRepFeat_SelectionSh",BRepFeat_PerfSelection::BRepFeat_SelectionSh) 
91 ········.value("BRepFeat_SelectionShU",BRepFeat_PerfSelection::BRepFeat_SelectionShU).export_values(); 
92 ····py::enum_<BRepFeat_StatusError>(m,·"BRepFeat_StatusError",R"#(Describes·the·error.)#")86 ····py::enum_<BRepFeat_StatusError>(m,·"BRepFeat_StatusError",R"#(Describes·the·error.)#")
93 ········.value("BRepFeat_OK",BRepFeat_StatusError::BRepFeat_OK)87 ········.value("BRepFeat_OK",BRepFeat_StatusError::BRepFeat_OK)
94 ········.value("BRepFeat_BadDirect",BRepFeat_StatusError::BRepFeat_BadDirect)88 ········.value("BRepFeat_BadDirect",BRepFeat_StatusError::BRepFeat_BadDirect)
95 ········.value("BRepFeat_BadIntersect",BRepFeat_StatusError::BRepFeat_BadIntersect)89 ········.value("BRepFeat_BadIntersect",BRepFeat_StatusError::BRepFeat_BadIntersect)
96 ········.value("BRepFeat_EmptyBaryCurve",BRepFeat_StatusError::BRepFeat_EmptyBaryCurve)90 ········.value("BRepFeat_EmptyBaryCurve",BRepFeat_StatusError::BRepFeat_EmptyBaryCurve)
97 ········.value("BRepFeat_EmptyCutResult",BRepFeat_StatusError::BRepFeat_EmptyCutResult)91 ········.value("BRepFeat_EmptyCutResult",BRepFeat_StatusError::BRepFeat_EmptyCutResult)
98 ········.value("BRepFeat_FalseSide",BRepFeat_StatusError::BRepFeat_FalseSide)92 ········.value("BRepFeat_FalseSide",BRepFeat_StatusError::BRepFeat_FalseSide)
Offset 115, 14 lines modifiedOffset 109, 20 lines modified
115 ········.value("BRepFeat_NoParts",BRepFeat_StatusError::BRepFeat_NoParts)109 ········.value("BRepFeat_NoParts",BRepFeat_StatusError::BRepFeat_NoParts)
116 ········.value("BRepFeat_NoProjPt",BRepFeat_StatusError::BRepFeat_NoProjPt)110 ········.value("BRepFeat_NoProjPt",BRepFeat_StatusError::BRepFeat_NoProjPt)
117 ········.value("BRepFeat_NotInitialized",BRepFeat_StatusError::BRepFeat_NotInitialized)111 ········.value("BRepFeat_NotInitialized",BRepFeat_StatusError::BRepFeat_NotInitialized)
118 ········.value("BRepFeat_NotYetImplemented",BRepFeat_StatusError::BRepFeat_NotYetImplemented)112 ········.value("BRepFeat_NotYetImplemented",BRepFeat_StatusError::BRepFeat_NotYetImplemented)
119 ········.value("BRepFeat_NullRealTool",BRepFeat_StatusError::BRepFeat_NullRealTool)113 ········.value("BRepFeat_NullRealTool",BRepFeat_StatusError::BRepFeat_NullRealTool)
120 ········.value("BRepFeat_NullToolF",BRepFeat_StatusError::BRepFeat_NullToolF)114 ········.value("BRepFeat_NullToolF",BRepFeat_StatusError::BRepFeat_NullToolF)
121 ········.value("BRepFeat_NullToolU",BRepFeat_StatusError::BRepFeat_NullToolU).export_values();115 ········.value("BRepFeat_NullToolU",BRepFeat_StatusError::BRepFeat_NullToolU).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.)#")
 117 ········.value("BRepFeat_NoSelection",BRepFeat_PerfSelection::BRepFeat_NoSelection)
 118 ········.value("BRepFeat_SelectionFU",BRepFeat_PerfSelection::BRepFeat_SelectionFU)
 119 ········.value("BRepFeat_SelectionU",BRepFeat_PerfSelection::BRepFeat_SelectionU)
 120 ········.value("BRepFeat_SelectionSh",BRepFeat_PerfSelection::BRepFeat_SelectionSh)
 121 ········.value("BRepFeat_SelectionShU",BRepFeat_PerfSelection::BRepFeat_SelectionShU).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.26 KB
./usr/share/libocp/OCP/BRepFill_pre.cpp
Ordering differences only
    
Offset 160, 22 lines modifiedOffset 160, 22 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_TypeOfContact>(m,·"BRepFill_TypeOfContact",R"#(A·pair·of·bound·shapes·with·the·result.)#")164 ····py::enum_<BRepFill_TypeOfContact>(m,·"BRepFill_TypeOfContact",R"#(A·pair·of·bound·shapes·with·the·result.)#")
169 ········.value("BRepFill_NoContact",BRepFill_TypeOfContact::BRepFill_NoContact)165 ········.value("BRepFill_NoContact",BRepFill_TypeOfContact::BRepFill_NoContact)
170 ········.value("BRepFill_Contact",BRepFill_TypeOfContact::BRepFill_Contact)166 ········.value("BRepFill_Contact",BRepFill_TypeOfContact::BRepFill_Contact)
171 ········.value("BRepFill_ContactOnBorder",BRepFill_TypeOfContact::BRepFill_ContactOnBorder).export_values();167 ········.value("BRepFill_ContactOnBorder",BRepFill_TypeOfContact::BRepFill_ContactOnBorder).export_values();
 168 ····py::enum_<BRepFill_TransitionStyle>(m,·"BRepFill_TransitionStyle",R"#()#")
 169 ········.value("BRepFill_Modified",BRepFill_TransitionStyle::BRepFill_Modified)
 170 ········.value("BRepFill_Right",BRepFill_TransitionStyle::BRepFill_Right)
 171 ········.value("BRepFill_Round",BRepFill_TransitionStyle::BRepFill_Round).export_values();
172 ····py::enum_<BRepFill_ThruSectionErrorStatus>(m,·"BRepFill_ThruSectionErrorStatus",R"#(Errors·that·can·occur·at·thrusection·algorithm.)#")172 ····py::enum_<BRepFill_ThruSectionErrorStatus>(m,·"BRepFill_ThruSectionErrorStatus",R"#(Errors·that·can·occur·at·thrusection·algorithm.)#")
173 ········.value("BRepFill_ThruSectionErrorStatus_Done",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Done)173 ········.value("BRepFill_ThruSectionErrorStatus_Done",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Done)
174 ········.value("BRepFill_ThruSectionErrorStatus_NotDone",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotDone)174 ········.value("BRepFill_ThruSectionErrorStatus_NotDone",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotDone)
175 ········.value("BRepFill_ThruSectionErrorStatus_NotSameTopology",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotSameTopology)175 ········.value("BRepFill_ThruSectionErrorStatus_NotSameTopology",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_NotSameTopology)
176 ········.value("BRepFill_ThruSectionErrorStatus_ProfilesInconsistent",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_ProfilesInconsistent)176 ········.value("BRepFill_ThruSectionErrorStatus_ProfilesInconsistent",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_ProfilesInconsistent)
177 ········.value("BRepFill_ThruSectionErrorStatus_WrongUsage",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_WrongUsage)177 ········.value("BRepFill_ThruSectionErrorStatus_WrongUsage",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_WrongUsage)
178 ········.value("BRepFill_ThruSectionErrorStatus_Null3DCurve",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Null3DCurve)178 ········.value("BRepFill_ThruSectionErrorStatus_Null3DCurve",BRepFill_ThruSectionErrorStatus::BRepFill_ThruSectionErrorStatus_Null3DCurve)
⊟
4.36 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_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_FaceError>(m,·"BRepLib_FaceError",R"#(Errors·that·can·occur·at·face·construction.·no·error·not·initialised)#") 
111 ········.value("BRepLib_FaceDone",BRepLib_FaceError::BRepLib_FaceDone) 
112 ········.value("BRepLib_NoFace",BRepLib_FaceError::BRepLib_NoFace) 
113 ········.value("BRepLib_NotPlanar",BRepLib_FaceError::BRepLib_NotPlanar) 
114 ········.value("BRepLib_CurveProjectionFailed",BRepLib_FaceError::BRepLib_CurveProjectionFailed) 
115 ········.value("BRepLib_ParametersOutOfRange",BRepLib_FaceError::BRepLib_ParametersOutOfRange).export_values(); 
116 ····py::enum_<BRepLib_ShellError>(m,·"BRepLib_ShellError",R"#(Errors·that·can·occur·at·shell·construction.)#")104 ····py::enum_<BRepLib_ShellError>(m,·"BRepLib_ShellError",R"#(Errors·that·can·occur·at·shell·construction.)#")
117 ········.value("BRepLib_ShellDone",BRepLib_ShellError::BRepLib_ShellDone)105 ········.value("BRepLib_ShellDone",BRepLib_ShellError::BRepLib_ShellDone)
118 ········.value("BRepLib_EmptyShell",BRepLib_ShellError::BRepLib_EmptyShell)106 ········.value("BRepLib_EmptyShell",BRepLib_ShellError::BRepLib_EmptyShell)
119 ········.value("BRepLib_DisconnectedShell",BRepLib_ShellError::BRepLib_DisconnectedShell)107 ········.value("BRepLib_DisconnectedShell",BRepLib_ShellError::BRepLib_DisconnectedShell)
120 ········.value("BRepLib_ShellParametersOutOfRange",BRepLib_ShellError::BRepLib_ShellParametersOutOfRange).export_values();108 ········.value("BRepLib_ShellParametersOutOfRange",BRepLib_ShellError::BRepLib_ShellParametersOutOfRange).export_values();
121 ····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)#")
122 ········.value("BRepLib_WireDone",BRepLib_WireError::BRepLib_WireDone)110 ········.value("BRepLib_WireDone",BRepLib_WireError::BRepLib_WireDone)
123 ········.value("BRepLib_EmptyWire",BRepLib_WireError::BRepLib_EmptyWire)111 ········.value("BRepLib_EmptyWire",BRepLib_WireError::BRepLib_EmptyWire)
124 ········.value("BRepLib_DisconnectedWire",BRepLib_WireError::BRepLib_DisconnectedWire)112 ········.value("BRepLib_DisconnectedWire",BRepLib_WireError::BRepLib_DisconnectedWire)
125 ········.value("BRepLib_NonManifoldWire",BRepLib_WireError::BRepLib_NonManifoldWire).export_values();113 ········.value("BRepLib_NonManifoldWire",BRepLib_WireError::BRepLib_NonManifoldWire).export_values();
 114 ····py::enum_<BRepLib_ShapeModification>(m,·"BRepLib_ShapeModification",R"#(Modification·type·after·a·topologic·operation.)#")
 115 ········.value("BRepLib_Preserved",BRepLib_ShapeModification::BRepLib_Preserved)
 116 ········.value("BRepLib_Deleted",BRepLib_ShapeModification::BRepLib_Deleted)
 117 ········.value("BRepLib_Trimmed",BRepLib_ShapeModification::BRepLib_Trimmed)
 118 ········.value("BRepLib_Merged",BRepLib_ShapeModification::BRepLib_Merged)
 119 ········.value("BRepLib_BoundaryModified",BRepLib_ShapeModification::BRepLib_BoundaryModified).export_values();
126 ····py::enum_<BRepLib_EdgeError>(m,·"BRepLib_EdgeError",R"#(Errors·that·can·occur·at·edge·construction.·no·error)#")120 ····py::enum_<BRepLib_EdgeError>(m,·"BRepLib_EdgeError",R"#(Errors·that·can·occur·at·edge·construction.·no·error)#")
127 ········.value("BRepLib_EdgeDone",BRepLib_EdgeError::BRepLib_EdgeDone)121 ········.value("BRepLib_EdgeDone",BRepLib_EdgeError::BRepLib_EdgeDone)
128 ········.value("BRepLib_PointProjectionFailed",BRepLib_EdgeError::BRepLib_PointProjectionFailed)122 ········.value("BRepLib_PointProjectionFailed",BRepLib_EdgeError::BRepLib_PointProjectionFailed)
129 ········.value("BRepLib_ParameterOutOfRange",BRepLib_EdgeError::BRepLib_ParameterOutOfRange)123 ········.value("BRepLib_ParameterOutOfRange",BRepLib_EdgeError::BRepLib_ParameterOutOfRange)
130 ········.value("BRepLib_DifferentPointsOnClosedCurve",BRepLib_EdgeError::BRepLib_DifferentPointsOnClosedCurve)124 ········.value("BRepLib_DifferentPointsOnClosedCurve",BRepLib_EdgeError::BRepLib_DifferentPointsOnClosedCurve)
131 ········.value("BRepLib_PointWithInfiniteParameter",BRepLib_EdgeError::BRepLib_PointWithInfiniteParameter)125 ········.value("BRepLib_PointWithInfiniteParameter",BRepLib_EdgeError::BRepLib_PointWithInfiniteParameter)
132 ········.value("BRepLib_DifferentsPointAndParameter",BRepLib_EdgeError::BRepLib_DifferentsPointAndParameter)126 ········.value("BRepLib_DifferentsPointAndParameter",BRepLib_EdgeError::BRepLib_DifferentsPointAndParameter)
133 ········.value("BRepLib_LineThroughIdenticPoints",BRepLib_EdgeError::BRepLib_LineThroughIdenticPoints).export_values();127 ········.value("BRepLib_LineThroughIdenticPoints",BRepLib_EdgeError::BRepLib_LineThroughIdenticPoints).export_values();
 128 ····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)
 130 ········.value("BRepLib_NoFace",BRepLib_FaceError::BRepLib_NoFace)
 131 ········.value("BRepLib_NotPlanar",BRepLib_FaceError::BRepLib_NotPlanar)
 132 ········.value("BRepLib_CurveProjectionFailed",BRepLib_FaceError::BRepLib_CurveProjectionFailed)
 133 ········.value("BRepLib_ParametersOutOfRange",BRepLib_FaceError::BRepLib_ParametersOutOfRange).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;
  
  
⊟
1.96 KB
./usr/share/libocp/OCP/BRepMesh_pre.cpp
Ordering differences only
    
Offset 91, 27 lines modifiedOffset 91, 27 lines modified
  
91 //·add·namespaces·as·submodules91 //·add·namespaces·as·submodules
92 m.def_submodule("std");92 m.def_submodule("std");
  
93 //·user-defined·inclusion·per·module·in·the·body93 //·user-defined·inclusion·per·module·in·the·body
  
94 //·enums94 //·enums
 95 ····py::enum_<BRepMesh_FactoryError>(m,·"BRepMesh_FactoryError",R"#()#")
 96 ········.value("BRepMesh_FE_NOERROR",BRepMesh_FactoryError::BRepMesh_FE_NOERROR)
 97 ········.value("BRepMesh_FE_LIBRARYNOTFOUND",BRepMesh_FactoryError::BRepMesh_FE_LIBRARYNOTFOUND)
 98 ········.value("BRepMesh_FE_FUNCTIONNOTFOUND",BRepMesh_FactoryError::BRepMesh_FE_FUNCTIONNOTFOUND)
 99 ········.value("BRepMesh_FE_CANNOTCREATEALGO",BRepMesh_FactoryError::BRepMesh_FE_CANNOTCREATEALGO).export_values();
95 ····py::enum_<BRepMesh_DegreeOfFreedom>(m,·"BRepMesh_DegreeOfFreedom",R"#()#")100 ····py::enum_<BRepMesh_DegreeOfFreedom>(m,·"BRepMesh_DegreeOfFreedom",R"#()#")
96 ········.value("BRepMesh_Free",BRepMesh_DegreeOfFreedom::BRepMesh_Free)101 ········.value("BRepMesh_Free",BRepMesh_DegreeOfFreedom::BRepMesh_Free)
97 ········.value("BRepMesh_InVolume",BRepMesh_DegreeOfFreedom::BRepMesh_InVolume)102 ········.value("BRepMesh_InVolume",BRepMesh_DegreeOfFreedom::BRepMesh_InVolume)
98 ········.value("BRepMesh_OnSurface",BRepMesh_DegreeOfFreedom::BRepMesh_OnSurface)103 ········.value("BRepMesh_OnSurface",BRepMesh_DegreeOfFreedom::BRepMesh_OnSurface)
99 ········.value("BRepMesh_OnCurve",BRepMesh_DegreeOfFreedom::BRepMesh_OnCurve)104 ········.value("BRepMesh_OnCurve",BRepMesh_DegreeOfFreedom::BRepMesh_OnCurve)
100 ········.value("BRepMesh_Fixed",BRepMesh_DegreeOfFreedom::BRepMesh_Fixed)105 ········.value("BRepMesh_Fixed",BRepMesh_DegreeOfFreedom::BRepMesh_Fixed)
101 ········.value("BRepMesh_Frontier",BRepMesh_DegreeOfFreedom::BRepMesh_Frontier)106 ········.value("BRepMesh_Frontier",BRepMesh_DegreeOfFreedom::BRepMesh_Frontier)
102 ········.value("BRepMesh_Deleted",BRepMesh_DegreeOfFreedom::BRepMesh_Deleted).export_values();107 ········.value("BRepMesh_Deleted",BRepMesh_DegreeOfFreedom::BRepMesh_Deleted).export_values();
103 ····py::enum_<BRepMesh_FactoryError>(m,·"BRepMesh_FactoryError",R"#()#") 
104 ········.value("BRepMesh_FE_NOERROR",BRepMesh_FactoryError::BRepMesh_FE_NOERROR) 
105 ········.value("BRepMesh_FE_LIBRARYNOTFOUND",BRepMesh_FactoryError::BRepMesh_FE_LIBRARYNOTFOUND) 
106 ········.value("BRepMesh_FE_FUNCTIONNOTFOUND",BRepMesh_FactoryError::BRepMesh_FE_FUNCTIONNOTFOUND) 
107 ········.value("BRepMesh_FE_CANNOTCREATEALGO",BRepMesh_FactoryError::BRepMesh_FE_CANNOTCREATEALGO).export_values(); 
  
108 //Python·trampoline·classes108 //Python·trampoline·classes
109 ····class·Py_BRepMesh_DiscretRoot·:·public·BRepMesh_DiscretRoot{109 ····class·Py_BRepMesh_DiscretRoot·:·public·BRepMesh_DiscretRoot{
110 ····public:110 ····public:
111 ········using·BRepMesh_DiscretRoot::BRepMesh_DiscretRoot;111 ········using·BRepMesh_DiscretRoot::BRepMesh_DiscretRoot;
  
  
⊟
3.34 KB
./usr/share/libocp/OCP/BRepOffset_pre.cpp
Ordering differences only
    
Offset 102, 23 lines modifiedOffset 102, 23 lines modified
102 ········.value("BRepOffset_NullOffset",BRepOffset_Error::BRepOffset_NullOffset)102 ········.value("BRepOffset_NullOffset",BRepOffset_Error::BRepOffset_NullOffset)
103 ········.value("BRepOffset_NotConnectedShell",BRepOffset_Error::BRepOffset_NotConnectedShell)103 ········.value("BRepOffset_NotConnectedShell",BRepOffset_Error::BRepOffset_NotConnectedShell)
104 ········.value("BRepOffset_CannotTrimEdges",BRepOffset_Error::BRepOffset_CannotTrimEdges)104 ········.value("BRepOffset_CannotTrimEdges",BRepOffset_Error::BRepOffset_CannotTrimEdges)
105 ········.value("BRepOffset_CannotFuseVertices",BRepOffset_Error::BRepOffset_CannotFuseVertices)105 ········.value("BRepOffset_CannotFuseVertices",BRepOffset_Error::BRepOffset_CannotFuseVertices)
106 ········.value("BRepOffset_CannotExtentEdge",BRepOffset_Error::BRepOffset_CannotExtentEdge)106 ········.value("BRepOffset_CannotExtentEdge",BRepOffset_Error::BRepOffset_CannotExtentEdge)
107 ········.value("BRepOffset_UserBreak",BRepOffset_Error::BRepOffset_UserBreak)107 ········.value("BRepOffset_UserBreak",BRepOffset_Error::BRepOffset_UserBreak)
108 ········.value("BRepOffset_MixedConnectivity",BRepOffset_Error::BRepOffset_MixedConnectivity).export_values();108 ········.value("BRepOffset_MixedConnectivity",BRepOffset_Error::BRepOffset_MixedConnectivity).export_values();
109 ····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.)#") 
110 ········.value("BRepOffset_Skin",BRepOffset_Mode::BRepOffset_Skin) 
111 ········.value("BRepOffset_Pipe",BRepOffset_Mode::BRepOffset_Pipe) 
112 ········.value("BRepOffset_RectoVerso",BRepOffset_Mode::BRepOffset_RectoVerso).export_values(); 
113 ····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)#")109 ····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)#")
114 ········.value("BRepOffset_Good",BRepOffset_Status::BRepOffset_Good)110 ········.value("BRepOffset_Good",BRepOffset_Status::BRepOffset_Good)
115 ········.value("BRepOffset_Reversed",BRepOffset_Status::BRepOffset_Reversed)111 ········.value("BRepOffset_Reversed",BRepOffset_Status::BRepOffset_Reversed)
116 ········.value("BRepOffset_Degenerated",BRepOffset_Status::BRepOffset_Degenerated)112 ········.value("BRepOffset_Degenerated",BRepOffset_Status::BRepOffset_Degenerated)
117 ········.value("BRepOffset_Unknown",BRepOffset_Status::BRepOffset_Unknown).export_values();113 ········.value("BRepOffset_Unknown",BRepOffset_Status::BRepOffset_Unknown).export_values();
 114 ····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.)#")
 115 ········.value("BRepOffset_Skin",BRepOffset_Mode::BRepOffset_Skin)
 116 ········.value("BRepOffset_Pipe",BRepOffset_Mode::BRepOffset_Pipe)
 117 ········.value("BRepOffset_RectoVerso",BRepOffset_Mode::BRepOffset_RectoVerso).export_values();
118 ····py::enum_<BRepOffsetSimple_Status>(m,·"BRepOffsetSimple_Status",R"#()#")118 ····py::enum_<BRepOffsetSimple_Status>(m,·"BRepOffsetSimple_Status",R"#()#")
119 ········.value("BRepOffsetSimple_OK",BRepOffsetSimple_Status::BRepOffsetSimple_OK)119 ········.value("BRepOffsetSimple_OK",BRepOffsetSimple_Status::BRepOffsetSimple_OK)
120 ········.value("BRepOffsetSimple_NullInputShape",BRepOffsetSimple_Status::BRepOffsetSimple_NullInputShape)120 ········.value("BRepOffsetSimple_NullInputShape",BRepOffsetSimple_Status::BRepOffsetSimple_NullInputShape)
121 ········.value("BRepOffsetSimple_ErrorOffsetComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorOffsetComputation)121 ········.value("BRepOffsetSimple_ErrorOffsetComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorOffsetComputation)
122 ········.value("BRepOffsetSimple_ErrorWallFaceComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorWallFaceComputation)122 ········.value("BRepOffsetSimple_ErrorWallFaceComputation",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorWallFaceComputation)
123 ········.value("BRepOffsetSimple_ErrorInvalidNbShells",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorInvalidNbShells)123 ········.value("BRepOffsetSimple_ErrorInvalidNbShells",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorInvalidNbShells)
124 ········.value("BRepOffsetSimple_ErrorNonClosedShell",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorNonClosedShell).export_values();124 ········.value("BRepOffsetSimple_ErrorNonClosedShell",BRepOffsetSimple_Status::BRepOffsetSimple_ErrorNonClosedShell).export_values();
⊟
1.83 KB
./usr/share/libocp/OCP/BSplCLib_pre.cpp
Ordering differences only
    
Offset 37, 21 lines modifiedOffset 37, 21 lines modified
37 py::module·m·=·main_module.def_submodule("BSplCLib",·R"#()#");37 py::module·m·=·main_module.def_submodule("BSplCLib",·R"#()#");
  
38 //·add·namespaces·as·submodules38 //·add·namespaces·as·submodules
  
39 //·user-defined·inclusion·per·module·in·the·body39 //·user-defined·inclusion·per·module·in·the·body
  
40 //·enums40 //·enums
 41 ····py::enum_<BSplCLib_KnotDistribution>(m,·"BSplCLib_KnotDistribution",R"#(This·enumeration·describes·the·repartition·of·the·knots·sequence.·If·all·the·knots·differ·by·the·same·positive·constant·from·the·preceding·knot·the·"KnotDistribution"·is·<Uniform>·else·it·is·<NonUniform>)#")
 42 ········.value("BSplCLib_NonUniform",BSplCLib_KnotDistribution::BSplCLib_NonUniform)
 43 ········.value("BSplCLib_Uniform",BSplCLib_KnotDistribution::BSplCLib_Uniform).export_values();
41 ····py::enum_<BSplCLib_MultDistribution>(m,·"BSplCLib_MultDistribution",R"#(This·enumeration·describes·the·form·of·the·sequence·of·mutiplicities.·MultDistribution·is·:)#")44 ····py::enum_<BSplCLib_MultDistribution>(m,·"BSplCLib_MultDistribution",R"#(This·enumeration·describes·the·form·of·the·sequence·of·mutiplicities.·MultDistribution·is·:)#")
42 ········.value("BSplCLib_NonConstant",BSplCLib_MultDistribution::BSplCLib_NonConstant)45 ········.value("BSplCLib_NonConstant",BSplCLib_MultDistribution::BSplCLib_NonConstant)
43 ········.value("BSplCLib_Constant",BSplCLib_MultDistribution::BSplCLib_Constant)46 ········.value("BSplCLib_Constant",BSplCLib_MultDistribution::BSplCLib_Constant)
44 ········.value("BSplCLib_QuasiConstant",BSplCLib_MultDistribution::BSplCLib_QuasiConstant).export_values();47 ········.value("BSplCLib_QuasiConstant",BSplCLib_MultDistribution::BSplCLib_QuasiConstant).export_values();
45 ····py::enum_<BSplCLib_KnotDistribution>(m,·"BSplCLib_KnotDistribution",R"#(This·enumeration·describes·the·repartition·of·the·knots·sequence.·If·all·the·knots·differ·by·the·same·positive·constant·from·the·preceding·knot·the·"KnotDistribution"·is·<Uniform>·else·it·is·<NonUniform>)#") 
46 ········.value("BSplCLib_NonUniform",BSplCLib_KnotDistribution::BSplCLib_NonUniform) 
47 ········.value("BSplCLib_Uniform",BSplCLib_KnotDistribution::BSplCLib_Uniform).export_values(); 
  
48 //Python·trampoline·classes48 //Python·trampoline·classes
49 ····class·Py_BSplCLib_EvaluatorFunction·:·public·BSplCLib_EvaluatorFunction{49 ····class·Py_BSplCLib_EvaluatorFunction·:·public·BSplCLib_EvaluatorFunction{
50 ····public:50 ····public:
51 ········using·BSplCLib_EvaluatorFunction::BSplCLib_EvaluatorFunction;51 ········using·BSplCLib_EvaluatorFunction::BSplCLib_EvaluatorFunction;
  
  
⊟
105 KB
./usr/share/libocp/OCP/BVH_tmpl.hxx
Ordering differences only
    
Offset 47, 199 lines modifiedOffset 47, 197 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_LinearBuilder(py::object·&m,·const·char·*name){51 void·preregister_template_BVH_QueueBuilder(py::object·&m,·const·char·*name){
52 ····py::class_<BVH_LinearBuilder<T,N>·,·shared_ptr<BVH_LinearBuilder<T,N>>·>(m,name,R"#(Performs·fast·BVH·construction·using·LBVH·building·approach.·Algorithm·uses·spatial·Morton·codes·to·reduce·the·BVH·construction·problem·to·a·sorting·problem·(radix·sort·--·O(N)·complexity[·...·truncated·by·diffoscope;·len:·202,·SHA:·bf0b38433a1c867207909535645d918f85395a8276e542c6970fd2fcc4497dca·...·].)#");52 ····py::class_<BVH_QueueBuilder<T,N>·,·shared_ptr<BVH_QueueBuilder<T,N>>·>(m,name,R"#(Abstract·BVH·builder·based·on·the·concept·of·work·queue.·Queue·based·BVH·builders·support·parallelization·with·a·fixed·number·of·threads·(maximum·efficiency·is·achieved·by·setting·the·numbe[·...·truncated·by·diffoscope;·len:·260,·SHA:·7c9461f700f31be4bb16219a50593c49308a9807f3c94aef5f50f4da1ad26bfc·...·].)#");
53 }53 }
  
54 template·<typename·T,int·N>54 template·<typename·T,int·N>
55 void·register_template_BVH_LinearBuilder(py::object·&m,·const·char·*name){55 void·register_template_BVH_QueueBuilder(py::object·&m,·const·char·*name){
56 ····static_cast<py::class_<BVH_LinearBuilder<T,N>·,·shared_ptr<BVH_LinearBuilder<T,N>>·>>(m.attr(name))56 ····static_cast<py::class_<BVH_QueueBuilder<T,N>·,·shared_ptr<BVH_QueueBuilder<T,N>>·>>(m.attr(name))
57 ········.def(py::init<··const·Standard_Integer,·const·Standard_Integer·>()·,py::arg("theLeafNodeSize")=static_cast<·const·Standard_Integer>(BVH_Constants_LeafNodeSizeDefault),·py::arg("theMaxTreeDepth")=static_cast<·const·Standard_Integer>(BVH_Constants_MaxTreeDepth)·)57 ········.def(py::init<··const·Standard_Integer,·const·Standard_Integer,·const·Standard_Integer·>()·,py::arg("theLeafNodeSize"),·py::arg("theMaxTreeDepth"),·py::arg("theNumOfThreads")=static_cast<·const·Standard_Integer>(1)·)
58 ········.def("Build",58 ········.def("Build",
59 ·············(void·(BVH_LinearBuilder<T,N>::*)(·BVH_Set<T,·N>·*·,··BVH_Tree<T,·N>·*·,···const·BVH_Box<T,·N>·&··)·const)·&BVH_LinearBuilder<T,N>::Build,59 ·············(void·(BVH_QueueBuilder<T,N>::*)(·BVH_Set<T,·N>·*·,··BVH_Tree<T,·N>·*·,···const·BVH_Box<T,·N>·&··)·const)·&BVH_QueueBuilder<T,N>::Build,
60 ·············R"#(Builds·BVH.)#"·,py::arg("theSet"),·py::arg("theBVH"),·py::arg("theBox"))60 ·············R"#(Builds·BVH·using·specific·algorithm.)#"·,py::arg("theSet"),·py::arg("theBVH"),·py::arg("theBox"))
61 ····;61 ····;
62 };62 };
  
63 template·<typename·T,int·N>63 template·<typename·T,int·N>
64 void·preregister_template_BoundData(py::object·&m,·const·char·*name){64 void·preregister_template_BVH_Transform(py::object·&m,·const·char·*name){
65 ····py::class_<BoundData<T,N>·,·shared_ptr<BoundData<T,N>>·>(m,name,R"#()#");65 ····py::class_<BVH_Transform<T,N>·,·opencascade::handle<BVH_Transform<T,N>>·,·BVH_Properties·>(m,name,R"#(Stores·transform·properties·of·geometric·object.)#");
66 }66 }
  
67 template·<typename·T,int·N>67 template·<typename·T,int·N>
68 void·register_template_BoundData(py::object·&m,·const·char·*name){68 void·register_template_BVH_Transform(py::object·&m,·const·char·*name){
69 ····static_cast<py::class_<BoundData<T,N>·,·shared_ptr<BoundData<T,N>>·>>(m.attr(name))69 ····static_cast<py::class_<BVH_Transform<T,N>·,·opencascade::handle<BVH_Transform<T,N>>·,·BVH_Properties·>>(m.attr(name))
 70 ········.def(py::init<··>()··)
 71 ········.def(py::init<··const·typename·BVH_Transform<T,·N>::BVH_MatNt·&·>()·,py::arg("theTransform")·)
 72 ········.def("Transform",
 73 ·············(·const·typename·BVH_Transform<T,·N>::BVH_MatNt·&·(BVH_Transform<T,N>::*)()·const)·&BVH_Transform<T,N>::Transform,
 74 ·············R"#(Returns·transformation·matrix.)#"·)
 75 ········.def("SetTransform",
 76 ·············(void·(BVH_Transform<T,N>::*)(··const·typename·BVH_Transform<T,·N>::BVH_MatNt·&··)·)·&BVH_Transform<T,N>::SetTransform,
 77 ·············R"#(Sets·new·transformation·matrix.)#"·,py::arg("theTransform"))
 78 ········.def("Inversed",
 79 ·············(·const·typename·BVH_Transform<T,·N>::BVH_MatNt·&·(BVH_Transform<T,N>::*)()·const)·&BVH_Transform<T,N>::Inversed,
 80 ·············R"#(Returns·inversed·transformation·matrix.)#"·)
 81 ········.def("Apply",
 82 ·············(BVH_Box<T,·N>·(BVH_Transform<T,N>::*)(··const·BVH_Box<T,·N>·&··)·const)·&BVH_Transform<T,N>::Apply,
 83 ·············R"#(Applies·transformation·matrix·to·bounding·box.)#"·,py::arg("theBox"))
70 ····;84 ····;
71 };85 };
  
72 template·<typename·T,int·N>86 template·<typename·T,int·N>
73 void·preregister_template_UpdateBoundTask(py::object·&m,·const·char·*name){87 void·preregister_template_MatrixOp(py::object·&m,·const·char·*name){
74 ····py::class_<UpdateBoundTask<T,N>·,·shared_ptr<UpdateBoundTask<T,N>>·>(m,name,R"#(Task·for·parallel·bounds·updating.)#");88 ····py::class_<MatrixOp<T,N>·,·shared_ptr<MatrixOp<T,N>>·>(m,name,R"#()#");
75 }89 }
  
76 template·<typename·T,int·N>90 template·<typename·T,int·N>
77 void·register_template_UpdateBoundTask(py::object·&m,·const·char·*name){91 void·register_template_MatrixOp(py::object·&m,·const·char·*name){
78 ····static_cast<py::class_<UpdateBoundTask<T,N>·,·shared_ptr<UpdateBoundTask<T,N>>·>>(m.attr(name))92 ····static_cast<py::class_<MatrixOp<T,N>·,·shared_ptr<MatrixOp<T,N>>·>>(m.attr(name))
79 ········.def(py::init<··const·Standard_Boolean·>()·,py::arg("isParallel")·) 
80 ····;93 ····;
81 };94 };
  
82 template·<typename·T,int·N>95 template·<typename·T,int·N>
83 void·preregister_template_BVH_BaseBox(py::object·&m,·const·char·*name){96 void·preregister_template_UnitVector(py::object·&m,·const·char·*name){
84 ····py::class_<BVH_BaseBox<T,N>·,·shared_ptr<BVH_BaseBox<T,N>>·>(m,name,R"#(Base·class·for·BVH_Box·(CRTP·idiom·is·used).)#");97 ····py::class_<UnitVector<T,N>·,·shared_ptr<UnitVector<T,N>>·>(m,name,R"#()#");
85 }98 }
  
86 template·<typename·T,int·N>99 template·<typename·T,int·N>
87 void·register_template_BVH_BaseBox(py::object·&m,·const·char·*name){100 void·register_template_UnitVector(py::object·&m,·const·char·*name){
88 ····static_cast<py::class_<BVH_BaseBox<T,N>·,·shared_ptr<BVH_BaseBox<T,N>>·>>(m.attr(name))101 ····static_cast<py::class_<UnitVector<T,N>·,·shared_ptr<UnitVector<T,N>>·>>(m.attr(name))
89 ····;102 ····;
90 };103 };
  
91 template·<typename·T,int·N>104 template·<typename·MetricType>
92 void·preregister_template_BVH_Box(py::object·&m,·const·char·*name){105 void·preregister_template_BVH_BaseTraverse(py::object·&m,·const·char·*name){
93 ····py::class_<BVH_Box<T,N>·,·shared_ptr<BVH_Box<T,N>>·>(m,name,R"#(Defines·axis·aligned·bounding·box·(AABB)·based·on·BVH·vectors.)#");106 ····py::class_<BVH_BaseTraverse<MetricType>·,·shared_ptr_nodelete<BVH_BaseTraverse<MetricType>>·>(m,name,R"#(Abstract·class·implementing·the·base·Traverse·interface·required·for·selection·of·the·elements·from·BVH·tree.)#");
94 }107 }
  
95 template·<typename·T,int·N>108 template·<typename·MetricType>
96 void·register_template_BVH_Box(py::object·&m,·const·char·*name){109 void·register_template_BVH_BaseTraverse(py::object·&m,·const·char·*name){
 110 ····static_cast<py::class_<BVH_BaseTraverse<MetricType>·,·shared_ptr_nodelete<BVH_BaseTraverse<MetricType>>·>>(m.attr(name))
 111 ········.def("IsMetricBetter",
 112 ·············(Standard_Boolean·(BVH_BaseTraverse<MetricType>::*)(··const·MetricType·&·,···const·MetricType·&··)·const)·&BVH_BaseTraverse<MetricType>::IsMetricBetter,
 113 ·············R"#(Compares·the·two·metrics·and·chooses·the·best·one.·Returns·true·if·the·first·metric·is·better·than·the·second,·false·otherwise.)#"·,py::arg("arg"),·py::arg("arg"))
 114 ········.def("RejectMetric",
 115 ·············(Standard_Boolean·(BVH_BaseTraverse<MetricType>::*)(··const·MetricType·&··)·const)·&BVH_BaseTraverse<MetricType>::RejectMetric,
 116 ·············R"#(Rejects·the·node·by·the·metric)#"·,py::arg("arg"))
97 ····static_cast<py::class_<BVH_Box<T,N>·,·shared_ptr<BVH_Box<T,N>>·>>(m.attr(name)) 
98 ········.def(py::init<··>()··) 
99 ········.def(py::init<··const·typename·BVH_Box<T,·N>::BVH_VecNt·&·>()·,py::arg("thePoint")·) 
100 ········.def(py::init<··const·typename·BVH_Box<T,·N>::BVH_VecNt·&,·const·typename·BVH_Box<T,·N>::BVH_VecNt·&·>()·,py::arg("theMinPoint"),·py::arg("theMaxPoint")·) 
101 ········.def("Clear", 
102 ·············(void·(BVH_Box<T,N>::*)()·)·&BVH_Box<T,N>::Clear, 
103 ·············R"#(Clears·bounding·box.)#"·) 
104 ········.def("IsValid", 
105 ·············(Standard_Boolean·(BVH_Box<T,N>::*)()·const)·&BVH_Box<T,N>::IsValid, 
106 ·············R"#(Is·bounding·box·valid?)#"·) 
107 ········.def("Add", 
108 ·············(void·(BVH_Box<T,N>::*)(··const·typename·BVH_Box<T,·N>::BVH_VecNt·&··)·)·&BVH_Box<T,N>::Add, 
109 ·············R"#(Appends·new·point·to·the·bounding·box.)#"·,py::arg("thePoint")) 
110 ········.def("Combine", 
111 ·············(void·(BVH_Box<T,N>::*)(··const·BVH_Box<T,·N>·&··)·)·&BVH_Box<T,N>::Combine, 
112 ·············R"#(Combines·bounding·box·with·another·one.)#"·,py::arg("theBox")) 
113 ········.def("CornerMin", 
114 ·············(·const·typename·BVH_Box<T,·N>::BVH_VecNt·&·(BVH_Box<T,N>::*)()·const)·&BVH_Box<T,N>::CornerMin, 
115 ·············R"#(Returns·minimum·point·of·bounding·box.)#"·) 
116 ········.def("CornerMax", 
117 ·············(·const·typename·BVH_Box<T,·N>::BVH_VecNt·&·(BVH_Box<T,N>::*)()·const)·&BVH_Box<T,N>::CornerMax, 
118 ·············R"#(Returns·maximum·point·of·bounding·box.)#"·) 
119 ········.def("CornerMin", 
120 ·············(typename·BVH_Box<T,·N>::BVH_VecNt·&·(BVH_Box<T,N>::*)()·)·&BVH_Box<T,N>::CornerMin, 
121 ·············R"#(Returns·minimum·point·of·bounding·box.)#"·) 
122 ········.def("CornerMax", 
123 ·············(typename·BVH_Box<T,·N>::BVH_VecNt·&·(BVH_Box<T,N>::*)()·)·&BVH_Box<T,N>::CornerMax, 
124 ·············R"#(Returns·maximum·point·of·bounding·box.)#"·) 
125 ········.def("Area", 
126 ·············(T·(BVH_Box<T,N>::*)()·const)·&BVH_Box<T,N>::Area, 
127 ·············R"#(Returns·surface·area·of·bounding·box.·If·the·box·is·degenerated·into·line,·returns·the·perimeter·instead.)#"·) 
128 ········.def("Size",117 ········.def("Stop",
 118 ·············(Standard_Boolean·(BVH_BaseTraverse<MetricType>::*)()·const)·&BVH_BaseTraverse<MetricType>::Stop,
 119 ·············R"#(Returns·the·flag·controlling·the·tree·descend.·Returns·true·if·the·tree·descend·should·be·stopped.)#"·)
129 ·············(typename·BVH_Box<T,·N>::BVH_VecNt·(BVH_Box<T,N>::*)()·const)·&BVH_Box<T,N>::Size, 
130 ·············R"#(Returns·diagonal·of·bounding·box.)#"·) 
131 ········.def("Center", 
132 ·············(typename·BVH_Box<T,·N>::BVH_VecNt·(BVH_Box<T,N>::*)()·const)·&BVH_Box<T,N>::Center, 
133 ·············R"#(Returns·center·of·bounding·box.)#"·) 
134 ········.def("Center", 
135 ·············(T·(BVH_Box<T,N>::*)(··const·Standard_Integer··)·const)·&BVH_Box<T,N>::Center, 
136 ·············R"#(Returns·center·of·bounding·box·along·the·given·axis.)#"·,py::arg("theAxis")) 
137 ········.def("DumpJson", 
138 ·············(void·(BVH_Box<T,N>::*)(·Standard_OStream·&·,··Standard_Integer··)·const)·&BVH_Box<T,N>::DumpJson, 
Max diff block lines reached; 94389/107072 bytes (88.15%) of diff not shown.
⊟
3.98 KB
./usr/share/libocp/OCP/BinTools_pre.cpp
Ordering differences only
    
Offset 63, 22 lines modifiedOffset 63, 14 lines modified
63 py::module·m·=·main_module.def_submodule("BinTools",·R"#()#");63 py::module·m·=·main_module.def_submodule("BinTools",·R"#()#");
  
64 //·add·namespaces·as·submodules64 //·add·namespaces·as·submodules
  
65 //·user-defined·inclusion·per·module·in·the·body65 //·user-defined·inclusion·per·module·in·the·body
  
66 //·enums66 //·enums
67 ····py::enum_<BinTools_FormatVersion>(m,·"BinTools_FormatVersion",R"#(Defined·BinTools·format·version)#") 
68 ········.value("BinTools_FormatVersion_VERSION_1",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_1) 
69 ········.value("BinTools_FormatVersion_VERSION_2",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_2) 
70 ········.value("BinTools_FormatVersion_VERSION_3",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_3) 
71 ········.value("BinTools_FormatVersion_VERSION_4",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_4) 
72 ········.value("BinTools_FormatVersion_CURRENT",BinTools_FormatVersion::BinTools_FormatVersion_CURRENT).export_values(); 
73 ····m.attr("BinTools_FormatVersion_LOWER")·=·py::cast(int(BinTools_FormatVersion_LOWER)); 
74 ····m.attr("BinTools_FormatVersion_UPPER")·=·py::cast(int(BinTools_FormatVersion_UPPER)); 
75 ····py::enum_<BinTools_ObjectType>(m,·"BinTools_ObjectType",R"#(Enumeration·defining·objects·identifiers·in·the·shape·read/write·format.)#")67 ····py::enum_<BinTools_ObjectType>(m,·"BinTools_ObjectType",R"#(Enumeration·defining·objects·identifiers·in·the·shape·read/write·format.)#")
76 ········.value("BinTools_ObjectType_Unknown",BinTools_ObjectType::BinTools_ObjectType_Unknown)68 ········.value("BinTools_ObjectType_Unknown",BinTools_ObjectType::BinTools_ObjectType_Unknown)
77 ········.value("BinTools_ObjectType_Reference8",BinTools_ObjectType::BinTools_ObjectType_Reference8)69 ········.value("BinTools_ObjectType_Reference8",BinTools_ObjectType::BinTools_ObjectType_Reference8)
78 ········.value("BinTools_ObjectType_Reference16",BinTools_ObjectType::BinTools_ObjectType_Reference16)70 ········.value("BinTools_ObjectType_Reference16",BinTools_ObjectType::BinTools_ObjectType_Reference16)
79 ········.value("BinTools_ObjectType_Reference32",BinTools_ObjectType::BinTools_ObjectType_Reference32)71 ········.value("BinTools_ObjectType_Reference32",BinTools_ObjectType::BinTools_ObjectType_Reference32)
80 ········.value("BinTools_ObjectType_Reference64",BinTools_ObjectType::BinTools_ObjectType_Reference64)72 ········.value("BinTools_ObjectType_Reference64",BinTools_ObjectType::BinTools_ObjectType_Reference64)
81 ········.value("BinTools_ObjectType_Location",BinTools_ObjectType::BinTools_ObjectType_Location)73 ········.value("BinTools_ObjectType_Location",BinTools_ObjectType::BinTools_ObjectType_Location)
Offset 95, 14 lines modifiedOffset 87, 22 lines modified
95 ········.value("BinTools_ObjectType_EmptyPolygon3d",BinTools_ObjectType::BinTools_ObjectType_EmptyPolygon3d)87 ········.value("BinTools_ObjectType_EmptyPolygon3d",BinTools_ObjectType::BinTools_ObjectType_EmptyPolygon3d)
96 ········.value("BinTools_ObjectType_PolygonOnTriangulation",BinTools_ObjectType::BinTools_ObjectType_PolygonOnTriangulation)88 ········.value("BinTools_ObjectType_PolygonOnTriangulation",BinTools_ObjectType::BinTools_ObjectType_PolygonOnTriangulation)
97 ········.value("BinTools_ObjectType_EmptyPolygonOnTriangulation",BinTools_ObjectType::BinTools_ObjectType_EmptyPolygonOnTriangulation)89 ········.value("BinTools_ObjectType_EmptyPolygonOnTriangulation",BinTools_ObjectType::BinTools_ObjectType_EmptyPolygonOnTriangulation)
98 ········.value("BinTools_ObjectType_Triangulation",BinTools_ObjectType::BinTools_ObjectType_Triangulation)90 ········.value("BinTools_ObjectType_Triangulation",BinTools_ObjectType::BinTools_ObjectType_Triangulation)
99 ········.value("BinTools_ObjectType_EmptyTriangulation",BinTools_ObjectType::BinTools_ObjectType_EmptyTriangulation)91 ········.value("BinTools_ObjectType_EmptyTriangulation",BinTools_ObjectType::BinTools_ObjectType_EmptyTriangulation)
100 ········.value("BinTools_ObjectType_EmptyShape",BinTools_ObjectType::BinTools_ObjectType_EmptyShape)92 ········.value("BinTools_ObjectType_EmptyShape",BinTools_ObjectType::BinTools_ObjectType_EmptyShape)
101 ········.value("BinTools_ObjectType_EndShape",BinTools_ObjectType::BinTools_ObjectType_EndShape).export_values();93 ········.value("BinTools_ObjectType_EndShape",BinTools_ObjectType::BinTools_ObjectType_EndShape).export_values();
 94 ····py::enum_<BinTools_FormatVersion>(m,·"BinTools_FormatVersion",R"#(Defined·BinTools·format·version)#")
 95 ········.value("BinTools_FormatVersion_VERSION_1",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_1)
 96 ········.value("BinTools_FormatVersion_VERSION_2",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_2)
 97 ········.value("BinTools_FormatVersion_VERSION_3",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_3)
 98 ········.value("BinTools_FormatVersion_VERSION_4",BinTools_FormatVersion::BinTools_FormatVersion_VERSION_4)
 99 ········.value("BinTools_FormatVersion_CURRENT",BinTools_FormatVersion::BinTools_FormatVersion_CURRENT).export_values();
 100 ····m.attr("BinTools_FormatVersion_LOWER")·=·py::cast(int(BinTools_FormatVersion_LOWER));
 101 ····m.attr("BinTools_FormatVersion_UPPER")·=·py::cast(int(BinTools_FormatVersion_UPPER));
  
102 //Python·trampoline·classes102 //Python·trampoline·classes
  
103 //·pre-register·typdefs+classes·(topologically·sorted)103 //·pre-register·typdefs+classes·(topologically·sorted)
104 ····py::class_<BinTools·,·shared_ptr<BinTools>··>(m,"BinTools",R"#(Tool·to·keep·shapes·in·binary·format)#");104 ····py::class_<BinTools·,·shared_ptr<BinTools>··>(m,"BinTools",R"#(Tool·to·keep·shapes·in·binary·format)#");
105 ····py::class_<BinTools_Curve2dSet·,·shared_ptr<BinTools_Curve2dSet>··>(m,"BinTools_Curve2dSet",R"#(Stores·a·set·of·Curves·from·Geom2d·in·binary·format)#");105 ····py::class_<BinTools_Curve2dSet·,·shared_ptr<BinTools_Curve2dSet>··>(m,"BinTools_Curve2dSet",R"#(Stores·a·set·of·Curves·from·Geom2d·in·binary·format)#");
106 ····py::class_<BinTools_CurveSet·,·shared_ptr<BinTools_CurveSet>··>(m,"BinTools_CurveSet",R"#(Stores·a·set·of·Curves·from·Geom·in·binary·format.)#");106 ····py::class_<BinTools_CurveSet·,·shared_ptr<BinTools_CurveSet>··>(m,"BinTools_CurveSet",R"#(Stores·a·set·of·Curves·from·Geom·in·binary·format.)#");
⊟
1.75 KB
./usr/share/libocp/OCP/Blend_pre.cpp
Ordering differences only
    
Offset 52, 28 lines modifiedOffset 52, 28 lines modified
52 py::module·m·=·main_module.def_submodule("Blend",·R"#()#");52 py::module·m·=·main_module.def_submodule("Blend",·R"#()#");
  
53 //·add·namespaces·as·submodules53 //·add·namespaces·as·submodules
  
54 //·user-defined·inclusion·per·module·in·the·body54 //·user-defined·inclusion·per·module·in·the·body
  
55 //·enums55 //·enums
56 ····py::enum_<Blend_DecrochStatus>(m,·"Blend_DecrochStatus",R"#()#") 
57 ········.value("Blend_NoDecroch",Blend_DecrochStatus::Blend_NoDecroch) 
58 ········.value("Blend_DecrochRst1",Blend_DecrochStatus::Blend_DecrochRst1) 
59 ········.value("Blend_DecrochRst2",Blend_DecrochStatus::Blend_DecrochRst2) 
60 ········.value("Blend_DecrochBoth",Blend_DecrochStatus::Blend_DecrochBoth).export_values(); 
61 ····py::enum_<Blend_Status>(m,·"Blend_Status",R"#()#")56 ····py::enum_<Blend_Status>(m,·"Blend_Status",R"#()#")
62 ········.value("Blend_StepTooLarge",Blend_Status::Blend_StepTooLarge)57 ········.value("Blend_StepTooLarge",Blend_Status::Blend_StepTooLarge)
63 ········.value("Blend_StepTooSmall",Blend_Status::Blend_StepTooSmall)58 ········.value("Blend_StepTooSmall",Blend_Status::Blend_StepTooSmall)
64 ········.value("Blend_Backward",Blend_Status::Blend_Backward)59 ········.value("Blend_Backward",Blend_Status::Blend_Backward)
65 ········.value("Blend_SamePoints",Blend_Status::Blend_SamePoints)60 ········.value("Blend_SamePoints",Blend_Status::Blend_SamePoints)
66 ········.value("Blend_OnRst1",Blend_Status::Blend_OnRst1)61 ········.value("Blend_OnRst1",Blend_Status::Blend_OnRst1)
67 ········.value("Blend_OnRst2",Blend_Status::Blend_OnRst2)62 ········.value("Blend_OnRst2",Blend_Status::Blend_OnRst2)
68 ········.value("Blend_OnRst12",Blend_Status::Blend_OnRst12)63 ········.value("Blend_OnRst12",Blend_Status::Blend_OnRst12)
69 ········.value("Blend_OK",Blend_Status::Blend_OK).export_values();64 ········.value("Blend_OK",Blend_Status::Blend_OK).export_values();
 65 ····py::enum_<Blend_DecrochStatus>(m,·"Blend_DecrochStatus",R"#()#")
 66 ········.value("Blend_NoDecroch",Blend_DecrochStatus::Blend_NoDecroch)
 67 ········.value("Blend_DecrochRst1",Blend_DecrochStatus::Blend_DecrochRst1)
 68 ········.value("Blend_DecrochRst2",Blend_DecrochStatus::Blend_DecrochRst2)
 69 ········.value("Blend_DecrochBoth",Blend_DecrochStatus::Blend_DecrochBoth).export_values();
  
70 //Python·trampoline·classes70 //Python·trampoline·classes
71 ····class·Py_Blend_AppFunction·:·public·Blend_AppFunction{71 ····class·Py_Blend_AppFunction·:·public·Blend_AppFunction{
72 ····public:72 ····public:
73 ········using·Blend_AppFunction::Blend_AppFunction;73 ········using·Blend_AppFunction::Blend_AppFunction;
  
  
⊟
2.01 KB
./usr/share/libocp/OCP/CDF_pre.cpp
Ordering differences only
    
Offset 67, 27 lines modifiedOffset 67, 27 lines modified
  
67 //·enums67 //·enums
68 ····py::enum_<CDF_SubComponentStatus>(m,·"CDF_SubComponentStatus",R"#()#")68 ····py::enum_<CDF_SubComponentStatus>(m,·"CDF_SubComponentStatus",R"#()#")
69 ········.value("CDF_SCS_Consistent",CDF_SubComponentStatus::CDF_SCS_Consistent)69 ········.value("CDF_SCS_Consistent",CDF_SubComponentStatus::CDF_SCS_Consistent)
70 ········.value("CDF_SCS_Unconsistent",CDF_SubComponentStatus::CDF_SCS_Unconsistent)70 ········.value("CDF_SCS_Unconsistent",CDF_SubComponentStatus::CDF_SCS_Unconsistent)
71 ········.value("CDF_SCS_Stored",CDF_SubComponentStatus::CDF_SCS_Stored)71 ········.value("CDF_SCS_Stored",CDF_SubComponentStatus::CDF_SCS_Stored)
72 ········.value("CDF_SCS_Modified",CDF_SubComponentStatus::CDF_SCS_Modified).export_values();72 ········.value("CDF_SCS_Modified",CDF_SubComponentStatus::CDF_SCS_Modified).export_values();
 73 ····py::enum_<CDF_TypeOfActivation>(m,·"CDF_TypeOfActivation",R"#()#")
 74 ········.value("CDF_TOA_New",CDF_TypeOfActivation::CDF_TOA_New)
 75 ········.value("CDF_TOA_Modified",CDF_TypeOfActivation::CDF_TOA_Modified)
 76 ········.value("CDF_TOA_Unchanged",CDF_TypeOfActivation::CDF_TOA_Unchanged).export_values();
73 ····py::enum_<CDF_StoreSetNameStatus>(m,·"CDF_StoreSetNameStatus",R"#()#")77 ····py::enum_<CDF_StoreSetNameStatus>(m,·"CDF_StoreSetNameStatus",R"#()#")
74 ········.value("CDF_SSNS_OK",CDF_StoreSetNameStatus::CDF_SSNS_OK)78 ········.value("CDF_SSNS_OK",CDF_StoreSetNameStatus::CDF_SSNS_OK)
75 ········.value("CDF_SSNS_ReplacingAnExistentDocument",CDF_StoreSetNameStatus::CDF_SSNS_ReplacingAnExistentDocument)79 ········.value("CDF_SSNS_ReplacingAnExistentDocument",CDF_StoreSetNameStatus::CDF_SSNS_ReplacingAnExistentDocument)
76 ········.value("CDF_SSNS_OpenDocument",CDF_StoreSetNameStatus::CDF_SSNS_OpenDocument).export_values();80 ········.value("CDF_SSNS_OpenDocument",CDF_StoreSetNameStatus::CDF_SSNS_OpenDocument).export_values();
77 ····py::enum_<CDF_TryStoreStatus>(m,·"CDF_TryStoreStatus",R"#()#")81 ····py::enum_<CDF_TryStoreStatus>(m,·"CDF_TryStoreStatus",R"#()#")
78 ········.value("CDF_TS_OK",CDF_TryStoreStatus::CDF_TS_OK)82 ········.value("CDF_TS_OK",CDF_TryStoreStatus::CDF_TS_OK)
79 ········.value("CDF_TS_NoCurrentDocument",CDF_TryStoreStatus::CDF_TS_NoCurrentDocument)83 ········.value("CDF_TS_NoCurrentDocument",CDF_TryStoreStatus::CDF_TS_NoCurrentDocument)
80 ········.value("CDF_TS_NoDriver",CDF_TryStoreStatus::CDF_TS_NoDriver)84 ········.value("CDF_TS_NoDriver",CDF_TryStoreStatus::CDF_TS_NoDriver)
81 ········.value("CDF_TS_NoSubComponentDriver",CDF_TryStoreStatus::CDF_TS_NoSubComponentDriver).export_values();85 ········.value("CDF_TS_NoSubComponentDriver",CDF_TryStoreStatus::CDF_TS_NoSubComponentDriver).export_values();
82 ····py::enum_<CDF_TypeOfActivation>(m,·"CDF_TypeOfActivation",R"#()#") 
83 ········.value("CDF_TOA_New",CDF_TypeOfActivation::CDF_TOA_New) 
84 ········.value("CDF_TOA_Modified",CDF_TypeOfActivation::CDF_TOA_Modified) 
85 ········.value("CDF_TOA_Unchanged",CDF_TypeOfActivation::CDF_TOA_Unchanged).export_values(); 
  
86 //Python·trampoline·classes86 //Python·trampoline·classes
87 ····class·Py_CDF_Application·:·public·CDF_Application{87 ····class·Py_CDF_Application·:·public·CDF_Application{
88 ····public:88 ····public:
89 ········using·CDF_Application::CDF_Application;89 ········using·CDF_Application::CDF_Application;
  
  
⊟
4.62 KB
./usr/share/libocp/OCP/ChFiDS_pre.cpp
Ordering differences only
    
Offset 85, 14 lines modifiedOffset 85, 26 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_ChamfMethod>(m,·"ChFiDS_ChamfMethod",R"#()#")
 98 ········.value("ChFiDS_Sym",ChFiDS_ChamfMethod::ChFiDS_Sym)
 99 ········.value("ChFiDS_TwoDist",ChFiDS_ChamfMethod::ChFiDS_TwoDist)
 100 ········.value("ChFiDS_DistAngle",ChFiDS_ChamfMethod::ChFiDS_DistAngle).export_values();
89 ····py::enum_<ChFiDS_ChamfMode>(m,·"ChFiDS_ChamfMode",R"#(this·enumeration·defines·several·modes·of·chamfer)#")101 ····py::enum_<ChFiDS_ChamfMode>(m,·"ChFiDS_ChamfMode",R"#(this·enumeration·defines·several·modes·of·chamfer)#")
90 ········.value("ChFiDS_ClassicChamfer",ChFiDS_ChamfMode::ChFiDS_ClassicChamfer)102 ········.value("ChFiDS_ClassicChamfer",ChFiDS_ChamfMode::ChFiDS_ClassicChamfer)
91 ········.value("ChFiDS_ConstThroatChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatChamfer)103 ········.value("ChFiDS_ConstThroatChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatChamfer)
92 ········.value("ChFiDS_ConstThroatWithPenetrationChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatWithPenetrationChamfer).export_values();104 ········.value("ChFiDS_ConstThroatWithPenetrationChamfer",ChFiDS_ChamfMode::ChFiDS_ConstThroatWithPenetrationChamfer).export_values();
93 ····py::enum_<ChFiDS_TypeOfConcavity>(m,·"ChFiDS_TypeOfConcavity",R"#()#")105 ····py::enum_<ChFiDS_TypeOfConcavity>(m,·"ChFiDS_TypeOfConcavity",R"#()#")
94 ········.value("ChFiDS_Concave",ChFiDS_TypeOfConcavity::ChFiDS_Concave)106 ········.value("ChFiDS_Concave",ChFiDS_TypeOfConcavity::ChFiDS_Concave)
95 ········.value("ChFiDS_Convex",ChFiDS_TypeOfConcavity::ChFiDS_Convex)107 ········.value("ChFiDS_Convex",ChFiDS_TypeOfConcavity::ChFiDS_Convex)
Offset 102, 26 lines modifiedOffset 114, 14 lines modified
102 ········.value("ChFiDS_Mixed",ChFiDS_TypeOfConcavity::ChFiDS_Mixed).export_values();114 ········.value("ChFiDS_Mixed",ChFiDS_TypeOfConcavity::ChFiDS_Mixed).export_values();
103 ····py::enum_<ChFiDS_ErrorStatus>(m,·"ChFiDS_ErrorStatus",R"#(---·Purpose·statuts·concernant·la·cause·de·l'erreur)#")115 ····py::enum_<ChFiDS_ErrorStatus>(m,·"ChFiDS_ErrorStatus",R"#(---·Purpose·statuts·concernant·la·cause·de·l'erreur)#")
104 ········.value("ChFiDS_Ok",ChFiDS_ErrorStatus::ChFiDS_Ok)116 ········.value("ChFiDS_Ok",ChFiDS_ErrorStatus::ChFiDS_Ok)
105 ········.value("ChFiDS_Error",ChFiDS_ErrorStatus::ChFiDS_Error)117 ········.value("ChFiDS_Error",ChFiDS_ErrorStatus::ChFiDS_Error)
106 ········.value("ChFiDS_WalkingFailure",ChFiDS_ErrorStatus::ChFiDS_WalkingFailure)118 ········.value("ChFiDS_WalkingFailure",ChFiDS_ErrorStatus::ChFiDS_WalkingFailure)
107 ········.value("ChFiDS_StartsolFailure",ChFiDS_ErrorStatus::ChFiDS_StartsolFailure)119 ········.value("ChFiDS_StartsolFailure",ChFiDS_ErrorStatus::ChFiDS_StartsolFailure)
108 ········.value("ChFiDS_TwistedSurface",ChFiDS_ErrorStatus::ChFiDS_TwistedSurface).export_values();120 ········.value("ChFiDS_TwistedSurface",ChFiDS_ErrorStatus::ChFiDS_TwistedSurface).export_values();
109 ····py::enum_<ChFiDS_ChamfMethod>(m,·"ChFiDS_ChamfMethod",R"#()#") 
110 ········.value("ChFiDS_Sym",ChFiDS_ChamfMethod::ChFiDS_Sym) 
111 ········.value("ChFiDS_TwoDist",ChFiDS_ChamfMethod::ChFiDS_TwoDist) 
112 ········.value("ChFiDS_DistAngle",ChFiDS_ChamfMethod::ChFiDS_DistAngle).export_values(); 
113 ····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.)#") 
114 ········.value("ChFiDS_OnSame",ChFiDS_State::ChFiDS_OnSame) 
115 ········.value("ChFiDS_OnDiff",ChFiDS_State::ChFiDS_OnDiff) 
116 ········.value("ChFiDS_AllSame",ChFiDS_State::ChFiDS_AllSame) 
117 ········.value("ChFiDS_BreakPoint",ChFiDS_State::ChFiDS_BreakPoint) 
118 ········.value("ChFiDS_FreeBoundary",ChFiDS_State::ChFiDS_FreeBoundary) 
119 ········.value("ChFiDS_Closed",ChFiDS_State::ChFiDS_Closed) 
120 ········.value("ChFiDS_Tangent",ChFiDS_State::ChFiDS_Tangent).export_values(); 
  
121 //Python·trampoline·classes121 //Python·trampoline·classes
  
122 //·pre-register·typdefs+classes·(topologically·sorted)122 //·pre-register·typdefs+classes·(topologically·sorted)
123 ····py::class_<ChFiDS_CircSection·,·shared_ptr<ChFiDS_CircSection>··>(m,"ChFiDS_CircSection",R"#(A·Section·of·fillet.)#");123 ····py::class_<ChFiDS_CircSection·,·shared_ptr<ChFiDS_CircSection>··>(m,"ChFiDS_CircSection",R"#(A·Section·of·fillet.)#");
124 ····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)#");124 ····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)#");
125 ····py::class_<ChFiDS_FaceInterference·,·shared_ptr<ChFiDS_FaceInterference>··>(m,"ChFiDS_FaceInterference",R"#(interference·face/fillet)#");125 ····py::class_<ChFiDS_FaceInterference·,·shared_ptr<ChFiDS_FaceInterference>··>(m,"ChFiDS_FaceInterference",R"#(interference·face/fillet)#");
⊟
1.83 KB
./usr/share/libocp/OCP/Contap_pre.cpp
Ordering differences only
    
Offset 85, 24 lines modifiedOffset 85, 24 lines modified
85 py::module·m·=·main_module.def_submodule("Contap",·R"#()#");85 py::module·m·=·main_module.def_submodule("Contap",·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_<Contap_TFunction>(m,·"Contap_TFunction",R"#()#") 
90 ········.value("Contap_ContourStd",Contap_TFunction::Contap_ContourStd) 
91 ········.value("Contap_ContourPrs",Contap_TFunction::Contap_ContourPrs) 
92 ········.value("Contap_DraftStd",Contap_TFunction::Contap_DraftStd) 
93 ········.value("Contap_DraftPrs",Contap_TFunction::Contap_DraftPrs).export_values(); 
94 ····py::enum_<Contap_IType>(m,·"Contap_IType",R"#()#")89 ····py::enum_<Contap_IType>(m,·"Contap_IType",R"#()#")
95 ········.value("Contap_Lin",Contap_IType::Contap_Lin)90 ········.value("Contap_Lin",Contap_IType::Contap_Lin)
96 ········.value("Contap_Circle",Contap_IType::Contap_Circle)91 ········.value("Contap_Circle",Contap_IType::Contap_Circle)
97 ········.value("Contap_Walking",Contap_IType::Contap_Walking)92 ········.value("Contap_Walking",Contap_IType::Contap_Walking)
98 ········.value("Contap_Restriction",Contap_IType::Contap_Restriction).export_values();93 ········.value("Contap_Restriction",Contap_IType::Contap_Restriction).export_values();
 94 ····py::enum_<Contap_TFunction>(m,·"Contap_TFunction",R"#()#")
 95 ········.value("Contap_ContourStd",Contap_TFunction::Contap_ContourStd)
 96 ········.value("Contap_ContourPrs",Contap_TFunction::Contap_ContourPrs)
 97 ········.value("Contap_DraftStd",Contap_TFunction::Contap_DraftStd)
 98 ········.value("Contap_DraftPrs",Contap_TFunction::Contap_DraftPrs).export_values();
  
99 //Python·trampoline·classes99 //Python·trampoline·classes
  
100 //·pre-register·typdefs+classes·(topologically·sorted)100 //·pre-register·typdefs+classes·(topologically·sorted)
101 ····py::class_<Contap_ContAna·,·shared_ptr<Contap_ContAna>··>(m,"Contap_ContAna",R"#(This·class·provides·the·computation·of·the·contours·for·quadric·surfaces.)#");101 ····py::class_<Contap_ContAna·,·shared_ptr<Contap_ContAna>··>(m,"Contap_ContAna",R"#(This·class·provides·the·computation·of·the·contours·for·quadric·surfaces.)#");
102 ····py::class_<Contap_Contour·,·shared_ptr<Contap_Contour>··>(m,"Contap_Contour",R"#()#");102 ····py::class_<Contap_Contour·,·shared_ptr<Contap_Contour>··>(m,"Contap_Contour",R"#()#");
103 ····py::class_<Contap_HContTool·,·shared_ptr<Contap_HContTool>··>(m,"Contap_HContTool",R"#(Tool·for·the·intersection·between·2·surfaces.·Regroupe·pour·l·instant·les·methodes·hors·Adaptor3d...)#");103 ····py::class_<Contap_HContTool·,·shared_ptr<Contap_HContTool>··>(m,"Contap_HContTool",R"#(Tool·for·the·intersection·between·2·surfaces.·Regroupe·pour·l·instant·les·methodes·hors·Adaptor3d...)#");
⊟
1.77 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_ExtAlgo>(m,·"Extrema_ExtAlgo",R"#()#")
 270 ········.value("Extrema_ExtAlgo_Grad",Extrema_ExtAlgo::Extrema_ExtAlgo_Grad)
 271 ········.value("Extrema_ExtAlgo_Tree",Extrema_ExtAlgo::Extrema_ExtAlgo_Tree).export_values();
269 ····py::enum_<Extrema_ElementType>(m,·"Extrema_ElementType",R"#()#")272 ····py::enum_<Extrema_ElementType>(m,·"Extrema_ElementType",R"#()#")
270 ········.value("Extrema_Node",Extrema_ElementType::Extrema_Node)273 ········.value("Extrema_Node",Extrema_ElementType::Extrema_Node)
271 ········.value("Extrema_UIsoEdge",Extrema_ElementType::Extrema_UIsoEdge)274 ········.value("Extrema_UIsoEdge",Extrema_ElementType::Extrema_UIsoEdge)
272 ········.value("Extrema_VIsoEdge",Extrema_ElementType::Extrema_VIsoEdge)275 ········.value("Extrema_VIsoEdge",Extrema_ElementType::Extrema_VIsoEdge)
273 ········.value("Extrema_Face",Extrema_ElementType::Extrema_Face).export_values();276 ········.value("Extrema_Face",Extrema_ElementType::Extrema_Face).export_values();
274 ····py::enum_<Extrema_ExtFlag>(m,·"Extrema_ExtFlag",R"#()#")277 ····py::enum_<Extrema_ExtFlag>(m,·"Extrema_ExtFlag",R"#()#")
275 ········.value("Extrema_ExtFlag_MIN",Extrema_ExtFlag::Extrema_ExtFlag_MIN)278 ········.value("Extrema_ExtFlag_MIN",Extrema_ExtFlag::Extrema_ExtFlag_MIN)
276 ········.value("Extrema_ExtFlag_MAX",Extrema_ExtFlag::Extrema_ExtFlag_MAX)279 ········.value("Extrema_ExtFlag_MAX",Extrema_ExtFlag::Extrema_ExtFlag_MAX)
277 ········.value("Extrema_ExtFlag_MINMAX",Extrema_ExtFlag::Extrema_ExtFlag_MINMAX).export_values();280 ········.value("Extrema_ExtFlag_MINMAX",Extrema_ExtFlag::Extrema_ExtFlag_MINMAX).export_values();
278 ····py::enum_<Extrema_ExtAlgo>(m,·"Extrema_ExtAlgo",R"#()#") 
279 ········.value("Extrema_ExtAlgo_Grad",Extrema_ExtAlgo::Extrema_ExtAlgo_Grad) 
280 ········.value("Extrema_ExtAlgo_Tree",Extrema_ExtAlgo::Extrema_ExtAlgo_Tree).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"#()#");
⊟
3.05 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_ErrorTypeStatus>(m,·"FilletSurf_ErrorTypeStatus",R"#()#")
 44 ········.value("FilletSurf_EmptyList",FilletSurf_ErrorTypeStatus::FilletSurf_EmptyList)
 45 ········.value("FilletSurf_EdgeNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotG1)
 46 ········.value("FilletSurf_FacesNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_FacesNotG1)
 47 ········.value("FilletSurf_EdgeNotOnShape",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotOnShape)
 48 ········.value("FilletSurf_NotSharpEdge",FilletSurf_ErrorTypeStatus::FilletSurf_NotSharpEdge)
 49 ········.value("FilletSurf_PbFilletCompute",FilletSurf_ErrorTypeStatus::FilletSurf_PbFilletCompute).export_values();
43 ····py::enum_<FilletSurf_StatusType>(m,·"FilletSurf_StatusType",R"#()#")50 ····py::enum_<FilletSurf_StatusType>(m,·"FilletSurf_StatusType",R"#()#")
44 ········.value("FilletSurf_TwoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_TwoExtremityOnEdge)51 ········.value("FilletSurf_TwoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_TwoExtremityOnEdge)
45 ········.value("FilletSurf_OneExtremityOnEdge",FilletSurf_StatusType::FilletSurf_OneExtremityOnEdge)52 ········.value("FilletSurf_OneExtremityOnEdge",FilletSurf_StatusType::FilletSurf_OneExtremityOnEdge)
46 ········.value("FilletSurf_NoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_NoExtremityOnEdge).export_values();53 ········.value("FilletSurf_NoExtremityOnEdge",FilletSurf_StatusType::FilletSurf_NoExtremityOnEdge).export_values();
47 ····py::enum_<FilletSurf_StatusDone>(m,·"FilletSurf_StatusDone",R"#()#")54 ····py::enum_<FilletSurf_StatusDone>(m,·"FilletSurf_StatusDone",R"#()#")
48 ········.value("FilletSurf_IsOk",FilletSurf_StatusDone::FilletSurf_IsOk)55 ········.value("FilletSurf_IsOk",FilletSurf_StatusDone::FilletSurf_IsOk)
49 ········.value("FilletSurf_IsNotOk",FilletSurf_StatusDone::FilletSurf_IsNotOk)56 ········.value("FilletSurf_IsNotOk",FilletSurf_StatusDone::FilletSurf_IsNotOk)
50 ········.value("FilletSurf_IsPartial",FilletSurf_StatusDone::FilletSurf_IsPartial).export_values();57 ········.value("FilletSurf_IsPartial",FilletSurf_StatusDone::FilletSurf_IsPartial).export_values();
51 ····py::enum_<FilletSurf_ErrorTypeStatus>(m,·"FilletSurf_ErrorTypeStatus",R"#()#") 
52 ········.value("FilletSurf_EmptyList",FilletSurf_ErrorTypeStatus::FilletSurf_EmptyList) 
53 ········.value("FilletSurf_EdgeNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotG1) 
54 ········.value("FilletSurf_FacesNotG1",FilletSurf_ErrorTypeStatus::FilletSurf_FacesNotG1) 
55 ········.value("FilletSurf_EdgeNotOnShape",FilletSurf_ErrorTypeStatus::FilletSurf_EdgeNotOnShape) 
56 ········.value("FilletSurf_NotSharpEdge",FilletSurf_ErrorTypeStatus::FilletSurf_NotSharpEdge) 
57 ········.value("FilletSurf_PbFilletCompute",FilletSurf_ErrorTypeStatus::FilletSurf_PbFilletCompute).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.63 KB
./usr/share/libocp/OCP/Font_pre.cpp
Ordering differences only
    
Offset 51, 20 lines modifiedOffset 51, 18 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.)#")55 ····py::enum_<Font_StrictLevel>(m,·"Font_StrictLevel",R"#(Enumeration·defining·font·search·restrictions.)#")
 56 ········.value("Font_StrictLevel_Strict",Font_StrictLevel::Font_StrictLevel_Strict)
 57 ········.value("Font_StrictLevel_Aliases",Font_StrictLevel::Font_StrictLevel_Aliases)
 58 ········.value("Font_StrictLevel_Any",Font_StrictLevel::Font_StrictLevel_Any).export_values();
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_UnicodeSubset>(m,·"Font_UnicodeSubset",R"#(Enumeration·defining·Unicode·subsets.)#")59 ····py::enum_<Font_UnicodeSubset>(m,·"Font_UnicodeSubset",R"#(Enumeration·defining·Unicode·subsets.)#")
62 ········.value("Font_UnicodeSubset_Western",Font_UnicodeSubset::Font_UnicodeSubset_Western)60 ········.value("Font_UnicodeSubset_Western",Font_UnicodeSubset::Font_UnicodeSubset_Western)
63 ········.value("Font_UnicodeSubset_Korean",Font_UnicodeSubset::Font_UnicodeSubset_Korean)61 ········.value("Font_UnicodeSubset_Korean",Font_UnicodeSubset::Font_UnicodeSubset_Korean)
64 ········.value("Font_UnicodeSubset_CJK",Font_UnicodeSubset::Font_UnicodeSubset_CJK)62 ········.value("Font_UnicodeSubset_CJK",Font_UnicodeSubset::Font_UnicodeSubset_CJK)
65 ········.value("Font_UnicodeSubset_Arabic",Font_UnicodeSubset::Font_UnicodeSubset_Arabic).export_values();63 ········.value("Font_UnicodeSubset_Arabic",Font_UnicodeSubset::Font_UnicodeSubset_Arabic).export_values();
66 ····m.attr("Font_UnicodeSubset_NB")·=·py::cast(int(Font_UnicodeSubset_NB));64 ····m.attr("Font_UnicodeSubset_NB")·=·py::cast(int(Font_UnicodeSubset_NB));
67 ····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.)#")
Offset 75, 18 lines modifiedOffset 73, 20 lines modified
75 ········.value("Font_FontAspect_BoldItalic",Font_FontAspect::Font_FontAspect_BoldItalic)73 ········.value("Font_FontAspect_BoldItalic",Font_FontAspect::Font_FontAspect_BoldItalic)
76 ········.value("Font_FA_Undefined",Font_FontAspect::Font_FA_Undefined)74 ········.value("Font_FA_Undefined",Font_FontAspect::Font_FA_Undefined)
77 ········.value("Font_FA_Regular",Font_FontAspect::Font_FA_Regular)75 ········.value("Font_FA_Regular",Font_FontAspect::Font_FA_Regular)
78 ········.value("Font_FA_Bold",Font_FontAspect::Font_FA_Bold)76 ········.value("Font_FA_Bold",Font_FontAspect::Font_FA_Bold)
79 ········.value("Font_FA_Italic",Font_FontAspect::Font_FA_Italic)77 ········.value("Font_FA_Italic",Font_FontAspect::Font_FA_Italic)
80 ········.value("Font_FA_BoldItalic",Font_FontAspect::Font_FA_BoldItalic).export_values();78 ········.value("Font_FA_BoldItalic",Font_FontAspect::Font_FA_BoldItalic).export_values();
81 ····m.attr("Font_FontAspect_NB")·=·py::cast(int(Font_FontAspect_NB));79 ····m.attr("Font_FontAspect_NB")·=·py::cast(int(Font_FontAspect_NB));
82 ····py::enum_<Font_StrictLevel>(m,·"Font_StrictLevel",R"#(Enumeration·defining·font·search·restrictions.)#")80 ····py::enum_<Font_Hinting>(m,·"Font_Hinting",R"#(Enumeration·defining·font·hinting·options.)#")
83 ········.value("Font_StrictLevel_Strict",Font_StrictLevel::Font_StrictLevel_Strict) 
84 ········.value("Font_StrictLevel_Aliases",Font_StrictLevel::Font_StrictLevel_Aliases) 
85 ········.value("Font_StrictLevel_Any",Font_StrictLevel::Font_StrictLevel_Any).export_values();81 ········.value("Font_Hinting_Off",Font_Hinting::Font_Hinting_Off)
 82 ········.value("Font_Hinting_Normal",Font_Hinting::Font_Hinting_Normal)
 83 ········.value("Font_Hinting_Light",Font_Hinting::Font_Hinting_Light)
 84 ········.value("Font_Hinting_ForceAutohint",Font_Hinting::Font_Hinting_ForceAutohint)
 85 ········.value("Font_Hinting_NoAutohint",Font_Hinting::Font_Hinting_NoAutohint).export_values();
  
86 //Python·trampoline·classes86 //Python·trampoline·classes
  
87 //·pre-register·typdefs+classes·(topologically·sorted)87 //·pre-register·typdefs+classes·(topologically·sorted)
88 ····py::class_<Font_FTFontParams·,·shared_ptr<Font_FTFontParams>··>(m,"Font_FTFontParams",R"#(Font·initialization·parameters.)#");88 ····py::class_<Font_FTFontParams·,·shared_ptr<Font_FTFontParams>··>(m,"Font_FTFontParams",R"#(Font·initialization·parameters.)#");
89 ····py::class_<Font_Rect·,·shared_ptr<Font_Rect>··>(m,"Font_Rect",R"#(Auxiliary·POD·structure·-·2D·rectangle·definition.)#");89 ····py::class_<Font_Rect·,·shared_ptr<Font_Rect>··>(m,"Font_Rect",R"#(Auxiliary·POD·structure·-·2D·rectangle·definition.)#");
90 ····py::class_<std::hash<opencascade::handle<Font_SystemFont>>·,·shared_ptr<std::hash<opencascade::handle<Font_SystemFont>>>··>(m,"std::hash_opencascade::handle_Font_SystemFont",R"#()#");90 ····py::class_<std::hash<opencascade::handle<Font_SystemFont>>·,·shared_ptr<std::hash<opencascade::handle<Font_SystemFont>>>··>(m,"std::hash_opencascade::handle_Font_SystemFont",R"#()#");
⊟
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(); 
59 ····py::enum_<GCPnts_DeflectionType>(m,·"GCPnts_DeflectionType",R"#()#")55 ····py::enum_<GCPnts_DeflectionType>(m,·"GCPnts_DeflectionType",R"#()#")
60 ········.value("GCPnts_Linear",GCPnts_DeflectionType::GCPnts_Linear)56 ········.value("GCPnts_Linear",GCPnts_DeflectionType::GCPnts_Linear)
61 ········.value("GCPnts_Circular",GCPnts_DeflectionType::GCPnts_Circular)57 ········.value("GCPnts_Circular",GCPnts_DeflectionType::GCPnts_Circular)
62 ········.value("GCPnts_Curved",GCPnts_DeflectionType::GCPnts_Curved)58 ········.value("GCPnts_Curved",GCPnts_DeflectionType::GCPnts_Curved)
63 ········.value("GCPnts_DefComposite",GCPnts_DeflectionType::GCPnts_DefComposite).export_values();59 ········.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();
61 ····py::enum_<GProp_ValueType>(m,·"GProp_ValueType",R"#(Algorithmes·:)#")67 ····py::enum_<GProp_ValueType>(m,·"GProp_ValueType",R"#(Algorithmes·:)#")
62 ········.value("GProp_Mass",GProp_ValueType::GProp_Mass)68 ········.value("GProp_Mass",GProp_ValueType::GProp_Mass)
63 ········.value("GProp_CenterMassX",GProp_ValueType::GProp_CenterMassX)69 ········.value("GProp_CenterMassX",GProp_ValueType::GProp_CenterMassX)
64 ········.value("GProp_CenterMassY",GProp_ValueType::GProp_CenterMassY)70 ········.value("GProp_CenterMassY",GProp_ValueType::GProp_CenterMassY)
65 ········.value("GProp_CenterMassZ",GProp_ValueType::GProp_CenterMassZ)71 ········.value("GProp_CenterMassZ",GProp_ValueType::GProp_CenterMassZ)
66 ········.value("GProp_InertiaXX",GProp_ValueType::GProp_InertiaXX)72 ········.value("GProp_InertiaXX",GProp_ValueType::GProp_InertiaXX)
67 ········.value("GProp_InertiaYY",GProp_ValueType::GProp_InertiaYY)73 ········.value("GProp_InertiaYY",GProp_ValueType::GProp_InertiaYY)
68 ········.value("GProp_InertiaZZ",GProp_ValueType::GProp_InertiaZZ)74 ········.value("GProp_InertiaZZ",GProp_ValueType::GProp_InertiaZZ)
69 ········.value("GProp_InertiaXY",GProp_ValueType::GProp_InertiaXY)75 ········.value("GProp_InertiaXY",GProp_ValueType::GProp_InertiaXY)
70 ········.value("GProp_InertiaXZ",GProp_ValueType::GProp_InertiaXZ)76 ········.value("GProp_InertiaXZ",GProp_ValueType::GProp_InertiaXZ)
71 ········.value("GProp_InertiaYZ",GProp_ValueType::GProp_InertiaYZ)77 ········.value("GProp_InertiaYZ",GProp_ValueType::GProp_InertiaYZ)
72 ········.value("GProp_Unknown",GProp_ValueType::GProp_Unknown).export_values();78 ········.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.)#");
⊟
4.42 KB
./usr/share/libocp/OCP/Geom2dGcc_pre.cpp
Ordering differences only
    
Offset 112, 37 lines modifiedOffset 112, 37 lines modified
112 py::module·m·=·main_module.def_submodule("Geom2dGcc",·R"#()#");112 py::module·m·=·main_module.def_submodule("Geom2dGcc",·R"#()#");
  
113 //·add·namespaces·as·submodules113 //·add·namespaces·as·submodules
  
114 //·user-defined·inclusion·per·module·in·the·body114 //·user-defined·inclusion·per·module·in·the·body
  
115 //·enums115 //·enums
 116 ····py::enum_<Geom2dGcc_Type3>(m,·"Geom2dGcc_Type3",R"#()#")
 117 ········.value("Geom2dGcc_CuCu",Geom2dGcc_Type3::Geom2dGcc_CuCu)
 118 ········.value("Geom2dGcc_CiCu",Geom2dGcc_Type3::Geom2dGcc_CiCu).export_values();
 119 ····py::enum_<Geom2dGcc_Type1>(m,·"Geom2dGcc_Type1",R"#()#")
 120 ········.value("Geom2dGcc_CuCuCu",Geom2dGcc_Type1::Geom2dGcc_CuCuCu)
 121 ········.value("Geom2dGcc_CiCuCu",Geom2dGcc_Type1::Geom2dGcc_CiCuCu)
 122 ········.value("Geom2dGcc_CiCiCu",Geom2dGcc_Type1::Geom2dGcc_CiCiCu)
 123 ········.value("Geom2dGcc_CiLiCu",Geom2dGcc_Type1::Geom2dGcc_CiLiCu)
 124 ········.value("Geom2dGcc_LiLiCu",Geom2dGcc_Type1::Geom2dGcc_LiLiCu)
 125 ········.value("Geom2dGcc_LiCuCu",Geom2dGcc_Type1::Geom2dGcc_LiCuCu).export_values();
116 ····py::enum_<Geom2dGcc_Type2>(m,·"Geom2dGcc_Type2",R"#()#")126 ····py::enum_<Geom2dGcc_Type2>(m,·"Geom2dGcc_Type2",R"#()#")
117 ········.value("Geom2dGcc_CuCuOnCu",Geom2dGcc_Type2::Geom2dGcc_CuCuOnCu)127 ········.value("Geom2dGcc_CuCuOnCu",Geom2dGcc_Type2::Geom2dGcc_CuCuOnCu)
118 ········.value("Geom2dGcc_CiCuOnCu",Geom2dGcc_Type2::Geom2dGcc_CiCuOnCu)128 ········.value("Geom2dGcc_CiCuOnCu",Geom2dGcc_Type2::Geom2dGcc_CiCuOnCu)
119 ········.value("Geom2dGcc_LiCuOnCu",Geom2dGcc_Type2::Geom2dGcc_LiCuOnCu)129 ········.value("Geom2dGcc_LiCuOnCu",Geom2dGcc_Type2::Geom2dGcc_LiCuOnCu)
120 ········.value("Geom2dGcc_CuPtOnCu",Geom2dGcc_Type2::Geom2dGcc_CuPtOnCu)130 ········.value("Geom2dGcc_CuPtOnCu",Geom2dGcc_Type2::Geom2dGcc_CuPtOnCu)
121 ········.value("Geom2dGcc_CuCuOnLi",Geom2dGcc_Type2::Geom2dGcc_CuCuOnLi)131 ········.value("Geom2dGcc_CuCuOnLi",Geom2dGcc_Type2::Geom2dGcc_CuCuOnLi)
122 ········.value("Geom2dGcc_CiCuOnLi",Geom2dGcc_Type2::Geom2dGcc_CiCuOnLi)132 ········.value("Geom2dGcc_CiCuOnLi",Geom2dGcc_Type2::Geom2dGcc_CiCuOnLi)
123 ········.value("Geom2dGcc_LiCuOnLi",Geom2dGcc_Type2::Geom2dGcc_LiCuOnLi)133 ········.value("Geom2dGcc_LiCuOnLi",Geom2dGcc_Type2::Geom2dGcc_LiCuOnLi)
124 ········.value("Geom2dGcc_CuPtOnLi",Geom2dGcc_Type2::Geom2dGcc_CuPtOnLi)134 ········.value("Geom2dGcc_CuPtOnLi",Geom2dGcc_Type2::Geom2dGcc_CuPtOnLi)
125 ········.value("Geom2dGcc_CuCuOnCi",Geom2dGcc_Type2::Geom2dGcc_CuCuOnCi)135 ········.value("Geom2dGcc_CuCuOnCi",Geom2dGcc_Type2::Geom2dGcc_CuCuOnCi)
126 ········.value("Geom2dGcc_CiCuOnCi",Geom2dGcc_Type2::Geom2dGcc_CiCuOnCi)136 ········.value("Geom2dGcc_CiCuOnCi",Geom2dGcc_Type2::Geom2dGcc_CiCuOnCi)
127 ········.value("Geom2dGcc_LiCuOnCi",Geom2dGcc_Type2::Geom2dGcc_LiCuOnCi)137 ········.value("Geom2dGcc_LiCuOnCi",Geom2dGcc_Type2::Geom2dGcc_LiCuOnCi)
128 ········.value("Geom2dGcc_CuPtOnCi",Geom2dGcc_Type2::Geom2dGcc_CuPtOnCi).export_values();138 ········.value("Geom2dGcc_CuPtOnCi",Geom2dGcc_Type2::Geom2dGcc_CuPtOnCi).export_values();
129 ····py::enum_<Geom2dGcc_Type3>(m,·"Geom2dGcc_Type3",R"#()#") 
130 ········.value("Geom2dGcc_CuCu",Geom2dGcc_Type3::Geom2dGcc_CuCu) 
131 ········.value("Geom2dGcc_CiCu",Geom2dGcc_Type3::Geom2dGcc_CiCu).export_values(); 
132 ····py::enum_<Geom2dGcc_Type1>(m,·"Geom2dGcc_Type1",R"#()#") 
133 ········.value("Geom2dGcc_CuCuCu",Geom2dGcc_Type1::Geom2dGcc_CuCuCu) 
134 ········.value("Geom2dGcc_CiCuCu",Geom2dGcc_Type1::Geom2dGcc_CiCuCu) 
135 ········.value("Geom2dGcc_CiCiCu",Geom2dGcc_Type1::Geom2dGcc_CiCiCu) 
136 ········.value("Geom2dGcc_CiLiCu",Geom2dGcc_Type1::Geom2dGcc_CiLiCu) 
137 ········.value("Geom2dGcc_LiLiCu",Geom2dGcc_Type1::Geom2dGcc_LiLiCu) 
138 ········.value("Geom2dGcc_LiCuCu",Geom2dGcc_Type1::Geom2dGcc_LiCuCu).export_values(); 
  
139 //Python·trampoline·classes139 //Python·trampoline·classes
  
140 //·pre-register·typdefs+classes·(topologically·sorted)140 //·pre-register·typdefs+classes·(topologically·sorted)
141 ····py::class_<Geom2dGcc·,·shared_ptr<Geom2dGcc>··>(m,"Geom2dGcc",R"#(The·Geom2dGcc·package·describes·qualified·2D·curves·used·in·the·construction·of·constrained·geometric·objects·by·an·algorithm·provided·by·the·Geom2dGcc·package.·A·qualified·2D·curve·is·a·curve·with·a·qualifier·which·specifies·whether·the·solution·of·a·construction·algorithm·using·the·qualified·curve·(as·an·argument):·-·encloses·the·curve,·or·-·is·enclosed·by·the·curve,·or·-·is·built·so·that·both·the·curve·and·this·solution·are·external·to·one·another,·or·-·is·undefined·(all·solutions·apply).·These·package·methods·provide·simpler·functions·to·construct·a·qualified·curve.·Note:·the·interior·of·a·curve·is·defined·as·the·left-hand·side·of·the·curve·in·relation·to·its·orientation.)#");141 ····py::class_<Geom2dGcc·,·shared_ptr<Geom2dGcc>··>(m,"Geom2dGcc",R"#(The·Geom2dGcc·package·describes·qualified·2D·curves·used·in·the·construction·of·constrained·geometric·objects·by·an·algorithm·provided·by·the·Geom2dGcc·package.·A·qualified·2D·curve·is·a·curve·with·a·qualifier·which·specifies·whether·the·solution·of·a·construction·algorithm·using·the·qualified·curve·(as·an·argument):·-·encloses·the·curve,·or·-·is·enclosed·by·the·curve,·or·-·is·built·so·that·both·the·curve·and·this·solution·are·external·to·one·another,·or·-·is·undefined·(all·solutions·apply).·These·package·methods·provide·simpler·functions·to·construct·a·qualified·curve.·Note:·the·interior·of·a·curve·is·defined·as·the·left-hand·side·of·the·curve·in·relation·to·its·orientation.)#");
142 ····py::class_<Geom2dGcc_Circ2d2TanOn·,·shared_ptr<Geom2dGcc_Circ2d2TanOn>··>(m,"Geom2dGcc_Circ2d2TanOn",R"#(This·class·implements·the·algorithms·used·to·create·2d·circles·TANgent·to·2·entities·and·having·the·center·ON·a·curve.·The·order·of·the·tangency·argument·is·always·QualifiedCirc,·QualifiedLin,·QualifiedCurv,·Pnt2d.·the·arguments·are·:·-·The·two·tangency·arguments.·-·The·center·line.·-·The·parameter·for·each·tangency·argument·which·is·a·curve.·-·The·tolerance.)#");142 ····py::class_<Geom2dGcc_Circ2d2TanOn·,·shared_ptr<Geom2dGcc_Circ2d2TanOn>··>(m,"Geom2dGcc_Circ2d2TanOn",R"#(This·class·implements·the·algorithms·used·to·create·2d·circles·TANgent·to·2·entities·and·having·the·center·ON·a·curve.·The·order·of·the·tangency·argument·is·always·QualifiedCirc,·QualifiedLin,·QualifiedCurv,·Pnt2d.·the·arguments·are·:·-·The·two·tangency·arguments.·-·The·center·line.·-·The·parameter·for·each·tangency·argument·which·is·a·curve.·-·The·tolerance.)#");
143 ····py::class_<Geom2dGcc_Circ2d2TanOnGeo·,·shared_ptr<Geom2dGcc_Circ2d2TanOnGeo>··>(m,"Geom2dGcc_Circ2d2TanOnGeo",R"#(This·class·implements·the·algorithms·used·to·create·2d·circles·TANgent·to·2·entities·and·having·the·center·ON·a·curve.·The·order·of·the·tangency·argument·is·always·QualifiedCirc,·QualifiedLin,·QualifiedCurv,·Pnt2d.·the·arguments·are·:·-·The·two·tangency·arguments·(lines,·circles·or·points).·-·The·center·line·(a·curve).·-·The·parameter·for·each·tangency·argument·which·is·a·curve.·-·The·tolerance.)#");143 ····py::class_<Geom2dGcc_Circ2d2TanOnGeo·,·shared_ptr<Geom2dGcc_Circ2d2TanOnGeo>··>(m,"Geom2dGcc_Circ2d2TanOnGeo",R"#(This·class·implements·the·algorithms·used·to·create·2d·circles·TANgent·to·2·entities·and·having·the·center·ON·a·curve.·The·order·of·the·tangency·argument·is·always·QualifiedCirc,·QualifiedLin,·QualifiedCurv,·Pnt2d.·the·arguments·are·:·-·The·two·tangency·arguments·(lines,·circles·or·points).·-·The·center·line·(a·curve).·-·The·parameter·for·each·tangency·argument·which·is·a·curve.·-·The·tolerance.)#");
⊟
6.44 KB
./usr/share/libocp/OCP/GeomAbs_pre.cpp
Ordering differences only
    
Offset 36, 39 lines modifiedOffset 36, 26 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_IsoType>(m,·"GeomAbs_IsoType",R"#(this·enumeration·describes·if·a·curve·is·an·U·isoparaetric·or·V·isoparametric)#") 
41 ········.value("GeomAbs_IsoU",GeomAbs_IsoType::GeomAbs_IsoU) 
42 ········.value("GeomAbs_IsoV",GeomAbs_IsoType::GeomAbs_IsoV) 
43 ········.value("GeomAbs_NoneIso",GeomAbs_IsoType::GeomAbs_NoneIso).export_values(); 
44 ····py::enum_<GeomAbs_SurfaceType>(m,·"GeomAbs_SurfaceType",R"#()#")40 ····py::enum_<GeomAbs_SurfaceType>(m,·"GeomAbs_SurfaceType",R"#()#")
45 ········.value("GeomAbs_Plane",GeomAbs_SurfaceType::GeomAbs_Plane)41 ········.value("GeomAbs_Plane",GeomAbs_SurfaceType::GeomAbs_Plane)
46 ········.value("GeomAbs_Cylinder",GeomAbs_SurfaceType::GeomAbs_Cylinder)42 ········.value("GeomAbs_Cylinder",GeomAbs_SurfaceType::GeomAbs_Cylinder)
47 ········.value("GeomAbs_Cone",GeomAbs_SurfaceType::GeomAbs_Cone)43 ········.value("GeomAbs_Cone",GeomAbs_SurfaceType::GeomAbs_Cone)
48 ········.value("GeomAbs_Sphere",GeomAbs_SurfaceType::GeomAbs_Sphere)44 ········.value("GeomAbs_Sphere",GeomAbs_SurfaceType::GeomAbs_Sphere)
49 ········.value("GeomAbs_Torus",GeomAbs_SurfaceType::GeomAbs_Torus)45 ········.value("GeomAbs_Torus",GeomAbs_SurfaceType::GeomAbs_Torus)
50 ········.value("GeomAbs_BezierSurface",GeomAbs_SurfaceType::GeomAbs_BezierSurface)46 ········.value("GeomAbs_BezierSurface",GeomAbs_SurfaceType::GeomAbs_BezierSurface)
51 ········.value("GeomAbs_BSplineSurface",GeomAbs_SurfaceType::GeomAbs_BSplineSurface)47 ········.value("GeomAbs_BSplineSurface",GeomAbs_SurfaceType::GeomAbs_BSplineSurface)
52 ········.value("GeomAbs_SurfaceOfRevolution",GeomAbs_SurfaceType::GeomAbs_SurfaceOfRevolution)48 ········.value("GeomAbs_SurfaceOfRevolution",GeomAbs_SurfaceType::GeomAbs_SurfaceOfRevolution)
53 ········.value("GeomAbs_SurfaceOfExtrusion",GeomAbs_SurfaceType::GeomAbs_SurfaceOfExtrusion)49 ········.value("GeomAbs_SurfaceOfExtrusion",GeomAbs_SurfaceType::GeomAbs_SurfaceOfExtrusion)
54 ········.value("GeomAbs_OffsetSurface",GeomAbs_SurfaceType::GeomAbs_OffsetSurface)50 ········.value("GeomAbs_OffsetSurface",GeomAbs_SurfaceType::GeomAbs_OffsetSurface)
55 ········.value("GeomAbs_OtherSurface",GeomAbs_SurfaceType::GeomAbs_OtherSurface).export_values();51 ········.value("GeomAbs_OtherSurface",GeomAbs_SurfaceType::GeomAbs_OtherSurface).export_values();
56 ····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.)#") 
57 ········.value("GeomAbs_Arc",GeomAbs_JoinType::GeomAbs_Arc) 
58 ········.value("GeomAbs_Tangent",GeomAbs_JoinType::GeomAbs_Tangent) 
59 ········.value("GeomAbs_Intersection",GeomAbs_JoinType::GeomAbs_Intersection).export_values(); 
60 ····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))#") 
61 ········.value("GeomAbs_NonUniform",GeomAbs_BSplKnotDistribution::GeomAbs_NonUniform) 
62 ········.value("GeomAbs_Uniform",GeomAbs_BSplKnotDistribution::GeomAbs_Uniform) 
63 ········.value("GeomAbs_QuasiUniform",GeomAbs_BSplKnotDistribution::GeomAbs_QuasiUniform) 
64 ········.value("GeomAbs_PiecewiseBezier",GeomAbs_BSplKnotDistribution::GeomAbs_PiecewiseBezier).export_values(); 
65 ····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.)#")52 ····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.)#")
66 ········.value("GeomAbs_C0",GeomAbs_Shape::GeomAbs_C0)53 ········.value("GeomAbs_C0",GeomAbs_Shape::GeomAbs_C0)
67 ········.value("GeomAbs_G1",GeomAbs_Shape::GeomAbs_G1)54 ········.value("GeomAbs_G1",GeomAbs_Shape::GeomAbs_G1)
68 ········.value("GeomAbs_C1",GeomAbs_Shape::GeomAbs_C1)55 ········.value("GeomAbs_C1",GeomAbs_Shape::GeomAbs_C1)
69 ········.value("GeomAbs_G2",GeomAbs_Shape::GeomAbs_G2)56 ········.value("GeomAbs_G2",GeomAbs_Shape::GeomAbs_G2)
70 ········.value("GeomAbs_C2",GeomAbs_Shape::GeomAbs_C2)57 ········.value("GeomAbs_C2",GeomAbs_Shape::GeomAbs_C2)
71 ········.value("GeomAbs_C3",GeomAbs_Shape::GeomAbs_C3)58 ········.value("GeomAbs_C3",GeomAbs_Shape::GeomAbs_C3)
Offset 79, 14 lines modifiedOffset 66, 27 lines modified
79 ········.value("GeomAbs_Ellipse",GeomAbs_CurveType::GeomAbs_Ellipse)66 ········.value("GeomAbs_Ellipse",GeomAbs_CurveType::GeomAbs_Ellipse)
80 ········.value("GeomAbs_Hyperbola",GeomAbs_CurveType::GeomAbs_Hyperbola)67 ········.value("GeomAbs_Hyperbola",GeomAbs_CurveType::GeomAbs_Hyperbola)
81 ········.value("GeomAbs_Parabola",GeomAbs_CurveType::GeomAbs_Parabola)68 ········.value("GeomAbs_Parabola",GeomAbs_CurveType::GeomAbs_Parabola)
82 ········.value("GeomAbs_BezierCurve",GeomAbs_CurveType::GeomAbs_BezierCurve)69 ········.value("GeomAbs_BezierCurve",GeomAbs_CurveType::GeomAbs_BezierCurve)
83 ········.value("GeomAbs_BSplineCurve",GeomAbs_CurveType::GeomAbs_BSplineCurve)70 ········.value("GeomAbs_BSplineCurve",GeomAbs_CurveType::GeomAbs_BSplineCurve)
84 ········.value("GeomAbs_OffsetCurve",GeomAbs_CurveType::GeomAbs_OffsetCurve)71 ········.value("GeomAbs_OffsetCurve",GeomAbs_CurveType::GeomAbs_OffsetCurve)
85 ········.value("GeomAbs_OtherCurve",GeomAbs_CurveType::GeomAbs_OtherCurve).export_values();72 ········.value("GeomAbs_OtherCurve",GeomAbs_CurveType::GeomAbs_OtherCurve).export_values();
 73 ····py::enum_<GeomAbs_IsoType>(m,·"GeomAbs_IsoType",R"#(this·enumeration·describes·if·a·curve·is·an·U·isoparaetric·or·V·isoparametric)#")
 74 ········.value("GeomAbs_IsoU",GeomAbs_IsoType::GeomAbs_IsoU)
 75 ········.value("GeomAbs_IsoV",GeomAbs_IsoType::GeomAbs_IsoV)
 76 ········.value("GeomAbs_NoneIso",GeomAbs_IsoType::GeomAbs_NoneIso).export_values();
 77 ····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))#")
 78 ········.value("GeomAbs_NonUniform",GeomAbs_BSplKnotDistribution::GeomAbs_NonUniform)
 79 ········.value("GeomAbs_Uniform",GeomAbs_BSplKnotDistribution::GeomAbs_Uniform)
 80 ········.value("GeomAbs_QuasiUniform",GeomAbs_BSplKnotDistribution::GeomAbs_QuasiUniform)
 81 ········.value("GeomAbs_PiecewiseBezier",GeomAbs_BSplKnotDistribution::GeomAbs_PiecewiseBezier).export_values();
 82 ····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.)#")
 83 ········.value("GeomAbs_Arc",GeomAbs_JoinType::GeomAbs_Arc)
 84 ········.value("GeomAbs_Tangent",GeomAbs_JoinType::GeomAbs_Tangent)
 85 ········.value("GeomAbs_Intersection",GeomAbs_JoinType::GeomAbs_Intersection).export_values();
  
86 //Python·trampoline·classes86 //Python·trampoline·classes
  
87 //·pre-register·typdefs+classes·(topologically·sorted)87 //·pre-register·typdefs+classes·(topologically·sorted)
  
88 };88 };
  
⊟
2.65 KB
./usr/share/libocp/OCP/GeomFill_pre.cpp
Ordering differences only
    
Offset 173, 14 lines modifiedOffset 173, 17 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();
177 ····py::enum_<GeomFill_Trihedron>(m,·"GeomFill_Trihedron",R"#()#")180 ····py::enum_<GeomFill_Trihedron>(m,·"GeomFill_Trihedron",R"#()#")
178 ········.value("GeomFill_IsCorrectedFrenet",GeomFill_Trihedron::GeomFill_IsCorrectedFrenet)181 ········.value("GeomFill_IsCorrectedFrenet",GeomFill_Trihedron::GeomFill_IsCorrectedFrenet)
179 ········.value("GeomFill_IsFixed",GeomFill_Trihedron::GeomFill_IsFixed)182 ········.value("GeomFill_IsFixed",GeomFill_Trihedron::GeomFill_IsFixed)
180 ········.value("GeomFill_IsFrenet",GeomFill_Trihedron::GeomFill_IsFrenet)183 ········.value("GeomFill_IsFrenet",GeomFill_Trihedron::GeomFill_IsFrenet)
181 ········.value("GeomFill_IsConstantNormal",GeomFill_Trihedron::GeomFill_IsConstantNormal)184 ········.value("GeomFill_IsConstantNormal",GeomFill_Trihedron::GeomFill_IsConstantNormal)
182 ········.value("GeomFill_IsDarboux",GeomFill_Trihedron::GeomFill_IsDarboux)185 ········.value("GeomFill_IsDarboux",GeomFill_Trihedron::GeomFill_IsDarboux)
183 ········.value("GeomFill_IsGuideAC",GeomFill_Trihedron::GeomFill_IsGuideAC)186 ········.value("GeomFill_IsGuideAC",GeomFill_Trihedron::GeomFill_IsGuideAC)
Offset 188, 17 lines modifiedOffset 191, 14 lines modified
188 ········.value("GeomFill_IsGuideACWithContact",GeomFill_Trihedron::GeomFill_IsGuideACWithContact)191 ········.value("GeomFill_IsGuideACWithContact",GeomFill_Trihedron::GeomFill_IsGuideACWithContact)
189 ········.value("GeomFill_IsGuidePlanWithContact",GeomFill_Trihedron::GeomFill_IsGuidePlanWithContact)192 ········.value("GeomFill_IsGuidePlanWithContact",GeomFill_Trihedron::GeomFill_IsGuidePlanWithContact)
190 ········.value("GeomFill_IsDiscreteTrihedron",GeomFill_Trihedron::GeomFill_IsDiscreteTrihedron).export_values();193 ········.value("GeomFill_IsDiscreteTrihedron",GeomFill_Trihedron::GeomFill_IsDiscreteTrihedron).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.)#")194 ····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)195 ········.value("GeomFill_StretchStyle",GeomFill_FillingStyle::GeomFill_StretchStyle)
193 ········.value("GeomFill_CoonsStyle",GeomFill_FillingStyle::GeomFill_CoonsStyle)196 ········.value("GeomFill_CoonsStyle",GeomFill_FillingStyle::GeomFill_CoonsStyle)
194 ········.value("GeomFill_CurvedStyle",GeomFill_FillingStyle::GeomFill_CurvedStyle).export_values();197 ········.value("GeomFill_CurvedStyle",GeomFill_FillingStyle::GeomFill_CurvedStyle).export_values();
195 ····py::enum_<GeomFill_ApproxStyle>(m,·"GeomFill_ApproxStyle",R"#()#") 
196 ········.value("GeomFill_Section",GeomFill_ApproxStyle::GeomFill_Section) 
197 ········.value("GeomFill_Location",GeomFill_ApproxStyle::GeomFill_Location).export_values(); 
198 ····py::enum_<GeomFill_PipeError>(m,·"GeomFill_PipeError",R"#()#")198 ····py::enum_<GeomFill_PipeError>(m,·"GeomFill_PipeError",R"#()#")
199 ········.value("GeomFill_PipeOk",GeomFill_PipeError::GeomFill_PipeOk)199 ········.value("GeomFill_PipeOk",GeomFill_PipeError::GeomFill_PipeOk)
200 ········.value("GeomFill_PipeNotOk",GeomFill_PipeError::GeomFill_PipeNotOk)200 ········.value("GeomFill_PipeNotOk",GeomFill_PipeError::GeomFill_PipeNotOk)
201 ········.value("GeomFill_PlaneNotIntersectGuide",GeomFill_PipeError::GeomFill_PlaneNotIntersectGuide)201 ········.value("GeomFill_PlaneNotIntersectGuide",GeomFill_PipeError::GeomFill_PlaneNotIntersectGuide)
202 ········.value("GeomFill_ImpossibleContact",GeomFill_PipeError::GeomFill_ImpossibleContact).export_values();202 ········.value("GeomFill_ImpossibleContact",GeomFill_PipeError::GeomFill_ImpossibleContact).export_values();
  
203 //Python·trampoline·classes203 //Python·trampoline·classes
⊟
85.9 KB
./usr/share/libocp/OCP/Graphic3d_pre.cpp
Ordering differences only
    
Offset 284, 128 lines modifiedOffset 284, 91 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 ····py::enum_<Graphic3d_HorizontalTextAlignment>(m,·"Graphic3d_HorizontalTextAlignment",R"#(Defines·the·horizontal·position·of·the·text·relative·to·its·anchor.)#")
 289 ········.value("Graphic3d_HTA_LEFT",Graphic3d_HorizontalTextAlignment::Graphic3d_HTA_LEFT)
 290 ········.value("Graphic3d_HTA_CENTER",Graphic3d_HorizontalTextAlignment::Graphic3d_HTA_CENTER)
 291 ········.value("Graphic3d_HTA_RIGHT",Graphic3d_HorizontalTextAlignment::Graphic3d_HTA_RIGHT).export_values();
288 ····py::enum_<Graphic3d_GlslExtension>(m,·"Graphic3d_GlslExtension",R"#(GLSL·syntax·extensions.)#") 
289 ········.value("Graphic3d_GlslExtension_GL_OES_standard_derivatives",Graphic3d_GlslExtension::Graphic3d_GlslExtension_GL_OES_standard_derivatives) 
290 ········.value("Graphic3d_GlslExtension_GL_EXT_shader_texture_lod",Graphic3d_GlslExtension::Graphic3d_GlslExtension_GL_EXT_shader_texture_lod) 
291 ········.value("Graphic3d_GlslExtension_GL_EXT_frag_depth",Graphic3d_GlslExtension::Graphic3d_GlslExtension_GL_EXT_frag_depth) 
292 ········.value("Graphic3d_GlslExtension_GL_EXT_gpu_shader4",Graphic3d_GlslExtension::Graphic3d_GlslExtension_GL_EXT_gpu_shader4).export_values(); 
293 ····m.attr("Graphic3d_GlslExtension_NB")·=·py::cast(int(Graphic3d_GlslExtension_NB)); 
294 ····m.attr("Graphic3d_ZLayerId_UNKNOWN")·=·py::cast(int(Graphic3d_ZLayerId_UNKNOWN)); 
295 ····m.attr("Graphic3d_ZLayerId_Default")·=·py::cast(int(Graphic3d_ZLayerId_Default)); 
296 ····m.attr("Graphic3d_ZLayerId_Top")·=·py::cast(int(Graphic3d_ZLayerId_Top)); 
297 ····m.attr("Graphic3d_ZLayerId_Topmost")·=·py::cast(int(Graphic3d_ZLayerId_Topmost)); 
298 ····m.attr("Graphic3d_ZLayerId_TopOSD")·=·py::cast(int(Graphic3d_ZLayerId_TopOSD)); 
299 ····m.attr("Graphic3d_ZLayerId_BotOSD")·=·py::cast(int(Graphic3d_ZLayerId_BotOSD)); 
300 ····py::enum_<Graphic3d_TypeOfLimit>(m,·"Graphic3d_TypeOfLimit",R"#(Type·of·graphic·resource·limit.)#") 
301 ········.value("Graphic3d_TypeOfLimit_MaxNbLights",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxNbLights) 
302 ········.value("Graphic3d_TypeOfLimit_MaxNbClipPlanes",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxNbClipPlanes) 
303 ········.value("Graphic3d_TypeOfLimit_MaxNbViews",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxNbViews) 
304 ········.value("Graphic3d_TypeOfLimit_MaxTextureSize",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxTextureSize) 
305 ········.value("Graphic3d_TypeOfLimit_MaxViewDumpSizeX",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxViewDumpSizeX) 
306 ········.value("Graphic3d_TypeOfLimit_MaxViewDumpSizeY",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxViewDumpSizeY) 
307 ········.value("Graphic3d_TypeOfLimit_MaxCombinedTextureUnits",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxCombinedTextureUnits) 
308 ········.value("Graphic3d_TypeOfLimit_MaxMsaa",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_MaxMsaa) 
309 ········.value("Graphic3d_TypeOfLimit_HasPBR",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasPBR) 
310 ········.value("Graphic3d_TypeOfLimit_HasRayTracing",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasRayTracing) 
311 ········.value("Graphic3d_TypeOfLimit_HasRayTracingTextures",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasRayTracingTextures) 
312 ········.value("Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSampling",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSampling) 
313 ········.value("Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSamplingAtomic",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSamplingAtomic) 
314 ········.value("Graphic3d_TypeOfLimit_HasSRGB",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasSRGB) 
315 ········.value("Graphic3d_TypeOfLimit_HasBlendedOit",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasBlendedOit) 
316 ········.value("Graphic3d_TypeOfLimit_HasBlendedOitMsaa",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasBlendedOitMsaa) 
317 ········.value("Graphic3d_TypeOfLimit_HasFlatShading",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasFlatShading) 
318 ········.value("Graphic3d_TypeOfLimit_HasMeshEdges",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_HasMeshEdges) 
319 ········.value("Graphic3d_TypeOfLimit_IsWorkaroundFBO",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_IsWorkaroundFBO) 
320 ········.value("Graphic3d_TypeOfLimit_NB",Graphic3d_TypeOfLimit::Graphic3d_TypeOfLimit_NB).export_values(); 
321 ····py::enum_<Graphic3d_TypeOfTextureFilter>(m,·"Graphic3d_TypeOfTextureFilter",R"#(Type·of·the·texture·filter.·Notice·that·for·textures·without·mipmaps·linear·interpolation·will·be·used·instead·of·TOTF_BILINEAR·and·TOTF_TRILINEAR.)#") 
322 ········.value("Graphic3d_TOTF_NEAREST",Graphic3d_TypeOfTextureFilter::Graphic3d_TOTF_NEAREST) 
323 ········.value("Graphic3d_TOTF_BILINEAR",Graphic3d_TypeOfTextureFilter::Graphic3d_TOTF_BILINEAR) 
324 ········.value("Graphic3d_TOTF_TRILINEAR",Graphic3d_TypeOfTextureFilter::Graphic3d_TOTF_TRILINEAR).export_values(); 
325 ····py::enum_<Graphic3d_TypeOfReflection>(m,·"Graphic3d_TypeOfReflection",R"#(Nature·of·the·reflection·of·a·material.)#") 
326 ········.value("Graphic3d_TOR_AMBIENT",Graphic3d_TypeOfReflection::Graphic3d_TOR_AMBIENT) 
327 ········.value("Graphic3d_TOR_DIFFUSE",Graphic3d_TypeOfReflection::Graphic3d_TOR_DIFFUSE) 
328 ········.value("Graphic3d_TOR_SPECULAR",Graphic3d_TypeOfReflection::Graphic3d_TOR_SPECULAR) 
329 ········.value("Graphic3d_TOR_EMISSION",Graphic3d_TypeOfReflection::Graphic3d_TOR_EMISSION).export_values(); 
330 ····m.attr("Graphic3d_TypeOfReflection_NB")·=·py::cast(int(Graphic3d_TypeOfReflection_NB)); 
331 ····py::enum_<Graphic3d_CappingFlags>(m,·"Graphic3d_CappingFlags",R"#(Enumeration·of·capping·flags.)#") 
332 ········.value("Graphic3d_CappingFlags_None",Graphic3d_CappingFlags::Graphic3d_CappingFlags_None) 
333 ········.value("Graphic3d_CappingFlags_ObjectMaterial",Graphic3d_CappingFlags::Graphic3d_CappingFlags_ObjectMaterial) 
334 ········.value("Graphic3d_CappingFlags_ObjectTexture",Graphic3d_CappingFlags::Graphic3d_CappingFlags_ObjectTexture) 
335 ········.value("Graphic3d_CappingFlags_ObjectShader",Graphic3d_CappingFlags::Graphic3d_CappingFlags_ObjectShader) 
336 ········.value("Graphic3d_CappingFlags_ObjectAspect",Graphic3d_CappingFlags::Graphic3d_CappingFlags_ObjectAspect).export_values(); 
337 ····py::enum_<Graphic3d_TypeOfMaterial>(m,·"Graphic3d_TypeOfMaterial",R"#(Types·of·materials·specifies·if·a·material·can·change·color.)#") 
338 ········.value("Graphic3d_MATERIAL_ASPECT",Graphic3d_TypeOfMaterial::Graphic3d_MATERIAL_ASPECT) 
339 ········.value("Graphic3d_MATERIAL_PHYSIC",Graphic3d_TypeOfMaterial::Graphic3d_MATERIAL_PHYSIC).export_values(); 
340 ····m.attr("Graphic3d_ArrayFlags_None")·=·py::cast(int(Graphic3d_ArrayFlags_None));292 ····m.attr("Graphic3d_ArrayFlags_None")·=·py::cast(int(Graphic3d_ArrayFlags_None));
341 ····m.attr("Graphic3d_ArrayFlags_VertexNormal")·=·py::cast(int(Graphic3d_ArrayFlags_VertexNormal));293 ····m.attr("Graphic3d_ArrayFlags_VertexNormal")·=·py::cast(int(Graphic3d_ArrayFlags_VertexNormal));
342 ····m.attr("Graphic3d_ArrayFlags_VertexColor")·=·py::cast(int(Graphic3d_ArrayFlags_VertexColor));294 ····m.attr("Graphic3d_ArrayFlags_VertexColor")·=·py::cast(int(Graphic3d_ArrayFlags_VertexColor));
343 ····m.attr("Graphic3d_ArrayFlags_VertexTexel")·=·py::cast(int(Graphic3d_ArrayFlags_VertexTexel));295 ····m.attr("Graphic3d_ArrayFlags_VertexTexel")·=·py::cast(int(Graphic3d_ArrayFlags_VertexTexel));
344 ····m.attr("Graphic3d_ArrayFlags_BoundColor")·=·py::cast(int(Graphic3d_ArrayFlags_BoundColor));296 ····m.attr("Graphic3d_ArrayFlags_BoundColor")·=·py::cast(int(Graphic3d_ArrayFlags_BoundColor));
345 ····m.attr("Graphic3d_ArrayFlags_AttribsMutable")·=·py::cast(int(Graphic3d_ArrayFlags_AttribsMutable));297 ····m.attr("Graphic3d_ArrayFlags_AttribsMutable")·=·py::cast(int(Graphic3d_ArrayFlags_AttribsMutable));
346 ····m.attr("Graphic3d_ArrayFlags_AttribsDeinterleaved")·=·py::cast(int(Graphic3d_ArrayFlags_AttribsDeinterleaved));298 ····m.attr("Graphic3d_ArrayFlags_AttribsDeinterleaved")·=·py::cast(int(Graphic3d_ArrayFlags_AttribsDeinterleaved));
347 ····m.attr("Graphic3d_ArrayFlags_IndexesMutable")·=·py::cast(int(Graphic3d_ArrayFlags_IndexesMutable));299 ····m.attr("Graphic3d_ArrayFlags_IndexesMutable")·=·py::cast(int(Graphic3d_ArrayFlags_IndexesMutable));
348 ····py::enum_<Graphic3d_ShaderFlags>(m,·"Graphic3d_ShaderFlags",R"#(Standard·GLSL·program·combination·bits.)#") 
349 ········.value("Graphic3d_ShaderFlags_VertColor",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_VertColor) 
350 ········.value("Graphic3d_ShaderFlags_TextureRGB",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_TextureRGB) 
351 ········.value("Graphic3d_ShaderFlags_TextureEnv",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_TextureEnv) 
352 ········.value("Graphic3d_ShaderFlags_TextureNormal",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_TextureNormal) 
353 ········.value("Graphic3d_ShaderFlags_PointSimple",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_PointSimple) 
354 ········.value("Graphic3d_ShaderFlags_PointSprite",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_PointSprite) 
355 ········.value("Graphic3d_ShaderFlags_PointSpriteA",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_PointSpriteA) 
356 ········.value("Graphic3d_ShaderFlags_StippleLine",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_StippleLine) 
357 ········.value("Graphic3d_ShaderFlags_ClipPlanes1",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_ClipPlanes1) 
358 ········.value("Graphic3d_ShaderFlags_ClipPlanes2",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_ClipPlanes2) 
359 ········.value("Graphic3d_ShaderFlags_ClipPlanesN",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_ClipPlanesN) 
360 ········.value("Graphic3d_ShaderFlags_ClipChains",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_ClipChains) 
361 ········.value("Graphic3d_ShaderFlags_MeshEdges",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_MeshEdges) 
362 ········.value("Graphic3d_ShaderFlags_AlphaTest",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_AlphaTest) 
363 ········.value("Graphic3d_ShaderFlags_WriteOit",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_WriteOit) 
364 ········.value("Graphic3d_ShaderFlags_OitDepthPeeling",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_OitDepthPeeling) 
365 ········.value("Graphic3d_ShaderFlags_NB",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_NB) 
366 ········.value("Graphic3d_ShaderFlags_IsPoint",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_IsPoint) 
367 ········.value("Graphic3d_ShaderFlags_HasTextures",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_HasTextures) 
368 ········.value("Graphic3d_ShaderFlags_NeedsGeomShader",Graphic3d_ShaderFlags::Graphic3d_ShaderFlags_NeedsGeomShader).export_values(); 
369 ····py::enum_<Graphic3d_NameOfTexture1D>(m,·"Graphic3d_NameOfTexture1D",R"#(Types·of·standard·textures.)#") 
370 ········.value("Graphic3d_NOT_1D_ELEVATION",Graphic3d_NameOfTexture1D::Graphic3d_NOT_1D_ELEVATION) 
371 ········.value("Graphic3d_NOT_1D_UNKNOWN",Graphic3d_NameOfTexture1D::Graphic3d_NOT_1D_UNKNOWN).export_values();300 ····py::enum_<Graphic3d_FrameStatsCounter>(m,·"Graphic3d_FrameStatsCounter",R"#(Stats·counter.)#")
 301 ········.value("Graphic3d_FrameStatsCounter_NbLayers",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbLayers)
 302 ········.value("Graphic3d_FrameStatsCounter_NbStructs",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbStructs)
 303 ········.value("Graphic3d_FrameStatsCounter_EstimatedBytesGeom",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_EstimatedBytesGeom)
 304 ········.value("Graphic3d_FrameStatsCounter_EstimatedBytesFbos",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_EstimatedBytesFbos)
 305 ········.value("Graphic3d_FrameStatsCounter_EstimatedBytesTextures",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_EstimatedBytesTextures)
 306 ········.value("Graphic3d_FrameStatsCounter_NbLayersNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbLayersNotCulled)
 307 ········.value("Graphic3d_FrameStatsCounter_NbStructsNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbStructsNotCulled)
 308 ········.value("Graphic3d_FrameStatsCounter_NbGroupsNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbGroupsNotCulled)
 309 ········.value("Graphic3d_FrameStatsCounter_NbElemsNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsNotCulled)
 310 ········.value("Graphic3d_FrameStatsCounter_NbElemsFillNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsFillNotCulled)
 311 ········.value("Graphic3d_FrameStatsCounter_NbElemsLineNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsLineNotCulled)
 312 ········.value("Graphic3d_FrameStatsCounter_NbElemsPointNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsPointNotCulled)
 313 ········.value("Graphic3d_FrameStatsCounter_NbElemsTextNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsTextNotCulled)
 314 ········.value("Graphic3d_FrameStatsCounter_NbTrianglesNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbTrianglesNotCulled)
 315 ········.value("Graphic3d_FrameStatsCounter_NbLinesNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbLinesNotCulled)
 316 ········.value("Graphic3d_FrameStatsCounter_NbPointsNotCulled",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbPointsNotCulled)
 317 ········.value("Graphic3d_FrameStatsCounter_NbLayersImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbLayersImmediate)
 318 ········.value("Graphic3d_FrameStatsCounter_NbStructsImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbStructsImmediate)
 319 ········.value("Graphic3d_FrameStatsCounter_NbGroupsImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbGroupsImmediate)
 320 ········.value("Graphic3d_FrameStatsCounter_NbElemsImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsImmediate)
 321 ········.value("Graphic3d_FrameStatsCounter_NbElemsFillImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsFillImmediate)
 322 ········.value("Graphic3d_FrameStatsCounter_NbElemsLineImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsLineImmediate)
 323 ········.value("Graphic3d_FrameStatsCounter_NbElemsPointImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsPointImmediate)
 324 ········.value("Graphic3d_FrameStatsCounter_NbElemsTextImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbElemsTextImmediate)
 325 ········.value("Graphic3d_FrameStatsCounter_NbTrianglesImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbTrianglesImmediate)
 326 ········.value("Graphic3d_FrameStatsCounter_NbLinesImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbLinesImmediate)
 327 ········.value("Graphic3d_FrameStatsCounter_NbPointsImmediate",Graphic3d_FrameStatsCounter::Graphic3d_FrameStatsCounter_NbPointsImmediate).export_values();
 328 ····m.attr("Graphic3d_FrameStatsCounter_NB")·=·py::cast(int(Graphic3d_FrameStatsCounter_NB));
 329 ····m.attr("Graphic3d_FrameStatsCounter_SCENE_LOWER")·=·py::cast(int(Graphic3d_FrameStatsCounter_SCENE_LOWER));
 330 ····m.attr("Graphic3d_FrameStatsCounter_SCENE_UPPER")·=·py::cast(int(Graphic3d_FrameStatsCounter_SCENE_UPPER));
 331 ····m.attr("Graphic3d_FrameStatsCounter_RENDERED_LOWER")·=·py::cast(int(Graphic3d_FrameStatsCounter_RENDERED_LOWER));
 332 ····m.attr("Graphic3d_FrameStatsCounter_RENDERED_UPPER")·=·py::cast(int(Graphic3d_FrameStatsCounter_RENDERED_UPPER));
Max diff block lines reached; 72925/87814 bytes (83.04%) of diff not shown.
⊟
4.03 KB
./usr/share/libocp/OCP/Graphic3d_tmpl.hxx
Ordering differences only
    
Offset 199, 57 lines modifiedOffset 199, 57 lines modified
  
199 //·user-defined·pre199 //·user-defined·pre
200 #include·"OCP_specific.inc"200 #include·"OCP_specific.inc"
  
201 //·Class·template·handling·functions201 //·Class·template·handling·functions
  
202 template·<typename·T>202 template·<typename·T>
203 void·preregister_template_MatrixType(py::object·&m,·const·char·*name){203 void·preregister_template_Graphic3d_UniformValueTypeID(py::object·&m,·const·char·*name){
204 ····py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>(m,name,R"#()#");204 ····py::class_<Graphic3d_UniformValueTypeID<T>·,·shared_ptr<Graphic3d_UniformValueTypeID<T>>·>(m,name,R"#(Generates·unique·type·identifier·for·variable·value.)#");
205 }205 }
  
206 template·<typename·T>206 template·<typename·T>
207 void·register_template_MatrixType(py::object·&m,·const·char·*name){207 void·register_template_Graphic3d_UniformValueTypeID(py::object·&m,·const·char·*name){
208 ····static_cast<py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>>(m.attr(name))208 ····static_cast<py::class_<Graphic3d_UniformValueTypeID<T>·,·shared_ptr<Graphic3d_UniformValueTypeID<T>>·>>(m.attr(name))
209 ····;209 ····;
210 };210 };
  
211 template·<typename·T>211 template·<typename·T>
212 void·preregister_template_VectorType(py::object·&m,·const·char·*name){212 void·preregister_template_Graphic3d_UniformValue(py::object·&m,·const·char·*name){
213 ····py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>(m,name,R"#()#");213 ····py::class_<Graphic3d_UniformValue<T>·,·shared_ptr<Graphic3d_UniformValue<T>>·,·Graphic3d_ValueInterface·>(m,name,R"#(Describes·specific·value·of·custom·uniform·variable.)#");
214 }214 }
  
215 template·<typename·T>215 template·<typename·T>
216 void·register_template_VectorType(py::object·&m,·const·char·*name){216 void·register_template_Graphic3d_UniformValue(py::object·&m,·const·char·*name){
217 ····static_cast<py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>>(m.attr(name))217 ····static_cast<py::class_<Graphic3d_UniformValue<T>·,·shared_ptr<Graphic3d_UniformValue<T>>·,·Graphic3d_ValueInterface·>>(m.attr(name))
 218 ········.def(py::init<··const·T·&·>()·,py::arg("theValue")·)
 219 ········.def("TypeID",
 220 ·············(Standard_Size·(Graphic3d_UniformValue<T>::*)()·const)·&Graphic3d_UniformValue<T>::TypeID,
 221 ·············R"#(Returns·unique·identifier·of·value·type.)#"·)
218 ····;222 ····;
219 };223 };
  
220 template·<typename·T>224 template·<typename·T>
221 void·preregister_template_Graphic3d_UniformValueTypeID(py::object·&m,·const·char·*name){225 void·preregister_template_MatrixType(py::object·&m,·const·char·*name){
222 ····py::class_<Graphic3d_UniformValueTypeID<T>·,·shared_ptr<Graphic3d_UniformValueTypeID<T>>·>(m,name,R"#(Generates·unique·type·identifier·for·variable·value.)#");226 ····py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>(m,name,R"#()#");
223 }227 }
  
224 template·<typename·T>228 template·<typename·T>
225 void·register_template_Graphic3d_UniformValueTypeID(py::object·&m,·const·char·*name){229 void·register_template_MatrixType(py::object·&m,·const·char·*name){
226 ····static_cast<py::class_<Graphic3d_UniformValueTypeID<T>·,·shared_ptr<Graphic3d_UniformValueTypeID<T>>·>>(m.attr(name))230 ····static_cast<py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>>(m.attr(name))
227 ····;231 ····;
228 };232 };
  
229 template·<typename·T>233 template·<typename·T>
230 void·preregister_template_Graphic3d_UniformValue(py::object·&m,·const·char·*name){234 void·preregister_template_VectorType(py::object·&m,·const·char·*name){
231 ····py::class_<Graphic3d_UniformValue<T>·,·shared_ptr<Graphic3d_UniformValue<T>>·,·Graphic3d_ValueInterface·>(m,name,R"#(Describes·specific·value·of·custom·uniform·variable.)#");235 ····py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>(m,name,R"#()#");
232 }236 }
  
233 template·<typename·T>237 template·<typename·T>
234 void·register_template_Graphic3d_UniformValue(py::object·&m,·const·char·*name){238 void·register_template_VectorType(py::object·&m,·const·char·*name){
 239 ····static_cast<py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>>(m.attr(name))
235 ····static_cast<py::class_<Graphic3d_UniformValue<T>·,·shared_ptr<Graphic3d_UniformValue<T>>·,·Graphic3d_ValueInterface·>>(m.attr(name)) 
236 ········.def(py::init<··const·T·&·>()·,py::arg("theValue")·) 
237 ········.def("TypeID", 
238 ·············(Standard_Size·(Graphic3d_UniformValue<T>::*)()·const)·&Graphic3d_UniformValue<T>::TypeID, 
239 ·············R"#(Returns·unique·identifier·of·value·type.)#"·) 
240 ····;240 ····;
241 };241 };
  
  
242 //·user-defined·post242 //·user-defined·post
  
⊟
1.93 KB
./usr/share/libocp/OCP/HatchGen_pre.cpp
Ordering differences only
    
Offset 47, 25 lines modifiedOffset 47, 25 lines modified
47 py::module·m·=·main_module.def_submodule("HatchGen",·R"#()#");47 py::module·m·=·main_module.def_submodule("HatchGen",·R"#()#");
  
48 //·add·namespaces·as·submodules48 //·add·namespaces·as·submodules
  
49 //·user-defined·inclusion·per·module·in·the·body49 //·user-defined·inclusion·per·module·in·the·body
  
50 //·enums50 //·enums
51 ····py::enum_<HatchGen_IntersectionType>(m,·"HatchGen_IntersectionType",R"#(Intersection·type·between·the·hatching·and·the·element.)#") 
52 ········.value("HatchGen_TRUE",HatchGen_IntersectionType::HatchGen_TRUE) 
53 ········.value("HatchGen_TOUCH",HatchGen_IntersectionType::HatchGen_TOUCH) 
54 ········.value("HatchGen_TANGENT",HatchGen_IntersectionType::HatchGen_TANGENT) 
55 ········.value("HatchGen_UNDETERMINED",HatchGen_IntersectionType::HatchGen_UNDETERMINED).export_values(); 
56 ····py::enum_<HatchGen_ErrorStatus>(m,·"HatchGen_ErrorStatus",R"#(Error·status.)#")51 ····py::enum_<HatchGen_ErrorStatus>(m,·"HatchGen_ErrorStatus",R"#(Error·status.)#")
57 ········.value("HatchGen_NoProblem",HatchGen_ErrorStatus::HatchGen_NoProblem)52 ········.value("HatchGen_NoProblem",HatchGen_ErrorStatus::HatchGen_NoProblem)
58 ········.value("HatchGen_TrimFailure",HatchGen_ErrorStatus::HatchGen_TrimFailure)53 ········.value("HatchGen_TrimFailure",HatchGen_ErrorStatus::HatchGen_TrimFailure)
59 ········.value("HatchGen_TransitionFailure",HatchGen_ErrorStatus::HatchGen_TransitionFailure)54 ········.value("HatchGen_TransitionFailure",HatchGen_ErrorStatus::HatchGen_TransitionFailure)
60 ········.value("HatchGen_IncoherentParity",HatchGen_ErrorStatus::HatchGen_IncoherentParity)55 ········.value("HatchGen_IncoherentParity",HatchGen_ErrorStatus::HatchGen_IncoherentParity)
61 ········.value("HatchGen_IncompatibleStates",HatchGen_ErrorStatus::HatchGen_IncompatibleStates).export_values();56 ········.value("HatchGen_IncompatibleStates",HatchGen_ErrorStatus::HatchGen_IncompatibleStates).export_values();
 57 ····py::enum_<HatchGen_IntersectionType>(m,·"HatchGen_IntersectionType",R"#(Intersection·type·between·the·hatching·and·the·element.)#")
 58 ········.value("HatchGen_TRUE",HatchGen_IntersectionType::HatchGen_TRUE)
 59 ········.value("HatchGen_TOUCH",HatchGen_IntersectionType::HatchGen_TOUCH)
 60 ········.value("HatchGen_TANGENT",HatchGen_IntersectionType::HatchGen_TANGENT)
 61 ········.value("HatchGen_UNDETERMINED",HatchGen_IntersectionType::HatchGen_UNDETERMINED).export_values();
  
62 //Python·trampoline·classes62 //Python·trampoline·classes
63 ····class·Py_HatchGen_IntersectionPoint·:·public·HatchGen_IntersectionPoint{63 ····class·Py_HatchGen_IntersectionPoint·:·public·HatchGen_IntersectionPoint{
64 ····public:64 ····public:
65 ········using·HatchGen_IntersectionPoint::HatchGen_IntersectionPoint;65 ········using·HatchGen_IntersectionPoint::HatchGen_IntersectionPoint;
  
  
⊟
3.01 KB
./usr/share/libocp/OCP/IFSelect_pre.cpp
Ordering differences only
    
Offset 383, 26 lines modifiedOffset 383, 26 lines modified
383 ········.value("IFSelect_ShortByItem",IFSelect_PrintCount::IFSelect_ShortByItem)383 ········.value("IFSelect_ShortByItem",IFSelect_PrintCount::IFSelect_ShortByItem)
384 ········.value("IFSelect_ListByItem",IFSelect_PrintCount::IFSelect_ListByItem)384 ········.value("IFSelect_ListByItem",IFSelect_PrintCount::IFSelect_ListByItem)
385 ········.value("IFSelect_EntitiesByItem",IFSelect_PrintCount::IFSelect_EntitiesByItem)385 ········.value("IFSelect_EntitiesByItem",IFSelect_PrintCount::IFSelect_EntitiesByItem)
386 ········.value("IFSelect_CountSummary",IFSelect_PrintCount::IFSelect_CountSummary)386 ········.value("IFSelect_CountSummary",IFSelect_PrintCount::IFSelect_CountSummary)
387 ········.value("IFSelect_GeneralInfo",IFSelect_PrintCount::IFSelect_GeneralInfo)387 ········.value("IFSelect_GeneralInfo",IFSelect_PrintCount::IFSelect_GeneralInfo)
388 ········.value("IFSelect_Mapping",IFSelect_PrintCount::IFSelect_Mapping)388 ········.value("IFSelect_Mapping",IFSelect_PrintCount::IFSelect_Mapping)
389 ········.value("IFSelect_ResultCount",IFSelect_PrintCount::IFSelect_ResultCount).export_values();389 ········.value("IFSelect_ResultCount",IFSelect_PrintCount::IFSelect_ResultCount).export_values();
390 ····py::enum_<IFSelect_RemainMode>(m,·"IFSelect_RemainMode",R"#()#") 
391 ········.value("IFSelect_RemainForget",IFSelect_RemainMode::IFSelect_RemainForget) 
392 ········.value("IFSelect_RemainCompute",IFSelect_RemainMode::IFSelect_RemainCompute) 
393 ········.value("IFSelect_RemainDisplay",IFSelect_RemainMode::IFSelect_RemainDisplay) 
394 ········.value("IFSelect_RemainUndo",IFSelect_RemainMode::IFSelect_RemainUndo).export_values(); 
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)#")390 ····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)391 ········.value("IFSelect_Optional",IFSelect_EditValue::IFSelect_Optional)
397 ········.value("IFSelect_Editable",IFSelect_EditValue::IFSelect_Editable)392 ········.value("IFSelect_Editable",IFSelect_EditValue::IFSelect_Editable)
398 ········.value("IFSelect_EditProtected",IFSelect_EditValue::IFSelect_EditProtected)393 ········.value("IFSelect_EditProtected",IFSelect_EditValue::IFSelect_EditProtected)
399 ········.value("IFSelect_EditComputed",IFSelect_EditValue::IFSelect_EditComputed)394 ········.value("IFSelect_EditComputed",IFSelect_EditValue::IFSelect_EditComputed)
400 ········.value("IFSelect_EditRead",IFSelect_EditValue::IFSelect_EditRead)395 ········.value("IFSelect_EditRead",IFSelect_EditValue::IFSelect_EditRead)
401 ········.value("IFSelect_EditDynamic",IFSelect_EditValue::IFSelect_EditDynamic).export_values();396 ········.value("IFSelect_EditDynamic",IFSelect_EditValue::IFSelect_EditDynamic).export_values();
 397 ····py::enum_<IFSelect_RemainMode>(m,·"IFSelect_RemainMode",R"#()#")
 398 ········.value("IFSelect_RemainForget",IFSelect_RemainMode::IFSelect_RemainForget)
 399 ········.value("IFSelect_RemainCompute",IFSelect_RemainMode::IFSelect_RemainCompute)
 400 ········.value("IFSelect_RemainDisplay",IFSelect_RemainMode::IFSelect_RemainDisplay)
 401 ········.value("IFSelect_RemainUndo",IFSelect_RemainMode::IFSelect_RemainUndo).export_values();
402 ····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)#")402 ····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)#")
403 ········.value("IFSelect_FailOnly",IFSelect_PrintFail::IFSelect_FailOnly)403 ········.value("IFSelect_FailOnly",IFSelect_PrintFail::IFSelect_FailOnly)
404 ········.value("IFSelect_FailAndWarn",IFSelect_PrintFail::IFSelect_FailAndWarn).export_values();404 ········.value("IFSelect_FailAndWarn",IFSelect_PrintFail::IFSelect_FailAndWarn).export_values();
  
405 //Python·trampoline·classes405 //Python·trampoline·classes
406 ····class·Py_IFSelect_Activator·:·public·IFSelect_Activator{406 ····class·Py_IFSelect_Activator·:·public·IFSelect_Activator{
407 ····public:407 ····public:
⊟
5.44 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_Status>(m,·"IGESData_Status",R"#()#")
 211 ········.value("IGESData_EntityOK",IGESData_Status::IGESData_EntityOK)
 212 ········.value("IGESData_EntityError",IGESData_Status::IGESData_EntityError)
 213 ········.value("IGESData_ReferenceError",IGESData_Status::IGESData_ReferenceError)
 214 ········.value("IGESData_TypeError",IGESData_Status::IGESData_TypeError).export_values();
 215 ····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.)#")
 216 ········.value("IGESData_DefVoid",IGESData_DefType::IGESData_DefVoid)
 217 ········.value("IGESData_DefValue",IGESData_DefType::IGESData_DefValue)
 218 ········.value("IGESData_DefReference",IGESData_DefType::IGESData_DefReference)
 219 ········.value("IGESData_DefAny",IGESData_DefType::IGESData_DefAny)
 220 ········.value("IGESData_ErrorVal",IGESData_DefType::IGESData_ErrorVal)
 221 ········.value("IGESData_ErrorRef",IGESData_DefType::IGESData_ErrorRef).export_values();
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·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.)#")222 ····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.)#")
211 ········.value("IGESData_DefNone",IGESData_DefList::IGESData_DefNone)223 ········.value("IGESData_DefNone",IGESData_DefList::IGESData_DefNone)
212 ········.value("IGESData_DefOne",IGESData_DefList::IGESData_DefOne)224 ········.value("IGESData_DefOne",IGESData_DefList::IGESData_DefOne)
213 ········.value("IGESData_DefSeveral",IGESData_DefList::IGESData_DefSeveral)225 ········.value("IGESData_DefSeveral",IGESData_DefList::IGESData_DefSeveral)
214 ········.value("IGESData_ErrorOne",IGESData_DefList::IGESData_ErrorOne)226 ········.value("IGESData_ErrorOne",IGESData_DefList::IGESData_ErrorOne)
215 ········.value("IGESData_ErrorSeveral",IGESData_DefList::IGESData_ErrorSeveral).export_values();227 ········.value("IGESData_ErrorSeveral",IGESData_DefList::IGESData_ErrorSeveral).export_values();
216 ····py::enum_<IGESData_ReadStage>(m,·"IGESData_ReadStage",R"#(gives·successive·stages·of·reading·an·entity·(see·ParamReader))#")228 ····py::enum_<IGESData_ReadStage>(m,·"IGESData_ReadStage",R"#(gives·successive·stages·of·reading·an·entity·(see·ParamReader))#")
217 ········.value("IGESData_ReadDir",IGESData_ReadStage::IGESData_ReadDir)229 ········.value("IGESData_ReadDir",IGESData_ReadStage::IGESData_ReadDir)
218 ········.value("IGESData_ReadOwn",IGESData_ReadStage::IGESData_ReadOwn)230 ········.value("IGESData_ReadOwn",IGESData_ReadStage::IGESData_ReadOwn)
219 ········.value("IGESData_ReadAssocs",IGESData_ReadStage::IGESData_ReadAssocs)231 ········.value("IGESData_ReadAssocs",IGESData_ReadStage::IGESData_ReadAssocs)
220 ········.value("IGESData_ReadProps",IGESData_ReadStage::IGESData_ReadProps)232 ········.value("IGESData_ReadProps",IGESData_ReadStage::IGESData_ReadProps)
221 ········.value("IGESData_ReadEnd",IGESData_ReadStage::IGESData_ReadEnd).export_values();233 ········.value("IGESData_ReadEnd",IGESData_ReadStage::IGESData_ReadEnd).export_values();
222 ····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.)#") 
223 ········.value("IGESData_DefVoid",IGESData_DefType::IGESData_DefVoid) 
224 ········.value("IGESData_DefValue",IGESData_DefType::IGESData_DefValue) 
225 ········.value("IGESData_DefReference",IGESData_DefType::IGESData_DefReference) 
226 ········.value("IGESData_DefAny",IGESData_DefType::IGESData_DefAny) 
227 ········.value("IGESData_ErrorVal",IGESData_DefType::IGESData_ErrorVal) 
228 ········.value("IGESData_ErrorRef",IGESData_DefType::IGESData_ErrorRef).export_values(); 
229 ····py::enum_<IGESData_Status>(m,·"IGESData_Status",R"#()#") 
230 ········.value("IGESData_EntityOK",IGESData_Status::IGESData_EntityOK) 
231 ········.value("IGESData_EntityError",IGESData_Status::IGESData_EntityError) 
232 ········.value("IGESData_ReferenceError",IGESData_Status::IGESData_ReferenceError) 
233 ········.value("IGESData_TypeError",IGESData_Status::IGESData_TypeError).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;
  
  
⊟
3.64 KB
./usr/share/libocp/OCP/Image_pre.cpp
Ordering differences only
    
Offset 48, 21 lines modifiedOffset 48, 14 lines modified
  
48 //·add·namespaces·as·submodules48 //·add·namespaces·as·submodules
49 m.def_submodule("std");49 m.def_submodule("std");
  
50 //·user-defined·inclusion·per·module·in·the·body50 //·user-defined·inclusion·per·module·in·the·body
  
51 //·enums51 //·enums
52 ····py::enum_<Image_CompressedFormat>(m,·"Image_CompressedFormat",R"#(List·of·compressed·pixel·formats·natively·supported·by·various·graphics·hardware·(e.g.·for·efficient·decoding·on-the-fly).·It·is·defined·as·extension·of·Image_Format.)#") 
53 ········.value("Image_CompressedFormat_UNKNOWN",Image_CompressedFormat::Image_CompressedFormat_UNKNOWN) 
54 ········.value("Image_CompressedFormat_RGB_S3TC_DXT1",Image_CompressedFormat::Image_CompressedFormat_RGB_S3TC_DXT1) 
55 ········.value("Image_CompressedFormat_RGBA_S3TC_DXT1",Image_CompressedFormat::Image_CompressedFormat_RGBA_S3TC_DXT1) 
56 ········.value("Image_CompressedFormat_RGBA_S3TC_DXT3",Image_CompressedFormat::Image_CompressedFormat_RGBA_S3TC_DXT3) 
57 ········.value("Image_CompressedFormat_RGBA_S3TC_DXT5",Image_CompressedFormat::Image_CompressedFormat_RGBA_S3TC_DXT5).export_values(); 
58 ····m.attr("Image_CompressedFormat_NB")·=·py::cast(int(Image_CompressedFormat_NB)); 
59 ····py::enum_<Image_Format>(m,·"Image_Format",R"#(This·enumeration·defines·packed·image·plane·formats)#")52 ····py::enum_<Image_Format>(m,·"Image_Format",R"#(This·enumeration·defines·packed·image·plane·formats)#")
60 ········.value("Image_Format_UNKNOWN",Image_Format::Image_Format_UNKNOWN)53 ········.value("Image_Format_UNKNOWN",Image_Format::Image_Format_UNKNOWN)
61 ········.value("Image_Format_Gray",Image_Format::Image_Format_Gray)54 ········.value("Image_Format_Gray",Image_Format::Image_Format_Gray)
62 ········.value("Image_Format_Alpha",Image_Format::Image_Format_Alpha)55 ········.value("Image_Format_Alpha",Image_Format::Image_Format_Alpha)
63 ········.value("Image_Format_RGB",Image_Format::Image_Format_RGB)56 ········.value("Image_Format_RGB",Image_Format::Image_Format_RGB)
64 ········.value("Image_Format_BGR",Image_Format::Image_Format_BGR)57 ········.value("Image_Format_BGR",Image_Format::Image_Format_BGR)
65 ········.value("Image_Format_RGB32",Image_Format::Image_Format_RGB32)58 ········.value("Image_Format_RGB32",Image_Format::Image_Format_RGB32)
Offset 77, 14 lines modifiedOffset 70, 21 lines modified
77 ········.value("Image_Format_RGBAF",Image_Format::Image_Format_RGBAF)70 ········.value("Image_Format_RGBAF",Image_Format::Image_Format_RGBAF)
78 ········.value("Image_Format_BGRAF",Image_Format::Image_Format_BGRAF)71 ········.value("Image_Format_BGRAF",Image_Format::Image_Format_BGRAF)
79 ········.value("Image_Format_GrayF_half",Image_Format::Image_Format_GrayF_half)72 ········.value("Image_Format_GrayF_half",Image_Format::Image_Format_GrayF_half)
80 ········.value("Image_Format_RGF_half",Image_Format::Image_Format_RGF_half)73 ········.value("Image_Format_RGF_half",Image_Format::Image_Format_RGF_half)
81 ········.value("Image_Format_RGBAF_half",Image_Format::Image_Format_RGBAF_half)74 ········.value("Image_Format_RGBAF_half",Image_Format::Image_Format_RGBAF_half)
82 ········.value("Image_Format_Gray16",Image_Format::Image_Format_Gray16).export_values();75 ········.value("Image_Format_Gray16",Image_Format::Image_Format_Gray16).export_values();
83 ····m.attr("Image_Format_NB")·=·py::cast(int(Image_Format_NB));76 ····m.attr("Image_Format_NB")·=·py::cast(int(Image_Format_NB));
 77 ····py::enum_<Image_CompressedFormat>(m,·"Image_CompressedFormat",R"#(List·of·compressed·pixel·formats·natively·supported·by·various·graphics·hardware·(e.g.·for·efficient·decoding·on-the-fly).·It·is·defined·as·extension·of·Image_Format.)#")
 78 ········.value("Image_CompressedFormat_UNKNOWN",Image_CompressedFormat::Image_CompressedFormat_UNKNOWN)
 79 ········.value("Image_CompressedFormat_RGB_S3TC_DXT1",Image_CompressedFormat::Image_CompressedFormat_RGB_S3TC_DXT1)
 80 ········.value("Image_CompressedFormat_RGBA_S3TC_DXT1",Image_CompressedFormat::Image_CompressedFormat_RGBA_S3TC_DXT1)
 81 ········.value("Image_CompressedFormat_RGBA_S3TC_DXT3",Image_CompressedFormat::Image_CompressedFormat_RGBA_S3TC_DXT3)
 82 ········.value("Image_CompressedFormat_RGBA_S3TC_DXT5",Image_CompressedFormat::Image_CompressedFormat_RGBA_S3TC_DXT5).export_values();
 83 ····m.attr("Image_CompressedFormat_NB")·=·py::cast(int(Image_CompressedFormat_NB));
  
84 //Python·trampoline·classes84 //Python·trampoline·classes
  
85 //·pre-register·typdefs+classes·(topologically·sorted)85 //·pre-register·typdefs+classes·(topologically·sorted)
86 ····py::class_<Image_ColorBGR·,·shared_ptr<Image_ColorBGR>··>(m,"Image_ColorBGR",R"#(POD·structure·for·packed·BGR·color·value·(3·bytes))#");86 ····py::class_<Image_ColorBGR·,·shared_ptr<Image_ColorBGR>··>(m,"Image_ColorBGR",R"#(POD·structure·for·packed·BGR·color·value·(3·bytes))#");
87 ····py::class_<Image_ColorBGR32·,·shared_ptr<Image_ColorBGR32>··>(m,"Image_ColorBGR32",R"#(POD·structure·for·packed·BGR·color·value·(4·bytes·with·extra·byte·for·alignment))#");87 ····py::class_<Image_ColorBGR32·,·shared_ptr<Image_ColorBGR32>··>(m,"Image_ColorBGR32",R"#(POD·structure·for·packed·BGR·color·value·(4·bytes·with·extra·byte·for·alignment))#");
88 ····py::class_<Image_ColorBGRA·,·shared_ptr<Image_ColorBGRA>··>(m,"Image_ColorBGRA",R"#(POD·structure·for·packed·BGRA·color·value·(4·bytes))#");88 ····py::class_<Image_ColorBGRA·,·shared_ptr<Image_ColorBGRA>··>(m,"Image_ColorBGRA",R"#(POD·structure·for·packed·BGRA·color·value·(4·bytes))#");
⊟
2.5 KB
./usr/share/libocp/OCP/IntPatch_pre.cpp
Ordering differences only
    
Offset 128, 30 lines modifiedOffset 128, 30 lines modified
128 py::module·m·=·main_module.def_submodule("IntPatch",·R"#()#");128 py::module·m·=·main_module.def_submodule("IntPatch",·R"#()#");
  
129 //·add·namespaces·as·submodules129 //·add·namespaces·as·submodules
  
130 //·user-defined·inclusion·per·module·in·the·body130 //·user-defined·inclusion·per·module·in·the·body
  
131 //·enums131 //·enums
132 ····py::enum_<IntPatch_SpecPntType>(m,·"IntPatch_SpecPntType",R"#(This·enum·describe·the·different·kinds·of·special·(singular)·points·of·Surface-Surface·intersection·algorithm.·Such·as·pole·of·sphere,·apex·of·cone,·point·on·U-·or·V-seam·etc.)#") 
133 ········.value("IntPatch_SPntNone",IntPatch_SpecPntType::IntPatch_SPntNone) 
134 ········.value("IntPatch_SPntSeamU",IntPatch_SpecPntType::IntPatch_SPntSeamU) 
135 ········.value("IntPatch_SPntSeamV",IntPatch_SpecPntType::IntPatch_SPntSeamV) 
136 ········.value("IntPatch_SPntSeamUV",IntPatch_SpecPntType::IntPatch_SPntSeamUV) 
137 ········.value("IntPatch_SPntPoleSeamU",IntPatch_SpecPntType::IntPatch_SPntPoleSeamU) 
138 ········.value("IntPatch_SPntPole",IntPatch_SpecPntType::IntPatch_SPntPole).export_values(); 
139 ····py::enum_<IntPatch_IType>(m,·"IntPatch_IType",R"#()#")132 ····py::enum_<IntPatch_IType>(m,·"IntPatch_IType",R"#()#")
140 ········.value("IntPatch_Lin",IntPatch_IType::IntPatch_Lin)133 ········.value("IntPatch_Lin",IntPatch_IType::IntPatch_Lin)
141 ········.value("IntPatch_Circle",IntPatch_IType::IntPatch_Circle)134 ········.value("IntPatch_Circle",IntPatch_IType::IntPatch_Circle)
142 ········.value("IntPatch_Ellipse",IntPatch_IType::IntPatch_Ellipse)135 ········.value("IntPatch_Ellipse",IntPatch_IType::IntPatch_Ellipse)
143 ········.value("IntPatch_Parabola",IntPatch_IType::IntPatch_Parabola)136 ········.value("IntPatch_Parabola",IntPatch_IType::IntPatch_Parabola)
144 ········.value("IntPatch_Hyperbola",IntPatch_IType::IntPatch_Hyperbola)137 ········.value("IntPatch_Hyperbola",IntPatch_IType::IntPatch_Hyperbola)
145 ········.value("IntPatch_Analytic",IntPatch_IType::IntPatch_Analytic)138 ········.value("IntPatch_Analytic",IntPatch_IType::IntPatch_Analytic)
146 ········.value("IntPatch_Walking",IntPatch_IType::IntPatch_Walking)139 ········.value("IntPatch_Walking",IntPatch_IType::IntPatch_Walking)
147 ········.value("IntPatch_Restriction",IntPatch_IType::IntPatch_Restriction).export_values();140 ········.value("IntPatch_Restriction",IntPatch_IType::IntPatch_Restriction).export_values();
 141 ····py::enum_<IntPatch_SpecPntType>(m,·"IntPatch_SpecPntType",R"#(This·enum·describe·the·different·kinds·of·special·(singular)·points·of·Surface-Surface·intersection·algorithm.·Such·as·pole·of·sphere,·apex·of·cone,·point·on·U-·or·V-seam·etc.)#")
 142 ········.value("IntPatch_SPntNone",IntPatch_SpecPntType::IntPatch_SPntNone)
 143 ········.value("IntPatch_SPntSeamU",IntPatch_SpecPntType::IntPatch_SPntSeamU)
 144 ········.value("IntPatch_SPntSeamV",IntPatch_SpecPntType::IntPatch_SPntSeamV)
 145 ········.value("IntPatch_SPntSeamUV",IntPatch_SpecPntType::IntPatch_SPntSeamUV)
 146 ········.value("IntPatch_SPntPoleSeamU",IntPatch_SpecPntType::IntPatch_SPntPoleSeamU)
 147 ········.value("IntPatch_SPntPole",IntPatch_SpecPntType::IntPatch_SPntPole).export_values();
  
148 //Python·trampoline·classes148 //Python·trampoline·classes
149 ····class·Py_IntPatch_Polygo·:·public·IntPatch_Polygo{149 ····class·Py_IntPatch_Polygo·:·public·IntPatch_Polygo{
150 ····public:150 ····public:
151 ········using·IntPatch_Polygo::IntPatch_Polygo;151 ········using·IntPatch_Polygo::IntPatch_Polygo;
  
  
⊟
2.28 KB
./usr/share/libocp/OCP/IntRes2d_pre.cpp
Ordering differences only
    
Offset 49, 22 lines modifiedOffset 49, 22 lines modified
  
49 //·enums49 //·enums
50 ····py::enum_<IntRes2d_TypeTrans>(m,·"IntRes2d_TypeTrans",R"#()#")50 ····py::enum_<IntRes2d_TypeTrans>(m,·"IntRes2d_TypeTrans",R"#()#")
51 ········.value("IntRes2d_In",IntRes2d_TypeTrans::IntRes2d_In)51 ········.value("IntRes2d_In",IntRes2d_TypeTrans::IntRes2d_In)
52 ········.value("IntRes2d_Out",IntRes2d_TypeTrans::IntRes2d_Out)52 ········.value("IntRes2d_Out",IntRes2d_TypeTrans::IntRes2d_Out)
53 ········.value("IntRes2d_Touch",IntRes2d_TypeTrans::IntRes2d_Touch)53 ········.value("IntRes2d_Touch",IntRes2d_TypeTrans::IntRes2d_Touch)
54 ········.value("IntRes2d_Undecided",IntRes2d_TypeTrans::IntRes2d_Undecided).export_values();54 ········.value("IntRes2d_Undecided",IntRes2d_TypeTrans::IntRes2d_Undecided).export_values();
55 ····py::enum_<IntRes2d_Position>(m,·"IntRes2d_Position",R"#()#") 
56 ········.value("IntRes2d_Head",IntRes2d_Position::IntRes2d_Head) 
57 ········.value("IntRes2d_Middle",IntRes2d_Position::IntRes2d_Middle) 
58 ········.value("IntRes2d_End",IntRes2d_Position::IntRes2d_End).export_values(); 
59 ····py::enum_<IntRes2d_Situation>(m,·"IntRes2d_Situation",R"#()#")55 ····py::enum_<IntRes2d_Situation>(m,·"IntRes2d_Situation",R"#()#")
60 ········.value("IntRes2d_Inside",IntRes2d_Situation::IntRes2d_Inside)56 ········.value("IntRes2d_Inside",IntRes2d_Situation::IntRes2d_Inside)
61 ········.value("IntRes2d_Outside",IntRes2d_Situation::IntRes2d_Outside)57 ········.value("IntRes2d_Outside",IntRes2d_Situation::IntRes2d_Outside)
62 ········.value("IntRes2d_Unknown",IntRes2d_Situation::IntRes2d_Unknown).export_values();58 ········.value("IntRes2d_Unknown",IntRes2d_Situation::IntRes2d_Unknown).export_values();
 59 ····py::enum_<IntRes2d_Position>(m,·"IntRes2d_Position",R"#()#")
 60 ········.value("IntRes2d_Head",IntRes2d_Position::IntRes2d_Head)
 61 ········.value("IntRes2d_Middle",IntRes2d_Position::IntRes2d_Middle)
 62 ········.value("IntRes2d_End",IntRes2d_Position::IntRes2d_End).export_values();
  
63 //Python·trampoline·classes63 //Python·trampoline·classes
  
64 //·pre-register·typdefs+classes·(topologically·sorted)64 //·pre-register·typdefs+classes·(topologically·sorted)
65 ····py::class_<IntRes2d_Domain·,·shared_ptr<IntRes2d_Domain>··>(m,"IntRes2d_Domain",R"#(Definition·of·the·domain·of·parameter·on·a·2d-curve.·Most·of·the·time,·a·domain·is·defined·by·two·extremities.·An·extremity·is·made·of·:·-·a·point·in·2d-space·(Pnt2d·from·gp),·-·a·parameter·on·the·curve,·-·a·tolerance·in·the·2d-space.·Sometimes,·it·can·be·made·of·0·or·1·point·(·for·an·infinite·or·semi-infinite·line·for·example).)#");65 ····py::class_<IntRes2d_Domain·,·shared_ptr<IntRes2d_Domain>··>(m,"IntRes2d_Domain",R"#(Definition·of·the·domain·of·parameter·on·a·2d-curve.·Most·of·the·time,·a·domain·is·defined·by·two·extremities.·An·extremity·is·made·of·:·-·a·point·in·2d-space·(Pnt2d·from·gp),·-·a·parameter·on·the·curve,·-·a·tolerance·in·the·2d-space.·Sometimes,·it·can·be·made·of·0·or·1·point·(·for·an·infinite·or·semi-infinite·line·for·example).)#");
66 ····py::class_<IntRes2d_Intersection·,·shared_ptr_nodelete<IntRes2d_Intersection>··>(m,"IntRes2d_Intersection",R"#(Defines·the·root·class·of·all·the·Intersections·between·two·2D-Curves,·and·provides·all·the·methods·about·the·results·of·the·Intersections·Algorithms.)#");66 ····py::class_<IntRes2d_Intersection·,·shared_ptr_nodelete<IntRes2d_Intersection>··>(m,"IntRes2d_Intersection",R"#(Defines·the·root·class·of·all·the·Intersections·between·two·2D-Curves,·and·provides·all·the·methods·about·the·results·of·the·Intersections·Algorithms.)#");
67 ····py::class_<IntRes2d_IntersectionPoint·,·shared_ptr<IntRes2d_IntersectionPoint>··>(m,"IntRes2d_IntersectionPoint",R"#(Definition·of·an·intersection·point·between·two·2D·curves.)#");67 ····py::class_<IntRes2d_IntersectionPoint·,·shared_ptr<IntRes2d_IntersectionPoint>··>(m,"IntRes2d_IntersectionPoint",R"#(Definition·of·an·intersection·point·between·two·2D·curves.)#");
⊟
1.89 KB
./usr/share/libocp/OCP/IntSurf_pre.cpp
Ordering differences only
    
Offset 61, 23 lines modifiedOffset 61, 23 lines modified
61 py::module·m·=·main_module.def_submodule("IntSurf",·R"#()#");61 py::module·m·=·main_module.def_submodule("IntSurf",·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_<IntSurf_Situation>(m,·"IntSurf_Situation",R"#()#") 
66 ········.value("IntSurf_Inside",IntSurf_Situation::IntSurf_Inside) 
67 ········.value("IntSurf_Outside",IntSurf_Situation::IntSurf_Outside) 
68 ········.value("IntSurf_Unknown",IntSurf_Situation::IntSurf_Unknown).export_values(); 
69 ····py::enum_<IntSurf_TypeTrans>(m,·"IntSurf_TypeTrans",R"#()#")65 ····py::enum_<IntSurf_TypeTrans>(m,·"IntSurf_TypeTrans",R"#()#")
70 ········.value("IntSurf_In",IntSurf_TypeTrans::IntSurf_In)66 ········.value("IntSurf_In",IntSurf_TypeTrans::IntSurf_In)
71 ········.value("IntSurf_Out",IntSurf_TypeTrans::IntSurf_Out)67 ········.value("IntSurf_Out",IntSurf_TypeTrans::IntSurf_Out)
72 ········.value("IntSurf_Touch",IntSurf_TypeTrans::IntSurf_Touch)68 ········.value("IntSurf_Touch",IntSurf_TypeTrans::IntSurf_Touch)
73 ········.value("IntSurf_Undecided",IntSurf_TypeTrans::IntSurf_Undecided).export_values();69 ········.value("IntSurf_Undecided",IntSurf_TypeTrans::IntSurf_Undecided).export_values();
 70 ····py::enum_<IntSurf_Situation>(m,·"IntSurf_Situation",R"#()#")
 71 ········.value("IntSurf_Inside",IntSurf_Situation::IntSurf_Inside)
 72 ········.value("IntSurf_Outside",IntSurf_Situation::IntSurf_Outside)
 73 ········.value("IntSurf_Unknown",IntSurf_Situation::IntSurf_Unknown).export_values();
  
74 //Python·trampoline·classes74 //Python·trampoline·classes
  
75 //·pre-register·typdefs+classes·(topologically·sorted)75 //·pre-register·typdefs+classes·(topologically·sorted)
76 ····py::class_<IntSurf·,·shared_ptr<IntSurf>··>(m,"IntSurf",R"#(This·package·provides·resources·for·all·the·packages·concerning·the·intersection·between·surfaces.)#");76 ····py::class_<IntSurf·,·shared_ptr<IntSurf>··>(m,"IntSurf",R"#(This·package·provides·resources·for·all·the·packages·concerning·the·intersection·between·surfaces.)#");
77 ····py::class_<IntSurf_Couple·,·shared_ptr<IntSurf_Couple>··>(m,"IntSurf_Couple",R"#(creation·d·'un·couple·de·2·entiers)#");77 ····py::class_<IntSurf_Couple·,·shared_ptr<IntSurf_Couple>··>(m,"IntSurf_Couple",R"#(creation·d·'un·couple·de·2·entiers)#");
78 ····py::class_<IntSurf_InteriorPoint·,·shared_ptr<IntSurf_InteriorPoint>··>(m,"IntSurf_InteriorPoint",R"#(Definition·of·a·point·solution·of·the·intersection·between·an·implicit·an·a·parametrised·surface.·These·points·are·passing·points·on·the·intersection·lines,·or·starting·points·for·the·closed·lines·on·the·parametrised·surface.)#");78 ····py::class_<IntSurf_InteriorPoint·,·shared_ptr<IntSurf_InteriorPoint>··>(m,"IntSurf_InteriorPoint",R"#(Definition·of·a·point·solution·of·the·intersection·between·an·implicit·an·a·parametrised·surface.·These·points·are·passing·points·on·the·intersection·lines,·or·starting·points·for·the·closed·lines·on·the·parametrised·surface.)#");
⊟
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))#")225 ····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)#")
226 ········.value("Interface_StateOK",Interface_DataState::Interface_StateOK)226 ········.value("Interface_CheckOK",Interface_CheckStatus::Interface_CheckOK)
227 ········.value("Interface_LoadWarning",Interface_DataState::Interface_LoadWarning)227 ········.value("Interface_CheckWarning",Interface_CheckStatus::Interface_CheckWarning)
228 ········.value("Interface_LoadFail",Interface_DataState::Interface_LoadFail)228 ········.value("Interface_CheckFail",Interface_CheckStatus::Interface_CheckFail)
 229 ········.value("Interface_CheckAny",Interface_CheckStatus::Interface_CheckAny)
 230 ········.value("Interface_CheckMessage",Interface_CheckStatus::Interface_CheckMessage)
 231 ········.value("Interface_CheckNoFail",Interface_CheckStatus::Interface_CheckNoFail).export_values();
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_ParamType>(m,·"Interface_ParamType",R"#()#")232 ····py::enum_<Interface_ParamType>(m,·"Interface_ParamType",R"#()#")
234 ········.value("Interface_ParamMisc",Interface_ParamType::Interface_ParamMisc)233 ········.value("Interface_ParamMisc",Interface_ParamType::Interface_ParamMisc)
235 ········.value("Interface_ParamInteger",Interface_ParamType::Interface_ParamInteger)234 ········.value("Interface_ParamInteger",Interface_ParamType::Interface_ParamInteger)
236 ········.value("Interface_ParamReal",Interface_ParamType::Interface_ParamReal)235 ········.value("Interface_ParamReal",Interface_ParamType::Interface_ParamReal)
237 ········.value("Interface_ParamIdent",Interface_ParamType::Interface_ParamIdent)236 ········.value("Interface_ParamIdent",Interface_ParamType::Interface_ParamIdent)
238 ········.value("Interface_ParamVoid",Interface_ParamType::Interface_ParamVoid)237 ········.value("Interface_ParamVoid",Interface_ParamType::Interface_ParamVoid)
239 ········.value("Interface_ParamText",Interface_ParamType::Interface_ParamText)238 ········.value("Interface_ParamText",Interface_ParamType::Interface_ParamText)
240 ········.value("Interface_ParamEnum",Interface_ParamType::Interface_ParamEnum)239 ········.value("Interface_ParamEnum",Interface_ParamType::Interface_ParamEnum)
241 ········.value("Interface_ParamLogical",Interface_ParamType::Interface_ParamLogical)240 ········.value("Interface_ParamLogical",Interface_ParamType::Interface_ParamLogical)
242 ········.value("Interface_ParamSub",Interface_ParamType::Interface_ParamSub)241 ········.value("Interface_ParamSub",Interface_ParamType::Interface_ParamSub)
243 ········.value("Interface_ParamHexa",Interface_ParamType::Interface_ParamHexa)242 ········.value("Interface_ParamHexa",Interface_ParamType::Interface_ParamHexa)
244 ········.value("Interface_ParamBinary",Interface_ParamType::Interface_ParamBinary).export_values();243 ········.value("Interface_ParamBinary",Interface_ParamType::Interface_ParamBinary).export_values();
245 ····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)#")244 ····py::enum_<Interface_DataState>(m,·"Interface_DataState",R"#(validity·state·of·anentity's·content·(see·InterfaceModel))#")
246 ········.value("Interface_CheckOK",Interface_CheckStatus::Interface_CheckOK)245 ········.value("Interface_StateOK",Interface_DataState::Interface_StateOK)
247 ········.value("Interface_CheckWarning",Interface_CheckStatus::Interface_CheckWarning)246 ········.value("Interface_LoadWarning",Interface_DataState::Interface_LoadWarning)
248 ········.value("Interface_CheckFail",Interface_CheckStatus::Interface_CheckFail)247 ········.value("Interface_LoadFail",Interface_DataState::Interface_LoadFail)
249 ········.value("Interface_CheckAny",Interface_CheckStatus::Interface_CheckAny) 
250 ········.value("Interface_CheckMessage",Interface_CheckStatus::Interface_CheckMessage)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_CheckNoFail",Interface_CheckStatus::Interface_CheckNoFail).export_values();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;
  
  
⊟
8.71 KB
./usr/share/libocp/OCP/MeshVS_pre.cpp
Ordering differences only
    
Offset 153, 60 lines modifiedOffset 153, 37 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_EntityType>(m,·"MeshVS_EntityType",R"#()#") 
158 ········.value("MeshVS_ET_NONE",MeshVS_EntityType::MeshVS_ET_NONE) 
159 ········.value("MeshVS_ET_Node",MeshVS_EntityType::MeshVS_ET_Node) 
160 ········.value("MeshVS_ET_0D",MeshVS_EntityType::MeshVS_ET_0D) 
161 ········.value("MeshVS_ET_Link",MeshVS_EntityType::MeshVS_ET_Link) 
162 ········.value("MeshVS_ET_Face",MeshVS_EntityType::MeshVS_ET_Face) 
163 ········.value("MeshVS_ET_Volume",MeshVS_EntityType::MeshVS_ET_Volume) 
164 ········.value("MeshVS_ET_Element",MeshVS_EntityType::MeshVS_ET_Element) 
165 ········.value("MeshVS_ET_All",MeshVS_EntityType::MeshVS_ET_All).export_values(); 
166 ····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·))#")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·))#")
167 ········.value("MeshVS_MSM_PRECISE",MeshVS_MeshSelectionMethod::MeshVS_MSM_PRECISE)158 ········.value("MeshVS_MSM_PRECISE",MeshVS_MeshSelectionMethod::MeshVS_MSM_PRECISE)
168 ········.value("MeshVS_MSM_NODES",MeshVS_MeshSelectionMethod::MeshVS_MSM_NODES)159 ········.value("MeshVS_MSM_NODES",MeshVS_MeshSelectionMethod::MeshVS_MSM_NODES)
169 ········.value("MeshVS_MSM_BOX",MeshVS_MeshSelectionMethod::MeshVS_MSM_BOX).export_values();160 ········.value("MeshVS_MSM_BOX",MeshVS_MeshSelectionMethod::MeshVS_MSM_BOX).export_values();
170 ····py::enum_<MeshVS_SelectionModeFlags>(m,·"MeshVS_SelectionModeFlags",R"#()#")161 ····py::enum_<MeshVS_SelectionModeFlags>(m,·"MeshVS_SelectionModeFlags",R"#()#")
171 ········.value("MeshVS_SMF_Mesh",MeshVS_SelectionModeFlags::MeshVS_SMF_Mesh)162 ········.value("MeshVS_SMF_Mesh",MeshVS_SelectionModeFlags::MeshVS_SMF_Mesh)
172 ········.value("MeshVS_SMF_Node",MeshVS_SelectionModeFlags::MeshVS_SMF_Node)163 ········.value("MeshVS_SMF_Node",MeshVS_SelectionModeFlags::MeshVS_SMF_Node)
173 ········.value("MeshVS_SMF_0D",MeshVS_SelectionModeFlags::MeshVS_SMF_0D)164 ········.value("MeshVS_SMF_0D",MeshVS_SelectionModeFlags::MeshVS_SMF_0D)
174 ········.value("MeshVS_SMF_Link",MeshVS_SelectionModeFlags::MeshVS_SMF_Link)165 ········.value("MeshVS_SMF_Link",MeshVS_SelectionModeFlags::MeshVS_SMF_Link)
175 ········.value("MeshVS_SMF_Face",MeshVS_SelectionModeFlags::MeshVS_SMF_Face)166 ········.value("MeshVS_SMF_Face",MeshVS_SelectionModeFlags::MeshVS_SMF_Face)
176 ········.value("MeshVS_SMF_Volume",MeshVS_SelectionModeFlags::MeshVS_SMF_Volume)167 ········.value("MeshVS_SMF_Volume",MeshVS_SelectionModeFlags::MeshVS_SMF_Volume)
177 ········.value("MeshVS_SMF_Element",MeshVS_SelectionModeFlags::MeshVS_SMF_Element)168 ········.value("MeshVS_SMF_Element",MeshVS_SelectionModeFlags::MeshVS_SMF_Element)
178 ········.value("MeshVS_SMF_All",MeshVS_SelectionModeFlags::MeshVS_SMF_All)169 ········.value("MeshVS_SMF_All",MeshVS_SelectionModeFlags::MeshVS_SMF_All)
179 ········.value("MeshVS_SMF_Group",MeshVS_SelectionModeFlags::MeshVS_SMF_Group).export_values();170 ········.value("MeshVS_SMF_Group",MeshVS_SelectionModeFlags::MeshVS_SMF_Group).export_values();
 171 ····py::enum_<MeshVS_EntityType>(m,·"MeshVS_EntityType",R"#()#")
 172 ········.value("MeshVS_ET_NONE",MeshVS_EntityType::MeshVS_ET_NONE)
 173 ········.value("MeshVS_ET_Node",MeshVS_EntityType::MeshVS_ET_Node)
 174 ········.value("MeshVS_ET_0D",MeshVS_EntityType::MeshVS_ET_0D)
 175 ········.value("MeshVS_ET_Link",MeshVS_EntityType::MeshVS_ET_Link)
 176 ········.value("MeshVS_ET_Face",MeshVS_EntityType::MeshVS_ET_Face)
 177 ········.value("MeshVS_ET_Volume",MeshVS_EntityType::MeshVS_ET_Volume)
 178 ········.value("MeshVS_ET_Element",MeshVS_EntityType::MeshVS_ET_Element)
 179 ········.value("MeshVS_ET_All",MeshVS_EntityType::MeshVS_ET_All).export_values();
180 ····m.attr("MeshVS_DMF_WireFrame")·=·py::cast(int(MeshVS_DMF_WireFrame)); 
181 ····m.attr("MeshVS_DMF_Shading")·=·py::cast(int(MeshVS_DMF_Shading)); 
182 ····m.attr("MeshVS_DMF_Shrink")·=·py::cast(int(MeshVS_DMF_Shrink)); 
183 ····m.attr("MeshVS_DMF_OCCMask")·=·py::cast(int(MeshVS_DMF_OCCMask)); 
184 ····m.attr("MeshVS_DMF_VectorDataPrs")·=·py::cast(int(MeshVS_DMF_VectorDataPrs)); 
185 ····m.attr("MeshVS_DMF_NodalColorDataPrs")·=·py::cast(int(MeshVS_DMF_NodalColorDataPrs)); 
186 ····m.attr("MeshVS_DMF_ElementalColorDataPrs")·=·py::cast(int(MeshVS_DMF_ElementalColorDataPrs)); 
187 ····m.attr("MeshVS_DMF_TextDataPrs")·=·py::cast(int(MeshVS_DMF_TextDataPrs)); 
188 ····m.attr("MeshVS_DMF_EntitiesWithData")·=·py::cast(int(MeshVS_DMF_EntitiesWithData)); 
189 ····m.attr("MeshVS_DMF_DeformedPrsWireFrame")·=·py::cast(int(MeshVS_DMF_DeformedPrsWireFrame)); 
190 ····m.attr("MeshVS_DMF_DeformedPrsShading")·=·py::cast(int(MeshVS_DMF_DeformedPrsShading)); 
191 ····m.attr("MeshVS_DMF_DeformedPrsShrink")·=·py::cast(int(MeshVS_DMF_DeformedPrsShrink)); 
192 ····m.attr("MeshVS_DMF_DeformedMask")·=·py::cast(int(MeshVS_DMF_DeformedMask)); 
193 ····m.attr("MeshVS_DMF_SelectionPrs")·=·py::cast(int(MeshVS_DMF_SelectionPrs)); 
194 ····m.attr("MeshVS_DMF_HilightPrs")·=·py::cast(int(MeshVS_DMF_HilightPrs)); 
195 ····m.attr("MeshVS_DMF_User")·=·py::cast(int(MeshVS_DMF_User)); 
196 ····m.attr("MeshVS_BP_Mesh")·=·py::cast(int(MeshVS_BP_Mesh)); 
197 ····m.attr("MeshVS_BP_NodalColor")·=·py::cast(int(MeshVS_BP_NodalColor)); 
198 ····m.attr("MeshVS_BP_ElemColor")·=·py::cast(int(MeshVS_BP_ElemColor)); 
199 ····m.attr("MeshVS_BP_Text")·=·py::cast(int(MeshVS_BP_Text)); 
200 ····m.attr("MeshVS_BP_Vector")·=·py::cast(int(MeshVS_BP_Vector)); 
201 ····m.attr("MeshVS_BP_User")·=·py::cast(int(MeshVS_BP_User)); 
202 ····m.attr("MeshVS_BP_Default")·=·py::cast(int(MeshVS_BP_Default)); 
203 ····py::enum_<MeshVS_DrawerAttribute>(m,·"MeshVS_DrawerAttribute",R"#(Is·it·allowed·to·draw·beam·and·face's·edge·overlapping·with·this·beam.·Is·mesh·drawn·with·reflective·material·Is·colored·mesh·data·representation·drawn·with·reflective·material·What·part·of·face·or·link·will·be·shown·if·shrink·mode.·It·is·recommended·this·coeff·to·be·between·0·and·1.·How·many·nodes·is·possible·to·be·in·face·If·this·parameter·is·true,·the·compute·method·CPU·time·will·be·displayed·in·console·window·If·this·parameter·is·true,·the·compute·selection·method·CPU·time·will·be·displayed·in·console·window·If·this·parameter·is·false,·the·nodes·won't·be·shown·in·viewer,·otherwise·will·be.//!·If·this·parameter·is·true,·the·selectable·nodes·map·will·be·updated·automatically·when·hidden·elements·change//!·If·this·parameter·is·false,·the·face's·edges·are·not·shown·Warning:·in·wireframe·mode·this·parameter·is·ignored·Is·mesh·drawing·in·smooth·shading·mode·Is·back·faces·of·volume·elements·should·be·suppressed·The·integer·keys·for·most·useful·constants·attuning·mesh·presentation·appearance·WARNING:·DA_TextExpansionFactor,·DA_TextSpace,·DA_TextDisplayType·have·no·effect·and·might·be·removed·in·the·future.)#")180 ····py::enum_<MeshVS_DrawerAttribute>(m,·"MeshVS_DrawerAttribute",R"#(Is·it·allowed·to·draw·beam·and·face's·edge·overlapping·with·this·beam.·Is·mesh·drawn·with·reflective·material·Is·colored·mesh·data·representation·drawn·with·reflective·material·What·part·of·face·or·link·will·be·shown·if·shrink·mode.·It·is·recommended·this·coeff·to·be·between·0·and·1.·How·many·nodes·is·possible·to·be·in·face·If·this·parameter·is·true,·the·compute·method·CPU·time·will·be·displayed·in·console·window·If·this·parameter·is·true,·the·compute·selection·method·CPU·time·will·be·displayed·in·console·window·If·this·parameter·is·false,·the·nodes·won't·be·shown·in·viewer,·otherwise·will·be.//!·If·this·parameter·is·true,·the·selectable·nodes·map·will·be·updated·automatically·when·hidden·elements·change//!·If·this·parameter·is·false,·the·face's·edges·are·not·shown·Warning:·in·wireframe·mode·this·parameter·is·ignored·Is·mesh·drawing·in·smooth·shading·mode·Is·back·faces·of·volume·elements·should·be·suppressed·The·integer·keys·for·most·useful·constants·attuning·mesh·presentation·appearance·WARNING:·DA_TextExpansionFactor,·DA_TextSpace,·DA_TextDisplayType·have·no·effect·and·might·be·removed·in·the·future.)#")
204 ········.value("MeshVS_DA_InteriorStyle",MeshVS_DrawerAttribute::MeshVS_DA_InteriorStyle)181 ········.value("MeshVS_DA_InteriorStyle",MeshVS_DrawerAttribute::MeshVS_DA_InteriorStyle)
205 ········.value("MeshVS_DA_InteriorColor",MeshVS_DrawerAttribute::MeshVS_DA_InteriorColor)182 ········.value("MeshVS_DA_InteriorColor",MeshVS_DrawerAttribute::MeshVS_DA_InteriorColor)
206 ········.value("MeshVS_DA_BackInteriorColor",MeshVS_DrawerAttribute::MeshVS_DA_BackInteriorColor)183 ········.value("MeshVS_DA_BackInteriorColor",MeshVS_DrawerAttribute::MeshVS_DA_BackInteriorColor)
207 ········.value("MeshVS_DA_EdgeColor",MeshVS_DrawerAttribute::MeshVS_DA_EdgeColor)184 ········.value("MeshVS_DA_EdgeColor",MeshVS_DrawerAttribute::MeshVS_DA_EdgeColor)
208 ········.value("MeshVS_DA_EdgeType",MeshVS_DrawerAttribute::MeshVS_DA_EdgeType)185 ········.value("MeshVS_DA_EdgeType",MeshVS_DrawerAttribute::MeshVS_DA_EdgeType)
209 ········.value("MeshVS_DA_EdgeWidth",MeshVS_DrawerAttribute::MeshVS_DA_EdgeWidth)186 ········.value("MeshVS_DA_EdgeWidth",MeshVS_DrawerAttribute::MeshVS_DA_EdgeWidth)
Offset 240, 14 lines modifiedOffset 217, 37 lines modified
240 ········.value("MeshVS_DA_ComputeSelectionTime",MeshVS_DrawerAttribute::MeshVS_DA_ComputeSelectionTime)217 ········.value("MeshVS_DA_ComputeSelectionTime",MeshVS_DrawerAttribute::MeshVS_DA_ComputeSelectionTime)
241 ········.value("MeshVS_DA_DisplayNodes",MeshVS_DrawerAttribute::MeshVS_DA_DisplayNodes)218 ········.value("MeshVS_DA_DisplayNodes",MeshVS_DrawerAttribute::MeshVS_DA_DisplayNodes)
242 ········.value("MeshVS_DA_SelectableAuto",MeshVS_DrawerAttribute::MeshVS_DA_SelectableAuto)219 ········.value("MeshVS_DA_SelectableAuto",MeshVS_DrawerAttribute::MeshVS_DA_SelectableAuto)
243 ········.value("MeshVS_DA_ShowEdges",MeshVS_DrawerAttribute::MeshVS_DA_ShowEdges)220 ········.value("MeshVS_DA_ShowEdges",MeshVS_DrawerAttribute::MeshVS_DA_ShowEdges)
244 ········.value("MeshVS_DA_SmoothShading",MeshVS_DrawerAttribute::MeshVS_DA_SmoothShading)221 ········.value("MeshVS_DA_SmoothShading",MeshVS_DrawerAttribute::MeshVS_DA_SmoothShading)
245 ········.value("MeshVS_DA_SupressBackFaces",MeshVS_DrawerAttribute::MeshVS_DA_SupressBackFaces)222 ········.value("MeshVS_DA_SupressBackFaces",MeshVS_DrawerAttribute::MeshVS_DA_SupressBackFaces)
246 ········.value("MeshVS_DA_User",MeshVS_DrawerAttribute::MeshVS_DA_User).export_values();223 ········.value("MeshVS_DA_User",MeshVS_DrawerAttribute::MeshVS_DA_User).export_values();
 224 ····m.attr("MeshVS_BP_Mesh")·=·py::cast(int(MeshVS_BP_Mesh));
 225 ····m.attr("MeshVS_BP_NodalColor")·=·py::cast(int(MeshVS_BP_NodalColor));
 226 ····m.attr("MeshVS_BP_ElemColor")·=·py::cast(int(MeshVS_BP_ElemColor));
 227 ····m.attr("MeshVS_BP_Text")·=·py::cast(int(MeshVS_BP_Text));
 228 ····m.attr("MeshVS_BP_Vector")·=·py::cast(int(MeshVS_BP_Vector));
 229 ····m.attr("MeshVS_BP_User")·=·py::cast(int(MeshVS_BP_User));
 230 ····m.attr("MeshVS_BP_Default")·=·py::cast(int(MeshVS_BP_Default));
 231 ····m.attr("MeshVS_DMF_WireFrame")·=·py::cast(int(MeshVS_DMF_WireFrame));
 232 ····m.attr("MeshVS_DMF_Shading")·=·py::cast(int(MeshVS_DMF_Shading));
 233 ····m.attr("MeshVS_DMF_Shrink")·=·py::cast(int(MeshVS_DMF_Shrink));
 234 ····m.attr("MeshVS_DMF_OCCMask")·=·py::cast(int(MeshVS_DMF_OCCMask));
 235 ····m.attr("MeshVS_DMF_VectorDataPrs")·=·py::cast(int(MeshVS_DMF_VectorDataPrs));
 236 ····m.attr("MeshVS_DMF_NodalColorDataPrs")·=·py::cast(int(MeshVS_DMF_NodalColorDataPrs));
 237 ····m.attr("MeshVS_DMF_ElementalColorDataPrs")·=·py::cast(int(MeshVS_DMF_ElementalColorDataPrs));
 238 ····m.attr("MeshVS_DMF_TextDataPrs")·=·py::cast(int(MeshVS_DMF_TextDataPrs));
 239 ····m.attr("MeshVS_DMF_EntitiesWithData")·=·py::cast(int(MeshVS_DMF_EntitiesWithData));
 240 ····m.attr("MeshVS_DMF_DeformedPrsWireFrame")·=·py::cast(int(MeshVS_DMF_DeformedPrsWireFrame));
 241 ····m.attr("MeshVS_DMF_DeformedPrsShading")·=·py::cast(int(MeshVS_DMF_DeformedPrsShading));
 242 ····m.attr("MeshVS_DMF_DeformedPrsShrink")·=·py::cast(int(MeshVS_DMF_DeformedPrsShrink));
 243 ····m.attr("MeshVS_DMF_DeformedMask")·=·py::cast(int(MeshVS_DMF_DeformedMask));
 244 ····m.attr("MeshVS_DMF_SelectionPrs")·=·py::cast(int(MeshVS_DMF_SelectionPrs));
 245 ····m.attr("MeshVS_DMF_HilightPrs")·=·py::cast(int(MeshVS_DMF_HilightPrs));
 246 ····m.attr("MeshVS_DMF_User")·=·py::cast(int(MeshVS_DMF_User));
  
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;
  
  
⊟
6.96 KB
./usr/share/libocp/OCP/Message_pre.cpp
Ordering differences only
    
Offset 85, 14 lines modifiedOffset 85, 20 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_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)#")
 90 ········.value("Message_Trace",Message_Gravity::Message_Trace)
 91 ········.value("Message_Info",Message_Gravity::Message_Info)
 92 ········.value("Message_Warning",Message_Gravity::Message_Warning)
 93 ········.value("Message_Alarm",Message_Gravity::Message_Alarm)
 94 ········.value("Message_Fail",Message_Gravity::Message_Fail).export_values();
89 ····py::enum_<Message_StatusType>(m,·"Message_StatusType",R"#(Definition·of·types·of·execution·status·supported·by·the·class·Message_ExecStatus)#")95 ····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)96 ········.value("Message_DONE",Message_StatusType::Message_DONE)
91 ········.value("Message_WARN",Message_StatusType::Message_WARN)97 ········.value("Message_WARN",Message_StatusType::Message_WARN)
92 ········.value("Message_ALARM",Message_StatusType::Message_ALARM)98 ········.value("Message_ALARM",Message_StatusType::Message_ALARM)
93 ········.value("Message_FAIL",Message_StatusType::Message_FAIL).export_values();99 ········.value("Message_FAIL",Message_StatusType::Message_FAIL).export_values();
94 ····py::enum_<Message_ConsoleColor>(m,·"Message_ConsoleColor",R"#(Color·definition·for·console/terminal·output·(limited·palette).)#")100 ····py::enum_<Message_ConsoleColor>(m,·"Message_ConsoleColor",R"#(Color·definition·for·console/terminal·output·(limited·palette).)#")
95 ········.value("Message_ConsoleColor_Default",Message_ConsoleColor::Message_ConsoleColor_Default)101 ········.value("Message_ConsoleColor_Default",Message_ConsoleColor::Message_ConsoleColor_Default)
Offset 100, 34 lines modifiedOffset 106, 14 lines modified
100 ········.value("Message_ConsoleColor_White",Message_ConsoleColor::Message_ConsoleColor_White)106 ········.value("Message_ConsoleColor_White",Message_ConsoleColor::Message_ConsoleColor_White)
101 ········.value("Message_ConsoleColor_Red",Message_ConsoleColor::Message_ConsoleColor_Red)107 ········.value("Message_ConsoleColor_Red",Message_ConsoleColor::Message_ConsoleColor_Red)
102 ········.value("Message_ConsoleColor_Blue",Message_ConsoleColor::Message_ConsoleColor_Blue)108 ········.value("Message_ConsoleColor_Blue",Message_ConsoleColor::Message_ConsoleColor_Blue)
103 ········.value("Message_ConsoleColor_Green",Message_ConsoleColor::Message_ConsoleColor_Green)109 ········.value("Message_ConsoleColor_Green",Message_ConsoleColor::Message_ConsoleColor_Green)
104 ········.value("Message_ConsoleColor_Yellow",Message_ConsoleColor::Message_ConsoleColor_Yellow)110 ········.value("Message_ConsoleColor_Yellow",Message_ConsoleColor::Message_ConsoleColor_Yellow)
105 ········.value("Message_ConsoleColor_Cyan",Message_ConsoleColor::Message_ConsoleColor_Cyan)111 ········.value("Message_ConsoleColor_Cyan",Message_ConsoleColor::Message_ConsoleColor_Cyan)
106 ········.value("Message_ConsoleColor_Magenta",Message_ConsoleColor::Message_ConsoleColor_Magenta).export_values();112 ········.value("Message_ConsoleColor_Magenta",Message_ConsoleColor::Message_ConsoleColor_Magenta).export_values();
107 ····py::enum_<Message_MetricType>(m,·"Message_MetricType",R"#(Specifies·kind·of·report·information·to·collect)#") 
108 ········.value("Message_MetricType_None",Message_MetricType::Message_MetricType_None) 
109 ········.value("Message_MetricType_ThreadCPUUserTime",Message_MetricType::Message_MetricType_ThreadCPUUserTime) 
110 ········.value("Message_MetricType_ThreadCPUSystemTime",Message_MetricType::Message_MetricType_ThreadCPUSystemTime) 
111 ········.value("Message_MetricType_ProcessCPUUserTime",Message_MetricType::Message_MetricType_ProcessCPUUserTime) 
112 ········.value("Message_MetricType_ProcessCPUSystemTime",Message_MetricType::Message_MetricType_ProcessCPUSystemTime) 
113 ········.value("Message_MetricType_WallClock",Message_MetricType::Message_MetricType_WallClock) 
114 ········.value("Message_MetricType_MemPrivate",Message_MetricType::Message_MetricType_MemPrivate) 
115 ········.value("Message_MetricType_MemVirtual",Message_MetricType::Message_MetricType_MemVirtual) 
116 ········.value("Message_MetricType_MemWorkingSet",Message_MetricType::Message_MetricType_MemWorkingSet) 
117 ········.value("Message_MetricType_MemWorkingSetPeak",Message_MetricType::Message_MetricType_MemWorkingSetPeak) 
118 ········.value("Message_MetricType_MemSwapUsage",Message_MetricType::Message_MetricType_MemSwapUsage) 
119 ········.value("Message_MetricType_MemSwapUsagePeak",Message_MetricType::Message_MetricType_MemSwapUsagePeak) 
120 ········.value("Message_MetricType_MemHeapUsage",Message_MetricType::Message_MetricType_MemHeapUsage).export_values(); 
121 ····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)#") 
122 ········.value("Message_Trace",Message_Gravity::Message_Trace) 
123 ········.value("Message_Info",Message_Gravity::Message_Info) 
124 ········.value("Message_Warning",Message_Gravity::Message_Warning) 
125 ········.value("Message_Alarm",Message_Gravity::Message_Alarm) 
126 ········.value("Message_Fail",Message_Gravity::Message_Fail).export_values(); 
127 ····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))#")113 ····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))#")
128 ········.value("Message_None",Message_Status::Message_None)114 ········.value("Message_None",Message_Status::Message_None)
129 ········.value("Message_Done1",Message_Status::Message_Done1)115 ········.value("Message_Done1",Message_Status::Message_Done1)
130 ········.value("Message_Done2",Message_Status::Message_Done2)116 ········.value("Message_Done2",Message_Status::Message_Done2)
131 ········.value("Message_Done3",Message_Status::Message_Done3)117 ········.value("Message_Done3",Message_Status::Message_Done3)
132 ········.value("Message_Done4",Message_Status::Message_Done4)118 ········.value("Message_Done4",Message_Status::Message_Done4)
133 ········.value("Message_Done5",Message_Status::Message_Done5)119 ········.value("Message_Done5",Message_Status::Message_Done5)
Offset 250, 14 lines modifiedOffset 236, 28 lines modified
250 ········.value("Message_Fail26",Message_Status::Message_Fail26)236 ········.value("Message_Fail26",Message_Status::Message_Fail26)
251 ········.value("Message_Fail27",Message_Status::Message_Fail27)237 ········.value("Message_Fail27",Message_Status::Message_Fail27)
252 ········.value("Message_Fail28",Message_Status::Message_Fail28)238 ········.value("Message_Fail28",Message_Status::Message_Fail28)
253 ········.value("Message_Fail29",Message_Status::Message_Fail29)239 ········.value("Message_Fail29",Message_Status::Message_Fail29)
254 ········.value("Message_Fail30",Message_Status::Message_Fail30)240 ········.value("Message_Fail30",Message_Status::Message_Fail30)
255 ········.value("Message_Fail31",Message_Status::Message_Fail31)241 ········.value("Message_Fail31",Message_Status::Message_Fail31)
256 ········.value("Message_Fail32",Message_Status::Message_Fail32).export_values();242 ········.value("Message_Fail32",Message_Status::Message_Fail32).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;
  
  
⊟
308 KB
./usr/share/libocp/OCP/NCollection_tmpl.hxx
Ordering differences only
    
Offset 78, 68 lines modifiedOffset 78, 14 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_SparseArray(py::object·&m,·const·char·*name){ 
83 ····py::class_<NCollection_SparseArray<TheItemType>·,·shared_ptr<NCollection_SparseArray<TheItemType>>·,·NCollection_SparseArrayBase·>(m,name,R"#(Dynamically·resizable·sparse·array·of·objects)#"); 
84 } 
  
85 template·<typename·TheItemType> 
86 void·register_template_NCollection_SparseArray(py::object·&m,·const·char·*name){ 
87 ····static_cast<py::class_<NCollection_SparseArray<TheItemType>·,·shared_ptr<NCollection_SparseArray<TheItemType>>·,·NCollection_SparseArrayBase·>>(m.attr(name)) 
88 ········.def(py::init<·Standard_Size·>()·,py::arg("theIncrement")·) 
89 ········.def("Assign", 
90 ·············(NCollection_SparseArray<TheItemType>·&·(NCollection_SparseArray<TheItemType>::*)(··const·NCollection_SparseArray<TheItemType>·&··)·)·&NCollection_SparseArray<TheItemType>::Assign, 
91 ·············R"#(Explicit·assignment·operator)#"·,py::arg("theOther")) 
92 ········.def("Exchange", 
93 ·············(void·(NCollection_SparseArray<TheItemType>::*)(·NCollection_SparseArray<TheItemType>·&··)·)·&NCollection_SparseArray<TheItemType>::Exchange, 
94 ·············R"#(Exchange·the·data·of·two·arrays;·can·be·used·primarily·to·move·contents·of·theOther·into·the·new·array·in·a·fast·way·(without·creation·of·duplicated·data))#"·,py::arg("theOther")) 
95 ········.def("Value", 
96 ·············(·const·TheItemType·&·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size··)·const)·&NCollection_SparseArray<TheItemType>::Value, 
97 ·············R"#(Direct·const·access·to·the·item)#"·,py::arg("theIndex")) 
98 ········.def("ChangeValue", 
99 ·············(TheItemType·&·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size··)·)·&NCollection_SparseArray<TheItemType>::ChangeValue, 
100 ·············R"#(Modification·access·to·the·item)#"·,py::arg("theIndex")) 
101 ········.def("SetValue", 
102 ·············(TheItemType·&·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size·,···const·TheItemType·&··)·)·&NCollection_SparseArray<TheItemType>::SetValue, 
103 ·············R"#(Set·a·value·at·specified·index·method)#"·,py::arg("theIndex"),·py::arg("theValue")) 
104 ········.def("Extent", 
105 ·············(Standard_Size·(NCollection_SparseArray<TheItemType>::*)()·const)·&NCollection_SparseArray<TheItemType>::Extent, 
106 ·············R"#(Returns·number·of·items·in·the·array)#"·) 
107 ········.def("IsEmpty", 
108 ·············(Standard_Boolean·(NCollection_SparseArray<TheItemType>::*)()·const)·&NCollection_SparseArray<TheItemType>::IsEmpty, 
109 ·············R"#(Returns·True·if·array·is·empty)#"·) 
110 ········.def("Find", 
111 ·············(·const·TheItemType·&·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size··)·const)·&NCollection_SparseArray<TheItemType>::Find, 
112 ·············R"#(Direct·const·access·to·the·item)#"·,py::arg("theIndex")) 
113 ········.def("ChangeFind", 
114 ·············(TheItemType·&·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size··)·)·&NCollection_SparseArray<TheItemType>::ChangeFind, 
115 ·············R"#(Modification·access·to·the·item)#"·,py::arg("theIndex")) 
116 ········.def("Bind", 
117 ·············(TheItemType·&·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size·,···const·TheItemType·&··)·)·&NCollection_SparseArray<TheItemType>::Bind, 
118 ·············R"#(Set·a·value·as·explicit·method)#"·,py::arg("theIndex"),·py::arg("theValue")) 
119 ········.def("IsBound", 
120 ·············(Standard_Boolean·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size··)·const)·&NCollection_SparseArray<TheItemType>::IsBound, 
121 ·············R"#(Returns·True·if·the·item·is·defined)#"·,py::arg("theIndex")) 
122 ········.def("UnBind", 
123 ·············(Standard_Boolean·(NCollection_SparseArray<TheItemType>::*)(··const·Standard_Size··)·)·&NCollection_SparseArray<TheItemType>::UnBind, 
124 ·············R"#(Remove·the·item·from·array)#"·,py::arg("theIndex")) 
125 ········.def("__len__",[](const·NCollection_SparseArray<TheItemType>·&self) 
126 ·············{·return·self.Extent();·} 
127 ·············) 
128 ········.def("__bool__",[](const·NCollection_SparseArray<TheItemType>·&self) 
129 ·············{·return·self.IsEmpty();·} 
130 ·············) 
131 ····; 
132 }; 
  
133 template·<typename·TheItemType> 
134 void·preregister_template_NCollection_Array1(py::object·&m,·const·char·*name){82 void·preregister_template_NCollection_Array1(py::object·&m,·const·char·*name){
135 ····py::class_<NCollection_Array1<TheItemType>·,·shared_ptr<NCollection_Array1<TheItemType>>·>(m,name,R"#(The·class·NCollection_Array1·represents·unidimensional·arrays·of·fixed·size·known·at·run·time.·The·range·of·the·index·is·user·defined.·An·array1·can·be·constructed·with·a·"C·array".·This·functionality·is·useful·to·call·methods·expecting·an·Array1.·It·allows·to·carry·the·bounds·inside·the·arrays.)#");83 ····py::class_<NCollection_Array1<TheItemType>·,·shared_ptr<NCollection_Array1<TheItemType>>·>(m,name,R"#(The·class·NCollection_Array1·represents·unidimensional·arrays·of·fixed·size·known·at·run·time.·The·range·of·the·index·is·user·defined.·An·array1·can·be·constructed·with·a·"C·array".·This·functionality·is·useful·to·call·methods·expecting·an·Array1.·It·allows·to·carry·the·bounds·inside·the·arrays.)#");
136 }84 }
  
137 template·<typename·TheItemType>85 template·<typename·TheItemType>
138 void·register_template_NCollection_Array1(py::object·&m,·const·char·*name){86 void·register_template_NCollection_Array1(py::object·&m,·const·char·*name){
139 ····static_cast<py::class_<NCollection_Array1<TheItemType>·,·shared_ptr<NCollection_Array1<TheItemType>>·>>(m.attr(name))87 ····static_cast<py::class_<NCollection_Array1<TheItemType>·,·shared_ptr<NCollection_Array1<TheItemType>>·>>(m.attr(name))
Offset 231, 80 lines modifiedOffset 177, 424 lines modified
231 ·············)177 ·············)
232 ········.def("__bool__",[](const·NCollection_Array1<TheItemType>·&self)178 ········.def("__bool__",[](const·NCollection_Array1<TheItemType>·&self)
233 ·············{·return·self.IsEmpty();·}179 ·············{·return·self.IsEmpty();·}
234 ·············)180 ·············)
235 ····;181 ····;
236 };182 };
  
237 template·<typename·TheKey1Type,typename·TheKey2Type,typename·Hasher1=NCollection_DefaultHasher<TheKey1Type>,typename·Hasher2=NCollection_DefaultHasher<TheKey2Type>>183 template·<typename·Inspector>
238 void·preregister_template_NCollection_DoubleMap(py::object·&m,·const·char·*name){184 void·preregister_template_NCollection_CellFilter(py::object·&m,·const·char·*name){
239 ····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.)#");185 ····py::class_<NCollection_CellFilter<Inspector>·,·shared_ptr<NCollection_CellFilter<Inspector>>·>(m,name,R"#(A·data·structure·for·sorting·geometric·objects·(called·targets)·in·n-dimensional·space·into·cells,·with·associated·algorithm·for·fast·checking·of·coincidence·(overlapping,·i[·...·truncated·by·diffoscope;·len:·59,·SHA:·3816927d7b2abbc60b34eaff68f2a106e393274584834f6dcab45ff60ae6da24·...·].)#");
240 }186 }
  
241 template·<typename·TheKey1Type,typename·TheKey2Type,typename·Hasher1=NCollection_DefaultHasher<TheKey1Type>,typename·Hasher2=NCollection_DefaultHasher<TheKey2Type>>187 template·<typename·Inspector>
 188 void·register_template_NCollection_CellFilter(py::object·&m,·const·char·*name){
 189 ····static_cast<py::class_<NCollection_CellFilter<Inspector>·,·shared_ptr<NCollection_CellFilter<Inspector>>·>>(m.attr(name))
 190 ········.def(py::init<··const·Standard_Integer,·const·Standard_Real,·const·handle<NCollection_IncAllocator>·&·>()·,py::arg("theDim"),·py::arg("theCellSize")=static_cast<·const·Standard_Real>(0),·py::arg("theAlloc")=static_cast<·const·handle<NCollection_IncAllocator>·&>(0)·)
 191 ········.def(py::init<··const·Standard_Real,·const·handle<NCollection_IncAllocator>·&·>()·,py::arg("theCellSize")=static_cast<·const·Standard_Real>(0),·py::arg("theAlloc")=static_cast<·const·handle<NCollection_IncAllocator>·&>(0)·)
 192 ········.def("Reset",
 193 ·············(void·(NCollection_CellFilter<Inspector>::*)(·Standard_Real·,···const·handle<NCollection_IncAllocator>·&··)·)·&NCollection_CellFilter<Inspector>::Reset,
 194 ·············R"#(Clear·the·data·structures,·set·new·cell·size·and·allocator)#"·,py::arg("theCellSize"),·py::arg("theAlloc")=static_cast<·const·handle<NCollection_IncAllocator>·&>(0))
 195 ········.def("Reset",
 196 ·············(void·(NCollection_CellFilter<Inspector>::*)(·NCollection_Array1<Standard_Real>·&·,···const·handle<NCollection_IncAllocator>·&··)·)·&NCollection_CellFilter<Inspector>::Reset,
 197 ·············R"#(Clear·the·data·structures·and·set·new·cell·sizes·and·allocator)#"·,py::arg("theCellSize"),·py::arg("theAlloc")=static_cast<·const·handle<NCollection_IncAllocator>·&>(0))
 198 ········.def("Add",
 199 ·············(void·(NCollection_CellFilter<Inspector>::*)(··const·typename·NCollection_CellFilter<Inspector>::Target·&·,···const·typename·NCollection_CellFilter<Inspector>::Point·&··)·)·&NCollection_CellFilter<Inspector>::Add,
 200 ·············R"#(Adds·a·target·object·for·further·search·at·a·point·(into·only·one·cell))#"·,py::arg("theTarget"),·py::arg("thePnt"))
 201 ········.def("Add",
 202 ·············(void·(NCollection_CellFilter<Inspector>::*)(··const·typename·NCollection_CellFilter<Inspector>::Target·&·,···const·typename·NCollection_CellFilter<Inspector>::Point·&·,···const·typename·NCollection_CellFilter<Inspector>::Point·&··)·)·&NCollection_CellFilter<Inspector>::Add,
 203 ·············R"#(Adds·a·target·object·for·further·search·in·the·range·of·cells·defined·by·two·points·(the·first·point·must·have·all·coordinates·equal·or·less·than·the·same·coordinate·of·the·second·point))#"·,py::arg("theTarget"),·py::arg("thePntMin"),·py::arg("thePntMax"))
 204 ········.def("Remove",
 205 ·············(void·(NCollection_CellFilter<Inspector>::*)(··const·typename·NCollection_CellFilter<Inspector>::Target·&·,···const·typename·NCollection_CellFilter<Inspector>::Point·&··)·)·&NCollection_CellFilter<Inspector>::Remove,
 206 ·············R"#(Find·a·target·object·at·a·point·and·remove·it·from·the·structures.·For·usage·of·this·method·"operator·=="·should·be·defined·for·Target.)#"·,py::arg("theTarget"),·py::arg("thePnt"))
 207 ········.def("Remove",
 208 ·············(void·(NCollection_CellFilter<Inspector>::*)(··const·typename·NCollection_CellFilter<Inspector>::Target·&·,···const·typename·NCollection_CellFilter<Inspector>::Point·&·,···const·typename·NCollection_CellFilter<Inspector>::Point·&··)·)·&NCollection_CellFilter<Inspector>::Remove,
 209 ·············R"#(Find·a·target·object·in·the·range·of·cells·defined·by·two·points·and·remove·it·from·the·structures·(the·first·point·must·have·all·coordinates·equal·or·less·than·the·same·coordinate·of·the·second·point).·For·usage·of·this·method·"operator·=="·should·be·defined·for·Target.)#"·,py::arg("theTarget"),·py::arg("thePntMin"),·py::arg("thePntMax"))
 210 ········.def("Inspect",
 211 ·············(void·(NCollection_CellFilter<Inspector>::*)(··const·typename·NCollection_CellFilter<Inspector>::Point·&·,··Inspector·&··)·)·&NCollection_CellFilter<Inspector>::Inspect,
 212 ·············R"#(Inspect·all·targets·in·the·cell·corresponding·to·the·given·point)#"·,py::arg("thePnt"),·py::arg("theInspector"))
 213 ········.def("Inspect",
 214 ·············(void·(NCollection_CellFilter<Inspector>::*)(··const·typename·NCollection_CellFilter<Inspector>::Point·&·,···const·typename·NCollection_CellFilter<Inspector>::Point·&·,··Inspector·&··)·)·&NCollection_CellFilter<Inspector>::Inspect,
 215 ·············R"#(Inspect·all·targets·in·the·cells·range·limited·by·two·given·points·(the·first·point·must·have·all·coordinates·equal·or·less·than·the·same·coordinate·of·the·second·point))#"·,py::arg("thePntMin"),·py::arg("thePntMax"),·py::arg("theInspector"))
 216 ····;
 217 };
  
 218 template·<typename·Type>
 219 void·preregister_template_NCollection_UtfString(py::object·&m,·const·char·*name){
 220 ····py::class_<NCollection_UtfString<Type>·,·shared_ptr<NCollection_UtfString<Type>>·>(m,name,R"#(This·template·class·represent·constant·UTF-*·string.·String·stored·in·memory·continuously,·always·NULL-terminated·and·can·be·used·as·standard·C-string·using·ToCString()·method.)#");
 221 }
  
 222 template·<typename·Type>
 223 void·register_template_NCollection_UtfString(py::object·&m,·const·char·*name){
 224 ····static_cast<py::class_<NCollection_UtfString<Type>·,·shared_ptr<NCollection_UtfString<Type>>·>>(m.attr(name))
 225 ········.def(py::init<··>()··)
 226 ········.def(py::init<··const·NCollection_UtfString<Type>·&·>()·,py::arg("theCopy")·)
 227 ········.def(py::init<··const·char·*,·const·Standard_Integer·>()·,py::arg("theCopyUtf8"),·py::arg("theLength")=static_cast<·const·Standard_Integer>(-·1)·)
 228 ········.def(py::init<··const·Standard_Utf16Char·*,·const·Standard_Integer·>()·,py::arg("theCopyUtf16"),·py::arg("theLength")=static_cast<·const·Standard_Integer>(-·1)·)
 229 ········.def(py::init<··const·Standard_Utf32Char·*,·const·Standard_Integer·>()·,py::arg("theCopyUtf32"),·py::arg("theLength")=static_cast<·const·Standard_Integer>(-·1)·)
 230 ········.def(py::init<··const·Standard_WideChar·*,·const·Standard_Integer·>()·,py::arg("theCopyUtfWide"),·py::arg("theLength")=static_cast<·const·Standard_Integer>(-·1)·)
Max diff block lines reached; 297346/315675 bytes (94.19%) of diff not shown.
⊟
9.04 KB
./usr/share/libocp/OCP/OSD_pre.cpp
Ordering differences only
    
Offset 105, 80 lines modifiedOffset 105, 70 lines modified
105 py::module·m·=·main_module.def_submodule("OSD",·R"#()#");105 py::module·m·=·main_module.def_submodule("OSD",·R"#()#");
  
106 //·add·namespaces·as·submodules106 //·add·namespaces·as·submodules
  
107 //·user-defined·inclusion·per·module·in·the·body107 //·user-defined·inclusion·per·module·in·the·body
  
108 //·enums108 //·enums
109 ····py::enum_<OSD_LoadMode>(m,·"OSD_LoadMode",R"#(This·enumeration·is·used·to·load·shareable·libraries.)#") 
110 ········.value("OSD_RTLD_LAZY",OSD_LoadMode::OSD_RTLD_LAZY) 
111 ········.value("OSD_RTLD_NOW",OSD_LoadMode::OSD_RTLD_NOW).export_values(); 
112 ····py::enum_<OSD_OEMType>(m,·"OSD_OEMType",R"#(This·is·set·of·possible·machine·types·used·in·OSD_Host::MachineType)#")109 ····py::enum_<OSD_OEMType>(m,·"OSD_OEMType",R"#(This·is·set·of·possible·machine·types·used·in·OSD_Host::MachineType)#")
113 ········.value("OSD_Unavailable",OSD_OEMType::OSD_Unavailable)110 ········.value("OSD_Unavailable",OSD_OEMType::OSD_Unavailable)
114 ········.value("OSD_SUN",OSD_OEMType::OSD_SUN)111 ········.value("OSD_SUN",OSD_OEMType::OSD_SUN)
115 ········.value("OSD_DEC",OSD_OEMType::OSD_DEC)112 ········.value("OSD_DEC",OSD_OEMType::OSD_DEC)
116 ········.value("OSD_SGI",OSD_OEMType::OSD_SGI)113 ········.value("OSD_SGI",OSD_OEMType::OSD_SGI)
117 ········.value("OSD_NEC",OSD_OEMType::OSD_NEC)114 ········.value("OSD_NEC",OSD_OEMType::OSD_NEC)
118 ········.value("OSD_MAC",OSD_OEMType::OSD_MAC)115 ········.value("OSD_MAC",OSD_OEMType::OSD_MAC)
119 ········.value("OSD_PC",OSD_OEMType::OSD_PC)116 ········.value("OSD_PC",OSD_OEMType::OSD_PC)
120 ········.value("OSD_HP",OSD_OEMType::OSD_HP)117 ········.value("OSD_HP",OSD_OEMType::OSD_HP)
121 ········.value("OSD_IBM",OSD_OEMType::OSD_IBM)118 ········.value("OSD_IBM",OSD_OEMType::OSD_IBM)
122 ········.value("OSD_VAX",OSD_OEMType::OSD_VAX)119 ········.value("OSD_VAX",OSD_OEMType::OSD_VAX)
123 ········.value("OSD_LIN",OSD_OEMType::OSD_LIN)120 ········.value("OSD_LIN",OSD_OEMType::OSD_LIN)
124 ········.value("OSD_AIX",OSD_OEMType::OSD_AIX).export_values();121 ········.value("OSD_AIX",OSD_OEMType::OSD_AIX).export_values();
125 ····py::enum_<OSD_SignalMode>(m,·"OSD_SignalMode",R"#(Mode·of·operation·for·OSD::SetSignal()·function)#") 
126 ········.value("OSD_SignalMode_AsIs",OSD_SignalMode::OSD_SignalMode_AsIs) 
127 ········.value("OSD_SignalMode_Set",OSD_SignalMode::OSD_SignalMode_Set) 
128 ········.value("OSD_SignalMode_SetUnhandled",OSD_SignalMode::OSD_SignalMode_SetUnhandled) 
129 ········.value("OSD_SignalMode_Unset",OSD_SignalMode::OSD_SignalMode_Unset).export_values(); 
130 ····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.)#") 
131 ········.value("OSD_None",OSD_SingleProtection::OSD_None) 
132 ········.value("OSD_R",OSD_SingleProtection::OSD_R) 
133 ········.value("OSD_W",OSD_SingleProtection::OSD_W) 
134 ········.value("OSD_RW",OSD_SingleProtection::OSD_RW) 
135 ········.value("OSD_X",OSD_SingleProtection::OSD_X) 
136 ········.value("OSD_RX",OSD_SingleProtection::OSD_RX) 
137 ········.value("OSD_WX",OSD_SingleProtection::OSD_WX) 
138 ········.value("OSD_RWX",OSD_SingleProtection::OSD_RWX) 
139 ········.value("OSD_D",OSD_SingleProtection::OSD_D) 
140 ········.value("OSD_RD",OSD_SingleProtection::OSD_RD) 
141 ········.value("OSD_WD",OSD_SingleProtection::OSD_WD) 
142 ········.value("OSD_RWD",OSD_SingleProtection::OSD_RWD) 
143 ········.value("OSD_XD",OSD_SingleProtection::OSD_XD) 
144 ········.value("OSD_RXD",OSD_SingleProtection::OSD_RXD) 
145 ········.value("OSD_WXD",OSD_SingleProtection::OSD_WXD) 
146 ········.value("OSD_RWXD",OSD_SingleProtection::OSD_RWXD).export_values(); 
147 ····py::enum_<OSD_KindFile>(m,·"OSD_KindFile",R"#(Specifies·the·type·of·files.)#") 
148 ········.value("OSD_FILE",OSD_KindFile::OSD_FILE) 
149 ········.value("OSD_DIRECTORY",OSD_KindFile::OSD_DIRECTORY) 
150 ········.value("OSD_LINK",OSD_KindFile::OSD_LINK) 
151 ········.value("OSD_SOCKET",OSD_KindFile::OSD_SOCKET) 
152 ········.value("OSD_UNKNOWN",OSD_KindFile::OSD_UNKNOWN).export_values(); 
153 ····py::enum_<OSD_OpenMode>(m,·"OSD_OpenMode",R"#(Specifies·the·file·open·mode.)#") 
154 ········.value("OSD_ReadOnly",OSD_OpenMode::OSD_ReadOnly) 
155 ········.value("OSD_WriteOnly",OSD_OpenMode::OSD_WriteOnly) 
156 ········.value("OSD_ReadWrite",OSD_OpenMode::OSD_ReadWrite).export_values(); 
157 ····py::enum_<OSD_LockType>(m,·"OSD_LockType",R"#(locks·for·files.·NoLock·is·the·default·value·when·opening·a·file.)#")122 ····py::enum_<OSD_LockType>(m,·"OSD_LockType",R"#(locks·for·files.·NoLock·is·the·default·value·when·opening·a·file.)#")
158 ········.value("OSD_NoLock",OSD_LockType::OSD_NoLock)123 ········.value("OSD_NoLock",OSD_LockType::OSD_NoLock)
159 ········.value("OSD_ReadLock",OSD_LockType::OSD_ReadLock)124 ········.value("OSD_ReadLock",OSD_LockType::OSD_ReadLock)
160 ········.value("OSD_WriteLock",OSD_LockType::OSD_WriteLock)125 ········.value("OSD_WriteLock",OSD_LockType::OSD_WriteLock)
161 ········.value("OSD_ExclusiveLock",OSD_LockType::OSD_ExclusiveLock).export_values();126 ········.value("OSD_ExclusiveLock",OSD_LockType::OSD_ExclusiveLock).export_values();
 127 ····py::enum_<OSD_FromWhere>(m,·"OSD_FromWhere",R"#(Used·by·OSD_File·in·the·method·Seek.)#")
 128 ········.value("OSD_FromBeginning",OSD_FromWhere::OSD_FromBeginning)
 129 ········.value("OSD_FromHere",OSD_FromWhere::OSD_FromHere)
 130 ········.value("OSD_FromEnd",OSD_FromWhere::OSD_FromEnd).export_values();
 131 ····py::enum_<OSD_OpenMode>(m,·"OSD_OpenMode",R"#(Specifies·the·file·open·mode.)#")
 132 ········.value("OSD_ReadOnly",OSD_OpenMode::OSD_ReadOnly)
 133 ········.value("OSD_WriteOnly",OSD_OpenMode::OSD_WriteOnly)
 134 ········.value("OSD_ReadWrite",OSD_OpenMode::OSD_ReadWrite).export_values();
162 ····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.)#")135 ····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.)#")
163 ········.value("OSD_Unknown",OSD_SysType::OSD_Unknown)136 ········.value("OSD_Unknown",OSD_SysType::OSD_Unknown)
164 ········.value("OSD_Default",OSD_SysType::OSD_Default)137 ········.value("OSD_Default",OSD_SysType::OSD_Default)
165 ········.value("OSD_UnixBSD",OSD_SysType::OSD_UnixBSD)138 ········.value("OSD_UnixBSD",OSD_SysType::OSD_UnixBSD)
166 ········.value("OSD_UnixSystemV",OSD_SysType::OSD_UnixSystemV)139 ········.value("OSD_UnixSystemV",OSD_SysType::OSD_UnixSystemV)
167 ········.value("OSD_VMS",OSD_SysType::OSD_VMS)140 ········.value("OSD_VMS",OSD_SysType::OSD_VMS)
168 ········.value("OSD_OS2",OSD_SysType::OSD_OS2)141 ········.value("OSD_OS2",OSD_SysType::OSD_OS2)
169 ········.value("OSD_OSF",OSD_SysType::OSD_OSF)142 ········.value("OSD_OSF",OSD_SysType::OSD_OSF)
170 ········.value("OSD_MacOs",OSD_SysType::OSD_MacOs)143 ········.value("OSD_MacOs",OSD_SysType::OSD_MacOs)
171 ········.value("OSD_Taligent",OSD_SysType::OSD_Taligent)144 ········.value("OSD_Taligent",OSD_SysType::OSD_Taligent)
172 ········.value("OSD_WindowsNT",OSD_SysType::OSD_WindowsNT)145 ········.value("OSD_WindowsNT",OSD_SysType::OSD_WindowsNT)
173 ········.value("OSD_LinuxREDHAT",OSD_SysType::OSD_LinuxREDHAT)146 ········.value("OSD_LinuxREDHAT",OSD_SysType::OSD_LinuxREDHAT)
174 ········.value("OSD_Aix",OSD_SysType::OSD_Aix).export_values();147 ········.value("OSD_Aix",OSD_SysType::OSD_Aix).export_values();
 148 ····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.)#")
 149 ········.value("OSD_None",OSD_SingleProtection::OSD_None)
 150 ········.value("OSD_R",OSD_SingleProtection::OSD_R)
 151 ········.value("OSD_W",OSD_SingleProtection::OSD_W)
 152 ········.value("OSD_RW",OSD_SingleProtection::OSD_RW)
 153 ········.value("OSD_X",OSD_SingleProtection::OSD_X)
 154 ········.value("OSD_RX",OSD_SingleProtection::OSD_RX)
 155 ········.value("OSD_WX",OSD_SingleProtection::OSD_WX)
 156 ········.value("OSD_RWX",OSD_SingleProtection::OSD_RWX)
 157 ········.value("OSD_D",OSD_SingleProtection::OSD_D)
 158 ········.value("OSD_RD",OSD_SingleProtection::OSD_RD)
 159 ········.value("OSD_WD",OSD_SingleProtection::OSD_WD)
 160 ········.value("OSD_RWD",OSD_SingleProtection::OSD_RWD)
 161 ········.value("OSD_XD",OSD_SingleProtection::OSD_XD)
 162 ········.value("OSD_RXD",OSD_SingleProtection::OSD_RXD)
 163 ········.value("OSD_WXD",OSD_SingleProtection::OSD_WXD)
 164 ········.value("OSD_RWXD",OSD_SingleProtection::OSD_RWXD).export_values();
175 ····py::enum_<OSD_WhoAmI>(m,·"OSD_WhoAmI",R"#(Allows·great·accuracy·for·error·management.·This·is·private.)#")165 ····py::enum_<OSD_WhoAmI>(m,·"OSD_WhoAmI",R"#(Allows·great·accuracy·for·error·management.·This·is·private.)#")
176 ········.value("OSD_WDirectory",OSD_WhoAmI::OSD_WDirectory)166 ········.value("OSD_WDirectory",OSD_WhoAmI::OSD_WDirectory)
177 ········.value("OSD_WDirectoryIterator",OSD_WhoAmI::OSD_WDirectoryIterator)167 ········.value("OSD_WDirectoryIterator",OSD_WhoAmI::OSD_WDirectoryIterator)
178 ········.value("OSD_WEnvironment",OSD_WhoAmI::OSD_WEnvironment)168 ········.value("OSD_WEnvironment",OSD_WhoAmI::OSD_WEnvironment)
179 ········.value("OSD_WFile",OSD_WhoAmI::OSD_WFile)169 ········.value("OSD_WFile",OSD_WhoAmI::OSD_WFile)
180 ········.value("OSD_WFileNode",OSD_WhoAmI::OSD_WFileNode)170 ········.value("OSD_WFileNode",OSD_WhoAmI::OSD_WFileNode)
181 ········.value("OSD_WFileIterator",OSD_WhoAmI::OSD_WFileIterator)171 ········.value("OSD_WFileIterator",OSD_WhoAmI::OSD_WFileIterator)
Offset 187, 18 lines modifiedOffset 177, 28 lines modified
187 ········.value("OSD_WProtection",OSD_WhoAmI::OSD_WProtection)177 ········.value("OSD_WProtection",OSD_WhoAmI::OSD_WProtection)
188 ········.value("OSD_WHost",OSD_WhoAmI::OSD_WHost)178 ········.value("OSD_WHost",OSD_WhoAmI::OSD_WHost)
189 ········.value("OSD_WDisk",OSD_WhoAmI::OSD_WDisk)179 ········.value("OSD_WDisk",OSD_WhoAmI::OSD_WDisk)
190 ········.value("OSD_WChronometer",OSD_WhoAmI::OSD_WChronometer)180 ········.value("OSD_WChronometer",OSD_WhoAmI::OSD_WChronometer)
191 ········.value("OSD_WTimer",OSD_WhoAmI::OSD_WTimer)181 ········.value("OSD_WTimer",OSD_WhoAmI::OSD_WTimer)
192 ········.value("OSD_WPackage",OSD_WhoAmI::OSD_WPackage)182 ········.value("OSD_WPackage",OSD_WhoAmI::OSD_WPackage)
193 ········.value("OSD_WEnvironmentIterator",OSD_WhoAmI::OSD_WEnvironmentIterator).export_values();183 ········.value("OSD_WEnvironmentIterator",OSD_WhoAmI::OSD_WEnvironmentIterator).export_values();
194 ····py::enum_<OSD_FromWhere>(m,·"OSD_FromWhere",R"#(Used·by·OSD_File·in·the·method·Seek.)#") 
195 ········.value("OSD_FromBeginning",OSD_FromWhere::OSD_FromBeginning) 
196 ········.value("OSD_FromHere",OSD_FromWhere::OSD_FromHere) 
197 ········.value("OSD_FromEnd",OSD_FromWhere::OSD_FromEnd).export_values();184 ····py::enum_<OSD_SignalMode>(m,·"OSD_SignalMode",R"#(Mode·of·operation·for·OSD::SetSignal()·function)#")
 185 ········.value("OSD_SignalMode_AsIs",OSD_SignalMode::OSD_SignalMode_AsIs)
 186 ········.value("OSD_SignalMode_Set",OSD_SignalMode::OSD_SignalMode_Set)
 187 ········.value("OSD_SignalMode_SetUnhandled",OSD_SignalMode::OSD_SignalMode_SetUnhandled)
 188 ········.value("OSD_SignalMode_Unset",OSD_SignalMode::OSD_SignalMode_Unset).export_values();
 189 ····py::enum_<OSD_KindFile>(m,·"OSD_KindFile",R"#(Specifies·the·type·of·files.)#")
 190 ········.value("OSD_FILE",OSD_KindFile::OSD_FILE)
 191 ········.value("OSD_DIRECTORY",OSD_KindFile::OSD_DIRECTORY)
 192 ········.value("OSD_LINK",OSD_KindFile::OSD_LINK)
 193 ········.value("OSD_SOCKET",OSD_KindFile::OSD_SOCKET)
 194 ········.value("OSD_UNKNOWN",OSD_KindFile::OSD_UNKNOWN).export_values();
Max diff block lines reached; 147/9160 bytes (1.60%) of diff not shown.
⊟
1.02 KB
./usr/share/libocp/OCP/OpenGl.cpp
Ordering differences only
    
Offset 6632, 18 lines modifiedOffset 6632, 18 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·mopencascade·=·static_cast<py::module>(m.attr("opencascade")); 
6639 auto·mOpenGl_HashMapInitializer·=·static_cast<py::module>(m.attr("OpenGl_HashMapInitializer"));6638 auto·mOpenGl_HashMapInitializer·=·static_cast<py::module>(m.attr("OpenGl_HashMapInitializer"));
6640 auto·mOpenGl_Raytrace·=·static_cast<py::module>(m.attr("OpenGl_Raytrace"));6639 auto·mOpenGl_Raytrace·=·static_cast<py::module>(m.attr("OpenGl_Raytrace"));
6641 auto·mOpenGl·=·static_cast<py::module>(m.attr("OpenGl"));6640 auto·mOpenGl·=·static_cast<py::module>(m.attr("OpenGl"));
 6641 auto·mopencascade·=·static_cast<py::module>(m.attr("opencascade"));
  
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
6647 //·/usr/include/opencascade/OpenGl_ArbTexBindless.hxx6647 //·/usr/include/opencascade/OpenGl_ArbTexBindless.hxx
⊟
5.76 KB
./usr/share/libocp/OCP/OpenGl_pre.cpp
Ordering differences only
    
Offset 238, 33 lines modifiedOffset 238, 42 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("opencascade"); 
243 m.def_submodule("OpenGl_HashMapInitializer");242 m.def_submodule("OpenGl_HashMapInitializer");
244 m.def_submodule("OpenGl_Raytrace");243 m.def_submodule("OpenGl_Raytrace");
245 m.def_submodule("OpenGl");244 m.def_submodule("OpenGl");
 245 m.def_submodule("opencascade");
  
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_MaterialFlag>(m,·"OpenGl_MaterialFlag",R"#(Material·flag)#") 
250 ········.value("OpenGl_MaterialFlag_Front",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Front) 
251 ········.value("OpenGl_MaterialFlag_Back",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Back).export_values(); 
252 ····py::enum_<OpenGl_RenderFilter>(m,·"OpenGl_RenderFilter",R"#(Filter·for·rendering·elements.)#")249 ····py::enum_<OpenGl_RenderFilter>(m,·"OpenGl_RenderFilter",R"#(Filter·for·rendering·elements.)#")
253 ········.value("OpenGl_RenderFilter_Empty",OpenGl_RenderFilter::OpenGl_RenderFilter_Empty)250 ········.value("OpenGl_RenderFilter_Empty",OpenGl_RenderFilter::OpenGl_RenderFilter_Empty)
254 ········.value("OpenGl_RenderFilter_OpaqueOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_OpaqueOnly)251 ········.value("OpenGl_RenderFilter_OpaqueOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_OpaqueOnly)
255 ········.value("OpenGl_RenderFilter_TransparentOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_TransparentOnly)252 ········.value("OpenGl_RenderFilter_TransparentOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_TransparentOnly)
256 ········.value("OpenGl_RenderFilter_NonRaytraceableOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_NonRaytraceableOnly)253 ········.value("OpenGl_RenderFilter_NonRaytraceableOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_NonRaytraceableOnly)
257 ········.value("OpenGl_RenderFilter_FillModeOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_FillModeOnly)254 ········.value("OpenGl_RenderFilter_FillModeOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_FillModeOnly)
258 ········.value("OpenGl_RenderFilter_SkipTrsfPersistence",OpenGl_RenderFilter::OpenGl_RenderFilter_SkipTrsfPersistence).export_values();255 ········.value("OpenGl_RenderFilter_SkipTrsfPersistence",OpenGl_RenderFilter::OpenGl_RenderFilter_SkipTrsfPersistence).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_ShaderProgramDumpLevel>(m,·"OpenGl_ShaderProgramDumpLevel",R"#(Definition·of·shader·programs·source·code·dump·levels.)#")
 262 ········.value("OpenGl_ShaderProgramDumpLevel_Off",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Off)
 263 ········.value("OpenGl_ShaderProgramDumpLevel_Short",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Short)
 264 ········.value("OpenGl_ShaderProgramDumpLevel_Full",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Full).export_values();
 265 ····py::enum_<OpenGl_MaterialFlag>(m,·"OpenGl_MaterialFlag",R"#(Material·flag)#")
 266 ········.value("OpenGl_MaterialFlag_Front",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Front)
 267 ········.value("OpenGl_MaterialFlag_Back",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Back).export_values();
259 ····py::enum_<OpenGl_StateVariable>(m,·"OpenGl_StateVariable",R"#(The·enumeration·of·OCCT-specific·OpenGL/GLSL·variables.)#")268 ····py::enum_<OpenGl_StateVariable>(m,·"OpenGl_StateVariable",R"#(The·enumeration·of·OCCT-specific·OpenGL/GLSL·variables.)#")
260 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX)269 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX)
261 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX)270 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX)
262 ········.value("OpenGl_OCC_PROJECTION_MATRIX",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX)271 ········.value("OpenGl_OCC_PROJECTION_MATRIX",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX)
263 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE)272 ········.value("OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE)
264 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE)273 ········.value("OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE)
265 ········.value("OpenGl_OCC_PROJECTION_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX_INVERSE)274 ········.value("OpenGl_OCC_PROJECTION_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX_INVERSE)
Offset 311, 27 lines modifiedOffset 320, 18 lines modified
311 ········.value("OpenGl_MODEL_WORLD_STATE",OpenGl_UniformStateType::OpenGl_MODEL_WORLD_STATE)320 ········.value("OpenGl_MODEL_WORLD_STATE",OpenGl_UniformStateType::OpenGl_MODEL_WORLD_STATE)
312 ········.value("OpenGl_WORLD_VIEW_STATE",OpenGl_UniformStateType::OpenGl_WORLD_VIEW_STATE)321 ········.value("OpenGl_WORLD_VIEW_STATE",OpenGl_UniformStateType::OpenGl_WORLD_VIEW_STATE)
313 ········.value("OpenGl_PROJECTION_STATE",OpenGl_UniformStateType::OpenGl_PROJECTION_STATE)322 ········.value("OpenGl_PROJECTION_STATE",OpenGl_UniformStateType::OpenGl_PROJECTION_STATE)
314 ········.value("OpenGl_MATERIAL_STATE",OpenGl_UniformStateType::OpenGl_MATERIAL_STATE)323 ········.value("OpenGl_MATERIAL_STATE",OpenGl_UniformStateType::OpenGl_MATERIAL_STATE)
315 ········.value("OpenGl_SURF_DETAIL_STATE",OpenGl_UniformStateType::OpenGl_SURF_DETAIL_STATE)324 ········.value("OpenGl_SURF_DETAIL_STATE",OpenGl_UniformStateType::OpenGl_SURF_DETAIL_STATE)
316 ········.value("OpenGL_OIT_STATE",OpenGl_UniformStateType::OpenGL_OIT_STATE)325 ········.value("OpenGL_OIT_STATE",OpenGl_UniformStateType::OpenGL_OIT_STATE)
317 ········.value("OpenGl_UniformStateType_NB",OpenGl_UniformStateType::OpenGl_UniformStateType_NB).export_values();326 ········.value("OpenGl_UniformStateType_NB",OpenGl_UniformStateType::OpenGl_UniformStateType_NB).export_values();
318 ····py::enum_<OpenGl_ShaderProgramDumpLevel>(m,·"OpenGl_ShaderProgramDumpLevel",R"#(Definition·of·shader·programs·source·code·dump·levels.)#") 
319 ········.value("OpenGl_ShaderProgramDumpLevel_Off",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Off) 
320 ········.value("OpenGl_ShaderProgramDumpLevel_Short",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Short) 
321 ········.value("OpenGl_ShaderProgramDumpLevel_Full",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Full).export_values(); 
322 ····py::enum_<OpenGl_FeatureFlag>(m,·"OpenGl_FeatureFlag",R"#()#")327 ····py::enum_<OpenGl_FeatureFlag>(m,·"OpenGl_FeatureFlag",R"#()#")
323 ········.value("OpenGl_FeatureNotAvailable",OpenGl_FeatureFlag::OpenGl_FeatureNotAvailable)328 ········.value("OpenGl_FeatureNotAvailable",OpenGl_FeatureFlag::OpenGl_FeatureNotAvailable)
324 ········.value("OpenGl_FeatureInExtensions",OpenGl_FeatureFlag::OpenGl_FeatureInExtensions)329 ········.value("OpenGl_FeatureInExtensions",OpenGl_FeatureFlag::OpenGl_FeatureInExtensions)
325 ········.value("OpenGl_FeatureInCore",OpenGl_FeatureFlag::OpenGl_FeatureInCore).export_values();330 ········.value("OpenGl_FeatureInCore",OpenGl_FeatureFlag::OpenGl_FeatureInCore).export_values();
326 ····py::enum_<OpenGl_LayerFilter>(m,·"OpenGl_LayerFilter",R"#(Tool·object·to·specify·processed·OpenGL·layers·for·intermixed·rendering·of·raytracable·and·non-raytracable·layers.)#") 
327 ········.value("OpenGl_LF_All",OpenGl_LayerFilter::OpenGl_LF_All) 
328 ········.value("OpenGl_LF_Upper",OpenGl_LayerFilter::OpenGl_LF_Upper) 
329 ········.value("OpenGl_LF_Bottom",OpenGl_LayerFilter::OpenGl_LF_Bottom) 
330 ········.value("OpenGl_LF_RayTracable",OpenGl_LayerFilter::OpenGl_LF_RayTracable).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;
  
  
⊟
11.5 KB
./usr/share/libocp/OCP/OpenGl_tmpl.hxx
Ordering differences only
    
Offset 213, 36 lines modifiedOffset 213, 32 lines modified
  
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>216 template·<typename·T>
217 void·preregister_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){217 void·preregister_template_VectorType(py::object·&m,·const·char·*name){
218 ····py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>(m,name,R"#()#");218 ····py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>(m,name,R"#(Tool·class·for·selecting·appropriate·vector·type.)#");
219 }219 }
  
220 template·<typename·T>220 template·<typename·T>
221 void·register_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){221 void·register_template_VectorType(py::object·&m,·const·char·*name){
 222 ····static_cast<py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>>(m.attr(name))
222 ····static_cast<py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>>(m.attr(name)) 
223 ········.def("Set", 
224 ·············(void·(OpenGl_VariableSetter<T>::*)(··const·handle<OpenGl_Context>·&·,···const·handle<Graphic3d_ShaderVariable>·&·,··OpenGl_ShaderProgram·*··)·)·&OpenGl_VariableSetter<T>::Set, 
225 ·············R"#()#"·,py::arg("theCtx"),·py::arg("theVariable"),·py::arg("theProgram")) 
226 ····;223 ····;
227 };224 };
  
228 template·<typename·K,typename·V>225 template·<typename·T>
229 void·preregister_template_MapListOfType(py::object·&m,·const·char·*name){226 void·preregister_template_MatrixType(py::object·&m,·const·char·*name){
230 ····py::class_<MapListOfType<K,V>·,·shared_ptr<MapListOfType<K,V>>·>(m,name,R"#()#");227 ····py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>(m,name,R"#(Tool·class·for·selecting·appropriate·matrix·type.)#");
231 }228 }
  
232 template·<typename·K,typename·V>229 template·<typename·T>
233 void·register_template_MapListOfType(py::object·&m,·const·char·*name){230 void·register_template_MatrixType(py::object·&m,·const·char·*name){
234 ····static_cast<py::class_<MapListOfType<K,V>·,·shared_ptr<MapListOfType<K,V>>·>>(m.attr(name))231 ····static_cast<py::class_<MatrixType<T>·,·shared_ptr<MatrixType<T>>·>>(m.attr(name))
235 ········.def(py::init<·K,V·>()·,py::arg("theKey"),·py::arg("theValue")·) 
236 ····;232 ····;
237 };233 };
  
238 template·<typename·BaseBufferT>234 template·<typename·BaseBufferT>
239 void·preregister_template_OpenGl_BufferCompatT(py::object·&m,·const·char·*name){235 void·preregister_template_OpenGl_BufferCompatT(py::object·&m,·const·char·*name){
240 ····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).)#");236 ····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).)#");
241 }237 }
Offset 277, 50 lines modifiedOffset 273, 37 lines modified
277 ·············R"#(Update·part·of·the·buffer·with·new·data.)#"·,py::arg("theGlCtx"),·py::arg("theElemFrom"),·py::arg("theElemsNb"),·py::arg("theData"),·py::arg("theDataType"))273 ·············R"#(Update·part·of·the·buffer·with·new·data.)#"·,py::arg("theGlCtx"),·py::arg("theElemFrom"),·py::arg("theElemsNb"),·py::arg("theData"),·py::arg("theDataType"))
278 ········.def("getSubData",274 ········.def("getSubData",
279 ·············(bool·(OpenGl_BufferCompatT<BaseBufferT>::*)(··const·handle<OpenGl_Context>·&·,···const·Standard_Integer·,···const·Standard_Integer·,··void·*·,···const·unsigned·int··)·)·&OpenGl_BufferCompatT<BaseBufferT>::getSubData,275 ·············(bool·(OpenGl_BufferCompatT<BaseBufferT>::*)(··const·handle<OpenGl_Context>·&·,···const·Standard_Integer·,···const·Standard_Integer·,··void·*·,···const·unsigned·int··)·)·&OpenGl_BufferCompatT<BaseBufferT>::getSubData,
280 ·············R"#(Read·back·buffer·sub-range.)#"·,py::arg("theGlCtx"),·py::arg("theElemFrom"),·py::arg("theElemsNb"),·py::arg("theData"),·py::arg("theDataType"))276 ·············R"#(Read·back·buffer·sub-range.)#"·,py::arg("theGlCtx"),·py::arg("theElemFrom"),·py::arg("theElemsNb"),·py::arg("theData"),·py::arg("theDataType"))
281 ····;277 ····;
282 };278 };
  
283 template·<typename·theVec_t>279 template·<typename·T>
284 void·preregister_template_OpenGl_VertexBufferEditor(py::object·&m,·const·char·*name){280 void·preregister_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){
285 ····py::class_<OpenGl_VertexBufferEditor<theVec_t>·,·shared_ptr<OpenGl_VertexBufferEditor<theVec_t>>·>(m,name,R"#(Auxiliary·class·to·iteratively·modify·data·of·existing·VBO.·It·provides·iteration·interface·with·delayed·CPU->GPU·memory·transfer·to·avoid·slow·per-element·data·tran[·...·truncated·by·diffoscope;·len:·238,·SHA:·25131017fc42ca56313f5975e109710852c75e8be1166456d373d54f7e206ee0·...·])#");281 ····py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>(m,name,R"#()#");
286 }282 }
  
287 template·<typename·theVec_t>283 template·<typename·T>
288 void·register_template_OpenGl_VertexBufferEditor(py::object·&m,·const·char·*name){284 void·register_template_OpenGl_VariableSetter(py::object·&m,·const·char·*name){
 285 ····static_cast<py::class_<OpenGl_VariableSetter<T>·,·shared_ptr<OpenGl_VariableSetter<T>>·,·OpenGl_SetterInterface·>>(m.attr(name))
289 ····static_cast<py::class_<OpenGl_VertexBufferEditor<theVec_t>·,·shared_ptr<OpenGl_VertexBufferEditor<theVec_t>>·>>(m.attr(name)) 
290 ········.def(py::init<··const·Standard_Integer·>()·,py::arg("theTmpBufferLength")=static_cast<·const·Standard_Integer>(0)·) 
291 ········.def(py::init<·theVec_t·*,·const·Standard_Integer·>()·,py::arg("theTmpBuffer"),·py::arg("theTmpBufferLength")·) 
292 ········.def("Init", 
293 ·············(Standard_Boolean·(OpenGl_VertexBufferEditor<theVec_t>::*)(··const·handle<OpenGl_Context>·&·,···const·handle<OpenGl_Buffer>·&··)·)·&OpenGl_VertexBufferEditor<theVec_t>::Init, 
294 ·············R"#(Initialize·editor·for·specified·buffer·object.·theGlCtx·[in]·bound·OpenGL·context·to·edit·buffer·object·theVbo·[in]·buffer·to·edit)#"·,py::arg("theGlCtx"),·py::arg("theVbo")) 
295 ········.def("Value", 
296 ·············(theVec_t·&·(OpenGl_VertexBufferEditor<theVec_t>::*)()·)·&OpenGl_VertexBufferEditor<theVec_t>::Value, 
297 ·············R"#(Modify·current·element·in·VBO.)#"·) 
298 ········.def("Next",286 ········.def("Set",
 287 ·············(void·(OpenGl_VariableSetter<T>::*)(··const·handle<OpenGl_Context>·&·,···const·handle<Graphic3d_ShaderVariable>·&·,··OpenGl_ShaderProgram·*··)·)·&OpenGl_VariableSetter<T>::Set,
 288 ·············R"#()#"·,py::arg("theCtx"),·py::arg("theVariable"),·py::arg("theProgram"))
299 ·············(Standard_Boolean·(OpenGl_VertexBufferEditor<theVec_t>::*)()·)·&OpenGl_VertexBufferEditor<theVec_t>::Next, 
300 ·············R"#(Move·to·the·next·position·in·VBO.)#"·) 
301 ········.def("Flush", 
302 ·············(Standard_Boolean·(OpenGl_VertexBufferEditor<theVec_t>::*)()·)·&OpenGl_VertexBufferEditor<theVec_t>::Flush, 
303 ·············R"#(Push·current·data·from·local·buffer·to·VBO.)#"·) 
304 ········.def("GetVBO", 
305 ·············(·const·handle<OpenGl_Buffer>·&·(OpenGl_VertexBufferEditor<theVec_t>::*)()·const)·&OpenGl_VertexBufferEditor<theVec_t>::GetVBO, 
306 ·············R"#(Returns·assigned·VBO)#"·) 
307 ····;289 ····;
308 };290 };
  
309 template·<typename·T>291 template·<typename·K,typename·V>
310 void·preregister_template_OpenGl_TextureFormatSelector(py::object·&m,·const·char·*name){292 void·preregister_template_MapListOfType(py::object·&m,·const·char·*name){
311 ····py::class_<OpenGl_TextureFormatSelector<T>·,·shared_ptr<OpenGl_TextureFormatSelector<T>>·>(m,name,R"#(Selects·preferable·texture·format·for·specified·parameters.)#");293 ····py::class_<MapListOfType<K,V>·,·shared_ptr<MapListOfType<K,V>>·>(m,name,R"#()#");
312 }294 }
  
313 template·<typename·T>295 template·<typename·K,typename·V>
314 void·register_template_OpenGl_TextureFormatSelector(py::object·&m,·const·char·*name){296 void·register_template_MapListOfType(py::object·&m,·const·char·*name){
315 ····static_cast<py::class_<OpenGl_TextureFormatSelector<T>·,·shared_ptr<OpenGl_TextureFormatSelector<T>>·>>(m.attr(name))297 ····static_cast<py::class_<MapListOfType<K,V>·,·shared_ptr<MapListOfType<K,V>>·>>(m.attr(name))
 298 ········.def(py::init<·K,V·>()·,py::arg("theKey"),·py::arg("theValue")·)
316 ····;299 ····;
317 };300 };
  
318 template·<typename·T>301 template·<typename·T>
319 void·preregister_template_OpenGl_MatrixState(py::object·&m,·const·char·*name){302 void·preregister_template_OpenGl_MatrixState(py::object·&m,·const·char·*name){
320 ····py::class_<OpenGl_MatrixState<T>·,·shared_ptr<OpenGl_MatrixState<T>>·>(m,name,R"#(Software·implementation·for·OpenGL·matrix·stack.)#");303 ····py::class_<OpenGl_MatrixState<T>·,·shared_ptr<OpenGl_MatrixState<T>>·>(m,name,R"#(Software·implementation·for·OpenGL·matrix·stack.)#");
321 }304 }
Offset 349, 32 lines modifiedOffset 332, 49 lines modified
349 ·············R"#(Sets·current·matrix·to·identity.)#"·)332 ·············R"#(Sets·current·matrix·to·identity.)#"·)
350 ········.def("DumpJson",333 ········.def("DumpJson",
351 ·············(void·(OpenGl_MatrixState<T>::*)(·Standard_OStream·&·,··Standard_Integer··)·const)·&OpenGl_MatrixState<T>::DumpJson,334 ·············(void·(OpenGl_MatrixState<T>::*)(·Standard_OStream·&·,··Standard_Integer··)·const)·&OpenGl_MatrixState<T>::DumpJson,
352 ·············R"#(Dumps·the·content·of·me·into·the·stream)#"·,py::arg("theOStream"),·py::arg("theDepth")=static_cast<Standard_Integer>(-·1))335 ·············R"#(Dumps·the·content·of·me·into·the·stream)#"·,py::arg("theOStream"),·py::arg("theDepth")=static_cast<Standard_Integer>(-·1))
353 ····;336 ····;
354 };337 };
  
355 template·<typename·T>338 template·<typename·theVec_t>
356 void·preregister_template_VectorType(py::object·&m,·const·char·*name){339 void·preregister_template_OpenGl_VertexBufferEditor(py::object·&m,·const·char·*name){
357 ····py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>(m,name,R"#(Tool·class·for·selecting·appropriate·vector·type.)#");340 ····py::class_<OpenGl_VertexBufferEditor<theVec_t>·,·shared_ptr<OpenGl_VertexBufferEditor<theVec_t>>·>(m,name,R"#(Auxiliary·class·to·iteratively·modify·data·of·existing·VBO.·It·provides·iteration·interface·with·delayed·CPU->GPU·memory·transfer·to·avoid·slow·per-element·d[·...·truncated·by·diffoscope;·len:·245,·SHA:·22d39330856f8b1a3738b4945d81d8d15365c9acd6174f5f1a6807b330dd5681·...·].)#");
358 }341 }
  
359 template·<typename·T>342 template·<typename·theVec_t>
360 void·register_template_VectorType(py::object·&m,·const·char·*name){343 void·register_template_OpenGl_VertexBufferEditor(py::object·&m,·const·char·*name){
361 ····static_cast<py::class_<VectorType<T>·,·shared_ptr<VectorType<T>>·>>(m.attr(name))344 ····static_cast<py::class_<OpenGl_VertexBufferEditor<theVec_t>·,·shared_ptr<OpenGl_VertexBufferEditor<theVec_t>>·>>(m.attr(name))
 345 ········.def(py::init<··const·Standard_Integer·>()·,py::arg("theTmpBufferLength")=static_cast<·const·Standard_Integer>(0)·)
 346 ········.def(py::init<·theVec_t·*,·const·Standard_Integer·>()·,py::arg("theTmpBuffer"),·py::arg("theTmpBufferLength")·)
 347 ········.def("Init",
 348 ·············(Standard_Boolean·(OpenGl_VertexBufferEditor<theVec_t>::*)(··const·handle<OpenGl_Context>·&·,···const·handle<OpenGl_Buffer>·&··)·)·&OpenGl_VertexBufferEditor<theVec_t>::Init,
 349 ·············R"#(Initialize·editor·for·specified·buffer·object.·theGlCtx·[in]·bound·OpenGL·context·to·edit·buffer·object·theVbo·[in]·buffer·to·edit)#"·,py::arg("theGlCtx"),·py::arg("theVbo"))
 350 ········.def("Value",
 351 ·············(theVec_t·&·(OpenGl_VertexBufferEditor<theVec_t>::*)()·)·&OpenGl_VertexBufferEditor<theVec_t>::Value,
 352 ·············R"#(Modify·current·element·in·VBO.)#"·)
 353 ········.def("Next",
 354 ·············(Standard_Boolean·(OpenGl_VertexBufferEditor<theVec_t>::*)()·)·&OpenGl_VertexBufferEditor<theVec_t>::Next,
 355 ·············R"#(Move·to·the·next·position·in·VBO.)#"·)
 356 ········.def("Flush",
 357 ·············(Standard_Boolean·(OpenGl_VertexBufferEditor<theVec_t>::*)()·)·&OpenGl_VertexBufferEditor<theVec_t>::Flush,
 358 ·············R"#(Push·current·data·from·local·buffer·to·VBO.)#"·)
 359 ········.def("GetVBO",
 360 ·············(·const·handle<OpenGl_Buffer>·&·(OpenGl_VertexBufferEditor<theVec_t>::*)()·const)·&OpenGl_VertexBufferEditor<theVec_t>::GetVBO,
 361 ·············R"#(Returns·assigned·VBO)#"·)
362 ····;362 ····;
363 };363 };
Max diff block lines reached; 916/11717 bytes (7.82%) of diff not shown.
⊟
4.38 KB
./usr/share/libocp/OCP/PCDM_pre.cpp
Ordering differences only
    
Offset 73, 14 lines modifiedOffset 73, 19 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_TypeOfFileDriver>(m,·"PCDM_TypeOfFileDriver",R"#()#")
 78 ········.value("PCDM_TOFD_File",PCDM_TypeOfFileDriver::PCDM_TOFD_File)
 79 ········.value("PCDM_TOFD_CmpFile",PCDM_TypeOfFileDriver::PCDM_TOFD_CmpFile)
 80 ········.value("PCDM_TOFD_XmlFile",PCDM_TypeOfFileDriver::PCDM_TOFD_XmlFile)
 81 ········.value("PCDM_TOFD_Unknown",PCDM_TypeOfFileDriver::PCDM_TOFD_Unknown).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;)#")82 ····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)83 ········.value("PCDM_RS_OK",PCDM_ReaderStatus::PCDM_RS_OK)
79 ········.value("PCDM_RS_NoDriver",PCDM_ReaderStatus::PCDM_RS_NoDriver)84 ········.value("PCDM_RS_NoDriver",PCDM_ReaderStatus::PCDM_RS_NoDriver)
80 ········.value("PCDM_RS_UnknownFileDriver",PCDM_ReaderStatus::PCDM_RS_UnknownFileDriver)85 ········.value("PCDM_RS_UnknownFileDriver",PCDM_ReaderStatus::PCDM_RS_UnknownFileDriver)
81 ········.value("PCDM_RS_OpenError",PCDM_ReaderStatus::PCDM_RS_OpenError)86 ········.value("PCDM_RS_OpenError",PCDM_ReaderStatus::PCDM_RS_OpenError)
82 ········.value("PCDM_RS_NoVersion",PCDM_ReaderStatus::PCDM_RS_NoVersion)87 ········.value("PCDM_RS_NoVersion",PCDM_ReaderStatus::PCDM_RS_NoVersion)
83 ········.value("PCDM_RS_NoSchema",PCDM_ReaderStatus::PCDM_RS_NoSchema)88 ········.value("PCDM_RS_NoSchema",PCDM_ReaderStatus::PCDM_RS_NoSchema)
Offset 97, 19 lines modifiedOffset 102, 14 lines modified
97 ········.value("PCDM_RS_AlreadyRetrievedAndModified",PCDM_ReaderStatus::PCDM_RS_AlreadyRetrievedAndModified)102 ········.value("PCDM_RS_AlreadyRetrievedAndModified",PCDM_ReaderStatus::PCDM_RS_AlreadyRetrievedAndModified)
98 ········.value("PCDM_RS_AlreadyRetrieved",PCDM_ReaderStatus::PCDM_RS_AlreadyRetrieved)103 ········.value("PCDM_RS_AlreadyRetrieved",PCDM_ReaderStatus::PCDM_RS_AlreadyRetrieved)
99 ········.value("PCDM_RS_UnknownDocument",PCDM_ReaderStatus::PCDM_RS_UnknownDocument)104 ········.value("PCDM_RS_UnknownDocument",PCDM_ReaderStatus::PCDM_RS_UnknownDocument)
100 ········.value("PCDM_RS_WrongResource",PCDM_ReaderStatus::PCDM_RS_WrongResource)105 ········.value("PCDM_RS_WrongResource",PCDM_ReaderStatus::PCDM_RS_WrongResource)
101 ········.value("PCDM_RS_ReaderException",PCDM_ReaderStatus::PCDM_RS_ReaderException)106 ········.value("PCDM_RS_ReaderException",PCDM_ReaderStatus::PCDM_RS_ReaderException)
102 ········.value("PCDM_RS_NoModel",PCDM_ReaderStatus::PCDM_RS_NoModel)107 ········.value("PCDM_RS_NoModel",PCDM_ReaderStatus::PCDM_RS_NoModel)
103 ········.value("PCDM_RS_UserBreak",PCDM_ReaderStatus::PCDM_RS_UserBreak).export_values();108 ········.value("PCDM_RS_UserBreak",PCDM_ReaderStatus::PCDM_RS_UserBreak).export_values();
104 ····py::enum_<PCDM_TypeOfFileDriver>(m,·"PCDM_TypeOfFileDriver",R"#()#") 
105 ········.value("PCDM_TOFD_File",PCDM_TypeOfFileDriver::PCDM_TOFD_File) 
106 ········.value("PCDM_TOFD_CmpFile",PCDM_TypeOfFileDriver::PCDM_TOFD_CmpFile) 
107 ········.value("PCDM_TOFD_XmlFile",PCDM_TypeOfFileDriver::PCDM_TOFD_XmlFile) 
108 ········.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.)#")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)110 ········.value("PCDM_SS_OK",PCDM_StoreStatus::PCDM_SS_OK)
111 ········.value("PCDM_SS_DriverFailure",PCDM_StoreStatus::PCDM_SS_DriverFailure)111 ········.value("PCDM_SS_DriverFailure",PCDM_StoreStatus::PCDM_SS_DriverFailure)
112 ········.value("PCDM_SS_WriteFailure",PCDM_StoreStatus::PCDM_SS_WriteFailure)112 ········.value("PCDM_SS_WriteFailure",PCDM_StoreStatus::PCDM_SS_WriteFailure)
113 ········.value("PCDM_SS_Failure",PCDM_StoreStatus::PCDM_SS_Failure)113 ········.value("PCDM_SS_Failure",PCDM_StoreStatus::PCDM_SS_Failure)
114 ········.value("PCDM_SS_Doc_IsNull",PCDM_StoreStatus::PCDM_SS_Doc_IsNull)114 ········.value("PCDM_SS_Doc_IsNull",PCDM_StoreStatus::PCDM_SS_Doc_IsNull)
115 ········.value("PCDM_SS_No_Obj",PCDM_StoreStatus::PCDM_SS_No_Obj)115 ········.value("PCDM_SS_No_Obj",PCDM_StoreStatus::PCDM_SS_No_Obj)
⊟
13.9 KB
./usr/share/libocp/OCP/Prs3d_pre.cpp
Ordering differences only
    
Offset 84, 26 lines modifiedOffset 84, 30 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_TypeOfHighlight>(m,·"Prs3d_TypeOfHighlight",R"#(Type·of·highlighting·to·apply·specific·style.)#") 
89 ········.value("Prs3d_TypeOfHighlight_None",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_None) 
90 ········.value("Prs3d_TypeOfHighlight_Selected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Selected) 
91 ········.value("Prs3d_TypeOfHighlight_Dynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Dynamic) 
92 ········.value("Prs3d_TypeOfHighlight_LocalSelected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalSelected) 
93 ········.value("Prs3d_TypeOfHighlight_LocalDynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalDynamic) 
94 ········.value("Prs3d_TypeOfHighlight_SubIntensity",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_SubIntensity) 
95 ········.value("Prs3d_TypeOfHighlight_NB",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_NB).export_values(); 
96 ····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[·...·truncated·by·diffoscope;·len:·74,·SHA:·f284ad01796fa0dcfab9a00e28b2be7e17a2183ada670ed07e5429e6d52849d6·...·])#")88 ····py::enum_<Prs3d_DatumMode>(m,·"Prs3d_DatumMode",R"#(Enumeration·defining·a·mode·of·datum·graphic·presentation,·see·Prs3d_Datum.)#")
 89 ········.value("Prs3d_DM_WireFrame",Prs3d_DatumMode::Prs3d_DM_WireFrame)
 90 ········.value("Prs3d_DM_Shaded",Prs3d_DatumMode::Prs3d_DM_Shaded).export_values();
 91 ····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.)#")
 92 ········.value("Prs3d_DTVP_Above",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Above)
 93 ········.value("Prs3d_DTVP_Below",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Below)
 94 ········.value("Prs3d_DTVP_Center",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Center).export_values();
 95 ····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.)#")
 96 ········.value("Prs3d_DTHP_Left",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Left)
 97 ········.value("Prs3d_DTHP_Right",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Right)
97 ········.value("Prs3d_DAO_Internal",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Internal)98 ········.value("Prs3d_DTHP_Center",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Center)
98 ········.value("Prs3d_DAO_External",Prs3d_DimensionArrowOrientation::Prs3d_DAO_External) 
99 ········.value("Prs3d_DAO_Fit",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Fit).export_values();99 ········.value("Prs3d_DTHP_Fit",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Fit).export_values();
 100 ····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.)#")
 101 ········.value("Prs3d_VDM_Isolated",Prs3d_VertexDrawMode::Prs3d_VDM_Isolated)
 102 ········.value("Prs3d_VDM_All",Prs3d_VertexDrawMode::Prs3d_VDM_All)
 103 ········.value("Prs3d_VDM_Inherited",Prs3d_VertexDrawMode::Prs3d_VDM_Inherited).export_values();
100 ····py::enum_<Prs3d_DatumParts>(m,·"Prs3d_DatumParts",R"#(Enumeration·defining·a·part·of·datum·aspect,·see·Prs3d_Datum.)#")104 ····py::enum_<Prs3d_DatumParts>(m,·"Prs3d_DatumParts",R"#(Enumeration·defining·a·part·of·datum·aspect,·see·Prs3d_Datum.)#")
101 ········.value("Prs3d_DatumParts_Origin",Prs3d_DatumParts::Prs3d_DatumParts_Origin)105 ········.value("Prs3d_DatumParts_Origin",Prs3d_DatumParts::Prs3d_DatumParts_Origin)
102 ········.value("Prs3d_DatumParts_XAxis",Prs3d_DatumParts::Prs3d_DatumParts_XAxis)106 ········.value("Prs3d_DatumParts_XAxis",Prs3d_DatumParts::Prs3d_DatumParts_XAxis)
103 ········.value("Prs3d_DatumParts_YAxis",Prs3d_DatumParts::Prs3d_DatumParts_YAxis)107 ········.value("Prs3d_DatumParts_YAxis",Prs3d_DatumParts::Prs3d_DatumParts_YAxis)
104 ········.value("Prs3d_DatumParts_ZAxis",Prs3d_DatumParts::Prs3d_DatumParts_ZAxis)108 ········.value("Prs3d_DatumParts_ZAxis",Prs3d_DatumParts::Prs3d_DatumParts_ZAxis)
105 ········.value("Prs3d_DatumParts_XArrow",Prs3d_DatumParts::Prs3d_DatumParts_XArrow)109 ········.value("Prs3d_DatumParts_XArrow",Prs3d_DatumParts::Prs3d_DatumParts_XArrow)
106 ········.value("Prs3d_DatumParts_YArrow",Prs3d_DatumParts::Prs3d_DatumParts_YArrow)110 ········.value("Prs3d_DatumParts_YArrow",Prs3d_DatumParts::Prs3d_DatumParts_YArrow)
Offset 120, 18 lines modifiedOffset 124, 18 lines modified
120 ········.value("Prs3d_DP_YArrow",Prs3d_DatumParts::Prs3d_DP_YArrow)124 ········.value("Prs3d_DP_YArrow",Prs3d_DatumParts::Prs3d_DP_YArrow)
121 ········.value("Prs3d_DP_ZArrow",Prs3d_DatumParts::Prs3d_DP_ZArrow)125 ········.value("Prs3d_DP_ZArrow",Prs3d_DatumParts::Prs3d_DP_ZArrow)
122 ········.value("Prs3d_DP_XOYAxis",Prs3d_DatumParts::Prs3d_DP_XOYAxis)126 ········.value("Prs3d_DP_XOYAxis",Prs3d_DatumParts::Prs3d_DP_XOYAxis)
123 ········.value("Prs3d_DP_YOZAxis",Prs3d_DatumParts::Prs3d_DP_YOZAxis)127 ········.value("Prs3d_DP_YOZAxis",Prs3d_DatumParts::Prs3d_DP_YOZAxis)
124 ········.value("Prs3d_DP_XOZAxis",Prs3d_DatumParts::Prs3d_DP_XOZAxis)128 ········.value("Prs3d_DP_XOZAxis",Prs3d_DatumParts::Prs3d_DP_XOZAxis)
125 ········.value("Prs3d_DP_None",Prs3d_DatumParts::Prs3d_DP_None).export_values();129 ········.value("Prs3d_DP_None",Prs3d_DatumParts::Prs3d_DP_None).export_values();
126 ····m.attr("Prs3d_DatumParts_NB")·=·py::cast(int(Prs3d_DatumParts_NB));130 ····m.attr("Prs3d_DatumParts_NB")·=·py::cast(int(Prs3d_DatumParts_NB));
127 ····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.)#") 
128 ········.value("Prs3d_VDM_Isolated",Prs3d_VertexDrawMode::Prs3d_VDM_Isolated) 
129 ········.value("Prs3d_VDM_All",Prs3d_VertexDrawMode::Prs3d_VDM_All) 
130 ········.value("Prs3d_VDM_Inherited",Prs3d_VertexDrawMode::Prs3d_VDM_Inherited).export_values();131 ····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·th[·...·truncated·by·diffoscope;·len:·158,·SHA:·6e764b91411803c41690a97535b37955bc1906c1d963faf96de1e745857b8317·...·]
 132 ········.value("Prs3d_TOH_NotSet",Prs3d_TypeOfHLR::Prs3d_TOH_NotSet)
 133 ········.value("Prs3d_TOH_PolyAlgo",Prs3d_TypeOfHLR::Prs3d_TOH_PolyAlgo)
 134 ········.value("Prs3d_TOH_Algo",Prs3d_TypeOfHLR::Prs3d_TOH_Algo).export_values();
131 ····py::enum_<Prs3d_DatumAttribute>(m,·"Prs3d_DatumAttribute",R"#(Enumeration·defining·a·datum·attribute,·see·Prs3d_Datum.)#")135 ····py::enum_<Prs3d_DatumAttribute>(m,·"Prs3d_DatumAttribute",R"#(Enumeration·defining·a·datum·attribute,·see·Prs3d_Datum.)#")
132 ········.value("Prs3d_DatumAttribute_XAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_XAxisLength)136 ········.value("Prs3d_DatumAttribute_XAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_XAxisLength)
133 ········.value("Prs3d_DatumAttribute_YAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_YAxisLength)137 ········.value("Prs3d_DatumAttribute_YAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_YAxisLength)
134 ········.value("Prs3d_DatumAttribute_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ZAxisLength)138 ········.value("Prs3d_DatumAttribute_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ZAxisLength)
135 ········.value("Prs3d_DatumAttribute_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingTubeRadiusPercent)139 ········.value("Prs3d_DatumAttribute_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingTubeRadiusPercent)
136 ········.value("Prs3d_DatumAttribute_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeRadiusPercent)140 ········.value("Prs3d_DatumAttribute_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeRadiusPercent)
137 ········.value("Prs3d_DatumAttribute_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeLengthPercent)141 ········.value("Prs3d_DatumAttribute_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DatumAttribute_ShadingConeLengthPercent)
Offset 142, 25 lines modifiedOffset 146, 22 lines modified
142 ········.value("Prs3d_DA_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DA_ZAxisLength)146 ········.value("Prs3d_DA_ZAxisLength",Prs3d_DatumAttribute::Prs3d_DA_ZAxisLength)
143 ········.value("Prs3d_DP_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingTubeRadiusPercent)147 ········.value("Prs3d_DP_ShadingTubeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingTubeRadiusPercent)
144 ········.value("Prs3d_DP_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeRadiusPercent)148 ········.value("Prs3d_DP_ShadingConeRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeRadiusPercent)
145 ········.value("Prs3d_DP_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeLengthPercent)149 ········.value("Prs3d_DP_ShadingConeLengthPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingConeLengthPercent)
146 ········.value("Prs3d_DP_ShadingOriginRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingOriginRadiusPercent)150 ········.value("Prs3d_DP_ShadingOriginRadiusPercent",Prs3d_DatumAttribute::Prs3d_DP_ShadingOriginRadiusPercent)
147 ········.value("Prs3d_DP_ShadingNumberOfFacettes",Prs3d_DatumAttribute::Prs3d_DP_ShadingNumberOfFacettes).export_values();151 ········.value("Prs3d_DP_ShadingNumberOfFacettes",Prs3d_DatumAttribute::Prs3d_DP_ShadingNumberOfFacettes).export_values();
148 ····m.attr("Prs3d_DatumAttribute_NB")·=·py::cast(int(Prs3d_DatumAttribute_NB));152 ····m.attr("Prs3d_DatumAttribute_NB")·=·py::cast(int(Prs3d_DatumAttribute_NB));
 153 ····py::enum_<Prs3d_TypeOfHighlight>(m,·"Prs3d_TypeOfHighlight",R"#(Type·of·highlighting·to·apply·specific·style.)#")
 154 ········.value("Prs3d_TypeOfHighlight_None",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_None)
 155 ········.value("Prs3d_TypeOfHighlight_Selected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Selected)
 156 ········.value("Prs3d_TypeOfHighlight_Dynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_Dynamic)
 157 ········.value("Prs3d_TypeOfHighlight_LocalSelected",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalSelected)
 158 ········.value("Prs3d_TypeOfHighlight_LocalDynamic",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_LocalDynamic)
 159 ········.value("Prs3d_TypeOfHighlight_SubIntensity",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_SubIntensity)
 160 ········.value("Prs3d_TypeOfHighlight_NB",Prs3d_TypeOfHighlight::Prs3d_TypeOfHighlight_NB).export_values();
149 ····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.)#") 
150 ········.value("Prs3d_DTHP_Left",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Left) 
151 ········.value("Prs3d_DTHP_Right",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Right) 
152 ········.value("Prs3d_DTHP_Center",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Center) 
153 ········.value("Prs3d_DTHP_Fit",Prs3d_DimensionTextHorizontalPosition::Prs3d_DTHP_Fit).export_values(); 
154 ····py::enum_<Prs3d_DatumMode>(m,·"Prs3d_DatumMode",R"#(Enumeration·defining·a·mode·of·datum·graphic·presentation,·see·Prs3d_Datum.)#") 
155 ········.value("Prs3d_DM_WireFrame",Prs3d_DatumMode::Prs3d_DM_WireFrame) 
156 ········.value("Prs3d_DM_Shaded",Prs3d_DatumMode::Prs3d_DM_Shaded).export_values(); 
157 ····py::enum_<Prs3d_TypeOfLinePicking>(m,·"Prs3d_TypeOfLinePicking",R"#()#") 
158 ········.value("Prs3d_TOLP_Point",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Point) 
159 ········.value("Prs3d_TOLP_Segment",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Segment).export_values(); 
160 ····py::enum_<Prs3d_DatumAxes>(m,·"Prs3d_DatumAxes",R"#(Enumeration·defining·axes·used·in·datum·aspect,·see·Prs3d_Datum.)#")161 ····py::enum_<Prs3d_DatumAxes>(m,·"Prs3d_DatumAxes",R"#(Enumeration·defining·axes·used·in·datum·aspect,·see·Prs3d_Datum.)#")
161 ········.value("Prs3d_DatumAxes_XAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_XAxis)162 ········.value("Prs3d_DatumAxes_XAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_XAxis)
162 ········.value("Prs3d_DatumAxes_YAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_YAxis)163 ········.value("Prs3d_DatumAxes_YAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_YAxis)
163 ········.value("Prs3d_DatumAxes_ZAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_ZAxis)164 ········.value("Prs3d_DatumAxes_ZAxis",Prs3d_DatumAxes::Prs3d_DatumAxes_ZAxis)
164 ········.value("Prs3d_DatumAxes_XYAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XYAxes)165 ········.value("Prs3d_DatumAxes_XYAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XYAxes)
165 ········.value("Prs3d_DatumAxes_YZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_YZAxes)166 ········.value("Prs3d_DatumAxes_YZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_YZAxes)
166 ········.value("Prs3d_DatumAxes_XZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XZAxes)167 ········.value("Prs3d_DatumAxes_XZAxes",Prs3d_DatumAxes::Prs3d_DatumAxes_XZAxes)
Offset 168, 22 lines modifiedOffset 169, 21 lines modified
168 ········.value("Prs3d_DA_XAxis",Prs3d_DatumAxes::Prs3d_DA_XAxis)169 ········.value("Prs3d_DA_XAxis",Prs3d_DatumAxes::Prs3d_DA_XAxis)
169 ········.value("Prs3d_DA_YAxis",Prs3d_DatumAxes::Prs3d_DA_YAxis)170 ········.value("Prs3d_DA_YAxis",Prs3d_DatumAxes::Prs3d_DA_YAxis)
170 ········.value("Prs3d_DA_ZAxis",Prs3d_DatumAxes::Prs3d_DA_ZAxis)171 ········.value("Prs3d_DA_ZAxis",Prs3d_DatumAxes::Prs3d_DA_ZAxis)
171 ········.value("Prs3d_DA_XYAxis",Prs3d_DatumAxes::Prs3d_DA_XYAxis)172 ········.value("Prs3d_DA_XYAxis",Prs3d_DatumAxes::Prs3d_DA_XYAxis)
172 ········.value("Prs3d_DA_YZAxis",Prs3d_DatumAxes::Prs3d_DA_YZAxis)173 ········.value("Prs3d_DA_YZAxis",Prs3d_DatumAxes::Prs3d_DA_YZAxis)
173 ········.value("Prs3d_DA_XZAxis",Prs3d_DatumAxes::Prs3d_DA_XZAxis)174 ········.value("Prs3d_DA_XZAxis",Prs3d_DatumAxes::Prs3d_DA_XZAxis)
174 ········.value("Prs3d_DA_XYZAxis",Prs3d_DatumAxes::Prs3d_DA_XYZAxis).export_values();175 ········.value("Prs3d_DA_XYZAxis",Prs3d_DatumAxes::Prs3d_DA_XYZAxis).export_values();
175 ····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·r[·...·truncated·by·diffoscope;·len:·132,·SHA:·d10722dcd22859dcb85610092fa6a8075df88bccd5a911e1e2d109e0468ce8dc·...·])#")176 ····py::enum_<Prs3d_TypeOfLinePicking>(m,·"Prs3d_TypeOfLinePicking",R"#()#")
176 ········.value("Prs3d_TOH_NotSet",Prs3d_TypeOfHLR::Prs3d_TOH_NotSet)177 ········.value("Prs3d_TOLP_Point",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Point)
177 ········.value("Prs3d_TOH_PolyAlgo",Prs3d_TypeOfHLR::Prs3d_TOH_PolyAlgo) 
178 ········.value("Prs3d_TOH_Algo",Prs3d_TypeOfHLR::Prs3d_TOH_Algo).export_values();178 ········.value("Prs3d_TOLP_Segment",Prs3d_TypeOfLinePicking::Prs3d_TOLP_Segment).export_values();
179 ····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.)#") 
180 ········.value("Prs3d_DTVP_Above",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Above) 
181 ········.value("Prs3d_DTVP_Below",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Below)179 ····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·o[·...·truncated·by·diffoscope;·len:·94,·SHA:·6115cdfb90f8ebe1d2c7902c0e3a599bc76595a5e984fd6c04e448d44d2e148b·...·])
 180 ········.value("Prs3d_DAO_Internal",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Internal)
 181 ········.value("Prs3d_DAO_External",Prs3d_DimensionArrowOrientation::Prs3d_DAO_External)
182 ········.value("Prs3d_DTVP_Center",Prs3d_DimensionTextVerticalPosition::Prs3d_DTVP_Center).export_values();182 ········.value("Prs3d_DAO_Fit",Prs3d_DimensionArrowOrientation::Prs3d_DAO_Fit).export_values();
  
183 //Python·trampoline·classes183 //Python·trampoline·classes
184 ····class·Py_Prs3d_BasicAspect·:·public·Prs3d_BasicAspect{184 ····class·Py_Prs3d_BasicAspect·:·public·Prs3d_BasicAspect{
185 ····public:185 ····public:
186 ········using·Prs3d_BasicAspect::Prs3d_BasicAspect;186 ········using·Prs3d_BasicAspect::Prs3d_BasicAspect;
  
  
⊟
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();
60 ····py::enum_<PrsMgr_DisplayStatus>(m,·"PrsMgr_DisplayStatus",R"#(To·give·the·display·status·of·an·Interactive·Object.)#")63 ····py::enum_<PrsMgr_DisplayStatus>(m,·"PrsMgr_DisplayStatus",R"#(To·give·the·display·status·of·an·Interactive·Object.)#")
61 ········.value("PrsMgr_DisplayStatus_Displayed",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Displayed)64 ········.value("PrsMgr_DisplayStatus_Displayed",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Displayed)
62 ········.value("PrsMgr_DisplayStatus_Erased",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Erased)65 ········.value("PrsMgr_DisplayStatus_Erased",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_Erased)
63 ········.value("PrsMgr_DisplayStatus_None",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_None)66 ········.value("PrsMgr_DisplayStatus_None",PrsMgr_DisplayStatus::PrsMgr_DisplayStatus_None)
64 ········.value("AIS_DS_Displayed",PrsMgr_DisplayStatus::AIS_DS_Displayed)67 ········.value("AIS_DS_Displayed",PrsMgr_DisplayStatus::AIS_DS_Displayed)
65 ········.value("AIS_DS_Erased",PrsMgr_DisplayStatus::AIS_DS_Erased)68 ········.value("AIS_DS_Erased",PrsMgr_DisplayStatus::AIS_DS_Erased)
66 ········.value("AIS_DS_None",PrsMgr_DisplayStatus::AIS_DS_None).export_values();69 ········.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, 14 lines modifiedOffset 44, 20 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();
48 ····py::enum_<Quantity_NameOfColor>(m,·"Quantity_NameOfColor",R"#(Definition·of·names·of·known·colors.·The·names·come·(mostly)·from·the·X11·specification.)#")54 ····py::enum_<Quantity_NameOfColor>(m,·"Quantity_NameOfColor",R"#(Definition·of·names·of·known·colors.·The·names·come·(mostly)·from·the·X11·specification.)#")
49 ········.value("Quantity_NOC_BLACK",Quantity_NameOfColor::Quantity_NOC_BLACK)55 ········.value("Quantity_NOC_BLACK",Quantity_NameOfColor::Quantity_NOC_BLACK)
50 ········.value("Quantity_NOC_MATRABLUE",Quantity_NameOfColor::Quantity_NOC_MATRABLUE)56 ········.value("Quantity_NOC_MATRABLUE",Quantity_NameOfColor::Quantity_NOC_MATRABLUE)
51 ········.value("Quantity_NOC_MATRAGRAY",Quantity_NameOfColor::Quantity_NOC_MATRAGRAY)57 ········.value("Quantity_NOC_MATRAGRAY",Quantity_NameOfColor::Quantity_NOC_MATRAGRAY)
52 ········.value("Quantity_NOC_ALICEBLUE",Quantity_NameOfColor::Quantity_NOC_ALICEBLUE)58 ········.value("Quantity_NOC_ALICEBLUE",Quantity_NameOfColor::Quantity_NOC_ALICEBLUE)
53 ········.value("Quantity_NOC_ANTIQUEWHITE",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE)59 ········.value("Quantity_NOC_ANTIQUEWHITE",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE)
54 ········.value("Quantity_NOC_ANTIQUEWHITE1",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE1)60 ········.value("Quantity_NOC_ANTIQUEWHITE1",Quantity_NameOfColor::Quantity_NOC_ANTIQUEWHITE1)
Offset 566, 20 lines modifiedOffset 572, 14 lines modified
566 ········.value("Quantity_NOC_YELLOW",Quantity_NameOfColor::Quantity_NOC_YELLOW)572 ········.value("Quantity_NOC_YELLOW",Quantity_NameOfColor::Quantity_NOC_YELLOW)
567 ········.value("Quantity_NOC_YELLOW1",Quantity_NameOfColor::Quantity_NOC_YELLOW1)573 ········.value("Quantity_NOC_YELLOW1",Quantity_NameOfColor::Quantity_NOC_YELLOW1)
568 ········.value("Quantity_NOC_YELLOW2",Quantity_NameOfColor::Quantity_NOC_YELLOW2)574 ········.value("Quantity_NOC_YELLOW2",Quantity_NameOfColor::Quantity_NOC_YELLOW2)
569 ········.value("Quantity_NOC_YELLOW3",Quantity_NameOfColor::Quantity_NOC_YELLOW3)575 ········.value("Quantity_NOC_YELLOW3",Quantity_NameOfColor::Quantity_NOC_YELLOW3)
570 ········.value("Quantity_NOC_YELLOW4",Quantity_NameOfColor::Quantity_NOC_YELLOW4)576 ········.value("Quantity_NOC_YELLOW4",Quantity_NameOfColor::Quantity_NOC_YELLOW4)
571 ········.value("Quantity_NOC_YELLOWGREEN",Quantity_NameOfColor::Quantity_NOC_YELLOWGREEN)577 ········.value("Quantity_NOC_YELLOWGREEN",Quantity_NameOfColor::Quantity_NOC_YELLOWGREEN)
572 ········.value("Quantity_NOC_WHITE",Quantity_NameOfColor::Quantity_NOC_WHITE).export_values();578 ········.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.23 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_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_TypeOfUpdate>(m,·"SelectMgr_TypeOfUpdate",R"#(Provides·values·for·types·of·update,·including·-·full·-·partial·-·none.)#")
 115 ········.value("SelectMgr_TOU_Full",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Full)
 116 ········.value("SelectMgr_TOU_Partial",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Partial)
 117 ········.value("SelectMgr_TOU_None",SelectMgr_TypeOfUpdate::SelectMgr_TOU_None).export_values();
111 ····py::enum_<SelectMgr_SelectionType>(m,·"SelectMgr_SelectionType",R"#(Possible·selection·types)#")118 ····py::enum_<SelectMgr_SelectionType>(m,·"SelectMgr_SelectionType",R"#(Possible·selection·types)#")
112 ········.value("SelectMgr_SelectionType_Unknown",SelectMgr_SelectionType::SelectMgr_SelectionType_Unknown)119 ········.value("SelectMgr_SelectionType_Unknown",SelectMgr_SelectionType::SelectMgr_SelectionType_Unknown)
113 ········.value("SelectMgr_SelectionType_Point",SelectMgr_SelectionType::SelectMgr_SelectionType_Point)120 ········.value("SelectMgr_SelectionType_Point",SelectMgr_SelectionType::SelectMgr_SelectionType_Point)
114 ········.value("SelectMgr_SelectionType_Box",SelectMgr_SelectionType::SelectMgr_SelectionType_Box)121 ········.value("SelectMgr_SelectionType_Box",SelectMgr_SelectionType::SelectMgr_SelectionType_Box)
115 ········.value("SelectMgr_SelectionType_Polyline",SelectMgr_SelectionType::SelectMgr_SelectionType_Polyline).export_values();122 ········.value("SelectMgr_SelectionType_Polyline",SelectMgr_SelectionType::SelectMgr_SelectionType_Polyline).export_values();
 123 ····py::enum_<SelectMgr_FilterType>(m,·"SelectMgr_FilterType",R"#(Enumeration·defines·the·filter·type.)#")
 124 ········.value("SelectMgr_FilterType_AND",SelectMgr_FilterType::SelectMgr_FilterType_AND)
 125 ········.value("SelectMgr_FilterType_OR",SelectMgr_FilterType::SelectMgr_FilterType_OR).export_values();
 126 ····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).)#")
 127 ········.value("SelectMgr_TypeOfDepthTolerance_Uniform",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_Uniform)
 128 ········.value("SelectMgr_TypeOfDepthTolerance_UniformPixels",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_UniformPixels)
 129 ········.value("SelectMgr_TypeOfDepthTolerance_SensitivityFactor",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_SensitivityFactor).export_values();
116 ····py::enum_<SelectMgr_StateOfSelection>(m,·"SelectMgr_StateOfSelection",R"#(different·state·of·a·Selection·in·a·ViewerSelector...)#")130 ····py::enum_<SelectMgr_StateOfSelection>(m,·"SelectMgr_StateOfSelection",R"#(different·state·of·a·Selection·in·a·ViewerSelector...)#")
117 ········.value("SelectMgr_SOS_Any",SelectMgr_StateOfSelection::SelectMgr_SOS_Any)131 ········.value("SelectMgr_SOS_Any",SelectMgr_StateOfSelection::SelectMgr_SOS_Any)
118 ········.value("SelectMgr_SOS_Unknown",SelectMgr_StateOfSelection::SelectMgr_SOS_Unknown)132 ········.value("SelectMgr_SOS_Unknown",SelectMgr_StateOfSelection::SelectMgr_SOS_Unknown)
119 ········.value("SelectMgr_SOS_Deactivated",SelectMgr_StateOfSelection::SelectMgr_SOS_Deactivated)133 ········.value("SelectMgr_SOS_Deactivated",SelectMgr_StateOfSelection::SelectMgr_SOS_Deactivated)
120 ········.value("SelectMgr_SOS_Activated",SelectMgr_StateOfSelection::SelectMgr_SOS_Activated).export_values();134 ········.value("SelectMgr_SOS_Activated",SelectMgr_StateOfSelection::SelectMgr_SOS_Activated).export_values();
121 ····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).)#") 
122 ········.value("SelectMgr_TypeOfDepthTolerance_Uniform",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_Uniform) 
123 ········.value("SelectMgr_TypeOfDepthTolerance_UniformPixels",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_UniformPixels) 
124 ········.value("SelectMgr_TypeOfDepthTolerance_SensitivityFactor",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_SensitivityFactor).export_values(); 
125 ····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.)#")
126 ········.value("SelectMgr_TBU_Add",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Add)136 ········.value("SelectMgr_TBU_Add",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Add)
127 ········.value("SelectMgr_TBU_Remove",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Remove)137 ········.value("SelectMgr_TBU_Remove",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Remove)
128 ········.value("SelectMgr_TBU_Renew",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Renew)138 ········.value("SelectMgr_TBU_Renew",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Renew)
129 ········.value("SelectMgr_TBU_Invalidate",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Invalidate)139 ········.value("SelectMgr_TBU_Invalidate",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Invalidate)
130 ········.value("SelectMgr_TBU_None",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_None).export_values();140 ········.value("SelectMgr_TBU_None",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_None).export_values();
131 ····py::enum_<SelectMgr_PickingStrategy>(m,·"SelectMgr_PickingStrategy",R"#(Enumeration·defines·picking·strategy·-·which·entities·detected·by·picking·line·will·be·accepted,·considering·selection·filters.)#") 
132 ········.value("SelectMgr_PickingStrategy_FirstAcceptable",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_FirstAcceptable) 
133 ········.value("SelectMgr_PickingStrategy_OnlyTopmost",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_OnlyTopmost).export_values(); 
134 ····py::enum_<SelectMgr_FilterType>(m,·"SelectMgr_FilterType",R"#(Enumeration·defines·the·filter·type.)#") 
135 ········.value("SelectMgr_FilterType_AND",SelectMgr_FilterType::SelectMgr_FilterType_AND) 
136 ········.value("SelectMgr_FilterType_OR",SelectMgr_FilterType::SelectMgr_FilterType_OR).export_values(); 
137 ····py::enum_<SelectMgr_TypeOfUpdate>(m,·"SelectMgr_TypeOfUpdate",R"#(Provides·values·for·types·of·update,·including·-·full·-·partial·-·none.)#") 
138 ········.value("SelectMgr_TOU_Full",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Full) 
139 ········.value("SelectMgr_TOU_Partial",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Partial) 
140 ········.value("SelectMgr_TOU_None",SelectMgr_TypeOfUpdate::SelectMgr_TOU_None).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.17 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·mMurmurHash·=·static_cast<py::module>(m.attr("MurmurHash"));
 912 auto·mstd·=·static_cast<py::module>(m.attr("std"));
 913 auto·mFNVHash·=·static_cast<py::module>(m.attr("FNVHash"));
911 auto·mopencascade·=·static_cast<py::module>(m.attr("opencascade"));914 auto·mopencascade·=·static_cast<py::module>(m.attr("opencascade"));
912 auto·mMurmurHashUtils·=·static_cast<py::module>(m.attr("MurmurHashUtils"));915 auto·mMurmurHashUtils·=·static_cast<py::module>(m.attr("MurmurHashUtils"));
913 auto·mFNVHash·=·static_cast<py::module>(m.attr("FNVHash")); 
914 auto·mstd·=·static_cast<py::module>(m.attr("std")); 
915 auto·mMurmurHash·=·static_cast<py::module>(m.attr("MurmurHash")); 
  
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),
⊟
2.32 KB
./usr/share/libocp/OCP/Standard_pre.cpp
Ordering differences only
    
Offset 107, 36 lines modifiedOffset 107, 36 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("MurmurHash");
 112 m.def_submodule("std");
 113 m.def_submodule("FNVHash");
111 m.def_submodule("opencascade");114 m.def_submodule("opencascade");
112 m.def_submodule("MurmurHashUtils");115 m.def_submodule("MurmurHashUtils");
113 m.def_submodule("FNVHash"); 
114 m.def_submodule("std"); 
115 m.def_submodule("MurmurHash"); 
  
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"#()#") 
119 ········.value("Standard_HandlerVoid",Standard_HandlerStatus::Standard_HandlerVoid) 
120 ········.value("Standard_HandlerJumped",Standard_HandlerStatus::Standard_HandlerJumped) 
121 ········.value("Standard_HandlerProcessed",Standard_HandlerStatus::Standard_HandlerProcessed).export_values(); 
122 ····py::enum_<Standard_JsonKey>(m,·"Standard_JsonKey",R"#(Kind·of·key·in·Json·string)#")118 ····py::enum_<Standard_JsonKey>(m,·"Standard_JsonKey",R"#(Kind·of·key·in·Json·string)#")
123 ········.value("Standard_JsonKey_None",Standard_JsonKey::Standard_JsonKey_None)119 ········.value("Standard_JsonKey_None",Standard_JsonKey::Standard_JsonKey_None)
124 ········.value("Standard_JsonKey_OpenChild",Standard_JsonKey::Standard_JsonKey_OpenChild)120 ········.value("Standard_JsonKey_OpenChild",Standard_JsonKey::Standard_JsonKey_OpenChild)
125 ········.value("Standard_JsonKey_CloseChild",Standard_JsonKey::Standard_JsonKey_CloseChild)121 ········.value("Standard_JsonKey_CloseChild",Standard_JsonKey::Standard_JsonKey_CloseChild)
126 ········.value("Standard_JsonKey_OpenContainer",Standard_JsonKey::Standard_JsonKey_OpenContainer)122 ········.value("Standard_JsonKey_OpenContainer",Standard_JsonKey::Standard_JsonKey_OpenContainer)
127 ········.value("Standard_JsonKey_CloseContainer",Standard_JsonKey::Standard_JsonKey_CloseContainer)123 ········.value("Standard_JsonKey_CloseContainer",Standard_JsonKey::Standard_JsonKey_CloseContainer)
128 ········.value("Standard_JsonKey_Quote",Standard_JsonKey::Standard_JsonKey_Quote)124 ········.value("Standard_JsonKey_Quote",Standard_JsonKey::Standard_JsonKey_Quote)
129 ········.value("Standard_JsonKey_SeparatorKeyToValue",Standard_JsonKey::Standard_JsonKey_SeparatorKeyToValue)125 ········.value("Standard_JsonKey_SeparatorKeyToValue",Standard_JsonKey::Standard_JsonKey_SeparatorKeyToValue)
130 ········.value("Standard_JsonKey_SeparatorValueToValue",Standard_JsonKey::Standard_JsonKey_SeparatorValueToValue).export_values();126 ········.value("Standard_JsonKey_SeparatorValueToValue",Standard_JsonKey::Standard_JsonKey_SeparatorValueToValue).export_values();
 127 ····py::enum_<Standard_HandlerStatus>(m,·"Standard_HandlerStatus",R"#()#")
 128 ········.value("Standard_HandlerVoid",Standard_HandlerStatus::Standard_HandlerVoid)
 129 ········.value("Standard_HandlerJumped",Standard_HandlerStatus::Standard_HandlerJumped)
 130 ········.value("Standard_HandlerProcessed",Standard_HandlerStatus::Standard_HandlerProcessed).export_values();
  
131 //Python·trampoline·classes131 //Python·trampoline·classes
132 ····class·Py_Standard_MMgrRoot·:·public·Standard_MMgrRoot{132 ····class·Py_Standard_MMgrRoot·:·public·Standard_MMgrRoot{
133 ····public:133 ····public:
134 ········using·Standard_MMgrRoot::Standard_MMgrRoot;134 ········using·Standard_MMgrRoot::Standard_MMgrRoot;
  
  
⊟
5.33 KB
./usr/share/libocp/OCP/StdSelect_pre.cpp
Ordering differences only
    
Offset 47, 36 lines modifiedOffset 47, 36 lines modified
47 py::module·m·=·main_module.def_submodule("StdSelect",·R"#()#");47 py::module·m·=·main_module.def_submodule("StdSelect",·R"#()#");
  
48 //·add·namespaces·as·submodules48 //·add·namespaces·as·submodules
  
49 //·user-defined·inclusion·per·module·in·the·body49 //·user-defined·inclusion·per·module·in·the·body
  
50 //·enums50 //·enums
 51 ····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.)#")
 52 ········.value("StdSelect_AnyFace",StdSelect_TypeOfFace::StdSelect_AnyFace)
 53 ········.value("StdSelect_Plane",StdSelect_TypeOfFace::StdSelect_Plane)
 54 ········.value("StdSelect_Cylinder",StdSelect_TypeOfFace::StdSelect_Cylinder)
 55 ········.value("StdSelect_Sphere",StdSelect_TypeOfFace::StdSelect_Sphere)
 56 ········.value("StdSelect_Torus",StdSelect_TypeOfFace::StdSelect_Torus)
 57 ········.value("StdSelect_Revol",StdSelect_TypeOfFace::StdSelect_Revol)
 58 ········.value("StdSelect_Cone",StdSelect_TypeOfFace::StdSelect_Cone).export_values();
51 ····py::enum_<StdSelect_TypeOfSelectionImage>(m,·"StdSelect_TypeOfSelectionImage",R"#(Type·of·output·selection·image.)#")59 ····py::enum_<StdSelect_TypeOfSelectionImage>(m,·"StdSelect_TypeOfSelectionImage",R"#(Type·of·output·selection·image.)#")
52 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepth)60 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepth)
53 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepthInverted",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepthInverted)61 ········.value("StdSelect_TypeOfSelectionImage_NormalizedDepthInverted",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_NormalizedDepthInverted)
54 ········.value("StdSelect_TypeOfSelectionImage_UnnormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_UnnormalizedDepth)62 ········.value("StdSelect_TypeOfSelectionImage_UnnormalizedDepth",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_UnnormalizedDepth)
55 ········.value("StdSelect_TypeOfSelectionImage_ColoredDetectedObject",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredDetectedObject)63 ········.value("StdSelect_TypeOfSelectionImage_ColoredDetectedObject",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredDetectedObject)
56 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntity",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntity)64 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntity",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntity)
57 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntityType",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntityType)65 ········.value("StdSelect_TypeOfSelectionImage_ColoredEntityType",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredEntityType)
58 ········.value("StdSelect_TypeOfSelectionImage_ColoredOwner",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredOwner)66 ········.value("StdSelect_TypeOfSelectionImage_ColoredOwner",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredOwner)
59 ········.value("StdSelect_TypeOfSelectionImage_ColoredSelectionMode",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredSelectionMode)67 ········.value("StdSelect_TypeOfSelectionImage_ColoredSelectionMode",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_ColoredSelectionMode)
60 ········.value("StdSelect_TypeOfSelectionImage_SurfaceNormal",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_SurfaceNormal).export_values();68 ········.value("StdSelect_TypeOfSelectionImage_SurfaceNormal",StdSelect_TypeOfSelectionImage::StdSelect_TypeOfSelectionImage_SurfaceNormal).export_values();
61 ····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.)#")69 ····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.)#")
62 ········.value("StdSelect_AnyEdge",StdSelect_TypeOfEdge::StdSelect_AnyEdge)70 ········.value("StdSelect_AnyEdge",StdSelect_TypeOfEdge::StdSelect_AnyEdge)
63 ········.value("StdSelect_Line",StdSelect_TypeOfEdge::StdSelect_Line)71 ········.value("StdSelect_Line",StdSelect_TypeOfEdge::StdSelect_Line)
64 ········.value("StdSelect_Circle",StdSelect_TypeOfEdge::StdSelect_Circle).export_values();72 ········.value("StdSelect_Circle",StdSelect_TypeOfEdge::StdSelect_Circle).export_values();
65 ····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.)#") 
66 ········.value("StdSelect_AnyFace",StdSelect_TypeOfFace::StdSelect_AnyFace) 
67 ········.value("StdSelect_Plane",StdSelect_TypeOfFace::StdSelect_Plane) 
68 ········.value("StdSelect_Cylinder",StdSelect_TypeOfFace::StdSelect_Cylinder) 
69 ········.value("StdSelect_Sphere",StdSelect_TypeOfFace::StdSelect_Sphere) 
70 ········.value("StdSelect_Torus",StdSelect_TypeOfFace::StdSelect_Torus) 
71 ········.value("StdSelect_Revol",StdSelect_TypeOfFace::StdSelect_Revol) 
72 ········.value("StdSelect_Cone",StdSelect_TypeOfFace::StdSelect_Cone).export_values(); 
  
73 //Python·trampoline·classes73 //Python·trampoline·classes
  
74 //·pre-register·typdefs+classes·(topologically·sorted)74 //·pre-register·typdefs+classes·(topologically·sorted)
75 ····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:)#");75 ····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:)#");
76 ····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.)#");76 ····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.)#");
77 ····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.)#");77 ····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.)#");
⊟
12.4 KB
./usr/share/libocp/OCP/StepDimTol_pre.cpp
Ordering differences only
    
Offset 199, 38 lines modifiedOffset 199, 39 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_LimitCondition>(m,·"StepDimTol_LimitCondition",R"#()#") 
204 ········.value("StepDimTol_MaximumMaterialCondition",StepDimTol_LimitCondition::StepDimTol_MaximumMaterialCondition) 
205 ········.value("StepDimTol_LeastMaterialCondition",StepDimTol_LimitCondition::StepDimTol_LeastMaterialCondition) 
206 ········.value("StepDimTol_RegardlessOfFeatureSize",StepDimTol_LimitCondition::StepDimTol_RegardlessOfFeatureSize).export_values(); 
207 ····py::enum_<StepDimTol_AreaUnitType>(m,·"StepDimTol_AreaUnitType",R"#()#")203 ····py::enum_<StepDimTol_AreaUnitType>(m,·"StepDimTol_AreaUnitType",R"#()#")
208 ········.value("StepDimTol_Circular",StepDimTol_AreaUnitType::StepDimTol_Circular)204 ········.value("StepDimTol_Circular",StepDimTol_AreaUnitType::StepDimTol_Circular)
209 ········.value("StepDimTol_Rectangular",StepDimTol_AreaUnitType::StepDimTol_Rectangular)205 ········.value("StepDimTol_Rectangular",StepDimTol_AreaUnitType::StepDimTol_Rectangular)
210 ········.value("StepDimTol_Square",StepDimTol_AreaUnitType::StepDimTol_Square).export_values();206 ········.value("StepDimTol_Square",StepDimTol_AreaUnitType::StepDimTol_Square).export_values();
 207 ····py::enum_<StepDimTol_DatumReferenceModifierType>(m,·"StepDimTol_DatumReferenceModifierType",R"#()#")
 208 ········.value("StepDimTol_CircularOrCylindrical",StepDimTol_DatumReferenceModifierType::StepDimTol_CircularOrCylindrical)
 209 ········.value("StepDimTol_Distance",StepDimTol_DatumReferenceModifierType::StepDimTol_Distance)
 210 ········.value("StepDimTol_Projected",StepDimTol_DatumReferenceModifierType::StepDimTol_Projected)
 211 ········.value("StepDimTol_Spherical",StepDimTol_DatumReferenceModifierType::StepDimTol_Spherical).export_values();
211 ····py::enum_<StepDimTol_GeometricToleranceModifier>(m,·"StepDimTol_GeometricToleranceModifier",R"#()#")212 ····py::enum_<StepDimTol_GeometricToleranceType>(m,·"StepDimTol_GeometricToleranceType",R"#()#")
212 ········.value("StepDimTol_GTMAnyCrossSection",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMAnyCrossSection)213 ········.value("StepDimTol_GTTAngularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTAngularityTolerance)
 214 ········.value("StepDimTol_GTTCircularRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCircularRunoutTolerance)
213 ········.value("StepDimTol_GTMCommonZone",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMCommonZone)215 ········.value("StepDimTol_GTTCoaxialityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCoaxialityTolerance)
214 ········.value("StepDimTol_GTMEachRadialElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMEachRadialElement)216 ········.value("StepDimTol_GTTConcentricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTConcentricityTolerance)
 217 ········.value("StepDimTol_GTTCylindricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCylindricityTolerance)
215 ········.value("StepDimTol_GTMFreeState",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMFreeState)218 ········.value("StepDimTol_GTTFlatnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTFlatnessTolerance)
216 ········.value("StepDimTol_GTMLeastMaterialRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLeastMaterialRequirement) 
217 ········.value("StepDimTol_GTMLineElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLineElement)219 ········.value("StepDimTol_GTTLineProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTLineProfileTolerance)
 220 ········.value("StepDimTol_GTTParallelismTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTParallelismTolerance)
 221 ········.value("StepDimTol_GTTPerpendicularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPerpendicularityTolerance)
218 ········.value("StepDimTol_GTMMajorDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMajorDiameter) 
219 ········.value("StepDimTol_GTMMaximumMaterialRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMaximumMaterialRequirement) 
220 ········.value("StepDimTol_GTMMinorDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMinorDiameter) 
221 ········.value("StepDimTol_GTMNotConvex",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMNotConvex)222 ········.value("StepDimTol_GTTPositionTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPositionTolerance)
 223 ········.value("StepDimTol_GTTRoundnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTRoundnessTolerance)
222 ········.value("StepDimTol_GTMPitchDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMPitchDiameter) 
223 ········.value("StepDimTol_GTMReciprocityRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMReciprocityRequirement) 
224 ········.value("StepDimTol_GTMSeparateRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMSeparateRequirement) 
225 ········.value("StepDimTol_GTMStatisticalTolerance",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMStatisticalTolerance)224 ········.value("StepDimTol_GTTStraightnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTStraightnessTolerance)
 225 ········.value("StepDimTol_GTTSurfaceProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSurfaceProfileTolerance)
 226 ········.value("StepDimTol_GTTSymmetryTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSymmetryTolerance)
226 ········.value("StepDimTol_GTMTangentPlane",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMTangentPlane).export_values();227 ········.value("StepDimTol_GTTTotalRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTTotalRunoutTolerance).export_values();
227 ····py::enum_<StepDimTol_SimpleDatumReferenceModifier>(m,·"StepDimTol_SimpleDatumReferenceModifier",R"#()#")228 ····py::enum_<StepDimTol_SimpleDatumReferenceModifier>(m,·"StepDimTol_SimpleDatumReferenceModifier",R"#()#")
228 ········.value("StepDimTol_SDRMAnyCrossSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyCrossSection)229 ········.value("StepDimTol_SDRMAnyCrossSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyCrossSection)
229 ········.value("StepDimTol_SDRMAnyLongitudinalSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyLongitudinalSection)230 ········.value("StepDimTol_SDRMAnyLongitudinalSection",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMAnyLongitudinalSection)
230 ········.value("StepDimTol_SDRMBasic",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMBasic)231 ········.value("StepDimTol_SDRMBasic",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMBasic)
231 ········.value("StepDimTol_SDRMContactingFeature",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMContactingFeature)232 ········.value("StepDimTol_SDRMContactingFeature",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMContactingFeature)
232 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintU",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintU)233 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintU",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintU)
233 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintV",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintV)234 ········.value("StepDimTol_SDRMDegreeOfFreedomConstraintV",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMDegreeOfFreedomConstraintV)
Offset 246, 35 lines modifiedOffset 247, 34 lines modified
246 ········.value("StepDimTol_SDRMMaximumMaterialRequirement",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMaximumMaterialRequirement)247 ········.value("StepDimTol_SDRMMaximumMaterialRequirement",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMaximumMaterialRequirement)
247 ········.value("StepDimTol_SDRMMinorDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMinorDiameter)248 ········.value("StepDimTol_SDRMMinorDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMMinorDiameter)
248 ········.value("StepDimTol_SDRMOrientation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMOrientation)249 ········.value("StepDimTol_SDRMOrientation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMOrientation)
249 ········.value("StepDimTol_SDRMPitchDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPitchDiameter)250 ········.value("StepDimTol_SDRMPitchDiameter",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPitchDiameter)
250 ········.value("StepDimTol_SDRMPlane",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPlane)251 ········.value("StepDimTol_SDRMPlane",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPlane)
251 ········.value("StepDimTol_SDRMPoint",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPoint)252 ········.value("StepDimTol_SDRMPoint",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMPoint)
252 ········.value("StepDimTol_SDRMTranslation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMTranslation).export_values();253 ········.value("StepDimTol_SDRMTranslation",StepDimTol_SimpleDatumReferenceModifier::StepDimTol_SDRMTranslation).export_values();
 254 ····py::enum_<StepDimTol_LimitCondition>(m,·"StepDimTol_LimitCondition",R"#()#")
 255 ········.value("StepDimTol_MaximumMaterialCondition",StepDimTol_LimitCondition::StepDimTol_MaximumMaterialCondition)
 256 ········.value("StepDimTol_LeastMaterialCondition",StepDimTol_LimitCondition::StepDimTol_LeastMaterialCondition)
 257 ········.value("StepDimTol_RegardlessOfFeatureSize",StepDimTol_LimitCondition::StepDimTol_RegardlessOfFeatureSize).export_values();
253 ····py::enum_<StepDimTol_DatumReferenceModifierType>(m,·"StepDimTol_DatumReferenceModifierType",R"#()#") 
254 ········.value("StepDimTol_CircularOrCylindrical",StepDimTol_DatumReferenceModifierType::StepDimTol_CircularOrCylindrical) 
255 ········.value("StepDimTol_Distance",StepDimTol_DatumReferenceModifierType::StepDimTol_Distance) 
256 ········.value("StepDimTol_Projected",StepDimTol_DatumReferenceModifierType::StepDimTol_Projected) 
257 ········.value("StepDimTol_Spherical",StepDimTol_DatumReferenceModifierType::StepDimTol_Spherical).export_values(); 
258 ····py::enum_<StepDimTol_GeometricToleranceType>(m,·"StepDimTol_GeometricToleranceType",R"#()#")258 ····py::enum_<StepDimTol_GeometricToleranceModifier>(m,·"StepDimTol_GeometricToleranceModifier",R"#()#")
259 ········.value("StepDimTol_GTTAngularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTAngularityTolerance)259 ········.value("StepDimTol_GTMAnyCrossSection",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMAnyCrossSection)
260 ········.value("StepDimTol_GTTCircularRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCircularRunoutTolerance) 
261 ········.value("StepDimTol_GTTCoaxialityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCoaxialityTolerance)260 ········.value("StepDimTol_GTMCommonZone",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMCommonZone)
 261 ········.value("StepDimTol_GTMEachRadialElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMEachRadialElement)
262 ········.value("StepDimTol_GTTConcentricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTConcentricityTolerance) 
263 ········.value("StepDimTol_GTTCylindricityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTCylindricityTolerance) 
264 ········.value("StepDimTol_GTTFlatnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTFlatnessTolerance)262 ········.value("StepDimTol_GTMFreeState",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMFreeState)
 263 ········.value("StepDimTol_GTMLeastMaterialRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLeastMaterialRequirement)
265 ········.value("StepDimTol_GTTLineProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTLineProfileTolerance)264 ········.value("StepDimTol_GTMLineElement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMLineElement)
266 ········.value("StepDimTol_GTTParallelismTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTParallelismTolerance)265 ········.value("StepDimTol_GTMMajorDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMajorDiameter)
267 ········.value("StepDimTol_GTTPerpendicularityTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPerpendicularityTolerance)266 ········.value("StepDimTol_GTMMaximumMaterialRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMaximumMaterialRequirement)
 267 ········.value("StepDimTol_GTMMinorDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMMinorDiameter)
268 ········.value("StepDimTol_GTTPositionTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTPositionTolerance)268 ········.value("StepDimTol_GTMNotConvex",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMNotConvex)
269 ········.value("StepDimTol_GTTRoundnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTRoundnessTolerance)269 ········.value("StepDimTol_GTMPitchDiameter",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMPitchDiameter)
 270 ········.value("StepDimTol_GTMReciprocityRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMReciprocityRequirement)
 271 ········.value("StepDimTol_GTMSeparateRequirement",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMSeparateRequirement)
270 ········.value("StepDimTol_GTTStraightnessTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTStraightnessTolerance)272 ········.value("StepDimTol_GTMStatisticalTolerance",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMStatisticalTolerance)
271 ········.value("StepDimTol_GTTSurfaceProfileTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSurfaceProfileTolerance) 
272 ········.value("StepDimTol_GTTSymmetryTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTSymmetryTolerance) 
273 ········.value("StepDimTol_GTTTotalRunoutTolerance",StepDimTol_GeometricToleranceType::StepDimTol_GTTTotalRunoutTolerance).export_values();273 ········.value("StepDimTol_GTMTangentPlane",StepDimTol_GeometricToleranceModifier::StepDimTol_GTMTangentPlane).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");
⊟
7.57 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_CurveEdge>(m,·"StepElement_CurveEdge",R"#()#")
 155 ········.value("StepElement_ElementEdge",StepElement_CurveEdge::StepElement_ElementEdge).export_values();
154 ····py::enum_<StepElement_ElementVolume>(m,·"StepElement_ElementVolume",R"#()#")156 ····py::enum_<StepElement_ElementVolume>(m,·"StepElement_ElementVolume",R"#()#")
155 ········.value("StepElement_Volume",StepElement_ElementVolume::StepElement_Volume).export_values();157 ········.value("StepElement_Volume",StepElement_ElementVolume::StepElement_Volume).export_values();
156 ····py::enum_<StepElement_UnspecifiedValue>(m,·"StepElement_UnspecifiedValue",R"#()#") 
157 ········.value("StepElement_Unspecified",StepElement_UnspecifiedValue::StepElement_Unspecified).export_values(); 
158 ····py::enum_<StepElement_EnumeratedCurveElementPurpose>(m,·"StepElement_EnumeratedCurveElementPurpose",R"#()#")158 ····py::enum_<StepElement_ElementOrder>(m,·"StepElement_ElementOrder",R"#()#")
159 ········.value("StepElement_Axial",StepElement_EnumeratedCurveElementPurpose::StepElement_Axial) 
160 ········.value("StepElement_YYBending",StepElement_EnumeratedCurveElementPurpose::StepElement_YYBending) 
161 ········.value("StepElement_ZZBending",StepElement_EnumeratedCurveElementPurpose::StepElement_ZZBending) 
162 ········.value("StepElement_Torsion",StepElement_EnumeratedCurveElementPurpose::StepElement_Torsion) 
163 ········.value("StepElement_XYShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XYShear)159 ········.value("StepElement_Linear",StepElement_ElementOrder::StepElement_Linear)
164 ········.value("StepElement_XZShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XZShear)160 ········.value("StepElement_Quadratic",StepElement_ElementOrder::StepElement_Quadratic)
165 ········.value("StepElement_Warping",StepElement_EnumeratedCurveElementPurpose::StepElement_Warping).export_values();161 ········.value("StepElement_Cubic",StepElement_ElementOrder::StepElement_Cubic).export_values();
166 ····py::enum_<StepElement_EnumeratedVolumeElementPurpose>(m,·"StepElement_EnumeratedVolumeElementPurpose",R"#()#") 
167 ········.value("StepElement_StressDisplacement",StepElement_EnumeratedVolumeElementPurpose::StepElement_StressDisplacement).export_values(); 
168 ····py::enum_<StepElement_Volume3dElementShape>(m,·"StepElement_Volume3dElementShape",R"#()#")162 ····py::enum_<StepElement_Volume3dElementShape>(m,·"StepElement_Volume3dElementShape",R"#()#")
169 ········.value("StepElement_Hexahedron",StepElement_Volume3dElementShape::StepElement_Hexahedron)163 ········.value("StepElement_Hexahedron",StepElement_Volume3dElementShape::StepElement_Hexahedron)
170 ········.value("StepElement_Wedge",StepElement_Volume3dElementShape::StepElement_Wedge)164 ········.value("StepElement_Wedge",StepElement_Volume3dElementShape::StepElement_Wedge)
171 ········.value("StepElement_Tetrahedron",StepElement_Volume3dElementShape::StepElement_Tetrahedron)165 ········.value("StepElement_Tetrahedron",StepElement_Volume3dElementShape::StepElement_Tetrahedron)
172 ········.value("StepElement_Pyramid",StepElement_Volume3dElementShape::StepElement_Pyramid).export_values();166 ········.value("StepElement_Pyramid",StepElement_Volume3dElementShape::StepElement_Pyramid).export_values();
173 ····py::enum_<StepElement_ElementOrder>(m,·"StepElement_ElementOrder",R"#()#")167 ····py::enum_<StepElement_Element2dShape>(m,·"StepElement_Element2dShape",R"#()#")
174 ········.value("StepElement_Linear",StepElement_ElementOrder::StepElement_Linear) 
175 ········.value("StepElement_Quadratic",StepElement_ElementOrder::StepElement_Quadratic)168 ········.value("StepElement_Quadrilateral",StepElement_Element2dShape::StepElement_Quadrilateral)
176 ········.value("StepElement_Cubic",StepElement_ElementOrder::StepElement_Cubic).export_values();169 ········.value("StepElement_Triangle",StepElement_Element2dShape::StepElement_Triangle).export_values();
 170 ····py::enum_<StepElement_UnspecifiedValue>(m,·"StepElement_UnspecifiedValue",R"#()#")
 171 ········.value("StepElement_Unspecified",StepElement_UnspecifiedValue::StepElement_Unspecified).export_values();
177 ····py::enum_<StepElement_EnumeratedCurveElementFreedom>(m,·"StepElement_EnumeratedCurveElementFreedom",R"#()#")172 ····py::enum_<StepElement_EnumeratedCurveElementFreedom>(m,·"StepElement_EnumeratedCurveElementFreedom",R"#()#")
178 ········.value("StepElement_XTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_XTranslation)173 ········.value("StepElement_XTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_XTranslation)
179 ········.value("StepElement_YTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_YTranslation)174 ········.value("StepElement_YTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_YTranslation)
180 ········.value("StepElement_ZTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZTranslation)175 ········.value("StepElement_ZTranslation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZTranslation)
181 ········.value("StepElement_XRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_XRotation)176 ········.value("StepElement_XRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_XRotation)
182 ········.value("StepElement_YRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_YRotation)177 ········.value("StepElement_YRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_YRotation)
183 ········.value("StepElement_ZRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZRotation)178 ········.value("StepElement_ZRotation",StepElement_EnumeratedCurveElementFreedom::StepElement_ZRotation)
184 ········.value("StepElement_Warp",StepElement_EnumeratedCurveElementFreedom::StepElement_Warp)179 ········.value("StepElement_Warp",StepElement_EnumeratedCurveElementFreedom::StepElement_Warp)
185 ········.value("StepElement_None",StepElement_EnumeratedCurveElementFreedom::StepElement_None).export_values();180 ········.value("StepElement_None",StepElement_EnumeratedCurveElementFreedom::StepElement_None).export_values();
186 ····py::enum_<StepElement_Element2dShape>(m,·"StepElement_Element2dShape",R"#()#") 
187 ········.value("StepElement_Quadrilateral",StepElement_Element2dShape::StepElement_Quadrilateral) 
188 ········.value("StepElement_Triangle",StepElement_Element2dShape::StepElement_Triangle).export_values(); 
189 ····py::enum_<StepElement_CurveEdge>(m,·"StepElement_CurveEdge",R"#()#") 
190 ········.value("StepElement_ElementEdge",StepElement_CurveEdge::StepElement_ElementEdge).export_values(); 
191 ····py::enum_<StepElement_EnumeratedSurfaceElementPurpose>(m,·"StepElement_EnumeratedSurfaceElementPurpose",R"#()#")181 ····py::enum_<StepElement_EnumeratedSurfaceElementPurpose>(m,·"StepElement_EnumeratedSurfaceElementPurpose",R"#()#")
192 ········.value("StepElement_MembraneDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneDirect)182 ········.value("StepElement_MembraneDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneDirect)
193 ········.value("StepElement_MembraneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneShear)183 ········.value("StepElement_MembraneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_MembraneShear)
194 ········.value("StepElement_BendingDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingDirect)184 ········.value("StepElement_BendingDirect",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingDirect)
195 ········.value("StepElement_BendingTorsion",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingTorsion)185 ········.value("StepElement_BendingTorsion",StepElement_EnumeratedSurfaceElementPurpose::StepElement_BendingTorsion)
196 ········.value("StepElement_NormalToPlaneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_NormalToPlaneShear).export_values();186 ········.value("StepElement_NormalToPlaneShear",StepElement_EnumeratedSurfaceElementPurpose::StepElement_NormalToPlaneShear).export_values();
 187 ····py::enum_<StepElement_EnumeratedVolumeElementPurpose>(m,·"StepElement_EnumeratedVolumeElementPurpose",R"#()#")
 188 ········.value("StepElement_StressDisplacement",StepElement_EnumeratedVolumeElementPurpose::StepElement_StressDisplacement).export_values();
 189 ····py::enum_<StepElement_EnumeratedCurveElementPurpose>(m,·"StepElement_EnumeratedCurveElementPurpose",R"#()#")
 190 ········.value("StepElement_Axial",StepElement_EnumeratedCurveElementPurpose::StepElement_Axial)
 191 ········.value("StepElement_YYBending",StepElement_EnumeratedCurveElementPurpose::StepElement_YYBending)
 192 ········.value("StepElement_ZZBending",StepElement_EnumeratedCurveElementPurpose::StepElement_ZZBending)
 193 ········.value("StepElement_Torsion",StepElement_EnumeratedCurveElementPurpose::StepElement_Torsion)
 194 ········.value("StepElement_XYShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XYShear)
 195 ········.value("StepElement_XZShear",StepElement_EnumeratedCurveElementPurpose::StepElement_XZShear)
 196 ········.value("StepElement_Warping",StepElement_EnumeratedCurveElementPurpose::StepElement_Warping).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");
⊟
3.05 KB
./usr/share/libocp/OCP/StepFEA_pre.cpp
Ordering differences only
    
Offset 217, 32 lines modifiedOffset 217, 32 lines modified
217 py::module·m·=·main_module.def_submodule("StepFEA",·R"#()#");217 py::module·m·=·main_module.def_submodule("StepFEA",·R"#()#");
  
218 //·add·namespaces·as·submodules218 //·add·namespaces·as·submodules
  
219 //·user-defined·inclusion·per·module·in·the·body219 //·user-defined·inclusion·per·module·in·the·body
  
220 //·enums220 //·enums
221 ····py::enum_<StepFEA_CoordinateSystemType>(m,·"StepFEA_CoordinateSystemType",R"#()#") 
222 ········.value("StepFEA_Cartesian",StepFEA_CoordinateSystemType::StepFEA_Cartesian) 
223 ········.value("StepFEA_Cylindrical",StepFEA_CoordinateSystemType::StepFEA_Cylindrical) 
224 ········.value("StepFEA_Spherical",StepFEA_CoordinateSystemType::StepFEA_Spherical).export_values(); 
225 ····py::enum_<StepFEA_ElementVolume>(m,·"StepFEA_ElementVolume",R"#()#")221 ····py::enum_<StepFEA_ElementVolume>(m,·"StepFEA_ElementVolume",R"#()#")
226 ········.value("StepFEA_Volume",StepFEA_ElementVolume::StepFEA_Volume).export_values();222 ········.value("StepFEA_Volume",StepFEA_ElementVolume::StepFEA_Volume).export_values();
 223 ····py::enum_<StepFEA_CurveEdge>(m,·"StepFEA_CurveEdge",R"#()#")
 224 ········.value("StepFEA_ElementEdge",StepFEA_CurveEdge::StepFEA_ElementEdge).export_values();
 225 ····py::enum_<StepFEA_UnspecifiedValue>(m,·"StepFEA_UnspecifiedValue",R"#()#")
 226 ········.value("StepFEA_Unspecified",StepFEA_UnspecifiedValue::StepFEA_Unspecified).export_values();
227 ····py::enum_<StepFEA_EnumeratedDegreeOfFreedom>(m,·"StepFEA_EnumeratedDegreeOfFreedom",R"#()#")227 ····py::enum_<StepFEA_EnumeratedDegreeOfFreedom>(m,·"StepFEA_EnumeratedDegreeOfFreedom",R"#()#")
228 ········.value("StepFEA_XTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XTranslation)228 ········.value("StepFEA_XTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XTranslation)
229 ········.value("StepFEA_YTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YTranslation)229 ········.value("StepFEA_YTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YTranslation)
230 ········.value("StepFEA_ZTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZTranslation)230 ········.value("StepFEA_ZTranslation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZTranslation)
231 ········.value("StepFEA_XRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XRotation)231 ········.value("StepFEA_XRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_XRotation)
232 ········.value("StepFEA_YRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YRotation)232 ········.value("StepFEA_YRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_YRotation)
233 ········.value("StepFEA_ZRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZRotation)233 ········.value("StepFEA_ZRotation",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_ZRotation)
234 ········.value("StepFEA_Warp",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_Warp).export_values();234 ········.value("StepFEA_Warp",StepFEA_EnumeratedDegreeOfFreedom::StepFEA_Warp).export_values();
235 ····py::enum_<StepFEA_CurveEdge>(m,·"StepFEA_CurveEdge",R"#()#") 
236 ········.value("StepFEA_ElementEdge",StepFEA_CurveEdge::StepFEA_ElementEdge).export_values(); 
237 ····py::enum_<StepFEA_UnspecifiedValue>(m,·"StepFEA_UnspecifiedValue",R"#()#") 
238 ········.value("StepFEA_Unspecified",StepFEA_UnspecifiedValue::StepFEA_Unspecified).export_values();235 ····py::enum_<StepFEA_CoordinateSystemType>(m,·"StepFEA_CoordinateSystemType",R"#()#")
 236 ········.value("StepFEA_Cartesian",StepFEA_CoordinateSystemType::StepFEA_Cartesian)
 237 ········.value("StepFEA_Cylindrical",StepFEA_CoordinateSystemType::StepFEA_Cylindrical)
 238 ········.value("StepFEA_Spherical",StepFEA_CoordinateSystemType::StepFEA_Spherical).export_values();
  
239 //Python·trampoline·classes239 //Python·trampoline·classes
  
240 //·pre-register·typdefs+classes·(topologically·sorted)240 //·pre-register·typdefs+classes·(topologically·sorted)
241 ····preregister_template_NCollection_Array1<opencascade::handle<StepFEA_CurveElementEndOffset>>(m,"StepFEA_Array1OfCurveElementEndOffset");241 ····preregister_template_NCollection_Array1<opencascade::handle<StepFEA_CurveElementEndOffset>>(m,"StepFEA_Array1OfCurveElementEndOffset");
242 ····preregister_template_NCollection_Array1<opencascade::handle<StepFEA_CurveElementEndRelease>>(m,"StepFEA_Array1OfCurveElementEndRelease");242 ····preregister_template_NCollection_Array1<opencascade::handle<StepFEA_CurveElementEndRelease>>(m,"StepFEA_Array1OfCurveElementEndRelease");
243 ····preregister_template_NCollection_Array1<opencascade::handle<StepFEA_CurveElementInterval>>(m,"StepFEA_Array1OfCurveElementInterval");243 ····preregister_template_NCollection_Array1<opencascade::handle<StepFEA_CurveElementInterval>>(m,"StepFEA_Array1OfCurveElementInterval");
⊟
5.17 KB
./usr/share/libocp/OCP/StepGeom_pre.cpp
Ordering differences only
    
Offset 306, 46 lines modifiedOffset 306, 46 lines modified
  
306 //·enums306 //·enums
307 ····py::enum_<StepGeom_KnotType>(m,·"StepGeom_KnotType",R"#()#")307 ····py::enum_<StepGeom_KnotType>(m,·"StepGeom_KnotType",R"#()#")
308 ········.value("StepGeom_ktUniformKnots",StepGeom_KnotType::StepGeom_ktUniformKnots)308 ········.value("StepGeom_ktUniformKnots",StepGeom_KnotType::StepGeom_ktUniformKnots)
309 ········.value("StepGeom_ktUnspecified",StepGeom_KnotType::StepGeom_ktUnspecified)309 ········.value("StepGeom_ktUnspecified",StepGeom_KnotType::StepGeom_ktUnspecified)
310 ········.value("StepGeom_ktQuasiUniformKnots",StepGeom_KnotType::StepGeom_ktQuasiUniformKnots)310 ········.value("StepGeom_ktQuasiUniformKnots",StepGeom_KnotType::StepGeom_ktQuasiUniformKnots)
311 ········.value("StepGeom_ktPiecewiseBezierKnots",StepGeom_KnotType::StepGeom_ktPiecewiseBezierKnots).export_values();311 ········.value("StepGeom_ktPiecewiseBezierKnots",StepGeom_KnotType::StepGeom_ktPiecewiseBezierKnots).export_values();
 312 ····py::enum_<StepGeom_PreferredSurfaceCurveRepresentation>(m,·"StepGeom_PreferredSurfaceCurveRepresentation",R"#()#")
 313 ········.value("StepGeom_pscrCurve3d",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrCurve3d)
 314 ········.value("StepGeom_pscrPcurveS1",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS1)
 315 ········.value("StepGeom_pscrPcurveS2",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS2).export_values();
312 ····py::enum_<StepGeom_TrimmingPreference>(m,·"StepGeom_TrimmingPreference",R"#()#")316 ····py::enum_<StepGeom_TrimmingPreference>(m,·"StepGeom_TrimmingPreference",R"#()#")
313 ········.value("StepGeom_tpCartesian",StepGeom_TrimmingPreference::StepGeom_tpCartesian)317 ········.value("StepGeom_tpCartesian",StepGeom_TrimmingPreference::StepGeom_tpCartesian)
314 ········.value("StepGeom_tpParameter",StepGeom_TrimmingPreference::StepGeom_tpParameter)318 ········.value("StepGeom_tpParameter",StepGeom_TrimmingPreference::StepGeom_tpParameter)
315 ········.value("StepGeom_tpUnspecified",StepGeom_TrimmingPreference::StepGeom_tpUnspecified).export_values();319 ········.value("StepGeom_tpUnspecified",StepGeom_TrimmingPreference::StepGeom_tpUnspecified).export_values();
 320 ····py::enum_<StepGeom_TransitionCode>(m,·"StepGeom_TransitionCode",R"#()#")
 321 ········.value("StepGeom_tcDiscontinuous",StepGeom_TransitionCode::StepGeom_tcDiscontinuous)
 322 ········.value("StepGeom_tcContinuous",StepGeom_TransitionCode::StepGeom_tcContinuous)
 323 ········.value("StepGeom_tcContSameGradient",StepGeom_TransitionCode::StepGeom_tcContSameGradient)
 324 ········.value("StepGeom_tcContSameGradientSameCurvature",StepGeom_TransitionCode::StepGeom_tcContSameGradientSameCurvature).export_values();
316 ····py::enum_<StepGeom_BSplineSurfaceForm>(m,·"StepGeom_BSplineSurfaceForm",R"#()#")325 ····py::enum_<StepGeom_BSplineSurfaceForm>(m,·"StepGeom_BSplineSurfaceForm",R"#()#")
317 ········.value("StepGeom_bssfPlaneSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfPlaneSurf)326 ········.value("StepGeom_bssfPlaneSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfPlaneSurf)
318 ········.value("StepGeom_bssfCylindricalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfCylindricalSurf)327 ········.value("StepGeom_bssfCylindricalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfCylindricalSurf)
319 ········.value("StepGeom_bssfConicalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfConicalSurf)328 ········.value("StepGeom_bssfConicalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfConicalSurf)
320 ········.value("StepGeom_bssfSphericalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfSphericalSurf)329 ········.value("StepGeom_bssfSphericalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfSphericalSurf)
321 ········.value("StepGeom_bssfToroidalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfToroidalSurf)330 ········.value("StepGeom_bssfToroidalSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfToroidalSurf)
322 ········.value("StepGeom_bssfSurfOfRevolution",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfRevolution)331 ········.value("StepGeom_bssfSurfOfRevolution",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfRevolution)
323 ········.value("StepGeom_bssfRuledSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfRuledSurf)332 ········.value("StepGeom_bssfRuledSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfRuledSurf)
324 ········.value("StepGeom_bssfGeneralisedCone",StepGeom_BSplineSurfaceForm::StepGeom_bssfGeneralisedCone)333 ········.value("StepGeom_bssfGeneralisedCone",StepGeom_BSplineSurfaceForm::StepGeom_bssfGeneralisedCone)
325 ········.value("StepGeom_bssfQuadricSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfQuadricSurf)334 ········.value("StepGeom_bssfQuadricSurf",StepGeom_BSplineSurfaceForm::StepGeom_bssfQuadricSurf)
326 ········.value("StepGeom_bssfSurfOfLinearExtrusion",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfLinearExtrusion)335 ········.value("StepGeom_bssfSurfOfLinearExtrusion",StepGeom_BSplineSurfaceForm::StepGeom_bssfSurfOfLinearExtrusion)
327 ········.value("StepGeom_bssfUnspecified",StepGeom_BSplineSurfaceForm::StepGeom_bssfUnspecified).export_values();336 ········.value("StepGeom_bssfUnspecified",StepGeom_BSplineSurfaceForm::StepGeom_bssfUnspecified).export_values();
328 ····py::enum_<StepGeom_PreferredSurfaceCurveRepresentation>(m,·"StepGeom_PreferredSurfaceCurveRepresentation",R"#()#") 
329 ········.value("StepGeom_pscrCurve3d",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrCurve3d) 
330 ········.value("StepGeom_pscrPcurveS1",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS1) 
331 ········.value("StepGeom_pscrPcurveS2",StepGeom_PreferredSurfaceCurveRepresentation::StepGeom_pscrPcurveS2).export_values(); 
332 ····py::enum_<StepGeom_BSplineCurveForm>(m,·"StepGeom_BSplineCurveForm",R"#()#")337 ····py::enum_<StepGeom_BSplineCurveForm>(m,·"StepGeom_BSplineCurveForm",R"#()#")
333 ········.value("StepGeom_bscfPolylineForm",StepGeom_BSplineCurveForm::StepGeom_bscfPolylineForm)338 ········.value("StepGeom_bscfPolylineForm",StepGeom_BSplineCurveForm::StepGeom_bscfPolylineForm)
334 ········.value("StepGeom_bscfCircularArc",StepGeom_BSplineCurveForm::StepGeom_bscfCircularArc)339 ········.value("StepGeom_bscfCircularArc",StepGeom_BSplineCurveForm::StepGeom_bscfCircularArc)
335 ········.value("StepGeom_bscfEllipticArc",StepGeom_BSplineCurveForm::StepGeom_bscfEllipticArc)340 ········.value("StepGeom_bscfEllipticArc",StepGeom_BSplineCurveForm::StepGeom_bscfEllipticArc)
336 ········.value("StepGeom_bscfParabolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfParabolicArc)341 ········.value("StepGeom_bscfParabolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfParabolicArc)
337 ········.value("StepGeom_bscfHyperbolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfHyperbolicArc)342 ········.value("StepGeom_bscfHyperbolicArc",StepGeom_BSplineCurveForm::StepGeom_bscfHyperbolicArc)
338 ········.value("StepGeom_bscfUnspecified",StepGeom_BSplineCurveForm::StepGeom_bscfUnspecified).export_values();343 ········.value("StepGeom_bscfUnspecified",StepGeom_BSplineCurveForm::StepGeom_bscfUnspecified).export_values();
339 ····py::enum_<StepGeom_TransitionCode>(m,·"StepGeom_TransitionCode",R"#()#") 
340 ········.value("StepGeom_tcDiscontinuous",StepGeom_TransitionCode::StepGeom_tcDiscontinuous) 
341 ········.value("StepGeom_tcContinuous",StepGeom_TransitionCode::StepGeom_tcContinuous) 
342 ········.value("StepGeom_tcContSameGradient",StepGeom_TransitionCode::StepGeom_tcContSameGradient) 
343 ········.value("StepGeom_tcContSameGradientSameCurvature",StepGeom_TransitionCode::StepGeom_tcContSameGradientSameCurvature).export_values(); 
  
344 //Python·trampoline·classes344 //Python·trampoline·classes
  
345 //·pre-register·typdefs+classes·(topologically·sorted)345 //·pre-register·typdefs+classes·(topologically·sorted)
346 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_BoundaryCurve>>(m,"StepGeom_Array1OfBoundaryCurve");346 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_BoundaryCurve>>(m,"StepGeom_Array1OfBoundaryCurve");
347 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CartesianPoint>>(m,"StepGeom_Array1OfCartesianPoint");347 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CartesianPoint>>(m,"StepGeom_Array1OfCartesianPoint");
348 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CompositeCurveSegment>>(m,"StepGeom_Array1OfCompositeCurveSegment");348 ····preregister_template_NCollection_Array1<opencascade::handle<StepGeom_CompositeCurveSegment>>(m,"StepGeom_Array1OfCompositeCurveSegment");
⊟
1.71 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_AngleRelator>(m,·"StepShape_AngleRelator",R"#()#") 
320 ········.value("StepShape_Equal",StepShape_AngleRelator::StepShape_Equal) 
321 ········.value("StepShape_Large",StepShape_AngleRelator::StepShape_Large) 
322 ········.value("StepShape_Small",StepShape_AngleRelator::StepShape_Small).export_values(); 
323 ····py::enum_<StepShape_BooleanOperator>(m,·"StepShape_BooleanOperator",R"#()#")319 ····py::enum_<StepShape_BooleanOperator>(m,·"StepShape_BooleanOperator",R"#()#")
324 ········.value("StepShape_boDifference",StepShape_BooleanOperator::StepShape_boDifference)320 ········.value("StepShape_boDifference",StepShape_BooleanOperator::StepShape_boDifference)
325 ········.value("StepShape_boIntersection",StepShape_BooleanOperator::StepShape_boIntersection)321 ········.value("StepShape_boIntersection",StepShape_BooleanOperator::StepShape_boIntersection)
326 ········.value("StepShape_boUnion",StepShape_BooleanOperator::StepShape_boUnion).export_values();322 ········.value("StepShape_boUnion",StepShape_BooleanOperator::StepShape_boUnion).export_values();
 323 ····py::enum_<StepShape_AngleRelator>(m,·"StepShape_AngleRelator",R"#()#")
 324 ········.value("StepShape_Equal",StepShape_AngleRelator::StepShape_Equal)
 325 ········.value("StepShape_Large",StepShape_AngleRelator::StepShape_Large)
 326 ········.value("StepShape_Small",StepShape_AngleRelator::StepShape_Small).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.51 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();
172 ····py::enum_<StepToTopoDS_TranslateVertexError>(m,·"StepToTopoDS_TranslateVertexError",R"#()#")175 ····py::enum_<StepToTopoDS_TranslateVertexError>(m,·"StepToTopoDS_TranslateVertexError",R"#()#")
173 ········.value("StepToTopoDS_TranslateVertexDone",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexDone)176 ········.value("StepToTopoDS_TranslateVertexDone",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexDone)
174 ········.value("StepToTopoDS_TranslateVertexOther",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexOther).export_values();177 ········.value("StepToTopoDS_TranslateVertexOther",StepToTopoDS_TranslateVertexError::StepToTopoDS_TranslateVertexOther).export_values();
175 ····py::enum_<StepToTopoDS_TranslateSolidError>(m,·"StepToTopoDS_TranslateSolidError",R"#()#")178 ····py::enum_<StepToTopoDS_GeometricToolError>(m,·"StepToTopoDS_GeometricToolError",R"#()#")
176 ········.value("StepToTopoDS_TranslateSolidDone",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidDone)179 ········.value("StepToTopoDS_GeometricToolDone",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolDone)
 180 ········.value("StepToTopoDS_GeometricToolIsDegenerated",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolIsDegenerated)
 181 ········.value("StepToTopoDS_GeometricToolHasNoPCurve",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolHasNoPCurve)
 182 ········.value("StepToTopoDS_GeometricToolWrong3dParameters",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolWrong3dParameters)
 183 ········.value("StepToTopoDS_GeometricToolNoProjectiOnCurve",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolNoProjectiOnCurve)
177 ········.value("StepToTopoDS_TranslateSolidOther",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidOther).export_values();184 ········.value("StepToTopoDS_GeometricToolOther",StepToTopoDS_GeometricToolError::StepToTopoDS_GeometricToolOther).export_values();
178 ····py::enum_<StepToTopoDS_TranslateVertexLoopError>(m,·"StepToTopoDS_TranslateVertexLoopError",R"#()#") 
179 ········.value("StepToTopoDS_TranslateVertexLoopDone",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopDone) 
180 ········.value("StepToTopoDS_TranslateVertexLoopOther",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopOther).export_values(); 
181 ····py::enum_<StepToTopoDS_TranslateShellError>(m,·"StepToTopoDS_TranslateShellError",R"#()#")185 ····py::enum_<StepToTopoDS_TranslateShellError>(m,·"StepToTopoDS_TranslateShellError",R"#()#")
182 ········.value("StepToTopoDS_TranslateShellDone",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellDone)186 ········.value("StepToTopoDS_TranslateShellDone",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellDone)
183 ········.value("StepToTopoDS_TranslateShellOther",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellOther).export_values();187 ········.value("StepToTopoDS_TranslateShellOther",StepToTopoDS_TranslateShellError::StepToTopoDS_TranslateShellOther).export_values();
184 ····py::enum_<StepToTopoDS_BuilderError>(m,·"StepToTopoDS_BuilderError",R"#()#")188 ····py::enum_<StepToTopoDS_TranslateVertexLoopError>(m,·"StepToTopoDS_TranslateVertexLoopError",R"#()#")
185 ········.value("StepToTopoDS_BuilderDone",StepToTopoDS_BuilderError::StepToTopoDS_BuilderDone)189 ········.value("StepToTopoDS_TranslateVertexLoopDone",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopDone)
186 ········.value("StepToTopoDS_BuilderOther",StepToTopoDS_BuilderError::StepToTopoDS_BuilderOther).export_values();190 ········.value("StepToTopoDS_TranslateVertexLoopOther",StepToTopoDS_TranslateVertexLoopError::StepToTopoDS_TranslateVertexLoopOther).export_values();
187 ····py::enum_<StepToTopoDS_TranslateFaceError>(m,·"StepToTopoDS_TranslateFaceError",R"#()#")191 ····py::enum_<StepToTopoDS_TranslateFaceError>(m,·"StepToTopoDS_TranslateFaceError",R"#()#")
188 ········.value("StepToTopoDS_TranslateFaceDone",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceDone)192 ········.value("StepToTopoDS_TranslateFaceDone",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceDone)
189 ········.value("StepToTopoDS_TranslateFaceOther",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceOther).export_values();193 ········.value("StepToTopoDS_TranslateFaceOther",StepToTopoDS_TranslateFaceError::StepToTopoDS_TranslateFaceOther).export_values();
190 ····py::enum_<StepToTopoDS_TranslatePolyLoopError>(m,·"StepToTopoDS_TranslatePolyLoopError",R"#()#")194 ····py::enum_<StepToTopoDS_BuilderError>(m,·"StepToTopoDS_BuilderError",R"#()#")
191 ········.value("StepToTopoDS_TranslatePolyLoopDone",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopDone) 
192 ········.value("StepToTopoDS_TranslatePolyLoopOther",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopOther).export_values();195 ········.value("StepToTopoDS_BuilderDone",StepToTopoDS_BuilderError::StepToTopoDS_BuilderDone)
 196 ········.value("StepToTopoDS_BuilderOther",StepToTopoDS_BuilderError::StepToTopoDS_BuilderOther).export_values();
193 ····py::enum_<StepToTopoDS_TranslateEdgeError>(m,·"StepToTopoDS_TranslateEdgeError",R"#()#")197 ····py::enum_<StepToTopoDS_TranslateEdgeError>(m,·"StepToTopoDS_TranslateEdgeError",R"#()#")
194 ········.value("StepToTopoDS_TranslateEdgeDone",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeDone)198 ········.value("StepToTopoDS_TranslateEdgeDone",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeDone)
195 ········.value("StepToTopoDS_TranslateEdgeOther",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeOther).export_values();199 ········.value("StepToTopoDS_TranslateEdgeOther",StepToTopoDS_TranslateEdgeError::StepToTopoDS_TranslateEdgeOther).export_values();
196 ····py::enum_<StepToTopoDS_TranslateEdgeLoopError>(m,·"StepToTopoDS_TranslateEdgeLoopError",R"#()#")200 ····py::enum_<StepToTopoDS_TranslatePolyLoopError>(m,·"StepToTopoDS_TranslatePolyLoopError",R"#()#")
197 ········.value("StepToTopoDS_TranslateEdgeLoopDone",StepToTopoDS_TranslateEdgeLoopError::StepToTopoDS_TranslateEdgeLoopDone)201 ········.value("StepToTopoDS_TranslatePolyLoopDone",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopDone)
198 ········.value("StepToTopoDS_TranslateEdgeLoopOther",StepToTopoDS_TranslateEdgeLoopError::StepToTopoDS_TranslateEdgeLoopOther).export_values();202 ········.value("StepToTopoDS_TranslatePolyLoopOther",StepToTopoDS_TranslatePolyLoopError::StepToTopoDS_TranslatePolyLoopOther).export_values();
199 ····py::enum_<StepToTopoDS_GeometricToolError>(m,·"StepToTopoDS_GeometricToolError",R"#()#")203 ····py::enum_<StepToTopoDS_TranslateSolidError>(m,·"StepToTopoDS_TranslateSolidError",R"#()#")
 204 ········.value("StepToTopoDS_TranslateSolidDone",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidDone)
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();205 ········.value("StepToTopoDS_TranslateSolidOther",StepToTopoDS_TranslateSolidError::StepToTopoDS_TranslateSolidOther).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.)#");
⊟
4.32 KB
./usr/share/libocp/OCP/StepVisual_pre.cpp
Ordering differences only
    
Offset 366, 41 lines modifiedOffset 366, 41 lines modified
366 py::module·m·=·main_module.def_submodule("StepVisual",·R"#()#");366 py::module·m·=·main_module.def_submodule("StepVisual",·R"#()#");
  
367 //·add·namespaces·as·submodules367 //·add·namespaces·as·submodules
  
368 //·user-defined·inclusion·per·module·in·the·body368 //·user-defined·inclusion·per·module·in·the·body
  
369 //·enums369 //·enums
 370 ····py::enum_<StepVisual_NullStyle>(m,·"StepVisual_NullStyle",R"#()#")
370 ····py::enum_<StepVisual_CentralOrParallel>(m,·"StepVisual_CentralOrParallel",R"#()#") 
371 ········.value("StepVisual_copCentral",StepVisual_CentralOrParallel::StepVisual_copCentral) 
372 ········.value("StepVisual_copParallel",StepVisual_CentralOrParallel::StepVisual_copParallel).export_values();371 ········.value("StepVisual_Null",StepVisual_NullStyle::StepVisual_Null).export_values();
 372 ····py::enum_<StepVisual_TextPath>(m,·"StepVisual_TextPath",R"#()#")
 373 ········.value("StepVisual_tpUp",StepVisual_TextPath::StepVisual_tpUp)
 374 ········.value("StepVisual_tpRight",StepVisual_TextPath::StepVisual_tpRight)
 375 ········.value("StepVisual_tpDown",StepVisual_TextPath::StepVisual_tpDown)
 376 ········.value("StepVisual_tpLeft",StepVisual_TextPath::StepVisual_tpLeft).export_values();
 377 ····py::enum_<StepVisual_SurfaceSide>(m,·"StepVisual_SurfaceSide",R"#()#")
 378 ········.value("StepVisual_ssNegative",StepVisual_SurfaceSide::StepVisual_ssNegative)
 379 ········.value("StepVisual_ssPositive",StepVisual_SurfaceSide::StepVisual_ssPositive)
 380 ········.value("StepVisual_ssBoth",StepVisual_SurfaceSide::StepVisual_ssBoth).export_values();
373 ····py::enum_<StepVisual_MarkerType>(m,·"StepVisual_MarkerType",R"#()#")381 ····py::enum_<StepVisual_MarkerType>(m,·"StepVisual_MarkerType",R"#()#")
374 ········.value("StepVisual_mtDot",StepVisual_MarkerType::StepVisual_mtDot)382 ········.value("StepVisual_mtDot",StepVisual_MarkerType::StepVisual_mtDot)
375 ········.value("StepVisual_mtX",StepVisual_MarkerType::StepVisual_mtX)383 ········.value("StepVisual_mtX",StepVisual_MarkerType::StepVisual_mtX)
376 ········.value("StepVisual_mtPlus",StepVisual_MarkerType::StepVisual_mtPlus)384 ········.value("StepVisual_mtPlus",StepVisual_MarkerType::StepVisual_mtPlus)
377 ········.value("StepVisual_mtAsterisk",StepVisual_MarkerType::StepVisual_mtAsterisk)385 ········.value("StepVisual_mtAsterisk",StepVisual_MarkerType::StepVisual_mtAsterisk)
378 ········.value("StepVisual_mtRing",StepVisual_MarkerType::StepVisual_mtRing)386 ········.value("StepVisual_mtRing",StepVisual_MarkerType::StepVisual_mtRing)
379 ········.value("StepVisual_mtSquare",StepVisual_MarkerType::StepVisual_mtSquare)387 ········.value("StepVisual_mtSquare",StepVisual_MarkerType::StepVisual_mtSquare)
380 ········.value("StepVisual_mtTriangle",StepVisual_MarkerType::StepVisual_mtTriangle).export_values();388 ········.value("StepVisual_mtTriangle",StepVisual_MarkerType::StepVisual_mtTriangle).export_values();
381 ····py::enum_<StepVisual_SurfaceSide>(m,·"StepVisual_SurfaceSide",R"#()#") 
382 ········.value("StepVisual_ssNegative",StepVisual_SurfaceSide::StepVisual_ssNegative) 
383 ········.value("StepVisual_ssPositive",StepVisual_SurfaceSide::StepVisual_ssPositive) 
384 ········.value("StepVisual_ssBoth",StepVisual_SurfaceSide::StepVisual_ssBoth).export_values(); 
385 ····py::enum_<StepVisual_TextPath>(m,·"StepVisual_TextPath",R"#()#") 
386 ········.value("StepVisual_tpUp",StepVisual_TextPath::StepVisual_tpUp) 
387 ········.value("StepVisual_tpRight",StepVisual_TextPath::StepVisual_tpRight) 
388 ········.value("StepVisual_tpDown",StepVisual_TextPath::StepVisual_tpDown) 
389 ········.value("StepVisual_tpLeft",StepVisual_TextPath::StepVisual_tpLeft).export_values(); 
390 ····py::enum_<StepVisual_NullStyle>(m,·"StepVisual_NullStyle",R"#()#") 
391 ········.value("StepVisual_Null",StepVisual_NullStyle::StepVisual_Null).export_values(); 
392 ····py::enum_<StepVisual_ShadingSurfaceMethod>(m,·"StepVisual_ShadingSurfaceMethod",R"#()#")389 ····py::enum_<StepVisual_ShadingSurfaceMethod>(m,·"StepVisual_ShadingSurfaceMethod",R"#()#")
393 ········.value("StepVisual_ssmConstantShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmConstantShading)390 ········.value("StepVisual_ssmConstantShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmConstantShading)
394 ········.value("StepVisual_ssmColourShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmColourShading)391 ········.value("StepVisual_ssmColourShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmColourShading)
395 ········.value("StepVisual_ssmDotShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmDotShading)392 ········.value("StepVisual_ssmDotShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmDotShading)
396 ········.value("StepVisual_ssmNormalShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmNormalShading).export_values();393 ········.value("StepVisual_ssmNormalShading",StepVisual_ShadingSurfaceMethod::StepVisual_ssmNormalShading).export_values();
 394 ····py::enum_<StepVisual_CentralOrParallel>(m,·"StepVisual_CentralOrParallel",R"#()#")
 395 ········.value("StepVisual_copCentral",StepVisual_CentralOrParallel::StepVisual_copCentral)
 396 ········.value("StepVisual_copParallel",StepVisual_CentralOrParallel::StepVisual_copParallel).export_values();
  
397 //Python·trampoline·classes397 //Python·trampoline·classes
  
398 //·pre-register·typdefs+classes·(topologically·sorted)398 //·pre-register·typdefs+classes·(topologically·sorted)
399 ····py::class_<StepVisual_BoxCharacteristicSelect·,·shared_ptr<StepVisual_BoxCharacteristicSelect>··>(m,"StepVisual_BoxCharacteristicSelect",R"#()#");399 ····py::class_<StepVisual_BoxCharacteristicSelect·,·shared_ptr<StepVisual_BoxCharacteristicSelect>··>(m,"StepVisual_BoxCharacteristicSelect",R"#()#");
400 ····py::class_<StepVisual_DirectionCountSelect·,·shared_ptr<StepVisual_DirectionCountSelect>··>(m,"StepVisual_DirectionCountSelect",R"#()#");400 ····py::class_<StepVisual_DirectionCountSelect·,·shared_ptr<StepVisual_DirectionCountSelect>··>(m,"StepVisual_DirectionCountSelect",R"#()#");
401 ····py::class_<StepVisual_AnnotationFillArea·,opencascade::handle<StepVisual_AnnotationFillArea>··,·StepShape_GeometricCurveSet·>(m,"StepVisual_AnnotationFillArea",R"#()#");401 ····py::class_<StepVisual_AnnotationFillArea·,opencascade::handle<StepVisual_AnnotationFillArea>··,·StepShape_GeometricCurveSet·>(m,"StepVisual_AnnotationFillArea",R"#()#");
⊟
4.27 KB
./usr/share/libocp/OCP/Storage_pre.cpp
Ordering differences only
    
Offset 99, 23 lines modifiedOffset 99, 14 lines modified
99 py::module·m·=·main_module.def_submodule("Storage",·R"#()#");99 py::module·m·=·main_module.def_submodule("Storage",·R"#()#");
  
100 //·add·namespaces·as·submodules100 //·add·namespaces·as·submodules
  
101 //·user-defined·inclusion·per·module·in·the·body101 //·user-defined·inclusion·per·module·in·the·body
  
102 //·enums102 //·enums
103 ····py::enum_<Storage_SolveMode>(m,·"Storage_SolveMode",R"#()#") 
104 ········.value("Storage_AddSolve",Storage_SolveMode::Storage_AddSolve) 
105 ········.value("Storage_WriteSolve",Storage_SolveMode::Storage_WriteSolve) 
106 ········.value("Storage_ReadSolve",Storage_SolveMode::Storage_ReadSolve).export_values(); 
107 ····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.)#") 
108 ········.value("Storage_VSNone",Storage_OpenMode::Storage_VSNone) 
109 ········.value("Storage_VSRead",Storage_OpenMode::Storage_VSRead) 
110 ········.value("Storage_VSWrite",Storage_OpenMode::Storage_VSWrite) 
111 ········.value("Storage_VSReadWrite",Storage_OpenMode::Storage_VSReadWrite).export_values(); 
112 ····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)#")103 ····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)#")
113 ········.value("Storage_VSOk",Storage_Error::Storage_VSOk)104 ········.value("Storage_VSOk",Storage_Error::Storage_VSOk)
114 ········.value("Storage_VSOpenError",Storage_Error::Storage_VSOpenError)105 ········.value("Storage_VSOpenError",Storage_Error::Storage_VSOpenError)
115 ········.value("Storage_VSModeError",Storage_Error::Storage_VSModeError)106 ········.value("Storage_VSModeError",Storage_Error::Storage_VSModeError)
116 ········.value("Storage_VSCloseError",Storage_Error::Storage_VSCloseError)107 ········.value("Storage_VSCloseError",Storage_Error::Storage_VSCloseError)
117 ········.value("Storage_VSAlreadyOpen",Storage_Error::Storage_VSAlreadyOpen)108 ········.value("Storage_VSAlreadyOpen",Storage_Error::Storage_VSAlreadyOpen)
118 ········.value("Storage_VSNotOpen",Storage_Error::Storage_VSNotOpen)109 ········.value("Storage_VSNotOpen",Storage_Error::Storage_VSNotOpen)
Offset 123, 14 lines modifiedOffset 114, 23 lines modified
123 ········.value("Storage_VSWriteError",Storage_Error::Storage_VSWriteError)114 ········.value("Storage_VSWriteError",Storage_Error::Storage_VSWriteError)
124 ········.value("Storage_VSFormatError",Storage_Error::Storage_VSFormatError)115 ········.value("Storage_VSFormatError",Storage_Error::Storage_VSFormatError)
125 ········.value("Storage_VSUnknownType",Storage_Error::Storage_VSUnknownType)116 ········.value("Storage_VSUnknownType",Storage_Error::Storage_VSUnknownType)
126 ········.value("Storage_VSTypeMismatch",Storage_Error::Storage_VSTypeMismatch)117 ········.value("Storage_VSTypeMismatch",Storage_Error::Storage_VSTypeMismatch)
127 ········.value("Storage_VSInternalError",Storage_Error::Storage_VSInternalError)118 ········.value("Storage_VSInternalError",Storage_Error::Storage_VSInternalError)
128 ········.value("Storage_VSExtCharParityError",Storage_Error::Storage_VSExtCharParityError)119 ········.value("Storage_VSExtCharParityError",Storage_Error::Storage_VSExtCharParityError)
129 ········.value("Storage_VSWrongFileDriver",Storage_Error::Storage_VSWrongFileDriver).export_values();120 ········.value("Storage_VSWrongFileDriver",Storage_Error::Storage_VSWrongFileDriver).export_values();
 121 ····py::enum_<Storage_SolveMode>(m,·"Storage_SolveMode",R"#()#")
 122 ········.value("Storage_AddSolve",Storage_SolveMode::Storage_AddSolve)
 123 ········.value("Storage_WriteSolve",Storage_SolveMode::Storage_WriteSolve)
 124 ········.value("Storage_ReadSolve",Storage_SolveMode::Storage_ReadSolve).export_values();
 125 ····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.)#")
 126 ········.value("Storage_VSNone",Storage_OpenMode::Storage_VSNone)
 127 ········.value("Storage_VSRead",Storage_OpenMode::Storage_VSRead)
 128 ········.value("Storage_VSWrite",Storage_OpenMode::Storage_VSWrite)
 129 ········.value("Storage_VSReadWrite",Storage_OpenMode::Storage_VSReadWrite).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, 14 lines modifiedOffset 90, 23 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();
94 ····py::enum_<TDataXtd_ConstraintEnum>(m,·"TDataXtd_ConstraintEnum",R"#(The·terms·of·this·enumeration·define·the·types·of·available·constraint.·==================)#")103 ····py::enum_<TDataXtd_ConstraintEnum>(m,·"TDataXtd_ConstraintEnum",R"#(The·terms·of·this·enumeration·define·the·types·of·available·constraint.·==================)#")
95 ········.value("TDataXtd_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_RADIUS)104 ········.value("TDataXtd_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_RADIUS)
96 ········.value("TDataXtd_DIAMETER",TDataXtd_ConstraintEnum::TDataXtd_DIAMETER)105 ········.value("TDataXtd_DIAMETER",TDataXtd_ConstraintEnum::TDataXtd_DIAMETER)
97 ········.value("TDataXtd_MINOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MINOR_RADIUS)106 ········.value("TDataXtd_MINOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MINOR_RADIUS)
98 ········.value("TDataXtd_MAJOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MAJOR_RADIUS)107 ········.value("TDataXtd_MAJOR_RADIUS",TDataXtd_ConstraintEnum::TDataXtd_MAJOR_RADIUS)
99 ········.value("TDataXtd_TANGENT",TDataXtd_ConstraintEnum::TDataXtd_TANGENT)108 ········.value("TDataXtd_TANGENT",TDataXtd_ConstraintEnum::TDataXtd_TANGENT)
100 ········.value("TDataXtd_PARALLEL",TDataXtd_ConstraintEnum::TDataXtd_PARALLEL)109 ········.value("TDataXtd_PARALLEL",TDataXtd_ConstraintEnum::TDataXtd_PARALLEL)
Offset 117, 23 lines modifiedOffset 126, 14 lines modified
117 ········.value("TDataXtd_MATE",TDataXtd_ConstraintEnum::TDataXtd_MATE)126 ········.value("TDataXtd_MATE",TDataXtd_ConstraintEnum::TDataXtd_MATE)
118 ········.value("TDataXtd_ALIGN_FACES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_FACES)127 ········.value("TDataXtd_ALIGN_FACES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_FACES)
119 ········.value("TDataXtd_ALIGN_AXES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_AXES)128 ········.value("TDataXtd_ALIGN_AXES",TDataXtd_ConstraintEnum::TDataXtd_ALIGN_AXES)
120 ········.value("TDataXtd_AXES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_AXES_ANGLE)129 ········.value("TDataXtd_AXES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_AXES_ANGLE)
121 ········.value("TDataXtd_FACES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_FACES_ANGLE)130 ········.value("TDataXtd_FACES_ANGLE",TDataXtd_ConstraintEnum::TDataXtd_FACES_ANGLE)
122 ········.value("TDataXtd_ROUND",TDataXtd_ConstraintEnum::TDataXtd_ROUND)131 ········.value("TDataXtd_ROUND",TDataXtd_ConstraintEnum::TDataXtd_ROUND)
123 ········.value("TDataXtd_OFFSET",TDataXtd_ConstraintEnum::TDataXtd_OFFSET).export_values();132 ········.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;
  
  
⊟
3.99 KB
./usr/share/libocp/OCP/TopAbs_pre.cpp
Ordering differences only
    
Offset 44, 24 lines modifiedOffset 44, 24 lines modified
44 ········.value("TopAbs_SOLID",TopAbs_ShapeEnum::TopAbs_SOLID)44 ········.value("TopAbs_SOLID",TopAbs_ShapeEnum::TopAbs_SOLID)
45 ········.value("TopAbs_SHELL",TopAbs_ShapeEnum::TopAbs_SHELL)45 ········.value("TopAbs_SHELL",TopAbs_ShapeEnum::TopAbs_SHELL)
46 ········.value("TopAbs_FACE",TopAbs_ShapeEnum::TopAbs_FACE)46 ········.value("TopAbs_FACE",TopAbs_ShapeEnum::TopAbs_FACE)
47 ········.value("TopAbs_WIRE",TopAbs_ShapeEnum::TopAbs_WIRE)47 ········.value("TopAbs_WIRE",TopAbs_ShapeEnum::TopAbs_WIRE)
48 ········.value("TopAbs_EDGE",TopAbs_ShapeEnum::TopAbs_EDGE)48 ········.value("TopAbs_EDGE",TopAbs_ShapeEnum::TopAbs_EDGE)
49 ········.value("TopAbs_VERTEX",TopAbs_ShapeEnum::TopAbs_VERTEX)49 ········.value("TopAbs_VERTEX",TopAbs_ShapeEnum::TopAbs_VERTEX)
50 ········.value("TopAbs_SHAPE",TopAbs_ShapeEnum::TopAbs_SHAPE).export_values();50 ········.value("TopAbs_SHAPE",TopAbs_ShapeEnum::TopAbs_SHAPE).export_values();
51 ····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.)#") 
52 ········.value("TopAbs_FORWARD",TopAbs_Orientation::TopAbs_FORWARD) 
53 ········.value("TopAbs_REVERSED",TopAbs_Orientation::TopAbs_REVERSED) 
54 ········.value("TopAbs_INTERNAL",TopAbs_Orientation::TopAbs_INTERNAL) 
55 ········.value("TopAbs_EXTERNAL",TopAbs_Orientation::TopAbs_EXTERNAL).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.)#")51 ····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)52 ········.value("TopAbs_IN",TopAbs_State::TopAbs_IN)
58 ········.value("TopAbs_OUT",TopAbs_State::TopAbs_OUT)53 ········.value("TopAbs_OUT",TopAbs_State::TopAbs_OUT)
59 ········.value("TopAbs_ON",TopAbs_State::TopAbs_ON)54 ········.value("TopAbs_ON",TopAbs_State::TopAbs_ON)
60 ········.value("TopAbs_UNKNOWN",TopAbs_State::TopAbs_UNKNOWN).export_values();55 ········.value("TopAbs_UNKNOWN",TopAbs_State::TopAbs_UNKNOWN).export_values();
 56 ····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.)#")
 57 ········.value("TopAbs_FORWARD",TopAbs_Orientation::TopAbs_FORWARD)
 58 ········.value("TopAbs_REVERSED",TopAbs_Orientation::TopAbs_REVERSED)
 59 ········.value("TopAbs_INTERNAL",TopAbs_Orientation::TopAbs_INTERNAL)
 60 ········.value("TopAbs_EXTERNAL",TopAbs_Orientation::TopAbs_EXTERNAL).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 };
⊟
3.14 KB
./usr/share/libocp/OCP/TopOpeBRepDS_pre.cpp
Ordering differences only
    
Offset 202, 34 lines modifiedOffset 202, 34 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_Config>(m,·"TopOpeBRepDS_Config",R"#()#")206 ····py::enum_<TopOpeBRepDS_CheckStatus>(m,·"TopOpeBRepDS_CheckStatus",R"#()#")
207 ········.value("TopOpeBRepDS_UNSHGEOMETRY",TopOpeBRepDS_Config::TopOpeBRepDS_UNSHGEOMETRY)207 ········.value("TopOpeBRepDS_OK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_OK)
208 ········.value("TopOpeBRepDS_SAMEORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_SAMEORIENTED) 
209 ········.value("TopOpeBRepDS_DIFFORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_DIFFORIENTED).export_values();208 ········.value("TopOpeBRepDS_NOK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_NOK).export_values();
210 ····py::enum_<TopOpeBRepDS_Kind>(m,·"TopOpeBRepDS_Kind",R"#(different·types·of·objects·in·DataStructure)#")209 ····py::enum_<TopOpeBRepDS_Kind>(m,·"TopOpeBRepDS_Kind",R"#(different·types·of·objects·in·DataStructure)#")
211 ········.value("TopOpeBRepDS_POINT",TopOpeBRepDS_Kind::TopOpeBRepDS_POINT)210 ········.value("TopOpeBRepDS_POINT",TopOpeBRepDS_Kind::TopOpeBRepDS_POINT)
212 ········.value("TopOpeBRepDS_CURVE",TopOpeBRepDS_Kind::TopOpeBRepDS_CURVE)211 ········.value("TopOpeBRepDS_CURVE",TopOpeBRepDS_Kind::TopOpeBRepDS_CURVE)
213 ········.value("TopOpeBRepDS_SURFACE",TopOpeBRepDS_Kind::TopOpeBRepDS_SURFACE)212 ········.value("TopOpeBRepDS_SURFACE",TopOpeBRepDS_Kind::TopOpeBRepDS_SURFACE)
214 ········.value("TopOpeBRepDS_VERTEX",TopOpeBRepDS_Kind::TopOpeBRepDS_VERTEX)213 ········.value("TopOpeBRepDS_VERTEX",TopOpeBRepDS_Kind::TopOpeBRepDS_VERTEX)
215 ········.value("TopOpeBRepDS_EDGE",TopOpeBRepDS_Kind::TopOpeBRepDS_EDGE)214 ········.value("TopOpeBRepDS_EDGE",TopOpeBRepDS_Kind::TopOpeBRepDS_EDGE)
216 ········.value("TopOpeBRepDS_WIRE",TopOpeBRepDS_Kind::TopOpeBRepDS_WIRE)215 ········.value("TopOpeBRepDS_WIRE",TopOpeBRepDS_Kind::TopOpeBRepDS_WIRE)
217 ········.value("TopOpeBRepDS_FACE",TopOpeBRepDS_Kind::TopOpeBRepDS_FACE)216 ········.value("TopOpeBRepDS_FACE",TopOpeBRepDS_Kind::TopOpeBRepDS_FACE)
218 ········.value("TopOpeBRepDS_SHELL",TopOpeBRepDS_Kind::TopOpeBRepDS_SHELL)217 ········.value("TopOpeBRepDS_SHELL",TopOpeBRepDS_Kind::TopOpeBRepDS_SHELL)
219 ········.value("TopOpeBRepDS_SOLID",TopOpeBRepDS_Kind::TopOpeBRepDS_SOLID)218 ········.value("TopOpeBRepDS_SOLID",TopOpeBRepDS_Kind::TopOpeBRepDS_SOLID)
220 ········.value("TopOpeBRepDS_COMPSOLID",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPSOLID)219 ········.value("TopOpeBRepDS_COMPSOLID",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPSOLID)
221 ········.value("TopOpeBRepDS_COMPOUND",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPOUND)220 ········.value("TopOpeBRepDS_COMPOUND",TopOpeBRepDS_Kind::TopOpeBRepDS_COMPOUND)
222 ········.value("TopOpeBRepDS_UNKNOWN",TopOpeBRepDS_Kind::TopOpeBRepDS_UNKNOWN).export_values();221 ········.value("TopOpeBRepDS_UNKNOWN",TopOpeBRepDS_Kind::TopOpeBRepDS_UNKNOWN).export_values();
223 ····py::enum_<TopOpeBRepDS_CheckStatus>(m,·"TopOpeBRepDS_CheckStatus",R"#()#")222 ····py::enum_<TopOpeBRepDS_Config>(m,·"TopOpeBRepDS_Config",R"#()#")
224 ········.value("TopOpeBRepDS_OK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_OK)223 ········.value("TopOpeBRepDS_UNSHGEOMETRY",TopOpeBRepDS_Config::TopOpeBRepDS_UNSHGEOMETRY)
 224 ········.value("TopOpeBRepDS_SAMEORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_SAMEORIENTED)
225 ········.value("TopOpeBRepDS_NOK",TopOpeBRepDS_CheckStatus::TopOpeBRepDS_NOK).export_values();225 ········.value("TopOpeBRepDS_DIFFORIENTED",TopOpeBRepDS_Config::TopOpeBRepDS_DIFFORIENTED).export_values();
  
226 //Python·trampoline·classes226 //Python·trampoline·classes
  
227 //·pre-register·typdefs+classes·(topologically·sorted)227 //·pre-register·typdefs+classes·(topologically·sorted)
228 ····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.)#");228 ····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.)#");
229 ····py::class_<TopOpeBRepDS_BuildTool·,·shared_ptr<TopOpeBRepDS_BuildTool>··>(m,"TopOpeBRepDS_BuildTool",R"#(Provides·a·Tool·to·build·topologies.·Used·to·instantiate·the·Builder·algorithm.)#");229 ····py::class_<TopOpeBRepDS_BuildTool·,·shared_ptr<TopOpeBRepDS_BuildTool>··>(m,"TopOpeBRepDS_BuildTool",R"#(Provides·a·Tool·to·build·topologies.·Used·to·instantiate·the·Builder·algorithm.)#");
230 ····py::class_<TopOpeBRepDS_Curve·,·shared_ptr<TopOpeBRepDS_Curve>··>(m,"TopOpeBRepDS_Curve",R"#(A·Geom·curve·and·a·tolerance.)#");230 ····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.47 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_BuilderError>(m,·"TopoDSToStep_BuilderError",R"#()#") 
127 ········.value("TopoDSToStep_BuilderDone",TopoDSToStep_BuilderError::TopoDSToStep_BuilderDone) 
128 ········.value("TopoDSToStep_NoFaceMapped",TopoDSToStep_BuilderError::TopoDSToStep_NoFaceMapped) 
129 ········.value("TopoDSToStep_BuilderOther",TopoDSToStep_BuilderError::TopoDSToStep_BuilderOther).export_values(); 
130 ····py::enum_<TopoDSToStep_MakeVertexError>(m,·"TopoDSToStep_MakeVertexError",R"#()#") 
131 ········.value("TopoDSToStep_VertexDone",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexDone) 
132 ········.value("TopoDSToStep_VertexOther",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexOther).export_values(); 
133 ····py::enum_<TopoDSToStep_MakeWireError>(m,·"TopoDSToStep_MakeWireError",R"#()#")126 ····py::enum_<TopoDSToStep_MakeWireError>(m,·"TopoDSToStep_MakeWireError",R"#()#")
134 ········.value("TopoDSToStep_WireDone",TopoDSToStep_MakeWireError::TopoDSToStep_WireDone)127 ········.value("TopoDSToStep_WireDone",TopoDSToStep_MakeWireError::TopoDSToStep_WireDone)
135 ········.value("TopoDSToStep_NonManifoldWire",TopoDSToStep_MakeWireError::TopoDSToStep_NonManifoldWire)128 ········.value("TopoDSToStep_NonManifoldWire",TopoDSToStep_MakeWireError::TopoDSToStep_NonManifoldWire)
136 ········.value("TopoDSToStep_WireOther",TopoDSToStep_MakeWireError::TopoDSToStep_WireOther).export_values();129 ········.value("TopoDSToStep_WireOther",TopoDSToStep_MakeWireError::TopoDSToStep_WireOther).export_values();
137 ····py::enum_<TopoDSToStep_FacetedError>(m,·"TopoDSToStep_FacetedError",R"#()#") 
138 ········.value("TopoDSToStep_FacetedDone",TopoDSToStep_FacetedError::TopoDSToStep_FacetedDone) 
139 ········.value("TopoDSToStep_SurfaceNotPlane",TopoDSToStep_FacetedError::TopoDSToStep_SurfaceNotPlane) 
140 ········.value("TopoDSToStep_PCurveNotLinear",TopoDSToStep_FacetedError::TopoDSToStep_PCurveNotLinear).export_values(); 
141 ····py::enum_<TopoDSToStep_MakeEdgeError>(m,·"TopoDSToStep_MakeEdgeError",R"#()#")130 ····py::enum_<TopoDSToStep_MakeEdgeError>(m,·"TopoDSToStep_MakeEdgeError",R"#()#")
142 ········.value("TopoDSToStep_EdgeDone",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeDone)131 ········.value("TopoDSToStep_EdgeDone",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeDone)
143 ········.value("TopoDSToStep_NonManifoldEdge",TopoDSToStep_MakeEdgeError::TopoDSToStep_NonManifoldEdge)132 ········.value("TopoDSToStep_NonManifoldEdge",TopoDSToStep_MakeEdgeError::TopoDSToStep_NonManifoldEdge)
144 ········.value("TopoDSToStep_EdgeOther",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeOther).export_values();133 ········.value("TopoDSToStep_EdgeOther",TopoDSToStep_MakeEdgeError::TopoDSToStep_EdgeOther).export_values();
 134 ····py::enum_<TopoDSToStep_BuilderError>(m,·"TopoDSToStep_BuilderError",R"#()#")
 135 ········.value("TopoDSToStep_BuilderDone",TopoDSToStep_BuilderError::TopoDSToStep_BuilderDone)
 136 ········.value("TopoDSToStep_NoFaceMapped",TopoDSToStep_BuilderError::TopoDSToStep_NoFaceMapped)
 137 ········.value("TopoDSToStep_BuilderOther",TopoDSToStep_BuilderError::TopoDSToStep_BuilderOther).export_values();
 138 ····py::enum_<TopoDSToStep_MakeVertexError>(m,·"TopoDSToStep_MakeVertexError",R"#()#")
 139 ········.value("TopoDSToStep_VertexDone",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexDone)
 140 ········.value("TopoDSToStep_VertexOther",TopoDSToStep_MakeVertexError::TopoDSToStep_VertexOther).export_values();
145 ····py::enum_<TopoDSToStep_MakeFaceError>(m,·"TopoDSToStep_MakeFaceError",R"#()#")141 ····py::enum_<TopoDSToStep_MakeFaceError>(m,·"TopoDSToStep_MakeFaceError",R"#()#")
146 ········.value("TopoDSToStep_FaceDone",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceDone)142 ········.value("TopoDSToStep_FaceDone",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceDone)
147 ········.value("TopoDSToStep_InfiniteFace",TopoDSToStep_MakeFaceError::TopoDSToStep_InfiniteFace)143 ········.value("TopoDSToStep_InfiniteFace",TopoDSToStep_MakeFaceError::TopoDSToStep_InfiniteFace)
148 ········.value("TopoDSToStep_NonManifoldFace",TopoDSToStep_MakeFaceError::TopoDSToStep_NonManifoldFace)144 ········.value("TopoDSToStep_NonManifoldFace",TopoDSToStep_MakeFaceError::TopoDSToStep_NonManifoldFace)
149 ········.value("TopoDSToStep_NoWireMapped",TopoDSToStep_MakeFaceError::TopoDSToStep_NoWireMapped)145 ········.value("TopoDSToStep_NoWireMapped",TopoDSToStep_MakeFaceError::TopoDSToStep_NoWireMapped)
150 ········.value("TopoDSToStep_FaceOther",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceOther).export_values();146 ········.value("TopoDSToStep_FaceOther",TopoDSToStep_MakeFaceError::TopoDSToStep_FaceOther).export_values();
 147 ····py::enum_<TopoDSToStep_FacetedError>(m,·"TopoDSToStep_FacetedError",R"#()#")
 148 ········.value("TopoDSToStep_FacetedDone",TopoDSToStep_FacetedError::TopoDSToStep_FacetedDone)
 149 ········.value("TopoDSToStep_SurfaceNotPlane",TopoDSToStep_FacetedError::TopoDSToStep_SurfaceNotPlane)
 150 ········.value("TopoDSToStep_PCurveNotLinear",TopoDSToStep_FacetedError::TopoDSToStep_PCurveNotLinear).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.06 KB
./usr/share/libocp/OCP/Transfer_pre.cpp
Ordering differences only
    
Offset 144, 24 lines modifiedOffset 144, 24 lines modified
  
144 //·enums144 //·enums
145 ····py::enum_<Transfer_UndefMode>(m,·"Transfer_UndefMode",R"#(used·on·processing·Undefined·Entities·(see·TransferOutput))#")145 ····py::enum_<Transfer_UndefMode>(m,·"Transfer_UndefMode",R"#(used·on·processing·Undefined·Entities·(see·TransferOutput))#")
146 ········.value("Transfer_UndefIgnore",Transfer_UndefMode::Transfer_UndefIgnore)146 ········.value("Transfer_UndefIgnore",Transfer_UndefMode::Transfer_UndefIgnore)
147 ········.value("Transfer_UndefFailure",Transfer_UndefMode::Transfer_UndefFailure)147 ········.value("Transfer_UndefFailure",Transfer_UndefMode::Transfer_UndefFailure)
148 ········.value("Transfer_UndefContent",Transfer_UndefMode::Transfer_UndefContent)148 ········.value("Transfer_UndefContent",Transfer_UndefMode::Transfer_UndefContent)
149 ········.value("Transfer_UndefUser",Transfer_UndefMode::Transfer_UndefUser).export_values();149 ········.value("Transfer_UndefUser",Transfer_UndefMode::Transfer_UndefUser).export_values();
150 ····py::enum_<Transfer_StatusResult>(m,·"Transfer_StatusResult",R"#(result·status·of·transferring·an·entity·(see·Transcriptor))#") 
151 ········.value("Transfer_StatusVoid",Transfer_StatusResult::Transfer_StatusVoid) 
152 ········.value("Transfer_StatusDefined",Transfer_StatusResult::Transfer_StatusDefined) 
153 ········.value("Transfer_StatusUsed",Transfer_StatusResult::Transfer_StatusUsed).export_values(); 
154 ····py::enum_<Transfer_StatusExec>(m,·"Transfer_StatusExec",R"#(execution·status·of·an·individual·transfer·(see·Transcriptor))#")150 ····py::enum_<Transfer_StatusExec>(m,·"Transfer_StatusExec",R"#(execution·status·of·an·individual·transfer·(see·Transcriptor))#")
155 ········.value("Transfer_StatusInitial",Transfer_StatusExec::Transfer_StatusInitial)151 ········.value("Transfer_StatusInitial",Transfer_StatusExec::Transfer_StatusInitial)
156 ········.value("Transfer_StatusRun",Transfer_StatusExec::Transfer_StatusRun)152 ········.value("Transfer_StatusRun",Transfer_StatusExec::Transfer_StatusRun)
157 ········.value("Transfer_StatusDone",Transfer_StatusExec::Transfer_StatusDone)153 ········.value("Transfer_StatusDone",Transfer_StatusExec::Transfer_StatusDone)
158 ········.value("Transfer_StatusError",Transfer_StatusExec::Transfer_StatusError)154 ········.value("Transfer_StatusError",Transfer_StatusExec::Transfer_StatusError)
159 ········.value("Transfer_StatusLoop",Transfer_StatusExec::Transfer_StatusLoop).export_values();155 ········.value("Transfer_StatusLoop",Transfer_StatusExec::Transfer_StatusLoop).export_values();
 156 ····py::enum_<Transfer_StatusResult>(m,·"Transfer_StatusResult",R"#(result·status·of·transferring·an·entity·(see·Transcriptor))#")
 157 ········.value("Transfer_StatusVoid",Transfer_StatusResult::Transfer_StatusVoid)
 158 ········.value("Transfer_StatusDefined",Transfer_StatusResult::Transfer_StatusDefined)
 159 ········.value("Transfer_StatusUsed",Transfer_StatusResult::Transfer_StatusUsed).export_values();
  
160 //Python·trampoline·classes160 //Python·trampoline·classes
161 ····class·Py_Transfer_Binder·:·public·Transfer_Binder{161 ····class·Py_Transfer_Binder·:·public·Transfer_Binder{
162 ····public:162 ····public:
163 ········using·Transfer_Binder::Transfer_Binder;163 ········using·Transfer_Binder::Transfer_Binder;
  
  
⊟
4.53 KB
./usr/share/libocp/OCP/V3d_pre.cpp
Ordering differences only
    
Offset 78, 21 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_TypeOfVisualization>(m,·"V3d_TypeOfVisualization",R"#(Determines·the·type·of·visualization·in·the·view,·either·WIREFRAME·or·ZBUFFER·(shading).)#") 
83 ········.value("V3d_WIREFRAME",V3d_TypeOfVisualization::V3d_WIREFRAME) 
84 ········.value("V3d_ZBUFFER",V3d_TypeOfVisualization::V3d_ZBUFFER).export_values(); 
85 ····py::enum_<V3d_TypeOfAxe>(m,·"V3d_TypeOfAxe",R"#(Determines·the·axis·type·through·the·coordinates·X,·Y,·Z.)#") 
86 ········.value("V3d_X",V3d_TypeOfAxe::V3d_X) 
87 ········.value("V3d_Y",V3d_TypeOfAxe::V3d_Y) 
88 ········.value("V3d_Z",V3d_TypeOfAxe::V3d_Z).export_values(); 
89 ····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.)#")
90 ········.value("V3d_Xpos",V3d_TypeOfOrientation::V3d_Xpos)83 ········.value("V3d_Xpos",V3d_TypeOfOrientation::V3d_Xpos)
91 ········.value("V3d_Ypos",V3d_TypeOfOrientation::V3d_Ypos)84 ········.value("V3d_Ypos",V3d_TypeOfOrientation::V3d_Ypos)
92 ········.value("V3d_Zpos",V3d_TypeOfOrientation::V3d_Zpos)85 ········.value("V3d_Zpos",V3d_TypeOfOrientation::V3d_Zpos)
93 ········.value("V3d_Xneg",V3d_TypeOfOrientation::V3d_Xneg)86 ········.value("V3d_Xneg",V3d_TypeOfOrientation::V3d_Xneg)
94 ········.value("V3d_Yneg",V3d_TypeOfOrientation::V3d_Yneg)87 ········.value("V3d_Yneg",V3d_TypeOfOrientation::V3d_Yneg)
95 ········.value("V3d_Zneg",V3d_TypeOfOrientation::V3d_Zneg)88 ········.value("V3d_Zneg",V3d_TypeOfOrientation::V3d_Zneg)
Offset 128, 22 lines modifiedOffset 121, 29 lines modified
128 ········.value("V3d_TypeOfOrientation_Yup_AxoRight",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_AxoRight)121 ········.value("V3d_TypeOfOrientation_Yup_AxoRight",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_AxoRight)
129 ········.value("V3d_TypeOfOrientation_Yup_Front",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Front)122 ········.value("V3d_TypeOfOrientation_Yup_Front",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Front)
130 ········.value("V3d_TypeOfOrientation_Yup_Back",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Back)123 ········.value("V3d_TypeOfOrientation_Yup_Back",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Back)
131 ········.value("V3d_TypeOfOrientation_Yup_Top",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Top)124 ········.value("V3d_TypeOfOrientation_Yup_Top",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Top)
132 ········.value("V3d_TypeOfOrientation_Yup_Bottom",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Bottom)125 ········.value("V3d_TypeOfOrientation_Yup_Bottom",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Bottom)
133 ········.value("V3d_TypeOfOrientation_Yup_Left",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Left)126 ········.value("V3d_TypeOfOrientation_Yup_Left",V3d_TypeOfOrientation::V3d_TypeOfOrientation_Yup_Left)
134 ········.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_TypeOfView>(m,·"V3d_TypeOfView",R"#(Defines·the·type·of·projection·of·the·view.)#")
 129 ········.value("V3d_ORTHOGRAPHIC",V3d_TypeOfView::V3d_ORTHOGRAPHIC)
 130 ········.value("V3d_PERSPECTIVE",V3d_TypeOfView::V3d_PERSPECTIVE).export_values();
 131 ····py::enum_<V3d_TypeOfVisualization>(m,·"V3d_TypeOfVisualization",R"#(Determines·the·type·of·visualization·in·the·view,·either·WIREFRAME·or·ZBUFFER·(shading).)#")
 132 ········.value("V3d_WIREFRAME",V3d_TypeOfVisualization::V3d_WIREFRAME)
 133 ········.value("V3d_ZBUFFER",V3d_TypeOfVisualization::V3d_ZBUFFER).export_values();
135 ····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.)#")134 ····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.)#")
136 ········.value("V3d_SDO_MONO",V3d_StereoDumpOptions::V3d_SDO_MONO)135 ········.value("V3d_SDO_MONO",V3d_StereoDumpOptions::V3d_SDO_MONO)
137 ········.value("V3d_SDO_LEFT_EYE",V3d_StereoDumpOptions::V3d_SDO_LEFT_EYE)136 ········.value("V3d_SDO_LEFT_EYE",V3d_StereoDumpOptions::V3d_SDO_LEFT_EYE)
138 ········.value("V3d_SDO_RIGHT_EYE",V3d_StereoDumpOptions::V3d_SDO_RIGHT_EYE)137 ········.value("V3d_SDO_RIGHT_EYE",V3d_StereoDumpOptions::V3d_SDO_RIGHT_EYE)
139 ········.value("V3d_SDO_BLENDED",V3d_StereoDumpOptions::V3d_SDO_BLENDED).export_values();138 ········.value("V3d_SDO_BLENDED",V3d_StereoDumpOptions::V3d_SDO_BLENDED).export_values();
140 ····py::enum_<V3d_TypeOfView>(m,·"V3d_TypeOfView",R"#(Defines·the·type·of·projection·of·the·view.)#") 
141 ········.value("V3d_ORTHOGRAPHIC",V3d_TypeOfView::V3d_ORTHOGRAPHIC)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_PERSPECTIVE",V3d_TypeOfView::V3d_PERSPECTIVE).export_values();142 ········.value("V3d_Z",V3d_TypeOfAxe::V3d_Z).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.)#");
⊟
40.8 KB
./usr/share/libocp/OCP/XCAFDimTolObjects_pre.cpp
Ordering differences only
    
Offset 71, 14 lines modifiedOffset 71, 44 lines modified
71 py::module·m·=·main_module.def_submodule("XCAFDimTolObjects",·R"#()#");71 py::module·m·=·main_module.def_submodule("XCAFDimTolObjects",·R"#()#");
  
72 //·add·namespaces·as·submodules72 //·add·namespaces·as·submodules
  
73 //·user-defined·inclusion·per·module·in·the·body73 //·user-defined·inclusion·per·module·in·the·body
  
74 //·enums74 //·enums
 75 ····py::enum_<XCAFDimTolObjects_GeomToleranceZoneModif>(m,·"XCAFDimTolObjects_GeomToleranceZoneModif",R"#(Defines·types·of·zone)#")
 76 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_None",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_None)
 77 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_Projected",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_Projected)
 78 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_Runout",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_Runout)
 79 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_NonUniform",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_NonUniform).export_values();
 80 ····py::enum_<XCAFDimTolObjects_DimensionGrade>(m,·"XCAFDimTolObjects_DimensionGrade",R"#(Defines·value·of·grade)#")
 81 ········.value("XCAFDimTolObjects_DimensionGrade_IT01",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT01)
 82 ········.value("XCAFDimTolObjects_DimensionGrade_IT0",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT0)
 83 ········.value("XCAFDimTolObjects_DimensionGrade_IT1",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT1)
 84 ········.value("XCAFDimTolObjects_DimensionGrade_IT2",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT2)
 85 ········.value("XCAFDimTolObjects_DimensionGrade_IT3",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT3)
 86 ········.value("XCAFDimTolObjects_DimensionGrade_IT4",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT4)
 87 ········.value("XCAFDimTolObjects_DimensionGrade_IT5",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT5)
 88 ········.value("XCAFDimTolObjects_DimensionGrade_IT6",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT6)
 89 ········.value("XCAFDimTolObjects_DimensionGrade_IT7",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT7)
 90 ········.value("XCAFDimTolObjects_DimensionGrade_IT8",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT8)
 91 ········.value("XCAFDimTolObjects_DimensionGrade_IT9",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT9)
 92 ········.value("XCAFDimTolObjects_DimensionGrade_IT10",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT10)
 93 ········.value("XCAFDimTolObjects_DimensionGrade_IT11",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT11)
 94 ········.value("XCAFDimTolObjects_DimensionGrade_IT12",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT12)
 95 ········.value("XCAFDimTolObjects_DimensionGrade_IT13",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT13)
 96 ········.value("XCAFDimTolObjects_DimensionGrade_IT14",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT14)
 97 ········.value("XCAFDimTolObjects_DimensionGrade_IT15",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT15)
 98 ········.value("XCAFDimTolObjects_DimensionGrade_IT16",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT16)
 99 ········.value("XCAFDimTolObjects_DimensionGrade_IT17",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT17)
 100 ········.value("XCAFDimTolObjects_DimensionGrade_IT18",XCAFDimTolObjects_DimensionGrade::XCAFDimTolObjects_DimensionGrade_IT18).export_values();
 101 ····py::enum_<XCAFDimTolObjects_ToleranceZoneAffectedPlane>(m,·"XCAFDimTolObjects_ToleranceZoneAffectedPlane",R"#(Defines·types·of·tolerance·zone·affected·plane)#")
 102 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_None",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_None)
 103 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_Intersection",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_Intersection)
 104 ········.value("XCAFDimTolObjects_ToleranceZoneAffectedPlane_Orientation",XCAFDimTolObjects_ToleranceZoneAffectedPlane::XCAFDimTolObjects_ToleranceZoneAffectedPlane_Orientation).export_values();
75 ····py::enum_<XCAFDimTolObjects_DimensionFormVariance>(m,·"XCAFDimTolObjects_DimensionFormVariance",R"#(Defines·value·of·form·variance)#")105 ····py::enum_<XCAFDimTolObjects_DimensionFormVariance>(m,·"XCAFDimTolObjects_DimensionFormVariance",R"#(Defines·value·of·form·variance)#")
76 ········.value("XCAFDimTolObjects_DimensionFormVariance_None",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_None)106 ········.value("XCAFDimTolObjects_DimensionFormVariance_None",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_None)
77 ········.value("XCAFDimTolObjects_DimensionFormVariance_A",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_A)107 ········.value("XCAFDimTolObjects_DimensionFormVariance_A",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_A)
78 ········.value("XCAFDimTolObjects_DimensionFormVariance_B",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_B)108 ········.value("XCAFDimTolObjects_DimensionFormVariance_B",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_B)
79 ········.value("XCAFDimTolObjects_DimensionFormVariance_C",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_C)109 ········.value("XCAFDimTolObjects_DimensionFormVariance_C",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_C)
80 ········.value("XCAFDimTolObjects_DimensionFormVariance_CD",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_CD)110 ········.value("XCAFDimTolObjects_DimensionFormVariance_CD",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_CD)
81 ········.value("XCAFDimTolObjects_DimensionFormVariance_D",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_D)111 ········.value("XCAFDimTolObjects_DimensionFormVariance_D",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_D)
Offset 101, 14 lines modifiedOffset 131, 47 lines modified
101 ········.value("XCAFDimTolObjects_DimensionFormVariance_V",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_V)131 ········.value("XCAFDimTolObjects_DimensionFormVariance_V",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_V)
102 ········.value("XCAFDimTolObjects_DimensionFormVariance_X",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_X)132 ········.value("XCAFDimTolObjects_DimensionFormVariance_X",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_X)
103 ········.value("XCAFDimTolObjects_DimensionFormVariance_Y",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Y)133 ········.value("XCAFDimTolObjects_DimensionFormVariance_Y",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Y)
104 ········.value("XCAFDimTolObjects_DimensionFormVariance_Z",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Z)134 ········.value("XCAFDimTolObjects_DimensionFormVariance_Z",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_Z)
105 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZA",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZA)135 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZA",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZA)
106 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZB",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZB)136 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZB",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZB)
107 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZC",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZC).export_values();137 ········.value("XCAFDimTolObjects_DimensionFormVariance_ZC",XCAFDimTolObjects_DimensionFormVariance::XCAFDimTolObjects_DimensionFormVariance_ZC).export_values();
 138 ····py::enum_<XCAFDimTolObjects_DimensionType>(m,·"XCAFDimTolObjects_DimensionType",R"#(Defines·types·of·dimension)#")
 139 ········.value("XCAFDimTolObjects_DimensionType_Location_None",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_None)
 140 ········.value("XCAFDimTolObjects_DimensionType_Location_CurvedDistance",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_CurvedDistance)
 141 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance)
 142 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromCenterToOuter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromCenterToOuter)
 143 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromCenterToInner",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromCenterToInner)
 144 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromOuterToCenter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromOuterToCenter)
 145 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromOuterToOuter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromOuterToOuter)
 146 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromOuterToInner",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromOuterToInner)
 147 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromInnerToCenter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromInnerToCenter)
 148 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromInnerToOuter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromInnerToOuter)
 149 ········.value("XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromInnerToInner",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_LinearDistance_FromInnerToInner)
 150 ········.value("XCAFDimTolObjects_DimensionType_Location_Angular",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_Angular)
 151 ········.value("XCAFDimTolObjects_DimensionType_Location_Oriented",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_Oriented)
 152 ········.value("XCAFDimTolObjects_DimensionType_Location_WithPath",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Location_WithPath)
 153 ········.value("XCAFDimTolObjects_DimensionType_Size_CurveLength",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_CurveLength)
 154 ········.value("XCAFDimTolObjects_DimensionType_Size_Diameter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_Diameter)
 155 ········.value("XCAFDimTolObjects_DimensionType_Size_SphericalDiameter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_SphericalDiameter)
 156 ········.value("XCAFDimTolObjects_DimensionType_Size_Radius",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_Radius)
 157 ········.value("XCAFDimTolObjects_DimensionType_Size_SphericalRadius",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_SphericalRadius)
 158 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalMinorDiameter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalMinorDiameter)
 159 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalMajorDiameter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalMajorDiameter)
 160 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalMinorRadius",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalMinorRadius)
 161 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalMajorRadius",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalMajorRadius)
 162 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalHighMajorDiameter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalHighMajorDiameter)
 163 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalLowMajorDiameter",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalLowMajorDiameter)
 164 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalHighMajorRadius",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalHighMajorRadius)
 165 ········.value("XCAFDimTolObjects_DimensionType_Size_ToroidalLowMajorRadius",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_ToroidalLowMajorRadius)
 166 ········.value("XCAFDimTolObjects_DimensionType_Size_Thickness",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_Thickness)
 167 ········.value("XCAFDimTolObjects_DimensionType_Size_Angular",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_Angular)
 168 ········.value("XCAFDimTolObjects_DimensionType_Size_WithPath",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_Size_WithPath)
 169 ········.value("XCAFDimTolObjects_DimensionType_CommonLabel",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_CommonLabel)
 170 ········.value("XCAFDimTolObjects_DimensionType_DimensionPresentation",XCAFDimTolObjects_DimensionType::XCAFDimTolObjects_DimensionType_DimensionPresentation).export_values();
108 ····py::enum_<XCAFDimTolObjects_DatumSingleModif>(m,·"XCAFDimTolObjects_DatumSingleModif",R"#(Defines·modifirs)#")171 ····py::enum_<XCAFDimTolObjects_DatumSingleModif>(m,·"XCAFDimTolObjects_DatumSingleModif",R"#(Defines·modifirs)#")
109 ········.value("XCAFDimTolObjects_DatumSingleModif_AnyCrossSection",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_AnyCrossSection)172 ········.value("XCAFDimTolObjects_DatumSingleModif_AnyCrossSection",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_AnyCrossSection)
110 ········.value("XCAFDimTolObjects_DatumSingleModif_Any_LongitudinalSection",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Any_LongitudinalSection)173 ········.value("XCAFDimTolObjects_DatumSingleModif_Any_LongitudinalSection",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Any_LongitudinalSection)
111 ········.value("XCAFDimTolObjects_DatumSingleModif_Basic",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Basic)174 ········.value("XCAFDimTolObjects_DatumSingleModif_Basic",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Basic)
112 ········.value("XCAFDimTolObjects_DatumSingleModif_ContactingFeature",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_ContactingFeature)175 ········.value("XCAFDimTolObjects_DatumSingleModif_ContactingFeature",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_ContactingFeature)
113 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintU",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintU)176 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintU",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintU)
114 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintV",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintV)177 ········.value("XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintV",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_DegreeOfFreedomConstraintV)
Offset 124, 19 lines modifiedOffset 187, 29 lines modified
124 ········.value("XCAFDimTolObjects_DatumSingleModif_MaximumMaterialRequirement",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_MaximumMaterialRequirement)187 ········.value("XCAFDimTolObjects_DatumSingleModif_MaximumMaterialRequirement",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_MaximumMaterialRequirement)
125 ········.value("XCAFDimTolObjects_DatumSingleModif_MinorDiameter",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_MinorDiameter)188 ········.value("XCAFDimTolObjects_DatumSingleModif_MinorDiameter",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_MinorDiameter)
126 ········.value("XCAFDimTolObjects_DatumSingleModif_Orientation",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Orientation)189 ········.value("XCAFDimTolObjects_DatumSingleModif_Orientation",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Orientation)
127 ········.value("XCAFDimTolObjects_DatumSingleModif_PitchDiameter",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_PitchDiameter)190 ········.value("XCAFDimTolObjects_DatumSingleModif_PitchDiameter",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_PitchDiameter)
128 ········.value("XCAFDimTolObjects_DatumSingleModif_Plane",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Plane)191 ········.value("XCAFDimTolObjects_DatumSingleModif_Plane",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Plane)
129 ········.value("XCAFDimTolObjects_DatumSingleModif_Point",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Point)192 ········.value("XCAFDimTolObjects_DatumSingleModif_Point",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Point)
130 ········.value("XCAFDimTolObjects_DatumSingleModif_Translation",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Translation).export_values();193 ········.value("XCAFDimTolObjects_DatumSingleModif_Translation",XCAFDimTolObjects_DatumSingleModif::XCAFDimTolObjects_DatumSingleModif_Translation).export_values();
 194 ····py::enum_<XCAFDimTolObjects_DatumTargetType>(m,·"XCAFDimTolObjects_DatumTargetType",R"#(Defines·types·of·dimension)#")
 195 ········.value("XCAFDimTolObjects_DatumTargetType_Point",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Point)
 196 ········.value("XCAFDimTolObjects_DatumTargetType_Line",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Line)
 197 ········.value("XCAFDimTolObjects_DatumTargetType_Rectangle",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Rectangle)
 198 ········.value("XCAFDimTolObjects_DatumTargetType_Circle",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Circle)
 199 ········.value("XCAFDimTolObjects_DatumTargetType_Area",XCAFDimTolObjects_DatumTargetType::XCAFDimTolObjects_DatumTargetType_Area).export_values();
131 ····py::enum_<XCAFDimTolObjects_GeomToleranceZoneModif>(m,·"XCAFDimTolObjects_GeomToleranceZoneModif",R"#(Defines·types·of·zone)#")200 ····py::enum_<XCAFDimTolObjects_GeomToleranceMatReqModif>(m,·"XCAFDimTolObjects_GeomToleranceMatReqModif",R"#(Defines·types·of·material·requirement)#")
132 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_None",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_None)201 ········.value("XCAFDimTolObjects_GeomToleranceMatReqModif_None",XCAFDimTolObjects_GeomToleranceMatReqModif::XCAFDimTolObjects_GeomToleranceMatReqModif_None)
133 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_Projected",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_Projected) 
134 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_Runout",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_Runout)202 ········.value("XCAFDimTolObjects_GeomToleranceMatReqModif_M",XCAFDimTolObjects_GeomToleranceMatReqModif::XCAFDimTolObjects_GeomToleranceMatReqModif_M)
135 ········.value("XCAFDimTolObjects_GeomToleranceZoneModif_NonUniform",XCAFDimTolObjects_GeomToleranceZoneModif::XCAFDimTolObjects_GeomToleranceZoneModif_NonUniform).export_values();203 ········.value("XCAFDimTolObjects_GeomToleranceMatReqModif_L",XCAFDimTolObjects_GeomToleranceMatReqModif::XCAFDimTolObjects_GeomToleranceMatReqModif_L).export_values();
 204 ····py::enum_<XCAFDimTolObjects_AngularQualifier>(m,·"XCAFDimTolObjects_AngularQualifier",R"#(Defines·types·of·qualifier·for·angular·dimensions)#")
 205 ········.value("XCAFDimTolObjects_AngularQualifier_None",XCAFDimTolObjects_AngularQualifier::XCAFDimTolObjects_AngularQualifier_None)
 206 ········.value("XCAFDimTolObjects_AngularQualifier_Small",XCAFDimTolObjects_AngularQualifier::XCAFDimTolObjects_AngularQualifier_Small)
 207 ········.value("XCAFDimTolObjects_AngularQualifier_Large",XCAFDimTolObjects_AngularQualifier::XCAFDimTolObjects_AngularQualifier_Large)
 208 ········.value("XCAFDimTolObjects_AngularQualifier_Equal",XCAFDimTolObjects_AngularQualifier::XCAFDimTolObjects_AngularQualifier_Equal).export_values();
136 ····py::enum_<XCAFDimTolObjects_GeomToleranceModif>(m,·"XCAFDimTolObjects_GeomToleranceModif",R"#(Defines·modifirs)#")209 ····py::enum_<XCAFDimTolObjects_GeomToleranceModif>(m,·"XCAFDimTolObjects_GeomToleranceModif",R"#(Defines·modifirs)#")
137 ········.value("XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section)210 ········.value("XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Any_Cross_Section)
138 ········.value("XCAFDimTolObjects_GeomToleranceModif_Common_Zone",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Common_Zone)211 ········.value("XCAFDimTolObjects_GeomToleranceModif_Common_Zone",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Common_Zone)
139 ········.value("XCAFDimTolObjects_GeomToleranceModif_Each_Radial_Element",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Each_Radial_Element)212 ········.value("XCAFDimTolObjects_GeomToleranceModif_Each_Radial_Element",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Each_Radial_Element)
140 ········.value("XCAFDimTolObjects_GeomToleranceModif_Free_State",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Free_State)213 ········.value("XCAFDimTolObjects_GeomToleranceModif_Free_State",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Free_State)
141 ········.value("XCAFDimTolObjects_GeomToleranceModif_Least_Material_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Least_Material_Requirement)214 ········.value("XCAFDimTolObjects_GeomToleranceModif_Least_Material_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Least_Material_Requirement)
142 ········.value("XCAFDimTolObjects_GeomToleranceModif_Line_Element",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Line_Element)215 ········.value("XCAFDimTolObjects_GeomToleranceModif_Line_Element",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Line_Element)
Offset 147, 47 lines modifiedOffset 220, 19 lines modified
147 ········.value("XCAFDimTolObjects_GeomToleranceModif_Pitch_Diameter",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Pitch_Diameter)220 ········.value("XCAFDimTolObjects_GeomToleranceModif_Pitch_Diameter",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Pitch_Diameter)
148 ········.value("XCAFDimTolObjects_GeomToleranceModif_Reciprocity_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Reciprocity_Requirement)221 ········.value("XCAFDimTolObjects_GeomToleranceModif_Reciprocity_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Reciprocity_Requirement)
149 ········.value("XCAFDimTolObjects_GeomToleranceModif_Separate_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Separate_Requirement)222 ········.value("XCAFDimTolObjects_GeomToleranceModif_Separate_Requirement",XCAFDimTolObjects_GeomToleranceModif::XCAFDimTolObjects_GeomToleranceModif_Separate_Requirement)
Max diff block lines reached; 22714/41643 bytes (54.54%) of diff not shown.
⊟
3.95 KB
./usr/share/libocp/OCP/gp.cpp
Ordering differences only
    
Offset 7623, 30 lines modifiedOffset 7623, 14 lines modified
7623 ··········py::is_operator(),7623 ··········py::is_operator(),
7624 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));7624 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));
7625 ····m.def("__rmul__",7625 ····m.def("__rmul__",
7626 ··········(gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··))··static_cast<gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··)>(&operator*),7626 ··········(gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··))··static_cast<gp_Vec2d·(*)(··const·Standard_Real·,···const·gp_Vec2d·&··)>(&operator*),
7627 ··········py::is_operator(),7627 ··········py::is_operator(),
7628 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));7628 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theV"));
7629 ····m.def("__mul__",7629 ····m.def("__mul__",
7630 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*), 
7631 ··········py::is_operator(), 
7632 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1")); 
7633 ····m.def("__rmul__", 
7634 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*), 
7635 ··········py::is_operator(), 
7636 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1")); 
7637 ····m.def("__mul__", 
7638 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*), 
7639 ··········py::is_operator(), 
7640 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1")); 
7641 ····m.def("__rmul__", 
7642 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*), 
7643 ··········py::is_operator(), 
7644 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1")); 
7645 ····m.def("__mul__", 
7646 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*),7630 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*),
7647 ··········py::is_operator(),7631 ··········py::is_operator(),
7648 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D"));7632 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D"));
7649 ····m.def("__rmul__",7633 ····m.def("__rmul__",
7650 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*),7634 ··········(gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··))··static_cast<gp_Mat·(*)(··const·Standard_Real·,···const·gp_Mat·&··)>(&operator*),
7651 ··········py::is_operator(),7635 ··········py::is_operator(),
7652 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D"));7636 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat3D"));
Offset 7655, 14 lines modifiedOffset 7639, 30 lines modified
7655 ··········py::is_operator(),7639 ··········py::is_operator(),
7656 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));7640 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));
7657 ····m.def("__rmul__",7641 ····m.def("__rmul__",
7658 ··········(gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··))··static_cast<gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··)>(&operator*),7642 ··········(gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··))··static_cast<gp_Mat2d·(*)(··const·Standard_Real·,···const·gp_Mat2d·&··)>(&operator*),
7659 ··········py::is_operator(),7643 ··········py::is_operator(),
7660 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));7644 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theMat2D"));
7661 ····m.def("__mul__",7645 ····m.def("__mul__",
 7646 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*),
 7647 ··········py::is_operator(),
 7648 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
 7649 ····m.def("__rmul__",
 7650 ··········(gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·gp_Mat2d·&·,···const·gp_XY·&··)>(&operator*),
 7651 ··········py::is_operator(),
 7652 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
 7653 ····m.def("__mul__",
 7654 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*),
 7655 ··········py::is_operator(),
 7656 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));
 7657 ····m.def("__rmul__",
 7658 ··········(gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··))··static_cast<gp_XY·(*)(··const·Standard_Real·,···const·gp_XY·&··)>(&operator*),
 7659 ··········py::is_operator(),
 7660 ··········R"#()#"··,·py::arg("theScalar"),··py::arg("theCoord1"));
 7661 ····m.def("__mul__",
7662 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),7662 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),
7663 ··········py::is_operator(),7663 ··········py::is_operator(),
7664 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));7664 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
7665 ····m.def("__rmul__",7665 ····m.def("__rmul__",
7666 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),7666 ··········(gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··))··static_cast<gp_XYZ·(*)(··const·gp_Mat·&·,···const·gp_XYZ·&··)>(&operator*),
7667 ··········py::is_operator(),7667 ··········py::is_operator(),
7668 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));7668 ··········R"#()#"··,·py::arg("theMatrix"),··py::arg("theCoord1"));
⊟
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