From 13fb859cc0b8f492b07d22b2116edbabe7c6c4f1 Mon Sep 17 00:00:00 2001 From: "Michael P. Gerlek" Date: Mon, 19 Sep 2011 15:24:54 -0700 Subject: [PATCH] make the Dimension be a single enum, not an enum+datatype combination --- apps/pcview/main.cpp | 12 +- include/pdal/Dimension.hpp | 155 +++++++----- include/pdal/DimensionLayout.hpp | 4 + include/pdal/Schema.hpp | 18 +- include/pdal/XMLSchema.hpp | 2 +- include/pdal/filters/StatsFilter.hpp | 4 +- src/Dimension.cpp | 346 ++++++++++++++++++++++----- src/DimensionLayout.cpp | 5 + src/PointBuffer.cpp | 4 +- src/Schema.cpp | 77 +----- src/XMLSchema.cpp | 60 +++-- src/drivers/faux/Reader.cpp | 45 ++-- src/drivers/faux/Writer.cpp | 6 +- src/drivers/las/Support.cpp | 246 ++++++------------- src/drivers/las/Writer.cpp | 6 +- src/drivers/liblas/Writer.cpp | 6 +- src/drivers/oci/Writer.cpp | 48 ++-- src/drivers/qfit/Reader.cpp | 187 +++++---------- src/drivers/terrasolid/Reader.cpp | 218 ++++++----------- src/filters/ByteSwapFilter.cpp | 6 +- src/filters/Chipper.cpp | 16 +- src/filters/ChipperIterator.cpp | 4 +- src/filters/ColorFilter.cpp | 22 +- src/filters/CropFilter.cpp | 6 +- src/filters/ReprojectionFilter.cpp | 12 +- src/filters/ScalingFilter.cpp | 118 ++++----- src/filters/StatsFilter.cpp | 43 ++-- test/unit/ByteSwapFilterTest.cpp | 8 +- test/unit/CacheFilterTest.cpp | 4 +- test/unit/ChipperTest.cpp | 4 +- test/unit/DecimationFilterTest.cpp | 4 +- test/unit/DimensionLayoutTest.cpp | 8 +- test/unit/DimensionTest.cpp | 23 +- test/unit/FauxReaderTest.cpp | 58 ++--- test/unit/MosaicFilterTest.cpp | 8 +- test/unit/PointBufferCacheTest.cpp | 4 +- test/unit/PointBufferTest.cpp | 22 +- test/unit/QFITReaderTest.cpp | 8 +- test/unit/ReprojectionFilterTest.cpp | 6 +- test/unit/ScalingFilterTest.cpp | 12 +- test/unit/SchemaLayoutTest.cpp | 42 ++-- test/unit/SchemaTest.cpp | 30 +-- test/unit/StatsFilterTest.cpp | 6 +- test/unit/Support.cpp | 16 +- test/unit/TerraSolidTest.cpp | 8 +- test/unit/XMLSchemaTest.cpp | 4 +- test/unit/pcinfoTest.cpp | 1 - test/unit/pcpipelineTest.cpp | 1 - 48 files changed, 972 insertions(+), 981 deletions(-) diff --git a/apps/pcview/main.cpp b/apps/pcview/main.cpp index a39c0d315f..7bca90f65a 100644 --- a/apps/pcview/main.cpp +++ b/apps/pcview/main.cpp @@ -175,12 +175,12 @@ static void givePointsToEngine(ThreadArgs* threadArgs) colors = new boost::uint16_t[numRead * 3]; } - const int offsetX = schema.getDimensionIndex(pdal::Dimension::Field_X, pdal::Dimension::Int32); - const int offsetY = schema.getDimensionIndex(pdal::Dimension::Field_Y, pdal::Dimension::Int32); - const int offsetZ = schema.getDimensionIndex(pdal::Dimension::Field_Z, pdal::Dimension::Int32); - const int offsetR = schema.getDimensionIndex(pdal::Dimension::Field_Red, pdal::Dimension::Uint16); - const int offsetG = schema.getDimensionIndex(pdal::Dimension::Field_Green, pdal::Dimension::Uint16); - const int offsetB = schema.getDimensionIndex(pdal::Dimension::Field_Blue, pdal::Dimension::Uint16); + const int offsetX = schema.getDimensionIndex(pdal::Dimension::Id_X_i32); + const int offsetY = schema.getDimensionIndex(pdal::Dimension::Id_Y_i32); + const int offsetZ = schema.getDimensionIndex(pdal::Dimension::Id_Z_i32); + const int offsetR = schema.getDimensionIndex(pdal::Dimension::Id_Red_u16); + const int offsetG = schema.getDimensionIndex(pdal::Dimension::Id_Green_u16); + const int offsetB = schema.getDimensionIndex(pdal::Dimension::Id_Blue_u16); const pdal::Dimension& xDim = schema.getDimension(offsetX); const pdal::Dimension& yDim = schema.getDimension(offsetY); diff --git a/include/pdal/Dimension.hpp b/include/pdal/Dimension.hpp index c774bc2c4d..476e6d58f0 100644 --- a/include/pdal/Dimension.hpp +++ b/include/pdal/Dimension.hpp @@ -44,6 +44,7 @@ #include #include +#include #include @@ -59,59 +60,79 @@ namespace pdal class PDAL_DLL Dimension { public: - /// \name Enumerations - enum Field + //typedef pdal::external::boost::uuids::uuid Id; + + enum Id { - Field_INVALID = 0, - Field_X, - Field_Y, - Field_Z, - Field_Intensity, - Field_ReturnNumber, - Field_NumberOfReturns, - Field_ScanDirectionFlag, - Field_EdgeOfFlightLine, - Field_Classification, - Field_ScanAngleRank, - Field_UserData, - Field_PointSourceId, - Field_Time, - Field_Red, - Field_Green, - Field_Blue, - Field_WavePacketDescriptorIndex, - Field_WaveformDataOffset, - Field_ReturnPointWaveformLocation, - Field_WaveformXt, - Field_WaveformYt, - Field_WaveformZt, - Field_Alpha, - // ... - - // add more here - Field_User1 = 512, - Field_User2, - Field_User3, - Field_User4, - Field_User5, - Field_User6, - Field_User7, - Field_User8, - Field_User9, - Field_User10, - Field_User11, - Field_User12, - Field_User13, - Field_User14, - Field_User15, - // ... - // feel free to use your own int here - - Field_LAST = 1023 + Id_X_i32 = 0, + Id_Y_i32, + Id_Z_i32, + Id_X_f64, + Id_Y_f64, + Id_Z_f64, + + Id_Red_u8, + Id_Green_u8, + Id_Blue_u8, + Id_Red_u16, + Id_Green_u16, + Id_Blue_u16, + + Id_Time_u64, + + Id_Las_Intensity = 100, + Id_Las_ReturnNumber, + Id_Las_NumberOfReturns, + Id_Las_ScanDirectionFlag, + Id_Las_EdgeOfFlightLine, + Id_Las_Classification, + Id_Las_ScanAngleRank, + Id_Las_UserData, + Id_Las_PointSourceId, + Id_Las_WavePacketDescriptorIndex, + Id_Las_WaveformDataOffset, + Id_Las_ReturnPointWaveformLocation, + Id_Las_WaveformXt, + Id_Las_WaveformYt, + Id_Las_WaveformZt, + Id_Las_Time, + + // terrasolid + Id_TerraSolid_Alpha = 200, + Id_TerraSolid_Classification, + Id_TerraSolid_PointSourceId_u8, + Id_TerraSolid_PointSourceId_u16, + Id_TerraSolid_ReturnNumber_u8, + Id_TerraSolid_ReturnNumber_u16, + Id_TerraSolid_Flag, + Id_TerraSolid_Mark, + Id_TerraSolid_Intensity, + Id_TerraSolid_Time, + + // chipper stuff + Id_Chipper_1 = 300, + Id_Chipper_2, + + // qfit + Id_Qfit_StartPulse = 400, + Id_Qfit_ReflectedPulse, + Id_Qfit_ScanAngleRank, + Id_Qfit_Pitch, + Id_Qfit_Roll, + Id_Qfit_Time, + Id_Qfit_PassiveSignal, + Id_Qfit_PassiveX, + Id_Qfit_PassiveY, + Id_Qfit_PassiveZ, + Id_Qfit_GpsTime, + Id_Qfit_PDOP, + Id_Qfit_PulseWidth, + + Id_Qfit_User1 = 10000, + + Id_Undefined = 100000 }; - // Do not explicitly specify these enum values because they - // are (probably wrongly) used to iterate through for Schema::getX, Schema::getY, Schema::getZ enum DataType { Int8, @@ -122,40 +143,53 @@ class PDAL_DLL Dimension Uint32, Int64, Uint64, + Pointer, // stored as 64 bits, even on a 32-bit box Float, // 32 bits Double, // 64 bits Undefined }; + enum Flags + { + IsAdded = 0x1, + IsRead = 0x2, + IsWritten = 0x4, + }; + /// \name Constructors - Dimension(Field field, DataType type); - Dimension& operator=(Dimension const& rhs); + Dimension(const Id& id); // will use table to lookup datatype, description, etc + Dimension(const Id& id, DataType datatype, std::string name); // for dimensions not in the master table Dimension(Dimension const& other); + Dimension& operator=(Dimension const& rhs); + /// \name Equality bool operator==(const Dimension& other) const; bool operator!=(const Dimension& other) const; /// \name Data Access - std::string const& getFieldName() const; + std::string const& getName() const; - Field getField() const + Id getId() const { - return m_field; + return m_id; } + boost::uint32_t getFlags() const { return m_flags; } + void setFlags(boost::uint32_t flags) { m_flags = flags; } + DataType getDataType() const { return m_dataType; } + static std::string getDataTypeName(DataType); static DataType getDataTypeFromString(const std::string&); static std::size_t getDataTypeSize(DataType); static bool getDataTypeIsNumeric(DataType); static bool getDataTypeIsSigned(DataType); static bool getDataTypeIsInteger(DataType); - static std::string const& getFieldName(Field); /// \return Number of bytes required to serialize this dimension std::size_t getByteSize() const @@ -345,7 +379,9 @@ class PDAL_DLL Dimension private: DataType m_dataType; - Field m_field; + Id m_id; + std::string m_name; + boost::uint32_t m_flags; EndianType m_endian; std::size_t m_byteSize; std::string m_description; @@ -354,16 +390,11 @@ class PDAL_DLL Dimension bool m_precise; double m_numericScale; double m_numericOffset; - - static void initFieldNames(); - static bool s_fieldNamesValid; - static std::string s_fieldNames[Field_LAST]; }; PDAL_DLL std::ostream& operator<<(std::ostream& os, pdal::Dimension const& d); - } // namespace pdal #endif // PDAL_DIMENSION_HPP_INCLUDED diff --git a/include/pdal/DimensionLayout.hpp b/include/pdal/DimensionLayout.hpp index 038da8d6d5..0a092bfada 100644 --- a/include/pdal/DimensionLayout.hpp +++ b/include/pdal/DimensionLayout.hpp @@ -66,6 +66,9 @@ class PDAL_DLL DimensionLayout return m_dimension; } + bool isValid() const { return m_isValid; } + void setIsValid(bool v) { m_isValid = v; } + /// The byte location to start reading/writing /// point data from in a composited schema. liblas::Schema /// will set these values for you when liblas::Dimension are @@ -118,6 +121,7 @@ class PDAL_DLL DimensionLayout Dimension m_dimension; std::size_t m_byteOffset; std::size_t m_position; + bool m_isValid; }; diff --git a/include/pdal/Schema.hpp b/include/pdal/Schema.hpp index d700fe8020..eef7999712 100644 --- a/include/pdal/Schema.hpp +++ b/include/pdal/Schema.hpp @@ -65,8 +65,6 @@ namespace pdal { -typedef boost::tuple tpl_t; - /// Schema definition class PDAL_DLL Schema { @@ -84,25 +82,22 @@ class PDAL_DLL Schema bool operator==(const Schema& other) const; bool operator!=(const Schema& other) const; - void addDimension(Dimension const& dim); - void addDimensions(const std::vector& dims); - - void removeDimension(Dimension const& dim); + void appendDimension(Dimension const& dim); + void appendDimensions(const std::vector& dim); const Dimension& getDimension(std::size_t index) const; Dimension& getDimension(std::size_t index); const Dimensions& getDimensions() const; - // Dimensions& getDimensions(); // returns the index of the field // // This function assumes the field is present and valid. If not, it will throw. // (This behaviour is okay because looking up the diemsnion index is not expected // to be on the critical path anywhere.) - int getDimensionIndex(Dimension::Field field, Dimension::DataType datatype) const; + int getDimensionIndex(const Dimension::Id& id) const; int getDimensionIndex(const Dimension& dim) const; - bool hasDimension(Dimension::Field field, Dimension::DataType datatype) const; + bool hasDimension(const Dimension::Id& id) const; bool hasDimension(const Dimension& dim) const; // returns a ptree reprsenting the Schema @@ -125,10 +120,7 @@ class PDAL_DLL Schema private: std::vector m_dimensions; - std::map m_dimensions_map; - // this is a mapping from field name to index position in the - // m_dimensions array (or -1 if field not present) - // int m_indexTable[Dimension::Field_LAST]; + std::map m_dimensions_map; }; diff --git a/include/pdal/XMLSchema.hpp b/include/pdal/XMLSchema.hpp index 022e236236..d3a6b99842 100644 --- a/include/pdal/XMLSchema.hpp +++ b/include/pdal/XMLSchema.hpp @@ -141,7 +141,7 @@ class PDAL_DLL Reader void Initialize(); void Load(); Dimension::DataType GetDimensionType(std::string const& interpretation); - Dimension::Field GetDimensionField(std::string const& name, boost::uint32_t position); + Dimension::Id GetDimensionField(std::string const& name, boost::uint32_t position); private: diff --git a/include/pdal/filters/StatsFilter.hpp b/include/pdal/filters/StatsFilter.hpp index e257a98154..7a24ba586b 100644 --- a/include/pdal/filters/StatsFilter.hpp +++ b/include/pdal/filters/StatsFilter.hpp @@ -97,7 +97,7 @@ class PDAL_DLL StatsFilter : public Filter void processBuffer(PointBuffer& data) const; // returns the stats for field i - const StatsCollector& getStats(Dimension::Field field) const; + const StatsCollector& getStats(Dimension::Id id) const; // clears the counters for all fields void reset(); @@ -117,7 +117,7 @@ class PDAL_DLL StatsFilter : public Filter private: // the stats are keyed by the field name // BUG: not threadsafe, these should maybe live in the iterator - std::map m_stats; // one Stats item per field in the schema + std::map m_stats; // one Stats item per field in the schema StatsFilter& operator=(const StatsFilter&); // not implemented StatsFilter(const StatsFilter&); // not implemented diff --git a/src/Dimension.cpp b/src/Dimension.cpp index 9dce455be2..a925f28558 100644 --- a/src/Dimension.cpp +++ b/src/Dimension.cpp @@ -40,18 +40,270 @@ ****************************************************************************/ #include +#include +#include namespace pdal { -std::string Dimension::s_fieldNames[Field_LAST]; -bool Dimension::s_fieldNamesValid = false; +// -------------------------------------------------------------------------- +#if 0 +Dimension::Id Dimension_X_i32 = { 0xab, 0xca, 0x4c, 0x06, 0xef, 0x6c, 0x4c, 0x38, 0xbb, 0x30, 0x0c, 0x8c, 0x43, 0x58, 0x6f, 0xcc }; +Dimension::Id Dimension_Y_i32 = { 0x6E, 0xE5, 0xCA, 0xCB, 0x35, 0x68, 0x4F, 0x3F, 0x80, 0xAA, 0xE9, 0x96, 0x5B, 0x7E, 0x4A, 0x23 }; +Dimension::Id Dimension_Z_i32 = { 0x93, 0xE1, 0x61, 0x79, 0xC0, 0xC5, 0x43, 0x7E, 0xB9, 0x06, 0x60, 0x01, 0xC4, 0x96, 0xA3, 0x35 }; +Dimension::Id Dimension_X_f64 = { 0x14, 0x96, 0x0E, 0x7A, 0x11, 0xBD, 0x49, 0xD9, 0xB2, 0x4B, 0xE0, 0xBB, 0xB7, 0x59, 0xCE, 0x32 }; +Dimension::Id Dimension_Y_f64 = { 0xAD, 0xF4, 0xD3, 0x4F, 0x6B, 0x34, 0x47, 0x64, 0x9F, 0x35, 0xFC, 0x42, 0x28, 0x2D, 0x5A, 0x76 }; +Dimension::Id Dimension_Z_f64 = { 0x2D, 0xB0, 0x00, 0x14, 0x05, 0xFE, 0x4C, 0x0A, 0x83, 0xAC, 0xE5, 0xB9, 0x87, 0xC6, 0x0F, 0x6D }; + +Dimension::Id Dimension_Red_u8 = { 0xD9, 0x2F, 0x5F, 0x32, 0xB7, 0x0E, 0x4E, 0x98, 0xB3, 0x97, 0xB6, 0xF0, 0xAA, 0x87, 0x73, 0x2A }; +Dimension::Id Dimension_Green_u8 = { 0xD7, 0x3D, 0xDA, 0x07, 0x83, 0x43, 0x44, 0x5C, 0xA1, 0x4F, 0xB0, 0x30, 0xB7, 0xB5, 0x00, 0x4E }; +Dimension::Id Dimension_Blue_u8 = { 0xBC, 0x2F, 0xEC, 0x3D, 0x69, 0xA7, 0x43, 0x10, 0xB5, 0xAF, 0xE7, 0xFF, 0xBF, 0xD4, 0x8C, 0x8F }; +Dimension::Id Dimension_Red_u16 = { 0xBB, 0xA4, 0xCF, 0x23, 0x28, 0xA4, 0x48, 0x07, 0x91, 0xAC, 0xC6, 0xF5, 0x9A, 0xE3, 0x5D, 0xDC }; +Dimension::Id Dimension_Green_u16 = { 0x55, 0xC7, 0x02, 0xC7, 0x14, 0xB6, 0x43, 0x94, 0x9F, 0xDB, 0x4D, 0x43, 0x24, 0x0A, 0x17, 0xE7 }; +Dimension::Id Dimension_Blue_u16 ;//= { 0xBA, 0xC2, 0x52, 0x5E, 0x43, 0x54, 0x4B, 0x1E, 0x98, 0x31, 0xDC, 0xE1, 0xBD, 0xEC, 0x58, 0x81 }; + +Dimension::Id Dimension_Time_u64 = { 0xF0, 0xC1, 0x92, 0xFA, 0x60, 0x7D, 0x42, 0xD7, 0x96, 0xA2, 0x16, 0x0A, 0x63, 0x78, 0x6C, 0x45 }; + +// f64, gps +Dimension::Id Dimension_Las_Intensity = { 0xEF, 0x7C, 0x70, 0xC9, 0x2F, 0xCC, 0x4D, 0x8F, 0x82, 0x2C, 0x1C, 0x95, 0x73, 0xCF, 0x55, 0xEE }; +Dimension::Id Dimension_Las_ReturnNumber = { 0xB7, 0xED, 0x85, 0x45, 0x49, 0xD0, 0x47, 0x2F, 0xBE, 0xF9, 0xAF, 0x10, 0x82, 0x2A, 0x3A, 0x27 }; +Dimension::Id Dimension_Las_NumberOfReturns = { 0x50, 0x8E, 0x08, 0x60, 0x56, 0xF7, 0x4C, 0x67, 0xB5, 0xCE, 0xD1, 0x94, 0x2A, 0xCF, 0xBE, 0xC6 }; +Dimension::Id Dimension_Las_ScanDirectionFlag = { 0x53, 0x52, 0x00, 0xF6, 0xBD, 0xE1, 0x49, 0x43, 0xB6, 0x32, 0x38, 0x7A, 0x4F, 0x09, 0x55, 0xFD }; +Dimension::Id Dimension_Las_EdgeOfFlightLine = { 0x44, 0x50, 0x43, 0xD6, 0x43, 0xED, 0x44, 0x69, 0x9C, 0x53, 0x32, 0xCE, 0x65, 0x63, 0x60, 0x11 }; +Dimension::Id Dimension_Las_Classification = { 0x88, 0x38, 0xCA, 0xBA, 0xCF, 0x54, 0x43, 0xED, 0x98, 0xD5, 0xE1, 0x66, 0x5C, 0x6B, 0xBB, 0xD6 }; +Dimension::Id Dimension_Las_ScanAngleRank = { 0x79, 0x16, 0x19, 0xE1, 0x36, 0x3B, 0x40, 0x56, 0xAD, 0x4B, 0x20, 0x74, 0xD3, 0x62, 0x8C, 0x4B }; +Dimension::Id Dimension_Las_UserData = { 0x7F, 0x50, 0xAD, 0xCF, 0x09, 0x9D, 0x42, 0xFC, 0x8D, 0x1C, 0xF3, 0xFF, 0x68, 0x70, 0x42, 0xB3 }; +Dimension::Id Dimension_Las_PointSourceId = { 0x0F, 0x8B, 0xDF, 0x1F, 0x78, 0x6E, 0x4B, 0xF9, 0xB2, 0x77, 0x47, 0x12, 0xE1, 0x22, 0x0D, 0x25 }; +Dimension::Id Dimension_Las_WavePacketDescriptorIndex = { 0xB4, 0xC9, 0x39, 0x72, 0x3C, 0x19, 0x4C, 0x70, 0x86, 0x63, 0xA6, 0xC5, 0xF5, 0xF1, 0x10, 0x87 }; +Dimension::Id Dimension_Las_WaveformDataOffset = { 0x9A, 0xDE, 0x88, 0xC0, 0xB8, 0x1E, 0x47, 0x2F, 0xAD, 0xF6, 0x3F, 0x4B, 0x85, 0xB1, 0xE0, 0xEC }; +Dimension::Id Dimension_Las_ReturnPointWaveformLocation = { 0xDB, 0x1D, 0x7F, 0x9E, 0x03, 0x23, 0x4B, 0x60, 0xB8, 0x4B, 0x09, 0x8C, 0x20, 0x1B, 0x3A, 0x8A }; +Dimension::Id Dimension_Las_WaveformXt = { 0xF4, 0x90, 0xF2, 0xAC, 0xCB, 0xAC, 0x41, 0x56, 0x93, 0x9D, 0x4E, 0xD6, 0x1C, 0x6A, 0x1C, 0x6B }; +Dimension::Id Dimension_Las_WaveformYt = { 0x90, 0x1F, 0x76, 0x27, 0xF5, 0xC3, 0x48, 0x8D, 0x99, 0xD8, 0xCF, 0x4B, 0x3E, 0xDA, 0x42, 0x87 }; +Dimension::Id Dimension_Las_WaveformZt = { 0x5F, 0xFC, 0x07, 0x62, 0x0B, 0xA2, 0x4A, 0x64, 0x91, 0xCF, 0x1C, 0x62, 0x85, 0x76, 0x21, 0x90 }; +Dimension::Id Dimension_Las_Time = { 0xE3, 0x32, 0xB3, 0x93, 0xC3, 0x44, 0x49, 0x25, 0xA1, 0x45, 0x3C, 0x72, 0xA9, 0x1D, 0xC5, 0xD1 }; + +// +// TerraSolid +// +// +// X: "Easting" +// Y": "Northing" +// Z: "Elevation" + +//u8 The alpha image channel value associated with this point"; //u8 +Dimension::Id Dimension_TerraSolid_Alpha = { 0xEC, 0x91, 0x99, 0xEC, 0xC5, 0x4D, 0x40, 0x78, 0x84, 0x85, 0x72, 0xFC, 0x25, 0x73, 0x61, 0x8F }; +//"Classification code 0-255" //u8 +Dimension::Id Dimension_TerraSolid_Classification = { 0xDB, 0x65, 0x44, 0xFC, 0x25, 0x8D, 0x46, 0x09, 0x8A, 0x59, 0x55, 0x13, 0x29, 0x3A, 0x9C, 0xCF }; +//"Flightline number 0-255" +Dimension::Id Dimension_TerraSolid_PointSourceId_u8 = { 0xB6, 0x66, 0xEF, 0x8B, 0xB6, 0x13, 0x4F, 0x61, 0xBD, 0xFB, 0x40, 0x1F, 0x4A, 0xC1, 0x40, 0xF9 }; +//"Flightline number 0-255" +Dimension::Id Dimension_TerraSolid_PointSourceId_u16 = { 0x7B, 0x56, 0x73, 0x4C, 0xC3, 0x9C, 0x49, 0xC3, 0x96, 0x1A, 0x71, 0x0A, 0x7C, 0x70, 0xE4, 0x81 }; +//"Echo/Return Number. 0 - Only echo. 1 - First of many echo. 2 - Intermediate echo. 3 - Last of many echo." +Dimension::Id Dimension_TerraSolid_ReturnNumber_u8 = { 0x50, 0x23, 0x0B, 0x8D, 0x89, 0xAC, 0x4D, 0xEC, 0x95, 0x8A, 0x28, 0x45, 0x9C, 0x35, 0x78, 0xB9 }; +Dimension::Id Dimension_TerraSolid_ReturnNumber_u16 = { 0xEA, 0x17, 0x26, 0x34, 0x72, 0xA5, 0x43, 0x34, 0x95, 0x1E, 0x58, 0x20, 0x13, 0x64, 0x8A, 0x19 }; +//"Echo/Return Number. 0 - Only echo. 1 - First of many echo. 2 - Intermediate echo. 3 - Last of many echo." +Dimension::Id Dimension_TerraSolid_Flag = { 0xA2, 0x9A, 0x22, 0xD2, 0xF0, 0x6E, 0x4E, 0x07, 0x9D, 0x41, 0x6F, 0x69, 0xBC, 0xBB, 0xE8, 0xCD }; +//"Runtime flag"//u8 +Dimension::Id Dimension_TerraSolid_Mark = { 0x95, 0xBA, 0xC8, 0x1D, 0x97, 0x4D, 0x42, 0x11, 0x84, 0xAD, 0xA9, 0x10, 0x03, 0x9E, 0x18, 0xDC }; +//"Intensity bits 0-13, echo bits 14-15" //u16 +Dimension::Id Dimension_TerraSolid_Intensity = { 0xB5, 0x0A, 0x89, 0xFB, 0x14, 0x2D, 0x45, 0xC2, 0xBC, 0xDE, 0x29, 0x8F, 0x78, 0x3D, 0xE0, 0xED }; +//"32 bit integer time stamps. Time stamps are assumed to be GPS week seconds. The storage format is a 32 bit unsigned integer where each integer step is 0.0002 seconds.";//i32 +Dimension::Id Dimension_TerraSolid_Time = { 0xA1, 0x56, 0x63, 0xBB, 0xB4, 0xC2, 0x41, 0x92, 0xBB, 0xE8, 0x55, 0x91, 0x35, 0xDA, 0x5A, 0x3A }; + +// +// Chipper +// +Dimension::Id Dimension_Chipper_1 = { 0xF2, 0x52, 0xF1, 0x5A, 0x2F, 0x96, 0x48, 0x68, 0xA3, 0x5C, 0x9F, 0xDC, 0x6D, 0xA7, 0x6B, 0x22 }; +Dimension::Id Dimension_Chipper_2 = { 0x2E, 0xB2, 0x64, 0xCB, 0x9F, 0x18, 0x45, 0xB8, 0xA3, 0x4F, 0x16, 0x60, 0xD8, 0x6C, 0xDC, 0x74 }; + +// +// Qfit +// + +// //"Longitude coordinate with 1/1000000 decimals of precision" +////"Latitude coordinate with 1/1000000 decimals of precision" +////"z coordinate as a long integer. You must use the scale and offset information of the header to determine the double value." +//"Start Pulse Signal Strength (relative)" +Dimension::Id Dimension_Qfit_StartPulse = { 0xAC, 0x04, 0x01, 0xA2, 0x45, 0xC5, 0x4F, 0x5A, 0x93, 0x70, 0x51, 0x91, 0xBD, 0x40, 0x33, 0x6A }; +//"Reflected Laser Signal Strength (relative)" +Dimension::Id Dimension_Qfit_ReflectedPulse = { 0xF6, 0x51, 0x99, 0x72, 0x8C, 0xF9, 0x40, 0xF0, 0x9A, 0x30, 0x16, 0x8A, 0x1E, 0x02, 0xB3, 0x40 }; +//"Scan Azimuth (degrees X 1,000)" +Dimension::Id Dimension_Qfit_ScanAngleRank = { 0xA2, 0xCD, 0x54, 0x4B, 0x63, 0x12, 0x46, 0x20, 0xB7, 0x19, 0x6A, 0xAF, 0x95, 0x4A, 0xAF, 0x00 }; +//"Pitch (degrees X 1,000)" +Dimension::Id Dimension_Qfit_Pitch = { 0xAA, 0x8B, 0xE1, 0xA8, 0x34, 0xFA, 0x41, 0x8E, 0xA2, 0xEB, 0x11, 0x43, 0x16, 0xC2, 0x24, 0xC8 }; +//"Roll (degrees X 1,000)" +Dimension::Id Dimension_Qfit_Roll = { 0xFC, 0xCE, 0x23, 0x04, 0xED, 0xED, 0x43, 0x4D, 0xA0, 0x41, 0x3B, 0xBA, 0x29, 0x75, 0xC7, 0x75 }; +// "Relative Time (msec from start of data file)";// i32 +Dimension::Id Dimension_Qfit_Time = { 0x5F, 0xFC, 0x07, 0x62, 0x0B, 0xA2, 0x4A, 0x64, 0x91, 0xCF, 0x1C, 0x62, 0x85, 0x76, 0x21, 0x90 }; +//"Passive Signal (relative)" // i32 +Dimension::Id Dimension_Qfit_PassiveSignal = { 0xEA, 0x96, 0x37, 0x54, 0x6B, 0x9C, 0x4B, 0x5F, 0xB7, 0x5E, 0xD6, 0xF9, 0xCC, 0x55, 0x44, 0xD7 }; +//"Passive Footprint Longitude (degrees X 1,000,000)" // i32 +Dimension::Id Dimension_Qfit_PassiveX = { 0x01, 0x6A, 0x10, 0x07, 0xC3, 0x9D, 0x48, 0x6E, 0xAA, 0x91, 0x1A, 0x50, 0xBB, 0x62, 0xDF, 0x9D }; +//"Passive Footprint Latitude (degrees X 1,000,000)" // i32 +Dimension::Id Dimension_Qfit_PassiveY = { 0x66, 0x6D, 0x81, 0x0B, 0xB7, 0xED, 0x41, 0xC8, 0x8E, 0xA2, 0xEA, 0x6E, 0x46, 0x3B, 0xAE, 0xCD }; +//"Passive Footprint Synthesized Elevation (millimeters)" // i32 +Dimension::Id Dimension_Qfit_PassiveZ = { 0x5D, 0xC5, 0xFB, 0x8F, 0xC4, 0x24, 0x4F, 0x2E, 0xA1, 0x93, 0xF9, 0xB1, 0x0B, 0xE8, 0x1C, 0xD7 }; +//"GPS Time packed (example: 153320100 = 15h 33m 20s 100ms)" // i32 +Dimension::Id Dimension_Qfit_GpsTime = { 0x4E, 0x87, 0x33, 0x04, 0xBB, 0x38, 0x4F, 0x26, 0x8E, 0x52, 0x68, 0x33, 0xDE, 0x59, 0xFB, 0xB9 }; +//"GPS PDOP (dilution of precision) (X 10) // i32 +Dimension::Id Dimension_Qfit_PDOP = { 0x2A, 0x12, 0xC6, 0x49, 0xBC, 0xF0, 0x48, 0x47, 0x88, 0x83, 0xD5, 0x1E, 0xEC, 0xC5, 0x82, 0xB4 }; +//"Laser received pulse width (digitizer samples) // i32 +Dimension::Id Dimension_Qfit_PulseWidth = { 0x00, 0xD3, 0x7C, 0x5C, 0x6A, 0xAF, 0x44, 0x53, 0x97, 0xD2, 0xB6, 0x1E, 0xCE, 0xEB, 0x88, 0x05 }; +#endif +class KnownDimension +{ +public: + Dimension::Id id; + Dimension::DataType datatype; + std::string name; +}; + +KnownDimension s_knownDimensions[] = +{ + // common x,y,z + { Dimension::Id_X_i32, Dimension::Int32, "X" }, + { Dimension::Id_Y_i32, Dimension::Int32, "Y" }, + { Dimension::Id_Z_i32, Dimension::Int32, "Z" }, + { Dimension::Id_X_f64, Dimension::Double, "X" }, + { Dimension::Id_Y_f64, Dimension::Double, "Y" }, + { Dimension::Id_Z_f64, Dimension::Double, "Z" }, + + { Dimension::Id_Time_u64, Dimension::Uint64, "Time" }, + + { Dimension::Id_Red_u16, Dimension::Uint16, "Red" }, + { Dimension::Id_Green_u16, Dimension::Uint16, "Green" }, + { Dimension::Id_Blue_u16, Dimension::Uint16, "Blue" }, + { Dimension::Id_Red_u8, Dimension::Uint8, "Red" }, + { Dimension::Id_Green_u8, Dimension::Uint8, "Green" }, + { Dimension::Id_Blue_u8, Dimension::Uint8, "Blue" }, + + // las + { Dimension::Id_Las_Intensity, Dimension::Uint16, "Intensity" }, + { Dimension::Id_Las_ReturnNumber, Dimension::Uint8, "ReturnNumber" }, + { Dimension::Id_Las_NumberOfReturns, Dimension::Uint8, "NumberOfReturns" }, + { Dimension::Id_Las_ScanDirectionFlag, Dimension::Uint8, "ScanDirectionFlag" }, + { Dimension::Id_Las_EdgeOfFlightLine, Dimension::Uint8, "EdgeOfFlightLine" }, + { Dimension::Id_Las_Classification, Dimension::Uint8, "Classification" }, + { Dimension::Id_Las_ScanAngleRank, Dimension::Int8, "ScanAngleRank" }, + { Dimension::Id_Las_UserData, Dimension::Uint8, "UserData" }, + { Dimension::Id_Las_PointSourceId, Dimension::Uint16, "PointSourceId" }, + { Dimension::Id_Las_WavePacketDescriptorIndex, Dimension::Uint8, "WavePacketDescriptorIndex" }, + { Dimension::Id_Las_WaveformDataOffset, Dimension::Uint64, "WaveformDataOffset" }, + { Dimension::Id_Las_ReturnPointWaveformLocation, Dimension::Uint32, "ReturnPointWaveformLocation" }, + { Dimension::Id_Las_WaveformXt, Dimension::Float, "WaveformXt" }, + { Dimension::Id_Las_WaveformYt, Dimension::Float, "WaveformYt" }, + { Dimension::Id_Las_WaveformZt, Dimension::Float, "WaveformZt" }, + { Dimension::Id_Las_Time, Dimension::Double, "Time" }, + + // terrasolid + { Dimension::Id_TerraSolid_Alpha, Dimension::Uint8, "Alpha" }, + { Dimension::Id_TerraSolid_Classification, Dimension::Uint8, "Classification" }, + { Dimension::Id_TerraSolid_PointSourceId_u8, Dimension::Uint8, "PointSourceId_u8" }, + { Dimension::Id_TerraSolid_PointSourceId_u16, Dimension::Uint16, "PointSourceId_u16" }, + { Dimension::Id_TerraSolid_ReturnNumber_u8, Dimension::Uint8, "ReturnNumber" }, + { Dimension::Id_TerraSolid_ReturnNumber_u16, Dimension::Uint16, "ReturnNumber" }, + { Dimension::Id_TerraSolid_Flag, Dimension::Uint8, "Flag" }, + { Dimension::Id_TerraSolid_Mark, Dimension::Uint8, "Mark" }, + { Dimension::Id_TerraSolid_Intensity, Dimension::Uint16, "Intensity" }, + { Dimension::Id_TerraSolid_Time, Dimension::Uint32, "TerraSolid Time" }, + + // chipper + { Dimension::Id_Chipper_1, Dimension::Int32, "Chipper1" }, + { Dimension::Id_Chipper_2, Dimension::Int32, "Chipper2" }, + + // qfit + { Dimension::Id_Qfit_StartPulse, Dimension::Int32, "StartPulse" }, + { Dimension::Id_Qfit_ReflectedPulse, Dimension::Int32, "ReflectedPulse" }, + { Dimension::Id_Qfit_ScanAngleRank, Dimension::Int32, "ScanAngleRank" }, + { Dimension::Id_Qfit_Pitch, Dimension::Int32, "Pitch" }, + { Dimension::Id_Qfit_Roll, Dimension::Int32, "Roll" }, + { Dimension::Id_Qfit_Time, Dimension::Int32, "Qfit Time" }, + { Dimension::Id_Qfit_PassiveSignal, Dimension::Int32, "PassiveSignal" }, + { Dimension::Id_Qfit_PassiveX, Dimension::Int32, "PassiveX" }, + { Dimension::Id_Qfit_PassiveY, Dimension::Int32, "PassiveY" }, + { Dimension::Id_Qfit_PassiveZ, Dimension::Int32, "PassiveZ" }, + { Dimension::Id_Qfit_GpsTime, Dimension::Int32, "GpsTime" }, + { Dimension::Id_Qfit_PDOP, Dimension::Int32, "PDOP" }, + { Dimension::Id_Qfit_PulseWidth, Dimension::Int32, "PulseWdith" }, + + // eof + { Dimension::Id_Undefined, Dimension::Undefined, "" } +}; + + +static void validate(); + +// BUG: this is too slow +static const KnownDimension& lookupKnownDimension(const Dimension::Id& id) +{ + validate(); + + int i=0; + while (s_knownDimensions[i].id != Dimension::Id_Undefined) + { + const KnownDimension& kd = s_knownDimensions[i]; + if (kd.id == id) return kd; + ++i; + } + throw pdal_error("Dimension not found"); +} + +static bool hasKnownDimension(const Dimension::Id& id) +{ + int i=0; + while (s_knownDimensions[i].id != Dimension::Id_Undefined) + { + const KnownDimension& kd = s_knownDimensions[i]; + if (kd.id == id) return true; + ++i; + } + return false; +} + +static void validate() +{ + std::map map; + + int i=0; + while (s_knownDimensions[i].id != Dimension::Id_Undefined) + { + assert(map.find(s_knownDimensions[i].id) == map.end()); + map.insert(std::pair(s_knownDimensions[i].id,1) ); + ++i; + } +} + +// -------------------------------------------------------------------------- + +Dimension::Dimension(const Id& id) + : m_dataType(Undefined) + , m_id(id) + , m_name(std::string("")) + , m_flags(0) + , m_endian(pdal::Endian_Little) + , m_byteSize(0) + , m_description(std::string("")) + , m_min(0.0) + , m_max(0.0) + , m_precise(false) + , m_numericScale(0.0) + , m_numericOffset(0.0) +{ + const KnownDimension& kd = lookupKnownDimension(id); + m_dataType = kd.datatype; + m_name = kd.name; + m_description = ""; + + m_byteSize = getDataTypeSize(m_dataType); +} -Dimension::Dimension(Field field, DataType dataType) +Dimension::Dimension(const Id& id, DataType dataType, std::string name) : m_dataType(dataType) - , m_field(field) + , m_id(id) + , m_name(name) + , m_flags(0) , m_endian(pdal::Endian_Little) , m_byteSize(0) , m_description(std::string("")) @@ -61,13 +313,17 @@ Dimension::Dimension(Field field, DataType dataType) , m_numericScale(0.0) , m_numericOffset(0.0) { + assert(!hasKnownDimension(id)); + m_byteSize = getDataTypeSize(m_dataType); } /// copy constructor Dimension::Dimension(Dimension const& other) : m_dataType(other.m_dataType) - , m_field(other.m_field) + , m_id(other.m_id) + , m_name(other.m_name) + , m_flags(other.m_flags) , m_endian(other.m_endian) , m_byteSize(other.m_byteSize) , m_description(other.m_description) @@ -77,6 +333,7 @@ Dimension::Dimension(Dimension const& other) , m_numericScale(other.m_numericScale) , m_numericOffset(other.m_numericOffset) { + return; } /// assignment operator @@ -85,7 +342,9 @@ Dimension& Dimension::operator=(Dimension const& rhs) if (&rhs != this) { m_dataType = rhs.m_dataType; - m_field = rhs.m_field; + m_id = rhs.m_id; + m_name = rhs.m_name; + m_flags = rhs.m_flags; m_endian = rhs.m_endian; m_byteSize = rhs.m_byteSize; m_description = rhs.m_description; @@ -103,7 +362,9 @@ Dimension& Dimension::operator=(Dimension const& rhs) bool Dimension::operator==(const Dimension& other) const { if (m_dataType == other.m_dataType && - m_field == other.m_field && + m_id == other.m_id && + m_name == other.m_name && + m_flags == other.m_flags && m_endian == other.m_endian && m_byteSize == other.m_byteSize && m_description == other.m_description && @@ -145,6 +406,8 @@ std::string Dimension::getDataTypeName(DataType type) return "Int32"; case Uint32: return "Uint32"; + case Pointer: + return "Pointer"; case Int64: return "Int64"; case Uint64: @@ -176,6 +439,8 @@ std::size_t Dimension::getDataTypeSize(DataType type) return 4; case Uint32: return 4; + case Pointer: + return sizeof(void*); case Int64: return 8; case Uint64: @@ -204,6 +469,8 @@ bool Dimension::getDataTypeIsNumeric(DataType type) case Int64: case Uint64: return true; + case Pointer: + return false; case Float: case Double: return true; @@ -228,6 +495,8 @@ bool Dimension::getDataTypeIsSigned(DataType type) case Int32: case Int64: return true; + case Pointer: + return false; case Float: case Double: return true; @@ -253,6 +522,8 @@ bool Dimension::getDataTypeIsInteger(DataType type) case Int32: case Int64: return true; + case Pointer: + return false; case Float: case Double: return false; @@ -274,80 +545,27 @@ Dimension::DataType Dimension::getDataTypeFromString(const std::string& s) if (s == "Uint32") return Uint32; if (s == "Int64") return Int64; if (s == "Uint64") return Uint64; + if (s == "Pointer") return Pointer; if (s == "Float") return Float; if (s == "Double") return Double; throw; } -std::string const& Dimension::getFieldName() const +std::string const& Dimension::getName() const { - return getFieldName(m_field); + return m_name; } -std::string const& Dimension::getFieldName(Field field) -{ - if (!s_fieldNamesValid) - initFieldNames(); - - if (field > Field_LAST) - throw pdal_error("invalid field value (too large)"); - - const std::string& s = s_fieldNames[field]; - if (s.empty()) - { - throw pdal_error("Field name not set for built-in field value"); - } - - return s; -} -void Dimension::initFieldNames() -{ - for (int i=0; i& dims) -{ - for (DimensionsCIter iter = dims.begin(); iter != dims.end(); ++iter) - { - const Dimension& dim = *iter; - addDimension(dim); - } - - return; -} - -void Schema::addDimension(Dimension const& dim) +void Schema::appendDimension(const Dimension& dim) { m_dimensions.push_back(dim); - std::pair p(tpl_t(dim.getField(),dim.getDataType() ), m_dimensions.size()-1); + std::pair p(dim.getId(), m_dimensions.size()-1); m_dimensions_map.insert(p); return; } -void Schema::removeDimension(Dimension const& dim) -{ - m_dimensions.erase( std::remove( m_dimensions.begin(), m_dimensions.end(), dim), - m_dimensions.end()); - - m_dimensions_map.clear(); - DimensionsCIter it = m_dimensions.begin(); - int i(0); - while (it != m_dimensions.end()) - { - std::pair p(tpl_t(it->getField(),it->getDataType() ), i); - - m_dimensions_map.insert(p); - ++it; - ++i; - } - - return; -} - - const Dimension& Schema::getDimension(std::size_t index) const { return m_dimensions[index]; @@ -160,56 +128,31 @@ const Schema::Dimensions& Schema::getDimensions() const return m_dimensions; } -// Schema::Dimensions& Schema::getDimensions() -// { -// return m_dimensions; -// } - -int Schema::getDimensionIndex(Dimension::Field field, Dimension::DataType datatype) const +int Schema::getDimensionIndex(const Dimension::Id& id) const { - - tpl_t t(field,datatype); - - std::map::const_iterator i = m_dimensions_map.find(t); + std::map::const_iterator i = m_dimensions_map.find(id); int m = 0; - if (i == m_dimensions_map.end()) m = -1; + if (i == m_dimensions_map.end()) + m = -1; else m = i->second; - - - // DimensionsCIter it = m_dimensions.begin(); - // int j = 0; - // while (it != m_dimensions.end()) - // { - // if (field == it->getField() && datatype == it->getDataType()) - // { - // break; - // } - // ++it; - // ++j; - // } - - // if (j == m_dimensions.size()) j = -1; - - // std::cout << "i->second: " << m << " j: " << j << " map size: "<< m_dimensions_map.size() << " vec size: " << m_dimensions.size() << std::endl; return m; - } int Schema::getDimensionIndex(const Dimension& dim) const { - return getDimensionIndex(dim.getField(), dim.getDataType()); + return getDimensionIndex(dim.getId()); } -bool Schema::hasDimension(Dimension::Field field, Dimension::DataType datatype) const +bool Schema::hasDimension(const Dimension::Id& field) const { - int t = getDimensionIndex(field, datatype); + int t = getDimensionIndex(field); if (t == -1) return false; return true; @@ -218,7 +161,7 @@ bool Schema::hasDimension(Dimension::Field field, Dimension::DataType datatype) bool Schema::hasDimension(const Dimension& dim) const { - return hasDimension(dim.getField(), dim.getDataType()); + return hasDimension(dim.getId()); } diff --git a/src/XMLSchema.cpp b/src/XMLSchema.cpp index cb08e748a1..a249d2b03e 100644 --- a/src/XMLSchema.cpp +++ b/src/XMLSchema.cpp @@ -521,10 +521,9 @@ void Reader::Load() properties = properties->next; } - Dimension::DataType t = GetDimensionType(interpretation); - Dimension::Field f = GetDimensionField(name, position); + Dimension::Id f = GetDimensionField(name, position); - Dimension d(f, t); + Dimension d(f); if (! Utils::compare_distance(scale, 0.0)) { d.setNumericScale(scale); @@ -560,7 +559,7 @@ void Reader::Load() std::vector::const_iterator i; for (i = layouts.begin(); i!= layouts.end(); ++i) { - m_schema.addDimension(i->getDimension()); + m_schema.appendDimension(i->getDimension()); } } @@ -611,78 +610,75 @@ Dimension::DataType Reader::GetDimensionType(std::string const& interpretation) return Dimension::Undefined; } -Dimension::Field Reader::GetDimensionField(std::string const& name, boost::uint32_t /*position*/) +Dimension::Id Reader::GetDimensionField(std::string const& name, boost::uint32_t /*position*/) { - if (!Utils::compare_no_case(name, "X")) - return Dimension::Field_X; + // BUG: should we be checking for the Double datatype version of X,Y,Z too? + if (!Utils::compare_no_case(name, "X")) + return Dimension::Id_X_i32; if (!Utils::compare_no_case(name, "Y")) - return Dimension::Field_Y; + return Dimension::Id_Y_i32; if (!Utils::compare_no_case(name, "Z")) - return Dimension::Field_Z; + return Dimension::Id_Z_i32; if (!Utils::compare_no_case(name, "Intensity")) - return Dimension::Field_Intensity; + return Dimension::Id_Las_Intensity; if (!Utils::compare_no_case(name, "Return Number") || !Utils::compare_no_case(name, "ReturnNumber")) - return Dimension::Field_ReturnNumber; + return Dimension::Id_Las_ReturnNumber; if (!Utils::compare_no_case(name, "Number of Returns") || !Utils::compare_no_case(name, "NumberOfReturns")) - return Dimension::Field_NumberOfReturns; + return Dimension::Id_Las_NumberOfReturns; if (!Utils::compare_no_case(name, "Number of Returns")) - return Dimension::Field_NumberOfReturns; + return Dimension::Id_Las_NumberOfReturns; if (!Utils::compare_no_case(name, "Scan Direction") || !Utils::compare_no_case(name, "ScanDirectionFlag") || !Utils::compare_no_case(name, "ScanDirection")) - return Dimension::Field_ScanDirectionFlag; + return Dimension::Id_Las_ScanDirectionFlag; if (!Utils::compare_no_case(name, "Flightline Edge") || !Utils::compare_no_case(name, "EdgeOfFlightLine") || !Utils::compare_no_case(name, "FlightlineEdge")) - return Dimension::Field_EdgeOfFlightLine; + return Dimension::Id_Las_EdgeOfFlightLine; if (!Utils::compare_no_case(name, "Classification")) - return Dimension::Field_Classification; + return Dimension::Id_Las_Classification; if (!Utils::compare_no_case(name, "Scan Angle Rank") || !Utils::compare_no_case(name, "ScanAngle") || !Utils::compare_no_case(name, "ScanAngleRank")) - return Dimension::Field_ScanAngleRank; + return Dimension::Id_Las_ScanAngleRank; if (!Utils::compare_no_case(name, "User Data") || !Utils::compare_no_case(name, "UserData")) - return Dimension::Field_UserData; + return Dimension::Id_Las_UserData; if (!Utils::compare_no_case(name, "Point Source ID")|| !Utils::compare_no_case(name, "PointSourceId")) - return Dimension::Field_PointSourceId; + return Dimension::Id_Las_PointSourceId; if (!Utils::compare_no_case(name, "Time")) - return Dimension::Field_Time; + return Dimension::Id_Las_Time; if (!Utils::compare_no_case(name, "Red")) - return Dimension::Field_Red; + return Dimension::Id_Red_u16; if (!Utils::compare_no_case(name, "Green")) - return Dimension::Field_Green; + return Dimension::Id_Green_u16; if (!Utils::compare_no_case(name, "Blue")) - return Dimension::Field_Blue; + return Dimension::Id_Blue_u16; if (!Utils::compare_no_case(name, "Alpha")) - return Dimension::Field_Alpha; - - // Yes, this is scary. What else can we do? The user didn't give us a - // name to map to, so we'll just assume the positions are the same as - // our dimension positions - m_field_position = m_field_position + 1; - return static_cast(m_field_position -1 ); + return Dimension::Id_TerraSolid_Alpha; + // Yes, this is scary. What else can we do? + throw pdal_error("unknown field name: " + name); } Writer::Writer(pdal::Schema const& schema) @@ -757,10 +753,8 @@ void Writer::writeSchema(TextWriterPtr writer) if (description.str().size()) xmlTextWriterWriteElementNS(w, BAD_CAST "pc", BAD_CAST "description", NULL, BAD_CAST description.str().c_str()); - pdal::Dimension::Field f = dim.getField(); - std::ostringstream name; - name << dim.getFieldName(f); + name << dim.getName(); if (name.str().size()) xmlTextWriterWriteElementNS(w, BAD_CAST "pc", BAD_CAST "name", NULL, BAD_CAST name.str().c_str()); diff --git a/src/drivers/faux/Reader.cpp b/src/drivers/faux/Reader.cpp index 31a84ee5c9..9654cd0395 100644 --- a/src/drivers/faux/Reader.cpp +++ b/src/drivers/faux/Reader.cpp @@ -91,22 +91,35 @@ void Reader::initialize() { pdal::Reader::initialize(); + Schema& schema = getSchemaRef(); + if (m_dimensions.size() == 0) { // these are the default dimensions we use - const Dimension dimx(Dimension::Field_X, Dimension::Double); - const Dimension dimy(Dimension::Field_Y, Dimension::Double); - const Dimension dimz(Dimension::Field_Z, Dimension::Double); - const Dimension dimt(Dimension::Field_Time, Dimension::Uint64); - - m_dimensions.push_back(dimx); - m_dimensions.push_back(dimy); - m_dimensions.push_back(dimz); - m_dimensions.push_back(dimt); - } + Dimension dimx(Dimension::Id_X_f64); + dimx.setFlags(Dimension::IsAdded & Dimension::IsWritten); + schema.appendDimension(dimx); - Schema& schema = getSchemaRef(); - schema.addDimensions(m_dimensions); + Dimension dimy(Dimension::Id_Y_f64); + dimy.setFlags(Dimension::IsAdded & Dimension::IsWritten); + schema.appendDimension(dimy); + + Dimension dimz(Dimension::Id_Z_f64); + dimz.setFlags(Dimension::IsAdded & Dimension::IsWritten); + schema.appendDimension(dimz); + + Dimension dimt(Dimension::Id_Time_u64); + dimt.setFlags(Dimension::IsAdded & Dimension::IsWritten); + schema.appendDimension(dimt); + } + else + { + for (boost::uint32_t i=0; i ids = block.GetIDs(); - bool hasTimeData = schema.hasDimension(Dimension::Field_Time, Dimension::Double); - bool hasColorData = schema.hasDimension(Dimension::Field_Red, Dimension::Uint16); + bool hasTimeData = schema.hasDimension(Dimension::Id_Las_Time); + bool hasColorData = schema.hasDimension(Dimension::Id_Red_u16); boost::uint64_t count = buffer.getNumPoints(); @@ -884,22 +884,22 @@ bool Writer::FillOraclePointBuffer(PointBuffer const& buffer, // assert(count*oracle_record_size == point_data.size()); - const int indexX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - const int indexY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - const int indexZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); - const int indexClassification = schema.getDimensionIndex(Dimension::Field_Classification, Dimension::Uint8); - const int indexTime = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Double); - const int indexIntensity = schema.getDimensionIndex(Dimension::Field_Intensity, Dimension::Uint16); - const int indexReturnNumber = schema.getDimensionIndex(Dimension::Field_ReturnNumber, Dimension::Uint8); - const int indexNumberOfReturns = schema.getDimensionIndex(Dimension::Field_NumberOfReturns, Dimension::Uint8); - const int indexScanDirectionFlag = schema.getDimensionIndex(Dimension::Field_ScanDirectionFlag, Dimension::Uint8); - const int indexEdgeOfFlightLine = schema.getDimensionIndex(Dimension::Field_EdgeOfFlightLine, Dimension::Uint8); - const int indexUserData = schema.getDimensionIndex(Dimension::Field_UserData, Dimension::Uint8); - const int indexPointSourceId = schema.getDimensionIndex(Dimension::Field_PointSourceId, Dimension::Uint16); - const int indexScanAngleRank = schema.getDimensionIndex(Dimension::Field_ScanAngleRank, Dimension::Int8); - const int indexRed = schema.getDimensionIndex(Dimension::Field_Red, Dimension::Uint16); - const int indexGreen = schema.getDimensionIndex(Dimension::Field_Green, Dimension::Uint16); - const int indexBlue = schema.getDimensionIndex(Dimension::Field_Blue, Dimension::Uint16); + const int indexX = schema.getDimensionIndex(Dimension::Id_X_i32); + const int indexY = schema.getDimensionIndex(Dimension::Id_Y_i32); + const int indexZ = schema.getDimensionIndex(Dimension::Id_Z_i32); + const int indexClassification = schema.getDimensionIndex(Dimension::Id_Las_Classification); + const int indexTime = schema.getDimensionIndex(Dimension::Id_Las_Time); + const int indexIntensity = schema.getDimensionIndex(Dimension::Id_Las_Intensity); + const int indexReturnNumber = schema.getDimensionIndex(Dimension::Id_Las_ReturnNumber); + const int indexNumberOfReturns = schema.getDimensionIndex(Dimension::Id_Las_NumberOfReturns); + const int indexScanDirectionFlag = schema.getDimensionIndex(Dimension::Id_Las_ScanDirectionFlag); + const int indexEdgeOfFlightLine = schema.getDimensionIndex(Dimension::Id_Las_EdgeOfFlightLine); + const int indexUserData = schema.getDimensionIndex(Dimension::Id_Las_UserData); + const int indexPointSourceId = schema.getDimensionIndex(Dimension::Id_Las_PointSourceId); + const int indexScanAngleRank = schema.getDimensionIndex(Dimension::Id_Las_ScanAngleRank); + const int indexRed = schema.getDimensionIndex(Dimension::Id_Red_u16); + const int indexGreen = schema.getDimensionIndex(Dimension::Id_Green_u16); + const int indexBlue = schema.getDimensionIndex(Dimension::Id_Blue_u16); @@ -908,8 +908,8 @@ bool Writer::FillOraclePointBuffer(PointBuffer const& buffer, // "Global" ids from the chipper are also available here. - // const int indexId = schema.getDimensionIndex(Dimension::Field_User1, Dimension::Int32); - const int indexBlockId = schema.getDimensionIndex(Dimension::Field_User2, Dimension::Int32); + // const int indexId = schema.getDimensionIndex(Dimension::Id_Chipper_1); + const int indexBlockId = schema.getDimensionIndex(Dimension::Id_Chipper_2); Dimension const& dimX = schema.getDimension(indexX); Dimension const& dimY = schema.getDimension(indexY); @@ -1112,9 +1112,9 @@ pdal::Bounds Writer::CalculateBounds(PointBuffer const& buffer) pdal::Bounds output; pdal::Schema const& schema = buffer.getSchemaLayout().getSchema(); - const int indexXi = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - const int indexYi = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - const int indexZi = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); + const int indexXi = schema.getDimensionIndex(Dimension::Id_X_i32); + const int indexYi = schema.getDimensionIndex(Dimension::Id_Y_i32); + const int indexZi = schema.getDimensionIndex(Dimension::Id_Z_i32); const Dimension& dimXi = schema.getDimension(indexXi); const Dimension& dimYi = schema.getDimension(indexYi); @@ -1162,7 +1162,7 @@ bool Writer::WriteBlock(PointBuffer const& buffer) // Pluck the block id out of the first point in the buffer pdal::Schema const& schema = buffer.getSchema(); - const int indexBlockId = schema.getDimensionIndex(Dimension::Field_User2, Dimension::Int32); + const int indexBlockId = schema.getDimensionIndex(Dimension::Id_Chipper_2); boost::int32_t block_id = buffer.getField(0, indexBlockId); // SWAP_ENDIANNESS(block_id); //We've already swapped these data, but we need to write a real number here. diff --git a/src/drivers/qfit/Reader.cpp b/src/drivers/qfit/Reader.cpp index ddc56952c0..3d60420ca4 100644 --- a/src/drivers/qfit/Reader.cpp +++ b/src/drivers/qfit/Reader.cpp @@ -182,34 +182,34 @@ namespace pdal { namespace drivers { namespace qfit { PointIndexes::PointIndexes(const Schema& schema, QFIT_Format_Type format) { - Time = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Int32); - X = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - Y = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - Z = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); + Time = schema.getDimensionIndex(Dimension::Id_Qfit_Time); + X = schema.getDimensionIndex(Dimension::Id_X_i32); + Y = schema.getDimensionIndex(Dimension::Id_Y_i32); + Z = schema.getDimensionIndex(Dimension::Id_Z_i32); - StartPulse = schema.getDimensionIndex(Dimension::Field_User1, Dimension::Int32); - ReflectedPulse = schema.getDimensionIndex(Dimension::Field_User2, Dimension::Int32); - ScanAngleRank = schema.getDimensionIndex(Dimension::Field_User3, Dimension::Int32); - Pitch = schema.getDimensionIndex(Dimension::Field_User4, Dimension::Int32); - Roll = schema.getDimensionIndex(Dimension::Field_User5, Dimension::Int32); + StartPulse = schema.getDimensionIndex(Dimension::Id_Qfit_StartPulse); + ReflectedPulse = schema.getDimensionIndex(Dimension::Id_Qfit_ReflectedPulse); + ScanAngleRank = schema.getDimensionIndex(Dimension::Id_Qfit_ScanAngleRank); + Pitch = schema.getDimensionIndex(Dimension::Id_Qfit_Pitch); + Roll = schema.getDimensionIndex(Dimension::Id_Qfit_Roll); if (format == QFIT_Format_14) { - PassiveSignal = schema.getDimensionIndex(Dimension::Field_User6, Dimension::Int32); - PassiveX = schema.getDimensionIndex(Dimension::Field_User7, Dimension::Int32); - PassiveY = schema.getDimensionIndex(Dimension::Field_User8, Dimension::Int32); - PassiveZ = schema.getDimensionIndex(Dimension::Field_User9, Dimension::Int32); - GPSTime = schema.getDimensionIndex(Dimension::Field_User10, Dimension::Int32); + PassiveSignal = schema.getDimensionIndex(Dimension::Id_Qfit_PassiveSignal); + PassiveX = schema.getDimensionIndex(Dimension::Id_Qfit_PassiveX); + PassiveY = schema.getDimensionIndex(Dimension::Id_Qfit_PassiveY); + PassiveZ = schema.getDimensionIndex(Dimension::Id_Qfit_PassiveZ); + GPSTime = schema.getDimensionIndex(Dimension::Id_Qfit_GpsTime); } else if (format == QFIT_Format_12) { - PDOP = schema.getDimensionIndex(Dimension::Field_User6, Dimension::Int32); - PulseWidth = schema.getDimensionIndex(Dimension::Field_User7, Dimension::Int32); - GPSTime = schema.getDimensionIndex(Dimension::Field_User8, Dimension::Int32); + PDOP = schema.getDimensionIndex(Dimension::Id_Qfit_PDOP); + PulseWidth = schema.getDimensionIndex(Dimension::Id_Qfit_PulseWidth); + GPSTime = schema.getDimensionIndex(Dimension::Id_Qfit_GpsTime); } else { - GPSTime = schema.getDimensionIndex(Dimension::Field_User6, Dimension::Int32); + GPSTime = schema.getDimensionIndex(Dimension::Id_Qfit_GpsTime); } @@ -324,138 +324,75 @@ void Reader::registerFields() double xy_scale = 1/1000000.0; - std::ostringstream text; + Dimension time(Dimension::Id_Qfit_Time); + schema.appendDimension(time); - Dimension time(Dimension::Field_Time, Dimension::Int32); - text << "Relative Time (msec from start of data file)"; - time.setDescription(text.str()); - schema.addDimension(time); - text.str(""); - - Dimension y(Dimension::Field_Y, Dimension::Int32); - text << "Latitude coordinate with 1/1000000 decimals of precision"; - y.setDescription(text.str()); + Dimension y(Dimension::Id_Y_i32); y.setNumericScale(xy_scale); - schema.addDimension(y); - text.str(""); - + schema.appendDimension(y); - Dimension x(Dimension::Field_X, Dimension::Int32); - text << "Longitude coordinate with 1/1000000 decimals of precision"; - x.setDescription(text.str()); + Dimension x(Dimension::Id_X_i32); x.setNumericScale(xy_scale); - schema.addDimension(x); - text.str(""); - - Dimension z(Dimension::Field_Z, Dimension::Int32); - text << "z coordinate as a long integer. You must use the scale and " - << "offset information of the header to determine the double value."; - z.setDescription(text.str()); - schema.addDimension(z); - text.str(""); - + schema.appendDimension(x); - Dimension start_pulse(Dimension::Field_User1, Dimension::Int32); - text << "Start Pulse Signal Strength (relative)"; - start_pulse.setDescription(text.str()); - schema.addDimension(start_pulse); - text.str(""); + Dimension z(Dimension::Id_Z_i32); + schema.appendDimension(z); - Dimension reflected_pulse(Dimension::Field_User2, Dimension::Int32); - text << "Reflected Laser Signal Strength (relative)"; - reflected_pulse.setDescription(text.str()); - schema.addDimension(reflected_pulse); - text.str(""); + Dimension start_pulse(Dimension::Id_Qfit_StartPulse); + schema.appendDimension(start_pulse); + Dimension reflected_pulse(Dimension::Id_Qfit_ReflectedPulse); + schema.appendDimension(reflected_pulse); - Dimension scan_angle(Dimension::Field_User3, Dimension::Int32); - text << "Scan Azimuth (degrees X 1,000)"; - scan_angle.setDescription(text.str()); + Dimension scan_angle(Dimension::Id_Qfit_ScanAngleRank); scan_angle.setNumericScale(1.0/1000.0); - schema.addDimension(scan_angle); - text.str(""); + schema.appendDimension(scan_angle); - Dimension pitch(Dimension::Field_User4, Dimension::Int32); - text << "Pitch (degrees X 1,000)"; - pitch.setDescription(text.str()); + Dimension pitch(Dimension::Id_Qfit_Pitch); pitch.setNumericScale(1.0/1000.0); - schema.addDimension(pitch); - text.str(""); + schema.appendDimension(pitch); - Dimension roll(Dimension::Field_User5, Dimension::Int32); - text << "Roll (degrees X 1,000)"; - roll.setDescription(text.str()); + Dimension roll(Dimension::Id_Qfit_Roll); roll.setNumericScale(1.0/1000.0); - schema.addDimension(roll); - text.str(""); + schema.appendDimension(roll); if (m_format == QFIT_Format_12) { - Dimension pdop(Dimension::Field_User6, Dimension::Int32); - text << "GPS PDOP (dilution of precision) (X 10) "; - pdop.setDescription(text.str()); + Dimension pdop(Dimension::Id_Qfit_PDOP); pdop.setNumericScale(1.0/10.0); - schema.addDimension(pdop); - text.str(""); - - Dimension pulse_width(Dimension::Field_User7, Dimension::Int32); - text << "Laser received pulse width (digitizer samples)"; - pulse_width.setDescription(text.str()); - schema.addDimension(pulse_width); - text.str(""); - - Dimension gpstime(Dimension::Field_User8, Dimension::Int32); - text << "GPS Time packed (example: 153320100 = 15h 33m 20s 100ms)"; - gpstime.setDescription(text.str()); - schema.addDimension(gpstime); - text.str(""); + schema.appendDimension(pdop); + + Dimension pulse_width(Dimension::Id_Qfit_PulseWidth); + schema.appendDimension(pulse_width); + + Dimension gpstime(Dimension::Id_Qfit_GpsTime); + schema.appendDimension(gpstime); - } else if (m_format == QFIT_Format_14) + } + else if (m_format == QFIT_Format_14) { + Dimension passive_signal(Dimension::Id_Qfit_PassiveSignal); + schema.appendDimension(passive_signal); - Dimension passive_signal(Dimension::Field_User6, Dimension::Int32); - text << "Passive Signal (relative)"; - passive_signal.setDescription(text.str()); - schema.addDimension(passive_signal); - text.str(""); - - Dimension passive_y(Dimension::Field_User7, Dimension::Int32); - text << "Passive Footprint Latitude (degrees X 1,000,000)"; - passive_y.setDescription(text.str()); + Dimension passive_y(Dimension::Id_Qfit_PassiveY); passive_y.setNumericScale(xy_scale); - schema.addDimension(passive_y); - text.str(""); + schema.appendDimension(passive_y); - Dimension passive_x(Dimension::Field_User8, Dimension::Int32); - text << "Passive Footprint Longitude (degrees X 1,000,000)"; - passive_x.setDescription(text.str()); + Dimension passive_x(Dimension::Id_Qfit_PassiveX); passive_x.setNumericScale(xy_scale); - schema.addDimension(passive_x); - text.str(""); - - Dimension passive_z(Dimension::Field_User9, Dimension::Int32); - text << "Passive Footprint Synthesized Elevation (millimeters)"; - passive_z.setDescription(text.str()); - schema.addDimension(passive_z); - text.str(""); - - Dimension gpstime(Dimension::Field_User10, Dimension::Int32); - text << "GPS Time packed (example: 153320100 = 15h 33m 20s 100ms)"; - gpstime.setDescription(text.str()); - schema.addDimension(gpstime); - text.str(""); - - } else - { - Dimension gpstime(Dimension::Field_User6, Dimension::Int32); - text << "GPS Time packed (example: 153320100 = 15h 33m 20s 100ms)"; - gpstime.setDescription(text.str()); - schema.addDimension(gpstime); - text.str(""); - - } + schema.appendDimension(passive_x); + Dimension passive_z(Dimension::Id_Qfit_PassiveZ); + schema.appendDimension(passive_z); + Dimension gpstime(Dimension::Id_Qfit_GpsTime); + schema.appendDimension(gpstime); + } + else + { + Dimension gpstime(Dimension::Id_Qfit_GpsTime); + schema.appendDimension(gpstime); + } return; } diff --git a/src/drivers/terrasolid/Reader.cpp b/src/drivers/terrasolid/Reader.cpp index ba6e827b46..55217f94ee 100644 --- a/src/drivers/terrasolid/Reader.cpp +++ b/src/drivers/terrasolid/Reader.cpp @@ -45,39 +45,35 @@ namespace pdal { namespace drivers { namespace terrasolid { PointIndexes::PointIndexes(const Schema& schema, TERRASOLID_Format_Type format) { - if (format == TERRASOLID_Format_1) { - Classification = schema.getDimensionIndex(Dimension::Field_Classification, Dimension::Uint8); - PointSourceId = schema.getDimensionIndex(Dimension::Field_PointSourceId, Dimension::Uint8); - EchoInt = schema.getDimensionIndex(Dimension::Field_ReturnNumber, Dimension::Uint16); - X = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - Y = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - Z = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); - - } else if (format == TERRASOLID_Format_2) + Classification = schema.getDimensionIndex(Dimension::Id_TerraSolid_Classification); + PointSourceId = schema.getDimensionIndex(Dimension::Id_TerraSolid_PointSourceId_u8); + EchoInt = schema.getDimensionIndex(Dimension::Id_TerraSolid_ReturnNumber_u16); + X = schema.getDimensionIndex(Dimension::Id_X_i32); + Y = schema.getDimensionIndex(Dimension::Id_Y_i32); + Z = schema.getDimensionIndex(Dimension::Id_Z_i32); + } + else if (format == TERRASOLID_Format_2) { - X = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - Y = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - Z = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); - Classification = schema.getDimensionIndex(Dimension::Field_Classification, Dimension::Uint8); - ReturnNumber = schema.getDimensionIndex(Dimension::Field_ReturnNumber, Dimension::Uint8); - Flag = schema.getDimensionIndex(Dimension::Field_User1, Dimension::Uint8); - Mark = schema.getDimensionIndex(Dimension::Field_User2, Dimension::Uint8); - PointSourceId = schema.getDimensionIndex(Dimension::Field_PointSourceId, Dimension::Uint16); - Intensity = schema.getDimensionIndex(Dimension::Field_Intensity, Dimension::Uint16); - + X = schema.getDimensionIndex(Dimension::Id_X_i32); + Y = schema.getDimensionIndex(Dimension::Id_Y_i32); + Z = schema.getDimensionIndex(Dimension::Id_Z_i32); + Classification = schema.getDimensionIndex(Dimension::Id_TerraSolid_Classification); + ReturnNumber = schema.getDimensionIndex(Dimension::Id_TerraSolid_ReturnNumber_u8); + Flag = schema.getDimensionIndex(Dimension::Id_TerraSolid_Flag); + Mark = schema.getDimensionIndex(Dimension::Id_TerraSolid_Mark); + PointSourceId = schema.getDimensionIndex(Dimension::Id_TerraSolid_PointSourceId_u16); + Intensity = schema.getDimensionIndex(Dimension::Id_TerraSolid_Intensity); } - Time = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint32); + Time = schema.getDimensionIndex(Dimension::Id_TerraSolid_Time); - Red = schema.getDimensionIndex(Dimension::Field_Red, Dimension::Uint8); - Green = schema.getDimensionIndex(Dimension::Field_Green, Dimension::Uint8); - Blue = schema.getDimensionIndex(Dimension::Field_Blue, Dimension::Uint8); - Alpha = schema.getDimensionIndex(Dimension::Field_Alpha, Dimension::Uint8); + Red = schema.getDimensionIndex(Dimension::Id_Red_u8); + Green = schema.getDimensionIndex(Dimension::Id_Green_u8); + Blue = schema.getDimensionIndex(Dimension::Id_Blue_u8); + Alpha = schema.getDimensionIndex(Dimension::Id_TerraSolid_Alpha); - - return; } @@ -178,158 +174,90 @@ void Reader::registerFields() double xyz_scale = 1/static_cast(m_header->Units); - std::ostringstream text; - if (m_format == TERRASOLID_Format_1) { - Dimension classification(Dimension::Field_Classification, Dimension::Uint8); - text << "Classification code 0-255"; - classification.setDescription(text.str()); - schema.addDimension(classification); - text.str(""); - - Dimension flight_line(Dimension::Field_PointSourceId, Dimension::Uint8); - text << "Flightline number 0-255"; - flight_line.setDescription(text.str()); - schema.addDimension(flight_line); - text.str(""); - - Dimension echoint(Dimension::Field_User1, Dimension::Uint16); - text << "Intensity bits 0-13, echo bits 14-15"; - echoint.setDescription(text.str()); - schema.addDimension(echoint); - text.str(""); - - Dimension x(Dimension::Field_X, Dimension::Int32); - text << "Easting"; - x.setDescription(text.str()); + Dimension classification(Dimension::Id_TerraSolid_Classification); + schema.appendDimension(classification); + + Dimension flight_line(Dimension::Id_TerraSolid_PointSourceId_u8); + schema.appendDimension(flight_line); + + Dimension echoint(Dimension::Id_TerraSolid_Intensity); + schema.appendDimension(echoint); + + Dimension x(Dimension::Id_X_i32); x.setNumericScale(xyz_scale); x.setNumericOffset(m_header->OrgX); - schema.addDimension(x); - text.str(""); + schema.appendDimension(x); - Dimension y(Dimension::Field_Y, Dimension::Int32); - text << "Northing"; - y.setDescription(text.str()); + Dimension y(Dimension::Id_Y_i32); y.setNumericScale(xyz_scale); y.setNumericOffset(m_header->OrgY); - schema.addDimension(y); - text.str(""); + schema.appendDimension(y); - Dimension z(Dimension::Field_Z, Dimension::Int32); - text << "Elevation"; - z.setDescription(text.str()); + Dimension z(Dimension::Id_Z_i32); z.setNumericScale(xyz_scale); z.setNumericOffset(m_header->OrgZ); - schema.addDimension(z); - text.str(""); - + schema.appendDimension(z); } if (m_format == TERRASOLID_Format_2) { - Dimension x(Dimension::Field_X, Dimension::Int32); - text << "Easting"; - x.setDescription(text.str()); + Dimension x(Dimension::Id_X_i32); x.setNumericScale(xyz_scale); x.setNumericOffset(m_header->OrgX); - schema.addDimension(x); - text.str(""); + schema.appendDimension(x); - Dimension y(Dimension::Field_Y, Dimension::Int32); - text << "Northing"; - y.setDescription(text.str()); + Dimension y(Dimension::Id_Y_i32); y.setNumericScale(xyz_scale); y.setNumericOffset(m_header->OrgY); - schema.addDimension(y); - text.str(""); + schema.appendDimension(y); - Dimension z(Dimension::Field_Z, Dimension::Int32); - text << "Elevation"; - z.setDescription(text.str()); + Dimension z(Dimension::Id_Z_i32); z.setNumericScale(xyz_scale); z.setNumericOffset(m_header->OrgZ); - schema.addDimension(z); - text.str(""); - - Dimension classification(Dimension::Field_Classification, Dimension::Uint8); - text << "Classification code 0-255"; - classification.setDescription(text.str()); - schema.addDimension(classification); - text.str(""); - - Dimension return_no(Dimension::Field_ReturnNumber, Dimension::Uint8); - text << "Echo/Return Number. 0 - Only echo. 1 - First of many echo. 2 - Intermediate echo. 3 - Last of many echo."; - return_no.setDescription(text.str()); - schema.addDimension(return_no); - text.str(""); - - Dimension flag(Dimension::Field_User1, Dimension::Uint8); - text << "Runtime flag (view visibility)"; - flag.setDescription(text.str()); - schema.addDimension(flag); - text.str(""); - - Dimension mark(Dimension::Field_User2, Dimension::Uint8); - text << "Runtime flag"; - mark.setDescription(text.str()); - schema.addDimension(mark); - text.str(""); - - Dimension flight_line(Dimension::Field_PointSourceId, Dimension::Uint16); - text << "Flightline number 0-255"; - flight_line.setDescription(text.str()); - schema.addDimension(flight_line); - text.str(""); - - Dimension intensity(Dimension::Field_Intensity, Dimension::Uint16); - text << "The intensity value is the integer representation of the pulse " - "return magnitude. This value is optional and system specific. " - "However, it should always be included if available."; - intensity.setDescription(text.str()); - schema.addDimension(intensity); - text.str(""); - + schema.appendDimension(z); + + Dimension classification(Dimension::Id_TerraSolid_Classification); + schema.appendDimension(classification); + + Dimension return_no(Dimension::Id_TerraSolid_ReturnNumber_u8); + schema.appendDimension(return_no); + + Dimension flag(Dimension::Id_TerraSolid_Flag); + schema.appendDimension(flag); + + Dimension mark(Dimension::Id_TerraSolid_Mark); + schema.appendDimension(mark); + + Dimension flight_line(Dimension::Id_TerraSolid_PointSourceId_u16); + schema.appendDimension(flight_line); + + Dimension intensity(Dimension::Id_TerraSolid_Intensity); + schema.appendDimension(intensity); } - if (m_haveTime) { - Dimension time(Dimension::Field_Time, Dimension::Uint32); - text << "32 bit integer time stamps. Time stamps are assumed to be GPS week seconds. The storage format is a 32 bit unsigned integer where each integer step is 0.0002 seconds."; - time.setDescription(text.str()); + Dimension time(Dimension::Id_TerraSolid_Time); time.setNumericScale(0.0002); time.setNumericOffset(0.0); - schema.addDimension(time); - text.str(""); + schema.appendDimension(time); } if (m_haveColor) { - Dimension red(Dimension::Field_Red, Dimension::Uint8); - text << "The red image channel value associated with this point"; - red.setDescription(text.str()); - schema.addDimension(red); - text.str(""); - - Dimension green(Dimension::Field_Green, Dimension::Uint8); - text << "The green image channel value associated with this point"; - green.setDescription(text.str()); - schema.addDimension(green); - text.str(""); - - Dimension blue(Dimension::Field_Blue, Dimension::Uint8); - text << "The blue image channel value associated with this point"; - blue.setDescription(text.str()); - schema.addDimension(blue); - text.str(""); - - Dimension alpha(Dimension::Field_Alpha, Dimension::Uint8); - text << "The alpha image channel value associated with this point"; - alpha.setDescription(text.str()); - schema.addDimension(alpha); - text.str(""); + Dimension red(Dimension::Id_Red_u8); + schema.appendDimension(red); + + Dimension green(Dimension::Id_Green_u8); + schema.appendDimension(green); + + Dimension blue(Dimension::Id_Blue_u8); + schema.appendDimension(blue); + Dimension alpha(Dimension::Id_TerraSolid_Alpha); + schema.appendDimension(alpha); } return; diff --git a/src/filters/ByteSwapFilter.cpp b/src/filters/ByteSwapFilter.cpp index fde2673b66..44984fc590 100644 --- a/src/filters/ByteSwapFilter.cpp +++ b/src/filters/ByteSwapFilter.cpp @@ -141,9 +141,9 @@ boost::uint32_t ByteSwapFilter::processBuffer(PointBuffer& dstData, const PointB // - // int fieldX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - // int fieldY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - // int fieldZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); + // int fieldX = schema.getDimensionIndex(Dimension_X, Dimension::Double); + // int fieldY = schema.getDimensionIndex(Dimension_Y, Dimension::Double); + // int fieldZ = schema.getDimensionIndex(Dimension_Z, Dimension::Double); // // const Bounds& bounds = this->getBounds(); // diff --git a/src/filters/Chipper.cpp b/src/filters/Chipper.cpp index a66dfb9d81..7bfb002f5b 100644 --- a/src/filters/Chipper.cpp +++ b/src/filters/Chipper.cpp @@ -110,8 +110,8 @@ void Block::GetBuffer( Stage const& stage, PointBuffer& buffer, boost::uint32_t std::vector::const_iterator it; boost::uint32_t count = 0; - // const int indexId = schema.getDimensionIndex(Dimension::Field_User1, Dimension::Int32); - // const int indexBlockId = schema.getDimensionIndex(Dimension::Field_User2, Dimension::Int32); + // const int indexId = schema.getDimensionIndex(Dimension_User1, Dimension::Int32); + // const int indexBlockId = schema.getDimensionIndex(Dimension_User2, Dimension::Int32); boost::uint8_t* p_block_id = reinterpret_cast(&block_id); for (it = ids.begin(); it != ids.end(); it++) @@ -194,8 +194,8 @@ void Chipper::Load(RefList& xvec, RefList& yvec, RefList& spare ) - const int indexX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - const int indexY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); + const int indexX = schema.getDimensionIndex(Dimension::Id_X_i32); + const int indexY = schema.getDimensionIndex(Dimension::Id_Y_i32); Dimension const& dimX = schema.getDimension(indexX); Dimension const& dimY = schema.getDimension(indexY); @@ -488,16 +488,16 @@ void Chipper::checkImpedance() Schema& schema = getSchemaRef(); - Dimension pointID(Dimension::Field_User1, Dimension::Int32); - Dimension blockID(Dimension::Field_User2, Dimension::Int32); + Dimension pointID(Dimension::Id_Chipper_1); + Dimension blockID(Dimension::Id_Chipper_2); if (!schema.hasDimension(pointID)) { - schema.addDimension(pointID); + schema.appendDimension(pointID); } if (!schema.hasDimension(blockID)) { - schema.addDimension(blockID); + schema.appendDimension(blockID); } return; diff --git a/src/filters/ChipperIterator.cpp b/src/filters/ChipperIterator.cpp index f721485703..7c2701da01 100644 --- a/src/filters/ChipperIterator.cpp +++ b/src/filters/ChipperIterator.cpp @@ -74,8 +74,8 @@ boost::uint32_t ChipperSequentialIterator::readBufferImpl(PointBuffer& buffer) } Schema const& schema = buffer.getSchemaLayout().getSchema(); - const int indexId = schema.getDimensionIndex(Dimension::Field_User1, Dimension::Int32); - const int indexBlockId = schema.getDimensionIndex(Dimension::Field_User2, Dimension::Int32); + const int indexId = schema.getDimensionIndex(Dimension::Id_Chipper_1); + const int indexBlockId = schema.getDimensionIndex(Dimension::Id_Chipper_2); block.GetBuffer(m_chipper.getPrevStage(), buffer, m_currentBlockId, indexId, indexBlockId); buffer.setSpatialBounds(block.GetBounds()); diff --git a/src/filters/ColorFilter.cpp b/src/filters/ColorFilter.cpp index 9b21fe7840..7de94920f0 100644 --- a/src/filters/ColorFilter.cpp +++ b/src/filters/ColorFilter.cpp @@ -75,28 +75,28 @@ void ColorFilter::checkImpedance() { Schema& schema = getSchemaRef(); - Dimension dimZ(Dimension::Field_Z, Dimension::Int32); + Dimension dimZ(Dimension::Id_Z_i32); if (schema.hasDimension(dimZ) == false) { throw impedance_invalid("color filter does not have Z/Int32 field"); } - Dimension dimRed(Dimension::Field_Red, Dimension::Uint16); - Dimension dimGreen(Dimension::Field_Green, Dimension::Uint16); - Dimension dimBlue(Dimension::Field_Blue, Dimension::Uint16); + Dimension dimRed(Dimension::Id_Red_u16); + Dimension dimGreen(Dimension::Id_Green_u16); + Dimension dimBlue(Dimension::Id_Blue_u16); // are there already u16 fields for color? if (!schema.hasDimension(dimRed)) { - schema.addDimension(dimRed); + schema.appendDimension(dimRed); } if (!schema.hasDimension(dimGreen)) { - schema.addDimension(dimGreen); + schema.appendDimension(dimGreen); } if (!schema.hasDimension(dimBlue)) { - schema.addDimension(dimBlue); + schema.appendDimension(dimBlue); } return; @@ -110,10 +110,10 @@ void ColorFilter::processBuffer(PointBuffer& data) const const SchemaLayout& schemaLayout = data.getSchemaLayout(); const Schema& schema = schemaLayout.getSchema(); - const int indexR = schema.getDimensionIndex(Dimension::Field_Red, Dimension::Uint16); - const int indexG = schema.getDimensionIndex(Dimension::Field_Green, Dimension::Uint16); - const int indexB = schema.getDimensionIndex(Dimension::Field_Blue, Dimension::Uint16); - const int indexZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); + const int indexR = schema.getDimensionIndex(Dimension::Id_Red_u16); + const int indexG = schema.getDimensionIndex(Dimension::Id_Green_u16); + const int indexB = schema.getDimensionIndex(Dimension::Id_Blue_u16); + const int indexZ = schema.getDimensionIndex(Dimension::Id_Z_i32); const Dimension& zDim = schema.getDimension(indexZ); for (boost::uint32_t pointIndex=0; pointIndex& bounds = this->getBounds(); diff --git a/src/filters/ReprojectionFilter.cpp b/src/filters/ReprojectionFilter.cpp index 529019e4f7..b7883c2796 100644 --- a/src/filters/ReprojectionFilter.cpp +++ b/src/filters/ReprojectionFilter.cpp @@ -218,9 +218,9 @@ void ReprojectionFilter::checkImpedance() { const Schema& schema = this->getSchema(); - if (!schema.hasDimension(Dimension::Field_X, Dimension::Double) || - !schema.hasDimension(Dimension::Field_Y, Dimension::Double) || - !schema.hasDimension(Dimension::Field_Z, Dimension::Double)) + if (!schema.hasDimension(Dimension::Id_X_f64) || + !schema.hasDimension(Dimension::Id_Y_f64) || + !schema.hasDimension(Dimension::Id_Z_f64)) { throw impedance_invalid("Reprojection filter requires X,Y,Z dimensions as doubles"); } @@ -259,9 +259,9 @@ void ReprojectionFilter::processBuffer(PointBuffer& data) const const SchemaLayout& schemaLayout = data.getSchemaLayout(); const Schema& schema = schemaLayout.getSchema(); - const int indexX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - const int indexY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - const int indexZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); + const int indexX = schema.getDimensionIndex(Dimension::Id_X_f64); + const int indexY = schema.getDimensionIndex(Dimension::Id_Y_f64); + const int indexZ = schema.getDimensionIndex(Dimension::Id_Z_f64); for (boost::uint32_t pointIndex=0; pointIndex ints - const int indexXd = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - const int indexYd = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - const int indexZd = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); - - const Dimension dimXd = schema.getDimension(indexXd); - const Dimension dimYd = schema.getDimension(indexYd); - const Dimension dimZd = schema.getDimension(indexZd); - - Dimension dimXi(Dimension::Field_X, Dimension::Int32); - Dimension dimYi(Dimension::Field_Y, Dimension::Int32); - Dimension dimZi(Dimension::Field_Z, Dimension::Int32); - - if (!schema.hasDimension(dimXd) || !schema.hasDimension(dimYd) || !schema.hasDimension(dimZd)) + // verify we have the doubles we need, and add the ints if we have to + if (!schema.hasDimension(Dimension::Id_X_f64) || !schema.hasDimension(Dimension::Id_Y_f64) || !schema.hasDimension(Dimension::Id_X_f64)) { throw impedance_invalid("Descaling filter requires X,Y,Z dimensions as doubles"); } - if (schema.hasDimension(dimXi) || schema.hasDimension(dimYi) || schema.hasDimension(dimZi)) + if (!schema.hasDimension(Dimension::Id_X_i32)) + { + schema.appendDimension(Dimension::Id_X_i32); + } + if (!schema.hasDimension(Dimension::Id_Y_i32)) + { + schema.appendDimension(Dimension::Id_Y_i32); + } + if (!schema.hasDimension(Dimension::Id_Z_i32)) { - throw impedance_invalid("Descaling filter requires X,Y,Z dimensions as ints not be initially present"); + schema.appendDimension(Dimension::Id_Z_i32); } - schema.removeDimension(dimXd); - schema.removeDimension(dimYd); - schema.removeDimension(dimZd); + const int indexXd = schema.getDimensionIndex(Dimension::Id_X_f64); + const int indexYd = schema.getDimensionIndex(Dimension::Id_Y_f64); + const int indexZd = schema.getDimensionIndex(Dimension::Id_Z_f64); + + const int indexXi = schema.getDimensionIndex(Dimension::Id_X_i32); + const int indexYi = schema.getDimensionIndex(Dimension::Id_Y_i32); + const int indexZi = schema.getDimensionIndex(Dimension::Id_Z_i32); + + const Dimension dimXd = schema.getDimension(indexXd); + const Dimension dimYd = schema.getDimension(indexYd); + const Dimension dimZd = schema.getDimension(indexZd); + + Dimension& dimXi = schema.getDimension(indexXi); + Dimension& dimYi = schema.getDimension(indexYi); + Dimension& dimZi = schema.getDimension(indexZi); if (m_customScaleOffset) { @@ -181,33 +190,44 @@ void ScalingFilterBase::checkImpedance() dimZi.setNumericOffset(dimZd.getNumericOffset()); } - schema.addDimension(dimXi); - schema.addDimension(dimYi); - schema.addDimension(dimZi); } else { - const int indexXi = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - const int indexYi = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - const int indexZi = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); - - const Dimension dimXi = schema.getDimension(indexXi); - const Dimension dimYi = schema.getDimension(indexYi); - const Dimension dimZi = schema.getDimension(indexZi); - - Dimension dimXd(Dimension::Field_X, Dimension::Double); - Dimension dimYd(Dimension::Field_Y, Dimension::Double); - Dimension dimZd(Dimension::Field_Z, Dimension::Double); - // ints --> doubles - if (!schema.hasDimension(dimXi) || !schema.hasDimension(dimYi) || !schema.hasDimension(dimZi)) + + // verify we have the ints we need, and add the doubles if we have to + if (!schema.hasDimension(Dimension::Id_X_i32) || !schema.hasDimension(Dimension::Id_X_i32) || !schema.hasDimension(Dimension::Id_X_i32)) { throw impedance_invalid("Scaling filter requires X,Y,Z dimensions as int32s"); } - if (schema.hasDimension(dimXd) || schema.hasDimension(dimYd) || schema.hasDimension(dimZd)) + if (!schema.hasDimension(Dimension::Id_X_f64)) + { + schema.appendDimension(Dimension::Id_X_f64); + } + if (!schema.hasDimension(Dimension::Id_Y_f64)) + { + schema.appendDimension(Dimension::Id_Y_f64); + } + if (!schema.hasDimension(Dimension::Id_Z_f64)) { - throw impedance_invalid("Scaling filter requires X,Y,Z dimensions as int32s not be initially present"); + schema.appendDimension(Dimension::Id_Z_f64); } + + const int indexXi = schema.getDimensionIndex(Dimension::Id_X_i32); + const int indexYi = schema.getDimensionIndex(Dimension::Id_Y_i32); + const int indexZi = schema.getDimensionIndex(Dimension::Id_Z_i32); + + const int indexXd = schema.getDimensionIndex(Dimension::Id_X_f64); + const int indexYd = schema.getDimensionIndex(Dimension::Id_Y_f64); + const int indexZd = schema.getDimensionIndex(Dimension::Id_Z_f64); + + const Dimension dimXi = schema.getDimension(indexXi); + const Dimension dimYi = schema.getDimension(indexYi); + const Dimension dimZi = schema.getDimension(indexZi); + + Dimension& dimXd = schema.getDimension(indexXd); + Dimension& dimYd = schema.getDimension(indexYd); + Dimension& dimZd = schema.getDimension(indexZd); if (m_customScaleOffset) { @@ -227,14 +247,6 @@ void ScalingFilterBase::checkImpedance() dimZd.setNumericScale(dimZi.getNumericScale()); dimZd.setNumericOffset(dimZi.getNumericOffset()); } - - schema.removeDimension(dimXi); - schema.removeDimension(dimYi); - schema.removeDimension(dimZi); - - schema.addDimension(dimXd); - schema.addDimension(dimYd); - schema.addDimension(dimZd); } return; @@ -255,15 +267,15 @@ void ScalingFilterBase::processBuffer(const PointBuffer& srcData, PointBuffer& d const Schema& schemaD = (m_isDescaling ? srcSchema : dstSchema); const Schema& schemaI = (m_isDescaling ? dstSchema : srcSchema); - assert(schemaD.hasDimension(Dimension::Field_X, Dimension::Double)); - assert(schemaI.hasDimension(Dimension::Field_X, Dimension::Int32)); + assert(schemaD.hasDimension(Dimension::Id_X_f64)); + assert(schemaI.hasDimension(Dimension::Id_X_i32)); - const int indexXd = schemaD.getDimensionIndex(Dimension::Field_X, Dimension::Double); - const int indexYd = schemaD.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - const int indexZd = schemaD.getDimensionIndex(Dimension::Field_Z, Dimension::Double); - const int indexXi = schemaI.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - const int indexYi = schemaI.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - const int indexZi = schemaI.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); + const int indexXd = schemaD.getDimensionIndex(Dimension::Id_X_f64); + const int indexYd = schemaD.getDimensionIndex(Dimension::Id_Y_f64); + const int indexZd = schemaD.getDimensionIndex(Dimension::Id_Z_f64); + const int indexXi = schemaI.getDimensionIndex(Dimension::Id_X_i32); + const int indexYi = schemaI.getDimensionIndex(Dimension::Id_Y_i32); + const int indexZi = schemaI.getDimensionIndex(Dimension::Id_Z_i32); const Dimension& dimXd = schemaD.getDimension(indexXd); const Dimension& dimYd = schemaD.getDimension(indexYd); @@ -321,7 +333,6 @@ void ScalingFilterBase::processBuffer(const PointBuffer& srcData, PointBuffer& d const boost::int32_t yi = srcData.getField(pointIndex, indexYi); const boost::int32_t zi = srcData.getField(pointIndex, indexZi); - const double xd = dimXd.applyScaling(xi); const double yd = dimYd.applyScaling(yi); const double zd = dimZd.applyScaling(zi); @@ -339,7 +350,6 @@ void ScalingFilterBase::processBuffer(const PointBuffer& srcData, PointBuffer& d dstData.setField(pointIndex, indexXd, xd); dstData.setField(pointIndex, indexYd, yd); dstData.setField(pointIndex, indexZd, zd); - } dstData.setNumPoints(pointIndex+1); diff --git a/src/filters/StatsFilter.cpp b/src/filters/StatsFilter.cpp index f29dcf4d11..0d2d543b80 100644 --- a/src/filters/StatsFilter.cpp +++ b/src/filters/StatsFilter.cpp @@ -120,9 +120,9 @@ StatsFilter::~StatsFilter() for (Schema::DimensionsIter iter = dims.begin(); iter != dims.end(); ++iter) { const Dimension& dim = *iter; - StatsCollector* stats = m_stats[dim.getField()]; + StatsCollector* stats = m_stats[dim.getId()]; delete stats; - m_stats.erase(dim.getField()); + m_stats.erase(dim.getId()); } } @@ -134,7 +134,7 @@ void StatsFilter::initialize() for (Schema::DimensionsCIter iter = dims.begin(); iter != dims.end(); ++iter) { const Dimension& dim = *iter; - m_stats[dim.getField()] = new StatsCollector(); + m_stats[dim.getId()] = new StatsCollector(); } return; @@ -154,12 +154,12 @@ void StatsFilter::reset() for (Schema::DimensionsCIter iter = dims.begin(); iter != dims.end(); ++iter) { const Dimension& dim = *iter; - m_stats[dim.getField()]->reset(); + m_stats[dim.getId()]->reset(); } } -const StatsCollector& StatsFilter::getStats(Dimension::Field field) const +const StatsCollector& StatsFilter::getStats(Dimension::Id field) const { const StatsCollector* s = m_stats.find(field)->second; return *s; @@ -174,16 +174,16 @@ void StatsFilter::processBuffer(PointBuffer& data) const const Schema& schema = schemaLayout.getSchema(); // BUG: fix this! - const int indexXi = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - const int indexYi = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - const int indexZi = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); - const int indexXd = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - const int indexYd = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - const int indexZd = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); + const int indexXi = schema.getDimensionIndex(Dimension::Id_X_i32); + const int indexYi = schema.getDimensionIndex(Dimension::Id_Y_i32); + const int indexZi = schema.getDimensionIndex(Dimension::Id_Z_i32); + const int indexXd = schema.getDimensionIndex(Dimension::Id_X_f64); + const int indexYd = schema.getDimensionIndex(Dimension::Id_Y_f64); + const int indexZd = schema.getDimensionIndex(Dimension::Id_Z_f64); - StatsCollector& statsX = *(m_stats.find(Dimension::Field_X)->second); - StatsCollector& statsY = *(m_stats.find(Dimension::Field_Y)->second); - StatsCollector& statsZ = *(m_stats.find(Dimension::Field_Z)->second); + StatsCollector& statsX = (indexXi!=-1) ? *(m_stats.find(Dimension::Id_X_i32)->second) : *(m_stats.find(Dimension::Id_X_f64)->second); + StatsCollector& statsY = (indexYi!=-1) ? *(m_stats.find(Dimension::Id_Y_i32)->second) : *(m_stats.find(Dimension::Id_Y_f64)->second); + StatsCollector& statsZ = (indexZi!=-1) ? *(m_stats.find(Dimension::Id_Z_i32)->second) : *(m_stats.find(Dimension::Id_Z_f64)->second); for (boost::uint32_t pointIndex=0; pointIndex::const_iterator iter = m_stats.begin(); + for (std::map::const_iterator iter = m_stats.begin(); iter != m_stats.end(); ++iter) { @@ -220,10 +220,17 @@ boost::property_tree::ptree StatsFilter::toStatsPTree() const boost::property_tree::ptree subtree = stat->toPTree(); // BUG: make this work for all fields - if (iter->first == Dimension::Field_X || iter->first == Dimension::Field_Y ||iter->first == Dimension::Field_Z) + if (iter->first == Dimension::Id_X_i32 || iter->first == Dimension::Id_X_f64) { - const std::string key = Dimension::getFieldName(iter->first); - tree.add_child(key, subtree); + tree.add_child("X", subtree); + } + else if (iter->first == Dimension::Id_Y_i32 || iter->first == Dimension::Id_Y_f64) + { + tree.add_child("Y", subtree); + } + else if (iter->first == Dimension::Id_Z_i32 || iter->first == Dimension::Id_Z_f64) + { + tree.add_child("Z", subtree); } } diff --git a/test/unit/ByteSwapFilterTest.cpp b/test/unit/ByteSwapFilterTest.cpp index 09ac0dd500..0bf57060c1 100644 --- a/test/unit/ByteSwapFilterTest.cpp +++ b/test/unit/ByteSwapFilterTest.cpp @@ -79,10 +79,10 @@ BOOST_AUTO_TEST_CASE(test_swapping) BOOST_CHECK_EQUAL(unfliped_read, buffer_size); - int offsetX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - int offsetY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - int offsetZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); - int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); + int offsetX = schema.getDimensionIndex(Dimension::Id_X_f64); + int offsetY = schema.getDimensionIndex(Dimension::Id_Y_f64); + int offsetZ = schema.getDimensionIndex(Dimension::Id_Z_f64); + int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); BOOST_CHECK_EQUAL(offsetX, 0); BOOST_CHECK_EQUAL(offsetY, 1); diff --git a/test/unit/CacheFilterTest.cpp b/test/unit/CacheFilterTest.cpp index c138b9c78b..6d3c09db06 100644 --- a/test/unit/CacheFilterTest.cpp +++ b/test/unit/CacheFilterTest.cpp @@ -56,7 +56,7 @@ BOOST_AUTO_TEST_CASE(test1) const Schema& schema = reader.getSchema(); SchemaLayout layout(schema); - const int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); + const int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); PointBuffer dataBig(layout, 1024); PointBuffer dataSmall(layout, 1); @@ -111,7 +111,7 @@ BOOST_AUTO_TEST_CASE(CacheFilterTest_test_options) const Schema& schema = reader.getSchema(); SchemaLayout layout(schema); - const int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); + const int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); PointBuffer dataBig(layout, 1024); PointBuffer dataSmall(layout, 1); diff --git a/test/unit/ChipperTest.cpp b/test/unit/ChipperTest.cpp index 1144609ddc..64c4ebadaa 100644 --- a/test/unit/ChipperTest.cpp +++ b/test/unit/ChipperTest.cpp @@ -93,8 +93,8 @@ BOOST_AUTO_TEST_CASE(test_construction) pdal::Schema const& schema = reader.getSchema(); PointBuffer buffer(schema, 15); - const int indexId = schema.getDimensionIndex(Dimension::Field_User1, Dimension::Int32); - const int indexBlockId = schema.getDimensionIndex(Dimension::Field_User2, Dimension::Int32); + const int indexId = schema.getDimensionIndex(Dimension::Id_Chipper_1); + const int indexBlockId = schema.getDimensionIndex(Dimension::Id_Chipper_2); chipper.GetBlock(20).GetBuffer(reader, buffer, 70, indexId, indexBlockId); // diff --git a/test/unit/DecimationFilterTest.cpp b/test/unit/DecimationFilterTest.cpp index 2f41968a48..8a3b619b35 100644 --- a/test/unit/DecimationFilterTest.cpp +++ b/test/unit/DecimationFilterTest.cpp @@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE(DecimationFilterTest_test1) BOOST_CHECK(numRead == 3); - int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); + int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); boost::uint64_t t0 = data.getField(0, offsetT); boost::uint64_t t1 = data.getField(1, offsetT); @@ -104,7 +104,7 @@ BOOST_AUTO_TEST_CASE(DecimationFilterTest_test_options) BOOST_CHECK(numRead == 3); - int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); + int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); boost::uint64_t t0 = data.getField(0, offsetT); boost::uint64_t t1 = data.getField(1, offsetT); diff --git a/test/unit/DimensionLayoutTest.cpp b/test/unit/DimensionLayoutTest.cpp index 8604d62672..c8080e254a 100644 --- a/test/unit/DimensionLayoutTest.cpp +++ b/test/unit/DimensionLayoutTest.cpp @@ -45,10 +45,10 @@ BOOST_AUTO_TEST_SUITE(DimensionLayoutTest) BOOST_AUTO_TEST_CASE(test1) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); DimensionLayout l1(d1); - Dimension d2(Dimension::Field_Y, Dimension::Uint32); + Dimension d2(Dimension::Id_Y_i32); DimensionLayout l2(d2); DimensionLayout l3(l1); @@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(test1) BOOST_AUTO_TEST_CASE(DimensionLayoutTest_ptree) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); DimensionLayout l1(d1); std::stringstream ss1(std::stringstream::in | std::stringstream::out); @@ -77,7 +77,7 @@ BOOST_AUTO_TEST_CASE(DimensionLayoutTest_ptree) std::string out1 = ss1.str(); static std::string xml_header = "\n"; - std::string ref = xml_header + "XUint324little000"; + std::string ref = xml_header + "XInt324little000false"; boost::algorithm::erase_all(out1, "\n"); boost::algorithm::erase_all(ref, "\n"); diff --git a/test/unit/DimensionTest.cpp b/test/unit/DimensionTest.cpp index 8d5bff5d1b..84ce5a038c 100644 --- a/test/unit/DimensionTest.cpp +++ b/test/unit/DimensionTest.cpp @@ -46,19 +46,19 @@ BOOST_AUTO_TEST_SUITE(DimensionTest) BOOST_AUTO_TEST_CASE(test_ctor) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); - BOOST_CHECK(d1.getField() == Dimension::Field_X); - BOOST_CHECK(d1.getFieldName() == "X"); - BOOST_CHECK(d1.getDataType() == Dimension::Uint32); + BOOST_CHECK(d1.getId() == Dimension::Id_X_i32); + BOOST_CHECK(d1.getName() == "X"); + BOOST_CHECK(d1.getDataType() == Dimension::Int32); Dimension d2(d1); - BOOST_CHECK(d1.getField() == Dimension::Field_X); - BOOST_CHECK(d1.getDataType() == Dimension::Uint32); + BOOST_CHECK(d1.getId() == Dimension::Id_X_i32); + BOOST_CHECK(d1.getDataType() == Dimension::Int32); Dimension d3 = d1; - BOOST_CHECK(d1.getField() == Dimension::Field_X); - BOOST_CHECK(d1.getDataType() == Dimension::Uint32); + BOOST_CHECK(d1.getId() == Dimension::Id_X_i32); + BOOST_CHECK(d1.getDataType() == Dimension::Int32); BOOST_CHECK(d1 == d1); BOOST_CHECK(d1 == d2); @@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(test_ctor) BOOST_CHECK(d1 == d3); BOOST_CHECK(d3 == d1); - Dimension d4(Dimension::Field_Y, Dimension::Uint32); + Dimension d4(Dimension::Id_Y_i32); d4.setEndianness(Endian_Big); BOOST_CHECK(d1 != d4); BOOST_CHECK(d4 != d1); @@ -75,7 +75,7 @@ BOOST_AUTO_TEST_CASE(test_ctor) BOOST_AUTO_TEST_CASE(DimensionTest_ptree) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); std::stringstream ss1(std::stringstream::in | std::stringstream::out); @@ -85,7 +85,7 @@ BOOST_AUTO_TEST_CASE(DimensionTest_ptree) std::string out1 = ss1.str(); std::string xml_header = "\n"; - std::string ref = xml_header + "XUint324little0"; + std::string ref = xml_header + "XInt324little0"; boost::algorithm::erase_all(out1, "\n"); boost::algorithm::erase_all(ref, "\n"); @@ -96,3 +96,4 @@ BOOST_AUTO_TEST_CASE(DimensionTest_ptree) BOOST_AUTO_TEST_SUITE_END() + diff --git a/test/unit/FauxReaderTest.cpp b/test/unit/FauxReaderTest.cpp index 1cf353dd40..570eb1d70d 100644 --- a/test/unit/FauxReaderTest.cpp +++ b/test/unit/FauxReaderTest.cpp @@ -35,6 +35,8 @@ #include #include +#include + #include #include #include @@ -69,10 +71,10 @@ BOOST_AUTO_TEST_CASE(test_constant_mode_sequential_iter) BOOST_CHECK_EQUAL(numRead, 750u); - int offsetX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - int offsetY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - int offsetZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); - int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); + int offsetX = schema.getDimensionIndex(Dimension::Id_X_f64); + int offsetY = schema.getDimensionIndex(Dimension::Id_Y_f64); + int offsetZ = schema.getDimensionIndex(Dimension::Id_Z_f64); + int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); for (boost::uint32_t i=0; i(0, offsetX); const double y0 = data.getField(0, offsetY); @@ -362,10 +364,10 @@ BOOST_AUTO_TEST_CASE(test_ramp_mode_2) BOOST_CHECK_EQUAL(numRead,750u); - int offsetX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - int offsetY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - int offsetZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); - int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); + int offsetX = schema.getDimensionIndex(Dimension::Id_X_f64); + int offsetY = schema.getDimensionIndex(Dimension::Id_Y_f64); + int offsetZ = schema.getDimensionIndex(Dimension::Id_Z_f64); + int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); double delX = (101.0 - 1.0) / (750.0 - 1.0); double delY = (152.0 - 2.0) / (750.0 - 1.0); @@ -395,8 +397,8 @@ BOOST_AUTO_TEST_CASE(test_custom_fields) { Bounds bounds(1.0, 2.0, 3.0, 101.0, 102.0, 103.0); - Dimension dimY(Dimension::Field_Y, Dimension::Uint8); - Dimension dimX(Dimension::Field_X, Dimension::Uint8); + Dimension dimY(Dimension::Id_Red_u8); + Dimension dimX(Dimension::Id_Blue_u8); std::vector dims; dims.push_back(dimY); dims.push_back(dimX); @@ -406,8 +408,8 @@ BOOST_AUTO_TEST_CASE(test_custom_fields) const Schema& schema = reader.getSchema(); BOOST_CHECK_EQUAL(schema.getDimensions().size(), 2u); - BOOST_CHECK_EQUAL(schema.getDimension(0).getField(), Dimension::Field_Y); - BOOST_CHECK_EQUAL(schema.getDimension(1).getField(), Dimension::Field_X); + BOOST_CHECK_EQUAL(schema.getDimension(0).getId(), Dimension::Id_Red_u8); + BOOST_CHECK_EQUAL(schema.getDimension(1).getId(), Dimension::Id_Blue_u8); return; } diff --git a/test/unit/MosaicFilterTest.cpp b/test/unit/MosaicFilterTest.cpp index f0d7265217..4a0697b855 100644 --- a/test/unit/MosaicFilterTest.cpp +++ b/test/unit/MosaicFilterTest.cpp @@ -75,10 +75,10 @@ BOOST_AUTO_TEST_CASE(test1) BOOST_CHECK(numRead == 300); - const int offsetT = schema.getDimensionIndex(Dimension::Field_Time, Dimension::Uint64); - const int offsetX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - const int offsetY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - const int offsetZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); + const int offsetT = schema.getDimensionIndex(Dimension::Id_Time_u64); + const int offsetX = schema.getDimensionIndex(Dimension::Id_X_f64); + const int offsetY = schema.getDimensionIndex(Dimension::Id_Y_f64); + const int offsetZ = schema.getDimensionIndex(Dimension::Id_Z_f64); for (boost::uint32_t i=0; i<300; i++) { diff --git a/test/unit/PointBufferCacheTest.cpp b/test/unit/PointBufferCacheTest.cpp index 1028acef26..7275773a29 100644 --- a/test/unit/PointBufferCacheTest.cpp +++ b/test/unit/PointBufferCacheTest.cpp @@ -30,8 +30,8 @@ BOOST_AUTO_TEST_SUITE(PointBufferCacheTest) BOOST_AUTO_TEST_CASE(test1) { Schema schema; - Dimension d1(Dimension::Field_X, Dimension::Uint32); - schema.addDimension(d1); + Dimension d1(Dimension::Id_X_i32); + schema.appendDimension(d1); SchemaLayout layout(schema); PointBuffer* item0 = new PointBuffer(layout, 10); diff --git a/test/unit/PointBufferTest.cpp b/test/unit/PointBufferTest.cpp index 1ff688b302..4a17d7c324 100644 --- a/test/unit/PointBufferTest.cpp +++ b/test/unit/PointBufferTest.cpp @@ -44,11 +44,11 @@ BOOST_AUTO_TEST_SUITE(PointBufferTest) BOOST_AUTO_TEST_CASE(test_ctor) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); - Dimension d2(Dimension::Field_Y, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); + Dimension d2(Dimension::Id_Y_i32); Schema schema; - schema.addDimension(d1); - schema.addDimension(d2); + schema.appendDimension(d1); + schema.appendDimension(d2); SchemaLayout layout(schema); PointBuffer data(layout, 10); @@ -62,13 +62,13 @@ BOOST_AUTO_TEST_CASE(test_ctor) PointBuffer* makeTestBuffer() { - Dimension d1(Dimension::Field_X, Dimension::Uint8); - Dimension d2(Dimension::Field_Y, Dimension::Int32); - Dimension d3(Dimension::Field_Z, Dimension::Double); + Dimension d1(Dimension::Id_Las_Classification); + Dimension d2(Dimension::Id_X_i32); + Dimension d3(Dimension::Id_Y_f64); Schema schema; - schema.addDimension(d1); - schema.addDimension(d2); - schema.addDimension(d3); + schema.appendDimension(d1); + schema.appendDimension(d2); + schema.appendDimension(d3); SchemaLayout layout(schema); std::size_t offX = layout.getDimensionLayout(0).getByteOffset(); @@ -208,7 +208,7 @@ BOOST_AUTO_TEST_CASE(PointBufferTest_ptree) const std::string out1 = ss1.str(); static std::string xml_header = "\n"; - const std::string ref = xml_header + "<0>100<1>210100"; + const std::string ref = xml_header + "<0>100<1>210100"; BOOST_CHECK_EQUAL(ref, out1.substr(0, ref.length())); diff --git a/test/unit/QFITReaderTest.cpp b/test/unit/QFITReaderTest.cpp index 159fc3dbd1..630af9d29a 100644 --- a/test/unit/QFITReaderTest.cpp +++ b/test/unit/QFITReaderTest.cpp @@ -63,10 +63,10 @@ void Check_Point(const pdal::PointBuffer& data, const ::pdal::Schema& schema, boost::int32_t tref) { - int offsetX = schema.getDimensionIndex(pdal::Dimension::Field_X, pdal::Dimension::Int32); - int offsetY = schema.getDimensionIndex(pdal::Dimension::Field_Y, pdal::Dimension::Int32); - int offsetZ = schema.getDimensionIndex(pdal::Dimension::Field_Z, pdal::Dimension::Int32); - int offsetTime = schema.getDimensionIndex(pdal::Dimension::Field_Time, pdal::Dimension::Int32); + int offsetX = schema.getDimensionIndex(pdal::Dimension::Id_X_i32); + int offsetY = schema.getDimensionIndex(pdal::Dimension::Id_Y_i32); + int offsetZ = schema.getDimensionIndex(pdal::Dimension::Id_Z_i32); + int offsetTime = schema.getDimensionIndex(pdal::Dimension::Id_Qfit_Time); boost::int32_t x = data.getField(index, offsetX); boost::int32_t y = data.getField(index, offsetY); diff --git a/test/unit/ReprojectionFilterTest.cpp b/test/unit/ReprojectionFilterTest.cpp index 3617125541..91373d4e2e 100644 --- a/test/unit/ReprojectionFilterTest.cpp +++ b/test/unit/ReprojectionFilterTest.cpp @@ -56,9 +56,9 @@ static void getPoint(const pdal::PointBuffer& data, double& x, double& y, double const Schema& schema = data.getSchema(); - const int indexX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Int32); - const int indexY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Int32); - const int indexZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Int32); + const int indexX = schema.getDimensionIndex(Dimension::Id_X_i32); + const int indexY = schema.getDimensionIndex(Dimension::Id_Y_i32); + const int indexZ = schema.getDimensionIndex(Dimension::Id_Z_i32); const boost::int32_t xraw = data.getField(0, indexX); const boost::int32_t yraw = data.getField(0, indexY); diff --git a/test/unit/ScalingFilterTest.cpp b/test/unit/ScalingFilterTest.cpp index 1a6c5cb226..58d0781c47 100644 --- a/test/unit/ScalingFilterTest.cpp +++ b/test/unit/ScalingFilterTest.cpp @@ -61,12 +61,12 @@ static void getDoublePoint(const pdal::PointBuffer& data, double& x, double& y, const Schema& schema = data.getSchema(); - const int indexX = schema.getDimensionIndex(Dimension::Field_X, Dimension::Double); - const int indexY = schema.getDimensionIndex(Dimension::Field_Y, Dimension::Double); - const int indexZ = schema.getDimensionIndex(Dimension::Field_Z, Dimension::Double); - const int indexIntensity = schema.getDimensionIndex(Dimension::Field_Intensity, Dimension::Uint8); - const int indexScanAngle = schema.getDimensionIndex(Dimension::Field_ScanAngleRank, Dimension::Int8); - const int indexGreen = schema.getDimensionIndex(Dimension::Field_Green, Dimension::Uint16); + const int indexX = schema.getDimensionIndex(Dimension::Id_X_f64); + const int indexY = schema.getDimensionIndex(Dimension::Id_Y_f64); + const int indexZ = schema.getDimensionIndex(Dimension::Id_Z_f64); + const int indexIntensity = schema.getDimensionIndex(Dimension::Id_Las_Intensity); + const int indexScanAngle = schema.getDimensionIndex(Dimension::Id_Las_ScanAngleRank); + const int indexGreen = schema.getDimensionIndex(Dimension::Id_Green_u16); x = data.getField(0, indexX); diff --git a/test/unit/SchemaLayoutTest.cpp b/test/unit/SchemaLayoutTest.cpp index d724a955ff..fd81f99edf 100644 --- a/test/unit/SchemaLayoutTest.cpp +++ b/test/unit/SchemaLayoutTest.cpp @@ -46,23 +46,23 @@ BOOST_AUTO_TEST_SUITE(SchemaLayoutTest) BOOST_AUTO_TEST_CASE(test_layout) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); - Dimension d2(Dimension::Field_Y, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); + Dimension d2(Dimension::Id_Y_i32); Schema s1; - s1.addDimension(d1); - s1.addDimension(d2); - BOOST_CHECK(s1.getDimensionIndex(Dimension::Field_X, Dimension::Uint32) == 0); - BOOST_CHECK(s1.getDimensionIndex(Dimension::Field_Y, Dimension::Uint32) == 1); + s1.appendDimension(d1); + s1.appendDimension(d2); + BOOST_CHECK(s1.getDimensionIndex(Dimension::Id_X_i32) == 0); + BOOST_CHECK(s1.getDimensionIndex(Dimension::Id_Y_i32) == 1); - BOOST_CHECK(s1.hasDimension(Dimension::Field_X, Dimension::Uint8) == false); - BOOST_CHECK(s1.hasDimension(Dimension::Field_Y, Dimension::Uint8) == false); + BOOST_CHECK(s1.hasDimension(Dimension::Id_X_f64) == false); + BOOST_CHECK(s1.hasDimension(Dimension::Id_Y_f64) == false); Schema s2; - s2.addDimension(d1); - BOOST_CHECK(s2.hasDimension(Dimension::Field_X, Dimension::Uint32) == true); - BOOST_CHECK(s2.getDimensionIndex(Dimension::Field_X, Dimension::Uint32) == 0); - BOOST_CHECK(s2.hasDimension(Dimension::Field_Y, Dimension::Uint32) == false); + s2.appendDimension(d1); + BOOST_CHECK(s2.hasDimension(Dimension::Id_X_i32) == true); + BOOST_CHECK(s2.getDimensionIndex(Dimension::Id_X_i32) == 0); + BOOST_CHECK(s2.hasDimension(Dimension::Id_Y_i32) == false); SchemaLayout l1(s1); SchemaLayout l2(l1); @@ -81,11 +81,11 @@ BOOST_AUTO_TEST_CASE(test_layout) BOOST_AUTO_TEST_CASE(test_layout_size) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); - Dimension d2(Dimension::Field_Y, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); + Dimension d2(Dimension::Id_Y_i32); Schema s1; - s1.addDimension(d1); - s1.addDimension(d2); + s1.appendDimension(d1); + s1.appendDimension(d2); SchemaLayout sl1(s1); const DimensionLayout& dl1 = sl1.getDimensionLayout(0); @@ -102,11 +102,11 @@ BOOST_AUTO_TEST_CASE(test_layout_size) BOOST_AUTO_TEST_CASE(SchemaLayoutTest_ptree) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); - Dimension d2(Dimension::Field_Y, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); + Dimension d2(Dimension::Id_Y_i32); Schema s1; - s1.addDimension(d1); - s1.addDimension(d2); + s1.appendDimension(d1); + s1.appendDimension(d2); SchemaLayout sl1(s1); std::stringstream ss1(std::stringstream::in | std::stringstream::out); @@ -117,7 +117,7 @@ BOOST_AUTO_TEST_CASE(SchemaLayoutTest_ptree) std::string out1 = ss1.str(); static std::string xml_header = "\n"; - std::string ref = xml_header + "XUint324little000YUint324little041"; + std::string ref = xml_header + "XInt324little000falseYInt324little041false"; boost::algorithm::erase_all(out1, "\n"); boost::algorithm::erase_all(ref, "\n"); diff --git a/test/unit/SchemaTest.cpp b/test/unit/SchemaTest.cpp index cfef7dfc92..3549b0f276 100644 --- a/test/unit/SchemaTest.cpp +++ b/test/unit/SchemaTest.cpp @@ -47,12 +47,12 @@ BOOST_AUTO_TEST_SUITE(SchemaTest) BOOST_AUTO_TEST_CASE(test_ctor) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); - Dimension d2(Dimension::Field_Y, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); + Dimension d2(Dimension::Id_Y_i32); Schema s1; - s1.addDimension(d1); - s1.addDimension(d2); + s1.appendDimension(d1); + s1.appendDimension(d2); Schema s2(s1); Schema s3 = s1; @@ -64,27 +64,27 @@ BOOST_AUTO_TEST_CASE(test_ctor) BOOST_CHECK(s3==s1); Schema s4; - s4.addDimension(d1); + s4.appendDimension(d1); BOOST_CHECK(s1!=s4); BOOST_CHECK(s4!=s1); - BOOST_CHECK(s1.hasDimension(Dimension::Field_X, Dimension::Uint32)); - BOOST_CHECK(!s1.hasDimension(Dimension::Field_X, Dimension::Uint16)); - Dimension dx32(Dimension::Field_X, Dimension::Uint32); - Dimension dx16(Dimension::Field_X, Dimension::Uint16); + BOOST_CHECK(s1.hasDimension(Dimension::Id_X_i32)); + BOOST_CHECK(!s1.hasDimension(Dimension::Id_X_f64)); + Dimension dx32(Dimension::Id_X_i32); + Dimension dx64(Dimension::Id_X_f64); BOOST_CHECK(s1.hasDimension(dx32)); - BOOST_CHECK(!s1.hasDimension(dx16)); + BOOST_CHECK(!s1.hasDimension(dx64)); } BOOST_AUTO_TEST_CASE(SchemaTest_ptree) { - Dimension d1(Dimension::Field_X, Dimension::Uint32); - Dimension d2(Dimension::Field_Y, Dimension::Uint32); + Dimension d1(Dimension::Id_X_i32); + Dimension d2(Dimension::Id_Y_i32); Schema s1; - s1.addDimension(d1); - s1.addDimension(d2); + s1.appendDimension(d1); + s1.appendDimension(d2); std::stringstream ss1(std::stringstream::in | std::stringstream::out); @@ -95,7 +95,7 @@ BOOST_AUTO_TEST_CASE(SchemaTest_ptree) boost::algorithm::erase_all(out1, "\n"); static std::string xml_header = "\n"; - std::string ref = xml_header + "XUint324little0YUint324little0"; + std::string ref = xml_header + "XInt324little0YInt324little0"; boost::algorithm::erase_all(ref, "\n"); BOOST_CHECK_EQUAL(ref, out1); diff --git a/test/unit/StatsFilterTest.cpp b/test/unit/StatsFilterTest.cpp index cf65245035..500a5d99b3 100644 --- a/test/unit/StatsFilterTest.cpp +++ b/test/unit/StatsFilterTest.cpp @@ -68,9 +68,9 @@ BOOST_AUTO_TEST_CASE(StatsFilterTest_test1) BOOST_CHECK(numRead == 1000); } - const pdal::filters::StatsCollector& statsX = filter.getStats(Dimension::Field_X); - const pdal::filters::StatsCollector& statsY = filter.getStats(Dimension::Field_Y); - const pdal::filters::StatsCollector& statsZ = filter.getStats(Dimension::Field_Z); + const pdal::filters::StatsCollector& statsX = filter.getStats(Dimension::Id_X_f64); + const pdal::filters::StatsCollector& statsY = filter.getStats(Dimension::Id_Y_f64); + const pdal::filters::StatsCollector& statsZ = filter.getStats(Dimension::Id_Z_f64); BOOST_CHECK_EQUAL(statsX.count(), 1000u); BOOST_CHECK_EQUAL(statsY.count(), 1000u); diff --git a/test/unit/Support.cpp b/test/unit/Support.cpp index 678b44031d..216e0c3988 100644 --- a/test/unit/Support.cpp +++ b/test/unit/Support.cpp @@ -343,9 +343,9 @@ void Support::check_pN(const pdal::PointBuffer& data, const pdal::Schema& schema std::size_t index, double xref, double yref, double zref) { - int offsetX = schema.getDimensionIndex(pdal::Dimension::Field_X, pdal::Dimension::Int32); - int offsetY = schema.getDimensionIndex(pdal::Dimension::Field_Y, pdal::Dimension::Int32); - int offsetZ = schema.getDimensionIndex(pdal::Dimension::Field_Z, pdal::Dimension::Int32); + int offsetX = schema.getDimensionIndex(pdal::Dimension::Id_X_i32); + int offsetY = schema.getDimensionIndex(pdal::Dimension::Id_Y_i32); + int offsetZ = schema.getDimensionIndex(pdal::Dimension::Id_Z_i32); boost::int32_t x0raw = data.getField(index, offsetX); boost::int32_t y0raw = data.getField(index, offsetY); @@ -368,13 +368,13 @@ void Support::check_pN(const pdal::PointBuffer& data, const ::pdal::Schema& sche { check_pN(data, schema, index, xref, yref, zref); - int offsetT = schema.getDimensionIndex(pdal::Dimension::Field_Time, pdal::Dimension::Double); + int offsetT = schema.getDimensionIndex(pdal::Dimension::Id_Las_Time); double t0 = data.getField(index, offsetT); - Compare(t0, tref); + BOOST_CHECK_EQUAL(t0, tref); - int offsetR = schema.getDimensionIndex(pdal::Dimension::Field_Red, pdal::Dimension::Uint16); - int offsetG = schema.getDimensionIndex(pdal::Dimension::Field_Green, pdal::Dimension::Uint16); - int offsetB = schema.getDimensionIndex(pdal::Dimension::Field_Blue, pdal::Dimension::Uint16); + int offsetR = schema.getDimensionIndex(pdal::Dimension::Id_Red_u16); + int offsetG = schema.getDimensionIndex(pdal::Dimension::Id_Green_u16); + int offsetB = schema.getDimensionIndex(pdal::Dimension::Id_Blue_u16); boost::uint16_t r0 = data.getField(index, offsetR); boost::uint16_t g0 = data.getField(index, offsetG); boost::uint16_t b0 = data.getField(index, offsetB); diff --git a/test/unit/TerraSolidTest.cpp b/test/unit/TerraSolidTest.cpp index 6b092cd313..b083d58769 100644 --- a/test/unit/TerraSolidTest.cpp +++ b/test/unit/TerraSolidTest.cpp @@ -64,10 +64,10 @@ void Check_Point(const pdal::PointBuffer& data, const ::pdal::Schema& schema, double tref) { - int offsetX = schema.getDimensionIndex(pdal::Dimension::Field_X, pdal::Dimension::Int32); - int offsetY = schema.getDimensionIndex(pdal::Dimension::Field_Y, pdal::Dimension::Int32); - int offsetZ = schema.getDimensionIndex(pdal::Dimension::Field_Z, pdal::Dimension::Int32); - int offsetTime = schema.getDimensionIndex(pdal::Dimension::Field_Time, pdal::Dimension::Uint32); + int offsetX = schema.getDimensionIndex(pdal::Dimension::Id_X_i32); + int offsetY = schema.getDimensionIndex(pdal::Dimension::Id_Y_i32); + int offsetZ = schema.getDimensionIndex(pdal::Dimension::Id_Z_i32); + int offsetTime = schema.getDimensionIndex(pdal::Dimension::Id_TerraSolid_Time); boost::int32_t x = data.getField(index, offsetX); boost::int32_t y = data.getField(index, offsetY); diff --git a/test/unit/XMLSchemaTest.cpp b/test/unit/XMLSchemaTest.cpp index f4c6f58e4e..51cddc53a5 100644 --- a/test/unit/XMLSchemaTest.cpp +++ b/test/unit/XMLSchemaTest.cpp @@ -36,6 +36,8 @@ #include #include +#include + #include @@ -121,7 +123,7 @@ BOOST_AUTO_TEST_CASE(test_schema_read) BOOST_CHECK_EQUAL(dim1.getDataType(), dim2.getDataType()); BOOST_CHECK_EQUAL(dim1.getByteSize(), dim2.getByteSize()); - BOOST_CHECK_EQUAL(dim1.getField(), dim2.getField()); + BOOST_CHECK_EQUAL(dim1.getId(), dim2.getId()); BOOST_CHECK_EQUAL(dim1.getDescription(), dim2.getDescription()); } diff --git a/test/unit/pcinfoTest.cpp b/test/unit/pcinfoTest.cpp index e4c55e19c9..236f5d4a1e 100644 --- a/test/unit/pcinfoTest.cpp +++ b/test/unit/pcinfoTest.cpp @@ -174,4 +174,3 @@ BOOST_AUTO_TEST_CASE(pcinfo_test_dumps) BOOST_AUTO_TEST_SUITE_END() - diff --git a/test/unit/pcpipelineTest.cpp b/test/unit/pcpipelineTest.cpp index 805c12b77e..d5d0fc1f4b 100644 --- a/test/unit/pcpipelineTest.cpp +++ b/test/unit/pcpipelineTest.cpp @@ -85,4 +85,3 @@ BOOST_AUTO_TEST_CASE(pcpipelineTest_test_common_opts) BOOST_AUTO_TEST_SUITE_END() -