dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/compression/attributes/point_d_vector.h

@@ -0,0 +1,288 @@
+// Copyright 2018 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_ATTRIBUTES_POINT_D_VECTOR_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <memory>
+#include <vector>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// The main class of this file is PointDVector providing an interface similar to
+// std::vector<PointD> for arbitrary number of dimensions (without a template
+// argument). PointDVectorIterator is a random access iterator, which allows for
+// compatibility with existing algorithms. PseudoPointD provides for a view on
+// the individual items in a contiguous block of memory, which is compatible
+// with the swap function and is returned by a dereference of
+// PointDVectorIterator. Swap functions provide for compatibility/specialization
+// that allows these classes to work with currently utilized STL functions.
+
+// This class allows for swap functionality from the RandomIterator
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+class PseudoPointD {
+ public:
+  PseudoPointD(internal_t *mem, internal_t dimension)
+      : mem_(mem), dimension_(dimension) {}
+
+  // Specifically copies referenced memory
+  void swap(PseudoPointD &other) noexcept {
+    for (internal_t dim = 0; dim < dimension_; dim += 1) {
+      std::swap(mem_[dim], other.mem_[dim]);
+    }
+  }
+
+  PseudoPointD(const PseudoPointD &other)
+      : mem_(other.mem_), dimension_(other.dimension_) {}
+
+  const internal_t &operator[](const size_t &n) const {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+  internal_t &operator[](const size_t &n) {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+
+  bool operator==(const PseudoPointD &other) const {
+    for (auto dim = 0; dim < dimension_; dim += 1) {
+      if (mem_[dim] != other.mem_[dim]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  bool operator!=(const PseudoPointD &other) const {
+    return !this->operator==(other);
+  }
+
+ private:
+  internal_t *const mem_;
+  const internal_t dimension_;
+};
+
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &&a,
+          draco::PseudoPointD<internal_t> &&b) noexcept {
+  a.swap(b);
+};
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &a,
+          draco::PseudoPointD<internal_t> &b) noexcept {
+  a.swap(b);
+};
+
+template <typename internal_t>
+class PointDVector {
+ public:
+  PointDVector(const uint32_t n_items, const uint32_t dimensionality)
+      : n_items_(n_items),
+        dimensionality_(dimensionality),
+        item_size_bytes_(dimensionality * sizeof(internal_t)),
+        data_(n_items * dimensionality),
+        data0_(data_.data()) {}
+  // random access iterator
+  class PointDVectorIterator {
+    friend class PointDVector;
+
+   public:
+    // Iterator traits expected by std libraries.
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = size_t;
+    using difference_type = size_t;
+    using pointer = PointDVector *;
+    using reference = PointDVector &;
+
+    // std::iter_swap is called inside of std::partition and needs this
+    // specialized support
+    PseudoPointD<internal_t> operator*() const {
+      return PseudoPointD<internal_t>(vec_->data0_ + item_ * dimensionality_,
+                                      dimensionality_);
+    }
+    const PointDVectorIterator &operator++() {
+      item_ += 1;
+      return *this;
+    }
+    const PointDVectorIterator &operator--() {
+      item_ -= 1;
+      return *this;
+    }
+    PointDVectorIterator operator++(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ += 1;
+      return copy;
+    }
+    PointDVectorIterator operator--(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ -= 1;
+      return copy;
+    }
+    PointDVectorIterator &operator=(const PointDVectorIterator &other) {
+      this->item_ = other.item_;
+      return *this;
+    }
+
+    bool operator==(const PointDVectorIterator &ref) const {
+      return item_ == ref.item_;
+    }
+    bool operator!=(const PointDVectorIterator &ref) const {
+      return item_ != ref.item_;
+    }
+    bool operator<(const PointDVectorIterator &ref) const {
+      return item_ < ref.item_;
+    }
+    bool operator>(const PointDVectorIterator &ref) const {
+      return item_ > ref.item_;
+    }
+    bool operator<=(const PointDVectorIterator &ref) const {
+      return item_ <= ref.item_;
+    }
+    bool operator>=(const PointDVectorIterator &ref) const {
+      return item_ >= ref.item_;
+    }
+
+    PointDVectorIterator operator+(const int32_t &add) const {
+      PointDVectorIterator copy(vec_, item_ + add);
+      return copy;
+    }
+    PointDVectorIterator &operator+=(const int32_t &add) {
+      item_ += add;
+      return *this;
+    }
+    PointDVectorIterator operator-(const int32_t &sub) const {
+      PointDVectorIterator copy(vec_, item_ - sub);
+      return copy;
+    }
+    size_t operator-(const PointDVectorIterator &sub) const {
+      return (item_ - sub.item_);
+    }
+
+    PointDVectorIterator &operator-=(const int32_t &sub) {
+      item_ -= sub;
+      return *this;
+    }
+
+    internal_t *operator[](const size_t &n) const {
+      return vec_->data0_ + (item_ + n) * dimensionality_;
+    }
+
+   protected:
+    explicit PointDVectorIterator(PointDVector *vec, size_t start_item)
+        : item_(start_item), vec_(vec), dimensionality_(vec->dimensionality_) {}
+
+   private:
+    size_t item_;  // this counts the item that should be referenced.
+    PointDVector *const vec_;        // the thing that we're iterating on
+    const uint32_t dimensionality_;  // local copy from vec_
+  };
+
+  PointDVectorIterator begin() { return PointDVectorIterator(this, 0); }
+  PointDVectorIterator end() { return PointDVectorIterator(this, n_items_); }
+
+  // operator[] allows for unprotected user-side usage of operator[] on the
+  // return value AS IF it were a natively indexable type like Point3*
+  internal_t *operator[](const uint32_t index) {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+  const internal_t *operator[](const uint32_t index) const {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+
+  uint32_t size() const { return n_items_; }
+  size_t GetBufferSize() const { return data_.size(); }
+
+  // copy a single contiguous 'item' from one PointDVector into this one.
+  void CopyItem(const PointDVector &source, const internal_t source_index,
+                const internal_t destination_index) {
+    DRACO_DCHECK(&source != this ||
+                 (&source == this && source_index != destination_index));
+    DRACO_DCHECK_LT(destination_index, n_items_);
+    DRACO_DCHECK_LT(source_index, source.n_items_);
+
+    // DRACO_DCHECK_EQ(source.n_items_, n_items_); // not technically necessary
+    DRACO_DCHECK_EQ(source.dimensionality_, dimensionality_);
+
+    const internal_t *ref = source[source_index];
+    internal_t *const dest = this->operator[](destination_index);
+    std::memcpy(dest, ref, item_size_bytes_);
+  }
+
+  // Copy data directly off of an attribute buffer interleaved into internal
+  // memory.
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality, const internal_t index,
+      // The direct pointer to the data
+      const void *const attribute_item_data) {
+    // chunk copy
+    const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+
+    // a multiply and add can be optimized away with an iterator
+    std::memcpy(data0_ + index * dimensionality_ + offset_dimensionality,
+                attribute_item_data, copy_size);
+  }
+  // Copy data off of a contiguous buffer interleaved into internal memory
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality,
+      const internal_t *const attribute_mem) {
+    DRACO_DCHECK_LT(offset_dimensionality,
+                    dimensionality_ - attribute_dimensionality);
+    // degenerate case block copy the whole buffer.
+    if (dimensionality_ == attribute_dimensionality) {
+      DRACO_DCHECK_EQ(offset_dimensionality, 0);
+      const size_t copy_size =
+          sizeof(internal_t) * attribute_dimensionality * n_items_;
+      std::memcpy(data0_, attribute_mem, copy_size);
+    } else {  // chunk copy
+      const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+      internal_t *internal_data;
+      const internal_t *attribute_data;
+      internal_t item;
+      for (internal_data = data0_ + offset_dimensionality,
+          attribute_data = attribute_mem, item = 0;
+           item < n_items_; internal_data += dimensionality_,
+          attribute_data += attribute_dimensionality, item += 1) {
+        std::memcpy(internal_data, attribute_data, copy_size);
+      }
+    }
+  }
+
+ private:
+  // internal parameters.
+  const uint32_t n_items_;
+  const uint32_t dimensionality_;  // The dimension of the points in the buffer
+  const uint32_t item_size_bytes_;
+  std::vector<internal_t> data_;  // contiguously stored data.  Never resized.
+  internal_t *const data0_;       // raw pointer to base data.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_

include/draco/compression/attributes/points_sequencer.h

@@ -0,0 +1,63 @@
+// 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_ATTRIBUTES_POINTS_SEQUENCER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
+
+#include <vector>
+
+#include "draco/attributes/point_attribute.h"
+
+namespace draco {
+
+// Class for generating a sequence of point ids that can be used to encode
+// or decode attribute values in a specific order.
+// See sequential_attribute_encoders/decoders_controller.h for more details.
+class PointsSequencer {
+ public:
+  PointsSequencer() : out_point_ids_(nullptr) {}
+  virtual ~PointsSequencer() = default;
+
+  // Fills the |out_point_ids| with the generated sequence of point ids.
+  bool GenerateSequence(std::vector<PointIndex> *out_point_ids) {
+    out_point_ids_ = out_point_ids;
+    return GenerateSequenceInternal();
+  }
+
+  // Appends a point to the sequence.
+  void AddPointId(PointIndex point_id) { out_point_ids_->push_back(point_id); }
+
+  // Sets the correct mapping between point ids and value ids. I.e., the inverse
+  // of the |out_point_ids|. In general, |out_point_ids_| does not contain
+  // sufficient information to compute the inverse map, because not all point
+  // ids are necessarily contained within the map.
+  // Must be implemented for sequencers that are used by attribute decoders.
+  virtual bool UpdatePointToAttributeIndexMapping(PointAttribute * /* attr */) {
+    return false;
+  }
+
+ protected:
+  // Method that needs to be implemented by the derived classes. The
+  // implementation is responsible for filling |out_point_ids_| with the valid
+  // sequence of point ids.
+  virtual bool GenerateSequenceInternal() = 0;
+  std::vector<PointIndex> *out_point_ids() const { return out_point_ids_; }
+
+ private:
+  std::vector<PointIndex> *out_point_ids_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_

include/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h

@@ -0,0 +1,236 @@
+// 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_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for predictions encoded with the constrained multi-parallelogram
+// encoder. See the corresponding encoder for more details about the prediction
+// method.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeConstrainedMultiParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+  MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute, const TransformT &transform,
+      const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+
+ private:
+  typedef constrained_multi_parallelogram::Mode Mode;
+  static constexpr int kMaxNumParallelograms =
+      constrained_multi_parallelogram::kMaxNumParallelograms;
+  // Crease edges are used to store whether any given edge should be used for
+  // parallelogram prediction or not. New values are added in the order in which
+  // the edges are processed. For better compression, the flags are stored in
+  // in separate contexts based on the number of available parallelograms at a
+  // given vertex.
+  std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
+  Mode selected_mode_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  // Predicted values for all simple parallelograms encountered at any given
+  // vertex.
+  std::vector<DataTypeT> pred_vals[kMaxNumParallelograms];
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    pred_vals[i].resize(num_components, 0);
+  }
+  this->transform().ComputeOriginalValue(pred_vals[0].data(), in_corr,
+                                         out_data);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // Current position in the |is_crease_edge_| array for each context.
+  std::vector<int> is_crease_edge_pos(kMaxNumParallelograms, 0);
+
+  // Used to store predicted value for multi-parallelogram prediction.
+  std::vector<DataTypeT> multi_pred_vals(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    bool first_pass = true;
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, out_data,
+              num_components, &(pred_vals[num_parallelograms][0]))) {
+        // Parallelogram prediction applied and stored in
+        // |pred_vals[num_parallelograms]|
+        ++num_parallelograms;
+        // Stop processing when we reach the maximum number of allowed
+        // parallelograms.
+        if (num_parallelograms == kMaxNumParallelograms) {
+          break;
+        }
+      }
+
+      // Proceed to the next corner attached to the vertex. First swing left
+      // and if we reach a boundary, swing right from the start corner.
+      if (first_pass) {
+        corner_id = table->SwingLeft(corner_id);
+      } else {
+        corner_id = table->SwingRight(corner_id);
+      }
+      if (corner_id == start_corner_id) {
+        break;
+      }
+      if (corner_id == kInvalidCornerIndex && first_pass) {
+        first_pass = false;
+        corner_id = table->SwingRight(start_corner_id);
+      }
+    }
+
+    // Check which of the available parallelograms are actually used and compute
+    // the final predicted value.
+    int num_used_parallelograms = 0;
+    if (num_parallelograms > 0) {
+      for (int i = 0; i < num_components; ++i) {
+        multi_pred_vals[i] = 0;
+      }
+      // Check which parallelograms are actually used.
+      for (int i = 0; i < num_parallelograms; ++i) {
+        const int context = num_parallelograms - 1;
+        const int pos = is_crease_edge_pos[context]++;
+        if (is_crease_edge_[context].size() <= pos) {
+          return false;
+        }
+        const bool is_crease = is_crease_edge_[context][pos];
+        if (!is_crease) {
+          ++num_used_parallelograms;
+          for (int j = 0; j < num_components; ++j) {
+            multi_pred_vals[j] =
+                AddAsUnsigned(multi_pred_vals[j], pred_vals[i][j]);
+          }
+        }
+      }
+    }
+    const int dst_offset = p * num_components;
+    if (num_used_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last decoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        multi_pred_vals[c] /= num_used_parallelograms;
+      }
+      this->transform().ComputeOriginalValue(
+          multi_pred_vals.data(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    // Decode prediction mode.
+    uint8_t mode;
+    if (!buffer->Decode(&mode)) {
+      return false;
+    }
+
+    if (mode != Mode::OPTIMAL_MULTI_PARALLELOGRAM) {
+      // Unsupported mode.
+      return false;
+    }
+  }
+#endif
+
+  // Encode selected edges using separate rans bit coder for each context.
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    uint32_t num_flags;
+    if (!DecodeVarint<uint32_t>(&num_flags, buffer)) {
+      return false;
+    }
+    if (num_flags > this->mesh_data().corner_table()->num_corners()) {
+      return false;
+    }
+    if (num_flags > 0) {
+      is_crease_edge_[i].resize(num_flags);
+      RAnsBitDecoder decoder;
+      if (!decoder.StartDecoding(buffer)) {
+        return false;
+      }
+      for (uint32_t j = 0; j < num_flags; ++j) {
+        is_crease_edge_[i][j] = decoder.DecodeNextBit();
+      }
+      decoder.EndDecoding();
+    }
+  }
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_