dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/core/math_utils.h

@@ -0,0 +1,79 @@
+// 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_CORE_MATH_UTILS_H_
+#define DRACO_CORE_MATH_UTILS_H_
+
+#include <inttypes.h>
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+#define DRACO_INCREMENT_MOD(I, M) (((I) == ((M)-1)) ? 0 : ((I) + 1))
+
+// Returns floor(sqrt(x)) where x is an integer number. The main intend of this
+// function is to provide a cross platform and deterministic implementation of
+// square root for integer numbers. This function is not intended to be a
+// replacement for std::sqrt() for general cases. IntSqrt is in fact about 3X
+// slower compared to most implementation of std::sqrt().
+inline uint64_t IntSqrt(uint64_t number) {
+  if (number == 0) {
+    return 0;
+  }
+  // First estimate good initial value of the square root as log2(number).
+  uint64_t act_number = number;
+  uint64_t square_root = 1;
+  while (act_number >= 2) {
+    // Double the square root until |square_root * square_root > number|.
+    square_root *= 2;
+    act_number /= 4;
+  }
+  // Perform Newton's (or Babylonian) method to find the true floor(sqrt()).
+  do {
+    // New |square_root| estimate is computed as the average between
+    // |square_root| and |number / square_root|.
+    square_root = (square_root + number / square_root) / 2;
+
+    // Note that after the first iteration, the estimate is always going to be
+    // larger or equal to the true square root value. Therefore to check
+    // convergence, we can simply detect condition when the square of the
+    // estimated square root is larger than the input.
+  } while (square_root * square_root > number);
+  return square_root;
+}
+
+// Performs the addition in unsigned type to avoid signed integer overflow. Note
+// that the result will be the same (for non-overflowing values).
+template <
+    typename DataTypeT,
+    typename std::enable_if<std::is_integral<DataTypeT>::value &&
+                            std::is_signed<DataTypeT>::value>::type * = nullptr>
+inline DataTypeT AddAsUnsigned(DataTypeT a, DataTypeT b) {
+  typedef typename std::make_unsigned<DataTypeT>::type DataTypeUT;
+  return static_cast<DataTypeT>(static_cast<DataTypeUT>(a) +
+                                static_cast<DataTypeUT>(b));
+}
+
+template <typename DataTypeT,
+          typename std::enable_if<!std::is_integral<DataTypeT>::value ||
+                                  !std::is_signed<DataTypeT>::value>::type * =
+              nullptr>
+inline DataTypeT AddAsUnsigned(DataTypeT a, DataTypeT b) {
+  return a + b;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_MATH_UTILS_H_

include/draco/core/options.h

@@ -0,0 +1,151 @@
+// 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_CORE_OPTIONS_H_
+#define DRACO_CORE_OPTIONS_H_
+
+#include <cstdlib>
+#include <map>
+#include <string>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for storing generic options as a <name, value> pair in a string map.
+// The API provides helper methods for directly storing values of various types
+// such as ints and bools. One named option should be set with only a single
+// data type.
+class Options {
+ public:
+  Options() = default;
+  ~Options() = default;
+
+  // Merges |other_options| on top of the existing options of this instance
+  // replacing all entries that are present in both options instances.
+  void MergeAndReplace(const Options &other_options);
+
+  void SetInt(const std::string &name, int val);
+  void SetFloat(const std::string &name, float val);
+  void SetBool(const std::string &name, bool val);
+  void SetString(const std::string &name, const std::string &val);
+  template <class VectorT>
+  void SetVector(const std::string &name, const VectorT &vec) {
+    SetVector(name, &vec[0], VectorT::dimension);
+  }
+  template <typename DataTypeT>
+  void SetVector(const std::string &name, const DataTypeT *vec, int num_dims);
+
+  // Getters will return a default value if the entry is not found. The default
+  // value can be specified in the overloaded version of each function.
+  int GetInt(const std::string &name) const;
+  int GetInt(const std::string &name, int default_val) const;
+  float GetFloat(const std::string &name) const;
+  float GetFloat(const std::string &name, float default_val) const;
+  bool GetBool(const std::string &name) const;
+  bool GetBool(const std::string &name, bool default_val) const;
+  std::string GetString(const std::string &name) const;
+  std::string GetString(const std::string &name,
+                        const std::string &default_val) const;
+  template <class VectorT>
+  VectorT GetVector(const std::string &name, const VectorT &default_val) const;
+  // Unlike other Get functions, this function returns false if the option does
+  // not exist, otherwise it fills |out_val| with the vector values. If a
+  // default value is needed, it can be set in |out_val|.
+  template <typename DataTypeT>
+  bool GetVector(const std::string &name, int num_dims,
+                 DataTypeT *out_val) const;
+
+  bool IsOptionSet(const std::string &name) const {
+    return options_.count(name) > 0;
+  }
+
+ private:
+  // All entries are internally stored as strings and converted to the desired
+  // return type based on the used Get* method.
+  std::map<std::string, std::string> options_;
+};
+
+template <typename DataTypeT>
+void Options::SetVector(const std::string &name, const DataTypeT *vec,
+                        int num_dims) {
+  std::string out;
+  for (int i = 0; i < num_dims; ++i) {
+    if (i > 0) {
+      out += " ";
+    }
+
+// GNU STL on android doesn't include a proper std::to_string, but the libc++
+// version does
+#if defined(ANDROID) && !defined(_LIBCPP_VERSION)
+    out += to_string(vec[i]);
+#else
+    out += std::to_string(vec[i]);
+#endif
+  }
+  options_[name] = out;
+}
+
+template <class VectorT>
+VectorT Options::GetVector(const std::string &name,
+                           const VectorT &default_val) const {
+  VectorT ret = default_val;
+  GetVector(name, VectorT::dimension, &ret[0]);
+  return ret;
+}
+
+template <typename DataTypeT>
+bool Options::GetVector(const std::string &name, int num_dims,
+                        DataTypeT *out_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return false;
+  }
+  const std::string value = it->second;
+  if (value.length() == 0) {
+    return true;  // Option set but no data is present
+  }
+  const char *act_str = value.c_str();
+  char *next_str;
+  for (int i = 0; i < num_dims; ++i) {
+    if (std::is_integral<DataTypeT>::value) {
+#ifdef ANDROID
+      const int val = strtol(act_str, &next_str, 10);
+#else
+      const int val = static_cast<int>(std::strtol(act_str, &next_str, 10));
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    } else {
+#ifdef ANDROID
+      const float val = strtof(act_str, &next_str);
+#else
+      const float val = std::strtof(act_str, &next_str);
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_OPTIONS_H_

include/draco/core/quantization_utils.h

@@ -0,0 +1,82 @@
+// 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.
+//
+// A set of classes for quantizing and dequantizing of floating point values
+// into integers.
+// The quantization works on all floating point numbers within (-range, +range)
+// interval producing integers in range
+// (-max_quantized_value, +max_quantized_value).
+
+#ifndef DRACO_CORE_QUANTIZATION_UTILS_H_
+#define DRACO_CORE_QUANTIZATION_UTILS_H_
+
+#include <stdint.h>
+
+#include <cmath>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Class for quantizing single precision floating point values. The values
+// should be centered around zero and be within interval (-range, +range), where
+// the range is specified in the Init() method. Alternatively, the quantization
+// can be defined by |delta| that specifies the distance between two quantized
+// values. Note that the quantizer always snaps the values to the nearest
+// integer value. E.g. for |delta| == 1.f, values -0.4f and 0.4f would be
+// both quantized to 0 while value 0.6f would be quantized to 1. If a value
+// lies exactly between two quantized states, it is always rounded up. E.g.,
+// for |delta| == 1.f, value -0.5f would be quantized to 0 while 0.5f would be
+// quantized to 1.
+class Quantizer {
+ public:
+  Quantizer();
+  void Init(float range, int32_t max_quantized_value);
+  void Init(float delta);
+  inline int32_t QuantizeFloat(float val) const {
+    val *= inverse_delta_;
+    return static_cast<int32_t>(floor(val + 0.5f));
+  }
+  inline int32_t operator()(float val) const { return QuantizeFloat(val); }
+
+ private:
+  float inverse_delta_;
+};
+
+// Class for dequantizing values that were previously quantized using the
+// Quantizer class.
+class Dequantizer {
+ public:
+  Dequantizer();
+
+  // Initializes the dequantizer. Both parameters must correspond to the values
+  // provided to the initializer of the Quantizer class.
+  // Returns false when the initialization fails.
+  bool Init(float range, int32_t max_quantized_value);
+
+  // Initializes the dequantizer using the |delta| between two quantized values.
+  bool Init(float delta);
+
+  inline float DequantizeFloat(int32_t val) const {
+    return static_cast<float>(val) * delta_;
+  }
+  inline float operator()(int32_t val) const { return DequantizeFloat(val); }
+
+ private:
+  float delta_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_QUANTIZATION_UTILS_H_

include/draco/core/status.h

@@ -0,0 +1,83 @@
+// 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_CORE_STATUS_H_
+#define DRACO_CORE_STATUS_H_
+
+#include <ostream>
+#include <string>
+
+namespace draco {
+
+// Class encapsulating a return status of an operation with an optional error
+// message. Intended to be used as a return type for functions instead of bool.
+class Status {
+ public:
+  enum Code {
+    OK = 0,
+    DRACO_ERROR = -1,          // Used for general errors.
+    IO_ERROR = -2,             // Error when handling input or output stream.
+    INVALID_PARAMETER = -3,    // Invalid parameter passed to a function.
+    UNSUPPORTED_VERSION = -4,  // Input not compatible with the current version.
+    UNKNOWN_VERSION = -5,      // Input was created with an unknown version of
+                               // the library.
+    UNSUPPORTED_FEATURE = -6,  // Input contains feature that is not supported.
+  };
+
+  Status() : code_(OK) {}
+  Status(const Status &status) = default;
+  Status(Status &&status) = default;
+  explicit Status(Code code) : code_(code) {}
+  Status(Code code, const std::string &error_msg)
+      : code_(code), error_msg_(error_msg) {}
+
+  Code code() const { return code_; }
+  const std::string &error_msg_string() const { return error_msg_; }
+  const char *error_msg() const { return error_msg_.c_str(); }
+  std::string code_string() const;
+  std::string code_and_error_string() const;
+
+  bool operator==(Code code) const { return code == code_; }
+  bool ok() const { return code_ == OK; }
+
+  Status &operator=(const Status &) = default;
+
+ private:
+  Code code_;
+  std::string error_msg_;
+};
+
+inline std::ostream &operator<<(std::ostream &os, const Status &status) {
+  os << status.error_msg_string();
+  return os;
+}
+
+inline Status OkStatus() { return Status(Status::OK); }
+inline Status ErrorStatus(const std::string &msg) {
+  return Status(Status::DRACO_ERROR, msg);
+}
+
+// Evaluates an expression that returns draco::Status. If the status is not OK,
+// the macro returns the status object.
+#define DRACO_RETURN_IF_ERROR(expression)             \
+  {                                                   \
+    const draco::Status _local_status = (expression); \
+    if (!_local_status.ok()) {                        \
+      return _local_status;                           \
+    }                                                 \
+  }
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_H_

include/draco/core/status_or.h

@@ -0,0 +1,81 @@
+// 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_CORE_STATUS_OR_H_
+#define DRACO_CORE_STATUS_OR_H_
+
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+
+namespace draco {
+
+// Class StatusOr is used to wrap a Status along with a value of a specified
+// type |T|. StatusOr is intended to be returned from functions in situations
+// where it is desirable to carry over more information about the potential
+// errors encountered during the function execution. If there are not errors,
+// the caller can simply use the return value, otherwise the Status object
+// provides more info about the encountered problem.
+template <class T>
+class StatusOr {
+ public:
+  StatusOr() {}
+  // Note: Constructors are intentionally not explicit to allow returning
+  // Status or the return value directly from functions.
+  StatusOr(const StatusOr &) = default;
+  StatusOr(StatusOr &&) = default;
+  StatusOr(const Status &status) : status_(status) {}
+  StatusOr(const T &value) : status_(OkStatus()), value_(value) {}
+  StatusOr(T &&value) : status_(OkStatus()), value_(std::move(value)) {}
+  StatusOr(const Status &status, const T &value)
+      : status_(status), value_(value) {}
+
+  const Status &status() const { return status_; }
+  const T &value() const & { return value_; }
+  const T &&value() const && { return std::move(value_); }
+  T &&value() && { return std::move(value_); }
+
+  // For consistency with existing Google StatusOr API we also include
+  // ValueOrDie() that currently returns the value().
+  const T &ValueOrDie() const & { return value(); }
+  T &&ValueOrDie() && { return std::move(value()); }
+
+  bool ok() const { return status_.ok(); }
+
+ private:
+  Status status_;
+  T value_;
+};
+
+// In case StatusOr<T> is ok(), this macro assigns value stored in StatusOr<T>
+// to |lhs|, otherwise it returns the error Status.
+//
+//   DRACO_ASSIGN_OR_RETURN(lhs, expression)
+//
+#define DRACO_ASSIGN_OR_RETURN(lhs, expression)                                \
+  DRACO_ASSIGN_OR_RETURN_IMPL_(DRACO_MACROS_IMPL_CONCAT_(_statusor, __LINE__), \
+                               lhs, expression, _status)
+
+// The actual implementation of the above macro.
+#define DRACO_ASSIGN_OR_RETURN_IMPL_(statusor, lhs, expression, error_expr) \
+  auto statusor = (expression);                                             \
+  if (!statusor.ok()) {                                                     \
+    auto _status = std::move(statusor.status());                            \
+    (void)_status; /* error_expression may not use it */                    \
+    return error_expr;                                                      \
+  }                                                                         \
+  lhs = std::move(statusor).value();
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_OR_H_

include/draco/core/varint_decoding.h

@@ -0,0 +1,81 @@
+// 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_CORE_VARINT_DECODING_H_
+#define DRACO_CORE_VARINT_DECODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+namespace {
+
+// Decodes a specified unsigned integer as varint. |depth| is the current
+// recursion call depth. The first call to the function must be 1.
+template <typename IntTypeT>
+bool DecodeVarintUnsigned(int depth, IntTypeT *out_val, DecoderBuffer *buffer) {
+  constexpr IntTypeT max_depth = sizeof(IntTypeT) + 1 + (sizeof(IntTypeT) >> 3);
+  if (depth > max_depth) {
+    return false;
+  }
+  // Coding of unsigned values.
+  // 0-6 bit - data
+  // 7 bit - next byte?
+  uint8_t in;
+  if (!buffer->Decode(&in)) {
+    return false;
+  }
+  if (in & (1 << 7)) {
+    // Next byte is available, decode it first.
+    if (!DecodeVarintUnsigned<IntTypeT>(depth + 1, out_val, buffer)) {
+      return false;
+    }
+    // Append decoded info from this byte.
+    *out_val <<= 7;
+    *out_val |= in & ((1 << 7) - 1);
+  } else {
+    // Last byte reached
+    *out_val = in;
+  }
+  return true;
+}
+
+}  // namespace
+
+// Decodes a specified integer as varint. Note that the IntTypeT must be the
+// same as the one used in the corresponding EncodeVarint() call.
+// out_val is undefined if this returns false.
+template <typename IntTypeT>
+bool DecodeVarint(IntTypeT *out_val, DecoderBuffer *buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    if (!DecodeVarintUnsigned<IntTypeT>(1, out_val, buffer)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Decode the symbol and convert to signed.
+    typename std::make_unsigned<IntTypeT>::type symbol;
+    if (!DecodeVarintUnsigned(1, &symbol, buffer)) {
+      return false;
+    }
+    *out_val = ConvertSymbolToSignedInt(symbol);
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_DECODING_H_

include/draco/core/varint_encoding.h

@@ -0,0 +1,61 @@
+// 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_CORE_VARINT_ENCODING_H_
+#define DRACO_CORE_VARINT_ENCODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Encodes a specified integer as varint. Note that different coding is used
+// when IntTypeT is an unsigned data type.
+template <typename IntTypeT>
+bool EncodeVarint(IntTypeT val, EncoderBuffer *out_buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    // Coding of unsigned values.
+    // 0-6 bit - data
+    // 7 bit - next byte?
+    uint8_t out = 0;
+    out |= val & ((1 << 7) - 1);
+    if (val >= (1 << 7)) {
+      out |= (1 << 7);
+      if (!out_buffer->Encode(out)) {
+        return false;
+      }
+      if (!EncodeVarint<IntTypeT>(val >> 7, out_buffer)) {
+        return false;
+      }
+      return true;
+    }
+    if (!out_buffer->Encode(out)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Convert to unsigned symbol and encode.
+    const typename std::make_unsigned<IntTypeT>::type symbol =
+        ConvertSignedIntToSymbol(val);
+    if (!EncodeVarint(symbol, out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_ENCODING_H_