guimainwindow.h

   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 #ifndef mainwindow_H
  24 #define mainwindow_H
  25
  26 class GuiMainWindow;
  27
  28 #include <QMainWindow>
  29 #include <QSettings>
  30 #include <QLabel>
  31 #include <QSet>
  32 #include <QFileSystemWatcher>
  33 #include <QMutex>
  34 #include <QTimer>
  35 #include <QDockWidget>
  36
  37 #include <vtkUnstructuredGrid.h>
  38 #include <vtkActor.h>
  39 #include <vtkPolyDataMapper.h>
  40 #include <vtkGeometryFilter.h>
  41 #include <vtkCubeAxesActor2D.h>
  42 #include <vtkCellPicker.h>
  43 #include <vtkPointPicker.h>
  44 #include <vtkSphereSource.h>
  45 #include <vtkTextActor.h>
  46 #include <vtkVectorText.h>
  47 #include <vtkFollower.h>
  48
  49 #include "ui_guimainwindow.h"
  50 #include "ui_guioutputwindow.h"
  51 #include "vtkEgBoundaryCodesFilter.h"
  52 #include "vtkEgExtractVolumeCells.h"
  53 #include "egvtkobject.h"
  54 #include "boundarycondition.h"
  55
  56 #include "std_includes.h"
  57 #include "guitransform.h"
  58
  59 class GuiOutputWindow : public QWidget
  60 {
  61
  62   friend class GuiMainWindow;
  63
  64   Q_OBJECT;
  65
  66 private: // attributes
  67
  68   Ui::GuiOutputWindow ui;
  69
  70 public: // methods
  71
  72   GuiOutputWindow();
  73
  74 };
  75
  76
  77
  78
  79 /**
  80  * This is the main GUI class of enGrid.
  81  */
  82 class GuiMainWindow : public QMainWindow, public EgVtkObject
  83 {
  84
  85   Q_OBJECT;
  86
  87 private: // attributes
  88
  89   /** The user interface definition -- created by QtDesigner. */
  90   Ui::GuiMainWindow ui;
  91
  92   /** The current state of the grid that is being generated. */
  93   vtkUnstructuredGrid *grid;
  94
  95   vtkPolyData *boundary_pd;
  96   vtkPolyData *tetras_pd;
  97   vtkPolyData *wedges_pd;
  98   vtkPolyData *pyras_pd;
  99   vtkPolyData *hexas_pd;
 100   vtkPolyData *volume_pd;
 101
 102   /** The VTK renderer object, used for visualising the grid */
 103   vtkRenderer *renderer;
 104
 105   vtkActor *surface_actor;
 106   vtkActor *surface_wire_actor;
 107   vtkActor *tetra_actor;
 108   vtkActor *wedge_actor;
 109   vtkActor *pyramid_actor;
 110   vtkActor *hexa_actor;
 111   vtkActor *volume_wire_actor;
 112   vtkProperty *backface_property;
 113
 114   vtkPolyDataMapper *surface_mapper;
 115   vtkPolyDataMapper *surface_wire_mapper;
 116   vtkPolyDataMapper *tetra_mapper;
 117   vtkPolyDataMapper *pyramid_mapper;
 118   vtkPolyDataMapper *wedge_mapper;
 119   vtkPolyDataMapper *hexa_mapper;
 120   vtkPolyDataMapper *volume_wire_mapper;
 121
 122   vtkEgExtractVolumeCells *extr_vol;
 123   vtkEgExtractVolumeCells *extr_tetras;
 124   vtkEgExtractVolumeCells *extr_pyramids;
 125   vtkEgExtractVolumeCells *extr_wedges;
 126   vtkEgExtractVolumeCells *extr_hexas;
 127
 128   vtkGeometryFilter *volume_geometry;
 129   vtkGeometryFilter *tetra_geometry;
 130   vtkGeometryFilter *pyramid_geometry;
 131   vtkGeometryFilter *wedge_geometry;
 132   vtkGeometryFilter *hexa_geometry;
 133
 134   /** VTK filter to extract the surface of the current grid. */
 135   vtkGeometryFilter *surface_filter;
 136
 137   /** sphere to mark picked cell/points */
 138   vtkSphereSource *pick_sphere;
 139
 140   /** Size to use for picker objects and annotations */
 141   double ReferenceSize;
 142
 143   /** 2D Text actor to display node IDs */
 144   vector <vtkTextActor*> NodeText;
 145
 146   /** 2D Text actor to display cell IDs */
 147   vector <vtkTextActor*> CellText;
 148
 149   /** 3D Text actor to display node IDs */
 150   vector <vtkVectorText*> NodeText_VectorText;
 151   vector <vtkPolyDataMapper*> NodeText_PolyDataMapper;
 152   vector <vtkFollower*> NodeText_Follower;
 153
 154   /** 3D Text actor to display cell IDs */
 155   vector <vtkVectorText*> CellText_VectorText;
 156   vector <vtkPolyDataMapper*> CellText_PolyDataMapper;
 157   vector <vtkFollower*> CellText_Follower;
 158
 159   /** Picked point */
 160   static vtkIdType PickedPoint;
 161
 162   /** Picked cell */
 163   static vtkIdType PickedCell;
 164
 165   /** Boolean value specifying wether the VTK Interactor should be used or not to determine picked points/cells */
 166   static bool m_UseVTKInteractor;
 167
 168 /*  vtkTextActor* textActor[3];
 169
 170   vtkVectorText* atext[3];
 171   vtkPolyDataMapper* textMapper[3];
 172   vtkFollower* textActor2[3];*/
 173
 174   /** VTK mapper to map pick marker */
 175   vtkPolyDataMapper *pick_mapper;
 176
 177   /** VTK actor to display pick marker */
 178   vtkActor *pick_actor;
 179
 180   /** VTK actor to display the coordinate system */
 181   vtkCubeAxesActor2D *axes;
 182
 183   /** The current file name of the grid. */
 184   QString current_filename;
 185
 186   /** Status bar of the main window and application */
 187   QStatusBar *status_bar;
 188
 189   /** Label for the information in the status bar */
 190   QLabel *status_label;
 191
 192   /** A QList with all active boundary codes. */
 193   QSet<int> display_boundary_codes;
 194
 195     /** A QList with all boundary codes. */
 196   QSet<int> all_boundary_codes;
 197
 198   /** VTK filter to extract boundary elements with certain codes */
 199   vtkEgBoundaryCodesFilter *bcodes_filter;
 200
 201   /** VTK CellPicker to pick cells for various user interactions */
 202   vtkCellPicker *CellPicker;
 203
 204   /** VTK PointPicker to pick points for various user interactions */
 205   vtkPointPicker *PointPicker;
 206
 207   /** flag to indicate that enGrid is busy with an operation */
 208   bool busy;
 209
 210   /** log file to collect program output for display in the output window */
 211   QString log_file_name;
 212
 213   /** number of lines that have been read from the log file */
 214   long int N_chars;
 215
 216   FILE *system_stdout;
 217   static QMutex mutex;
 218   QTimer garbage_timer;
 219   QTimer log_timer;
 220   GuiOutputWindow *output_window;
 221   QDockWidget *dock_widget;
 222
 223   /** mapping between numerical and symbolic boundary codes */
 224   QMap<int,BoundaryCondition> bcmap;
 225
 226 private: // static attributes
 227
 228   /**
 229    * Platform independant access to application settings.
 230    * For a UNIX system the user preferences will be stored in the file
 231    * folder ".config/enGits/enGrid.conf" in the user's home directory;
 232    * on Windows preferences will be stored in the registry.
 233    */
 234   static QSettings qset;
 235
 236   /**
 237    * The current working directory of enGrid
 238    */
 239   static QString cwd;
 240
 241   /** a static this pointer (somewhat ugly, but there is only one MainWindow) */
 242   static GuiMainWindow *THIS;
 243
 244 private: // methods
 245
 246   /** Add VTK type information to the grid (useful for visualisation with ParaView). */
 247   void addVtkTypeInfo();
 248
 249   /** callback for cell picking */
 250   static void pickCellCallBack(vtkObject *caller, unsigned long int eid, void *clientdata, void *calldata);
 251
 252   /** callback for point picking */
 253   static void pickPointCallBack(vtkObject *caller, unsigned long int eid, void *clientdata, void *calldata);
 254
 255 public: // methods
 256
 257   /**
 258    * The constructor connects the menu and toolbar actions and
 259    * the VTK basics(i.e. renderer, actor, ...) will be set up.
 260    * Furthermore preferences will be read from qset.
 261    */
 262   GuiMainWindow();
 263
 264   /**
 265    * Preferences will be written back.
 266    */
 267   virtual ~GuiMainWindow();
 268
 269   /**
 270    * Get the VTK render window
 271    * @return the VTK render window
 272    */
 273   vtkRenderWindow* getRenderWindow();
 274
 275   /**
 276    * Get the VTK renderer
 277    * @return the VTK renderer
 278    */
 279   vtkRenderer* getRenderer();
 280
 281   /**
 282    * Get the Qt-VTK interactor
 283    * @return the Qt-VTK interactor
 284    */
 285   QVTKInteractor* getInteractor();
 286
 287   /**
 288    * Get a pointer to the current grid object
 289    * @return a pointer to the current vtkUnstructuredGrid object
 290    */
 291   vtkUnstructuredGrid* getGrid() { return grid; };
 292
 293   void setBusy() { busy = true; updateStatusBar(); };
 294   void setIdle() { busy = false; updateStatusBar(); };
 295
 296 public: // static methods
 297
 298   /**
 299    * Get the current working directory.
 300    * @return the current working directory
 301    */
 302   static QString getCwd();
 303
 304   /**
 305    * Set the current working directory
 306    * @param cwd the current working directory
 307    */
 308   static void setCwd(QString dir);
 309
 310   /**
 311    * Get the currently picked cell.
 312    * @return the picked cell ID or -1 if no cell has been picked
 313    */
 314   static vtkIdType getPickedCell();
 315
 316   /**
 317    * Get the currently picked point.
 318    * @return the picked point ID or -1 if no point has been picked
 319    */
 320   static vtkIdType getPickedPoint();
 321
 322   /**
 323    * Access to the QSettings object/
 324    */
 325   static QSettings* settings() { return &qset; };
 326
 327   BoundaryCondition getBC(int bc) { return bcmap[bc]; };
 328
 329   static GuiMainWindow* pointer() { return THIS; };
 330   static void lock() { mutex.lock(); };
 331   static void unlock() { mutex.unlock(); };
 332   static bool tryLock() { return mutex.tryLock(); };
 333   void getAllBoundaryCodes(QSet<int> &bcs);
 334   vtkPointPicker* getPointPicker(){return(PointPicker);};
 335   vtkSphereSource* getPickSphere(){return(pick_sphere);};
 336   bool pickPoint(vtkIdType Point);
 337   bool pickCell(vtkIdType cellId);
 338
 339 public slots:
 340   void setUseVTKInteractor(int a_UseVTKInteractor);
 341   void setPickMode(bool a_UseVTKInteractor,bool a_CellPickerMode);
 342
 343   /** Exit the application */
 344   void exit();
 345
 346   /** Import an STL file (ASCII or binary) */
 347   void importSTL();
 348
 349   /** Import a Gmsh grid from an ASCII file -- using version 1.0 of the Gmsh file format */
 350   void importGmsh1Ascii();
 351
 352   /** Export a grid from to an ASCII Gmsh file -- using version 1.0 of the Gmsh file format */
 353   void exportGmsh1Ascii();
 354
 355   /** Import a Gmsh grid from an ASCII file -- using version 2.0 of the Gmsh file format */
 356   void importGmsh2Ascii();
 357
 358   /** Export a grid from to an ASCII Gmsh file -- using version 2.0 of the Gmsh file format */
 359   void exportGmsh2Ascii();
 360
 361   /** Export a grid to neutral format for NETGEN */
 362   void exportNeutral();
 363
 364   /** Update the VTK output */
 365   void updateActors();
 366
 367   /** Move the camera in order to show everything on the screen */
 368   void zoomAll();
 369
 370   /** Open an existing grid */
 371   void open();
 372
 373   void openBC();
 374   void saveBC();
 375
 376   void undo();
 377   void redo();
 378
 379   /** Save the current grid */
 380   void save();
 381
 382   /** Save the current grid -- using a different file name */
 383   void saveAs();
 384
 385   /** Save the current grid as a_filename */
 386   void QuickSave(QString a_filename);
 387
 388   /** Update the status bar */
 389   void updateStatusBar();
 390
 391   /** Select the boundary codes to be diplayed/hidden */
 392   void selectBoundaryCodes();
 393
 394   /** Update the boundary code book keeping (e.g. after reading a mesh). */
 395   void updateBoundaryCodes(bool all_on);
 396
 397   /** Normal extrusion of boundary elements (no validity check). */
 398   void normalExtrusion();
 399
 400   /** Toggle the visibility of the axes annotation. */
 401   void setAxesVisibility();
 402
 403   /** Toggle orthogonal viewing mode. */
 404   void setViewingMode();
 405
 406   /** Toggle node ID viewing mode. */
 407   void ViewNodeIDs();
 408
 409   /** Toggle cell ID viewing mode. */
 410   void ViewCellIDs();
 411
 412   /** Change the orientation of all surface elements */
 413   void changeSurfaceOrientation();
 414
 415   /** Check and, if required, change the orientation of all surface elements */
 416   void checkSurfaceOrientation();
 417
 418   /** Eliminate edges in order to improve the aspect ratio of the cells */
 419   void improveAspectRatio();
 420
 421   /** Write surface elements to an ASCII STL file. */
 422   void exportAsciiStl();
 423
 424   /** Write surface elements to a binary STL file. */
 425   void exportBinaryStl();
 426
 427   /** Edit boundary conditions (names and types) */
 428   void editBoundaryConditions();
 429
 430   /** Edit settings */
 431   void configure();
 432
 433   /** Display an about message */
 434   void about();
 435
 436   void viewXP();
 437   void viewXM();
 438   void viewYP();
 439   void viewYM();
 440   void viewZP();
 441   void viewZM();
 442
 443   void appendOutput(QString txt) { output_window->ui.textEditOutput->append(txt); };
 444   void clearOutput() { output_window->ui.textEditOutput->clear(); };
 445   void updateOutput();
 446   void periodicUpdate();
 447
 448   // SLOTS for all standard operations should be defined below;
 449   // entries should look like this:
 450   // void callOperationName() { EG_STDSLOT(OperationName); };
 451   // The actual class name in this case, however, would be GuiOperationName.
 452   //
 453   // the following line can be used as a template:
 454   // void call() { EG_STDSLOT(); };
 455
 456   void callSmoothSurface() { EG_STDINTERSLOT(GuiSmoothSurface); };
 457   void callCreateBoundaryLayer() { EG_STDSLOT(GuiCreateBoundaryLayer); };
 458   void callDivideBoundaryLayer() { EG_STDSLOT(GuiDivideBoundaryLayer); };
 459   void callDeleteVolumeGrid() { EG_STDSLOT(DeleteVolumeGrid); };
 460   void callDeleteTetras() { EG_STDSLOT(DeleteTetras); };
 461   void callCreateVolumeMesh() { EG_STDSLOT(CreateVolumeMesh); };
 462   void callSmoothVolumeGrid() { EG_STDSLOT(SmoothVolumeGrid); };
 463   void callSetBoundaryCode()  { EG_STDINTERSLOT(GuiSetBoundaryCode); };
 464   void callDeleteBadAspectTris() { EG_STDINTERSLOT(GuiDeleteBadAspectTris); };
 465   void callDeletePickedCell() { EG_STDSLOT(DeletePickedCell); };
 466   void callDeletePickedPoint() { EG_STDINTERSLOT(DeletePickedPoint); };
 467   void callPick_cell_point() { EG_STDINTERSLOT(GuiPick); };
 468   void callTransform() { EG_STDINTERSLOT(GuiTransform); };
 469
 470   void callFixSTL();
 471
 472   void callFoamReader()       { EG_STDREADERSLOT(FoamReader); };
 473   void callFoamWriter()       { EG_STDINTERSLOT(FoamWriter); };
 474   void callSimpleFoamWriter() { EG_STDINTERSLOT(SimpleFoamWriter); };
 475   void callVtkReader()        { EG_STDREADERSLOT(VtkReader); };
 476   void callPolyDataReader()   { EG_STDREADERSLOT(PolyDataReader); };
 477
 478 };
 479
 480 #endif