Create a fixed point table.

include/pdal/PointTable.hpp

@@ -56,65 +56,115 @@ class PDAL_DLL BasePointTable : public PointContainer
     virtual ~BasePointTable()
         {}
 
-public:
     // Layout operations.
     virtual PointLayoutPtr layout() const = 0;
 
     // Metadata operations.
     MetadataNode metadata()
         { return m_metadata->getNode(); }
+    virtual void finalize()
+        { layout()->finalize(); }
     SpatialReference spatialRef() const;
     void setSpatialRef(const SpatialReference& sref);
     MetadataNode privateMetadata(const std::string& name);
 
 private:
     // Point data operations.
     virtual PointId addPoint() = 0;
-    virtual char *getPoint(PointId idx) const = 0;
+
+protected:
+    virtual char *getPoint(PointId idx) = 0;
 
 protected:
     MetadataPtr m_metadata;
+
 };
 typedef BasePointTable& PointTableRef;
 typedef BasePointTable const & ConstPointTableRef;
 
 
-// This provides a context for processing a set of points and allows the library
-// to be used to process multiple point sets simultaneously.
-class PDAL_DLL PointTable : public BasePointTable
+class PDAL_DLL SimplePointTable : public BasePointTable
 {
 private:
-    // Point storage.
-    std::vector<char *> m_blocks;
-    point_count_t m_numPts;
     std::unique_ptr<PointLayout> m_layout;
 
 public:
-    PointTable() : m_numPts(0), m_layout(new PointLayout())
+    SimplePointTable() : m_layout(new PointLayout())
         {}
-    virtual ~PointTable();
 
     virtual PointLayoutPtr layout() const
         { return m_layout.get(); }
 
-private:
-    // Point data operations.
-    virtual PointId addPoint();
-    virtual char *getPoint(PointId idx) const;
+protected:
+    std::size_t pointsToBytes(point_count_t numPts) const
+        { return m_layout->pointSize() * numPts; }
 
+private:
     virtual void setFieldInternal(Dimension::Id::Enum id, PointId idx,
         const void *value);
     virtual void getFieldInternal(Dimension::Id::Enum id, PointId idx,
         void *value) const;
 
     // The number of points in each memory block.
+    char *getDimension(const Dimension::Detail *d, PointId idx)
+        { return getPoint(idx) + d->offset(); }
+
+    const char *getDimension(const Dimension::Detail *d, PointId idx) const
+    {
+        SimplePointTable *ncThis = const_cast<SimplePointTable *>(this);
+        return ncThis->getPoint(idx) + d->offset();
+    }
+};
+
+// This provides a context for processing a set of points and allows the library
+// to be used to process multiple point sets simultaneously.
+class PDAL_DLL PointTable : public SimplePointTable
+{
+private:
+    // Point storage.
+    std::vector<char *> m_blocks;
+    point_count_t m_numPts;
     static const point_count_t m_blockPtCnt = 65536;
 
-    char *getDimension(const Dimension::Detail *d, PointId idx) const
-        { return getPoint(idx) + d->offset(); }
+public:
+    PointTable() : m_numPts(0)
+        {}
+    virtual ~PointTable();
 
-    std::size_t pointsToBytes(point_count_t numPts) const
-        { return m_layout->pointSize() * numPts; }
+protected:
+    virtual char *getPoint(PointId idx);
+
+private:
+    // Point data operations.
+    virtual PointId addPoint();
+};
+
+class PDAL_DLL FixedPointTable : SimplePointTable
+{
+public:
+    FixedPointTable(point_count_t capacity) : m_capacity(capacity), m_numPts(0)
+    {}
+
+    virtual void finalize()
+    {
+        BasePointTable::finalize();
+        m_buf.resize(pointsToBytes(m_capacity + 1));
+    }
+
+    void reset()
+        { m_numPts = 0; }
+
+protected:
+    virtual char *getPoint(PointId idx)
+        { return m_buf.data() + pointsToBytes(idx); }
+
+private:
+    std::vector<char> m_buf;
+    point_count_t m_capacity;
+    point_count_t m_numPts;
+
+    virtual PointId addPoint()
+        { return ++m_numPts; }
 };
 
 } //namespace

src/PointTable.cpp

@@ -63,6 +63,26 @@ MetadataNode BasePointTable::privateMetadata(const std::string& name)
 }
 
 
+void SimplePointTable::setFieldInternal(Dimension::Id::Enum id, PointId idx,
+    const void *value)
+{
+    const Dimension::Detail *d = m_layout->dimDetail(id);
+    const char *src  = (const char *)value;
+    char *dst = getDimension(d, idx);
+    std::copy(src, src + d->size(), dst);
+}
+
+
+void SimplePointTable::getFieldInternal(Dimension::Id::Enum id, PointId idx,
+    void *value) const
+{
+    const Dimension::Detail *d = m_layout->dimDetail(id);
+    const char *src = getDimension(d, idx);
+    char *dst = (char *)value;
+    std::copy(src, src + d->size(), dst);
+}
+
+
 PointTable::~PointTable()
 {
     for (auto vi = m_blocks.begin(); vi != m_blocks.end(); ++vi)
@@ -82,30 +102,11 @@ PointId PointTable::addPoint()
 }
 
 
-char *PointTable::getPoint(PointId idx) const
+char *PointTable::getPoint(PointId idx)
 {
     char *buf = m_blocks[idx / m_blockPtCnt];
     return buf + pointsToBytes(idx % m_blockPtCnt);
 }
 
-
-void PointTable::setFieldInternal(Dimension::Id::Enum id, PointId idx,
-    const void *value)
-{
-    const Dimension::Detail *d = m_layout->dimDetail(id);
-    const char *src  = (const char *)value;
-    char *dst = getDimension(d, idx);
-    std::copy(src, src + d->size(), dst);
-}
-
-void PointTable::getFieldInternal(Dimension::Id::Enum id, PointId idx,
-    void *value) const
-{
-    const Dimension::Detail *d = m_layout->dimDetail(id);
-    const char *src = getDimension(d, idx);
-    char *dst = (char *)value;
-    std::copy(src, src + d->size(), dst);
-}
-
 } // namespace pdal
 

src/Stage.cpp

@@ -89,7 +89,7 @@ void Stage::prepare(PointTableRef table)
 
 PointViewSet Stage::execute(PointTableRef table)
 {
-    table.layout()->finalize();
+    table.finalize();
 
     PointViewSet views;
     if (m_inputs.empty())

test/unit/PointTableTest.cpp

@@ -116,7 +116,7 @@ TEST(PointTable, userView)
     public:
         PointId addPoint()
             { return 0; }
-        char *getPoint(PointId idx) const
+        char *getPoint(PointId idx)
             { return NULL; }
         void setFieldInternal(Dimension::Id::Enum id, PointId idx,
             const void *value)