PeriDyno 1.0.0
Loading...
Searching...
No Matches
NormalVisualization.cu
Go to the documentation of this file.
1#include "NormalVisualization.h"
2#include "Topology/PointSet.h"
3#include "GLSurfaceVisualModule.h"
4#include "GLWireframeVisualModule.h"
5#include "GLPointVisualModule.h"
6#include "BasicShapes/CylinderModel.h"
7#include "BasicShapes/ConeModel.h"
8#include "ColorMapping.h"
9
10namespace dyno
11{
12 template<typename TDataType>
13 NormalVisualization<TDataType>::NormalVisualization()
14 : Node()
15 {
16 this->varLength()->setRange(0, 02);
17 this->varLineWidth()->setRange(0,1);
18 this->stateNormalSet()->setDataPtr(std::make_shared<EdgeSet<DataType3f>>());
19
20 auto callback = std::make_shared<FCallBackFunc>(std::bind(&NormalVisualization<TDataType>::varChanged, this));
21
22 this->varLength()->attach(callback);
23 this->varLineWidth()->attach(callback);
24 this->varArrowResolution()->attach(callback);
25
26
27 auto render_callback = std::make_shared<FCallBackFunc>(std::bind(&NormalVisualization<TDataType>::renderChanged, this));
28 this->varLineWidth()->attach(render_callback);
29 this->varShowWireframe()->attach(render_callback);
30
31
32 this->varArrowResolution()->setRange(4,15);
33 this->varLength()->setRange(0.1,10);
34
35 this->inInNormal()->tagOptional(true);
36 this->inScalar()->tagOptional(true);
37
38
39 auto colorMapper = std::make_shared<ColorMapping<DataType3f>>();
40 colorMapper->varMin()->setValue(-0.5);
41 colorMapper->varMax()->setValue(0.5);
42 this->inScalar()->connect(colorMapper->inScalar());
43 this->graphicsPipeline()->pushModule(colorMapper);
44
45 //cylinder
46 this->stateArrowCylinder()->setDataPtr(std::make_shared<TriangleSet<TDataType>>());
47 this->stateTriangleCenter()->setDataPtr(std::make_shared<PointSet<TDataType>>());
48
49 glInstanceCylinder = std::make_shared<GLInstanceVisualModule>();
50 glInstanceCylinder->setColor(Color(0, 1, 0));
51
52 this->stateArrowCylinder()->connect(glInstanceCylinder->inTriangleSet());
53 this->stateTransformsCylinder()->connect(glInstanceCylinder->inInstanceTransform());
54 colorMapper->outColor()->connect(glInstanceCylinder->inInstanceColor());
55 this->graphicsPipeline()->pushModule(glInstanceCylinder);
56
57 //cone
58 this->stateArrowCone()->setDataPtr(std::make_shared<TriangleSet<TDataType>>());
59
60
61 glInstanceCone = std::make_shared<GLInstanceVisualModule>();
62 glInstanceCone->setColor(Color(0, 1, 0));
63
64 this->stateArrowCone()->connect(glInstanceCone->inTriangleSet());
65 this->stateTransformsCone()->connect(glInstanceCone->inInstanceTransform());
66 colorMapper->outColor()->connect(glInstanceCone->inInstanceColor());
67 this->graphicsPipeline()->pushModule(glInstanceCone);
68
69 this->stateNormal()->promoteOuput();
70 this->stateTriangleCenter()->promoteOuput();
71 }
72
73 template<typename TDataType>
74 void NormalVisualization<TDataType>::renderChanged()
75 {
76
77 }
78
79
80 template<typename TDataType>
81 void NormalVisualization<TDataType>::resetStates()
82 {
83 this->varChanged();
84 this->renderChanged();
85 }
86
87 template<typename TDataType>
88 void NormalVisualization<TDataType>::updateStates()
89 {
90 this->varChanged();
91 //this->renderChanged();
92 }
93
94 template<typename TDataType>
95 void NormalVisualization<TDataType>::varChanged()
96 {
97 printf("varChanged\n");
98
99 if (this->inTriangleSet()->isEmpty())
100 {
101 printf("Normal Node: Need input!\n");
102 return;
103 }
104
105 auto normalSet = this->stateNormalSet()->getDataPtr();
106 auto inTriSet = this->inTriangleSet()->getDataPtr();
107
108 ////********************************** build Normal by Cuda **********************************////
109 {
110 DArray<TopologyModule::Triangle>& d_triangles = inTriSet->getTriangles();
111 d_points = inTriSet->getPoints();
112 d_edges.resize(d_triangles.size());
113 d_normalPt.resize(d_triangles.size() * 2);
114
115 d_normal.resize(d_triangles.size());
116 triangleCenter.resize(d_triangles.size());
117
118 cuExecute(d_triangles.size(),
119 UpdateTriangleNormal,
120 d_triangles,
121 d_points,
122 d_edges,
123 d_normalPt,
124 d_normal,
125 triangleCenter,
126 this->varLength()->getValue(),
127 this->varNormalize()->getValue()
128 );
129
130 normalSet->setPoints(d_normalPt);
131 normalSet->setEdges(d_edges);
132 normalSet->update();
133
134 auto triCenter = this->stateTriangleCenter()->getDataPtr();
135 triCenter->setPoints(triangleCenter);
136 triCenter->update();
137
138 this->stateNormal()->assign(d_normal);
139
140
141 }
142
143
144 //Build Arrow
145 {
146 auto cylinder = std::make_shared<CylinderModel<DataType3f>>();
147 cylinder->varColumns()->setValue(this->varArrowResolution()->getValue());
148 cylinder->varEndSegment()->setValue(1);
149 cylinder->varRow()->setValue(1);
150 cylinder->varRadius()->setValue(this->varLineWidth()->getValue());
151 cylinder->varHeight()->setValue(1.0f);
152 cylinder->varLocation()->setValue(Coord(0.0f, 0.5f, 0.0f));
153 auto cylinderTriSet = cylinder->stateTriangleSet()->getDataPtr();
154
155 auto cone = std::make_shared<ConeModel<DataType3f>>();
156 cone->varColumns()->setValue(this->varArrowResolution()->getValue());
157 cone->varRadius()->setValue(this->varLineWidth()->getValue() * 2);
158 cone->varHeight()->setValue(this->varLineWidth()->getValue() * 2 * 2);
159 cone->varLocation()->setValue(Vec3f(0, this->varLineWidth()->getValue(), 0));
160 cone->varRow()->setValue(1);
161 auto coneTriSet = cone->stateTriangleSet()->getDataPtr();
162
163 auto merge = std::make_shared<TriangleSet<DataType3f>>();
164 merge->copyFrom(*coneTriSet->merge(*cylinderTriSet));
165
166 this->stateArrowCylinder()->setDataPtr(cylinder->stateTriangleSet()->getDataPtr());
167
168 DArray<Transform3f> transformCylinder;
169 transformCylinder.resize(d_normalPt.size() / 2);
170 cuExecute(d_normalPt.size()/2,
171 UpdateArrowPoint,
172 d_normalPt,
173 transformCylinder,
174 0,
175 false,
176 0
177 );
178
179 this->stateTransformsCylinder()->assign(transformCylinder);
180 this->stateArrowCone()->setDataPtr(cone->stateTriangleSet()->getDataPtr());
181
182 DArray<Transform3f> transformCone;
183 transformCone.resize(d_normalPt.size() / 2);
184 cuExecute(d_normalPt.size() / 2,
185 UpdateArrowPoint,
186 d_normalPt,
187 transformCone,
188 0,
189 true,
190 0
191 );
192
193 this->stateTransformsCone()->assign(transformCone);
194 }
195
196 }
197
198 template< typename Coord>
199 __global__ void UpdatePointNormal(
200 DArray<Coord> d_point,
201 DArray<Coord> normal_points,
202 DArray<Coord> normal,
203 DArray<TopologyModule::Edge> edges,
204 float length,
205 bool normallization
206 )
207 {
208 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
209 if (pId >= d_point.size()) return;
210 Coord dirNormal = normal[pId];
211
212 if(normallization)
213 dirNormal = dirNormal.normalize() * length;
214 else
215 dirNormal = dirNormal * length;
216
217 normal_points[2 * pId] = d_point[pId] ;
218 normal_points[2 * pId + 1] = d_point[pId] + dirNormal;
219
220 edges[pId] = TopologyModule::Edge(2 * pId, 2 * pId + 1);
221 }
222
223
224 template< typename Coord>
225 __global__ void UpdateTriangleNormal(
226 DArray<TopologyModule::Triangle> d_triangles,
227 DArray<Coord> d_points,
228 DArray<TopologyModule::Edge> edges,
229 DArray<Coord> normal_points,
230 DArray<Coord> normal,
231 DArray<Coord> triangleCenter,
232 float length,
233 bool normalization)
234 {
235 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
236 if (pId >= d_triangles.size()) return;
237
238 int a = d_triangles[pId][0];
239 int b = d_triangles[pId][1];
240 int c = d_triangles[pId][2];
241
242 float x = (d_points[a][0] + d_points[b][0] + d_points[c][0]) / 3;
243 float y = (d_points[a][1] + d_points[b][1] + d_points[c][1]) / 3;
244 float z = (d_points[a][2] + d_points[b][2] + d_points[c][2]) / 3;
245
246 Coord ca = d_points[b] - d_points[a];
247 Coord cb = d_points[b] - d_points[c];
248 Coord dirNormal;
249
250 if(normalization)
251 dirNormal = ca.cross(cb).normalize() * -1 *length;
252 else
253 dirNormal = ca.cross(cb) * -1 * length;
254
255 normal_points[2 * pId] = Coord(x, y, z);
256 normal_points[2 * pId + 1] = Coord(x, y, z) + dirNormal;
257 triangleCenter[pId] = Coord(x, y, z);
258
259 edges[pId] = TopologyModule::Edge(2 * pId, 2 * pId + 1);
260 normal[pId] = dirNormal.normalize();
261 }
262
263 template< typename Coord>
264 __global__ void UpdateArrowPoint(
265 DArray<Coord> NormalPt,
266 DArray<Transform3f> transform,
267 int offest,
268 bool moveToTop,
269 float lengthOverride
270 )
271 {
272 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
273 if (pId >= NormalPt.size()/2) return;
274
275 int i = pId;
276
277 Coord root = NormalPt[i * 2];
278 Coord head = NormalPt[i * 2 + 1];
279 Vec3f defaultDirection = Vec3f(0, 1, 0);
280 Vec3f direction = head - root;
281
282 float length = direction.norm();
283 if (lengthOverride != 0)
284 length = lengthOverride;
285
286 Vec3f distance = Vec3f(0,direction.norm(),0);
287
288 direction.normalize();
289 defaultDirection.normalize();
290 Real angle;
291 Vec3f Axis = direction.cross(defaultDirection);
292 if (Axis == Vec3f(0, 0, 0) && direction[1] < 0)
293 {
294 Axis = Vec3f(1, 0, 0);
295 angle = M_PI;
296 }
297 Axis.normalize();
298
299 angle = -1 * acos(direction.dot(defaultDirection));
300
301 Quat<Real> quat = Quat<Real>(angle, Axis);
302 Vec3f location;
303 Vec3f scale;
304
305 if (moveToTop)
306 {
307 location = root + offest + quat.rotate(distance);
308 scale = Vec3f(1, 1, 1);
309 }
310 else
311 {
312 location = root + offest;
313 scale = Vec3f(1, length, 1);
314 }
315
316 transform[pId].translation() = location;
317 transform[pId].scale() = scale;
318 transform[pId].rotation() = quat.toMatrix3x3();
319 }
320
321
322 DEFINE_CLASS(NormalVisualization);
323}
Generated by doxygen 1.13.2