dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/compression/expert_encode.h

@@ -0,0 +1,160 @@
+// Copyright 2017 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_EXPERT_ENCODE_H_
+#define DRACO_COMPRESSION_EXPERT_ENCODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Advanced helper class for encoding geometry using the Draco compression
+// library. Unlike the basic Encoder (encode.h), this class allows users to
+// specify options for each attribute individually using provided attribute ids.
+// The drawback of this encoder is that it can be used to encode only one model
+// at a time, and for each new model the options need to be set again,
+class ExpertEncoder : public EncoderBase<EncoderOptions> {
+ public:
+  typedef EncoderBase<EncoderOptions> Base;
+  typedef EncoderOptions OptionsType;
+
+  explicit ExpertEncoder(const PointCloud &point_cloud);
+  explicit ExpertEncoder(const Mesh &mesh);
+
+  // Encodes the geometry provided in the constructor to the target buffer.
+  Status EncodeToBuffer(EncoderBuffer *out_buffer);
+
+  // Set encoder options used during the geometry encoding. Note that this call
+  // overwrites any modifications to the options done with the functions below.
+  void Reset(const EncoderOptions &options);
+  void Reset();
+
+  // Sets the desired encoding and decoding speed for the given options.
+  //
+  //  0 = slowest speed, but the best compression.
+  // 10 = fastest, but the worst compression.
+  // -1 = undefined.
+  //
+  // Note that both speed options affect the encoder choice of used methods and
+  // algorithms. For example, a requirement for fast decoding may prevent the
+  // encoder from using the best compression methods even if the encoding speed
+  // is set to 0. In general, the faster of the two options limits the choice of
+  // features that can be used by the encoder. Additionally, setting
+  // |decoding_speed| to be faster than the |encoding_speed| may allow the
+  // encoder to choose the optimal method out of the available features for the
+  // given |decoding_speed|.
+  void SetSpeedOptions(int encoding_speed, int decoding_speed);
+
+  // Sets the quantization compression options for a specific attribute. The
+  // attribute values will be quantized in a box defined by the maximum extent
+  // of the attribute values. I.e., the actual precision of this option depends
+  // on the scale of the attribute values.
+  void SetAttributeQuantization(int32_t attribute_id, int quantization_bits);
+
+  // Sets the explicit quantization compression for a named attribute. The
+  // attribute values will be quantized in a coordinate system defined by the
+  // provided origin and range (the input values should be within interval:
+  // <origin, origin + range>).
+  void SetAttributeExplicitQuantization(int32_t attribute_id,
+                                        int quantization_bits, int num_dims,
+                                        const float *origin, float range);
+
+  // Enables/disables built in entropy coding of attribute values. Disabling
+  // this option may be useful to improve the performance when third party
+  // compression is used on top of the Draco compression. Default: [true].
+  void SetUseBuiltInAttributeCompression(bool enabled);
+
+  // Sets the desired encoding method for a given geometry. By default, encoding
+  // method is selected based on the properties of the input geometry and based
+  // on the other options selected in the used EncoderOptions (such as desired
+  // encoding and decoding speed). This function should be called only when a
+  // specific method is required.
+  //
+  // |encoding_method| can be one of the values defined in
+  // compression/config/compression_shared.h based on the type of the input
+  // geometry that is going to be encoded. For point clouds, allowed entries are
+  //   POINT_CLOUD_SEQUENTIAL_ENCODING
+  //   POINT_CLOUD_KD_TREE_ENCODING
+  //
+  // For meshes the input can be
+  //   MESH_SEQUENTIAL_ENCODING
+  //   MESH_EDGEBREAKER_ENCODING
+  //
+  // If the selected method cannot be used for the given input, the subsequent
+  // call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
+  void SetEncodingMethod(int encoding_method);
+
+  // Sets the desired encoding submethod, only for MESH_EDGEBREAKER_ENCODING.
+  // Valid values for |encoding_submethod| are:
+  //   MESH_EDGEBREAKER_STANDARD_ENCODING
+  //   MESH_EDGEBREAKER_VALENCE_ENCODING
+  // see also compression/config/compression_shared.h.
+  void SetEncodingSubmethod(int encoding_submethod);
+
+  // Sets the desired prediction method for a given attribute. By default,
+  // prediction scheme is selected automatically by the encoder using other
+  // provided options (such as speed) and input geometry type (mesh, point
+  // cloud). This function should be called only when a specific prediction is
+  // preferred (e.g., when it is known that the encoder would select a less
+  // optimal prediction for the given input data).
+  //
+  // |prediction_scheme_method| should be one of the entries defined in
+  // compression/config/compression_shared.h :
+  //
+  //   PREDICTION_NONE - use no prediction.
+  //   PREDICTION_DIFFERENCE - delta coding
+  //   MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
+  //   MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
+  //      - better and more costly version of the parallelogram prediction.
+  //   MESH_PREDICTION_TEX_COORDS_PORTABLE
+  //      - specialized predictor for tex coordinates.
+  //   MESH_PREDICTION_GEOMETRIC_NORMAL
+  //      - specialized predictor for normal coordinates.
+  //
+  // Note that in case the desired prediction cannot be used, the default
+  // prediction will be automatically used instead.
+  Status SetAttributePredictionScheme(int32_t attribute_id,
+                                      int prediction_scheme_method);
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Applies grid quantization to position attribute in point cloud |pc| at
+  // |attribute_index| with a given grid |spacing|.
+  Status SetAttributeGridQuantization(const PointCloud &pc, int attribute_index,
+                                      float spacing);
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+ private:
+  Status EncodePointCloudToBuffer(const PointCloud &pc,
+                                  EncoderBuffer *out_buffer);
+
+  Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Applies compression options stored in |pc|.
+  Status ApplyCompressionOptions(const PointCloud &pc);
+  Status ApplyGridQuantization(const PointCloud &pc, int attribute_index);
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+  const PointCloud *point_cloud_;
+  const Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_EXPERT_ENCODE_H_

include/draco/compression/mesh/mesh_decoder.h

@@ -0,0 +1,68 @@
+// 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_MESH_MESH_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_DECODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Class that reconstructs a 3D mesh from input data that was encoded by
+// MeshEncoder.
+class MeshDecoder : public PointCloudDecoder {
+ public:
+  MeshDecoder();
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // The main entry point for mesh decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                Mesh *out_mesh);
+
+  // Returns the base connectivity of the decoded mesh (or nullptr if it is not
+  // initialized).
+  virtual const CornerTable *GetCornerTable() const { return nullptr; }
+
+  // Returns the attribute connectivity data or nullptr if it does not exist.
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  // Returns the decoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  Mesh *mesh() const { return mesh_; }
+
+ protected:
+  bool DecodeGeometryData() override;
+  virtual bool DecodeConnectivity() = 0;
+
+ private:
+  Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_DECODER_H_

include/draco/compression/mesh/mesh_edgebreaker_decoder.h

@@ -0,0 +1,54 @@
+// 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_MESH_MESH_EDGEBREAKER_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshEdgebreakerEncoder.
+class MeshEdgebreakerDecoder : public MeshDecoder {
+ public:
+  MeshEdgebreakerDecoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+ protected:
+  bool InitializeDecoder() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+
+  std::unique_ptr<MeshEdgebreakerDecoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_

include/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h

@@ -0,0 +1,228 @@
+// 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_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Implementation of the edgebreaker decoder that decodes data encoded with the
+// MeshEdgebreakerEncoderImpl class. The implementation of the decoder is based
+// on the algorithm presented in Isenburg et al'02 "Spirale Reversi: Reverse
+// decoding of the Edgebreaker encoding". Note that the encoding is still based
+// on the standard edgebreaker method as presented in "3D Compression
+// Made Simple: Edgebreaker on a Corner-Table" by Rossignac at al.'01.
+// http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf. One difference is
+// caused by the properties of the spirale reversi algorithm that decodes the
+// symbols from the last one to the first one. To make the decoding more
+// efficient, we encode all symbols in the reverse order, therefore the decoder
+// can process them one by one.
+// The main advantage of the spirale reversi method is that the partially
+// decoded mesh has valid connectivity data at any time during the decoding
+// process (valid with respect to the decoded portion of the mesh). The standard
+// Edgebreaker decoder used two passes (forward decoding + zipping) which not
+// only prevented us from having a valid connectivity but it was also slower.
+// The main benefit of having the valid connectivity is that we can use the
+// known connectivity to predict encoded symbols that can improve the
+// compression rate.
+template <class TraversalDecoderT>
+class MeshEdgebreakerDecoderImpl : public MeshEdgebreakerDecoderImplInterface {
+ public:
+  MeshEdgebreakerDecoderImpl();
+  bool Init(MeshEdgebreakerDecoder *decoder) override;
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override;
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override;
+
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+  MeshEdgebreakerDecoder *GetDecoder() const override { return decoder_; }
+  const CornerTable *GetCornerTable() const override {
+    return corner_table_.get();
+  }
+
+ private:
+  // Creates a vertex traversal sequencer for the specified |TraverserT| type.
+  template <class TraverserT>
+  std::unique_ptr<PointsSequencer> CreateVertexTraversalSequencer(
+      MeshAttributeIndicesEncodingData *encoding_data);
+
+  // Decodes connectivity between vertices (vertex indices).
+  // Returns the number of vertices created by the decoder or -1 on error.
+  int DecodeConnectivity(int num_symbols);
+
+  // Returns true if the current symbol was part of a topology split event. This
+  // means that the current face was connected to the left edge of a face
+  // encoded with the TOPOLOGY_S symbol. |out_symbol_edge| can be used to
+  // identify which edge of the source symbol was connected to the TOPOLOGY_S
+  // symbol.
+  bool IsTopologySplit(int encoder_symbol_id, EdgeFaceName *out_face_edge,
+                       int *out_encoder_split_symbol_id) {
+    if (topology_split_data_.size() == 0) {
+      return false;
+    }
+    if (topology_split_data_.back().source_symbol_id >
+        static_cast<uint32_t>(encoder_symbol_id)) {
+      // Something is wrong; if the desired source symbol is greater than the
+      // current encoder_symbol_id, we missed it, or the input was tampered
+      // (|encoder_symbol_id| keeps decreasing).
+      // Return invalid symbol id to notify the decoder that there was an
+      // error.
+      *out_encoder_split_symbol_id = -1;
+      return true;
+    }
+    if (topology_split_data_.back().source_symbol_id != encoder_symbol_id) {
+      return false;
+    }
+    *out_face_edge =
+        static_cast<EdgeFaceName>(topology_split_data_.back().source_edge);
+    *out_encoder_split_symbol_id = topology_split_data_.back().split_symbol_id;
+    // Remove the latest split event.
+    topology_split_data_.pop_back();
+    return true;
+  }
+
+  // Decodes event data for hole and topology split events and stores them for
+  // future use.
+  // Returns the number of parsed bytes, or -1 on error.
+  int32_t DecodeHoleAndTopologySplitEvents(DecoderBuffer *decoder_buffer);
+
+  // Decodes all non-position attribute connectivity on the currently
+  // processed face.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  bool DecodeAttributeConnectivitiesOnFaceLegacy(CornerIndex corner);
+#endif
+  bool DecodeAttributeConnectivitiesOnFace(CornerIndex corner);
+
+  // Initializes mapping between corners and point ids.
+  bool AssignPointsToCorners(int num_connectivity_verts);
+
+  bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id < 0) {
+      return true;  // Invalid corner signalizes that the face does not exist.
+    }
+    return visited_faces_[corner_table_->Face(corner_id).value()];
+  }
+
+  void SetOppositeCorners(CornerIndex corner_0, CornerIndex corner_1) {
+    corner_table_->SetOppositeCorner(corner_0, corner_1);
+    corner_table_->SetOppositeCorner(corner_1, corner_0);
+  }
+
+  MeshEdgebreakerDecoder *decoder_;
+
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Stack used for storing corners that need to be traversed when decoding
+  // mesh vertices. New corner is added for each initial face and a split
+  // symbol, and one corner is removed when the end symbol is reached.
+  // Stored as member variable to prevent frequent memory reallocations when
+  // handling meshes with lots of disjoint components.  Originally, we used
+  // recursive functions to handle this behavior, but that can cause stack
+  // memory overflow when compressing huge meshes.
+  std::vector<CornerIndex> corner_traversal_stack_;
+
+  // Array stores the number of visited visited for each mesh traversal.
+  std::vector<int> vertex_traversal_length_;
+
+  // List of decoded topology split events.
+  std::vector<TopologySplitEventData> topology_split_data_;
+
+  // List of decoded hole events.
+  std::vector<HoleEventData> hole_event_data_;
+
+  // Configuration of the initial face for each mesh component.
+  std::vector<bool> init_face_configurations_;
+
+  // Initial corner for each traversal.
+  std::vector<CornerIndex> init_corners_;
+
+  // Id of the last processed input symbol.
+  int last_symbol_id_;
+
+  // Id of the last decoded vertex.
+  int last_vert_id_;
+
+  // Id of the last decoded face.
+  int last_face_id_;
+
+  // Array for marking visited faces.
+  std::vector<bool> visited_faces_;
+  // Array for marking visited vertices.
+  std::vector<bool> visited_verts_;
+  // Array for marking vertices on open boundaries.
+  std::vector<bool> is_vert_hole_;
+
+  // The number of new vertices added by the encoder (because of non-manifold
+  // vertices on the input mesh).
+  // If there are no non-manifold edges/vertices on the input mesh, this should
+  // be 0.
+  int num_new_vertices_;
+  // For every newly added vertex, this array stores it's mapping to the
+  // parent vertex id of the encoded mesh.
+  std::unordered_map<int, int> new_to_parent_vertex_map_;
+  // The number of vertices that were encoded (can be different from the number
+  // of vertices of the input mesh).
+  int num_encoded_vertices_;
+
+  // Array for storing the encoded corner ids in the order their associated
+  // vertices were decoded.
+  std::vector<int32_t> processed_corner_ids_;
+
+  // Array storing corners in the order they were visited during the
+  // connectivity decoding (always storing the tip corner of each newly visited
+  // face).
+  std::vector<int> processed_connectivity_corners_;
+
+  MeshAttributeIndicesEncodingData pos_encoding_data_;
+
+  // Id of an attributes decoder that uses |pos_encoding_data_|.
+  int pos_data_decoder_id_;
+
+  // Data for non-position attributes used by the decoder.
+  struct AttributeData {
+    AttributeData() : decoder_id(-1), is_connectivity_used(true) {}
+    // Id of the attribute decoder that was used to decode this attribute data.
+    int decoder_id;
+    MeshAttributeCornerTable connectivity_data;
+    // Flag that can mark the connectivity_data invalid. In such case the base
+    // corner table of the mesh should be used instead.
+    bool is_connectivity_used;
+    MeshAttributeIndicesEncodingData encoding_data;
+    // Opposite corners to attribute seam edges.
+    std::vector<int32_t> attribute_seam_corners;
+  };
+  std::vector<AttributeData> attribute_data_;
+
+  TraversalDecoderT traversal_decoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_

include/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h

@@ -0,0 +1,47 @@
+// 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_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Forward declaration is necessary here to avoid circular dependencies.
+class MeshEdgebreakerDecoder;
+
+// Abstract interface used by MeshEdgebreakerDecoder to interact with the actual
+// implementation of the edgebreaker decoding method.
+class MeshEdgebreakerDecoderImplInterface {
+ public:
+  virtual ~MeshEdgebreakerDecoderImplInterface() = default;
+  virtual bool Init(MeshEdgebreakerDecoder *decoder) = 0;
+
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const = 0;
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const = 0;
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeConnectivity() = 0;
+  virtual bool OnAttributesDecoded() = 0;
+
+  virtual MeshEdgebreakerDecoder *GetDecoder() const = 0;
+  virtual const CornerTable *GetCornerTable() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_

include/draco/compression/mesh/mesh_edgebreaker_encoder.h

@@ -0,0 +1,73 @@
+// 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_MESH_MESH_EDGEBREAKER_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
+
+#include <unordered_map>
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class implements the edge breaker geometry compression method as described
+// in "3D Compression Made Simple: Edgebreaker on a Corner-Table" by Rossignac
+// at al.'01. http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf
+class MeshEdgebreakerEncoder : public MeshEncoder {
+ public:
+  MeshEdgebreakerEncoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+  uint8_t GetEncodingMethod() const override {
+    return MESH_EDGEBREAKER_ENCODING;
+  }
+
+ protected:
+  bool InitializeEncoder() override;
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // The actual implementation of the edge breaker method. The implementations
+  // are in general specializations of a template class
+  // MeshEdgebreakerEncoderImpl where the template arguments control encoding
+  // of the connectivity data. The actual implementation is selected in this
+  // class based on the provided encoding options. Because this choice is done
+  // in run-time, the actual implementation has to be hidden behind the
+  // abstract interface MeshEdgebreakerEncoderImplInterface.
+  std::unique_ptr<MeshEdgebreakerEncoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_