Loading [MathJax]/extensions/TeX/AMSsymbols.js
DGtal 2.0.0
Display3D.ih
1/**
2 * This program is free software: you can redistribute it and/or modify
3 * it under the terms of the GNU Lesser General Public License as
4 * published by the Free Software Foundation, either version 3 of the
5 * License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 */
15
16/*
17 * @file Display3D.ih
18 * @author Bastien Doignies <bastien.doignies@liris.cnrs.fr>
19 *
20 * @date 2025/05/11
21 *
22 * Implementation file for 3D Display
23 *
24 * This file is part of the DGtal library.
25 */
26
27namespace DGtal {
28 namespace drawutils {
29 template<size_t I>
30 std::vector<std::array<size_t, I>> makeIndices(size_t N) {
31 std::vector<std::array<size_t, I>> indices(N);
32
33 for (size_t i = 0; i < N; ++i) {
34 for (size_t j = 0; j < I; ++j) {
35 indices[i][j] = j + i * I;
36 }
37 }
38 return indices;
39 }
40
41 template<typename T>
42 std::array<T, 8> getCubeVertices(T center, double size) {
43 return {
44 center + 0.5 * size * T(-1, -1, -1),
45 center + 0.5 * size * T( 1, -1, -1),
46 center + 0.5 * size * T( 1, 1, -1),
47 center + 0.5 * size * T(-1, 1, -1),
48 center + 0.5 * size * T(-1, -1, 1),
49 center + 0.5 * size * T( 1, -1, 1),
50 center + 0.5 * size * T( 1, 1, 1),
51 center + 0.5 * size * T(-1, 1, 1)
52 };
53 }
54
55 template<typename T, typename U>
56 void insertCubeVertices(U& dest, T center, double scale) {
57 auto vertices = getCubeVertices(center, scale);
58 dest.insert(dest.end(), vertices.begin(), vertices.end());
59 }
60
61 template <typename T>
62 std::array<T, 4> getAASquareVertices(T center, int orientation, double size) {
63 switch(orientation) {
64 case 0: // Normal in x direction
65 return {
66 center + 0.5 * size * T(0, -1, -1),
67 center + 0.5 * size * T(0, -1, 1),
68 center + 0.5 * size * T(0, 1, 1),
69 center + 0.5 * size * T(0, 1, -1)
70 };
71 case 1: // Normal in y direction
72 return {
73 center + 0.5 * size * T(-1, 0, -1),
74 center + 0.5 * size * T(-1, 0, 1),
75 center + 0.5 * size * T( 1, 0, 1),
76 center + 0.5 * size * T( 1, 0, -1)
77 };
78 case 2: // Normal in z direction
79 default:
80 return {
81 center + 0.5 * size * T(-1, -1, 0),
82 center + 0.5 * size * T(-1, 1, 0),
83 center + 0.5 * size * T( 1, 1, 0),
84 center + 0.5 * size * T( 1, -1, 0)
85 };
86 }
87 }
88
89 template<typename U, typename T>
90 void insertAASquare(U& dest, T center, int orientation, double size) {
91 auto vertices = getAASquareVertices(center, orientation, size);
92 dest.insert(dest.end(), vertices.begin(), vertices.end());
93 }
94
95 template<typename T>
96 std::array<T, 8> getPrism(
97 T center, int orientation,
98 double size1, double size2, double shift1, double shift2
99 ) {
100 T dir(0, 0, 0); dir[orientation] = 1;
101
102 std::array<T, 8> vertices;
103 auto fQuad = getAASquareVertices(center + shift1 * dir, orientation, size1);
104 auto sQuad = getAASquareVertices(center + shift2 * dir, orientation, size2);
105
106 std::copy(fQuad.begin(), fQuad.end(), vertices.begin());
107 std::copy(sQuad.begin(), sQuad.end(), vertices.begin() + fQuad.size());
108 return vertices;
109 }
110
111 template<typename T, typename U>
112 void insertPrism(U& dest, T center, int orientation,
113 double scale1, double scale2, double shift1, double shift2) {
114 auto vertices = getPrism(center, orientation, scale1, scale2, shift1, shift2);
115 dest.insert(dest.end(), vertices.begin(), vertices.end());
116 }
117 } // drawutils
118
119 ///////////////////////////////////////////////////////////////////////////
120 ///////////////////////////// GENERAL COMMANDS ////////////////////////////
121
122 template <typename Space, typename KSpace>
123 void Display3D<Space, KSpace>::clear() {
124 endCurrentGroup();
125
126 myToRender.clear();
127 planes.clear();
128 data.clear();
129
130 clearView();
131 }
132
133 template <typename Space, typename KSpace>
134 void Display3D<Space, KSpace>::setCallback(typename Display3D<Space, KSpace>::Callback* callback) {
135 this->myCallback = callback;
136 if (this->myCallback) {
137 this->myCallback->viewer = this;
138 this->myCallback->OnAttach(this);
139 }
140 }
141
142 ///////////////////////////// GENERAL COMMANDS ////////////////////////////
143 ///////////////////////////////////////////////////////////////////////////
144
145 ///////////////////////////////////////////////////////////////////////////
146 ///////////////////////////// GROUP MANAGEMENT ////////////////////////////
147
148 template <typename Space, typename KSpace>
149 std::string Display3D<Space, KSpace>::newList(const std::string& name, size_t eSize) {
150 static const std::string token = "{i}";
151
152 auto it = data.find(name);
153 std::string newName = name;
154
155 size_t idx = name.find(token);
156 if (it != data.end() || idx != std::string::npos) {
157 std::string prefix = name;
158
159 if (idx == std::string::npos) {
160 idx = prefix.size() + 1;
161 prefix = prefix + "_" + token;
162 }
163
164 size_t i = 1;
165 do {
166 std::string tmpPrefix = prefix;
167 newName = tmpPrefix.replace(idx, token.size(), std::to_string(i));
168
169 i += 1;
170 } while (data.find(newName) != data.end());
171 }
172
173 // Insert a new empty container
174 DisplayData<RealPoint> newData;
175
176 // Set properties
177 newData.style = currentStyle;
178 newData.elementSize = eSize;
179
180 myCurrentData = &data.emplace(newName, std::move(newData)).first->second;
181 myCurrentName = newName;
182 // Add to render queue
183 myToRender.push_back(myCurrentName);
184 // Return computed name
185 return newName;
186 }
187
188 template <typename Space, typename KSpace>
189 bool Display3D<Space, KSpace>::setCurrentList(const std::string& name) {
190 auto it = data.find(name);
191 if (it == data.end())
192 return false;
193
194 myCurrentData = &it->second;
195 myCurrentName = name;
196 return true;
197 }
198
199 template <typename Space, typename KSpace>
200 bool Display3D<Space, KSpace>::canCreateNewList(size_t elementSize) const {
201 if (!myCurrentData) return true;
202 if (myCurrentData->elementSize != elementSize) return true;
203 return !allowReuseList;
204 }
205
206 template <typename Space, typename KSpace>
207 std::string Display3D<Space, KSpace>::createOrReuseList(const std::string& name, size_t elementSize) {
208 if (canCreateNewList(elementSize)) {
209 return newList(name, elementSize);
210 }
211 return myCurrentName;
212 }
213
214 template <typename Space, typename KSpace>
215 void Display3D<Space, KSpace>::endCurrentGroup() {
216 myCurrentData = nullptr;
217 myCurrentName = "";
218 }
219
220 ///////////////////////////// GROUP MANAGEMENT /////////////////////////////
221 ////////////////////////////////////////////////////////////////////////////
222
223 ////////////////////////////////////////////////////////////////////////////
224 ////////////////////////////// DRAW MODIFIERS //////////////////////////////
225
226 template <typename Space, typename KSpace>
227 std::string Display3D<Space, KSpace>::draw(const DGtal::Color& color, const std::string& name) {
228 drawColor(color);
229 return "";
230 }
231
232 template <typename Space, typename KSpace>
233 void Display3D<Space, KSpace>::drawColor(const DGtal::Color& color) {
234 currentStyle.color = color;
235 currentStyle.useDefaultColors = false;
236 }
237
238 template <typename Space, typename KSpace>
239 void Display3D<Space, KSpace>::setDefaultColors() {
240 currentStyle.useDefaultColors = true;
241 }
242
243 template <typename Space, typename KSpace>
244 void Display3D<Space, KSpace>::drawAdjacencies(bool toggle) {
245 if (toggle) currentStyle.mode |= DisplayStyle::ADJACENCIES;
246 else currentStyle.mode &= ~DisplayStyle::ADJACENCIES;
247 }
248
249 template <typename Space, typename KSpace>
250 void Display3D<Space, KSpace>::drawAsSimplified(bool toggle) {
251 if (toggle) currentStyle.mode |= DisplayStyle::SIMPLIFIED;
252 else currentStyle.mode &= ~DisplayStyle::SIMPLIFIED;
253 }
254
255 template <typename Space, typename KSpace>
256 void Display3D<Space, KSpace>::drawAsGrid(bool toggle) {
257 if (toggle) currentStyle.mode |= DisplayStyle::GRID;
258 else currentStyle.mode &= ~DisplayStyle::GRID;
259 }
260
261 template <typename Space, typename KSpace>
262 void Display3D<Space, KSpace>::defaultStyle() {
263 currentStyle.mode = DisplayStyle::DEFAULT;
264 }
265
266 template <typename Space, typename KSpace>
267 void Display3D<Space, KSpace>::drawAsPaving() {
268 currentStyle.mode &= ~DisplayStyle::BALLS;
269 currentStyle.mode |= DisplayStyle::PAVING;
270 }
271
272 template <typename Space, typename KSpace>
273 void Display3D<Space, KSpace>::drawAsBalls() {
274 currentStyle.mode &= ~DisplayStyle::PAVING;
275 currentStyle.mode |= DisplayStyle::BALLS;
276 }
277
278 ////////////////////////////// DRAW MODIFIERS //////////////////////////////
279 ////////////////////////////////////////////////////////////////////////////
280
281 ////////////////////////////////////////////////////////////////////////////
282 ////////////////////////////// DRAW COMMANDS ///////////////////////////////
283
284 template <typename Space, typename KSpace>
285 template<typename Obj>
286 Display3D<Space, KSpace>& Display3D<Space, KSpace>::operator<<(const Obj& obj) {
287 draw(obj);
288 return *this;
289 }
290
291 template <typename Space, typename KSpace>
292 std::string Display3D<Space, KSpace>::draw(const Point& p, const std::string& uname) {
293 return draw(myEmbedder.embed(p), uname);
294 }
295
296 template <typename Space, typename KSpace>
297 std::string Display3D<Space, KSpace>::draw(const RealPoint& rp, const std::string& uname) {
298 std::string name = myCurrentName;
299
300 if (currentStyle.mode & DisplayStyle::BALLS) {
301 name = createOrReuseBallList(uname);
302 myCurrentData->vertices.push_back(rp);
303 } else {
304 name = createOrReuseCubeList(uname);
305 drawutils::insertCubeVertices(myCurrentData->vertices, rp, myCurrentData->style.width);
306 }
307 return name;
308 }
309
310 template <typename Space, typename KSpace>
311 std::string Display3D<Space, KSpace>::draw(const std::pair<RealPoint, RealPoint>& arrow, const std::string& uname) {
312 // Warning, this function draw arrows, not lines !
313 std::string name = createOrReuseBallList(uname);
314 myCurrentData->vertices.push_back(arrow.first);
315 myCurrentData->vectorQuantities[QuantityScale::VERTEX]["value"].push_back(arrow.second);
316 return name;
317 }
318
319 template <typename Space, typename KSpace>
320 template<typename T>
321 std::string Display3D<Space, KSpace>::draw(const std::vector<T>& range, const std::string& uname) {
322 return drawGenericRange(range, uname);
323 }
324
325 template <typename Space, typename KSpace>
326 template<typename A, typename B, typename C>
327 std::string Display3D<Space, KSpace>::draw(const ConstRangeAdapter<A, B, C> range, const std::string& uname) {
328 return drawGenericRange(range, uname);
329 }
330
331 template <typename Space, typename KSpace>
332 template<typename A, typename B, typename C>
333 std::string Display3D<Space, KSpace>::draw(const ConstIteratorAdapter<A, B, C>& adapter, const std::string& uname) {
334 if (uname.empty()) {
335 // Use default value of draw
336 return draw(*adapter);
337 }
338 return draw(*adapter, uname);
339 }
340
341 template <typename Space, typename KSpace>
342 std::string Display3D<Space, KSpace>::draw(const GridCurve<KSpace>& curve, const std::string& uname) {
343 return draw(curve.getSCellsRange(), uname);
344 }
345
346 template <typename Space, typename KSpace>
347 std::string Display3D<Space, KSpace>::draw(const typename GridCurve<KSpace>::MidPointsRange& range, const std::string& uname) {
348 return drawGenericRange(range, uname);
349 }
350
351 template <typename Space, typename KSpace>
352 std::string Display3D<Space, KSpace>::draw(const typename GridCurve<KSpace>::ArrowsRange& range, const std::string& uname) {
353 return drawGenericRange(range, uname);
354 }
355
356 template <typename Space, typename KSpace>
357 template <DGtal::Dimension emb, DGtal::Dimension amb, typename Algebra, typename Int>
358 std::string Display3D<Space, KSpace>::draw(const DiscreteExteriorCalculus<emb, amb, Algebra, Int>& calc, const std::string& uname) {
359 bool save = allowReuseList;
360 allowReuseList = true;
361
362 // Maintains multiple names it contains any dimension type
363 std::string list0 = newBallList(uname + "_0d");
364 std::string list1 = newLineList(uname + "_1d");
365 std::string list2_1 = newQuadList(uname + "_2d");
366 std::string list2_2 = newVolumetricList(uname + "_2d_signed");
367 std::string list3 = newCubeList(uname + "_3d");
368
369 const std::string* const lists[4] = { &list0, &list1, &list2_2, &list3 };
370
371 for (auto it = calc.begin(); it != calc.end(); ++it) {
372 const auto& cell = it->first;
373 const bool& flip = it->second.flipped;
374
375 const SCell displayed = calc.myKSpace.signs(cell, flip ? KSpace::NEG : KSpace::POS);
376
377 const bool xodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(displayed.preCell().coordinates[0]) & 1);
378 const bool yodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(displayed.preCell().coordinates[1]) & 1);
379 const bool zodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(displayed.preCell().coordinates[2]) & 1);
380
381 const int dim = xodd + yodd + zodd;
382
383 setCurrentList(*lists[dim]);
384 if ((dim == 2) && (currentStyle.mode & DisplayStyle::SIMPLIFIED))
385 setCurrentList(list2_1);
386
387 const auto rp = mySCellEmbedder.embed(displayed);
388 drawKCell(*lists[dim], rp, xodd, yodd, zodd, true, displayed.preCell().positive);
389 }
390
391 allowReuseList = save;
392 endCurrentGroup();
393 return list2_2; // Return one of the name
394 }
395
396 template <typename Space, typename KSpace>
397 template <typename Calculus, DGtal::Order order, DGtal::Duality duality>
398 std::string Display3D<Space, KSpace>::draw(const KForm<Calculus, order, duality>& kform, const std::string& uname) {
399 bool save = allowReuseList;
400 allowReuseList = true;
401
402 using CSCell = Calculus::SCell;
403 using Scalar = Calculus::Scalar;
404
405 std::string list0 = newBallList(uname + "_0d");
406 std::string list1 = newLineList(uname + "_1d");
407 std::string list2_1 = newQuadList(uname + "_2d");
408 std::string list2_2 = newVolumetricList(uname + "_2d_signed");
409 std::string list3 = newCubeList(uname + "_3d");
410
411 const std::string* lists[4] = { &list0, &list1, &list2_2, &list3 };
412
413 for (typename Calculus::Index i = 0; i < kform.length(); ++i) {
414 const SCell cell = kform.getSCell(i);
415 const Scalar val = kform.myContainer(i);
416
417 const bool xodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[0]) & 1);
418 const bool zodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[2]) & 1);
419 const bool yodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[1]) & 1);
420
421 const int dim = xodd + yodd + zodd;
422 if (!std::isfinite(val)) continue;
423
424 setCurrentList(*lists[dim]);
425 if ((dim == 2) && (currentStyle.mode & DisplayStyle::SIMPLIFIED))
426 setCurrentList(list2_1);
427
428 // Automatically decide the scalle of the quantity
429 draw(WithQuantity(cell, "value", val));
430 }
431
432 allowReuseList = save;
433 endCurrentGroup();
434 return list2_2; // Return one of the name
435 }
436
437
438 template <typename Space, typename KSpace>
439 template <typename Calculus, DGtal::Duality dual>
440 std::string Display3D<Space, KSpace>::draw(const VectorField<Calculus, dual>& field, const std::string& uname) {
441 std::string name = newBallList(uname);
442
443 myCurrentData->style.width = 0.; // Make ball diseapear
444 myCurrentData->vertices.reserve(field.length());
445 myCurrentData->vectorQuantities[QuantityScale::VERTEX]["value"].reserve(field.length());
446
447 for (typename Calculus::Index i = 0; i < field.length(); ++i) {
448 const auto& origin = mySCellEmbedder.embed(field.getSCell(i));
449 const auto vector = field.getVector(i);
450
451 if (std::isfinite(vector[0]) && std::isfinite(vector[1]) && std::isfinite(vector[2])) {
452 myCurrentData->vertices.push_back(origin);
453 myCurrentData->vectorQuantities[QuantityScale::VERTEX]["value"].push_back(vector);
454 }
455 }
456
457 endCurrentGroup();
458 return name;
459 }
460
461 template <typename Space, typename KSpace>
462 std::string Display3D<Space, KSpace>::draw(const KCell& cell, const std::string& name) {
463 const RealPoint rp = myCellEmbedder.embed(cell);
464
465 const bool xodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[0]) & 1);
466 const bool yodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[1]) & 1);
467 const bool zodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[2]) & 1);
468
469 return drawKCell(name, rp, xodd, yodd, zodd, false, false);
470 }
471
472 template <typename Space, typename KSpace>
473 std::string Display3D<Space, KSpace>::draw(const SCell& cell, const std::string& name) {
474 const RealPoint rp = mySCellEmbedder.embed(cell);
475
476 const bool xodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[0]) & 1);
477 const bool yodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[1]) & 1);
478 const bool zodd = (NumberTraits<typename KSpace::Integer>::castToInt64_t(cell.preCell().coordinates[2]) & 1);
479
480 return drawKCell(name, rp, xodd, yodd, zodd, true, cell.preCell().positive);
481 }
482
483 template <typename Space, typename KSpace>
484 std::string Display3D<Space, KSpace>::draw(const HyperRectDomain<Space>& domain, const std::string& uname) {
485
486 std::string name;
487
488 if (currentStyle.mode & DisplayStyle::GRID) {
489 name = newLineList(uname);
490
491 // Faces YX
492 for (auto z = domain.myLowerBound[2]; z <= domain.myUpperBound[2]; z++) {
493 for (auto x = domain.myLowerBound[0]; x <= domain.myUpperBound[0]; x++) {
494 DGtal::Z3i::RealPoint rp1 = myEmbedder.embed( DGtal::Z3i::Point(x, domain.myLowerBound[1], z) );
495 DGtal::Z3i::RealPoint rp2 = myEmbedder.embed( DGtal::Z3i::Point(x, domain.myUpperBound[1], z) );
496 myCurrentData->vertices.push_back(rp1);
497 myCurrentData->vertices.push_back(rp2);
498 }
499
500 for (auto y = domain.myLowerBound[1]; y <= domain.myUpperBound[1]; y++) {
501 DGtal::Z3i::RealPoint rp1 = myEmbedder.embed( DGtal::Z3i::Point(domain.myLowerBound[0], y, z) );
502 DGtal::Z3i::RealPoint rp2 = myEmbedder.embed( DGtal::Z3i::Point(domain.myUpperBound[0], y, z) );
503 myCurrentData->vertices.push_back(rp1);
504 myCurrentData->vertices.push_back(rp2);
505 }
506 }
507
508 // Faces XZ
509 for (auto y = domain.myLowerBound[1]; y <= domain.myUpperBound[1]; y++) {
510 for (auto x = domain.myLowerBound[0]; x <= domain.myUpperBound[0]; x++) {
511 DGtal::Z3i::RealPoint rp1 = myEmbedder.embed( DGtal::Z3i::Point(x, y, domain.myLowerBound[2]) );
512 DGtal::Z3i::RealPoint rp2 = myEmbedder.embed( DGtal::Z3i::Point(x, y, domain.myLowerBound[2]) );
513
514 myCurrentData->vertices.push_back(rp1);
515 myCurrentData->vertices.push_back(rp2);
516 }
517 for (auto z = domain.myLowerBound[2]; z <= domain.myUpperBound[2]; z++) {
518 DGtal::Z3i::RealPoint rp1 = myEmbedder.embed( DGtal::Z3i::Point(domain.myLowerBound[0], y, z) );
519 DGtal::Z3i::RealPoint rp2 = myEmbedder.embed( DGtal::Z3i::Point(domain.myUpperBound[0], y, z) );
520
521 myCurrentData->vertices.push_back(rp1);
522 myCurrentData->vertices.push_back(rp2);
523 }
524 }
525
526 // Faces YZ
527 for (auto x = domain.myLowerBound[0]; x <= domain.myUpperBound[0]; x++) {
528 for (auto y = domain.myLowerBound[1]; y <= domain.myUpperBound[1]; y++) {
529 DGtal::Z3i::RealPoint rp1 = myEmbedder.embed( DGtal::Z3i::Point(x, y, domain.myLowerBound[2]) );
530 DGtal::Z3i::RealPoint rp2 = myEmbedder.embed( DGtal::Z3i::Point(x, y, domain.myUpperBound[2]) );
531
532 myCurrentData->vertices.push_back(rp1);
533 myCurrentData->vertices.push_back(rp2);
534 }
535 for (auto z = domain.myLowerBound[2]; z <= domain.myUpperBound[2]; z++) {
536 DGtal::Z3i::RealPoint rp1 = myEmbedder.embed( DGtal::Z3i::Point(x, domain.myLowerBound[1], z) );
537 DGtal::Z3i::RealPoint rp2 = myEmbedder.embed( DGtal::Z3i::Point(x, domain.myLowerBound[1], z) );
538
539 myCurrentData->vertices.push_back(rp1);
540 myCurrentData->vertices.push_back(rp2);
541 }
542 }
543 }
544 else
545 {
546 name = drawGenericRange(domain, uname);
547 if (!(currentStyle.mode & DisplayStyle::BALLS))
548 {
549 data[name].style.useDefaultColors=false;
550 data[name].style.color.alpha(64);
551 }
552 }
553
554 endCurrentGroup();
555 return name;
556 }
557
558 template <typename Space, typename KSpace>
559 template <typename Vec>
560 std::string Display3D<Space, KSpace>::drawPolygon(const std::vector<Vec>& vertices, const std::string& uname) {
561 std::string name = createOrReusePolygonList(uname);
562
563 std::vector<unsigned> indices;
564 indices.reserve(vertices.size());
565
566 size_t count = myCurrentData->vertices.size();
567 for (const auto& vert : vertices) {
568 myCurrentData->vertices.push_back(vert);
569 indices.push_back(count++);
570 }
571 myCurrentData->indices.push_back(std::move(indices));
572 return name;
573 }
574
575 template <typename Space, typename KSpace>
576 std::string Display3D<Space, KSpace>::drawBall(const RealPoint& c, const std::string& uname) {
577 std::string name = createOrReuseBallList(uname);
578 myCurrentData->vertices.push_back(c);
579 return name;
580 }
581
582 template <typename Space, typename KSpace>
583 std::string Display3D<Space, KSpace>::drawLine(const RealPoint& a, const RealPoint& b, const std::string& uname) {
584 std::string name = createOrReuseLineList(uname);
585
586 myCurrentData->vertices.push_back(a);
587 myCurrentData->vertices.push_back(b);
588 return name;
589 }
590
591 template <typename Space, typename KSpace>
592 std::string Display3D<Space, KSpace>::drawQuad(const RealPoint& a, const RealPoint& b, const RealPoint& c, const RealPoint& d, const std::string& uname) {
593 // Not a draw specialization as it would be confusing with a drawing call of
594 // an array of points, or other primitives
595 std::string name = createOrReuseQuadList(uname);
596
597 myCurrentData->vertices.push_back(a);
598 myCurrentData->vertices.push_back(b);
599 myCurrentData->vertices.push_back(c);
600 myCurrentData->vertices.push_back(d);
601
602 return name;
603 }
604
605 template <typename Space, typename KSpace>
606 template <typename Obj, typename Cont>
607 std::string Display3D<Space, KSpace>::draw(const DigitalSetByAssociativeContainer<Obj, Cont>& set, const std::string& name) {
608 return drawGenericRange(set, name);
609 }
610
611 template <typename Space, typename KSpace>
612 template <typename D, typename T>
613 std::string Display3D<Space, KSpace>::draw(const ImageContainerBySTLVector<D, T>& image, const std::string& name) {
614 return drawImage(name, image);
615 }
616
617 template <typename Space, typename KSpace>
618 template <typename TImageContainer,
619 typename TNewDomain,
620 typename TFunctorD,
621 typename TNewValue,
622 typename TFunctorV,
623 typename TFunctorVm1>
624 std::string Display3D<Space, KSpace>::draw(const ImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV, TFunctorVm1>& adapter, const std::string& name) {
625 return drawImage(name, adapter);
626 }
627
628 template <typename Space, typename KSpace>
629 template <typename TImageContainer,
630 typename TNewDomain,
631 typename TFunctorD,
632 typename TNewValue,
633 typename TFunctorV>
634 std::string Display3D<Space, KSpace>::draw(const ConstImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV>& adapter, const std::string& name) {
635 return drawImage(name, adapter);
636 }
637
638 template <typename Space, typename KSpace>
639 template <typename Adj, typename Set>
640 std::string Display3D<Space, KSpace>::draw(const DGtal::Object<Adj, Set>& obj, const std::string& uname) {
641 std::string name = drawGenericRange(obj, uname);
642
643 // Draw adjacency if needed
644 if (currentStyle.mode & DisplayStyle::ADJACENCIES) {
645 newLineList(name + "_adj");
646
647 for (auto it = obj.begin(); it != obj.end(); ++it) {
648 auto neig = obj.properNeighborhood(*it);
649
650 const RealPoint p = myEmbedder.embed(*it);
651 for (auto it2 = neig.begin(); it2 != neig.end(); ++it2) {
652 auto p2 = myEmbedder.embed(*it2);
653
654 myCurrentData->vertices.push_back(p);
655 myCurrentData->vertices.push_back(p2);
656 }
657 }
658 }
659 endCurrentGroup();
660 return name;
661 }
662
663 template <typename Space, typename KSpace>
664 template <typename T, typename Type>
665 std::string Display3D<Space, KSpace>::draw(const WithQuantity<T, Type>& props, const std::string& uname) {
666 std::string name;
667 if (uname.empty())
668 name = draw(props.object);
669 else
670 name = draw(props.object, uname);
671
672 QuantityScale sloc = props.scale;
673
674 // Tries to find an appropriate scale
675 if (sloc == QuantityScale::UNKNOWN)
676 sloc = data[name].getDefaultQuantityLevel(data[name].elementSize);
677
678 if (sloc == QuantityScale::UNKNOWN) {
679 trace.error() << "Unable to find suitable quantity scale, defaulting to vertex (for: '" << name << "')\n";
680 sloc = QuantityScale::VERTEX;
681 }
682
683 addQuantity(name, props.name, props.values, sloc);
684 return name;
685 }
686
687 template <typename Space, typename KSpace>
688 template <typename Type>
689 void Display3D<Space, KSpace>::addQuantity(const std::string& oName, const std::string& qName, const Type& value, QuantityScale scale) {
690 std::vector<Type> values = {value};
691 addQuantity(oName, qName, values, scale);
692 }
693
694 template <typename Space, typename KSpace>
695 template <typename Type>
696 void Display3D<Space, KSpace>::addQuantity(const std::string& oName, const std::string& qName, const std::vector<Type>& values, QuantityScale scale) {
697 if (scale == QuantityScale::UNKNOWN)
698 scale = data[oName].getDefaultQuantityLevel(data[oName].elementSize);
699
700 if (scale == QuantityScale::UNKNOWN) {
701 trace.error() << "Unable to find suitable quantity scale, defaulting to vertex (for: '" << oName << "')\n";
702 scale = QuantityScale::VERTEX;
703 }
704
705 if constexpr (std::is_scalar_v<Type>) {
706 auto& loc = data[oName].scalarQuantities[scale][qName];
707 loc.insert(loc.end(), values.begin(), values.end());
708 }
709 else if constexpr(std::is_same_v<RealPoint, Type>) {
710 auto& loc = data[oName].vectorQuantities[scale][qName];
711 loc.insert(loc.end(), values.begin(), values.end());
712 }
713 else if constexpr(std::is_same_v<Color , Type>) {
714 auto& loc = data[oName].colorQuantities[scale][qName];
715 loc.insert(loc.end(), values.begin(), values.end());
716 }
717 else {
718 trace.error() << "Unknown quantity type (for: '" << oName << "')\n";
719 }
720
721 }
722
723 template <typename Space, typename KSpace>
724 template <typename Pt>
725 std::string Display3D<Space, KSpace>::draw(const Mesh<Pt>& mesh, const std::string& uname) {
726 // A mesh may have quad faces, therefore we render it as a polygonal mesh
727 std::string name = newPolygonList(uname);
728
729 myCurrentData->vertices.reserve(mesh.nbVertex());
730
731 myCurrentData->indices.reserve(mesh.nbFaces());
732 myCurrentData->colorQuantities[QuantityScale::FACE]["color"].reserve(mesh.nbFaces());
733
734 // Can not insert directly vectors because of type mismatch
735 for (auto it = mesh.vertexBegin(); it != mesh.vertexEnd(); ++it) {
736 myCurrentData->vertices.push_back(*it);
737 }
738 for (size_t i = 0; i < mesh.nbFaces(); ++i) {
739 const auto& face = mesh.getFace(i);
740 std::vector<unsigned int> fIdx;
741 fIdx.reserve(face.size());
742 for (auto j : face) {
743 fIdx.push_back(j);
744 }
745 myCurrentData->indices.push_back(std::move(fIdx));
746 myCurrentData->colorQuantities[QuantityScale::FACE]["color"].push_back(mesh.getFaceColor(i));
747 }
748 endCurrentGroup();
749 return name;
750 }
751
752 template <typename Space, typename KSpace>
753 template <typename It, typename Int, int Con>
754 std::string Display3D<Space, KSpace>::draw(const StandardDSS6Computer<It, Int, Con>& computer, const std::string& uname) {
755 std::string name;
756 if (currentStyle.mode & DisplayStyle::BALLS) {
757 name = newBallList(uname);
758
759 for (auto it = computer.begin(); it != computer.end(); ++it) {
760 const auto rp = myEmbedder.embed(*it);
761 myCurrentData->vertices.push_back(rp);
762 }
763 } else { // Default mode
764 name = newLineList(uname);
765
766 auto it = computer.begin();
767 RealPoint a = myEmbedder.embed(*it);
768 RealPoint b = a;
769
770 for (++it; it != computer.end(); ++it) {
771 b = myEmbedder.embed(*it);
772 myCurrentData->vertices.push_back(a);
773 myCurrentData->vertices.push_back(b);
774
775 std::swap(a, b);
776 }
777 }
778
779 endCurrentGroup();
780 return name;
781 }
782
783 template <typename Space, typename KSpace>
784 template<typename It, typename Int, int Con>
785 std::string Display3D<Space, KSpace>::draw(const Naive3DDSSComputer<It, Int, Con>& computer, const std::string& uname) {
786 std::string name = drawGenericRange(computer, uname);
787 endCurrentGroup();
788
789 if (currentStyle.mode & DisplayStyle::ADJACENCIES) {
790 newLineList(uname + "_links");
791
792 auto it = computer.begin();
793 auto prev = myEmbedder(*it);
794 ++it;
795
796 for (; it != computer.end(); ++it) {
797 auto p = myEmbedder(*it);
798 myCurrentData->vertices.push_back(prev);
799 myCurrentData->vertices.push_back(p);
800 prev = p;
801 }
802
803 endCurrentGroup();
804 }
805 return name;
806 }
807
808 template <typename Space, typename KSpace>
809 std::string Display3D<Space, KSpace>::draw(const ClippingPlane& plane, const std::string& uname) {
810 planes.push_back(plane);
811 planes.back().style = currentStyle;
812 return "";
813 }
814
815 template <typename Space, typename KSpace>
816 template <typename T>
817 std::string Display3D<Space, KSpace>::draw(const SphericalAccumulator<T> accumulator, const std::string& uname) {
818 std::string name = newQuadList(uname);
819
820 typedef typename SphericalAccumulator<T>::Size Size;
821 typedef typename SphericalAccumulator<T>::RealVector Vec;
822
823 Size i, j;
824 Vec a, b, c, d;
825 for (auto it = accumulator.begin(); it != accumulator.end(); ++it) {
826 accumulator.binCoordinates(it, i, j);
827
828 if (accumulator.isValidBin(i, j)) {
829 accumulator.getBinGeometry(i, j, a, b, c, d);
830
831 myCurrentData->vertices.push_back(a);
832 myCurrentData->vertices.push_back(b);
833 myCurrentData->vertices.push_back(c);
834 myCurrentData->vertices.push_back(d);
835 myCurrentData->scalarQuantities[QuantityScale::FACE]["value"].push_back(accumulator.count(i, j));
836 }
837 }
838 return name;
839 }
840
841 // Generic functions
842 template <typename Space, typename KSpace>
843 template <typename Range>
844 std::string Display3D<Space, KSpace>::drawGenericRange(const Range& range, const std::string& uname) {
845 bool save = allowReuseList;
846
847 endCurrentGroup();
848 allowReuseList = true;
849
850 auto it = range.begin();
851
852 std::string name = myCurrentName;
853 if (uname.empty()) {
854 name = draw(*it);
855 } else {
856 name = draw(*it, uname);
857 }
858
859 myCurrentData->vertices.reserve(
860 myCurrentData->vertices.size() +
861 myCurrentData->elementSize * std::distance(range.begin(), range.end())
862 );
863
864 for (++it; it != range.end(); ++it) {
865 draw(*it, name);
866 }
867
868 endCurrentGroup();
869 allowReuseList = save;
870 return name;
871 }
872
873 template <typename Space, typename KSpace>
874 template <typename T>
875 std::string Display3D<Space, KSpace>::drawImage(const std::string& uname, const T& image) {
876 std::string name = newCubeList(uname);
877
878 size_t total = image.domain().size();
879
880 auto it = image.domain().begin();
881 auto itend = image.domain().end();
882 constexpr size_t dim = T::Domain::Space::dimension;
883
884 myCurrentData->vertices.reserve(8 * total);
885 myCurrentData->scalarQuantities[QuantityScale::CELL]["value"].reserve(total);
886 for(; it != itend; ++it) {
887 RealPoint rp;
888 if constexpr (dim == 3) {
889 rp = myEmbedder.embed(*it);
890 } else {
891 // We accept to draw theses 2D image, do ask to parametrize to also the myEmbedder...
892 rp = myEmbedder.embed(Point((*it)[0], (*it)[1], 0));
893 }
894 myCurrentData->scalarQuantities[QuantityScale::CELL]["value"].push_back(image(*it));
895 drawutils::insertCubeVertices(myCurrentData->vertices, rp, myCurrentData->style.width);
896 }
897 return name;
898 }
899
900 template <typename Space, typename KSpace>
901 std::string Display3D<Space, KSpace>::drawKCell(std::string uname, const RealPoint& rp, bool xodd, bool yodd, bool zodd, bool hasSign, bool sign) {
902 std::string name = myCurrentName;
903 static const std::string TOKEN = "{d}";
904 static const double scale = 0.9;
905 static const double shift = 0.05;
906 static const double smallScale = 0.3;
907 static const double smallShift = 0.15;
908 // For 2D cell, this indicates if the big quad is
909 // inside the cell or outside
910 static const int orientationPermut[3][2] = {
911 {1, 0}, {0, 1}, {1, 0}
912 };
913
914 const unsigned int dim = xodd + yodd + zodd;
915
916 auto tokenPos = uname.find(TOKEN);
917 if (tokenPos != std::string::npos)
918 uname.replace(uname.find(TOKEN), TOKEN.size(), std::to_string(dim));
919
920 switch(dim) {
921 case 0: {
922 name = createOrReuseBallList(uname);
923 if (myCurrentData->vertices.size() == 0)
924 myCurrentData->style.width *= scale;
925
926 myCurrentData->vertices.push_back(rp);
927 }
928 break;
929 case 1: {
930 name = createOrReuseLineList(uname);
931
932 const RealPoint shift(xodd, yodd, zodd);
933 myCurrentData->vertices.push_back(rp - 0.5 * shift);
934 myCurrentData->vertices.push_back(rp + 0.5 * shift);
935 }
936 break;
937 case 2: {
938 const unsigned int orientation = (!xodd ? 0 : (!yodd ? 1 : 2));
939 if (currentStyle.mode & DisplayStyle::SIMPLIFIED || !hasSign) {
940 name = createOrReuseQuadList(uname);
941
942 const double scale1 = myCurrentData->style.width * scale;
943
944 drawutils::insertAASquare(myCurrentData->vertices, rp, orientation, scale1);
945 } else {
946 name = createOrReuseVolumetricList(uname);
947
948 const double scales[2] = {
949 scale * myCurrentData->style.width,
950 smallScale * myCurrentData->style.width
951 };
952
953 // Decide where the big quad goes, in the interior or the exterior
954 // of the cell depending on sign and the orientation
955 int permut = orientationPermut[orientation][sign];
956 double scale1 = scales[ permut];
957 double scale2 = scales[1 - permut];
958 double shift1 = shift;
959 double shift2 = smallShift;
960
961 drawutils::insertPrism(myCurrentData->vertices, rp, orientation, scale1, scale2, shift1, shift2);
962 }
963 }
964 break;
965 case 3: {
966 name = createOrReuseCubeList(uname);
967 drawutils::insertCubeVertices(myCurrentData->vertices, rp, myCurrentData->style.width);
968 };
969 break;
970 };
971
972 return name;
973 }
974
975
976} // DGtal