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

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.RMTrajectory¶

Freeze(self: pyroadmanager.roadmanager.RMTrajectory) → None ¶: C++: roadmanager::RMTrajectory::Freeze() –> void

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

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

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

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

Scenario Engine¶

Bindings for ::scenarioengine namespace

pyscenarioengine.scenarioengine.InstantiateController(args: capsule) → pyscenarioengine.scenarioengine.Controller ¶: C++: scenarioengine::InstantiateController(void *) –> class scenarioengine::Controller *

class pyscenarioengine.scenarioengine.Object¶

CheckDirtyBits(self: pyscenarioengine.scenarioengine.Object, bits: int) → bool ¶: C++: scenarioengine::Object::CheckDirtyBits(int) –> bool

ClearDirtyBits(*args, **kwargs)¶

Overloaded function.

ClearDirtyBits(self: pyscenarioengine.scenarioengine.Object, bits: int) -> None

C++: scenarioengine::Object::ClearDirtyBits(int) –> void

ClearDirtyBits(self: pyscenarioengine.scenarioengine.Object) -> None

C++: scenarioengine::Object::ClearDirtyBits() –> void

Collision(self: pyscenarioengine.scenarioengine.Object, target: pyscenarioengine.scenarioengine.Object) → bool ¶: C++: scenarioengine::Object::Collision(class scenarioengine::Object *) –> bool

CollisionAndRelativeDistLatLong(self: pyscenarioengine.scenarioengine.Object, target: pyscenarioengine.scenarioengine.Object, distLat: float, distLong: float) → bool ¶: Check if object is colliding/overlapping with specified target object Definition of collision is overlapping bounding boxes

The object to check

true if bounding boxes overlap else false

C++: scenarioengine::Object::CollisionAndRelativeDistLatLong(class scenarioengine::Object *, double *, double *) –> bool

Distance(*args, **kwargs)¶

Overloaded function.

Distance(self: pyscenarioengine.scenarioengine.Object, target: pyscenarioengine.scenarioengine.Object, cs: roadmanager::CoordinateSystem, relDistType: roadmanager::RelativeDistanceType, freeSpace: bool, dist: float) -> int
Distance(self: pyscenarioengine.scenarioengine.Object, target: pyscenarioengine.scenarioengine.Object, cs: roadmanager::CoordinateSystem, relDistType: roadmanager::RelativeDistanceType, freeSpace: bool, dist: float, maxDist: float) -> int

Measure the distance to provided target object

The object to check

CoordinateSystem, see roadmanager::CoordinateSystem

see roadmanager::RelativeDistanceType

measure free distance between bounding boxes or just refpoint to refpoint

Distance (output parameter)

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

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

Distance(self: pyscenarioengine.scenarioengine.Object, x: float, y: float, cs: roadmanager::CoordinateSystem, relDistType: roadmanager::RelativeDistanceType, freeSpace: bool, dist: float) -> int
Distance(self: pyscenarioengine.scenarioengine.Object, x: float, y: float, cs: roadmanager::CoordinateSystem, relDistType: roadmanager::RelativeDistanceType, freeSpace: bool, dist: float, maxDist: float) -> int

Measure the distance to provided target world x, y position

X coordinate of target world position

Y coordinate of target world position

CoordinateSystem, see roadmanager::CoordinateSystem

see roadmanager::RelativeDistanceType

measure free distance between bounding boxes or just refpoint to refpoint

Distance (output parameter)

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

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

FreeSpaceDistance(self: pyscenarioengine.scenarioengine.Object, target: pyscenarioengine.scenarioengine.Object, latDist: float, longDist: float) → float ¶: Measure the free-space distance to provided target object based on closest distance between the bounding boxes

The object to check

Returns lateral distance to target object

Returns longitudinal distance to target object

distance The free-space Euclidean distance between objects (0 if collision)

C++: scenarioengine::Object::FreeSpaceDistance(class scenarioengine::Object *, double *, double *) –> double

FreeSpaceDistanceObjectRoadLane(self: pyscenarioengine.scenarioengine.Object, target: pyscenarioengine.scenarioengine.Object, latDist: float, longDist: float, cs: roadmanager::CoordinateSystem) → int ¶: C++: scenarioengine::Object::FreeSpaceDistanceObjectRoadLane(class scenarioengine::Object *, double *, double *, enum roadmanager::CoordinateSystem) –> int

FreeSpaceDistancePoint(self: pyscenarioengine.scenarioengine.Object, x: float, y: float, latDist: float, longDist: float) → float ¶: Measure the free-space distance to provided target 2D position based on closest point on object’s bounding box

X coordinate of target point

Y coordinate of target point

Returns lateral distance

Returns longitudinal distance

distance The free-space Euclidean distance between objects (0 if collision)

C++: scenarioengine::Object::FreeSpaceDistancePoint(double, double, double *, double *) –> double

FreeSpaceDistancePointRoadLane(self: pyscenarioengine.scenarioengine.Object, x: float, y: float, latDist: float, longDist: float, cs: roadmanager::CoordinateSystem) → int ¶: C++: scenarioengine::Object::FreeSpaceDistancePointRoadLane(double, double, double *, double *, enum roadmanager::CoordinateSystem) –> int

GetActivatedControllerType(self: pyscenarioengine.scenarioengine.Object) → int ¶: C++: scenarioengine::Object::GetActivatedControllerType() –> int

GetAssignedControllerType(self: pyscenarioengine.scenarioengine.Object) → int ¶: C++: scenarioengine::Object::GetAssignedControllerType() –> int

GetControllerMode(self: pyscenarioengine.scenarioengine.Object) → int ¶: C++: scenarioengine::Object::GetControllerMode() –> int

GetEndOfRoadTimestamp(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetEndOfRoadTimestamp() –> double

GetGhost(self: pyscenarioengine.scenarioengine.Object) → pyscenarioengine.scenarioengine.Object ¶: C++: scenarioengine::Object::GetGhost() –> class scenarioengine::Object *

GetHeadstartTime(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetHeadstartTime() –> double

GetId(self: pyscenarioengine.scenarioengine.Object) → int ¶: C++: scenarioengine::Object::GetId() –> int

GetJunctionSelectorAngle(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetJunctionSelectorAngle() –> double

GetJunctionSelectorStrategy(self: pyscenarioengine.scenarioengine.Object) → roadmanager::Junction::JunctionStrategyType¶: Get current strategy how to choose way in next junction

JunctionStrategyType: Use specified angle (SetJunctionSelectorAngle*) or randomize. See roadmanager::Junction::JunctionStrategyType.

C++: scenarioengine::Object::GetJunctionSelectorStrategy() –> roadmanager::Junction::JunctionStrategyType

GetMaxAcceleration(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetMaxAcceleration() –> double

GetMaxDeceleration(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetMaxDeceleration() –> double

GetMaxSpeed(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetMaxSpeed() –> double

GetOffRoadTimestamp(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetOffRoadTimestamp() –> double

GetSpeed(self: pyscenarioengine.scenarioengine.Object) → float ¶: C++: scenarioengine::Object::GetSpeed() –> double

GetStandStillTimestamp(self: pyscenarioengine.scenarioengine.Object) → float ¶: Returns the timestamp from which the entity has not moved.

The timestamp in seconds.

C++: scenarioengine::Object::GetStandStillTimestamp() –> double

IsControllerActive(self: pyscenarioengine.scenarioengine.Object) → bool ¶: C++: scenarioengine::Object::IsControllerActive() –> bool

IsControllerActiveOnAnyOfDomains(self: pyscenarioengine.scenarioengine.Object, domainMask: pyscenarioengine.ControlDomains) → bool ¶: C++: scenarioengine::Object::IsControllerActiveOnAnyOfDomains(enum ControlDomains) –> bool

IsControllerActiveOnDomains(self: pyscenarioengine.scenarioengine.Object, domainMask: pyscenarioengine.ControlDomains) → bool ¶: C++: scenarioengine::Object::IsControllerActiveOnDomains(enum ControlDomains) –> bool

IsEndOfRoad(self: pyscenarioengine.scenarioengine.Object) → bool ¶: C++: scenarioengine::Object::IsEndOfRoad() –> bool

IsGhost(self: pyscenarioengine.scenarioengine.Object) → bool ¶: C++: scenarioengine::Object::IsGhost() –> bool

IsOffRoad(self: pyscenarioengine.scenarioengine.Object) → bool ¶: C++: scenarioengine::Object::IsOffRoad() –> bool

IsStandStill(self: pyscenarioengine.scenarioengine.Object) → bool ¶: C++: scenarioengine::Object::IsStandStill() –> bool

MoveAlongS(*args, **kwargs)¶

Overloaded function.

MoveAlongS(self: pyscenarioengine.scenarioengine.Object, ds: float) -> int
MoveAlongS(self: pyscenarioengine.scenarioengine.Object, ds: float, actualDistance: bool) -> int

Move current position along the road or route (if assigned)

Distance to move, negative will move backwards

if true ds will adjusted for curvature and lat offset

Non zero return value indicates error of some kind

C++: scenarioengine::Object::MoveAlongS(double, bool) –> int

PointCollision(self: pyscenarioengine.scenarioengine.Object, x: float, y: float) → float ¶: Check if point is colliding/overlapping with specified target object

X coordinate of target point

Y coordinate of target point

true if bounding boxes overlap else false

C++: scenarioengine::Object::PointCollision(double, double) –> double

SetAcc(self: pyscenarioengine.scenarioengine.Object, x_acc: float, y_acc: float, z_acc: float) → None ¶: C++: scenarioengine::Object::SetAcc(double, double, double) –> void

SetAngularAcc(self: pyscenarioengine.scenarioengine.Object, h_acc: float, p_acc: float, r_acc: float) → None ¶: C++: scenarioengine::Object::SetAngularAcc(double, double, double) –> void

SetAngularVel(self: pyscenarioengine.scenarioengine.Object, h_vel: float, p_vel: float, r_vel: float) → None ¶: C++: scenarioengine::Object::SetAngularVel(double, double, double) –> void

SetAssignedController(self: pyscenarioengine.scenarioengine.Object, controller: scenarioengine::Controller) → None ¶: C++: scenarioengine::Object::SetAssignedController(class scenarioengine::Controller *) –> void

SetDirtyBits(self: pyscenarioengine.scenarioengine.Object, bits: int) → None ¶: C++: scenarioengine::Object::SetDirtyBits(int) –> void

SetEndOfRoad(*args, **kwargs)¶

Overloaded function.

SetEndOfRoad(self: pyscenarioengine.scenarioengine.Object, state: bool) -> None
SetEndOfRoad(self: pyscenarioengine.scenarioengine.Object, state: bool, time: float) -> None

C++: scenarioengine::Object::SetEndOfRoad(bool, double) –> void

SetGhost(self: pyscenarioengine.scenarioengine.Object, ghost: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::Object::SetGhost(class scenarioengine::Object *) –> void

SetHeadstartTime(self: pyscenarioengine.scenarioengine.Object, headstartTime: float) → None ¶: C++: scenarioengine::Object::SetHeadstartTime(double) –> void

SetJunctionSelectorAngle(self: pyscenarioengine.scenarioengine.Object, angle: float) → None ¶: Specify how to choose way in next junction

Specify desired direction [0:2pi] from incoming road direction (angle = 0)

C++: scenarioengine::Object::SetJunctionSelectorAngle(double) –> void

SetJunctionSelectorAngleRandom(self: pyscenarioengine.scenarioengine.Object) → None ¶: Choose a random angle for junction selector, in effect random choice in next junction

C++: scenarioengine::Object::SetJunctionSelectorAngleRandom() –> void

SetJunctionSelectorStrategy(self: pyscenarioengine.scenarioengine.Object, type: roadmanager::Junction::JunctionStrategyType) → None ¶: Specify strategy how to choose way in next junction

Use specified angle (SetJunctionSelectorAngle*) or randomize. See roadmanager::Junction::JunctionStrategyType.

C++: scenarioengine::Object::SetJunctionSelectorStrategy(roadmanager::Junction::JunctionStrategyType) –> void

SetMaxAcceleration(self: pyscenarioengine.scenarioengine.Object, maxAcceleration: float) → None ¶: C++: scenarioengine::Object::SetMaxAcceleration(double) –> void

SetMaxDeceleration(self: pyscenarioengine.scenarioengine.Object, maxDeceleration: float) → None ¶: C++: scenarioengine::Object::SetMaxDeceleration(double) –> void

SetMaxSpeed(self: pyscenarioengine.scenarioengine.Object, maxSpeed: float) → None ¶: C++: scenarioengine::Object::SetMaxSpeed(double) –> void

SetOffRoad(*args, **kwargs)¶

Overloaded function.

SetOffRoad(self: pyscenarioengine.scenarioengine.Object, state: bool) -> None
SetOffRoad(self: pyscenarioengine.scenarioengine.Object, state: bool, time: float) -> None

C++: scenarioengine::Object::SetOffRoad(bool, double) –> void

SetSpeed(self: pyscenarioengine.scenarioengine.Object, speed: float) → None ¶: C++: scenarioengine::Object::SetSpeed(double) –> void

SetStandStill(*args, **kwargs)¶

Overloaded function.

SetStandStill(self: pyscenarioengine.scenarioengine.Object, state: bool) -> None
SetStandStill(self: pyscenarioengine.scenarioengine.Object, state: bool, time: float) -> None

C++: scenarioengine::Object::SetStandStill(bool, double) –> void

SetVel(self: pyscenarioengine.scenarioengine.Object, x_vel: float, y_vel: float, z_vel: float) → None ¶: C++: scenarioengine::Object::SetVel(double, double, double) –> void

SetVisibilityMask(self: pyscenarioengine.scenarioengine.Object, mask: int) → None ¶: C++: scenarioengine::Object::SetVisibilityMask(int) –> void

addEvent(self: pyscenarioengine.scenarioengine.Object, event: scenarioengine::Event) → None ¶: C++: scenarioengine::Object::addEvent(class scenarioengine::Event *) –> void

assign(self: pyscenarioengine.scenarioengine.Object, : pyscenarioengine.scenarioengine.Object) → pyscenarioengine.scenarioengine.Object ¶: C++: scenarioengine::Object::operator=(const class scenarioengine::Object &) –> class scenarioengine::Object &

containsEvent(self: pyscenarioengine.scenarioengine.Object, event: scenarioengine::Event) → bool ¶: C++: scenarioengine::Object::containsEvent(class scenarioengine::Event *) –> bool

removeEvent(self: pyscenarioengine.scenarioengine.Object, event: scenarioengine::Event) → None ¶: C++: scenarioengine::Object::removeEvent(class scenarioengine::Event *) –> void

class pyscenarioengine.scenarioengine.Vehicle¶

assign(self: pyscenarioengine.scenarioengine.Vehicle, : pyscenarioengine.scenarioengine.Vehicle) → pyscenarioengine.scenarioengine.Vehicle ¶: C++: scenarioengine::Vehicle::operator=(const class scenarioengine::Vehicle &) –> class scenarioengine::Vehicle &

class pyscenarioengine.scenarioengine.Pedestrian¶

class pyscenarioengine.scenarioengine.MiscObject¶

class pyscenarioengine.scenarioengine.Entities¶

GetObjectById(self: pyscenarioengine.scenarioengine.Entities, id: int) → pyscenarioengine.scenarioengine.Object ¶: C++: scenarioengine::Entities::GetObjectById(int) –> class scenarioengine::Object *

addObject(self: pyscenarioengine.scenarioengine.Entities, obj: pyscenarioengine.scenarioengine.Object) → int ¶: C++: scenarioengine::Entities::addObject(class scenarioengine::Object *) –> int

assign(self: pyscenarioengine.scenarioengine.Entities, : pyscenarioengine.scenarioengine.Entities) → pyscenarioengine.scenarioengine.Entities ¶: C++: scenarioengine::Entities::operator=(const class scenarioengine::Entities &) –> class scenarioengine::Entities &

getNewId(self: pyscenarioengine.scenarioengine.Entities) → int ¶: C++: scenarioengine::Entities::getNewId() –> int

indexExists(self: pyscenarioengine.scenarioengine.Entities, id: int) → bool ¶: C++: scenarioengine::Entities::indexExists(int) –> bool

removeObject(self: pyscenarioengine.scenarioengine.Entities, id: int) → None ¶: C++: scenarioengine::Entities::removeObject(int) –> void

class pyscenarioengine.scenarioengine.Entry¶

class pyscenarioengine.scenarioengine.Catalog¶

AddEntry(self: pyscenarioengine.scenarioengine.Catalog, entry: pyscenarioengine.scenarioengine.Entry) → None ¶: C++: scenarioengine::Catalog::AddEntry(class scenarioengine::Entry *) –> void

GetType(self: pyscenarioengine.scenarioengine.Catalog) → scenarioengine::CatalogType¶: C++: scenarioengine::Catalog::GetType() –> scenarioengine::CatalogType

class pyscenarioengine.scenarioengine.Catalogs¶

AddCatalog(self: pyscenarioengine.scenarioengine.Catalogs, catalog: pyscenarioengine.scenarioengine.Catalog) → None ¶: C++: scenarioengine::Catalogs::AddCatalog(class scenarioengine::Catalog *) –> void

assign(self: pyscenarioengine.scenarioengine.Catalogs, : pyscenarioengine.scenarioengine.Catalogs) → pyscenarioengine.scenarioengine.Catalogs ¶: C++: scenarioengine::Catalogs::operator=(const class scenarioengine::Catalogs &) –> class scenarioengine::Catalogs &

class pyscenarioengine.scenarioengine.StoryBoardElement¶

End(self: pyscenarioengine.scenarioengine.StoryBoardElement) → None ¶: C++: scenarioengine::StoryBoardElement::End() –> void

IsActive(self: pyscenarioengine.scenarioengine.StoryBoardElement) → bool ¶: C++: scenarioengine::StoryBoardElement::IsActive() –> bool

IsTriggable(self: pyscenarioengine.scenarioengine.StoryBoardElement) → bool ¶: C++: scenarioengine::StoryBoardElement::IsTriggable() –> bool

Reset(self: pyscenarioengine.scenarioengine.StoryBoardElement) → None ¶: C++: scenarioengine::StoryBoardElement::Reset() –> void

SetState(self: pyscenarioengine.scenarioengine.StoryBoardElement, state: scenarioengine::StoryBoardElement::State) → None ¶: C++: scenarioengine::StoryBoardElement::SetState(scenarioengine::StoryBoardElement::State) –> void

Standby(self: pyscenarioengine.scenarioengine.StoryBoardElement) → None ¶: C++: scenarioengine::StoryBoardElement::Standby() –> void

Start(self: pyscenarioengine.scenarioengine.StoryBoardElement, simTime: float, dt: float) → None ¶: C++: scenarioengine::StoryBoardElement::Start(double, double) –> void

Stop(self: pyscenarioengine.scenarioengine.StoryBoardElement) → None ¶: C++: scenarioengine::StoryBoardElement::Stop() –> void

UpdateState(self: pyscenarioengine.scenarioengine.StoryBoardElement) → None ¶: C++: scenarioengine::StoryBoardElement::UpdateState() –> void

assign(self: pyscenarioengine.scenarioengine.StoryBoardElement, : pyscenarioengine.scenarioengine.StoryBoardElement) → pyscenarioengine.scenarioengine.StoryBoardElement ¶: C++: scenarioengine::StoryBoardElement::operator=(const class scenarioengine::StoryBoardElement &) –> class scenarioengine::StoryBoardElement &

class pyscenarioengine.scenarioengine.OSCAction¶

Step(self: pyscenarioengine.scenarioengine.OSCAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::OSCAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.OSCAction, : pyscenarioengine.scenarioengine.OSCAction) → pyscenarioengine.scenarioengine.OSCAction ¶: C++: scenarioengine::OSCAction::operator=(const class scenarioengine::OSCAction &) –> class scenarioengine::OSCAction &

class pyscenarioengine.scenarioengine.OSCParameterDeclarations¶

class ParameterType¶

Members:

PARAM_TYPE_INTEGER

PARAM_TYPE_DOUBLE

PARAM_TYPE_STRING

PARAM_TYPE_BOOL

property name¶

assign(self: pyscenarioengine.scenarioengine.OSCParameterDeclarations, : pyscenarioengine.scenarioengine.OSCParameterDeclarations) → pyscenarioengine.scenarioengine.OSCParameterDeclarations ¶: C++: scenarioengine::OSCParameterDeclarations::operator=(const class scenarioengine::OSCParameterDeclarations &) –> class scenarioengine::OSCParameterDeclarations &

class pyscenarioengine.scenarioengine.Parameters¶

Clear(self: pyscenarioengine.scenarioengine.Parameters) → None ¶: C++: scenarioengine::Parameters::Clear() –> void

CreateRestorePoint(self: pyscenarioengine.scenarioengine.Parameters) → None ¶: C++: scenarioengine::Parameters::CreateRestorePoint() –> void

GetNumberOfParameters(self: pyscenarioengine.scenarioengine.Parameters) → int ¶: C++: scenarioengine::Parameters::GetNumberOfParameters() –> int

GetParameterName(self: pyscenarioengine.scenarioengine.Parameters, index: int, type: pyscenarioengine.scenarioengine.OSCParameterDeclarations.ParameterType) → str ¶: C++: scenarioengine::Parameters::GetParameterName(int, enum scenarioengine::OSCParameterDeclarations::ParameterType *) –> const char *

RestoreParameterDeclarations(self: pyscenarioengine.scenarioengine.Parameters) → None ¶: C++: scenarioengine::Parameters::RestoreParameterDeclarations() –> void

class pyscenarioengine.scenarioengine.OSCOrientation¶

assign(self: pyscenarioengine.scenarioengine.OSCOrientation, : pyscenarioengine.scenarioengine.OSCOrientation) → pyscenarioengine.scenarioengine.OSCOrientation ¶: C++: scenarioengine::OSCOrientation::operator=(const class scenarioengine::OSCOrientation &) –> class scenarioengine::OSCOrientation &

class pyscenarioengine.scenarioengine.OSCPosition¶

GetH(self: pyscenarioengine.scenarioengine.OSCPosition) → float ¶: C++: scenarioengine::OSCPosition::GetH() –> double

GetP(self: pyscenarioengine.scenarioengine.OSCPosition) → float ¶: C++: scenarioengine::OSCPosition::GetP() –> double

GetR(self: pyscenarioengine.scenarioengine.OSCPosition) → float ¶: C++: scenarioengine::OSCPosition::GetR() –> double

GetX(self: pyscenarioengine.scenarioengine.OSCPosition) → float ¶: C++: scenarioengine::OSCPosition::GetX() –> double

GetY(self: pyscenarioengine.scenarioengine.OSCPosition) → float ¶: C++: scenarioengine::OSCPosition::GetY() –> double

GetZ(self: pyscenarioengine.scenarioengine.OSCPosition) → float ¶: C++: scenarioengine::OSCPosition::GetZ() –> double

Print(self: pyscenarioengine.scenarioengine.OSCPosition) → None ¶: C++: scenarioengine::OSCPosition::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPosition, : pyscenarioengine.scenarioengine.OSCPosition) → pyscenarioengine.scenarioengine.OSCPosition ¶: C++: scenarioengine::OSCPosition::operator=(const class scenarioengine::OSCPosition &) –> class scenarioengine::OSCPosition &

class pyscenarioengine.scenarioengine.OSCPositionWorld¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionWorld) → None ¶: C++: scenarioengine::OSCPositionWorld::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionWorld, : pyscenarioengine.scenarioengine.OSCPositionWorld) → pyscenarioengine.scenarioengine.OSCPositionWorld ¶: C++: scenarioengine::OSCPositionWorld::operator=(const class scenarioengine::OSCPositionWorld &) –> class scenarioengine::OSCPositionWorld &

class pyscenarioengine.scenarioengine.OSCPositionLane¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionLane) → None ¶: C++: scenarioengine::OSCPositionLane::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionLane, : pyscenarioengine.scenarioengine.OSCPositionLane) → pyscenarioengine.scenarioengine.OSCPositionLane ¶: C++: scenarioengine::OSCPositionLane::operator=(const class scenarioengine::OSCPositionLane &) –> class scenarioengine::OSCPositionLane &

class pyscenarioengine.scenarioengine.OSCPositionRoad¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionRoad) → None ¶: C++: scenarioengine::OSCPositionRoad::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionRoad, : pyscenarioengine.scenarioengine.OSCPositionRoad) → pyscenarioengine.scenarioengine.OSCPositionRoad ¶: C++: scenarioengine::OSCPositionRoad::operator=(const class scenarioengine::OSCPositionRoad &) –> class scenarioengine::OSCPositionRoad &

class pyscenarioengine.scenarioengine.OSCPositionRelativeObject¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionRelativeObject) → None ¶: C++: scenarioengine::OSCPositionRelativeObject::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionRelativeObject, : pyscenarioengine.scenarioengine.OSCPositionRelativeObject) → pyscenarioengine.scenarioengine.OSCPositionRelativeObject ¶: C++: scenarioengine::OSCPositionRelativeObject::operator=(const class scenarioengine::OSCPositionRelativeObject &) –> class scenarioengine::OSCPositionRelativeObject &

class pyscenarioengine.scenarioengine.OSCPositionRelativeWorld¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionRelativeWorld) → None ¶: C++: scenarioengine::OSCPositionRelativeWorld::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionRelativeWorld, : pyscenarioengine.scenarioengine.OSCPositionRelativeWorld) → pyscenarioengine.scenarioengine.OSCPositionRelativeWorld ¶: C++: scenarioengine::OSCPositionRelativeWorld::operator=(const class scenarioengine::OSCPositionRelativeWorld &) –> class scenarioengine::OSCPositionRelativeWorld &

class pyscenarioengine.scenarioengine.OSCPositionRelativeLane¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionRelativeLane) → None ¶: C++: scenarioengine::OSCPositionRelativeLane::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionRelativeLane, : pyscenarioengine.scenarioengine.OSCPositionRelativeLane) → pyscenarioengine.scenarioengine.OSCPositionRelativeLane ¶: C++: scenarioengine::OSCPositionRelativeLane::operator=(const class scenarioengine::OSCPositionRelativeLane &) –> class scenarioengine::OSCPositionRelativeLane &

class pyscenarioengine.scenarioengine.OSCPositionRelativeRoad¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionRelativeRoad) → None ¶: C++: scenarioengine::OSCPositionRelativeRoad::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionRelativeRoad, : pyscenarioengine.scenarioengine.OSCPositionRelativeRoad) → pyscenarioengine.scenarioengine.OSCPositionRelativeRoad ¶: C++: scenarioengine::OSCPositionRelativeRoad::operator=(const class scenarioengine::OSCPositionRelativeRoad &) –> class scenarioengine::OSCPositionRelativeRoad &

class pyscenarioengine.scenarioengine.OSCPositionRoute¶

Print(self: pyscenarioengine.scenarioengine.OSCPositionRoute) → None ¶: C++: scenarioengine::OSCPositionRoute::Print() –> void

SetRouteRelativeHeading(self: pyscenarioengine.scenarioengine.OSCPositionRoute, h_relative: float) → None ¶: C++: scenarioengine::OSCPositionRoute::SetRouteRelativeHeading(double) –> void

assign(self: pyscenarioengine.scenarioengine.OSCPositionRoute, : pyscenarioengine.scenarioengine.OSCPositionRoute) → pyscenarioengine.scenarioengine.OSCPositionRoute ¶: C++: scenarioengine::OSCPositionRoute::operator=(const class scenarioengine::OSCPositionRoute &) –> class scenarioengine::OSCPositionRoute &

class pyscenarioengine.scenarioengine.OSCProperties¶

assign(self: pyscenarioengine.scenarioengine.OSCProperties, : pyscenarioengine.scenarioengine.OSCProperties) → pyscenarioengine.scenarioengine.OSCProperties ¶: C++: scenarioengine::OSCProperties::operator=(const class scenarioengine::OSCProperties &) –> class scenarioengine::OSCProperties &

class pyscenarioengine.scenarioengine.Controller¶

Activate(self: pyscenarioengine.scenarioengine.Controller, domainMask: pyscenarioengine.ControlDomains) → None ¶: C++: scenarioengine::Controller::Activate(enum ControlDomains) –> void

Active(self: pyscenarioengine.scenarioengine.Controller) → bool ¶: C++: scenarioengine::Controller::Active() –> bool

Assign(self: pyscenarioengine.scenarioengine.Controller, object: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::Controller::Assign(class scenarioengine::Object *) –> void

Deactivate(self: pyscenarioengine.scenarioengine.Controller) → None ¶: C++: scenarioengine::Controller::Deactivate() –> void

GetDomain(self: pyscenarioengine.scenarioengine.Controller) → pyscenarioengine.ControlDomains¶: C++: scenarioengine::Controller::GetDomain() –> enum ControlDomains

GetMode(self: pyscenarioengine.scenarioengine.Controller) → int ¶: C++: scenarioengine::Controller::GetMode() –> int

GetObject(self: pyscenarioengine.scenarioengine.Controller) → pyscenarioengine.scenarioengine.Object ¶: C++: scenarioengine::Controller::GetObject() –> class scenarioengine::Object *

GetType(self: pyscenarioengine.scenarioengine.Controller) → int ¶: C++: scenarioengine::Controller::GetType() –> int

GetTypeName(self: pyscenarioengine.scenarioengine.Controller) → str ¶: C++: scenarioengine::Controller::GetTypeName() –> const char *

static GetTypeNameStatic() → str ¶: C++: scenarioengine::Controller::GetTypeNameStatic() –> const char *

static GetTypeStatic() → int ¶: C++: scenarioengine::Controller::GetTypeStatic() –> const int

Init(self: pyscenarioengine.scenarioengine.Controller) → None ¶: C++: scenarioengine::Controller::Init() –> void

IsActive(self: pyscenarioengine.scenarioengine.Controller) → bool ¶: C++: scenarioengine::Controller::IsActive() –> bool

IsActiveOnAnyOfDomains(self: pyscenarioengine.scenarioengine.Controller, domainMask: pyscenarioengine.ControlDomains) → bool ¶: C++: scenarioengine::Controller::IsActiveOnAnyOfDomains(enum ControlDomains) –> bool

IsActiveOnDomains(self: pyscenarioengine.scenarioengine.Controller, domainMask: pyscenarioengine.ControlDomains) → bool ¶: C++: scenarioengine::Controller::IsActiveOnDomains(enum ControlDomains) –> bool

ReportKeyEvent(self: pyscenarioengine.scenarioengine.Controller, key: int, down: bool) → None ¶: C++: scenarioengine::Controller::ReportKeyEvent(int, bool) –> void

Step(self: pyscenarioengine.scenarioengine.Controller, timeStep: float) → None ¶: C++: scenarioengine::Controller::Step(double) –> void

class Type¶

Members:

CONTROLLER_TYPE_DEFAULT

CONTROLLER_TYPE_EXTERNAL

CONTROLLER_TYPE_FOLLOW_GHOST

CONTROLLER_TYPE_INTERACTIVE

CONTROLLER_TYPE_SLOPPY_DRIVER

CONTROLLER_TYPE_SUMO

CONTROLLER_TYPE_REL2ABS

CONTROLLER_TYPE_ACC

CONTROLLER_TYPE_ALKS

CONTROLLER_TYPE_UDP_DRIVER

CONTROLLER_TYPE_ECE_ALKS_REF_DRIVER

N_CONTROLLER_TYPES

GHOST_RESERVED_TYPE

USER_CONTROLLER_TYPE_BASE

property name¶

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

class pyscenarioengine.scenarioengine.OSCPrivateAction¶

class ActionType¶

Members:

LONG_SPEED

LONG_DISTANCE

LAT_LANE_CHANGE

LAT_LANE_OFFSET

LAT_DISTANCE

VISIBILITY

CONTROLLER

ASSIGN_CONTROLLER

ACTIVATE_CONTROLLER

OVERRIDE_CONTROLLER

TELEPORT

ASSIGN_ROUTE

FOLLOW_TRAJECTORY

Acquire_POSITION

SYNCHRONIZE

property name¶

Copy(self: pyscenarioengine.scenarioengine.OSCPrivateAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::OSCPrivateAction::Copy() –> class scenarioengine::OSCPrivateAction *

class DynamicsDimension¶

Members:

RATE

TIME

DISTANCE

DIMENSION_UNDEFINED

property name¶

class DynamicsShape¶

Members:

LINEAR

CUBIC

SINUSOIDAL

STEP

SHAPE_UNDEFINED

property name¶

GetDomain(self: pyscenarioengine.scenarioengine.OSCPrivateAction) → pyscenarioengine.ControlDomains¶: C++: scenarioengine::OSCPrivateAction::GetDomain() –> enum ControlDomains

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.OSCPrivateAction, : pyscenarioengine.scenarioengine.Object, : pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::OSCPrivateAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

assign(self: pyscenarioengine.scenarioengine.OSCPrivateAction, : pyscenarioengine.scenarioengine.OSCPrivateAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::OSCPrivateAction::operator=(const class scenarioengine::OSCPrivateAction &) –> class scenarioengine::OSCPrivateAction &

print(self: pyscenarioengine.scenarioengine.OSCPrivateAction) → None ¶: C++: scenarioengine::OSCPrivateAction::print() –> void

class pyscenarioengine.scenarioengine.LongSpeedAction¶

Copy(self: pyscenarioengine.scenarioengine.LongSpeedAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::LongSpeedAction::Copy() –> class scenarioengine::OSCPrivateAction *

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.LongSpeedAction, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::LongSpeedAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

Start(self: pyscenarioengine.scenarioengine.LongSpeedAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LongSpeedAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.LongSpeedAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LongSpeedAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.LongSpeedAction, : pyscenarioengine.scenarioengine.LongSpeedAction) → pyscenarioengine.scenarioengine.LongSpeedAction ¶: C++: scenarioengine::LongSpeedAction::operator=(const class scenarioengine::LongSpeedAction &) –> class scenarioengine::LongSpeedAction &

print(self: pyscenarioengine.scenarioengine.LongSpeedAction) → None ¶: C++: scenarioengine::LongSpeedAction::print() –> void

class pyscenarioengine.scenarioengine.LongDistanceAction¶

Copy(self: pyscenarioengine.scenarioengine.LongDistanceAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::LongDistanceAction::Copy() –> class scenarioengine::OSCPrivateAction *

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.LongDistanceAction, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::LongDistanceAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

Start(self: pyscenarioengine.scenarioengine.LongDistanceAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LongDistanceAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.LongDistanceAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LongDistanceAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.LongDistanceAction, : pyscenarioengine.scenarioengine.LongDistanceAction) → pyscenarioengine.scenarioengine.LongDistanceAction ¶: C++: scenarioengine::LongDistanceAction::operator=(const class scenarioengine::LongDistanceAction &) –> class scenarioengine::LongDistanceAction &

print(self: pyscenarioengine.scenarioengine.LongDistanceAction) → None ¶: C++: scenarioengine::LongDistanceAction::print() –> void

class pyscenarioengine.scenarioengine.LatLaneChangeAction¶

Copy(self: pyscenarioengine.scenarioengine.LatLaneChangeAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::LatLaneChangeAction::Copy() –> class scenarioengine::OSCPrivateAction *

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.LatLaneChangeAction, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::LatLaneChangeAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

Start(self: pyscenarioengine.scenarioengine.LatLaneChangeAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LatLaneChangeAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.LatLaneChangeAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LatLaneChangeAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.LatLaneChangeAction, : pyscenarioengine.scenarioengine.LatLaneChangeAction) → pyscenarioengine.scenarioengine.LatLaneChangeAction ¶: C++: scenarioengine::LatLaneChangeAction::operator=(const class scenarioengine::LatLaneChangeAction &) –> class scenarioengine::LatLaneChangeAction &

class pyscenarioengine.scenarioengine.LatLaneOffsetAction¶

Copy(self: pyscenarioengine.scenarioengine.LatLaneOffsetAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::LatLaneOffsetAction::Copy() –> class scenarioengine::OSCPrivateAction *

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.LatLaneOffsetAction, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::LatLaneOffsetAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

Start(self: pyscenarioengine.scenarioengine.LatLaneOffsetAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LatLaneOffsetAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.LatLaneOffsetAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::LatLaneOffsetAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.LatLaneOffsetAction, : pyscenarioengine.scenarioengine.LatLaneOffsetAction) → pyscenarioengine.scenarioengine.LatLaneOffsetAction ¶: C++: scenarioengine::LatLaneOffsetAction::operator=(const class scenarioengine::LatLaneOffsetAction &) –> class scenarioengine::LatLaneOffsetAction &

class pyscenarioengine.scenarioengine.SynchronizeAction¶

Copy(self: pyscenarioengine.scenarioengine.SynchronizeAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::SynchronizeAction::Copy() –> class scenarioengine::OSCPrivateAction *

Mode2Str(self: pyscenarioengine.scenarioengine.SynchronizeAction, mode: scenarioengine::SynchronizeAction::SynchMode) → str ¶: C++: scenarioengine::SynchronizeAction::Mode2Str(scenarioengine::SynchronizeAction::SynchMode) –> const char *

Start(self: pyscenarioengine.scenarioengine.SynchronizeAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::SynchronizeAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.SynchronizeAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::SynchronizeAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.SynchronizeAction, : pyscenarioengine.scenarioengine.SynchronizeAction) → pyscenarioengine.scenarioengine.SynchronizeAction ¶: C++: scenarioengine::SynchronizeAction::operator=(const class scenarioengine::SynchronizeAction &) –> class scenarioengine::SynchronizeAction &

class pyscenarioengine.scenarioengine.TeleportAction¶

Copy(self: pyscenarioengine.scenarioengine.TeleportAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::TeleportAction::Copy() –> class scenarioengine::OSCPrivateAction *

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.TeleportAction, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::TeleportAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

Start(self: pyscenarioengine.scenarioengine.TeleportAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::TeleportAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.TeleportAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::TeleportAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.TeleportAction, : pyscenarioengine.scenarioengine.TeleportAction) → pyscenarioengine.scenarioengine.TeleportAction ¶: C++: scenarioengine::TeleportAction::operator=(const class scenarioengine::TeleportAction &) –> class scenarioengine::TeleportAction &

class pyscenarioengine.scenarioengine.AssignRouteAction¶

Copy(self: pyscenarioengine.scenarioengine.AssignRouteAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::AssignRouteAction::Copy() –> class scenarioengine::OSCPrivateAction *

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.AssignRouteAction, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::AssignRouteAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

Start(self: pyscenarioengine.scenarioengine.AssignRouteAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::AssignRouteAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.AssignRouteAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::AssignRouteAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.AssignRouteAction, : pyscenarioengine.scenarioengine.AssignRouteAction) → pyscenarioengine.scenarioengine.AssignRouteAction ¶: C++: scenarioengine::AssignRouteAction::operator=(const class scenarioengine::AssignRouteAction &) –> class scenarioengine::AssignRouteAction &

class pyscenarioengine.scenarioengine.FollowTrajectoryAction¶

Copy(self: pyscenarioengine.scenarioengine.FollowTrajectoryAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::FollowTrajectoryAction::Copy() –> class scenarioengine::OSCPrivateAction *

End(self: pyscenarioengine.scenarioengine.FollowTrajectoryAction) → None ¶: C++: scenarioengine::FollowTrajectoryAction::End() –> void

ReplaceObjectRefs(self: pyscenarioengine.scenarioengine.FollowTrajectoryAction, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::FollowTrajectoryAction::ReplaceObjectRefs(class scenarioengine::Object *, class scenarioengine::Object *) –> void

Start(self: pyscenarioengine.scenarioengine.FollowTrajectoryAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::FollowTrajectoryAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.FollowTrajectoryAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::FollowTrajectoryAction::Step(double, double) –> void

class TimingDomain¶

Members:

NONE

TIMING_RELATIVE

TIMING_ABSOLUTE

property name¶

assign(self: pyscenarioengine.scenarioengine.FollowTrajectoryAction, : pyscenarioengine.scenarioengine.FollowTrajectoryAction) → pyscenarioengine.scenarioengine.FollowTrajectoryAction ¶: C++: scenarioengine::FollowTrajectoryAction::operator=(const class scenarioengine::FollowTrajectoryAction &) –> class scenarioengine::FollowTrajectoryAction &

class pyscenarioengine.scenarioengine.AssignControllerAction¶

Copy(self: pyscenarioengine.scenarioengine.AssignControllerAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::AssignControllerAction::Copy() –> class scenarioengine::OSCPrivateAction *

Start(self: pyscenarioengine.scenarioengine.AssignControllerAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::AssignControllerAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.AssignControllerAction, : float, : float) → None ¶: C++: scenarioengine::AssignControllerAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.AssignControllerAction, : pyscenarioengine.scenarioengine.AssignControllerAction) → pyscenarioengine.scenarioengine.AssignControllerAction ¶: C++: scenarioengine::AssignControllerAction::operator=(const class scenarioengine::AssignControllerAction &) –> class scenarioengine::AssignControllerAction &

class pyscenarioengine.scenarioengine.ActivateControllerAction¶

Copy(self: pyscenarioengine.scenarioengine.ActivateControllerAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::ActivateControllerAction::Copy() –> class scenarioengine::OSCPrivateAction *

End(self: pyscenarioengine.scenarioengine.ActivateControllerAction) → None ¶: C++: scenarioengine::ActivateControllerAction::End() –> void

Start(self: pyscenarioengine.scenarioengine.ActivateControllerAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::ActivateControllerAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.ActivateControllerAction, : float, : float) → None ¶: C++: scenarioengine::ActivateControllerAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.ActivateControllerAction, : pyscenarioengine.scenarioengine.ActivateControllerAction) → pyscenarioengine.scenarioengine.ActivateControllerAction ¶: C++: scenarioengine::ActivateControllerAction::operator=(const class scenarioengine::ActivateControllerAction &) –> class scenarioengine::ActivateControllerAction &

class pyscenarioengine.scenarioengine.VisibilityAction¶

Copy(self: pyscenarioengine.scenarioengine.VisibilityAction) → pyscenarioengine.scenarioengine.OSCPrivateAction ¶: C++: scenarioengine::VisibilityAction::Copy() –> class scenarioengine::OSCPrivateAction *

Start(self: pyscenarioengine.scenarioengine.VisibilityAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::VisibilityAction::Start(double, double) –> void

Step(self: pyscenarioengine.scenarioengine.VisibilityAction, simTime: float, dt: float) → None ¶: C++: scenarioengine::VisibilityAction::Step(double, double) –> void

assign(self: pyscenarioengine.scenarioengine.VisibilityAction, : pyscenarioengine.scenarioengine.VisibilityAction) → pyscenarioengine.scenarioengine.VisibilityAction ¶: C++: scenarioengine::VisibilityAction::operator=(const class scenarioengine::VisibilityAction &) –> class scenarioengine::VisibilityAction &

class pyscenarioengine.scenarioengine.Init¶

assign(self: pyscenarioengine.scenarioengine.Init, : pyscenarioengine.scenarioengine.Init) → pyscenarioengine.scenarioengine.Init ¶: C++: scenarioengine::Init::operator=(const class scenarioengine::Init &) –> class scenarioengine::Init &

class pyscenarioengine.scenarioengine.OSCCondition¶

CheckCondition(self: pyscenarioengine.scenarioengine.OSCCondition, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::OSCCondition::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

CheckEdge(self: pyscenarioengine.scenarioengine.OSCCondition, new_value: bool, old_value: bool, edge: scenarioengine::OSCCondition::ConditionEdge) → bool ¶: C++: scenarioengine::OSCCondition::CheckEdge(bool, bool, scenarioengine::OSCCondition::ConditionEdge) –> bool

Evaluate(self: pyscenarioengine.scenarioengine.OSCCondition, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::OSCCondition::Evaluate(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.OSCCondition) → None ¶: C++: scenarioengine::OSCCondition::Log() –> void

assign(self: pyscenarioengine.scenarioengine.OSCCondition, : pyscenarioengine.scenarioengine.OSCCondition) → pyscenarioengine.scenarioengine.OSCCondition ¶: C++: scenarioengine::OSCCondition::operator=(const class scenarioengine::OSCCondition &) –> class scenarioengine::OSCCondition &

class pyscenarioengine.scenarioengine.ConditionGroup¶

Evaluate(self: pyscenarioengine.scenarioengine.ConditionGroup, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::ConditionGroup::Evaluate(class scenarioengine::StoryBoard *, double) –> bool

class pyscenarioengine.scenarioengine.Trigger¶

Evaluate(self: pyscenarioengine.scenarioengine.Trigger, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::Trigger::Evaluate(class scenarioengine::StoryBoard *, double) –> bool

class pyscenarioengine.scenarioengine.TrigByEntity¶

Print(self: pyscenarioengine.scenarioengine.TrigByEntity) → None ¶: C++: scenarioengine::TrigByEntity::Print() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByEntity, : pyscenarioengine.scenarioengine.TrigByEntity) → pyscenarioengine.scenarioengine.TrigByEntity ¶: C++: scenarioengine::TrigByEntity::operator=(const class scenarioengine::TrigByEntity &) –> class scenarioengine::TrigByEntity &

class pyscenarioengine.scenarioengine.TrigByTimeHeadway¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByTimeHeadway, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByTimeHeadway::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByTimeHeadway) → None ¶: C++: scenarioengine::TrigByTimeHeadway::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByTimeHeadway, : pyscenarioengine.scenarioengine.TrigByTimeHeadway) → pyscenarioengine.scenarioengine.TrigByTimeHeadway ¶: C++: scenarioengine::TrigByTimeHeadway::operator=(const class scenarioengine::TrigByTimeHeadway &) –> class scenarioengine::TrigByTimeHeadway &

class pyscenarioengine.scenarioengine.TrigByTimeToCollision¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByTimeToCollision, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByTimeToCollision::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByTimeToCollision) → None ¶: C++: scenarioengine::TrigByTimeToCollision::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByTimeToCollision, : pyscenarioengine.scenarioengine.TrigByTimeToCollision) → pyscenarioengine.scenarioengine.TrigByTimeToCollision ¶: C++: scenarioengine::TrigByTimeToCollision::operator=(const class scenarioengine::TrigByTimeToCollision &) –> class scenarioengine::TrigByTimeToCollision &

class pyscenarioengine.scenarioengine.TrigByReachPosition¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByReachPosition, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByReachPosition::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByReachPosition) → None ¶: C++: scenarioengine::TrigByReachPosition::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByReachPosition, : pyscenarioengine.scenarioengine.TrigByReachPosition) → pyscenarioengine.scenarioengine.TrigByReachPosition ¶: C++: scenarioengine::TrigByReachPosition::operator=(const class scenarioengine::TrigByReachPosition &) –> class scenarioengine::TrigByReachPosition &

class pyscenarioengine.scenarioengine.TrigByDistance¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByDistance, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByDistance::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByDistance) → None ¶: C++: scenarioengine::TrigByDistance::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByDistance, : pyscenarioengine.scenarioengine.TrigByDistance) → pyscenarioengine.scenarioengine.TrigByDistance ¶: C++: scenarioengine::TrigByDistance::operator=(const class scenarioengine::TrigByDistance &) –> class scenarioengine::TrigByDistance &

class pyscenarioengine.scenarioengine.TrigByTraveledDistance¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByTraveledDistance, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByTraveledDistance::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByTraveledDistance) → None ¶: C++: scenarioengine::TrigByTraveledDistance::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByTraveledDistance, : pyscenarioengine.scenarioengine.TrigByTraveledDistance) → pyscenarioengine.scenarioengine.TrigByTraveledDistance ¶: C++: scenarioengine::TrigByTraveledDistance::operator=(const class scenarioengine::TrigByTraveledDistance &) –> class scenarioengine::TrigByTraveledDistance &

class pyscenarioengine.scenarioengine.TrigByRelativeDistance¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByRelativeDistance, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByRelativeDistance::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByRelativeDistance) → None ¶: C++: scenarioengine::TrigByRelativeDistance::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByRelativeDistance, : pyscenarioengine.scenarioengine.TrigByRelativeDistance) → pyscenarioengine.scenarioengine.TrigByRelativeDistance ¶: C++: scenarioengine::TrigByRelativeDistance::operator=(const class scenarioengine::TrigByRelativeDistance &) –> class scenarioengine::TrigByRelativeDistance &

class pyscenarioengine.scenarioengine.TrigByCollision¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByCollision, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByCollision::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByCollision) → None ¶: C++: scenarioengine::TrigByCollision::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByCollision, : pyscenarioengine.scenarioengine.TrigByCollision) → pyscenarioengine.scenarioengine.TrigByCollision ¶: C++: scenarioengine::TrigByCollision::operator=(const class scenarioengine::TrigByCollision &) –> class scenarioengine::TrigByCollision &

class pyscenarioengine.scenarioengine.TrigByEndOfRoad¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByEndOfRoad, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByEndOfRoad::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByEndOfRoad) → None ¶: C++: scenarioengine::TrigByEndOfRoad::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByEndOfRoad, : pyscenarioengine.scenarioengine.TrigByEndOfRoad) → pyscenarioengine.scenarioengine.TrigByEndOfRoad ¶: C++: scenarioengine::TrigByEndOfRoad::operator=(const class scenarioengine::TrigByEndOfRoad &) –> class scenarioengine::TrigByEndOfRoad &

class pyscenarioengine.scenarioengine.TrigByOffRoad¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByOffRoad, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByOffRoad::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByOffRoad) → None ¶: C++: scenarioengine::TrigByOffRoad::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByOffRoad, : pyscenarioengine.scenarioengine.TrigByOffRoad) → pyscenarioengine.scenarioengine.TrigByOffRoad ¶: C++: scenarioengine::TrigByOffRoad::operator=(const class scenarioengine::TrigByOffRoad &) –> class scenarioengine::TrigByOffRoad &

class pyscenarioengine.scenarioengine.TrigByAcceleration¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByAcceleration, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByAcceleration::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByAcceleration) → None ¶: C++: scenarioengine::TrigByAcceleration::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByAcceleration, : pyscenarioengine.scenarioengine.TrigByAcceleration) → pyscenarioengine.scenarioengine.TrigByAcceleration ¶: C++: scenarioengine::TrigByAcceleration::operator=(const class scenarioengine::TrigByAcceleration &) –> class scenarioengine::TrigByAcceleration &

class pyscenarioengine.scenarioengine.TrigBySpeed¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigBySpeed, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigBySpeed::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigBySpeed) → None ¶: C++: scenarioengine::TrigBySpeed::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigBySpeed, : pyscenarioengine.scenarioengine.TrigBySpeed) → pyscenarioengine.scenarioengine.TrigBySpeed ¶: C++: scenarioengine::TrigBySpeed::operator=(const class scenarioengine::TrigBySpeed &) –> class scenarioengine::TrigBySpeed &

class pyscenarioengine.scenarioengine.TrigByRelativeSpeed¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByRelativeSpeed, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByRelativeSpeed::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByRelativeSpeed) → None ¶: C++: scenarioengine::TrigByRelativeSpeed::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByRelativeSpeed, : pyscenarioengine.scenarioengine.TrigByRelativeSpeed) → pyscenarioengine.scenarioengine.TrigByRelativeSpeed ¶: C++: scenarioengine::TrigByRelativeSpeed::operator=(const class scenarioengine::TrigByRelativeSpeed &) –> class scenarioengine::TrigByRelativeSpeed &

class pyscenarioengine.scenarioengine.TrigByStandStill¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByStandStill, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByStandStill::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByStandStill) → None ¶: C++: scenarioengine::TrigByStandStill::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByStandStill, : pyscenarioengine.scenarioengine.TrigByStandStill) → pyscenarioengine.scenarioengine.TrigByStandStill ¶: C++: scenarioengine::TrigByStandStill::operator=(const class scenarioengine::TrigByStandStill &) –> class scenarioengine::TrigByStandStill &

class pyscenarioengine.scenarioengine.TrigByState¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByState, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByState::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByState) → None ¶: C++: scenarioengine::TrigByState::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByState, : pyscenarioengine.scenarioengine.TrigByState) → pyscenarioengine.scenarioengine.TrigByState ¶: C++: scenarioengine::TrigByState::operator=(const class scenarioengine::TrigByState &) –> class scenarioengine::TrigByState &

class pyscenarioengine.scenarioengine.TrigByValue¶

assign(self: pyscenarioengine.scenarioengine.TrigByValue, : pyscenarioengine.scenarioengine.TrigByValue) → pyscenarioengine.scenarioengine.TrigByValue ¶: C++: scenarioengine::TrigByValue::operator=(const class scenarioengine::TrigByValue &) –> class scenarioengine::TrigByValue &

class pyscenarioengine.scenarioengine.TrigBySimulationTime¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigBySimulationTime, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigBySimulationTime::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigBySimulationTime) → None ¶: C++: scenarioengine::TrigBySimulationTime::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigBySimulationTime, : pyscenarioengine.scenarioengine.TrigBySimulationTime) → pyscenarioengine.scenarioengine.TrigBySimulationTime ¶: C++: scenarioengine::TrigBySimulationTime::operator=(const class scenarioengine::TrigBySimulationTime &) –> class scenarioengine::TrigBySimulationTime &

class pyscenarioengine.scenarioengine.TrigByParameter¶

CheckCondition(self: pyscenarioengine.scenarioengine.TrigByParameter, storyBoard: scenarioengine::StoryBoard, sim_time: float) → bool ¶: C++: scenarioengine::TrigByParameter::CheckCondition(class scenarioengine::StoryBoard *, double) –> bool

Log(self: pyscenarioengine.scenarioengine.TrigByParameter) → None ¶: C++: scenarioengine::TrigByParameter::Log() –> void

assign(self: pyscenarioengine.scenarioengine.TrigByParameter, : pyscenarioengine.scenarioengine.TrigByParameter) → pyscenarioengine.scenarioengine.TrigByParameter ¶: C++: scenarioengine::TrigByParameter::operator=(const class scenarioengine::TrigByParameter &) –> class scenarioengine::TrigByParameter &

class pyscenarioengine.scenarioengine.Event¶

End(self: pyscenarioengine.scenarioengine.Event) → None ¶: C++: scenarioengine::Event::End() –> void

Start(self: pyscenarioengine.scenarioengine.Event, simTime: float, dt: float) → None ¶: C++: scenarioengine::Event::Start(double, double) –> void

Stop(self: pyscenarioengine.scenarioengine.Event) → None ¶: C++: scenarioengine::Event::Stop() –> void

assign(self: pyscenarioengine.scenarioengine.Event, : pyscenarioengine.scenarioengine.Event) → pyscenarioengine.scenarioengine.Event ¶: C++: scenarioengine::Event::operator=(const class scenarioengine::Event &) –> class scenarioengine::Event &

class pyscenarioengine.scenarioengine.OSCManeuver¶

IsAnyEventActive(self: pyscenarioengine.scenarioengine.OSCManeuver) → bool ¶: C++: scenarioengine::OSCManeuver::IsAnyEventActive() –> bool

Print(self: pyscenarioengine.scenarioengine.OSCManeuver) → None ¶: C++: scenarioengine::OSCManeuver::Print() –> void

class pyscenarioengine.scenarioengine.Act¶

assign(self: pyscenarioengine.scenarioengine.Act, : pyscenarioengine.scenarioengine.Act) → pyscenarioengine.scenarioengine.Act ¶: C++: scenarioengine::Act::operator=(const class scenarioengine::Act &) –> class scenarioengine::Act &

class pyscenarioengine.scenarioengine.Story¶

Print(self: pyscenarioengine.scenarioengine.Story) → None ¶: C++: scenarioengine::Story::Print() –> void

class pyscenarioengine.scenarioengine.StoryBoard¶

Print(self: pyscenarioengine.scenarioengine.StoryBoard) → None ¶: C++: scenarioengine::StoryBoard::Print() –> void

assign(self: pyscenarioengine.scenarioengine.StoryBoard, : pyscenarioengine.scenarioengine.StoryBoard) → pyscenarioengine.scenarioengine.StoryBoard ¶: C++: scenarioengine::StoryBoard::operator=(const class scenarioengine::StoryBoard &) –> class scenarioengine::StoryBoard &

class pyscenarioengine.scenarioengine.ObjectStateStruct¶

class pyscenarioengine.scenarioengine.ObjectState¶

Print(self: pyscenarioengine.scenarioengine.ObjectState) → None ¶: C++: scenarioengine::ObjectState::Print() –> void

clearDirtyBits(self: pyscenarioengine.scenarioengine.ObjectState) → None ¶: C++: scenarioengine::ObjectState::clearDirtyBits() –> void

getStruct(self: pyscenarioengine.scenarioengine.ObjectState) → pyscenarioengine.scenarioengine.ObjectStateStruct ¶: C++: scenarioengine::ObjectState::getStruct() –> struct scenarioengine::ObjectStateStruct

class pyscenarioengine.scenarioengine.ScenarioGateway¶

WriteStatesToFile(self: pyscenarioengine.scenarioengine.ScenarioGateway) → None ¶: C++: scenarioengine::ScenarioGateway::WriteStatesToFile() –> void

clearDirtyBits(self: pyscenarioengine.scenarioengine.ScenarioGateway) → None ¶: C++: scenarioengine::ScenarioGateway::clearDirtyBits() –> void

getNumberOfObjects(self: pyscenarioengine.scenarioengine.ScenarioGateway) → int ¶: C++: scenarioengine::ScenarioGateway::getNumberOfObjects() –> int

getObjectStateById(self: pyscenarioengine.scenarioengine.ScenarioGateway, idx: int, objState: pyscenarioengine.scenarioengine.ObjectState) → int ¶: C++: scenarioengine::ScenarioGateway::getObjectStateById(int, class scenarioengine::ObjectState &) –> int

getObjectStateByIdx(self: pyscenarioengine.scenarioengine.ScenarioGateway, idx: int) → pyscenarioengine.scenarioengine.ObjectState ¶: C++: scenarioengine::ScenarioGateway::getObjectStateByIdx(int) –> class scenarioengine::ObjectState

getObjectStatePtrById(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int) → pyscenarioengine.scenarioengine.ObjectState ¶: C++: scenarioengine::ScenarioGateway::getObjectStatePtrById(int) –> class scenarioengine::ObjectState *

getObjectStatePtrByIdx(self: pyscenarioengine.scenarioengine.ScenarioGateway, idx: int) → pyscenarioengine.scenarioengine.ObjectState ¶: C++: scenarioengine::ScenarioGateway::getObjectStatePtrByIdx(int) –> class scenarioengine::ObjectState *

isObjectReported(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int) → bool ¶: C++: scenarioengine::ScenarioGateway::isObjectReported(int) –> bool

removeObject(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int) → None ¶: C++: scenarioengine::ScenarioGateway::removeObject(int) –> void

updateObjectAcc(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, x_acc: float, y_acc: float, z_acc: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectAcc(int, double, double, double, double) –> int

updateObjectAngularAcc(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, h_acc: float, p_acc: float, r_acc: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectAngularAcc(int, double, double, double, double) –> int

updateObjectAngularVel(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, h_rate: float, p_rate: float, r_rate: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectAngularVel(int, double, double, double, double) –> int

updateObjectLanePos(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, roadId: int, laneId: int, offset: float, s: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectLanePos(int, double, int, int, double, double) –> int

updateObjectRoadPos(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, roadId: int, lateralOffset: float, s: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectRoadPos(int, double, int, double, double) –> int

updateObjectSpeed(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, speed: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectSpeed(int, double, double) –> int

updateObjectVel(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, x_vel: float, y_vel: float, z_vel: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectVel(int, double, double, double, double) –> int

updateObjectVisibilityMask(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, visibilityMask: int) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectVisibilityMask(int, int) –> int

updateObjectWheelAngle(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, wheelAngle: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectWheelAngle(int, double, double) –> int

updateObjectWheelRotation(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, wheelRotation: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectWheelRotation(int, double, double) –> int

updateObjectWorldPos(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, x: float, y: float, z: float, h: float, p: float, r: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectWorldPos(int, double, double, double, double, double, double, double) –> int

updateObjectWorldPosXYH(self: pyscenarioengine.scenarioengine.ScenarioGateway, id: int, timestamp: float, x: float, y: float, h: float) → int ¶: C++: scenarioengine::ScenarioGateway::updateObjectWorldPosXYH(int, double, double, double, double) –> int

class pyscenarioengine.scenarioengine.OSCFile¶

Print(self: pyscenarioengine.scenarioengine.OSCFile) → None ¶: C++: scenarioengine::OSCFile::Print() –> void

assign(self: pyscenarioengine.scenarioengine.OSCFile, : pyscenarioengine.scenarioengine.OSCFile) → pyscenarioengine.scenarioengine.OSCFile ¶: C++: scenarioengine::OSCFile::operator=(const class scenarioengine::OSCFile &) –> class scenarioengine::OSCFile &

class pyscenarioengine.scenarioengine.RoadNetwork¶

Print(self: pyscenarioengine.scenarioengine.RoadNetwork) → None ¶: C++: scenarioengine::RoadNetwork::Print() –> void

assign(self: pyscenarioengine.scenarioengine.RoadNetwork, : pyscenarioengine.scenarioengine.RoadNetwork) → pyscenarioengine.scenarioengine.RoadNetwork ¶: C++: scenarioengine::RoadNetwork::operator=(const class scenarioengine::RoadNetwork &) –> class scenarioengine::RoadNetwork &

class pyscenarioengine.scenarioengine.ControllerPool¶

Clear(self: pyscenarioengine.scenarioengine.ControllerPool) → None ¶: C++: scenarioengine::ControllerPool::Clear() –> void

class pyscenarioengine.scenarioengine.ScenarioReader¶

AddController(self: pyscenarioengine.scenarioengine.ScenarioReader, controller: pyscenarioengine.scenarioengine.Controller) → None ¶: C++: scenarioengine::ScenarioReader::AddController(class scenarioengine::Controller *) –> void

GetCatalogs(self: pyscenarioengine.scenarioengine.ScenarioReader) → pyscenarioengine.scenarioengine.Catalogs ¶: C++: scenarioengine::ScenarioReader::GetCatalogs() –> class scenarioengine::Catalogs *

GetVersionMajor(self: pyscenarioengine.scenarioengine.ScenarioReader) → int ¶: C++: scenarioengine::ScenarioReader::GetVersionMajor() –> int

GetVersionMinor(self: pyscenarioengine.scenarioengine.ScenarioReader) → int ¶: C++: scenarioengine::ScenarioReader::GetVersionMinor() –> int

IsLoaded(self: pyscenarioengine.scenarioengine.ScenarioReader) → bool ¶: C++: scenarioengine::ScenarioReader::IsLoaded() –> bool

LoadControllers(self: pyscenarioengine.scenarioengine.ScenarioReader) → None ¶: C++: scenarioengine::ScenarioReader::LoadControllers() –> void

RemoveController(self: pyscenarioengine.scenarioengine.ScenarioReader, controller: pyscenarioengine.scenarioengine.Controller) → int ¶: C++: scenarioengine::ScenarioReader::RemoveController(class scenarioengine::Controller *) –> int

SetGateway(self: pyscenarioengine.scenarioengine.ScenarioReader, gateway: pyscenarioengine.scenarioengine.ScenarioGateway) → None ¶: C++: scenarioengine::ScenarioReader::SetGateway(class scenarioengine::ScenarioGateway *) –> void

UnloadControllers(self: pyscenarioengine.scenarioengine.ScenarioReader) → None ¶: C++: scenarioengine::ScenarioReader::UnloadControllers() –> void

loadOSCFile(self: pyscenarioengine.scenarioengine.ScenarioReader, path: str) → int ¶: C++: scenarioengine::ScenarioReader::loadOSCFile(const char *) –> int

parseCatalogs(self: pyscenarioengine.scenarioengine.ScenarioReader) → None ¶: C++: scenarioengine::ScenarioReader::parseCatalogs() –> void

parseEntities(self: pyscenarioengine.scenarioengine.ScenarioReader) → int ¶: C++: scenarioengine::ScenarioReader::parseEntities() –> int

parseGlobalParameterDeclarations(self: pyscenarioengine.scenarioengine.ScenarioReader) → None ¶: C++: scenarioengine::ScenarioReader::parseGlobalParameterDeclarations() –> void

parseInit(self: pyscenarioengine.scenarioengine.ScenarioReader, init: pyscenarioengine.scenarioengine.Init) → None ¶: C++: scenarioengine::ScenarioReader::parseInit(class scenarioengine::Init &) –> void

parseOSCHeader(self: pyscenarioengine.scenarioengine.ScenarioReader) → int ¶: C++: scenarioengine::ScenarioReader::parseOSCHeader() –> int

parseRoadNetwork(self: pyscenarioengine.scenarioengine.ScenarioReader, roadNetwork: pyscenarioengine.scenarioengine.RoadNetwork) → None ¶: C++: scenarioengine::ScenarioReader::parseRoadNetwork(class scenarioengine::RoadNetwork &) –> void

parseStoryBoard(self: pyscenarioengine.scenarioengine.ScenarioReader, storyBoard: pyscenarioengine.scenarioengine.StoryBoard) → int ¶: C++: scenarioengine::ScenarioReader::parseStoryBoard(class scenarioengine::StoryBoard &) –> int

class pyscenarioengine.scenarioengine.ScenarioEngine¶

GetHeadstartTime(self: pyscenarioengine.scenarioengine.ScenarioEngine) → float ¶: C++: scenarioengine::ScenarioEngine::GetHeadstartTime() –> double

GetQuitFlag(self: pyscenarioengine.scenarioengine.ScenarioEngine) → bool ¶: C++: scenarioengine::ScenarioEngine::GetQuitFlag() –> bool

GetScenarioReader(self: pyscenarioengine.scenarioengine.ScenarioEngine) → pyscenarioengine.scenarioengine.ScenarioReader ¶: C++: scenarioengine::ScenarioEngine::GetScenarioReader() –> class scenarioengine::ScenarioReader *

GetSimulationTimePtr(self: pyscenarioengine.scenarioengine.ScenarioEngine) → float ¶: C++: scenarioengine::ScenarioEngine::GetSimulationTimePtr() –> double *

GetTrueTime(self: pyscenarioengine.scenarioengine.ScenarioEngine) → float ¶: C++: scenarioengine::ScenarioEngine::GetTrueTime() –> double

GetTrueTimePtr(self: pyscenarioengine.scenarioengine.ScenarioEngine) → float ¶: C++: scenarioengine::ScenarioEngine::GetTrueTimePtr() –> double *

ReplaceObjectInTrigger(*args, **kwargs)¶

Overloaded function.

ReplaceObjectInTrigger(self: pyscenarioengine.scenarioengine.ScenarioEngine, trigger: pyscenarioengine.scenarioengine.Trigger, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object, timeOffset: float) -> None
ReplaceObjectInTrigger(self: pyscenarioengine.scenarioengine.ScenarioEngine, trigger: pyscenarioengine.scenarioengine.Trigger, obj1: pyscenarioengine.scenarioengine.Object, obj2: pyscenarioengine.scenarioengine.Object, timeOffset: float, event: pyscenarioengine.scenarioengine.Event) -> None

C++: scenarioengine::ScenarioEngine::ReplaceObjectInTrigger(class scenarioengine::Trigger *, class scenarioengine::Object *, class scenarioengine::Object *, double, class scenarioengine::Event *) –> void

ResetEvents(self: pyscenarioengine.scenarioengine.ScenarioEngine) → None ¶: C++: scenarioengine::ScenarioEngine::ResetEvents() –> void

SetHeadstartTime(self: pyscenarioengine.scenarioengine.ScenarioEngine, headstartTime: float) → None ¶: C++: scenarioengine::ScenarioEngine::SetHeadstartTime(double) –> void

SetSimulationTime(self: pyscenarioengine.scenarioengine.ScenarioEngine, time: float) → None ¶: C++: scenarioengine::ScenarioEngine::SetSimulationTime(double) –> void

SetTrueTime(self: pyscenarioengine.scenarioengine.ScenarioEngine, time: float) → None ¶: C++: scenarioengine::ScenarioEngine::SetTrueTime(double) –> void

SetupGhost(self: pyscenarioengine.scenarioengine.ScenarioEngine, object: pyscenarioengine.scenarioengine.Object) → None ¶: C++: scenarioengine::ScenarioEngine::SetupGhost(class scenarioengine::Object *) –> void

defaultController(self: pyscenarioengine.scenarioengine.ScenarioEngine, obj: pyscenarioengine.scenarioengine.Object, dt: float) → int ¶: C++: scenarioengine::ScenarioEngine::defaultController(class scenarioengine::Object *, double) –> int

getScenarioGateway(self: pyscenarioengine.scenarioengine.ScenarioEngine) → pyscenarioengine.scenarioengine.ScenarioGateway ¶: C++: scenarioengine::ScenarioEngine::getScenarioGateway() –> class scenarioengine::ScenarioGateway *

getSimulationTime(self: pyscenarioengine.scenarioengine.ScenarioEngine) → float ¶: C++: scenarioengine::ScenarioEngine::getSimulationTime() –> double

prepareGroundTruth(self: pyscenarioengine.scenarioengine.ScenarioEngine, dt: float) → None ¶: C++: scenarioengine::ScenarioEngine::prepareGroundTruth(double) –> void

printSimulationTime(self: pyscenarioengine.scenarioengine.ScenarioEngine) → None ¶: C++: scenarioengine::ScenarioEngine::printSimulationTime() –> void

step(self: pyscenarioengine.scenarioengine.ScenarioEngine, deltaSimTime: float) → int ¶: C++: scenarioengine::ScenarioEngine::step(double) –> int

Viewer base¶

Bindings for ::viewer namespace

class pyviewerbase.viewer.CarModel¶

GetType(self: pyviewerbase.viewer.CarModel) → pyviewerbase.viewer.EntityModel.EntityType ¶: C++: viewer::CarModel::GetType() –> enum viewer::EntityModel::EntityType

UpdateWheels(self: pyviewerbase.viewer.CarModel, wheel_angle: float, wheel_rotation: float) → None ¶: C++: viewer::CarModel::UpdateWheels(double, double) –> void

UpdateWheelsDelta(self: pyviewerbase.viewer.CarModel, wheel_angle: float, wheel_rotation_delta: float) → None ¶: C++: viewer::CarModel::UpdateWheelsDelta(double, double) –> void

assign(self: pyviewerbase.viewer.CarModel, : pyviewerbase.viewer.CarModel) → pyviewerbase.viewer.CarModel ¶: C++: viewer::CarModel::operator=(const class viewer::CarModel &) –> class viewer::CarModel &

class pyviewerbase.viewer.EntityModel¶

class EntityType¶

Members:

VEHICLE

OTHER

property name¶

GetType(self: pyviewerbase.viewer.EntityModel) → pyviewerbase.viewer.EntityModel.EntityType ¶: C++: viewer::EntityModel::GetType() –> enum viewer::EntityModel::EntityType

SetPosition(self: pyviewerbase.viewer.EntityModel, x: float, y: float, z: float) → None ¶: C++: viewer::EntityModel::SetPosition(double, double, double) –> void

SetRotation(*args, **kwargs)¶

Overloaded function.

SetRotation(self: pyviewerbase.viewer.EntityModel, hRoad: float, pRoad: float, hRelative: float, r: float) -> None

C++: viewer::EntityModel::SetRotation(double, double, double, double) –> void

SetRotation(self: pyviewerbase.viewer.EntityModel, h: float, p: float, r: float) -> None

C++: viewer::EntityModel::SetRotation(double, double, double) –> void

SetTransparency(self: pyviewerbase.viewer.EntityModel, factor: float) → None ¶: C++: viewer::EntityModel::SetTransparency(double) –> void

assign(self: pyviewerbase.viewer.EntityModel, : pyviewerbase.viewer.EntityModel) → pyviewerbase.viewer.EntityModel ¶: C++: viewer::EntityModel::operator=(const class viewer::EntityModel &) –> class viewer::EntityModel &

class pyviewerbase.viewer.PointSensor¶

Hide(self: pyviewerbase.viewer.PointSensor) → None ¶: C++: viewer::PointSensor::Hide() –> void

Show(self: pyviewerbase.viewer.PointSensor) → None ¶: C++: viewer::PointSensor::Show() –> void

class pyviewerbase.viewer.SensorViewFrustum¶

Update(self: pyviewerbase.viewer.SensorViewFrustum) → None ¶: C++: viewer::SensorViewFrustum::Update() –> void

class pyviewerbase.viewer.Viewer¶

AddCustomCamera(self: pyviewerbase.viewer.Viewer, x: float, y: float, z: float, h: float, p: float) → None ¶: C++: viewer::Viewer::AddCustomCamera(double, double, double, double, double) –> void

AddEntityModel(self: pyviewerbase.viewer.Viewer, model: pyviewerbase.viewer.EntityModel) → int ¶: C++: viewer::Viewer::AddEntityModel(class viewer::EntityModel *) –> int

AddEnvironment(self: pyviewerbase.viewer.Viewer, filename: str) → int ¶: C++: viewer::Viewer::AddEnvironment(const char *) –> int

CaptureContinuously(self: pyviewerbase.viewer.Viewer, state: bool) → None ¶: C++: viewer::Viewer::CaptureContinuously(bool) –> void

CaptureNextFrame(self: pyviewerbase.viewer.Viewer) → None ¶: C++: viewer::Viewer::CaptureNextFrame() –> void

ClearNodeMaskBits(self: pyviewerbase.viewer.Viewer, bits: int) → None ¶: C++: viewer::Viewer::ClearNodeMaskBits(int) –> void

CreateRoadSensors(self: pyviewerbase.viewer.Viewer, vehicle_model: pyviewerbase.viewer.CarModel) → bool ¶: C++: viewer::Viewer::CreateRoadSensors(class viewer::CarModel *) –> bool

GetEntityInFocus(self: pyviewerbase.viewer.Viewer) → int ¶: C++: viewer::Viewer::GetEntityInFocus() –> int

GetNodeMaskBit(self: pyviewerbase.viewer.Viewer, mask: int) → int ¶: C++: viewer::Viewer::GetNodeMaskBit(int) –> int

GetNumberOfCameraModes(self: pyviewerbase.viewer.Viewer) → int ¶: C++: viewer::Viewer::GetNumberOfCameraModes() –> int

GetQuitRequest(self: pyviewerbase.viewer.Viewer) → bool ¶: C++: viewer::Viewer::GetQuitRequest() –> bool

static PrintUsage() → None ¶: C++: viewer::Viewer::PrintUsage() –> void

RemoveCar(self: pyviewerbase.viewer.Viewer, index: int) → None ¶: C++: viewer::Viewer::RemoveCar(int) –> void

ReplaceCar(self: pyviewerbase.viewer.Viewer, index: int, model: pyviewerbase.viewer.EntityModel) → None ¶: C++: viewer::Viewer::ReplaceCar(int, class viewer::EntityModel *) –> void

SensorSetPivotPos(self: pyviewerbase.viewer.Viewer, sensor: pyviewerbase.viewer.PointSensor, x: float, y: float, z: float) → None ¶: C++: viewer::Viewer::SensorSetPivotPos(class viewer::PointSensor *, double, double, double) –> void

SensorSetTargetPos(self: pyviewerbase.viewer.Viewer, sensor: pyviewerbase.viewer.PointSensor, x: float, y: float, z: float) → None ¶: C++: viewer::Viewer::SensorSetTargetPos(class viewer::PointSensor *, double, double, double) –> void

SetCameraMode(self: pyviewerbase.viewer.Viewer, mode: int) → None ¶

Set mode of the esmini camera model

According to the RubberbandManipulator::CAMERA_MODE enum, plus any number of custom cameras. Set -1 to select the last.

C++: viewer::Viewer::SetCameraMode(int) –> void

SetInfoText(self: pyviewerbase.viewer.Viewer, text: str) → None ¶: C++: viewer::Viewer::SetInfoText(const char *) –> void

SetInfoTextProjection(self: pyviewerbase.viewer.Viewer, width: int, height: int) → None ¶: C++: viewer::Viewer::SetInfoTextProjection(int, int) –> void

SetNodeMaskBits(*args, **kwargs)¶

Overloaded function.

SetNodeMaskBits(self: pyviewerbase.viewer.Viewer, bits: int) -> None

C++: viewer::Viewer::SetNodeMaskBits(int) –> void

SetNodeMaskBits(self: pyviewerbase.viewer.Viewer, mask: int, bits: int) -> None

C++: viewer::Viewer::SetNodeMaskBits(int, int) –> void

SetQuitRequest(self: pyviewerbase.viewer.Viewer, value: bool) → None ¶: C++: viewer::Viewer::SetQuitRequest(bool) –> void

SetVehicleInFocus(self: pyviewerbase.viewer.Viewer, idx: int) → None ¶: C++: viewer::Viewer::SetVehicleInFocus(int) –> void

ToggleNodeMaskBits(self: pyviewerbase.viewer.Viewer, bits: int) → None ¶: C++: viewer::Viewer::ToggleNodeMaskBits(int) –> void

UpdateCameraFOV(self: pyviewerbase.viewer.Viewer) → None ¶: C++: viewer::Viewer::UpdateCameraFOV() –> void

UpdateSensor(self: pyviewerbase.viewer.Viewer, sensor: pyviewerbase.viewer.PointSensor) → None ¶: C++: viewer::Viewer::UpdateSensor(class viewer::PointSensor *) –> void

getKeyDown(self: pyviewerbase.viewer.Viewer) → bool ¶: C++: viewer::Viewer::getKeyDown() –> bool

getKeyLeft(self: pyviewerbase.viewer.Viewer) → bool ¶: C++: viewer::Viewer::getKeyLeft() –> bool

getKeyRight(self: pyviewerbase.viewer.Viewer) → bool ¶: C++: viewer::Viewer::getKeyRight() –> bool

getKeyUp(self: pyviewerbase.viewer.Viewer) → bool ¶: C++: viewer::Viewer::getKeyUp() –> bool

setKeyDown(self: pyviewerbase.viewer.Viewer, pressed: bool) → None ¶: C++: viewer::Viewer::setKeyDown(bool) –> void

setKeyLeft(self: pyviewerbase.viewer.Viewer, pressed: bool) → None ¶: C++: viewer::Viewer::setKeyLeft(bool) –> void

setKeyRight(self: pyviewerbase.viewer.Viewer, pressed: bool) → None ¶: C++: viewer::Viewer::setKeyRight(bool) –> void

setKeyUp(self: pyviewerbase.viewer.Viewer, pressed: bool) → None ¶: C++: viewer::Viewer::setKeyUp(bool) –> void

class pyviewerbase.viewer.ViewerEventHandler¶

class pyviewerbase.viewer.VisibilityCallback¶

Player base¶

class pyplayerbase.ScenarioPlayer¶

AddOSIDetection(self: pyplayerbase.ScenarioPlayer, object_index: int) → None ¶: C++: ScenarioPlayer::AddOSIDetection(int) –> void

AddObjectSensor(self: pyplayerbase.ScenarioPlayer, object_index: int, pos_x: float, pos_y: float, pos_z: float, heading: float, near: float, far: float, fovH: float, maxObj: int) → None ¶: C++: ScenarioPlayer::AddObjectSensor(int, double, double, double, double, double, double, double, int) –> void

Frame(*args, **kwargs)¶

Overloaded function.

Frame(self: pyplayerbase.ScenarioPlayer) -> None

C++: ScenarioPlayer::Frame() –> void

Frame(self: pyplayerbase.ScenarioPlayer, timestep_s: float) -> None

C++: ScenarioPlayer::Frame(double) –> void

GetFixedTimestep(self: pyplayerbase.ScenarioPlayer) → float ¶: C++: ScenarioPlayer::GetFixedTimestep() –> double

GetNumberOfParameters(self: pyplayerbase.ScenarioPlayer) → int ¶: C++: ScenarioPlayer::GetNumberOfParameters() –> int

GetNumberOfProperties(self: pyplayerbase.ScenarioPlayer, index: int) → int ¶: C++: ScenarioPlayer::GetNumberOfProperties(int) –> int

GetODRManager(self: pyplayerbase.ScenarioPlayer) → roadmanager::OpenDrive¶

GetOSIFreq(self: pyplayerbase.ScenarioPlayer) → int ¶: C++: ScenarioPlayer::GetOSIFreq() –> int

GetParameterName(self: pyplayerbase.ScenarioPlayer, index: int, type: scenarioengine::OSCParameterDeclarations::ParameterType) → str ¶: C++: ScenarioPlayer::GetParameterName(int, enum scenarioengine::OSCParameterDeclarations::ParameterType *) –> const char *

GetParameterValue(self: pyplayerbase.ScenarioPlayer, name: str, value: capsule) → int ¶: C++: ScenarioPlayer::GetParameterValue(const char *, void *) –> int

GetParameterValueBool(self: pyplayerbase.ScenarioPlayer, name: str, value: bool) → int ¶: C++: ScenarioPlayer::GetParameterValueBool(const char *, bool &) –> int

GetParameterValueDouble(self: pyplayerbase.ScenarioPlayer, name: str, value: float) → int ¶: C++: ScenarioPlayer::GetParameterValueDouble(const char *, double &) –> int

GetParameterValueInt(self: pyplayerbase.ScenarioPlayer, name: str, value: int) → int ¶: C++: ScenarioPlayer::GetParameterValueInt(const char *, int &) –> int

GetPropertyName(self: pyplayerbase.ScenarioPlayer, index: int, propertyIndex: int) → str ¶: C++: ScenarioPlayer::GetPropertyName(int, int) –> const char *

GetPropertyValue(self: pyplayerbase.ScenarioPlayer, index: int, propertyIndex: int) → str ¶: C++: ScenarioPlayer::GetPropertyValue(int, int) –> const char *

IsQuitRequested(self: pyplayerbase.ScenarioPlayer) → bool ¶: C++: ScenarioPlayer::IsQuitRequested() –> bool

ScenarioFrame(self: pyplayerbase.ScenarioPlayer, timestep_s: float) → None ¶: C++: ScenarioPlayer::ScenarioFrame(double) –> void

ScenarioFramePart(self: pyplayerbase.ScenarioPlayer, timestep_s: float) → None ¶: C++: ScenarioPlayer::ScenarioFramePart(double) –> void

SetFixedTimestep(self: pyplayerbase.ScenarioPlayer, timestep: float) → None ¶: C++: ScenarioPlayer::SetFixedTimestep(double) –> void

SetOSIFileStatus(*args, **kwargs)¶

Overloaded function.

SetOSIFileStatus(self: pyplayerbase.ScenarioPlayer, is_on: bool) -> None
SetOSIFileStatus(self: pyplayerbase.ScenarioPlayer, is_on: bool, filename: str) -> None

C++: ScenarioPlayer::SetOSIFileStatus(bool, const char *) –> void

SetParameterValue(*args, **kwargs)¶

Overloaded function.

SetParameterValue(self: pyplayerbase.ScenarioPlayer, name: str, value: capsule) -> int

C++: ScenarioPlayer::SetParameterValue(const char *, const void *) –> int

SetParameterValue(self: pyplayerbase.ScenarioPlayer, name: str, value: int) -> int

C++: ScenarioPlayer::SetParameterValue(const char *, int) –> int

SetParameterValue(self: pyplayerbase.ScenarioPlayer, name: str, value: float) -> int

C++: ScenarioPlayer::SetParameterValue(const char *, double) –> int

SetParameterValue(self: pyplayerbase.ScenarioPlayer, name: str, value: str) -> int

C++: ScenarioPlayer::SetParameterValue(const char *, const char *) –> int

SetParameterValue(self: pyplayerbase.ScenarioPlayer, name: str, value: bool) -> int

C++: ScenarioPlayer::SetParameterValue(const char *, bool) –> int

ShowObjectSensors(self: pyplayerbase.ScenarioPlayer, mode: bool) → None ¶: C++: ScenarioPlayer::ShowObjectSensors(bool) –> void

UpdateCSV_Log(self: pyplayerbase.ScenarioPlayer) → None ¶: C++: ScenarioPlayer::UpdateCSV_Log() –> void

python-esmini Documentation¶

Road Manager¶

Scenario Engine¶

Viewer base¶

Player base¶

python-esmini

Navigation

Related Topics