PeriDyno 1.0.0
Loading...
Searching...
No Matches
EdgeInteraction.cu
Go to the documentation of this file.
1#include "EdgeInteraction.h"
2#include <thrust/sort.h>
3#include <iostream>
4#include <OrbitCamera.h>
5
6namespace dyno
7{
8 __global__ void EI_EdgeInitializeArray(
9 DArray<int> intersected)
10 {
11 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
12 if (pId >= intersected.size()) return;
13
14 intersected[pId] = 0;
15 }
16
17 __global__ void EI_EdgeMergeIntersectedIndexOR(
18 DArray<int> intersected1,
19 DArray<int> intersected2,
20 DArray<int> outIntersected,
21 DArray<int> outUnintersected)
22 {
23 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
24 if (pId >= intersected1.size()) return;
25
26 if (intersected1[pId] == 0 && intersected2[pId] == 0)
27 outIntersected[pId] = 0;
28 else
29 outIntersected[pId] = 1;
30
31 outUnintersected[pId] = outIntersected[pId] == 1 ? 0 : 1;
32 }
33
34 __global__ void EI_EdgeMergeIntersectedIndexXOR(
35 DArray<int> intersected1,
36 DArray<int> intersected2,
37 DArray<int> outIntersected,
38 DArray<int> outUnintersected)
39 {
40 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
41 if (pId >= intersected1.size()) return;
42
43 if (intersected1[pId] == intersected2[pId])
44 outIntersected[pId] = 0;
45 else
46 outIntersected[pId] = 1;
47
48 outUnintersected[pId] = outIntersected[pId] == 1 ? 0 : 1;
49 }
50
51 __global__ void EI_EdgeMergeIntersectedIndexC(
52 DArray<int> intersected1,
53 DArray<int> intersected2,
54 DArray<int> outIntersected,
55 DArray<int> outUnintersected)
56 {
57 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
58 if (pId >= intersected1.size()) return;
59
60 if (intersected2[pId] == 1)
61 outIntersected[pId] = 0;
62 else
63 outIntersected[pId] = intersected1[pId];
64
65 outUnintersected[pId] = outIntersected[pId] == 1 ? 0 : 1;
66 }
67
68 template<typename TDataType>
69 EdgeInteraction<TDataType>::EdgeInteraction()
70 {
71 this->ray1 = TRay3D<Real>();
72 this->ray2 = TRay3D<Real>();
73 this->isPressed = false;
74
75 this->outOtherEdgeSet()->setDataPtr(std::make_shared<EdgeSet<TDataType>>());
76 this->outOtherEdgeSet()->getDataPtr()->getEdges().resize(0);
77 this->outSelectedEdgeSet()->setDataPtr(std::make_shared<EdgeSet<TDataType>>());
78 this->outSelectedEdgeSet()->getDataPtr()->getEdges().resize(0);
79 }
80
81 template<typename TDataType>
82 void EdgeInteraction<TDataType>::onEvent(PMouseEvent event)
83 {
84 if (!event.altKeyPressed()) {
85 if (camera == nullptr)
86 {
87 this->camera = event.camera;
88 }
89 this->varToggleMultiSelect()->setValue(false);
90 if (event.shiftKeyPressed() || event.controlKeyPressed())
91 {
92 this->varToggleMultiSelect()->setValue(true);
93 if (event.shiftKeyPressed() && !event.controlKeyPressed())
94 {
95 this->varMultiSelectionType()->getDataPtr()->setCurrentKey(0);
96 }
97 else if (!event.shiftKeyPressed() && event.controlKeyPressed())
98 {
99 this->varMultiSelectionType()->getDataPtr()->setCurrentKey(1);;
100 }
101 else if (event.shiftKeyPressed() && event.controlKeyPressed())
102 {
103 this->varMultiSelectionType()->getDataPtr()->setCurrentKey(2);;
104 }
105 }
106 if (event.actionType == AT_PRESS)
107 {
108 this->camera = event.camera;
109 this->isPressed = true;
110 //printf("Mouse pressed: Origin: %f %f %f; Direction: %f %f %f \n", event.ray.origin.x, event.ray.origin.y, event.ray.origin.z, event.ray.direction.x, event.ray.direction.y, event.ray.direction.z);
111 this->ray1.origin = event.ray.origin;
112 this->ray1.direction = event.ray.direction;
113 this->x1 = event.x;
114 this->y1 = event.y;
115 if (this->varEdgePickingType()->getValue() == PickingTypeSelection::Both || this->varEdgePickingType()->getValue() == PickingTypeSelection::Click)
116 {
117 this->calcIntersectClick();
118 this->printInfoClick();
119 }
120 }
121 else if (event.actionType == AT_RELEASE)
122 {
123 this->isPressed = false;
124 //printf("Mouse released: Origin: %f %f %f; Direction: %f %f %f \n", event.ray.origin.x, event.ray.origin.y, event.ray.origin.z, event.ray.direction.x, event.ray.direction.y, event.ray.direction.z);
125 this->ray2.origin = event.ray.origin;
126 this->ray2.direction = event.ray.direction;
127 this->x2 = event.x;
128 this->y2 = event.y;
129 if (this->varToggleMultiSelect()->getValue() && this->varTogglePicker()->getValue())
130 {
131 this->mergeIndex();
132 this->printInfoDragRelease();
133 }
134 }
135 else
136 {
137 //printf("Mouse repeated: Origin: %f %f %f; Direction: %f %f %f \n", event.ray.origin.x, event.ray.origin.y, event.ray.origin.z, event.ray.direction.x, event.ray.direction.y, event.ray.direction.z);
138 if (this->isPressed)
139 {
140 this->ray2.origin = event.ray.origin;
141 this->ray2.direction = event.ray.direction;
142 this->x2 = event.x;
143 this->y2 = event.y;
144 if (this->x2 == this->x1 && this->y2 == this->y1)
145 {
146 if (this->varEdgePickingType()->getValue() == PickingTypeSelection::Both || this->varEdgePickingType()->getValue() == PickingTypeSelection::Click)
147 this->calcIntersectClick();
148 }
149 else
150 {
151 if (this->varEdgePickingType()->getValue() == PickingTypeSelection::Both || this->varEdgePickingType()->getValue() == PickingTypeSelection::Drag)
152 {
153 this->calcIntersectDrag();
154 this->printInfoDragging();
155 }
156 }
157 }
158 }
159 }
160 }
161
162 template <typename Edge, typename Real, typename Coord>
163 __global__ void EI_CalIntersectedEdgesRay(
164 DArray<Coord> points,
165 DArray<Edge> edges,
166 DArray<int> intersected,
167 DArray<int> unintersected,
168 DArray<Real> lineDistance,
169 TRay3D<Real> mouseray,
170 Real radius)
171 {
172 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
173 if (pId >= edges.size()) return;
174
175 TSegment3D<Real> seg = TSegment3D<Real>(points[edges[pId].data[0]], points[edges[pId].data[1]]);
176
177 bool flag = false;
178 if (mouseray.distance(seg) <= radius)
179 {
180 flag = true;
181 lineDistance[pId] = abs(TPoint3D<Real>(mouseray.origin[0], mouseray.origin[1], mouseray.origin[2]).distance(seg));
182 }
183 else
184 {
185 flag = false;
186 lineDistance[pId] = 3.4E38;
187 }
188
189 if (flag || intersected[pId] == 1)
190 intersected[pId] = 1;
191 else
192 intersected[pId] = 0;
193 unintersected[pId] = (intersected[pId] == 1 ? 0 : 1);
194 }
195
196 __global__ void EI_CalEdgesNearest(
197 int min_index,
198 DArray<int> intersected,
199 DArray<int> unintersected
200 )
201 {
202 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
203 if (pId >= intersected.size()) return;
204
205 if (intersected[pId] == 1)
206 {
207 if (pId != min_index)
208 {
209 intersected[pId] = 0;
210 unintersected[pId] = 1;
211 }
212 }
213 }
214
215 template <typename Edge, typename Real, typename Coord>
216 __global__ void EI_CalIntersectedEdgesBox(
217 DArray<Coord> points,
218 DArray<Edge> edges,
219 DArray<int> intersected,
220 DArray<int> unintersected,
221 TPlane3D<Real> plane13,
222 TPlane3D<Real> plane42,
223 TPlane3D<Real> plane14,
224 TPlane3D<Real> plane32,
225 Real radius,
226 TRay3D<Real> mouseray)
227 {
228 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
229 if (pId >= edges.size()) return;
230
231 bool flag = false;
232
233 TPoint3D<Real> p;
234
235 TSegment3D<Real> s = TSegment3D<Real>(points[edges[pId].data[0]], points[edges[pId].data[1]]);
236 bool temp1 = s.intersect(plane13, p);
237 temp1 = temp1 && (((p.origin - plane14.origin).dot(plane14.normal)) * ((p.origin - plane32.origin).dot(plane32.normal))) > 0;
238 if (temp1)
239 flag = true;
240 bool temp2 = s.intersect(plane42, p);
241 temp2 = temp2 && (((p.origin - plane14.origin).dot(plane14.normal)) * ((p.origin - plane32.origin).dot(plane32.normal))) > 0;
242 if (temp2)
243 flag = true;
244 bool temp3 = s.intersect(plane14, p);
245 temp3 = temp3 && (((p.origin - plane13.origin).dot(plane13.normal)) * ((p.origin - plane42.origin).dot(plane42.normal))) > 0;
246 if (temp3)
247 flag = true;
248 bool temp4 = s.intersect(plane32, p);
249 temp4 = temp4 && (((p.origin - plane13.origin).dot(plane13.normal)) * ((p.origin - plane42.origin).dot(plane42.normal))) > 0;
250 if (temp4)
251 flag = true;
252
253 for (int i = 0; i < 2; i++)
254 {
255 float temp1 = ((points[edges[pId].data[i]] - plane13.origin).dot(plane13.normal)) * ((points[edges[pId].data[i]] - plane42.origin).dot(plane42.normal));
256 float temp2 = ((points[edges[pId].data[i]] - plane14.origin).dot(plane14.normal)) * ((points[edges[pId].data[i]] - plane32.origin).dot(plane32.normal));
257 if (temp1 >= 0 && temp2 >= 0)
258 {
259 flag = flag||true;
260 break;
261 }
262 }
263
264 TSegment3D<Real> seg = TSegment3D<Real>(points[edges[pId].data[0]], points[edges[pId].data[1]]);
265
266 if (mouseray.distance(seg) <= radius)
267 {
268 flag = flag || true;
269 }
270
271 if (flag || intersected[pId] == 1)
272 intersected[pId] = 1;
273 else
274 intersected[pId] = 0;
275 unintersected[pId] = (intersected[pId] == 1 ? 0 : 1);
276 }
277
278 template <typename Edge>
279 __global__ void EI_AssignOutEdges(
280 DArray<Edge> edges,
281 DArray<Edge> intersected_edges,
282 DArray<Edge> unintersected_edges,
283 DArray<int> outEdgeIndex,
284 DArray<int> intersected,
285 DArray<int> unintersected,
286 DArray<int> intersected_o)
287 {
288 int pId = threadIdx.x + (blockIdx.x * blockDim.x);
289 if (pId >= edges.size()) return;
290
291 if (intersected_o[pId] == 1)
292 {
293 intersected_edges[intersected[pId]] = edges[pId];
294 outEdgeIndex[intersected[pId]] = pId;
295 }
296 else
297 {
298 unintersected_edges[unintersected[pId]] = edges[pId];
299 }
300 }
301
302 template<typename TDataType>
303 void EdgeInteraction<TDataType>::calcEdgeIntersectClick()
304 {
305 auto& initialEdgeSet = this->inInitialEdgeSet()->getData();
306 auto& edges = initialEdgeSet.getEdges();
307 auto& points = initialEdgeSet.getPoints();
308
309 this->tempNumT = edges.size();
310 DArray<int> intersected;
311 intersected.resize(edges.size());
312 cuExecute(edges.size(),
313 EI_EdgeInitializeArray,
314 intersected
315 );
316 DArray<int> unintersected;
317 unintersected.resize(edges.size());
318
319 DArray<Real> lineDistance;
320 lineDistance.resize(edges.size());
321
322 cuExecute(edges.size(),
323 EI_CalIntersectedEdgesRay,
324 points,
325 edges,
326 intersected,
327 unintersected,
328 lineDistance,
329 this->ray1,
330 this->varInteractionRadius()->getData()
331 );
332
333 int min_index = thrust::min_element(thrust::device, lineDistance.begin(), lineDistance.begin() + lineDistance.size()) - lineDistance.begin();
334
335 cuExecute(intersected.size(),
336 EI_CalEdgesNearest,
337 min_index,
338 intersected,
339 unintersected
340 );
341
342 this->tempEdgeIntersectedIndex.assign(intersected);
343
344 if (this->varToggleMultiSelect()->getData())
345 {
346 if (this->edgeIntersectedIndex.size() == 0)
347 {
348 this->edgeIntersectedIndex.resize(edges.size());
349 cuExecute(edges.size(),
350 EI_EdgeInitializeArray,
351 this->edgeIntersectedIndex
352 )
353 }
354 DArray<int> outIntersected;
355 outIntersected.resize(intersected.size());
356 DArray<int> outUnintersected;
357 outUnintersected.resize(unintersected.size());
358 if (this->varMultiSelectionType()->getValue() == MultiSelectionType::OR)
359 {
360 cuExecute(edges.size(),
361 EI_EdgeMergeIntersectedIndexOR,
362 this->edgeIntersectedIndex,
363 intersected,
364 outIntersected,
365 outUnintersected
366 );
367 }
368 else if (this->varMultiSelectionType()->getValue() == MultiSelectionType::XOR)
369 {
370 cuExecute(edges.size(),
371 EI_EdgeMergeIntersectedIndexXOR,
372 this->edgeIntersectedIndex,
373 intersected,
374 outIntersected,
375 outUnintersected
376 );
377 }
378 else if (this->varMultiSelectionType()->getValue() == MultiSelectionType::C)
379 {
380 cuExecute(edges.size(),
381 EI_EdgeMergeIntersectedIndexC,
382 this->edgeIntersectedIndex,
383 intersected,
384 outIntersected,
385 outUnintersected
386 );
387 }
388 intersected.assign(outIntersected);
389 unintersected.assign(outUnintersected);
390 }
391 else
392 {
393 this->edgeIntersectedIndex.assign(intersected);
394 }
395
396 DArray<int> intersected_o;
397 intersected_o.assign(intersected);
398
399 int intersected_size = thrust::reduce(thrust::device, intersected.begin(), intersected.begin() + intersected.size(), (int)0, thrust::plus<int>());
400 DArray<int> outEdgeIndex;
401 outEdgeIndex.resize(intersected_size);
402 thrust::exclusive_scan(thrust::device, intersected.begin(), intersected.begin() + intersected.size(), intersected.begin());
403 DArray<Edge> intersected_edges;
404 intersected_edges.resize(intersected_size);
405
406 int unintersected_size = thrust::reduce(thrust::device, unintersected.begin(), unintersected.begin() + unintersected.size(), (int)0, thrust::plus<int>());
407 thrust::exclusive_scan(thrust::device, unintersected.begin(), unintersected.begin() + unintersected.size(), unintersected.begin());
408 DArray<Edge> unintersected_edges;
409 unintersected_edges.resize(unintersected_size);
410
411 this->tempNumS = intersected_size;
412 cuExecute(edges.size(),
413 EI_AssignOutEdges,
414 edges,
415 intersected_edges,
416 unintersected_edges,
417 outEdgeIndex,
418 intersected,
419 unintersected,
420 intersected_o
421 );
422 this->outSelectedEdgeSet()->getDataPtr()->copyFrom(initialEdgeSet);
423 this->outSelectedEdgeSet()->getDataPtr()->setEdges(intersected_edges);
424 this->outOtherEdgeSet()->getDataPtr()->copyFrom(initialEdgeSet);
425 this->outOtherEdgeSet()->getDataPtr()->setEdges(unintersected_edges);
426 if (this->varToggleIndexOutput()->getValue())
427 {
428 this->outEdgeIndex()->getDataPtr()->assign(outEdgeIndex);
429 }
430 else
431 {
432 this->outEdgeIndex()->getDataPtr()->assign(intersected_o);
433 }
434 }
435
436 template<typename TDataType>
437 void EdgeInteraction<TDataType>::calcEdgeIntersectDrag()
438 {
439 if (x1 == x2)
440 {
441 x2 += 1.0f;
442 }
443 if (y1 == y2)
444 {
445 y2 += 1.0f;
446 }
447 TRay3D<Real> ray1 = this->camera->castRayInWorldSpace((float)x1, (float)y1);
448 TRay3D<Real> ray2 = this->camera->castRayInWorldSpace((float)x2, (float)y2);
449 TRay3D<Real> ray3 = this->camera->castRayInWorldSpace((float)x1, (float)y2);
450 TRay3D<Real> ray4 = this->camera->castRayInWorldSpace((float)x2, (float)y1);
451
452 TPlane3D<Real> plane13 = TPlane3D<Real>(ray1.origin, ray1.direction.cross(ray3.direction));
453 TPlane3D<Real> plane42 = TPlane3D<Real>(ray2.origin, ray2.direction.cross(ray4.direction));
454 TPlane3D<Real> plane14 = TPlane3D<Real>(ray4.origin, ray1.direction.cross(ray4.direction));
455 TPlane3D<Real> plane32 = TPlane3D<Real>(ray3.origin, ray2.direction.cross(ray3.direction));
456
457 auto& initialEdgeSet = this->inInitialEdgeSet()->getData();
458 auto& edges = initialEdgeSet.getEdges();
459 auto& points = initialEdgeSet.getPoints();
460 DArray<int> intersected;
461 intersected.resize(edges.size());
462 cuExecute(edges.size(),
463 EI_EdgeInitializeArray,
464 intersected
465 );
466 DArray<int> unintersected;
467 unintersected.resize(edges.size());
468 this->tempNumT = edges.size();
469 cuExecute(edges.size(),
470 EI_CalIntersectedEdgesBox,
471 points,
472 edges,
473 intersected,
474 unintersected,
475 plane13,
476 plane42,
477 plane14,
478 plane32,
479 this->varInteractionRadius()->getData(),
480 this->ray1
481 );
482
483 this->tempEdgeIntersectedIndex.assign(intersected);
484
485 if (this->varToggleMultiSelect()->getData())
486 {
487 if (this->edgeIntersectedIndex.size() == 0)
488 {
489 this->edgeIntersectedIndex.resize(edges.size());
490 cuExecute(edges.size(),
491 EI_EdgeInitializeArray,
492 this->edgeIntersectedIndex
493 )
494 }
495 DArray<int> outIntersected;
496 outIntersected.resize(intersected.size());
497 DArray<int> outUnintersected;
498 outUnintersected.resize(unintersected.size());
499 if (this->varMultiSelectionType()->getValue() == MultiSelectionType::OR)
500 {
501 cuExecute(edges.size(),
502 EI_EdgeMergeIntersectedIndexOR,
503 this->edgeIntersectedIndex,
504 intersected,
505 outIntersected,
506 outUnintersected
507 );
508 }
509 else if (this->varMultiSelectionType()->getValue() == MultiSelectionType::XOR)
510 {
511 cuExecute(edges.size(),
512 EI_EdgeMergeIntersectedIndexXOR,
513 this->edgeIntersectedIndex,
514 intersected,
515 outIntersected,
516 outUnintersected
517 );
518 }
519 else if (this->varMultiSelectionType()->getValue() == MultiSelectionType::C)
520 {
521 cuExecute(edges.size(),
522 EI_EdgeMergeIntersectedIndexC,
523 this->edgeIntersectedIndex,
524 intersected,
525 outIntersected,
526 outUnintersected
527 );
528 }
529 intersected.assign(outIntersected);
530 unintersected.assign(outUnintersected);
531 }
532 else
533 {
534 this->edgeIntersectedIndex.assign(intersected);
535 }
536
537 DArray<int> intersected_o;
538 intersected_o.assign(intersected);
539
540 int intersected_size = thrust::reduce(thrust::device, intersected.begin(), intersected.begin() + intersected.size(), (int)0, thrust::plus<int>());
541 DArray<int> outEdgeIndex;
542 outEdgeIndex.resize(intersected_size);
543 thrust::exclusive_scan(thrust::device, intersected.begin(), intersected.begin() + intersected.size(), intersected.begin());
544 DArray<Edge> intersected_edges;
545 intersected_edges.resize(intersected_size);
546
547 int unintersected_size = thrust::reduce(thrust::device, unintersected.begin(), unintersected.begin() + unintersected.size(), (int)0, thrust::plus<int>());
548 thrust::exclusive_scan(thrust::device, unintersected.begin(), unintersected.begin() + unintersected.size(), unintersected.begin());
549 DArray<Edge> unintersected_edges;
550 unintersected_edges.resize(unintersected_size);
551
552 cuExecute(edges.size(),
553 EI_AssignOutEdges,
554 edges,
555 intersected_edges,
556 unintersected_edges,
557 outEdgeIndex,
558 intersected,
559 unintersected,
560 intersected_o
561 );
562 this->tempNumS = intersected_size;
563 this->outSelectedEdgeSet()->getDataPtr()->copyFrom(initialEdgeSet);
564 this->outSelectedEdgeSet()->getDataPtr()->setEdges(intersected_edges);
565 this->outOtherEdgeSet()->getDataPtr()->copyFrom(initialEdgeSet);
566 this->outOtherEdgeSet()->getDataPtr()->setEdges(unintersected_edges);
567 if (this->varToggleIndexOutput()->getValue())
568 {
569 this->outEdgeIndex()->getDataPtr()->assign(outEdgeIndex);
570 }
571 else
572 {
573 this->outEdgeIndex()->getDataPtr()->assign(intersected_o);
574 }
575 }
576
577 template<typename TDataType>
578 void EdgeInteraction<TDataType>::mergeIndex()
579 {
580 auto& initialEdgeSet = this->inInitialEdgeSet()->getData();
581 auto& edges = initialEdgeSet.getEdges();
582 auto& points = initialEdgeSet.getPoints();
583 DArray<int> intersected;
584 intersected.resize(edges.size());
585 cuExecute(edges.size(),
586 EI_EdgeInitializeArray,
587 intersected
588 );
589 DArray<int> unintersected;
590 unintersected.resize(edges.size());
591 this->tempNumT = edges.size();
592
593 DArray<int> outIntersected;
594 outIntersected.resize(intersected.size());
595 DArray<int> outUnintersected;
596 outUnintersected.resize(unintersected.size());
597
598 if (this->varMultiSelectionType()->getValue() == MultiSelectionType::OR)
599 {
600 cuExecute(edges.size(),
601 EI_EdgeMergeIntersectedIndexOR,
602 this->edgeIntersectedIndex,
603 this->tempEdgeIntersectedIndex,
604 outIntersected,
605 outUnintersected
606 );
607 }
608 else if (this->varMultiSelectionType()->getValue() == MultiSelectionType::XOR)
609 {
610 cuExecute(edges.size(),
611 EI_EdgeMergeIntersectedIndexXOR,
612 this->edgeIntersectedIndex,
613 this->tempEdgeIntersectedIndex,
614 outIntersected,
615 outUnintersected
616 );
617 }
618 else if (this->varMultiSelectionType()->getValue() == MultiSelectionType::C)
619 {
620 cuExecute(edges.size(),
621 EI_EdgeMergeIntersectedIndexC,
622 this->edgeIntersectedIndex,
623 this->tempEdgeIntersectedIndex,
624 outIntersected,
625 outUnintersected
626 );
627 }
628
629 intersected.assign(outIntersected);
630 unintersected.assign(outUnintersected);
631 this->edgeIntersectedIndex.assign(intersected);
632
633 DArray<int> intersected_o;
634 intersected_o.assign(intersected);
635
636 int intersected_size = thrust::reduce(thrust::device, intersected.begin(), intersected.begin() + intersected.size(), (int)0, thrust::plus<int>());
637 DArray<int> outEdgeIndex;
638 outEdgeIndex.resize(intersected_size);
639 thrust::exclusive_scan(thrust::device, intersected.begin(), intersected.begin() + intersected.size(), intersected.begin());
640 DArray<Edge> intersected_edges;
641 intersected_edges.resize(intersected_size);
642
643 int unintersected_size = thrust::reduce(thrust::device, unintersected.begin(), unintersected.begin() + unintersected.size(), (int)0, thrust::plus<int>());
644 thrust::exclusive_scan(thrust::device, unintersected.begin(), unintersected.begin() + unintersected.size(), unintersected.begin());
645 DArray<Edge> unintersected_edges;
646 unintersected_edges.resize(unintersected_size);
647
648 cuExecute(edges.size(),
649 EI_AssignOutEdges,
650 edges,
651 intersected_edges,
652 unintersected_edges,
653 outEdgeIndex,
654 intersected,
655 unintersected,
656 intersected_o
657 );
658 this->tempNumS = intersected_size;
659 this->outSelectedEdgeSet()->getDataPtr()->copyFrom(initialEdgeSet);
660 this->outSelectedEdgeSet()->getDataPtr()->setEdges(intersected_edges);
661 this->outOtherEdgeSet()->getDataPtr()->copyFrom(initialEdgeSet);
662 this->outOtherEdgeSet()->getDataPtr()->setEdges(unintersected_edges);
663 if (this->varToggleIndexOutput()->getData())
664 {
665 this->outEdgeIndex()->getDataPtr()->assign(outEdgeIndex);
666 }
667 else
668 {
669 this->outEdgeIndex()->getDataPtr()->assign(intersected_o);
670 }
671 }
672
673 template<typename TDataType>
674 void EdgeInteraction<TDataType>::printInfoClick()
675 {
676 std::cout << "----------edge picking: click----------" << std::endl;
677 std::cout << "multiple picking: " << this->varToggleMultiSelect()->getValue() << std::endl;
678 std::cout << "Interation radius:" << this->varInteractionRadius()->getValue() << std::endl;
679 std::cout << "selected num/ total num:" << this->tempNumS << "/" << this->tempNumT << std::endl;
680 }
681
682 template<typename TDataType>
683 void EdgeInteraction<TDataType>::printInfoDragging()
684 {
685 std::cout << "----------edge picking: dragging----------" << std::endl;
686 std::cout << "multiple picking: " << this->varToggleMultiSelect()->getValue() << std::endl;
687 std::cout << "Interation radius:" << this->varInteractionRadius()->getValue() << std::endl;
688 std::cout << "selected num/ total num:" << this->tempNumS << "/" << this->tempNumT << std::endl;
689 }
690
691 template<typename TDataType>
692 void EdgeInteraction<TDataType>::printInfoDragRelease()
693 {
694 std::cout << "----------edge picking: drag release----------" << std::endl;
695 std::cout << "multiple picking: " << this->varToggleMultiSelect()->getValue() << std::endl;
696 std::cout << "Interation radius:" << this->varInteractionRadius()->getValue() << std::endl;
697 std::cout << "selected num/ total num:" << this->tempNumS << "/" << this->tempNumT << std::endl;
698 }
699
700 template<typename TDataType>
701 void EdgeInteraction<TDataType>::calcIntersectClick()
702 {
703 if(this->varTogglePicker()->getData())
704 calcEdgeIntersectClick();
705 }
706
707 template<typename TDataType>
708 void EdgeInteraction<TDataType>::calcIntersectDrag()
709 {
710 if (this->varTogglePicker()->getData())
711 calcEdgeIntersectDrag();
712 }
713
714 DEFINE_CLASS(EdgeInteraction);
715}
Generated by doxygen 1.13.2