dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/compression/point_cloud/algorithms/point_cloud_types.h

@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+
+#include <inttypes.h>
+
+#include <vector>
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Using Eigen as this is favored by project Cartographer.
+typedef Vector3f Point3f;
+typedef Vector4f Point4f;
+typedef Vector3ui Point3ui;
+typedef Vector4ui Point4ui;
+typedef Vector5ui Point5ui;
+typedef Vector6ui Point6ui;
+typedef Vector7ui Point7ui;
+
+typedef std::vector<Point3f> PointCloud3f;
+
+template <class PointDT>
+struct PointDLess;
+
+template <class CoeffT, int dimension_t>
+struct PointDLess<VectorD<CoeffT, dimension_t>> {
+  bool operator()(const VectorD<CoeffT, dimension_t> &a,
+                  const VectorD<CoeffT, dimension_t> &b) const {
+    return a < b;
+  }
+};
+
+template <class PointDT>
+class PointTraits {};
+
+template <class CoordinateTypeT, int dimension_t>
+class PointTraits<VectorD<CoordinateTypeT, dimension_t>> {
+ public:
+  typedef VectorD<CoordinateTypeT, dimension_t> PointD;
+  typedef CoordinateTypeT CoordinateType;
+
+  static constexpr uint32_t Dimension() { return dimension_t; }
+  static PointD Origin() {
+    PointD origin;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      origin(i) = 0;
+    }
+    return origin;
+  }
+  static std::array<uint32_t, dimension_t> ZeroArray() {
+    std::array<uint32_t, dimension_t> zero;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      zero[i] = 0;
+    }
+    return zero;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_

include/draco/compression/point_cloud/algorithms/quantize_points_3.h

@@ -0,0 +1,84 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+
+#include <inttypes.h>
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+// TODO(b/199760123): Make this a stable bounding box.
+struct QuantizationInfo {
+  uint32_t quantization_bits;
+  float range;
+};
+
+template <class PointIterator, class OutputIterator>
+OutputIterator QuantizePoints3(const PointIterator &begin,
+                               const PointIterator &end, QuantizationInfo *info,
+                               OutputIterator oit) {
+  DRACO_DCHECK_GE(info->quantization_bits, 0);
+
+  float max_range = 0;
+  for (auto it = begin; it != end; ++it) {
+    max_range = std::max(std::fabs((*it)[0]), max_range);
+    max_range = std::max(std::fabs((*it)[1]), max_range);
+    max_range = std::max(std::fabs((*it)[2]), max_range);
+  }
+
+  const uint32_t max_quantized_value((1u << info->quantization_bits) - 1);
+  Quantizer quantize;
+  quantize.Init(max_range, max_quantized_value);
+  info->range = max_range;
+
+  Point3ui qpoint;
+  for (auto it = begin; it != end; ++it) {
+    // Quantize and all positive.
+    qpoint[0] = quantize((*it)[0]) + max_quantized_value;
+    qpoint[1] = quantize((*it)[1]) + max_quantized_value;
+    qpoint[2] = quantize((*it)[2]) + max_quantized_value;
+    *oit++ = (qpoint);
+  }
+
+  return oit;
+}
+
+template <class QPointIterator, class OutputIterator>
+void DequantizePoints3(const QPointIterator &begin, const QPointIterator &end,
+                       const QuantizationInfo &info, OutputIterator &oit) {
+  DRACO_DCHECK_GE(info.quantization_bits, 0);
+  DRACO_DCHECK_GE(info.range, 0);
+
+  const uint32_t quantization_bits = info.quantization_bits;
+  const float range = info.range;
+  const uint32_t max_quantized_value((1u << quantization_bits) - 1);
+  Dequantizer dequantize;
+  dequantize.Init(range, max_quantized_value);
+
+  for (auto it = begin; it != end; ++it) {
+    const float x = dequantize((*it)[0] - max_quantized_value);
+    const float y = dequantize((*it)[1] - max_quantized_value);
+    const float z = dequantize((*it)[2] - max_quantized_value);
+    *oit = Point3f(x, y, z);
+    ++oit;
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_

include/draco/compression/point_cloud/algorithms/queuing_policy.h

@@ -0,0 +1,75 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File defining a coherent interface for different queuing strategies.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+
+#include <queue>
+#include <stack>
+#include <utility>
+
+namespace draco {
+
+template <class T>
+class Queue {
+ public:
+  bool empty() const { return q_.empty(); }
+  typename std::queue<T>::size_type size() const { return q_.size(); }
+  void clear() { return q_.clear(); }
+  void push(const T &value) { q_.push(value); }
+  void push(T &&value) { q_.push(std::move(value)); }
+  void pop() { q_.pop(); }
+  typename std::queue<T>::const_reference front() const { return q_.front(); }
+
+ private:
+  std::queue<T> q_;
+};
+
+template <class T>
+class Stack {
+ public:
+  bool empty() const { return s_.empty(); }
+  typename std::stack<T>::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename std::stack<T>::const_reference front() const { return s_.top(); }
+
+ private:
+  std::stack<T> s_;
+};
+
+template <class T, class Compare = std::less<T> >
+class PriorityQueue {
+  typedef std::priority_queue<T, std::vector<T>, Compare> QType;
+
+ public:
+  bool empty() const { return s_.empty(); }
+  typename QType::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename QType::const_reference front() const { return s_.top(); }
+
+ private:
+  QType s_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_

include/draco/compression/point_cloud/point_cloud_decoder.h

@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+
+#include "draco/compression/attributes/attributes_decoder_interface.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/decoder_options.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh decoders. It provides a
+// basic functionality that is shared between different decoders.
+class PointCloudDecoder {
+ public:
+  PointCloudDecoder();
+  virtual ~PointCloudDecoder() = default;
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Decodes a Draco header int other provided |out_header|.
+  // Returns false on error.
+  static Status DecodeHeader(DecoderBuffer *buffer, DracoHeader *out_header);
+
+  // The main entry point for point cloud decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                PointCloud *out_point_cloud);
+
+  bool SetAttributesDecoder(
+      int att_decoder_id, std::unique_ptr<AttributesDecoderInterface> decoder) {
+    if (att_decoder_id < 0) {
+      return false;
+    }
+    if (att_decoder_id >= static_cast<int>(attributes_decoders_.size())) {
+      attributes_decoders_.resize(att_decoder_id + 1);
+    }
+    attributes_decoders_[att_decoder_id] = std::move(decoder);
+    return true;
+  }
+
+  // Returns an attribute containing decoded data in their portable form that
+  // is guaranteed to be the same for both encoder and decoder. I.e., it returns
+  // an attribute before it was transformed back into its final form which may
+  // be slightly different (non-portable) across platforms. For example, for
+  // attributes encoded with quantization, this method returns an attribute
+  // that contains the quantized values (before the dequantization step).
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  uint16_t bitstream_version() const {
+    return DRACO_BITSTREAM_VERSION(version_major_, version_minor_);
+  }
+
+  const AttributesDecoderInterface *attributes_decoder(int dec_id) {
+    return attributes_decoders_[dec_id].get();
+  }
+  int32_t num_attributes_decoders() const {
+    return static_cast<int32_t>(attributes_decoders_.size());
+  }
+
+  // Get a mutable pointer to the decoded point cloud. This is intended to be
+  // used mostly by other decoder subsystems.
+  PointCloud *point_cloud() { return point_cloud_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+  DecoderBuffer *buffer() { return buffer_; }
+  const DecoderOptions *options() const { return options_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the decoder. Called in the Decode() method.
+  virtual bool InitializeDecoder() { return true; }
+
+  // Creates an attribute decoder.
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeGeometryData() { return true; }
+  virtual bool DecodePointAttributes();
+
+  virtual bool DecodeAllAttributes();
+  virtual bool OnAttributesDecoded() { return true; }
+
+  Status DecodeMetadata();
+
+ private:
+  // Point cloud that is being filled in by the decoder.
+  PointCloud *point_cloud_;
+
+  std::vector<std::unique_ptr<AttributesDecoderInterface>> attributes_decoders_;
+
+  // Map between attribute id and decoder id.
+  std::vector<int32_t> attribute_to_decoder_map_;
+
+  // Input buffer holding the encoded data.
+  DecoderBuffer *buffer_;
+
+  // Bit-stream version of the encoder that encoded the input data.
+  uint8_t version_major_;
+  uint8_t version_minor_;
+
+  const DecoderOptions *options_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_

include/draco/compression/point_cloud/point_cloud_encoder.h

@@ -0,0 +1,158 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh encoders. It provides a
+// basic functionality that's shared between different encoders.
+class PointCloudEncoder {
+ public:
+  PointCloudEncoder();
+  virtual ~PointCloudEncoder() = default;
+
+  // Sets the point cloud that is going be encoded. Must be called before the
+  // Encode() method.
+  void SetPointCloud(const PointCloud &pc);
+
+  // The main entry point that encodes provided point cloud.
+  Status Encode(const EncoderOptions &options, EncoderBuffer *out_buffer);
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Returns the unique identifier of the encoding method (such as Edgebreaker
+  // for mesh compression).
+  virtual uint8_t GetEncodingMethod() const = 0;
+
+  // Returns the number of points that were encoded during the last Encode()
+  // function call. Valid only if "store_number_of_encoded_points" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_points() const { return num_encoded_points_; }
+
+  int num_attributes_encoders() const {
+    return static_cast<int>(attributes_encoders_.size());
+  }
+  AttributesEncoder *attributes_encoder(int i) {
+    return attributes_encoders_[i].get();
+  }
+
+  // Adds a new attribute encoder, returning its id.
+  int AddAttributesEncoder(std::unique_ptr<AttributesEncoder> att_enc) {
+    attributes_encoders_.push_back(std::move(att_enc));
+    return static_cast<int>(attributes_encoders_.size() - 1);
+  }
+
+  // Marks one attribute as a parent of another attribute. Must be called after
+  // all attribute encoders are created (usually in the
+  // AttributeEncoder::Init() method).
+  bool MarkParentAttribute(int32_t parent_att_id);
+
+  // Returns an attribute containing portable version of the attribute data that
+  // is guaranteed to be encoded losslessly. This attribute can be used safely
+  // as predictor for other attributes.
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  EncoderBuffer *buffer() { return buffer_; }
+  const EncoderOptions *options() const { return options_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the encoder. Called in the Encode() method.
+  virtual bool InitializeEncoder() { return true; }
+
+  // Should be used to encode any encoder-specific data.
+  virtual bool EncodeEncoderData() { return true; }
+
+  // Encodes any global geometry data (such as the number of points).
+  virtual Status EncodeGeometryData() { return OkStatus(); }
+
+  // encode all attribute values. The attribute encoders are sorted to resolve
+  // any attribute dependencies and all the encoded data is stored into the
+  // |buffer_|.
+  // Returns false if the encoding failed.
+  virtual bool EncodePointAttributes();
+
+  // Generate attribute encoders that are going to be used for encoding
+  // point attribute data. Calls GenerateAttributesEncoder() for every attribute
+  // of the encoded PointCloud.
+  virtual bool GenerateAttributesEncoders();
+
+  // Creates attribute encoder for a specific point attribute. This function
+  // needs to be implemented by the derived classes. The derived classes need
+  // to either 1. Create a new attribute encoder and add it using the
+  // AddAttributeEncoder method, or 2. add the attribute to an existing
+  // attribute encoder (using AttributesEncoder::AddAttributeId() method).
+  virtual bool GenerateAttributesEncoder(int32_t att_id) = 0;
+
+  // Encodes any data that is necessary to recreate a given attribute encoder.
+  // Note: this is called in order in which the attribute encoders are going to
+  // be encoded.
+  virtual bool EncodeAttributesEncoderIdentifier(int32_t /* att_encoder_id */) {
+    return true;
+  }
+
+  // Encodes all the attribute data using the created attribute encoders.
+  virtual bool EncodeAllAttributes();
+
+  // Computes and sets the num_encoded_points_ for the encoder.
+  virtual void ComputeNumberOfEncodedPoints() = 0;
+
+  void set_num_encoded_points(size_t num_points) {
+    num_encoded_points_ = num_points;
+  }
+
+ private:
+  // Encodes Draco header that is the same for all encoders.
+  Status EncodeHeader();
+
+  // Encode metadata.
+  Status EncodeMetadata();
+
+  // Rearranges attribute encoders and their attributes to reflect the
+  // underlying attribute dependencies. This ensures that the attributes are
+  // encoded in the correct order (parent attributes before their children).
+  bool RearrangeAttributesEncoders();
+
+  const PointCloud *point_cloud_;
+  std::vector<std::unique_ptr<AttributesEncoder>> attributes_encoders_;
+
+  // Map between attribute id and encoder id.
+  std::vector<int32_t> attribute_to_encoder_map_;
+
+  // Encoding order of individual attribute encoders (i.e., the order in which
+  // they are processed during encoding that may be different from the order
+  // in which they were created because of attribute dependencies.
+  std::vector<int32_t> attributes_encoder_ids_order_;
+
+  // This buffer holds the final encoded data.
+  EncoderBuffer *buffer_;
+
+  const EncoderOptions *options_;
+
+  size_t num_encoded_points_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_

include/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h

@@ -0,0 +1,31 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Decodes PointCloud encoded with the PointCloudKdTreeEncoder.
+class PointCloudKdTreeDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_

include/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h

@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// Encodes a PointCloud using one of the available Kd-tree compression methods.
+// See FloatPointsKdTreeEncoder and DynamicIntegerPointsKdTreeEncoder for more
+// details. Currently, the input PointCloud must satisfy the following
+// requirements to use this encoder:
+//  1. PointCloud has only one attribute of type GeometryAttribute::POSITION.
+//  2. The position attribute has three components (x,y,z).
+//  3. The position values are stored as either DT_FLOAT32 or DT_UINT32.
+//  4. If the position values are stored as DT_FLOAT32, quantization needs to
+//     be enabled for the position attribute.
+class PointCloudKdTreeEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_KD_TREE_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_

include/draco/compression/point_cloud/point_cloud_sequential_decoder.h

@@ -0,0 +1,33 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Point cloud decoder for data encoded by the PointCloudSequentialEncoder.
+// All attribute values are decoded using an identity mapping between point ids
+// and attribute value ids.
+class PointCloudSequentialDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_

include/draco/compression/point_cloud/point_cloud_sequential_encoder.h

@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// A basic point cloud encoder that iterates over all points and encodes all
+// attribute values for every visited point. The attribute values encoding
+// can be controlled using provided encoding option to enable features such
+// as quantization or prediction schemes.
+// This encoder preserves the order and the number of input points, but the
+// mapping between point ids and attribute values may be different for the
+// decoded point cloud.
+class PointCloudSequentialEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_