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