guimainwindow.cpp

   1 //
   2 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   3 // +                                                                      +
   4 // + This file is part of enGrid.                                         +
   5 // +                                                                      +
   6 // + Copyright 2008,2009 Oliver Gloth                                     +
   7 // +                                                                      +
   8 // + enGrid is free software: you can redistribute it and/or modify       +
   9 // + it under the terms of the GNU General Public License as published by +
  10 // + the Free Software Foundation, either version 3 of the License, or    +
  11 // + (at your option) any later version.                                  +
  12 // +                                                                      +
  13 // + enGrid is distributed in the hope that it will be useful,            +
  14 // + but WITHOUT ANY WARRANTY; without even the implied warranty of       +
  15 // + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        +
  16 // + GNU General Public License for more details.                         +
  17 // +                                                                      +
  18 // + You should have received a copy of the GNU General Public License    +
  19 // + along with enGrid. If not, see <http://www.gnu.org/licenses/>.       +
  20 // +                                                                      +
  21 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  22 //
  23 #include "guimainwindow.h"
  24 #include "guiselectboundarycodes.h"
  25 #include "guiimproveaspectratio.h"
  26 #include "guinormalextrusion.h"
  27 #include "guisetboundarycode.h"
  28 #include "guipick.h"
  29
  30 #include "vtkEgPolyDataToUnstructuredGridFilter.h"
  31 #include "stlreader.h"
  32 #include "gmshreader.h"
  33 #include "gmshwriter.h"
  34 #include "neutralwriter.h"
  35 #include "stlwriter.h"
  36 #include "correctsurfaceorientation.h"
  37 #include "guieditboundaryconditions.h"
  38
  39 #include <vtkRenderer.h>
  40 #include <vtkRenderWindow.h>
  41 #include <vtkXMLUnstructuredGridWriter.h>
  42 #include <vtkXMLUnstructuredGridReader.h>
  43 #include <vtkProperty.h>
  44 #include <vtkCallbackCommand.h>
  45 #include <vtkCamera.h>
  46 #include <vtkCharArray.h>
  47 #include <vtkTextActor.h>
  48 #include <vtkVectorText.h>
  49 #include <vtkFollower.h>
  50 #include <vtkLookupTable.h>
  51 #include <vtkScalarBarActor.h>
  52
  53 #include <QFileDialog>
  54 #include <QFileSystemWatcher>
  55 #include <stdlib.h>
  56 #include <stdio.h>
  57
  58 #include "geometrytools.h"
  59 using namespace GeometryTools;
  60
  61 #include "guisettingsviewer.h"
  62 #include "guitransform.h"
  63
  64 // GuiOutputWindow::GuiOutputWindow()
  65 // {
  66 //   ui.setupUi(this);
  67 // };
  68
  69 QString GuiMainWindow::cwd = ".";
  70 QSettings GuiMainWindow::qset("enGits","enGrid");
  71 GuiMainWindow* GuiMainWindow::THIS = NULL;
  72 QMutex GuiMainWindow::mutex;
  73 vtkIdType GuiMainWindow::PickedPoint;
  74 vtkIdType GuiMainWindow::PickedCell;
  75 bool GuiMainWindow::m_UseVTKInteractor;
  76
  77 GuiMainWindow::GuiMainWindow() : QMainWindow(NULL)
  78 {
  79   ui.setupUi(this);
  80   THIS = this;
  81
  82   QPoint pos = qset.value("pos", QPoint(200, 200)).toPoint();
  83   QSize size = qset.value("size", QSize(400, 400)).toSize();
  84   resize(size);
  85   move(pos);
  86
  87 //   dock_widget = new QDockWidget(tr("output"), this);
  88 //   dock_widget->setFeatures(QDockWidget::AllDockWidgetFeatures);
  89 //   output_window = new GuiOutputWindow();
  90 //   dock_widget->setWidget(output_window);
  91 //   addDockWidget(Qt::LeftDockWidgetArea, dock_widget);
  92 //   ui.menuView->addAction(dock_widget->toggleViewAction());
  93
  94   connect(ui.actionImportSTL,              SIGNAL(activated()),       this, SLOT(importSTL()));
  95   connect(ui.actionImportGmsh1Ascii,       SIGNAL(activated()),       this, SLOT(importGmsh1Ascii()));
  96   connect(ui.actionImportGmsh2Ascii,       SIGNAL(activated()),       this, SLOT(importGmsh2Ascii()));
  97   connect(ui.actionExportGmsh1Ascii,       SIGNAL(activated()),       this, SLOT(exportGmsh1Ascii()));
  98   connect(ui.actionExportGmsh2Ascii,       SIGNAL(activated()),       this, SLOT(exportGmsh2Ascii()));
  99   connect(ui.actionExportNeutral,          SIGNAL(activated()),       this, SLOT(exportNeutral()));
 100   connect(ui.actionExportAsciiStl,         SIGNAL(activated()),       this, SLOT(exportAsciiStl()));
 101   connect(ui.actionExportBinaryStl,        SIGNAL(activated()),       this, SLOT(exportBinaryStl()));
 102   connect(ui.actionExit,                   SIGNAL(activated()),       this, SLOT(exit()));
 103   connect(ui.actionZoomAll,                SIGNAL(activated()),       this, SLOT(zoomAll()));
 104   connect(ui.actionOpen,                   SIGNAL(activated()),       this, SLOT(open()));
 105   connect(ui.actionSave,                   SIGNAL(activated()),       this, SLOT(save()));
 106   connect(ui.actionSaveAs,                 SIGNAL(activated()),       this, SLOT(saveAs()));
 107   connect(ui.actionBoundaryCodes,          SIGNAL(activated()),       this, SLOT(selectBoundaryCodes()));
 108   connect(ui.actionNormalExtrusion,        SIGNAL(activated()),       this, SLOT(normalExtrusion()));
 109   connect(ui.actionViewAxes,               SIGNAL(changed()),         this, SLOT(setAxesVisibility()));
 110   connect(ui.actionViewOrthogonal,         SIGNAL(changed()),         this, SLOT(setViewingMode()));
 111   connect(ui.actionViewNodeIDs,            SIGNAL(changed()),         this, SLOT(ViewNodeIDs()));
 112   connect(ui.actionViewCellIDs,            SIGNAL(changed()),         this, SLOT(ViewCellIDs()));
 113   connect(ui.actionChangeOrientation,      SIGNAL(activated()),       this, SLOT(changeSurfaceOrientation()));
 114   connect(ui.actionCheckOrientation,       SIGNAL(activated()),       this, SLOT(checkSurfaceOrientation()));
 115   connect(ui.actionImproveAspectRatio,     SIGNAL(activated()),       this, SLOT(improveAspectRatio()));
 116   connect(ui.actionRedraw,                 SIGNAL(activated()),       this, SLOT(updateActors()));
 117   connect(ui.actionScaleToData,            SIGNAL(activated()),       this, SLOT(ScaleToData()));
 118   connect(ui.actionClearOutputWindow,      SIGNAL(activated()),       this, SLOT(clearOutput()));
 119   connect(ui.actionEditBoundaryConditions, SIGNAL(activated()),       this, SLOT(editBoundaryConditions()));
 120   connect(ui.actionConfigure,              SIGNAL(activated()),       this, SLOT(configure()));
 121   connect(ui.actionAbout,                  SIGNAL(activated()),       this, SLOT(about()));
 122
 123   connect(ui.checkBox_UseVTKInteractor,    SIGNAL(stateChanged(int)), this, SLOT(setUseVTKInteractor(int)));
 124
 125   connect(ui.actionViewXP, SIGNAL(activated()), this, SLOT(viewXP()));
 126   connect(ui.actionViewXM, SIGNAL(activated()), this, SLOT(viewXM()));
 127   connect(ui.actionViewYP, SIGNAL(activated()), this, SLOT(viewYP()));
 128   connect(ui.actionViewYM, SIGNAL(activated()), this, SLOT(viewYM()));
 129   connect(ui.actionViewZP, SIGNAL(activated()), this, SLOT(viewZP()));
 130   connect(ui.actionViewZM, SIGNAL(activated()), this, SLOT(viewZM()));
 131
 132
 133 #include "std_connections.h"
 134
 135   if (qset.contains("working_directory")) {
 136     cwd = qset.value("working_directory").toString();
 137   };
 138   grid = vtkUnstructuredGrid::New();
 139   renderer = vtkRenderer::New();
 140   getRenderWindow()->AddRenderer(renderer);
 141   surface_actor = vtkActor::New();
 142   surface_wire_actor = vtkActor::New();
 143
 144   tetra_mapper        = vtkPolyDataMapper::New();
 145   pyramid_mapper      = vtkPolyDataMapper::New();
 146   wedge_mapper        = vtkPolyDataMapper::New();
 147   hexa_mapper         = vtkPolyDataMapper::New();
 148   volume_wire_mapper  = vtkPolyDataMapper::New();
 149   surface_mapper      = vtkPolyDataMapper::New();
 150   surface_wire_mapper = vtkPolyDataMapper::New();
 151
 152   backface_property = vtkProperty::New();
 153
 154   tetra_actor       = NULL;
 155   pyramid_actor     = NULL;
 156   wedge_actor       = NULL;
 157   hexa_actor        = NULL;
 158   volume_wire_actor = NULL;
 159   iamlegend_actor = NULL;
 160   lut = NULL;
 161   field_mapper = NULL;
 162
 163   surface_filter = vtkGeometryFilter::New();
 164   bcodes_filter = vtkEgBoundaryCodesFilter::New();
 165   renderer->AddActor(surface_actor);
 166   renderer->AddActor(surface_wire_actor);
 167   pick_sphere = vtkSphereSource::New();
 168   pick_mapper = vtkPolyDataMapper::New();
 169   pick_actor = NULL;
 170
 171   extr_vol        = vtkEgExtractVolumeCells::New();
 172   extr_tetras     = vtkEgExtractVolumeCells::New();
 173   extr_pyramids   = vtkEgExtractVolumeCells::New();
 174   extr_wedges     = vtkEgExtractVolumeCells::New();
 175   extr_hexas      = vtkEgExtractVolumeCells::New();
 176
 177   volume_geometry  = vtkGeometryFilter::New();
 178   tetra_geometry   = vtkGeometryFilter::New();
 179   pyramid_geometry = vtkGeometryFilter::New();
 180   wedge_geometry   = vtkGeometryFilter::New();
 181   hexa_geometry   = vtkGeometryFilter::New();
 182
 183   extr_tetras->SetAllOff();
 184   extr_tetras->SetTetrasOn();
 185   extr_pyramids->SetAllOff();
 186   extr_pyramids->SetPyramidsOn();
 187   extr_wedges->SetAllOff();
 188   extr_wedges->SetWedgesOn();
 189   extr_hexas->SetAllOff();
 190   extr_hexas->SetHexasOn();
 191
 192   boundary_pd = vtkPolyData::New();
 193   tetras_pd   = vtkPolyData::New();
 194   wedges_pd   = vtkPolyData::New();
 195   pyras_pd    = vtkPolyData::New();
 196   hexas_pd    = vtkPolyData::New();
 197   volume_pd   = vtkPolyData::New();
 198
 199   current_filename = "untitled.vtu";
 200   setWindowTitle(current_filename + " - enGrid");
 201
 202   status_bar = new QStatusBar(this);
 203   setStatusBar(status_bar);
 204   status_label = new QLabel(this);
 205   status_bar->addWidget(status_label);
 206   QString txt = "0 volume cells (0 tetras, 0 hexas, 0 pyramids, 0 prisms), ";
 207   txt += "0 surface cells (0 triangles, 0 quads), 0 nodes";
 208   status_label->setText(txt);
 209
 210   axes = vtkCubeAxesActor2D::New();
 211   axes->SetCamera(getRenderer()->GetActiveCamera());
 212   getRenderer()->AddActor(axes);
 213   setAxesVisibility();
 214
 215   CellPicker = vtkCellPicker::New();
 216 //   getInteractor()->SetPicker(CellPicker);
 217   PointPicker = vtkPointPicker::New();
 218 //   getInteractor()->SetPicker(PointPicker);
 219
 220   pick_sphere->SetRadius(0.25);//in case the user starts picking points instead of cells
 221
 222   vtkCallbackCommand *cbc = vtkCallbackCommand::New();
 223   cbc->SetCallback(pickCellCallBack);
 224   CellPicker->AddObserver(vtkCommand::EndPickEvent, cbc);
 225   cbc->SetCallback(pickPointCallBack);
 226   PointPicker->AddObserver(vtkCommand::EndPickEvent, cbc);
 227   cbc->Delete();
 228
 229   QString user = QString(getenv("USER"));
 230   QString basename="enGrid_output_"+user+".txt";
 231
 232   if (qset.contains("tmp_directory")) {
 233     log_file_name = qset.value("tmp_directory").toString() + "/" + basename;
 234   } else {
 235     log_file_name = "/tmp/" + basename;
 236   };
 237   system_stdout = stdout;
 238   freopen (log_file_name.toAscii().data(), "w", stdout);
 239
 240   busy = false;
 241   updateStatusBar();
 242
 243   connect(&garbage_timer, SIGNAL(timeout()), this, SLOT(periodicUpdate()));
 244   garbage_timer.start(1000);
 245
 246   connect(&log_timer, SIGNAL(timeout()), this, SLOT(updateOutput()));
 247   log_timer.start(1000);
 248
 249   N_chars = 0;
 250
 251   bool exp_features;
 252   getSet("","enable experimental features",false,exp_features);
 253   ui.actionFoamWriter->setEnabled(exp_features);
 254
 255   ReferenceSize=0.2;
 256
 257 //   ui.checkBox_UseVTKInteractor->setCheckState(Qt::Checked);
 258 //   ui.radioButton_CellPicker->setChecked(true);
 259   setPickMode(true,true);
 260   PickedPoint=-1;
 261   PickedCell=-1;
 262
 263   ui.doubleSpinBox_HueMin->setValue(0.667);
 264   ui.doubleSpinBox_HueMax->setValue(0);
 265 };
 266
 267 GuiMainWindow::~GuiMainWindow()
 268 {
 269   qset.setValue("pos", pos());
 270   qset.setValue("size", size());
 271 };
 272
 273 void GuiMainWindow::updateOutput()
 274 {
 275   QFile log_file(log_file_name);
 276   log_file.open(QIODevice::ReadOnly);
 277   QByteArray buffer = log_file.readAll();
 278   if (buffer.size() > N_chars) {
 279     QByteArray newchars = buffer.right(buffer.size() - N_chars);
 280     N_chars = buffer.size();
 281     QString txt(newchars);
 282     if (txt.right(1) == "\n") {
 283       txt = txt.left(txt.size()-1);
 284     };
 285     ui.textEditOutput->append(txt);
 286   };
 287 };
 288
 289 void GuiMainWindow::exit()
 290 {
 291   QCoreApplication::exit();
 292 };
 293
 294 vtkRenderWindow* GuiMainWindow::getRenderWindow()
 295 {
 296   return ui.qvtkWidget->GetRenderWindow();
 297 };
 298
 299 vtkRenderer* GuiMainWindow::getRenderer()
 300 {
 301   return renderer;
 302 };
 303
 304 QVTKInteractor* GuiMainWindow::getInteractor()
 305 {
 306   return ui.qvtkWidget->GetInteractor();
 307 };
 308
 309 QString GuiMainWindow::getCwd()
 310 {
 311   return cwd;
 312 };
 313
 314 void GuiMainWindow::setCwd(QString dir)
 315 {
 316   cwd = dir;
 317   qset.setValue("working_directory",dir);
 318 };
 319
 320 void GuiMainWindow::ScaleToData()
 321 {
 322   int current_field=ui.comboBox_Field->currentIndex();
 323   if(current_field>0)
 324   {
 325     double range[2];
 326     boundary_pd->GetPointData()->GetArray(current_field-1)->GetRange(range);
 327     cout<<"current_field="<<current_field<<endl;
 328     cout<<"range[0]="<<range[0]<<endl;
 329     cout<<"range[1]="<<range[1]<<endl;
 330     ui.doubleSpinBox_FieldMin->setRange(range[0],range[1]);
 331     ui.doubleSpinBox_FieldMax->setRange(range[0],range[1]);
 332     ui.doubleSpinBox_FieldMin->setValue(range[0]);
 333     ui.doubleSpinBox_FieldMax->setValue(range[1]);
 334   }
 335 }
 336
 337 void GuiMainWindow::updateActors()
 338 {
 339   if (!tryLock()) return;
 340   try {
 341     {
 342       {
 343         if (!grid->GetCellData()->GetScalars("cell_index")) {
 344           EG_VTKSP(vtkLongArray_t, cell_idx);
 345           cell_idx->SetName("cell_index");
 346           cell_idx->SetNumberOfValues(grid->GetNumberOfCells());
 347           grid->GetCellData()->AddArray(cell_idx);
 348         };
 349       };
 350       EG_VTKDCC(vtkLongArray_t, cell_index, grid, "cell_index");
 351       for (vtkIdType cellId = 0; cellId < grid->GetNumberOfCells(); ++cellId) {
 352         cell_index->SetValue(cellId, cellId);
 353       };
 354     };
 355
 356     axes->SetInput(grid);
 357
 358     double xmin =  1e99;
 359     double xmax = -1e99;
 360     double ymin =  1e99;
 361     double ymax = -1e99;
 362     double zmin =  1e99;
 363     double zmax = -1e99;
 364     for (vtkIdType nodeId = 0; nodeId < grid->GetNumberOfPoints(); ++nodeId) {
 365       vec3_t x;
 366       grid->GetPoints()->GetPoint(nodeId, x.data());
 367       xmin = min(x[0], xmin);
 368       xmax = max(x[0], xmax);
 369       ymin = min(x[1], ymin);
 370       ymax = max(x[1], ymax);
 371       zmin = min(x[2], zmin);
 372       zmax = max(x[2], zmax);
 373     };
 374
 375     if (surface_actor) {
 376       getRenderer()->RemoveActor(surface_actor);
 377       surface_actor->Delete();
 378       surface_actor = NULL;
 379     };
 380     if (surface_wire_actor) {
 381       getRenderer()->RemoveActor(surface_wire_actor);
 382       surface_wire_actor->Delete();
 383       surface_wire_actor = NULL;
 384     };
 385     if (tetra_actor) {
 386       getRenderer()->RemoveActor(tetra_actor);
 387       tetra_actor->Delete();
 388       tetra_actor = NULL;
 389     };
 390     if (pyramid_actor) {
 391       getRenderer()->RemoveActor(pyramid_actor);
 392       pyramid_actor->Delete();
 393       pyramid_actor = NULL;
 394     };
 395     if (wedge_actor) {
 396       getRenderer()->RemoveActor(wedge_actor);
 397       wedge_actor->Delete();
 398       wedge_actor = NULL;
 399     };
 400     if (hexa_actor) {
 401       getRenderer()->RemoveActor(hexa_actor);
 402       hexa_actor->Delete();
 403       hexa_actor = NULL;
 404     };
 405     if (volume_wire_actor) {
 406       getRenderer()->RemoveActor(volume_wire_actor);
 407       volume_wire_actor->Delete();
 408       volume_wire_actor = NULL;
 409     };
 410     if (pick_actor) {
 411       getRenderer()->RemoveActor(pick_actor);
 412       pick_actor->Delete();
 413       pick_actor = NULL;
 414     };
 415     if (iamlegend_actor) {
 416       getRenderer()->RemoveActor(iamlegend_actor);
 417       iamlegend_actor->Delete();
 418       iamlegend_actor = NULL;
 419     };
 420     if (lut) {
 421       lut->Delete();
 422       lut = NULL;
 423     };
 424     if (field_mapper) {
 425       field_mapper->Delete();
 426       field_mapper = NULL;
 427     };
 428
 429     if (ui.checkBoxSurface->isChecked()) {
 430       bcodes_filter->SetBoundaryCodes(&display_boundary_codes);
 431
 432       bcodes_filter->SetInput(grid);
 433
 434       surface_filter->SetInput(bcodes_filter->GetOutput());
 435
 436       surface_filter->Update();
 437
 438       boundary_pd->DeepCopy(surface_filter->GetOutput());
 439
 440       surface_mapper->SetInput(boundary_pd);
 441
 442       surface_wire_mapper->SetInput(boundary_pd);
 443       surface_actor = vtkActor::New();
 444       surface_actor->GetProperty()->SetRepresentationToSurface();
 445
 446       int current_field=ui.comboBox_Field->currentIndex();
 447       ui.comboBox_Field->clear();
 448       ui.comboBox_Field->addItem("None");
 449       int N_Arrays=boundary_pd->GetPointData()->GetNumberOfArrays();
 450       cout<<"N_Arrays="<<N_Arrays<<endl;
 451       for (int i=0; i<N_Arrays; i++)
 452       {
 453         ui.comboBox_Field->addItem(boundary_pd->GetPointData()->GetArrayName(i));
 454       }
 455
 456       if(current_field==-1) ui.comboBox_Field->setCurrentIndex(0);
 457       else ui.comboBox_Field->setCurrentIndex(current_field);
 458
 459       cout<<"index="<<ui.comboBox_Field->currentIndex()<<endl;
 460       cout<<"name="<<ui.comboBox_Field->currentText().toLatin1().data()<<endl;
 461
 462       current_field=ui.comboBox_Field->currentIndex();
 463       if(current_field>0)
 464       {
 465         double range[2];
 466         boundary_pd->GetPointData()->GetArray(current_field-1)->GetRange(range);
 467         cout<<"current_field="<<current_field<<endl;
 468         cout<<"range[0]="<<range[0]<<endl;
 469         cout<<"range[1]="<<range[1]<<endl;
 470         ui.doubleSpinBox_FieldMin->setRange(range[0],range[1]);
 471         ui.doubleSpinBox_FieldMax->setRange(range[0],range[1]);
 472       }
 473
 474       if(ui.comboBox_Field->currentIndex()<=0) {
 475         surface_actor->SetBackfaceProperty(backface_property);
 476         surface_actor->GetProperty()->SetColor(0.5,1,0.5);
 477         surface_actor->GetBackfaceProperty()->SetColor(1,1,0.5);
 478         surface_actor->SetMapper(surface_mapper);
 479       }
 480       else {
 481         lut=vtkLookupTable::New();
 482         lut->SetNumberOfColors(256);
 483         lut->SetHueRange(ui.doubleSpinBox_HueMin->value(),ui.doubleSpinBox_HueMax->value());
 484         lut->Build();
 485         field_mapper=vtkPolyDataMapper::New();
 486         field_mapper->SetLookupTable(lut);
 487         field_mapper->SetInput(boundary_pd);
 488         field_mapper->SetColorModeToMapScalars();
 489         field_mapper->SetScalarModeToUsePointFieldData();
 490         field_mapper->ColorByArrayComponent(ui.comboBox_Field->currentText().toLatin1().data(),0);
 491         field_mapper->SetScalarRange(ui.doubleSpinBox_FieldMin->value(),ui.doubleSpinBox_FieldMax->value());
 492         surface_actor->SetMapper(field_mapper);
 493
 494         if(ui.checkBox_Legend->checkState()) {
 495           iamlegend_actor = vtkScalarBarActor::New();
 496           iamlegend_actor->SetLookupTable (lut);
 497           getRenderer()->AddActor(iamlegend_actor);
 498         }
 499       }
 500
 501       vtkDoubleArray *newScalars = vtkDoubleArray::New();
 502       int index;
 503       newScalars=(vtkDoubleArray *)boundary_pd->GetPointData()->GetArray("node_meshdensity_current",index);
 504       cout<<"index="<<index<<endl;
 505
 506       cout<<"=========="<<endl;
 507       boundary_pd->GetPointData()->GetArray("node_status",index);
 508       cout<<"index="<<index<<endl;
 509       boundary_pd->GetPointData()->GetArray("node_layer",index);
 510       cout<<"index="<<index<<endl;
 511       boundary_pd->GetPointData()->GetArray("node_index",index);
 512       cout<<"index="<<index<<endl;
 513       boundary_pd->GetPointData()->GetArray("node_meshdensity",index);
 514       cout<<"index="<<index<<endl;
 515       boundary_pd->GetPointData()->GetArray("node_meshdensity_current",index);
 516       cout<<"index="<<index<<endl;
 517       boundary_pd->GetPointData()->GetArray("node_type",index);
 518       cout<<"index="<<index<<endl;
 519       cout<<"=========="<<endl;
 520
 521       int N2=newScalars->GetNumberOfComponents();
 522       int N3=newScalars->GetNumberOfTuples();
 523       cout<<"Number of components=N2="<<N2<<endl;
 524       cout<<"Number of tuples=N3="<<N3<<endl;
 525
 526
 527 /*      for (int i=0; i<N3; i++)
 528       {
 529         double D=newScalars->GetComponent(i,0);//strange, but works. O.o
 530         cout<<"D["<<i<<"]="<<D<<endl;
 531       }*/
 532
 533       surface_wire_actor = vtkActor::New();
 534       surface_wire_actor->GetProperty()->SetRepresentationToWireframe();
 535       surface_wire_actor->GetProperty()->SetColor(0,0,1);
 536
 537       surface_wire_actor->SetMapper(surface_wire_mapper);
 538       getRenderer()->AddActor(surface_actor);
 539       getRenderer()->AddActor(surface_wire_actor);
 540       bcodes_filter->Update();
 541
 542       if(m_UseVTKInteractor)
 543       {
 544         if(ui.radioButton_CellPicker->isChecked())
 545         {
 546   //         CellPicker->Pick(0,0,0, getRenderer());
 547           getInteractor()->SetPicker(CellPicker);
 548   //         CellPicker->Pick(0,0,0, getRenderer());
 549           vtkIdType cellId = getPickedCell();
 550           pickCell(cellId);
 551         }
 552         else
 553         {
 554           getInteractor()->SetPicker(PointPicker);
 555           vtkIdType nodeId = getPickedPoint();
 556           pickPoint(nodeId);
 557         }
 558       }
 559       else
 560       {
 561         if(ui.radioButton_CellPicker->isChecked()) pickCell(PickedCell);
 562         else pickPoint(PickedPoint);
 563       }
 564 /*        getInteractor()->SetPicker(CellPicker);
 565         vtkIdType cellId = getPickedCell();
 566         pickCell(cellId);
 567         getInteractor()->SetPicker(PointPicker);
 568         vtkIdType nodeId = getPickedPoint();
 569         pickPoint(nodeId);*/
 570
 571     };
 572
 573     vec3_t x, n;
 574     x[0] = ui.lineEditClipX->text().toDouble();
 575     x[1] = ui.lineEditClipY->text().toDouble();
 576     x[2] = ui.lineEditClipZ->text().toDouble();
 577     n[0] = ui.lineEditClipNX->text().toDouble();
 578     n[1] = ui.lineEditClipNY->text().toDouble();
 579     n[2] = ui.lineEditClipNZ->text().toDouble();
 580     n.normalise();
 581     x = x + ui.lineEditOffset->text().toDouble()*n;
 582     extr_vol->SetAllOff();
 583     if (ui.checkBoxTetra->isChecked()) {
 584       extr_vol->SetTetrasOn();
 585       extr_tetras->SetInput(grid);
 586       if (ui.checkBoxClip->isChecked()) {
 587         extr_tetras->SetClippingOn();
 588         extr_tetras->SetX(x);
 589         extr_tetras->SetN(n);
 590       } else {
 591         extr_tetras->SetClippingOff();
 592       };
 593       tetra_actor = vtkActor::New();
 594       tetra_geometry->SetInput(extr_tetras->GetOutput());
 595       tetra_geometry->Update();
 596       tetras_pd->DeepCopy(tetra_geometry->GetOutput());
 597       tetra_mapper->SetInput(tetras_pd);
 598       tetra_actor = vtkActor::New();
 599       tetra_actor->SetMapper(tetra_mapper);
 600       tetra_actor->GetProperty()->SetColor(1,0,0);
 601       getRenderer()->AddActor(tetra_actor);
 602     };
 603     if (ui.checkBoxPyramid->isChecked()) {
 604       extr_vol->SetPyramidsOn();
 605       extr_pyramids->SetInput(grid);
 606       if (ui.checkBoxClip->isChecked()) {
 607         extr_pyramids->SetClippingOn();
 608         extr_pyramids->SetX(x);
 609         extr_pyramids->SetN(n);
 610       } else {
 611         extr_pyramids->SetClippingOff();
 612       };
 613       pyramid_actor = vtkActor::New();
 614       pyramid_geometry->SetInput(extr_pyramids->GetOutput());
 615       pyramid_geometry->Update();
 616       pyras_pd->DeepCopy(pyramid_geometry->GetOutput());
 617       pyramid_mapper->SetInput(pyras_pd);
 618       pyramid_actor = vtkActor::New();
 619       pyramid_actor->SetMapper(pyramid_mapper);
 620       pyramid_actor->GetProperty()->SetColor(1,1,0);
 621       getRenderer()->AddActor(pyramid_actor);
 622     };
 623     if (ui.checkBoxWedge->isChecked()) {
 624       extr_vol->SetWedgesOn();
 625       extr_wedges->SetInput(grid);
 626       if (ui.checkBoxClip->isChecked()) {
 627         extr_wedges->SetClippingOn();
 628         extr_wedges->SetX(x);
 629         extr_wedges->SetN(n);
 630       } else {
 631         extr_wedges->SetClippingOff();
 632       };
 633       wedge_actor = vtkActor::New();
 634       wedge_geometry->SetInput(extr_wedges->GetOutput());
 635       wedge_geometry->Update();
 636       wedges_pd->DeepCopy(wedge_geometry->GetOutput());
 637       wedge_mapper->SetInput(wedges_pd);
 638       wedge_actor = vtkActor::New();
 639       wedge_actor->SetMapper(wedge_mapper);
 640       wedge_actor->GetProperty()->SetColor(0,1,0);
 641       getRenderer()->AddActor(wedge_actor);
 642     };
 643     if (ui.checkBoxHexa->isChecked()) {
 644       extr_vol->SetHexasOn();
 645       extr_hexas->SetInput(grid);
 646       if (ui.checkBoxClip->isChecked()) {
 647         extr_hexas->SetClippingOn();
 648         extr_hexas->SetX(x);
 649         extr_hexas->SetN(n);
 650       } else {
 651         extr_hexas->SetClippingOff();
 652       };
 653       hexa_actor = vtkActor::New();
 654       hexa_geometry->SetInput(extr_hexas->GetOutput());
 655       hexa_geometry->Update();
 656       hexas_pd->DeepCopy(hexa_geometry->GetOutput());
 657       hexa_mapper->SetInput(hexas_pd);
 658       hexa_actor = vtkActor::New();
 659       hexa_actor->SetMapper(hexa_mapper);
 660       hexa_actor->GetProperty()->SetColor(0,0.7,1);
 661       getRenderer()->AddActor(hexa_actor);
 662     };
 663
 664     // wireframe
 665     extr_vol->SetInput(grid);
 666     if (ui.checkBoxClip->isChecked()) {
 667       extr_vol->SetClippingOn();
 668       extr_vol->SetX(x);
 669       extr_vol->SetN(n);
 670     } else {
 671       extr_vol->SetClippingOff();
 672     };
 673     volume_wire_actor = vtkActor::New();
 674     volume_geometry->SetInput(extr_vol->GetOutput());
 675     volume_geometry->Update();
 676     volume_pd->DeepCopy(volume_geometry->GetOutput());
 677     volume_wire_mapper->SetInput(volume_pd);
 678     volume_wire_actor->SetMapper(volume_wire_mapper);
 679     volume_wire_actor->GetProperty()->SetRepresentationToWireframe();
 680     volume_wire_actor->GetProperty()->SetColor(0,0,1);
 681     getRenderer()->AddActor(volume_wire_actor);
 682
 683
 684     updateStatusBar();
 685     getRenderWindow()->Render();
 686   } catch (Error err) {
 687     err.display();
 688   };
 689   unlock();
 690 };
 691
 692 void GuiMainWindow::setPickMode(bool a_UseVTKInteractor,bool a_CellPickerMode)
 693 {
 694   m_UseVTKInteractor=a_UseVTKInteractor;
 695   if(a_UseVTKInteractor) ui.checkBox_UseVTKInteractor->setCheckState(Qt::Checked);
 696   else ui.checkBox_UseVTKInteractor->setCheckState(Qt::Unchecked);
 697   if(a_CellPickerMode) ui.radioButton_CellPicker->toggle();
 698   else ui.radioButton_PointPicker->toggle();
 699 //   cout<<"m_UseVTKInteractor="<<m_UseVTKInteractor<<endl;
 700 }
 701
 702 void GuiMainWindow::setUseVTKInteractor(int a_UseVTKInteractor)
 703 {
 704   m_UseVTKInteractor=a_UseVTKInteractor;
 705 //   cout<<"m_UseVTKInteractor="<<m_UseVTKInteractor<<endl;
 706 }
 707
 708 bool GuiMainWindow::pickPoint(vtkIdType nodeId)
 709 {
 710   if (nodeId >= 0 && nodeId<grid->GetNumberOfPoints()) {
 711     vec3_t x(0,0,0);
 712     grid->GetPoints()->GetPoint(nodeId, x.data());
 713     pick_sphere->SetCenter(x.data());
 714     pick_mapper->SetInput(pick_sphere->GetOutput());
 715     pick_actor = vtkActor::New();
 716     pick_actor->SetMapper(pick_mapper);
 717     pick_actor->GetProperty()->SetRepresentationToSurface();
 718     pick_actor->GetProperty()->SetColor(0,0,1);
 719     getRenderer()->AddActor(pick_actor);
 720     PickedPoint=nodeId;
 721     return(true);
 722   }
 723   else return(false);
 724 }
 725
 726 bool GuiMainWindow::pickCell(vtkIdType cellId)
 727 {
 728   if (cellId >= 0 && cellId<grid->GetNumberOfCells()) {
 729     vtkIdType *pts, Npts;
 730     grid->GetCellPoints(cellId, Npts, pts);
 731     vec3_t x(0,0,0);
 732     for (vtkIdType i = 0; i < Npts; ++i) {
 733       vec3_t xp;
 734       grid->GetPoints()->GetPoint(pts[i], xp.data());
 735       x += double(1)/Npts * xp;
 736     };
 737     pick_sphere->SetCenter(x.data());
 738     double R = 1e99;
 739     for (vtkIdType i = 0; i < Npts; ++i) {
 740       vec3_t xp;
 741       grid->GetPoints()->GetPoint(pts[i], xp.data());
 742       R = min(R, 0.25*(xp-x).abs());
 743     };
 744     ReferenceSize=R;//Used for text annotations too!
 745     pick_sphere->SetRadius(R);
 746     pick_mapper->SetInput(pick_sphere->GetOutput());
 747     pick_actor = vtkActor::New();
 748     pick_actor->SetMapper(pick_mapper);
 749     pick_actor->GetProperty()->SetRepresentationToSurface();
 750     pick_actor->GetProperty()->SetColor(1,0,0);
 751     getRenderer()->AddActor(pick_actor);
 752     PickedCell=cellId;
 753     return(true);
 754   }
 755   else return(false);
 756 }
 757
 758 void GuiMainWindow::importSTL()
 759 {
 760   StlReader stl;
 761   stl();
 762   updateBoundaryCodes(true);
 763   updateActors();
 764   updateStatusBar();
 765   zoomAll();
 766 };
 767
 768 void GuiMainWindow::importGmsh1Ascii()
 769 {
 770   GmshReader gmsh;
 771   gmsh.setV1Ascii();
 772   gmsh();
 773   updateBoundaryCodes(true);
 774   updateActors();
 775   updateStatusBar();
 776   zoomAll();
 777 };
 778
 779 void GuiMainWindow::exportGmsh1Ascii()
 780 {
 781   GmshWriter gmsh;
 782   gmsh.setV1Ascii();
 783   gmsh();
 784 };
 785
 786 void GuiMainWindow::importGmsh2Ascii()
 787 {
 788   GmshReader gmsh;
 789   gmsh.setV2Ascii();
 790   gmsh();
 791   updateBoundaryCodes(true);
 792   updateActors();
 793   updateStatusBar();
 794   zoomAll();
 795 };
 796
 797 void GuiMainWindow::exportGmsh2Ascii()
 798 {
 799   GmshWriter gmsh;
 800   gmsh.setV2Ascii();
 801   gmsh();
 802 };
 803
 804 void GuiMainWindow::exportNeutral()
 805 {
 806   NeutralWriter neutral;
 807   neutral();
 808 };
 809
 810 void GuiMainWindow::zoomAll()
 811 {
 812   getRenderer()->ResetCamera();
 813   getRenderWindow()->Render();
 814 };
 815
 816 void GuiMainWindow::open()
 817 {
 818   current_filename = QFileDialog::getOpenFileName
 819     (
 820       NULL,
 821       "open grid from file",
 822       getCwd(),
 823       "VTK unstructured grid files (*.vtu *.VTU)"
 824     );
 825   if (!current_filename.isNull()) {
 826     GuiMainWindow::setCwd(QFileInfo(current_filename).absolutePath());
 827     EG_VTKSP(vtkXMLUnstructuredGridReader,vtu);
 828     vtu->SetFileName(current_filename.toAscii().data());
 829     vtu->Update();
 830     grid->DeepCopy(vtu->GetOutput());
 831     createBasicFields(grid, grid->GetNumberOfCells(), grid->GetNumberOfPoints(), false);
 832     setWindowTitle(current_filename + " - enGrid");
 833     openBC();
 834     updateBoundaryCodes(true);
 835     updateActors();
 836     updateStatusBar();
 837     zoomAll();
 838   };
 839 };
 840
 841 void GuiMainWindow::undo()
 842 {
 843 };
 844
 845 void GuiMainWindow::redo()
 846 {
 847 };
 848
 849 void GuiMainWindow::openBC()
 850 {
 851   QString bc_file = current_filename + ".bcs";
 852   QFile file(bc_file);
 853   bcmap.clear();
 854   if (file.exists()) {
 855     file.open(QIODevice::ReadOnly | QIODevice::Text);
 856     QTextStream f(&file);
 857     while (!f.atEnd()) {
 858       QString name, type;
 859       int i;
 860       f >> i >> name >> type;
 861       bcmap[i] = BoundaryCondition(name,type);
 862     };
 863   };
 864 };
 865
 866 void GuiMainWindow::saveBC()
 867 {
 868   QString bc_file = current_filename + ".bcs";
 869   QFile file(bc_file);
 870   file.open(QIODevice::WriteOnly | QIODevice::Text);
 871   QTextStream f(&file);
 872   foreach(int i, all_boundary_codes) {
 873     BoundaryCondition bc = bcmap[i];
 874     f << i << " " << bc.getName() << " " << bc.getType() << "\n";
 875   };
 876 };
 877
 878 void GuiMainWindow::save()
 879 {
 880   cout << current_filename.toAscii().data() << endl;
 881   if (current_filename == "untitled.vtu") {
 882     saveAs();
 883   } else {
 884     EG_VTKDCC(vtkDoubleArray, cell_VA, grid, "cell_VA");
 885     for (vtkIdType cellId = 0; cellId < grid->GetNumberOfCells(); ++cellId) {
 886       cell_VA->SetValue(cellId, GeometryTools::cellVA(grid, cellId, true));
 887     };
 888     EG_VTKSP(vtkXMLUnstructuredGridWriter,vtu);
 889     addVtkTypeInfo();
 890     createIndices(grid);
 891     vtu->SetFileName(current_filename.toAscii().data());
 892     vtu->SetDataModeToBinary();
 893     vtu->SetInput(grid);
 894     vtu->Write();
 895     saveBC();
 896   };
 897 };
 898
 899 void GuiMainWindow::saveAs()
 900 {
 901   current_filename = QFileDialog::getSaveFileName
 902     (
 903       NULL,
 904       "write grid to file",
 905       getCwd(),
 906       "VTK unstructured grid files (*.vtu *.VTU)"
 907     );
 908   if (!current_filename.isNull()) {
 909     if (current_filename.right(4) != ".vtu") {
 910       if (current_filename.right(4) != ".VTU") {
 911         current_filename += ".vtu";
 912       };
 913     };
 914     EG_VTKDCC(vtkDoubleArray, cell_VA, grid, "cell_VA");
 915     for (vtkIdType cellId = 0; cellId < grid->GetNumberOfCells(); ++cellId) {
 916       cell_VA->SetValue(cellId, GeometryTools::cellVA(grid, cellId, true));
 917     };
 918     GuiMainWindow::setCwd(QFileInfo(current_filename).absolutePath());
 919     EG_VTKSP(vtkXMLUnstructuredGridWriter,vtu);
 920     addVtkTypeInfo();
 921     createIndices(grid);
 922     vtu->SetFileName(current_filename.toAscii().data());
 923     vtu->SetDataModeToBinary();
 924     vtu->SetInput(grid);
 925     vtu->Write();
 926     saveBC();
 927     setWindowTitle(current_filename + " - enGrid");
 928   };
 929 };
 930
 931 void GuiMainWindow::QuickSave(QString a_filename)
 932 {
 933   cout << a_filename.toAscii().data() << endl;
 934
 935   EG_VTKDCC(vtkDoubleArray, cell_VA, grid, "cell_VA");
 936   for (vtkIdType cellId = 0; cellId < grid->GetNumberOfCells(); ++cellId) {
 937     cell_VA->SetValue(cellId, GeometryTools::cellVA(grid, cellId, true));
 938   };
 939   EG_VTKSP(vtkXMLUnstructuredGridWriter,vtu);
 940   addVtkTypeInfo();
 941   createIndices(grid);
 942   vtu->SetFileName(a_filename.toAscii().data());
 943   vtu->SetDataModeToBinary();
 944   vtu->SetInput(grid);
 945   vtu->Write();
 946   saveBC();
 947 };
 948
 949
 950 void GuiMainWindow::updateStatusBar()
 951 {
 952   QString num, txt = "enGrid is currently busy with an operation ...";
 953   if (!busy) {
 954     txt = "";
 955   };
 956   if (!tryLock()) {
 957     status_label->setText(txt);
 958     return;
 959   };
 960   vtkIdType Ncells = grid->GetNumberOfCells();
 961   vtkIdType Nnodes = grid->GetNumberOfPoints();
 962   vtkIdType Ntris  = 0;
 963   vtkIdType Nquads = 0;
 964   vtkIdType Ntets  = 0;
 965   vtkIdType Npyras = 0;
 966   vtkIdType Nprism = 0;
 967   vtkIdType Nhexas = 0;
 968   for (vtkIdType i = 0; i < Ncells; ++i) {
 969     int ct = grid->GetCellType(i);
 970     if      (ct == VTK_TRIANGLE)   ++Ntris;
 971     else if (ct == VTK_QUAD)       ++Nquads;
 972     else if (ct == VTK_TETRA)      ++Ntets;
 973     else if (ct == VTK_WEDGE)      ++Nprism;
 974     else if (ct == VTK_PYRAMID)    ++Npyras;
 975     else if (ct == VTK_HEXAHEDRON) ++Nhexas;
 976   };
 977   num.setNum(Ntets + Npyras + Nprism + Nhexas); txt += num + " volume cells(";
 978   num.setNum(Ntets);  txt += num + " tetras, ";
 979   num.setNum(Npyras); txt += num + " pyramids, ";
 980   num.setNum(Nprism); txt += num + " prisms, ";
 981   num.setNum(Nhexas); txt += num + " hexas), ";
 982   num.setNum(Ntris + Nquads); txt += num + " surface cells(";
 983   num.setNum(Ntris);  txt += num + " triangles, ";
 984   num.setNum(Nquads); txt += num + " quads), ";
 985   num.setNum(Nnodes); txt += num + " nodes";
 986
 987   if(ui.radioButton_CellPicker->isChecked())
 988   {
 989     QString pick_txt = ", picked cell: ";
 990     vtkIdType id_cell = getPickedCell();
 991     if (id_cell < 0) {
 992       pick_txt += "no cell picked";
 993     } else {
 994       vtkIdType type_cell = grid->GetCellType(id_cell);
 995       if      (type_cell == VTK_TRIANGLE)   pick_txt += "triangle";
 996       else if (type_cell == VTK_QUAD)       pick_txt += "quad";
 997       else if (type_cell == VTK_TETRA)      pick_txt += "tetrahedron";
 998       else if (type_cell == VTK_PYRAMID)    pick_txt += "pyramid";
 999       else if (type_cell == VTK_WEDGE)      pick_txt += "prism";
1000       else if (type_cell == VTK_HEXAHEDRON) pick_txt += "hexahedron";
1001       vtkIdType N_pts, *pts;
1002       grid->GetCellPoints(id_cell, N_pts, pts);
1003       pick_txt += " [";
1004       for (int i_pts = 0; i_pts < N_pts; ++i_pts) {
1005         QString num;
1006         num.setNum(pts[i_pts]);
1007         pick_txt += num;
1008         if (i_pts < N_pts-1) {
1009           pick_txt += ",";
1010         };
1011       };
1012       pick_txt += "]";
1013       QString tmp;
1014       tmp.setNum(id_cell);
1015       pick_txt += " id_cell=" + tmp;
1016     };
1017     txt += pick_txt;
1018   }
1019   else
1020   {
1021     QString pick_txt = ", picked node: ";
1022     vtkIdType id_node = getPickedPoint();
1023     if (id_node < 0) {
1024       pick_txt += "no node picked";
1025     } else {
1026       vec3_t x;
1027       grid->GetPoints()->GetPoint(id_node,x.data());
1028       pick_txt += " [";
1029       for (int i = 0; i < 3; i++) {
1030         QString num;
1031         num.setNum(x[i]);
1032         pick_txt += num;
1033         if (i < 2) {
1034           pick_txt += ",";
1035         };
1036       };
1037       pick_txt += "]";
1038       QString tmp;
1039       tmp.setNum(id_node);
1040       pick_txt += " id_node=" + tmp;
1041       EG_VTKDCN(vtkDoubleArray, node_meshdensity, grid, "node_meshdensity");
1042       tmp.setNum(node_meshdensity->GetValue(id_node));
1043       pick_txt += " wanted density=" + tmp;
1044       EG_VTKDCN(vtkDoubleArray, node_meshdensity_current, grid, "node_meshdensity_current");
1045       tmp.setNum(node_meshdensity_current->GetValue(id_node));
1046       pick_txt += " current density=" + tmp;
1047       EG_VTKDCN(vtkCharArray, node_type, grid, "node_type");
1048       pick_txt += " type=" + QString(VertexType2Str( node_type->GetValue(id_node)));
1049     };
1050
1051     txt += pick_txt;
1052   }
1053
1054   status_label->setText(txt);
1055   unlock();
1056 };
1057
1058 void GuiMainWindow::selectBoundaryCodes()
1059 {
1060   GuiSelectBoundaryCodes bcodes;
1061   bcodes.setDisplayBoundaryCodes(display_boundary_codes);
1062   bcodes.setBoundaryCodes(all_boundary_codes);
1063   bcodes();
1064   bcodes.getThread().wait();
1065   bcodes.getSelectedBoundaryCodes(display_boundary_codes);
1066   updateActors();
1067 };
1068
1069 void GuiMainWindow::updateBoundaryCodes(bool all_on)
1070 {
1071   try {
1072     all_boundary_codes.clear();
1073     EG_VTKDCC(vtkIntArray, cell_code, grid, "cell_code");
1074     for (vtkIdType i = 0; i < grid->GetNumberOfCells(); ++i) {
1075       int ct = grid->GetCellType(i);
1076       if ((ct == VTK_TRIANGLE) || (ct == VTK_QUAD)) {
1077         all_boundary_codes.insert(cell_code->GetValue(i));
1078       };
1079     };
1080     if (all_on) {
1081       display_boundary_codes.clear();
1082       foreach (int bc, all_boundary_codes) {
1083         display_boundary_codes.insert(bc);
1084       };
1085     } else {
1086       QSet<int> dbcs;
1087       foreach (int bc, display_boundary_codes) {
1088         if (all_boundary_codes.contains(bc)) {
1089           dbcs.insert(bc);
1090         };
1091       };
1092       display_boundary_codes.clear();
1093       foreach (int bc, all_boundary_codes) {
1094         if (dbcs.contains(bc)) {
1095           display_boundary_codes.insert(bc);
1096         };
1097       };
1098     };
1099   } catch (Error err) {
1100     err.display();
1101   };
1102 };
1103
1104 void GuiMainWindow::normalExtrusion()
1105 {
1106   GuiNormalExtrusion extr;
1107   extr();
1108   updateBoundaryCodes(false);
1109   updateActors();
1110 };
1111
1112 void GuiMainWindow::setAxesVisibility()
1113 {
1114   if (ui.actionViewAxes->isChecked()) axes->SetVisibility(1);
1115   else                                axes->SetVisibility(0);
1116   getRenderWindow()->Render();
1117 };
1118
1119 void GuiMainWindow::setViewingMode()
1120 {
1121   if (ui.actionViewOrthogonal->isChecked()) getRenderer()->GetActiveCamera()->ParallelProjectionOn();
1122   else getRenderer()->GetActiveCamera()->ParallelProjectionOff();
1123   getRenderWindow()->Render();
1124 };
1125
1126 void GuiMainWindow::ViewNodeIDs()
1127 {
1128   int N=grid->GetNumberOfPoints();
1129   cout<<"N="<<N<<endl;
1130   if (ui.actionViewNodeIDs->isChecked()) {
1131     cout<<"Activating node ID view"<<endl;
1132     NodeText_VectorText.resize(N);
1133     NodeText_PolyDataMapper.resize(N);
1134     NodeText_Follower.resize(N);
1135     for(int i=0;i<N;i++){
1136       NodeText_VectorText[i]=vtkVectorText::New();
1137       QString tmp;
1138       tmp.setNum(i);
1139       NodeText_VectorText[i]->SetText(tmp.toLatin1().data());
1140       NodeText_PolyDataMapper[i]=vtkPolyDataMapper::New();
1141       NodeText_PolyDataMapper[i]->SetInputConnection(NodeText_VectorText[i]->GetOutputPort());
1142       NodeText_Follower[i]=vtkFollower::New();
1143       NodeText_Follower[i]->SetMapper(NodeText_PolyDataMapper[i]);
1144       NodeText_Follower[i]->SetScale(ReferenceSize,ReferenceSize,ReferenceSize);
1145       vec3_t M;
1146       grid->GetPoint(i,M.data());
1147       vec3_t tmp_M=M;
1148       vec3_t OffSet=ReferenceSize*tmp_M.normalise();
1149       M=M+OffSet;
1150       NodeText_Follower[i]->AddPosition(M[0],M[1],M[2]);
1151       NodeText_Follower[i]->SetCamera(getRenderer()->GetActiveCamera());
1152       NodeText_Follower[i]->GetProperty()->SetColor(0,0,1);
1153       getRenderer()->AddActor(NodeText_Follower[i]);
1154     }
1155   }
1156   else {
1157     cout<<"Deactivating node ID view"<<endl;
1158     for(unsigned int i=0;i<NodeText_Follower.size();i++){
1159       getRenderer()->RemoveActor(NodeText_Follower[i]);
1160       NodeText_Follower[i]->Delete();
1161       NodeText_PolyDataMapper[i]->Delete();
1162       NodeText_VectorText[i]->Delete();
1163     }
1164     NodeText_Follower.clear();
1165     NodeText_PolyDataMapper.clear();
1166     NodeText_VectorText.clear();
1167   }
1168
1169   getRenderWindow()->Render();
1170 };
1171
1172 void GuiMainWindow::ViewCellIDs()
1173 {
1174   int N=grid->GetNumberOfCells();
1175   cout<<"N="<<N<<endl;
1176   if (ui.actionViewCellIDs->isChecked()) {
1177     cout<<"Activating cell ID view"<<endl;
1178     CellText_VectorText.resize(N);
1179     CellText_PolyDataMapper.resize(N);
1180     CellText_Follower.resize(N);
1181     for(int i=0;i<N;i++){
1182       CellText_VectorText[i]=vtkVectorText::New();
1183       QString tmp;
1184       tmp.setNum(i);
1185       CellText_VectorText[i]->SetText(tmp.toLatin1().data());
1186       CellText_PolyDataMapper[i]=vtkPolyDataMapper::New();
1187       CellText_PolyDataMapper[i]->SetInputConnection(CellText_VectorText[i]->GetOutputPort());
1188       CellText_Follower[i]=vtkFollower::New();
1189       CellText_Follower[i]->SetMapper(CellText_PolyDataMapper[i]);
1190       CellText_Follower[i]->SetScale(ReferenceSize,ReferenceSize,ReferenceSize);
1191       vtkIdType N_pts,*pts;
1192       grid->GetCellPoints(i,N_pts,pts);
1193       vec3_t Center(0,0,0);
1194       for(int p=0;p<N_pts;p++)
1195       {
1196         vec3_t M;
1197         grid->GetPoint(pts[p],M.data());
1198         Center+=M.data();
1199       }
1200       vec3_t OffSet=ReferenceSize*triNormal(grid,pts[0],pts[1],pts[2]).normalise();
1201       Center=1.0/(double)N_pts*Center+OffSet;
1202       CellText_Follower[i]->AddPosition(Center[0],Center[1],Center[2]);
1203       CellText_Follower[i]->SetCamera(getRenderer()->GetActiveCamera());
1204       CellText_Follower[i]->GetProperty()->SetColor(1,0,0);
1205       getRenderer()->AddActor(CellText_Follower[i]);
1206     }
1207   }
1208   else {
1209     cout<<"Deactivating cell ID view"<<endl;
1210     for(unsigned int i=0;i<CellText_Follower.size();i++){
1211       getRenderer()->RemoveActor(CellText_Follower[i]);
1212       CellText_Follower[i]->Delete();
1213       CellText_PolyDataMapper[i]->Delete();
1214       CellText_VectorText[i]->Delete();
1215     }
1216     CellText_Follower.clear();
1217     CellText_PolyDataMapper.clear();
1218     CellText_VectorText.clear();
1219   }
1220
1221   getRenderWindow()->Render();
1222 };
1223
1224 void GuiMainWindow::addVtkTypeInfo()
1225 {
1226   EG_VTKSP(vtkIntArray, vtk_type);
1227   vtk_type->SetName("vtk_type");
1228   vtk_type->SetNumberOfValues(grid->GetNumberOfCells());
1229   for (vtkIdType cellId = 0; cellId < grid->GetNumberOfCells(); ++cellId) {
1230     vtk_type->SetValue(cellId, grid->GetCellType(cellId));
1231   };
1232   grid->GetCellData()->AddArray(vtk_type);
1233 };
1234
1235 void GuiMainWindow::pickCellCallBack
1236 (
1237   vtkObject *caller,
1238   unsigned long int eid,
1239   void *clientdata,
1240   void *calldata
1241 )
1242 {
1243   caller = caller;
1244   eid = eid;
1245   clientdata = clientdata;
1246   calldata = calldata;
1247   THIS->updateActors();
1248   THIS->updateStatusBar();
1249 };
1250
1251 void GuiMainWindow::pickPointCallBack
1252 (
1253   vtkObject *caller,
1254   unsigned long int eid,
1255   void *clientdata,
1256   void *calldata
1257 )
1258 {
1259   caller = caller;
1260   eid = eid;
1261   clientdata = clientdata;
1262   calldata = calldata;
1263   THIS->updateActors();
1264   THIS->updateStatusBar();
1265 };
1266
1267 vtkIdType GuiMainWindow::getPickedCell()
1268 {
1269   vtkIdType picked_cell = -1;
1270   if (THIS->grid->GetNumberOfCells() > 0) {
1271     THIS->bcodes_filter->Update();
1272     EG_VTKDCC(vtkLongArray_t, cell_index, THIS->bcodes_filter->GetOutput(), "cell_index");
1273
1274     vtkIdType cellId;
1275     if(m_UseVTKInteractor) cellId = THIS->CellPicker->GetCellId();
1276     else cellId = PickedCell;
1277
1278     if (cellId >= 0) {
1279       if (cellId < THIS->bcodes_filter->GetOutput()->GetNumberOfCells()) {
1280         picked_cell = cell_index->GetValue(cellId);
1281       };
1282     };
1283   };
1284   return picked_cell;
1285 };
1286
1287 vtkIdType GuiMainWindow::getPickedPoint()
1288 {
1289   vtkIdType picked_point = -1;
1290   if (THIS->grid->GetNumberOfCells() > 0) {
1291     THIS->bcodes_filter->Update();
1292
1293     vtkIdType pointId;
1294     if(m_UseVTKInteractor) pointId = THIS->PointPicker->GetPointId();
1295     else pointId = PickedPoint;
1296
1297     if (pointId >= 0) {
1298       picked_point = pointId;
1299     }
1300   };
1301   return picked_point;
1302 };
1303
1304 void GuiMainWindow::changeSurfaceOrientation()
1305 {
1306   for (vtkIdType cellId = 0; cellId < grid->GetNumberOfCells(); ++cellId) {
1307     vtkIdType Npts, *pts;
1308     grid->GetCellPoints(cellId, Npts, pts);
1309     QVector<vtkIdType> nodes(Npts);
1310     for (vtkIdType j = 0; j < Npts; ++j) nodes[j]          = pts[j];
1311     for (vtkIdType j = 0; j < Npts; ++j) pts[Npts - j - 1] = nodes[j];
1312   };
1313   updateActors();
1314 };
1315
1316 void GuiMainWindow::checkSurfaceOrientation()
1317 {
1318   CorrectSurfaceOrientation corr_surf;
1319   vtkIdType picked_cell = getPickedCell();
1320   if (picked_cell >= 0) {
1321     corr_surf.setStart(picked_cell);
1322   };
1323   corr_surf();
1324   updateActors();
1325 };
1326
1327 void GuiMainWindow::improveAspectRatio()
1328 {
1329   GuiImproveAspectRatio impr_ar;
1330   impr_ar();
1331   updateActors();
1332 };
1333
1334 void GuiMainWindow::exportAsciiStl()
1335 {
1336   StlWriter stl;
1337   stl();
1338 };
1339
1340 void GuiMainWindow::exportBinaryStl()
1341 {
1342 };
1343
1344 void GuiMainWindow::periodicUpdate()
1345 {
1346   Operation::collectGarbage();
1347   updateStatusBar();
1348 };
1349
1350 void GuiMainWindow::viewXP()
1351 {
1352   getRenderer()->ResetCamera();
1353   double x[3];
1354   getRenderer()->GetActiveCamera()->GetFocalPoint(x);
1355   x[0] += 1;
1356   getRenderer()->GetActiveCamera()->SetPosition(x);
1357   getRenderer()->GetActiveCamera()->ComputeViewPlaneNormal();
1358   getRenderer()->GetActiveCamera()->SetViewUp(0,1,0);
1359   getRenderer()->ResetCamera();
1360   getRenderWindow()->Render();
1361 };
1362
1363 void GuiMainWindow::viewXM()
1364 {
1365   getRenderer()->ResetCamera();
1366   double x[3];
1367   getRenderer()->GetActiveCamera()->GetFocalPoint(x);
1368   x[0] -= 1;
1369   getRenderer()->GetActiveCamera()->SetPosition(x);
1370   getRenderer()->GetActiveCamera()->ComputeViewPlaneNormal();
1371   getRenderer()->GetActiveCamera()->SetViewUp(0,1,0);
1372   getRenderer()->ResetCamera();
1373   getRenderWindow()->Render();
1374 };
1375
1376 void GuiMainWindow::viewYP()
1377 {
1378   getRenderer()->ResetCamera();
1379   double x[3];
1380   getRenderer()->GetActiveCamera()->GetFocalPoint(x);
1381   x[1] += 1;
1382   getRenderer()->GetActiveCamera()->SetPosition(x);
1383   getRenderer()->GetActiveCamera()->ComputeViewPlaneNormal();
1384   getRenderer()->GetActiveCamera()->SetViewUp(0,0,-1);
1385   getRenderer()->ResetCamera();
1386   getRenderWindow()->Render();
1387 };
1388
1389 void GuiMainWindow::viewYM()
1390 {
1391   getRenderer()->ResetCamera();
1392   double x[3];
1393   getRenderer()->GetActiveCamera()->GetFocalPoint(x);
1394   x[1] -= 1;
1395   getRenderer()->GetActiveCamera()->SetPosition(x);
1396   getRenderer()->GetActiveCamera()->ComputeViewPlaneNormal();
1397   getRenderer()->GetActiveCamera()->SetViewUp(0,0,-1);
1398   getRenderer()->ResetCamera();
1399   getRenderWindow()->Render();
1400 };
1401
1402 void GuiMainWindow::viewZP()
1403 {
1404   getRenderer()->ResetCamera();
1405   double x[3];
1406   getRenderer()->GetActiveCamera()->GetFocalPoint(x);
1407   x[2] += 1;
1408   getRenderer()->GetActiveCamera()->SetPosition(x);
1409   getRenderer()->GetActiveCamera()->ComputeViewPlaneNormal();
1410   getRenderer()->GetActiveCamera()->SetViewUp(0,1,0);
1411   getRenderer()->ResetCamera();
1412   getRenderWindow()->Render();
1413 };
1414
1415 void GuiMainWindow::viewZM()
1416 {
1417   getRenderer()->ResetCamera();
1418   double x[3];
1419   getRenderer()->GetActiveCamera()->GetFocalPoint(x);
1420   x[2] -= 1;
1421   getRenderer()->GetActiveCamera()->SetPosition(x);
1422   getRenderer()->GetActiveCamera()->ComputeViewPlaneNormal();
1423   getRenderer()->GetActiveCamera()->SetViewUp(0,1,0);
1424   getRenderer()->ResetCamera();
1425   getRenderWindow()->Render();
1426 };
1427
1428 void GuiMainWindow::callFixSTL()
1429 {
1430   FixSTL *fix;
1431   fix = new FixSTL();
1432   fix->setGui();
1433   (*fix)();
1434   updateBoundaryCodes(false);
1435   updateActors();
1436 };
1437
1438 void GuiMainWindow::editBoundaryConditions()
1439 {
1440   GuiEditBoundaryConditions editbcs;
1441   editbcs.setBoundaryCodes(all_boundary_codes);
1442   editbcs.setMap(&bcmap);
1443   editbcs();
1444 };
1445
1446 void GuiMainWindow::configure()
1447 {
1448   {
1449     // Just to create initial entries in the settings file
1450     // so that the options menu isn't empty at first start.
1451     GridSmoother tmp01;
1452     GuiCreateBoundaryLayer tmp02;
1453   };
1454   GuiSettingsViewer settings(&qset);
1455   settings.exec();
1456 };
1457
1458 void GuiMainWindow::about()
1459 {
1460   QMessageBox box(this);
1461
1462   QString title="ENGRID";
1463   QString version = QString("version ") + ENGRID_VERSION;
1464   if (version == "version CVS") {
1465     version += " build on ";
1466     version += QString(__DATE__);
1467     version += " at ";
1468     version += QString(__TIME__);
1469   };
1470   QString address = tr("ENGRID is being developed and maintained by:<br/>"
1471                        "enGits GmbH<br/>"
1472                        "Marie-Curie-Strasse 8<br/>"
1473                        "79539 Loerrach<br/>"
1474                        "Germany<br/>");
1475
1476   QString mainurl="<a href=\"http://www.engits.com\">www.engits.com</a>";
1477   QString mail="<a href=\"mailto:info@engits.com\">info@engits.com</a>";
1478   QString gnuurl="<a href=\"http://www.gnu.org/licenses\">http://www.gnu.org/licenses</a>";
1479   QString license=tr("ENGRID is licenced under the GPL version 3.<br/>"
1480                      "(see ")+gnuurl+tr(" for details)<br/>");
1481   QString bugurl="<a href=\"http://sourceforge.net/tracker2/?func=add&group_id=245110&atid=1126548\">the bugtracker available on Sourceforge</a>";
1482   QString bugreporting=tr("To submit a bug report, please use ")+bugurl;
1483   box.setText(QString::fromLatin1("<center><img src=\":/icons/resources/icons/G.png\">"
1484                                   "<h3>%1</h3>"
1485                                   "<p>%2</p>"
1486                                   "<p>%3</p>"
1487                                   "<p>Homepage: %4</p>"
1488                                   "<p>E-mail: %5</p>"
1489                                   "<p>%6</p>"
1490                                   "<p>%7</p></center>")
1491               .arg(title).arg(version).arg(address).arg(mainurl).arg(mail).arg(license).arg(bugreporting));
1492   box.setWindowTitle(tr("about ENGRID"));
1493   box.setIcon(QMessageBox::NoIcon);
1494   box.exec();
1495
1496 };
1497
1498 void GuiMainWindow::getAllBoundaryCodes(QSet<int> &bcs)
1499 {
1500   bcs.clear();
1501   foreach (int bc, all_boundary_codes) {
1502     bcs.insert(bc);
1503   };
1504 };
1505
1506