PyBrxCv.pyi
class ArcParameterType Class
eRadius: ClassVar[Self]
eDegreeOfCurve: ClassVar[Self]
eTangentLength: ClassVar[Self]
eChordLength: ClassVar[Self]
eCurveLength: ClassVar[Self]
eExternalDist: ClassVar[Self]
eMiddleOrdinate: ClassVar[Self]
eCurveAngle: ClassVar[Self]
eCurveThroughPoint: ClassVar[Self]
class ArcType Class
eCompound: ClassVar[Self]
eReverse: ClassVar[Self]
class BlockAttachment Class
eBlockAttachmentTopLeft: ClassVar[Self]
eBlockAttachmentTopCenter: ClassVar[Self]
eBlockAttachmentTopRight: ClassVar[Self]
eBlockAttachmentMiddleLeft: ClassVar[Self]
eBlockAttachmentMiddleCenter: ClassVar[Self]
eBlockAttachmentMiddleRight: ClassVar[Self]
eBlockAttachmentBottomLeft: ClassVar[Self]
eBlockAttachmentBottomCenter: ClassVar[Self]
eBlockAttachmentBottomRight: ClassVar[Self]
eBlockAttachmentInsertionPoint: ClassVar[Self]
class BorderType Class
eBorderTypeRectangular: ClassVar[Self]
eBorderTypeRoundedRectangular: ClassVar[Self]
eBorderTypeCircular: ClassVar[Self]
class BreaklineIntersectionElevation Class
eTinNotAllowed: ClassVar[Self]
eTinElevationMin: ClassVar[Self]
eTinElevationMax: ClassVar[Self]
eTinElevationMid: ClassVar[Self]
class Civil3dAlignmentType Class
eNotAlignment: ClassVar[Self]
eCenterline: ClassVar[Self]
eOffset: ClassVar[Self]
eCurbReturn: ClassVar[Self]
eRail: ClassVar[Self]
eMiscellaneous: ClassVar[Self]
class Civil3dEntityType Class
eNoEntity: ClassVar[Self]
eAlignment: ClassVar[Self]
eProfile: ClassVar[Self]
eTinSurface: ClassVar[Self]
eProfileView: ClassVar[Self]
class Civil3dLabels Class
eNoLabels: ClassVar[Self]
eSurfaceLabels: ClassVar[Self]
eAlignmentsLabels: ClassVar[Self]
eUnattachedLabels: ClassVar[Self]
eDefaultLabels: ClassVar[Self]
eAllLabels: ClassVar[Self]
class Civil3dProfileType Class
eNotProfile: ClassVar[Self]
eLayout: ClassVar[Self]
eStaticSurface: ClassVar[Self]
eDynamicSurface: ClassVar[Self]
eQuick: ClassVar[Self]
class CustomSymbol Class
eCustomSymbolSpotPoint: ClassVar[Self]
eCustomSymbolSpotEmpty: ClassVar[Self]
eCustomSymbolSpotCross: ClassVar[Self]
eCustomSymbolSpotCross45: ClassVar[Self]
eCustomSymbolSpotVerticalLine: ClassVar[Self]
eCustomSymbolFrameCircle: ClassVar[Self]
eCustomSymbolFrameSquare: ClassVar[Self]
class CvAttribVariant Class
def __init__(self) -> None:
def __init__(self, val: str) -> None:
def __init__(self, val: PyBrxCv.CvDataType) -> None:
def __init__(*args) -> None:
def __reduce__(self) -> Any:
def className() -> str:
def getAngle(self) -> float:
def getArea(self) -> float:
def getAzimuth(self) -> float:
def getBool(self) -> bool:
def getDirection(self) -> float:
def getDistance(self) -> float:
def getDouble(self) -> float:
def getElevation(self) -> float:
def getInteger(self) -> int:
def getLatitude(self) -> float:
def getLinear(self) -> float:
def getLongitude(self) -> float:
def getRatio(self) -> float:
def getRotation(self) -> float:
def getSlope(self) -> float:
def getSpeed(self) -> float:
def getStation(self) -> float:
def getString(self) -> str:
def getVolume(self) -> float:
def isValid(self) -> bool:
def setAngle(self, val: float) -> None:
def setArea(self, val: float) -> None:
def setAzimuth(self, val: float) -> None:
def setBool(self, val: bool) -> None:
def setDirection(self, val: float) -> None:
def setDistance(self, val: float) -> None:
def setElevation(self, val: float) -> None:
def setInteger(self, val: int) -> None:
def setLatitude(self, val: float) -> None:
def setLinear(self, val: float) -> None:
def setLongitude(self, val: float) -> None:
def setRatio(self, val: float) -> None:
def setRotation(self, val: float) -> None:
def setSlope(self, val: float) -> None:
def setSpeed(self, val: float) -> None:
def setStation(self, val: float) -> None:
def setString(self, val: str) -> None:
def setVolume(self, val: float) -> None:
def type(self) -> CvDataType:
class CvCivil3dConverter Class
def __init__(self) -> None:
def __init__(self, sourceDb: PyDb.Database, targetDb: PyDb.Database, doLabels: PyBrxCv.Civil3dLabels) -> None:
def __init__(*args) -> None:
def __reduce__(self) -> Any:
def attachedLabels(self, civilEntity: PyBrxCv.CvCivil3dEntityInfo) -> list[PyDb.ObjectId]:
def className() -> str:
def convert(self, entitiesToConvert: list) -> list:
def getCivilEntities(self) -> list[PyBrxCv.CvCivil3dEntityInfo]:
def getInsertedEntities(self) -> list[PyDb.ObjectId]:
def unattachedLabels(self) -> list[PyDb.ObjectId]:
class CvCivil3dEntityInfo Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def alignmentType(self) -> Civil3dAlignmentType:
def baseAlignment(self) -> CvCivil3dEntityInfo:
def baseSurface(self) -> CvCivil3dEntityInfo:
def className() -> str:
def description(self) -> str:
def isNull(self) -> bool:
def name(self) -> str:
def objectId(self) -> PyDb.ObjectId:
def profileType(self) -> Civil3dProfileType:
def profiles(self) -> list[PyBrxCv.CvCivil3dEntityInfo]:
def type(self) -> Civil3dEntityType:
class CvDataType Class
eBrxCvDataTypeNone: ClassVar[Self]
eBrxCvDataTypeBool: ClassVar[Self]
eBrxCvDataTypeString: ClassVar[Self]
eBrxCvDataTypeInteger: ClassVar[Self]
eBrxCvDataTypeDate: ClassVar[Self]
eBrxCvDataTypeLinear: ClassVar[Self]
eBrxCvDataTypeStation: ClassVar[Self]
eBrxCvDataTypeAngle: ClassVar[Self]
eBrxCvDataTypeRatio: ClassVar[Self]
eBrxCvDataTypeArea: ClassVar[Self]
eBrxCvDataTypeAzimuth: ClassVar[Self]
eBrxCvDataTypeDirection: ClassVar[Self]
eBrxCvDataTypeDistance: ClassVar[Self]
eBrxCvDataTypeElevation: ClassVar[Self]
eBrxCvDataTypeSlope: ClassVar[Self]
eBrxCvDataTypeLatitude: ClassVar[Self]
eBrxCvDataTypeLongitude: ClassVar[Self]
eBrxCvDataTypeRotation: ClassVar[Self]
eBrxCvDataTypeVolume: ClassVar[Self]
eBrxCvDataTypeSpeed: ClassVar[Self]
class CvDb3dAlignment Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def baseHAlignment(self) -> PyDb.ObjectId:
def cast(otherObject: PyRx.RxObject) -> CvDb3dAlignment:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDb3dAlignment:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getPointsArray(self) -> list[PyGe.Point3d]:
def length(self) -> float:
def setBaseHAlignment(self, id: PyDb.ObjectId) -> bool:
def setVAlignment(self, id: PyDb.ObjectId) -> bool:
def vAlignment(self) -> PyDb.ObjectId:
class CvDbCurve Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbCurve:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbCurve:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def description(self) -> str:
def name(self) -> str:
def setDescription(self, val: str) -> bool:
def setName(self, val: str) -> bool:
class CvDbCurveLabelStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbCurveLabelStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbCurveLabelStyleManager:
def createLabelStyle(self, name: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def managerId() -> str:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbCurveLabelStyleManager:
class CvDbEntity Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbEntity:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbEntity:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def description(self) -> str:
def name(self) -> str:
def setDescription(self, val: str) -> bool:
def setName(self, val: str) -> bool:
class CvDbFileFormatManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def allFileFormats(self) -> list[PyDb.ObjectId]:
def applicableFileFormats(self, val: str) -> list[PyDb.ObjectId]:
def cast(otherObject: PyRx.RxObject) -> CvDbFileFormatManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbFileFormatManager:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManager(db: PyDb.Database) -> PyDb.ObjectId:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbFileFormatManager:
class CvDbGrading Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbGrading:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbGrading:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getCalculationCurve(self) -> PyGe.Curve3d:
def getCalculationMethod(self) -> GradingCalculationMethod:
def getGradingVisualStyle(self) -> GradingVisualStyle:
def getInputEntityId(self) -> PyDb.ObjectId:
def getIsAssociative(self) -> bool:
def getIsDrawInfill(self) -> bool:
def getMidOrdinateDist(self) -> float:
def getRegionEnd(self) -> float:
def getRegionStart(self) -> float:
def getSegmentMaxAngle(self) -> float:
def getSegmentMaxLength(self) -> float:
def isClosed(self) -> bool:
def resultDayLight(self) -> list[list[PyGe.Point3d]]:
def rule(self) -> CvGradingRule:
def setCalculationMethod(self, val: PyBrxCv.GradingCalculationMethod) -> bool:
def setDrawInfill(self, val: bool) -> GradingStatus:
def setGradingVisualStyle(self, val: PyBrxCv.GradingVisualStyle) -> bool:
def setInputData(self, curve: PyGe.Curve3d) -> GradingStatus:
def setInputDataId(self, id: PyDb.ObjectId) -> GradingStatus:
def setIsAssociative(self, val: bool) -> bool:
def setMidOrdinateDist(self, val: float) -> GradingStatus:
def setRegionEnd(self, val: float) -> GradingStatus:
def setRegionStart(self, val: float) -> GradingStatus:
def setRule(self, val: PyBrxCv.CvGradingRule) -> GradingStatus:
def setSegmentMaxAngle(self, val: float) -> GradingStatus:
def setSegmentMaxLength(self, val: float) -> GradingStatus:
def targetSurface(self) -> PyDb.ObjectId:
def update(self, val: bool) -> GradingStatus:
class CvDbHAlignment Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def addArcAuto(self, prevId: int, nextId: int) -> int:
def addArcBetween(self, prevId: int, nextId: int, passThroughPoint: PyGe.Point2d) -> int:
def addArcBetween(self, prevId: int, nextId: int, parameter: float, paramType: PyBrxCv.EArcParameterType, isGreaterThan180: bool, arcType: PyBrxCv.ArcType) -> int:
def addArcBetween(*args) -> int:
def addArcFixed(self, center: PyGe.Point2d, radius: float, clockwise: bool) -> int:
def addArcFixed(self, startPoint: PyGe.Point2d, midPoint: PyGe.Point2d, endPoint: PyGe.Point2d) -> int:
def addArcFixed(*args) -> int:
def addArcFrom(self, prevId: int, passThroughPoint: PyGe.Point2d) -> int:
def addArcFrom(self, prevId: int, passThroughPoint: PyGe.Point2d, direction: PyGe.Vector2d) -> int:
def addArcFrom(self, prevId: int, passThroughPoint: PyGe.Point2d, radius: float, isGreaterThan180: bool, arcType: PyBrxCv.ArcType) -> int:
def addArcFrom(self, prevId: int, radius: float, paramValue: float, paramType: PyBrxCv.ArcType, isClockwise: bool) -> int:
def addArcFrom(*args) -> int:
def addArcTo(self, nextId: int, passThroughPoint: PyGe.Point2d) -> int:
def addArcTo(self, nextId: int, passThroughPoint: PyGe.Point2d, direction: PyGe.Vector2d) -> int:
def addArcTo(self, nextId: int, passThroughPoint: PyGe.Point2d, radius: float, isGreaterThan180: bool, arcType: PyBrxCv.ArcType) -> int:
def addArcTo(self, nextId: int, radius: float, paramValue: float, paramType: PyBrxCv.ArcType, isClockwise: bool) -> int:
def addArcTo(*args) -> int:
def addCSSTo(self, nextId: int, spiral1Param: float, spiral2Param: float, spiralParamType, radius: float, passThroughPoint: PyGe.Point2d, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addCSTo(self, nextId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, radius: float, passThroughPoint: PyGe.Point2d, isGreaterThan180: bool, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addCSTo(self, nextId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, radius: float, arcLength: float, isClockwise: bool, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addCSTo(*args) -> int:
def addLineBetween(self, prevId: int, nextId: int) -> int:
def addLineFixed(self, prevId: int, length: float) -> int:
def addLineFixed(self, start: PyGe.Point2d, end: PyGe.Point2d) -> int:
def addLineFixed(*args) -> int:
def addLineFrom(self, prevId: int, length: float) -> int:
def addLineFrom(self, prevId: int, to: PyGe.Point2d) -> int:
def addLineFrom(*args) -> int:
def addLineTo(self, nextId: int, length: float) -> int:
def addLineTo(self, nextId: int, to: PyGe.Point2d) -> int:
def addLineTo(*args) -> int:
def addSCFrom(self, prevId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, radius: float, passThroughPoint: PyGe.Point2d, isGreaterThan180: bool, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addSCFrom(self, prevId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, radius: float, arcLength: float, isClockwise: bool, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addSCFrom(*args) -> int:
def addSCSAuto(self, prevId: int, nextId: int) -> int:
def addSCSBetween(self, prevId: int, nextId: int, spiral1: float, spiral2: float, spiralType: PyBrxCv.SpiralParameterType, radius: float, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addSSBetween(self, prevId: int, nextId: int, spiralRatio: float, spiralParamType: PyBrxCv.SpiralParameterType, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addSSCFrom(self, prevId: int, spiral1Param: float, spiral2Param: float, spiralParamType, radius: float, passThroughPoint: PyGe.Point2d, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addSTFrom(self, prevId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, passThroughPoint: PyGe.Point2d, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addSTFrom(self, prevId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, tangentLength: float, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addSTFrom(*args) -> int:
def addSTSBetween(self, prevId: int, nextId: int, spiral1Param: float, spiral2Param: float, spiralType: PyBrxCv.SpiralParameterType, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addSpiralBetween(self, prevId: int, nextId: int, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addSpiralFrom(self, prevId: int, radius: float, length: float, isClockwise: bool, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addSpiralTo(self, nextId: int, radius: float, length: float, isClockwise: bool, spiralDef: PyBrxCv.SpiralDefinitionType) -> int:
def addTSTo(self, nextId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, passThroughPoint: PyGe.Point2d, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addTSTo(self, nextId: int, spiralParam: float, spiralParamType: PyBrxCv.EArcParameterType, tangentLength: float, spiralDefinition: PyBrxCv.SpiralDefinitionType) -> int:
def addTSTo(*args) -> int:
def alignment3dAt(self, index: int) -> PyDb.ObjectId:
def alignment3dCount(self) -> int:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignment:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbHAlignment:
def curveAtPI(self, pi: PyBrxCv.CvDbHAlignmentPI) -> int:
def curveElementColor(self) -> int:
def deleteElement(self, id: int) -> bool:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def elementAtId(self, Id: int) -> CvDbHAlignmentElement:
def elementAtStation(self, station: float) -> CvDbHAlignmentElement:
def elementCount(self) -> int:
def elementExtensionColor(self) -> int:
def firstElementId(self) -> int:
def firstLineElementId(self) -> int:
def getElementId(self, gsMarker: int) -> int:
def getPIsArray(self) -> list[PyBrxCv.CvDbHAlignmentPI]:
def getPointAtStation(self, station: float) -> tuple[bool, PyGe.Point2d]:
def getRadius(self, param: float) -> float:
def getStationAtPoint(self, station: PyGe.Point2d) -> tuple[bool, float, float]:
def getStationAtPoint(self, station: PyGe.Point2d, fromStation: float, toStation: float) -> tuple[bool, float, float]:
def getStationAtPoint(*args) -> tuple[bool, float, float]:
def getUnorderedElementIds(self) -> list[int]:
def insertLineFixed(self, start: PyGe.Point2d, end: PyGe.Point2d, prevId: int) -> int:
def lastElementId(self) -> int:
def length(self) -> float:
def lineElementColor(self) -> int:
def nextLineElementId(self, Id: int) -> int:
def previousLineElementId(self, Id: int) -> int:
def setCurveElementColor(self, colACI: int) -> bool:
def setElementExtensionColor(self, colACI: int) -> bool:
def setLineElementColor(self, colACI: int) -> bool:
def setSpiralElementColor(self, colACI: int) -> bool:
def setStationEquations(self, val: PyBrxCv.CvStationEquations) -> bool:
def setStyle(self, style: int) -> bool:
def setTangentExtensionColor(self, colACI: int) -> bool:
def spiralElementColor(self) -> int:
def stationEquations(self) -> CvStationEquations:
def style(self) -> int:
def tangentExtensionColor(self) -> int:
def update(self) -> bool:
def verticalAlignmentAt(self, index: int) -> PyDb.ObjectId:
def verticalAlignmentCount(self) -> int:
def verticalAlignmentViewAt(self, index: int) -> PyDb.ObjectId:
def verticalAlignmentViewCount(self) -> int:
class CvDbHAlignmentArc Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentArc:
def center(self) -> PyGe.Point2d:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def isClockwise(self) -> bool:
def isCompound(self) -> bool:
def isLessThan180(self) -> bool:
def paramLength(self) -> float:
def passThroughPoint1(self) -> PyGe.Point2d:
def passThroughPoint2(self) -> PyGe.Point2d:
def passThroughPoint3(self) -> PyGe.Point2d:
def radius(self) -> float:
def setCenter(self, pt: PyGe.Point2d) -> bool:
def setClockwise(self, val: bool) -> bool:
def setCompound(self, val: bool) -> bool:
def setLessThan180(self, val: bool) -> bool:
def setParamLength(self, val: float) -> bool:
def setPassThroughPoint1(self, pt: PyGe.Point2d) -> bool:
def setPassThroughPoint2(self, pt: PyGe.Point2d) -> bool:
def setPassThroughPoint3(self, pt: PyGe.Point2d) -> bool:
def setRadius(self, val: float) -> bool:
class CvDbHAlignmentCurve Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentCurve:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def endPoint(self) -> PyGe.Point2d:
def endStation(self) -> float:
def length(self) -> float:
def startPoint(self) -> PyGe.Point2d:
def startStation(self) -> float:
class CvDbHAlignmentElement Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentElement:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def id(self) -> int:
def isSubentity(self) -> bool:
def nextId(self) -> int:
def parameterConstraint(self) -> HAlignmentParameterConstraint:
def previousId(self) -> int:
def setNextId(self, val: int) -> bool:
def setParameterConstraint(self, val: PyBrxCv.EParameterConstraint) -> bool:
def setPreviousId(self, val: int) -> bool:
def setTangencyConstraint(self, val: PyBrxCv.ETangencyConstraint) -> bool:
def tangencyConstraint(self) -> HAlignmentTangencyConstraint:
def type(self) -> HAlignmentElementType:
class CvDbHAlignmentLine Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentLine:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def paramLength(self) -> float:
def passThroughPoint1(self) -> PyGe.Point2d:
def passThroughPoint2(self) -> PyGe.Point2d:
def setParamLength(self, val: float) -> bool:
def setPassThroughPoint1(self, pt: PyGe.Point2d) -> bool:
def setPassThroughPoint2(self, pt: PyGe.Point2d) -> bool:
class CvDbHAlignmentPI Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentPI:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def location(self) -> PyGe.Point2d:
class CvDbHAlignmentSCS Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def arc(self) -> CvDbHAlignmentArc:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentSCS:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def spiralIn(self) -> CvDbHAlignmentSpiral:
def spiralOut(self) -> CvDbHAlignmentSpiral:
class CvDbHAlignmentSSCSS Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def arc(self) -> CvDbHAlignmentArc:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentSSCSS:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def spiral1(self) -> CvDbHAlignmentSpiral:
def spiral2(self) -> CvDbHAlignmentSpiral:
def spiral3(self) -> CvDbHAlignmentSpiral:
def spiral4(self) -> CvDbHAlignmentSpiral:
class CvDbHAlignmentSTS Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentSTS:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def line(self) -> CvDbHAlignmentLine:
def spiralIn(self) -> CvDbHAlignmentSpiral:
def spiralOut(self) -> CvDbHAlignmentSpiral:
def spiralRatio(self) -> float:
class CvDbHAlignmentSpiral Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbHAlignmentSpiral:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def endDirection(self) -> float:
def isCompound(self) -> bool:
def paramA(self) -> float:
def paramLength(self) -> float:
def radiusIn(self) -> float:
def radiusOut(self) -> float:
def setClockwise(self, val: bool) -> bool:
def setCompound(self, val: float) -> bool:
def setEndDirection(self, val: float) -> bool:
def setParamA(self, val: float) -> bool:
def setParamLength(self, val: float) -> bool:
def setRadiusIn(self, val: float) -> bool:
def setRadiusOut(self, val: float) -> bool:
def setSpiralCurveType(self, val: PyBrxCv.ESpiralCurveType) -> bool:
def setSpiralDefinition(self, val: PyBrxCv.ESpiralDefinitionType) -> bool:
def spiralCurveType(self) -> SpiralCurveType:
def spiralDefinition(self) -> SpiralDefinitionTypeSpiral:
def startDirection(self) -> float:
class CvDbLabelStyle Class
def __init__(self) -> None:
def __init__(self, metric: bool) -> None:
def __init__(self, id: PyDb.ObjectId) -> None:
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode) -> None:
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __init__(*args) -> None:
def __reduce__(self) -> Any:
def addComponent(self, val: PyBrxCv.CvDbLabelStyleComponent) -> None:
def cast(otherObject: PyRx.RxObject) -> CvDbLabelStyle:
def className() -> str:
def componentAt(self, index: int) -> CvDbLabelStyleComponent:
def componentCount(self) -> int:
def components(self) -> list[PyBrxCv.CvDbLabelStyleComponent]:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def draggedStateBackgroundMask(self) -> bool:
def draggedStateBorderAndLeaderGap(self) -> float:
def draggedStateBorderAndLeaderGapExprIndex(self) -> int:
def draggedStateBorderIsVisible(self) -> bool:
def draggedStateBorderType(self) -> BorderType:
def draggedStateColor(self) -> PyDb.Color:
def draggedStateDisplayMode(self) -> DisplayMode:
def draggedStateLeaderArrowHeadSize(self) -> float:
def draggedStateLeaderArrowHeadSizeExprIndex(self) -> int:
def draggedStateLeaderArrowHeadStyle(self) -> PyDb.ObjectId:
def draggedStateLeaderAttachment(self) -> LeaderAttachment:
def draggedStateLeaderColor(self) -> PyDb.Color:
def draggedStateLeaderIsVisible(self) -> bool:
def draggedStateLeaderJustification(self) -> bool:
def draggedStateLeaderLinetype(self) -> PyDb.ObjectId:
def draggedStateLeaderLineweight(self) -> PyDb.LineWeight:
def draggedStateLeaderTail(self) -> bool:
def draggedStateLeaderType(self) -> LeaderType:
def draggedStateLinetype(self) -> PyDb.ObjectId:
def draggedStateLineweight(self) -> PyDb.LineWeight:
def draggedStateMaximumTextWidth(self) -> float:
def draggedStateMaximumTextWidthExprIndex(self) -> int:
def draggedStateTagDisplayMode(self) -> bool:
def draggedStateTextHeight(self) -> float:
def draggedStateTextHeightExprIndex(self) -> int:
def expressionAt(self, index: int) -> tuple[str, str]:
def expressionCount(self) -> int:
def flipAnchorsWithText(self) -> bool:
def forceInsideCurve(self) -> bool:
def forcedInsertion(self) -> ForcedInsertion:
def isVisible(self) -> bool:
def layer(self) -> PyDb.ObjectId:
def moveComponent(self, _from: int, _to: int) -> None:
def orientationReference(self) -> OrientationRef:
def planReadable(self) -> bool:
def readabilityBias(self) -> float:
def removeComponent(self, val: int | PyBrxCv.CvDbLabelStyleComponent) -> None:
def setDraggedStateBackgroundMask(self, val: bool) -> None:
def setDraggedStateBorderAndLeaderGap(self, val: float) -> None:
def setDraggedStateBorderAndLeaderGapExprIndex(self, val: int) -> None:
def setDraggedStateBorderType(self, val: BorderType) -> None:
def setDraggedStateBorderVisibility(self, val: bool) -> None:
def setDraggedStateColor(self, val: PyDb.Color) -> None:
def setDraggedStateDisplayMode(self, val: DisplayMode) -> None:
def setDraggedStateLeaderArrowHeadSize(self, val: float) -> None:
def setDraggedStateLeaderArrowHeadSizeExprIndex(self, val: int) -> None:
def setDraggedStateLeaderArrowHeadStyle(self, id: PyDb.ObjectId) -> None:
def setDraggedStateLeaderAttachment(self, val: LeaderAttachment) -> None:
def setDraggedStateLeaderColor(self, val: PyDb.Color) -> None:
def setDraggedStateLeaderJustification(self, val: bool) -> None:
def setDraggedStateLeaderLinetype(self, id: PyDb.ObjectId) -> None:
def setDraggedStateLeaderLineweight(self, val: PyDb.LineWeight) -> None:
def setDraggedStateLeaderTail(self, val: bool) -> None:
def setDraggedStateLeaderType(self, val: LeaderType) -> None:
def setDraggedStateLeaderVisibility(self, val: bool) -> None:
def setDraggedStateLinetype(self, id: PyDb.ObjectId) -> None:
def setDraggedStateLineweight(self, val: PyDb.LineWeight) -> None:
def setDraggedStateMaximumTextWidth(self, val: float) -> None:
def setDraggedStateMaximumTextWidthExprIndex(self, val: int) -> None:
def setDraggedStateTagDisplayMode(self, val: bool) -> None:
def setDraggedStateTextHeight(self, val: float) -> None:
def setDraggedStateTextHeightExprIndex(self, val: int) -> None:
def setExpressionAt(self, index: int, name: str, expr: str, val: PyBrxCv.DataType) -> None:
def setFlipAnchorsWithText(self, val: bool) -> None:
def setForceInsideCurve(self, val: bool) -> None:
def setForcedInsertion(self, val: ForcedInsertion) -> None:
def setLayer(self, id: PyDb.ObjectId) -> None:
def setOrientationReference(self, val: PyBrxCv.OrientationRef) -> None:
def setPlanReadable(self, val: bool) -> None:
def setReadabilityBias(self, val: float) -> None:
def setTextStyle(self, id: PyDb.ObjectId) -> None:
def setVisibility(self, val: bool) -> None:
def textStyle(self) -> PyDb.ObjectId:
class CvDbLabelStyleArrow Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def angle(self) -> float:
def angleExprIndex(self) -> int:
def arrowHeadSize(self) -> float:
def arrowHeadStyle(self) -> PyDb.ObjectId:
def cast(otherObject: PyRx.RxObject) -> CvDbLabelStyleArrow:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def isFixedLength(self) -> bool:
def length(self) -> float:
def lengthExprIndex(self) -> int:
def linetype(self) -> PyDb.ObjectId:
def lineweight(self) -> PyDb.LineWeight:
def offset(self) -> PyGe.Vector2d:
def setAngle(self, val: float) -> None:
def setAngleExprIndex(self, val: int) -> None:
def setArrowHeadSize(self, val: float) -> None:
def setArrowHeadSizeExprIndex(self, val: int) -> None:
def setArrowHeadStyle(self, id: PyDb.ObjectId) -> None:
def setFixedLength(self, val: bool) -> None:
def setLength(self, val: float) -> None:
def setLengthExprIndex(self, val: int) -> None:
def setLinetype(self, id: PyDb.ObjectId) -> None:
def setLineweight(self, val: PyDb.LineWeight) -> None:
def setOffset(self, val: PyGe.Vector2d) -> None:
class CvDbLabelStyleBlock Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def angle(self) -> float:
def angleExprIndex(self) -> int:
def attachment(self) -> BlockAttachment:
def blockId(self) -> PyDb.ObjectId:
def cast(otherObject: PyRx.RxObject) -> CvDbLabelStyleBlock:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def height(self) -> float:
def heightExprIndex(self) -> int:
def linetype(self) -> PyDb.ObjectId:
def lineweight(self) -> PyDb.LineWeight:
def offset(self) -> PyGe.Vector2d:
def setAngle(self, val: float) -> None:
def setAngleExprIndex(self, val: int) -> None:
def setAttachment(self, attachment: PyBrxCv.BlockAttachment) -> None:
def setBlockId(self, id: PyDb.ObjectId) -> None:
def setHeight(self, val: float) -> None:
def setHeightExprIndex(self, val: int) -> None:
def setLinetype(self, id: PyDb.ObjectId) -> None:
def setLineweight(self, lineWeight: PyDb.LineWeight) -> None:
def setOffset(self, val: PyGe.Vector2d) -> None:
class CvDbLabelStyleComponent Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def anchorIndex(self) -> int:
def anchorPoint(self) -> LabelAnchor:
def color(self) -> PyDb.Color:
def displaySetting(self) -> bool:
def setAnchorIndex(self, val: int) -> None:
def setAnchorPoint(self, val: PyBrxCv.LabelAnchor) -> None:
def setColor(self, clr: PyDb.Color) -> None:
def setVisible(self, val: bool) -> None:
class CvDbLabelStyleLine Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def angle(self) -> float:
def angleExprIndex(self) -> int:
def cast(otherObject: PyRx.RxObject) -> CvDbLabelStyleLine:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def endPointAnchorIndex(self) -> int:
def endPointAnchorPoint(self) -> LabelAnchor:
def endPointOffset(self) -> PyGe.Vector2d:
def length(self) -> float:
def lengthExprIndex(self) -> int:
def lengthPercentage(self) -> float:
def lengthPercentageExprIndex(self) -> int:
def lengthType(self) -> LengthType:
def linetype(self) -> PyDb.ObjectId:
def lineweight(self) -> PyDb.LineWeight:
def setAngle(self, val: float) -> None:
def setAngleExprIndex(self, val: int) -> None:
def setEndPointAnchorIndex(self, val: int) -> None:
def setEndPointAnchorPoint(self, val: PyBrxCv.LabelAnchor) -> None:
def setEndPointOffset(self, val: PyGe.Vector2d) -> None:
def setLength(self, val: float) -> None:
def setLengthExprIndex(self, val: int) -> None:
def setLengthPercentage(self, val: float) -> None:
def setLengthPercentageExprIndex(self, val: int) -> None:
def setLengthType(self, val: PyBrxCv.LengthType) -> None:
def setLinetype(self, id: PyDb.ObjectId) -> None:
def setLineweight(self, id: PyDb.LineWeight) -> None:
def setStartPointOffset(self, val: PyGe.Vector2d) -> None:
def setUseEndPointAnchor(self, val: bool) -> None:
def startPointOffset(self) -> PyGe.Vector2d:
def useEndPointAnchor(self) -> bool:
class CvDbLabelStyleText Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def allowCurvedText(self) -> bool:
def borderBackgroudMask(self) -> bool:
def borderColor(self) -> PyDb.Color:
def borderGap(self) -> float:
def borderGapExprIndex(self) -> int:
def borderIsVisible(self) -> bool:
def borderLinetype(self) -> PyDb.ObjectId:
def borderLineweight(self, val: PyDb.LineWeight) -> PyDb.LineWeight:
def borderType(self) -> BorderType:
def cast(otherObject: PyRx.RxObject) -> CvDbLabelStyleText:
def className() -> str:
def contents(self) -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def setAllowCurvedText(self, val: bool) -> None:
def setBorderBackgroudMask(self, val: bool) -> None:
def setBorderColor(self, val: PyDb.Color) -> None:
def setBorderGap(self, val: float) -> None:
def setBorderGapExprIndex(self, val: int) -> None:
def setBorderLinetype(self, id: PyDb.ObjectId) -> None:
def setBorderLineweight(self) -> None:
def setBorderType(self, val: BorderType) -> None:
def setBorderVisibility(self, val: bool) -> None:
def setContents(self, val: str) -> None:
def setTextAngle(self, val: float) -> None:
def setTextAngleExprIndex(self, val: int) -> None:
def setTextAttachment(self, val: PyDb.MTextAttachmentPoint) -> None:
def setTextHeight(self, val: float) -> None:
def setTextHeightExprIndex(self, val: int) -> None:
def setTextHorizontalAlignment(self, val: PyDb.TextHorzMode) -> None:
def setTextLinetype(self, id: PyDb.ObjectId) -> None:
def setTextLineweight(self, val: PyDb.LineWeight) -> None:
def setTextMaximumWidth(self, val: float) -> None:
def setTextMaximumWidthExprIndex(self, val: int) -> None:
def setTextOffset(self, val: PyGe.Vector2d) -> None:
def textAngle(self) -> float:
def textAngleExprIndex(self) -> int:
def textAttachment(self) -> PyDb.MTextAttachmentPoint:
def textHeight(self) -> float:
def textHeightExprIndex(self) -> int:
def textHorizontalAlignment(self) -> PyDb.TextHorzMode:
def textLinetype(self) -> PyDb.ObjectId:
def textLineweight(self) -> PyDb.LineWeight:
def textMaximumWidth(self) -> float:
def textMaximumWidthExprIndex(self) -> int:
def textOffset(self) -> PyGe.Vector2d:
class CvDbLineLabelStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbLineLabelStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbLineLabelStyleManager:
def createLabelStyle(self, name: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def managerId() -> str:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbLineLabelStyleManager:
class CvDbObject Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbObject:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbObject:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def description(self) -> str:
def name(self) -> str:
def setDescription(self, val: str) -> bool:
def setName(self, val: str) -> bool:
class CvDbObjectManager Class
def __contains__(self, id: str | PyDb.ObjectId) -> bool:
def __getitem__(self, val: int | str) -> PyDb.ObjectId:
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbObjectManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbObjectManager:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def elementCount(self) -> int:
def has(self, id: str | PyDb.ObjectId) -> bool:
def idAt(self, val: int | str) -> PyDb.ObjectId:
def ids(self) -> list[PyDb.ObjectId]:
def nameAt(self, val: int) -> str:
def names(self) -> list[str]:
def remove(self, id: str | PyDb.ObjectId) -> bool:
def toDict(self) -> dict:
class CvDbPoint Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def addUserAttribute(self, name: str, value: PyBrxCv.CvAttribVariant) -> bool:
def assignPointToPointGroup(cvpoint: PyBrxCv.CvDbPoint, groupid: PyDb.ObjectId) -> None:
def assignPointsToPointGroup(cvpoint: list[PyBrxCv.CvDbPoint], groupid: PyDb.ObjectId) -> None:
def assignStylesToPoints(cvpoint: list[PyBrxCv.CvDbPoint], symbolStyleId: PyDb.ObjectId, labelStyleId: PyDb.ObjectId) -> None:
def cast(otherObject: PyRx.RxObject) -> CvDbPoint:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbPoint:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def easting(self) -> float:
def elevation(self) -> float:
def fullDescription(self) -> str:
def importPointsFromFile(files: list[str], fmtid: PyDb.ObjectId) -> list[PyBrxCv.CvDbPoint]:
def isLabelDragged(self) -> bool:
def isLabelPinned(self) -> bool:
def labelId(self) -> PyDb.ObjectId:
def labelLeaderVertices(self) -> list[PyGe.Point3d]:
def labelPosition(self) -> PyGe.Point3d:
def labelRotation(self) -> float:
def northing(self) -> float:
def number(self) -> int:
def pointGroupsIds(self) -> list[PyDb.ObjectId]:
def pointGroupsNames(self) -> list[str]:
def position(self) -> PyGe.Point3d:
def rawDescription(self) -> str:
def referencedEntityAt(self, val: int) -> CvDbPointReferencedEntity:
def referencedEntityCount(self) -> int:
def removeUserAttribute(self, name: str, value: PyBrxCv.CvDataType) -> bool:
def resetLabel(self) -> bool:
def setEasting(self, val: float) -> bool:
def setElevation(self, val: float) -> bool:
def setFullDescription(self, val: str) -> bool:
def setLabelId(self, id: PyDb.ObjectId) -> bool:
def setLabelLeaderVertices(self, vertices: list[PyGe.Point3d]) -> bool:
def setLabelPinned(self, val: bool) -> bool:
def setLabelPosition(self, pt: PyGe.Point3d) -> bool:
def setLabelRotation(self, val: float) -> bool:
def setNorthing(self, val: float) -> bool:
def setNumber(self, val: int) -> bool:
def setPosition(self, pt: PyGe.Point3d) -> bool:
def setRawDescription(self, val: str) -> bool:
def setSymbolId(self, id: PyDb.ObjectId) -> bool:
def setSymbolRotation(self, val: float) -> bool:
def symbolId(self) -> PyDb.ObjectId:
def symbolRotation(self) -> float:
def update(self) -> bool:
def userAttribute(self, name: str, value: PyBrxCv.CvDataType) -> CvAttribVariant:
def userAttributeAt(self, index: int) -> tuple:
def userAttributeCount(self) -> int:
def userAttributeNames(self) -> list:
def userAttributes(self) -> list:
class CvDbPointGroup Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbPointGroup:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbPointGroup:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def excludeElevations(self) -> str:
def excludeFullDescriptions(self) -> str:
def excludeNames(self) -> str:
def excludeNumbers(self) -> str:
def excludeRawDescriptions(self) -> str:
def excludeUserAttributesKeys(self) -> str:
def excludeUserAttributesValues(self) -> str:
def hasPoint(self, val: int) -> PyDb.ObjectId:
def includeElevations(self) -> str:
def includeFullDescriptions(self) -> str:
def includeNames(self) -> str:
def includeNumbers(self) -> str:
def includeRawDescriptions(self) -> str:
def includeUserAttributesKeys(self) -> str:
def includeUserAttributesValues(self) -> str:
def isApplicable(self) -> bool:
def isEditable(self) -> bool:
def pointCount(self) -> int:
def pointIds(self) -> list[PyDb.ObjectId]:
def setExcludeElevations(self, filter: str) -> bool:
def setExcludeFullDescriptions(self, filter: str) -> bool:
def setExcludeNames(self, filter: str) -> bool:
def setExcludeNumbers(self, filter: str) -> bool:
def setExcludeRawDescriptions(self, filter: str) -> bool:
def setExcludeUserAttributesKeys(self, filter: str) -> bool:
def setIncludeElevations(self, filter: str) -> bool:
def setIncludeFullDescriptions(self, filter: str) -> bool:
def setIncludeNames(self, filter: str) -> bool:
def setIncludeNumbers(self, filter: str) -> bool:
def setIncludeRawDescriptions(self, filter: str) -> bool:
def setIncludeUserAttributesKeys(self, filter: str) -> bool:
def setIncludeUserAttributesValues(self, filter: str) -> bool:
def update(self) -> bool:
def updateNeeded(self) -> bool:
class CvDbPointGroupManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbPointGroupManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbPointGroupManager:
def createPointGroup(self, val: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def groupsWithPoint(self, val: int) -> list[PyDb.ObjectId]:
def nextPointNumber(self) -> int:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbPointGroupManager:
def setNextPointNumber(self, val: int) -> bool:
def updatePointGroups(self) -> int:
class CvDbPointLabelStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbPointLabelStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbPointLabelStyleManager:
def createLabelStyle(self, name: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def managerId() -> str:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbPointLabelStyleManager:
class CvDbPointReferencedEntity Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbPointReferencedEntity:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def id(self) -> PyDb.ObjectId:
def setId(self, id: PyDb.ObjectId) -> bool:
def type(self) -> PyRx.RxClass:
class CvDbStyle Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbStyle:
def className() -> str:
def createdBy(self) -> str:
def createdDate(self) -> PyDb.Date:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def displaySetting(self, orientation: PyBrxCv.DisplayOrientation, partName: str) -> CvDbStylePartDisplaySettings:
def displaySettings(self, orientation: PyBrxCv.DisplayOrientation) -> list[PyBrxCv.CvDbStylePartDisplaySettings]:
def lastEditedBy(self) -> str:
def lastEditedDate(self) -> PyDb.Date:
def setCreatedBy(self, filter: str) -> None:
class CvDbStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbStyleManager:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManager(db: PyDb.Database, styleType: PyBrxCv.StyleManagerType) -> PyDb.ObjectId:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode, styleType: PyBrxCv.StyleManagerType) -> CvDbObjectManager:
class CvDbStylePartDisplaySettings Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def color(self) -> PyDb.Color:
def displaySetting(self) -> bool:
def layer(self) -> PyDb.ObjectId:
def lineType(self) -> PyDb.ObjectId:
def lineTypeScale(self) -> float:
def lineWeight(self) -> PyDb.LineWeight:
def plotStyleNameId(self) -> PyDb.ObjectId:
def plotStyleNameType(self) -> PyDb.PlotStyleNameType:
def setColor(self, clr: PyDb.Color) -> None:
def setLayer(self, id: PyDb.ObjectId) -> None:
def setLineType(self, id: PyDb.ObjectId) -> None:
def setLineTypeScale(self, val: float) -> None:
def setLineWeight(self, val: PyDb.LineWeight) -> None:
def setPlotStyleNameId(self, id: PyDb.ObjectId) -> None:
def setPlotStyleNameType(self, val: PyDb.PlotStyleNameType) -> None:
def setVisible(self, val: bool) -> None:
class CvDbSubObject Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbSubObject:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def description(self) -> str:
def name(self) -> str:
def setDescription(self, val: str) -> bool:
def setName(self, val: str) -> bool:
class CvDbSurfaceContourLabelStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbSurfaceContourLabelStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbSurfaceContourLabelStyleManager:
def createLabelStyle(self, name: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def managerId() -> str:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbSurfaceContourLabelStyleManager:
class CvDbSurfaceElevationLabelStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbSurfaceElevationLabelStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbSurfaceElevationLabelStyleManager:
def createLabelStyle(self, name: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def managerId() -> str:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbSurfaceElevationLabelStyleManager:
class CvDbSurfaceSlopeLabelStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbSurfaceSlopeLabelStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbSurfaceSlopeLabelStyleManager:
def createLabelStyle(self, name: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def managerId() -> str:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbSurfaceSlopeLabelStyleManager:
class CvDbSymbolStyle Class
def __init__(self) -> None:
def __init__(self, metric: bool) -> None:
def __init__(self, id: PyDb.ObjectId) -> None:
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode) -> None:
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __init__(*args) -> None:
def __reduce__(self) -> Any:
def asPDMODE(self) -> int:
def cast(otherObject: PyRx.RxObject) -> CvDbSymbolStyle:
def circleFrame(self) -> bool:
def className() -> str:
def customSymbol(self) -> CustomSymbol:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def fixedScale(self) -> PyGe.Scale3d:
def maximumSize(self) -> float:
def orientationReference(self) -> OrientationRef:
def rotationAngle(self) -> float:
def scalingType(self) -> ScalingType:
def setCircleFrame(self, val: bool) -> None:
def setCustomSymbol(self, val: PyBrxCv.CustomSymbol) -> None:
def setFixedScale(self, scale: PyGe.Scale3d) -> None:
def setMaximumSize(self, val: float) -> None:
def setOrientationReference(self, val: PyBrxCv.OrientationRef) -> None:
def setPDMODE(self, val: int) -> None:
def setRotationAngle(self, val: float) -> None:
def setScalingType(self, val: PyBrxCv.ScalingType) -> None:
def setSize(self, val: float) -> None:
def setSquareFrame(self, val: bool) -> None:
def setSymbolBlockId(self, id: PyDb.ObjectId) -> None:
def setSymbolType(self, val: PyBrxCv.SymbolType) -> None:
def size(self) -> float:
def squareFrame(self) -> bool:
def symbolBlockId(self) -> PyDb.ObjectId:
def symbolType(self) -> SymbolType:
class CvDbSymbolStyleManager Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbSymbolStyleManager:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbSymbolStyleManager:
def createSymbolStyle(self, name: str) -> PyDb.ObjectId:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def getManagerId(db: PyDb.Database) -> PyDb.ObjectId:
def managerId() -> str:
def openManager(db: PyDb.Database, mode: PyDb.OpenMode) -> CvDbSymbolStyleManager:
class CvDbTinSurface Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def addConstraint(self, constraint: PyBrxCv.CvDbTinSurfaceConstraint, addReactor: bool) -> bool:
def addConstraints(self, constraints: list[PyBrxCv.CvDbTinSurfaceConstraint], addReactor: bool) -> bool:
def addDefinition(self, ref: PyBrxCv.CvDbTinSurfaceDefinition) -> int:
def addPoint(self, pt: PyGe.Point3d) -> bool:
def addPoints(self, pts: list[PyGe.Point3d]) -> bool:
def area2d(self, visibleOnly: bool) -> float:
def area3d(self, visibleOnly: bool) -> float:
def boundingBox(self) -> tuple[PyGe.Point2d, PyGe.Point2d]:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurface:
def changePointsElevations(self, pts: list[PyGe.Point3d], newZValues: list[float]) -> bool:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbTinSurface:
def closestPointTo(self, pt: PyGe.Point3d) -> PyGe.Point3d:
def contains(self, pt: PyGe.Point3d) -> bool:
def contoursAtElevation(self, elevation: float) -> list[list[PyGe.Point3d]]:
def createSnapshot(self) -> int:
def definitionAt(self, index: int) -> CvDbTinSurfaceDefinition:
def definitionCount(self) -> int:
def definitionIndex(self, ref: PyBrxCv.CvDbTinSurfaceDefinition) -> tuple[bool, int]:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def drapeId(self, id: PyDb.ObjectId) -> list[list[PyGe.Point3d]]:
def drapePoints(self, pts: list[PyGe.Point3d]) -> list[list[PyGe.Point3d]]:
def elevationAtPoint(self, pt: PyGe.Point3d) -> tuple[bool, float]:
def eraseConstraint(self, id: PyDb.ObjectId | int, removeReactor: bool) -> bool:
def eraseConstraints(self, int64ids: list[int], removeReactor: bool) -> bool:
def eraseConstraintsIds(self, ids: list[PyDb.ObjectId], removeReactor: bool) -> bool:
def findDefinition(self, id: int) -> CvDbTinSurfaceDefinition:
def findTinPointAt(self, pt: PyGe.Point3d) -> tuple[bool, PyBrxCv.CvTinPoint]:
def findTinTrianglesAt(self, pt: PyGe.Point3d) -> list[PyBrx.CvTinTriangle]:
def getBorders(self) -> list[list[PyGe.Point3d]]:
def getConstraint(self, id: PyDb.ObjectId | int) -> CvDbTinSurfaceConstraint:
def getConstraints(self) -> list[PyBrxCv.CvDbTinSurfaceConstraint]:
def getPoints(self, visibleOnly: bool) -> list[PyGe.Point3d]:
def getPointsInsidePolygon(self, pts: list[PyGe.Point3d], includeOnEdge: bool) -> list[PyGe.Point3d]:
def getTinPoints(self) -> list[PyBrx.CvTinPoint]:
def hasSnapshot(self) -> bool:
def initialize(self, min: PyGe.Point3d, max: PyGe.Point3d, numOfPoints: int) -> None:
def insertDefinitionAt(self, index: int, ref: PyBrxCv.CvDbTinSurfaceDefinition) -> int:
def intersectionsWithLine(self, start: PyGe.Point3d, end: PyGe.Point3d, type: PyBrxCv.TinSurfaceIntersectType, visibleOnly: bool) -> tuple[bool, list[PyGe.Point3d]]:
def isAssociative(self) -> bool:
def isAutoUpdate(self) -> bool:
def isRebuildPossible(self) -> bool:
def isSnapshotUpdateNeeded(self) -> bool:
def isUpdateNeeded(self) -> bool:
def majorContours(self) -> list[list[PyGe.Point3d]]:
def majorContoursColor(self) -> tuple[bool, int]:
def majorContoursInterval(self) -> tuple[bool, int]:
def maxElevation(self, visibleOnly: bool) -> float:
def merge(self, other: PyBrxCv.CvDbTinSurface) -> bool:
def mergeSurfaces(theOne: PyBrxCv.CvDbTinSurface, theOther: PyBrxCv.CvDbTinSurface) -> CvDbTinSurface:
def minElevation(self, visibleOnly: bool) -> float:
def minorContours(self) -> list[list[PyGe.Point3d]]:
def minorContoursColor(self) -> tuple[bool, int]:
def minorContoursInterval(self) -> tuple[bool, int]:
def moveDefinition(self, _from: int, _to: int) -> int:
def movePoint(self, _from: PyGe.Point3d, _to: PyGe.Point3d) -> bool:
def movePoints(self, _from: list[PyGe.Point3d], _to: list[PyGe.Point3d]) -> bool:
def pointsCount(self, visibleOnly: bool) -> int:
def raiseSurface(self, offset: float) -> bool:
def rebuild(self, val: bool) -> bool:
def rebuildSnapshot(self) -> bool:
def removeAllDefinitions(self) -> int:
def removeDefinitionAt(self, index: int) -> bool:
def removePoint(self, pt: PyGe.Point3d) -> bool:
def removePoints(self, pts: list[PyGe.Point3d]) -> bool:
def removeSnapshot(self) -> bool:
def setAssociative(self, isAssociative: bool) -> bool:
def setIsAutoUpdate(self, autoUpdateOn: bool) -> bool:
def setMajorContoursColor(self, colorIndex: int) -> bool:
def setMajorContoursInterval(self, interval: float) -> bool:
def setMinorContoursColor(self, colorIndex: int) -> bool:
def setMinorContoursInterval(self, interval: float) -> bool:
def setStyle(self, style: PyBrxCv.TinSurfaceStyle) -> bool:
def setSurfaceElevation(self, elevation: float) -> bool:
def solid3d(self, surface: PyBrxCv.CvDbTinSurface) -> PyDb.Solid3d:
def solid3d(self, surfaceType: PyBrxCv.TinSurfaceMeshType, thickness: float) -> PyDb.Solid3d:
def solid3d(*args) -> PyDb.Solid3d:
def style(self) -> TinSurfaceStyle:
def subDMesh(self) -> PyDb.SubDMesh:
def subDMesh(self, surface: PyBrxCv.CvDbTinSurface) -> PyDb.SubDMesh:
def subDMesh(self, surfaceType: PyBrxCv.TinSurfaceMeshType, depthOrElevation: float) -> PyDb.SubDMesh:
def subDMesh(*args) -> PyDb.SubDMesh:
def swapEdge(self, pt: PyGe.Point3d) -> bool:
def tinTriangles(self) -> list[PyBrx.CvTinTriangle]:
def triangles(self, visibleOnly: bool) -> list[PyBrx.CvTinTriangle]:
def trianglesCount(self, visibleOnly: bool) -> int:
def updateConstraint(self, val: PyBrxCv.CvDbTinSurfaceConstraint) -> bool:
def updateObjectData(self) -> None:
class CvDbTinSurfaceBoundary Class
def __init__(self, type: PyBrxCv.TinBoundaryType) -> None:
def __reduce__(self) -> Any:
def className() -> str:
def wallType(self) -> TinBoundaryType:
class CvDbTinSurfaceBreakline Class
def __init__(self, type: PyBrxCv.TinBreaklineType) -> None:
def __reduce__(self) -> Any:
def className() -> str:
def intersectionElevation(self) -> BreaklineIntersectionElevation:
def setIntersectionElevation(self, val: PyBrxCv.TinBreaklineType) -> None:
class CvDbTinSurfaceConstraint Class
def __init__(self, type: PyBrxCv.TinConstraintType) -> None:
def __reduce__(self) -> Any:
def className() -> str:
def constraintType(self) -> TinConstraintType:
def data(self) -> list[PyGe.Point3d]:
def id(self) -> int:
def isDbResident(self) -> bool:
def midOrdinateDistance(self) -> float:
def setData(self, intId: int, pts: list[PyGe.Point3d]) -> None:
def setDataId(self, id: PyDb.ObjectId, midOrdinateDist: float) -> None:
def setIsDbResident(self, val: bool) -> None:
def setMidOrdinateDistance(self, val: float) -> None:
class CvDbTinSurfaceDefinition Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinition:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def description(self) -> str:
def id(self) -> int:
def isEnabled(self) -> bool:
def isReadOnly(self) -> bool:
def isSubDefinition(self) -> bool:
def isUpdateNeeded(self) -> bool:
def isValid(self) -> bool:
def name(self) -> str:
def setDescription(self, desc: str) -> bool:
def setEnabled(self, val: bool) -> bool:
def setName(self, name: str) -> bool:
def setReadOnly(self, val: bool) -> bool:
def type(self) -> TinSurfaceDefinitionType:
class CvDbTinSurfaceDefinitionAddDrawingObjects Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def addEntity(self, entity: PyDb.Entity) -> bool:
def addEntityId(self, id: PyDb.ObjectId) -> bool:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddDrawingObjects:
def className() -> str:
def crossingsElevation(self) -> TinIntersectionElevation:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def drawingObjectAt(self, idx: int) -> tuple[bool, PyBrx.DrawingObjectTypet, list[PyGe.Point3d]]:
def drawingObjectsCount(self) -> int:
def isApplyEdges(self) -> bool:
def removeAllDrawingObjects(self) -> bool:
def removeDrawingObjectAt(self, idx: int) -> bool:
def setCrossingsElevation(self, val: PyBrxCv.TinIntersectionElevation) -> bool:
def setIsApplyEdges(self, val: bool) -> bool:
class CvDbTinSurfaceDefinitionAddFromFiles Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddFromFiles:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def fileFormatId(self) -> PyDb.ObjectId:
def filesPaths(self) -> list[str]:
def setFileFormatId(self, id: PyDb.ObjectId) -> bool:
def setFilesPaths(self, val: list[str]) -> bool:
class CvDbTinSurfaceDefinitionAddFromPointClouds Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddFromPointClouds:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def pcObjectIds(self) -> list[PyDb.ObjectId]:
def setPcObjectIds(self, val: list[PyDb.ObjectId]) -> bool:
class CvDbTinSurfaceDefinitionAddLine Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddLine:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def line(self) -> PyGe.LineSeg2d:
def setLine(self, line: PyGe.LineSeg2d) -> bool:
class CvDbTinSurfaceDefinitionAddLines Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddLines:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def lines(self) -> list[PyGe.LineSeg3d]:
def setLines(self, lines: list[PyGe.LineSeg2d]) -> bool:
class CvDbTinSurfaceDefinitionAddPoint Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddPoint:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def position(self) -> PyGe.Point3d:
def setPosition(self, pt: PyGe.Point3d) -> bool:
class CvDbTinSurfaceDefinitionAddPointGroups Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddPointGroups:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def pointGroupsIds(self) -> list[PyDb.ObjectId]:
def setPointGroupsIds(self, val: list[PyDb.ObjectId]) -> bool:
class CvDbTinSurfaceDefinitionAddPoints Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionAddPoints:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def positions(self) -> list[PyGe.Point2d]:
def setPositions(self, pt: list[PyGe.Point3d]) -> bool:
class CvDbTinSurfaceDefinitionCreateFromC3D Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionCreateFromC3D:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def filePath(self) -> str:
def setFilePath(self, val: str) -> bool:
def setSurfaceName(self, val: str) -> bool:
def surfaceName(self) -> str:
class CvDbTinSurfaceDefinitionCreateFromFaces Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionCreateFromFaces:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def faceAt(self) -> tuple[bool, PyDb.Face]:
def facesCount(self) -> int:
def isApplyEdgesVisibility(self) -> bool:
def points(self) -> list[PyGe.Point3d]:
def setIsApplyEdgesVisibility(self) -> bool:
class CvDbTinSurfaceDefinitionCreateFromLandXML Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionCreateFromLandXML:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def dwgUnits(self) -> PyDb.UnitsValue:
def filePath(self) -> str:
def scaleToDwgUnits(self) -> bool:
def setFilePath(self, val: str) -> bool:
def setScaleToDwgUnits(self, val: bool) -> bool:
def setSurfaceName(self, val: str) -> bool:
def surfaceName(self) -> str:
class CvDbTinSurfaceDefinitionDeleteEdge Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionDeleteEdge:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def position(self) -> PyGe.Point2d:
def setPosition(self, pt: PyGe.Point2d) -> bool:
class CvDbTinSurfaceDefinitionDeleteEdges Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def addPolygon(self, edgePolygon: list[PyGe.Point2d], includeIntersected: bool) -> bool:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionDeleteEdges:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def polygonAt(self, index: int) -> tuple[bool, list[PyGe.Point2d]]:
def polygonsCount(self) -> int:
def removeAllPolygons(self) -> bool:
def removePolygonAt(self, index: int) -> bool:
class CvDbTinSurfaceDefinitionDeletePoint Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionDeletePoint:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def position(self) -> PyGe.Point2d:
def setPosition(self, pt: PyGe.Point2d) -> bool:
class CvDbTinSurfaceDefinitionGroupDefs Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def addSubDefinition(self, val: PyBrxCv.CvDbTinSurfaceDefinition) -> int:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionGroupDefs:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def findSubDefinition(self, defid: int) -> int:
def getSubDefinitionAt(self, index: int) -> CvDbTinSurfaceDefinition:
def numSubDefinitions(self) -> int:
def removeSubDefinitionAt(self, index: int) -> bool:
class CvDbTinSurfaceDefinitionModifyPointElevation Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionModifyPointElevation:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def elevation(self) -> float:
def isDeltaElevation(self) -> bool:
def position(self) -> PyGe.Point2d:
def setElevation(self, val: float) -> bool:
def setIsDeltaElevation(self, val: float) -> bool:
def setPosition(self, pt: PyGe.Point2d) -> bool:
class CvDbTinSurfaceDefinitionModifyPointsElevation Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionModifyPointsElevation:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def elevation(self) -> float:
def isDeltaElevation(self) -> bool:
def positions(self) -> list[PyGe.Point2d]:
def setElevation(self, val: float) -> bool:
def setPositions(self, pt: list[PyGe.Point2d]) -> bool:
class CvDbTinSurfaceDefinitionModifyPointsElevations Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def addPointElevation(self) -> bool:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionModifyPointsElevations:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def pointElevationAt(self) -> tuple[bool, PyGe.Point2d]:
def pointElevationsCount(self) -> int:
def removeAllPointElevations(self) -> bool:
def removePointElevationAt(self) -> bool:
class CvDbTinSurfaceDefinitionMovePoint Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionMovePoint:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def fromPosition(self) -> PyGe.Point2d:
def setFromPosition(self, pt: PyGe.Point2d) -> bool:
def setToPosition(self, pt: PyGe.Point2d) -> bool:
def toPosition(self) -> PyGe.Point2d:
class CvDbTinSurfaceDefinitionMovePoints Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionMovePoints:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def displacement(self) -> PyGe.Vector2d:
def fromPoints(self) -> list[PyGe.Point2d]:
def setDisplacement(self, vec: PyGe.Vector3d) -> bool:
def setFromPoints(self, pt: list[PyGe.Point2d]) -> bool:
class CvDbTinSurfaceDefinitionRemoveElevations Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionRemoveElevations:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def removeAbove(self) -> bool:
def removeAboveElevation(self) -> float:
def removeBelow(self) -> bool:
def removeBelowElevation(self) -> float:
def removedPointsCount(self) -> int:
def setRemoveAbove(self, val: bool) -> bool:
def setRemoveAboveElevation(self, val: float) -> bool:
def setRemoveBelow(self, val: bool) -> bool:
def setRemoveBelowElevation(self, val: float) -> bool:
class CvDbTinSurfaceDefinitionRemoveOuterEdges Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionRemoveOuterEdges:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def maxAdjAngle(self) -> float:
def maxEdgeLength(self) -> float:
def minEdgeLength(self) -> float:
def setMaxAdjAngle(self, val: float) -> bool:
def setMaxEdgeLength(self, val: float) -> bool:
def setMinEdgeLength(self, val: float) -> bool:
def setUseMaxAdjAngle(self, val: bool) -> bool:
def setUseMaxEdgeLength(self, val: bool) -> bool:
def setUseMinEdgeLength(self, val: bool) -> bool:
def useMaxAdjAngle(self) -> bool:
def useMaxEdgeLength(self) -> bool:
def useMinEdgeLength(self) -> bool:
class CvDbTinSurfaceDefinitionRiseLower Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionRiseLower:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def offset(self) -> float:
def setOffset(self, val: float) -> bool:
class CvDbTinSurfaceDefinitionSwapEdge Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionSwapEdge:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def position(self) -> PyGe.Point2d:
def setPosition(self, pt: PyGe.Point2d) -> bool:
class CvDbTinSurfaceDefinitionTransform Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionTransform:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def setTransformationMatrix(self, xform: PyGe.Matrix3d) -> bool:
def transformationMatrix(self) -> PyGe.Matrix3d:
class CvDbTinSurfaceDefinitionTrianglesVisibility Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbTinSurfaceDefinitionTrianglesVisibility:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def positions(self) -> list[PyGe.Point2d]:
def setPositions(self, val: list[PyGe.Point2d]) -> bool:
def setVisible(self, val: bool) -> bool:
def visible(self) -> bool:
class CvDbTinSurfaceWall Class
def __init__(self, type: PyBrxCv.TinWallType) -> None:
def __reduce__(self) -> Any:
def className() -> str:
def setHeight(self, val: float) -> None:
def setWallSide(self, val: PyBrxCv.TinWallSide) -> None:
def wallSide(self) -> TinWallSide:
def wallType(self) -> TinWallType:
class CvDbVAlignment Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def addArcAuto(self, prevId: int, nextId: int) -> int:
def addArcBetween(self, prevId: int, nextId: int, radius: float) -> int:
def addParabolaAuto(self, prevId: int, nextId: int) -> int:
def addParabolaBetween(self, prevId: int, nextId: int, radius: float) -> int:
def addTangentFixed(self, startPoint: PyGe.Point2d, endPoint: PyGe.Point2d) -> int:
def baseHAlignment(self) -> PyDb.ObjectId:
def baseSurface(self) -> PyDb.ObjectId:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignment:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbVAlignment:
def curveAtPVI(self, pvi: PyBrxCv.CvDbVAlignmentPVI) -> int:
def curveElementColor(self) -> int:
def deleteElement(self, id: int) -> bool:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def elementAtId(self, id: int) -> CvDbVAlignmentElement:
def elementCount(self) -> int:
def elevationMax(self) -> float:
def elevationMin(self) -> float:
def firstElementId(self) -> int:
def firstTangentElementId(self) -> int:
def getElementId(self, gsMarker: int) -> int:
def getElevationAt(self, station: float) -> tuple[bool, float]:
def getElevations(self) -> list[PyGe.Point2d]:
def getPVIsArrays(self) -> list[PyBrxCv.CvDbVAlignmentPVI]:
def getRadius(self, param: float) -> float:
def getUnorderedElementIds(self) -> list[int]:
def insertTangentFixed(self, startPoint: PyGe.Point2d, endPoint: PyGe.Point2d, val: int) -> int:
def lastElementId(self) -> int:
def length(self) -> float:
def lineElementColor(self) -> int:
def nextTangentElementId(self, id: int) -> int:
def previousTangentElementId(self, id: int) -> int:
def pviAtCurve(self, curve: PyBrxCv.CvDbVAlignmentCurve) -> CvDbVAlignmentPVI:
def setBaseHAlignment(self, id: PyDb.ObjectId) -> bool:
def setBaseSurface(self, id: PyDb.ObjectId) -> bool:
def setCurveElementColor(self, val: int) -> bool:
def setLineElementColor(self, val: int) -> bool:
def setStyle(self, val: int) -> bool:
def setTangentPolygonColor(self, val: int) -> bool:
def setType(self, val: VAlignmentType) -> bool:
def style(self) -> int:
def tangentPolygonColor(self) -> int:
def type(self) -> VAlignmentType:
def update(self, updateDependencies: bool) -> bool:
class CvDbVAlignmentArc Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignmentArc:
def center(self) -> PyGe.Point2d:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def gradeIn(self) -> float:
def gradeOut(self) -> float:
def isClockwise(self) -> bool:
def radius(self) -> float:
def setCenter(self, pt: PyGe.Point2d) -> bool:
def setClockwise(self, val: bool) -> bool:
def setRadius(self, val: float) -> bool:
class CvDbVAlignmentCurve Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignmentCurve:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def endPoint(self) -> PyGe.Point2d:
def length(self) -> float:
def startPoint(self) -> PyGe.Point2d:
class CvDbVAlignmentElement Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignmentElement:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def id(self) -> int:
def nextId(self) -> int:
def parameterConstraint(self) -> VAlignmentParameterConstraint:
def previousId(self) -> int:
def setNextId(self, val: int) -> bool:
def setParameterConstraint(self, val: PyBrxCv.VAlignmentParameterConstraint) -> bool:
def setPreviousId(self, val: int) -> bool:
def setTangencyConstraint(self, val: PyBrxCv.VAlignmentTangencyConstraint) -> bool:
def tangencyConstraint(self) -> VAlignmentTangencyConstraint:
def type(self) -> VAlignmentElementType:
class CvDbVAlignmentPVI Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignmentPVI:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def location(self) -> PyGe.Point2d:
class CvDbVAlignmentParabola Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignmentParabola:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def gradeIn(self) -> float:
def gradeOut(self) -> float:
def radius(self) -> float:
def setRadius(self, val: float) -> bool:
class CvDbVAlignmentTangent Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignmentTangent:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def passThroughPoint1(self) -> PyGe.Point2d:
def passThroughPoint2(self) -> PyGe.Point2d:
def setPassThroughPoint1(self, pt: PyGe.Point2d) -> bool:
def setPassThroughPoint2(self, pt: PyGe.Point2d) -> bool:
class CvDbVAlignmentView Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyRx.RxObject) -> CvDbVAlignmentView:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbVAlignmentView:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def update(self, bUpdateDependencies: bool, updateOrigin: bool) -> bool:
class CvDbView Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def addGraph(self, id: PyDb.ObjectId) -> bool:
def baseElevation(self) -> float:
def baseHAlignment(self) -> PyDb.ObjectId:
def cast(otherObject: PyRx.RxObject) -> CvDbView:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbView:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def fromWCSPoint2d(self, pt: PyGe.Point2d) -> PyGe.Point2d:
def fromWCSX(self, val: float) -> float:
def fromWCSY(self, val: float) -> float:
def graphAt(self, val: int) -> PyDb.ObjectId:
def graphCount(self) -> int:
def height(self) -> float:
def horizontalScale(self) -> float:
def length(self) -> float:
def origin(self) -> PyGe.Point2d:
def removeGraph(self, id: PyDb.ObjectId) -> bool:
def setBaseElevation(self, val: float) -> bool:
def setBaseHAlignment(self, id: PyDb.ObjectId) -> bool:
def setHeight(self, val: float) -> bool:
def setHorizontalScale(self, val: float) -> bool:
def setLength(self, val: float) -> bool:
def setOrigin(self, pt: PyGe.Point2d) -> bool:
def setVerticalScale(self, val: float) -> bool:
def toWCSPoint2d(self, pt: PyGe.Point2d) -> PyGe.Point2d:
def toWCSX(self, val: float) -> float:
def toWCSY(self, val: float) -> float:
def verticalScale(self) -> float:
class CvDbVolumeSurface Class
def __init__(self, id: PyDb.ObjectId, mode: PyDb.OpenMode, erased: bool) -> None:
def __reduce__(self) -> Any:
def baseSurfaceObjectId(self) -> PyDb.ObjectId:
def boundingPolygon(self) -> list[PyGe.Point3d]:
def boundingPolygonObjectId(self) -> PyDb.ObjectId:
def cast(otherObject: PyRx.RxObject) -> CvDbVolumeSurface:
def className() -> str:
def cloneFrom(otherObject: PyRx.RxObject) -> CvDbVolumeSurface:
def comparisonSurfaceObjectId(self) -> PyDb.ObjectId:
def cutVolume(self) -> float:
def depthElevation(self) -> float:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def fillVolume(self) -> float:
def initialize(self, baseSurface: PyBrxCv.CvDbTinSurface, compSurface: PyBrxCv.CvDbTinSurface, boundingPolygon: list[PyGe.Poin3d]) -> bool:
def initialize(self, baseSurface: PyBrxCv.CvDbTinSurface, compSurface: PyBrxCv.CvDbTinSurface, boundingPolygon: list[PyGe.Poin3d], midOrdinateDist: float) -> bool:
def initialize(self, baseSurface: PyBrxCv.CvDbTinSurface, referenceElevation: float, vType: PyBrxCv.VolumeSurfaceType, boundingPolygon: list[PyGe.Poin3d]) -> bool:
def initialize(self, baseSurface: PyBrxCv.CvDbTinSurface, referenceElevation: float, vType: PyBrxCv.VolumeSurfaceType, boundingPolygonId: PyDb.ObjectId, midOrdinateDist: float) -> bool:
def initialize(*args) -> bool:
def type(self) -> VolumeSurfaceType:
class CvGradingRule Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyBrxCv.CvGradingRule) -> CvGradingRule:
def className() -> str:
def convertRadToSlope() -> float:
def convertSlopeToRad() -> float:
def isNull(self) -> bool:
def release(self) -> bool:
def setSide(self, format: int) -> bool:
def setSlopeFormat(self, format: int) -> bool:
def side(self) -> GradingSide:
def slopeFormat(self) -> GradingSlopeFormat:
def type(self) -> GradingType:
class CvGradingSlopeOffsetRule Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyBrxCv.CvGradingRule) -> CvGradingSlopeOffsetRule:
def className() -> str:
def offset(self) -> float:
def setOffset(self, offset: float) -> bool:
def setSlope(self, slope: float) -> bool:
def slope(self) -> float:
class CvGradingSlopeSurfaceRule Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def cast(otherObject: PyBrxCv.CvGradingRule) -> CvGradingSlopeSurfaceRule:
def className() -> str:
def cutSlope(self) -> float:
def fillSlope(self) -> float:
def setCutSlope(self, val: float) -> bool:
def setFillSlope(self, val: float) -> bool:
def setSurfaceId(self, id: PyDb.ObjectId) -> bool:
def surfaceId(self) -> PyDb.ObjectId:
class CvStationEquation Class
def __init__(self) -> None:
def __init__(self, rawStation: float, stationForward: float, type: StationEquationType) -> None:
def __init__(*args) -> None:
def __reduce__(self) -> Any:
def className() -> str:
def getRawStation(self) -> float:
def getStationForward(self) -> float:
def getType(self) -> StationEquationType:
def isNull(self) -> bool:
def setRawStation(self, val: float) -> bool:
def setStationForward(self, val: float) -> bool:
def setType(self, val: PyBrxCv.EStationEquationType) -> bool:
class CvStationEquations Class
def __init__(self) -> None:
def __init__(self, alignment: PyBrxCv.CvDbHAlignment) -> None:
def __init__(*args) -> None:
def __reduce__(self) -> Any:
def addStationEquation(self, equation: PyBrxCv.CvStationEquation) -> bool:
def className() -> str:
def getLengthFromRawStation(self, rawStation: float) -> float:
def getRawStation(self, station: float) -> list[float]:
def getRawStationFromLength(self, length: float) -> float:
def getRefRawStartingStation(self) -> float:
def getRefStartingLength(self) -> float:
def getStartingStation(self) -> float:
def getStation(self, rawStation: float) -> float:
def getStationBack(self, idx: int) -> float:
def getStationEquation(self, idx: int) -> CvStationEquation:
def removeAllStationEquations(self) -> bool:
def removeStationEquation(self, idx: int) -> bool:
def setRefRawStartingStation(self, rawStartingStation: float) -> bool:
def setRefStartingLength(self, startingStation: float) -> bool:
def stationEquationsCount(self) -> int:
def update(self) -> bool:
class CvTinPoint Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def isValid(self) -> bool:
def location(self) -> PyGe.Point3d:
def triangleWithPoint(self) -> CvTinTriangle:
class CvTinTriangle Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def isValid(self) -> bool:
def isVisible(self) -> bool:
def locationAt(self, index: int) -> PyGe.Point3d:
def neighborAt(self, index: int) -> CvTinTriangle:
def pointAt(self, index: int) -> CvTinPoint:
class DisplayMode Class
eDisplayModeAsComposed: ClassVar[Self]
eDisplayModeStackedText: ClassVar[Self]
class DisplayOrientation Class
eDisplayOrientationPlan: ClassVar[Self]
eDisplayOrientationModel: ClassVar[Self]
eDisplayOrientationProfile: ClassVar[Self]
eDisplayOrientationSection: ClassVar[Self]
class DrawingObjectType Class
eUnknown: ClassVar[Self]
ePoint: ClassVar[Self]
eBlock: ClassVar[Self]
eText: ClassVar[Self]
eLine: ClassVar[Self]
eFace: ClassVar[Self]
ePolyline: ClassVar[Self]
eCivilPoint: ClassVar[Self]
class ForcedInsertion Class
eForcedInsertionNone: ClassVar[Self]
eForcedInsertionTop: ClassVar[Self]
eForcedInsertionBottom: ClassVar[Self]
class GradingCalculationMethod Class
eGradingAccurate: ClassVar[Self]
eGradingFast: ClassVar[Self]
class GradingSide Class
eGradingSideNone: ClassVar[Self]
eGradingSideLeft: ClassVar[Self]
eGradingSideRight: ClassVar[Self]
class GradingSlopeFormat Class
eSlopeNoFormat: ClassVar[Self]
eSlopeRiseRun: ClassVar[Self]
eSlopeDegrees: ClassVar[Self]
eSlopePercent: ClassVar[Self]
eSlopeRadians: ClassVar[Self]
class GradingStatus Class
eGradingNoStatus: ClassVar[Self]
eGradingOk: ClassVar[Self]
eGradingUpdateNeeded: ClassVar[Self]
eGradingIncorrectInputData: ClassVar[Self]
eGradingSurfaceMissing: ClassVar[Self]
eGradingRuleMissing: ClassVar[Self]
eGradingInputDataOutsideSurface: ClassVar[Self]
eGradingGradingOutsideSurface: ClassVar[Self]
eGradingOffsetFailed: ClassVar[Self]
eGradingMultipleOffsetResult: ClassVar[Self]
eGradingZeroGrading: ClassVar[Self]
eGradingUnknownError: ClassVar[Self]
eGradingInputDataMissing: ClassVar[Self]
eGradingInvalidInput: ClassVar[Self]
eGradingInvalidRule: ClassVar[Self]
eGradingTimeout: ClassVar[Self]
class GradingType Class
eGradingTypeNone: ClassVar[Self]
eGradingTypeSlopeSurface: ClassVar[Self]
eGradingTypeSlopeOffset: ClassVar[Self]
class GradingVisualStyle Class
eGradingDrawNothing: ClassVar[Self]
eGradingDrawSurface: ClassVar[Self]
eGradingDrawRays: ClassVar[Self]
eGradingDrawDaylight: ClassVar[Self]
class HAlignmentElementType Class
eUndefined: ClassVar[Self]
eLine: ClassVar[Self]
eArc: ClassVar[Self]
eSpiral: ClassVar[Self]
eSpiralCurveSpiral: ClassVar[Self]
eSpiralLineSpiral: ClassVar[Self]
eSpiralLine: ClassVar[Self]
eLineSpiral: ClassVar[Self]
eSpiralCurve: ClassVar[Self]
eCurveSpiral: ClassVar[Self]
eSpiralSpiralCurveSpiralSpiral: ClassVar[Self]
eMultipleSegments: ClassVar[Self]
eSpiralCurveSpiralCurveSpiral: ClassVar[Self]
eSpiralCurveSpiralSpiralCurveSpiral: ClassVar[Self]
eSpiralSpiral: ClassVar[Self]
eSpiralSpiralCurve: ClassVar[Self]
eCurveSpiralSpiral: ClassVar[Self]
eCurveLineCurve: ClassVar[Self]
eCurveReverseCurve: ClassVar[Self]
eCurveCurveReverseCurve: ClassVar[Self]
ePI: ClassVar[Self]
class HAlignmentParameterConstraint Class
eUndefined: ClassVar[Self]
eAutomatic: ClassVar[Self]
eLine_TwoPoints: ClassVar[Self]
eLine_ThroughPoint: ClassVar[Self]
eLine_Length: ClassVar[Self]
eLine_BestFit: ClassVar[Self]
eArc_ThreePoints: ClassVar[Self]
eArc_CenterRadius: ClassVar[Self]
eArc_CenterPassThrough: ClassVar[Self]
eArc_PassThroughRadius: ClassVar[Self]
eArc_PassThroughAttachToEnd: ClassVar[Self]
eArc_PassThroughDirection: ClassVar[Self]
eArc_Radius: ClassVar[Self]
eArc_PassThrough: ClassVar[Self]
eArc_RadiusAndLength: ClassVar[Self]
eArc_PointOnTangent: ClassVar[Self]
eArc_BestFit: ClassVar[Self]
eSCS_SpiralInRadiusSpiralOut: ClassVar[Self]
eSCS_SpiralLengthRadiusPassThrough: ClassVar[Self]
eSCS_SpiralLengthRadiusArcLength: ClassVar[Self]
eSCS_SpiralLengthRadius: ClassVar[Self]
eSCS_SpiralLength: ClassVar[Self]
eSCS_SpiralInLengthSpiralOutLength: ClassVar[Self]
eSCS_SpiralInAValSpiralOutAVal: ClassVar[Self]
eSCS_SpiralInAValRadiusSpiralOutAVal: ClassVar[Self]
eSCS_SpiralAValRadiusPassThrough: ClassVar[Self]
eSCS_SpiralAValRadiusArcLength: ClassVar[Self]
eSCS_SpiralAValRadius: ClassVar[Self]
eSCS_SpiralAVal: ClassVar[Self]
eSCS_PointOnTangent: ClassVar[Self]
eSpiral_StartPointDirRadiusLength: ClassVar[Self]
eSpiral_StartPointDirStartAndEndRadiusLength: ClassVar[Self]
eSTS_SpiralInLengthSpiralOutLength: ClassVar[Self]
eSTS_TangentLength: ClassVar[Self]
eSTS_SpiralInAValSpiralOutAVal: ClassVar[Self]
eSTS_SpiralLengthTangentPassThrough: ClassVar[Self]
eSTS_SpiralLengthTangentLength: ClassVar[Self]
eSTS_SpiralAValTangentPassThrough: ClassVar[Self]
eSTS_SpiralAValTangentLength: ClassVar[Self]
eSSCSS_Sp1LenSp2LenRadiusPt: ClassVar[Self]
eSSCSS_Sp1LenSp2LenPt1Pt2: ClassVar[Self]
eSSCSS_Sp1AValSp2AValRadiusPt: ClassVar[Self]
eSSCSS_Sp1AValSp2AValPt1Pt2: ClassVar[Self]
class HAlignmentTangencyConstraint Class
eUndefined: ClassVar[Self]
eFixed: ClassVar[Self]
ePrevious: ClassVar[Self]
eNext: ClassVar[Self]
eBoth: ClassVar[Self]
class HAlignmentVisualStyle Class
eUndefined: ClassVar[Self]
eElements: ClassVar[Self]
eTangentExtensions: ClassVar[Self]
eElementExtensions: ClassVar[Self]
class LabelAnchor Class
eLabelAnchors: ClassVar[Self]
eLabelAnchorStart: ClassVar[Self]
eLabelAnchorMiddle: ClassVar[Self]
eLabelAnchorEnd: ClassVar[Self]
eLabelAnchorTopLeft: ClassVar[Self]
eLabelAnchorTopCenter: ClassVar[Self]
eLabelAnchorTopRight: ClassVar[Self]
eLabelAnchorMiddleLeft: ClassVar[Self]
eLabelAnchorMiddleCenter: ClassVar[Self]
eLabelAnchorMiddleRight: ClassVar[Self]
eLabelAnchorBottomLeft: ClassVar[Self]
eLabelAnchorBottomCenter: ClassVar[Self]
eLabelAnchorBottomRight: ClassVar[Self]
eLabelAnchorInsertionPoint: ClassVar[Self]
eLabelAnchorCurveCenter: ClassVar[Self]
eLabelAnchorCurvePI: ClassVar[Self]
eLabelAnchorFeatureLocation: ClassVar[Self]
class LeaderAttachment Class
eLeaderAttachmentTopOfTopLine: ClassVar[Self]
eLeaderAttachmentMiddleOfTopLine: ClassVar[Self]
eLeaderAttachmentMiddle: ClassVar[Self]
eLeaderAttachmentMiddleOfBottomLine: ClassVar[Self]
eLeaderAttachmentBottomOfBottomLine: ClassVar[Self]
class LeaderType Class
eLeaderTypeStraight: ClassVar[Self]
eLeaderTypeSpline: ClassVar[Self]
class LengthType Class
eLengthTypeFixed: ClassVar[Self]
eLengthTypePercentage: ClassVar[Self]
class OrientationRef Class
eOrientationReferenceObject: ClassVar[Self]
eOrientationReferenceView: ClassVar[Self]
eOrientationReferenceWCS: ClassVar[Self]
eOrientationReferenceStartLeaderAtMarker: ClassVar[Self]
class ScalingType Class
eScalingTypeDrawingScale: ClassVar[Self]
eScalingTypeFixedScale: ClassVar[Self]
eScalingTypeAbsoluteUnits: ClassVar[Self]
eScalingTypeRelativeToScreen: ClassVar[Self]
class SpiralCurveType Class
eInCurve: ClassVar[Self]
eOutCurve: ClassVar[Self]
class SpiralDefinitionType Class
eClothoid: ClassVar[Self]
eCubicParabola: ClassVar[Self]
class SpiralDefinitionTypeSpiral Class
eClothoid: ClassVar[Self]
eCubicParabola: ClassVar[Self]
class SpiralDirectionType Class
eDirectionRight: ClassVar[Self]
eDirectionLeft: ClassVar[Self]
class SpiralParameterType Class
eClothoid: ClassVar[Self]
eCubicParabola: ClassVar[Self]
class SpiralParameterType2 Class
eParamA: ClassVar[Self]
eParamLength: ClassVar[Self]
class StationEquationType Class
Increasing: ClassVar[Self]
Decreasing: ClassVar[Self]
class StyleManagerType Class
eSymbolStyle: ClassVar[Self]
eLineLabel: ClassVar[Self]
eCurveLabel: ClassVar[Self]
ePointLabel: ClassVar[Self]
eContourLabel: ClassVar[Self]
eSurfaceSlopeLabel: ClassVar[Self]
eSurfaceElevationLabel: ClassVar[Self]
class SymbolType Class
eSymbolTypeACADPoint: ClassVar[Self]
eSymbolTypeCustom: ClassVar[Self]
eSymbolTypeBlock: ClassVar[Self]
eSymbolTypeVerticalLine: ClassVar[Self]
class TinBoundaryType Class
eTinShow: ClassVar[Self]
eTinHide: ClassVar[Self]
eTinOuter: ClassVar[Self]
class TinBreaklineType Class
eTinBreaklineNormal: ClassVar[Self]
eTinNonDestructive: ClassVar[Self]
class TinConstraintType Class
eTinBreakline: ClassVar[Self]
eTinBoundary: ClassVar[Self]
eTinWall: ClassVar[Self]
class TinIntersectionElevation Class
eTinNotAllowed: ClassVar[Self]
eTinElevationMin: ClassVar[Self]
eTinElevationMax: ClassVar[Self]
eTinElevationMid: ClassVar[Self]
class TinSurfaceDefinitionType Class
eNone: ClassVar[Self]
eTransform: ClassVar[Self]
eAddPoint: ClassVar[Self]
eAddPoints: ClassVar[Self]
eDeletePoint: ClassVar[Self]
eDeletePoints: ClassVar[Self]
eSwapEdge: ClassVar[Self]
eMovePoint: ClassVar[Self]
eMovePoints: ClassVar[Self]
eAddBreaklines: ClassVar[Self]
eAddBoundaries: ClassVar[Self]
eAddWalls: ClassVar[Self]
eVolume: ClassVar[Self]
eMerge: ClassVar[Self]
eDeleteEdge: ClassVar[Self]
eDeleteEdges: ClassVar[Self]
eAddLine: ClassVar[Self]
eAddLines: ClassVar[Self]
eModifyPointElevation: ClassVar[Self]
eModifyPointsElevation: ClassVar[Self]
eModifyPointsElevations: ClassVar[Self]
eCreateFromFaces: ClassVar[Self]
eAddDrawingObjects: ClassVar[Self]
eCreateSnapshot: ClassVar[Self]
eRiseLower: ClassVar[Self]
eLandXML: ClassVar[Self]
eAddPointFiles: ClassVar[Self]
eAddPointGroups: ClassVar[Self]
eAddPointClouds: ClassVar[Self]
eGroupDefinitions: ClassVar[Self]
eDeform: ClassVar[Self]
eSmoothen: ClassVar[Self]
eCreateMerged: ClassVar[Self]
eIFC: ClassVar[Self]
eCreateTypedSnapshot: ClassVar[Self]
eCreateFromCorridor: ClassVar[Self]
eCreateFromC3D: ClassVar[Self]
eRemoveOuterEdges: ClassVar[Self]
eCreateFromContours: ClassVar[Self]
eMinimizeFlatAreas: ClassVar[Self]
eTrianglesVisibility: ClassVar[Self]
eRemoveBelowAboveElevation: ClassVar[Self]
class TinSurfaceIntersectType Class
eTinSurfaceFirstOnly: ClassVar[Self]
eTinSurfaceAll: ClassVar[Self]
class TinSurfaceMeshType Class
eTinSurfaceMeshSurface: ClassVar[Self]
eTinSurfaceMeshElevation: ClassVar[Self]
eTinSurfaceMeshDepth: ClassVar[Self]
class TinSurfaceSolidType Class
eSolidTypeSurfaceSurface: ClassVar[Self]
eSolidTypeSurfaceElevation: ClassVar[Self]
eSolidTypeSurfaceDepth: ClassVar[Self]
class TinSurfaceStyle Class
eTinStyleNone: ClassVar[Self]
eTinStyleBoundaryLine: ClassVar[Self]
eTinStylePoints: ClassVar[Self]
eTinStyleTriangles: ClassVar[Self]
eTinStyleContours: ClassVar[Self]
eTinStyleElevationTooltip: ClassVar[Self]
class TinWallSide Class
eTinWallLeft: ClassVar[Self]
eTinWallRight: ClassVar[Self]
class TinWallType Class
eTinWallNormal: ClassVar[Self]
eTinWallProjected: ClassVar[Self]
class VAlignmentElementType Class
eUndefined: ClassVar[Self]
eTangent: ClassVar[Self]
eArc: ClassVar[Self]
eParabola: ClassVar[Self]
ePVI: ClassVar[Self]
class VAlignmentParameterConstraint Class
eUndefined: ClassVar[Self]
ePassThroughPoints: ClassVar[Self]
eRadius: ClassVar[Self]
eLength: ClassVar[Self]
eAngle: ClassVar[Self]
eAutomatic: ClassVar[Self]
ePointOnTangent: ClassVar[Self]
class VAlignmentTangencyConstraint Class
eUndefined: ClassVar[Self]
eFixed: ClassVar[Self]
ePrevious: ClassVar[Self]
eNext: ClassVar[Self]
eBoth: ClassVar[Self]
class VAlignmentType Class
eLayout: ClassVar[Self]
eStaticSurface: ClassVar[Self]
eDynamicSurface: ClassVar[Self]
eAutomatic: ClassVar[Self]
class VAlignmentVisualStyle Class
eElements: ClassVar[Self]
eTangents: ClassVar[Self]
eExtensions: ClassVar[Self]
class VolumeSurfaceType Class
eTinVolumeBaseComparison: ClassVar[Self]
eTinVolumeToElevation: ClassVar[Self]
eTinVolumeToDepth: ClassVar[Self]