osi_object.proto

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;
            }
        }
    }
}