| |
|
|
| from __future__ import annotations |
|
|
| from Base.Metadata import export, constmethod, no_args |
| from Base.Quantity import Quantity |
| from Base.Vector import Vector |
| from Base.Axis import Axis |
| from Part.App.Part2DObject import Part2DObject |
| from Part.App.Geometry import Geometry |
| from Sketcher.App.Constraint import Constraint |
| from typing import List, Tuple, Union, Final, overload |
|
|
| @export( |
| Include="Mod/Sketcher/App/SketchObject.h", |
| FatherInclude="Mod/Part/App/Part2DObjectPy.h", |
| ) |
| class SketchObject(Part2DObject): |
| """ |
| Represents a sketch object |
| |
| Author: Juergen Riegel |
| Licence: LGPL |
| """ |
|
|
| MissingPointOnPointConstraints: List = ... |
| """Returns a list of (First FirstPos Second SecondPos Type) tuples with all the detected endpoint constraints.""" |
|
|
| MissingVerticalHorizontalConstraints: List = ... |
| """Returns a list of (First FirstPos Second SecondPos Type) tuples with all the detected vertical/horizontal constraints.""" |
|
|
| MissingLineEqualityConstraints: List = ... |
| """Returns a list of (First FirstPos Second SecondPos) tuples with all the detected line segment equality constraints.""" |
|
|
| MissingRadiusConstraints: List = ... |
| """Returns a list of (First FirstPos Second SecondPos) tuples with all the detected radius constraints.""" |
|
|
| OpenVertices: Final[List] = ... |
| """Returns a list of vertices positions.""" |
|
|
| ConstraintCount: Final[int] = ... |
| """Number of Constraints in this sketch""" |
|
|
| GeometryCount: Final[int] = ... |
| """Number of geometric objects in this sketch""" |
|
|
| AxisCount: Final[int] = ... |
| """Return the number of construction lines in the sketch which can be used as axes""" |
|
|
| GeometryFacadeList: List = ... |
| """Return a list of GeometryFacade objects corresponding to the PropertyGeometryList""" |
|
|
| DoF: Final[int] = ... |
| """Return the DoFs of the current solved sketch""" |
|
|
| ConflictingConstraints: Final[List] = ... |
| """Return a list of integers indicating the constraints detected as conflicting""" |
|
|
| RedundantConstraints: Final[List] = ... |
| """Return a list of integers indicating the constraints detected as redundant""" |
|
|
| PartiallyRedundantConstraints: Final[List] = ... |
| """Return a list of integers indicating the constraints detected as partially redundant""" |
|
|
| MalformedConstraints: Final[List] = ... |
| """Return a list of integers indicating the constraints detected as malformed""" |
|
|
| def solve(self) -> int: |
| """ |
| Solve the sketch and update the geometry. |
| |
| solve() |
| |
| Returns: |
| 0 in case of success, otherwise the following codes in this order of |
| priority: |
| -4 if over-constrained, |
| -3 if conflicting constraints, |
| -5 if malformed constraints |
| -1 if solver error, |
| -2 if redundant constraints. |
| """ |
| ... |
|
|
| @overload |
| def addGeometry(self, geo: Geometry, isConstruction: bool = False, /) -> int: ... |
| @overload |
| def addGeometry( |
| self, geo: List[Geometry], isConstruction: bool = False, / |
| ) -> Tuple[int, ...]: ... |
| def addGeometry( |
| self, geo: Union[Geometry, List[Geometry]], isConstruction: bool = False, / |
| ) -> Union[int, Tuple[int, ...]]: |
| """ |
| Add geometric objects to the sketch. |
| |
| addGeometry(geo:Geometry, isConstruction=False) -> int |
| Add a single geometric object to the sketch. |
| |
| Args: |
| geo: The geometry to add. e.g. a Part.LineSegement |
| isConstruction: Whether the added geometry is a "construction geometry". |
| Defaults to `False`, i.e. by omitting, a regular geometry is added. |
| |
| Returns: |
| The zero-based index of the newly added geometry. |
| |
| addGeometry(geo:List(Geometry), isConstruction=False) -> Tuple(int) |
| Add many geometric objects to the sketch. |
| |
| Args: |
| geo: The geometry to add. |
| isConstruction: see above. |
| |
| Returns: |
| A tuple of zero-based indices of all newly added geometry. |
| """ |
| ... |
|
|
| def delGeometry(self, geoId: int, noSolve: bool, /) -> None: |
| """ |
| Delete a geometric object from the sketch. |
| |
| delGeometry(geoId:int) |
| |
| Args: |
| geoId: The zero-based index of the geometry to delete. |
| Any internal alignment geometry thereof will be deleted, too. |
| """ |
| ... |
|
|
| def delGeometries(self, geoIds: List[int], noSolve: bool, /) -> None: |
| """ |
| Delete a list of geometric objects from the sketch. |
| |
| delGeometries(geoIds:List(int)) |
| |
| Args: |
| geoId: A list of zero-based indices of the geometry to delete. |
| Any internal alignment geometry thereof will be deleted, too. |
| """ |
| ... |
|
|
| def deleteAllGeometry(self, noSolve: bool, /) -> None: |
| """ |
| Delete all the geometry objects from the sketch, except external geometry. |
| |
| deleteAllGeometry() |
| """ |
| ... |
|
|
| def detectDegeneratedGeometries(self, tolerance: float, /) -> int: |
| """ |
| Detect degenerated geometries. A curve geometry is considered degenerated |
| if the parameter range is less than the tolerance. |
| |
| detectDegeneratedGeometries(tolerance:float) |
| |
| Args: |
| tolerance: The tolerance to check the parameter range of a curve. |
| |
| Returns: |
| The number of degenerated geometries. |
| """ |
| ... |
|
|
| def removeDegeneratedGeometries(self, tolerance: float, /) -> int: |
| """ |
| Remove degenerated geometries. A curve geometry is considered degenerated |
| if the parameter range is less than the tolerance. |
| |
| removeDegeneratedGeometries(tolerance:float) |
| |
| Args: |
| tolerance: The tolerance to check the parameter range of a curve. |
| |
| Returns: |
| The number of degenerated geometries. |
| """ |
| ... |
|
|
| def deleteAllConstraints(self) -> None: |
| """ |
| Delete all the constraints from the sketch. |
| |
| deleteAllConstraints() |
| """ |
| ... |
|
|
| def toggleConstruction(self, geoId: int, /) -> None: |
| """ |
| Toggles a geometry between regular and construction. |
| |
| toggleConstruction(geoId:int) |
| |
| Args: |
| geoId: The zero-based index of the geometry to toggle. |
| """ |
| ... |
|
|
| def setConstruction(self, geoId: int, state: bool, /) -> None: |
| """ |
| Set construction mode of a geometry. |
| |
| setConstruction(geoId:int, state:bool) |
| |
| Args: |
| geoId: The zero-based index of the geometry to configure. |
| state: `True` configures the geometry to "construction geometry", |
| `False` configures it to regular geometry. |
| """ |
| ... |
|
|
| def getConstruction(self, geoId: int, /) -> bool: |
| """ |
| Determine whether the given geometry is a "construction geometry". |
| |
| getConstruction(geoId:int) |
| |
| Args: |
| geoId: The zero-based index of the geometry to query. |
| |
| Returns: |
| `True` if the geometry is "construction geometry" and |
| `False` if it s a regular geometry. |
| """ |
| ... |
|
|
| @overload |
| def addConstraint(self, constraint: Constraint, /) -> int: ... |
| @overload |
| def addConstraint(self, constraints: List[Constraint], /) -> Tuple[int, ...]: ... |
| def addConstraint( |
| self, constraint: Union[Constraint, List[Constraint]], / |
| ) -> Union[int, Tuple[int, ...]]: |
| """ |
| Add constraints to the sketch. |
| |
| addConstraint(constraint:Constraint) -> int |
| Add a single constraint to the sketch and solves it. |
| |
| Returns: |
| The zero-based index of the newly added constraint. |
| |
| addConstraint(constraints:List(Constraint)) -> Tuple(int) |
| Add many constraints to the sketch without solving. |
| |
| Returns: |
| A tuple of zero-based indices of all newly added constraints. |
| """ |
| ... |
|
|
| def delConstraint(self, constraintIndex: int, noSolve: bool, /) -> None: |
| """ |
| Delete a constraint from the sketch. |
| |
| delConstraint(constraintIndex:int) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to delete. |
| """ |
| ... |
|
|
| def delConstraints( |
| self, constraintIndices: List[int], updateGeometry: bool, noSolve: bool, / |
| ) -> None: |
| """ |
| Delete multiple constraints from a sketch |
| |
| delConstraints(constraintIndices: List[int], updateGeometry: bool) |
| |
| Args: |
| constraintIndices: The zero-based indices of the constraints to delete |
| updateGeometry: Whether to update the geometry after solve |
| """ |
| ... |
|
|
| def renameConstraint(self, constraintIndex: int, name: str, /) -> None: |
| """ |
| Rename a constraint in the sketch. |
| |
| renameConstraint(constraintIndex:int, name:str) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to rename. |
| name: The new name for the constraint. |
| An empty string makes the constraint "unnamed" again. |
| """ |
| ... |
|
|
| @constmethod |
| def getIndexByName(self, name: str, /) -> int: |
| """ |
| Get the index of a constraint by name. |
| |
| getIndexByName(name:str) |
| |
| Args: |
| name: The name for the constraint to look up. |
| If there is no such constraint an exception is raised. |
| """ |
| ... |
|
|
| def setAllowUnaligned(self, state: bool, /) -> None: |
| """ |
| Set whether unaligned geometry is allowed in the sketch. |
| |
| setAllowUnaligned(state:bool) |
| |
| Args: |
| state: `True` allows unaligned geometry, |
| `False` enforces aligned geometry. |
| """ |
| ... |
|
|
| def carbonCopy(self, objName: str, asConstruction: bool = True, /) -> None: |
| """ |
| Copy another sketch's geometry and constraints into this sketch. |
| |
| carbonCopy(objName:str, asConstruction=True) |
| |
| Args: |
| ObjName: The name of the sketch object to copy from. |
| asConstruction: Whether to copy the geometry as "construction geometry". |
| """ |
| ... |
|
|
| def addExternal( |
| self, objName: str, subName: str, defining: bool = False, intersection: bool = False, / |
| ) -> None: |
| """ |
| Add a link to an external geometry. |
| |
| addExternal(objName:str, subName:str, defining:bool=False, intersection:bool=False) |
| |
| Args: |
| objName: The name of the document object to reference. |
| subName: The name of the sub-element of the object's shape to link as |
| "external geometry". |
| defining: Should the external edges be defining or construction? |
| intersection: Should the external edges be projections or intersections? |
| """ |
| ... |
|
|
| def delExternal(self, extGeoId: int, /) -> None: |
| """ |
| Delete an external geometry link from the sketch. |
| |
| delExternal(extGeoId:int) |
| |
| Args: |
| extGeoId: The zero-based index of the external geometry to remove. |
| """ |
| ... |
|
|
| @overload |
| def delConstraintOnPoint(self, vertexId: int, /) -> None: ... |
| @overload |
| def delConstraintOnPoint(self, geoId: int, pointPos: int, /) -> None: ... |
| def delConstraintOnPoint(self, *args: int) -> None: |
| """ |
| Delete coincident constraints associated with a sketch point. |
| |
| delConstraintOnPoint(vertexId:int) |
| |
| Args: |
| vertexId: A zero-based index of the shape's vertices. |
| |
| delConstraintOnPoint(geoId:int, pointPos:int) |
| |
| Args: |
| geoId: The zero-based index of the geometry that contains the point. |
| pointPos: Enum denoting which point on the geometry is meant: |
| 1: the start of a line or bounded curve. |
| 2: the end of a line or bounded curve. |
| 3: the center of a circle or ellipse. |
| """ |
| ... |
|
|
| @no_args |
| def delConstraintsToExternal(self) -> None: |
| """ |
| Deletes all constraints referencing an external geometry. |
| """ |
| ... |
|
|
| def setDatum(self, constraint: Union[int, str], value: Union[float, Quantity], /) -> None: |
| """ |
| Set the value of a datum constraint (e.g. Distance or Angle) |
| |
| setDatum(constraint, value) |
| |
| Args: |
| constraint (int or str): The index or name of the constraint to set. |
| value (float or Quantity): The value to set for the constraint. When |
| using floats, values for linear dimensions are interpreted as |
| millimeter, angular ones as radians. |
| """ |
| ... |
|
|
| @constmethod |
| def getDatum(self, constraint: Union[int, str], /) -> Quantity: |
| """ |
| Get the value of a datum constraint (e.g. Distance or Angle) |
| |
| getDatum(constraint) -> Quantity |
| |
| Args: |
| constraint (int or str): The index or name of the constraint to query. |
| |
| Returns: |
| The value of the constraint. |
| """ |
| ... |
|
|
| def setDriving(self, constraintIndex: int, state: bool, /) -> None: |
| """ |
| Set the Driving status of a datum constraint. |
| |
| setDriving(constraintIndex:int, state:bool) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to configure. |
| state: `True` sets the constraint to driving, |
| `False` configures it as non-driving, i.e. reference. |
| """ |
| ... |
|
|
| def setDatumsDriving(self, state: bool, /) -> None: |
| """ |
| Set the Driving status of all datum constraints. |
| |
| setDatumsDriving(state:bool) |
| |
| Args: |
| state: `True` set all datum constraints to driving, |
| `False` configures them as non-driving, i.e. reference. |
| """ |
| ... |
|
|
| def moveDatumsToEnd(self) -> None: |
| """ |
| Moves all datum constraints to the end of the constraint list. |
| |
| moveDatumsToEnd() |
| |
| Warning: This method reorders the constraint indices. Previously held |
| numeric references to constraints may reference different constraints |
| after this operation. |
| """ |
| ... |
|
|
| @constmethod |
| def getDriving(self, constraintIndex: int, /) -> bool: |
| """ |
| Get the Driving status of a datum constraint. |
| |
| getDriving(constraintIndex:int) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to query. |
| |
| Returns: |
| `True` if the constraint is driving, |
| `False` if it is non-driving, i.e. reference. |
| """ |
| ... |
|
|
| def toggleDriving(self, constraintIndex: int, /) -> None: |
| """ |
| Toggle the Driving status of a datum constraint. |
| |
| toggleDriving(constraintIndex:int) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to toggle. |
| """ |
| ... |
|
|
| def setVirtualSpace(self) -> None: |
| """ |
| Set the VirtualSpace status of a constraint |
| """ |
| ... |
|
|
| def setVisibility(self) -> None: |
| """ |
| Set the visibility of a constraint |
| """ |
| ... |
|
|
| def getVirtualSpace(self) -> bool: |
| """ |
| Get the VirtualSpace status of a constraint |
| """ |
| ... |
|
|
| def toggleVirtualSpace(self) -> None: |
| """ |
| Toggle the VirtualSpace status of a constraint |
| """ |
| ... |
|
|
| def setActive(self, constraintIndex: int, state: bool, /) -> None: |
| """ |
| Activates or deactivates a constraint (enforce it or not). |
| |
| setActive(constraintIndex:int, state:bool) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to configure. |
| state: `True` sets the constraint to active i.e. enforced, |
| `False` configures it as inactive, i.e. not enforced. |
| """ |
| ... |
|
|
| @constmethod |
| def getActive(self, constraintIndex: int, /) -> bool: |
| """ |
| Get whether a constraint is active, i.e. enforced, or not. |
| |
| getActive(constraintIndex:int) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to query. |
| |
| Returns: |
| `True` if the constraint is active, i.e. enforced, |
| `False` if it is inactive, i.e. not enforced. |
| """ |
| ... |
|
|
| def toggleActive(self, constraintIndex: int, /) -> None: |
| """ |
| Toggle the constraint between active (enforced) and inactive. |
| |
| toggleActive(constraintIndex:int) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to toggle. |
| """ |
| ... |
|
|
| @constmethod |
| def getLabelPosition(self, constraintIndex: int, /) -> float: |
| """ |
| Get label position of the constraint. |
| |
| getLabelPosition(constraintIndex:int) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to query. |
| |
| Returns: |
| float with the current value. |
| """ |
| ... |
|
|
| def setLabelPosition(self, constraintIndex: int, value: float, /) -> None: |
| """ |
| Set label position of the constraint. |
| |
| setLabelPosition(constraintIndex:int, value:float) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to query. |
| value: Value of the label position. |
| """ |
| ... |
|
|
| @constmethod |
| def getLabelDistance(self, constraintIndex: int, /) -> float: |
| """ |
| Get label distance of the constraint. |
| |
| getLabelDistance(constraintIndex:int) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to query. |
| |
| Returns: |
| float with the current value. |
| """ |
| ... |
|
|
| def setLabelDistance(self, constraintIndex: int, value: float, /) -> None: |
| """ |
| Set label distance of the constraint. |
| |
| setLabelDistance(constraintIndex:int, value:float) |
| |
| Args: |
| constraintIndex: The zero-based index of the constraint to query. |
| value: Value of the label position. |
| """ |
| ... |
|
|
| def moveGeometry( |
| self, GeoIndex: int, PointPos: int, Vector: Vector, relative: bool = False, / |
| ) -> None: |
| """ |
| Move a given point (or curve) to another location. |
| |
| moveGeometry(GeoIndex,PointPos,Vector,[relative]) |
| |
| It moves the specified point (or curve) to the given location by adding some |
| temporary weak constraints and solving the sketch. |
| This method is mostly used to allow the user to drag some portions of the sketch |
| in real time by e.g. the mouse and it works only for underconstrained portions of |
| the sketch. |
| The argument 'relative', if present, states if the new location is given |
| relatively to the current one. |
| """ |
| ... |
|
|
| def moveGeometries( |
| self, Geos: List[Tuple[int, int]], Vector: Vector, relative: bool = False, / |
| ) -> None: |
| """ |
| Move given points and curves to another location. |
| |
| moveGeometries(Geos,Vector,[relative]) |
| |
| It moves the specified points and curves to the given location by adding some |
| temporary weak constraints and solving the sketch. |
| This method is mostly used to allow the user to drag some portions of the sketch |
| in real time by e.g. the mouse and it works only for underconstrained portions of |
| the sketch. |
| The argument 'relative', if present, states if the new location is given |
| relatively to the current one. For group dragging this is enforced. |
| Geos is a vector of pairs of geoId and posId. |
| """ |
| ... |
|
|
| @constmethod |
| def getPoint(self, GeoIndex: int, PointPos: int, /) -> Vector: |
| """ |
| Retrieve the vector of a point in the sketch. |
| |
| getPoint(GeoIndex,PointPos) |
| """ |
| ... |
|
|
| @constmethod |
| def getGeoVertexIndex(self, index: int, /) -> Tuple[int, int]: |
| """ |
| Retrieve the GeoId and PosId of a point in the sketch. |
| |
| (geoId, posId) = getGeoVertexIndex(index) |
| """ |
| ... |
|
|
| @constmethod |
| def getAxis(self) -> Axis: |
| """ |
| Return an axis based on the corresponding construction line |
| """ |
| ... |
|
|
| def fillet(self) -> None: |
| """ |
| Create a fillet between two edges or at a point |
| """ |
| ... |
|
|
| def trim(self) -> None: |
| """ |
| Trim a curve with a given id at a given reference point |
| """ |
| ... |
|
|
| def extend(self) -> None: |
| """ |
| Extend a curve to new start and end positions |
| """ |
| ... |
|
|
| def split(self) -> None: |
| """ |
| Split a curve with a given id at a given reference point |
| """ |
| ... |
|
|
| def join(self) -> None: |
| """ |
| Join two curves at the given end points |
| """ |
| ... |
|
|
| def addSymmetric(self) -> None: |
| """ |
| Add symmetric geometric objects to the sketch with respect to a reference point or line |
| """ |
| ... |
|
|
| def addCopy(self) -> None: |
| """ |
| Add a copy of geometric objects to the sketch displaced by a vector3d |
| """ |
| ... |
|
|
| def addMove(self) -> None: |
| """ |
| Move the geometric objects in the sketch displaced by a vector3d |
| """ |
| ... |
|
|
| def addRectangularArray(self) -> None: |
| """ |
| Add an array of size cols by rows where each element is a copy of the selected geometric objects displaced by a vector3d in the cols direction and by a vector perpendicular to it in the rows direction |
| """ |
| ... |
|
|
| def removeAxesAlignment(self) -> None: |
| """ |
| Modifies constraints so that the shape is not forced to be aligned with axes. |
| """ |
| ... |
|
|
| def ExposeInternalGeometry(self) -> None: |
| """ |
| Deprecated -- use exposeInternalGeometry |
| """ |
| ... |
|
|
| def DeleteUnusedInternalGeometry(self) -> None: |
| """ |
| Deprecated -- use deleteUnusedInternalGeometry |
| """ |
| ... |
|
|
| def exposeInternalGeometry(self) -> None: |
| """ |
| Exposes all internal geometry of an object supporting internal geometry |
| """ |
| ... |
|
|
| def deleteUnusedInternalGeometry(self) -> None: |
| """ |
| Deletes all unused (not further constrained) internal geometry |
| """ |
| ... |
|
|
| def convertToNURBS(self) -> None: |
| """ |
| Approximates the given geometry with a B-spline |
| """ |
| ... |
|
|
| def increaseBSplineDegree(self) -> None: |
| """ |
| Increases the given B-spline Degree by a number of degrees |
| """ |
| ... |
|
|
| def decreaseBSplineDegree(self) -> None: |
| """ |
| Decreases the given B-spline Degree by a number of degrees by approximating this curve |
| """ |
| ... |
|
|
| def modifyBSplineKnotMultiplicity(self) -> None: |
| """ |
| Increases or reduces the given BSpline knot multiplicity |
| """ |
| ... |
|
|
| def insertBSplineKnot(self) -> None: |
| """ |
| Inserts a knot into the BSpline at the given param with given multiplicity. If the knot already exists, this increases the knot multiplicity by the given multiplicity. |
| """ |
| ... |
|
|
| def calculateAngleViaPoint(self, GeoId1: int, GeoId2: int, px: float, py: float, /) -> float: |
| """ |
| calculateAngleViaPoint(GeoId1, GeoId2, px, py) - calculates angle between |
| curves identified by GeoId1 and GeoId2 at point (x,y). The point must be |
| on intersection of the curves, otherwise the result may be useless (except |
| line-to-line, where (0,0) is OK). Returned value is in radians. |
| """ |
| ... |
|
|
| def isPointOnCurve(self, GeoIdCurve: int, x: float, y: float, /) -> bool: |
| """ |
| isPointOnCurve(GeoIdCurve, float x, float y) -> bool - tests if the point (x,y) |
| geometrically lies on a curve (e.g. ellipse). It treats lines as infinite, |
| arcs as full circles/ellipses/etc. |
| """ |
| ... |
|
|
| def calculateConstraintError(self, index: int, /) -> float: |
| """ |
| calculateConstraintError(index) - calculates the error function of the |
| constraint identified by its index and returns the signed error value. |
| The error value roughly corresponds to by how much the constraint is |
| violated. If the constraint internally has more than one error function, |
| the returned value is RMS of all errors (sign is lost in this case). |
| """ |
| ... |
|
|
| def changeConstraintsLocking(self, bLock: bool, /) -> None: |
| """ |
| changeConstraintsLocking(bLock) - locks or unlocks all tangent and |
| perpendicular constraints. (Constraint locking prevents it from |
| flipping to another valid configuration, when e.g. external geometry |
| is updated from outside.) The sketch solve is not triggered by the |
| function, but the SketchObject is touched (a recompute will be |
| necessary). The geometry should not be affected by the function. |
| |
| The bLock argument specifies, what to do. If true, all constraints |
| are unlocked and locked again. If false, all tangent and perp. |
| constraints are unlocked. |
| """ |
| ... |
|
|
| def getGeometryWithDependentParameters(self) -> List[Tuple[int, int]]: |
| """ |
| getGeometryWithDependentParameters - returns a list of geoid posid pairs |
| with all the geometry element edges and vertices which the solver regards |
| as being dependent on other parameters. |
| """ |
| ... |
|
|
| def autoconstraint(self) -> None: |
| """ |
| Automatic sketch constraining algorithm. |
| """ |
| ... |
|
|
| def detectMissingPointOnPointConstraints(self) -> None: |
| """ |
| Detects missing Point On Point Constraints. The detect step just identifies possible missing constraints. |
| The result may be retrieved or applied using the corresponding Get / Make methods. |
| """ |
| ... |
|
|
| def analyseMissingPointOnPointCoincident(self) -> None: |
| """ |
| Analyses the already detected missing Point On Point Constraints to detect endpoint tangency/perpendicular. |
| The result may be retrieved or applied using the corresponding Get / Make methods. |
| """ |
| ... |
|
|
| def detectMissingVerticalHorizontalConstraints(self) -> None: |
| """ |
| Detects missing Horizontal/Vertical Constraints. The detect step just identifies possible missing constraints. |
| The result may be retrieved or applied using the corresponding Get / Make methods. |
| """ |
| ... |
|
|
| def detectMissingEqualityConstraints(self) -> None: |
| """ |
| Detects missing Equality Constraints. The detect step just identifies possible missing constraints. |
| The result may be retrieved or applied using the corresponding Get / Make methods. |
| """ |
| ... |
|
|
| def makeMissingPointOnPointCoincident(self, arg: bool, /) -> None: |
| """ |
| Applies the detected / set Point On Point coincident constraints. If the argument is True, then solving and redundant removal is done after each individual addition. |
| """ |
| ... |
|
|
| def makeMissingVerticalHorizontal(self, arg: bool, /) -> None: |
| """ |
| Applies the detected / set Vertical/Horizontal constraints. If the argument is True, then solving and redundant removal is done after each individual addition. |
| """ |
| ... |
|
|
| def makeMissingEquality(self, arg: bool, /) -> None: |
| """ |
| Applies the detected / set Equality constraints. If the argument is True, then solving and redundant removal is done after each individual addition. |
| """ |
| ... |
|
|
| @constmethod |
| @no_args |
| def evaluateConstraints(self) -> bool: |
| """ |
| Check for constraints with invalid indexes. Returns True if invalid constraints are found, False otherwise. |
| """ |
| ... |
|
|
| @no_args |
| def validateConstraints(self) -> None: |
| """ |
| Removes constraints with invalid indexes. |
| """ |
| ... |
|
|
| def autoRemoveRedundants(self, arg: bool, /) -> None: |
| """ |
| Removes constraints currently detected as redundant by the solver. If the argument is True, then the geometry is updated after solving. |
| """ |
| ... |
|
|
| def toPythonCommands(self) -> None: |
| """ |
| Prints the commands that should be executed to recreate the Geometry and Constraints of the present sketch (excluding any External Geometry). |
| """ |
| ... |
|
|
| def setGeometryId(): |
| """ |
| Sets the GeometryId of the SketchGeometryExtension of the geometry with the provided GeoId |
| """ |
| ... |
|
|
| def setGeometryIds(GeoIdsToIds: List[Tuple[int, int]], /): |
| """ |
| Sets the GeometryId of the SketchGeometryExtension of the geometries with the provided GeoIds |
| Expects a list of pairs (GeoId, id) |
| """ |
|
|
| def getGeometryId(): |
| """ |
| Gets the GeometryId of the SketchGeometryExtension of the geometry with the provided GeoId |
| """ |
| ... |
|
|
