Object.hpp

Go to the documentation of this file.

//
// Object.hpp
//
// Container for objects.
//


#ifndef OBJECT_HPP
#define OBJECT_HPP


#include <vector>
#include "../BasicDatatypes.hpp"
#include "Point2D.hpp"
#include "Polygon2D.hpp"
#include "Box2D.hpp"
#include "../tools/Time.hpp"

namespace datatypes
{

// Represents a tracked object in our environmental model.
class Object
{
public:
        enum ObjectClassification
        {
                Unclassified = 0,
                UnknownSmall = 1,
                UnknownBig = 2,
                Pedestrian = 3,
                Bike = 4,
                Car = 5,
                Truck = 6,
                Structure_Pylon = 7,
                Structure_Beacon = 8,
                Structure_GuardRail = 9,
                Structure_ConcreteBarrier = 10,
                NumClasses,
                Unknown = 15
        };

public:
        Object();
        ~Object();

        bool operator==(const Object& other) const;

        UINT16 getObjectId() const { return m_objectId; }

        void setObjectId(UINT16 v) { m_objectId = v; }


        UINT16 getFlags() const { return m_flags; }
        void setFlags(UINT16 v) { m_flags = v; }

        UINT32 getObjectAge() const { return m_objectAge; }
        void setObjectAge(UINT32 v) { m_objectAge = v; }

        UINT16 getHiddenStatusAge() const { return m_hiddenStatusAge; }
        bool isHiddenStatus() const { return m_hiddenStatusAge > 0; }
        void setHiddenStatusAge(UINT16 v) { m_hiddenStatusAge = v; }

        const Time& getTimestamp() const { return m_timestamp; }
        void setTimestamp(const Time& v) { m_timestamp = v; }

        ObjectClassification getClassification() const { return m_classification; }
        void setClassification(ObjectClassification v) { m_classification = v; }

        UINT32  getClassificationAge() const { return m_classificationAge; }
        void setClassificationAge(UINT32 v) { m_classificationAge = v; }

        double  getClassificationQuality() const { return m_classificationQuality; }
        void setClassificationQuality(double v);


        const Point2D&  getCenterPoint() const { return m_centerPoint; }
        void setCenterPoint(const Point2D& v) { m_centerPoint = v; }

        const Point2D&  getCenterPointSigma() const { return m_centerPointSigma; }
        void setCenterPointSigma(const Point2D& v);

        double  getCourseAngle() const { return m_courseAngle; }

        void setCourseAngle(double newCourseAngle);

        double getCourseAngleSigma() const { return m_courseAngleSigma; }
        void setCourseAngleSigma(double v);

        const Point2D&  getRelativeVelocity() const { return m_relativeVelocity; }
        void setRelativeVelocity(const Point2D&  v) { m_relativeVelocity = v; }

        const Point2D&  getRelativeVelocitySigma() const { return m_relativeVelocitySigma; }
        void setRelativeVelocitySigma(const Point2D& v) { m_relativeVelocitySigma = v; }

        const Point2D&  getAbsoluteVelocity() const { return m_absoluteVelocity; }
        void setAbsoluteVelocity(const Point2D&  v);

        const Point2D&  getAbsoluteVelocitySigma() const { return m_absoluteVelocitySigma; }
        void setAbsoluteVelocitySigma(const Point2D& v);


        const Point2D& getObjectBox() const { return m_objectBox; }

        void setObjectBox(const Point2D& v);

        Box2D getBox() const;

        const Point2D& getObjectBoxSigma() const { return m_objectBoxSigma; }
        void setObjectBoxSigma(const Point2D& v);

        void getObjectBoxVarCovar(double &var_x, double &var_y, double &covar_xy) const;

        const Point2D& getBoundingBox() const { return m_boundingBox; }
        void setBoundingBox(const Point2D& v);

        const Point2D& getBoundingBoxCenter() const { return m_boundingBoxCenter; }
        void setBoundingBoxCenter(const Point2D& v);

        const Point2D& getClosestPoint() const { return m_closestPoint; }
        void setClosestPoint(const Point2D& v) { m_closestPoint = v; }

        const Polygon2D& getContourPoints() const { return m_contourPoints; }
        void setContourPoints(const Polygon2D& v);
        void addContourPoint(const Point2D cp);

        UINT64 getVehicleWLANid() const { return m_vehicleWLANid; }
        void setVehicleWLANid(UINT64 v) { m_vehicleWLANid = v; }

        double getObjectHeight() const { return m_objectHeight; }
        void setObjectHeight(double v) { m_objectHeight = v; }

        double getObjectHeightSigma() const { return m_objectHeightSigma; }
        void setObjectHeightSigma(double v);

        double getObjectMass() const { return m_objectMass; }
        void setObjectMass(double v);

        bool isValid() const { return m_isValid; }

        void setValid(bool newValue = true) { m_isValid = newValue; }

        double getMaxAbsoluteVelocity() const { return m_maxAbsoluteVelocity; }
        void setMaxAbsoluteVelocity(double v);

        double getNormalizedMeanPointDist() const { return m_normalizedMeanPointDist; }
        void setNormalizedMeanPointDist(double v);

        double getTotalTrackingDuration() const { return m_totalTrackingDuration; }
        void setTotalTrackingDuration(double v);

        double getTotalTrackedPathLength() const { return m_totalTrackedPathLength; }
        void setTotalTrackedPathLength(double v);

        double getMeanAbsoluteVelocity() const;


        // Size of the object in memory
        const UINT32 getUsedMemory() const { return sizeof(Object); };


        std::streamsize getSerializedSize(UINT32 version) const;

        std::string toString() const;
        //\}

        static const char* objectClassificationToString(ObjectClassification v);

        static std::string objectClassificationToStringWithNum(ObjectClassification v);

        static const char* objectClassificationToShortString(ObjectClassification v);

        static Object::ObjectClassification stringToObjectClassification(const std::string& s);

        void incrementObjectAge();

private:
        UINT16  m_objectId;
        UINT16  m_flags; 
        // Data from the tracking/classification:
        UINT32  m_objectAge;            
        UINT16  m_hiddenStatusAge;      
        Time    m_timestamp;            

        ObjectClassification m_classification; 
        UINT32  m_classificationAge;           
        double   m_classificationQuality;       

        Point2D m_centerPoint;      
        Point2D m_centerPointSigma;
        double   m_courseAngle;      
        double   m_courseAngleSigma; // in [rad]
        Point2D m_relativeVelocity; 
        Point2D m_relativeVelocitySigma;
        Point2D m_absoluteVelocity; 
        Point2D m_absoluteVelocitySigma;

        Point2D m_objectBox;         
        Point2D m_objectBoxSigma;
        Point2D m_boundingBoxCenter; 
        Point2D m_boundingBox;       

        // These components are also proposed
        Point2D m_closestPoint; 

        // This can also be calculated
        Polygon2D m_contourPoints; 

        UINT64 m_vehicleWLANid;    
        double m_objectHeight;      
        double m_objectHeightSigma; 

        double m_objectMass; 


        double m_maxAbsoluteVelocity;

        double m_normalizedMeanPointDist;

        double m_totalTrackingDuration;

        double m_totalTrackedPathLength;

//      const Segment *m_segment;

        // True, if this object is valid.
        bool m_isValid;
};


// ////////////////////////////////////////////////////////////

//
// List of Objects
//
//
class ObjectList : public std::vector<Object>,
                                        public BasicData
{
public:

        typedef std::vector<Object> base_class;

        ObjectList();

        bool operator==(const ObjectList& other) const;

        // Size of the object in memory
        const UINT32 getUsedMemory() const { return sizeof(*this) + size()*sizeof(Object); };

        // Get the timestamp of the object list. Typically it should be the midTimestamp of the corresponding scan.
        const Time& getTimestamp() const { return m_timestamp; }

        // Set the timestamp of the object list. Typically it should be the midTimestamp of the corresponding scan.
        void setTimestamp(const Time& timestamp);

        void incrementObjectAge();

protected:

        // The timestamp of the ObjectList
        Time m_timestamp;
};

}       // namespace datatypes


#endif // OBJECT_HPP