Scan.hpp

Go to the documentation of this file.

//
// Scan.hpp
//
// A simple data structure for scan data.
//

#ifndef SCAN_HPP
#define SCAN_HPP

#include <vector>
#include "ScannerInfo.hpp"
#include "ScanPoint.hpp"
#include "../BasicDatatypes.hpp"

namespace datatypes
{
        
//
// Sehr einfacher Container fuer Scandaten.
//
// Ein Objekt dieser Klasse repraesentiert einen Einzelscan eines
// Laserscanners.
//
class Scan : public BasicData
{
public:
        // Type of the scan point list
        typedef std::vector<ScanPoint> PointList;

        // Type of the scan point list
        typedef std::vector<ScannerInfo> ScannerInfoVector;

        // Type of a reference to an element
        typedef ScanPoint& reference;

        typedef const ScanPoint& const_reference;

        // Type of container size
        typedef PointList::size_type size_type;

        // Type of constant iterator
        typedef PointList::const_iterator const_iterator;

        // Type of iterator
        typedef PointList::iterator iterator;

        // Property flags
        enum ScanFlags
        {
                FlagVehicleCoordinates  = 0x00000800    
        };

        // Estimate the memory usage of this object
        virtual const UINT32 getUsedMemory() const;

protected:
        // Properties of this scan.
        // See ScanFlags for a list of available property flags.
        UINT32 m_flags;

        // Consecutive scan number
        UINT16 m_scanNumber;

        // The list of scan points
        //
        // At Scan creation, enough points are reserved in this vector in
        // order to avoid memory re-allocations during runtime. This is
        // now all handled by std::vector<> directly.
        PointList m_points;

        ScannerInfoVector m_scannerInfos;

        // WATCH OUT: If you add more member variables here, you MUST also
        // adapt the method Scan::copy(), addScan() and add the variables there.

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

public:

        // Constructor
        Scan (size_type maxPoints = 5280); // 5280 = Maxpoints with 1/8deg resolution, for 50- -60deg

        Scan (const Scan&);

        // Copy the given right hand side object into this object. An
        // alias for copy().
        Scan& operator= (const Scan&);

        // Copy the given right hand side object into this object.
        Scan& copy(const Scan&);

        ~Scan();

        void clear ();


        // Equality predicate
//      bool operator==(const Scan& other) const;

        // Returns the number of points in this scan. The same number can be retrieved by size().
        UINT16 getNumPoints() const { return size(); }

        // Returns the number of points in the scan. An alias for getNumPoints().
        size_type size() const { return m_points.size(); }

        // Returns true if this scan contains no points.
        bool empty() const { return m_points.empty(); }

        void resize(size_type new_size, const ScanPoint& default_point = ScanPoint());

        // Returns the size of the memory (in number of points) allocated.
        //
        // Note: This is probably not the number of currently available
        // scan points! See size() or getNumPoints() for this.
        //
        size_type capacity() const { return m_points.capacity(); }

        void reserve(size_type new_capacity);



        // Returns the consecutive number of this scan.
        // Intended to detect missing scans.
        UINT16 getScanNumber() const { return (UINT16)m_scanNumber; }

        // Set the consecutive number of this scan.
        void setScanNumber        (UINT16 val) { m_scanNumber    = val; }


        // Returns the total size of the current scan object, in [bytes]. This value is the actual memory
        // usage, including all sub-structures. Intended usage: Find out how much memory will be used when
        // storing this object in a buffer.
        //
        // Note that the returned value is an estimation that may not match up to the last byte...
        UINT32 getTotalObjectSize();

        // Returns all property flags of this scan in one number
        // isGroundLabeled(), isDirtLabeled(), isRainLabeled() etc.
        UINT32 getFlags() const { return m_flags; }

        // Returns true if the ground detection ran on this scan.
//      bool isGroundLabeled()   const { return ((m_flags & FlagGroundLabeled) != 0); }

        // Returns true if the dirt detection ran on this scan.
//      bool isDirtLabeled()     const { return ((m_flags & FlagDirtLabeled) != 0); }

        // Returns true if the background detection ran on this scan.
//      bool isBackgroundLabeled() const { return ((m_flags & FlagBackgroundLabeled) != 0); }

        // Returns true if the scan points are given in vehicle coordinates, or false if the scan points are given in the Laserscanner coordinate system.
//      bool isVehicleCoordinates() const { return ((m_flags & FlagVehicleCoordinates) != 0); }

        // Set all flags in one number
        void setFlags             (UINT32 val) { m_flags                 = val; }

        // Clears the given processing flag in the scan.
        //
        // Note: This only changes the flags of the Scan object, not the
        // flags in the individual scan points!  The flags in the
        // individual points are unchanged and must be modified in a
        // manual iteration loop.
        void clearLabelFlag(Scan::ScanFlags scanFlag);

//      void setGroundLabeled(bool isGroundLabeled = true); ///< Set the Scan has ground labeled.
//      void setDirtLabeled(bool isDirtLabeled = true); ///< Set the Scan has dirt labeled.
//      void setRainLabeled(bool isRainLabeled = true); ///< Set the Scan has rain labeled.
//      void setCoverageLabeled(bool isCoverageLabeled = true); ///< Set the Scan has coverage labeled.
//      void setBackgroundLabeled(bool isBackgroundLabeled = true); ///< Set the Scan has background labeled.
//      void setReflectorLabeled(bool isReflectorLabeled = true); ///< Set the Scan has reflector labeled.

        void setVehicleCoordinates(bool inVehicleCoordinates);  


        // Returns the list of scan points (read only)
        const PointList& getPointList() const { return m_points; }
        // Returns the list of scan points (read/write)
        PointList& getPointList() { return m_points; }

        // Returns the iterator of the first scan point (read only)
        PointList::const_iterator getPointListBegin() const { return m_points.begin(); }
        // Returns the iterator of the first scan point (read/write)
        PointList::iterator getPointListBegin() { return m_points.begin(); }

        // Returns the iterator of one behind the last scan point (read only)
        PointList::const_iterator getPointListEnd() const { return m_points.end(); }

        // Returns the iterator of one behind the last scan point (read/write)
        PointList::iterator getPointListEnd() { return m_points.end(); }

        // Returns the iterator of the first scan point (read only)
        const_iterator begin() const { return m_points.begin(); }

        // Returns the iterator of the first scan point (read/write)
        iterator begin() { return m_points.begin(); }

        // Returns the iterator of one behind the last scan point (read only)
        const_iterator end() const { return m_points.end(); }

        // Returns the iterator of one behind the last scan point (read/write)
        iterator end() { return m_points.end(); }

        // Returns the n-th scan point (read/write). No range checking to avoid runtime costs.
        reference operator[](size_type n) { return m_points[n]; }

        // Returns the n-th scan point (read only). No range checking to avoid runtime costs.
        const_reference operator[](size_type n) const { return m_points[n]; }

        // Returns the n-th scan point (read/write) with range checking.
        reference at(size_type n) { return m_points.at(n); }

        const_reference at(size_type n) const { return m_points.at(n); }

        // Returns the n-th scan point (read only). No range checking to avoid runtime costs.
        const ScanPoint& getPoint (UINT16 n) const { return m_points[n]; }
        // Returns the n-th scan point (read/write). No range checking to avoid runtime costs.
        ScanPoint& getPoint (UINT16 n) { return m_points[n]; }

        // Adds a new point to the list of scan points
        ScanPoint& addNewPoint();


        // Returns the ScannerInfo collection.
        //
        // If this Scan contains points on 8 Layers (because of the
        // interlaced fusion of an 8-Layer scanner), the returned list
        // contains two ScannerInfo objects with the same deviceID. In all
        // other cases there will be only one ScannerInfo object for each
        // deviceID.
        //
        const ScannerInfoVector& getScannerInfos() const { return m_scannerInfos; }
        ScannerInfoVector& getScannerInfos();
        const ScannerInfo* getScannerInfoByDeviceId(UINT8 id) const;

        // Sets the ScannerInfo collection.
        void setScannerInfos(const ScannerInfoVector& v);


        //
        // Sorts the scan points of this scan by angle in descending
        // order. (Angles from high to low.)
        //
        // The first scan point will be the one with the largest
        // (leftmost) angle. The last scan point will be the one with
        // smallest (rightmost) angle, most probably a negative value.
        //
        // (Is used for the scan fusion.)
        //
        void sort();


        //
        // Coordinate system transformations
        //
        
        void addCartesianOffset(double offsetX, double offsetY, double offsetZ);
        void addPolarOffset(double distOffset, double hAngleOffset, double vAngleOffset);



        bool transformToVehicleCoordinates();


        bool transformToVehicleCoordinatesUnsorted();


private:
        
        bool m_beVerbose;
};

}       // namespace datatypes


#endif // SCAN_HPP