OpenVDB : use underscores instead of spaces in grid names.
[blender.git] / intern / openvdb / intern / openvdb_dense_convert.cc
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2015 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Kevin Dietrich
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #include "openvdb_dense_convert.h"
29
30 #include <openvdb/tools/ValueTransformer.h>  /* for tools::foreach */
31
32 namespace internal {
33
34 openvdb::Mat4R convertMatrix(const float mat[4][4])
35 {
36         return openvdb::Mat4R(
37                 mat[0][0], mat[0][1], mat[0][2], mat[0][3],
38                 mat[1][0], mat[1][1], mat[1][2], mat[1][3],
39                 mat[2][0], mat[2][1], mat[2][2], mat[2][3],
40                 mat[3][0], mat[3][1], mat[3][2], mat[3][3]);
41 }
42
43
44 class MergeScalarGrids {
45         typedef openvdb::FloatTree ScalarTree;
46
47         openvdb::tree::ValueAccessor<const ScalarTree> m_acc_x, m_acc_y, m_acc_z;
48
49 public:
50         MergeScalarGrids(const ScalarTree *x_tree, const ScalarTree *y_tree, const ScalarTree *z_tree)
51             : m_acc_x(*x_tree)
52             , m_acc_y(*y_tree)
53             , m_acc_z(*z_tree)
54         {}
55
56         MergeScalarGrids(const MergeScalarGrids &other)
57             : m_acc_x(other.m_acc_x)
58             , m_acc_y(other.m_acc_y)
59             , m_acc_z(other.m_acc_z)
60         {}
61
62         void operator()(const openvdb::Vec3STree::ValueOnIter &it) const
63         {
64                 using namespace openvdb;
65
66                 const math::Coord xyz = it.getCoord();
67                 float x = m_acc_x.getValue(xyz);
68                 float y = m_acc_y.getValue(xyz);
69                 float z = m_acc_z.getValue(xyz);
70
71                 it.setValue(math::Vec3s(x, y, z));
72         }
73 };
74
75 openvdb::GridBase *OpenVDB_export_vector_grid(
76         OpenVDBWriter *writer,
77         const openvdb::Name &name,
78         const float *data_x, const float *data_y, const float *data_z,
79         const int res[3],
80         float fluid_mat[4][4],
81         openvdb::VecType vec_type,
82         const bool is_color,
83         const openvdb::FloatGrid *mask)
84 {
85         using namespace openvdb;
86
87         math::CoordBBox bbox(Coord(0), Coord(res[0] - 1, res[1] - 1, res[2] - 1));
88         Mat4R mat = convertMatrix(fluid_mat);
89         math::Transform::Ptr transform = math::Transform::createLinearTransform(mat);
90
91         FloatGrid::Ptr grid[3];
92
93         grid[0] = FloatGrid::create(0.0f);
94         tools::Dense<const float, tools::LayoutXYZ> dense_grid_x(bbox, data_x);
95         tools::copyFromDense(dense_grid_x, grid[0]->tree(), TOLERANCE);
96
97         grid[1] = FloatGrid::create(0.0f);
98         tools::Dense<const float, tools::LayoutXYZ> dense_grid_y(bbox, data_y);
99         tools::copyFromDense(dense_grid_y, grid[1]->tree(), TOLERANCE);
100
101         grid[2] = FloatGrid::create(0.0f);
102         tools::Dense<const float, tools::LayoutXYZ> dense_grid_z(bbox, data_z);
103         tools::copyFromDense(dense_grid_z, grid[2]->tree(), TOLERANCE);
104
105         Vec3SGrid::Ptr vecgrid = Vec3SGrid::create(Vec3s(0.0f));
106
107         /* Activate voxels in the vector grid based on the scalar grids to ensure
108          * thread safety later on */
109         for (int i = 0; i < 3; ++i) {
110                 vecgrid->tree().topologyUnion(grid[i]->tree());
111         }
112
113         MergeScalarGrids op(&(grid[0]->tree()), &(grid[1]->tree()), &(grid[2]->tree()));
114         tools::foreach(vecgrid->beginValueOn(), op, true, false);
115
116         vecgrid->setTransform(transform);
117
118         /* Avoid clipping against an empty grid. */
119         if (mask && !mask->tree().empty()) {
120                 vecgrid = tools::clip(*vecgrid, *mask);
121         }
122
123         vecgrid->setName(name);
124         vecgrid->setIsInWorldSpace(false);
125         vecgrid->setVectorType(vec_type);
126         vecgrid->insertMeta("is_color", BoolMetadata(is_color));
127         vecgrid->setGridClass(GRID_STAGGERED);
128
129         writer->insert(vecgrid);
130
131         return vecgrid.get();
132 }
133
134 void OpenVDB_import_grid_vector(
135         OpenVDBReader *reader,
136         const openvdb::Name &name,
137         float **data_x, float **data_y, float **data_z,
138         const int res[3])
139 {
140         using namespace openvdb;
141
142         if (!reader->hasGrid(name)) {
143                 std::fprintf(stderr, "OpenVDB grid %s not found in file!\n", name.c_str());
144                 memset(*data_x, 0, sizeof(float) * res[0] * res[1] * res[2]);
145                 memset(*data_y, 0, sizeof(float) * res[0] * res[1] * res[2]);
146                 memset(*data_z, 0, sizeof(float) * res[0] * res[1] * res[2]);
147                 return;
148         }
149
150         Vec3SGrid::Ptr vgrid = gridPtrCast<Vec3SGrid>(reader->getGrid(name));
151         Vec3SGrid::ConstAccessor acc = vgrid->getConstAccessor();
152         math::Coord xyz;
153         int &x = xyz[0], &y = xyz[1], &z = xyz[2];
154
155         size_t index = 0;
156         for (z = 0; z < res[2]; ++z) {
157                 for (y = 0; y < res[1]; ++y) {
158                         for (x = 0; x < res[0]; ++x, ++index) {
159                                 math::Vec3s value = acc.getValue(xyz);
160                                 (*data_x)[index] = value.x();
161                                 (*data_y)[index] = value.y();
162                                 (*data_z)[index] = value.z();
163                         }
164                 }
165         }
166 }
167
168 openvdb::Name do_name_versionning(const openvdb::Name &name)
169 {
170         openvdb::Name temp_name = name;
171
172         if (temp_name.find("_low", temp_name.size() - 4, 4) == temp_name.size() - 4) {
173                 return temp_name.replace(temp_name.size() - 4, 4, " low");
174         }
175
176         if (temp_name.find("_old", temp_name.size() - 4, 4) == temp_name.size() - 4) {
177                 return temp_name.replace(temp_name.size() - 4, 4, " old");
178         }
179
180         return temp_name;
181 }
182
183 }  /* namespace internal */