PeriDyno 1.0.0
Loading...
Searching...
No Matches
PVec3FieldViewerWidget.cpp
Go to the documentation of this file.
1#include "PVec3FieldViewerWidget.h"
2#include <QHeaderView>
3#include "Vector/Vector3D.h"
4
5namespace dyno
6{
7
8 PVec3FieldViewerWidget::PVec3FieldViewerWidget(FBase* field, QWidget* pParent) :
9 PDataViewerWidget(field, pParent)
10 {
11 mfield = field;
12
13
14 updateDataTable();
15
16
17 }
18
19
24
25
26 void PVec3FieldViewerWidget::buildArrayDataTable(int first, int last)
27 {
28
29
30 // ************************ Vec3f **************************
31 {
32 CArray<Vec3f>* cVec3f = NULL;
33 CArray<Vec3f> cData;
34
35 // ************************ GPU **************************
36 FArray<Vec3f, DeviceType::GPU>* f_GPU = TypeInfo::cast<FArray<Vec3f, DeviceType::GPU>>(mfield);
37 if (f_GPU != nullptr)
38 {
39 std::shared_ptr<Array<Vec3f, DeviceType::GPU>>& data = f_GPU->getDataPtr();
40
41 cData.assign(*data);
42 cVec3f = &cData;
43 }
44
45 // ************************ CPU **************************
46 FArray<Vec3f, DeviceType::CPU>* f_CPU = TypeInfo::cast<FArray<Vec3f, DeviceType::CPU>>(mfield);
47 if (f_CPU != nullptr)
48 {
49 cVec3f = f_CPU->getDataPtr().get();
50 }
51
52
53 //BuildDataTable
54 if (cVec3f != NULL)
55 {
56 uint rowId = first;
57 uint rowTarget = 0;
58 for (size_t i = first; i <= last; i++)
59 {
60 for (size_t j = 0; j < 3; j++)
61 {
62 QString value = "";
63 value = (QString::number((*cVec3f)[i][j], 'f', 6));
64
65 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("float") + QString("[") + QString::number(j) + QString("]"));
66 }
67
68 //QTableWidgetItem* header = new QTableWidgetItem;
69 //header->setText(QString::number(i));
70 //this->setVerticalHeaderItem(i, header);
71
72 rowId++;
73 rowTarget++;
74 }
75 }
76
77 }
78
79
80 // ************************ Vec3d **************************
81 {
82 CArray<Vec3d>* cVec3d = NULL;
83 CArray<Vec3d> cData;
84
85 // ************************ GPU **************************
86 FArray<Vec3d, DeviceType::GPU>* f_GPU = TypeInfo::cast<FArray<Vec3d, DeviceType::GPU>>(mfield);
87 if (f_GPU != nullptr)
88 {
89 std::shared_ptr<Array<Vec3d, DeviceType::GPU>>& data = f_GPU->getDataPtr();
90
91 cData.assign(*data);
92 cVec3d = &cData;
93 }
94
95 // ************************ CPU **************************
96 FArray<Vec3d, DeviceType::CPU>* f_CPU = TypeInfo::cast<FArray<Vec3d, DeviceType::CPU>>(mfield);
97 if (f_CPU != nullptr)
98 {
99 cVec3d = f_CPU->getDataPtr().get();
100 }
101
102
103 //BuildDataTable
104 if (cVec3d != NULL)
105 {
106 uint rowId = first;
107 uint rowTarget = 0;
108 for (size_t i = first; i <= last; i++)
109 {
110 for (size_t j = 0; j < 3; j++)
111 {
112 QString value = "";
113 value = (QString::number((*cVec3d)[i][j], 'f', 10));
114
115 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("double") + QString("[") + QString::number(j) + QString("]"));
116 }
117
118 //QTableWidgetItem* header = new QTableWidgetItem;
119 //header->setText(QString::number(i));
120 //this->setVerticalHeaderItem(i, header);
121
122 rowId++;
123 rowTarget++;
124 }
125
126 }
127
128 }
129
130 // ************************ Vec3i **************************
131 {
132 CArray<Vec3i>* cVec3i = NULL;
133 CArray<Vec3i> cData;
134
135 // ************************ GPU **************************
136 FArray<Vec3i, DeviceType::GPU>* i_GPU = TypeInfo::cast<FArray<Vec3i, DeviceType::GPU>>(mfield);
137 if (i_GPU != nullptr)
138 {
139 std::shared_ptr<Array<Vec3i, DeviceType::GPU>>& data = i_GPU->getDataPtr();
140
141 cData.assign(*data);
142 cVec3i = &cData;
143 }
144
145 // ************************ CPU **************************
146 FArray<Vec3i, DeviceType::CPU>* i_CPU = TypeInfo::cast<FArray<Vec3i, DeviceType::CPU>>(mfield);
147 if (i_CPU != nullptr)
148 {
149 cVec3i = i_CPU->getDataPtr().get();
150 }
151
152
153 //BuildDataTable
154 if (cVec3i != NULL)
155 {
156 uint rowId = first;
157 uint rowTarget = 0;
158 for (size_t i = first; i <= last; i++)
159 {
160 for (size_t j = 0; j < 3; j++)
161 {
162 QString value = "";
163 value = (QString::number((*cVec3i)[i][j]));
164
165 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("int") + QString("[") + QString::number(j) + QString("]"));
166 }
167
168
169 rowId++;
170 rowTarget++;
171 }
172
173 }
174 }
175
176 // ************************ Vec3u **************************
177 {
178 CArray<Vec3u>* cVec3u = NULL;
179 CArray<Vec3u> cData;
180
181 // ************************ GPU **************************
182 FArray<Vec3u, DeviceType::GPU>* u_GPU = TypeInfo::cast<FArray<Vec3u, DeviceType::GPU>>(mfield);
183 if (u_GPU != nullptr)
184 {
185 std::shared_ptr<Array<Vec3u, DeviceType::GPU>>& data = u_GPU->getDataPtr();
186
187 cData.assign(*data);
188 cVec3u = &cData;
189 }
190
191 // ************************ CPU **************************
192 FArray<Vec3u, DeviceType::CPU>* u_CPU = TypeInfo::cast<FArray<Vec3u, DeviceType::CPU>>(mfield);
193 if (u_CPU != nullptr)
194 {
195 cVec3u = u_CPU->getDataPtr().get();
196 }
197
198
199 //BuildDataTable
200 if (cVec3u != NULL)
201 {
202 uint rowId = first;
203 uint rowTarget = 0;
204 for (size_t i = first; i <= last; i++)
205 {
206 for (size_t j = 0; j < 3; j++)
207 {
208 QString value = "";
209 value = (QString::number((*cVec3u)[i][j]));
210
211 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("uint") + QString("[") + QString::number(j) + QString("]"));
212 }
213 rowId++;
214 rowTarget++;
215 }
216 }
217 }
218
219
220 // ************************ Vector<int,3> **************************
221 {
222 CArray<Vector<int, 3>>* cVec3i = NULL;
223 CArray<Vector<int, 3>> cData;
224
225 // ************************ GPU **************************
226 FArray<Vector<int, 3>, DeviceType::GPU>* i_GPU = TypeInfo::cast<FArray<Vector<int, 3>, DeviceType::GPU>>(mfield);
227 if (i_GPU != nullptr)
228 {
229 std::shared_ptr<Array<Vector<int, 3>, DeviceType::GPU>>& data = i_GPU->getDataPtr();
230
231 cData.assign(*data);
232 cVec3i = &cData;
233 }
234
235 // ************************ CPU **************************
236 FArray<Vector<int, 3>, DeviceType::CPU>* i_CPU = TypeInfo::cast<FArray<Vector<int, 3>, DeviceType::CPU>>(mfield);
237 if (i_CPU != nullptr)
238 {
239 cVec3i = i_CPU->getDataPtr().get();
240 }
241
242
243 //BuildDataTable
244 if (cVec3i != NULL)
245 {
246 uint rowId = first;
247 uint rowTarget = 0;
248 for (size_t i = first; i <= last; i++)
249 {
250 for (size_t j = 0; j < 3; j++)
251 {
252 QString value = "";
253 value = (QString::number((*cVec3i)[i][j]));
254
255 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("int") + QString("[") + QString::number(j) + QString("]"));
256 }
257
258
259 rowId++;
260 rowTarget++;
261 }
262
263 }
264 }
265
266 }
267
268 void PVec3FieldViewerWidget::buildVarDataTable()
269 {
270
271 //std::string template_name = mfield->getTemplateName();
272
273 // ************************ FVar<Vec3f> **************************
274 {
275 FVar<Vec3f>* f = TypeInfo::cast<FVar<Vec3f>>(mfield);
276 if (f != nullptr)
277 {
278 const auto& Vec3f = f->getValue();
279
280
281 for (size_t j = 0; j < 3; j++)
282 {
283 QString value = "";
284 value = (QString::number((Vec3f)[j], 'f', 6));
285
286 addItemToPosition(value, 0, j, QString::number(0), QString("float") + QString("[") + QString::number(j) + QString("]"));
287 }
288
289 QTableWidgetItem* header = new QTableWidgetItem;
290 header->setText(QString::number(0));
291 this->setVerticalHeaderItem(0, header);
292
293 }
294 }
295
296 // ************************ FVar<Vec3d> **************************
297 {
298 FVar<Vec3d>* f = TypeInfo::cast<FVar<Vec3d>>(mfield);
299 if (f != nullptr)
300 {
301 const auto& Vec3d = f->getValue();
302
303
304 for (size_t j = 0; j < 3; j++)
305 {
306 QString value = "";
307 value = (QString::number((Vec3d)[j], 'f', 10));
308
309 addItemToPosition(value, 0, j, QString::number(0), QString("double") + QString("[") + QString::number(j) + QString("]"));
310 }
311
312 QTableWidgetItem* header = new QTableWidgetItem;
313 header->setText(QString::number(0));
314 this->setVerticalHeaderItem(0, header);
315
316 }
317 }
318
319
320 // ************************ FVar<Vec3i> **************************
321 {
322 FVar<Vec3i>* f = TypeInfo::cast<FVar<Vec3i>>(mfield);
323 if (f != nullptr)
324 {
325 const auto& Vec3i = f->getValue();
326
327
328 for (size_t j = 0; j < 3; j++)
329 {
330 QString value = "";
331 value = (QString::number((Vec3i)[j]));
332
333 addItemToPosition(value, 0, j, QString::number(0), QString("int") + QString("[") + QString::number(j) + QString("]"));
334 }
335
336 QTableWidgetItem* header = new QTableWidgetItem;
337 header->setText(QString::number(0));
338 this->setVerticalHeaderItem(0, header);
339
340 }
341 }
342
343 // ************************ FVar<Vec3i> **************************
344 {
345 FVar<Vec3u>* f = TypeInfo::cast<FVar<Vec3u>>(mfield);
346 if (f != nullptr)
347 {
348 const auto& Vec3u = f->getValue();
349
350
351 for (size_t j = 0; j < 3; j++)
352 {
353 QString value = "";
354 value = (QString::number((Vec3u)[j]));
355
356 addItemToPosition(value, 0, j, QString::number(0), QString("uint") + QString("[") + QString::number(j) + QString("]"));
357 }
358
359 QTableWidgetItem* header = new QTableWidgetItem;
360 header->setText(QString::number(0));
361 this->setVerticalHeaderItem(0, header);
362
363 }
364 }
365
366 // ************************ FVar<VectorND<int,3>> **************************
367 {
368 FVar<VectorND<int, 3>>* f = TypeInfo::cast<FVar<VectorND<int, 3>>>(mfield);
369 if (f != nullptr)
370 {
371 const auto& Vec3i = f->getValue();
372
373
374 for (size_t j = 0; j < 3; j++)
375 {
376 QString value = "";
377 value = (QString::number((Vec3i)[j]));
378
379 addItemToPosition(value, 0, j, QString::number(0), QString("int") + QString("[") + QString::number(j) + QString("]"));
380 }
381
382 QTableWidgetItem* header = new QTableWidgetItem;
383 header->setText(QString::number(0));
384 this->setVerticalHeaderItem(0, header);
385
386 }
387 }
388
389 }
390
391
392 void PVec3FieldViewerWidget::buildArrayListDataTable(int first, int last)
393 {
394
395 {
396
397 //std::string template_name = mfield->getTemplateName();
398
399
400 // *********************** Vec3f ***************************
401 CArrayList<Vec3f>* dataPtr = NULL;
402 CArrayList<Vec3f> cData;
403
404 // ************************ GPU **************************
405 FArrayList<Vec3f, DeviceType::GPU>* f_GPU = TypeInfo::cast<FArrayList<Vec3f, DeviceType::GPU>>(mfield);
406 if (f_GPU != nullptr)
407 {
408 std::shared_ptr<ArrayList<Vec3f, DeviceType::GPU>>& data = f_GPU->getDataPtr();
409
410 cData.assign(*data);
411 dataPtr = &cData;
412 }
413
414 // ************************ CPU **************************
415 FArrayList<Vec3f, DeviceType::CPU>* f_CPU = TypeInfo::cast<FArrayList<Vec3f, DeviceType::CPU>>(mfield);
416 if (f_CPU != nullptr)
417 {
418 dataPtr = f_CPU->getDataPtr().get();
419 }
420
421
422 if (dataPtr == NULL)
423 return;
424
425 //BuildDataTable
426 uint rowId = first;
427 uint rowTarget = 0;
428 for (size_t i = first; i <= last; i++)
429 {
430 auto it = (*dataPtr)[i];
431
432 for (size_t j = 0; j < it.size(); j++)
433 {
434 auto trans = it[j];
435
436 QString value;
437 for (size_t i = 0; i < 3; i++)
438 {
439 value.append(QString::number(trans[i]) + ", ");
440
441 }
442 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("[") + QString::number(j) + QString("]"), true, rowsHeight);
443
444 value.clear();
445
446 }
447
448
449 rowId++;
450 rowTarget++;
451 }
452
453 }
454
455
456
457 {
458 // *********************** Vec3d ***************************
459 CArrayList<Vec3d>* dataPtr = NULL;
460 CArrayList<Vec3d> cData;
461
462 // ************************ GPU **************************
463 FArrayList<Vec3d, DeviceType::GPU>* f_GPU = TypeInfo::cast<FArrayList<Vec3d, DeviceType::GPU>>(mfield);
464 if (f_GPU != nullptr)
465 {
466 std::shared_ptr<ArrayList<Vec3d, DeviceType::GPU>>& data = f_GPU->getDataPtr();
467
468 cData.assign(*data);
469 dataPtr = &cData;
470 }
471
472 // ************************ CPU **************************
473 FArrayList<Vec3d, DeviceType::CPU>* f_CPU = TypeInfo::cast<FArrayList<Vec3d, DeviceType::CPU>>(mfield);
474 if (f_CPU != nullptr)
475 {
476 dataPtr = f_CPU->getDataPtr().get();
477 }
478
479
480 if (dataPtr == NULL)
481 return;
482
483 //BuildDataTable
484 uint rowId = first;
485 uint rowTarget = 0;
486 for (size_t i = first; i <= last; i++)
487 {
488 auto it = (*dataPtr)[i];
489
490 for (size_t j = 0; j < it.size(); j++)
491 {
492 auto trans = it[j];
493
494 QString value;
495 for (size_t i = 0; i < 3; i++)
496 {
497 value.append(QString::number(trans[i]) + ", ");
498
499 }
500 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("[") + QString::number(j) + QString("]"), true, rowsHeight);
501
502 value.clear();
503
504 }
505
506
507 rowId++;
508 rowTarget++;
509 }
510 }
511
512 {
513 // *********************** Vec3i ***************************
514 CArrayList<Vec3i>* dataPtr = NULL;
515 CArrayList<Vec3i> cData;
516
517 // ************************ GPU **************************
518 FArrayList<Vec3i, DeviceType::GPU>* i_GPU = TypeInfo::cast<FArrayList<Vec3i, DeviceType::GPU>>(mfield);
519 if (i_GPU != nullptr)
520 {
521 std::shared_ptr<ArrayList<Vec3i, DeviceType::GPU>>& data = i_GPU->getDataPtr();
522
523 cData.assign(*data);
524 dataPtr = &cData;
525 }
526
527 // ************************ CPU **************************
528 FArrayList<Vec3i, DeviceType::CPU>* i_CPU = TypeInfo::cast<FArrayList<Vec3i, DeviceType::CPU>>(mfield);
529 if (i_CPU != nullptr)
530 {
531 dataPtr = i_CPU->getDataPtr().get();
532 }
533
534
535 if (dataPtr == NULL)
536 return;
537
538 //BuildDataTable
539 uint rowId = first;
540 uint rowTarget = 0;
541 for (size_t i = first; i <= last; i++)
542 {
543 auto it = (*dataPtr)[i];
544
545 for (size_t j = 0; j < it.size(); j++)
546 {
547 auto trans = it[j];
548
549 QString value;
550 for (size_t i = 0; i < 3; i++)
551 {
552 value.append(QString::number(trans[i]) + ", ");
553
554 }
555 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("[") + QString::number(j) + QString("]"), true, rowsHeight);
556
557 value.clear();
558
559 }
560
561
562 rowId++;
563 rowTarget++;
564 }
565 }
566
567
568 {
569 // *********************** Vec3u ***************************
570 CArrayList<Vec3u>* dataPtr = NULL;
571 CArrayList<Vec3u> cData;
572
573 // ************************ GPU **************************
574 FArrayList<Vec3u, DeviceType::GPU>* u_GPU = TypeInfo::cast<FArrayList<Vec3u, DeviceType::GPU>>(mfield);
575 if (u_GPU != nullptr)
576 {
577 std::shared_ptr<ArrayList<Vec3u, DeviceType::GPU>>& data = u_GPU->getDataPtr();
578
579 cData.assign(*data);
580 dataPtr = &cData;
581 }
582
583 // ************************ CPU **************************
584 FArrayList<Vec3u, DeviceType::CPU>* u_CPU = TypeInfo::cast<FArrayList<Vec3u, DeviceType::CPU>>(mfield);
585 if (u_CPU != nullptr)
586 {
587 dataPtr = u_CPU->getDataPtr().get();
588 }
589
590
591 if (dataPtr == NULL)
592 return;
593
594 //BuildDataTable
595 uint rowId = first;
596 uint rowTarget = 0;
597 for (size_t i = first; i <= last; i++)
598 {
599 auto it = (*dataPtr)[i];
600
601 for (size_t j = 0; j < it.size(); j++)
602 {
603 auto trans = it[j];
604
605 QString value;
606 for (size_t i = 0; i < 3; i++)
607 {
608 value.append(QString::number(trans[i]) + ", ");
609
610 }
611 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("[") + QString::number(j) + QString("]"), true, rowsHeight);
612
613 value.clear();
614
615 }
616
617
618 rowId++;
619 rowTarget++;
620 }
621 }
622
623 {
624 // *********************** VectorND<int,3> ***************************
625 CArrayList<VectorND<int,3>>* dataPtr = NULL;
626 CArrayList<VectorND<int, 3>> cData;
627
628 // ************************ GPU **************************
629 FArrayList<VectorND<int, 3>, DeviceType::GPU>* i_GPU = TypeInfo::cast<FArrayList<VectorND<int, 3>, DeviceType::GPU>>(mfield);
630 if (i_GPU != nullptr)
631 {
632 std::shared_ptr<ArrayList<VectorND<int, 3>, DeviceType::GPU>>& data = i_GPU->getDataPtr();
633
634 cData.assign(*data);
635 dataPtr = &cData;
636 }
637
638 // ************************ CPU **************************
639 FArrayList<VectorND<int, 3>, DeviceType::CPU>* i_CPU = TypeInfo::cast<FArrayList<VectorND<int, 3>, DeviceType::CPU>>(mfield);
640 if (i_CPU != nullptr)
641 {
642 dataPtr = i_CPU->getDataPtr().get();
643 }
644
645
646 if (dataPtr == NULL)
647 return;
648
649 //BuildDataTable
650 uint rowId = first;
651 uint rowTarget = 0;
652 for (size_t i = first; i <= last; i++)
653 {
654 auto it = (*dataPtr)[i];
655
656 for (size_t j = 0; j < it.size(); j++)
657 {
658 auto trans = it[j];
659
660 QString value;
661 for (size_t i = 0; i < 3; i++)
662 {
663 value.append(QString::number(trans[i]) + ", ");
664
665 }
666 addItemToPosition(value, rowTarget, j, QString::number(rowId), QString("[") + QString::number(j) + QString("]"), true, rowsHeight);
667
668 value.clear();
669
670 }
671
672
673 rowId++;
674 rowTarget++;
675 }
676 }
677
678 }
679
680}
dyno::FVar::getValue
T getValue()
Definition Field.h:130
dyno::PDataViewerWidget::PDataViewerWidget
PDataViewerWidget(FBase *field, QWidget *pParent=NULL)
Definition PDataViewerWidget.cpp:12
dyno::PDataViewerWidget::addItemToPosition
void addItemToPosition(const QString &qstr, int row, int column, const QString &rowName, const QString &columnName, const bool resizeRow=false, const int height=30)
Definition PDataViewerWidget.cpp:168
dyno::PVec3FieldViewerWidget::buildArrayListDataTable
void buildArrayListDataTable(int first, int last) override
Definition PVec3FieldViewerWidget.cpp:392
dyno::PVec3FieldViewerWidget::PVec3FieldViewerWidget
PVec3FieldViewerWidget(FBase *field, QWidget *pParent=NULL)
Definition PVec3FieldViewerWidget.cpp:8
dyno::PVec3FieldViewerWidget::buildArrayDataTable
void buildArrayDataTable(int first, int last) override
Definition PVec3FieldViewerWidget.cpp:26
TypeInfo::cast
TA * cast(TB *b)
Definition Typedef.inl:286
dyno
This is an implementation of AdditiveCCD based on peridyno.
Definition Array.h:25
dyno::Vec3u
Vector< uint, 3 > Vec3u
Definition Vector3D.h:96
dyno::Vec3i
Vector< int, 3 > Vec3i
Definition Vector3D.h:95
dyno::CArrayList
ArrayList< T, DeviceType::CPU > CArrayList
Definition ArrayList.h:207
dyno::Vec3d
Vector< double, 3 > Vec3d
Definition Vector3D.h:94
dyno::Vec3f
Vector< float, 3 > Vec3f
Definition Vector3D.h:93
dyno::CArray
Array< T, DeviceType::CPU > CArray
Definition Array.h:151
dyno::uint
unsigned int uint
Definition VkProgram.h:14
Generated by doxygen 1.13.2