dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/compression/mesh/traverser/max_prediction_degree_traverser.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_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// PredictionDegreeTraverser provides framework for traversal over a corner
+// table data structure following paper "Multi-way Geometry Encoding" by
+// Cohen-or at al.'02. The traversal is implicitly guided by prediction degree
+// of the destination vertices. A prediction degree is computed as the number of
+// possible faces that can be used as source points for traversal to the given
+// destination vertex (see image below, where faces F1 and F2 are already
+// traversed and face F0 is not traversed yet. The prediction degree of vertex
+// V is then equal to two).
+//
+//            X-----V-----o
+//           / \   / \   / \
+//          / F0\ /   \ / F2\
+//         X-----o-----o-----B
+//                \ F1/
+//                 \ /
+//                  A
+//
+// The class implements the same interface as the DepthFirstTraverser
+// (depth_first_traverser.h) and it can be controlled via the same template
+// trait classes |CornerTableT| and |TraversalObserverT|, that are used
+// for controlling and monitoring of the traversal respectively. For details,
+// please see depth_first_traverser.h.
+template <class CornerTableT, class TraversalObserverT>
+class MaxPredictionDegreeTraverser
+    : public TraverserBase<CornerTable, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  MaxPredictionDegreeTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {
+    prediction_degree_.resize(this->corner_table()->num_vertices(), 0);
+  }
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (prediction_degree_.size() == 0) {
+      return true;
+    }
+
+    // Traversal starts from the |corner_id|. It's going to follow either the
+    // right or the left neighboring faces to |corner_id| based on their
+    // prediction degree.
+    traversal_stacks_[0].push_back(corner_id);
+    best_priority_ = 0;
+    // 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 (!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));
+    }
+    const VertexIndex tip_vertex = this->corner_table()->Vertex(corner_id);
+    if (!this->IsVertexVisited(tip_vertex)) {
+      this->MarkVertexVisited(tip_vertex);
+      this->traversal_observer().OnNewVertexVisited(tip_vertex, corner_id);
+    }
+    // Start the actual traversal.
+    while ((corner_id = PopNextCornerToTraverse()) != kInvalidCornerIndex) {
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        continue;
+      }
+
+      while (true) {
+        face_id = FaceIndex(corner_id.value() / 3);
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+
+        // If the newly reached vertex hasn't been visited, mark it and notify
+        // the observer.
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (!this->IsVertexVisited(vert_id)) {
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+        }
+
+        // Check whether we can traverse to the right and left 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)));
+        const bool is_right_face_visited = this->IsFaceVisited(right_face_id);
+        const bool is_left_face_visited = this->IsFaceVisited(left_face_id);
+
+        if (!is_left_face_visited) {
+          // We can go to the left face.
+          const int priority = ComputePriority(left_corner_id);
+          if (is_right_face_visited && priority <= best_priority_) {
+            // Right face has been already visited and the priority is equal or
+            // better than the best priority. We are sure that the left face
+            // would be traversed next so there is no need to put it onto the
+            // stack.
+            corner_id = left_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(left_corner_id, priority);
+          }
+        }
+        if (!is_right_face_visited) {
+          // Go to the right face.
+          const int priority = ComputePriority(right_corner_id);
+          if (priority <= best_priority_) {
+            // We are sure that the right face would be traversed next so there
+            // is no need to put it onto the stack.
+            corner_id = right_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(right_corner_id, priority);
+          }
+        }
+
+        // Couldn't proceed directly to the next corner
+        break;
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Retrieves the next available corner (edge) to traverse. Edges are processed
+  // based on their priorities.
+  // Returns kInvalidCornerIndex when there is no edge available.
+  CornerIndex PopNextCornerToTraverse() {
+    for (int i = best_priority_; i < kMaxPriority; ++i) {
+      if (!traversal_stacks_[i].empty()) {
+        const CornerIndex ret = traversal_stacks_[i].back();
+        traversal_stacks_[i].pop_back();
+        best_priority_ = i;
+        return ret;
+      }
+    }
+    return kInvalidCornerIndex;
+  }
+
+  inline void AddCornerToTraversalStack(CornerIndex ci, int priority) {
+    traversal_stacks_[priority].push_back(ci);
+    // Make sure that the best available priority is up to date.
+    if (priority < best_priority_) {
+      best_priority_ = priority;
+    }
+  }
+
+  // Returns the priority of traversing edge leading to |corner_id|.
+  inline int ComputePriority(CornerIndex corner_id) {
+    const VertexIndex v_tip = this->corner_table()->Vertex(corner_id);
+    // Priority 0 when traversing to already visited vertices.
+    int priority = 0;
+    if (!this->IsVertexVisited(v_tip)) {
+      const int degree = ++prediction_degree_[v_tip];
+      // Priority 1 when prediction degree > 1, otherwise 2.
+      priority = (degree > 1 ? 1 : 2);
+    }
+    // Clamp the priority to the maximum number of buckets.
+    if (priority >= kMaxPriority) {
+      priority = kMaxPriority - 1;
+    }
+    return priority;
+  }
+
+  // For efficiency reasons, the priority traversal is implemented using buckets
+  // where each buckets represent a stack of available corners for a given
+  // priority. Corners with the highest priority are always processed first.
+  static constexpr int kMaxPriority = 3;
+  std::vector<CornerIndex> traversal_stacks_[kMaxPriority];
+
+  // Keep the track of the best available priority to improve the performance
+  // of PopNextCornerToTraverse() method.
+  int best_priority_;
+
+  // Prediction degree available for each vertex.
+  IndexTypeVector<VertexIndex, int> prediction_degree_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_

include/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.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_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class that can be used to generate encoding (and decoding) order of attribute
+// values based on the traversal of the encoded mesh. The class should be used
+// as the TraversalObserverT member of a Traverser class such as the
+// DepthFirstTraverser (depth_first_traverser.h).
+// TODO(b/199760123): Rename to AttributeIndicesCodingTraverserObserver.
+template <class CornerTableT>
+class MeshAttributeIndicesEncodingObserver {
+ public:
+  MeshAttributeIndicesEncodingObserver()
+      : att_connectivity_(nullptr),
+        encoding_data_(nullptr),
+        mesh_(nullptr),
+        sequencer_(nullptr) {}
+  MeshAttributeIndicesEncodingObserver(
+      const CornerTableT *connectivity, const Mesh *mesh,
+      PointsSequencer *sequencer,
+      MeshAttributeIndicesEncodingData *encoding_data)
+      : att_connectivity_(connectivity),
+        encoding_data_(encoding_data),
+        mesh_(mesh),
+        sequencer_(sequencer) {}
+
+  // Interface for TraversalObserverT
+
+  void OnNewFaceVisited(FaceIndex /* face */) {}
+
+  inline void OnNewVertexVisited(VertexIndex vertex, CornerIndex corner) {
+    const PointIndex point_id =
+        mesh_->face(FaceIndex(corner.value() / 3))[corner.value() % 3];
+    // Append the visited attribute to the encoding order.
+    sequencer_->AddPointId(point_id);
+
+    // Keep track of visited corners.
+    encoding_data_->encoded_attribute_value_index_to_corner_map.push_back(
+        corner);
+
+    encoding_data_
+        ->vertex_to_encoded_attribute_value_index_map[vertex.value()] =
+        encoding_data_->num_values;
+
+    encoding_data_->num_values++;
+  }
+
+ private:
+  const CornerTableT *att_connectivity_;
+  MeshAttributeIndicesEncodingData *encoding_data_;
+  const Mesh *mesh_;
+  PointsSequencer *sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_

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

@@ -0,0 +1,113 @@
+// 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_MESH_TRAVERSAL_SEQUENCER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Sequencer that generates point sequence in an order given by a deterministic
+// traversal on the mesh surface. Note that all attributes encoded with this
+// sequence must share the same connectivity.
+// TODO(b/199760123): Consider refactoring such that this is an observer.
+template <class TraverserT>
+class MeshTraversalSequencer : public PointsSequencer {
+ public:
+  MeshTraversalSequencer(const Mesh *mesh,
+                         const MeshAttributeIndicesEncodingData *encoding_data)
+      : mesh_(mesh), encoding_data_(encoding_data), corner_order_(nullptr) {}
+  void SetTraverser(const TraverserT &t) { traverser_ = t; }
+
+  // Function that can be used to set an order in which the mesh corners should
+  // be processed. This is an optional flag used usually only by the encoder
+  // to match the same corner order that is going to be used by the decoder.
+  // Note that |corner_order| should contain only one corner per face (it can
+  // have all corners but only the first encountered corner for each face is
+  // going to be used to start a traversal). If the corner order is not set, the
+  // corners are processed sequentially based on their ids.
+  void SetCornerOrder(const std::vector<CornerIndex> &corner_order) {
+    corner_order_ = &corner_order;
+  }
+
+  bool UpdatePointToAttributeIndexMapping(PointAttribute *attribute) override {
+    const auto *corner_table = traverser_.corner_table();
+    attribute->SetExplicitMapping(mesh_->num_points());
+    const size_t num_faces = mesh_->num_faces();
+    const size_t num_points = mesh_->num_points();
+    for (FaceIndex f(0); f < static_cast<uint32_t>(num_faces); ++f) {
+      const auto &face = mesh_->face(f);
+      for (int p = 0; p < 3; ++p) {
+        const PointIndex point_id = face[p];
+        const VertexIndex vert_id =
+            corner_table->Vertex(CornerIndex(3 * f.value() + p));
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        const AttributeValueIndex att_entry_id(
+            encoding_data_
+                ->vertex_to_encoded_attribute_value_index_map[vert_id.value()]);
+        if (point_id >= num_points || att_entry_id.value() >= num_points) {
+          // There cannot be more attribute values than the number of points.
+          return false;
+        }
+        attribute->SetPointMapEntry(point_id, att_entry_id);
+      }
+    }
+    return true;
+  }
+
+ protected:
+  bool GenerateSequenceInternal() override {
+    // Preallocate memory for storing point indices. We expect the number of
+    // points to be the same as the number of corner table vertices.
+    out_point_ids()->reserve(traverser_.corner_table()->num_vertices());
+
+    traverser_.OnTraversalStart();
+    if (corner_order_) {
+      for (uint32_t i = 0; i < corner_order_->size(); ++i) {
+        if (!ProcessCorner(corner_order_->at(i))) {
+          return false;
+        }
+      }
+    } else {
+      const int32_t num_faces = traverser_.corner_table()->num_faces();
+      for (int i = 0; i < num_faces; ++i) {
+        if (!ProcessCorner(CornerIndex(3 * i))) {
+          return false;
+        }
+      }
+    }
+    traverser_.OnTraversalEnd();
+    return true;
+  }
+
+ private:
+  bool ProcessCorner(CornerIndex corner_id) {
+    return traverser_.TraverseFromCorner(corner_id);
+  }
+
+  TraverserT traverser_;
+  const Mesh *mesh_;
+  const MeshAttributeIndicesEncodingData *encoding_data_;
+  const std::vector<CornerIndex> *corner_order_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_

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

@@ -0,0 +1,87 @@
+// 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_TRAVERSER_BASE_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
+
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class providing the basic traversal functionality needed by traversers (such
+// as the DepthFirstTraverser, see depth_first_traverser.h). It keeps a pointer
+// to the corner table that is used for the traversal, plus it provides a basic
+// bookkeeping of visited faces and vertices during the traversal.
+template <class CornerTableT, class TraversalObserverT>
+class TraverserBase {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+
+  TraverserBase() : corner_table_(nullptr) {}
+  virtual ~TraverserBase() = default;
+
+  virtual void Init(const CornerTable *corner_table,
+                    TraversalObserver traversal_observer) {
+    corner_table_ = corner_table;
+    is_face_visited_.assign(corner_table->num_faces(), false);
+    is_vertex_visited_.assign(corner_table_->num_vertices(), false);
+    traversal_observer_ = traversal_observer;
+  }
+
+  const CornerTable &GetCornerTable() const { return *corner_table_; }
+
+  inline bool IsFaceVisited(FaceIndex face_id) const {
+    if (face_id == kInvalidFaceIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[face_id.value()];
+  }
+
+  // Returns true if the face containing the given corner was visited.
+  inline bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[corner_id.value() / 3];
+  }
+
+  inline void MarkFaceVisited(FaceIndex face_id) {
+    is_face_visited_[face_id.value()] = true;
+  }
+  inline bool IsVertexVisited(VertexIndex vert_id) const {
+    return is_vertex_visited_[vert_id.value()];
+  }
+  inline void MarkVertexVisited(VertexIndex vert_id) {
+    is_vertex_visited_[vert_id.value()] = true;
+  }
+
+  inline const CornerTable *corner_table() const { return corner_table_; }
+  inline const TraversalObserverT &traversal_observer() const {
+    return traversal_observer_;
+  }
+  inline TraversalObserverT &traversal_observer() {
+    return traversal_observer_;
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  TraversalObserverT traversal_observer_;
+  std::vector<bool> is_face_visited_;
+  std::vector<bool> is_vertex_visited_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_