← Back to branch summary

~ubuntu-branches/debian/stretch/cgal/stretch

« back to all changes in this revision

Viewing changes to demo/Linear_cell_complex/MainWindow.cpp

  • Committer: Package Import Robot
  • Author(s): Joachim Reichel
  • Date: 2014-04-05 10:56:43 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20140405105643-jgnrpu2thtx23zfs
Tags: 4.4-1
* New upstream release.
* Remove patches do-not-link-example-with-qt4-support-library.patch and
  fix_jet_fitting_3.patch (applied upstream).

Show diffs side-by-side

added added

removed removed

Lines of Context:
demo/Linear_cell_complex/MainWindow.cpp
167
167
 
168
168
void MainWindow::on_new_volume(Dart_handle adart)
169
169
{
170
 
  CGAL_assertion( adart->attribute<3>()==NULL);
 
170
  CGAL_assertion( scene.lcc->attribute<3>(adart)==LCC::null_handle);
171
171
  CGAL::Set_i_attribute_functor<LCC, 3>::
172
172
      run(scene.lcc, adart, scene.lcc->create_attribute<3>());
173
 
  update_volume_list_add(adart->attribute<3>());
 
173
  update_volume_list_add(scene.lcc->attribute<3>(adart));
174
174
}
175
175
 
176
176
void MainWindow::init_all_new_volumes()
178
178
  for (LCC::One_dart_per_cell_range<3>::iterator
179
179
       it(scene.lcc->one_dart_per_cell<3>().begin());
180
180
       it.cont(); ++it)
181
 
    if ( it->attribute<3>()==NULL )
 
181
    if ( scene.lcc->attribute<3>(it)==LCC::null_handle )
182
182
    { on_new_volume(it); }
183
183
}
184
184
 
338
338
  on_new_volume(d2);
339
339
  on_new_volume(d3);
340
340
 
341
 
  scene.lcc->sew<3> (d1->beta(1)->beta(1)->beta(2), d2->beta(2));
342
 
  scene.lcc->sew<3> (d1->beta(2)->beta(1)->beta(1)->beta(2), d3);
 
341
  scene.lcc->sew<3>(scene.lcc->beta(d1,1,1,2), scene.lcc->beta(d2,2));
 
342
  scene.lcc->sew<3>(scene.lcc->beta(d1,2,1,1,2), d3);
343
343
 
344
344
  ++nbcube;
345
345
 
356
356
  Dart_handle d3 = make_iso_cuboid(Point_3(nbcube, nbcube + 1, nbcube), 1);
357
357
  Dart_handle d4 = make_iso_cuboid(Point_3(nbcube + 1, nbcube + 1, nbcube), 1);
358
358
 
359
 
  scene.lcc->sew<3>(d1->beta(1)->beta(1)->beta(2), d2->beta (2));
360
 
  scene.lcc->sew<3>(d1->beta(2)->beta(1)->beta(1)->beta (2), d3);
 
359
  scene.lcc->sew<3>(scene.lcc->beta(d1,1,1,2), scene.lcc->beta(d2,2));
 
360
  scene.lcc->sew<3>(scene.lcc->beta(d1,2,1,1,2), d3);
361
361
 
362
 
  scene.lcc->sew<3>(d3->beta(1)->beta(1)->beta(2), d4->beta (2));
363
 
  scene.lcc->sew<3>(d2->beta(2)->beta(1)->beta(1)->beta (2), d4);
 
362
  scene.lcc->sew<3>(scene.lcc->beta(d3,1,1,2), scene.lcc->beta(d4,2));
 
363
  scene.lcc->sew<3>(scene.lcc->beta(d2,2,1,1,2), d4);
364
364
 
365
365
  CGAL::remove_cell<LCC,2>(*scene.lcc, d3);
366
 
  CGAL::remove_cell<LCC,2>(*scene.lcc, d2->beta (2));
 
366
  CGAL::remove_cell<LCC,2>(*scene.lcc, scene.lcc->beta(d2,2));
367
367
 
368
368
  on_new_volume(d1);
369
369
  on_new_volume(d4);
527
527
         it=scene.lcc->darts_of_cell<3>(ddh).begin(),
528
528
         itend=scene.lcc->darts_of_cell<3>(ddh).end(); it!=itend; ++it)
529
529
    {
530
 
      if ( !scene.lcc->is_marked(it->beta(3), mark_toremove) )
 
530
      if ( !scene.lcc->is_marked(scene.lcc->beta(it,3), mark_toremove) )
531
531
      {
532
 
        CGAL::mark_cell<LCC,3>(*scene.lcc, it->beta(3), mark_toremove);
533
 
        toremove.push(it->beta(3));
 
532
        CGAL::mark_cell<LCC,3>(*scene.lcc,
 
533
                               scene.lcc->beta(it,3), mark_toremove);
 
534
        toremove.push(scene.lcc->beta(it,3));
534
535
      }
535
536
    }
536
537
    while( !toremove.empty() )
655
656
  for (LCC::Dart_range::iterator it=scene.lcc->darts().begin();
656
657
       it!=scene.lcc->darts().end(); ++it)
657
658
  {
658
 
    if ( !it->is_free(3) &&
659
 
         it->attribute<3>()->info().is_filled_and_visible() &&
660
 
         it->beta(3)->attribute<3>()->info().is_filled_and_visible())
 
659
    if ( !scene.lcc->is_free(it,3) &&
 
660
         scene.lcc->info<3>(it).is_filled_and_visible() &&
 
661
         scene.lcc->info<3>(scene.lcc->beta(it,3))
 
662
           .is_filled_and_visible())
661
663
    { scene.lcc->unsew<3>(it); ++nb; }
662
664
  }
663
665
 
691
693
       itend=scene.lcc->attributes<3>().end(); it!=itend; )
692
694
  {
693
695
    LCC::Attribute_handle<3>::type cur = it++;
694
 
    if( cur->info().is_filled_and_visible() )
 
696
    if( scene.lcc->get_attribute<3>(cur).info().is_filled_and_visible() )
695
697
    {
696
 
      CGAL::remove_cell<LCC,3>(*scene.lcc,cur->dart());
 
698
      CGAL::remove_cell<LCC,3>(*scene.lcc,scene.lcc->get_attribute<3>(cur).dart());
697
699
      ++count;
698
700
    }
699
701
  }
723
725
  for (LCC::One_dart_per_cell_range<2>::iterator
724
726
       it(scene.lcc->one_dart_per_cell<2>().begin()); it.cont(); ++it)
725
727
  {
726
 
    if ( it->attribute<3>()->info().is_filled_and_visible() )
 
728
    if ( scene.lcc->info<3>(it).is_filled_and_visible() )
727
729
      v.push_back(it);
728
730
  }
729
731
  for (std::vector<LCC::Dart_handle>::iterator itv(v.begin());
749
751
  timer.start();
750
752
#endif
751
753
 
752
 
  Dart_handle prev = NULL;
 
754
  Dart_handle prev = scene.lcc->null_handle;
753
755
  for (LCC::Dart_range::iterator it(scene.lcc->darts().begin()),
754
756
       itend=scene.lcc->darts().end(); it!=itend; )
755
757
  {
756
 
    if ( !it->is_free(3) &&
757
 
         it->attribute<3>()->info().is_filled_and_visible() &&
758
 
         it->beta(3)->attribute<3>()->info().is_filled_and_visible() )
 
758
    if ( !scene.lcc->is_free(it,3) &&
 
759
         scene.lcc->info<3>(it).is_filled_and_visible() &&
 
760
         scene.lcc->info<3>(scene.lcc->beta(it,3))
 
761
          .is_filled_and_visible())
759
762
    {
760
763
      CGAL::remove_cell<LCC,2>(*scene.lcc,it);
761
764
      itend=scene.lcc->darts().end();
762
 
      if ( prev==NULL ) it=scene.lcc->darts().begin();
 
765
      if ( prev==scene.lcc->null_handle ) it=scene.lcc->darts().begin();
763
766
      else { it=prev; if ( it!=itend ) ++it; }
764
767
    }
765
768
    else
787
790
        reinterpret_cast<LCC::Attribute_type<3>::type*>
788
791
        ( volumeList->item(row,3)->data(Qt::UserRole).value<quintptr>() );
789
792
 
790
 
    if(ptr==&*ah) return true;
 
793
    if(ptr==&(scene.lcc->get_attribute<3>(ah))) return true;
791
794
  }
792
795
 
793
796
  return false;
803
806
  volumeList->setRowCount(newRow+1);
804
807
 
805
808
  QTableWidgetItem* volumeLabel = new QTableWidgetItem
806
 
      (QString(ah->info().color_name().c_str()));
 
809
    (QString((scene.lcc->get_attribute<3>(ah).info().color_name().c_str())));
807
810
  volumeLabel->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
808
811
  volumeLabel->setTextAlignment(Qt::AlignRight|Qt::AlignVCenter);
809
812
  volumeList->setItem(newRow,0,volumeLabel);
810
813
 
811
814
  QTableWidgetItem* fillCB = new QTableWidgetItem;
812
815
  fillCB->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
813
 
  if ( ah->info().is_filled() ) fillCB->setCheckState(Qt::Checked);
814
 
  else                          fillCB->setCheckState(Qt::Unchecked);
 
816
  if ( scene.lcc->get_attribute<3>(ah).info().is_filled() )
 
817
    fillCB->setCheckState(Qt::Checked);
 
818
  else
 
819
    fillCB->setCheckState(Qt::Unchecked);
815
820
  volumeList->setItem(newRow,1, fillCB);
816
821
 
817
822
  QTableWidgetItem* hiddenCB = new QTableWidgetItem();
818
823
  hiddenCB->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
819
 
  if ( ah->info().is_visible() ) hiddenCB->setCheckState(Qt::Unchecked);
820
 
  else                           hiddenCB->setCheckState(Qt::Checked);
 
824
  if ( scene.lcc->get_attribute<3>(ah).info().is_visible() )
 
825
    hiddenCB->setCheckState(Qt::Unchecked);
 
826
  else
 
827
    hiddenCB->setCheckState(Qt::Checked);
821
828
  volumeList->setItem(newRow,2,hiddenCB);
822
829
 
823
830
  QTableWidgetItem* attribHandle = new QTableWidgetItem;
824
831
  attribHandle->setData
825
 
      (Qt::UserRole, reinterpret_cast<quintptr>(&*(ah)));
 
832
      (Qt::UserRole, reinterpret_cast<quintptr>(&scene.lcc->get_attribute<3>(ah)));
826
833
 
827
834
  volumeList->setItem(newRow,3,attribHandle);
828
835
 
843
850
        reinterpret_cast<LCC::Attribute_type<3>::type*>
844
851
        ( volumeList->item(row,3)->data(Qt::UserRole).value<quintptr>() );
845
852
 
846
 
    if(ptr==&*ah)
 
853
    if(ptr==&scene.lcc->get_attribute<3>(ah))
847
854
    {
848
855
      update_volume_list_remove(row);
849
856
      return;
925
932
      switch(qApp->keyboardModifiers())
926
933
      {
927
934
      case(Qt::ShiftModifier):
928
 
        if (col==1) ptr->info().set_filled(false);
 
935
        if (col==1)
 
936
          ptr->info().set_filled(false);
929
937
        else if (col==2)
930
938
        {
931
939
          ptr->info().set_visible(true);
935
943
        volumeList->item(i,col)->setCheckState(Qt::Unchecked);
936
944
        break;
937
945
      case(Qt::ControlModifier):
938
 
        if (col==1) ptr->info().negate_filled();
 
946
        if (col==1)
 
947
          ptr->info().negate_filled();
939
948
        else if (col==2)
940
949
        {
941
950
          ptr->info().negate_visible();
951
960
                            Qt::Unchecked: Qt::Checked);
952
961
        break;
953
962
      default:
954
 
        if (col==1) ptr->info().set_filled(true);
 
963
        if (col==1)
 
964
          ptr->info().set_filled(true);
955
965
        else if (col==2)
956
966
        {
957
967
          if ( ptr->info().is_visible() )
977
987
       it=scene.lcc->attributes<3>().begin(),
978
988
       itend=scene.lcc->attributes<3>().end(); it!=itend; ++it)
979
989
  {
980
 
    if ( it->info().is_filled_and_visible() &&
 
990
    if ( scene.lcc->get_attribute<3>(it).info().is_filled_and_visible() &&
981
991
         !scene.lcc->is_marked(it->dart(), amark) )
982
 
      CGAL::mark_cell<LCC,3>(*scene.lcc, it->dart(), amark);
 
992
      CGAL::mark_cell<LCC,3>(*scene.lcc,
 
993
                             scene.lcc->get_attribute<3>(it).dart(), amark);
983
994
  }
984
995
}
985
996
 
998
1009
  {
999
1010
    if ( !scene.lcc->is_marked(it->dart(), mark_volume) )
1000
1011
    {
1001
 
      if ( !it->info().is_filled() )
 
1012
      if ( !scene.lcc->get_attribute<3>(it).info().is_filled() )
1002
1013
      {
1003
1014
        already_tofill = false;
1004
1015
        for (LCC::Dart_of_cell_basic_range<3>::iterator it2=
1006
1017
             it2.cont(); ++it2 )
1007
1018
        {
1008
1019
          scene.lcc->mark(it2, mark_volume);
1009
 
          if ( !it2->is_free(3) &&
1010
 
               it2->beta(3)->attribute<3>()->info().is_filled() &&
1011
 
               !already_tofill)
 
1020
          if ( !scene.lcc->is_free(it2,3) &&
 
1021
               scene.lcc->info<3>(scene.lcc->beta(it2,3)).
 
1022
                 is_filled() && !already_tofill)
1012
1023
          {
1013
 
            tofill.push_back(it2->attribute<3>());
 
1024
            tofill.push_back(scene.lcc->attribute<3>(it2));
1014
1025
            already_tofill = true;
1015
1026
          }
1016
1027
        }
1028
1039
    for ( std::vector<LCC::Attribute_handle<3>::type>::iterator
1029
1040
            it=tofill.begin(), itend=tofill.end(); it!=itend; ++it )
1030
1041
    {
1031
 
      (*it)->info().set_filled(true);
 
1042
      scene.lcc->get_attribute<3>(*it).info().set_filled(true);
1032
1043
    }
1033
1044
 
1034
1045
    update_volume_list_all_ckeckstates();
1053
1064
  {
1054
1065
    if ( !scene.lcc->is_marked(it->dart(), mark_volume) )
1055
1066
    {
1056
 
      if ( it->info().is_visible() )
 
1067
      if ( scene.lcc->get_attribute<3>(it).info().is_visible() )
1057
1068
      {
1058
1069
        already_tohide = false;
1059
1070
        for (LCC::Dart_of_cell_basic_range<3>::iterator it2=
1061
1072
             it2.cont(); ++it2 )
1062
1073
        {
1063
1074
          scene.lcc->mark(it2, mark_volume);
1064
 
          if ( !it2->is_free(3) &&
1065
 
               !it2->beta(3)->attribute<3>()->info().is_visible() &&
1066
 
               !already_tohide)
 
1075
          if ( !scene.lcc->is_free(it2,3) &&
 
1076
               !scene.lcc->info<3>(scene.lcc->beta(it2,3)).
 
1077
                  is_visible() && !already_tohide)
1067
1078
          {
1068
 
            tohide.push_back(it2->attribute<3>());
 
1079
            tohide.push_back(scene.lcc->attribute<3>(it2));
1069
1080
            already_tohide = true;
1070
1081
          }
1071
1082
        }
1083
1094
    for ( std::vector<LCC::Attribute_handle<3>::type>::iterator
1084
1095
            it=tohide.begin(), itend=tohide.end(); it!=itend; ++it )
1085
1096
    {
1086
 
      (*it)->info().set_visible(false);
 
1097
      scene.lcc->get_attribute<3>(*it).info().set_visible(false);
1087
1098
    }
1088
1099
 
1089
1100
    update_volume_list_all_ckeckstates();
1227
1238
 
1228
1239
void MainWindow::split_edge_in_three(Dart_handle dh)
1229
1240
{
1230
 
  LCC::Point p1 = LCC::point(dh);
1231
 
  LCC::Point p2 = LCC::point(dh->other_extremity());
 
1241
  LCC::Point p1 = scene.lcc->point(dh);
 
1242
  LCC::Point p2 = scene.lcc->point(scene.lcc->other_extremity(dh));
1232
1243
 
1233
1244
  LCC::Vector v1 = LCC::Traits::Construct_vector() (p1,p2);
1234
1245
  LCC::Vector v2 = LCC::Traits::Construct_scaled_vector() (v1,1.0/3);
1243
1254
 
1244
1255
void MainWindow::split_face_in_three(Dart_handle dh)
1245
1256
{
1246
 
  CGAL::insert_cell_1_in_cell_2(*(scene.lcc),dh->beta(1)->beta(1)->beta(1),
1247
 
                                dh->beta(0)->beta(0));
1248
 
  CGAL::insert_cell_1_in_cell_2(*(scene.lcc),dh->beta(1)->beta(1),dh->beta(0));
 
1257
  CGAL::insert_cell_1_in_cell_2(*(scene.lcc),scene.lcc->beta(dh,1,1,1),
 
1258
                                scene.lcc->beta(dh,0,0));
 
1259
  CGAL::insert_cell_1_in_cell_2(*(scene.lcc),scene.lcc->beta(dh,1,1),
 
1260
                                scene.lcc->beta(dh,0));
1249
1261
}
1250
1262
 
1251
1263
void MainWindow::split_face_in_nine(Dart_handle dh)
1252
1264
{
1253
 
  Dart_handle d2 = dh->beta(1)->beta(1)->beta(1)->beta(1)
1254
 
      ->beta(1)->beta(1)->beta(1);
 
1265
  Dart_handle d2 = scene.lcc->beta(dh,1,1,1,1,1,1,1);
1255
1266
 
1256
1267
  Dart_handle e2= CGAL::insert_cell_1_in_cell_2(*(scene.lcc),
1257
 
                                                dh->beta(1)->beta(1),d2);
 
1268
                                                scene.lcc->beta(dh,1,1),d2);
1258
1269
  Dart_handle e1= CGAL::insert_cell_1_in_cell_2(*(scene.lcc),
1259
 
                                                dh->beta(1),d2->beta(1));
 
1270
                                                scene.lcc->beta(dh,1),
 
1271
                                                scene.lcc->beta(d2,1));
1260
1272
 
1261
1273
  split_edge_in_three(e1);
1262
1274
  split_edge_in_three(e2);
1263
1275
 
1264
1276
  split_face_in_three(dh);
1265
1277
  split_face_in_three(d2);
1266
 
  split_face_in_three(e2->beta(0));
 
1278
  split_face_in_three(scene.lcc->beta(e2,0));
1267
1279
}
1268
1280
 
1269
1281
void MainWindow::split_vol_in_three(Dart_handle dh, bool removecenter)
1271
1283
  std::vector<Dart_handle> edges1;
1272
1284
  std::vector<Dart_handle> edges2;
1273
1285
 
1274
 
  Dart_handle curd = dh->beta(2)->beta(1)->beta(1)->beta(2);
 
1286
  Dart_handle curd = scene.lcc->beta(dh,2,1,1,2);
1275
1287
  for (unsigned int i=0;i<4;++i)
1276
1288
  {
1277
1289
    edges1.push_back(curd);
1278
 
    curd=curd->beta(1)->beta(2)->beta(1);
 
1290
    curd=scene.lcc->beta(curd,1,2,1);
1279
1291
  }
1280
 
  CGAL_assertion( curd==dh->beta(2)->beta(1)->beta(1)->beta(2) );
 
1292
  CGAL_assertion( curd==scene.lcc->beta(dh,2,1,1,2) );
1281
1293
 
1282
 
  curd = curd->beta(1)->beta(1)->beta(2);
 
1294
  curd = scene.lcc->beta(curd,1,1,2);
1283
1295
  for (unsigned int i=0;i<4;++i)
1284
1296
  {
1285
1297
    edges2.push_back(curd);
1286
 
    curd=curd->beta(1)->beta(2)->beta(1);
 
1298
    curd=scene.lcc->beta(curd,1,2,1);
1287
1299
  }
1288
1300
  CGAL_assertion( curd==
1289
 
          dh->beta(2)->beta(1)->beta(1)->beta(2)->beta(1)->beta(1)->beta(2) );
 
1301
                  scene.lcc->beta(dh,2,1,1,2,1,1,2) );
1290
1302
 
1291
1303
  Dart_handle f1=
1292
1304
      insert_cell_2_in_cell_3(*(scene.lcc),edges1.begin(),edges1.end());
1294
1306
  Dart_handle f2=
1295
1307
      insert_cell_2_in_cell_3(*(scene.lcc),edges2.begin(),edges2.end());
1296
1308
 
1297
 
  f1->attribute<3>()->info().color()=
 
1309
  scene.lcc->info<3>(f1).color()=
1298
1310
    (CGAL::Color(myrandom.get_int(0,256),
1299
1311
                 myrandom.get_int(0,256),
1300
1312
                 myrandom.get_int(0,256)));
1301
 
  f2->attribute<3>()->info().color()=
 
1313
  scene.lcc->info<3>(f2).color()=
1302
1314
      (CGAL::Color(myrandom.get_int(0,256),
1303
1315
                   myrandom.get_int(0,256),
1304
1316
                   myrandom.get_int(0,256)));
1305
1317
 
1306
 
  update_volume_list_add(dh->attribute<3>());
 
1318
  update_volume_list_add(scene.lcc->attribute<3>(dh));
1307
1319
 
1308
1320
  if ( removecenter )
1309
1321
    CGAL::remove_cell<LCC,3>(*scene.lcc,f1);
1310
1322
  else
1311
1323
  {
1312
1324
    mengerVolumes.push_back(f1);
1313
 
    update_volume_list_add(f1->attribute<3>());
 
1325
    update_volume_list_add(scene.lcc->attribute<3>(f1));
1314
1326
  }
1315
1327
 
1316
1328
  mengerVolumes.push_back(f2);
1321
1333
  std::vector<Dart_handle> edges1;
1322
1334
  std::vector<Dart_handle> edges2;
1323
1335
 
1324
 
  Dart_handle curd = dh->beta(1)->beta(2);
 
1336
  Dart_handle curd = scene.lcc->beta(dh,1,2);
1325
1337
  for (unsigned int i=0;i<8;++i)
1326
1338
  {
1327
1339
    edges1.push_back(curd);
1328
 
    curd=curd->beta(1)->beta(2)->beta(1);
 
1340
    curd=scene.lcc->beta(curd,1,2,1);
1329
1341
  }
1330
 
  CGAL_assertion( curd==dh->beta(1)->beta(2) );
 
1342
  CGAL_assertion( curd==scene.lcc->beta(dh,1,2) );
1331
1343
 
1332
 
  curd = curd->beta(1)->beta(1)->beta(2);
 
1344
  curd = scene.lcc->beta(curd,1,1,2);
1333
1345
  for (unsigned int i=0;i<8;++i)
1334
1346
  {
1335
1347
    edges2.push_back(curd);
1336
 
    curd=curd->beta(1)->beta(2)->beta(1);
 
1348
    curd=scene.lcc->beta(curd,1,2,1);
1337
1349
  }
1338
 
  CGAL_assertion( curd==dh->beta(1)->beta(2)->beta(1)->beta(1)->beta(2) );
 
1350
  CGAL_assertion( curd==scene.lcc->beta(dh,1,2,1,1,2) );
1339
1351
 
1340
1352
  Dart_handle f1=
1341
1353
      insert_cell_2_in_cell_3(*(scene.lcc),edges1.begin(),edges1.end());
1343
1355
  Dart_handle f2=
1344
1356
      insert_cell_2_in_cell_3(*(scene.lcc),edges2.begin(),edges2.end());
1345
1357
 
1346
 
  f1->attribute<3>()->info().color()=
 
1358
  scene.lcc->info<3>(f1).color()=
1347
1359
    (CGAL::Color(myrandom.get_int(0,256),
1348
1360
                 myrandom.get_int(0,256),
1349
1361
                 myrandom.get_int(0,256)));
1350
 
  f2->attribute<3>()->info().color()=
 
1362
  scene.lcc->info<3>(f2).color()=
1351
1363
    (CGAL::Color(myrandom.get_int(0,256),
1352
1364
                 myrandom.get_int(0,256),
1353
1365
                 myrandom.get_int(0,256)));
1354
1366
 
1355
 
  update_volume_list_add(dh->attribute<3>());
 
1367
  update_volume_list_add(scene.lcc->attribute<3>(dh));
1356
1368
  if ( !removecenter)
1357
 
    update_volume_list_add(f1->attribute<3>());
 
1369
    update_volume_list_add(scene.lcc->attribute<3>(f1));
1358
1370
 
1359
1371
  split_face_in_three(f1);
1360
1372
  split_face_in_three(f2);
1361
1373
 
1362
1374
  split_vol_in_three(dh,removecenter);
1363
1375
 
1364
 
  mengerVolumes.push_back(f2->beta(2)->beta(1));
1365
 
  split_vol_in_three(f2->beta(2)->beta(1),removecenter);
 
1376
  mengerVolumes.push_back(scene.lcc->beta(f2,2,1));
 
1377
  split_vol_in_three(scene.lcc->beta(f2,2,1),removecenter);
1366
1378
 
1367
1379
  if ( removecenter )
1368
1380
    CGAL::remove_cell<LCC,3>(*scene.lcc,f1);
1369
1381
  else
1370
1382
  {
1371
 
    mengerVolumes.push_back(f1->beta(2)->beta(1));
1372
 
    split_vol_in_three(f1->beta(2)->beta(1),true);
 
1383
    mengerVolumes.push_back(scene.lcc->beta(f1,2,1));
 
1384
    split_vol_in_three(scene.lcc->beta(f1,2,1),true);
1373
1385
  }
1374
1386
}
1375
1387
 
1378
1390
  std::vector<Dart_handle> edges1;
1379
1391
  std::vector<Dart_handle> edges2;
1380
1392
 
1381
 
  Dart_handle curd = dh->beta(1)->beta(1)->beta(2);
 
1393
  Dart_handle curd = scene.lcc->beta(dh,1,1,2);
1382
1394
  for (unsigned int i=0;i<12;++i)
1383
1395
  {
1384
1396
    edges1.push_back(curd);
1385
 
    curd=curd->beta(1)->beta(2)->beta(1);
 
1397
    curd=scene.lcc->beta(curd,1,2,1);
1386
1398
  }
1387
 
  CGAL_assertion( curd==dh->beta(1)->beta(1)->beta(2) );
 
1399
  CGAL_assertion( curd==scene.lcc->beta(dh,1,1,2) );
1388
1400
 
1389
 
  curd = curd->beta(1)->beta(1)->beta(2);
 
1401
  curd = scene.lcc->beta(curd,1,1,2);
1390
1402
  for (unsigned int i=0;i<12;++i)
1391
1403
  {
1392
1404
    edges2.push_back(curd);
1393
 
    curd=curd->beta(1)->beta(2)->beta(1);
 
1405
    curd=scene.lcc->beta(curd,1,2,1);
1394
1406
  }
1395
 
  CGAL_assertion( curd==dh->beta(1)->beta(1)->beta(2)->beta(1)->beta(1)->beta(2) );
 
1407
  CGAL_assertion( curd==scene.lcc->beta(dh,1,1,2,1,1,2) );
1396
1408
 
1397
1409
  Dart_handle f1=
1398
1410
      insert_cell_2_in_cell_3(*(scene.lcc),edges1.begin(),edges1.end());
1400
1412
  Dart_handle f2=
1401
1413
      insert_cell_2_in_cell_3(*(scene.lcc),edges2.begin(),edges2.end());
1402
1414
 
1403
 
  f1->attribute<3>()->info().color()=
1404
 
    (CGAL::Color(myrandom.get_int(0,256),
1405
 
                 myrandom.get_int(0,256),
1406
 
                 myrandom.get_int(0,256)));
1407
 
  f2->attribute<3>()->info().color()=
1408
 
    (CGAL::Color(myrandom.get_int(0,256),
1409
 
                 myrandom.get_int(0,256),
1410
 
                 myrandom.get_int(0,256)));
1411
 
 
1412
 
  update_volume_list_add(dh->attribute<3>());
1413
 
  update_volume_list_add(f1->attribute<3>());
1414
 
 
1415
 
  mengerVolumes.push_back(f1->beta(2));
1416
 
  mengerVolumes.push_back(f2->beta(2));
1417
 
 
1418
 
  split_face_in_nine(f1->beta(1));
1419
 
  split_face_in_nine(f2->beta(1));
 
1415
  scene.lcc->info<3>(f1).color()=
 
1416
    (CGAL::Color(myrandom.get_int(0,256),
 
1417
                 myrandom.get_int(0,256),
 
1418
                 myrandom.get_int(0,256)));
 
1419
  scene.lcc->info<3>(f2).color()=
 
1420
    (CGAL::Color(myrandom.get_int(0,256),
 
1421
                 myrandom.get_int(0,256),
 
1422
                 myrandom.get_int(0,256)));
 
1423
 
 
1424
  update_volume_list_add(scene.lcc->attribute<3>(dh));
 
1425
  update_volume_list_add(scene.lcc->attribute<3>(f1));
 
1426
 
 
1427
  mengerVolumes.push_back(scene.lcc->beta(f1,2));
 
1428
  mengerVolumes.push_back(scene.lcc->beta(f2,2));
 
1429
 
 
1430
  split_face_in_nine(scene.lcc->beta(f1,1));
 
1431
  split_face_in_nine(scene.lcc->beta(f2,1));
1420
1432
 
1421
1433
  split_vol_in_nine(dh,false);
1422
 
  split_vol_in_nine(f1->beta(2),true);
1423
 
  split_vol_in_nine(f2->beta(2),false);
 
1434
  split_vol_in_nine(scene.lcc->beta(f1,2),true);
 
1435
  split_vol_in_nine(scene.lcc->beta(f2,2),false);
1424
1436
}
1425
1437
 
1426
1438
void MainWindow::process_full_slice(Dart_handle init,
1428
1440
                                  int markVols)
1429
1441
{
1430
1442
  Dart_handle d[12];
1431
 
  d[0]=init->beta(1)->beta(2);
1432
 
  d[1]=d[0]->beta(3)->beta(1)->beta(2)->beta(1);
1433
 
  d[2]=d[1]->beta(1)->beta(2)->beta(1);
1434
 
  d[3]=d[2]->beta(3)->beta(1)->beta(2)->beta(1);
1435
 
 
1436
 
  d[4]=init->beta(1)->beta(1)->beta(2);
1437
 
  d[5]=d[4]->beta(3)->beta(0)->beta(2)->beta(0);
1438
 
  d[6]=d[5]->beta(0)->beta(2)->beta(0);
1439
 
 
1440
 
  d[7]=d[6]->beta(3)->beta(0)->beta(2)->beta(0);
1441
 
  d[8]=d[7]->beta(3)->beta(0)->beta(2)->beta(0);
1442
 
  d[9]=d[8]->beta(0)->beta(2)->beta(0);
1443
 
 
1444
 
  d[10]=d[9]->beta(3)->beta(0)->beta(2)->beta(0);
1445
 
  d[11]=d[10]->beta(3)->beta(0)->beta(2)->beta(0);
 
1443
  d[0]=scene.lcc->beta(init,1,2);
 
1444
  d[1]=scene.lcc->beta(d[0],3,1,2,1);
 
1445
  d[2]=scene.lcc->beta(d[1],1,2,1);
 
1446
  d[3]=scene.lcc->beta(d[2],3,1,2,1);
 
1447
 
 
1448
  d[4]=scene.lcc->beta(init,1,1,2);
 
1449
  d[5]=scene.lcc->beta(d[4],3,0,2,0);
 
1450
  d[6]=scene.lcc->beta(d[5],0,2,0);
 
1451
 
 
1452
  d[7]=scene.lcc->beta(d[6],3,0,2,0);
 
1453
  d[8]=scene.lcc->beta(d[7],3,0,2,0);
 
1454
  d[9]=scene.lcc->beta(d[8],0,2,0);
 
1455
 
 
1456
  d[10]=scene.lcc->beta(d[9],3,0,2,0);
 
1457
  d[11]=scene.lcc->beta(d[10],3,0,2,0);
1446
1458
 
1447
1459
  for (unsigned int j=0; j<12; ++j)
1448
1460
  {
1460
1472
{
1461
1473
  Dart_handle d[24];
1462
1474
  d[0]=init;
1463
 
  d[1]=d[0]->beta(0)->beta(2)->beta(3)->beta(2)->beta(0);
1464
 
  d[2]=d[1]->beta(0)->beta(2)->beta(3)->beta(2)->beta(0);
1465
 
  d[3]=d[2]->beta(1)->beta(1)->beta(2)->beta(3)->beta(2);
1466
 
  d[4]=d[3]->beta(1)->beta(1)->beta(2)->beta(3)->beta(2);
1467
 
  d[5]=d[0]->beta(1)->beta(1)->beta(2)->beta(3)->beta(2);
1468
 
  d[6]=d[5]->beta(1)->beta(1)->beta(2)->beta(3)->beta(2);
1469
 
  d[7]=d[6]->beta(0)->beta(2)->beta(3)->beta(2)->beta(0);
 
1475
  d[1]=scene.lcc->beta(d[0],0,2,3,2,0);
 
1476
  d[2]=scene.lcc->beta(d[1],0,2,3,2,0);
 
1477
  d[3]=scene.lcc->beta(d[2],1,1,2,3,2);
 
1478
  d[4]=scene.lcc->beta(d[3],1,1,2,3,2);
 
1479
  d[5]=scene.lcc->beta(d[0],1,1,2,3,2);
 
1480
  d[6]=scene.lcc->beta(d[5],1,1,2,3,2);
 
1481
  d[7]=scene.lcc->beta(d[6],0,2,3,2,0);
1470
1482
 
1471
 
  init = init->beta(3)->beta(2)->beta(1)->beta(1)->beta(2);
 
1483
  init = scene.lcc->beta(init,3,2,1,1,2);
1472
1484
  d[8]=init;
1473
 
  d[9]=d[8]->beta(3)->beta(1)->beta(2)->beta(3)->beta(2)->beta(1);
1474
 
  d[10]=d[9]->beta(1)->beta(2)->beta(3)->beta(2)->beta(1)->beta(3);
1475
 
  d[11]=d[10]->beta(3)->beta(0)->beta(0)->beta(2)->beta(3)->beta(2);
1476
 
  d[12]=d[11]->beta(0)->beta(0)->beta(2)->beta(3)->beta(2)->beta(3);
1477
 
  d[13]=d[8]->beta(3)->beta(0)->beta(0)->beta(2)->beta(3)->beta(2);
1478
 
  d[14]=d[13]->beta(0)->beta(0)->beta(2)->beta(3)->beta(2)->beta(3);
1479
 
  d[15]=d[14]->beta(3)->beta(1)->beta(2)->beta(3)->beta(2)->beta(1);
1480
 
 
1481
 
  d[16]=d[0]->beta(3)->beta(1)->beta(2);
1482
 
  d[17]=d[0]->beta(3)->beta(1)->beta(1)->beta(2);
1483
 
 
1484
 
  d[18]=d[4]->beta(3)->beta(2);
1485
 
  d[19]=d[4]->beta(3)->beta(0)->beta(2);
1486
 
 
1487
 
  d[20]=d[2]->beta(3)->beta(0)->beta(2);
1488
 
  d[21]=d[2]->beta(3)->beta(1)->beta(1)->beta(2);
1489
 
 
1490
 
  d[22]=d[6]->beta(3)->beta(2);
1491
 
  d[23]=d[6]->beta(3)->beta(1)->beta(2);
 
1485
  d[9]=scene.lcc->beta(d[8],3,1,2,3,2,1);
 
1486
  d[10]=scene.lcc->beta(d[9],1,2,3,2,1,3);
 
1487
  d[11]=scene.lcc->beta(d[10],3,0,0,2,3,2);
 
1488
  d[12]=scene.lcc->beta(d[11],0,0,2,3,2,3);
 
1489
  d[13]=scene.lcc->beta(d[8],3,0,0,2,3,2);
 
1490
  d[14]=scene.lcc->beta(d[13],0,0,2,3,2,3);
 
1491
  d[15]=scene.lcc->beta(d[14],3,1,2,3,2,1);
 
1492
 
 
1493
  d[16]=scene.lcc->beta(d[0],3,1,2);
 
1494
  d[17]=scene.lcc->beta(d[0],3,1,1,2);
 
1495
 
 
1496
  d[18]=scene.lcc->beta(d[4],3,2);
 
1497
  d[19]=scene.lcc->beta(d[4],3,0,2);
 
1498
 
 
1499
  d[20]=scene.lcc->beta(d[2],3,0,2);
 
1500
  d[21]=scene.lcc->beta(d[2],3,1,1,2);
 
1501
 
 
1502
  d[22]=scene.lcc->beta(d[6],3,2);
 
1503
  d[23]=scene.lcc->beta(d[6],3,1,2);
1492
1504
 
1493
1505
  for (unsigned int j=0; j<24; ++j)
1494
1506
  {
1495
 
    CGAL_assertion( d[j]!=LCC::null_dart_handle );
 
1507
    CGAL_assertion( d[j]!=(scene.lcc)->null_dart_handle );
1496
1508
    if ( !(scene.lcc)->is_marked(d[j], markVols) )
1497
1509
    {
1498
1510
      CGAL::mark_cell<LCC,3>(*(scene.lcc), d[j], markVols);
1530
1542
      Dart_handle init=*itvol;
1531
1543
      CGAL::mark_cell<LCC,3>(*(scene.lcc), init, markVols);
1532
1544
      process_full_slice(init, faces, markVols);
1533
 
      init=init->beta(2)->beta(1)->beta(1)->beta(2);
 
1545
      init=scene.lcc->beta(init, 2,1,1,2);
1534
1546
      process_inter_slice(init, faces, markVols);
1535
 
      init=init->beta(3)->beta(2)->beta(1)->beta(1)->beta(2)->beta(3);
 
1547
      init=scene.lcc->beta(init, 3,2,1,1,2,3);
1536
1548
      process_full_slice(init, faces, markVols);
1537
1549
    }
1538
1550
  }
1555
1567
           itend=scene.lcc->darts_of_cell<3>(*itvol).end();
1556
1568
         it!=itend; ++it)
1557
1569
    {
1558
 
      if ( it->is_free(2) && ( it->is_free(3) || &*it<&*it->beta(3) ) )
 
1570
      if ( scene.lcc->is_free(it,2) &&
 
1571
           ( scene.lcc->is_free(it,3) || it<scene.lcc->beta(it,3) ) )
1559
1572
        edges.push_back(it);
1560
1573
    }
1561
1574
  }
1564
1577
 
1565
1578
  for(unsigned int i = 0; i < edges.size(); i++)
1566
1579
  {
1567
 
    CGAL::remove_cell<LCC,1>(*scene.lcc, edges[i]->beta(0));
1568
 
    CGAL::remove_cell<LCC,1>(*scene.lcc, edges[i]->beta(1));
 
1580
    CGAL::remove_cell<LCC,1>(*scene.lcc, scene.lcc->beta(edges[i],0));
 
1581
    CGAL::remove_cell<LCC,1>(*scene.lcc, scene.lcc->beta(edges[i],1));
1569
1582
    CGAL::remove_cell<LCC,1>(*scene.lcc, edges[i]);
1570
1583
  }
1571
1584
  edges.clear();