IImportLAS.hpp

#ifndef DM_IO_IMPORT_LAS_HPP_INCLUDED
#define DM_IO_IMPORT_LAS_HPP_INCLUDED

#ifdef _MSC_VER
  #pragma once
#endif

//DM
#include "DM/config.hpp"
#include "DM/AutoLink.hpp" //enable autolink

#include "DM/ColumnTypes.hpp"
#include "DM/IO/IImport.hpp"


DM_NAMESPACE_BEGIN

class DM_API IImportLAS : public virtual IImport 
{
public:
  static IImportLAS* New( const char *file, FilterHandle filter = FilterHandle(), 
                          ControlObjectHandle control = ControlObjectHandle(), 
                          bool collectHdrContents = false, unsigned maxBulkPoints = 1000,
                          AddInfoLayoutHandle defaultLayout = AddInfoLayoutHandle() );

  struct ExtraBytes {
    union AnyType {
      unsigned long long ul;
        signed long long sl;
      double             d;
    };
    ColumnType::Type  type;         // The quantity's data type. Note that unsigned long long is supported by LAS, but (currently) not by NG-attributes, which is thus mapped to signed long long.
    int           nElements;    // [1 3]; 1->scalar
    char name[32];              // max. length: 32
    char description[32];       // max. length: 32
    // Left variable specifies if right variable is meaningful.
    //                            consider nElements of right variable!
    //                            LAS 1.4 does not specify if right variables refer to raw values or transformed values. We use: raw values.
    bool hasNoData;  AnyType noData[3]; // These raw values should be considered as invalid.
    bool hasMin;     AnyType minima[3]; // Minimum valid, raw value.
    bool hasMax;     AnyType maxima[3]; // Maximum valid, raw value.

    // Transform raw values to external values.
    // If scale and/or offset are in use, then the external values may need to be represented as real numbers, although the raw values are integrals (maybe even unsigned ones).
    // LAS 1.4 does not specify how the transformation is defined.
    // We use: externalVal = rawVal * scale + offset, in accordance with the transformation of raw point coordinates
    bool hasOffset;  double offset[3];
    bool hasScale;   double scale[3];
  };
  

protected:
  virtual ~IImportLAS() {}

public:

  /// get number of extra byte records (available after header was read)
  virtual unsigned getExtraByteRecordCount() const = 0;
  /// get corresponding extra byte record (available after header was read)
  virtual void     getExtraByteRecord(unsigned idx, ExtraBytes &record) const = 0;
  
  // Specify a predefined NG-attribute by its enum. The LASattribute's type will be converted to that of the predefined attribute
  virtual void importExtraBytes( int lasAttrIndex, ColumnSemantic::Type ngCol ) = 0;
  // Specify the NG-attribute by name. By default, use the name and type of the LASattribute
  virtual void importExtraBytes( int lasAttrIndex, const char* ngName = 0, ColumnType::Type ngType = ColumnType::count ) = 0;
  // Map an arbitrary element of a multi-element LAS attribute. Indexing starts at zero.
  virtual void importExtraBytes( int lasAttrIndex, int lasElemIndex, ColumnSemantic::Type ngCol ) = 0;
  virtual void importExtraBytes( int lasAttrIndex, int lasElemIndex, const char* ngName = 0, ColumnType::Type ngType = ColumnType::count ) = 0;
  //}@
};

typedef Handle<IImportLAS> ImportLASHandle;


DM_NAMESPACE_END

#endif //DM_IO_IMPORT_LAS_HPP_INCLUDED