.. _program_listing_file_osi-documentation_osi-validation_open-simulation-interface_osi_object.proto: Program Listing for File osi_object.proto ========================================= |exhale_lsh| :ref:`Return to documentation for file ` (``osi-documentation/osi-validation/open-simulation-interface/osi_object.proto``) .. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS .. code-block:: cpp syntax = "proto2"; option optimize_for = SPEED; import "osi_common.proto"; package osi3; // // \brief A simulated object that is neither a moving object (vehicle or // \c MovingObject e.g. pedestrian, animal, or vehicle) nor a traffic related // object (\c TrafficLight, \c TrafficSign). // // \image html OSI_BaseStationary.svg // // \c StationaryObject excludes traffic lights, traffic signs and road marking // message StationaryObject { // The ID of the object. // optional Identifier id = 1; // The base parameters of the stationary object. // optional BaseStationary base = 2; // The classification of the stationary object. // optional Classification classification = 3; // Opaque reference of an associated 3D model of the stationary object. // // \note It is implementation-specific how model_references are resolved to // 3d models. // optional string model_reference = 4; // // \brief Classification data for a stationary object. // message Classification { // The type of the object. // optional Type type = 1; // The dominating material of the structure. // optional Material material = 2; // The dominating density of the material of the structure. // optional Density density = 3; // The dominating color of the material of the structure. // optional Color color = 4; // Definition of object types. // enum Type { // Type of the object is unknown (must not be used in ground truth). // TYPE_UNKNOWN = 0; // Other (unspecified but known) type of object. // TYPE_OTHER = 1; // Object is a bridge. // TYPE_BRIDGE = 2; // Object is a building. // TYPE_BUILDING = 3; // Object is a pole (e.g. from a traffic light). // TYPE_POLE = 4; // Object is a pylon. // TYPE_PYLON = 5; // Object is a delineator (e.g. at a construction site). // TYPE_DELINEATOR = 6; // Object is a tree. // TYPE_TREE = 7; // Object is a barrier. // TYPE_BARRIER = 8; // Object is vegetation. // TYPE_VEGETATION = 9; // Object is a curbstone. // TYPE_CURBSTONE = 10; // Object is a wall. // TYPE_WALL = 11; // Landmarks corresponding to vertical structures in the // environment. // TYPE_VERTICAL_STRUCTURE = 12; // Landmarks corresponding to rectangular structures in the // environment, like walls. // TYPE_RECTANGULAR_STRUCTURE = 13; // Landmarks corresponding to overhead structures in the // environment, like sign bridges. // TYPE_OVERHEAD_STRUCTURE = 14; // Landmarks corresponding to light sources or reflective structures // in the environment, like street lights or reflective poles on the // road boarder. // TYPE_REFLECTIVE_STRUCTURE = 15; // Landmarks corresponding to construction site elements in the // environment, like cones or beacons. // TYPE_CONSTRUCTION_SITE_ELEMENT = 16; } // Definition of material types. // enum Material { // Type of the material is unknown (must not be used in ground // truth). // MATERIAL_UNKNOWN = 0; // Other (unspecified but known) type of material. // MATERIAL_OTHER = 1; // Wooden structure. // MATERIAL_WOOD = 2; // Plastic structure. // MATERIAL_PLASTIC = 3; // Concrete structure. // MATERIAL_CONCRETE = 4; // Metal structure. // MATERIAL_METAL = 5; // Natural stone structure. // MATERIAL_STONE = 6; // Glas structure. // MATERIAL_GLAS = 7; // Mud structure. // MATERIAL_MUD = 8; } // Definition of material density types. // enum Density { // Type of the material density is unknown (must not be used in // ground truth). // DENSITY_UNKNOWN = 0; // Other (unspecified but known) type of material density. // DENSITY_OTHER = 1; // No perforation - solid; // DENSITY_SOLID = 2; // Perforation max. ]0; 100] [mm] // DENSITY_SMALL_MESH = 3; // Perforation max. ]100; 500] [mm] // DENSITY_MEDIAN_MESH = 4; // Perforation max. ]500; 5000] [mm] // DENSITY_LARGE_MESH = 5; // Perforation max. ]5000; infinity] [mm] // DENSITY_OPEN = 6; } // Definition of colors for structures. // enum Color { // Color is unknown (must not be used in ground truth). // COLOR_UNKNOWN = 0; // Other (unspecified but known) color. // COLOR_OTHER = 1; // Yellow. // COLOR_YELLOW = 2; // Green. // COLOR_GREEN = 3; // Blue. // COLOR_BLUE = 4; // Violet. // COLOR_VIOLET = 5; // Red. // COLOR_RED = 6; // Orange. // COLOR_ORANGE = 7; // Black. // COLOR_BLACK = 8; // GREY. // COLOR_GREY = 9; // White. // COLOR_WHITE = 10; } } } // // \brief A simulated object that is either a vehicle or another // moving object (animal, pedestrian, etc), but not a stationary // object (\c TrafficLight, \c TrafficSign, or \c StationaryObject). // // \image html OSI_MovingObject.svg // // \image html OSI_HostVehicle.svg // // \note The field \c MovingObject::vehicle_extension has to be // filled if the \c MovingObject::Type is a vehicle. // message MovingObject { // The ID of the object. // optional Identifier id = 1; // The base parameters of the vehicle. // // \note The bounding box does NOT includes mirrors for vehicles. // optional BaseMoving base = 2; // The type of the object. // optional Type type = 3; // The IDs of the lanes that this object is assigned to. // // \note Might be multiple if the object is switching lanes or moving from // one lane into another following lane. // // \note OSI uses singular instead of plural for repeated field names. // repeated Identifier assigned_lane_id = 4; // Specific information about the vehicle. // // \note This field is mandatory if the \c #type is // #TYPE_VEHICLE . // optional VehicleAttributes vehicle_attributes = 5; // Specific information about the classification of the vehicle. // // // \note This field is mandatory if the \c #type is // #TYPE_VEHICLE . // optional VehicleClassification vehicle_classification = 6; // Opaque reference of an associated 3D model of the moving object. // // \note It is implementation-specific how model_references are resolved to // 3d models. // optional string model_reference = 7; // Definition of object types. // enum Type { // Type of the object is unknown (must not be used in ground truth). // TYPE_UNKNOWN = 0; // Other (unspecified but known) type of moving object. // TYPE_OTHER = 1; // Object is a vehicle. // TYPE_VEHICLE = 2; // Object is a pedestrian. // TYPE_PEDESTRIAN = 3; // Object is an animal. // TYPE_ANIMAL = 4; } // // \brief The vehicle attributes for \c MovingObject (host or other). // // This is an extension to the \c MovingObject with additional attributes, // such as type and lights. The origin of the rear (front) axis coordinate // system in world coordinates is calculated as: // \c MovingObject::base . \c BaseMoving::position + R * \c // MovingObject::VehicleAttributes::bbcenter_to_rear (front) for the host // vehicle (R rotates from vehicle to world frame, i.e. inverse orientation // of \c MovingObject::base . \c BaseMoving::orientation). // // For all vehicles, including host vehicles, the position given in // \c MovingObject::base . \c BaseMoving::position points to the center of // the vehicle's bounding box. // // The vehicle object coordinates are defined as x-axis is the direction // from rear to front of the vehicle, y-axis corresponds to rear axle and // z-axis points to vehicle ceiling [1]. The coordinate system is // right-handed. Therefore the positive y-axis points to the left of the // vehicle. // // \par References: // - [1] DIN ISO 8855:2013-11 // message VehicleAttributes { // The ID of the driver of the (host) vehicle. // // \note Field need not be set if host_vehicle is set to false or use // value for non valid id. // optional Identifier driver_id = 1; // Median radius of the wheels measured from a center of the wheel // including tire. // // Unit: [m] // optional double radius_wheel = 2; // Number of independent wheels. // // Unit: [] // optional uint32 number_wheels = 3; // The vector pointing from the bounding box center point (\c // MovingObject::base . \c BaseMoving::position) to the middle (in x, y // and z) of the rear axle under neutral load conditions. In object // coordinates. // optional Vector3d bbcenter_to_rear = 4; // The vector pointing from the bounding box center point (\c // MovingObject::base . \c BaseMoving::position) to the middle (in x, y // and z) of the front axle under neutral load conditions. In object // coordinates. // optional Vector3d bbcenter_to_front = 5; // Static minimal distance in [m] of under-body plane to ground // surface plane (i.e. disregarding driving dynamic effects or road // surface effects) under neutral load conditions. Can be useful to // approximate the clear area under a vehicle that a sensor can see // through. // optional double ground_clearance = 6; } // // \brief Information for the classification of vehicles regarding // \c MovingObject (host or other). // message VehicleClassification { // The type of the vehicle. // optional Type type = 1; // The light state of the vehicle. // optional LightState light_state = 2; // Flag defining whether the vehicle has an attached trailer. // optional bool has_trailer = 3; // Id of the attached trailer. // // \note Field need not be set if has_Trailer is set to false or use // value for non valid id. // optional Identifier trailer_id = 4; // Definition of vehicle types. // enum Type { // Type of vehicle is unknown (must not be used in ground truth). // TYPE_UNKNOWN = 0; // Other (unspecified but known) type of vehicle. // TYPE_OTHER = 1; // Vehicle is a small car. // // Definition: Hatchback car with maximum length 4 m. // TYPE_SMALL_CAR = 2; // Vehicle is a compact car. // // Definition: Hatchback car with length between 4 and 4.5 m. // TYPE_COMPACT_CAR = 3; // Vehicle is a medium car. // // Definition: Hatchback or sedan with lenght between 4.5 and 5 m. // TYPE_MEDIUM_CAR = 4; // Vehicle is a luxury car. // // Definition: Sedan or coupe that is longer then 5 m. // TYPE_LUXURY_CAR = 5; // Vehicle is a delivery van. // // Definition: A delivery van. // TYPE_DELIVERY_VAN = 6; // Vehicle is a heavy truck. // TYPE_HEAVY_TRUCK = 7; // Vehicle is a truck with semitrailer. // TYPE_SEMITRAILER = 8; // Vehicle is a trailer (possibly attached to another vehicle). // TYPE_TRAILER = 9; // Vehicle is a motorbike or moped. // TYPE_MOTORBIKE = 10; // Vehicle is a bicycle (without motor and specific lights). // TYPE_BICYCLE = 11; // Vehicle is a bus. // TYPE_BUS = 12; // Vehicle is a tram. // TYPE_TRAM = 13; // Vehicle is a train. // TYPE_TRAIN = 14; // Vehicle is a wheelchair. // TYPE_WHEELCHAIR = 15; } // // \brief The state of the lights of a vehicle. // message LightState { // State of the object's indicators. // optional IndicatorState indicator_state = 1; // State of the front fog light. // optional GenericLightState front_fog_light = 2; // State of the rear fog light. // optional GenericLightState rear_fog_light = 3; // State of the head lights. // optional GenericLightState head_light = 4; // State of the high beam. // optional GenericLightState high_beam = 5; // State of the reversing light. // optional GenericLightState reversing_light = 6; // State of the brake lights. // optional BrakeLightState brake_light_state = 7; // State of the (rear) license plate illumination. // optional GenericLightState license_plate_illumination_rear = 8; // Lighting of emergency vehicles (ambulance, fire engine, police // car, etc.). Must be set only if a vehicle is allowed to use this // illumination type. // optional GenericLightState emergency_vehicle_illumination = 9; // Lighting of service vehicles (snow removal, garbage truck, towing // vehicle, slow or wide vehicle, etc.). Must be set only if a // vehicle is allowed to use this illumination type. // optional GenericLightState service_vehicle_illumination = 10; // Definition of indicator states. // enum IndicatorState { // Indicator state is unknown (must not be used in ground // truth). // INDICATOR_STATE_UNKNOWN = 0; // Other (unspecified but known) state of indicator. // INDICATOR_STATE_OTHER = 1; // Indicators are off. // INDICATOR_STATE_OFF = 2; // Left indicator is on. // INDICATOR_STATE_LEFT = 3; // Right indicator is on. // INDICATOR_STATE_RIGHT = 4; // Hazard/warning light, i.e. both indicators, are on. // INDICATOR_STATE_WARNING = 5; } // Definition of generic light states for light that may be on or // off. // enum GenericLightState { // Light state is unknown (must not be used in ground truth). // GENERIC_LIGHT_STATE_UNKNOWN = 0; // Other (unspecified but known) state of light. // GENERIC_LIGHT_STATE_OTHER = 1; // Light is off. // GENERIC_LIGHT_STATE_OFF = 2; // Light is on. // GENERIC_LIGHT_STATE_ON = 3; // Light is flashing blue. // To be used for emergency vehicles. // GENERIC_LIGHT_STATE_FLASHING_BLUE = 4; // Light is flashing blue and red. // To be used for emergency vehicles. // GENERIC_LIGHT_STATE_FLASHING_BLUE_AND_RED = 5; // Light is flashing amber. // To be used for service vehicles. // GENERIC_LIGHT_STATE_FLASHING_AMBER = 6; } // Definition of brake light states. // enum BrakeLightState { // Brake light state is unknown (must not be used in ground // truth). // BRAKE_LIGHT_STATE_UNKNOWN = 0; // Other (unspecified but known) state of brake light. // BRAKE_LIGHT_STATE_OTHER = 1; // Brake lights are off. // BRAKE_LIGHT_STATE_OFF = 2; // Brake lights are on with normal intensity. // BRAKE_LIGHT_STATE_NORMAL = 3; // Brake lights are on with extra bright intensity (indicating // stronger braking). BRAKE_LIGHT_STATE_STRONG = 4; } } } }