1 #include <U2Core/disable-warnings.h> 2 U2_DISABLE_WARNINGS 3 4 // -*- Mode: C++; tab-width: 2; -*- 5 // vi: set ts=2: 6 // 7 8 #include <BALL/STRUCTURE/triangulatedSurface.h> 9 10 #include <iterator> 11 #include <map> 12 13 namespace BALL 14 { TriangulatedSurface()15 TriangulatedSurface::TriangulatedSurface() 16 : number_of_points_(0), 17 points_(), 18 number_of_edges_(0), 19 edges_(), 20 number_of_triangles_(0), 21 triangles_() 22 { 23 } 24 25 TriangulatedSurface(const TriangulatedSurface & surface,bool)26 TriangulatedSurface::TriangulatedSurface(const TriangulatedSurface& surface, bool) 27 : number_of_points_(0), 28 points_(), 29 number_of_edges_(0), 30 edges_(), 31 number_of_triangles_(0), 32 triangles_() 33 { 34 copy(surface); 35 } 36 37 ~TriangulatedSurface()38 TriangulatedSurface::~TriangulatedSurface() 39 { 40 clear(); 41 } 42 createTube(unsigned int num_vertices,unsigned int subdiv,bool closed,bool out)43 TriangulatedSurface* TriangulatedSurface::createTube(unsigned int num_vertices, unsigned int subdiv, bool closed, bool out) 44 { 45 TriangulatedSurface* result = new TriangulatedSurface(); 46 47 //Compute the number of elements 48 result->number_of_points_ = num_vertices * (subdiv + 2); 49 result->number_of_edges_ = num_vertices * (3 * subdiv + 4); 50 result->number_of_triangles_ = 2 * num_vertices * (subdiv + 1); 51 52 //Allocate temporary storage for the elements 53 std::vector<TrianglePoint*> points(result->number_of_points_); 54 std::vector<TriangleEdge*> edges(result->number_of_edges_); 55 std::vector<Triangle*> triangles(result->number_of_triangles_); 56 57 //If the disk is closed there are more elements. 58 //However we need no temporary storage for them 59 result->number_of_points_ += closed ? 2 : 0; 60 result->number_of_edges_ += closed ? 2*num_vertices : 0; 61 result->number_of_triangles_ += closed ? num_vertices : 0; 62 63 const double angle = 2*M_PI/num_vertices; 64 const double spacing = 1./(subdiv + 1); 65 66 //First create all vertices 67 for(unsigned int i = 0; i < num_vertices; ++i) { 68 for(unsigned int j = 0; j < subdiv + 2; ++j) { 69 TVector3<double> coords(cos(i*angle), sin(i*angle), j*spacing); 70 TVector3<double> normal(cos(i*angle), sin(i*angle), 0); 71 points[i + j*num_vertices] = new TrianglePoint(coords, out ? normal : -normal); 72 } 73 } 74 75 //Create all edges and all triangles "pointing" upwards. 76 for(unsigned int j = 0; j < subdiv + 1; ++j) { 77 for(unsigned int i = 0; i < num_vertices - 1; ++i) { 78 TriangleEdge* e1 = new TriangleEdge(points[num_vertices * j + i], points[num_vertices * j + i + 1]); 79 TriangleEdge* e2 = new TriangleEdge(points[num_vertices * j + i + 1], points[num_vertices * (j + 1) + i + 1]); 80 TriangleEdge* e3 = new TriangleEdge(points[num_vertices * (j + 1) + i + 1], points[num_vertices * j + i]); 81 //Store the horizontal edges 82 edges[num_vertices * j + i] = e1; 83 //Store the vertical edges 84 edges[( subdiv+2 + j) * num_vertices + i] = e2; 85 //Store the diagonal edges 86 edges[(2*subdiv+3 + j) * num_vertices + i] = e3; 87 88 Triangle* t = new Triangle(e1, e2, e3, out); 89 90 triangles[2*num_vertices*j + 2*i] = t; 91 } 92 93 //Special case dealing with the ring closing 94 TriangleEdge* e1 = new TriangleEdge(points[num_vertices * j + num_vertices - 1], points[num_vertices * j ]); 95 TriangleEdge* e2 = new TriangleEdge(points[num_vertices * j], points[num_vertices * (j + 1) ]); 96 TriangleEdge* e3 = new TriangleEdge(points[num_vertices * (j + 1)], points[num_vertices * j + num_vertices - 1]); 97 edges[num_vertices * j + num_vertices - 1] = e1; 98 edges[( subdiv+2 + j) * num_vertices + num_vertices - 1] = e2; 99 edges[(2*subdiv+3 + j) * num_vertices + num_vertices - 1] = e3; 100 101 Triangle* t = new Triangle(e1, e2, e3, out); 102 e1->face_[0] = e2->face_[0] = e3->face_[0] = t; 103 104 triangles[2*num_vertices*j + 2*(num_vertices - 1)] = t; 105 } 106 107 //Create the topmost horizontal edges 108 for(unsigned int i = 0; i < num_vertices - 1; ++i) { 109 edges[num_vertices * (subdiv + 1) + i] = new TriangleEdge(points[num_vertices * (subdiv+1) + i], points[num_vertices * (subdiv+1) + i +1]); 110 } 111 112 //Again ring closing code 113 edges[num_vertices * (subdiv + 1) + num_vertices - 1] = new TriangleEdge(points[num_vertices * (subdiv+1) + num_vertices - 1], 114 points[num_vertices * (subdiv+1)]); 115 116 //Create all triangles pointing downward 117 //This special case is needed to set the edges faces appropriately 118 for(int i = num_vertices - 1; i >= 0; --i) { 119 TriangleEdge* e1 = edges[num_vertices * (subdiv + 1) + i]; 120 TriangleEdge* e2 = edges[(2*subdiv + 3 + subdiv) * num_vertices + i]; 121 TriangleEdge* e3 = edges[( subdiv + 2 + subdiv) * num_vertices + i]; 122 123 Triangle* t = new Triangle(e1, e2, e3, !out); 124 125 e1->face_[0] = e2->face_[0] = e3->face_[0] = t; 126 127 triangles[2*num_vertices*subdiv + 2*i + 1] = t; 128 } 129 130 for(unsigned int j = subdiv; j > 0; --j) { 131 for(int i = num_vertices - 1; i >= 0; --i) { 132 TriangleEdge* e1 = edges[num_vertices * j + i]; 133 TriangleEdge* e2 = edges[(2*subdiv + 3 + j - 1) * num_vertices + i]; 134 TriangleEdge* e3 = edges[( subdiv + 2 + j - 1) * num_vertices + i]; 135 136 Triangle* t = new Triangle(e1, e2, e3, !out); 137 138 e1->face_[1] = e2->face_[1] = e3->face_[1] = t; 139 140 triangles[2*num_vertices*(j-1) + 2*i + 1] = t; 141 } 142 } 143 144 std::copy(triangles.begin(), triangles.end(), std::back_inserter(result->triangles_)); 145 146 //Build the two endcaps if necessary 147 if(closed) { 148 TrianglePoint* p1 = new TrianglePoint(TVector3<double>(0, 0, 0), out ? TVector3<double>(0,0,-1) : TVector3<double>(0,0,1)); 149 TrianglePoint* p2 = new TrianglePoint(TVector3<double>(0, 0, 1), out ? TVector3<double>(0,0,1) : TVector3<double>(0,0,-1)); 150 result->points_.push_back(p1); 151 result->points_.push_back(p2); 152 153 //Remember 154 TriangleEdge* e_old1 = new TriangleEdge(p1, points[0]); 155 TriangleEdge* e1 = e_old1; 156 result->edges_.push_back(e1); 157 158 TriangleEdge* e_old2 = new TriangleEdge(p2, points[num_vertices * (subdiv + 1)]); 159 TriangleEdge* e2 = e_old2; 160 result->edges_.push_back(e2); 161 for(unsigned int i = 1; i < num_vertices; ++i) { 162 TriangleEdge* e_new1 = new TriangleEdge(p1, points[i]); 163 result->edges_.push_back(e_new1); 164 165 TriangleEdge* e_top1 = edges[i - 1]; 166 Triangle* t = new Triangle(e_old1, e_top1, e_new1, !out); 167 e_old1->face_[1] = e_top1->face_[1] = e_new1->face_[0] = t; 168 //The triangles belonging to the lower cap should go to the front 169 result->triangles_.push_front(t); 170 171 TriangleEdge* e_new2 = new TriangleEdge(p2, points[num_vertices * (subdiv + 1) + i]); 172 result->edges_.push_back(e_new2); 173 174 TriangleEdge* e_top2 = edges[(subdiv + 1)*num_vertices + i - 1]; 175 t = new Triangle(e_old2, e_top2, e_new2, out); 176 e_old2->face_[1] = e_top2->face_[1] = e_new2->face_[0] = t; 177 //The triangles belonging to the lower cap should go to the back 178 result->triangles_.push_back(t); 179 180 e_old1 = e_new1; 181 e_old2 = e_new2; 182 } 183 184 //Ring closing code 185 TriangleEdge* e_top1 = edges[ num_vertices - 1]; 186 TriangleEdge* e_top2 = edges[(subdiv + 2)*num_vertices - 1]; 187 188 Triangle* t = new Triangle(e_old1, e_top1, e1, !out); 189 e_old1->face_[1] = e_top1->face_[1] = e1->face_[0] = t; 190 result->triangles_.push_front(t); 191 192 t = new Triangle(e_old2, e_top2, e2, out); 193 e_old2->face_[1] = e_top2->face_[1] = e2->face_[0] = t; 194 result->triangles_.push_back(t); 195 } 196 197 std::copy(points.begin(), points.end(), std::back_inserter(result->points_)); 198 std::copy(edges.begin(), edges.end(), std::back_inserter(result->edges_)); 199 200 return result; 201 } 202 createDisk(unsigned int num_vertices,bool out)203 TriangulatedSurface* TriangulatedSurface::createDisk(unsigned int num_vertices, bool out) 204 { 205 TriangulatedSurface* result = new TriangulatedSurface(); 206 207 //Compute the amount of elements 208 result->number_of_points_ = num_vertices + 1; 209 result->number_of_edges_ = 2*num_vertices; 210 result->number_of_triangles_= num_vertices; 211 212 const double angle = 2*M_PI/num_vertices; 213 const TVector3<double> normal(0, 0 , out ? 1 : -1); 214 215 //Compute center vertex and store the first vertex/edge in an own variable 216 TrianglePoint* center = new TrianglePoint(TVector3<double>(0, 0, 0), normal); 217 result->points_.push_back(center); 218 219 TrianglePoint* p_old = new TrianglePoint(TVector3<double>(1, 0, 0), normal); 220 TrianglePoint* p1 = p_old; 221 result->points_.push_back(p1); 222 223 TriangleEdge* e1 = new TriangleEdge(p1, center); 224 TriangleEdge* e_old = e1; 225 result->edges_.push_back(e1); 226 227 //Triangulate the disk 228 for(unsigned int i = 1; i < num_vertices; ++i) { 229 TrianglePoint* p = new TrianglePoint(TVector3<double>(cos(i*angle), sin(i*angle), 0), normal); 230 result->points_.push_back(p); 231 232 TriangleEdge* e = new TriangleEdge(p, center); 233 TriangleEdge* e_top = new TriangleEdge(p, p_old); 234 result->edges_.push_back(e); 235 result->edges_.push_back(e_top); 236 237 Triangle* t = new Triangle(e_old, e_top, e, !out); 238 e_old->face_[1] = e->face_[0] = e_top->face_[0] = t; 239 result->triangles_.push_back(t); 240 241 e_old = e; 242 p_old = p; 243 } 244 245 //Ring closing code 246 TriangleEdge* e_top = new TriangleEdge(p1, p_old); 247 248 Triangle* t = new Triangle(e_old, e_top, e1, !out); 249 e_old->face_[1] = e1->face_[0] = e_top->face_[0] = t; 250 result->triangles_.push_back(t); 251 252 return result; 253 } 254 clear()255 void TriangulatedSurface::clear() 256 { 257 std::list<TrianglePoint*>::iterator p; 258 for (p = points_.begin(); p != points_.end(); p++) 259 { 260 delete *p; 261 } 262 std::list<TriangleEdge*>::iterator e; 263 for (e = edges_.begin(); e != edges_.end(); e++) 264 { 265 delete *e; 266 } 267 std::list<Triangle*>::iterator t; 268 for (t = triangles_.begin(); t != triangles_.end(); t++) 269 { 270 delete *t; 271 } 272 points_.clear(); 273 edges_.clear(); 274 triangles_.clear(); 275 number_of_points_ = 0; 276 number_of_edges_ = 0; 277 number_of_triangles_ = 0; 278 } 279 280 set(const TriangulatedSurface & surface,bool)281 void TriangulatedSurface::set(const TriangulatedSurface& surface, bool) 282 283 { 284 if (this != &surface) 285 { 286 copy(surface); 287 } 288 } 289 290 operator =(const TriangulatedSurface & surface)291 TriangulatedSurface& TriangulatedSurface::operator = (const TriangulatedSurface& surface) 292 293 { 294 if (this != &surface) 295 { 296 copy(surface); 297 } 298 return *this; 299 } 300 301 insert(TrianglePoint * p)302 void TriangulatedSurface::insert(TrianglePoint* p) 303 304 { 305 points_.push_back(p); 306 number_of_points_++; 307 } 308 309 insert(TriangleEdge * e)310 void TriangulatedSurface::insert(TriangleEdge* e) 311 312 { 313 edges_.push_back(e); 314 number_of_edges_++; 315 } 316 317 insert(Triangle * t)318 void TriangulatedSurface::insert(Triangle* t) 319 320 { 321 triangles_.push_back(t); 322 number_of_triangles_++; 323 } 324 325 numberOfPoints() const326 Size TriangulatedSurface::numberOfPoints() const 327 328 { 329 return number_of_points_; 330 } 331 getNumberOfPoints() const332 Size TriangulatedSurface::getNumberOfPoints() const 333 334 { 335 return number_of_points_; 336 } 337 338 numberOfEdges() const339 Size TriangulatedSurface::numberOfEdges() const 340 341 { 342 return number_of_edges_; 343 } 344 getNumberOfEdges() const345 Size TriangulatedSurface::getNumberOfEdges() const 346 347 { 348 return number_of_edges_; 349 } 350 numberOfTriangles() const351 Size TriangulatedSurface::numberOfTriangles() const 352 353 { 354 return number_of_triangles_; 355 } 356 getNumberOfTriangles() const357 Size TriangulatedSurface::getNumberOfTriangles() const 358 359 { 360 return number_of_triangles_; 361 } 362 remove(TrianglePoint * point,bool deep)363 void TriangulatedSurface::remove(TrianglePoint* point, bool deep) 364 365 { 366 if (deep) 367 { 368 HashSet<Triangle*> delete_triangles = point->faces_; 369 HashSet<Triangle*>::Iterator t; 370 for (t = delete_triangles.begin(); t != delete_triangles.end(); t++) 371 { 372 (*t)->vertex_[0]->faces_.erase(*t); 373 (*t)->vertex_[1]->faces_.erase(*t); 374 (*t)->vertex_[2]->faces_.erase(*t); 375 (*t)->edge_[0]->remove(*t); 376 (*t)->edge_[1]->remove(*t); 377 (*t)->edge_[2]->remove(*t); 378 triangles_.remove(*t); 379 number_of_triangles_--; 380 delete *t; 381 } 382 HashSet<TriangleEdge*> delete_edges = point->edges_; 383 HashSet<TriangleEdge*>::Iterator e; 384 for (e = delete_edges.begin(); e != delete_edges.end(); e++) 385 { 386 (*e)->vertex_[0]->edges_.erase(*e); 387 (*e)->vertex_[1]->edges_.erase(*e); 388 edges_.remove(*e); 389 number_of_edges_--; 390 delete *e; 391 } 392 } 393 points_.remove(point); 394 number_of_points_--; 395 delete point; 396 } 397 398 remove(PointIterator point,bool deep)399 void TriangulatedSurface::remove(PointIterator point, bool deep) 400 401 { 402 if (deep) 403 { 404 HashSet<Triangle*> delete_triangles = (*point)->faces_; 405 HashSet<Triangle*>::Iterator t; 406 for (t = delete_triangles.begin(); t != delete_triangles.end(); t++) 407 { 408 (*t)->vertex_[0]->faces_.erase(*t); 409 (*t)->vertex_[1]->faces_.erase(*t); 410 (*t)->vertex_[2]->faces_.erase(*t); 411 (*t)->edge_[0]->remove(*t); 412 (*t)->edge_[1]->remove(*t); 413 (*t)->edge_[2]->remove(*t); 414 triangles_.remove(*t); 415 number_of_triangles_--; 416 delete *t; 417 } 418 HashSet<TriangleEdge*> delete_edges = (*point)->edges_; 419 HashSet<TriangleEdge*>::Iterator e; 420 for (e = delete_edges.begin(); e != delete_edges.end(); e++) 421 { 422 (*e)->vertex_[0]->edges_.erase(*e); 423 (*e)->vertex_[1]->edges_.erase(*e); 424 edges_.remove(*e); 425 number_of_edges_--; 426 delete *e; 427 } 428 } 429 points_.erase(point); 430 number_of_points_--; 431 delete *point; 432 } 433 434 remove(TriangleEdge * edge,bool deep)435 void TriangulatedSurface::remove(TriangleEdge* edge, bool deep) 436 437 { 438 if (deep) 439 { 440 if (edge->face_[0] != NULL) 441 { 442 remove(edge->face_[0],true); 443 } 444 if (edge->face_[0] != NULL) 445 { 446 remove(edge->face_[0],true); 447 } 448 edge->vertex_[0]->edges_.erase(edge); 449 edge->vertex_[1]->edges_.erase(edge); 450 } 451 edges_.remove(edge); 452 number_of_edges_--; 453 delete edge; 454 } 455 456 remove(EdgeIterator e,bool deep)457 void TriangulatedSurface::remove(EdgeIterator e, bool deep) 458 459 { 460 TriangleEdge& edge = **e; 461 if (deep) 462 { 463 if (edge.face_[0] != NULL) 464 { 465 remove(edge.face_[0],true); 466 } 467 if (edge.face_[0] != NULL) 468 { 469 remove(edge.face_[0],true); 470 } 471 edge.vertex_[0]->edges_.erase(*e); 472 edge.vertex_[1]->edges_.erase(*e); 473 } 474 edges_.erase(e); 475 number_of_edges_--; 476 delete &edge; 477 } 478 479 remove(Triangle * triangle,bool deep)480 void TriangulatedSurface::remove(Triangle* triangle, bool deep) 481 482 { 483 if (deep) 484 { 485 triangle->vertex_[0]->faces_.erase(triangle); 486 triangle->vertex_[1]->faces_.erase(triangle); 487 triangle->vertex_[2]->faces_.erase(triangle); 488 triangle->edge_[0]->remove(triangle); 489 triangle->edge_[1]->remove(triangle); 490 triangle->edge_[2]->remove(triangle); 491 } 492 triangles_.remove(triangle); 493 number_of_triangles_--; 494 delete triangle; 495 } 496 497 remove(TriangleIterator t,bool deep)498 void TriangulatedSurface::remove(TriangleIterator t, bool deep) 499 500 { 501 Triangle& tri = **t; 502 if (deep) 503 { 504 tri.vertex_[0]->faces_.erase(*t); 505 tri.vertex_[1]->faces_.erase(*t); 506 tri.vertex_[2]->faces_.erase(*t); 507 tri.edge_[0]->remove(*t); 508 tri.edge_[1]->remove(*t); 509 tri.edge_[2]->remove(*t); 510 } 511 triangles_.erase(t); 512 number_of_triangles_--; 513 delete &tri; 514 } 515 516 exportSurface(Surface & surface)517 void TriangulatedSurface::exportSurface(Surface& surface) 518 519 { 520 std::list<TrianglePoint*>::iterator p; 521 Index i = 0; 522 Vector3 point; 523 Vector3 normal; 524 for (p = points_.begin(); p != points_.end(); p++) 525 { 526 TrianglePoint& tri_point = **p; 527 point.set((float)tri_point.point_.x, 528 (float)tri_point.point_.y, 529 (float)tri_point.point_.z); 530 normal.set((float)tri_point.normal_.x, 531 (float)tri_point.normal_.y, 532 (float)tri_point.normal_.z); 533 surface.vertex.push_back(point); 534 surface.normal.push_back(normal); 535 tri_point.index_ = i; 536 i++; 537 } 538 std::list<Triangle*>::iterator t; 539 for (t = triangles_.begin(); t != triangles_.end(); t++) 540 { 541 Surface::Triangle triangle; 542 triangle.v1 = (*t)->vertex_[0]->index_; 543 triangle.v2 = (*t)->vertex_[1]->index_; 544 triangle.v3 = (*t)->vertex_[2]->index_; 545 surface.triangle.push_back(triangle); 546 } 547 } 548 549 operator +=(const TriangulatedSurface & surface)550 TriangulatedSurface& TriangulatedSurface::operator += (const TriangulatedSurface& surface) 551 552 { 553 std::list<TrianglePoint*>::const_iterator p; 554 for (p = surface.points_.begin(); p != surface.points_.end(); p++) 555 { 556 points_.push_back(*p); 557 } 558 std::list<TriangleEdge*>::const_iterator e; 559 for (e = surface.edges_.begin(); e != surface.edges_.end(); e++) 560 { 561 edges_.push_back(*e); 562 } 563 std::list<Triangle*>::const_iterator t; 564 for (t = surface.triangles_.begin(); t != surface.triangles_.end(); t++) 565 { 566 triangles_.push_back(*t); 567 } 568 number_of_points_ += surface.number_of_points_; 569 number_of_edges_ += surface.number_of_edges_; 570 number_of_triangles_ += surface.number_of_triangles_; 571 return *this; 572 } 573 574 join(TriangulatedSurface & source)575 void TriangulatedSurface::join(TriangulatedSurface& source) 576 { 577 points_.splice(points_.end(),source.points_); 578 edges_.splice(edges_.end(),source.edges_); 579 triangles_.splice(triangles_.end(),source.triangles_); 580 number_of_points_ += source.number_of_points_; 581 number_of_edges_ += source.number_of_edges_; 582 number_of_triangles_ += source.number_of_triangles_; 583 source.number_of_points_ = 0; 584 source.number_of_edges_ = 0; 585 source.number_of_triangles_ = 0; 586 } 587 shift(const TVector3<double> & c)588 void TriangulatedSurface::shift(const TVector3<double>& c) 589 { 590 std::list<TrianglePoint*>::iterator i; 591 for (i = points_.begin(); i != points_.end(); i++) 592 { 593 (*i)->point_ += c; 594 } 595 } 596 blowUp(const double & r)597 void TriangulatedSurface::blowUp(const double& r) 598 { 599 std::list<TrianglePoint*>::iterator i; 600 for (i = points_.begin(); i != points_.end(); i++) 601 { 602 (*i)->point_ *= r; 603 } 604 } 605 setIndices()606 void TriangulatedSurface::setIndices() 607 { 608 Index i = 0; 609 std::list<TrianglePoint*>::iterator p; 610 for (p = points_.begin(); p != points_.end(); p++) 611 { 612 (*p)->index_ = i; 613 i++; 614 } 615 i = 0; 616 std::list<TriangleEdge*>::iterator e; 617 for (e = edges_.begin(); e != edges_.end(); e++) 618 { 619 (*e)->index_ = i; 620 i++; 621 } 622 i = 0; 623 std::list<Triangle*>::iterator t; 624 for (t = triangles_.begin(); t != triangles_.end(); t++) 625 { 626 (*t)->index_ = i; 627 i++; 628 } 629 } 630 setDensity(const double & density)631 void TriangulatedSurface::setDensity(const double& density) 632 { 633 density_ = density; 634 } 635 getDensity() const636 double TriangulatedSurface::getDensity() const 637 { 638 return density_; 639 } 640 cut(const TPlane3<double> & plane,const double & fuzzy)641 void TriangulatedSurface::cut(const TPlane3<double>& plane, const double& fuzzy) 642 { 643 // delete all points on the wrong side of the plane 644 std::list<TrianglePoint*>::iterator p; 645 std::list<TrianglePoint*>::iterator next_point; 646 double test_value; 647 test_value = plane.n*plane.p+fuzzy; 648 p = points_.begin(); 649 while (p != points_.end()) 650 { 651 if (Maths::isLessOrEqual(plane.n*(*p)->point_,test_value)) 652 { 653 next_point = p; 654 next_point++; 655 delete *p; 656 if (next_point == points_.end()) 657 { 658 points_.erase(p); 659 p = points_.end(); 660 } 661 else 662 { 663 points_.erase(p); 664 p = next_point; 665 } 666 number_of_points_--; 667 } 668 else 669 { 670 p++; 671 } 672 } 673 } 674 675 shrink()676 void TriangulatedSurface::shrink() 677 { 678 // delete all border triangles 679 std::list<Triangle*> delete_triangles; 680 std::list<Triangle*>::iterator t; 681 for (t = triangles_.begin(); t != triangles_.end(); t++) 682 { 683 if (((*t)->edge_[0]->face_[0] == NULL) || ((*t)->edge_[0]->face_[1] == NULL) || 684 ((*t)->edge_[1]->face_[0] == NULL) || ((*t)->edge_[1]->face_[1] == NULL) || 685 ((*t)->edge_[2]->face_[0] == NULL) || ((*t)->edge_[2]->face_[1] == NULL) ) 686 { 687 delete_triangles.push_back(*t); 688 } 689 } 690 for (t = delete_triangles.begin(); t != delete_triangles.end(); t++) 691 { 692 remove(*t,true); 693 } 694 // delete all "isolated" edges (edges with no triangles) 695 std::list<TriangleEdge*>::iterator e = edges_.begin(); 696 std::list<TriangleEdge*>::iterator next_edge; 697 while (e != edges_.end()) 698 { 699 if (((*e)->face_[0] == NULL) && ((*e)->face_[1] == NULL)) 700 { 701 next_edge = e; 702 next_edge++; 703 (*e)->vertex_[0]->edges_.erase(*e); 704 (*e)->vertex_[1]->edges_.erase(*e); 705 delete *e; 706 if (next_edge == edges_.end()) 707 { 708 edges_.erase(e); 709 e = edges_.end(); 710 } 711 else 712 { 713 edges_.erase(e); 714 e = next_edge; 715 } 716 number_of_edges_--; 717 } 718 else 719 { 720 e++; 721 } 722 } 723 } 724 725 deleteIsolatedEdges()726 void TriangulatedSurface::deleteIsolatedEdges() 727 728 { 729 std::list<TriangleEdge*>::iterator e1; 730 std::list<TriangleEdge*>::iterator e2; 731 e1 = edges_.begin(); 732 while (e1 != edges_.end()) 733 { 734 if ((*e1)->face_[0] == NULL) 735 { 736 e2 = e1; 737 e2++; 738 if (e2 == edges_.end()) 739 { 740 remove(e1); 741 e1 = edges_.end(); 742 } 743 else 744 { 745 remove(e1); 746 e1 = e2; 747 } 748 } 749 else 750 { 751 e1++; 752 } 753 } 754 } 755 756 deleteIsolatedPoints()757 void TriangulatedSurface::deleteIsolatedPoints() 758 759 { 760 std::list<TrianglePoint*>::iterator p1; 761 std::list<TrianglePoint*>::iterator p2; 762 p1 = points_.begin(); 763 while (p1 != points_.end()) 764 { 765 if ((*p1)->faces_.size() == 0) 766 { 767 delete *p1; 768 p2 = points_.erase(p1); 769 p1 = p2; 770 number_of_points_--; 771 } 772 else 773 { 774 p1++; 775 } 776 } 777 } 778 779 getBorder(std::list<TriangleEdge * > & border)780 void TriangulatedSurface::getBorder(std::list<TriangleEdge*>& border) 781 { 782 std::list<TriangleEdge*>::iterator e; 783 for (e = edges_.begin(); e != edges_.end(); e++) 784 { 785 if (((*e)->face_[0] == NULL) || ((*e)->face_[1] == NULL)) 786 { 787 border.push_back(*e); 788 } 789 } 790 } 791 792 793 TriangulatedSurface::PointIterator beginPoint()794 TriangulatedSurface::beginPoint() 795 796 { 797 return points_.begin(); 798 } 799 800 801 TriangulatedSurface::ConstPointIterator beginPoint() const802 TriangulatedSurface::beginPoint() const 803 804 { 805 return points_.begin(); 806 } 807 808 809 TriangulatedSurface::PointIterator endPoint()810 TriangulatedSurface::endPoint() 811 812 { 813 return points_.end(); 814 } 815 816 817 TriangulatedSurface::ConstPointIterator endPoint() const818 TriangulatedSurface::endPoint() const 819 820 { 821 return points_.end(); 822 } 823 824 825 TriangulatedSurface::EdgeIterator beginEdge()826 TriangulatedSurface::beginEdge() 827 828 { 829 return edges_.begin(); 830 } 831 832 833 TriangulatedSurface::ConstEdgeIterator beginEdge() const834 TriangulatedSurface::beginEdge() const 835 836 { 837 return edges_.begin(); 838 } 839 840 841 TriangulatedSurface::EdgeIterator endEdge()842 TriangulatedSurface::endEdge() 843 844 { 845 return edges_.end(); 846 } 847 848 849 TriangulatedSurface::ConstEdgeIterator endEdge() const850 TriangulatedSurface::endEdge() const 851 852 { 853 return edges_.end(); 854 } 855 856 857 TriangulatedSurface::TriangleIterator beginTriangle()858 TriangulatedSurface::beginTriangle() 859 860 { 861 return triangles_.begin(); 862 } 863 864 865 TriangulatedSurface::ConstTriangleIterator beginTriangle() const866 TriangulatedSurface::beginTriangle() const 867 868 { 869 return triangles_.begin(); 870 } 871 872 873 TriangulatedSurface::TriangleIterator endTriangle()874 TriangulatedSurface::endTriangle() 875 876 { 877 return triangles_.end(); 878 } 879 880 881 TriangulatedSurface::ConstTriangleIterator endTriangle() const882 TriangulatedSurface::endTriangle() const 883 884 { 885 return triangles_.end(); 886 } 887 888 canBeCopied() const889 bool TriangulatedSurface::canBeCopied() const 890 891 { 892 std::list<TrianglePoint*>::const_iterator p; 893 Index i = 0; 894 for (p = points_.begin(); p != points_.end(); p++) 895 { 896 if (*p == NULL) 897 { 898 Log.error() << "Error: TriangulatedSurface contains null pointer!" << std::endl; 899 return false; 900 } 901 if ((*p)->index_ != i) 902 { 903 Log.error() << "Error: TriangulatedSurface contains index mismatch!" << std::endl; 904 return false; 905 } 906 i++; 907 } 908 std::list<TriangleEdge*>::const_iterator e; 909 i = 0; 910 for (e = edges_.begin(); e != edges_.end(); e++) 911 { 912 if (*e == NULL) 913 { 914 return false; 915 } 916 if ((*e)->index_ != i) 917 { 918 return false; 919 } 920 i++; 921 } 922 std::list<Triangle*>::const_iterator t; 923 i = 0; 924 for (t = triangles_.begin(); t != triangles_.end(); t++) 925 { 926 if (*t == NULL) 927 { 928 return false; 929 } 930 if ((*t)->index_ != i) 931 { 932 return false; 933 } 934 i++; 935 } 936 return true; 937 } 938 939 copy(const TriangulatedSurface & surface)940 void TriangulatedSurface::copy(const TriangulatedSurface& surface) 941 942 { 943 if (surface.canBeCopied()) 944 { 945 number_of_points_ = surface.number_of_points_; 946 number_of_edges_ = surface.number_of_edges_; 947 number_of_triangles_ = surface.number_of_triangles_; 948 std::vector<TrianglePoint*> point_vector(number_of_points_); 949 std::list<TrianglePoint*>::const_iterator p; 950 Position i = 0; 951 for (p = surface.points_.begin(); p != surface.points_.end(); p++) 952 { 953 point_vector[i] = new TrianglePoint(**p,false); 954 points_.push_back(point_vector[i]); 955 i++; 956 } 957 std::vector<TriangleEdge*> edge_vector(number_of_edges_); 958 std::list<TriangleEdge*>::const_iterator e; 959 i = 0; 960 for (e = surface.edges_.begin(); e != surface.edges_.end(); e++) 961 { 962 edge_vector[i] = new TriangleEdge(**e,false); 963 edges_.push_back(edge_vector[i]); 964 i++; 965 } 966 std::vector<Triangle*> triangle_vector(number_of_triangles_); 967 std::list<Triangle*>::const_iterator t; 968 i = 0; 969 for (t = surface.triangles_.begin(); t != surface.triangles_.end(); t++) 970 { 971 triangle_vector[i] = new Triangle(**t,false); 972 triangles_.push_back(triangle_vector[i]); 973 i++; 974 } 975 HashSet<TriangleEdge*>::ConstIterator he; 976 HashSet<Triangle*>::ConstIterator ht; 977 i = 0; 978 for (p = surface.points_.begin(); p != surface.points_.end(); p++) 979 { 980 for (he = (*p)->edges_.begin(); he != (*p)->edges_.end(); he++) 981 { 982 point_vector[i]->edges_.insert(edge_vector[(*he)->index_]); 983 } 984 for (ht = (*p)->faces_.begin(); ht != (*p)->faces_.end(); ht++) 985 { 986 point_vector[i]->faces_.insert(triangle_vector[(*ht)->index_]); 987 } 988 i++; 989 } 990 i = 0; 991 for (e = surface.edges_.begin(); e != surface.edges_.end(); e++) 992 { 993 edge_vector[i]->vertex_[0] = point_vector[(*e)->vertex_[0]->index_]; 994 edge_vector[i]->vertex_[1] = point_vector[(*e)->vertex_[1]->index_]; 995 if ((*e)->face_[0] != NULL) 996 { 997 edge_vector[i]->face_[0] = triangle_vector[(*e)->face_[0]->index_]; 998 } 999 if ((*e)->face_[1] != NULL) 1000 { 1001 edge_vector[i]->face_[1] = triangle_vector[(*e)->face_[1]->index_]; 1002 } 1003 i++; 1004 } 1005 i = 0; 1006 for (t = surface.triangles_.begin(); t != surface.triangles_.end(); t++) 1007 { 1008 triangle_vector[i]->vertex_[0] = point_vector[(*t)->vertex_[0]->index_]; 1009 triangle_vector[i]->vertex_[1] = point_vector[(*t)->vertex_[1]->index_]; 1010 triangle_vector[i]->vertex_[2] = point_vector[(*t)->vertex_[2]->index_]; 1011 triangle_vector[i]->edge_[0] = edge_vector[(*t)->edge_[0]->index_]; 1012 triangle_vector[i]->edge_[1] = edge_vector[(*t)->edge_[1]->index_]; 1013 triangle_vector[i]->edge_[2] = edge_vector[(*t)->edge_[2]->index_]; 1014 i++; 1015 } 1016 } 1017 else 1018 { 1019 Log.error() << "Error: surface can not be copied!" << std::endl; 1020 } 1021 } 1022 1023 /////////////////////////////////////////////////////////////////////////////// 1024 1025 TriangulatedSphere()1026 TriangulatedSphere::TriangulatedSphere() 1027 : TriangulatedSurface() 1028 { 1029 } 1030 1031 TriangulatedSphere(const TriangulatedSphere & sphere,bool)1032 TriangulatedSphere::TriangulatedSphere(const TriangulatedSphere& sphere, bool) 1033 : TriangulatedSurface(sphere) 1034 { 1035 } 1036 1037 ~TriangulatedSphere()1038 TriangulatedSphere::~TriangulatedSphere() 1039 { 1040 } 1041 1042 set(const TriangulatedSphere & sphere,bool)1043 void TriangulatedSphere::set(const TriangulatedSphere& sphere, bool) 1044 { 1045 if (this != &sphere) 1046 { 1047 copy(sphere); 1048 } 1049 } 1050 1051 operator =(const TriangulatedSphere & sphere)1052 TriangulatedSphere& TriangulatedSphere::operator = (const TriangulatedSphere& sphere) 1053 { 1054 if (this != &sphere) 1055 { 1056 copy(sphere); 1057 } 1058 return *this; 1059 } 1060 1061 refine(Position iterations,bool out)1062 void TriangulatedSphere::refine(Position iterations, bool out) 1063 { 1064 for (Position i = 0; i < iterations; i++) 1065 { 1066 refine(out); 1067 } 1068 std::list<Triangle*>::iterator t; 1069 for (t = triangles_.begin(); t != triangles_.end(); t++) 1070 { 1071 TVector3<double> norm(((*t)->vertex_[1]->point_-(*t)->vertex_[0]->point_) % 1072 ((*t)->vertex_[2]->point_-(*t)->vertex_[0]->point_) ); 1073 if ((Maths::isGreater(norm*(*t)->vertex_[0]->point_,0) && 1074 (out == false) ) || 1075 (Maths::isLess(norm*(*t)->vertex_[0]->point_,0) && 1076 (out == true) ) ) 1077 { 1078 TrianglePoint* temp = (*t)->vertex_[1]; 1079 (*t)->vertex_[1] = (*t)->vertex_[2]; 1080 (*t)->vertex_[2] = temp; 1081 } 1082 } 1083 setIncidences(); 1084 } 1085 1086 refine(bool out)1087 void TriangulatedSphere::refine(bool out) 1088 { 1089 std::vector<Face> faces(number_of_triangles_); 1090 std::list<Triangle*>::iterator t; 1091 Position i = 0; 1092 for (t = triangles_.begin(); t != triangles_.end(); t++) 1093 { 1094 (*t)->index_ = i; 1095 faces[i].p[0] = (*t)->vertex_[0]; 1096 faces[i].p[1] = (*t)->vertex_[1]; 1097 faces[i].p[2] = (*t)->vertex_[2]; 1098 faces[i].pcount = 3; 1099 faces[i].ecount = 0; 1100 i++; 1101 } 1102 std::list<TriangleEdge*> new_edges; 1103 std::list<TriangleEdge*>::iterator e; 1104 int counter = 0; 1105 for (e = edges_.begin(); e != edges_.end(); e++, counter++) 1106 { 1107 TrianglePoint* point1 = (*e)->vertex_[0]; 1108 TrianglePoint* point2 = (*e)->vertex_[1]; 1109 TrianglePoint* new_point = new TrianglePoint; 1110 new_point->point_ = (point1->point_+point2->point_).normalize(); 1111 if (out == true) 1112 { 1113 new_point->normal_ = new_point->point_; 1114 } 1115 else 1116 { 1117 new_point->normal_ = -new_point->point_; 1118 } 1119 TriangleEdge* new_edge1 = *e; 1120 new_edge1->vertex_[0] = point1; 1121 new_edge1->vertex_[1] = new_point; 1122 TriangleEdge* new_edge2 = new TriangleEdge; 1123 new_edge2->vertex_[0] = point2; 1124 new_edge2->vertex_[1] = new_point; 1125 i = (*e)->face_[0]->index_; 1126 faces[i].p[faces[i].pcount] = new_point; 1127 faces[i].pcount++; 1128 faces[i].e[faces[i].ecount] = new_edge1; 1129 faces[i].e[faces[i].ecount+1] = new_edge2; 1130 faces[i].ecount += 2; 1131 i = (*e)->face_[1]->index_; 1132 faces[i].p[faces[i].pcount] = new_point; 1133 faces[i].pcount++; 1134 faces[i].e[faces[i].ecount] = new_edge1; 1135 faces[i].e[faces[i].ecount+1] = new_edge2; 1136 faces[i].ecount += 2; 1137 new_edge1->face_[0] = NULL; 1138 new_edge1->face_[1] = NULL; 1139 new_edge2->face_[0] = NULL; 1140 new_edge2->face_[1] = NULL; 1141 points_.push_back(new_point); 1142 new_edges.push_back(new_edge2); 1143 } 1144 edges_.splice(edges_.end(),new_edges); 1145 i = 0; 1146 std::list<Triangle*> new_triangles; 1147 for (t = triangles_.begin(); t != triangles_.end(); t++) 1148 { 1149 // create four new triangles 1150 Triangle* triangle[3]; 1151 for (Position k = 0; k < 3; k++) 1152 { 1153 triangle[k] = new Triangle; 1154 } 1155 // create three new edges 1156 for (Position k = 6; k < 9; k++) 1157 { 1158 faces[i].e[k] = new TriangleEdge; 1159 faces[i].e[k]->vertex_[0] = faces[i].p[k-3]; 1160 faces[i].e[k]->vertex_[1] = faces[i].p[(k-5)%3+3]; 1161 faces[i].e[k]->face_[0] = NULL; 1162 faces[i].e[k]->face_[1] = NULL; 1163 edges_.push_back(faces[i].e[k]); 1164 } 1165 // build the four triangles replacing the old one 1166 buildFourTriangles(faces[i], 1167 triangle[0],triangle[1], 1168 triangle[2],*t); 1169 new_triangles.push_back(triangle[0]); 1170 new_triangles.push_back(triangle[1]); 1171 new_triangles.push_back(triangle[2]); 1172 i++; 1173 } 1174 triangles_.splice(triangles_.end(),new_triangles); 1175 number_of_points_ += number_of_edges_; 1176 number_of_edges_ *= 4; 1177 number_of_triangles_ *= 4; 1178 } 1179 1180 buildFourTriangles(Face face,Triangle * face0,Triangle * face1,Triangle * face2,Triangle * face3)1181 void TriangulatedSphere::buildFourTriangles 1182 (Face face, 1183 Triangle* face0, 1184 Triangle* face1, 1185 Triangle* face2, 1186 Triangle* face3) 1187 1188 { 1189 Triangle* triangle[3]; 1190 triangle[0] = face0; 1191 triangle[1] = face1; 1192 triangle[2] = face2; 1193 TriangleEdge* edge[3]; 1194 edge[0] = NULL; 1195 edge[1] = NULL; 1196 edge[2] = NULL; 1197 for (Position k = 0; k < 3; k++) 1198 { 1199 // create a smaller triangle containing face.p[k] 1200 TriangleEdge* first = NULL; 1201 TriangleEdge* second = NULL; 1202 TrianglePoint* p1 = NULL; 1203 TrianglePoint* p2 = NULL; 1204 TrianglePoint* p3 = face.p[k]; 1205 Position i = 0; 1206 while (first == NULL) 1207 { 1208 if (face.e[i]->vertex_[0] == p3) 1209 { 1210 first = face.e[i]; 1211 p1 = face.e[i]->vertex_[1]; 1212 } 1213 else 1214 { 1215 if (face.e[i]->vertex_[1] == p3) 1216 { 1217 first = face.e[i]; 1218 p1 = face.e[i]->vertex_[0]; 1219 } 1220 } 1221 i++; 1222 } 1223 while (second == NULL) 1224 { 1225 if (face.e[i]->vertex_[0] == p3) 1226 { 1227 second = face.e[i]; 1228 p2 = face.e[i]->vertex_[1]; 1229 } 1230 else 1231 { 1232 if (face.e[i]->vertex_[1] == p3) 1233 { 1234 second = face.e[i]; 1235 p2 = face.e[i]->vertex_[0]; 1236 } 1237 } 1238 i++; 1239 } 1240 i = 6; 1241 while (edge[k] == NULL) 1242 { 1243 if (((face.e[i]->vertex_[0] == p1) && 1244 (face.e[i]->vertex_[1] == p2) ) || 1245 ((face.e[i]->vertex_[0] == p2) && 1246 (face.e[i]->vertex_[1] == p1) ) ) 1247 { 1248 edge[k] = face.e[i]; 1249 } 1250 i++; 1251 } 1252 triangle[k]->vertex_[0] = p1; 1253 triangle[k]->vertex_[1] = p2; 1254 triangle[k]->vertex_[2] = p3; 1255 triangle[k]->edge_[0] = first; 1256 triangle[k]->edge_[1] = second; 1257 triangle[k]->edge_[2] = edge[k]; 1258 if (first->face_[0] == NULL) 1259 { 1260 first->face_[0] = triangle[k]; 1261 } 1262 else 1263 { 1264 first->face_[1] = triangle[k]; 1265 } 1266 if (second->face_[0] == NULL) 1267 { 1268 second->face_[0] = triangle[k]; 1269 } 1270 else 1271 { 1272 second->face_[1] = triangle[k]; 1273 } 1274 edge[k]->face_[0] = triangle[k]; 1275 edge[k]->face_[1] = face3; 1276 } 1277 face3->vertex_[0] = face.p[3]; 1278 face3->vertex_[1] = face.p[4]; 1279 face3->vertex_[2] = face.p[5]; 1280 face3->edge_[0] = edge[0]; 1281 face3->edge_[1] = edge[1]; 1282 face3->edge_[2] = edge[2]; 1283 } 1284 1285 setIncidences()1286 void TriangulatedSphere::setIncidences() 1287 { 1288 std::list<TrianglePoint*>::iterator p; 1289 for (p = points_.begin(); p != points_.end(); p++) 1290 { 1291 (*p)->edges_.clear(); 1292 (*p)->faces_.clear(); 1293 } 1294 std::list<TriangleEdge*>::iterator e; 1295 for (e = edges_.begin(); e != edges_.end(); e++) 1296 { 1297 (*e)->vertex_[0]->edges_.insert(*e); 1298 (*e)->vertex_[0]->faces_.insert((*e)->face_[0]); 1299 (*e)->vertex_[0]->faces_.insert((*e)->face_[1]); 1300 (*e)->vertex_[1]->edges_.insert(*e); 1301 (*e)->vertex_[1]->faces_.insert((*e)->face_[0]); 1302 (*e)->vertex_[1]->faces_.insert((*e)->face_[1]); 1303 } 1304 } 1305 1306 struct PointerPairComparator { 1307 typedef std::pair<TrianglePoint*, TrianglePoint*> Input; 1308 operator ()BALL::PointerPairComparator1309 bool operator()(const Input& p1, const Input& p2) const { 1310 Input a = p1; 1311 if((unsigned long)a.first > (unsigned long)a.second) { 1312 std::swap(a.first, a.second); 1313 } 1314 1315 Input b = p2; 1316 if((unsigned long)b.first > (unsigned long)b.second) { 1317 std::swap(b.first, b.second); 1318 } 1319 1320 return (a.first < b.first) || ((a.first == b.first) && (a.second < b.second)); 1321 } 1322 1323 }; 1324 1325 1326 typedef std::map<std::pair<TrianglePoint*, TrianglePoint*>, TriangleEdge*, PointerPairComparator> EdgeMap; 1327 getEdge_(EdgeMap & edges,TrianglePoint * a,TrianglePoint * b)1328 TriangleEdge* getEdge_(EdgeMap& edges, TrianglePoint* a, TrianglePoint* b) 1329 { 1330 EdgeMap::iterator res = edges.find(std::make_pair(a, b)); 1331 if(res == edges.end()) { 1332 res = edges.insert(std::make_pair(std::make_pair(a, b), new TriangleEdge(a, b))).first; 1333 } 1334 1335 return res->second; 1336 } 1337 pentakisDodecaeder(bool out)1338 void TriangulatedSphere::pentakisDodecaeder(bool out) 1339 { 1340 icosaeder(out); 1341 1342 number_of_points_ = 32; 1343 number_of_edges_ = 90; 1344 number_of_triangles_ = 60; 1345 1346 std::map<Triangle*, TrianglePoint*> new_points; 1347 for(std::list<Triangle*>::iterator it = triangles_.begin(); it != triangles_.end(); ++it) { 1348 TrianglePoint* p = new TrianglePoint(((*it)->vertex_[0]->point_ + (*it)->vertex_[1]->point_ + (*it)->vertex_[2]->point_).normalize()); 1349 1350 p->normal_ = out ? p->point_ : -p->point_; 1351 1352 new_points[*it] = p; 1353 1354 delete *it; 1355 } 1356 1357 EdgeMap edge_map; 1358 std::list<Triangle*> new_triangles; 1359 for(std::list<TrianglePoint*>::iterator pt = points_.begin(); pt != points_.end(); ++pt) { 1360 BALL::HashSet<TriangleEdge*> p_edges((*pt)->edges_); 1361 for(TrianglePoint::EdgeIterator et = p_edges.begin(); et != p_edges.end(); ++et) { 1362 TrianglePoint* p1 = new_points[(*et)->getTriangle(0)]; 1363 TrianglePoint* p2 = new_points[(*et)->getTriangle(1)]; 1364 1365 TriangleEdge* e1 = getEdge_(edge_map, *pt, p1); 1366 TriangleEdge* e2 = getEdge_(edge_map, p1, p2); 1367 TriangleEdge* e3 = getEdge_(edge_map, p2, *pt); 1368 1369 Triangle* tri = new Triangle(e1, e2, e3); 1370 1371 if(e1->getTriangle(0) == 0) { 1372 e1->setTriangle(0, tri); 1373 } else { 1374 e1->setTriangle(1, tri); 1375 } 1376 1377 if(e2->getTriangle(0) == 0) { 1378 e2->setTriangle(0, tri); 1379 } else { 1380 e2->setTriangle(1, tri); 1381 } 1382 1383 if(e3->getTriangle(0) == 0) { 1384 e3->setTriangle(0, tri); 1385 } else { 1386 e3->setTriangle(1, tri); 1387 } 1388 1389 new_triangles.push_back(tri); 1390 1391 (*pt)->remove((*et)->getTriangle(0)); 1392 (*pt)->remove((*et)->getTriangle(1)); 1393 (*pt)->remove(*et); 1394 } 1395 } 1396 1397 for(std::list<TriangleEdge*>::iterator et = edges_.begin(); et != edges_.end(); ++et) { 1398 delete *et; 1399 } 1400 1401 edges_.clear(); 1402 1403 for(EdgeMap::iterator it = edge_map.begin(); it != edge_map.end(); ++it) { 1404 edges_.push_back(it->second); 1405 } 1406 1407 for(std::map<Triangle*, TrianglePoint*>::iterator it = new_points.begin(); it != new_points.end(); ++it) { 1408 points_.push_back(it->second); 1409 } 1410 1411 std::swap(triangles_, new_triangles); 1412 } 1413 icosaeder(bool out)1414 void TriangulatedSphere::icosaeder(bool out) 1415 { 1416 clear(); 1417 1418 number_of_points_ = 12; 1419 number_of_edges_ = 30; 1420 number_of_triangles_ = 20; 1421 1422 std::vector<TrianglePoint*> points_tmp(number_of_points_); 1423 points_tmp[0] = new TrianglePoint(TVector3<double>( 0.0 , 0.0 , 1.0 )); 1424 points_tmp[1] = new TrianglePoint(TVector3<double>( 0.894427, 0.0 , 0.4472135)); 1425 points_tmp[2] = new TrianglePoint(TVector3<double>( 0.276393, 0.850651, 0.4472135)); 1426 points_tmp[3] = new TrianglePoint(TVector3<double>(-0.723607, 0.525731, 0.4472135)); 1427 points_tmp[4] = new TrianglePoint(TVector3<double>(-0.723607,-0.525731, 0.4472135)); 1428 points_tmp[5] = new TrianglePoint(TVector3<double>( 0.276393,-0.850651, 0.4472135)); 1429 points_tmp[6] = new TrianglePoint(TVector3<double>( 0.723607, 0.525731,-0.4472135)); 1430 points_tmp[7] = new TrianglePoint(TVector3<double>(-0.276393, 0.850651,-0.4472135)); 1431 points_tmp[8] = new TrianglePoint(TVector3<double>(-0.894427, 0.0 ,-0.4472135)); 1432 points_tmp[9] = new TrianglePoint(TVector3<double>(-0.276393,-0.850651,-0.4472135)); 1433 points_tmp[10] = new TrianglePoint(TVector3<double>( 0.723607,-0.525731,-0.4472135)); 1434 points_tmp[11] = new TrianglePoint(TVector3<double>( 0.0 , 0.0 ,-1.0 )); 1435 1436 for (Position i=0; i < number_of_points_; ++i) { 1437 points_tmp[i]->normal_ = out ? points_tmp[i]->point_ : -1.*points_tmp[i]->point_; 1438 } 1439 1440 std::vector<TriangleEdge*> edges_tmp(number_of_edges_); 1441 edges_tmp[0] = new TriangleEdge(points_tmp[2], points_tmp[0]); 1442 edges_tmp[1] = new TriangleEdge(points_tmp[0], points_tmp[1]); 1443 edges_tmp[2] = new TriangleEdge(points_tmp[1], points_tmp[2]); 1444 edges_tmp[3] = new TriangleEdge(points_tmp[3], points_tmp[0]); 1445 edges_tmp[4] = new TriangleEdge(points_tmp[2], points_tmp[3]); 1446 edges_tmp[5] = new TriangleEdge(points_tmp[4], points_tmp[0]); 1447 edges_tmp[6] = new TriangleEdge(points_tmp[3], points_tmp[4]); 1448 edges_tmp[7] = new TriangleEdge(points_tmp[5], points_tmp[0]); 1449 edges_tmp[8] = new TriangleEdge(points_tmp[4], points_tmp[5]); 1450 edges_tmp[9] = new TriangleEdge(points_tmp[5], points_tmp[1]); 1451 edges_tmp[10] = new TriangleEdge(points_tmp[1], points_tmp[6]); 1452 edges_tmp[11] = new TriangleEdge(points_tmp[6], points_tmp[2]); 1453 edges_tmp[12] = new TriangleEdge(points_tmp[7], points_tmp[2]); 1454 edges_tmp[13] = new TriangleEdge(points_tmp[6], points_tmp[7]); 1455 edges_tmp[14] = new TriangleEdge(points_tmp[7], points_tmp[3]); 1456 edges_tmp[15] = new TriangleEdge(points_tmp[8], points_tmp[3]); 1457 edges_tmp[16] = new TriangleEdge(points_tmp[7], points_tmp[8]); 1458 edges_tmp[17] = new TriangleEdge(points_tmp[8], points_tmp[4]); 1459 edges_tmp[18] = new TriangleEdge(points_tmp[9], points_tmp[4]); 1460 edges_tmp[19] = new TriangleEdge(points_tmp[8], points_tmp[9]); 1461 edges_tmp[20] = new TriangleEdge(points_tmp[9], points_tmp[5]); 1462 edges_tmp[21] = new TriangleEdge(points_tmp[10], points_tmp[5]); 1463 edges_tmp[22] = new TriangleEdge(points_tmp[9], points_tmp[10]); 1464 edges_tmp[23] = new TriangleEdge(points_tmp[1], points_tmp[10]); 1465 edges_tmp[24] = new TriangleEdge(points_tmp[10], points_tmp[6]); 1466 edges_tmp[25] = new TriangleEdge(points_tmp[6], points_tmp[11]); 1467 edges_tmp[26] = new TriangleEdge(points_tmp[11], points_tmp[7]); 1468 edges_tmp[27] = new TriangleEdge(points_tmp[11], points_tmp[8]); 1469 edges_tmp[28] = new TriangleEdge(points_tmp[11], points_tmp[9]); 1470 edges_tmp[29] = new TriangleEdge(points_tmp[11], points_tmp[10]); 1471 1472 std::vector<Triangle*> triangles_tmp(number_of_triangles_); 1473 triangles_tmp[0] = new Triangle(edges_tmp[0], edges_tmp[1], edges_tmp[2]); 1474 triangles_tmp[1] = new Triangle(edges_tmp[0], edges_tmp[3], edges_tmp[4]); 1475 triangles_tmp[2] = new Triangle(edges_tmp[3], edges_tmp[5], edges_tmp[6]); 1476 triangles_tmp[3] = new Triangle(edges_tmp[5], edges_tmp[7], edges_tmp[8]); 1477 triangles_tmp[4] = new Triangle(edges_tmp[1], edges_tmp[7], edges_tmp[9]); 1478 triangles_tmp[5] = new Triangle(edges_tmp[2], edges_tmp[10], edges_tmp[11]); 1479 triangles_tmp[6] = new Triangle(edges_tmp[11], edges_tmp[12], edges_tmp[13]); 1480 triangles_tmp[7] = new Triangle(edges_tmp[4], edges_tmp[12], edges_tmp[14]); 1481 triangles_tmp[8] = new Triangle(edges_tmp[14], edges_tmp[15], edges_tmp[16]); 1482 triangles_tmp[9] = new Triangle(edges_tmp[6], edges_tmp[15], edges_tmp[17]); 1483 triangles_tmp[10] = new Triangle(edges_tmp[17], edges_tmp[18], edges_tmp[19]); 1484 triangles_tmp[11] = new Triangle(edges_tmp[8], edges_tmp[18], edges_tmp[20]); 1485 triangles_tmp[12] = new Triangle(edges_tmp[20], edges_tmp[21], edges_tmp[22]); 1486 triangles_tmp[13] = new Triangle(edges_tmp[10], edges_tmp[23], edges_tmp[24]); 1487 triangles_tmp[14] = new Triangle(edges_tmp[9], edges_tmp[21], edges_tmp[23]); 1488 triangles_tmp[15] = new Triangle(edges_tmp[13], edges_tmp[25], edges_tmp[26]); 1489 triangles_tmp[16] = new Triangle(edges_tmp[16], edges_tmp[26], edges_tmp[27]); 1490 triangles_tmp[17] = new Triangle(edges_tmp[19], edges_tmp[27], edges_tmp[28]); 1491 triangles_tmp[18] = new Triangle(edges_tmp[22], edges_tmp[28], edges_tmp[29]); 1492 triangles_tmp[19] = new Triangle(edges_tmp[24], edges_tmp[25], edges_tmp[29]); 1493 1494 edges_tmp[0]->face_[0] = triangles_tmp[0]; edges_tmp[0]->face_[1] = triangles_tmp[1]; 1495 edges_tmp[1]->face_[0] = triangles_tmp[0]; edges_tmp[1]->face_[1] = triangles_tmp[4]; 1496 edges_tmp[2]->face_[0] = triangles_tmp[0]; edges_tmp[2]->face_[1] = triangles_tmp[5]; 1497 edges_tmp[3]->face_[0] = triangles_tmp[1]; edges_tmp[3]->face_[1] = triangles_tmp[2]; 1498 edges_tmp[4]->face_[0] = triangles_tmp[1]; edges_tmp[4]->face_[1] = triangles_tmp[7]; 1499 edges_tmp[5]->face_[0] = triangles_tmp[2]; edges_tmp[5]->face_[1] = triangles_tmp[3]; 1500 edges_tmp[6]->face_[0] = triangles_tmp[2]; edges_tmp[6]->face_[1] = triangles_tmp[9]; 1501 edges_tmp[7]->face_[0] = triangles_tmp[3]; edges_tmp[7]->face_[1] = triangles_tmp[4]; 1502 edges_tmp[8]->face_[0] = triangles_tmp[3]; edges_tmp[8]->face_[1] = triangles_tmp[11]; 1503 edges_tmp[9]->face_[0] = triangles_tmp[4]; edges_tmp[9]->face_[1] = triangles_tmp[14]; 1504 edges_tmp[10]->face_[0] = triangles_tmp[5]; edges_tmp[10]->face_[1] = triangles_tmp[13]; 1505 edges_tmp[11]->face_[0] = triangles_tmp[5]; edges_tmp[11]->face_[1] = triangles_tmp[6]; 1506 edges_tmp[12]->face_[0] = triangles_tmp[6]; edges_tmp[12]->face_[1] = triangles_tmp[7]; 1507 edges_tmp[13]->face_[0] = triangles_tmp[6]; edges_tmp[13]->face_[1] = triangles_tmp[15]; 1508 edges_tmp[14]->face_[0] = triangles_tmp[7]; edges_tmp[14]->face_[1] = triangles_tmp[8]; 1509 edges_tmp[15]->face_[0] = triangles_tmp[8]; edges_tmp[15]->face_[1] = triangles_tmp[9]; 1510 edges_tmp[16]->face_[0] = triangles_tmp[8]; edges_tmp[16]->face_[1] = triangles_tmp[16]; 1511 edges_tmp[17]->face_[0] = triangles_tmp[9]; edges_tmp[17]->face_[1] = triangles_tmp[10]; 1512 edges_tmp[18]->face_[0] = triangles_tmp[10]; edges_tmp[18]->face_[1] = triangles_tmp[11]; 1513 edges_tmp[19]->face_[0] = triangles_tmp[10]; edges_tmp[19]->face_[1] = triangles_tmp[17]; 1514 edges_tmp[20]->face_[0] = triangles_tmp[11]; edges_tmp[20]->face_[1] = triangles_tmp[12]; 1515 edges_tmp[21]->face_[0] = triangles_tmp[12]; edges_tmp[21]->face_[1] = triangles_tmp[14]; 1516 edges_tmp[22]->face_[0] = triangles_tmp[12]; edges_tmp[22]->face_[1] = triangles_tmp[18]; 1517 edges_tmp[23]->face_[0] = triangles_tmp[13]; edges_tmp[23]->face_[1] = triangles_tmp[14]; 1518 edges_tmp[24]->face_[0] = triangles_tmp[13]; edges_tmp[24]->face_[1] = triangles_tmp[19]; 1519 edges_tmp[25]->face_[0] = triangles_tmp[15]; edges_tmp[25]->face_[1] = triangles_tmp[19]; 1520 edges_tmp[26]->face_[0] = triangles_tmp[15]; edges_tmp[26]->face_[1] = triangles_tmp[16]; 1521 edges_tmp[27]->face_[0] = triangles_tmp[16]; edges_tmp[27]->face_[1] = triangles_tmp[17]; 1522 edges_tmp[28]->face_[0] = triangles_tmp[17]; edges_tmp[28]->face_[1] = triangles_tmp[18]; 1523 edges_tmp[29]->face_[0] = triangles_tmp[18]; edges_tmp[29]->face_[1] = triangles_tmp[19]; 1524 1525 std::copy(points_tmp.begin(), points_tmp.end(), std::back_inserter(points_)); 1526 std::copy(triangles_tmp.begin(), triangles_tmp.end(), std::back_inserter(triangles_)); 1527 std::copy(edges_tmp.begin(), edges_tmp.end(), std::back_inserter(edges_)); 1528 } 1529 1530 operator <<(std::ostream & s,const TriangulatedSurface & surface)1531 std::ostream& operator << (std::ostream& s, 1532 const TriangulatedSurface& surface) 1533 { 1534 s << "Points: " << surface.getNumberOfPoints() << "\n"; 1535 TriangulatedSurface::ConstPointIterator p; 1536 for (p = surface.beginPoint(); p != surface.endPoint(); p++) 1537 { 1538 s << **p << "\n"; 1539 } 1540 s << "Edges: " << surface.getNumberOfEdges() << "\n"; 1541 TriangulatedSurface::ConstEdgeIterator e; 1542 for (e = surface.beginEdge(); e != surface.endEdge(); e++) 1543 { 1544 s << **e << "\n"; 1545 } 1546 s << "Triangles: " << surface.getNumberOfTriangles() << "\n"; 1547 TriangulatedSurface::ConstTriangleIterator t; 1548 for (t = surface.beginTriangle(); t != surface.endTriangle(); t++) 1549 { 1550 s << **t << "\n"; 1551 } 1552 return s; 1553 } 1554 1555 1556 } // namespace BALL 1557