Blender  V3.3
ViewMap.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
8 #include <cfloat>
9 
10 #include "ViewMap.h"
12 #include "ViewMapIterators.h"
13 
14 #include "../geometry/GeomUtils.h"
15 
16 namespace Freestyle {
17 
18 /**********************************/
19 /* */
20 /* */
21 /* ViewMap */
22 /* */
23 /* */
24 /**********************************/
25 
26 ViewMap *ViewMap::_pInstance = nullptr;
27 
29 {
30  // The view vertices must be deleted here as some of them are shared between two shapes:
31  for (vector<ViewVertex *>::iterator vv = _VVertices.begin(), vvend = _VVertices.end();
32  vv != vvend;
33  vv++) {
34  delete (*vv);
35  }
36  _VVertices.clear();
37 
38  for (vector<ViewShape *>::iterator vs = _VShapes.begin(), vsend = _VShapes.end(); vs != vsend;
39  vs++) {
40  delete (*vs);
41  }
42  _VShapes.clear();
43 
44  _FEdges.clear();
45  _SVertices.clear();
46  _VEdges.clear();
47 }
48 
50 {
51  vector<FEdge *> tmpEdges;
52 
53  for (vector<ViewShape *>::iterator vs = _VShapes.begin(), vsend = _VShapes.end(); vs != vsend;
54  vs++) {
55  vector<FEdge *> &edges = (*vs)->sshape()->getEdgeList();
56  for (vector<FEdge *>::iterator it = edges.begin(), itend = edges.end(); it != itend; it++) {
57  if ((*it)->isTemporary()) {
58  (*it)->setTemporary(false); // avoid being counted multiple times
59  tmpEdges.push_back(*it);
60  }
61  }
62  }
63 
64  for (vector<FEdge *>::iterator it = tmpEdges.begin(), itend = tmpEdges.end(); it != itend;
65  it++) {
66  for (vector<ViewShape *>::iterator vs = _VShapes.begin(), vsend = _VShapes.end(); vs != vsend;
67  vs++) {
68  (*vs)->sshape()->RemoveEdge(*it);
69  }
70  (*it)->vertexA()->RemoveFEdge(*it);
71  (*it)->vertexB()->RemoveFEdge(*it);
72  delete (*it);
73  }
74 }
75 
77 {
78  int index = _shapeIdToIndex[id];
79  return _VShapes[index];
80 }
81 
83 {
84  _shapeIdToIndex[iVShape->getId().getFirst()] = _VShapes.size();
85  _VShapes.push_back(iVShape);
86 }
87 
89 {
90  // find the closest of this candidates:
91  real minDist = DBL_MAX;
92  FEdge *winner = nullptr;
93  for (fedges_container::const_iterator fe = _FEdges.begin(), feend = _FEdges.end(); fe != feend;
94  fe++) {
95  Vec2d A((*fe)->vertexA()->point2D()[0], (*fe)->vertexA()->point2D()[1]);
96  Vec2d B((*fe)->vertexB()->point2D()[0], (*fe)->vertexB()->point2D()[1]);
97  real dist = GeomUtils::distPointSegment<Vec2r>(Vec2r(x, y), A, B);
98  if (dist < minDist) {
99  minDist = dist;
100  winner = (*fe);
101  }
102  }
103 
104  return winner;
105 }
106 
108 {
109  // find the closest of this candidates:
110  real minDist = DBL_MAX;
111  FEdge *winner = nullptr;
112  for (fedges_container::const_iterator fe = _FEdges.begin(), feend = _FEdges.end(); fe != feend;
113  fe++) {
114  Vec2d A((*fe)->vertexA()->point2D()[0], (*fe)->vertexA()->point2D()[1]);
115  Vec2d B((*fe)->vertexB()->point2D()[0], (*fe)->vertexB()->point2D()[1]);
116  real dist = GeomUtils::distPointSegment<Vec2r>(Vec2r(x, y), A, B);
117  if (dist < minDist) {
118  minDist = dist;
119  winner = (*fe);
120  }
121  }
122  if (!winner) {
123  return nullptr;
124  }
125 
126  return winner->viewedge();
127 }
128 
130  const Vec3r &iA2D,
131  FEdge *iFEdgeA,
132  const Vec3r &iB3D,
133  const Vec3r &iB2D,
134  FEdge *iFEdgeB,
135  const Id &id)
136 {
137  ViewShape *vshapeA = iFEdgeA->viewedge()->viewShape();
138  SShape *shapeA = iFEdgeA->shape();
139  ViewShape *vshapeB = iFEdgeB->viewedge()->viewShape();
140  SShape *shapeB = iFEdgeB->shape();
141 
142  SVertex *Ia = shapeA->CreateSVertex(iA3D, iA2D, iFEdgeA->vertexA()->getId());
143  SVertex *Ib = shapeB->CreateSVertex(iB3D, iB2D, iFEdgeB->vertexA()->getId());
144 
145  // depending on which of these 2 svertices is the nearest from the viewpoint, we're going to
146  // build the TVertex by giving them in an order or another (the first one must be the nearest)
147  real dista = Ia->point2D()[2];
148  real distb = Ib->point2D()[2];
149 
150  TVertex *tvertex;
151  if (dista < distb) {
152  tvertex = new TVertex(Ia, Ib);
153  }
154  else {
155  tvertex = new TVertex(Ib, Ia);
156  }
157 
158  tvertex->setId(id);
159 
160  // add these vertices to the view map
161  AddViewVertex(tvertex);
162  AddSVertex(Ia);
163  AddSVertex(Ib);
164 
165  // and this T Vertex to the view shapes:
166  vshapeA->AddVertex(tvertex);
167  vshapeB->AddVertex(tvertex);
168 
169  return tvertex;
170 }
171 
172 ViewVertex *ViewMap::InsertViewVertex(SVertex *iVertex, vector<ViewEdge *> &newViewEdges)
173 {
174  NonTVertex *vva = dynamic_cast<NonTVertex *>(iVertex->viewvertex());
175  if (vva) {
176  return vva;
177  }
178  // because it is not already a ViewVertex, this SVertex must have only 2 FEdges. The incoming one
179  // still belongs to ioEdge, the outgoing one now belongs to newVEdge
180  const vector<FEdge *> &fedges = iVertex->fedges();
181  if (fedges.size() != 2) {
182  cerr << "ViewMap warning: Can't split the ViewEdge" << endl;
183  return nullptr;
184  }
185  FEdge *fend(nullptr), *fbegin(nullptr);
186  for (vector<FEdge *>::const_iterator fe = fedges.begin(), feend = fedges.end(); fe != feend;
187  ++fe) {
188  if ((*fe)->vertexB() == iVertex) {
189  fend = (*fe);
190  }
191  if ((*fe)->vertexA() == iVertex) {
192  fbegin = (*fe);
193  }
194  if ((fbegin != nullptr) && (fend != nullptr)) {
195  break;
196  }
197  }
198  ViewEdge *ioEdge = fbegin->viewedge();
199  ViewShape *vshape = ioEdge->viewShape();
200  vva = new NonTVertex(iVertex);
201  // if the ViewEdge is a closed loop, we don't create a new VEdge
202  if (ioEdge->A() == nullptr) {
203  // closed loop
204  ioEdge->setA(vva);
205  ioEdge->setB(vva);
206  // update sshape
207  vshape->sshape()->RemoveEdgeFromChain(ioEdge->fedgeA());
208  vshape->sshape()->RemoveEdgeFromChain(ioEdge->fedgeB());
209 
210  ioEdge->setFEdgeA(fbegin);
211  ioEdge->setFEdgeB(fend);
212 
213  // Update FEdges
214  fend->setNextEdge(nullptr);
215  fbegin->setPreviousEdge(nullptr);
216 
217  // update new View Vertex:
218  vva->AddOutgoingViewEdge(ioEdge);
219  vva->AddIncomingViewEdge(ioEdge);
220 
221  vshape->sshape()->AddChain(ioEdge->fedgeA());
222  vshape->sshape()->AddChain(ioEdge->fedgeB());
223  }
224  else {
225  // Create new ViewEdge
226  ViewEdge *newVEdge = new ViewEdge(vva, ioEdge->B(), fbegin, ioEdge->fedgeB(), vshape);
227  newVEdge->setId(Id(ioEdge->getId().getFirst(), ioEdge->getId().getSecond() + 1));
228  newVEdge->setNature(ioEdge->getNature());
229  // newVEdge->UpdateFEdges(); // done in the ViewEdge constructor
230  // Update old ViewEdge
231  ioEdge->setB(vva);
232  ioEdge->setFEdgeB(fend);
233 
234  // Update FEdges
235  fend->setNextEdge(nullptr);
236  fbegin->setPreviousEdge(nullptr);
237 
238  // update new View Vertex:
239  vva->AddOutgoingViewEdge(newVEdge);
240  vva->AddIncomingViewEdge(ioEdge);
241 
242  NonTVertex *vvb = dynamic_cast<NonTVertex *>(newVEdge->B());
243  if (vvb) {
244  vvb->Replace(ioEdge, newVEdge);
245  }
246 
247  // update ViewShape
248  // vshape->AddEdge(newVEdge);
249  // update SShape
250  vshape->sshape()->AddChain(fbegin);
251  // update ViewMap
252  //_VEdges.push_back(newVEdge);
253  newViewEdges.push_back(newVEdge);
254  }
255 
256  // update ViewShape
257  vshape->AddVertex(vva);
258 
259  // update ViewMap
260  _VVertices.push_back(vva);
261 
262  return vva;
263 }
264 
265 #if 0
266 FEdge *ViewMap::Connect(FEdge *ioEdge, SVertex *ioVertex, vector<ViewEdge *> &oNewVEdges)
267 {
268  SShape *sshape = ioEdge->shape();
269  FEdge *newFEdge = sshape->SplitEdgeIn2(ioEdge, ioVertex);
270  AddFEdge(newFEdge);
271  InsertViewVertex(ioVertex, oNewVEdges);
272  return newFEdge;
273 }
274 #endif
275 
276 /**********************************/
277 /* */
278 /* */
279 /* TVertex */
280 /* */
281 /* */
282 /**********************************/
283 
284 // is dve1 before dve2 ? (does it have a smaller angle ?)
286 {
287  FEdge *fe1;
288  if (dve1.second) {
289  fe1 = dve1.first->fedgeB();
290  }
291  else {
292  fe1 = dve1.first->fedgeA();
293  }
294  FEdge *fe2;
295  if (dve2.second) {
296  fe2 = dve2.first->fedgeB();
297  }
298  else {
299  fe2 = dve2.first->fedgeA();
300  }
301 
302  Vec3r V1 = fe1->orientation2d();
303  Vec2r v1(V1.x(), V1.y());
304  v1.normalize();
305  Vec3r V2 = fe2->orientation2d();
306  Vec2r v2(V2.x(), V2.y());
307  v2.normalize();
308  if (v1.y() > 0) {
309  if (v2.y() < 0) {
310  return true;
311  }
312 
313  return (v1.x() > v2.x());
314  }
315 
316  if (v2.y() > 0) {
317  return false;
318  }
319 
320  return (v1.x() < v2.x());
321 }
322 
323 void TVertex::setFrontEdgeA(ViewEdge *iFrontEdgeA, bool incoming)
324 {
325  if (!iFrontEdgeA) {
326  cerr << "Warning: null pointer passed as argument of TVertex::setFrontEdgeA()" << endl;
327  return;
328  }
329  _FrontEdgeA = directedViewEdge(iFrontEdgeA, incoming);
330  if (!_sortedEdges.empty()) {
331  edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
332  for (; (dve != dveend) && ViewEdgeComp(**dve, _FrontEdgeA); ++dve) {
333  /* pass */
334  }
335  _sortedEdges.insert(dve, &_FrontEdgeA);
336  }
337  else {
338  _sortedEdges.push_back(&_FrontEdgeA);
339  }
340 }
341 
342 void TVertex::setFrontEdgeB(ViewEdge *iFrontEdgeB, bool incoming)
343 {
344  if (!iFrontEdgeB) {
345  cerr << "Warning: null pointer passed as argument of TVertex::setFrontEdgeB()" << endl;
346  return;
347  }
348  _FrontEdgeB = directedViewEdge(iFrontEdgeB, incoming);
349  if (!_sortedEdges.empty()) {
350  edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
351  for (; (dve != dveend) && ViewEdgeComp(**dve, _FrontEdgeB); ++dve) {
352  /* pass */
353  }
354  _sortedEdges.insert(dve, &_FrontEdgeB);
355  }
356  else {
357  _sortedEdges.push_back(&_FrontEdgeB);
358  }
359 }
360 
361 void TVertex::setBackEdgeA(ViewEdge *iBackEdgeA, bool incoming)
362 {
363  if (!iBackEdgeA) {
364  cerr << "Warning: null pointer passed as argument of TVertex::setBackEdgeA()" << endl;
365  return;
366  }
367  _BackEdgeA = directedViewEdge(iBackEdgeA, incoming);
368  if (!_sortedEdges.empty()) {
369  edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
370  for (; (dve != dveend) && ViewEdgeComp(**dve, _BackEdgeA); ++dve) {
371  /* pass */
372  }
373  _sortedEdges.insert(dve, &_BackEdgeA);
374  }
375  else {
376  _sortedEdges.push_back(&_BackEdgeA);
377  }
378 }
379 
380 void TVertex::setBackEdgeB(ViewEdge *iBackEdgeB, bool incoming)
381 {
382  if (!iBackEdgeB) {
383  cerr << "Warning: null pointer passed as argument of TVertex::setBackEdgeB()" << endl;
384  return;
385  }
386  _BackEdgeB = directedViewEdge(iBackEdgeB, incoming);
387  if (!_sortedEdges.empty()) {
388  edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
389  for (; (dve != dveend) && ViewEdgeComp(**dve, _BackEdgeB); ++dve) {
390  /* pass */
391  }
392  _sortedEdges.insert(dve, &_BackEdgeB);
393  }
394  else {
395  _sortedEdges.push_back(&_BackEdgeB);
396  }
397 }
398 
400 {
401  // theoritically, we only replace edges for which this
402  // view vertex is the B vertex
403  if ((iOld == _FrontEdgeA.first) && (_FrontEdgeA.first->B() == this)) {
404  _FrontEdgeA.first = iNew;
405  return;
406  }
407  if ((iOld == _FrontEdgeB.first) && (_FrontEdgeB.first->B() == this)) {
408  _FrontEdgeB.first = iNew;
409  return;
410  }
411  if ((iOld == _BackEdgeA.first) && (_BackEdgeA.first->B() == this)) {
412  _BackEdgeA.first = iNew;
413  return;
414  }
415  if ((iOld == _BackEdgeB.first) && (_BackEdgeB.first->B() == this)) {
416  _BackEdgeB.first = iNew;
417  return;
418  }
419 }
420 
423 {
424  // return edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, _FrontEdgeA);
425  return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
426 }
427 
429 {
430  // return const_edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, _FrontEdgeA);
431  return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
432 }
433 
435 {
436  // return edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB,
437  // directedViewEdge(0,true));
438  return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.end());
439 }
440 
442 {
443  // return const_edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB,
444  // directedViewEdge(0, true));
445  return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.end());
446 }
447 
449 {
450  for (edge_pointers_container::iterator it = _sortedEdges.begin(), itend = _sortedEdges.end();
451  it != itend;
452  it++) {
453  if ((*it)->first == iEdge) {
454  return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), it);
455  }
456  }
457  return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
458 
459 #if 0
460  directedViewEdge dEdge;
461  if (_FrontEdgeA.first == iEdge) {
462  dEdge = _FrontEdgeA;
463  }
464  else if (_FrontEdgeB.first == iEdge) {
465  dEdge = _FrontEdgeB;
466  }
467  else if (_BackEdgeA.first == iEdge) {
468  dEdge = _BackEdgeA;
469  }
470  else if (_BackEdgeB.first == iEdge) {
471  dEdge = _BackEdgeB;
472  }
473  return edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, dEdge);
474 #endif
475 }
476 
478 {
479  for (edge_pointers_container::const_iterator it = _sortedEdges.begin(),
480  itend = _sortedEdges.end();
481  it != itend;
482  it++) {
483  if ((*it)->first == iEdge) {
484  return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), it);
485  }
486  }
487  return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
488 
489 #if 0
490  directedViewEdge dEdge;
491  if (_FrontEdgeA.first == iEdge) {
492  dEdge = _FrontEdgeA;
493  }
494  else if (_FrontEdgeB.first == iEdge) {
495  dEdge = _FrontEdgeB;
496  }
497  else if (_BackEdgeA.first == iEdge) {
498  dEdge = _BackEdgeA;
499  }
500  else if (_BackEdgeB.first == iEdge) {
501  dEdge = _BackEdgeB;
502  }
503  return const_edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, dEdge);
504 #endif
505 }
506 
508 {
510  _sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
511 }
512 
514 {
516  _sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.end());
517 }
518 
520 {
521  for (edge_pointers_container::iterator it = _sortedEdges.begin(), itend = _sortedEdges.end();
522  it != itend;
523  it++) {
524  if ((*it)->first == iEdge) {
526  _sortedEdges.begin(), _sortedEdges.end(), it);
527  }
528  }
530  _sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
531 }
532 
533 /**********************************/
534 /* */
535 /* */
536 /* NonTVertex */
537 /* */
538 /* */
539 /**********************************/
540 
542 {
543  // let's keep the viewedges ordered in CCW order in the 2D image plan
544  directedViewEdge idve(iVEdge, false);
545  if (!_ViewEdges.empty()) {
546  edges_container::iterator dve = _ViewEdges.begin(), dveend = _ViewEdges.end();
547  for (; (dve != dveend) && ViewEdgeComp(*dve, idve); ++dve) {
548  /* pass */
549  }
550  _ViewEdges.insert(dve, idve);
551  }
552  else {
553  _ViewEdges.push_back(idve);
554  }
555 }
556 
558 {
559  // let's keep the viewedges ordered in CCW order in the 2D image plan
560  directedViewEdge idve(iVEdge, true);
561  if (!_ViewEdges.empty()) {
562  edges_container::iterator dve = _ViewEdges.begin(), dveend = _ViewEdges.end();
563  for (; (dve != dveend) && ViewEdgeComp(*dve, idve); ++dve) {
564  /* pass */
565  }
566  _ViewEdges.insert(dve, idve);
567  }
568  else {
569  _ViewEdges.push_back(idve);
570  }
571 }
572 
575 {
576  return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
577 }
578 
580 {
581  return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
582 }
583 
585 {
586  return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.end());
587 }
588 
590 {
591  return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.end());
592 }
593 
595 {
596  for (edges_container::iterator it = _ViewEdges.begin(), itend = _ViewEdges.end(); it != itend;
597  it++) {
598  if ((it)->first == iEdge) {
599  return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), it);
600  }
601  }
602  return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
603 }
604 
606 {
607  for (edges_container::const_iterator it = _ViewEdges.begin(), itend = _ViewEdges.end();
608  it != itend;
609  it++) {
610  if ((it)->first == iEdge) {
611  return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), it);
612  }
613  }
614  return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
615 }
616 
618 {
620  _ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
621 }
622 
624 {
626  _ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.end());
627 }
628 
630 {
631  for (edges_container::iterator it = _ViewEdges.begin(), itend = _ViewEdges.end(); it != itend;
632  it++) {
633  if ((it)->first == iEdge) {
635  _ViewEdges.begin(), _ViewEdges.end(), it);
636  }
637  }
639  _ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
640 }
641 
642 /**********************************/
643 /* */
644 /* */
645 /* ViewEdge */
646 /* */
647 /* */
648 /**********************************/
649 
651 {
652  float length = 0.0f;
655  Vec2r seg;
656  do {
657  seg = Vec2r((*it)->orientation2d()[0], (*it)->orientation2d()[1]);
658  length += seg.norm();
659  ++it;
660  } while ((it != itend) && (it != itlast));
661  return length;
662 }
663 
666 {
667  return edge_iterator(this);
668 }
669 
671 {
672  return const_edge_iterator((ViewEdge *)this);
673 }
674 
677 {
678  return fedge_iterator(this->_FEdgeA, this->_FEdgeB);
679 }
680 
682 {
683  return const_fedge_iterator(this->_FEdgeA, this->_FEdgeB);
684 }
685 
687 {
688  return fedge_iterator(this->_FEdgeB, this->_FEdgeB);
689 }
690 
692 {
693  return const_fedge_iterator(this->_FEdgeB, this->_FEdgeB);
694 }
695 
697 {
698  return fedge_iterator(nullptr, this->_FEdgeB);
699 }
700 
702 {
703  return const_fedge_iterator(nullptr, this->_FEdgeB);
704 }
705 
708 {
709  return const_vertex_iterator(this->_FEdgeA->vertexA(), nullptr, _FEdgeA);
710 }
711 
713 {
714  return vertex_iterator(this->_FEdgeA->vertexA(), nullptr, _FEdgeA);
715 }
716 
718 {
719  return const_vertex_iterator(this->_FEdgeB->vertexB(), _FEdgeB, nullptr);
720 }
721 
723 {
724  return vertex_iterator(this->_FEdgeB->vertexB(), _FEdgeB, nullptr);
725 }
726 
728 {
729  return const_vertex_iterator(nullptr, _FEdgeB, nullptr);
730 }
731 
733 {
734  return vertex_iterator(nullptr, _FEdgeB, nullptr);
735 }
736 
738 {
740  this->_FEdgeA->vertexA(), this->_FEdgeA->vertexA(), nullptr, _FEdgeA, 0.0f));
741  return ret;
742 }
743 
745 {
747  nullptr, this->_FEdgeA->vertexA(), _FEdgeB, nullptr, getLength2D()));
748  return ret;
749 }
750 
752 {
753  return verticesBegin();
754 }
755 
757 {
758  return verticesEnd();
759 }
760 
761 /**********************************/
762 /* */
763 /* */
764 /* ViewShape */
765 /* */
766 /* */
767 /**********************************/
768 
770 {
771  _Vertices.clear();
772 
773  if (!(_Edges.empty())) {
774  for (vector<ViewEdge *>::iterator e = _Edges.begin(), eend = _Edges.end(); e != eend; e++) {
775  delete (*e);
776  }
777  _Edges.clear();
778  }
779 
780  if (_SShape) {
781  delete _SShape;
782  _SShape = nullptr;
783  }
784 }
785 
787 {
788  FEdge *fedge = iViewEdge->fedgeA();
789  for (vector<ViewEdge *>::iterator ve = _Edges.begin(), veend = _Edges.end(); ve != veend; ve++) {
790  if (iViewEdge == (*ve)) {
791  _Edges.erase(ve);
792  _SShape->RemoveEdge(fedge);
793  break;
794  }
795  }
796 }
797 
799 {
800  for (vector<ViewVertex *>::iterator vv = _Vertices.begin(), vvend = _Vertices.end(); vv != vvend;
801  vv++) {
802  if (iViewVertex == (*vv)) {
803  _Vertices.erase(vv);
804  break;
805  }
806  }
807 }
808 
809 /**********************************/
810 /* */
811 /* */
812 /* ViewEdge */
813 /* */
814 /* */
815 /**********************************/
816 
818 {
819  FEdge *currentEdge = _FEdgeA;
820  do {
821  currentEdge->setViewEdge(this);
822  currentEdge = currentEdge->nextEdge();
823  } while (!ELEM(currentEdge, NULL, _FEdgeB));
824  // last one
825  _FEdgeB->setViewEdge(this);
826 }
827 
828 } /* namespace Freestyle */
#define ELEM(...)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint y
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble v1
Iterators used to iterate over the various elements of the ViewMap. These iterators can't be exported...
Iterators used to iterate over the various elements of the ViewMap.
Classes to define a View Map (ViewVertex, ViewEdge, etc.)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
#define A
SVertex * vertexA()
Definition: Silhouette.h:597
ViewEdge * viewedge() const
Definition: Silhouette.h:658
Vec3r orientation2d() const
Definition: Silhouette.h:912
void setViewEdge(ViewEdge *iViewEdge)
Definition: Silhouette.h:766
SVertex * vertexB()
Definition: Silhouette.h:603
SShape * shape()
Definition: Silhouette.h:636
void setPreviousEdge(FEdge *iEdge)
Definition: Silhouette.h:747
FEdge * nextEdge()
Definition: Silhouette.h:623
id_type getFirst() const
Definition: Id.h:62
id_type getSecond() const
Definition: Id.h:68
virtual void Replace(ViewEdge *iOld, ViewEdge *iNew)
Definition: ViewMap.h:825
void AddIncomingViewEdge(ViewEdge *iVEdge)
Definition: ViewMap.cpp:557
virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin()
Definition: ViewMap.cpp:617
virtual edge_iterator edges_iterator(ViewEdge *iEdge)
Definition: ViewMap.cpp:594
virtual edge_iterator edges_begin()
Definition: ViewMap.cpp:574
void AddOutgoingViewEdge(ViewEdge *iVEdge)
Definition: ViewMap.cpp:541
virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd()
Definition: ViewMap.cpp:623
virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge)
Definition: ViewMap.cpp:629
virtual edge_iterator edges_end()
Definition: ViewMap.cpp:584
void RemoveEdgeFromChain(FEdge *iEdge)
Definition: Silhouette.h:1819
SVertex * CreateSVertex(const Vec3r &P3D, const Vec3r &P2D, const Id &id)
Definition: Silhouette.h:1570
void AddChain(FEdge *iEdge)
Definition: Silhouette.h:1565
FEdge * SplitEdgeIn2(FEdge *ioEdge, SVertex *ioNewVertex)
Definition: Silhouette.h:1695
void RemoveEdge(FEdge *iEdge)
Definition: Silhouette.h:1830
const vector< FEdge * > & fedges()
Definition: Silhouette.h:248
ViewVertex * viewvertex()
Definition: Silhouette.h:276
virtual Id getId() const
Definition: Silhouette.h:117
const Vec3r & point2D() const
Definition: Silhouette.h:228
void setId(const Id &iId)
Definition: ViewMap.h:574
void setBackEdgeA(ViewEdge *iBackEdgeA, bool incoming=true)
Definition: ViewMap.cpp:361
virtual edge_iterator edges_iterator(ViewEdge *iEdge)
Definition: ViewMap.cpp:448
virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge)
Definition: ViewMap.cpp:519
virtual edge_iterator edges_begin()
Definition: ViewMap.cpp:422
void setBackEdgeB(ViewEdge *iBackEdgeB, bool incoming=true)
Definition: ViewMap.cpp:380
virtual edge_iterator edges_end()
Definition: ViewMap.cpp:434
void setFrontEdgeB(ViewEdge *iFrontEdgeB, bool incoming=true)
Definition: ViewMap.cpp:342
virtual void Replace(ViewEdge *iOld, ViewEdge *iNew)
Definition: ViewMap.cpp:399
void setFrontEdgeA(ViewEdge *iFrontEdgeA, bool incoming=true)
Definition: ViewMap.cpp:323
virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin()
Definition: ViewMap.cpp:507
virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd()
Definition: ViewMap.cpp:513
value_type x() const
Definition: VecMat.h:518
value_type y() const
Definition: VecMat.h:528
value_type norm() const
Definition: VecMat.h:95
const_vertex_iterator vertices_end() const
Definition: ViewMap.cpp:727
ViewShape * viewShape()
Definition: ViewMap.h:1091
FEdge * fedgeB()
Definition: ViewMap.h:1085
void setId(const Id &id)
Definition: ViewMap.h:1182
virtual Nature::EdgeNature getNature() const
Definition: ViewMap.h:914
FEdge * fedgeA()
Definition: ViewMap.h:1079
ViewVertex * B()
Definition: ViewMap.h:1073
void setFEdgeB(FEdge *iFEdge)
Definition: ViewMap.h:1170
fedge_iterator fedge_iterator_last()
Definition: ViewMap.cpp:686
fedge_iterator fedge_iterator_end()
Definition: ViewMap.cpp:696
ViewEdgeInternal::edge_iterator_base< Const_traits< ViewEdge * > > const_edge_iterator
Definition: ViewMap.h:924
void setA(ViewVertex *iA)
Definition: ViewMap.h:1146
virtual Id getId() const
Definition: ViewMap.h:908
edge_iterator ViewEdge_iterator()
view edge iterator
Definition: ViewMap.cpp:665
ViewEdgeInternal::fedge_iterator_base< Const_traits< FEdge * > > const_fedge_iterator
Definition: ViewMap.h:927
void setFEdgeA(FEdge *iFEdge)
Definition: ViewMap.h:1164
const_vertex_iterator vertices_last() const
Definition: ViewMap.cpp:717
virtual Interface0DIterator pointsBegin(float t=0.0f)
Definition: ViewMap.cpp:751
ViewVertex * A()
Definition: ViewMap.h:1067
ViewEdgeInternal::vertex_iterator_base< Nonconst_traits< SVertex * > > vertex_iterator
Definition: ViewMap.h:929
virtual Interface0DIterator pointsEnd(float t=0.0f)
Definition: ViewMap.cpp:756
ViewEdgeInternal::edge_iterator_base< Nonconst_traits< ViewEdge * > > edge_iterator
Definition: ViewMap.h:923
const_vertex_iterator vertices_begin() const
embedding vertex iterator
Definition: ViewMap.cpp:707
fedge_iterator fedge_iterator_begin()
feature edge iterator
Definition: ViewMap.cpp:676
real getLength2D() const
Definition: ViewMap.cpp:650
virtual Interface0DIterator verticesBegin()
Definition: ViewMap.cpp:737
ViewEdgeInternal::vertex_iterator_base< Const_traits< SVertex * > > const_vertex_iterator
Definition: ViewMap.h:930
virtual Interface0DIterator verticesEnd()
Definition: ViewMap.cpp:744
void setNature(Nature::EdgeNature iNature)
Definition: ViewMap.h:1158
ViewEdgeInternal::fedge_iterator_base< Nonconst_traits< FEdge * > > fedge_iterator
Definition: ViewMap.h:926
void setB(ViewVertex *iB)
Definition: ViewMap.h:1152
ViewShape * viewShape(unsigned id)
Definition: ViewMap.cpp:76
const FEdge * getClosestFEdge(real x, real y) const
Definition: ViewMap.cpp:88
void AddViewShape(ViewShape *iVShape)
Definition: ViewMap.cpp:82
const ViewEdge * getClosestViewEdge(real x, real y) const
Definition: ViewMap.cpp:107
void AddSVertex(SVertex *iSVertex)
Definition: ViewMap.h:173
virtual void Clean()
Definition: ViewMap.cpp:49
TVertex * CreateTVertex(const Vec3r &iA3D, const Vec3r &iA2D, FEdge *iFEdgeA, const Vec3r &iB3D, const Vec3r &iB2D, FEdge *iFEdgeB, const Id &id)
Definition: ViewMap.cpp:129
void AddFEdge(FEdge *iFEdge)
Definition: ViewMap.h:168
virtual ~ViewMap()
Definition: ViewMap.cpp:28
ViewVertex * InsertViewVertex(SVertex *iVertex, vector< ViewEdge * > &newViewEdges)
Definition: ViewMap.cpp:172
void AddViewVertex(ViewVertex *iVVertex)
Definition: ViewMap.h:163
SShape * sshape()
Definition: ViewMap.h:1539
void AddVertex(ViewVertex *iVertex)
Definition: ViewMap.h:1600
void RemoveVertex(ViewVertex *iViewVertex)
Definition: ViewMap.cpp:798
void RemoveEdge(ViewEdge *iViewEdge)
Definition: ViewMap.cpp:786
Id getId() const
Definition: ViewMap.h:1563
virtual ~ViewShape()
Definition: ViewMap.cpp:769
ViewVertexInternal::edge_iterator_base< ViewVertexInternal::edge_const_traits > const_edge_iterator
Definition: ViewMap.h:273
pair< ViewEdge *, bool > directedViewEdge
Definition: ViewMap.h:266
ViewVertexInternal::edge_iterator_base< ViewVertexInternal::edge_nonconst_traits > edge_iterator
Definition: ViewMap.h:271
#define B
VecMat::Vec2< real > Vec2r
Definition: Geom.h:22
inherits from class Rep
Definition: AppCanvas.cpp:18
static bool ViewEdgeComp(ViewVertex::directedViewEdge &dve1, ViewVertex::directedViewEdge &dve2)
Definition: ViewMap.cpp:285
static unsigned x[3]
Definition: RandGen.cpp:73
double real
Definition: Precision.h:12
T length(const vec_base< T, Size > &a)
return ret