dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h

@@ -0,0 +1,226 @@
+// 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_TRAVERSAL_VALENCE_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
+
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// Predictive encoder for the Edgebreaker symbols based on valences of the
+// previously encoded vertices, following the method described in: Szymczak'02,
+// "Optimized Edgebreaker Encoding for Large and Regular Triangle Meshes". Each
+// valence is used to specify a different entropy context for encoding of the
+// symbols.
+// Encoder can operate in various predefined modes that can be used to select
+// the way in which the entropy contexts are computed (e.g. using different
+// clamping for valences, or even using different inputs to compute the
+// contexts), see EdgebreakerValenceCodingMode in mesh_edgebreaker_shared.h for
+// a list of supported modes.
+class MeshEdgebreakerTraversalValenceEncoder
+    : public MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalValenceEncoder()
+      : corner_table_(nullptr),
+        prev_symbol_(-1),
+        last_corner_(kInvalidCornerIndex),
+        num_symbols_(0),
+        min_valence_(2),
+        max_valence_(7) {}
+
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    if (!MeshEdgebreakerTraversalEncoder::Init(encoder)) {
+      return false;
+    }
+    min_valence_ = 2;
+    max_valence_ = 7;
+    corner_table_ = encoder->GetCornerTable();
+
+    // Initialize valences of all vertices.
+    vertex_valences_.resize(corner_table_->num_vertices());
+    for (VertexIndex i(0); i < static_cast<uint32_t>(vertex_valences_.size());
+         ++i) {
+      vertex_valences_[i] = corner_table_->Valence(VertexIndex(i));
+    }
+
+    // Replicate the corner to vertex map from the corner table. We need to do
+    // this because the map may get updated during encoding because we add new
+    // vertices when we encounter split symbols.
+    corner_to_vertex_map_.resize(corner_table_->num_corners());
+    for (CornerIndex i(0); i < corner_table_->num_corners(); ++i) {
+      corner_to_vertex_map_[i] = corner_table_->Vertex(i);
+    }
+    const int32_t num_unique_valences = max_valence_ - min_valence_ + 1;
+
+    context_symbols_.resize(num_unique_valences);
+    return true;
+  }
+
+  inline void NewCornerReached(CornerIndex corner) { last_corner_ = corner; }
+
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    ++num_symbols_;
+    // Update valences on the mesh and compute the context that is going to be
+    // used to encode the processed symbol.
+    // Note that the valences are computed for the so far unencoded part of the
+    // mesh (i.e. the decoding is reverse). Adding a new symbol either reduces
+    // valences on the vertices or leaves the valence unchanged.
+
+    const CornerIndex next = corner_table_->Next(last_corner_);
+    const CornerIndex prev = corner_table_->Previous(last_corner_);
+
+    // Get valence on the tip corner of the active edge (outgoing edge that is
+    // going to be used in reverse decoding of the connectivity to predict the
+    // next symbol).
+    const int active_valence = vertex_valences_[corner_to_vertex_map_[next]];
+    switch (symbol) {
+      case TOPOLOGY_C:
+        // Compute prediction.
+        FALLTHROUGH_INTENDED;
+      case TOPOLOGY_S:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        if (symbol == TOPOLOGY_S) {
+          // Whenever we reach a split symbol, we need to split the vertex into
+          // two and attach all corners on the left and right sides of the split
+          // vertex to the respective vertices (see image below). This is
+          // necessary since the decoder works in the reverse order and it
+          // merges the two vertices only after the split symbol is processed.
+          //
+          //     * -----
+          //    / \--------
+          //   /   \--------
+          //  /     \-------
+          // *-------v-------*
+          //  \     /c\     /
+          //   \   /   \   /
+          //    \ /n S p\ /
+          //     *.......*
+          //
+
+          // Count the number of faces on the left side of the split vertex and
+          // update the valence on the "left vertex".
+          int num_left_faces = 0;
+          CornerIndex act_c = corner_table_->Opposite(prev);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_left_faces;
+            act_c = corner_table_->Opposite(corner_table_->Next(act_c));
+          }
+          vertex_valences_[corner_to_vertex_map_[last_corner_]] =
+              num_left_faces + 1;
+
+          // Create a new vertex for the right side and count the number of
+          // faces that should be attached to this vertex.
+          const int new_vert_id = static_cast<int>(vertex_valences_.size());
+          int num_right_faces = 0;
+
+          act_c = corner_table_->Opposite(next);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_right_faces;
+            // Map corners on the right side to the newly created vertex.
+            corner_to_vertex_map_[corner_table_->Next(act_c)] = new_vert_id;
+            act_c = corner_table_->Opposite(corner_table_->Previous(act_c));
+          }
+          vertex_valences_.push_back(num_right_faces + 1);
+        }
+        break;
+      case TOPOLOGY_R:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      case TOPOLOGY_L:
+
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      default:
+        break;
+    }
+
+    if (prev_symbol_ != -1) {
+      int clamped_valence;
+      if (active_valence < min_valence_) {
+        clamped_valence = min_valence_;
+      } else if (active_valence > max_valence_) {
+        clamped_valence = max_valence_;
+      } else {
+        clamped_valence = active_valence;
+      }
+
+      const int context = clamped_valence - min_valence_;
+      context_symbols_[context].push_back(
+          edge_breaker_topology_to_symbol_id[prev_symbol_]);
+    }
+
+    prev_symbol_ = symbol;
+  }
+
+  void Done() {
+    // Store the init face configurations and attribute seam data
+    MeshEdgebreakerTraversalEncoder::EncodeStartFaces();
+    MeshEdgebreakerTraversalEncoder::EncodeAttributeSeams();
+
+    // Store the contexts.
+    for (int i = 0; i < context_symbols_.size(); ++i) {
+      EncodeVarint<uint32_t>(static_cast<uint32_t>(context_symbols_[i].size()),
+                             GetOutputBuffer());
+      if (context_symbols_[i].size() > 0) {
+        EncodeSymbols(context_symbols_[i].data(),
+                      static_cast<int>(context_symbols_[i].size()), 1, nullptr,
+                      GetOutputBuffer());
+      }
+    }
+  }
+
+  int NumEncodedSymbols() const { return num_symbols_; }
+
+ private:
+  const CornerTable *corner_table_;
+  // Explicit map between corners and vertices. We cannot use the one stored
+  // in the |corner_table_| because we may need to add additional vertices to
+  // handle split symbols.
+  IndexTypeVector<CornerIndex, VertexIndex> corner_to_vertex_map_;
+  IndexTypeVector<VertexIndex, int> vertex_valences_;
+  // Previously encoded symbol.
+  int32_t prev_symbol_;
+  CornerIndex last_corner_;
+  // Explicitly count the number of encoded symbols.
+  int num_symbols_;
+
+  int min_valence_;
+  int max_valence_;
+  std::vector<std::vector<uint32_t>> context_symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_

include/draco/compression/mesh/mesh_encoder.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_MESH_MESH_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Abstract base class for all mesh encoders. It provides some basic
+// functionality that's shared between different encoders.
+class MeshEncoder : public PointCloudEncoder {
+ public:
+  MeshEncoder();
+
+  // Sets the mesh that is going be encoded. Must be called before the Encode()
+  // method.
+  void SetMesh(const Mesh &m);
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // Returns the number of faces that were encoded during the last Encode().
+  // function call. Valid only if "store_number_of_encoded_faces" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_faces() const { return num_encoded_faces_; }
+
+  // Returns the base connectivity of the encoded 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 encoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  const Mesh *mesh() const { return mesh_; }
+
+ protected:
+  Status EncodeGeometryData() override;
+
+  // Needs to be implemented by the derived classes.
+  virtual Status EncodeConnectivity() = 0;
+
+  // Computes and sets the num_encoded_faces_ for the encoder.
+  virtual void ComputeNumberOfEncodedFaces() = 0;
+
+  void set_mesh(const Mesh *mesh) { mesh_ = mesh; }
+  void set_num_encoded_faces(size_t num_faces) {
+    num_encoded_faces_ = num_faces;
+  }
+
+ private:
+  const Mesh *mesh_;
+  size_t num_encoded_faces_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_ENCODER_H_

include/draco/compression/mesh/mesh_sequential_decoder.h

@@ -0,0 +1,39 @@
+// 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_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshSequentialEncoder.
+class MeshSequentialDecoder : public MeshDecoder {
+ public:
+  MeshSequentialDecoder();
+
+ protected:
+  bool DecodeConnectivity() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+
+ private:
+  // Decodes face indices that were compressed with an entropy code.
+  // Returns false on error.
+  bool DecodeAndDecompressIndices(uint32_t num_faces);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_

include/draco/compression/mesh/mesh_sequential_encoder.h

@@ -0,0 +1,56 @@
+// 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.
+//
+// The encoder compresses all attribute values using an order preserving
+// attribute encoder (that can still support quantization, prediction schemes,
+// and other features).
+// The mesh connectivity data can be encoded using two modes that are controlled
+// using a global encoder options flag called "compress_connectivity"
+// 1. When "compress_connectivity" == true:
+//      All point ids are first delta coded and then compressed using an entropy
+//      coding.
+// 2. When "compress_connectivity" == false:
+//      All point ids are encoded directly using either 8, 16, or 32 bits per
+//      value based on the maximum point id value.
+
+#ifndef DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Class that encodes mesh data using a simple binary representation of mesh's
+// connectivity and geometry.
+class MeshSequentialEncoder : public MeshEncoder {
+ public:
+  MeshSequentialEncoder();
+  uint8_t GetEncodingMethod() const override {
+    return MESH_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // Returns false on error.
+  bool CompressAndEncodeIndices();
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_

include/draco/compression/mesh/traverser/depth_first_traverser.h

@@ -0,0 +1,172 @@
+// 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_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Basic traverser that traverses a mesh in a DFS like fashion using the
+// CornerTable data structure. The necessary bookkeeping is available via the
+// TraverserBase. Callbacks are handled through template argument
+// TraversalObserverT.
+//
+// TraversalObserverT can perform an action on a traversal event such as newly
+// visited face, or corner, but it does not affect the traversal itself.
+//
+// Concept TraversalObserverT requires:
+//
+// public:
+// void OnNewFaceVisited(FaceIndex face);
+//    - Called whenever a previously unvisited face is reached.
+//
+// void OnNewVertexVisited(VertexIndex vert, CornerIndex corner)
+//    - Called when a new vertex is visited. |corner| is used to indicate the
+//      which of the vertex's corners has been reached.
+
+template <class CornerTableT, class TraversalObserverT>
+class DepthFirstTraverser
+    : public TraverserBase<CornerTableT, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  DepthFirstTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {}
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (this->IsFaceVisited(corner_id)) {
+      return true;  // Already traversed.
+    }
+
+    corner_traversal_stack_.clear();
+    corner_traversal_stack_.push_back(corner_id);
+    // For the first face, check the remaining corners as they may not be
+    // processed yet.
+    const VertexIndex next_vert =
+        this->corner_table()->Vertex(this->corner_table()->Next(corner_id));
+    const VertexIndex prev_vert =
+        this->corner_table()->Vertex(this->corner_table()->Previous(corner_id));
+    if (next_vert == kInvalidVertexIndex || prev_vert == kInvalidVertexIndex) {
+      return false;
+    }
+    if (!this->IsVertexVisited(next_vert)) {
+      this->MarkVertexVisited(next_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          next_vert, this->corner_table()->Next(corner_id));
+    }
+    if (!this->IsVertexVisited(prev_vert)) {
+      this->MarkVertexVisited(prev_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          prev_vert, this->corner_table()->Previous(corner_id));
+    }
+
+    // Start the actual traversal.
+    while (!corner_traversal_stack_.empty()) {
+      // Currently processed corner.
+      corner_id = corner_traversal_stack_.back();
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (corner_id == kInvalidCornerIndex || this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        corner_traversal_stack_.pop_back();
+        continue;
+      }
+      while (true) {
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        if (!this->IsVertexVisited(vert_id)) {
+          const bool on_boundary = this->corner_table()->IsOnBoundary(vert_id);
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+          if (!on_boundary) {
+            corner_id = this->corner_table()->GetRightCorner(corner_id);
+            face_id = FaceIndex(corner_id.value() / 3);
+            continue;
+          }
+        }
+        // The current vertex has been already visited or it was on a boundary.
+        // We need to determine whether we can visit any of it's neighboring
+        // faces.
+        const CornerIndex right_corner_id =
+            this->corner_table()->GetRightCorner(corner_id);
+        const CornerIndex left_corner_id =
+            this->corner_table()->GetLeftCorner(corner_id);
+        const FaceIndex right_face_id(
+            (right_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(right_corner_id.value() / 3)));
+        const FaceIndex left_face_id(
+            (left_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(left_corner_id.value() / 3)));
+        if (this->IsFaceVisited(right_face_id)) {
+          // Right face has been already visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Both neighboring faces are visited. End reached.
+            corner_traversal_stack_.pop_back();
+            break;  // Break from the while (true) loop.
+          } else {
+            // Go to the left face.
+            corner_id = left_corner_id;
+            face_id = left_face_id;
+          }
+        } else {
+          // Right face was not visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Left face visited, go to the right one.
+            corner_id = right_corner_id;
+            face_id = right_face_id;
+          } else {
+            // Both neighboring faces are unvisited, we need to visit both of
+            // them.
+
+            // Split the traversal.
+            // First make the top of the current corner stack point to the left
+            // face (this one will be processed second).
+            corner_traversal_stack_.back() = left_corner_id;
+            // Add a new corner to the top of the stack (right face needs to
+            // be traversed first).
+            corner_traversal_stack_.push_back(right_corner_id);
+            // Break from the while (true) loop.
+            break;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  std::vector<CornerIndex> corner_traversal_stack_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_