dracox 0.0.1__cp39-cp39-win_amd64.whl

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

@@ -0,0 +1,134 @@
+// 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.
+//
+// Functions for creating prediction schemes for encoders using the provided
+// prediction method id.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h"
+#endif
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Selects a prediction method based on the input geometry type and based on the
+// encoder options.
+PredictionSchemeMethod SelectPredictionMethod(int att_id,
+                                              const PointCloudEncoder *encoder);
+
+PredictionSchemeMethod SelectPredictionMethod(int att_id,
+                                              const EncoderOptions &options,
+                                              const PointCloudEncoder *encoder);
+
+// Factory class for creating mesh prediction schemes.
+template <typename DataTypeT>
+struct MeshPredictionSchemeEncoderFactory {
+  template <class TransformT, class MeshDataT>
+  std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>> operator()(
+      PredictionSchemeMethod method, const PointAttribute *attribute,
+      const TransformT &transform, const MeshDataT &mesh_data,
+      uint16_t bitstream_version) {
+    if (method == MESH_PREDICTION_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeParallelogramEncoder<DataTypeT, TransformT,
+                                                       MeshDataT>(
+              attribute, transform, mesh_data));
+    } else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    } else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeTexCoordsPortableEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    }
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+    else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                         MeshDataT>(
+              attribute, transform, mesh_data));
+    }
+#endif
+    return nullptr;
+  }
+};
+
+// Creates a prediction scheme for a given encoder and given prediction method.
+// The prediction schemes are automatically initialized with encoder specific
+// data if needed.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder,
+                                 const TransformT &transform) {
+  const PointAttribute *const att = encoder->point_cloud()->attribute(att_id);
+  if (method == PREDICTION_UNDEFINED) {
+    method = SelectPredictionMethod(att_id, encoder);
+  }
+  if (method == PREDICTION_NONE) {
+    return nullptr;  // No prediction is used.
+  }
+  if (encoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Cast the encoder to mesh encoder. This is not necessarily safe if there
+    // is some other encoder decides to use TRIANGULAR_MESH as the return type,
+    // but unfortunately there is not nice work around for this without using
+    // RTTI (double dispatch and similar concepts will not work because of the
+    // template nature of the prediction schemes).
+    const MeshEncoder *const mesh_encoder =
+        static_cast<const MeshEncoder *>(encoder);
+    const uint16_t bitstream_version = kDracoMeshBitstreamVersion;
+    auto ret = CreateMeshPredictionScheme<
+        MeshEncoder, PredictionSchemeEncoder<DataTypeT, TransformT>,
+        MeshPredictionSchemeEncoderFactory<DataTypeT>>(
+        mesh_encoder, method, att_id, transform, bitstream_version);
+    if (ret) {
+      return ret;
+    }
+    // Otherwise try to create another prediction scheme.
+  }
+  // Create delta encoder.
+  return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+      new PredictionSchemeDeltaEncoder<DataTypeT, TransformT>(att, transform));
+}
+
+// Create a prediction scheme using a default transform constructor.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder) {
+  return CreatePredictionSchemeForEncoder<DataTypeT, TransformT>(
+      method, att_id, encoder, TransformT());
+}
+
+// Returns the preferred prediction scheme based on the encoder options.
+PredictionSchemeMethod GetPredictionMethodFromOptions(
+    int att_id, const EncoderOptions &options);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_

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

@@ -0,0 +1,55 @@
+// 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_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/core/encoder_buffer.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeEncoderInterface : public PredictionSchemeInterface {
+ public:
+  // Method that can be used to encode any prediction scheme specific data
+  // into the output buffer.
+  virtual bool EncodePredictionData(EncoderBuffer *buffer) = 0;
+};
+
+// A specialized version of the prediction scheme interface for specific
+// input and output data types.
+// |entry_to_point_id_map| is the mapping between value entries to point ids
+// of the associated point cloud, where one entry is defined as |num_components|
+// values of the |in_data|.
+// DataTypeT is the data type of input and predicted values.
+// CorrTypeT is the data type used for storing corrected values.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeTypedEncoderInterface
+    : public PredictionSchemeEncoderInterface {
+ public:
+  // Applies the prediction scheme when encoding the attribute.
+  // |in_data| contains value entries to be encoded.
+  // |out_corr| is an output array containing the to be encoded corrections.
+  virtual bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrTypeT *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_

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

@@ -0,0 +1,77 @@
+// 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_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeEncodingTransform is used to transform predicted values into
+// correction values.
+// CorrTypeT is the data type used for storing corrected values. It allows
+// transforms to store corrections into a different type or format compared to
+// the predicted data.
+template <typename DataTypeT, typename CorrTypeT>
+class PredictionSchemeEncodingTransform {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeEncodingTransform() : num_components_(0) {}
+
+  PredictionSchemeTransformType GetType() const {
+    return PREDICTION_TRANSFORM_DELTA;
+  }
+
+  // Performs any custom initialization of the transform for the encoder.
+  // |size| = total number of values in |orig_data| (i.e., number of entries *
+  // number of components).
+  void Init(const DataTypeT * /* orig_data */, int /* size */,
+            int num_components) {
+    num_components_ = num_components;
+  }
+
+  // Computes the corrections based on the input original values and the
+  // predicted values. The correction is always computed for all components
+  // of the input element. |val_id| is the id of the input value
+  // (i.e., element_id * num_components). The default implementation is equal to
+  // std::minus.
+  inline void ComputeCorrection(const DataTypeT *original_vals,
+                                const DataTypeT *predicted_vals,
+                                CorrTypeT *out_corr_vals) {
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "For the default prediction transform, correction and input "
+                  "data must be of the same type.");
+    for (int i = 0; i < num_components_; ++i) {
+      out_corr_vals[i] = original_vals[i] - predicted_vals[i];
+    }
+  }
+
+  // Encode any transform specific data.
+  bool EncodeTransformData(EncoderBuffer * /* buffer */) { return true; }
+
+  // Should return true if all corrected values are guaranteed to be positive.
+  bool AreCorrectionsPositive() const { return false; }
+
+ protected:
+  int num_components() const { return num_components_; }
+
+ private:
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_

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

@@ -0,0 +1,85 @@
+// 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.
+//
+// Functions for creating prediction schemes from a provided prediction method
+// name. The functions in this file can create only basic prediction schemes
+// that don't require any encoder or decoder specific data. To create more
+// sophisticated prediction schemes, use functions from either
+// prediction_scheme_encoder_factory.h  or,
+// prediction_scheme_decoder_factory.h.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+template <class EncodingDataSourceT, class PredictionSchemeT,
+          class MeshPredictionSchemeFactoryT>
+std::unique_ptr<PredictionSchemeT> CreateMeshPredictionScheme(
+    const EncodingDataSourceT *source, PredictionSchemeMethod method,
+    int att_id, const typename PredictionSchemeT::Transform &transform,
+    uint16_t bitstream_version) {
+  const PointAttribute *const att = source->point_cloud()->attribute(att_id);
+  if (source->GetGeometryType() == TRIANGULAR_MESH &&
+      (method == MESH_PREDICTION_PARALLELOGRAM ||
+       method == MESH_PREDICTION_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_TEX_COORDS_PORTABLE ||
+       method == MESH_PREDICTION_GEOMETRIC_NORMAL ||
+       method == MESH_PREDICTION_TEX_COORDS_DEPRECATED)) {
+    const CornerTable *const ct = source->GetCornerTable();
+    const MeshAttributeIndicesEncodingData *const encoding_data =
+        source->GetAttributeEncodingData(att_id);
+    if (ct == nullptr || encoding_data == nullptr) {
+      // No connectivity data found.
+      return nullptr;
+    }
+    // Connectivity data exists.
+    const MeshAttributeCornerTable *const att_ct =
+        source->GetAttributeCornerTable(att_id);
+    if (att_ct != nullptr) {
+      typedef MeshPredictionSchemeData<MeshAttributeCornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), att_ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    } else {
+      typedef MeshPredictionSchemeData<CornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    }
+  }
+  return nullptr;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_

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

@@ -0,0 +1,60 @@
+// 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_PREDICTION_SCHEME_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeInterface {
+ public:
+  virtual ~PredictionSchemeInterface() = default;
+  virtual PredictionSchemeMethod GetPredictionMethod() const = 0;
+
+  // Returns the encoded attribute.
+  virtual const PointAttribute *GetAttribute() const = 0;
+
+  // Returns true when the prediction scheme is initialized with all data it
+  // needs.
+  virtual bool IsInitialized() const = 0;
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  virtual int GetNumParentAttributes() const = 0;
+
+  // Returns the type of each of the parent attribute.
+  virtual GeometryAttribute::Type GetParentAttributeType(int i) const = 0;
+
+  // Sets the required parent attribute.
+  // Returns false if the attribute doesn't meet the requirements of the
+  // prediction scheme.
+  virtual bool SetParentAttribute(const PointAttribute *att) = 0;
+
+  // Method should return true if the prediction scheme guarantees that all
+  // correction values are always positive (or at least non-negative).
+  virtual bool AreCorrectionsPositive() = 0;
+
+  // Returns the transform type used by the prediction scheme.
+  virtual PredictionSchemeTransformType GetTransformType() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_

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

@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for converting correction values transformed by the canonicalized
+// normal octahedron transform back to the original values. See the
+// corresponding encoder for more details.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform() {}
+
+  // Dummy to fulfill concept.
+  void Init(int num_components) {}
+
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT max_quantized_value, center_value;
+    if (!buffer->Decode(&max_quantized_value)) {
+      return false;
+    }
+    if (!buffer->Decode(&center_value)) {
+      return false;
+    }
+    (void)center_value;
+    if (!this->set_max_quantized_value(max_quantized_value)) {
+      return false;
+    }
+    // Account for reading wrong values, e.g., due to fuzzing.
+    if (this->quantization_bits() < 2) {
+      return false;
+    }
+    if (this->quantization_bits() > 30) {
+      return false;
+    }
+    return true;
+  }
+
+  inline void ComputeOriginalValue(const DataType *pred_vals,
+                                   const CorrType *corr_vals,
+                                   DataType *out_orig_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(pred_vals[1], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[1], 2 * this->center_value());
+
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, corr_vals[0]);
+    DRACO_DCHECK_LE(0, corr_vals[1]);
+
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = Point2(corr_vals[0], corr_vals[1]);
+    const Point2 orig = ComputeOriginalValue(pred, corr);
+
+    out_orig_vals[0] = orig[0];
+    out_orig_vals[1] = orig[1];
+  }
+
+ private:
+  Point2 ComputeOriginalValue(Point2 pred, Point2 corr) const {
+    const Point2 t(this->center_value(), this->center_value());
+    pred = pred - t;
+    const bool pred_is_in_diamond = this->IsInDiamond(pred[0], pred[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    const bool pred_is_in_bottom_left = this->IsInBottomLeft(pred);
+    const int32_t rotation_count = this->GetRotationCount(pred);
+    if (!pred_is_in_bottom_left) {
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 orig(this->ModMax(AddAsUnsigned(pred[0], corr[0])),
+                this->ModMax(AddAsUnsigned(pred[1], corr[1])));
+    if (!pred_is_in_bottom_left) {
+      const int32_t reverse_rotation_count = (4 - rotation_count) % 4;
+      orig = this->RotatePoint(orig, reverse_rotation_count);
+    }
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+    }
+    orig = orig + t;
+    return orig;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_

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

@@ -0,0 +1,116 @@
+// 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_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// The transform works on octahedral coordinates for normals. The square is
+// subdivided into four inner triangles (diamond) and four outer triangles. The
+// inner triangles are associated with the upper part of the octahedron and the
+// outer triangles are associated with the lower part.
+// Given a prediction value P and the actual value Q that should be encoded,
+// this transform first checks if P is outside the diamond. If so, the outer
+// triangles are flipped towards the inside and vice versa. Then it checks if p
+// is in the bottom left quadrant. If it is not, it rotates p and q accordingly.
+// The actual correction value is then based on the mapped and rotated P and Q
+// values. The inversion tends to result in shorter correction vectors and the
+// rotation makes it so that all long correction values are positive, reducing
+// the possible value range of the correction values and increasing the
+// occurrences of positive large correction values, which helps the entropy
+// encoder. This is possible since P is also known by the decoder, see also
+// ComputeCorrection and ComputeOriginalValue functions.
+// Note that the tile is not periodic, which implies that the outer edges can
+// not be identified, which requires us to use an odd number of values on each
+// axis.
+// DataTypeT is expected to be some integral type.
+//
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronCanonicalizedTransformBase<DataTypeT>
+      Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform(
+      DataType max_quantized_value)
+      : Base(max_quantized_value) {}
+
+  // Dummy function to fulfill concept.
+  void Init(const DataTypeT *orig_data, int size, int num_components) {}
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    buffer->Encode(this->max_quantized_value());
+    buffer->Encode(this->center_value());
+    return true;
+  }
+
+  inline void ComputeCorrection(const DataType *orig_vals,
+                                const DataType *pred_vals,
+                                CorrType *out_corr_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(pred_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, orig_vals[0]);
+    DRACO_DCHECK_LE(0, orig_vals[1]);
+
+    const Point2 orig = Point2(orig_vals[0], orig_vals[1]);
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = ComputeCorrection(orig, pred);
+
+    out_corr_vals[0] = corr[0];
+    out_corr_vals[1] = corr[1];
+  }
+
+ private:
+  Point2 ComputeCorrection(Point2 orig, Point2 pred) const {
+    const Point2 t(this->center_value(), this->center_value());
+    orig = orig - t;
+    pred = pred - t;
+    if (!this->IsInDiamond(pred[0], pred[1])) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    if (!this->IsInBottomLeft(pred)) {
+      const int32_t rotation_count = this->GetRotationCount(pred);
+      orig = this->RotatePoint(orig, rotation_count);
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 corr = orig - pred;
+    corr[0] = this->MakePositive(corr[0]);
+    corr[1] = this->MakePositive(corr[1]);
+    return corr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_