dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/io/ply_property_writer.h

@@ -0,0 +1,94 @@
+// 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_IO_PLY_PROPERTY_WRITER_H_
+#define DRACO_IO_PLY_PROPERTY_WRITER_H_
+
+#include <functional>
+
+#include "draco/io/ply_reader.h"
+
+namespace draco {
+
+// Class for writing PlyProperty with a given type, performing data conversion
+// if necessary.
+template <typename WriteTypeT>
+class PlyPropertyWriter {
+ public:
+  explicit PlyPropertyWriter(PlyProperty *property) : property_(property) {
+    // Find the suitable function for converting values.
+    switch (property->data_type()) {
+      case DT_UINT8:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<uint8_t>(val);
+        };
+        break;
+      case DT_INT8:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<int8_t>(val);
+        };
+        break;
+      case DT_UINT16:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<uint16_t>(val);
+        };
+        break;
+      case DT_INT16:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<int16_t>(val);
+        };
+        break;
+      case DT_UINT32:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<uint32_t>(val);
+        };
+        break;
+      case DT_INT32:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<int32_t>(val);
+        };
+        break;
+      case DT_FLOAT32:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<float>(val);
+        };
+        break;
+      case DT_FLOAT64:
+        convert_value_func_ = [this](WriteTypeT val) {
+          return this->ConvertValue<double>(val);
+        };
+        break;
+      default:
+        break;
+    }
+  }
+
+  void PushBackValue(WriteTypeT value) const {
+    return convert_value_func_(value);
+  }
+
+ private:
+  template <typename SourceTypeT>
+  void ConvertValue(WriteTypeT value) const {
+    const SourceTypeT src_val = static_cast<SourceTypeT>(value);
+    property_->push_back_value(&src_val);
+  }
+
+  PlyProperty *property_;
+  std::function<void(WriteTypeT)> convert_value_func_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_PROPERTY_WRITER_H_

include/draco/io/ply_reader.h

@@ -0,0 +1,155 @@
+// 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.
+//
+// File contains helper classes used for parsing of PLY files. The classes are
+// used by the PlyDecoder (ply_decoder.h) to read a point cloud or mesh from a
+// source PLY file.
+// TODO(ostava): Currently, we support only binary PLYs encoded in the little
+// endian format ("format binary_little_endian 1.0").
+
+#ifndef DRACO_IO_PLY_READER_H_
+#define DRACO_IO_PLY_READER_H_
+
+#include <map>
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_types.h"
+#include "draco/core/status.h"
+#include "draco/core/status_or.h"
+
+namespace draco {
+
+// A single PLY property of a given PLY element. For "vertex" element this can
+// contain data such as "x", "y", or "z" coordinate of the vertex, while for
+// "face" element this usually contains corner indices.
+class PlyProperty {
+ public:
+  friend class PlyReader;
+
+  PlyProperty(const std::string &name, DataType data_type, DataType list_type);
+  void ReserveData(int num_entries) {
+    data_.reserve(DataTypeLength(data_type_) * num_entries);
+  }
+
+  int64_t GetListEntryOffset(int entry_id) const {
+    return list_data_[entry_id * 2];
+  }
+  int64_t GetListEntryNumValues(int entry_id) const {
+    return list_data_[entry_id * 2 + 1];
+  }
+  const void *GetDataEntryAddress(int entry_id) const {
+    return data_.data() + entry_id * data_type_num_bytes_;
+  }
+  void push_back_value(const void *data) {
+    data_.insert(data_.end(), static_cast<const uint8_t *>(data),
+                 static_cast<const uint8_t *>(data) + data_type_num_bytes_);
+  }
+
+  const std::string &name() const { return name_; }
+  bool is_list() const { return list_data_type_ != DT_INVALID; }
+  DataType data_type() const { return data_type_; }
+  int data_type_num_bytes() const { return data_type_num_bytes_; }
+  DataType list_data_type() const { return list_data_type_; }
+  int list_data_type_num_bytes() const { return list_data_type_num_bytes_; }
+
+ private:
+  std::string name_;
+  std::vector<uint8_t> data_;
+  // List data contain pairs of <offset, number_of_values>
+  std::vector<int64_t> list_data_;
+  DataType data_type_;
+  int data_type_num_bytes_;
+  DataType list_data_type_;
+  int list_data_type_num_bytes_;
+};
+
+// A single PLY element such as "vertex" or "face". Each element can store
+// arbitrary properties such as vertex coordinates or face indices.
+class PlyElement {
+ public:
+  PlyElement(const std::string &name, int64_t num_entries);
+  void AddProperty(const PlyProperty &prop) {
+    property_index_[prop.name()] = static_cast<int>(properties_.size());
+    properties_.emplace_back(prop);
+    if (!properties_.back().is_list()) {
+      properties_.back().ReserveData(static_cast<int>(num_entries_));
+    }
+  }
+
+  const PlyProperty *GetPropertyByName(const std::string &name) const {
+    const auto it = property_index_.find(name);
+    if (it != property_index_.end()) {
+      return &properties_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_properties() const { return static_cast<int>(properties_.size()); }
+  int num_entries() const { return static_cast<int>(num_entries_); }
+  const PlyProperty &property(int prop_index) const {
+    return properties_[prop_index];
+  }
+  PlyProperty &property(int prop_index) { return properties_[prop_index]; }
+
+ private:
+  std::string name_;
+  int64_t num_entries_;
+  std::vector<PlyProperty> properties_;
+  std::map<std::string, int> property_index_;
+};
+
+// Class responsible for parsing PLY data. It produces a list of PLY elements
+// and their properties that can be used to construct a mesh or a point cloud.
+class PlyReader {
+ public:
+  PlyReader();
+  Status Read(DecoderBuffer *buffer);
+
+  const PlyElement *GetElementByName(const std::string &name) const {
+    const auto it = element_index_.find(name);
+    if (it != element_index_.end()) {
+      return &elements_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_elements() const { return static_cast<int>(elements_.size()); }
+  const PlyElement &element(int element_index) const {
+    return elements_[element_index];
+  }
+
+ private:
+  enum Format { kLittleEndian = 0, kAscii };
+
+  Status ParseHeader(DecoderBuffer *buffer);
+  StatusOr<bool> ParseEndHeader(DecoderBuffer *buffer);
+  bool ParseElement(DecoderBuffer *buffer);
+  StatusOr<bool> ParseProperty(DecoderBuffer *buffer);
+  bool ParsePropertiesData(DecoderBuffer *buffer);
+  bool ParseElementData(DecoderBuffer *buffer, int element_index);
+  bool ParseElementDataAscii(DecoderBuffer *buffer, int element_index);
+
+  // Splits |line| by whitespace characters.
+  std::vector<std::string> SplitWords(const std::string &line);
+  DataType GetDataTypeFromString(const std::string &name) const;
+
+  std::vector<PlyElement> elements_;
+  std::map<std::string, int> element_index_;
+  Format format_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_READER_H_

include/draco/io/point_cloud_io.h

@@ -0,0 +1,89 @@
+// 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_IO_POINT_CLOUD_IO_H_
+#define DRACO_IO_POINT_CLOUD_IO_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+
+namespace draco {
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method,
+                                     const EncoderOptions &options) {
+  EncoderBuffer buffer;
+  EncoderOptions local_options = options;
+  ExpertEncoder encoder(*pc);
+  encoder.Reset(local_options);
+  encoder.SetEncodingMethod(method);
+  if (!encoder.EncodeToBuffer(&buffer).ok()) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+
+  os.write(static_cast<const char *>(buffer.data()), buffer.size());
+
+  return os;
+}
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method) {
+  const EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+  return WritePointCloudIntoStream(pc, os, method, options);
+}
+
+template <typename OutStreamT>
+OutStreamT &WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os) {
+  return WritePointCloudIntoStream(pc, os, POINT_CLOUD_SEQUENTIAL_ENCODING);
+}
+
+template <typename InStreamT>
+InStreamT &ReadPointCloudFromStream(std::unique_ptr<PointCloud> *point_cloud,
+                                    InStreamT &&is) {
+  // Determine size of stream and write into a vector
+  const auto start_pos = is.tellg();
+  is.seekg(0, std::ios::end);
+  const std::streampos is_size = is.tellg() - start_pos;
+  is.seekg(start_pos);
+  std::vector<char> data(is_size);
+  is.read(&data[0], is_size);
+
+  // Create a point cloud from that data.
+  DecoderBuffer buffer;
+  buffer.Init(&data[0], data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodePointCloudFromBuffer(&buffer);
+  *point_cloud = std::move(statusor).value();
+  if (!statusor.ok() || *point_cloud == nullptr) {
+    is.setstate(std::ios_base::badbit);
+  }
+
+  return is;
+}
+
+// Reads a point cloud from a file. The function automatically chooses the
+// correct decoder based on the extension of the files. Currently, .obj and .ply
+// files are supported. Other file extensions are processed by the default
+// draco::PointCloudDecoder.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<PointCloud>> ReadPointCloudFromFile(
+    const std::string &file_name);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_POINT_CLOUD_IO_H_

include/draco/io/stdio_file_reader.h

@@ -0,0 +1,48 @@
+#ifndef DRACO_IO_STDIO_FILE_READER_H_
+#define DRACO_IO_STDIO_FILE_READER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+
+class StdioFileReader : public FileReaderInterface {
+ public:
+  // Creates and returns a StdioFileReader that reads from |file_name|.
+  // Returns nullptr when the file does not exist or cannot be read.
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string &file_name);
+
+  StdioFileReader() = delete;
+  StdioFileReader(const StdioFileReader &) = delete;
+  StdioFileReader &operator=(const StdioFileReader &) = delete;
+
+  StdioFileReader(StdioFileReader &&) = default;
+  StdioFileReader &operator=(StdioFileReader &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileReader() override;
+
+  // Reads the entire contents of the input file into |buffer| and returns true.
+  bool ReadFileToBuffer(std::vector<char> *buffer) override;
+  bool ReadFileToBuffer(std::vector<uint8_t> *buffer) override;
+
+  // Returns the size of the file.
+  size_t GetFileSize() override;
+
+ private:
+  StdioFileReader(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_READER_H_

include/draco/io/stdio_file_writer.h

@@ -0,0 +1,42 @@
+#ifndef DRACO_IO_STDIO_FILE_WRITER_H_
+#define DRACO_IO_STDIO_FILE_WRITER_H_
+
+#include <cstddef>
+#include <cstdio>
+#include <memory>
+#include <string>
+
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+class StdioFileWriter : public FileWriterInterface {
+ public:
+  // Creates and returns a StdioFileWriter that writes to |file_name|.
+  // Returns nullptr when |file_name| cannot be opened for writing.
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string &file_name);
+
+  StdioFileWriter() = delete;
+  StdioFileWriter(const StdioFileWriter &) = delete;
+  StdioFileWriter &operator=(const StdioFileWriter &) = delete;
+
+  StdioFileWriter(StdioFileWriter &&) = default;
+  StdioFileWriter &operator=(StdioFileWriter &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileWriter() override;
+
+  // Writes |size| bytes to |file_| from |buffer|. Returns true for success.
+  bool Write(const char *buffer, size_t size) override;
+
+ private:
+  StdioFileWriter(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_WRITER_H_

include/draco/io/stl_decoder.h

@@ -0,0 +1,38 @@
+// Copyright 2022 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_IO_STL_DECODER_H_
+#define DRACO_IO_STL_DECODER_H_
+
+#include <string>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/core/status_or.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Decodes an STL file into draco::Mesh (or draco::PointCloud if the
+// connectivity data is not needed).
+class StlDecoder {
+ public:
+  StatusOr<std::unique_ptr<Mesh>> DecodeFromFile(const std::string &file_name);
+  StatusOr<std::unique_ptr<Mesh>> DecodeFromBuffer(DecoderBuffer *buffer);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STL_DECODER_H_

include/draco/io/stl_encoder.h

@@ -0,0 +1,52 @@
+// Copyright 2022 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_IO_STL_ENCODER_H_
+#define DRACO_IO_STL_ENCODER_H_
+
+#include <string>
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for encoding draco::Mesh into the STL file format.
+class StlEncoder {
+ public:
+  StlEncoder();
+
+  // Encodes the mesh and saves it into a file.
+  // Returns false when either the encoding failed or when the file couldn't be
+  // opened.
+  Status EncodeToFile(const Mesh &mesh, const std::string &file_name);
+
+  // Encodes the mesh into a buffer.
+  Status EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer);
+
+ protected:
+  Status EncodeInternal();
+  EncoderBuffer *buffer() const { return out_buffer_; }
+
+ private:
+  EncoderBuffer *out_buffer_;
+
+  const PointCloud *in_point_cloud_;
+  const Mesh *in_mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STL_ENCODER_H_