mi32/lidarlaspoint.h

Go to the documentation of this file.

#ifndef  INC_LIDARLASPOINT_H
#define  INC_LIDARLASPOINT_H

#ifndef  INC_MI32_LIDARPOINT32_H
#include <mi32/lidarpoint32.h>
#endif

#ifndef  INC_MI32_LIDARENUMS_H
#include <mi32/lidarenums.h>
#endif

#ifndef  INC_MI32_DELEGATE_H
#include <mi32/delegate.h>
#endif


#ifdef RVCSYSDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
struct COLOR;
class FILE_RAW;
#endif


namespace LIDAR {
namespace LAS {

//=====================================================================================================================

class CLASSLIBEXPORT POINTARRAY : public POINTARRAY32 {
   public:

      POINTARRAY ();

      ~POINTARRAY ();

      UINT8 GetFormat () const
         { return (m_Format); }

      UINT16 GetOffsetColor () const
         { return (m_OffsetColor); }

      UINT16 GetOffsetTime () const
         { return (m_OffsetTime); }

      UINT16 GetOffsetWave () const
         { return (m_OffsetWave); }

      void SetFormat (
         UINT8 format,        
         UINT16 RecordSize    
         );

      #ifdef BYTEORDER_HiLo
      void SwapBytes ();
      #endif

   private:
      #ifndef  GENERATING_DOXYGEN_OUTPUT
      UINT16 m_OffsetColor;
      UINT16 m_OffsetTime;
      UINT16 m_OffsetWave;
      UINT8 m_Format;
      #endif
   };

//=====================================================================================================================

class CLASSLIBEXPORT POINTRECORD : public POINTRECORD32 {
   public:

      POINTRECORD ()
         { }

      POINTRECORD (const POINTRECORD& rhs)
         : POINTRECORD32(rhs) { }

      POINTRECORD (POINTARRAY& Array)
         : POINTRECORD32(Array) { }

      POINTRECORD (POINTARRAY& Array, UINT32 ArrayIdx)
         : POINTRECORD32(Array,ArrayIdx) { }

      ~POINTRECORD ()
         { }

      void CopyFrom (
         const POINTRECORD& src
         );

      UINT8 GetClassFull (
         ) const { return (GetData()[OFFSET_Classification]); }

      UINT8 GetClassification (
         ) const { return (GetData()[OFFSET_Classification] & 0x1F); }

      void GetColor (
         COLOR& color               
         ) const;

      UINT16 GetIntensity (
         ) const { return (*reinterpret_cast<const UINT16*>(GetData()+OFFSET_Intensity)); }

      UINT8 GetReturnCount (
         ) const { return ((GetData()[OFFSET_ReturnValues] & 0x38) >> 3); }

      UINT8 GetReturnNumber (
         ) const { return (GetData()[OFFSET_ReturnValues] & 0x07); }

      POINTRETURNTYPE GetReturnType () const;

      UINT8 GetReturnValues (
         ) const { return (GetData()[OFFSET_ReturnValues]); }

      INT8 GetScanAngle (
         ) const { return (static_cast<INT8>(GetData()[OFFSET_ScanAngleRank])); }

      INT8 GetScanDirection (
         ) const { return (((GetData()[OFFSET_ReturnValues] & 0x40) != 0) ? 1 : -1); }

      UINT16 GetSourceID (
         ) const { return (*reinterpret_cast<const UINT16*>(GetData()+OFFSET_PointSourceID)); }

      double GetTime (
         ) const;

      UINT8 GetUserData (
         ) const { return (GetData()[OFFSET_UserData]); }

      UINT8 GetWaveDescIdx () const;

      UINT64 GetWaveOffset () const;

      float GetWavePointLocation () const;

      UINT32 GetWaveSize () const;

      float GetWaveXt () const;

      float GetWaveYt () const;

      float GetWaveZt () const;

      bool HasColor () const
         { return (GetOffsetColor() != 0); }

      bool HasTime () const
         { return (GetOffsetTime() != 0); }

      bool HasWave () const
         { return (GetOffsetWave() != 0); }

      bool IsDeleted (
         ) const { return ((GetData()[OFFSET_Classification] & 0x80) != 0); }

      bool IsEndOfSweep (
         ) const { return ((GetData()[OFFSET_ReturnValues] & 0x80) != 0); }
         
      bool IsFirstReturn (
         ) const { return (GetReturnNumber() == 1); }
         
      bool IsKeyPoint (
         ) const { return ((GetData()[OFFSET_Classification] & 0x40) != 0); }
         
      bool IsLastReturn (
         ) const { return (GetReturnNumber() == GetReturnCount()); }
         
      bool IsSynthetic (
         ) const { return ((GetData()[OFFSET_Classification] & 0x20) != 0); }
         
      void SetClassFull (
         UINT8 classfull                  
         ) { GetData()[OFFSET_Classification] = classfull; }

      void SetClassification (
         UINT8 classification             
         ) { GetData()[OFFSET_Classification] = (GetData()[OFFSET_Classification] & 0xE0) | (classification & 0x1F); }

      void SetClassification (
         UINT8 classification,            
         bool IsSynthetic,
         bool IsKeyPoint,
         bool IsDeleted
         ) { GetData()[OFFSET_Classification] = (classification & 0x1F) | (IsSynthetic ? 0x20 : 0) | (IsKeyPoint ? 0x40 : 0) | (IsDeleted ? 0x80 : 0); }

      void SetColor (
         const COLOR& color
         );

      void SetDeleted (
         bool deleted                     
         ) { if (deleted) GetData()[OFFSET_Classification] |= 0x80; else GetData()[OFFSET_Classification] &= 0x7F; }

      void SetIntensity (
         UINT16 intensity
         ) { *reinterpret_cast<UINT16*>(GetData() + OFFSET_Intensity) = intensity; }

      void SetKeyPoint (
         bool keypoint                    
         ) { if (keypoint) GetData()[OFFSET_Classification] |= 0x40; else GetData()[OFFSET_Classification] &= 0xBF; }

      void SetReturnValues (
         UINT8 ReturnNumber,
         UINT8 ReturnCount,
         bool IsScanPositive,
         bool IsEndOfSweep
         ) { GetData()[OFFSET_ReturnValues] = (ReturnNumber & 7) | ((ReturnCount & 7) << 3) | (IsScanPositive ? 0x40 : 0) | (IsEndOfSweep ? 0x80 : 0); }

      void SetScanAngle (
         INT8 ScanAngle
         ) { GetData()[OFFSET_ScanAngleRank] = ScanAngle; }

      void SetSourceID (
         UINT16 SourceID
         ) { *reinterpret_cast<UINT16*>(GetData() + OFFSET_PointSourceID) = SourceID; }

      void SetSynthetic (
         bool synthetic                   
         ) { if (synthetic) GetData()[OFFSET_Classification] |= 0x20; else GetData()[OFFSET_Classification] &= 0xDF; }

      void SetTime (
         double time
         );

      void SetUserData (
         UINT8 userdata
         ) { GetData()[OFFSET_UserData] = userdata; }

      #ifdef BYTEORDER_HiLo
      void SwapBytes (UINT8 *data) const;
      #endif

      ERRVALUE Write (FILE_RAW& file, INT64 offset) const;

   private:
      #ifndef  GENERATING_DOXYGEN_OUTPUT

      static const int OFFSET_X =               0;    // INT32
      static const int OFFSET_Y =               4;    // INT32
      static const int OFFSET_Z =               8;    // INT32
      static const int OFFSET_Intensity =       12;   // UINT16
      static const int OFFSET_ReturnValues =    14;   // UINT8 bit field
      static const int OFFSET_Classification =  15;   // UINT8 bit field
      static const int OFFSET_ScanAngleRank =   16;   // UINT8
      static const int OFFSET_UserData =        17;   // UINT8
      static const int OFFSET_PointSourceID =   18;   // UINT16

      UINT8 GetFormat () const
         { return (static_cast<const POINTARRAY&>(GetArray()).GetFormat()); }
      UINT16 GetOffsetColor () const
         { return (static_cast<const POINTARRAY&>(GetArray()).GetOffsetColor()); }
      UINT16 GetOffsetTime () const
         { return (static_cast<const POINTARRAY&>(GetArray()).GetOffsetTime()); }
      UINT16 GetOffsetWave () const
         { return (static_cast<const POINTARRAY&>(GetArray()).GetOffsetWave()); }
      const UINT8* GetPtrWave () const
         { return (GetData() + GetOffsetWave()); }

      #endif
   };

//=====================================================================================================================

typedef fastdelegate::FastDelegate<bool(const LAS::POINTRECORD&)> DELEGATE_BOOL_POINTRECORD;

//=====================================================================================================================

}  // End namespace LAS
}  // End namespace LIDAR

#undef   CLASSLIBEXPORT

#endif   // INC_LIDAR_POINTRECORD_H

---