super_jo_nathan/blender-PLY-project
0
1
Fork 0
forked from blender/blender
Code Issues Pull Requests Activity

Implemented feedback from Hans #1

Merged
Nathan Rozendaal merged 1 commits from Hans_feedback into D16792 2023-02-16 15:11:21 +01:00
Conversation 0 Commits 1 Files Changed 20 +184 -223
20 changed files with 184 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
source/blender/editors/io/io_ply_ops.c
View File

@ -181,8 +181,7 @@ void WM_OT_ply_export(struct wmOperatorType *ot)
FILE_SORT_DEFAULT); FILE_SORT_DEFAULT);
/* Object transform options. */ /* Object transform options. */
prop = RNA_def_enum( prop = RNA_def_enum(ot->srna, "forward_axis", io_transform_axis, IO_AXIS_Y, "Forward Axis", "");
ot->srna, "forward_axis", io_transform_axis, IO_AXIS_Y, "Forward Axis", "");
RNA_def_property_update_runtime(prop, (void *)forward_axis_update); RNA_def_property_update_runtime(prop, (void *)forward_axis_update);
prop = RNA_def_enum(ot->srna, "up_axis", io_transform_axis, IO_AXIS_Z, "Up Axis", ""); prop = RNA_def_enum(ot->srna, "up_axis", io_transform_axis, IO_AXIS_Z, "Up Axis", "");
RNA_def_property_update_runtime(prop, (void *)up_axis_update); RNA_def_property_update_runtime(prop, (void *)up_axis_update);
@ -205,12 +204,14 @@ void WM_OT_ply_export(struct wmOperatorType *ot)
"Export Selected Objects", "Export Selected Objects",
"Export only selected objects instead of all supported objects"); "Export only selected objects instead of all supported objects");
RNA_def_boolean(ot->srna, "export_uv", false, "Export UVs", ""); RNA_def_boolean(ot->srna, "export_uv", false, "Export UVs", "");
RNA_def_boolean(ot->srna, RNA_def_boolean(
ot->srna,
"export_normals", "export_normals",
false, false,
"Export Vertex Normals", "Export Vertex Normals",
"Export specific vertex normals if available, export calculated normals otherwise"); "Export specific vertex normals if available, export calculated normals otherwise");
RNA_def_boolean(ot->srna, "export_colors", true, "Export Vertex Colors", "Export per-vertex colors"); RNA_def_boolean(
ot->srna, "export_colors", true, "Export Vertex Colors", "Export per-vertex colors");
RNA_def_boolean(ot->srna, RNA_def_boolean(ot->srna,
"export_triangulated_mesh", "export_triangulated_mesh",
false, false,
@ -241,7 +242,6 @@ static int wm_ply_import_execute(bContext *C, wmOperator *op)
params.up_axis = RNA_enum_get(op->ptr, "up_axis"); params.up_axis = RNA_enum_get(op->ptr, "up_axis");
params.use_scene_unit = RNA_boolean_get(op->ptr, "use_scene_unit"); params.use_scene_unit = RNA_boolean_get(op->ptr, "use_scene_unit");
params.global_scale = RNA_float_get(op->ptr, "global_scale"); params.global_scale = RNA_float_get(op->ptr, "global_scale");
params.import_normals_as_attribute = RNA_boolean_get(op->ptr, "import_normals_as_attribute");
params.merge_verts = RNA_boolean_get(op->ptr, "merge_verts"); params.merge_verts = RNA_boolean_get(op->ptr, "merge_verts");
int files_len = RNA_collection_length(op->ptr, "files"); int files_len = RNA_collection_length(op->ptr, "files");
@ -321,16 +321,7 @@ void WM_OT_ply_import(struct wmOperatorType *ot)
"Apply current scene's unit (as defined by unit scale) to imported data"); "Apply current scene's unit (as defined by unit scale) to imported data");
RNA_def_enum(ot->srna, "forward_axis", io_transform_axis, IO_AXIS_Y, "Forward Axis", ""); RNA_def_enum(ot->srna, "forward_axis", io_transform_axis, IO_AXIS_Y, "Forward Axis", "");
RNA_def_enum(ot->srna, "up_axis", io_transform_axis, IO_AXIS_Z, "Up Axis", ""); RNA_def_enum(ot->srna, "up_axis", io_transform_axis, IO_AXIS_Z, "Up Axis", "");
RNA_def_boolean(ot->srna, RNA_def_boolean(ot->srna, "merge_verts", false, "Merge Vertices", "Merges vertices by distance");
"import_normals_as_attribute",
false,
"Normals As Attribute",
"Sets the vertex normal data as a vertex attribute");
RNA_def_boolean(ot->srna,
"merge_verts",
false,
"Merge Vertices",
"Merges vertices by distance");
/* Only show .ply files by default. */ /* Only show .ply files by default. */
prop = RNA_def_string(ot->srna, "filter_glob", "*.ply", 0, "Extension Filter", ""); prop = RNA_def_string(ot->srna, "filter_glob", "*.ply", 0, "Extension Filter", "");

4
source/blender/io/ply/IO_ply.cc
View File

@ -11,13 +11,13 @@
#include "ply_export.hh" #include "ply_export.hh"
#include "ply_import.hh" #include "ply_import.hh"
void PLY_export(bContext *C, const struct PLYExportParams *export_params) void PLY_export(bContext *C, const PLYExportParams *export_params)
{ {
SCOPED_TIMER("PLY Export"); SCOPED_TIMER("PLY Export");
blender::io::ply::exporter_main(C, *export_params); blender::io::ply::exporter_main(C, *export_params);
} }
void PLY_import(bContext *C, const struct PLYImportParams *import_params, wmOperator *op) void PLY_import(bContext *C, const PLYImportParams *import_params, wmOperator *op)
{ {
SCOPED_TIMER("PLY Import"); SCOPED_TIMER("PLY Import");
blender::io::ply::importer_main(C, *import_params, op); blender::io::ply::importer_main(C, *import_params, op);

1
source/blender/io/ply/IO_ply.h
View File

@ -49,7 +49,6 @@ struct PLYImportParams {
eIOAxis up_axis; eIOAxis up_axis;
bool use_scene_unit; bool use_scene_unit;
float global_scale; float global_scale;
bool import_normals_as_attribute;
bool merge_verts; bool merge_verts;
}; };

8
source/blender/io/ply/exporter/ply_export.cc
View File

@ -50,16 +50,16 @@ void exporter_main(Main *bmain,
} }
/* Generate and write header. */ /* Generate and write header. */
write_header(buffer, plyData, export_params); write_header(*buffer.get(), *plyData.get(), export_params);
/* Generate and write vertices. */ /* Generate and write vertices. */
write_vertices(buffer, plyData); write_vertices(*buffer.get(), *plyData.get());
/* Generate and write faces. */ /* Generate and write faces. */
write_faces(buffer, plyData); write_faces(*buffer.get(), *plyData.get());
/* Generate and write edges. */ /* Generate and write edges. */
write_edges(buffer, plyData); write_edges(*buffer.get(), *plyData.get());
/* Clean up. */ /* Clean up. */
buffer->close_file(); buffer->close_file();

49
source/blender/io/ply/exporter/ply_export_data.cc
View File

@ -3,48 +3,49 @@
/** \file /** \file
* \ingroup ply * \ingroup ply
*/ */
#include "BLI_array.hh"
#include "ply_data.hh" #include "ply_data.hh"
#include "ply_file_buffer.hh" #include "ply_file_buffer.hh"
namespace blender::io::ply { namespace blender::io::ply {
void write_vertices(std::unique_ptr<FileBuffer> &buffer, std::unique_ptr<PlyData> &plyData) void write_vertices(FileBuffer &buffer, const PlyData &ply_data)
{ {
for (int i = 0; i < plyData->vertices.size(); i++) { for (int i = 0; i < ply_data.vertices.size(); i++) {
buffer->write_vertex(plyData->vertices[i].x, plyData->vertices[i].y, plyData->vertices[i].z); buffer.write_vertex(ply_data.vertices[i].x, ply_data.vertices[i].y, ply_data.vertices[i].z);
if (!plyData->vertex_normals.is_empty()) if (!ply_data.vertex_normals.is_empty())
buffer->write_vertex_normal(plyData->vertex_normals[i].x, buffer.write_vertex_normal(ply_data.vertex_normals[i].x,
plyData->vertex_normals[i].y, ply_data.vertex_normals[i].y,
plyData->vertex_normals[i].z); ply_data.vertex_normals[i].z);
if (!plyData->vertex_colors.is_empty()) if (!ply_data.vertex_colors.is_empty())
buffer->write_vertex_color(uchar(plyData->vertex_colors[i].x * 255), buffer.write_vertex_color(uchar(ply_data.vertex_colors[i].x * 255),
uchar(plyData->vertex_colors[i].y * 255), uchar(ply_data.vertex_colors[i].y * 255),
uchar(plyData->vertex_colors[i].z * 255), uchar(ply_data.vertex_colors[i].z * 255),
uchar(plyData->vertex_colors[i].w * 255)); uchar(ply_data.vertex_colors[i].w * 255));
if (!plyData->UV_coordinates.is_empty()) if (!ply_data.UV_coordinates.is_empty())
buffer->write_UV(plyData->UV_coordinates[i].x, plyData->UV_coordinates[i].y); buffer.write_UV(ply_data.UV_coordinates[i].x, ply_data.UV_coordinates[i].y);
buffer->write_vertex_end(); buffer.write_vertex_end();
} }
buffer->write_to_file(); buffer.write_to_file();
} }
void write_faces(std::unique_ptr<FileBuffer> &buffer, std::unique_ptr<PlyData> &plyData) void write_faces(FileBuffer &buffer, const PlyData &ply_data)
{ {
for (const Vector<uint32_t> &face : plyData->faces) { for (const Array<uint32_t> &face : ply_data.faces) {
buffer->write_face(char(face.size()), face); buffer.write_face(char(face.size()), face);
} }
buffer->write_to_file(); buffer.write_to_file();
} }
void write_edges(std::unique_ptr<FileBuffer> &buffer, std::unique_ptr<PlyData> &plyData) void write_edges(FileBuffer &buffer, const PlyData &ply_data)
{ {
for (const std::pair<int, int> &edge : plyData->edges) { for (const std::pair<int, int> &edge : ply_data.edges) {
buffer->write_edge(edge.first, edge.second); buffer.write_edge(edge.first, edge.second);
} }
buffer->write_to_file(); buffer.write_to_file();
} }
} // namespace blender::io::ply } // namespace blender::io::ply

6
source/blender/io/ply/exporter/ply_export_data.hh
View File

@ -11,10 +11,10 @@
namespace blender::io::ply { namespace blender::io::ply {
void write_vertices(std::unique_ptr<FileBuffer> &buffer, std::unique_ptr<PlyData> &plyData); void write_vertices(FileBuffer &buffer, const PlyData &ply_data);
void write_faces(std::unique_ptr<FileBuffer> &buffer, std::unique_ptr<PlyData> &plyData); void write_faces(FileBuffer &buffer, const PlyData &ply_data);
void write_edges(std::unique_ptr<FileBuffer> &buffer, std::unique_ptr<PlyData> &plyData); void write_edges(FileBuffer &buffer, const PlyData &ply_data);
} // namespace blender::io::ply } // namespace blender::io::ply

60
source/blender/io/ply/exporter/ply_export_header.cc
View File

@ -13,54 +13,54 @@
namespace blender::io::ply { namespace blender::io::ply {
void write_header(std::unique_ptr<FileBuffer> &buffer, void write_header(FileBuffer &buffer,
std::unique_ptr<PlyData> &plyData, const PlyData &ply_data,
const PLYExportParams &export_params) const PLYExportParams &export_params)
{ {
buffer->write_string("ply"); buffer.write_string("ply");
StringRef format = export_params.ascii_format ? "ascii" : "binary_little_endian"; StringRef format = export_params.ascii_format ? "ascii" : "binary_little_endian";
buffer->write_string("format " + format + " 1.0"); buffer.write_string("format " + format + " 1.0");
StringRef version = BKE_blender_version_string(); StringRef version = BKE_blender_version_string();
buffer->write_string("comment Created in Blender version " + version); buffer.write_string("comment Created in Blender version " + version);
buffer->write_header_element("vertex", int32_t(plyData->vertices.size())); buffer.write_header_element("vertex", int32_t(ply_data.vertices.size()));
buffer->write_header_scalar_property("float", "x"); buffer.write_header_scalar_property("float", "x");
buffer->write_header_scalar_property("float", "y"); buffer.write_header_scalar_property("float", "y");
buffer->write_header_scalar_property("float", "z"); buffer.write_header_scalar_property("float", "z");
if (!plyData->vertex_normals.is_empty()) { if (!ply_data.vertex_normals.is_empty()) {
buffer->write_header_scalar_property("float", "nx"); buffer.write_header_scalar_property("float", "nx");
buffer->write_header_scalar_property("float", "ny"); buffer.write_header_scalar_property("float", "ny");
buffer->write_header_scalar_property("float", "nz"); buffer.write_header_scalar_property("float", "nz");
} }
if (!plyData->vertex_colors.is_empty()) { if (!ply_data.vertex_colors.is_empty()) {
buffer->write_header_scalar_property("uchar", "red"); buffer.write_header_scalar_property("uchar", "red");
buffer->write_header_scalar_property("uchar", "green"); buffer.write_header_scalar_property("uchar", "green");
buffer->write_header_scalar_property("uchar", "blue"); buffer.write_header_scalar_property("uchar", "blue");
buffer->write_header_scalar_property("uchar", "alpha"); buffer.write_header_scalar_property("uchar", "alpha");
} }
if (!plyData->UV_coordinates.is_empty()) { if (!ply_data.UV_coordinates.is_empty()) {
buffer->write_header_scalar_property("float", "s"); buffer.write_header_scalar_property("float", "s");
buffer->write_header_scalar_property("float", "t"); buffer.write_header_scalar_property("float", "t");
} }
if (!plyData->faces.is_empty()) { if (!ply_data.faces.is_empty()) {
buffer->write_header_element("face", int32_t(plyData->faces.size())); buffer.write_header_element("face", int32_t(ply_data.faces.size()));
buffer->write_header_list_property("uchar", "uint", "vertex_indices"); buffer.write_header_list_property("uchar", "uint", "vertex_indices");
} }
if (!plyData->edges.is_empty()) { if (!ply_data.edges.is_empty()) {
buffer->write_header_element("edge", int32_t(plyData->edges.size())); buffer.write_header_element("edge", int32_t(ply_data.edges.size()));
buffer->write_header_scalar_property("int", "vertex1"); buffer.write_header_scalar_property("int", "vertex1");
buffer->write_header_scalar_property("int", "vertex2"); buffer.write_header_scalar_property("int", "vertex2");
} }
buffer->write_string("end_header"); buffer.write_string("end_header");
buffer->write_to_file(); buffer.write_to_file();
} }
} // namespace blender::io::ply } // namespace blender::io::ply

4
source/blender/io/ply/exporter/ply_export_header.hh
View File

@ -11,8 +11,8 @@
namespace blender::io::ply { namespace blender::io::ply {
void write_header(std::unique_ptr<FileBuffer> &buffer, void write_header(FileBuffer &buffer,
std::unique_ptr<PlyData> &plyData, const PlyData &ply_data,
const PLYExportParams &export_params); const PLYExportParams &export_params);
} // namespace blender::io::ply } // namespace blender::io::ply

15
source/blender/io/ply/exporter/ply_export_load_plydata.cc
View File

@ -4,6 +4,7 @@
* \ingroup ply * \ingroup ply
*/ */
#include "BLI_array.hh"
#include "BLI_math.h" #include "BLI_math.h"
#include "BKE_attribute.hh" #include "BKE_attribute.hh"
@ -40,8 +41,6 @@ Mesh *do_triangulation(const Mesh *mesh, bool force_triangulation)
BMeshFromMeshParams bm_convert_params{}; BMeshFromMeshParams bm_convert_params{};
bm_convert_params.calc_face_normal = true; bm_convert_params.calc_face_normal = true;
bm_convert_params.calc_vert_normal = true; bm_convert_params.calc_vert_normal = true;
bm_convert_params.add_key_index = false;
bm_convert_params.use_shapekey = false;
const int triangulation_threshold = force_triangulation ? 4 : 255; const int triangulation_threshold = force_triangulation ? 4 : 255;
BMesh *bmesh = BKE_mesh_to_bmesh_ex(mesh, &bm_create_params, &bm_convert_params); BMesh *bmesh = BKE_mesh_to_bmesh_ex(mesh, &bm_create_params, &bm_convert_params);
@ -115,7 +114,7 @@ void load_plydata(PlyData &plyData, Depsgraph *depsgraph, const PLYExportParams
const float2 *uv_map = static_cast<const float2 *>( const float2 *uv_map = static_cast<const float2 *>(
CustomData_get_layer(&mesh->ldata, CD_PROP_FLOAT2)); CustomData_get_layer(&mesh->ldata, CD_PROP_FLOAT2));
blender::Map<UV_vertex_key, int> vertex_map = generate_vertex_map(mesh, uv_map, export_params); Map<UV_vertex_key, int> vertex_map = generate_vertex_map(mesh, uv_map, export_params);
set_world_axes_transform( set_world_axes_transform(
&export_object_eval_, export_params.forward_axis, export_params.up_axis); &export_object_eval_, export_params.forward_axis, export_params.up_axis);
@ -123,9 +122,9 @@ void load_plydata(PlyData &plyData, Depsgraph *depsgraph, const PLYExportParams
/* Load faces into plyData. */ /* Load faces into plyData. */
int loop_offset = 0; int loop_offset = 0;
Span<MLoop> loops = mesh->loops(); Span<MLoop> loops = mesh->loops();
for (auto &&poly : mesh->polys()) { for (const MPoly poly : mesh->polys()) {
Span<MLoop> loopSpan = loops.slice(poly.loopstart, poly.totloop); Span<MLoop> loopSpan = loops.slice(poly.loopstart, poly.totloop);
Vector<uint32_t> polyVector; Array<uint32_t> polyVector(loopSpan.size());
for (int i = 0; i < loopSpan.size(); ++i) { for (int i = 0; i < loopSpan.size(); ++i) {
float2 uv; float2 uv;
@ -137,7 +136,7 @@ void load_plydata(PlyData &plyData, Depsgraph *depsgraph, const PLYExportParams
} }
UV_vertex_key key = UV_vertex_key(uv, loopSpan[i].v); UV_vertex_key key = UV_vertex_key(uv, loopSpan[i].v);
int ply_vertex_index = vertex_map.lookup(key); int ply_vertex_index = vertex_map.lookup(key);
polyVector.append(uint32_t(ply_vertex_index + vertex_offset)); polyVector[i] = (uint32_t(ply_vertex_index + vertex_offset));
} }
loop_offset += loopSpan.size(); loop_offset += loopSpan.size();
@ -185,12 +184,12 @@ void load_plydata(PlyData &plyData, Depsgraph *depsgraph, const PLYExportParams
const StringRef name = mesh->active_color_attribute; const StringRef name = mesh->active_color_attribute;
if (!name.is_empty()) { if (!name.is_empty()) {
const bke::AttributeAccessor attributes = mesh->attributes(); const bke::AttributeAccessor attributes = mesh->attributes();
const VArray<ColorGeometry4f> colorAttribute = const VArray<ColorGeometry4f> color_attribute =
attributes.lookup_or_default<ColorGeometry4f>( attributes.lookup_or_default<ColorGeometry4f>(
name, ATTR_DOMAIN_POINT, {0.0f, 0.0f, 0.0f, 0.0f}); name, ATTR_DOMAIN_POINT, {0.0f, 0.0f, 0.0f, 0.0f});
for (int i = 0; i < vertex_map.size(); i++) { for (int i = 0; i < vertex_map.size(); i++) {
ColorGeometry4f colorGeometry = colorAttribute[mesh_vertex_index_LUT[i]]; ColorGeometry4f colorGeometry = color_attribute[mesh_vertex_index_LUT[i]];
float4 vertColor(colorGeometry.r, colorGeometry.g, colorGeometry.b, colorGeometry.a); float4 vertColor(colorGeometry.r, colorGeometry.g, colorGeometry.b, colorGeometry.a);
plyData.vertex_colors.append(vertColor); plyData.vertex_colors.append(vertColor);
} }

3
source/blender/io/ply/exporter/ply_file_buffer.hh
View File

@ -10,6 +10,7 @@
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include "BLI_array.hh"
#include "BLI_compiler_attrs.h" #include "BLI_compiler_attrs.h"
#include "BLI_fileops.h" #include "BLI_fileops.h"
#include "BLI_string_ref.hh" #include "BLI_string_ref.hh"
@ -101,7 +102,7 @@ class FileBuffer : private NonMovable {
virtual void write_vertex_end() = 0; virtual void write_vertex_end() = 0;
virtual void write_face(char count, Vector<uint32_t> const &vertex_indices) = 0; virtual void write_face(char count, Array<uint32_t> const &vertex_indices) = 0;
virtual void write_edge(int first, int second) = 0; virtual void write_edge(int first, int second) = 0;

5
source/blender/io/ply/exporter/ply_file_buffer_ascii.hh
View File

@ -8,13 +8,12 @@
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <vector>
#include "BLI_array.hh"
#include "BLI_compiler_attrs.h" #include "BLI_compiler_attrs.h"
#include "BLI_fileops.h" #include "BLI_fileops.h"
#include "BLI_string_ref.hh" #include "BLI_string_ref.hh"
#include "BLI_utility_mixins.hh" #include "BLI_utility_mixins.hh"
#include "BLI_vector.hh"
#include "ply_file_buffer.hh" #include "ply_file_buffer.hh"
@ -53,7 +52,7 @@ class FileBufferAscii : public FileBuffer {
write_fstring("\n"); write_fstring("\n");
} }
void write_face(char count, Vector<uint32_t> const &vertex_indices) override void write_face(char count, Array<uint32_t> const &vertex_indices) override
{ {
write_fstring("{}", int(count)); write_fstring("{}", int(count));

18
source/blender/io/ply/exporter/ply_file_buffer_binary.hh
View File

@ -9,12 +9,12 @@
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include "BLI_array.hh"
#include "BLI_compiler_attrs.h" #include "BLI_compiler_attrs.h"
#include "BLI_fileops.h" #include "BLI_fileops.h"
#include "BLI_math_vector_types.hh" #include "BLI_math_vector_types.hh"
#include "BLI_string_ref.hh" #include "BLI_string_ref.hh"
#include "BLI_utility_mixins.hh" #include "BLI_utility_mixins.hh"
#include "BLI_vector.hh"
#include "ply_file_buffer.hh" #include "ply_file_buffer.hh"
@ -70,19 +70,13 @@ class FileBufferBinary : public FileBuffer {
/* In binary, there is no end to a vertex. */ /* In binary, there is no end to a vertex. */
} }
void write_face(char size, Vector<uint32_t> const &vertex_indices) override void write_face(char size, Array<uint32_t> const &vertex_indices) override
{ {
/* Pre allocate memory so no further allocation has to be done for typical faces. */ write_bytes(Span<char>({size}));
Vector<char, 128> data;
data.append(size);
for (auto &&vertexIndex : vertex_indices) {
uint32_t x = vertexIndex;
auto *vtxbits = static_cast<char *>(static_cast<void *>(&x));
data.insert(data.end(), vtxbits, vtxbits + sizeof(uint32_t));
}
Span<char> span(data); Span<char> dataSpan(reinterpret_cast<const char *>(vertex_indices.data()),
write_bytes(span); vertex_indices.size() * sizeof(uint32_t));
write_bytes(dataSpan);
} }
void write_edge(int first, int second) override void write_edge(int first, int second) override

116
source/blender/io/ply/importer/ply_import_ascii.cc
View File

@ -24,46 +24,46 @@ PlyData load_ply_ascii(std::ifstream &file, const PlyHeader *header)
PlyData data; PlyData data;
/* Check if header contains alpha. */ /* Check if header contains alpha. */
std::pair<std::string, PlyDataTypes> alpha = {"alpha", PlyDataTypes::UCHAR}; std::pair<std::string, PlyDataTypes> alpha = {"alpha", PlyDataTypes::UCHAR};
bool hasAlpha = std::find(header->properties[0].begin(), header->properties[0].end(), alpha) != bool has_alpha = std::find(header->properties[0].begin(), header->properties[0].end(), alpha) !=
header->properties[0].end(); header->properties[0].end();
/* Check if header contains colors. */ /* Check if header contains colors. */
std::pair<std::string, PlyDataTypes> red = {"red", PlyDataTypes::UCHAR}; std::pair<std::string, PlyDataTypes> red = {"red", PlyDataTypes::UCHAR};
bool hasColor = std::find(header->properties[0].begin(), header->properties[0].end(), red) != bool has_color = std::find(header->properties[0].begin(), header->properties[0].end(), red) !=
header->properties[0].end(); header->properties[0].end();
/* Check if header contains normals. */ /* Check if header contains normals. */
std::pair<std::string, PlyDataTypes> normalx = {"nx", PlyDataTypes::FLOAT}; std::pair<std::string, PlyDataTypes> normalx = {"nx", PlyDataTypes::FLOAT};
bool hasNormals = std::find(header->properties[0].begin(), bool has_normals = std::find(header->properties[0].begin(),
header->properties[0].end(), header->properties[0].end(),
normalx) != header->properties[0].end(); normalx) != header->properties[0].end();
/* Check if header contains uv data. */ /* Check if header contains uv data. */
std::pair<std::string, PlyDataTypes> uv = {"s", PlyDataTypes::FLOAT}; std::pair<std::string, PlyDataTypes> uv = {"s", PlyDataTypes::FLOAT};
bool hasUv = std::find(header->properties[0].begin(), header->properties[0].end(), uv) != bool has_UV = std::find(header->properties[0].begin(), header->properties[0].end(), uv) !=
header->properties[0].end(); header->properties[0].end();
int3 vertexIndex = get_vertex_index(header); int3 vertex_index = get_vertex_index(header);
int alphaIndex; int alpha_index;
int3 colorIndex; int3 color_index;
int3 normalIndex; int3 normal_index;
int2 uvIndex; int2 UV_index;
if (hasAlpha) { if (has_alpha) {
alphaIndex = get_index(header, "alpha", PlyDataTypes::UCHAR); alpha_index = get_index(header, "alpha", PlyDataTypes::UCHAR);
} }
if (hasColor) { if (has_color) {
/* x=red, y=green, z=blue */ /* x=red, y=green, z=blue */
colorIndex = get_color_index(header); color_index = get_color_index(header);
} }
if (hasNormals) { if (has_normals) {
normalIndex = get_normal_index(header); normal_index = get_normal_index(header);
} }
if (hasUv) { if (has_UV) {
uvIndex = get_uv_index(header); UV_index = get_uv_index(header);
} }
for (int i = 0; i < header->vertex_count; i++) { for (int i = 0; i < header->vertex_count; i++) {
@ -73,20 +73,20 @@ PlyData load_ply_ascii(std::ifstream &file, const PlyHeader *header)
/* Vertex coords */ /* Vertex coords */
float3 vertex3; float3 vertex3;
vertex3.x = std::stof(value_vec[vertexIndex.x]); vertex3.x = std::stof(value_vec[vertex_index.x]);
vertex3.y = std::stof(value_vec[vertexIndex.y]); vertex3.y = std::stof(value_vec[vertex_index.y]);
vertex3.z = std::stof(value_vec[vertexIndex.z]); vertex3.z = std::stof(value_vec[vertex_index.z]);
data.vertices.append(vertex3); data.vertices.append(vertex3);
/* Vertex colors */ /* Vertex colors */
if (hasColor) { if (has_color) {
float4 colors4; float4 colors4;
colors4.x = std::stof(value_vec[colorIndex.x]) / 255.0f; colors4.x = std::stof(value_vec[color_index.x]) / 255.0f;
colors4.y = std::stof(value_vec[colorIndex.y]) / 255.0f; colors4.y = std::stof(value_vec[color_index.y]) / 255.0f;
colors4.z = std::stof(value_vec[colorIndex.z]) / 255.0f; colors4.z = std::stof(value_vec[color_index.z]) / 255.0f;
if (hasAlpha) { if (has_alpha) {
colors4.w = std::stof(value_vec[alphaIndex]) / 255.0f; colors4.w = std::stof(value_vec[alpha_index]) / 255.0f;
} }
else { else {
colors4.w = 1.0f; colors4.w = 1.0f;
@ -96,20 +96,20 @@ PlyData load_ply_ascii(std::ifstream &file, const PlyHeader *header)
} }
/* If normals */ /* If normals */
if (hasNormals) { if (has_normals) {
float3 normals3; float3 normals3;
normals3.x = std::stof(value_vec[normalIndex.x]); normals3.x = std::stof(value_vec[normal_index.x]);
normals3.y = std::stof(value_vec[normalIndex.y]); normals3.y = std::stof(value_vec[normal_index.y]);
normals3.z = std::stof(value_vec[normalIndex.z]); normals3.z = std::stof(value_vec[normal_index.z]);
data.vertex_normals.append(normals3); data.vertex_normals.append(normals3);
} }
/* If uv */ /* If uv */
if (hasUv) { if (has_UV) {
float2 uvmap; float2 uvmap;
uvmap.x = std::stof(value_vec[uvIndex.x]); uvmap.x = std::stof(value_vec[UV_index.x]);
uvmap.y = std::stof(value_vec[uvIndex.y]); uvmap.y = std::stof(value_vec[UV_index.y]);
data.UV_coordinates.append(uvmap); data.UV_coordinates.append(uvmap);
} }
@ -118,14 +118,16 @@ PlyData load_ply_ascii(std::ifstream &file, const PlyHeader *header)
std::string line; std::string line;
getline(file, line); getline(file, line);
Vector<std::string> value_vec = explode(line, ' '); Vector<std::string> value_vec = explode(line, ' ');
Vector<uint> vertex_indices; int count = std::stoi(value_vec[0]);
Array<uint> vertex_indices(count);
for (int j = 1; j <= std::stoi(value_vec[0]); j++) { for (int j = 1; j <= count; j++) {
int index = std::stoi(value_vec[j]);
/* If the face has a vertex index that is outside the range. */ /* If the face has a vertex index that is outside the range. */
if (std::stoi(value_vec[j]) >= data.vertices.size()) { if (index >= data.vertices.size()) {
throw std::runtime_error("Vertex index out of bounds"); throw std::runtime_error("Vertex index out of bounds");
} }
vertex_indices.append(std::stoi(value_vec[j])); vertex_indices[j - 1] = index;
} }
data.faces.append(vertex_indices); data.faces.append(vertex_indices);
} }
@ -144,41 +146,41 @@ PlyData load_ply_ascii(std::ifstream &file, const PlyHeader *header)
int3 get_vertex_index(const PlyHeader *header) int3 get_vertex_index(const PlyHeader *header)
{ {
int3 vertexPos; int3 vertex_index;
vertexPos.x = get_index(header, "x", PlyDataTypes::FLOAT); vertex_index.x = get_index(header, "x", PlyDataTypes::FLOAT);
vertexPos.y = get_index(header, "y", PlyDataTypes::FLOAT); vertex_index.y = get_index(header, "y", PlyDataTypes::FLOAT);
vertexPos.z = get_index(header, "z", PlyDataTypes::FLOAT); vertex_index.z = get_index(header, "z", PlyDataTypes::FLOAT);
return vertexPos; return vertex_index;
} }
int3 get_color_index(const PlyHeader *header) int3 get_color_index(const PlyHeader *header)
{ {
int3 vertexPos; int3 color_index;
vertexPos.x = get_index(header, "red", PlyDataTypes::UCHAR); color_index.x = get_index(header, "red", PlyDataTypes::UCHAR);
vertexPos.y = get_index(header, "green", PlyDataTypes::UCHAR); color_index.y = get_index(header, "green", PlyDataTypes::UCHAR);
vertexPos.z = get_index(header, "blue", PlyDataTypes::UCHAR); color_index.z = get_index(header, "blue", PlyDataTypes::UCHAR);
return vertexPos; return color_index;
} }
int3 get_normal_index(const PlyHeader *header) int3 get_normal_index(const PlyHeader *header)
{ {
int3 vertexPos; int3 normal_index;
vertexPos.x = get_index(header, "nx", PlyDataTypes::FLOAT); normal_index.x = get_index(header, "nx", PlyDataTypes::FLOAT);
vertexPos.y = get_index(header, "ny", PlyDataTypes::FLOAT); normal_index.y = get_index(header, "ny", PlyDataTypes::FLOAT);
vertexPos.z = get_index(header, "nz", PlyDataTypes::FLOAT); normal_index.z = get_index(header, "nz", PlyDataTypes::FLOAT);
return vertexPos; return normal_index;
} }
int2 get_uv_index(const PlyHeader *header) int2 get_uv_index(const PlyHeader *header)
{ {
int2 uvPos; int2 uv_index;
uvPos.x = get_index(header, "s", PlyDataTypes::FLOAT); uv_index.x = get_index(header, "s", PlyDataTypes::FLOAT);
uvPos.y = get_index(header, "t", PlyDataTypes::FLOAT); uv_index.y = get_index(header, "t", PlyDataTypes::FLOAT);
return uvPos; return uv_index;
} }
int get_index(const PlyHeader *header, std::string property, PlyDataTypes datatype) int get_index(const PlyHeader *header, std::string property, PlyDataTypes datatype)
@ -188,7 +190,7 @@ int get_index(const PlyHeader *header, std::string property, PlyDataTypes dataty
return (int)(it - header->properties[0].begin()); return (int)(it - header->properties[0].begin());
} }
Vector<std::string> explode(const StringRef &str, const char &ch) Vector<std::string> explode(const StringRef str, const char &ch)
{ {
std::string next; std::string next;
Vector<std::string> result; Vector<std::string> result;

4
source/blender/io/ply/importer/ply_import_ascii.hh
View File

@ -6,8 +6,6 @@
#pragma once #pragma once
#include "BKE_mesh.h"
#include "DNA_mesh_types.h" #include "DNA_mesh_types.h"
#include "IO_ply.h" #include "IO_ply.h"
@ -35,5 +33,5 @@ int3 get_color_index(const PlyHeader *header);
int3 get_normal_index(const PlyHeader *header); int3 get_normal_index(const PlyHeader *header);
int2 get_uv_index(const PlyHeader *header); int2 get_uv_index(const PlyHeader *header);
int get_index(const PlyHeader *header, std::string property, PlyDataTypes datatype); int get_index(const PlyHeader *header, std::string property, PlyDataTypes datatype);
Vector<std::string> explode(const StringRef &str, const char &ch); Vector<std::string> explode(const StringRef str, const char &ch);
} // namespace blender::io::ply } // namespace blender::io::ply

5
source/blender/io/ply/importer/ply_import_binary.cc
View File

@ -3,6 +3,7 @@
/** \file /** \file
* \ingroup ply * \ingroup ply
*/ */
#include "BLI_array.hh"
#include "ply_import_binary.hh" #include "ply_import_binary.hh"
@ -113,7 +114,7 @@ PlyData load_ply_binary(std::ifstream &file, const PlyHeader *header)
for (int j = 0; j < header->elements[i].second; j++) { for (int j = 0; j < header->elements[i].second; j++) {
/* Assume vertex_index_count_type is uchar. */ /* Assume vertex_index_count_type is uchar. */
uint8_t count = read<uint8_t>(file, isBigEndian); uint8_t count = read<uint8_t>(file, isBigEndian);
Vector<uint> vertex_indices; Array<uint> vertex_indices(count);
/* Loop over the amount of vertex indices in this face. */ /* Loop over the amount of vertex indices in this face. */
for (uint8_t k = 0; k < count; k++) { for (uint8_t k = 0; k < count; k++) {
@ -122,7 +123,7 @@ PlyData load_ply_binary(std::ifstream &file, const PlyHeader *header)
if (index >= data.vertices.size()) { if (index >= data.vertices.size()) {
throw std::runtime_error("Vertex index out of bounds"); throw std::runtime_error("Vertex index out of bounds");
} }
vertex_indices.append(index); vertex_indices[k] = index;
} }
data.faces.append(vertex_indices); data.faces.append(vertex_indices);
} }

10
source/blender/io/ply/importer/ply_import_binary.hh
View File

@ -6,24 +6,22 @@
#pragma once #pragma once
#include "BKE_mesh.h"
#include "ply_data.hh" #include "ply_data.hh"
namespace blender::io::ply { namespace blender::io::ply {
/** /**
* The function that gets called from the importer. * The function that gets called from the importer.
* \param file The PLY file that was opened. * \param file: The PLY file that was opened.
* \param header The information in the PLY header. * \param header: The information in the PLY header.
* \return The PlyData datastructure that can be used for conversion to a Mesh. * \return The PlyData datastructure that can be used for conversion to a Mesh.
*/ */
std::unique_ptr<PlyData> import_ply_binary(std::ifstream &file, const PlyHeader *header); std::unique_ptr<PlyData> import_ply_binary(std::ifstream &file, const PlyHeader *header);
/** /**
* Loads the information from the PLY file in binary format to the PlyData datastructure. * Loads the information from the PLY file in binary format to the PlyData datastructure.
* \param file The PLY file that was opened. * \param file: The PLY file that was opened.
* \param header The information in the PLY header. * \param header: The information in the PLY header.
* \return The PlyData datastructure that can be used for conversion to a Mesh. * \return The PlyData datastructure that can be used for conversion to a Mesh.
*/ */
PlyData load_ply_binary(std::ifstream &file, const PlyHeader *header); PlyData load_ply_binary(std::ifstream &file, const PlyHeader *header);

30
source/blender/io/ply/importer/ply_import_mesh.cc
View File

@ -24,8 +24,7 @@ Mesh *convert_ply_to_mesh(PlyData &data, Mesh *mesh, const PLYImportParams &para
mesh->totvert = int(data.vertices.size()); mesh->totvert = int(data.vertices.size());
CustomData_add_layer_named( CustomData_add_layer_named(
&mesh->vdata, CD_PROP_FLOAT3, CD_CONSTRUCT, nullptr, mesh->totvert, "position"); &mesh->vdata, CD_PROP_FLOAT3, CD_CONSTRUCT, nullptr, mesh->totvert, "position");
MutableSpan<float3> verts = mesh->vert_positions_for_write(); mesh->vert_positions_for_write().copy_from(data.vertices);
verts.copy_from(data.vertices);
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
@ -83,16 +82,16 @@ Mesh *convert_ply_to_mesh(PlyData &data, Mesh *mesh, const PLYImportParams &para
/* Uvmap */ /* Uvmap */
if (!data.UV_coordinates.is_empty()) { if (!data.UV_coordinates.is_empty()) {
bke::SpanAttributeWriter<float2> Uv = attributes.lookup_or_add_for_write_only_span<float2>( bke::SpanAttributeWriter<float2> uv_map = attributes.lookup_or_add_for_write_only_span<float2>(
"UVMap", ATTR_DOMAIN_CORNER); "UVMap", ATTR_DOMAIN_CORNER);
int counter = 0; int counter = 0;
for (int i = 0; i < data.faces.size(); i++) { for (int i = 0; i < data.faces.size(); i++) {
for (int j = 0; j < data.faces[i].size(); j++) { for (int j = 0; j < data.faces[i].size(); j++) {
copy_v2_v2(Uv.span[counter], data.UV_coordinates[data.faces[i][j]]); copy_v2_v2(uv_map.span[counter], data.UV_coordinates[data.faces[i][j]]);
counter++; counter++;
} }
} }
Uv.finish(); uv_map.finish();
} }
/* Calculate edges from the rest of the mesh. */ /* Calculate edges from the rest of the mesh. */
@ -100,25 +99,8 @@ Mesh *convert_ply_to_mesh(PlyData &data, Mesh *mesh, const PLYImportParams &para
/* Note: This is important to do after initializing the loops. */ /* Note: This is important to do after initializing the loops. */
if (!data.vertex_normals.is_empty()) { if (!data.vertex_normals.is_empty()) {
float(*vertex_normals)[3] = static_cast<float(*)[3]>( BKE_mesh_set_custom_normals_from_verts(
MEM_malloc_arrayN(data.vertex_normals.size(), sizeof(float[3]), __func__)); mesh, reinterpret_cast<float(*)[3]>(data.vertex_normals.data()));
/* Below code is necessary to access vertex normals within Blender.
* Until Blender supports custom vertex normals, this is a workaround. */
bke::SpanAttributeWriter<float3> normals;
if (params.import_normals_as_attribute) {
normals = attributes.lookup_or_add_for_write_span<float3>("Normal", ATTR_DOMAIN_POINT);
}
for (int i = 0; i < data.vertex_normals.size(); i++) {
copy_v3_v3(vertex_normals[i], data.vertex_normals[i]);
if (normals) {
copy_v3_v3(normals.span[i], data.vertex_normals[i]);
}
}
normals.finish();
BKE_mesh_set_custom_normals_from_verts(mesh, vertex_normals);
MEM_freeN(vertex_normals);
} }
/* Merge all vertices on the same location. */ /* Merge all vertices on the same location. */

3
source/blender/io/ply/intern/ply_data.hh
View File

@ -6,6 +6,7 @@
#pragma once #pragma once
#include "BLI_array.hh"
#include "BLI_math_vector_types.hh" #include "BLI_math_vector_types.hh"
#include "BLI_vector.hh" #include "BLI_vector.hh"
@ -20,7 +21,7 @@ struct PlyData {
Vector<float4> vertex_colors; Vector<float4> vertex_colors;
Vector<std::pair<int, int>> edges; Vector<std::pair<int, int>> edges;
Vector<float3> edge_colors; Vector<float3> edge_colors;
Vector<Vector<uint32_t>> faces; Vector<Array<uint32_t>> faces;
Vector<float2> UV_coordinates; Vector<float2> UV_coordinates;
}; };

16
source/blender/io/ply/tests/io_ply_exporter_test.cc
View File

@ -127,7 +127,7 @@ TEST_F(PlyExportTest, WriteHeaderAscii)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath);
write_header(buffer, plyData, _params); write_header(*buffer.get(), *plyData.get(), _params);
buffer->close_file(); buffer->close_file();
@ -165,7 +165,7 @@ TEST_F(PlyExportTest, WriteHeaderBinary)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath);
write_header(buffer, plyData, _params); write_header(*buffer.get(), *plyData.get(), _params);
buffer->close_file(); buffer->close_file();
@ -203,7 +203,7 @@ TEST_F(PlyExportTest, WriteVerticesAscii)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath);
write_vertices(buffer, plyData); write_vertices(*buffer.get(), *plyData.get());
buffer->close_file(); buffer->close_file();
@ -235,7 +235,7 @@ TEST_F(PlyExportTest, WriteVerticesBinary)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath);
write_vertices(buffer, plyData); write_vertices(*buffer.get(), *plyData.get());
buffer->close_file(); buffer->close_file();
@ -277,7 +277,7 @@ TEST_F(PlyExportTest, WriteFacesAscii)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath);
write_faces(buffer, plyData); write_faces(*buffer.get(), *plyData.get());
buffer->close_file(); buffer->close_file();
@ -309,7 +309,7 @@ TEST_F(PlyExportTest, WriteFacesBinary)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath);
write_faces(buffer, plyData); write_faces(*buffer.get(), *plyData.get());
buffer->close_file(); buffer->close_file();
@ -352,7 +352,7 @@ TEST_F(PlyExportTest, WriteVertexNormalsAscii)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferAscii>(_params.filepath);
write_vertices(buffer, plyData); write_vertices(*buffer.get(), *plyData.get());
buffer->close_file(); buffer->close_file();
@ -384,7 +384,7 @@ TEST_F(PlyExportTest, WriteVertexNormalsBinary)
std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath); std::unique_ptr<FileBuffer> buffer = std::make_unique<FileBufferBinary>(_params.filepath);
write_vertices(buffer, plyData); write_vertices(*buffer.get(), *plyData.get());
buffer->close_file(); buffer->close_file();

11
source/blender/io/ply/tests/io_ply_importer_test.cc
View File

@ -53,7 +53,6 @@ class PlyImportTest : public BlendfileLoadingBaseTest {
params.global_scale = 1.0f; params.global_scale = 1.0f;
params.forward_axis = IO_AXIS_NEGATIVE_Z; params.forward_axis = IO_AXIS_NEGATIVE_Z;
params.up_axis = IO_AXIS_Y; params.up_axis = IO_AXIS_Y;
params.import_normals_as_attribute = true;
params.merge_verts = false; params.merge_verts = false;
/* Import the test file. */ /* Import the test file. */
@ -97,14 +96,10 @@ class PlyImportTest : public BlendfileLoadingBaseTest {
EXPECT_V3_NEAR(verts.last(), exp.vert_last, 0.0001f); EXPECT_V3_NEAR(verts.last(), exp.vert_last, 0.0001f);
/* Fetch normal data from mesh and test if it matches expectation. */ /* Fetch normal data from mesh and test if it matches expectation. */
/* This uses the normal import workaround for vertex normals. This should be changed when
* Blender supports custom vertex normals. */
if (BKE_mesh_has_custom_loop_normals(mesh)) { if (BKE_mesh_has_custom_loop_normals(mesh)) {
const float3 *vertex_normals = (const float3 *)CustomData_get_layer_named( const Span<float3> vertex_normals = mesh->vertex_normals();
&mesh->vdata, CD_PROP_FLOAT3, "Normal"); ASSERT_FALSE(vertex_normals.is_empty());
ASSERT_TRUE(vertex_normals != nullptr); EXPECT_V3_NEAR(vertex_normals[0], exp.normal_first, 0.0001f);
float3 normal_first = vertex_normals != nullptr ? vertex_normals[0] : float3(0, 0, 0);
EXPECT_V3_NEAR(normal_first, exp.normal_first, 0.0001f);
} }
/* Fetch UV data from mesh and test if it matches expectation. */ /* Fetch UV data from mesh and test if it matches expectation. */