Vendor lazperf

CMakeLists.txt

@@ -8,7 +8,6 @@ if ((PDAL_VERSION_MAJOR EQUAL 1) AND (PDAL_VERSION_MINOR LESS 7))
   message(FATAL_ERROR "PDAL version is too old (${PDAL_VERSION}). Use 1.7 or higher.")
 endif()
 
-find_package(Lazperf REQUIRED 3.0.0)
 find_package(Threads)
 set_package_properties(Threads PROPERTIES DESCRIPTION
     "The thread library of the system" TYPE REQUIRED)
@@ -19,6 +18,8 @@ file(GLOB SRCS
     untwine/*.cpp
     epf/*.cpp
     bu/*.cpp
+    lazperf/*.cpp
+    lazperf/detail/*.cpp
 )
 
 add_executable(untwine ${SRCS})
@@ -29,12 +30,12 @@ target_include_directories(untwine
     PRIVATE
         ${CMAKE_CURRENT_BINARY_DIR}/include
         ${PDAL_INCLUDE_DIRS}
+        ${PROJECT_SOURCE_DIR}
 )
 target_link_libraries(untwine
     PRIVATE
         ${CMAKE_THREAD_LIBS_INIT}
         ${PDAL_LIBRARIES}
-        LAZPERF::lazperf
 )
 
 install(TARGETS untwine DESTINATION bin)

ci/linux/setup.sh

@@ -3,6 +3,7 @@
 mkdir build
 
 conda update -n base -c defaults conda
-conda install -c conda-forge cmake ninja compilers -y
-conda install -c conda-forge --yes --quiet laz-perf pdal -y
+#conda install -c conda-forge cmake ninja compilers -y
+conda install -c conda-forge cmake ninja -y
+conda install -c conda-forge --yes --quiet pdal -y
 

ci/osx/setup.sh

@@ -3,7 +3,8 @@
 mkdir build
 
 conda update -n base -c defaults conda
-conda install cmake ninja compilers -y
+#conda install cmake ninja compilers -y
+conda install cmake ninja -y
 
-conda install -c conda-forge laz-perf pdal -y
+conda install -c conda-forge pdal -y
 

ci/win/setup.sh

@@ -3,6 +3,7 @@
 mkdir build
 
 conda update -n base -c defaults conda
-conda install -c conda-forge cmake ninja compilers -y
+#conda install -c conda-forge cmake ninja compilers -y
+conda install -c conda-forge cmake ninja -y
 
-conda install -c conda-forge --yes --quiet laz-perf pdal -y
+conda install -c conda-forge --yes --quiet pdal -y

lazperf/Extractor.hpp

@@ -0,0 +1,319 @@
+/******************************************************************************
+* Copyright (c) 2014, Hobu Inc., [email protected]
+*
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following
+* conditions are met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above copyright
+*       notice, this list of conditions and the following disclaimer in
+*       the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
+*       names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior
+*       written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+* OF SUCH DAMAGE.
+****************************************************************************/
+
+#pragma once
+
+#include <cstring>
+#include <vector>
+
+#include "portable_endian.hpp"
+
+namespace lazperf
+{
+
+/**
+  Buffer wrapper for input of binary data from a buffer.
+*/
+class LeExtractor
+{
+public:
+    /**
+      Construct an extractor to operate on a buffer.
+
+      \param buf  Buffer to extract from.
+      \param size  Buffer size.
+    */
+    LeExtractor(const char *buf, std::size_t size) : m_eback(buf),
+        m_egptr(buf + size), m_gptr(buf)
+    {}
+
+private:
+    const char *m_eback;  ///< Start of the buffer (name from std::streambuf)
+    const char *m_egptr;  ///< End of the buffer.
+    const char *m_gptr;   ///< Current get position.
+
+public:
+    /**
+      Determine if the buffer is good.
+
+      \return  Whether the buffer is good.
+    */
+    operator bool ()
+        { return good(); }
+
+    /**
+      Seek to a position in the buffer.
+
+      \param pos  Position to seek in buffer.
+    */
+    void seek(std::size_t pos)
+        { m_gptr = m_eback + pos; }
+
+    /**
+      Advance buffer position.
+
+      \param cnt  Number of bytes to skip in buffer.
+    */
+    void skip(std::size_t cnt)
+        { m_gptr += cnt; }
+
+    /**
+      Return the get position of buffer.
+
+      \return  Get position.
+    */
+    size_t position() const
+        { return m_gptr - m_eback; }
+
+    /**
+      Determine whether the extractor is good (the get pointer is in the
+      buffer).
+
+      \return  Whether the get pointer is valid.
+    */
+    bool good() const
+        { return m_gptr < m_egptr; }
+
+    /**
+      Extract a string of a particular size from the buffer.  Trim trailing
+      null bytes.
+
+      \param s  String to extract to.
+      \param size  Number of bytes to extract from buffer into string.
+    */
+    void get(std::string& s, size_t size)
+    {
+        s = std::string(m_gptr, size);
+        m_gptr += size;
+        while (size)
+        {
+            size--;
+            if (s[size] != '\0')
+            {
+                s.resize(size + 1);
+                return;
+            }
+        }
+        s.clear();
+    }
+
+    /**
+      Extract data to char vector.  Vector must be sized to indicate
+      number of bytes to extract.
+
+      \param buf  Vector to which bytes should be extracted.
+    */
+    void get(std::vector<char>& buf)
+    {
+        memcpy((char *)buf.data(), m_gptr, buf.size());
+        m_gptr += buf.size();
+    }
+
+    /**
+      Extract data to unsigned char vector.  Vector must be sized to
+      indicate number of bytes to extract.
+
+      \param buf  Vector to which bytes should be extracted.
+    */
+    void get(std::vector<unsigned char>& buf)
+    {
+        memcpy((char *)buf.data(), m_gptr, buf.size());
+        m_gptr += buf.size();
+    }
+
+    /**
+      Extract data into a provided buffer.
+
+      \param buf  Pointer to buffer to which bytes should be extracted.
+      \param size  Number of bytes to extract.
+    */
+    void get(char *buf, size_t size)
+    {
+        memcpy(buf, m_gptr, size);
+        m_gptr += size;
+    }
+
+    /**
+      Extract data into a provided unsigned buffer.
+
+      \param buf  Pointer to buffer to which bytes should be extracted.
+      \param size  Number of bytes to extract.
+    */
+    void get(unsigned char *buf, size_t size)
+    {
+        memcpy(buf, m_gptr, size);
+        m_gptr += size;
+    }
+
+    /**
+      Extract an unsigned byte from a buffer.
+
+      \param v  Unsigned byte to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (uint8_t& v)
+    {
+        v = *(const uint8_t *)m_gptr++;
+        return *this;
+    }
+
+    /**
+      Extract a byte from a buffer.
+
+      \param v  Byte to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (int8_t& v)
+    {
+        v = *(const int8_t *)m_gptr++;
+        return *this;
+    }
+
+    /**
+      Extract an unsgined short from a buffer.
+
+      \param v  Short to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (uint16_t& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        v = le16toh(v);
+        m_gptr += sizeof(v);
+        return *this;
+    }
+
+    /**
+      Extract a short from a buffer.
+
+      \param v  Short to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (int16_t& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        v = (int16_t)le16toh((uint16_t)v);
+        m_gptr += sizeof(v);
+        return *this;
+    }
+
+    /**
+      Extract an unsigned int from a buffer.
+
+      \param v  Unsigned int to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (uint32_t& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        v = le32toh(v);
+        m_gptr += sizeof(v);
+        return *this;
+    }
+
+    /**
+      Extract an int from a buffer.
+
+      \param v  int to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (int32_t& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        v = (int32_t)le32toh((uint32_t)v);
+        m_gptr += sizeof(v);
+        return *this;
+    }
+
+    /**
+      Extract an unsigned long int from a buffer.
+
+      \param v  unsigned long int to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (uint64_t& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        v = le64toh(v);
+        m_gptr += sizeof(v);
+        return *this;
+    }
+
+    /**
+      Extract a long int from a buffer.
+
+      \param v  long int to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (int64_t& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        v = (int64_t)le64toh((uint64_t)v);
+        m_gptr += sizeof(v);
+        return *this;
+    }
+
+    /**
+      Extract a float from a buffer.
+
+      \param v  float to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (float& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        uint32_t tmp = le32toh(*(uint32_t *)(&v));
+        memcpy(&v, &tmp, sizeof(tmp));
+        m_gptr += sizeof(v);
+        return *this;
+    }
+
+    /**
+      Extract a double from a buffer.
+
+      \param v  double to extract to.
+      \return  This extractor.
+    */
+    LeExtractor& operator >> (double& v)
+    {
+        memcpy(&v, m_gptr, sizeof(v));
+        uint64_t tmp = le64toh(*(uint64_t *)(&v));
+        memcpy(&v, &tmp, sizeof(tmp));
+        m_gptr += sizeof(v);
+        return *this;
+    }
+};
+
+} // namespace lazperf
+