dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/attributes/geometry_attribute.h

@@ -0,0 +1,541 @@
+// 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_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/data_buffer.h"
+#include "draco/core/hash_utils.h"
+#include "draco/draco_features.h"
+#ifdef DRACO_TRANSCODER_SUPPORTED
+#include "draco/core/status.h"
+#endif
+
+namespace draco {
+
+// The class provides access to a specific attribute which is stored in a
+// DataBuffer, such as normals or coordinates. However, the GeometryAttribute
+// class does not own the buffer and the buffer itself may store other data
+// unrelated to this attribute (such as data for other attributes in which case
+// we can have multiple GeometryAttributes accessing one buffer). Typically,
+// all attributes for a point (or corner, face) are stored in one block, which
+// is advantageous in terms of memory access. The length of the entire block is
+// given by the byte_stride, the position where the attribute starts is given by
+// the byte_offset, the actual number of bytes that the attribute occupies is
+// given by the data_type and the number of components.
+class GeometryAttribute {
+ public:
+  // Supported attribute types.
+  enum Type {
+    INVALID = -1,
+    // Named attributes start here. The difference between named and generic
+    // attributes is that for named attributes we know their purpose and we
+    // can apply some special methods when dealing with them (e.g. during
+    // encoding).
+    POSITION = 0,
+    NORMAL,
+    COLOR,
+    TEX_COORD,
+    // A special id used to mark attributes that are not assigned to any known
+    // predefined use case. Such attributes are often used for a shader specific
+    // data.
+    GENERIC,
+#ifdef DRACO_TRANSCODER_SUPPORTED
+    // TODO(ostava): Adding a new attribute would be bit-stream change for GLTF.
+    // Older decoders wouldn't know what to do with this attribute type. This
+    // should be open-sourced only when we are ready to increase our bit-stream
+    // version.
+    TANGENT,
+    MATERIAL,
+    JOINTS,
+    WEIGHTS,
+#endif
+    // Total number of different attribute types.
+    // Always keep behind all named attributes.
+    NAMED_ATTRIBUTES_COUNT,
+  };
+
+  GeometryAttribute();
+  // Initializes and enables the attribute.
+  void Init(Type attribute_type, DataBuffer *buffer, uint8_t num_components,
+            DataType data_type, bool normalized, int64_t byte_stride,
+            int64_t byte_offset);
+  bool IsValid() const { return buffer_ != nullptr; }
+
+  // Copies data from the source attribute to the this attribute.
+  // This attribute must have a valid buffer allocated otherwise the operation
+  // is going to fail and return false.
+  bool CopyFrom(const GeometryAttribute &src_att);
+
+  // Function for getting a attribute value with a specific format.
+  // Unsafe. Caller must ensure the accessed memory is valid.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  std::array<T, att_components_t> GetValue(
+      AttributeValueIndex att_index) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    std::array<T, att_components_t> out;
+    buffer_->Read(byte_pos, &(out[0]), sizeof(out));
+    return out;
+  }
+
+  // Function for getting a attribute value with a specific format.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  bool GetValue(AttributeValueIndex att_index,
+                std::array<T, att_components_t> *out) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    // Check we are not reading past end of data.
+    if (byte_pos + sizeof(*out) > buffer_->data_size()) {
+      return false;
+    }
+    buffer_->Read(byte_pos, &((*out)[0]), sizeof(*out));
+    return true;
+  }
+
+  // Returns the byte position of the attribute entry in the data buffer.
+  inline int64_t GetBytePos(AttributeValueIndex att_index) const {
+    return byte_offset_ + byte_stride_ * att_index.value();
+  }
+
+  inline const uint8_t *GetAddress(AttributeValueIndex att_index) const {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline uint8_t *GetAddress(AttributeValueIndex att_index) {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline bool IsAddressValid(const uint8_t *address) const {
+    return ((buffer_->data() + buffer_->data_size()) > address);
+  }
+
+  // Fills out_data with the raw value of the requested attribute entry.
+  // out_data must be at least byte_stride_ long.
+  void GetValue(AttributeValueIndex att_index, void *out_data) const {
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    buffer_->Read(byte_pos, out_data, byte_stride_);
+  }
+
+  // Sets a value of an attribute entry. The input value must be allocated to
+  // cover all components of a single attribute entry.
+  void SetAttributeValue(AttributeValueIndex entry_index, const void *value) {
+    const int64_t byte_pos = entry_index.value() * byte_stride();
+    buffer_->Write(byte_pos, value, byte_stride());
+  }
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Sets a value of an attribute entry. The input |value| must have
+  // |input_num_components| entries and it will be automatically converted to
+  // the internal format used by the geometry attribute. If the conversion is
+  // not possible, an error status will be returned.
+  template <typename InputT>
+  Status ConvertAndSetAttributeValue(AttributeValueIndex avi,
+                                     int input_num_components,
+                                     const InputT *value);
+#endif
+
+  // DEPRECATED: Use
+  //   ConvertValue(AttributeValueIndex att_id,
+  //               int out_num_components,
+  //               OutT *out_val);
+  //
+  // Function for conversion of a attribute to a specific output format.
+  // OutT is the desired data type of the attribute.
+  // out_att_components_t is the number of components of the output format.
+  // Returns false when the conversion failed.
+  template <typename OutT, int out_att_components_t>
+  bool ConvertValue(AttributeValueIndex att_id, OutT *out_val) const {
+    return ConvertValue(att_id, out_att_components_t, out_val);
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // |out_val| needs to be able to store |out_num_components| values.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_id, int8_t out_num_components,
+                    OutT *out_val) const {
+    if (out_val == nullptr) {
+      return false;
+    }
+    switch (data_type_) {
+      case DT_INT8:
+        return ConvertTypedValue<int8_t, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_UINT8:
+        return ConvertTypedValue<uint8_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_INT16:
+        return ConvertTypedValue<int16_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT16:
+        return ConvertTypedValue<uint16_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT32:
+        return ConvertTypedValue<int32_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT32:
+        return ConvertTypedValue<uint32_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT64:
+        return ConvertTypedValue<int64_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT64:
+        return ConvertTypedValue<uint64_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_FLOAT32:
+        return ConvertTypedValue<float, OutT>(att_id, out_num_components,
+                                              out_val);
+      case DT_FLOAT64:
+        return ConvertTypedValue<double, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_BOOL:
+        return ConvertTypedValue<bool, OutT>(att_id, out_num_components,
+                                             out_val);
+      default:
+        // Wrong attribute type.
+        return false;
+    }
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // The |out_value| must be able to store all components of a single attribute
+  // entry.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_index, OutT *out_value) const {
+    return ConvertValue<OutT>(att_index, num_components_, out_value);
+  }
+
+  // Utility function. Returns |attribute_type| as std::string.
+  static std::string TypeToString(Type attribute_type) {
+    switch (attribute_type) {
+      case INVALID:
+        return "INVALID";
+      case POSITION:
+        return "POSITION";
+      case NORMAL:
+        return "NORMAL";
+      case COLOR:
+        return "COLOR";
+      case TEX_COORD:
+        return "TEX_COORD";
+      case GENERIC:
+        return "GENERIC";
+#ifdef DRACO_TRANSCODER_SUPPORTED
+      case TANGENT:
+        return "TANGENT";
+      case MATERIAL:
+        return "MATERIAL";
+      case JOINTS:
+        return "JOINTS";
+      case WEIGHTS:
+        return "WEIGHTS";
+#endif
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  bool operator==(const GeometryAttribute &va) const;
+
+  // Returns the type of the attribute indicating the nature of the attribute.
+  Type attribute_type() const { return attribute_type_; }
+  void set_attribute_type(Type type) { attribute_type_ = type; }
+  // Returns the data type that is stored in the attribute.
+  DataType data_type() const { return data_type_; }
+  // Returns the number of components that are stored for each entry.
+  // For position attribute this is usually three (x,y,z),
+  // while texture coordinates have two components (u,v).
+  uint8_t num_components() const { return num_components_; }
+  // Indicates whether the data type should be normalized before interpretation,
+  // that is, it should be divided by the max value of the data type.
+  bool normalized() const { return normalized_; }
+  void set_normalized(bool normalized) { normalized_ = normalized; }
+  // The buffer storing the entire data of the attribute.
+  const DataBuffer *buffer() const { return buffer_; }
+  // Returns the number of bytes between two attribute entries, this is, at
+  // least size of the data types times number of components.
+  int64_t byte_stride() const { return byte_stride_; }
+  // The offset where the attribute starts within the block of size byte_stride.
+  int64_t byte_offset() const { return byte_offset_; }
+  void set_byte_offset(int64_t byte_offset) { byte_offset_ = byte_offset; }
+  DataBufferDescriptor buffer_descriptor() const { return buffer_descriptor_; }
+  uint32_t unique_id() const { return unique_id_; }
+  void set_unique_id(uint32_t id) { unique_id_ = id; }
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  std::string name() const { return name_; }
+  void set_name(std::string name) { name_ = name; }
+#endif
+
+ protected:
+  // Sets a new internal storage for the attribute.
+  void ResetBuffer(DataBuffer *buffer, int64_t byte_stride,
+                   int64_t byte_offset);
+
+ private:
+  // Function for conversion of an attribute to a specific output format given a
+  // format of the stored attribute.
+  // T is the stored attribute data type.
+  // OutT is the desired data type of the attribute.
+  template <typename T, typename OutT>
+  bool ConvertTypedValue(AttributeValueIndex att_id, uint8_t out_num_components,
+                         OutT *out_value) const {
+    const uint8_t *src_address = GetAddress(att_id);
+
+    // Convert all components available in both the original and output formats.
+    for (int i = 0; i < std::min(num_components_, out_num_components); ++i) {
+      if (!IsAddressValid(src_address)) {
+        return false;
+      }
+      const T in_value = *reinterpret_cast<const T *>(src_address);
+      if (!ConvertComponentValue<T, OutT>(in_value, normalized_,
+                                          out_value + i)) {
+        return false;
+      }
+      src_address += sizeof(T);
+    }
+    // Fill empty data for unused output components if needed.
+    for (int i = num_components_; i < out_num_components; ++i) {
+      out_value[i] = static_cast<OutT>(0);
+    }
+    return true;
+  }
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Function that converts input |value| from type T to the internal attribute
+  // representation defined by OutT and |num_components_|.
+  template <typename T, typename OutT>
+  Status ConvertAndSetAttributeTypedValue(AttributeValueIndex avi,
+                                          int8_t input_num_components,
+                                          const T *value) {
+    uint8_t *address = GetAddress(avi);
+
+    // Convert all components available in both the original and output formats.
+    for (int i = 0; i < num_components_; ++i) {
+      if (!IsAddressValid(address)) {
+        return ErrorStatus("GeometryAttribute: Invalid address.");
+      }
+      OutT *const out_value = reinterpret_cast<OutT *>(address);
+      if (i < input_num_components) {
+        if (!ConvertComponentValue<T, OutT>(*(value + i), normalized_,
+                                            out_value)) {
+          return ErrorStatus(
+              "GeometryAttribute: Failed to convert component value.");
+        }
+      } else {
+        *out_value = static_cast<OutT>(0);
+      }
+      address += sizeof(OutT);
+    }
+    return OkStatus();
+  }
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+  // Converts |in_value| of type T into |out_value| of type OutT. If
+  // |normalized| is true, any conversion between floating point and integer
+  // values will be treating integers as normalized types (the entire integer
+  // range will be used to represent 0-1 floating point range).
+  template <typename T, typename OutT>
+  static bool ConvertComponentValue(const T &in_value, bool normalized,
+                                    OutT *out_value) {
+    // Make sure the |in_value| can be represented as an integral type OutT.
+    if (std::is_integral<OutT>::value) {
+      // Make sure the |in_value| fits within the range of values that OutT
+      // is able to represent. Perform the check only for integral types.
+      if (!std::is_same<T, bool>::value && std::is_integral<T>::value) {
+        static constexpr OutT kOutMin =
+            std::is_signed<T>::value ? std::numeric_limits<OutT>::min() : 0;
+        if (in_value < kOutMin || in_value > std::numeric_limits<OutT>::max()) {
+          return false;
+        }
+      }
+
+      // Check conversion of floating point |in_value| to integral value OutT.
+      if (std::is_floating_point<T>::value) {
+        // Make sure the floating point |in_value| is not NaN and not Inf as
+        // integral type OutT is unable to represent these values.
+        if (sizeof(in_value) > sizeof(double)) {
+          if (std::isnan(static_cast<long double>(in_value)) ||
+              std::isinf(static_cast<long double>(in_value))) {
+            return false;
+          }
+        } else if (sizeof(in_value) > sizeof(float)) {
+          if (std::isnan(static_cast<double>(in_value)) ||
+              std::isinf(static_cast<double>(in_value))) {
+            return false;
+          }
+        } else {
+          if (std::isnan(static_cast<float>(in_value)) ||
+              std::isinf(static_cast<float>(in_value))) {
+            return false;
+          }
+        }
+
+        // Make sure the floating point |in_value| fits within the range of
+        // values that integral type OutT is able to represent.
+        if (in_value < std::numeric_limits<OutT>::min() ||
+            in_value >= std::numeric_limits<OutT>::max()) {
+          return false;
+        }
+      }
+    }
+
+    if (std::is_integral<T>::value && std::is_floating_point<OutT>::value &&
+        normalized) {
+      // When converting integer to floating point, normalize the value if
+      // necessary.
+      *out_value = static_cast<OutT>(in_value);
+      *out_value /= static_cast<OutT>(std::numeric_limits<T>::max());
+    } else if (std::is_floating_point<T>::value &&
+               std::is_integral<OutT>::value && normalized) {
+      // Converting from floating point to a normalized integer.
+      if (in_value > 1 || in_value < 0) {
+        // Normalized float values need to be between 0 and 1.
+        return false;
+      }
+      // TODO(ostava): Consider allowing float to normalized integer conversion
+      // for 64-bit integer types. Currently it doesn't work because we don't
+      // have a floating point type that could store all 64 bit integers.
+      if (sizeof(OutT) > 4) {
+        return false;
+      }
+      // Expand the float to the range of the output integer and round it to the
+      // nearest representable value. Use doubles for the math to ensure the
+      // integer values are represented properly during the conversion process.
+      *out_value = static_cast<OutT>(std::floor(
+          in_value * static_cast<double>(std::numeric_limits<OutT>::max()) +
+          0.5));
+    } else {
+      *out_value = static_cast<OutT>(in_value);
+    }
+
+    // TODO(ostava): Add handling of normalized attributes when converting
+    // between different integer representations. If the attribute is
+    // normalized, integer values should be converted as if they represent 0-1
+    // range. E.g. when we convert uint16 to uint8, the range <0, 2^16 - 1>
+    // should be converted to range <0, 2^8 - 1>.
+    return true;
+  }
+
+  DataBuffer *buffer_;
+  // The buffer descriptor is stored at the time the buffer is attached to this
+  // attribute. The purpose is to detect if any changes happened to the buffer
+  // since the time it was attached.
+  DataBufferDescriptor buffer_descriptor_;
+  uint8_t num_components_;
+  DataType data_type_;
+  bool normalized_;
+  int64_t byte_stride_;
+  int64_t byte_offset_;
+
+  Type attribute_type_;
+
+  // Unique id of this attribute. No two attributes could have the same unique
+  // id. It is used to identify each attribute, especially when there are
+  // multiple attribute of the same type in a point cloud.
+  uint32_t unique_id_;
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  std::string name_;
+#endif
+
+  friend struct GeometryAttributeHasher;
+};
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+template <typename InputT>
+Status GeometryAttribute::ConvertAndSetAttributeValue(AttributeValueIndex avi,
+                                                      int input_num_components,
+                                                      const InputT *value) {
+  switch (this->data_type()) {
+    case DT_INT8:
+      return ConvertAndSetAttributeTypedValue<InputT, int8_t>(
+          avi, input_num_components, value);
+    case DT_UINT8:
+      return ConvertAndSetAttributeTypedValue<InputT, uint8_t>(
+          avi, input_num_components, value);
+    case DT_INT16:
+      return ConvertAndSetAttributeTypedValue<InputT, int16_t>(
+          avi, input_num_components, value);
+    case DT_UINT16:
+      return ConvertAndSetAttributeTypedValue<InputT, uint16_t>(
+          avi, input_num_components, value);
+    case DT_INT32:
+      return ConvertAndSetAttributeTypedValue<InputT, int32_t>(
+          avi, input_num_components, value);
+    case DT_UINT32:
+      return ConvertAndSetAttributeTypedValue<InputT, uint32_t>(
+          avi, input_num_components, value);
+    case DT_INT64:
+      return ConvertAndSetAttributeTypedValue<InputT, int64_t>(
+          avi, input_num_components, value);
+    case DT_UINT64:
+      return ConvertAndSetAttributeTypedValue<InputT, uint64_t>(
+          avi, input_num_components, value);
+    case DT_FLOAT32:
+      return ConvertAndSetAttributeTypedValue<InputT, float>(
+          avi, input_num_components, value);
+    case DT_FLOAT64:
+      return ConvertAndSetAttributeTypedValue<InputT, double>(
+          avi, input_num_components, value);
+    case DT_BOOL:
+      return ConvertAndSetAttributeTypedValue<InputT, bool>(
+          avi, input_num_components, value);
+    default:
+      break;
+  }
+  return ErrorStatus(
+      "GeometryAttribute::SetAndConvertAttributeValue: Unsupported "
+      "attribute type.");
+}
+#endif
+
+// Hashing support
+
+// Function object for using Attribute as a hash key.
+struct GeometryAttributeHasher {
+  size_t operator()(const GeometryAttribute &va) const {
+    size_t hash = HashCombine(va.buffer_descriptor_.buffer_id,
+                              va.buffer_descriptor_.buffer_update_count);
+    hash = HashCombine(va.num_components_, hash);
+    hash = HashCombine(static_cast<int8_t>(va.data_type_), hash);
+    hash = HashCombine(static_cast<int8_t>(va.attribute_type_), hash);
+    hash = HashCombine(va.byte_stride_, hash);
+    return HashCombine(va.byte_offset_, hash);
+  }
+};
+
+// Function object for using GeometryAttribute::Type as a hash key.
+struct GeometryAttributeTypeHasher {
+  size_t operator()(const GeometryAttribute::Type &at) const {
+    return static_cast<size_t>(at);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_

include/draco/attributes/geometry_indices.h

@@ -0,0 +1,54 @@
+// 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_ATTRIBUTES_GEOMETRY_INDICES_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
+
+#include <inttypes.h>
+
+#include <limits>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// Index of an attribute value entry stored in a GeometryAttribute.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, AttributeValueIndex)
+// Index of a point in a PointCloud.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, PointIndex)
+// Vertex index in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, VertexIndex)
+// Corner index that identifies a corner in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, CornerIndex)
+// Face index for Mesh and CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, FaceIndex)
+
+// Constants denoting invalid indices.
+static constexpr AttributeValueIndex kInvalidAttributeValueIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr PointIndex kInvalidPointIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr VertexIndex kInvalidVertexIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr CornerIndex kInvalidCornerIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr FaceIndex kInvalidFaceIndex(
+    std::numeric_limits<uint32_t>::max());
+
+// TODO(ostava): Add strongly typed indices for attribute id and unique
+// attribute id.
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_