diff --git a/PythonAPI/carla/source/carla/__carla_rss.pyi b/PythonAPI/carla/source/carla/__carla_rss.pyi index 43fda56f7a7..586e8c5b13d 100644 --- a/PythonAPI/carla/source/carla/__carla_rss.pyi +++ b/PythonAPI/carla/source/carla/__carla_rss.pyi @@ -2,7 +2,7 @@ from typing import Callable import ad -from libcarla import ( +from .libcarla import ( Actor, Sensor, SensorData, diff --git a/PythonAPI/carla/source/carla/ad/__init__.pyi b/PythonAPI/carla/source/carla/ad/__init__.pyi index 76b33c0e33c..b77b9a23f2d 100644 --- a/PythonAPI/carla/source/carla/ad/__init__.pyi +++ b/PythonAPI/carla/source/carla/ad/__init__.pyi @@ -73,7 +73,16 @@ class _IndexableVector(_Vector[_T], Protocol): class _VectorSequence(_IndexableVector[_T], Protocol): """Adds `count` and `index` methods.""" - def index(self, item: _T, /) -> int: + def count(self, item: _T, /) -> int: + ... + +@type_check_only +class _SortableSequence(_VectorSequence[_T], Protocol): + """Adds `sort` method. Not all _VectorSequences support sort.""" + + # TODO: Need to check if _VectorSequence is correct base or if needs two protocols + + def sort(self) -> None: ... @type_check_only @@ -109,6 +118,9 @@ class _FloatLike(Protocol): @type_check_only class _Calculable(_Assignable, _FloatLike, Protocol): + """ + A float like with Max, Min, and Precision values. + """ cMaxValue: float cMinValue: float diff --git a/PythonAPI/carla/source/carla/ad/map/lane.pyi b/PythonAPI/carla/source/carla/ad/map/lane.pyi index 6c34ff51bcc..eb756544bc7 100644 --- a/PythonAPI/carla/source/carla/ad/map/lane.pyi +++ b/PythonAPI/carla/source/carla/ad/map/lane.pyi @@ -1,3 +1,4 @@ +from typing import overload import ad from . import * @@ -837,3 +838,763 @@ class numeric_limits_less__ad_scope_map_scope_lane_scope_LaneId__greater_: ad::map::lane::LaneId max() """ ... + +def calcLaneAltitudeRange(lane: Lane) -> LaneAltitudeRange: + """ + + calcLaneAltitudeRange( (Lane)lane) -> LaneAltitudeRange : + + C++ signature : + ad::map::lane::LaneAltitudeRange calcLaneAltitudeRange(ad::map::lane::Lane) + """ + +def calcLength(laneId: LaneId | match.LaneOccupiedRegion | ENUBorder | ECEFBorder | GeoBorder | ENUBorderList | ECEFBorderList | GeoBorderList) -> ad.physics.Distance: + """ + + calcLength( (LaneId)laneId) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(ad::map::lane::LaneId) + + calcLength( (LaneOccupiedRegion)laneOccupiedRegion) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(ad::map::match::LaneOccupiedRegion) + + calcLength( (ENUBorder)border) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(ad::map::lane::ENUBorder) + + calcLength( (ECEFBorder)border) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(ad::map::lane::ECEFBorder) + + calcLength( (GeoBorder)border) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(ad::map::lane::GeoBorder) + + calcLength( (ENUBorderList)borderList) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(std::vector >) + + calcLength( (ECEFBorderList)borderList) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(std::vector >) + + calcLength( (GeoBorderList)borderList) -> Distance : + + C++ signature : + ad::physics::Distance calcLength(std::vector >) + """ + +def calcWidth(obj: point.ParaPoint | LaneId | ad.physics.ParametricValue | point.ENUPoint | match.LaneOccupiedRegion) -> ad.physics.Distance: + """ + + calcWidth( (ParaPoint)paraPoint) -> Distance : + + C++ signature : + ad::physics::Distance calcWidth(ad::map::point::ParaPoint) + + calcWidth( (LaneId)laneId, (ParametricValue)longOffset) -> Distance : + + C++ signature : + ad::physics::Distance calcWidth(ad::map::lane::LaneId,ad::physics::ParametricValue) + + calcWidth( (ENUPoint)enuPoint) -> Distance : + + C++ signature : + ad::physics::Distance calcWidth(ad::map::point::ENUPoint) + + calcWidth( (LaneOccupiedRegion)laneOccupiedRegion) -> Distance : + + C++ signature : + ad::physics::Distance calcWidth(ad::map::match::LaneOccupiedRegion) + """ + +def findNearestPointOnLane(lane: Lane, pt: point.ECEFPoint, mmpos: match.MapMatchedPosition) -> bool: + """ + + findNearestPointOnLane( (Lane)lane, (ECEFPoint)pt, (MapMatchedPosition)mmpos) -> bool : + + C++ signature : + bool findNearestPointOnLane(ad::map::lane::Lane,ad::map::point::ECEFPoint,ad::map::match::MapMatchedPosition {lvalue}) + """ + +def findNearestPointOnLaneInterval(laneInterval: route.LaneInterval, pt: point.ECEFPoint, mmpos: match.MapMatchedPosition) -> bool: + """ + + findNearestPointOnLaneInterval( (LaneInterval)laneInterval, (ECEFPoint)pt, (MapMatchedPosition)mmpos) -> bool : + + C++ signature : + bool findNearestPointOnLaneInterval(ad::map::route::LaneInterval,ad::map::point::ECEFPoint,ad::map::match::MapMatchedPosition {lvalue}) + """ + +def fromString(str: str) -> ContactLocation | LaneType | ContactType | LaneDirection: + """ + + fromString( (str)str) -> ContactLocation : + + C++ signature : + ad::map::lane::ContactLocation fromString(std::__cxx11::basic_string, std::allocator >) + + fromString( (str)str) -> LaneType : + + C++ signature : + ad::map::lane::LaneType fromString(std::__cxx11::basic_string, std::allocator >) + + fromString( (str)str) -> ContactType : + + C++ signature : + ad::map::lane::ContactType fromString(std::__cxx11::basic_string, std::allocator >) + + fromString( (str)str) -> LaneDirection : + + C++ signature : + ad::map::lane::LaneDirection fromString(std::__cxx11::basic_string, std::allocator >) + """ + +def getContactLanes(lane: Lane, location: ContactLocation | ContactLocationList) -> ContactLaneList: + """ + + getContactLanes( (Lane)lane, (ContactLocation)location) -> ContactLaneList : + + C++ signature : + std::vector > getContactLanes(ad::map::lane::Lane,ad::map::lane::ContactLocation) + + getContactLanes( (Lane)lane, (ContactLocationList)locations) -> ContactLaneList : + + C++ signature : + std::vector > getContactLanes(ad::map::lane::Lane,std::vector >) + """ + +def getContactLocation(lane: Lane, to_lane_id: LaneId) -> ContactLocation: + """ + + getContactLocation( (Lane)lane, (LaneId)to_lane_id) -> ContactLocation : + + C++ signature : + ad::map::lane::ContactLocation getContactLocation(ad::map::lane::Lane,ad::map::lane::LaneId) + """ + +def getDirectNeighborhoodRelation(laneId: LaneId, checkLaneId: LaneId) -> ContactLocation: + """ + + getDirectNeighborhoodRelation( (LaneId)laneId, (LaneId)checkLaneId) -> ContactLocation : + + C++ signature : + ad::map::lane::ContactLocation getDirectNeighborhoodRelation(ad::map::lane::LaneId,ad::map::lane::LaneId) + """ + +def getDistanceEnuPointToLateralAlignmentEdge(enuPoint: point.ENUPoint, lateralAlignmentEdge: point.ENUEdge) -> ad.physics.Distance: + """ + + getDistanceEnuPointToLateralAlignmentEdge( (ENUPoint)enuPoint, (ENUEdge)lateralAlignmentEdge) -> Distance : + + C++ signature : + ad::physics::Distance getDistanceEnuPointToLateralAlignmentEdge(ad::map::point::ENUPoint,std::vector >) + """ + +def getDistanceToLane(laneId: LaneId, object: rss.world.Object) -> ad.physics.Distance: + """ + + getDistanceToLane( (LaneId)laneId, (Object)object) -> Distance : + + C++ signature : + ad::physics::Distance getDistanceToLane(ad::map::lane::LaneId,ad::map::match::Object) + """ + +def getDuration(lane: Lane, range: ad.physics.ParametricRange) -> ad.physics.Duration: + """ + + getDuration( (Lane)lane, (ParametricRange)range) -> Duration : + + C++ signature : + ad::physics::Duration getDuration(ad::map::lane::Lane,ad::physics::ParametricRange) + """ + +def getENUHeading(borderList: ENUBorderList, enuPoint: point.ENUPoint) -> point.ENUHeading: + """ + + getENUHeading( (ENUBorderList)borderList, (ENUPoint)enuPoint) -> ENUHeading : + + C++ signature : + ad::map::point::ENUHeading getENUHeading(std::vector >,ad::map::point::ENUPoint) + """ + +def getENULanePoint(parametricPoint: point.ParaPoint, lateralOffset: ad.physics.ParametricValue) -> point.ENUHeading: + """ + + getENULanePoint( (ParaPoint)parametricPoint [, (ParametricValue)lateralOffset=]) -> ENUPoint : + + C++ signature : + ad::map::point::ENUPoint getENULanePoint(ad::map::point::ParaPoint [,ad::physics::ParametricValue=]) + """ + +def getEndPoint(lane: Lane) -> point.ECEFPoint: + """ + + getEndPoint( (Lane)lane) -> ECEFPoint : + + C++ signature : + ad::map::point::ECEFPoint getEndPoint(ad::map::lane::Lane) + """ + +def getHOV(lane: Lane) -> int: + """ + + getHOV( (Lane)lane) -> int : + + C++ signature : + unsigned short getHOV(ad::map::lane::Lane) + """ + +def getLane(id: LaneId) -> Lane: + """ + + getLane( (LaneId)id) -> Lane : + + C++ signature : + ad::map::lane::Lane getLane(ad::map::lane::LaneId) + """ + +def getLaneECEFHeading(position: match.MapMatchedPosition | point.ParaPoint, /) -> point.ECEFHeading: + """ + + getLaneECEFHeading( (MapMatchedPosition)mapMatchedPosition) -> ECEFHeading : + + C++ signature : + ad::map::point::ECEFHeading getLaneECEFHeading(ad::map::match::MapMatchedPosition) + + getLaneECEFHeading( (ParaPoint)paraPoint) -> ECEFHeading : + + C++ signature : + ad::map::point::ECEFHeading getLaneECEFHeading(ad::map::point::ParaPoint) + """ + + +@overload +def getLaneENUHeading(position: match.MapMatchedPosition | point.ParaPoint, /): + """ + + getLaneENUHeading( (MapMatchedPosition)mapMatchedPosition) -> ENUHeading : + + C++ signature : + ad::map::point::ENUHeading getLaneENUHeading(ad::map::match::MapMatchedPosition) + + getLaneENUHeading( (ParaPoint)paraPoint, (GeoPoint)gnssReference) -> ENUHeading : + + C++ signature : + ad::map::point::ENUHeading getLaneENUHeading(ad::map::point::ParaPoint,ad::map::point::GeoPoint) + + getLaneENUHeading( (ParaPoint)position) -> ENUHeading : + + C++ signature : + ad::map::point::ENUHeading getLaneENUHeading(ad::map::point::ParaPoint) + """ + +@overload +def getLaneENUHeading(paraPoint: point.ParaPoint, gnssReference: point.GeoPoint) -> point.ENUHeading: + """ + + getLaneENUHeading( (MapMatchedPosition)mapMatchedPosition) -> ENUHeading : + + C++ signature : + ad::map::point::ENUHeading getLaneENUHeading(ad::map::match::MapMatchedPosition) + + getLaneENUHeading( (ParaPoint)paraPoint, (GeoPoint)gnssReference) -> ENUHeading : + + C++ signature : + ad::map::point::ENUHeading getLaneENUHeading(ad::map::point::ParaPoint,ad::map::point::GeoPoint) + + getLaneENUHeading( (ParaPoint)position) -> ENUHeading : + + C++ signature : + ad::map::point::ENUHeading getLaneENUHeading(ad::map::point::ParaPoint) + """ + +def getLanePtr(id: LaneId) -> Lane: + """ + + getLanePtr( (LaneId)id) -> Lane : + + C++ signature : + std::shared_ptr getLanePtr(ad::map::lane::LaneId) + """ + +def getLanes() -> LaneIdList: + """ + + getLanes() -> LaneIdList : + + C++ signature : + std::vector > getLanes() + """ + +def getLateralAlignmentEdge(border: ENUBorder, lateralAlignment: ad.physics.ParametricValue) -> point.ENUEdge: + """ + + getLateralAlignmentEdge( (ENUBorder)border, (ParametricValue)lateralAlignment) -> ENUEdge : + + C++ signature : + std::vector > getLateralAlignmentEdge(ad::map::lane::ENUBorder,ad::physics::ParametricValue) + """ + +def getMaxSpeed(lane: Lane, range: ad.physics.ParametricRange) -> ad.physics.Speed: + """ + + getMaxSpeed( (Lane)lane, (ParametricRange)range) -> Speed : + + C++ signature : + ad::physics::Speed getMaxSpeed(ad::map::lane::Lane,ad::physics::ParametricRange) + """ + +def getParametricPoint(lane: Lane, longitudinalOffset: ad.physics.ParametricValue, lateralOffset: ad.physics.ParametricValue) -> point.ECEFPoint: + """ + + getParametricPoint( (Lane)lane, (ParametricValue)longitudinalOffset, (ParametricValue)lateralOffset) -> ECEFPoint : + + C++ signature : + ad::map::point::ECEFPoint getParametricPoint(ad::map::lane::Lane,ad::physics::ParametricValue,ad::physics::ParametricValue) + """ + +def getProjectedParametricPoint(lane: Lane, longitudinalOffset: ad.physics.ParametricValue, lateralOffset: ad.physics.ParametricValue) -> point.ECEFPoint: + """ + + getProjectedParametricPoint( (Lane)lane, (ParametricValue)longitudinalOffset, (ParametricValue)lateralOffset) -> ECEFPoint : + + C++ signature : + ad::map::point::ECEFPoint getProjectedParametricPoint(ad::map::lane::Lane,ad::physics::ParametricValue,ad::physics::ParametricValue) + """ + +def getSpeedLimits(lane: Lane, range: ad.physics.ParametricRange) -> restriction.SpeedLimitList: + """ + + getSpeedLimits( (Lane)lane, (ParametricRange)range) -> SpeedLimitList : + + C++ signature : + std::vector > getSpeedLimits(ad::map::lane::Lane,ad::physics::ParametricRange) + """ + +def getStartPoint(lane: Lane) -> point.ECEFPoint: + """ + + getStartPoint( (Lane)lane) -> ECEFPoint : + + C++ signature : + ad::map::point::ECEFPoint getStartPoint(ad::map::lane::Lane) + """ + +def getWidth(lane: Lane, longitudinalOffset: ad.physics.ParametricValue) -> ad.physics.Distance: + """ + + getWidth( (Lane)lane, (ParametricValue)longitudinalOffset) -> Distance : + + C++ signature : + ad::physics::Distance getWidth(ad::map::lane::Lane,ad::physics::ParametricValue) + """ + +def isAccessOk(lane: Lane | ContactLane, vehicle: restriction.VehicleDescriptor) -> bool: + """ + + isAccessOk( (Lane)lane, (VehicleDescriptor)vehicle) -> bool : + + C++ signature : + bool isAccessOk(ad::map::lane::Lane,ad::map::restriction::VehicleDescriptor) + + isAccessOk( (ContactLane)contactLane, (VehicleDescriptor)vehicle) -> bool : + + C++ signature : + bool isAccessOk(ad::map::lane::ContactLane,ad::map::restriction::VehicleDescriptor) + """ + +def isHeadingInLaneDirection(position: point.ParaPoint, heading: point.ENUHeading) -> bool: + """ + + isHeadingInLaneDirection( (ParaPoint)position, (ENUHeading)heading) -> bool : + + C++ signature : + bool isHeadingInLaneDirection(ad::map::point::ParaPoint,ad::map::point::ENUHeading) + """ + + +def isLaneDirectionNegative(lane: Lane | LaneId) -> bool: + """ + + isLaneDirectionNegative( (Lane)lane) -> bool : + + C++ signature : + bool isLaneDirectionNegative(ad::map::lane::Lane) + + isLaneDirectionNegative( (LaneId)laneId) -> bool : + + C++ signature : + bool isLaneDirectionNegative(ad::map::lane::LaneId) + """ + +def isLaneDirectionPositive(lane: Lane | LaneId) -> bool: + """ + + isLaneDirectionPositive( (Lane)lane) -> bool : + + C++ signature : + bool isLaneDirectionPositive(ad::map::lane::Lane) + + isLaneDirectionPositive( (LaneId)laneId) -> bool : + + C++ signature : + bool isLaneDirectionPositive(ad::map::lane::LaneId) + """ + +def isLanePartOfAnIntersection(lane: Lane) -> bool: + """ + + isLanePartOfAnIntersection( (Lane)lane) -> bool : + + C++ signature : + bool isLanePartOfAnIntersection(ad::map::lane::Lane) + """ + +def isLaneRelevantForExpansion(laneId: LaneId, relevantLanes: LaneIdSet) -> bool: + """ + + isLaneRelevantForExpansion( (LaneId)laneId, (LaneIdSet)relevantLanes) -> bool : + + C++ signature : + bool isLaneRelevantForExpansion(ad::map::lane::LaneId,std::set, std::allocator >) + """ + +def isLeftMost(lane: Lane) -> bool: + """ + + isLeftMost( (Lane)lane) -> bool : + + C++ signature : + bool isLeftMost(ad::map::lane::Lane) + """ + +def isNear(lane: Lane, boundingSphere: point.BoundingSphere) -> bool: + """ + + isNear( (Lane)lane, (BoundingSphere)boundingSphere) -> bool : + + C++ signature : + bool isNear(ad::map::lane::Lane,ad::map::point::BoundingSphere) + """ + +def isPhysicalPredecessor(lane: Lane, other: Lane) -> bool: + """ + + isPhysicalPredecessor( (Lane)lane, (Lane)other) -> bool : + + C++ signature : + bool isPhysicalPredecessor(ad::map::lane::Lane,ad::map::lane::Lane) + """ + +def isPyhsicalSuccessor(lane: Lane, other: Lane) -> bool: + """ + + isPyhsicalSuccessor( (Lane)lane, (Lane)other) -> bool : + + C++ signature : + bool isPyhsicalSuccessor(ad::map::lane::Lane,ad::map::lane::Lane) + """ + +def isRightMost(lane: Lane) -> bool: + """ + + isRightMost( (Lane)lane) -> bool : + + C++ signature : + bool isRightMost(ad::map::lane::Lane) + """ + +def isRouteable(lane: Lane) -> bool: + """ + + isRouteable( (Lane)lane) -> bool : + + C++ signature : + bool isRouteable(ad::map::lane::Lane) + """ + +def isSameOrDirectNeighbor(id: LaneId, neighbor: LaneId) -> bool: + """ + + isSameOrDirectNeighbor( (LaneId)id, (LaneId)neighbor) -> bool : + + C++ signature : + bool isSameOrDirectNeighbor(ad::map::lane::LaneId,ad::map::lane::LaneId) + """ + +def isSuccessorOrPredecessor(laneId: LaneId, checkLaneId: LaneId) -> bool: + """ + + isSuccessorOrPredecessor( (LaneId)laneId, (LaneId)checkLaneId) -> bool : + + C++ signature : + bool isSuccessorOrPredecessor(ad::map::lane::LaneId,ad::map::lane::LaneId) + """ + +def isValid(laneId: LaneId | Lane | ContactLane, /, logErrors: bool=True) -> bool: + """ + + isValid( (LaneId)laneId [, (bool)logErrors=True]) -> bool : + + C++ signature : + bool isValid(ad::map::lane::LaneId [,bool=True]) + + isValid( (Lane)lane [, (bool)logErrors=True]) -> bool : + + C++ signature : + bool isValid(ad::map::lane::Lane [,bool=True]) + + isValid( (ContactLane)contactLane [, (bool)logErrors=True]) -> bool : + + C++ signature : + bool isValid(ad::map::lane::ContactLane [,bool=True]) + """ + +def isVanishingLaneEnd(lane: Lane) -> bool: + """ + + isVanishingLaneEnd( (Lane)lane) -> bool : + + C++ signature : + bool isVanishingLaneEnd(ad::map::lane::Lane) + """ + +def isVanishingLaneStart(lane: Lane) -> bool: + """ + + isVanishingLaneStart( (Lane)lane) -> bool : + + C++ signature : + bool isVanishingLaneStart(ad::map::lane::Lane) + """ + +def makeTransitionFromFirstBorderContinuous(first: ENUBorder, second: ENUBorder) -> None: + """ + + makeTransitionFromFirstBorderContinuous( (ENUBorder)first, (ENUBorder)second) -> None : + + C++ signature : + void makeTransitionFromFirstBorderContinuous(ad::map::lane::ENUBorder {lvalue},ad::map::lane::ENUBorder) + """ + +def makeTransitionFromFirstEdgeContinuous(first: point.ENUEdge, second: point.ENUEdge) -> None: + """ + + makeTransitionFromFirstEdgeContinuous( (ENUEdge)first, (ENUEdge)second) -> None : + + C++ signature : + void makeTransitionFromFirstEdgeContinuous(std::vector > {lvalue},std::vector >) + """ + +def makeTransitionToSecondBorderContinuous(first: ENUBorder, second: ENUBorder) -> None: + """ + + makeTransitionToSecondBorderContinuous( (ENUBorder)first, (ENUBorder)second) -> None : + + C++ signature : + void makeTransitionToSecondBorderContinuous(ad::map::lane::ENUBorder,ad::map::lane::ENUBorder {lvalue}) + """ + +def makeTransitionToSecondEdgeContinuous(first: point.ENUEdge, second: point.ENUEdge) -> None: + """ + + makeTransitionToSecondEdgeContinuous( (ENUEdge)first, (ENUEdge)second) -> None : + + C++ signature : + void makeTransitionToSecondEdgeContinuous(std::vector >,std::vector > {lvalue}) + """ + +def normalizeBorder(border: ENUBorder, previousBorder: ENUBorder) -> None: + """ + + normalizeBorder( (ENUBorder)border [, (ENUBorder)previousBorder=0]) -> None : + + C++ signature : + void normalizeBorder(ad::map::lane::ENUBorder {lvalue} [,ad::map::lane::ENUBorder const*=0]) + """ + +def oppositeLocation(e: ContactLocation) -> ContactLocation: + """ + + oppositeLocation( (ContactLocation)e) -> ContactLocation : + + C++ signature : + ad::map::lane::ContactLocation oppositeLocation(ad::map::lane::ContactLocation) + """ + +def projectParametricPointToEdges(lane: Lane, referencePoint: point.ECEFPoint | ad.physics.ParametricValue, point_on_left_edge: point.ECEFPoint, point_on_right_edge: point.ECEFPoint) -> bool: + """ + + projectParametricPointToEdges( (Lane)lane, (ECEFPoint)referencePoint, (ECEFPoint)point_on_left_edge, (ECEFPoint)point_on_right_edge) -> bool : + + C++ signature : + bool projectParametricPointToEdges(ad::map::lane::Lane,ad::map::point::ECEFPoint,ad::map::point::ECEFPoint {lvalue},ad::map::point::ECEFPoint {lvalue}) + + projectParametricPointToEdges( (Lane)lane, (ParametricValue)longitudinalOffset, (ECEFPoint)point_on_left_edge, (ECEFPoint)point_on_right_edge) -> bool : + + C++ signature : + bool projectParametricPointToEdges(ad::map::lane::Lane,ad::physics::ParametricValue,ad::map::point::ECEFPoint {lvalue},ad::map::point::ECEFPoint {lvalue}) + """ + +def projectPositionToLaneInHeadingDirection(position: point.ParaPoint, heading: point.ENUHeading, projectedPosition: point.ParaPoint) -> bool: + """ + + projectPositionToLaneInHeadingDirection( (ParaPoint)position, (ENUHeading)heading, (ParaPoint)projectedPosition) -> bool : + + C++ signature : + bool projectPositionToLaneInHeadingDirection(ad::map::point::ParaPoint,ad::map::point::ENUHeading,ad::map::point::ParaPoint {lvalue}) + """ + +def satisfiesFilter(lane: Lane, typeFilter: str, isHov: bool) -> bool: + """ + + satisfiesFilter( (Lane)lane, (str)typeFilter, (bool)isHov) -> bool : + + C++ signature : + bool satisfiesFilter(ad::map::lane::Lane,std::__cxx11::basic_string, std::allocator >,bool) + """ + +def toString(e: ContactLocation | LaneType | ContactType | LaneDirection) -> str: + """ + + toString( (ContactLocation)e) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > toString(ad::map::lane::ContactLocation) + + toString( (LaneType)e) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > toString(ad::map::lane::LaneType) + + toString( (ContactType)e) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > toString(ad::map::lane::ContactType) + + toString( (LaneDirection)e) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > toString(ad::map::lane::LaneDirection) + """ + +def to_string(value: object) -> str: + """ + + to_string( (LaneId)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::LaneId) + + to_string( (LaneIdList)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::vector >) + + to_string( (ContactLocation)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::ContactLocation) + + to_string( (LaneType)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::LaneType) + + to_string( (ENUBorder)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::ENUBorder) + + to_string( (GeoBorder)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::GeoBorder) + + to_string( (ContactType)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::ContactType) + + to_string( (ContactTypeList)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::vector >) + + to_string( (ContactLane)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::ContactLane) + + to_string( (ContactLaneList)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::vector >) + + to_string( (LaneDirection)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::LaneDirection) + + to_string( (Lane)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::Lane) + + to_string( (GeoBorderList)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::vector >) + + to_string( (ECEFBorder)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(ad::map::lane::ECEFBorder) + + to_string( (ENUBorderList)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::vector >) + + to_string( (ECEFBorderList)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::vector >) + + to_string( (ContactLocationList)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::vector >) + + to_string( (LaneIdSet)laneIdSet) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(std::set, std::allocator >) + """ + +def uniqueLaneId(point: point.GeoPoint) -> LaneId: + """ + + uniqueLaneId( (GeoPoint)point) -> LaneId : + + C++ signature : + ad::map::lane::LaneId uniqueLaneId(ad::map::point::GeoPoint) + """ + +def uniqueParaPoint(point: point.GeoPoint) -> point.ParaPoint: + """ + + uniqueParaPoint( (GeoPoint)point) -> ParaPoint : + + C++ signature : + ad::map::point::ParaPoint uniqueParaPoint(ad::map::point::GeoPoint) + """ diff --git a/PythonAPI/carla/source/carla/ad/map/route.pyi b/PythonAPI/carla/source/carla/ad/map/route.pyi index 74f3fc9e3a6..159e5359942 100644 --- a/PythonAPI/carla/source/carla/ad/map/route.pyi +++ b/PythonAPI/carla/source/carla/ad/map/route.pyi @@ -24,6 +24,7 @@ from ...libcarla import _CarlaEnum from . import * + AllNeighborLanes = RouteCreationMode.AllNeighborLanes AllRoutableLanes = RouteCreationMode.AllRoutableLanes AllRouteLanes = RouteSectionCreationMode.AllRouteLanes diff --git a/PythonAPI/carla/source/carla/ad/physics.pyi b/PythonAPI/carla/source/carla/ad/physics.pyi index 79f9d866fe1..da8b38a869a 100644 --- a/PythonAPI/carla/source/carla/ad/physics.pyi +++ b/PythonAPI/carla/source/carla/ad/physics.pyi @@ -1,21 +1,9 @@ from collections.abc import MutableSequence -from ad import _FloatLike, _Calculable +from ad import _FloatLike, _Calculable, _Assignable, _SortableSequence, _VectorSequence -class Acceleration: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: Acceleration, other: Acceleration) -> Acceleration: - """ - - assign( (Acceleration)arg1, (Acceleration)other) -> Acceleration : - - C++ signature : - ad::physics::Acceleration {lvalue} assign(ad::physics::Acceleration {lvalue},ad::physics::Acceleration) - """ - ... +class Acceleration(_Calculable): cMaxValue: float = 1000.0 @@ -23,80 +11,7 @@ class Acceleration: cPrecisionValue: float = 0.0001 - def ensureValid(self, arg1: Acceleration) -> None: - """ - - ensureValid( (Acceleration)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::Acceleration {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: Acceleration) -> None: - """ - - ensureValidNonZero( (Acceleration)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::Acceleration {lvalue}) - """ - ... - - def getMax(self) -> Acceleration: - """ - - getMax() -> Acceleration : - - C++ signature : - ad::physics::Acceleration getMax() - """ - ... - - def getMin(self) -> Acceleration: - """ - - getMin() -> Acceleration : - - C++ signature : - ad::physics::Acceleration getMin() - """ - ... - - def getPrecision(self) -> Acceleration: - """ - - getPrecision() -> Acceleration : - - C++ signature : - ad::physics::Acceleration getPrecision() - """ - ... - - def __float__(self) -> float: ... - - def __gt__(self, other: float | Acceleration) -> bool: ... - - def __ge__(self, other: float | Acceleration) -> bool: ... - - def __lt__(self, other: float | Acceleration) -> bool: ... - - def __le__(self, other: float | Acceleration) -> bool: ... - - def __eq__(self, other: float | Acceleration) -> bool: ... - -class Acceleration3D: - def __float__(self) -> float: ... - - def assign(self, arg1: Acceleration3D, other: Acceleration3D) -> Acceleration3D: - """ - - assign( (Acceleration3D)arg1, (Acceleration3D)other) -> Acceleration3D : - - C++ signature : - ad::physics::Acceleration3D {lvalue} assign(ad::physics::Acceleration3D {lvalue},ad::physics::Acceleration3D) - """ - ... +class Acceleration3D(_FloatLike, _Assignable): @property def x(self) -> Acceleration: ... @@ -107,68 +22,9 @@ class Acceleration3D: @property def z(self) -> Acceleration: ... -class Acceleration3DList: - def append(self, arg1: Acceleration3DList, arg2: Acceleration3D) -> None: - """ - - append( (Acceleration3DList)arg1, (Acceleration3D)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Acceleration3D) - """ - ... - - def count(self, arg1: Acceleration3DList, arg2: Acceleration3D) -> int: - """ - - count( (Acceleration3DList)arg1, (Acceleration3D)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Acceleration3D) - """ - ... - - def extend(self, arg1: Acceleration3DList, arg2: object) -> None: - """ - - extend( (Acceleration3DList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: Acceleration3DList, arg2: Acceleration3D) -> int: - """ - - index( (Acceleration3DList)arg1, (Acceleration3D)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Acceleration3D) - """ - ... - - def insert(self, arg1: Acceleration3DList, arg2: int, arg3: Acceleration3D) -> None: - """ - - insert( (Acceleration3DList)arg1, (int)arg2, (Acceleration3D)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Acceleration3D) - """ - ... - - def reverse(self, arg1: Acceleration3DList) -> None: - """ - - reverse( (Acceleration3DList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - -class AccelerationList: +class Acceleration3DList(_VectorSequence[Acceleration3D]): ... + +class AccelerationList(_VectorSequence[Acceleration]): def append(self, arg1: AccelerationList, arg2: Acceleration) -> None: """ @@ -317,1122 +173,192 @@ class AccelerationRangeList: """ ... -class Angle: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: Angle, other: Angle) -> Angle: - """ - - assign( (Angle)arg1, (Angle)other) -> Angle : - - C++ signature : - ad::physics::Angle {lvalue} assign(ad::physics::Angle {lvalue},ad::physics::Angle) - """ - ... - - cMaxValue: float = ... +class Angle(_FloatLike): + cMaxValue: float = ... # likely unbound and depends on platform - cMinValue: float = ... + cMinValue: float = ... # likely unbound and depends on platform cPrecisionValue: float = 0.001 - def ensureValid(self, arg1: Angle) -> None: - """ - - ensureValid( (Angle)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::Angle {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: Angle) -> None: - """ - - ensureValidNonZero( (Angle)arg1) -> None : +class AngleList(_SortableSequence[Angle]): + ... - C++ signature : - void ensureValidNonZero(ad::physics::Angle {lvalue}) - """ - ... - - def getMax(self) -> Angle: +class AngleRange: + def assign(self, arg1: AngleRange, other: AngleRange) -> AngleRange: """ - getMax() -> Angle : + assign( (AngleRange)arg1, (AngleRange)other) -> AngleRange : C++ signature : - ad::physics::Angle getMax() + ad::physics::AngleRange {lvalue} assign(ad::physics::AngleRange {lvalue},ad::physics::AngleRange) """ ... - def getMin(self) -> Angle: - """ - - getMin() -> Angle : - - C++ signature : - ad::physics::Angle getMin() - """ - ... + @property + def maximum(self) -> Angle: ... - def getPrecision(self) -> Angle: - """ + @property + def minimum(self) -> Angle: ... - getPrecision() -> Angle : +class AngleRangeList(_VectorSequence[AngleRange]): + ... - C++ signature : - ad::physics::Angle getPrecision() - """ - ... +class AngularAcceleration(_Calculable): + cMaxValue: float = 1000.0 -class AngleList: - def append(self, arg1: AngleList, arg2: Angle) -> None: - """ + cMinValue: float = -1000.0 - append( (AngleList)arg1, (Angle)arg2) -> None : + cPrecisionValue: float = 0.0001 - C++ signature : - void append(std::vector > {lvalue},ad::physics::Angle) - """ - ... - def count(self, arg1: AngleList, arg2: Angle) -> int: - """ +class AngularAccelerationList(_SortableSequence[AngularAcceleration]): + ... + +class AngularVelocity(_Calculable): + + cMaxValue: float = 1000.0 - count( (AngleList)arg1, (Angle)arg2) -> int : + cMinValue: float = -1000.0 - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Angle) - """ - ... + cPrecisionValue: float = 0.001 - def extend(self, arg1: AngleList, arg2: object) -> None: +class AngularVelocity3D: + def assign(self, arg1: AngularVelocity3D, other: AngularVelocity3D) -> AngularVelocity3D: """ - extend( (AngleList)arg1, (object)arg2) -> None : + assign( (AngularVelocity3D)arg1, (AngularVelocity3D)other) -> AngularVelocity3D : C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) + ad::physics::AngularVelocity3D {lvalue} assign(ad::physics::AngularVelocity3D {lvalue},ad::physics::AngularVelocity3D) """ ... - def index(self, arg1: AngleList, arg2: Angle) -> int: - """ - - index( (AngleList)arg1, (Angle)arg2) -> int : + @property + def x(self) -> AngularVelocity: ... - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Angle) - """ - ... + @property + def y(self) -> AngularVelocity: ... - def insert(self, arg1: AngleList, arg2: int, arg3: Angle) -> None: - """ + @property + def z(self) -> AngularVelocity: ... - insert( (AngleList)arg1, (int)arg2, (Angle)arg3) -> None : +class AngularVelocity3DList(_VectorSequence[AngularVelocity3D]): + ... - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Angle) - """ - ... +class AngularVelocityList(_SortableSequence[AngularVelocity]): + ... - def reverse(self, arg1: AngleList) -> None: +class Dimension2D: + def assign(self, arg1: Dimension2D, other: Dimension2D) -> Dimension2D: """ - reverse( (AngleList)arg1) -> None : + assign( (Dimension2D)arg1, (Dimension2D)other) -> Dimension2D : C++ signature : - void reverse(std::vector > {lvalue}) + ad::physics::Dimension2D {lvalue} assign(ad::physics::Dimension2D {lvalue},ad::physics::Dimension2D) """ ... - def sort(self, arg1: AngleList) -> None: - """ + @property + def length(self) -> Distance: ... - sort( (AngleList)arg1) -> None : + @property + def width(self) -> Distance: ... - C++ signature : - void sort(std::vector > {lvalue}) - """ - ... +class Dimension2DList(_VectorSequence[Dimension2D]): + ... -class AngleRange: - def assign(self, arg1: AngleRange, other: AngleRange) -> AngleRange: +class Dimension3D: + def assign(self, arg1: Dimension3D, other: Dimension3D) -> Dimension3D: """ - assign( (AngleRange)arg1, (AngleRange)other) -> AngleRange : + assign( (Dimension3D)arg1, (Dimension3D)other) -> Dimension3D : C++ signature : - ad::physics::AngleRange {lvalue} assign(ad::physics::AngleRange {lvalue},ad::physics::AngleRange) + ad::physics::Dimension3D {lvalue} assign(ad::physics::Dimension3D {lvalue},ad::physics::Dimension3D) """ ... @property - def maximum(self) -> Angle: ... + def height(self) -> Distance: ... @property - def minimum(self) -> Angle: ... + def length(self) -> Distance: ... -class AngleRangeList: - def append(self, arg1: AngleRangeList, arg2: AngleRange) -> None: - """ + @property + def width(self) -> Distance: ... - append( (AngleRangeList)arg1, (AngleRange)arg2) -> None : +class Dimension3DList(_VectorSequence[Dimension3D]): + ... - C++ signature : - void append(std::vector > {lvalue},ad::physics::AngleRange) - """ - ... +class Distance(_Calculable): + cMaxValue: float = 1000000000.0 - def count(self, arg1: AngleRangeList, arg2: AngleRange) -> int: - """ + cMinValue: float = -1000000000.0 - count( (AngleRangeList)arg1, (AngleRange)arg2) -> int : + cPrecisionValue: float = 0.001 - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::AngleRange) - """ - ... - def extend(self, arg1: AngleRangeList, arg2: object) -> None: +class Distance2D: + def assign(self, other: Distance2D) -> Distance2D: """ - extend( (AngleRangeList)arg1, (object)arg2) -> None : + assign( (Distance2D)arg1, (Distance2D)other) -> Distance2D : C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) + ad::physics::Distance2D {lvalue} assign(ad::physics::Distance2D {lvalue},ad::physics::Distance2D) """ ... - def index(self, arg1: AngleRangeList, arg2: AngleRange) -> int: - """ - - index( (AngleRangeList)arg1, (AngleRange)arg2) -> int : + @property + def x(self) -> Distance: ... - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::AngleRange) - """ - ... + @property + def y(self) -> Distance: ... - def insert(self, arg1: AngleRangeList, arg2: int, arg3: AngleRange) -> None: +class Distance2DList(_VectorSequence[Distance2D]): + ... + +class Distance3D: + def assign(self, arg1: Distance3D, other: Distance3D) -> Distance3D: """ - insert( (AngleRangeList)arg1, (int)arg2, (AngleRange)arg3) -> None : + assign( (Distance3D)arg1, (Distance3D)other) -> Distance3D : C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::AngleRange) + ad::physics::Distance3D {lvalue} assign(ad::physics::Distance3D {lvalue},ad::physics::Distance3D) """ ... - def reverse(self, arg1: AngleRangeList) -> None: - """ - - reverse( (AngleRangeList)arg1) -> None : + @property + def x(self) -> Distance: ... - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... + @property + def y(self) -> Distance: ... -class AngularAcceleration: @property - def Valid(self) -> bool: ... + def z(self) -> Distance: ... - def assign(self, arg1: AngularAcceleration, other: AngularAcceleration) -> AngularAcceleration: - """ +class Distance3DList(_VectorSequence[Distance3D]): + ... - assign( (AngularAcceleration)arg1, (AngularAcceleration)other) -> AngularAcceleration : +class DistanceList(_SortableSequence[Distance]): + ... - C++ signature : - ad::physics::AngularAcceleration {lvalue} assign(ad::physics::AngularAcceleration {lvalue},ad::physics::AngularAcceleration) - """ - ... +class DistanceSquared(_Calculable): - cMaxValue: float = 1000.0 + cMaxValue: float = 1e+18 - cMinValue: float = -1000.0 + cMinValue: float = -1e+18 - cPrecisionValue: float = 0.0001 + cPrecisionValue: float = 1e-06 - def ensureValid(self, arg1: AngularAcceleration) -> None: + +class DistanceSquaredList: + def append(self, arg1: DistanceSquaredList, arg2: DistanceSquared) -> None: """ - ensureValid( (AngularAcceleration)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::AngularAcceleration {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: AngularAcceleration) -> None: - """ - - ensureValidNonZero( (AngularAcceleration)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::AngularAcceleration {lvalue}) - """ - ... - - def getMax(self) -> AngularAcceleration: - """ - - getMax() -> AngularAcceleration : - - C++ signature : - ad::physics::AngularAcceleration getMax() - """ - ... - - def getMin(self) -> AngularAcceleration: - """ - - getMin() -> AngularAcceleration : - - C++ signature : - ad::physics::AngularAcceleration getMin() - """ - ... - - def getPrecision(self) -> AngularAcceleration: - """ - - getPrecision() -> AngularAcceleration : - - C++ signature : - ad::physics::AngularAcceleration getPrecision() - """ - ... - -class AngularAccelerationList: - def append(self, arg1: AngularAccelerationList, arg2: AngularAcceleration) -> None: - """ - - append( (AngularAccelerationList)arg1, (AngularAcceleration)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::AngularAcceleration) - """ - ... - - def count(self, arg1: AngularAccelerationList, arg2: AngularAcceleration) -> int: - """ - - count( (AngularAccelerationList)arg1, (AngularAcceleration)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::AngularAcceleration) - """ - ... - - def extend(self, arg1: AngularAccelerationList, arg2: object) -> None: - """ - - extend( (AngularAccelerationList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: AngularAccelerationList, arg2: AngularAcceleration) -> int: - """ - - index( (AngularAccelerationList)arg1, (AngularAcceleration)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::AngularAcceleration) - """ - ... - - def insert(self, arg1: AngularAccelerationList, arg2: int, arg3: AngularAcceleration) -> None: - """ - - insert( (AngularAccelerationList)arg1, (int)arg2, (AngularAcceleration)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::AngularAcceleration) - """ - ... - - def reverse(self, arg1: AngularAccelerationList) -> None: - """ - - reverse( (AngularAccelerationList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - - def sort(self, arg1: AngularAccelerationList) -> None: - """ - - sort( (AngularAccelerationList)arg1) -> None : - - C++ signature : - void sort(std::vector > {lvalue}) - """ - ... - -class AngularVelocity: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: AngularVelocity, other: AngularVelocity) -> AngularVelocity: - """ - - assign( (AngularVelocity)arg1, (AngularVelocity)other) -> AngularVelocity : - - C++ signature : - ad::physics::AngularVelocity {lvalue} assign(ad::physics::AngularVelocity {lvalue},ad::physics::AngularVelocity) - """ - ... - - cMaxValue: float = 1000.0 - - cMinValue: float = -1000.0 - - cPrecisionValue: float = 0.001 - - def ensureValid(self, arg1: AngularVelocity) -> None: - """ - - ensureValid( (AngularVelocity)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::AngularVelocity {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: AngularVelocity) -> None: - """ - - ensureValidNonZero( (AngularVelocity)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::AngularVelocity {lvalue}) - """ - ... - - def getMax(self) -> AngularVelocity: - """ - - getMax() -> AngularVelocity : - - C++ signature : - ad::physics::AngularVelocity getMax() - """ - ... - - def getMin(self) -> AngularVelocity: - """ - - getMin() -> AngularVelocity : - - C++ signature : - ad::physics::AngularVelocity getMin() - """ - ... - - def getPrecision(self) -> AngularVelocity: - """ - - getPrecision() -> AngularVelocity : - - C++ signature : - ad::physics::AngularVelocity getPrecision() - """ - ... - -class AngularVelocity3D: - def assign(self, arg1: AngularVelocity3D, other: AngularVelocity3D) -> AngularVelocity3D: - """ - - assign( (AngularVelocity3D)arg1, (AngularVelocity3D)other) -> AngularVelocity3D : - - C++ signature : - ad::physics::AngularVelocity3D {lvalue} assign(ad::physics::AngularVelocity3D {lvalue},ad::physics::AngularVelocity3D) - """ - ... - - @property - def x(self) -> AngularVelocity: ... - - @property - def y(self) -> AngularVelocity: ... - - @property - def z(self) -> AngularVelocity: ... - -class AngularVelocity3DList: - def append(self, arg1: AngularVelocity3DList, arg2: AngularVelocity3D) -> None: - """ - - append( (AngularVelocity3DList)arg1, (AngularVelocity3D)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::AngularVelocity3D) - """ - ... - - def count(self, arg1: AngularVelocity3DList, arg2: AngularVelocity3D) -> int: - """ - - count( (AngularVelocity3DList)arg1, (AngularVelocity3D)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::AngularVelocity3D) - """ - ... - - def extend(self, arg1: AngularVelocity3DList, arg2: object) -> None: - """ - - extend( (AngularVelocity3DList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: AngularVelocity3DList, arg2: AngularVelocity3D) -> int: - """ - - index( (AngularVelocity3DList)arg1, (AngularVelocity3D)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::AngularVelocity3D) - """ - ... - - def insert(self, arg1: AngularVelocity3DList, arg2: int, arg3: AngularVelocity3D) -> None: - """ - - insert( (AngularVelocity3DList)arg1, (int)arg2, (AngularVelocity3D)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::AngularVelocity3D) - """ - ... - - def reverse(self, arg1: AngularVelocity3DList) -> None: - """ - - reverse( (AngularVelocity3DList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - -class AngularVelocityList: - def append(self, arg1: AngularVelocityList, arg2: AngularVelocity) -> None: - """ - - append( (AngularVelocityList)arg1, (AngularVelocity)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::AngularVelocity) - """ - ... - - def count(self, arg1: AngularVelocityList, arg2: AngularVelocity) -> int: - """ - - count( (AngularVelocityList)arg1, (AngularVelocity)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::AngularVelocity) - """ - ... - - def extend(self, arg1: AngularVelocityList, arg2: object) -> None: - """ - - extend( (AngularVelocityList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: AngularVelocityList, arg2: AngularVelocity) -> int: - """ - - index( (AngularVelocityList)arg1, (AngularVelocity)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::AngularVelocity) - """ - ... - - def insert(self, arg1: AngularVelocityList, arg2: int, arg3: AngularVelocity) -> None: - """ - - insert( (AngularVelocityList)arg1, (int)arg2, (AngularVelocity)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::AngularVelocity) - """ - ... - - def reverse(self, arg1: AngularVelocityList) -> None: - """ - - reverse( (AngularVelocityList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - - def sort(self, arg1: AngularVelocityList) -> None: - """ - - sort( (AngularVelocityList)arg1) -> None : - - C++ signature : - void sort(std::vector > {lvalue}) - """ - ... - -class Dimension2D: - def assign(self, arg1: Dimension2D, other: Dimension2D) -> Dimension2D: - """ - - assign( (Dimension2D)arg1, (Dimension2D)other) -> Dimension2D : - - C++ signature : - ad::physics::Dimension2D {lvalue} assign(ad::physics::Dimension2D {lvalue},ad::physics::Dimension2D) - """ - ... - - @property - def length(self) -> Distance: ... - - @property - def width(self) -> Distance: ... - -class Dimension2DList: - def append(self, arg1: Dimension2DList, arg2: Dimension2D) -> None: - """ - - append( (Dimension2DList)arg1, (Dimension2D)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Dimension2D) - """ - ... - - def count(self, arg1: Dimension2DList, arg2: Dimension2D) -> int: - """ - - count( (Dimension2DList)arg1, (Dimension2D)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Dimension2D) - """ - ... - - def extend(self, arg1: Dimension2DList, arg2: object) -> None: - """ - - extend( (Dimension2DList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: Dimension2DList, arg2: Dimension2D) -> int: - """ - - index( (Dimension2DList)arg1, (Dimension2D)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Dimension2D) - """ - ... - - def insert(self, arg1: Dimension2DList, arg2: int, arg3: Dimension2D) -> None: - """ - - insert( (Dimension2DList)arg1, (int)arg2, (Dimension2D)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Dimension2D) - """ - ... - - def reverse(self, arg1: Dimension2DList) -> None: - """ - - reverse( (Dimension2DList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - -class Dimension3D: - def assign(self, arg1: Dimension3D, other: Dimension3D) -> Dimension3D: - """ - - assign( (Dimension3D)arg1, (Dimension3D)other) -> Dimension3D : - - C++ signature : - ad::physics::Dimension3D {lvalue} assign(ad::physics::Dimension3D {lvalue},ad::physics::Dimension3D) - """ - ... - - @property - def height(self) -> Distance: ... - - @property - def length(self) -> Distance: ... - - @property - def width(self) -> Distance: ... - -class Dimension3DList: - def append(self, arg1: Dimension3DList, arg2: Dimension3D) -> None: - """ - - append( (Dimension3DList)arg1, (Dimension3D)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Dimension3D) - """ - ... - - def count(self, arg1: Dimension3DList, arg2: Dimension3D) -> int: - """ - - count( (Dimension3DList)arg1, (Dimension3D)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Dimension3D) - """ - ... - - def extend(self, arg1: Dimension3DList, arg2: object) -> None: - """ - - extend( (Dimension3DList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: Dimension3DList, arg2: Dimension3D) -> int: - """ - - index( (Dimension3DList)arg1, (Dimension3D)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Dimension3D) - """ - ... - - def insert(self, arg1: Dimension3DList, arg2: int, arg3: Dimension3D) -> None: - """ - - insert( (Dimension3DList)arg1, (int)arg2, (Dimension3D)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Dimension3D) - """ - ... - - def reverse(self, arg1: Dimension3DList) -> None: - """ - - reverse( (Dimension3DList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - -class Distance(_FloatLike): - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: Distance, other: Distance) -> Distance: - """ - - assign( (Distance)arg1, (Distance)other) -> Distance : - - C++ signature : - ad::physics::Distance {lvalue} assign(ad::physics::Distance {lvalue},ad::physics::Distance) - """ - ... - - cMaxValue: float = 1000000000.0 - - cMinValue: float = -1000000000.0 - - cPrecisionValue: float = 0.001 - - def ensureValid(self, arg1: Distance) -> None: - """ - - ensureValid( (Distance)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::Distance {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: Distance) -> None: - """ - - ensureValidNonZero( (Distance)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::Distance {lvalue}) - """ - ... - - def getMax(self) -> Distance: - """ - - getMax() -> Distance : - - C++ signature : - ad::physics::Distance getMax() - """ - ... - - def getMin(self) -> Distance: - """ - - getMin() -> Distance : - - C++ signature : - ad::physics::Distance getMin() - """ - ... - - def getPrecision(self) -> Distance: - """ - - getPrecision() -> Distance : - - C++ signature : - ad::physics::Distance getPrecision() - """ - ... - -class Distance2D: - def assign(self, other: Distance2D) -> Distance2D: - """ - - assign( (Distance2D)arg1, (Distance2D)other) -> Distance2D : - - C++ signature : - ad::physics::Distance2D {lvalue} assign(ad::physics::Distance2D {lvalue},ad::physics::Distance2D) - """ - ... - - @property - def x(self) -> Distance: ... - - @property - def y(self) -> Distance: ... - -class Distance2DList: - def append(self, arg1: Distance2DList, arg2: Distance2D) -> None: - """ - - append( (Distance2DList)arg1, (Distance2D)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Distance2D) - """ - ... - - def count(self, arg1: Distance2DList, arg2: Distance2D) -> int: - """ - - count( (Distance2DList)arg1, (Distance2D)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Distance2D) - """ - ... - - def extend(self, arg1: Distance2DList, arg2: object) -> None: - """ - - extend( (Distance2DList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: Distance2DList, arg2: Distance2D) -> int: - """ - - index( (Distance2DList)arg1, (Distance2D)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Distance2D) - """ - ... - - def insert(self, arg1: Distance2DList, arg2: int, arg3: Distance2D) -> None: - """ - - insert( (Distance2DList)arg1, (int)arg2, (Distance2D)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Distance2D) - """ - ... - - def reverse(self, arg1: Distance2DList) -> None: - """ - - reverse( (Distance2DList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - -class Distance3D: - def assign(self, arg1: Distance3D, other: Distance3D) -> Distance3D: - """ - - assign( (Distance3D)arg1, (Distance3D)other) -> Distance3D : - - C++ signature : - ad::physics::Distance3D {lvalue} assign(ad::physics::Distance3D {lvalue},ad::physics::Distance3D) - """ - ... - - @property - def x(self) -> Distance: ... - - @property - def y(self) -> Distance: ... - - @property - def z(self) -> Distance: ... - -class Distance3DList: - def append(self, arg1: Distance3DList, arg2: Distance3D) -> None: - """ - - append( (Distance3DList)arg1, (Distance3D)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Distance3D) - """ - ... - - def count(self, arg1: Distance3DList, arg2: Distance3D) -> int: - """ - - count( (Distance3DList)arg1, (Distance3D)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Distance3D) - """ - ... - - def extend(self, arg1: Distance3DList, arg2: object) -> None: - """ - - extend( (Distance3DList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: Distance3DList, arg2: Distance3D) -> int: - """ - - index( (Distance3DList)arg1, (Distance3D)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Distance3D) - """ - ... - - def insert(self, arg1: Distance3DList, arg2: int, arg3: Distance3D) -> None: - """ - - insert( (Distance3DList)arg1, (int)arg2, (Distance3D)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Distance3D) - """ - ... - - def reverse(self, arg1: Distance3DList) -> None: - """ - - reverse( (Distance3DList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - -class DistanceList: - def append(self, arg1: DistanceList, arg2: Distance) -> None: - """ - - append( (DistanceList)arg1, (Distance)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Distance) - """ - ... - - def count(self, arg1: DistanceList, arg2: Distance) -> int: - """ - - count( (DistanceList)arg1, (Distance)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Distance) - """ - ... - - def extend(self, arg1: DistanceList, arg2: object) -> None: - """ - - extend( (DistanceList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: DistanceList, arg2: Distance) -> int: - """ - - index( (DistanceList)arg1, (Distance)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Distance) - """ - ... - - def insert(self, arg1: DistanceList, arg2: int, arg3: Distance) -> None: - """ - - insert( (DistanceList)arg1, (int)arg2, (Distance)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Distance) - """ - ... - - def reverse(self, arg1: DistanceList) -> None: - """ - - reverse( (DistanceList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - - def sort(self, arg1: DistanceList) -> None: - """ - - sort( (DistanceList)arg1) -> None : - - C++ signature : - void sort(std::vector > {lvalue}) - """ - ... - -class DistanceSquared: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: DistanceSquared, other: DistanceSquared) -> DistanceSquared: - """ - - assign( (DistanceSquared)arg1, (DistanceSquared)other) -> DistanceSquared : - - C++ signature : - ad::physics::DistanceSquared {lvalue} assign(ad::physics::DistanceSquared {lvalue},ad::physics::DistanceSquared) - """ - ... - - cMaxValue: float = 1e+18 - - cMinValue: float = -1e+18 - - cPrecisionValue: float = 1e-06 - - def ensureValid(self, arg1: DistanceSquared) -> None: - """ - - ensureValid( (DistanceSquared)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::DistanceSquared {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: DistanceSquared) -> None: - """ - - ensureValidNonZero( (DistanceSquared)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::DistanceSquared {lvalue}) - """ - ... - - def getMax(self) -> DistanceSquared: - """ - - getMax() -> DistanceSquared : - - C++ signature : - ad::physics::DistanceSquared getMax() - """ - ... - - def getMin(self) -> DistanceSquared: - """ - - getMin() -> DistanceSquared : - - C++ signature : - ad::physics::DistanceSquared getMin() - """ - ... - - def getPrecision(self) -> DistanceSquared: - """ - - getPrecision() -> DistanceSquared : - - C++ signature : - ad::physics::DistanceSquared getPrecision() - """ - ... - -class DistanceSquaredList: - def append(self, arg1: DistanceSquaredList, arg2: DistanceSquared) -> None: - """ - - append( (DistanceSquaredList)arg1, (DistanceSquared)arg2) -> None : + append( (DistanceSquaredList)arg1, (DistanceSquared)arg2) -> None : C++ signature : void append(std::vector > {lvalue},ad::physics::DistanceSquared) @@ -1442,274 +368,82 @@ class DistanceSquaredList: def count(self, arg1: DistanceSquaredList, arg2: DistanceSquared) -> int: """ - count( (DistanceSquaredList)arg1, (DistanceSquared)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::DistanceSquared) - """ - ... - - def extend(self, arg1: DistanceSquaredList, arg2: object) -> None: - """ - - extend( (DistanceSquaredList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: DistanceSquaredList, arg2: DistanceSquared) -> int: - """ - - index( (DistanceSquaredList)arg1, (DistanceSquared)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::DistanceSquared) - """ - ... - - def insert(self, arg1: DistanceSquaredList, arg2: int, arg3: DistanceSquared) -> None: - """ - - insert( (DistanceSquaredList)arg1, (int)arg2, (DistanceSquared)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::DistanceSquared) - """ - ... - - def reverse(self, arg1: DistanceSquaredList) -> None: - """ - - reverse( (DistanceSquaredList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - - def sort(self, arg1: DistanceSquaredList) -> None: - """ - - sort( (DistanceSquaredList)arg1) -> None : - - C++ signature : - void sort(std::vector > {lvalue}) - """ - ... - -class Duration: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: Duration, other: Duration) -> Duration: - """ - - assign( (Duration)arg1, (Duration)other) -> Duration : - - C++ signature : - ad::physics::Duration {lvalue} assign(ad::physics::Duration {lvalue},ad::physics::Duration) - """ - ... - - cMaxValue: float = 1000000.0 - - cMinValue: float = -1000000.0 - - cPrecisionValue: float = 0.001 - - def ensureValid(self, arg1: Duration) -> None: - """ - - ensureValid( (Duration)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::Duration {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: Duration) -> None: - """ - - ensureValidNonZero( (Duration)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::Duration {lvalue}) - """ - ... - - def getMax(self) -> Duration: - """ - - getMax() -> Duration : - - C++ signature : - ad::physics::Duration getMax() - """ - ... - - def getMin(self) -> Duration: - """ - - getMin() -> Duration : - - C++ signature : - ad::physics::Duration getMin() - """ - ... - - def getPrecision(self) -> Duration: - """ - - getPrecision() -> Duration : - - C++ signature : - ad::physics::Duration getPrecision() - """ - ... - -class DurationList: - def append(self, arg1: DurationList, arg2: Duration) -> None: - """ - - append( (DurationList)arg1, (Duration)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Duration) - """ - ... - - def count(self, arg1: DurationList, arg2: Duration) -> int: - """ - - count( (DurationList)arg1, (Duration)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Duration) - """ - ... - - def extend(self, arg1: DurationList, arg2: object) -> None: - """ - - extend( (DurationList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: DurationList, arg2: Duration) -> int: - """ - - index( (DurationList)arg1, (Duration)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Duration) - """ - ... - - def insert(self, arg1: DurationList, arg2: int, arg3: Duration) -> None: - """ - - insert( (DurationList)arg1, (int)arg2, (Duration)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Duration) - """ - ... - - def reverse(self, arg1: DurationList) -> None: - """ - - reverse( (DurationList)arg1) -> None : - - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - - def sort(self, arg1: DurationList) -> None: - """ - - sort( (DurationList)arg1) -> None : - - C++ signature : - void sort(std::vector > {lvalue}) - """ - ... - -class DurationSquared: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: DurationSquared, other: DurationSquared) -> DurationSquared: - """ - - assign( (DurationSquared)arg1, (DurationSquared)other) -> DurationSquared : + count( (DistanceSquaredList)arg1, (DistanceSquared)arg2) -> int : C++ signature : - ad::physics::DurationSquared {lvalue} assign(ad::physics::DurationSquared {lvalue},ad::physics::DurationSquared) + unsigned long count(std::vector > {lvalue},ad::physics::DistanceSquared) """ ... - cMaxValue: float = 1000000000000.0 - - cMinValue: float = -1000000000000.0 - - cPrecisionValue: float = 1e-06 - - def ensureValid(self, arg1: DurationSquared) -> None: + def extend(self, arg1: DistanceSquaredList, arg2: object) -> None: """ - ensureValid( (DurationSquared)arg1) -> None : + extend( (DistanceSquaredList)arg1, (object)arg2) -> None : C++ signature : - void ensureValid(ad::physics::DurationSquared {lvalue}) + void extend(std::vector > {lvalue},boost::python::api::object) """ ... - def ensureValidNonZero(self, arg1: DurationSquared) -> None: + def index(self, arg1: DistanceSquaredList, arg2: DistanceSquared) -> int: """ - ensureValidNonZero( (DurationSquared)arg1) -> None : + index( (DistanceSquaredList)arg1, (DistanceSquared)arg2) -> int : C++ signature : - void ensureValidNonZero(ad::physics::DurationSquared {lvalue}) + unsigned long index(std::vector > {lvalue},ad::physics::DistanceSquared) """ ... - def getMax(self) -> DurationSquared: + def insert(self, arg1: DistanceSquaredList, arg2: int, arg3: DistanceSquared) -> None: """ - getMax() -> DurationSquared : + insert( (DistanceSquaredList)arg1, (int)arg2, (DistanceSquared)arg3) -> None : C++ signature : - ad::physics::DurationSquared getMax() + void insert(std::vector > {lvalue},long,ad::physics::DistanceSquared) """ ... - def getMin(self) -> DurationSquared: + def reverse(self, arg1: DistanceSquaredList) -> None: """ - getMin() -> DurationSquared : + reverse( (DistanceSquaredList)arg1) -> None : C++ signature : - ad::physics::DurationSquared getMin() + void reverse(std::vector > {lvalue}) """ ... - def getPrecision(self) -> DurationSquared: + def sort(self, arg1: DistanceSquaredList) -> None: """ - getPrecision() -> DurationSquared : + sort( (DistanceSquaredList)arg1) -> None : C++ signature : - ad::physics::DurationSquared getPrecision() + void sort(std::vector > {lvalue}) """ ... +class Duration(_Calculable): + + cMaxValue: float = 1000000.0 + + cMinValue: float = -1000000.0 + + cPrecisionValue: float = 0.001 + +class DurationList(_SortableSequence[Duration]): + ... + +class DurationSquared(_Calculable): + + cMaxValue: float = 1000000000000.0 + + cMinValue: float = -1000000000000.0 + + cPrecisionValue: float = 1e-06 + class DurationSquaredList: def append(self, arg1: DurationSquaredList, arg2: DurationSquared) -> None: """ @@ -1937,19 +671,7 @@ class ParametricRangeList: """ ... -class ParametricValue: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: ParametricValue, other: ParametricValue) -> ParametricValue: - """ - - assign( (ParametricValue)arg1, (ParametricValue)other) -> ParametricValue : - - C++ signature : - ad::physics::ParametricValue {lvalue} assign(ad::physics::ParametricValue {lvalue},ad::physics::ParametricValue) - """ - ... +class ParametricValue(_Calculable): cMaxValue: float = ... @@ -1957,56 +679,6 @@ class ParametricValue: cPrecisionValue: float = 1e-06 - def ensureValid(self, arg1: ParametricValue) -> None: - """ - - ensureValid( (ParametricValue)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::ParametricValue {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: ParametricValue) -> None: - """ - - ensureValidNonZero( (ParametricValue)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::ParametricValue {lvalue}) - """ - ... - - def getMax(self) -> ParametricValue: - """ - - getMax() -> ParametricValue : - - C++ signature : - ad::physics::ParametricValue getMax() - """ - ... - - def getMin(self) -> ParametricValue: - """ - - getMin() -> ParametricValue : - - C++ signature : - ad::physics::ParametricValue getMin() - """ - ... - - def getPrecision(self) -> ParametricValue: - """ - - getPrecision() -> ParametricValue : - - C++ signature : - ad::physics::ParametricValue getPrecision() - """ - ... - class ParametricValueList: def append(self, arg1: ParametricValueList, arg2: ParametricValue) -> None: """ @@ -2078,19 +750,7 @@ class ParametricValueList: """ ... -class Probability: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: Probability, other: Probability) -> Probability: - """ - - assign( (Probability)arg1, (Probability)other) -> Probability : - - C++ signature : - ad::physics::Probability {lvalue} assign(ad::physics::Probability {lvalue},ad::physics::Probability) - """ - ... +class Probability(_Calculable): cMaxValue: float = ... @@ -2098,56 +758,6 @@ class Probability: cPrecisionValue: float = 1e-06 - def ensureValid(self, arg1: Probability) -> None: - """ - - ensureValid( (Probability)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::Probability {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: Probability) -> None: - """ - - ensureValidNonZero( (Probability)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::Probability {lvalue}) - """ - ... - - def getMax(self) -> Probability: - """ - - getMax() -> Probability : - - C++ signature : - ad::physics::Probability getMax() - """ - ... - - def getMin(self) -> Probability: - """ - - getMin() -> Probability : - - C++ signature : - ad::physics::Probability getMin() - """ - ... - - def getPrecision(self) -> Probability: - """ - - getPrecision() -> Probability : - - C++ signature : - ad::physics::Probability getPrecision() - """ - ... - class ProbabilityList: def append(self, arg1: ProbabilityList, arg2: Probability) -> None: """ @@ -2518,76 +1128,13 @@ class SpeedRangeList: """ ... -class SpeedSquared: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: SpeedSquared, other: SpeedSquared) -> SpeedSquared: - """ - - assign( (SpeedSquared)arg1, (SpeedSquared)other) -> SpeedSquared : - - C++ signature : - ad::physics::SpeedSquared {lvalue} assign(ad::physics::SpeedSquared {lvalue},ad::physics::SpeedSquared) - """ - ... - +class SpeedSquared(_Calculable): cMaxValue: float = 1000000.0 cMinValue: float = -1000000.0 cPrecisionValue: float = 1e-06 - def ensureValid(self, arg1: SpeedSquared) -> None: - """ - - ensureValid( (SpeedSquared)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::SpeedSquared {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: SpeedSquared) -> None: - """ - - ensureValidNonZero( (SpeedSquared)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::SpeedSquared {lvalue}) - """ - ... - - def getMax(self) -> SpeedSquared: - """ - - getMax() -> SpeedSquared : - - C++ signature : - ad::physics::SpeedSquared getMax() - """ - ... - - def getMin(self) -> SpeedSquared: - """ - - getMin() -> SpeedSquared : - - C++ signature : - ad::physics::SpeedSquared getMin() - """ - ... - - def getPrecision(self) -> SpeedSquared: - """ - - getPrecision() -> SpeedSquared : - - C++ signature : - ad::physics::SpeedSquared getPrecision() - """ - ... - class SpeedSquaredList: def append(self, arg1: SpeedSquaredList, arg2: SpeedSquared) -> None: """ @@ -2679,80 +1226,10 @@ class Velocity: @property def z(self) -> Speed: ... -class VelocityList: - def append(self, arg1: VelocityList, arg2: Velocity) -> None: - """ - - append( (VelocityList)arg1, (Velocity)arg2) -> None : - - C++ signature : - void append(std::vector > {lvalue},ad::physics::Velocity) - """ - ... - - def count(self, arg1: VelocityList, arg2: Velocity) -> int: - """ - - count( (VelocityList)arg1, (Velocity)arg2) -> int : - - C++ signature : - unsigned long count(std::vector > {lvalue},ad::physics::Velocity) - """ - ... - - def extend(self, arg1: VelocityList, arg2: object) -> None: - """ - - extend( (VelocityList)arg1, (object)arg2) -> None : - - C++ signature : - void extend(std::vector > {lvalue},boost::python::api::object) - """ - ... - - def index(self, arg1: VelocityList, arg2: Velocity) -> int: - """ - - index( (VelocityList)arg1, (Velocity)arg2) -> int : - - C++ signature : - unsigned long index(std::vector > {lvalue},ad::physics::Velocity) - """ - ... - - def insert(self, arg1: VelocityList, arg2: int, arg3: Velocity) -> None: - """ - - insert( (VelocityList)arg1, (int)arg2, (Velocity)arg3) -> None : - - C++ signature : - void insert(std::vector > {lvalue},long,ad::physics::Velocity) - """ - ... - - def reverse(self, arg1: VelocityList) -> None: - """ - - reverse( (VelocityList)arg1) -> None : +class VelocityList(_VectorSequence[Velocity]): + ... - C++ signature : - void reverse(std::vector > {lvalue}) - """ - ... - -class Weight: - @property - def Valid(self) -> bool: ... - - def assign(self, arg1: Weight, other: Weight) -> Weight: - """ - - assign( (Weight)arg1, (Weight)other) -> Weight : - - C++ signature : - ad::physics::Weight {lvalue} assign(ad::physics::Weight {lvalue},ad::physics::Weight) - """ - ... +class Weight(_Calculable): cMaxValue: float = ... @@ -2760,56 +1237,6 @@ class Weight: cPrecisionValue: float = 0.001 - def ensureValid(self, arg1: Weight) -> None: - """ - - ensureValid( (Weight)arg1) -> None : - - C++ signature : - void ensureValid(ad::physics::Weight {lvalue}) - """ - ... - - def ensureValidNonZero(self, arg1: Weight) -> None: - """ - - ensureValidNonZero( (Weight)arg1) -> None : - - C++ signature : - void ensureValidNonZero(ad::physics::Weight {lvalue}) - """ - ... - - def getMax(self) -> Weight: - """ - - getMax() -> Weight : - - C++ signature : - ad::physics::Weight getMax() - """ - ... - - def getMin(self) -> Weight: - """ - - getMin() -> Weight : - - C++ signature : - ad::physics::Weight getMin() - """ - ... - - def getPrecision(self) -> Weight: - """ - - getPrecision() -> Weight : - - C++ signature : - ad::physics::Weight getPrecision() - """ - ... - class WeightList: def append(self, arg1: WeightList, arg2: Weight) -> None: """ diff --git a/PythonAPI/carla/source/carla/ad/rss/state.pyi b/PythonAPI/carla/source/carla/ad/rss/state.pyi index 669edea9f05..a8b1e4e1393 100644 --- a/PythonAPI/carla/source/carla/ad/rss/state.pyi +++ b/PythonAPI/carla/source/carla/ad/rss/state.pyi @@ -1,3 +1,4 @@ +from typing import Self from ... import ad from ...libcarla import _CarlaEnum from . import * @@ -31,22 +32,27 @@ class AccelerationRestriction(): @property def longitudinalRange(self) -> ad.physics.AccelerationRange: ... -class HeadingRange(): - def assign(self, arg1: HeadingRange, other: HeadingRange) -> HeadingRange: - ''' +class HeadingRange(ad._Assignable): + + def __init__(self, other: HeadingRange | None = None) -> None: + ... - assign( (HeadingRange)arg1, (HeadingRange)other) -> HeadingRange : + @property + def begin(self) -> ad.physics.Angle: + ... - C++ signature : - ad::rss::state::HeadingRange {lvalue} assign(ad::rss::state::HeadingRange {lvalue},ad::rss::state::HeadingRange) - ''' + @begin.setter + def begin(self, value: ad.physics.Angle | float) -> None: ... @property - def begin(self) -> ad.physics.Angle: ... + def end(self) -> ad.physics.Angle: + ... + + @end.setter + def end(self, value: ad.physics.Angle | float) -> None: + ... - @property - def end(self) -> ad.physics.Angle: ... class HeadingRangeVector(ad._Vector[HeadingRange]): def append(self, arg1: HeadingRangeVector, arg2: HeadingRange) -> None: diff --git a/PythonAPI/carla/source/carla/ad/rss/unstructured.pyi b/PythonAPI/carla/source/carla/ad/rss/unstructured.pyi index f7367bd2955..f8229a9e898 100644 --- a/PythonAPI/carla/source/carla/ad/rss/unstructured.pyi +++ b/PythonAPI/carla/source/carla/ad/rss/unstructured.pyi @@ -1,4 +1,7 @@ -from ad import _Vector +from typing import overload +from ... import ad +from .. import _Vector +from . import * class DebugDrawing: class DebugLine: @@ -90,3 +93,139 @@ class vector_less_ad_scope_rss_scope_unstructured_scope_DebugDrawing_scope_Debug class vector_less_ad_scope_rss_scope_unstructured_scope_DebugDrawing_scope_DebugPolygon_greater_(_Vector[DebugDrawing.DebugPolygon]): ... + +def collides(trajectorySet1: ad.physics.Distance2DList, trajectorySet2: ad.physics.Distance2DList): + """ + collides( (Distance2DList)trajectorySet1, (Distance2DList)trajectorySet2) -> bool : + + C++ signature : + bool collides(std::vector >,std::vector >)""" +def combinePolygon(*args, **kwargs): + """ + combinePolygon( (object)a, (object)b, (object)result) -> bool : + + C++ signature : + bool combinePolygon(boost::geometry::model::polygon, false, true, std::vector, std::vector, std::allocator, std::allocator>,boost::geometry::model::polygon, false, true, std::vector, std::vector, std::allocator, std::allocator>,boost::geometry::model::polygon, false, true, std::vector, std::vector, std::allocator, std::allocator> {lvalue})""" +def getCircleOrigin(*args, **kwargs): + """ + getCircleOrigin( (object)point, (Distance)radius, (Angle)angle) -> object : + + C++ signature : + boost::geometry::model::d2::point_xy getCircleOrigin(boost::geometry::model::d2::point_xy,ad::physics::Distance,ad::physics::Angle)""" + +@overload +def getHeadingOverlap(a: state.HeadingRange, b: state.HeadingRange, overlapRanges: state.HeadingRangeVector) -> bool: + """ + get the overlap between two angle ranges + [out] : overlapRanges + + getHeadingOverlap( (HeadingRange)a, (HeadingRange)b, (HeadingRangeVector)overlapRanges) -> bool : + + C++ signature : + bool getHeadingOverlap(ad::rss::state::HeadingRange,ad::rss::state::HeadingRange,std::vector > {lvalue}) + + getHeadingOverlap( (HeadingRange)headingRange, (HeadingRangeVector)overlapRanges) -> bool : + + C++ signature : + bool getHeadingOverlap(ad::rss::state::HeadingRange,std::vector > {lvalue})""" + +@overload +def getHeadingOverlap(headingRange: state.HeadingRange, overlapRanges: state.HeadingRangeVector) -> bool: + """ + get the overlap between an angle range and a heading range + [in,out]: overlapRanges + + getHeadingOverlap( (HeadingRange)a, (HeadingRange)b, (HeadingRangeVector)overlapRanges) -> bool : + + C++ signature : + bool getHeadingOverlap(ad::rss::state::HeadingRange,ad::rss::state::HeadingRange,std::vector > {lvalue}) + + getHeadingOverlap( (HeadingRange)headingRange, (HeadingRangeVector)overlapRanges) -> bool : + + C++ signature : + bool getHeadingOverlap(ad::rss::state::HeadingRange,std::vector > {lvalue})""" + + +def getPointOnCircle(origin: Unknown, radius: ad.physics.Distance, angle: ad.physics.Angle) -> Unknown: + """ + getPointOnCircle( (object)origin, (Distance)radius, (Angle)angle) -> object : + + C++ signature : + boost::geometry::model::d2::point_xy getPointOnCircle(boost::geometry::model::d2::point_xy,ad::physics::Distance,ad::physics::Angle)""" +def isInsideHeadingRange(angle: ad.physics.Angle, range: ad.rss.state.HeadingRange): + """ + isInsideHeadingRange( (Angle)angle, (HeadingRange)range) -> bool : + + C++ signature : + bool isInsideHeadingRange(ad::physics::Angle,ad::rss::state::HeadingRange)""" +def rotateAroundPoint(*args, **kwargs): + """ + rotateAroundPoint( (object)origin, (object)relativePoint, (Angle)angle) -> object : + + C++ signature : + boost::geometry::model::d2::point_xy rotateAroundPoint(boost::geometry::model::d2::point_xy,boost::geometry::model::d2::point_xy,ad::physics::Angle)""" +def toDistance(*args, **kwargs): + """ + toDistance( (object)point) -> Distance2D : + + C++ signature : + ad::physics::Distance2D toDistance(boost::geometry::model::d2::point_xy)""" + + +@overload +def toPoint(distance: ad.physics.Distance2D) -> Unknown: + """ + toPoint( (Distance2D)distance) -> object : + + C++ signature : + boost::geometry::model::d2::point_xy toPoint(ad::physics::Distance2D) + + toPoint( (Distance)distanceX, (Distance)distanceY) -> object : + + C++ signature : + boost::geometry::model::d2::point_xy toPoint(ad::physics::Distance,ad::physics::Distance) + """ + +@overload +def toPoint(distanceX: ad.physics.Distance, distanceY: ad.physics.Distance) -> Unknown: + """ + toPoint( (Distance2D)distance) -> object : + + C++ signature : + boost::geometry::model::d2::point_xy toPoint(ad::physics::Distance2D) + + toPoint( (Distance)distanceX, (Distance)distanceY) -> object : + + C++ signature : + boost::geometry::model::d2::point_xy toPoint(ad::physics::Distance,ad::physics::Distance) + """ + +def toPolygon(trajectorySet: ad.physics.Distance2DList, polygon): + """ + toPolygon( (Distance2DList)trajectorySet, (object)polygon) -> None : + + C++ signature : + void toPolygon(std::vector >,boost::geometry::model::polygon, false, true, std::vector, std::vector, std::allocator, std::allocator> {lvalue})""" +def toTrajectorySet(polygon, trajectorySet: ad.physics.Distance2DList) -> None: + """ + toTrajectorySet( (object)polygon, (Distance2DList)trajectorySet) -> None : + + C++ signature : + void toTrajectorySet(boost::geometry::model::polygon, false, true, std::vector, std::vector, std::allocator, std::allocator>,std::vector > {lvalue})""" + +def to_string(value: object) -> str: + """ + to_string( (object)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(boost::geometry::model::d2::point_xy) + + to_string( (object)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(boost::geometry::model::polygon, false, true, std::vector, std::vector, std::allocator, std::allocator>) + + to_string( (object)value) -> str : + + C++ signature : + std::__cxx11::basic_string, std::allocator > to_string(boost::geometry::model::linestring, std::vector, std::allocator>)""" diff --git a/PythonAPI/carla/source/carla/command.pyi b/PythonAPI/carla/source/carla/command.pyi index bafa68bfffa..24d0f2c46db 100644 --- a/PythonAPI/carla/source/carla/command.pyi +++ b/PythonAPI/carla/source/carla/command.pyi @@ -5,6 +5,9 @@ and `carla.Client.apply_batch_sync`. # needs change in API # pylint: disable=too-many-locals,too-many-public-methods,too-many-arguments,too-many-public-methods,too-few-public-methods,too-many-lines # Fixable low-priority +# pylint: disable=line-too-long,R0801# needs change in API +# pylint: disable=too-many-locals,too-many-public-methods,too-many-arguments,too-many-public-methods,too-few-public-methods,too-many-lines +# Fixable low-priority # pylint: disable=line-too-long,R0801 from typing import ( # pylint: disable=no-name-in-module diff --git a/PythonAPI/carla/source/carla/libcarla.pyi b/PythonAPI/carla/source/carla/libcarla.pyi index ead8944bf96..3d1db5606ab 100644 --- a/PythonAPI/carla/source/carla/libcarla.pyi +++ b/PythonAPI/carla/source/carla/libcarla.pyi @@ -14,7 +14,7 @@ # Should only trigger for class name used in itself # pylint: disable=undefined-variable # -# ruff: noqa: F401,F405,F403 +# ruff: noqa: F401,F403,F405 # ------------------------------- import sys @@ -105,8 +105,8 @@ class _CarlaEnum(Enum): """The value attribute is not available in CARLA's enums.""" def __init_subclass__(cls) -> None: - cls.values: dict[int, cls] # noqa: B032 - cls.names: dict[str, cls] # noqa: B032 + cls.values: dict[int, Self] # noqa: B032 + cls.names: dict[str, Self] # noqa: B032 # pylint: disable=function-redefined class AckermannControllerSettings: