E57SimpleData.h

Go to the documentation of this file.

/*
 * E57Simple - public header of E57 Simple API for reading/writing .e57 files.
 *
 * Copyright (c) 2010 Stan Coleby (scoleby@intelisum.com)
 * Copyright (c) 2020 PTC Inc.
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#pragma once
 
 
#include "E57Format.h"
 
namespace e57
{
 
   constexpr double E57_NOT_SCALED_USE_FLOAT = 0.;
   constexpr double E57_NOT_SCALED_USE_INTEGER = -1.;
 
   class ReaderImpl;
   class WriterImpl;
 
   struct E57_DLL Translation
   {
      double x{ 0. }; 
      double y{ 0. }; 
      double z{ 0. }; 
 
      bool operator==( const Translation &rhs ) const
      {
         return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
      }
      bool operator!=( const Translation &rhs ) const
      {
         return !operator==( rhs );
      }
 
      static Translation identity()
      {
         return {};
      }
   };
 
   struct E57_DLL Quaternion
   {
      double w{ 0. }; 
      double x{ 0. }; 
      double y{ 0. }; 
      double z{ 0. }; 
 
      bool operator==( const Quaternion &rhs ) const
      {
         return ( w == rhs.w ) && ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
      }
      bool operator!=( const Quaternion &rhs ) const
      {
         return !operator==( rhs );
      }
 
      static Quaternion identity()
      {
         Quaternion identity;
         identity.w = 1.;
         return identity;
      }
   };
 
   struct E57_DLL RigidBodyTransform
   {
      Quaternion rotation;     
      Translation translation; 
 
      bool operator==( const RigidBodyTransform &rhs ) const
      {
         return ( rotation == rhs.rotation ) && ( translation == rhs.translation );
      }
      bool operator!=( const RigidBodyTransform &rhs ) const
      {
         return !operator==( rhs );
      }
 
      static RigidBodyTransform identity()
      {
         return { Quaternion::identity(), Translation::identity() };
      }
   };
 
   struct E57_DLL CartesianBounds
   {
      double xMinimum{ -E57_DOUBLE_MAX }; 
      double xMaximum{ E57_DOUBLE_MAX };  
      double yMinimum{ -E57_DOUBLE_MAX }; 
      double yMaximum{ E57_DOUBLE_MAX };  
      double zMinimum{ -E57_DOUBLE_MAX }; 
      double zMaximum{ E57_DOUBLE_MAX };  
 
      bool operator==( const CartesianBounds &rhs ) const
      {
         return ( xMinimum == rhs.xMinimum ) && ( xMaximum == rhs.xMaximum ) && ( yMinimum == rhs.yMinimum ) &&
                ( yMaximum == rhs.yMaximum ) && ( zMinimum == rhs.zMinimum ) && ( zMaximum == rhs.zMaximum );
      }
      bool operator!=( const CartesianBounds &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL SphericalBounds
   {
      SphericalBounds();       // constructor in the cpp to avoid exposing M_PI
      double rangeMinimum;     
      double rangeMaximum;     
      double elevationMinimum; 
      double elevationMaximum; 
      double azimuthStart; 
      double azimuthEnd;   
 
      bool operator==( const SphericalBounds &rhs ) const
      {
         return ( rangeMinimum == rhs.rangeMinimum ) && ( rangeMaximum == rhs.rangeMaximum ) &&
                ( elevationMinimum == rhs.elevationMinimum ) && ( elevationMaximum == rhs.elevationMaximum ) &&
                ( azimuthStart == rhs.azimuthStart ) && ( azimuthEnd == rhs.azimuthEnd );
      }
      bool operator!=( const SphericalBounds &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL IndexBounds
   {
      int64_t rowMinimum{ 0 }; 
      int64_t rowMaximum{ 0 }; 
      int64_t columnMinimum{
         0
      }; 
      int64_t columnMaximum{
         0
      }; 
      int64_t returnMinimum{
         0
      }; 
      int64_t returnMaximum{
         0
      }; 
 
      bool operator==( const IndexBounds &rhs ) const
      {
         return ( rowMinimum == rhs.rowMinimum ) && ( rowMaximum == rhs.rowMaximum ) &&
                ( columnMinimum == rhs.columnMinimum ) && ( columnMaximum == rhs.columnMaximum ) &&
                ( returnMinimum == rhs.returnMinimum ) && ( returnMaximum == rhs.returnMaximum );
      }
      bool operator!=( const IndexBounds &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL IntensityLimits
   {
      double intensityMinimum{ 0. }; 
      double intensityMaximum{ 0. }; 
 
      bool operator==( const IntensityLimits &rhs ) const
      {
         return ( intensityMinimum == rhs.intensityMinimum ) && ( intensityMaximum == rhs.intensityMaximum );
      }
      bool operator!=( const IntensityLimits &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL ColorLimits
   {
      double colorRedMinimum{ 0. };   
      double colorRedMaximum{ 0. };   
      double colorGreenMinimum{ 0. }; 
      double colorGreenMaximum{ 0. }; 
      double colorBlueMinimum{ 0. };  
      double colorBlueMaximum{ 0. };  
 
      bool operator==( const ColorLimits &rhs ) const
      {
         return ( colorRedMinimum == rhs.colorRedMinimum ) && ( colorRedMaximum == rhs.colorRedMaximum ) &&
                ( colorGreenMinimum == rhs.colorGreenMinimum ) && ( colorGreenMaximum == rhs.colorGreenMaximum ) &&
                ( colorBlueMinimum == rhs.colorBlueMinimum ) && ( colorBlueMaximum == rhs.colorBlueMaximum );
      }
      bool operator!=( const ColorLimits &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL DateTime
   {
      double dateTimeValue{
         0.
      }; 
      int32_t isAtomicClockReferenced{
         0
      }; 
 
      bool operator==( const DateTime &rhs ) const
      {
         return ( dateTimeValue == rhs.dateTimeValue ) && ( isAtomicClockReferenced == rhs.isAtomicClockReferenced );
      }
      bool operator!=( const DateTime &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL E57Root
   {
      ustring formatName;         
      ustring guid;               
      uint32_t versionMajor{ 1 }; 
      uint32_t versionMinor{ 0 }; 
      ustring e57LibraryVersion;  
      DateTime creationDateTime;  
      int64_t data3DSize{ 0 };    
      int64_t images2DSize{ 0 };  
      ustring coordinateMetadata; 
   };
 
   struct E57_DLL LineGroupRecord
   {
      int64_t idElementValue{
         0
      }; 
      int64_t startPointIndex{
         0
      }; 
      int64_t pointCount{
         0
      }; 
      CartesianBounds cartesianBounds; 
      SphericalBounds sphericalBounds; 
   };
 
   struct E57_DLL GroupingByLine
   {
      ustring idElementName;   
      int64_t groupsSize{ 0 }; 
      int64_t pointCountSize{ 0 }; 
   };
 
   struct E57_DLL PointGroupingSchemes
   {
      GroupingByLine groupingByLine; 
   };
 
   struct E57_DLL PointStandardizedFieldsAvailable
   {
      bool cartesianXField{ false }; 
      bool cartesianYField{ false }; 
      bool cartesianZField{ false }; 
      bool cartesianInvalidStateField{
         false
      }; 
 
      bool sphericalRangeField{ false };     
      bool sphericalAzimuthField{ false };   
      bool sphericalElevationField{ false }; 
      bool sphericalInvalidStateField{
         false
      }; 
 
      double pointRangeMinimum{
         E57_FLOAT_MIN
      }; 
      double pointRangeMaximum{
         E57_FLOAT_MAX
      }; 
      double pointRangeScaledInteger{
         E57_NOT_SCALED_USE_FLOAT
      }; 
 
      double angleMinimum{
         E57_FLOAT_MIN
      }; 
      double angleMaximum{
         E57_FLOAT_MAX
      }; 
      double angleScaledInteger{
         E57_NOT_SCALED_USE_FLOAT
      }; 
 
      bool rowIndexField{ false };                
      uint32_t rowIndexMaximum{ E57_UINT32_MAX }; 
      bool columnIndexField{ false };             
      uint32_t columnIndexMaximum{
         E57_UINT32_MAX
      }; 
 
      bool returnIndexField{ false };         
      bool returnCountField{ false };         
      uint8_t returnMaximum{ E57_UINT8_MAX }; 
 
      bool timeStampField{ false };          
      bool isTimeStampInvalidField{ false }; 
      double timeMaximum{
         E57_DOUBLE_MAX
      }; 
      double timeMinimum{ E57_DOUBLE_MIN }; 
      double timeScaledInteger{
         E57_NOT_SCALED_USE_FLOAT
      }; 
 
      bool intensityField{ false };          
      bool isIntensityInvalidField{ false }; 
      double intensityScaledInteger{
         E57_NOT_SCALED_USE_INTEGER
      }; 
 
      bool colorRedField{ false };       
      bool colorGreenField{ false };     
      bool colorBlueField{ false };      
      bool isColorInvalidField{ false }; 
 
      bool normalX{ false }; 
      bool normalY{ false }; 
      bool normalZ{ false }; 
   };
 
   struct E57_DLL Data3D
   {
      ustring name; 
      ustring guid; 
      std::vector<ustring> originalGuids; 
      ustring description;                
 
      ustring sensorVendor; 
      ustring sensorModel;  
      ustring sensorSerialNumber;    
      ustring sensorHardwareVersion; 
      ustring sensorSoftwareVersion; 
      ustring sensorFirmwareVersion; 
 
      float temperature{ E57_FLOAT_MAX };      
      float relativeHumidity{ E57_FLOAT_MAX }; 
      float atmosphericPressure{ E57_FLOAT_MAX }; 
 
      DateTime acquisitionStart; 
      DateTime acquisitionEnd;   
 
      RigidBodyTransform pose; 
      IndexBounds indexBounds; 
      CartesianBounds cartesianBounds; 
      SphericalBounds sphericalBounds; 
      IntensityLimits
         intensityLimits; 
      ColorLimits colorLimits; 
 
      PointGroupingSchemes pointGroupingSchemes; 
      PointStandardizedFieldsAvailable
         pointFields; 
 
      int64_t pointsSize{ 0 }; 
   };
 
   template <typename COORDTYPE = float> struct Data3DPointsData_t
   {
      COORDTYPE *cartesianX{
         nullptr
      }; 
      COORDTYPE *cartesianY{
         nullptr
      }; 
      COORDTYPE *cartesianZ{
         nullptr
      }; 
      int8_t *cartesianInvalidState{ nullptr }; 
 
      float *intensity{ nullptr }; 
      int8_t *isIntensityInvalid{ nullptr }; 
 
      uint8_t *colorRed{ nullptr };      
      uint8_t *colorGreen{ nullptr };    
      uint8_t *colorBlue{ nullptr };     
      int8_t *isColorInvalid{ nullptr }; 
 
      COORDTYPE *sphericalRange{
         nullptr
      }; 
      COORDTYPE *sphericalAzimuth{
         nullptr
      }; 
      COORDTYPE *sphericalElevation{
         nullptr
      }; 
      int8_t *sphericalInvalidState{ nullptr }; 
 
      int32_t *rowIndex{ nullptr }; 
      int32_t *columnIndex{
         nullptr
      }; 
      int8_t *returnIndex{
         nullptr
      }; 
      int8_t *returnCount{
         nullptr
      }; 
 
      double *timeStamp{
         nullptr
      }; 
      int8_t *isTimeStampInvalid{ nullptr }; 
 
      // E57_EXT_surface_normals
      float *normalX{ nullptr }; 
      float *normalY{ nullptr }; 
      float *normalZ{ nullptr }; 
   };
 
   typedef Data3DPointsData_t<float> Data3DPointsData;
   typedef Data3DPointsData_t<double> Data3DPointsData_d;
 
   struct E57_DLL VisualReferenceRepresentation
   {
      int64_t jpegImageSize{ 0 }; 
      int64_t pngImageSize{ 0 };  
      int64_t imageMaskSize{ 0 }; 
      int32_t imageWidth{ 0 };    
      int32_t imageHeight{ 0 };   
 
      bool operator==( const VisualReferenceRepresentation &rhs ) const
      {
         return ( jpegImageSize == rhs.jpegImageSize ) && ( pngImageSize == rhs.pngImageSize ) &&
                ( imageMaskSize == rhs.imageMaskSize ) && ( imageWidth == rhs.imageWidth ) &&
                ( imageHeight == rhs.imageHeight );
      }
      bool operator!=( const VisualReferenceRepresentation &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL PinholeRepresentation
   {
      int64_t jpegImageSize{ 0 }; 
      int64_t pngImageSize{ 0 };  
      int64_t imageMaskSize{ 0 }; 
      int32_t imageWidth{ 0 };    
      int32_t imageHeight{ 0 };   
      double focalLength{ 0. };   
      double pixelWidth{ 0. };    
      double pixelHeight{ 0. };   
      double principalPointX{
         0.
      }; 
      double principalPointY{ 0. }; 
 
      bool operator==( const PinholeRepresentation &rhs ) const
      {
         return ( jpegImageSize == rhs.jpegImageSize ) && ( pngImageSize == rhs.pngImageSize ) &&
                ( imageMaskSize == rhs.imageMaskSize ) && ( imageWidth == rhs.imageWidth ) &&
                ( imageHeight == rhs.imageHeight ) && ( focalLength == rhs.focalLength ) &&
                ( pixelWidth == rhs.pixelWidth ) && ( pixelHeight == rhs.pixelHeight ) &&
                ( principalPointX == rhs.principalPointX ) && ( principalPointY == rhs.principalPointY );
      }
      bool operator!=( const PinholeRepresentation &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL SphericalRepresentation
   {
      int64_t jpegImageSize{ 0 }; 
      int64_t pngImageSize{ 0 };  
      int64_t imageMaskSize{ 0 }; 
      int32_t imageWidth{ 0 };    
      int32_t imageHeight{ 0 };   
      double pixelWidth{ 0. };    
      double pixelHeight{ 0. };   
 
      bool operator==( const SphericalRepresentation &rhs ) const
      {
         return ( jpegImageSize == rhs.jpegImageSize ) && ( pngImageSize == rhs.pngImageSize ) &&
                ( imageMaskSize == rhs.imageMaskSize ) && ( imageWidth == rhs.imageWidth ) &&
                ( imageHeight == rhs.imageHeight ) && ( pixelWidth == rhs.pixelWidth ) &&
                ( pixelHeight == rhs.pixelHeight );
      }
      bool operator!=( const SphericalRepresentation &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL CylindricalRepresentation
   {
      int64_t jpegImageSize{ 0 }; 
      int64_t pngImageSize{ 0 };  
      int64_t imageMaskSize{ 0 }; 
      int32_t imageWidth{ 0 };    
      int32_t imageHeight{ 0 };   
      double pixelWidth{ 0. };    
      double pixelHeight{ 0. };   
      double radius{ 0. }; 
      double principalPointY{ 0. }; 
 
      bool operator==( const CylindricalRepresentation &rhs ) const
      {
         return ( jpegImageSize == rhs.jpegImageSize ) && ( pngImageSize == rhs.pngImageSize ) &&
                ( imageMaskSize == rhs.imageMaskSize ) && ( imageWidth == rhs.imageWidth ) &&
                ( imageHeight == rhs.imageHeight ) && ( pixelWidth == rhs.pixelWidth ) &&
                ( pixelHeight == rhs.pixelHeight ) && ( radius == rhs.radius ) &&
                ( principalPointY == rhs.principalPointY );
      }
      bool operator!=( const CylindricalRepresentation &rhs ) const
      {
         return !operator==( rhs );
      }
   };
 
   struct E57_DLL Image2D
   {
      ustring name;        
      ustring guid;        
      ustring description; 
      DateTime acquisitionDateTime; 
 
      ustring associatedData3DGuid; 
 
      ustring sensorVendor; 
      ustring sensorModel;  
      ustring sensorSerialNumber; 
 
      RigidBodyTransform pose; 
 
      VisualReferenceRepresentation
         visualReferenceRepresentation; 
      PinholeRepresentation
         pinholeRepresentation; 
      SphericalRepresentation
         sphericalRepresentation; 
      CylindricalRepresentation
         cylindricalRepresentation; 
   };
 
   enum Image2DType
   {
      E57_NO_IMAGE = 0,      
      E57_JPEG_IMAGE = 1,    
      E57_PNG_IMAGE = 2,     
      E57_PNG_IMAGE_MASK = 3 
   };
 
   enum Image2DProjection
   {
      E57_NO_PROJECTION = 0, 
      E57_VISUAL = 1,        
      E57_PINHOLE = 2,       
      E57_SPHERICAL = 3,     
      E57_CYLINDRICAL = 4    
   };
 
} // end namespace e57