From 5f82b80b2a9d08d02d70571a57d6419346eaa1ea Mon Sep 17 00:00:00 2001 From: Aidan Clear Date: Fri, 15 Mar 2019 17:10:12 +0100 Subject: [PATCH] Updating and adding new lane record classes. Updating map builder to create instances of these classes for the parser --- LibCarla/source/carla/road/MapBuilder.cpp | 195 +++++++++++++++++- LibCarla/source/carla/road/MapBuilder.h | 25 ++- .../carla/road/element/RoadInfoLaneAccess.h | 46 +++++ .../carla/road/element/RoadInfoLaneBorder.h | 54 +++++ .../carla/road/element/RoadInfoLaneHeight.h | 53 +++++ .../carla/road/element/RoadInfoLaneMaterial.h | 58 ++++++ .../carla/road/element/RoadInfoLaneOffset.h | 10 +- .../carla/road/element/RoadInfoLaneRule.h | 44 ++++ .../road/element/RoadInfoLaneVisibility.h | 73 +++++++ .../carla/road/element/RoadInfoMarkRecord.h | 56 +++-- .../carla/road/element/RoadInfoMarkTypeLine.h | 82 ++++++++ .../carla/road/element/RoadInfoVelocity.h | 10 +- .../carla/road/element/RoadInfoVisitor.h | 38 ++-- 13 files changed, 700 insertions(+), 44 deletions(-) create mode 100644 LibCarla/source/carla/road/element/RoadInfoLaneAccess.h create mode 100644 LibCarla/source/carla/road/element/RoadInfoLaneBorder.h create mode 100644 LibCarla/source/carla/road/element/RoadInfoLaneHeight.h create mode 100644 LibCarla/source/carla/road/element/RoadInfoLaneMaterial.h create mode 100644 LibCarla/source/carla/road/element/RoadInfoLaneRule.h create mode 100644 LibCarla/source/carla/road/element/RoadInfoLaneVisibility.h create mode 100644 LibCarla/source/carla/road/element/RoadInfoMarkTypeLine.h diff --git a/LibCarla/source/carla/road/MapBuilder.cpp b/LibCarla/source/carla/road/MapBuilder.cpp index 6bb0b4b0e..40cbbb682 100644 --- a/LibCarla/source/carla/road/MapBuilder.cpp +++ b/LibCarla/source/carla/road/MapBuilder.cpp @@ -5,8 +5,22 @@ // For a copy, see . #include "carla/road/MapBuilder.h" +#include "carla/road/element/RoadElevationInfo.h" +#include "carla/road/element/RoadInfoLaneAccess.h" +#include "carla/road/element/RoadInfoLaneBorder.h" +#include "carla/road/element/RoadInfoLaneHeight.h" +#include "carla/road/element/RoadInfoLaneMaterial.h" +#include "carla/road/element/RoadInfoLaneOffset.h" +#include "carla/road/element/RoadInfoLaneRule.h" +#include "carla/road/element/RoadInfoLaneVisibility.h" +#include "carla/road/element/RoadInfoLaneWidth.h" +#include "carla/road/element/RoadInfoMarkRecord.h" +#include "carla/road/element/RoadInfoMarkTypeLine.h" +#include "carla/road/element/RoadInfoVelocity.h" #include "carla/road/element/RoadInfoVisitor.h" + #include +#include using namespace carla::road::element; @@ -25,6 +39,171 @@ namespace road { return Map{std::move(_map_data)}; } + // called from profiles parser + void AddRoadElevationProfile( + const int32_t /*road_id*/, + const double s, + const double a, + const double b, + const double c, + const double d) { + auto elevation = std::unique_ptr(new RoadElevationInfo(s, a, b, c, d)); + } + + // called from lane parser + void MapBuilder::CreateLaneAccess( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const std::string restriction) { + auto access = std::unique_ptr(new RoadInfoLaneAccess(s, restriction)); + } + + void MapBuilder::CreateLaneBorder( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const float a, + const float b, + const float c, + const float d) { + auto border = std::unique_ptr(new RoadInfoLaneBorder(s, a, b, c, d)); + } + + void MapBuilder::CreateLaneHeight( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const float inner, + const float outer) { + auto height = std::unique_ptr(new RoadInfoLaneHeight(s, inner, outer)); + } + + void MapBuilder::CreateLaneMaterial( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const std::string surface, + const float friction, + const float roughness) { + auto material = + std::unique_ptr(new RoadInfoLaneMaterial(s, surface, friction, roughness)); + } + + void MapBuilder::CreateLaneOffset( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const float a, + const float b, + const float c, + const float d) { + auto offset = std::unique_ptr(new RoadInfoLaneOffset(s, a, b, c, d)); + } + + void MapBuilder::CreateLaneRule( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const std::string value) { + auto rule = std::unique_ptr(new RoadInfoLaneRule(s, value)); + } + + void MapBuilder::CreateLaneVisibility( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const float forward, + const float back, + const float left, + const float right) { + auto visibility = + std::unique_ptr(new RoadInfoLaneVisibility(s, forward, back, left, right)); + } + + void MapBuilder::CreateLaneWidth( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const float a, + const float b, + const float c, + const float d) { + auto width = std::unique_ptr(new RoadInfoLaneWidth(s, a, b, c, d)); + } + + void MapBuilder::CreateRoadMark( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const int road_mark_id, + const float s, + const std::string type, + const std::string weight, + const std::string color, + const std::string material, + const float width, + const std::string lane_change, + const float height, + const std::string type_name, + const float type_width) { + RoadInfoMarkRecord::LaneChange lc; + + // to lower case. + auto tl = [](auto) -> std::string { throw_exception(std::runtime_error("not implemented")); }; + + if (tl(lane_change) == "increase") { + lc = RoadInfoMarkRecord::LaneChange::Increase; + } else if (tl(lane_change) == "decrease") { + lc = RoadInfoMarkRecord::LaneChange::Decrease; + } else if (tl(lane_change) == "both") { + lc = RoadInfoMarkRecord::LaneChange::Both; + } else { + lc = RoadInfoMarkRecord::LaneChange::None; + } + auto mark = + std::unique_ptr(new RoadInfoMarkRecord(s, road_mark_id, type, weight, color, + material, width, lc, height, type_name, type_width)); + } + + void MapBuilder::CreateRoadMarkTypeLine( + const int32_t /*road_id*/, + const int32_t /*lane_section_id*/, + const int32_t /*lane_id*/, + const int road_mark_id, + const float length, + const float space, + const float tOffset, + const float s, + const std::string rule, + const float width) { + auto line = + std::unique_ptr(new RoadInfoMarkTypeLine(s, road_mark_id, length, space, + tOffset, rule, width)); + // Find the parent road mark record using the ids provided and then add this + // line to its lise of lines + // road_mark.GetLines().push_back(std::move(line); + + } + + void MapBuilder::CreateLaneSpeed( + const int32_t /*road_id*/, + const int /*lane_section_id*/, + const int32_t /*lane_id*/, + const float s, + const float max, + const std::string /*unit*/) { + auto speed = std::unique_ptr(new RoadInfoVelocity(s, max)); + } + void MapBuilder::AddSignal( const uint32_t road_id, const uint32_t signal_id, @@ -46,13 +225,19 @@ namespace road { const float pitch, const float roll) { - _map_data.GetRoad(road_id)->getSignals().emplace(signal_id, signal::Signal(road_id, signal_id, s, t, name, dynamic, + _map_data.GetRoad(road_id)->getSignals().emplace(signal_id, + signal::Signal(road_id, signal_id, s, t, name, dynamic, orientation, zOffset, country, type, subtype, value, unit, height, width, text, hOffset, pitch, roll)); } - void MapBuilder::AddValidityToLastAddedSignal(uint32_t road_id, uint32_t signal_id, int32_t from_lane, int32_t to_lane) { - _map_data.GetRoad(road_id)->GetSignal(signal_id).AddValidity(general::Validity(signal_id, from_lane, to_lane)); + void MapBuilder::AddValidityToLastAddedSignal( + uint32_t road_id, + uint32_t signal_id, + int32_t from_lane, + int32_t to_lane) { + _map_data.GetRoad(road_id)->GetSignal(signal_id).AddValidity(general::Validity(signal_id, from_lane, + to_lane)); } // build road objects @@ -98,7 +283,6 @@ namespace road { sec->_lane_offset = cubic; } - void MapBuilder::AddRoadSectionLane( const uint32_t road_id, const uint32_t section_index, @@ -132,7 +316,8 @@ namespace road { lane->_lane_section = section; lane->_level = lane_level; lane->_type = lane_type; - // we save id as pointers temporally, later will be processed in the right way + // we save id as pointers temporally, later will be processed in the right + // way lane->_next_lanes.emplace_back(reinterpret_cast(successor)); lane->_prev_lanes.emplace_back(reinterpret_cast(predecessor)); } diff --git a/LibCarla/source/carla/road/MapBuilder.h b/LibCarla/source/carla/road/MapBuilder.h index 6ca7e8d35..d819f38ab 100644 --- a/LibCarla/source/carla/road/MapBuilder.h +++ b/LibCarla/source/carla/road/MapBuilder.h @@ -16,7 +16,6 @@ namespace carla { namespace road { class MapBuilder { - public: boost::optional Build(); @@ -164,7 +163,11 @@ namespace road { const float pitch, const float roll); - void AddValidityToLastAddedSignal(uint32_t road_id, uint32_t signal_id, int32_t from_lane, int32_t to_lane); + void AddValidityToLastAddedSignal( + uint32_t road_id, + uint32_t signal_id, + int32_t from_lane, + int32_t to_lane); // called from junction parser void AddJunction(const int32_t id, const std::string name); @@ -181,6 +184,24 @@ namespace road { const int32_t from, const int32_t to); + void AddRoadSection( + const uint32_t road_id, + const uint32_t section_index, + const double s, + const double a, + const double b, + const double c, + const double d); + + void SetRoadLaneLink( + const uint32_t road_id, + const int32_t section_index, + const int32_t lane_id, + const std::string lane_type, + const bool lane_level, + const int32_t predecessor, + const int32_t successor); + // called from lane parser void CreateLaneAccess( const int32_t road_id, diff --git a/LibCarla/source/carla/road/element/RoadInfoLaneAccess.h b/LibCarla/source/carla/road/element/RoadInfoLaneAccess.h new file mode 100644 index 000000000..113d9aa31 --- /dev/null +++ b/LibCarla/source/carla/road/element/RoadInfoLaneAccess.h @@ -0,0 +1,46 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/road/element/RoadInfo.h" +#include + +namespace carla { +namespace road { +namespace element { + + // This record defines access restrictions for certain types of road users. The record can be used to + // complement restrictions resulting from signs or signals in order to control the traffic flow in a scenario. + // Each entry is valid in direction of the increasing s co-ordinate until a new entry is defined. If multiple + // entries are defined, they must be listed in increasing order. + class RoadInfoLaneAccess : public RoadInfo { + + public: + + void AcceptVisitor(RoadInfoVisitor &v) override final { + v.Visit(*this); + } + + RoadInfoLaneAccess( + float s, // start position relative to the position of the preceding lane section + std::string restriction) + : RoadInfo(s), + _restriction(restriction) {} + + std::string GetRestriction() const { + return _restriction; + } + + private: + + std::string _restriction; // Examples: Simulator, Autonomous Traffic, Pedestrian and None + + }; + +} // namespace element +} // namespace road +} // namespace carla diff --git a/LibCarla/source/carla/road/element/RoadInfoLaneBorder.h b/LibCarla/source/carla/road/element/RoadInfoLaneBorder.h new file mode 100644 index 000000000..417e568b0 --- /dev/null +++ b/LibCarla/source/carla/road/element/RoadInfoLaneBorder.h @@ -0,0 +1,54 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/road/element/RoadInfo.h" +#include "carla/geom/CubicPolynomial.h" + +namespace carla { +namespace road { +namespace element { + + // Instead of describing lanes by their width entries and, thus, invariably + // depending on influences of inner + // lanes on outer lanes, it might be more convenient to just describe the + // outer border of each lane + // independent of any inner lanes’ parameters. Especially in cases where road + // data is derived from + // measurements, this type of definition will provide a more convenient method + // without the need to + // tesselate road sections into too many parts. Note. Lane borders and widths + // are mutually exclusive. + class RoadInfoLaneBorder : public RoadInfo { + public: + + void AcceptVisitor(RoadInfoVisitor &v) final { + v.Visit(*this); + } + + RoadInfoLaneBorder( + float s, + float a, + float b, + float c, + float d) + : RoadInfo(s), + _border(a, b, c, d, s) {} + + const geom::CubicPolynomial &GetPolynomial() const { + return _border; + } + + private: + + geom::CubicPolynomial _border; + + }; + +} // namespace element +} // namespace road +} // namespace carla diff --git a/LibCarla/source/carla/road/element/RoadInfoLaneHeight.h b/LibCarla/source/carla/road/element/RoadInfoLaneHeight.h new file mode 100644 index 000000000..69df31b4e --- /dev/null +++ b/LibCarla/source/carla/road/element/RoadInfoLaneHeight.h @@ -0,0 +1,53 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/road/element/RoadInfo.h" +#include "carla/geom/CubicPolynomial.h" + +namespace carla { +namespace road { +namespace element { + + // The surface of a lane may be offset from the plane defined by the reference line and the + // corresponding elevation and crossfall entries (e.g. pedestrian walkways are typically a few centimeters + // above road level). The height record provides a simplified method to describe this offset by setting an + // inner and outer offset from road level at discrete positions along the lane profile. + class RoadInfoLaneHeight : public RoadInfo { + public: + + void AcceptVisitor(RoadInfoVisitor &v) final { + v.Visit(*this); + } + + RoadInfoLaneHeight( + float s, // start position relative to the position of the preceding lane section + float inner, + float outer) + : RoadInfo(s), + _inner(inner), + _outer(outer) {} + + float GetInner() const { + return _inner; + } + + float GetOuter() const { + return _outer; + } + + private: + + float _inner; // inner offset from road level + + float _outer; // outer offset from road level + + }; + +} // namespace element +} // namespace road +} // namespace carla diff --git a/LibCarla/source/carla/road/element/RoadInfoLaneMaterial.h b/LibCarla/source/carla/road/element/RoadInfoLaneMaterial.h new file mode 100644 index 000000000..5b3764519 --- /dev/null +++ b/LibCarla/source/carla/road/element/RoadInfoLaneMaterial.h @@ -0,0 +1,58 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/road/element/RoadInfo.h" +#include + +namespace carla { +namespace road { +namespace element { + + class RoadInfoLaneMaterial : public RoadInfo { + + public: + + void AcceptVisitor(RoadInfoVisitor &v) override final { + v.Visit(*this); + } + + RoadInfoLaneMaterial( + float s, // start position relative to the position of the preceding + // lane section + std::string surface, + float friction, + float roughness) + : RoadInfo(s), + _surface(surface), + _friction(friction), + _roughness(roughness) {} + + const std::string& GetSurface() const { + return _surface; + } + + float GetFriction() const { + return _friction; + } + + float GetRoughness() const { + return _roughness; + } + + private: + + std::string _surface; + + float _friction; + + float _roughness; + }; + +} // namespace element +} // namespace road +} // namespace carla diff --git a/LibCarla/source/carla/road/element/RoadInfoLaneOffset.h b/LibCarla/source/carla/road/element/RoadInfoLaneOffset.h index cf1871df7..138138e3e 100644 --- a/LibCarla/source/carla/road/element/RoadInfoLaneOffset.h +++ b/LibCarla/source/carla/road/element/RoadInfoLaneOffset.h @@ -27,11 +27,11 @@ namespace element { } RoadInfoLaneOffset( - double s, - double a, - double b, - double c, - double d) + float s, + float a, + float b, + float c, + float d) : RoadInfo(s), _offset(a, b, c, d, s) {} diff --git a/LibCarla/source/carla/road/element/RoadInfoLaneRule.h b/LibCarla/source/carla/road/element/RoadInfoLaneRule.h new file mode 100644 index 000000000..5600051a8 --- /dev/null +++ b/LibCarla/source/carla/road/element/RoadInfoLaneRule.h @@ -0,0 +1,44 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/road/element/RoadInfo.h" +#include + +namespace carla { +namespace road { +namespace element { + + // This record defines rules that can be applied to lanes to describe additonal properties + // not covered by the other attributes. + class RoadInfoLaneRule : public RoadInfo { + + public: + + void AcceptVisitor(RoadInfoVisitor &v) override final { + v.Visit(*this); + } + + RoadInfoLaneRule( + float s, // start position relative to the position of the preceding lane section + std::string value) + : RoadInfo(s), + _value(value) {} + + std::string GetValue() const { + return _value; + } + + private: + + std::string _value; // Recommended values: No Stopping At Any Time, Disabled Parking and Car Pool + + }; + +} // namespace element +} // namespace road +} // namespace carla diff --git a/LibCarla/source/carla/road/element/RoadInfoLaneVisibility.h b/LibCarla/source/carla/road/element/RoadInfoLaneVisibility.h new file mode 100644 index 000000000..102e1c6b3 --- /dev/null +++ b/LibCarla/source/carla/road/element/RoadInfoLaneVisibility.h @@ -0,0 +1,73 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/road/element/RoadInfo.h" + +namespace carla { +namespace road { +namespace element { + + // Each lane within a road cross section may be provided with several entries + // defining the visibility in four + // directions relative to the lane’s direction. Each entry is valid until a + // new entry is defined. If multiple + // entries are defined, they must be listed in increasing order. + // + // For left lanes (positive ID), the forward direction is oriented opposite to + // the track’s direction, for right + // lanes, the forward direction and the track’s direction are identical. + class RoadInfoLaneVisibility : public RoadInfo { + public: + + void AcceptVisitor(RoadInfoVisitor &v) final { + v.Visit(*this); + } + + RoadInfoLaneVisibility( + float s, // start position relative to the position of the preceding + // lane section + float forward, + float back, + float left, + float right) + : RoadInfo(s), + _forward(forward), + _back(back), + _left(left), + _right(right) {} + + float GetForward() const { + return _forward; + } + + float GetBack() const { + return _back; + } + + float GetLeft() const { + return _left; + } + + float GetRight() const { + return _right; + } + + private: + + float _forward; + + float _back; + + float _left; + + float _right; + }; + +} // namespace element +} // namespace road +} // namespace carla diff --git a/LibCarla/source/carla/road/element/RoadInfoMarkRecord.h b/LibCarla/source/carla/road/element/RoadInfoMarkRecord.h index 8eaaa2f28..65e83bb8d 100644 --- a/LibCarla/source/carla/road/element/RoadInfoMarkRecord.h +++ b/LibCarla/source/carla/road/element/RoadInfoMarkRecord.h @@ -7,8 +7,10 @@ #pragma once #include "carla/road/element/RoadInfo.h" - +#include "carla/road/element/RoadInfoMarkTypeLine.h" #include +#include +#include namespace carla { namespace road { @@ -34,33 +36,48 @@ namespace element { Both = 0x03 //11 }; - RoadInfoMarkRecord(float d) - : RoadInfo(d), + RoadInfoMarkRecord( + float s, + int road_mark_id) + : RoadInfo(s), + _road_mark_id(road_mark_id), _type(""), _weight(""), _color("white"), _material("standard"), _width(0.15), _lane_change(LaneChange::None), - _height(0.0) {} + _height(0.0), + _type_name(""), + _type_width(0.0) {} RoadInfoMarkRecord( - float d, + float s, + int road_mark_id, std::string type, std::string weight, std::string color, std::string material, float width, LaneChange lane_change, - float height) - : RoadInfo(d), + float height, + std::string type_name, + float type_width) + : RoadInfo(s), + _road_mark_id(road_mark_id), _type(type), _weight(weight), _color(color), _material(material), _width(width), _lane_change(lane_change), - _height(height) {} + _height(height), + _type_name(type_name), + _type_width(type_width) {} + + int GetRoadMarkId() const { + return _road_mark_id; + } const std::string &GetType() const { return _type; @@ -90,25 +107,40 @@ namespace element { return _height; } - float GetLaneId() const { - return _height; + const std::string &GetTypeName() const { + return _type_name; + } + + float GetTypeWidth() const { + return _type_width; + } + + std::vector> &GetLines() { + return _lines; } private: + int _road_mark_id; // Unique identifer for the road mark std::string _type; // Type of the road mark std::string _weight; // Weight of the road mark std::string _color; // Color of the road mark std::string _material; // Material of the road mark (identifiers to be // defined, use "standard" for the moment - float _width; // Width of the road mark –optional + float _width; // Width of the road mark –optional LaneChange _lane_change; // Allow a lane change in the indicated direction // taking into account that lanes are numbered in // ascending order from right to left. If the // attributeis missing, “both” is assumed to be // valid. - float _height; // Physical distance of top edge of road mark from + float _height; // Physical distance of top edge of road mark from // reference plane of the lane + + std::string _type_name; // Name of the road mark type if it has one + + float _type_width; // Width of the road mark type if it has one + + std::vector> _lines; }; } // namespace element diff --git a/LibCarla/source/carla/road/element/RoadInfoMarkTypeLine.h b/LibCarla/source/carla/road/element/RoadInfoMarkTypeLine.h new file mode 100644 index 000000000..e7642c9ef --- /dev/null +++ b/LibCarla/source/carla/road/element/RoadInfoMarkTypeLine.h @@ -0,0 +1,82 @@ +// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma +// de Barcelona (UAB). +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +#pragma once + +#include "carla/road/element/RoadInfo.h" +#include + +namespace carla { +namespace road { +namespace element { + + class RoadInfoMarkTypeLine : public RoadInfo { + + public: + + void AcceptVisitor(RoadInfoVisitor &v) override final { + v.Visit(*this); + } + + RoadInfoMarkTypeLine( + float s, + int road_mark_id, + float length, + float space, + float tOffset, + std::string rule, + float width) + : RoadInfo(s), + _road_mark_id(road_mark_id), + _length(length), + _space(space), + _tOffset(tOffset), + _rule(rule), + _width(width) {} + + int GetRoadMarkId() const { + return _road_mark_id; + } + + float GetLength() const { + return _length; + } + + float GetSpace() const { + return _space; + } + + float GetTOffset() const { + return _tOffset; + } + + const std::string& GetRule() const { + return _rule; + } + + float GetWidth() const { + return _width; + } + + private: + + int _road_mark_id; + + float _length; + + float _space; + + float _tOffset; + + std::string _rule; + + float _width; + + }; + +} // namespace element +} // namespace road +} // namespace carla diff --git a/LibCarla/source/carla/road/element/RoadInfoVelocity.h b/LibCarla/source/carla/road/element/RoadInfoVelocity.h index b41b86d22..f0dfd31dd 100644 --- a/LibCarla/source/carla/road/element/RoadInfoVelocity.h +++ b/LibCarla/source/carla/road/element/RoadInfoVelocity.h @@ -20,18 +20,18 @@ namespace element { v.Visit(*this); } - RoadInfoVelocity(double vel) : velocity(vel) {} - RoadInfoVelocity(double d, double vel) - : RoadInfo(d), + RoadInfoVelocity(float vel) : velocity(vel) {} + RoadInfoVelocity(float s, float vel) + : RoadInfo(s), velocity(vel) {} - double GetVelocity() { + float GetVelocity() { return velocity; } private: - double velocity; + float velocity; }; } // namespace element diff --git a/LibCarla/source/carla/road/element/RoadInfoVisitor.h b/LibCarla/source/carla/road/element/RoadInfoVisitor.h index 27632b62a..345a23291 100644 --- a/LibCarla/source/carla/road/element/RoadInfoVisitor.h +++ b/LibCarla/source/carla/road/element/RoadInfoVisitor.h @@ -13,31 +13,39 @@ namespace carla { namespace road { namespace element { + class RoadElevationInfo; + class RoadGeneralInfo; class RoadInfo; class RoadInfoLane; - class RoadGeneralInfo; - class RoadInfoVelocity; - class RoadElevationInfo; + class RoadInfoLaneAccess; + class RoadInfoLaneBorder; + class RoadInfoLaneHeight; + class RoadInfoLaneMaterial; + class RoadInfoLaneOffset; + class RoadInfoLaneRule; + class RoadInfoLaneVisibility; class RoadInfoLaneWidth; class RoadInfoMarkRecord; - class RoadInfoLaneOffset; + class RoadInfoMarkTypeLine; + class RoadInfoVelocity; class RoadInfoVisitor { public: - virtual void Visit(RoadInfoLane &) {} - - virtual void Visit(RoadGeneralInfo &) {} - - virtual void Visit(RoadInfoVelocity &) {} - virtual void Visit(RoadElevationInfo &) {} - - virtual void Visit(RoadInfoLaneWidth &) {} - - virtual void Visit(RoadInfoMarkRecord &) {} - + virtual void Visit(RoadGeneralInfo &) {} + virtual void Visit(RoadInfoLane &) {} + virtual void Visit(RoadInfoLaneAccess &) {} + virtual void Visit(RoadInfoLaneBorder &) {} + virtual void Visit(RoadInfoLaneHeight &) {} + virtual void Visit(RoadInfoLaneMaterial &) {} virtual void Visit(RoadInfoLaneOffset &) {} + virtual void Visit(RoadInfoLaneRule &) {} + virtual void Visit(RoadInfoLaneVisibility &) {} + virtual void Visit(RoadInfoLaneWidth &) {} + virtual void Visit(RoadInfoMarkRecord &) {} + virtual void Visit(RoadInfoMarkTypeLine &) {} + virtual void Visit(RoadInfoVelocity &) {} }; template