dracox 0.0.1__cp39-cp39-win_amd64.whl

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

@@ -0,0 +1,176 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// See MeshPredictionSchemeGeometricNormalEncoder for documentation.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalDecoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+ private:
+  MeshPredictionSchemeGeometricNormalDecoder() {}
+
+ public:
+  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_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    if (!octahedron_tool_box_.IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+  void SetQuantizationBits(int q) {
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+
+ private:
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitDecoder flip_normal_bit_decoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT,
+    MeshDataT>::ComputeOriginalValues(const CorrType *in_corr,
+                                      DataTypeT *out_data, int /* size */,
+                                      int num_components,
+                                      const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  int32_t pred_normal_oct[2];
+
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+    if (flip_normal_bit_decoder_.DecodeNextBit()) {
+      pred_normal_3d = -pred_normal_3d;
+    }
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pred_normal_oct, pred_normal_oct + 1);
+
+    const int data_offset = data_id * 2;
+    this->transform().ComputeOriginalValue(
+        pred_normal_oct, in_corr + data_offset, out_data + data_offset);
+  }
+  flip_normal_bit_decoder_.EndDecoding();
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+  // Get data needed for transform
+  if (!this->transform().DecodeTransformData(buffer)) {
+    return false;
+  }
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint8_t prediction_mode;
+    if (!buffer->Decode(&prediction_mode)) {
+      return false;
+    }
+    if (prediction_mode > TRIANGLE_AREA) {
+      // Invalid prediction mode.
+      return false;
+    }
+
+    if (!predictor_.SetNormalPredictionMode(
+            NormalPredictionMode(prediction_mode))) {
+      return false;
+    }
+  }
+#endif
+
+  // Init normal flips.
+  if (!flip_normal_bit_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_

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

@@ -0,0 +1,180 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Prediction scheme for normals based on the underlying geometry.
+// At a smooth vertices normals are computed by weighting the normals of
+// adjacent faces with the area of these faces. At seams, the same approach
+// applies for seam corners.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalEncoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  void SetQuantizationBits(int q) {
+    DRACO_DCHECK_GE(q, 2);
+    DRACO_DCHECK_LE(q, 30);
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitEncoder flip_normal_bit_encoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  flip_normal_bit_encoder_.StartEncoding();
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  VectorD<int32_t, 2> pos_pred_normal_oct;
+  VectorD<int32_t, 2> neg_pred_normal_oct;
+  VectorD<int32_t, 2> pos_correction;
+  VectorD<int32_t, 2> neg_correction;
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+
+    // Compute octahedral coordinates for both possible directions.
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pos_pred_normal_oct.data(),
+        pos_pred_normal_oct.data() + 1);
+    pred_normal_3d = -pred_normal_3d;
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), neg_pred_normal_oct.data(),
+        neg_pred_normal_oct.data() + 1);
+
+    // Choose the one with the best correction value.
+    const int data_offset = data_id * 2;
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        pos_pred_normal_oct.data(),
+                                        pos_correction.data());
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        neg_pred_normal_oct.data(),
+                                        neg_correction.data());
+    pos_correction[0] = octahedron_tool_box_.ModMax(pos_correction[0]);
+    pos_correction[1] = octahedron_tool_box_.ModMax(pos_correction[1]);
+    neg_correction[0] = octahedron_tool_box_.ModMax(neg_correction[0]);
+    neg_correction[1] = octahedron_tool_box_.ModMax(neg_correction[1]);
+    if (pos_correction.AbsSum() < neg_correction.AbsSum()) {
+      flip_normal_bit_encoder_.EncodeBit(false);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(pos_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(pos_correction[1]);
+    } else {
+      flip_normal_bit_encoder_.EncodeBit(true);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(neg_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(neg_correction[1]);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  if (!this->transform().EncodeTransformData(buffer)) {
+    return false;
+  }
+
+  // Encode normal flips.
+  flip_normal_bit_encoder_.EndEncoding(buffer);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_

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

@@ -0,0 +1,117 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+
+namespace draco {
+
+// This predictor estimates the normal via the surrounding triangles of the
+// given corner. Triangles are weighted according to their area.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorArea
+    : public MeshPredictionSchemeGeometricNormalPredictorBase<
+          DataTypeT, TransformT, MeshDataT> {
+  typedef MeshPredictionSchemeGeometricNormalPredictorBase<
+      DataTypeT, TransformT, MeshDataT>
+      Base;
+
+ public:
+  explicit MeshPredictionSchemeGeometricNormalPredictorArea(const MeshDataT &md)
+      : Base(md) {
+    this->SetNormalPredictionMode(TRIANGLE_AREA);
+  };
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorArea() {}
+
+  // Computes predicted octahedral coordinates on a given corner.
+  void ComputePredictedValue(CornerIndex corner_id,
+                             DataTypeT *prediction) override {
+    DRACO_DCHECK(this->IsInitialized());
+    typedef typename MeshDataT::CornerTable CornerTable;
+    const CornerTable *const corner_table = this->mesh_data_.corner_table();
+    // Going to compute the predicted normal from the surrounding triangles
+    // according to the connectivity of the given corner table.
+    VertexCornersIterator<CornerTable> cit(corner_table, corner_id);
+    // Position of central vertex does not change in loop.
+    const VectorD<int64_t, 3> pos_cent = this->GetPositionForCorner(corner_id);
+    // Computing normals for triangles and adding them up.
+
+    VectorD<int64_t, 3> normal;
+    CornerIndex c_next, c_prev;
+    while (!cit.End()) {
+      // Getting corners.
+      if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+        c_next = corner_table->Next(corner_id);
+        c_prev = corner_table->Previous(corner_id);
+      } else {
+        c_next = corner_table->Next(cit.Corner());
+        c_prev = corner_table->Previous(cit.Corner());
+      }
+      const VectorD<int64_t, 3> pos_next = this->GetPositionForCorner(c_next);
+      const VectorD<int64_t, 3> pos_prev = this->GetPositionForCorner(c_prev);
+
+      // Computing delta vectors to next and prev.
+      const VectorD<int64_t, 3> delta_next = pos_next - pos_cent;
+      const VectorD<int64_t, 3> delta_prev = pos_prev - pos_cent;
+
+      // Computing cross product.
+      const VectorD<int64_t, 3> cross = CrossProduct(delta_next, delta_prev);
+
+      // Prevent signed integer overflows by doing math as unsigned.
+      auto normal_data = reinterpret_cast<uint64_t *>(normal.data());
+      auto cross_data = reinterpret_cast<const uint64_t *>(cross.data());
+      normal_data[0] = normal_data[0] + cross_data[0];
+      normal_data[1] = normal_data[1] + cross_data[1];
+      normal_data[2] = normal_data[2] + cross_data[2];
+
+      cit.Next();
+    }
+
+    // Convert to int32_t, make sure entries are not too large.
+    constexpr int64_t upper_bound = 1 << 29;
+    if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+      const int32_t abs_sum = static_cast<int32_t>(normal.AbsSum());
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    } else {
+      const int64_t abs_sum = normal.AbsSum();
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    }
+    DRACO_DCHECK_LE(normal.AbsSum(), upper_bound);
+    prediction[0] = static_cast<int32_t>(normal[0]);
+    prediction[1] = static_cast<int32_t>(normal[1]);
+    prediction[2] = static_cast<int32_t>(normal[2]);
+  }
+  bool SetNormalPredictionMode(NormalPredictionMode mode) override {
+    if (mode == ONE_TRIANGLE) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    } else if (mode == TRIANGLE_AREA) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    }
+    return false;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_

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

@@ -0,0 +1,96 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+
+#include <math.h>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+// Base class for geometric normal predictors using position attribute.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorBase {
+ protected:
+  explicit MeshPredictionSchemeGeometricNormalPredictorBase(const MeshDataT &md)
+      : pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        mesh_data_(md) {}
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorBase() {}
+
+ public:
+  void SetPositionAttribute(const PointAttribute &position_attribute) {
+    pos_attribute_ = &position_attribute;
+  }
+  void SetEntryToPointIdMap(const PointIndex *map) {
+    entry_to_point_id_map_ = map;
+  }
+  bool IsInitialized() const {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (entry_to_point_id_map_ == nullptr) {
+      return false;
+    }
+    return true;
+  }
+
+  virtual bool SetNormalPredictionMode(NormalPredictionMode mode) = 0;
+  virtual NormalPredictionMode GetNormalPredictionMode() const {
+    return normal_prediction_mode_;
+  }
+
+ protected:
+  VectorD<int64_t, 3> GetPositionForDataId(int data_id) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto point_id = entry_to_point_id_map_[data_id];
+    const auto pos_val_id = pos_attribute_->mapped_index(point_id);
+    VectorD<int64_t, 3> pos;
+    pos_attribute_->ConvertValue(pos_val_id, &pos[0]);
+    return pos;
+  }
+  VectorD<int64_t, 3> GetPositionForCorner(CornerIndex ci) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto corner_table = mesh_data_.corner_table();
+    const auto vert_id = corner_table->Vertex(ci).value();
+    const auto data_id = mesh_data_.vertex_to_data_map()->at(vert_id);
+    return GetPositionForDataId(data_id);
+  }
+  VectorD<int32_t, 2> GetOctahedralCoordForDataId(int data_id,
+                                                  const DataTypeT *data) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const int data_offset = data_id * 2;
+    return VectorD<int32_t, 2>(data[data_offset], data[data_offset + 1]);
+  }
+  // Computes predicted octahedral coordinates on a given corner.
+  virtual void ComputePredictedValue(CornerIndex corner_id,
+                                     DataTypeT *prediction) = 0;
+
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  MeshDataT mesh_data_;
+  NormalPredictionMode normal_prediction_mode_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_