GeezerVison is showing ebadi.github.io (truncated) — python-esmini 0.0.1 documentation

python-esmini Documentation¶

Road Manager¶

Bindings for ::roadmanager namespace

pyroadmanager.roadmanager.CheckOverlapingOSIPoints(first_set: pyroadmanager.roadmanager.OSIPoints, second_set: pyroadmanager.roadmanager.OSIPoints, tolerance: float) → int ¶: function that checks if two sets of osi points has the same start/end

the number of points that are within tolerance (0,1 or 2)

C++: roadmanager::CheckOverlapingOSIPoints(class roadmanager::OSIPoints *, class roadmanager::OSIPoints *, double) –> int

class pyroadmanager.roadmanager.ContactPointType¶

Members:

CONTACT_POINT_UNKNOWN

CONTACT_POINT_START

CONTACT_POINT_END

CONTACT_POINT_NONE

property name¶

class pyroadmanager.roadmanager.CoordinateSystem¶

Members:

CS_UNDEFINED

CS_ENTITY

CS_LANE

CS_ROAD

CS_TRAJECTORY

property name¶

pyroadmanager.roadmanager.GetNewGlobalLaneBoundaryId() → int ¶: C++: roadmanager::GetNewGlobalLaneBoundaryId() –> int

pyroadmanager.roadmanager.GetNewGlobalLaneId() → int ¶: C++: roadmanager::GetNewGlobalLaneId() –> int

class pyroadmanager.roadmanager.NurbsShape¶

This nurbs implementation is strongly inspired by the “Nurbs Curve Example” at: https://nccastaff.bournemouth.ac.uk/jmacey/OldWeb/RobTheBloke/www/opengl_programming.html

AddControlPoint(self: pyroadmanager.roadmanager.NurbsShape, pos: pyroadmanager.roadmanager.Position, time: float, weight: float, calcHeading: bool) → None ¶: C++: roadmanager::NurbsShape::AddControlPoint(class roadmanager::Position, double, double, bool) –> void

CalculatePolyLine(self: pyroadmanager.roadmanager.NurbsShape) → None ¶: C++: roadmanager::NurbsShape::CalculatePolyLine() –> void

GetDuration(self: pyroadmanager.roadmanager.NurbsShape) → float ¶: C++: roadmanager::NurbsShape::GetDuration() –> double

GetLength(self: pyroadmanager.roadmanager.NurbsShape) → float ¶: C++: roadmanager::NurbsShape::GetLength() –> double

GetStartTime(self: pyroadmanager.roadmanager.NurbsShape) → float ¶: C++: roadmanager::NurbsShape::GetStartTime() –> double

assign(self: pyroadmanager.roadmanager.NurbsShape, : pyroadmanager.roadmanager.NurbsShape) → pyroadmanager.roadmanager.NurbsShape ¶: C++: roadmanager::NurbsShape::operator=(const class roadmanager::NurbsShape &) –> class roadmanager::NurbsShape &

class pyroadmanager.roadmanager.RelativeDistanceType¶

Members:

REL_DIST_UNDEFINED

REL_DIST_LATERAL

REL_DIST_LONGITUDINAL

REL_DIST_CARTESIAN

REL_DIST_EUCLIDIAN

property name¶

class pyroadmanager.roadmanager.Polynomial¶

Evaluate(self: pyroadmanager.roadmanager.Polynomial, s: float) → float ¶: C++: roadmanager::Polynomial::Evaluate(double) –> double

EvaluatePrim(self: pyroadmanager.roadmanager.Polynomial, s: float) → float ¶: C++: roadmanager::Polynomial::EvaluatePrim(double) –> double

EvaluatePrimPrim(self: pyroadmanager.roadmanager.Polynomial, s: float) → float ¶: C++: roadmanager::Polynomial::EvaluatePrimPrim(double) –> double

GetA(self: pyroadmanager.roadmanager.Polynomial) → float ¶: C++: roadmanager::Polynomial::GetA() –> double

GetB(self: pyroadmanager.roadmanager.Polynomial) → float ¶: C++: roadmanager::Polynomial::GetB() –> double

GetC(self: pyroadmanager.roadmanager.Polynomial) → float ¶: C++: roadmanager::Polynomial::GetC() –> double

GetD(self: pyroadmanager.roadmanager.Polynomial) → float ¶: C++: roadmanager::Polynomial::GetD() –> double

GetPscale(self: pyroadmanager.roadmanager.Polynomial) → float ¶: C++: roadmanager::Polynomial::GetPscale() –> double

Set(*args, **kwargs)¶

Overloaded function.

Set(self: pyroadmanager.roadmanager.Polynomial, a: float, b: float, c: float, d: float) -> None
Set(self: pyroadmanager.roadmanager.Polynomial, a: float, b: float, c: float, d: float, p_scale: float) -> None

C++: roadmanager::Polynomial::Set(double, double, double, double, double) –> void

SetA(self: pyroadmanager.roadmanager.Polynomial, a: float) → None ¶: C++: roadmanager::Polynomial::SetA(double) –> void

SetB(self: pyroadmanager.roadmanager.Polynomial, b: float) → None ¶: C++: roadmanager::Polynomial::SetB(double) –> void

SetC(self: pyroadmanager.roadmanager.Polynomial, c: float) → None ¶: C++: roadmanager::Polynomial::SetC(double) –> void

SetD(self: pyroadmanager.roadmanager.Polynomial, d: float) → None ¶: C++: roadmanager::Polynomial::SetD(double) –> void

assign(self: pyroadmanager.roadmanager.Polynomial, : pyroadmanager.roadmanager.Polynomial) → pyroadmanager.roadmanager.Polynomial ¶: C++: roadmanager::Polynomial::operator=(const class roadmanager::Polynomial &) –> class roadmanager::Polynomial &

class pyroadmanager.roadmanager.OSIPoints¶

GetLength(self: pyroadmanager.roadmanager.OSIPoints) → float ¶: C++: roadmanager::OSIPoints::GetLength() –> double

GetNumOfOSIPoints(self: pyroadmanager.roadmanager.OSIPoints) → int ¶: C++: roadmanager::OSIPoints::GetNumOfOSIPoints() –> int

GetXfromIdx(self: pyroadmanager.roadmanager.OSIPoints, i: int) → float ¶: C++: roadmanager::OSIPoints::GetXfromIdx(int) –> double

GetYfromIdx(self: pyroadmanager.roadmanager.OSIPoints, i: int) → float ¶: C++: roadmanager::OSIPoints::GetYfromIdx(int) –> double

GetZfromIdx(self: pyroadmanager.roadmanager.OSIPoints, i: int) → float ¶: C++: roadmanager::OSIPoints::GetZfromIdx(int) –> double

class pyroadmanager.roadmanager.Geometry¶

EvaluateCurvatureDS(self: pyroadmanager.roadmanager.Geometry, ds: float) → float ¶: C++: roadmanager::Geometry::EvaluateCurvatureDS(double) –> double

EvaluateDS(self: pyroadmanager.roadmanager.Geometry, ds: float, x: float, y: float, h: float) → None ¶: C++: roadmanager::Geometry::EvaluateDS(double, double *, double *, double *) –> void

GetHdg(self: pyroadmanager.roadmanager.Geometry) → float ¶: C++: roadmanager::Geometry::GetHdg() –> double

GetLength(self: pyroadmanager.roadmanager.Geometry) → float ¶: C++: roadmanager::Geometry::GetLength() –> double

GetS(self: pyroadmanager.roadmanager.Geometry) → float ¶: C++: roadmanager::Geometry::GetS() –> double

GetType(self: pyroadmanager.roadmanager.Geometry) → roadmanager::Geometry::GeometryType¶: C++: roadmanager::Geometry::GetType() –> roadmanager::Geometry::GeometryType

GetX(self: pyroadmanager.roadmanager.Geometry) → float ¶: C++: roadmanager::Geometry::GetX() –> double

GetY(self: pyroadmanager.roadmanager.Geometry) → float ¶: C++: roadmanager::Geometry::GetY() –> double

Print(self: pyroadmanager.roadmanager.Geometry) → None ¶: C++: roadmanager::Geometry::Print() –> void

SetHdg(self: pyroadmanager.roadmanager.Geometry, hdg: float) → None ¶: C++: roadmanager::Geometry::SetHdg(double) –> void

SetX(self: pyroadmanager.roadmanager.Geometry, x: float) → None ¶: C++: roadmanager::Geometry::SetX(double) –> void

SetY(self: pyroadmanager.roadmanager.Geometry, y: float) → None ¶: C++: roadmanager::Geometry::SetY(double) –> void

assign(self: pyroadmanager.roadmanager.Geometry, : pyroadmanager.roadmanager.Geometry) → pyroadmanager.roadmanager.Geometry ¶: C++: roadmanager::Geometry::operator=(const class roadmanager::Geometry &) –> class roadmanager::Geometry &

class pyroadmanager.roadmanager.Line¶

EvaluateCurvatureDS(self: pyroadmanager.roadmanager.Line, ds: float) → float ¶: C++: roadmanager::Line::EvaluateCurvatureDS(double) –> double

EvaluateDS(self: pyroadmanager.roadmanager.Line, ds: float, x: float, y: float, h: float) → None ¶: C++: roadmanager::Line::EvaluateDS(double, double *, double *, double *) –> void

Print(self: pyroadmanager.roadmanager.Line) → None ¶: C++: roadmanager::Line::Print() –> void

assign(self: pyroadmanager.roadmanager.Line, : pyroadmanager.roadmanager.Line) → pyroadmanager.roadmanager.Line ¶: C++: roadmanager::Line::operator=(const class roadmanager::Line &) –> class roadmanager::Line &

class pyroadmanager.roadmanager.Arc¶

EvaluateCurvatureDS(self: pyroadmanager.roadmanager.Arc, ds: float) → float ¶: C++: roadmanager::Arc::EvaluateCurvatureDS(double) –> double

EvaluateDS(self: pyroadmanager.roadmanager.Arc, ds: float, x: float, y: float, h: float) → None ¶: C++: roadmanager::Arc::EvaluateDS(double, double *, double *, double *) –> void

GetCurvature(self: pyroadmanager.roadmanager.Arc) → float ¶: C++: roadmanager::Arc::GetCurvature() –> double

GetRadius(self: pyroadmanager.roadmanager.Arc) → float ¶: C++: roadmanager::Arc::GetRadius() –> double

Print(self: pyroadmanager.roadmanager.Arc) → None ¶: C++: roadmanager::Arc::Print() –> void

assign(self: pyroadmanager.roadmanager.Arc, : pyroadmanager.roadmanager.Arc) → pyroadmanager.roadmanager.Arc ¶: C++: roadmanager::Arc::operator=(const class roadmanager::Arc &) –> class roadmanager::Arc &

class pyroadmanager.roadmanager.Spiral¶

EvaluateCurvatureDS(self: pyroadmanager.roadmanager.Spiral, ds: float) → float ¶: C++: roadmanager::Spiral::EvaluateCurvatureDS(double) –> double

EvaluateDS(self: pyroadmanager.roadmanager.Spiral, ds: float, x: float, y: float, h: float) → None ¶: C++: roadmanager::Spiral::EvaluateDS(double, double *, double *, double *) –> void

GetCDot(self: pyroadmanager.roadmanager.Spiral) → float ¶: C++: roadmanager::Spiral::GetCDot() –> double

GetCurvEnd(self: pyroadmanager.roadmanager.Spiral) → float ¶: C++: roadmanager::Spiral::GetCurvEnd() –> double

GetCurvStart(self: pyroadmanager.roadmanager.Spiral) → float ¶: C++: roadmanager::Spiral::GetCurvStart() –> double

GetH0(self: pyroadmanager.roadmanager.Spiral) → float ¶: C++: roadmanager::Spiral::GetH0() –> double

GetS0(self: pyroadmanager.roadmanager.Spiral) → float ¶: C++: roadmanager::Spiral::GetS0() –> double

GetX0(self: pyroadmanager.roadmanager.Spiral) → float ¶: C++: roadmanager::Spiral::GetX0() –> double

GetY0(self: pyroadmanager.roadmanager.Spiral) → float ¶: C++: roadmanager::Spiral::GetY0() –> double

Print(self: pyroadmanager.roadmanager.Spiral) → None ¶: C++: roadmanager::Spiral::Print() –> void

SetCDot(self: pyroadmanager.roadmanager.Spiral, c_dot: float) → None ¶: C++: roadmanager::Spiral::SetCDot(double) –> void

SetH0(self: pyroadmanager.roadmanager.Spiral, h0: float) → None ¶: C++: roadmanager::Spiral::SetH0(double) –> void

SetHdg(self: pyroadmanager.roadmanager.Spiral, h: float) → None ¶: C++: roadmanager::Spiral::SetHdg(double) –> void

SetS0(self: pyroadmanager.roadmanager.Spiral, s0: float) → None ¶: C++: roadmanager::Spiral::SetS0(double) –> void

SetX(self: pyroadmanager.roadmanager.Spiral, x: float) → None ¶: C++: roadmanager::Spiral::SetX(double) –> void

SetX0(self: pyroadmanager.roadmanager.Spiral, x0: float) → None ¶: C++: roadmanager::Spiral::SetX0(double) –> void

SetY(self: pyroadmanager.roadmanager.Spiral, y: float) → None ¶: C++: roadmanager::Spiral::SetY(double) –> void

SetY0(self: pyroadmanager.roadmanager.Spiral, y0: float) → None ¶: C++: roadmanager::Spiral::SetY0(double) –> void

assign(self: pyroadmanager.roadmanager.Spiral, : pyroadmanager.roadmanager.Spiral) → pyroadmanager.roadmanager.Spiral ¶: C++: roadmanager::Spiral::operator=(const class roadmanager::Spiral &) –> class roadmanager::Spiral &

class pyroadmanager.roadmanager.Poly3¶

EvaluateCurvatureDS(self: pyroadmanager.roadmanager.Poly3, ds: float) → float ¶: C++: roadmanager::Poly3::EvaluateCurvatureDS(double) –> double

EvaluateDS(self: pyroadmanager.roadmanager.Poly3, ds: float, x: float, y: float, h: float) → None ¶: C++: roadmanager::Poly3::EvaluateDS(double, double *, double *, double *) –> void

GetPoly3(self: pyroadmanager.roadmanager.Poly3) → pyroadmanager.roadmanager.Polynomial ¶: C++: roadmanager::Poly3::GetPoly3() –> class roadmanager::Polynomial

GetUMax(self: pyroadmanager.roadmanager.Poly3) → float ¶: C++: roadmanager::Poly3::GetUMax() –> double

Print(self: pyroadmanager.roadmanager.Poly3) → None ¶: C++: roadmanager::Poly3::Print() –> void

SetUMax(self: pyroadmanager.roadmanager.Poly3, umax: float) → None ¶: C++: roadmanager::Poly3::SetUMax(double) –> void

assign(self: pyroadmanager.roadmanager.Poly3, : pyroadmanager.roadmanager.Poly3) → pyroadmanager.roadmanager.Poly3 ¶: C++: roadmanager::Poly3::operator=(const class roadmanager::Poly3 &) –> class roadmanager::Poly3 &

class pyroadmanager.roadmanager.ParamPoly3¶

EvaluateCurvatureDS(self: pyroadmanager.roadmanager.ParamPoly3, ds: float) → float ¶: C++: roadmanager::ParamPoly3::EvaluateCurvatureDS(double) –> double

EvaluateDS(self: pyroadmanager.roadmanager.ParamPoly3, ds: float, x: float, y: float, h: float) → None ¶: C++: roadmanager::ParamPoly3::EvaluateDS(double, double *, double *, double *) –> void

GetPoly3U(self: pyroadmanager.roadmanager.ParamPoly3) → pyroadmanager.roadmanager.Polynomial ¶: C++: roadmanager::ParamPoly3::GetPoly3U() –> class roadmanager::Polynomial

GetPoly3V(self: pyroadmanager.roadmanager.ParamPoly3) → pyroadmanager.roadmanager.Polynomial ¶: C++: roadmanager::ParamPoly3::GetPoly3V() –> class roadmanager::Polynomial

class PRangeType¶

Members:

P_RANGE_UNKNOWN

P_RANGE_NORMALIZED

P_RANGE_ARC_LENGTH

property name¶

Print(self: pyroadmanager.roadmanager.ParamPoly3) → None ¶: C++: roadmanager::ParamPoly3::Print() –> void

S2P(self: pyroadmanager.roadmanager.ParamPoly3, s: float) → float ¶: C++: roadmanager::ParamPoly3::S2P(double) –> double

assign(self: pyroadmanager.roadmanager.ParamPoly3, : pyroadmanager.roadmanager.ParamPoly3) → pyroadmanager.roadmanager.ParamPoly3 ¶: C++: roadmanager::ParamPoly3::operator=(const class roadmanager::ParamPoly3 &) –> class roadmanager::ParamPoly3 &

calcS2PMap(self: pyroadmanager.roadmanager.ParamPoly3, p_range: pyroadmanager.roadmanager.ParamPoly3.PRangeType) → None ¶: C++: roadmanager::ParamPoly3::calcS2PMap(enum roadmanager::ParamPoly3::PRangeType) –> void

class pyroadmanager.roadmanager.Elevation¶

GetLength(self: pyroadmanager.roadmanager.Elevation) → float ¶: C++: roadmanager::Elevation::GetLength() –> double

GetS(self: pyroadmanager.roadmanager.Elevation) → float ¶: C++: roadmanager::Elevation::GetS() –> double

Print(self: pyroadmanager.roadmanager.Elevation) → None ¶: C++: roadmanager::Elevation::Print() –> void

SetLength(self: pyroadmanager.roadmanager.Elevation, length: float) → None ¶: C++: roadmanager::Elevation::SetLength(double) –> void

class pyroadmanager.roadmanager.LaneLink¶

GetId(self: pyroadmanager.roadmanager.LaneLink) → int ¶: C++: roadmanager::LaneLink::GetId() –> int

GetType(self: pyroadmanager.roadmanager.LaneLink) → roadmanager::LinkType¶: C++: roadmanager::LaneLink::GetType() –> roadmanager::LinkType

Print(self: pyroadmanager.roadmanager.LaneLink) → None ¶: C++: roadmanager::LaneLink::Print() –> void

class pyroadmanager.roadmanager.LaneWidth¶

GetSOffset(self: pyroadmanager.roadmanager.LaneWidth) → float ¶: C++: roadmanager::LaneWidth::GetSOffset() –> double

Print(self: pyroadmanager.roadmanager.LaneWidth) → None ¶: C++: roadmanager::LaneWidth::Print() –> void

class pyroadmanager.roadmanager.LaneBoundaryOSI¶

GetGlobalId(self: pyroadmanager.roadmanager.LaneBoundaryOSI) → int ¶: C++: roadmanager::LaneBoundaryOSI::GetGlobalId() –> int

GetOSIPoints(self: pyroadmanager.roadmanager.LaneBoundaryOSI) → pyroadmanager.roadmanager.OSIPoints ¶: C++: roadmanager::LaneBoundaryOSI::GetOSIPoints() –> class roadmanager::OSIPoints *

SetGlobalId(self: pyroadmanager.roadmanager.LaneBoundaryOSI) → None ¶: C++: roadmanager::LaneBoundaryOSI::SetGlobalId() –> void

class pyroadmanager.roadmanager.RoadMarkInfo¶

class pyroadmanager.roadmanager.LaneRoadMarkTypeLine¶

GetGlobalId(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → int ¶: C++: roadmanager::LaneRoadMarkTypeLine::GetGlobalId() –> int

GetLength(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → float ¶: C++: roadmanager::LaneRoadMarkTypeLine::GetLength() –> double

GetOSIPoints(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → pyroadmanager.roadmanager.OSIPoints ¶: C++: roadmanager::LaneRoadMarkTypeLine::GetOSIPoints() –> class roadmanager::OSIPoints *

GetSOffset(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → float ¶: C++: roadmanager::LaneRoadMarkTypeLine::GetSOffset() –> double

GetSpace(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → float ¶: C++: roadmanager::LaneRoadMarkTypeLine::GetSpace() –> double

GetTOffset(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → float ¶: C++: roadmanager::LaneRoadMarkTypeLine::GetTOffset() –> double

GetWidth(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → float ¶: C++: roadmanager::LaneRoadMarkTypeLine::GetWidth() –> double

class RoadMarkTypeLineRule¶

Members:

NO_PASSING

CAUTION

NONE

property name¶

SetGlobalId(self: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → None ¶: C++: roadmanager::LaneRoadMarkTypeLine::SetGlobalId() –> void

class pyroadmanager.roadmanager.LaneRoadMarkType¶

AddLine(self: pyroadmanager.roadmanager.LaneRoadMarkType, lane_roadMarkTypeLine: pyroadmanager.roadmanager.LaneRoadMarkTypeLine) → None ¶: C++: roadmanager::LaneRoadMarkType::AddLine(class roadmanager::LaneRoadMarkTypeLine *) –> void

GetLaneRoadMarkTypeLineByIdx(self: pyroadmanager.roadmanager.LaneRoadMarkType, idx: int) → pyroadmanager.roadmanager.LaneRoadMarkTypeLine ¶: C++: roadmanager::LaneRoadMarkType::GetLaneRoadMarkTypeLineByIdx(int) –> class roadmanager::LaneRoadMarkTypeLine *

GetNumberOfRoadMarkTypeLines(self: pyroadmanager.roadmanager.LaneRoadMarkType) → int ¶: C++: roadmanager::LaneRoadMarkType::GetNumberOfRoadMarkTypeLines() –> int

GetWidth(self: pyroadmanager.roadmanager.LaneRoadMarkType) → float ¶: C++: roadmanager::LaneRoadMarkType::GetWidth() –> double

class pyroadmanager.roadmanager.LaneRoadMark¶

AddType(self: pyroadmanager.roadmanager.LaneRoadMark, lane_roadMarkType: pyroadmanager.roadmanager.LaneRoadMarkType) → None ¶: C++: roadmanager::LaneRoadMark::AddType(class roadmanager::LaneRoadMarkType *) –> void

GetColor(self: pyroadmanager.roadmanager.LaneRoadMark) → pyroadmanager.roadmanager.LaneRoadMark.RoadMarkColor ¶: C++: roadmanager::LaneRoadMark::GetColor() –> enum roadmanager::LaneRoadMark::RoadMarkColor

GetHeight(self: pyroadmanager.roadmanager.LaneRoadMark) → float ¶: C++: roadmanager::LaneRoadMark::GetHeight() –> double

GetLaneChange(self: pyroadmanager.roadmanager.LaneRoadMark) → pyroadmanager.roadmanager.LaneRoadMark.RoadMarkLaneChange ¶: C++: roadmanager::LaneRoadMark::GetLaneChange() –> enum roadmanager::LaneRoadMark::RoadMarkLaneChange

GetLaneRoadMarkTypeByIdx(self: pyroadmanager.roadmanager.LaneRoadMark, idx: int) → pyroadmanager.roadmanager.LaneRoadMarkType ¶: C++: roadmanager::LaneRoadMark::GetLaneRoadMarkTypeByIdx(int) –> class roadmanager::LaneRoadMarkType *

GetMaterial(self: pyroadmanager.roadmanager.LaneRoadMark) → pyroadmanager.roadmanager.LaneRoadMark.RoadMarkMaterial ¶: C++: roadmanager::LaneRoadMark::GetMaterial() –> enum roadmanager::LaneRoadMark::RoadMarkMaterial

GetNumberOfRoadMarkTypes(self: pyroadmanager.roadmanager.LaneRoadMark) → int ¶: C++: roadmanager::LaneRoadMark::GetNumberOfRoadMarkTypes() –> int

GetSOffset(self: pyroadmanager.roadmanager.LaneRoadMark) → float ¶: C++: roadmanager::LaneRoadMark::GetSOffset() –> double

GetType(self: pyroadmanager.roadmanager.LaneRoadMark) → pyroadmanager.roadmanager.LaneRoadMark.RoadMarkType ¶: C++: roadmanager::LaneRoadMark::GetType() –> enum roadmanager::LaneRoadMark::RoadMarkType

GetWeight(self: pyroadmanager.roadmanager.LaneRoadMark) → pyroadmanager.roadmanager.LaneRoadMark.RoadMarkWeight ¶: C++: roadmanager::LaneRoadMark::GetWeight() –> enum roadmanager::LaneRoadMark::RoadMarkWeight

GetWidth(self: pyroadmanager.roadmanager.LaneRoadMark) → float ¶: C++: roadmanager::LaneRoadMark::GetWidth() –> double

class RoadMarkColor¶

Members:

STANDARD_COLOR

BLUE

GREEN

RED

WHITE

YELLOW

property name¶

class RoadMarkLaneChange¶

Members:

INCREASE

DECREASE

BOTH

NONE_LANECHANGE

property name¶

class RoadMarkMaterial¶

Members:

STANDARD_MATERIAL

property name¶

class RoadMarkType¶

Members:

NONE_TYPE

SOLID

BROKEN

SOLID_SOLID

SOLID_BROKEN

BROKEN_SOLID

BROKEN_BROKEN

BOTTS_DOTS

GRASS

CURB

property name¶

class RoadMarkWeight¶

Members:

STANDARD

BOLD

property name¶

class pyroadmanager.roadmanager.LaneOffset¶

GetLaneOffset(self: pyroadmanager.roadmanager.LaneOffset, s: float) → float ¶: C++: roadmanager::LaneOffset::GetLaneOffset(double) –> double

GetLaneOffsetPrim(self: pyroadmanager.roadmanager.LaneOffset, s: float) → float ¶: C++: roadmanager::LaneOffset::GetLaneOffsetPrim(double) –> double

GetLength(self: pyroadmanager.roadmanager.LaneOffset) → float ¶: C++: roadmanager::LaneOffset::GetLength() –> double

GetPolynomial(self: pyroadmanager.roadmanager.LaneOffset) → pyroadmanager.roadmanager.Polynomial ¶: C++: roadmanager::LaneOffset::GetPolynomial() –> class roadmanager::Polynomial

GetS(self: pyroadmanager.roadmanager.LaneOffset) → float ¶: C++: roadmanager::LaneOffset::GetS() –> double

Print(self: pyroadmanager.roadmanager.LaneOffset) → None ¶: C++: roadmanager::LaneOffset::Print() –> void

Set(self: pyroadmanager.roadmanager.LaneOffset, s: float, a: float, b: float, c: float, d: float) → None ¶: C++: roadmanager::LaneOffset::Set(double, double, double, double, double) –> void

SetLength(self: pyroadmanager.roadmanager.LaneOffset, length: float) → None ¶: C++: roadmanager::LaneOffset::SetLength(double) –> void

class pyroadmanager.roadmanager.Lane¶

AddLaneRoadMark(self: pyroadmanager.roadmanager.Lane, lane_roadMark: pyroadmanager.roadmanager.LaneRoadMark) → None ¶: C++: roadmanager::Lane::AddLaneRoadMark(class roadmanager::LaneRoadMark *) –> void

AddLaneWidth(self: pyroadmanager.roadmanager.Lane, lane_width: pyroadmanager.roadmanager.LaneWidth) → None ¶: C++: roadmanager::Lane::AddLaneWidth(class roadmanager::LaneWidth *) –> void

AddLink(self: pyroadmanager.roadmanager.Lane, lane_link: pyroadmanager.roadmanager.LaneLink) → None ¶: C++: roadmanager::Lane::AddLink(class roadmanager::LaneLink *) –> void

GetGlobalId(self: pyroadmanager.roadmanager.Lane) → int ¶: C++: roadmanager::Lane::GetGlobalId() –> int

GetId(self: pyroadmanager.roadmanager.Lane) → int ¶: C++: roadmanager::Lane::GetId() –> int

GetLaneBoundary(self: pyroadmanager.roadmanager.Lane) → pyroadmanager.roadmanager.LaneBoundaryOSI ¶: C++: roadmanager::Lane::GetLaneBoundary() –> class roadmanager::LaneBoundaryOSI *

GetLaneBoundaryGlobalId(self: pyroadmanager.roadmanager.Lane) → int ¶: C++: roadmanager::Lane::GetLaneBoundaryGlobalId() –> int

GetLaneRoadMarkByIdx(self: pyroadmanager.roadmanager.Lane, idx: int) → pyroadmanager.roadmanager.LaneRoadMark ¶: C++: roadmanager::Lane::GetLaneRoadMarkByIdx(int) –> class roadmanager::LaneRoadMark *

GetLaneType(self: pyroadmanager.roadmanager.Lane) → roadmanager::Lane::LaneType¶: C++: roadmanager::Lane::GetLaneType() –> roadmanager::Lane::LaneType

GetLink(self: pyroadmanager.roadmanager.Lane, type: roadmanager::LinkType) → pyroadmanager.roadmanager.LaneLink ¶: C++: roadmanager::Lane::GetLink(roadmanager::LinkType) –> class roadmanager::LaneLink *

GetNumberOfLaneWidths(self: pyroadmanager.roadmanager.Lane) → int ¶: C++: roadmanager::Lane::GetNumberOfLaneWidths() –> int

GetNumberOfLinks(self: pyroadmanager.roadmanager.Lane) → int ¶: C++: roadmanager::Lane::GetNumberOfLinks() –> int

GetNumberOfRoadMarks(self: pyroadmanager.roadmanager.Lane) → int ¶: C++: roadmanager::Lane::GetNumberOfRoadMarks() –> int

GetOSIIntersectionId(self: pyroadmanager.roadmanager.Lane) → int ¶: C++: roadmanager::Lane::GetOSIIntersectionId() –> int

GetOSIPoints(self: pyroadmanager.roadmanager.Lane) → pyroadmanager.roadmanager.OSIPoints ¶: C++: roadmanager::Lane::GetOSIPoints() –> class roadmanager::OSIPoints *

GetOffsetFromRef(self: pyroadmanager.roadmanager.Lane) → float ¶: C++: roadmanager::Lane::GetOffsetFromRef() –> double

GetRoadMarkInfoByS(self: pyroadmanager.roadmanager.Lane, track_id: int, lane_id: int, s: float) → pyroadmanager.roadmanager.RoadMarkInfo ¶: C++: roadmanager::Lane::GetRoadMarkInfoByS(int, int, double) –> struct roadmanager::RoadMarkInfo

GetWidthByIndex(self: pyroadmanager.roadmanager.Lane, index: int) → pyroadmanager.roadmanager.LaneWidth ¶: C++: roadmanager::Lane::GetWidthByIndex(int) –> class roadmanager::LaneWidth *

GetWidthByS(self: pyroadmanager.roadmanager.Lane, s: float) → pyroadmanager.roadmanager.LaneWidth ¶: C++: roadmanager::Lane::GetWidthByS(double) –> class roadmanager::LaneWidth *

IsCenter(self: pyroadmanager.roadmanager.Lane) → bool ¶: C++: roadmanager::Lane::IsCenter() –> bool

IsDriving(self: pyroadmanager.roadmanager.Lane) → bool ¶: C++: roadmanager::Lane::IsDriving() –> bool

IsOSIIntersection(self: pyroadmanager.roadmanager.Lane) → bool ¶: C++: roadmanager::Lane::IsOSIIntersection() –> bool

IsType(self: pyroadmanager.roadmanager.Lane, type: roadmanager::Lane::LaneType) → bool ¶: C++: roadmanager::Lane::IsType(roadmanager::Lane::LaneType) –> bool

class LanePosition¶

Members:

LANE_POS_CENTER

LANE_POS_LEFT

LANE_POS_RIGHT

property name¶

Print(self: pyroadmanager.roadmanager.Lane) → None ¶: C++: roadmanager::Lane::Print() –> void

SetGlobalId(self: pyroadmanager.roadmanager.Lane) → None ¶: C++: roadmanager::Lane::SetGlobalId() –> void

SetLaneBoundary(self: pyroadmanager.roadmanager.Lane, lane_boundary: pyroadmanager.roadmanager.LaneBoundaryOSI) → None ¶: C++: roadmanager::Lane::SetLaneBoundary(class roadmanager::LaneBoundaryOSI *) –> void

SetOSIIntersection(self: pyroadmanager.roadmanager.Lane, is_osi_intersection: int) → None ¶: C++: roadmanager::Lane::SetOSIIntersection(int) –> void

SetOffsetFromRef(self: pyroadmanager.roadmanager.Lane, offset: float) → None ¶: C++: roadmanager::Lane::SetOffsetFromRef(double) –> void

class pyroadmanager.roadmanager.LaneSection¶

AddLane(self: pyroadmanager.roadmanager.LaneSection, lane: pyroadmanager.roadmanager.Lane) → None ¶: C++: roadmanager::LaneSection::AddLane(class roadmanager::Lane *) –> void

GetCenterOffset(self: pyroadmanager.roadmanager.LaneSection, s: float, lane_id: int) → float ¶: Get lateral position of lane center, from road reference lane (lane id=0) Example: If lane id 1 is 5 m wide and lane id 2 is 4 m wide, then

lane 1 center offset is 5/2 = 2.5 and lane 2 center offset is 5 + 4/2 = 7

distance along the road segment

lane specifier, starting from center -1, -2, … is on the right side, 1, 2… on the left

C++: roadmanager::LaneSection::GetCenterOffset(double, int) –> double

GetCenterOffsetHeading(self: pyroadmanager.roadmanager.LaneSection, s: float, lane_id: int) → float ¶: C++: roadmanager::LaneSection::GetCenterOffsetHeading(double, int) –> double

GetClosestLaneIdx(*args, **kwargs)¶

Overloaded function.

GetClosestLaneIdx(self: pyroadmanager.roadmanager.LaneSection, s: float, t: float, offset: float, noZeroWidth: bool) -> int
GetClosestLaneIdx(self: pyroadmanager.roadmanager.LaneSection, s: float, t: float, offset: float, noZeroWidth: bool, laneTypeMask: int) -> int

C++: roadmanager::LaneSection::GetClosestLaneIdx(double, double, double &, bool, int) –> int

GetConnectingLaneId(self: pyroadmanager.roadmanager.LaneSection, incoming_lane_id: int, link_type: roadmanager::LinkType) → int ¶: C++: roadmanager::LaneSection::GetConnectingLaneId(int, roadmanager::LinkType) –> int

GetLaneById(self: pyroadmanager.roadmanager.LaneSection, id: int) → pyroadmanager.roadmanager.Lane ¶: C++: roadmanager::LaneSection::GetLaneById(int) –> class roadmanager::Lane *

GetLaneByIdx(self: pyroadmanager.roadmanager.LaneSection, idx: int) → pyroadmanager.roadmanager.Lane ¶: C++: roadmanager::LaneSection::GetLaneByIdx(int) –> class roadmanager::Lane *

GetLaneGlobalIdById(self: pyroadmanager.roadmanager.LaneSection, id: int) → int ¶: C++: roadmanager::LaneSection::GetLaneGlobalIdById(int) –> int

GetLaneGlobalIdByIdx(self: pyroadmanager.roadmanager.LaneSection, idx: int) → int ¶: C++: roadmanager::LaneSection::GetLaneGlobalIdByIdx(int) –> int

GetLaneIdByIdx(self: pyroadmanager.roadmanager.LaneSection, idx: int) → int ¶: C++: roadmanager::LaneSection::GetLaneIdByIdx(int) –> int

GetLaneIdxById(self: pyroadmanager.roadmanager.LaneSection, id: int) → int ¶: C++: roadmanager::LaneSection::GetLaneIdxById(int) –> int

GetLength(self: pyroadmanager.roadmanager.LaneSection) → float ¶: C++: roadmanager::LaneSection::GetLength() –> double

GetNUmberOfLanesLeft(self: pyroadmanager.roadmanager.LaneSection) → int ¶: C++: roadmanager::LaneSection::GetNUmberOfLanesLeft() –> int

GetNUmberOfLanesRight(self: pyroadmanager.roadmanager.LaneSection) → int ¶: C++: roadmanager::LaneSection::GetNUmberOfLanesRight() –> int

GetNumberOfDrivingLanes(self: pyroadmanager.roadmanager.LaneSection) → int ¶: C++: roadmanager::LaneSection::GetNumberOfDrivingLanes() –> int

GetNumberOfDrivingLanesSide(self: pyroadmanager.roadmanager.LaneSection, side: int) → int ¶: C++: roadmanager::LaneSection::GetNumberOfDrivingLanesSide(int) –> int

GetNumberOfLanes(self: pyroadmanager.roadmanager.LaneSection) → int ¶: C++: roadmanager::LaneSection::GetNumberOfLanes() –> int

GetOffsetBetweenLanes(self: pyroadmanager.roadmanager.LaneSection, lane_id1: int, lane_id2: int, s: float) → float ¶: C++: roadmanager::LaneSection::GetOffsetBetweenLanes(int, int, double) –> double

GetOuterOffset(self: pyroadmanager.roadmanager.LaneSection, s: float, lane_id: int) → float ¶: C++: roadmanager::LaneSection::GetOuterOffset(double, int) –> double

GetOuterOffsetHeading(self: pyroadmanager.roadmanager.LaneSection, s: float, lane_id: int) → float ¶: C++: roadmanager::LaneSection::GetOuterOffsetHeading(double, int) –> double

GetS(self: pyroadmanager.roadmanager.LaneSection) → float ¶: C++: roadmanager::LaneSection::GetS() –> double

GetWidth(self: pyroadmanager.roadmanager.LaneSection, s: float, lane_id: int) → float ¶: C++: roadmanager::LaneSection::GetWidth(double, int) –> double

GetWidthBetweenLanes(self: pyroadmanager.roadmanager.LaneSection, lane_id1: int, lane_id2: int, s: float) → float ¶: C++: roadmanager::LaneSection::GetWidthBetweenLanes(int, int, double) –> double

IsOSILaneById(self: pyroadmanager.roadmanager.LaneSection, id: int) → bool ¶: C++: roadmanager::LaneSection::IsOSILaneById(int) –> bool

Print(self: pyroadmanager.roadmanager.LaneSection) → None ¶: C++: roadmanager::LaneSection::Print() –> void

SetLength(self: pyroadmanager.roadmanager.LaneSection, length: float) → None ¶: C++: roadmanager::LaneSection::SetLength(double) –> void

class pyroadmanager.roadmanager.RoadLink¶

GetContactPointType(self: pyroadmanager.roadmanager.RoadLink) → pyroadmanager.roadmanager.ContactPointType ¶: C++: roadmanager::RoadLink::GetContactPointType() –> enum roadmanager::ContactPointType

GetElementId(self: pyroadmanager.roadmanager.RoadLink) → int ¶: C++: roadmanager::RoadLink::GetElementId() –> int

GetElementType(self: pyroadmanager.roadmanager.RoadLink) → roadmanager::RoadLink::ElementType¶: C++: roadmanager::RoadLink::GetElementType() –> roadmanager::RoadLink::ElementType

GetType(self: pyroadmanager.roadmanager.RoadLink) → roadmanager::LinkType¶: C++: roadmanager::RoadLink::GetType() –> roadmanager::LinkType

Print(self: pyroadmanager.roadmanager.RoadLink) → None ¶: C++: roadmanager::RoadLink::Print() –> void

class pyroadmanager.roadmanager.LaneInfo¶

class pyroadmanager.roadmanager.RoadObject¶

class Orientation¶

Members:

POSITIVE

NEGATIVE

NONE

property name¶

assign(self: pyroadmanager.roadmanager.RoadObject, : pyroadmanager.roadmanager.RoadObject) → pyroadmanager.roadmanager.RoadObject ¶: C++: roadmanager::RoadObject::operator=(const class roadmanager::RoadObject &) –> class roadmanager::RoadObject &

class pyroadmanager.roadmanager.Signal¶

GetHOffset(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetHOffset() –> double

GetHeight(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetHeight() –> double

GetId(self: pyroadmanager.roadmanager.Signal) → int ¶: C++: roadmanager::Signal::GetId() –> int

GetLength(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetLength() –> double

GetOrientation(self: pyroadmanager.roadmanager.Signal) → pyroadmanager.roadmanager.RoadObject.Orientation ¶: C++: roadmanager::Signal::GetOrientation() –> enum roadmanager::RoadObject::Orientation

GetPitch(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetPitch() –> double

GetRoll(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetRoll() –> double

GetS(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetS() –> double

GetT(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetT() –> double

GetType(self: pyroadmanager.roadmanager.Signal) → int ¶: C++: roadmanager::Signal::GetType() –> int

GetValue(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetValue() –> double

GetWidth(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetWidth() –> double

GetZOffset(self: pyroadmanager.roadmanager.Signal) → float ¶: C++: roadmanager::Signal::GetZOffset() –> double

IsDynamic(self: pyroadmanager.roadmanager.Signal) → bool ¶: C++: roadmanager::Signal::IsDynamic() –> bool

SetLength(self: pyroadmanager.roadmanager.Signal, length: float) → None ¶: C++: roadmanager::Signal::SetLength(double) –> void

class Type¶

Members:

TYPE_UNKNOWN

TYPE_OTHER

TYPE_DANGER_SPOT

TYPE_ZEBRA_CROSSING

TYPE_FLIGHT

TYPE_CATTLE

TYPE_HORSE_RIDERS

TYPE_AMPHIBIANS

TYPE_FALLING_ROCKS

TYPE_SNOW_OR_ICE

TYPE_LOOSE_GRAVEL

TYPE_WATERSIDE

TYPE_CLEARANCE

TYPE_MOVABLE_BRIDGE

TYPE_RIGHT_BEFORE_LEFT_NEXT_INTERSECTION

TYPE_TURN_LEFT

TYPE_TURN_RIGHT

TYPE_DOUBLE_TURN_LEFT

TYPE_DOUBLE_TURN_RIGHT

TYPE_HILL_DOWNWARDS

TYPE_HILL_UPWARDS

TYPE_UNEVEN_ROAD

TYPE_ROAD_SLIPPERY_WET_OR_DIRTY

TYPE_SIDE_WINDS

TYPE_ROAD_NARROWING

TYPE_ROAD_NARROWING_RIGHT

TYPE_ROAD_NARROWING_LEFT

TYPE_ROAD_WORKS

TYPE_TRAFFIC_QUEUES

TYPE_TWO_WAY_TRAFFIC

TYPE_ATTENTION_TRAFFIC_LIGHT

TYPE_PEDESTRIANS

TYPE_CHILDREN_CROSSING

TYPE_CYCLE_ROUTE

TYPE_DEER_CROSSING

TYPE_UNGATED_LEVEL_CROSSING

TYPE_LEVEL_CROSSING_MARKER

TYPE_RAILWAY_TRAFFIC_PRIORITY

TYPE_GIVE_WAY

TYPE_STOP

TYPE_PRIORITY_TO_OPPOSITE_DIRECTION

TYPE_PRIORITY_TO_OPPOSITE_DIRECTION_UPSIDE_DOWN

TYPE_PRESCRIBED_LEFT_TURN

TYPE_PRESCRIBED_RIGHT_TURN

TYPE_PRESCRIBED_STRAIGHT

TYPE_PRESCRIBED_RIGHT_WAY

TYPE_PRESCRIBED_LEFT_WAY

TYPE_PRESCRIBED_RIGHT_TURN_AND_STRAIGHT

TYPE_PRESCRIBED_LEFT_TURN_AND_STRAIGHT

TYPE_PRESCRIBED_LEFT_TURN_AND_RIGHT_TURN

TYPE_PRESCRIBED_LEFT_TURN_RIGHT_TURN_AND_STRAIGHT

TYPE_ROUNDABOUT

TYPE_ONEWAY_LEFT

TYPE_ONEWAY_RIGHT

TYPE_PASS_LEFT

TYPE_PASS_RIGHT

TYPE_SIDE_LANE_OPEN_FOR_TRAFFIC

TYPE_SIDE_LANE_CLOSED_FOR_TRAFFIC

TYPE_SIDE_LANE_CLOSING_FOR_TRAFFIC

TYPE_BUS_STOP

TYPE_TAXI_STAND

TYPE_BICYCLES_ONLY

TYPE_HORSE_RIDERS_ONLY

TYPE_PEDESTRIANS_ONLY

TYPE_BICYCLES_PEDESTRIANS_SHARED_ONLY

TYPE_BICYCLES_PEDESTRIANS_SEPARATED_LEFT_ONLY

TYPE_BICYCLES_PEDESTRIANS_SEPARATED_RIGHT_ONLY

TYPE_PEDESTRIAN_ZONE_BEGIN

TYPE_PEDESTRIAN_ZONE_END

TYPE_BICYCLE_ROAD_BEGIN

TYPE_BICYCLE_ROAD_END

TYPE_BUS_LANE

TYPE_BUS_LANE_BEGIN

TYPE_BUS_LANE_END

TYPE_ALL_PROHIBITED

TYPE_MOTORIZED_MULTITRACK_PROHIBITED

TYPE_TRUCKS_PROHIBITED

TYPE_BICYCLES_PROHIBITED

TYPE_MOTORCYCLES_PROHIBITED

TYPE_MOPEDS_PROHIBITED

TYPE_HORSE_RIDERS_PROHIBITED

TYPE_HORSE_CARRIAGES_PROHIBITED

TYPE_CATTLE_PROHIBITED

TYPE_BUSES_PROHIBITED

TYPE_CARS_PROHIBITED

TYPE_CARS_TRAILERS_PROHIBITED

TYPE_TRUCKS_TRAILERS_PROHIBITED

TYPE_TRACTORS_PROHIBITED

TYPE_PEDESTRIANS_PROHIBITED

TYPE_MOTOR_VEHICLES_PROHIBITED

TYPE_HAZARDOUS_GOODS_VEHICLES_PROHIBITED

TYPE_OVER_WEIGHT_VEHICLES_PROHIBITED

TYPE_VEHICLES_AXLE_OVER_WEIGHT_PROHIBITED

TYPE_VEHICLES_EXCESS_WIDTH_PROHIBITED

TYPE_VEHICLES_EXCESS_HEIGHT_PROHIBITED

TYPE_VEHICLES_EXCESS_LENGTH_PROHIBITED

TYPE_DO_NOT_ENTER

TYPE_SNOW_CHAINS_REQUIRED

TYPE_WATER_POLLUTANT_VEHICLES_PROHIBITED

TYPE_ENVIRONMENTAL_ZONE_BEGIN

TYPE_ENVIRONMENTAL_ZONE_END

TYPE_NO_U_TURN_LEFT

TYPE_NO_U_TURN_RIGHT

TYPE_PRESCRIBED_U_TURN_LEFT

TYPE_PRESCRIBED_U_TURN_RIGHT

TYPE_MINIMUM_DISTANCE_FOR_TRUCKS

TYPE_SPEED_LIMIT_BEGIN

TYPE_SPEED_LIMIT_ZONE_BEGIN

TYPE_SPEED_LIMIT_ZONE_END

TYPE_MINIMUM_SPEED_BEGIN

TYPE_OVERTAKING_BAN_BEGIN

TYPE_OVERTAKING_BAN_FOR_TRUCKS_BEGIN

TYPE_SPEED_LIMIT_END

TYPE_MINIMUM_SPEED_END

TYPE_OVERTAKING_BAN_END

TYPE_OVERTAKING_BAN_FOR_TRUCKS_END

TYPE_ALL_RESTRICTIONS_END

TYPE_NO_STOPPING

TYPE_NO_PARKING

TYPE_NO_PARKING_ZONE_BEGIN

TYPE_NO_PARKING_ZONE_END

TYPE_RIGHT_OF_WAY_NEXT_INTERSECTION

TYPE_RIGHT_OF_WAY_BEGIN

TYPE_RIGHT_OF_WAY_END

TYPE_PRIORITY_OVER_OPPOSITE_DIRECTION

TYPE_PRIORITY_OVER_OPPOSITE_DIRECTION_UPSIDE_DOWN

TYPE_TOWN_BEGIN

TYPE_TOWN_END

TYPE_CAR_PARKING

TYPE_CAR_PARKING_ZONE_BEGIN

TYPE_CAR_PARKING_ZONE_END

TYPE_SIDEWALK_HALF_PARKING_LEFT

TYPE_SIDEWALK_HALF_PARKING_RIGHT

TYPE_SIDEWALK_PARKING_LEFT

TYPE_SIDEWALK_PARKING_RIGHT

TYPE_SIDEWALK_PERPENDICULAR_HALF_PARKING_LEFT

TYPE_SIDEWALK_PERPENDICULAR_HALF_PARKING_RIGHT

TYPE_SIDEWALK_PERPENDICULAR_PARKING_LEFT

TYPE_SIDEWALK_PERPENDICULAR_PARKING_RIGHT

TYPE_LIVING_STREET_BEGIN

TYPE_LIVING_STREET_END

TYPE_TUNNEL

TYPE_EMERGENCY_STOPPING_LEFT

TYPE_EMERGENCY_STOPPING_RIGHT

TYPE_HIGHWAY_BEGIN

TYPE_HIGHWAY_END

TYPE_EXPRESSWAY_BEGIN

TYPE_EXPRESSWAY_END

TYPE_NAMED_HIGHWAY_EXIT

TYPE_NAMED_EXPRESSWAY_EXIT

TYPE_NAMED_ROAD_EXIT

TYPE_HIGHWAY_EXIT

TYPE_EXPRESSWAY_EXIT

TYPE_ONEWAY_STREET

TYPE_CROSSING_GUARDS

TYPE_DEADEND

TYPE_DEADEND_EXCLUDING_DESIGNATED_ACTORS

TYPE_FIRST_AID_STATION

TYPE_POLICE_STATION

TYPE_TELEPHONE

TYPE_FILLING_STATION

TYPE_HOTEL

TYPE_INN

TYPE_KIOSK

TYPE_TOILET

TYPE_CHAPEL

TYPE_TOURIST_INFO

TYPE_REPAIR_SERVICE

TYPE_PEDESTRIAN_UNDERPASS

TYPE_PEDESTRIAN_BRIDGE

TYPE_CAMPER_PLACE

TYPE_ADVISORY_SPEED_LIMIT_BEGIN

TYPE_ADVISORY_SPEED_LIMIT_END

TYPE_PLACE_NAME

TYPE_TOURIST_ATTRACTION

TYPE_TOURIST_ROUTE

TYPE_TOURIST_AREA

TYPE_SHOULDER_NOT_PASSABLE_MOTOR_VEHICLES

TYPE_SHOULDER_UNSAFE_TRUCKS_TRACTORS

TYPE_TOLL_BEGIN

TYPE_TOLL_END

TYPE_TOLL_ROAD

TYPE_CUSTOMS

TYPE_INTERNATIONAL_BORDER_INFO

TYPE_STREETLIGHT_RED_BAND

TYPE_FEDERAL_HIGHWAY_ROUTE_NUMBER

TYPE_HIGHWAY_ROUTE_NUMBER

TYPE_HIGHWAY_INTERCHANGE_NUMBER

TYPE_EUROPEAN_ROUTE_NUMBER

TYPE_FEDERAL_HIGHWAY_DIRECTION_LEFT

TYPE_FEDERAL_HIGHWAY_DIRECTION_RIGHT

TYPE_PRIMARY_ROAD_DIRECTION_LEFT

TYPE_PRIMARY_ROAD_DIRECTION_RIGHT

TYPE_SECONDARY_ROAD_DIRECTION_LEFT

TYPE_SECONDARY_ROAD_DIRECTION_RIGHT

TYPE_DIRECTION_DESIGNATED_ACTORS_LEFT

TYPE_DIRECTION_DESIGNATED_ACTORS_RIGHT

TYPE_ROUTING_DESIGNATED_ACTORS

TYPE_DIRECTION_TO_HIGHWAY_LEFT

TYPE_DIRECTION_TO_HIGHWAY_RIGHT

TYPE_DIRECTION_TO_LOCAL_DESTINATION_LEFT

TYPE_DIRECTION_TO_LOCAL_DESTINATION_RIGHT

TYPE_CONSOLIDATED_DIRECTIONS

TYPE_STREET_NAME

TYPE_DIRECTION_PREANNOUNCEMENT

TYPE_DIRECTION_PREANNOUNCEMENT_LANE_CONFIG

TYPE_DIRECTION_PREANNOUNCEMENT_HIGHWAY_ENTRIES

TYPE_HIGHWAY_ANNOUNCEMENT

TYPE_OTHER_ROAD_ANNOUNCEMENT

TYPE_HIGHWAY_ANNOUNCEMENT_TRUCK_STOP

TYPE_HIGHWAY_PREANNOUNCEMENT_DIRECTIONS

TYPE_POLE_EXIT

TYPE_HIGHWAY_DISTANCE_BOARD

TYPE_DETOUR_LEFT

TYPE_DETOUR_RIGHT

TYPE_NUMBERED_DETOUR

TYPE_DETOUR_BEGIN

TYPE_DETOUR_END

TYPE_DETOUR_ROUTING_BOARD

TYPE_OPTIONAL_DETOUR

TYPE_OPTIONAL_DETOUR_ROUTING

TYPE_ROUTE_RECOMMENDATION

TYPE_ROUTE_RECOMMENDATION_END

TYPE_ANNOUNCE_LANE_TRANSITION_LEFT

TYPE_ANNOUNCE_LANE_TRANSITION_RIGHT

TYPE_ANNOUNCE_RIGHT_LANE_END

TYPE_ANNOUNCE_LEFT_LANE_END

TYPE_ANNOUNCE_RIGHT_LANE_BEGIN

TYPE_ANNOUNCE_LEFT_LANE_BEGIN

TYPE_ANNOUNCE_LANE_CONSOLIDATION

TYPE_DETOUR_CITY_BLOCK

TYPE_GATE

TYPE_POLE_WARNING

TYPE_TRAFFIC_CONE

TYPE_MOBILE_LANE_CLOSURE

TYPE_REFLECTOR_POST

TYPE_DIRECTIONAL_BOARD_WARNING

TYPE_GUIDING_PLATE

TYPE_GUIDING_PLATE_WEDGES

TYPE_PARKING_HAZARD

TYPE_TRAFFIC_LIGHT_GREEN_ARROW

TrafficSign_MainSign_Classification_Type_INT_MIN_SENTINEL_DO_NOT_USE_

TrafficSign_MainSign_Classification_Type_INT_MAX_SENTINEL_DO_NOT_USE_

property name¶

class pyroadmanager.roadmanager.OutlineCorner¶

GetHeight(self: pyroadmanager.roadmanager.OutlineCorner) → float ¶: C++: roadmanager::OutlineCorner::GetHeight() –> double

GetPos(self: pyroadmanager.roadmanager.OutlineCorner, x: float, y: float, z: float) → None ¶: C++: roadmanager::OutlineCorner::GetPos(double &, double &, double &) –> void

assign(self: pyroadmanager.roadmanager.OutlineCorner, : pyroadmanager.roadmanager.OutlineCorner) → pyroadmanager.roadmanager.OutlineCorner ¶: C++: roadmanager::OutlineCorner::operator=(const class roadmanager::OutlineCorner &) –> class roadmanager::OutlineCorner &

class pyroadmanager.roadmanager.OutlineCornerRoad¶

GetHeight(self: pyroadmanager.roadmanager.OutlineCornerRoad) → float ¶: C++: roadmanager::OutlineCornerRoad::GetHeight() –> double

GetPos(self: pyroadmanager.roadmanager.OutlineCornerRoad, x: float, y: float, z: float) → None ¶: C++: roadmanager::OutlineCornerRoad::GetPos(double &, double &, double &) –> void

assign(self: pyroadmanager.roadmanager.OutlineCornerRoad, : pyroadmanager.roadmanager.OutlineCornerRoad) → pyroadmanager.roadmanager.OutlineCornerRoad ¶: C++: roadmanager::OutlineCornerRoad::operator=(const class roadmanager::OutlineCornerRoad &) –> class roadmanager::OutlineCornerRoad &

class pyroadmanager.roadmanager.OutlineCornerLocal¶

GetHeight(self: pyroadmanager.roadmanager.OutlineCornerLocal) → float ¶: C++: roadmanager::OutlineCornerLocal::GetHeight() –> double

GetPos(self: pyroadmanager.roadmanager.OutlineCornerLocal, x: float, y: float, z: float) → None ¶: C++: roadmanager::OutlineCornerLocal::GetPos(double &, double &, double &) –> void

assign(self: pyroadmanager.roadmanager.OutlineCornerLocal, : pyroadmanager.roadmanager.OutlineCornerLocal) → pyroadmanager.roadmanager.OutlineCornerLocal ¶: C++: roadmanager::OutlineCornerLocal::operator=(const class roadmanager::OutlineCornerLocal &) –> class roadmanager::OutlineCornerLocal &

class pyroadmanager.roadmanager.Outline¶

AddCorner(self: pyroadmanager.roadmanager.Outline, outlineCorner: pyroadmanager.roadmanager.OutlineCorner) → None ¶: C++: roadmanager::Outline::AddCorner(class roadmanager::OutlineCorner *) –> void

class pyroadmanager.roadmanager.Repeat¶

GetDistance(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetDistance() –> double

GetHeightEnd(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetHeightEnd() –> double

GetHeightStart(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetHeightStart() –> double

GetLength(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetLength() –> double

GetLengthEnd(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetLengthEnd() –> double

GetLengthStart(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetLengthStart() –> double

GetRadiusEnd(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetRadiusEnd() –> double

GetRadiusStart(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetRadiusStart() –> double

GetS(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetS() –> double

GetTEnd(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetTEnd() –> double

GetTStart(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetTStart() –> double

GetWidthEnd(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetWidthEnd() –> double

GetWidthStart(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetWidthStart() –> double

GetZOffsetEnd(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetZOffsetEnd() –> double

GetZOffsetStart(self: pyroadmanager.roadmanager.Repeat) → float ¶: C++: roadmanager::Repeat::GetZOffsetStart() –> double

SeHeightEnd(self: pyroadmanager.roadmanager.Repeat, heightStart: float) → None ¶: C++: roadmanager::Repeat::SeHeightEnd(double) –> void

SetHeightStart(self: pyroadmanager.roadmanager.Repeat, heightStart: float) → None ¶: C++: roadmanager::Repeat::SetHeightStart(double) –> void

SetLengthEnd(self: pyroadmanager.roadmanager.Repeat, lengthEnd: float) → None ¶: C++: roadmanager::Repeat::SetLengthEnd(double) –> void

SetLengthStart(self: pyroadmanager.roadmanager.Repeat, lengthStart: float) → None ¶: C++: roadmanager::Repeat::SetLengthStart(double) –> void

SetWidthEnd(self: pyroadmanager.roadmanager.Repeat, widthEnd: float) → None ¶: C++: roadmanager::Repeat::SetWidthEnd(double) –> void

SetWidthStart(self: pyroadmanager.roadmanager.Repeat, widthStart: float) → None ¶: C++: roadmanager::Repeat::SetWidthStart(double) –> void

class pyroadmanager.roadmanager.RMObject¶

AddOutline(self: pyroadmanager.roadmanager.RMObject, outline: pyroadmanager.roadmanager.Outline) → None ¶: C++: roadmanager::RMObject::AddOutline(class roadmanager::Outline *) –> void

GetHOffset(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetHOffset() –> double

GetHeight(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetHeight() –> double

GetId(self: pyroadmanager.roadmanager.RMObject) → int ¶: C++: roadmanager::RMObject::GetId() –> int

GetLength(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetLength() –> double

GetNumberOfOutlines(self: pyroadmanager.roadmanager.RMObject) → int ¶: C++: roadmanager::RMObject::GetNumberOfOutlines() –> int

GetOrientation(self: pyroadmanager.roadmanager.RMObject) → pyroadmanager.roadmanager.RoadObject.Orientation ¶: C++: roadmanager::RMObject::GetOrientation() –> enum roadmanager::RoadObject::Orientation

GetOutline(self: pyroadmanager.roadmanager.RMObject, i: int) → pyroadmanager.roadmanager.Outline ¶: C++: roadmanager::RMObject::GetOutline(int) –> class roadmanager::Outline *

GetPitch(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetPitch() –> double

GetRepeat(self: pyroadmanager.roadmanager.RMObject) → pyroadmanager.roadmanager.Repeat ¶: C++: roadmanager::RMObject::GetRepeat() –> class roadmanager::Repeat *

GetRoll(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetRoll() –> double

GetS(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetS() –> double

GetT(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetT() –> double

GetWidth(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetWidth() –> double

GetZOffset(self: pyroadmanager.roadmanager.RMObject) → float ¶: C++: roadmanager::RMObject::GetZOffset() –> double

SetRepeat(self: pyroadmanager.roadmanager.RMObject, repeat: pyroadmanager.roadmanager.Repeat) → None ¶: C++: roadmanager::RMObject::SetRepeat(class roadmanager::Repeat *) –> void

class pyroadmanager.roadmanager.Road¶

AddArc(self: pyroadmanager.roadmanager.Road, arc: pyroadmanager.roadmanager.Arc) → None ¶: C++: roadmanager::Road::AddArc(class roadmanager::Arc *) –> void

AddElevation(self: pyroadmanager.roadmanager.Road, elevation: pyroadmanager.roadmanager.Elevation) → None ¶: C++: roadmanager::Road::AddElevation(class roadmanager::Elevation *) –> void

AddLaneOffset(self: pyroadmanager.roadmanager.Road, lane_offset: pyroadmanager.roadmanager.LaneOffset) → None ¶: C++: roadmanager::Road::AddLaneOffset(class roadmanager::LaneOffset *) –> void

AddLaneSection(self: pyroadmanager.roadmanager.Road, lane_section: pyroadmanager.roadmanager.LaneSection) → None ¶: C++: roadmanager::Road::AddLaneSection(class roadmanager::LaneSection *) –> void

AddLine(self: pyroadmanager.roadmanager.Road, line: pyroadmanager.roadmanager.Line) → None ¶: C++: roadmanager::Road::AddLine(class roadmanager::Line *) –> void

AddLink(self: pyroadmanager.roadmanager.Road, link: pyroadmanager.roadmanager.RoadLink) → None ¶: C++: roadmanager::Road::AddLink(class roadmanager::RoadLink *) –> void

AddObject(self: pyroadmanager.roadmanager.Road, object: pyroadmanager.roadmanager.RMObject) → None ¶: C++: roadmanager::Road::AddObject(class roadmanager::RMObject *) –> void

AddParamPoly3(self: pyroadmanager.roadmanager.Road, param_poly3: pyroadmanager.roadmanager.ParamPoly3) → None ¶: C++: roadmanager::Road::AddParamPoly3(class roadmanager::ParamPoly3 *) –> void

AddPoly3(self: pyroadmanager.roadmanager.Road, poly3: pyroadmanager.roadmanager.Poly3) → None ¶: C++: roadmanager::Road::AddPoly3(class roadmanager::Poly3 *) –> void

AddSignal(self: pyroadmanager.roadmanager.Road, signal: pyroadmanager.roadmanager.Signal) → None ¶: C++: roadmanager::Road::AddSignal(class roadmanager::Signal *) –> void

AddSpiral(self: pyroadmanager.roadmanager.Road, spiral: pyroadmanager.roadmanager.Spiral) → None ¶: C++: roadmanager::Road::AddSpiral(class roadmanager::Spiral *) –> void

AddSuperElevation(self: pyroadmanager.roadmanager.Road, super_elevation: pyroadmanager.roadmanager.Elevation) → None ¶: C++: roadmanager::Road::AddSuperElevation(class roadmanager::Elevation *) –> void

GetCenterOffset(self: pyroadmanager.roadmanager.Road, s: float, lane_id: int) → float ¶: Get lateral position of lane center, from road reference lane (lane id=0) Example: If lane id 1 is 5 m wide and lane id 2 is 4 m wide, then lane 1 center offset is 5/2 = 2.5 and lane 2 center offset is 5 + 4/2 = 7

distance along the road segment

lane specifier, starting from center -1, -2, … is on the right side, 1, 2… on the left

C++: roadmanager::Road::GetCenterOffset(double, int) –> double

GetConnectingLaneId(self: pyroadmanager.roadmanager.Road, road_link: pyroadmanager.roadmanager.RoadLink, fromLaneId: int, connectingRoadId: int) → int ¶: C++: roadmanager::Road::GetConnectingLaneId(class roadmanager::RoadLink *, int, int) –> int

GetDrivingLaneById(self: pyroadmanager.roadmanager.Road, s: float, idx: int) → pyroadmanager.roadmanager.Lane ¶: C++: roadmanager::Road::GetDrivingLaneById(double, int) –> class roadmanager::Lane *

GetDrivingLaneByIdx(self: pyroadmanager.roadmanager.Road, s: float, idx: int) → pyroadmanager.roadmanager.Lane ¶: C++: roadmanager::Road::GetDrivingLaneByIdx(double, int) –> class roadmanager::Lane *

GetElevation(self: pyroadmanager.roadmanager.Road, idx: int) → pyroadmanager.roadmanager.Elevation ¶: C++: roadmanager::Road::GetElevation(int) –> class roadmanager::Elevation *

GetGeometry(self: pyroadmanager.roadmanager.Road, idx: int) → pyroadmanager.roadmanager.Geometry ¶: C++: roadmanager::Road::GetGeometry(int) –> class roadmanager::Geometry *

GetId(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetId() –> int

GetJunction(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetJunction() const –> int

GetLaneInfoByS(*args, **kwargs)¶

Overloaded function.

GetLaneInfoByS(self: pyroadmanager.roadmanager.Road, s: float, start_lane_link_idx: int, start_lane_id: int) -> pyroadmanager.roadmanager.LaneInfo
GetLaneInfoByS(self: pyroadmanager.roadmanager.Road, s: float, start_lane_link_idx: int, start_lane_id: int, laneTypeMask: int) -> pyroadmanager.roadmanager.LaneInfo

C++: roadmanager::Road::GetLaneInfoByS(double, int, int, int) –> struct roadmanager::LaneInfo

GetLaneOffset(self: pyroadmanager.roadmanager.Road, s: float) → float ¶: C++: roadmanager::Road::GetLaneOffset(double) –> double

GetLaneOffsetPrim(self: pyroadmanager.roadmanager.Road, s: float) → float ¶: C++: roadmanager::Road::GetLaneOffsetPrim(double) –> double

GetLaneSectionByIdx(self: pyroadmanager.roadmanager.Road, idx: int) → pyroadmanager.roadmanager.LaneSection ¶: Retrieve the lanesection specified by vector element index (idx) useful for iterating over all available lane sections, e.g: for (int i = 0; i < road->GetNumberOfLaneSections(); i++) {

int n_lanes = road->GetLaneSectionByIdx(i)->GetNumberOfLanes();

…

index into the vector of lane sections

C++: roadmanager::Road::GetLaneSectionByIdx(int) –> class roadmanager::LaneSection *

GetLaneSectionByS(*args, **kwargs)¶

Overloaded function.

GetLaneSectionByS(self: pyroadmanager.roadmanager.Road, s: float) -> pyroadmanager.roadmanager.LaneSection
GetLaneSectionByS(self: pyroadmanager.roadmanager.Road, s: float, start_at: int) -> pyroadmanager.roadmanager.LaneSection

Retrieve the lanesection at specified s-value

distance along the road segment

C++: roadmanager::Road::GetLaneSectionByS(double, int) –> class roadmanager::LaneSection *

GetLaneSectionIdxByS(*args, **kwargs)¶

Overloaded function.

GetLaneSectionIdxByS(self: pyroadmanager.roadmanager.Road, s: float) -> int
GetLaneSectionIdxByS(self: pyroadmanager.roadmanager.Road, s: float, start_at: int) -> int

Retrieve the lanesection index at specified s-value

distance along the road segment

C++: roadmanager::Road::GetLaneSectionIdxByS(double, int) –> int

GetLaneWidthByS(self: pyroadmanager.roadmanager.Road, s: float, lane_id: int) → float ¶: C++: roadmanager::Road::GetLaneWidthByS(double, int) –> double

GetLength(self: pyroadmanager.roadmanager.Road) → float ¶: C++: roadmanager::Road::GetLength() const –> double

GetLink(self: pyroadmanager.roadmanager.Road, type: roadmanager::LinkType) → pyroadmanager.roadmanager.RoadLink ¶: C++: roadmanager::Road::GetLink(roadmanager::LinkType) –> class roadmanager::RoadLink *

GetNumberOfDrivingLanes(self: pyroadmanager.roadmanager.Road, s: float) → int ¶: C++: roadmanager::Road::GetNumberOfDrivingLanes(double) –> int

GetNumberOfDrivingLanesSide(self: pyroadmanager.roadmanager.Road, s: float, side: int) → int ¶: C++: roadmanager::Road::GetNumberOfDrivingLanesSide(double, int) –> int

GetNumberOfElevations(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetNumberOfElevations() –> int

GetNumberOfGeometries(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetNumberOfGeometries() –> int

GetNumberOfLaneSections(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetNumberOfLaneSections() –> int

GetNumberOfLanes(self: pyroadmanager.roadmanager.Road, s: float) → int ¶: C++: roadmanager::Road::GetNumberOfLanes(double) –> int

GetNumberOfObjects(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetNumberOfObjects() –> int

GetNumberOfRoadTypes(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetNumberOfRoadTypes() const –> int

GetNumberOfSignals(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetNumberOfSignals() –> int

GetNumberOfSuperElevations(self: pyroadmanager.roadmanager.Road) → int ¶: C++: roadmanager::Road::GetNumberOfSuperElevations() –> int

GetObject(self: pyroadmanager.roadmanager.Road, idx: int) → pyroadmanager.roadmanager.RMObject ¶: C++: roadmanager::Road::GetObject(int) –> class roadmanager::RMObject *

GetRule(self: pyroadmanager.roadmanager.Road) → pyroadmanager.roadmanager.Road.RoadRule ¶: C++: roadmanager::Road::GetRule() –> enum roadmanager::Road::RoadRule

GetSignal(self: pyroadmanager.roadmanager.Road, idx: int) → pyroadmanager.roadmanager.Signal ¶: C++: roadmanager::Road::GetSignal(int) –> class roadmanager::Signal *

GetSpeedByS(self: pyroadmanager.roadmanager.Road, s: float) → float ¶: C++: roadmanager::Road::GetSpeedByS(double) –> double

GetSuperElevation(self: pyroadmanager.roadmanager.Road, idx: int) → pyroadmanager.roadmanager.Elevation ¶: C++: roadmanager::Road::GetSuperElevation(int) –> class roadmanager::Elevation *

GetWidth(*args, **kwargs)¶

Overloaded function.

GetWidth(self: pyroadmanager.roadmanager.Road, s: float, side: int) -> float
GetWidth(self: pyroadmanager.roadmanager.Road, s: float, side: int, laneTypeMask: int) -> float

<summary>Get width of road</summary>: <param name=”s”>Longitudinal position/distance along the road</param> <param name=”side”>Side of the road: -1=right, 1=left, 0=both</param> <param name=”laneTypeMask”>Bitmask specifying what lane types to consider - see Lane::LaneType</param> <returns>Width (m)</returns>

C++: roadmanager::Road::GetWidth(double, int, int) –> double

GetZAndPitchByS(self: pyroadmanager.roadmanager.Road, s: float, z: float, pitch: float, index: int) → bool ¶: C++: roadmanager::Road::GetZAndPitchByS(double, double *, double *, int *) –> bool

Print(self: pyroadmanager.roadmanager.Road) → None ¶: C++: roadmanager::Road::Print() –> void

class RoadRule¶

Members:

RIGHT_HAND_TRAFFIC

LEFT_HAND_TRAFFIC

ROAD_RULE_UNDEFINED

property name¶

class RoadType¶

Members:

ROADTYPE_UNKNOWN

ROADTYPE_RURAL

ROADTYPE_MOTORWAY

ROADTYPE_TOWN

ROADTYPE_LOWSPEED

ROADTYPE_PEDESTRIAN

ROADTYPE_BICYCLE

property name¶

SetId(self: pyroadmanager.roadmanager.Road, id: int) → None ¶: C++: roadmanager::Road::SetId(int) –> void

SetJunction(self: pyroadmanager.roadmanager.Road, junction: int) → None ¶: C++: roadmanager::Road::SetJunction(int) –> void

SetLength(self: pyroadmanager.roadmanager.Road, length: float) → None ¶: C++: roadmanager::Road::SetLength(double) –> void

UpdateZAndRollBySAndT(self: pyroadmanager.roadmanager.Road, s: float, t: float, z: float, roll: float, index: int) → bool ¶: C++: roadmanager::Road::UpdateZAndRollBySAndT(double, double, double *, double *, int *) –> bool

class pyroadmanager.roadmanager.LaneRoadLaneConnection¶

GetConnectingRoadId(self: pyroadmanager.roadmanager.LaneRoadLaneConnection) → int ¶: C++: roadmanager::LaneRoadLaneConnection::GetConnectingRoadId() –> int

GetConnectinglaneId(self: pyroadmanager.roadmanager.LaneRoadLaneConnection) → int ¶: C++: roadmanager::LaneRoadLaneConnection::GetConnectinglaneId() –> int

GetLaneId(self: pyroadmanager.roadmanager.LaneRoadLaneConnection) → int ¶: C++: roadmanager::LaneRoadLaneConnection::GetLaneId() –> int

SetConnectingLane(self: pyroadmanager.roadmanager.LaneRoadLaneConnection, id: int) → None ¶: C++: roadmanager::LaneRoadLaneConnection::SetConnectingLane(int) –> void

SetConnectingRoad(self: pyroadmanager.roadmanager.LaneRoadLaneConnection, id: int) → None ¶: C++: roadmanager::LaneRoadLaneConnection::SetConnectingRoad(int) –> void

SetLane(self: pyroadmanager.roadmanager.LaneRoadLaneConnection, id: int) → None ¶: C++: roadmanager::LaneRoadLaneConnection::SetLane(int) –> void

class pyroadmanager.roadmanager.JunctionLaneLink¶

Print(self: pyroadmanager.roadmanager.JunctionLaneLink) → None ¶: C++: roadmanager::JunctionLaneLink::Print() –> void

class pyroadmanager.roadmanager.Connection¶

AddJunctionLaneLink(self: pyroadmanager.roadmanager.Connection, from: int, to: int) → None ¶: C++: roadmanager::Connection::AddJunctionLaneLink(int, int) –> void

GetConnectingLaneId(self: pyroadmanager.roadmanager.Connection, incoming_lane_id: int) → int ¶: C++: roadmanager::Connection::GetConnectingLaneId(int) –> int

GetConnectingRoad(self: pyroadmanager.roadmanager.Connection) → pyroadmanager.roadmanager.Road ¶: C++: roadmanager::Connection::GetConnectingRoad() –> class roadmanager::Road *

GetContactPoint(self: pyroadmanager.roadmanager.Connection) → pyroadmanager.roadmanager.ContactPointType ¶: C++: roadmanager::Connection::GetContactPoint() –> enum roadmanager::ContactPointType

GetIncomingRoad(self: pyroadmanager.roadmanager.Connection) → pyroadmanager.roadmanager.Road ¶: C++: roadmanager::Connection::GetIncomingRoad() –> class roadmanager::Road *

GetLaneLink(self: pyroadmanager.roadmanager.Connection, idx: int) → pyroadmanager.roadmanager.JunctionLaneLink ¶: C++: roadmanager::Connection::GetLaneLink(int) –> class roadmanager::JunctionLaneLink *

GetNumberOfLaneLinks(self: pyroadmanager.roadmanager.Connection) → int ¶: C++: roadmanager::Connection::GetNumberOfLaneLinks() –> int

Print(self: pyroadmanager.roadmanager.Connection) → None ¶: C++: roadmanager::Connection::Print() –> void

class pyroadmanager.roadmanager.Controller¶

GetId(self: pyroadmanager.roadmanager.Controller) → int ¶: C++: roadmanager::Controller::GetId() –> int

GetNumberOfControls(self: pyroadmanager.roadmanager.Controller) → int ¶: C++: roadmanager::Controller::GetNumberOfControls() –> int

GetSequence(self: pyroadmanager.roadmanager.Controller) → int ¶: C++: roadmanager::Controller::GetSequence() –> int

assign(self: pyroadmanager.roadmanager.Controller, : pyroadmanager.roadmanager.Controller) → pyroadmanager.roadmanager.Controller ¶: C++: roadmanager::Controller::operator=(const class roadmanager::Controller &) –> class roadmanager::Controller &

class pyroadmanager.roadmanager.Junction¶

AddConnection(self: pyroadmanager.roadmanager.Junction, connection: pyroadmanager.roadmanager.Connection) → None ¶: C++: roadmanager::Junction::AddConnection(class roadmanager::Connection *) –> void

GetConnectingRoadIdFromIncomingRoadId(self: pyroadmanager.roadmanager.Junction, incomingRoadId: int, index: int) → int ¶: C++: roadmanager::Junction::GetConnectingRoadIdFromIncomingRoadId(int, int) –> int

GetConnectionByIdx(self: pyroadmanager.roadmanager.Junction, idx: int) → pyroadmanager.roadmanager.Connection ¶: C++: roadmanager::Junction::GetConnectionByIdx(int) –> class roadmanager::Connection *

GetGlobalId(self: pyroadmanager.roadmanager.Junction) → int ¶: C++: roadmanager::Junction::GetGlobalId() –> int

GetId(self: pyroadmanager.roadmanager.Junction) → int ¶: C++: roadmanager::Junction::GetId() –> int

GetNoConnectionsFromRoadId(self: pyroadmanager.roadmanager.Junction, incomingRoadId: int) → int ¶: C++: roadmanager::Junction::GetNoConnectionsFromRoadId(int) –> int

GetNumberOfConnections(self: pyroadmanager.roadmanager.Junction) → int ¶: C++: roadmanager::Junction::GetNumberOfConnections() –> int

GetNumberOfControllers(self: pyroadmanager.roadmanager.Junction) → int ¶: C++: roadmanager::Junction::GetNumberOfControllers() –> int

GetNumberOfRoadConnections(self: pyroadmanager.roadmanager.Junction, roadId: int, laneId: int) → int ¶: C++: roadmanager::Junction::GetNumberOfRoadConnections(int, int) –> int

GetRoadConnectionByIdx(*args, **kwargs)¶

Overloaded function.

GetRoadConnectionByIdx(self: pyroadmanager.roadmanager.Junction, roadId: int, laneId: int, idx: int) -> pyroadmanager.roadmanager.LaneRoadLaneConnection
GetRoadConnectionByIdx(self: pyroadmanager.roadmanager.Junction, roadId: int, laneId: int, idx: int, laneTypeMask: int) -> pyroadmanager.roadmanager.LaneRoadLaneConnection

C++: roadmanager::Junction::GetRoadConnectionByIdx(int, int, int, int) –> class roadmanager::LaneRoadLaneConnection

IsOsiIntersection(self: pyroadmanager.roadmanager.Junction) → bool ¶: C++: roadmanager::Junction::IsOsiIntersection() –> bool

Print(self: pyroadmanager.roadmanager.Junction) → None ¶: C++: roadmanager::Junction::Print() –> void

SetGlobalId(self: pyroadmanager.roadmanager.Junction) → None ¶: C++: roadmanager::Junction::SetGlobalId() –> void

class pyroadmanager.roadmanager.OpenDrive¶

AddController(self: pyroadmanager.roadmanager.OpenDrive, controller: pyroadmanager.roadmanager.Controller) → None ¶: C++: roadmanager::OpenDrive::AddController(class roadmanager::Controller) –> void

CheckConnectedRoad(self: pyroadmanager.roadmanager.OpenDrive, road: pyroadmanager.roadmanager.Road, link: pyroadmanager.roadmanager.RoadLink, expected_contact_point_type: pyroadmanager.roadmanager.ContactPointType, link2: pyroadmanager.roadmanager.RoadLink) → int ¶: C++: roadmanager::OpenDrive::CheckConnectedRoad(class roadmanager::Road *, class roadmanager::RoadLink *, enum roadmanager::ContactPointType, class roadmanager::RoadLink *) –> int

CheckConnections(self: pyroadmanager.roadmanager.OpenDrive) → int ¶: Add any missing connections so that road connectivity is two-ways Look at all road connections, and make sure they are defined both ways

index into the vector of roads

number of added connections

C++: roadmanager::OpenDrive::CheckConnections() –> int

CheckJunctionConnection(self: pyroadmanager.roadmanager.OpenDrive, junction: pyroadmanager.roadmanager.Junction, connection: pyroadmanager.roadmanager.Connection) → int ¶: C++: roadmanager::OpenDrive::CheckJunctionConnection(class roadmanager::Junction *, class roadmanager::Connection *) –> int

CheckLink(self: pyroadmanager.roadmanager.OpenDrive, road: pyroadmanager.roadmanager.Road, link: pyroadmanager.roadmanager.RoadLink, expected_contact_point_type: pyroadmanager.roadmanager.ContactPointType) → int ¶: C++: roadmanager::OpenDrive::CheckLink(class roadmanager::Road *, class roadmanager::RoadLink *, enum roadmanager::ContactPointType) –> int

GetControllerById(self: pyroadmanager.roadmanager.OpenDrive, id: int) → pyroadmanager.roadmanager.Controller ¶: C++: roadmanager::OpenDrive::GetControllerById(int) –> class roadmanager::Controller *

GetControllerByIdx(self: pyroadmanager.roadmanager.OpenDrive, index: int) → pyroadmanager.roadmanager.Controller ¶: C++: roadmanager::OpenDrive::GetControllerByIdx(int) –> class roadmanager::Controller *

GetGeometryByIdx(self: pyroadmanager.roadmanager.OpenDrive, road_idx: int, geom_idx: int) → pyroadmanager.roadmanager.Geometry ¶: C++: roadmanager::OpenDrive::GetGeometryByIdx(int, int) –> class roadmanager::Geometry *

GetJunctionById(self: pyroadmanager.roadmanager.OpenDrive, id: int) → pyroadmanager.roadmanager.Junction ¶: C++: roadmanager::OpenDrive::GetJunctionById(int) –> class roadmanager::Junction *

GetJunctionByIdx(self: pyroadmanager.roadmanager.OpenDrive, idx: int) → pyroadmanager.roadmanager.Junction ¶: C++: roadmanager::OpenDrive::GetJunctionByIdx(int) –> class roadmanager::Junction *

GetNumOfJunctions(self: pyroadmanager.roadmanager.OpenDrive) → int ¶: C++: roadmanager::OpenDrive::GetNumOfJunctions() –> int

GetNumOfRoads(self: pyroadmanager.roadmanager.OpenDrive) → int ¶: C++: roadmanager::OpenDrive::GetNumOfRoads() –> int

GetNumberOfControllers(self: pyroadmanager.roadmanager.OpenDrive) → int ¶: C++: roadmanager::OpenDrive::GetNumberOfControllers() –> int

GetRoadById(self: pyroadmanager.roadmanager.OpenDrive, id: int) → pyroadmanager.roadmanager.Road ¶: Retrieve a road segment specified by road ID

road ID as specified in the OpenDRIVE file

C++: roadmanager::OpenDrive::GetRoadById(int) –> class roadmanager::Road *

GetRoadByIdx(self: pyroadmanager.roadmanager.OpenDrive, idx: int) → pyroadmanager.roadmanager.Road ¶: Retrieve a road segment specified by road vector element index useful for iterating over all available road segments, e.g: for (int i = 0; i < GetNumOfRoads(); i++) {

int n_lanes = GetRoadyIdx(i)->GetNumberOfLanes();

…

index into the vector of roads

C++: roadmanager::OpenDrive::GetRoadByIdx(int) –> class roadmanager::Road *

GetTrackIdByIdx(self: pyroadmanager.roadmanager.OpenDrive, idx: int) → int ¶: C++: roadmanager::OpenDrive::GetTrackIdByIdx(int) –> int

GetTrackIdxById(self: pyroadmanager.roadmanager.OpenDrive, id: int) → int ¶: C++: roadmanager::OpenDrive::GetTrackIdxById(int) –> int

InitGlobalLaneIds(self: pyroadmanager.roadmanager.OpenDrive) → None ¶: Initialize the global ids for lanes

C++: roadmanager::OpenDrive::InitGlobalLaneIds() –> void

IsDirectlyConnected(self: pyroadmanager.roadmanager.OpenDrive, road1_id: int, road2_id: int, angle: float) → int ¶: Check if two roads are connected directly

Id of the first road

Id of the second road

if connected, the angle between road 2 and road 1 is returned here

0 if not connected, -1 if road 2 is the predecessor of road 1, +1 if road 2 is the successor of road 1

C++: roadmanager::OpenDrive::IsDirectlyConnected(int, int, double &) –> int

LoadOpenDriveFile(*args, **kwargs)¶

Overloaded function.

LoadOpenDriveFile(self: pyroadmanager.roadmanager.OpenDrive, filename: str) -> bool
LoadOpenDriveFile(self: pyroadmanager.roadmanager.OpenDrive, filename: str, replace: bool) -> bool

Load a road network, specified in the OpenDRIVE file format

OpenDRIVE file

If true any old road data will be erased, else new will be added to the old

C++: roadmanager::OpenDrive::LoadOpenDriveFile(const char *, bool) –> bool

Print(self: pyroadmanager.roadmanager.OpenDrive) → None ¶: C++: roadmanager::OpenDrive::Print() –> void

SetLaneBoundaryPoints(self: pyroadmanager.roadmanager.OpenDrive) → None ¶: Checks all lanes - if a lane has RoadMarks it does nothing. If a lane does not have roadmarks then it creates a LaneBoundary following the lane border (left border for left lanes, right border for right lanes)

C++: roadmanager::OpenDrive::SetLaneBoundaryPoints() –> void

SetLaneOSIPoints(self: pyroadmanager.roadmanager.OpenDrive) → None ¶: C++: roadmanager::OpenDrive::SetLaneOSIPoints() –> void

SetRoadMarkOSIPoints(self: pyroadmanager.roadmanager.OpenDrive) → None ¶: C++: roadmanager::OpenDrive::SetRoadMarkOSIPoints() –> void

SetRoadOSI(self: pyroadmanager.roadmanager.OpenDrive) → bool ¶: Setting information based on the OSI standards for OpenDrive elements

C++: roadmanager::OpenDrive::SetRoadOSI() –> bool

class pyroadmanager.roadmanager.Position¶

CalcRoutePosition(self: pyroadmanager.roadmanager.Position) → int ¶: C++: roadmanager::Position::CalcRoutePosition() –> int

CopyRMPos(self: pyroadmanager.roadmanager.Position, from: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::CopyRMPos(class roadmanager::Position *) –> void

Distance(*args, **kwargs)¶

Overloaded function.

Distance(self: pyroadmanager.roadmanager.Position, pos_b: pyroadmanager.roadmanager.Position, cs: pyroadmanager.roadmanager.CoordinateSystem, relDistType: pyroadmanager.roadmanager.RelativeDistanceType, dist: float) -> int
Distance(self: pyroadmanager.roadmanager.Position, pos_b: pyroadmanager.roadmanager.Position, cs: pyroadmanager.roadmanager.CoordinateSystem, relDistType: pyroadmanager.roadmanager.RelativeDistanceType, dist: float, maxDist: float) -> int

Find out the distance, on specified system and type, between two position objects

The position from which to subtract the current position (this position object)

Distance (output parameter)

0 if position found and parameter values are valid, else -1

C++: roadmanager::Position::Distance(class roadmanager::Position *, enum roadmanager::CoordinateSystem, enum roadmanager::RelativeDistanceType, double &, double) –> int

Distance(self: pyroadmanager.roadmanager.Position, x: float, y: float, cs: pyroadmanager.roadmanager.CoordinateSystem, relDistType: pyroadmanager.roadmanager.RelativeDistanceType, dist: float) -> int
Distance(self: pyroadmanager.roadmanager.Position, x: float, y: float, cs: pyroadmanager.roadmanager.CoordinateSystem, relDistType: pyroadmanager.roadmanager.RelativeDistanceType, dist: float, maxDist: float) -> int

Find out the distance, on specified system and type, to a world x, y position

X coordinate of position from which to subtract the current position (this position object)

Y coordinate of position from which to subtract the current position (this position object)

Distance (output parameter)

0 if position found and parameter values are valid, else -1

C++: roadmanager::Position::Distance(double, double, enum roadmanager::CoordinateSystem, enum roadmanager::RelativeDistanceType, double &, double) –> int

DsToDistance(self: pyroadmanager.roadmanager.Position, ds: float) → float ¶: C++: roadmanager::Position::DsToDistance(double) –> double

class ErrorCode¶

Members:

ERROR_NO_ERROR

ERROR_GENERIC

ERROR_END_OF_ROAD

ERROR_END_OF_ROUTE

ERROR_OFF_ROAD

property name¶

EvaluateOrientation(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::EvaluateOrientation() –> void

ForceLaneId(self: pyroadmanager.roadmanager.Position, lane_id: int) → None ¶: C++: roadmanager::Position::ForceLaneId(int) –> void

GetAccLat(self: pyroadmanager.roadmanager.Position) → float ¶: Get lateral component of acceleration in vehicle local coordinate system

C++: roadmanager::Position::GetAccLat() –> double

GetAccLatLong(self: pyroadmanager.roadmanager.Position, alat: float, along: float) → None ¶

Get lateral and longitudinal component of acceleration in vehicle local coordinate system This is slightly more effecient than calling GetAccLat and GetAccLong separately

reference parameter returning lateral acceleration

reference parameter returning longitudinal acceleration

C++: roadmanager::Position::GetAccLatLong(double &, double &) –> void

GetAccLong(self: pyroadmanager.roadmanager.Position) → float ¶: Get longitudinal component of acceleration in vehicle local coordinate system

C++: roadmanager::Position::GetAccLong() –> double

GetAccS(self: pyroadmanager.roadmanager.Position) → float ¶: Get longitudinal component of acceleration in road coordinate system

C++: roadmanager::Position::GetAccS() –> double

GetAccT(self: pyroadmanager.roadmanager.Position) → float ¶: Get lateral component of acceleration in road coordinate system

C++: roadmanager::Position::GetAccT() –> double

GetAccTS(self: pyroadmanager.roadmanager.Position, at: float, as: float) → None ¶

Get lateral and longitudinal component of acceleration in road coordinate system This is slightly more effecient than calling GetAccT and GetAccS separately

reference parameter returning lateral acceleration

reference parameter returning longitudinal acceleration

C++: roadmanager::Position::GetAccTS(double &, double &) –> void

GetAccX(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetAccX() –> double

GetAccY(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetAccY() –> double

GetAccZ(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetAccZ() –> double

GetCurvature(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road curvature at current position

C++: roadmanager::Position::GetCurvature() –> double

GetDrivingDirection(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road heading/direction at current position, and in the direction given by current lane

C++: roadmanager::Position::GetDrivingDirection() const –> double

GetDrivingDirectionRelativeRoad(self: pyroadmanager.roadmanager.Position) → int ¶: Retrieve the driving direction considering lane ID and rult (lef or right hand traffic) Will be either 1 (road direction) or -1 (opposite road direction)

C++: roadmanager::Position::GetDrivingDirectionRelativeRoad() const –> int

GetH(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the world coordinate heading angle (radians)

C++: roadmanager::Position::GetH() const –> double

GetHAcc(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetHAcc() –> double

GetHRate(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetHRate() –> double

GetHRelative(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the relative heading angle (radians)

C++: roadmanager::Position::GetHRelative() const –> double

GetHRelativeDrivingDirection(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the heading angle (radians) relative driving direction (lane sign considered)

C++: roadmanager::Position::GetHRelativeDrivingDirection() const –> double

GetHRoad(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road heading angle (radians)

C++: roadmanager::Position::GetHRoad() const –> double

GetHRoadInDrivingDirection(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road heading angle (radians) relative driving direction (lane sign considered)

C++: roadmanager::Position::GetHRoadInDrivingDirection() const –> double

GetJunctionId(self: pyroadmanager.roadmanager.Position) → int ¶: Retrieve the junction ID from the position object

junction ID, -1 if not in a junction

C++: roadmanager::Position::GetJunctionId() const –> int

GetLaneGlobalId(self: pyroadmanager.roadmanager.Position) → int ¶: Retrieve the global lane ID from the position object

lane ID

C++: roadmanager::Position::GetLaneGlobalId() –> int

GetLaneId(self: pyroadmanager.roadmanager.Position) → int ¶: Retrieve the lane ID from the position object

lane ID

C++: roadmanager::Position::GetLaneId() const –> int

GetOffset(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the offset from current lane

C++: roadmanager::Position::GetOffset() –> double

static GetOpenDrive() → pyroadmanager.roadmanager.OpenDrive ¶: C++: roadmanager::Position::GetOpenDrive() –> class roadmanager::OpenDrive *

GetOrientationType(self: pyroadmanager.roadmanager.Position) → pyroadmanager.roadmanager.Position.OrientationType ¶: C++: roadmanager::Position::GetOrientationType() –> enum roadmanager::Position::OrientationType

GetP(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the world coordinate pitch angle (radians)

C++: roadmanager::Position::GetP() –> double

GetPAcc(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetPAcc() –> double

GetPRate(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetPRate() –> double

GetPRelative(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the relative pitch angle (radians)

C++: roadmanager::Position::GetPRelative() –> double

GetPRoad(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road pitch value

C++: roadmanager::Position::GetPRoad() const –> double

GetPRoadInDrivingDirection(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road pitch value, driving direction considered

C++: roadmanager::Position::GetPRoadInDrivingDirection() –> double

GetR(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the world coordinate roll angle (radians)

C++: roadmanager::Position::GetR() –> double

GetRAcc(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetRAcc() –> double

GetRRate(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetRRate() –> double

GetRRelative(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the relative roll angle (radians)

C++: roadmanager::Position::GetRRelative() –> double

GetRRoad(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road roll value

C++: roadmanager::Position::GetRRoad() const –> double

GetRelativePosition(self: pyroadmanager.roadmanager.Position) → pyroadmanager.roadmanager.Position ¶: C++: roadmanager::Position::GetRelativePosition() –> class roadmanager::Position *

GetRoadById(self: pyroadmanager.roadmanager.Position, id: int) → pyroadmanager.roadmanager.Road ¶: Retrieve a road segment specified by road ID

road ID as specified in the OpenDRIVE file

C++: roadmanager::Position::GetRoadById(int) const –> class roadmanager::Road *

GetRoute(self: pyroadmanager.roadmanager.Position) → roadmanager::Route¶: C++: roadmanager::Position::GetRoute() –> class roadmanager::Route *

GetRouteS(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the S-value of the current route position. Note: This is the S along the complete route, not the actual individual roads.

C++: roadmanager::Position::GetRouteS() –> double

GetS(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the s value (distance along the road segment)

C++: roadmanager::Position::GetS() const –> double

GetSpeedLimit(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the speed limit at current position

C++: roadmanager::Position::GetSpeedLimit() –> double

GetStatusBitMask(self: pyroadmanager.roadmanager.Position) → int ¶: C++: roadmanager::Position::GetStatusBitMask() –> int

GetT(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the t value (lateral distance from reference lanem (id=0))

C++: roadmanager::Position::GetT() const –> double

GetTrackId(self: pyroadmanager.roadmanager.Position) → int ¶: Retrieve the track/road ID from the position object

track/road ID

C++: roadmanager::Position::GetTrackId() const –> int

GetTrajectory(self: pyroadmanager.roadmanager.Position) → roadmanager::RMTrajectory¶: C++: roadmanager::Position::GetTrajectory() –> class roadmanager::RMTrajectory *

GetTrajectoryS(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the S-value of the current trajectory position

C++: roadmanager::Position::GetTrajectoryS() –> double

GetTrajectoryT(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the T-value of the current trajectory position

C++: roadmanager::Position::GetTrajectoryT() –> double

GetType(self: pyroadmanager.roadmanager.Position) → pyroadmanager.roadmanager.Position.PositionType ¶: C++: roadmanager::Position::GetType() –> enum roadmanager::Position::PositionType

GetVelLat(self: pyroadmanager.roadmanager.Position) → float ¶: Get lateral component of velocity in vehicle local coordinate system

C++: roadmanager::Position::GetVelLat() –> double

GetVelLatLong(self: pyroadmanager.roadmanager.Position, vlat: float, vlong: float) → None ¶

Get lateral and longitudinal component of velocity in vehicle local coordinate system This is slightly more effecient than calling GetVelLat and GetVelLong separately

reference parameter returning lateral velocity

reference parameter returning longitudinal velocity

C++: roadmanager::Position::GetVelLatLong(double &, double &) –> void

GetVelLong(self: pyroadmanager.roadmanager.Position) → float ¶: Get longitudinal component of velocity in vehicle local coordinate system

C++: roadmanager::Position::GetVelLong() –> double

GetVelS(self: pyroadmanager.roadmanager.Position) → float ¶: Get longitudinal component of velocity in road coordinate system

C++: roadmanager::Position::GetVelS() –> double

GetVelT(self: pyroadmanager.roadmanager.Position) → float ¶: Get lateral component of velocity in road coordinate system

C++: roadmanager::Position::GetVelT() –> double

GetVelTS(self: pyroadmanager.roadmanager.Position, vt: float, vs: float) → None ¶

Get lateral and longitudinal component of velocity in road coordinate system This is slightly more effecient than calling GetVelT and GetVelS separately

reference parameter returning lateral velocity

reference parameter returning longitudinal velocity

C++: roadmanager::Position::GetVelTS(double &, double &) –> void

GetVelX(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetVelX() –> double

GetVelY(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetVelY() –> double

GetVelZ(self: pyroadmanager.roadmanager.Position) → float ¶: C++: roadmanager::Position::GetVelZ() –> double

GetX(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the world coordinate X-value

C++: roadmanager::Position::GetX() const –> double

GetY(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the world coordinate Y-value

C++: roadmanager::Position::GetY() const –> double

GetZ(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the world coordinate Z-value

C++: roadmanager::Position::GetZ() const –> double

GetZRoad(self: pyroadmanager.roadmanager.Position) → float ¶: Retrieve the road Z-value

C++: roadmanager::Position::GetZRoad() const –> double

GotoClosestDrivingLaneAtCurrentPosition(self: pyroadmanager.roadmanager.Position) → int ¶: C++: roadmanager::Position::GotoClosestDrivingLaneAtCurrentPosition() –> int

Init(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::Init() –> void

IsAheadOf(self: pyroadmanager.roadmanager.Position, target_position: pyroadmanager.roadmanager.Position) → bool ¶: Is the current position ahead of the one specified in argument This method is more efficient than getRelativeDistance

The position to compare the current to.

true of false

C++: roadmanager::Position::IsAheadOf(class roadmanager::Position) –> bool

IsInJunction(self: pyroadmanager.roadmanager.Position) → bool ¶: C++: roadmanager::Position::IsInJunction() –> bool

IsOffRoad(self: pyroadmanager.roadmanager.Position) → bool ¶: C++: roadmanager::Position::IsOffRoad() –> bool

static LoadOpenDrive(filename: str) → bool ¶: C++: roadmanager::Position::LoadOpenDrive(const char *) –> bool

class LookAheadMode¶

Members:

LOOKAHEADMODE_AT_LANE_CENTER

LOOKAHEADMODE_AT_ROAD_CENTER

LOOKAHEADMODE_AT_CURRENT_LATERAL_OFFSET

property name¶

MoveAlongS(*args, **kwargs)¶

Overloaded function.

MoveAlongS(self: pyroadmanager.roadmanager.Position, ds: float, dLaneOffset: float, junctionSelectorAngle: float) -> pyroadmanager.roadmanager.Position.ErrorCode
MoveAlongS(self: pyroadmanager.roadmanager.Position, ds: float, dLaneOffset: float, junctionSelectorAngle: float, actualDistance: bool) -> pyroadmanager.roadmanager.Position.ErrorCode

Move position along the road network, forward or backward, from the current position It will automatically follow connecting lanes between connected roads If reaching a junction, choose way according to specified junctionSelectorAngle

distance to move from current position

delta lane offset (adding to current position lane offset)

Desired direction [0:2pi] from incoming road direction (angle = 0), set -1 to randomize

Distance considering lateral offset and curvature (true/default) or along centerline (false)

0 if successful, other codes see Position::ErrorCode

C++: roadmanager::Position::MoveAlongS(double, double, double, bool) –> enum roadmanager::Position::ErrorCode

MoveAlongS(self: pyroadmanager.roadmanager.Position, ds: float) -> pyroadmanager.roadmanager.Position.ErrorCode
MoveAlongS(self: pyroadmanager.roadmanager.Position, ds: float, actualDistance: bool) -> pyroadmanager.roadmanager.Position.ErrorCode

Move position along the road network, forward or backward, from the current position It will automatically follow connecting lanes between connected roads If multiple options (only possible in junctions) it will choose randomly

distance to move from current position

0 if successful, other codes see Position::ErrorCode

C++: roadmanager::Position::MoveAlongS(double, bool) –> enum roadmanager::Position::ErrorCode

MoveRouteDS(*args, **kwargs)¶

Overloaded function.

MoveRouteDS(self: pyroadmanager.roadmanager.Position, ds: float) -> pyroadmanager.roadmanager.Position.ErrorCode
MoveRouteDS(self: pyroadmanager.roadmanager.Position, ds: float, actualDistance: bool) -> pyroadmanager.roadmanager.Position.ErrorCode

Move current position forward, or backwards, ds meters along the route

Distance to move, negative will move backwards

Distance considering lateral offset and curvature (true/default) or along centerline (false)

Non zero return value indicates error of some kind, most likely End Of Route

C++: roadmanager::Position::MoveRouteDS(double, bool) –> enum roadmanager::Position::ErrorCode

MoveToConnectingRoad(*args, **kwargs)¶

Overloaded function.

MoveToConnectingRoad(self: pyroadmanager.roadmanager.Position, road_link: pyroadmanager.roadmanager.RoadLink, contact_point_type: pyroadmanager.roadmanager.ContactPointType) -> int
MoveToConnectingRoad(self: pyroadmanager.roadmanager.Position, road_link: pyroadmanager.roadmanager.RoadLink, contact_point_type: pyroadmanager.roadmanager.ContactPointType, junctionSelectorAngle: float) -> int

C++: roadmanager::Position::MoveToConnectingRoad(class roadmanager::RoadLink *, enum roadmanager::ContactPointType &, double) –> int

MoveTrajectoryDS(self: pyroadmanager.roadmanager.Position, ds: float) → int ¶: Move current position forward, or backwards, ds meters along the trajectory

Distance to move, negative will move backwards

Non zero return value indicates error of some kind

C++: roadmanager::Position::MoveTrajectoryDS(double) –> int

class OrientationType¶

Members:

ORIENTATION_RELATIVE

ORIENTATION_ABSOLUTE

property name¶

class PositionStatusMode¶

Members:

POS_STATUS_END_OF_ROAD

POS_STATUS_END_OF_ROUTE

property name¶

class PositionType¶

Members:

NORMAL

ROUTE

RELATIVE_OBJECT

RELATIVE_WORLD

RELATIVE_LANE

RELATIVE_ROAD

property name¶

Print(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::Print() –> void

PrintInertialPos(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::PrintInertialPos() –> void

PrintLanePos(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::PrintLanePos() –> void

PrintTrackPos(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::PrintTrackPos() –> void

PrintXY(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::PrintXY() –> void

ReleaseRelation(self: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::ReleaseRelation() –> void

ReplaceObjectRefs(self: pyroadmanager.roadmanager.Position, pos1: pyroadmanager.roadmanager.Position, pos2: pyroadmanager.roadmanager.Position) → None ¶: C++: roadmanager::Position::ReplaceObjectRefs(class roadmanager::Position *, class roadmanager::Position *) –> void

SetAcc(self: pyroadmanager.roadmanager.Position, x_acc: float, y_acc: float, z_acc: float) → None ¶: C++: roadmanager::Position::SetAcc(double, double, double) –> void

SetAlignMode(self: pyroadmanager.roadmanager.Position, mode: roadmanager::Position::ALIGN_MODE) → None ¶: C++: roadmanager::Position::SetAlignMode(roadmanager::Position::ALIGN_MODE) –> void

SetAlignModeH(self: pyroadmanager.roadmanager.Position, mode: roadmanager::Position::ALIGN_MODE) → None ¶: C++: roadmanager::Position::SetAlignModeH(roadmanager::Position::ALIGN_MODE) –> void

SetAlignModeP(self: pyroadmanager.roadmanager.Position, mode: roadmanager::Position::ALIGN_MODE) → None ¶: C++: roadmanager::Position::SetAlignModeP(roadmanager::Position::ALIGN_MODE) –> void

SetAlignModeR(self: pyroadmanager.roadmanager.Position, mode: roadmanager::Position::ALIGN_MODE) → None ¶: C++: roadmanager::Position::SetAlignModeR(roadmanager::Position::ALIGN_MODE) –> void

SetAlignModeZ(self: pyroadmanager.roadmanager.Position, mode: roadmanager::Position::ALIGN_MODE) → None ¶: C++: roadmanager::Position::SetAlignModeZ(roadmanager::Position::ALIGN_MODE) –> void

SetAngularAcc(self: pyroadmanager.roadmanager.Position, h_acc: float, p_acc: float, r_acc: float) → None ¶: C++: roadmanager::Position::SetAngularAcc(double, double, double) –> void

SetAngularVel(self: pyroadmanager.roadmanager.Position, h_vel: float, p_vel: float, r_vel: float) → None ¶: C++: roadmanager::Position::SetAngularVel(double, double, double) –> void

SetH(self: pyroadmanager.roadmanager.Position, h: float) → None ¶: C++: roadmanager::Position::SetH(double) –> void

SetHeading(self: pyroadmanager.roadmanager.Position, heading: float) → None ¶: C++: roadmanager::Position::SetHeading(double) –> void

SetHeadingRelative(self: pyroadmanager.roadmanager.Position, heading: float) → None ¶: C++: roadmanager::Position::SetHeadingRelative(double) –> void

SetHeadingRelativeRoadDirection(self: pyroadmanager.roadmanager.Position, heading: float) → None ¶: C++: roadmanager::Position::SetHeadingRelativeRoadDirection(double) –> void

SetInertiaPos(*args, **kwargs)¶

Overloaded function.

SetInertiaPos(self: pyroadmanager.roadmanager.Position, x: float, y: float, z: float, h: float, p: float, r: float) -> int
SetInertiaPos(self: pyroadmanager.roadmanager.Position, x: float, y: float, z: float, h: float, p: float, r: float, updateTrackPos: bool) -> int

Specify position by cartesian x, y, z and heading, pitch, roll

x

y

z

heading

pitch

roll

True: road position will be calculated False: don’t update road position

Non zero return value indicates error of some kind

C++: roadmanager::Position::SetInertiaPos(double, double, double, double, double, double, bool) –> int

SetInertiaPos(self: pyroadmanager.roadmanager.Position, x: float, y: float, h: float) -> int
SetInertiaPos(self: pyroadmanager.roadmanager.Position, x: float, y: float, h: float, updateTrackPos: bool) -> int

Specify position by cartesian x, y and heading. z, pitch and roll will be aligned to road.

x

y

heading

True: road position will be calculated False: don’t update road position

Non zero return value indicates error of some kind

C++: roadmanager::Position::SetInertiaPos(double, double, double, bool) –> int

SetLaneBoundaryPos(*args, **kwargs)¶

Overloaded function.

SetLaneBoundaryPos(self: pyroadmanager.roadmanager.Position, track_id: int, lane_id: int, s: float, offset: float) -> None
SetLaneBoundaryPos(self: pyroadmanager.roadmanager.Position, track_id: int, lane_id: int, s: float, offset: float, lane_section_idx: int) -> None

C++: roadmanager::Position::SetLaneBoundaryPos(int, int, double, double, int) –> void

SetLaneId(self: pyroadmanager.roadmanager.Position, laneId: int) → None ¶: C++: roadmanager::Position::SetLaneId(int) –> void

SetLanePos(*args, **kwargs)¶

Overloaded function.

SetLanePos(self: pyroadmanager.roadmanager.Position, track_id: int, lane_id: int, s: float, offset: float) -> pyroadmanager.roadmanager.Position.ErrorCode
SetLanePos(self: pyroadmanager.roadmanager.Position, track_id: int, lane_id: int, s: float, offset: float, lane_section_idx: int) -> pyroadmanager.roadmanager.Position.ErrorCode

C++: roadmanager::Position::SetLanePos(int, int, double, double, int) –> enum roadmanager::Position::ErrorCode

SetLockOnLane(self: pyroadmanager.roadmanager.Position, mode: bool) → None ¶

Controls whether to keep lane ID regardless of lateral position or snap to closest lane (default)
mode True=keep lane False=Snap to closest (default)

C++: roadmanager::Position::SetLockOnLane(bool) –> void

SetOffset(self: pyroadmanager.roadmanager.Position, offset: float) → None ¶: C++: roadmanager::Position::SetOffset(double) –> void

SetOrientationType(self: pyroadmanager.roadmanager.Position, type: pyroadmanager.roadmanager.Position.OrientationType) → None ¶: C++: roadmanager::Position::SetOrientationType(enum roadmanager::Position::OrientationType) –> void

SetP(self: pyroadmanager.roadmanager.Position, p: float) → None ¶: C++: roadmanager::Position::SetP(double) –> void

SetPitch(self: pyroadmanager.roadmanager.Position, roll: float) → None ¶: C++: roadmanager::Position::SetPitch(double) –> void

SetPitchRelative(self: pyroadmanager.roadmanager.Position, pitch: float) → None ¶: C++: roadmanager::Position::SetPitchRelative(double) –> void

SetR(self: pyroadmanager.roadmanager.Position, r: float) → None ¶: C++: roadmanager::Position::SetR(double) –> void

SetRelativePosition(self: pyroadmanager.roadmanager.Position, rel_pos: pyroadmanager.roadmanager.Position, type: pyroadmanager.roadmanager.Position.PositionType) → None ¶: C++: roadmanager::Position::SetRelativePosition(class roadmanager::Position *, enum roadmanager::Position::PositionType) –> void

SetRoadMarkPos(*args, **kwargs)¶

Overloaded function.

SetRoadMarkPos(self: pyroadmanager.roadmanager.Position, track_id: int, lane_id: int, roadmark_idx: int, roadmarktype_idx: int, roadmarkline_idx: int, s: float, offset: float) -> None
SetRoadMarkPos(self: pyroadmanager.roadmanager.Position, track_id: int, lane_id: int, roadmark_idx: int, roadmarktype_idx: int, roadmarkline_idx: int, s: float, offset: float, lane_section_idx: int) -> None

C++: roadmanager::Position::SetRoadMarkPos(int, int, int, int, int, double, double, int) –> void

SetRoll(self: pyroadmanager.roadmanager.Position, roll: float) → None ¶: C++: roadmanager::Position::SetRoll(double) –> void

SetRollRelative(self: pyroadmanager.roadmanager.Position, roll: float) → None ¶: C++: roadmanager::Position::SetRollRelative(double) –> void

SetRoute(self: pyroadmanager.roadmanager.Position, route: roadmanager::Route) → int ¶: C++: roadmanager::Position::SetRoute(class roadmanager::Route *) –> int

SetRouteLanePosition(self: pyroadmanager.roadmanager.Position, route: roadmanager::Route, route_s: float, laneId: int, laneOffset: float) → int ¶: Move current position along the route

Distance to move, negative will move backwards

Non zero return value indicates error of some kind

C++: roadmanager::Position::SetRouteLanePosition(class roadmanager::Route *, double, int, double) –> int

SetRoutePosition(self: pyroadmanager.roadmanager.Position, position: pyroadmanager.roadmanager.Position) → int ¶: Set the current position along the route.

A regular position created with road, lane or world coordinates

Non zero return value indicates error of some kind

C++: roadmanager::Position::SetRoutePosition(class roadmanager::Position *) –> int

SetRouteS(self: pyroadmanager.roadmanager.Position, route: roadmanager::Route, route_s: float) → pyroadmanager.roadmanager.Position.ErrorCode ¶: Move current position to specified S-value along the route

Distance to move, negative will move backwards

Non zero return value indicates error of some kind, most likely End Of Route

C++: roadmanager::Position::SetRouteS(class roadmanager::Route *, double) –> enum roadmanager::Position::ErrorCode

SetS(self: pyroadmanager.roadmanager.Position, s: float) → None ¶: C++: roadmanager::Position::SetS(double) –> void

SetSnapLaneTypes(self: pyroadmanager.roadmanager.Position, laneTypeMask: int) → None ¶

Specify which lane types the position object snaps to (is aware of)

A combination (bitmask) of lane types

C++: roadmanager::Position::SetSnapLaneTypes(int) –> void

SetT(self: pyroadmanager.roadmanager.Position, t: float) → None ¶: C++: roadmanager::Position::SetT(double) –> void

SetTrackId(self: pyroadmanager.roadmanager.Position, trackId: int) → None ¶: C++: roadmanager::Position::SetTrackId(int) –> void

SetTrackPos(*args, **kwargs)¶

Overloaded function.

SetTrackPos(self: pyroadmanager.roadmanager.Position, track_id: int, s: float, t: float) -> pyroadmanager.roadmanager.Position.ErrorCode
SetTrackPos(self: pyroadmanager.roadmanager.Position, track_id: int, s: float, t: float, UpdateXY: bool) -> pyroadmanager.roadmanager.Position.ErrorCode

Specify position by track coordinate (road_id, s, t)

Id of the road (track)

Distance to the position along and from the start of the road (track)

update world coordinates x, y… as well - or not

Non zero return value indicates error of some kind

C++: roadmanager::Position::SetTrackPos(int, double, double, bool) –> enum roadmanager::Position::ErrorCode

SetTrajectory(self: pyroadmanager.roadmanager.Position, trajectory: roadmanager::RMTrajectory) → None ¶: C++: roadmanager::Position::SetTrajectory(class roadmanager::RMTrajectory *) –> void

SetTrajectoryPosByTime(self: pyroadmanager.roadmanager.Position, time: float) → int ¶: C++: roadmanager::Position::SetTrajectoryPosByTime(double) –> int

SetTrajectoryS(self: pyroadmanager.roadmanager.Position, trajectory_s: float) → int ¶: Move current position to specified S-value along the trajectory

Distance from start of the trajectory

Non zero return value indicates error of some kind

C++: roadmanager::Position::SetTrajectoryS(double) –> int

SetTrajectoryT(self: pyroadmanager.roadmanager.Position, trajectory_t: float) → int ¶: Move current position to specified T-value along the trajectory

Lateral distance from trajectory at current s-value

Non zero return value indicates error of some kind

C++: roadmanager::Position::SetTrajectoryT(double) –> int

SetVel(self: pyroadmanager.roadmanager.Position, x_vel: float, y_vel: float, z_vel: float) → None ¶: C++: roadmanager::Position::SetVel(double, double, double) –> void

SetX(self: pyroadmanager.roadmanager.Position, x: float) → None ¶: C++: roadmanager::Position::SetX(double) –> void

SetY(self: pyroadmanager.roadmanager.Position, y: float) → None ¶: C++: roadmanager::Position::SetY(double) –> void

SetZ(self: pyroadmanager.roadmanager.Position, z: float) → None ¶: C++: roadmanager::Position::SetZ(double) –> void

SetZRelative(self: pyroadmanager.roadmanager.Position, z: float) → None ¶: C++: roadmanager::Position::SetZRelative(double) –> void

class UpdateTrackPosMode¶

Members:

UPDATE_NOT_XYZH

UPDATE_XYZ

UPDATE_XYZH

property name¶

XYZH2TrackPos(*args, **kwargs)¶

Overloaded function.

XYZH2TrackPos(self: pyroadmanager.roadmanager.Position, x: float, y: float, z: float, h: float) -> pyroadmanager.roadmanager.Position.ErrorCode
XYZH2TrackPos(self: pyroadmanager.roadmanager.Position, x: float, y: float, z: float, h: float, connectedOnly: bool) -> pyroadmanager.roadmanager.Position.ErrorCode
XYZH2TrackPos(self: pyroadmanager.roadmanager.Position, x: float, y: float, z: float, h: float, connectedOnly: bool, roadId: int) -> pyroadmanager.roadmanager.Position.ErrorCode

Specify position by cartesian coordinate (x, y, z, h)

X-coordinate

Y-coordinate

Z-coordinate

Heading

If true only roads that can be reached from current position will be considered, if false all roads will be considered

If != -1 only this road will be considered else all roads will be searched

Non zero return value indicates error of some kind

C++: roadmanager::Position::XYZH2TrackPos(double, double, double, double, bool, int) –> enum roadmanager::Position::ErrorCode

assign(self: pyroadmanager.roadmanager.Position, : pyroadmanager.roadmanager.Position) → pyroadmanager.roadmanager.Position ¶: C++: roadmanager::Position::operator=(const class roadmanager::Position &) –> class roadmanager::Position &

getRelativeDistance(self: pyroadmanager.roadmanager.Position, targetX: float, targetY: float, x: float, y: float) → float ¶: Straight (not route) distance between the current position and the one specified in argument

The position to measure distance from current position.

(meter). X component of the relative distance.

(meter). Y component of the relative distance.

distance (meter). Negative if the specified position is behind the current one.

C++: roadmanager::Position::getRelativeDistance(double, double, double &, double &) const –> double

class pyroadmanager.roadmanager.Route¶

AddWaypoint(self: pyroadmanager.roadmanager.Route, position: pyroadmanager.roadmanager.Position) → int ¶: Adds a waypoint to the route. One waypoint per road. At most one junction between waypoints.

A regular position created with road, lane or world coordinates

Non zero return value indicates error of some kind

C++: roadmanager::Route::AddWaypoint(class roadmanager::Position *) –> int

GetLength(self: pyroadmanager.roadmanager.Route) → float ¶: C++: roadmanager::Route::GetLength() –> double

GetWayPointDirection(self: pyroadmanager.roadmanager.Route, index: int) → int ¶: C++: roadmanager::Route::GetWayPointDirection(int) –> int

class pyroadmanager.roadmanager.RoadPath¶

Calculate(*args, **kwargs)¶

Overloaded function.

Calculate(self: pyroadmanager.roadmanager.RoadPath, dist: float) -> int
Calculate(self: pyroadmanager.roadmanager.RoadPath, dist: float, bothDirections: bool) -> int
Calculate(self: pyroadmanager.roadmanager.RoadPath, dist: float, bothDirections: bool, maxDist: float) -> int

Calculate shortest path between starting position and target position, using Dijkstra’s algorithm https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm it also calculates the length of the path, or distance between the positions positive distance means that the shortest path was found in forward direction negative distance means that the shortest path goes in opposite direction from the heading of the starting position

A reference parameter into which the calculated path distance is stored

Set to true in order to search also backwards from object

If set the search along each path branch will terminate after reaching this distance

0 on success, -1 on failure e.g. path not found

C++: roadmanager::RoadPath::Calculate(double &, bool, double) –> int

class pyroadmanager.roadmanager.PolyLineBase¶

GetNumberOfVertices(self: pyroadmanager.roadmanager.PolyLineBase) → int ¶: C++: roadmanager::PolyLineBase::GetNumberOfVertices() –> int

Reset(self: pyroadmanager.roadmanager.PolyLineBase) → None ¶: C++: roadmanager::PolyLineBase::Reset() –> void

Time2S(self: pyroadmanager.roadmanager.PolyLineBase, time: float, s: float) → int ¶: C++: roadmanager::PolyLineBase::Time2S(double, double &) –> int

assign(self: pyroadmanager.roadmanager.PolyLineBase, : pyroadmanager.roadmanager.PolyLineBase) → pyroadmanager.roadmanager.PolyLineBase ¶: C++: roadmanager::PolyLineBase::operator=(const class roadmanager::PolyLineBase &) –> class roadmanager::PolyLineBase &

reset(self: pyroadmanager.roadmanager.PolyLineBase) → None ¶: C++: roadmanager::PolyLineBase::reset() –> void

class pyroadmanager.roadmanager.Shape¶

GetDuration(self: pyroadmanager.roadmanager.Shape) → float ¶: C++: roadmanager::Shape::GetDuration() –> double

GetLength(self: pyroadmanager.roadmanager.Shape) → float ¶: C++: roadmanager::Shape::GetLength() –> double

GetStartTime(self: pyroadmanager.roadmanager.Shape) → float ¶: C++: roadmanager::Shape::GetStartTime() –> double

assign(self: pyroadmanager.roadmanager.Shape, : pyroadmanager.roadmanager.Shape) → pyroadmanager.roadmanager.Shape ¶: C++: roadmanager::Shape::operator=(const class roadmanager::Shape &) –> class roadmanager::Shape &

class pyroadmanager.roadmanager.PolyLineShape¶

AddVertex(self: pyroadmanager.roadmanager.PolyLineShape, pos: pyroadmanager.roadmanager.Position, time: float, calculateHeading: bool) → None ¶: C++: roadmanager::PolyLineShape::AddVertex(class roadmanager::Position, double, bool) –> void

GetDuration(self: pyroadmanager.roadmanager.PolyLineShape) → float ¶: C++: roadmanager::PolyLineShape::GetDuration() –> double

GetLength(self: pyroadmanager.roadmanager.PolyLineShape) → float ¶: C++: roadmanager::PolyLineShape::GetLength() –> double

GetStartTime(self: pyroadmanager.roadmanager.PolyLineShape) → float ¶: C++: roadmanager::PolyLineShape::GetStartTime() –> double

assign(self: pyroadmanager.roadmanager.PolyLineShape, : pyroadmanager.roadmanager.PolyLineShape) → pyroadmanager.roadmanager.PolyLineShape ¶: C++: roadmanager::PolyLineShape::operator=(const class roadmanager::PolyLineShape &) –> class roadmanager::PolyLineShape &

class pyroadmanager.roadmanager.ClothoidShape¶

CalculatePolyLine(self: pyroadmanager.roadmanager.ClothoidShape) → None ¶: C++: roadmanager::ClothoidShape::CalculatePolyLine() –> void

GetDuration(self: pyroadmanager.roadmanager.ClothoidShape) → float ¶: C++: roadmanager::ClothoidShape::GetDuration() –> double

GetLength(self: pyroadmanager.roadmanager.ClothoidShape) → float ¶: C++: roadmanager::ClothoidShape::GetLength() –> double

GetStartTime(self: pyroadmanager.roadmanager.ClothoidShape) → float ¶: C++: roadmanager::ClothoidShape::GetStartTime() –> double

assign(self: pyroadmanager.roadmanager.ClothoidShape, : pyroadmanager.roadmanager.ClothoidShape) → pyroadmanager.roadmanager.ClothoidShape ¶: C++: roadmanager::ClothoidShape::operator=(const class roadmanager::ClothoidShape &) –> class roadmanager::ClothoidShape &

class pyroadmanager.roadmanager.NurbsShape¶

This nurbs implementation is strongly inspired by the “Nurbs Curve Example” at: https://nccastaff.bournemouth.ac.uk/jmacey/OldWeb/RobTheBloke/www/opengl_programming.html

AddControlPoint(self: pyroadmanager.roadmanager.NurbsShape, pos: pyroadmanager.roadmanager.Position, time: float, weight: float, calcHeading: bool) → None ¶: C++: roadmanager::NurbsShape::AddControlPoint(class roadmanager::Position, double, double, bool) –> void

CalculatePolyLine(self: pyroadmanager.roadmanager.NurbsShape) → None ¶: C++: roadmanager::NurbsShape::CalculatePolyLine() –> void

GetDuration(self: pyroadmanager.roadmanager.NurbsShape) → float ¶: C++: roadmanager::NurbsShape::GetDuration() –> double

GetLength(self: pyroadmanager.roadmanager.NurbsShape) → float ¶: C++: roadmanager::NurbsShape::GetLength() –> double

< [Page truncated to keep GeezerVison snappy.]