operation.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 operation_H
  24 #define operation_H
  25
  26 class Operation;
  27 class GuiMainWindow;
  28
  29 #include "egvtkobject.h"
  30
  31 #include <vtkUnstructuredGrid.h>
  32 #include <vtkCellType.h>
  33 #include <vtkSmartPointer.h>
  34
  35 #include <QThread>
  36 #include <QMutex>
  37 #include <QListWidget>
  38
  39 #include <typeinfo>
  40
  41 class OperationThread : public QThread
  42 {
  43
  44 private:
  45
  46   Operation *op;
  47
  48 protected:
  49
  50   virtual void run();
  51
  52 public:
  53
  54   void setOperation(Operation *an_op) { op = an_op; };
  55
  56 };
  57
  58 struct stencil_t {
  59   vtkIdType id_cell1;
  60   vtkIdType id_cell2;
  61   vtkIdType p[4];
  62   bool valid;
  63 };
  64 ostream& operator<<(ostream &out, stencil_t S);
  65
  66 /**
  67  * This is the base class for all mesh operations.
  68  * Operations will typically be triggered by a Qt event; the MainWindow
  69  * object will call operator() with the current grid as parameter.
  70  */
  71 class Operation : public EgVtkObject
  72 {
  73
  74   friend class OperationThread;
  75   OperationThread thread;
  76
  77 private: // static attributes
  78
  79   static QSet<Operation*> garbage_operations;
  80
  81 private: // attributes
  82
  83   QVector<vtkIdType> nodes_map;
  84   QVector<vtkIdType> cells_map;
  85   bool               gui;
  86   bool               autoset;
  87   Error             *err;
  88
  89 private: // methods
  90
  91   void initMapping();
  92
  93 protected: // attributes
  94
  95   vtkUnstructuredGrid   *grid;
  96   QVector<vtkIdType>     cells;
  97   QVector<int>           _cells;
  98   QVector<vtkIdType>     nodes;
  99   QVector<int>           _nodes;
 100   QVector<QSet<int> >    n2c;
 101   QVector<QSet<int> >    n2n;
 102   QVector<QVector<int> > c2c;
 103   QVector<bool>          node_fixed;
 104   QVector<bool>          cell_fixed;
 105
 106   //Special attributes for UpdateNodeType_all function
 107   double Convergence;
 108   int NumberOfIterations;
 109   double RelaxationFactor;
 110   int FeatureEdgeSmoothing;
 111   double FeatureAngle;
 112   double EdgeAngle;
 113   int BoundarySmoothing;
 114   int GenerateErrorScalars;
 115   int GenerateErrorVectors;
 116
 117 protected: // methods
 118
 119   void checkGrid();
 120   void updateActors();
 121   GuiMainWindow* mainWindow();
 122   virtual void operate() = 0;
 123
 124 public: // methods
 125
 126   Operation();
 127   virtual ~Operation();
 128   void del();
 129
 130   void setGrid(vtkUnstructuredGrid *ug) { grid = ug; };
 131   void setAllCells();
 132   void setAllVolumeCells();
 133   void setAllSurfaceCells();
 134   vtkIdType getNewNode(vtkIdType id_old_node) { return nodes_map[_nodes[id_old_node]] ; };
 135   vtkIdType getNewCell(vtkIdType id_old_cell) { return cells_map[_cells[id_old_cell]] ; };
 136   void setNewNode(vtkIdType id_old_node, vtkIdType id_new_node) { nodes_map[_nodes[id_old_node]] = id_new_node; };
 137   void setNewCell(vtkIdType id_old_cell, vtkIdType id_new_cell) { cells_map[_cells[id_old_cell]] = id_new_cell; };
 138   void setGui() { gui = true; };
 139   OperationThread& getThread() { return thread; };
 140   void enableAutoSet() { autoset = true; };
 141   void disableAutoSet() { autoset = false; };
 142
 143   /**
 144    * Fill a QListWidget with all available boundary codes from a grid.
 145    * @param lw   The QListWidget to fill.
 146    * @param grid The grid to use.
 147    */
 148   void populateBoundaryCodes(QListWidget *lw);
 149
 150   virtual void operator()();
 151
 152   template <class T> void setCells(const T &cls);
 153   template <class T> void setNodes(const T &nds);
 154
 155   static void collectGarbage();
 156   stencil_t getStencil(vtkIdType id_cell1, int j1);
 157
 158   vtkIdType getClosestNode(vtkIdType a_id_node,vtkUnstructuredGrid* a_grid);
 159   vtkIdType getFarthestNode(vtkIdType a_id_node,vtkUnstructuredGrid* a_grid);
 160
 161   bool SwapCells(vtkUnstructuredGrid* a_grid, stencil_t S);
 162   void quad2triangle(vtkUnstructuredGrid* src,vtkIdType quadcell);
 163   void quad2triangle(vtkUnstructuredGrid* src,vtkIdType quadcell,vtkIdType MovingPoint);
 164
 165   bool DeletePoint(vtkUnstructuredGrid *src, vtkIdType DeadNode);
 166   int NumberOfCommonPoints(vtkIdType node1, vtkIdType node2, bool& IsTetra);
 167 //   vtkIdType FindSnapPoint(vtkUnstructuredGrid *src, vtkIdType DeadNode);
 168   bool EmptyVolume(vtkIdType DeadNode, vtkIdType PSP);
 169
 170   vec3_t GetCenter(vtkIdType cellId, double& R);
 171
 172 //   bool getNeighbours(vtkIdType Boss, vtkIdType& Peon1, vtkIdType& Peon2, int BC);
 173   bool getNeighbours(vtkIdType Boss, QVector <vtkIdType>& Peons, int BC);
 174
 175   int UpdateMeshDensity();
 176   int UpdateNodeType_all();
 177   int UpdateNodeType();
 178
 179   vtkIdType FindSnapPoint(vtkUnstructuredGrid *src, vtkIdType DeadNode,QSet <vtkIdType> & DeadCells,QSet <vtkIdType> & MutatedCells,QSet <vtkIdType> & MutilatedCells, int& N_newpoints, int& N_newcells);
 180   bool DeletePoint_2(vtkUnstructuredGrid *src, vtkIdType DeadNode, int& N_newpoints, int& N_newcells);
 181   bool DeleteSetOfPoints(vtkUnstructuredGrid *src, QSet <vtkIdType> DeadNodes, int& N_newpoints, int& N_newcells);
 182
 183   void TxtSave(QString a_filename);
 184   void DualSave(QString a_filename);
 185
 186   //Special for UpdateNodeType_all
 187   void SetConvergence(double C){Convergence=C;};
 188   void SetNumberOfIterations(int N){NumberOfIterations=N;};
 189   void SetRelaxationFactor(double RF){RelaxationFactor=RF;};
 190   void SetFeatureEdgeSmoothing(int FES){FeatureEdgeSmoothing=FES;};
 191   void SetFeatureAngle(double FA){FeatureAngle=FA;};
 192   void SetEdgeAngle(double EA){EdgeAngle=EA;};
 193   void SetBoundarySmoothing(int BS){BoundarySmoothing=BS;};
 194   void SetGenerateErrorScalars(int GES){GenerateErrorScalars=GES;};
 195   void SetGenerateErrorVectors(int GEV){GenerateErrorVectors=GEV;};
 196
 197 };
 198 //End of class Operation
 199
 200 template <class T>
 201 void Operation::setCells(const T &cls)
 202 {
 203   cells.resize(cls.size());
 204   qCopy(cls.begin(), cls.end(), cells.begin());
 205   getNodesFromCells(cells, nodes, grid);
 206   createCellMapping(cells, _cells, grid);
 207   createNodeMapping(nodes, _nodes, grid);
 208   createNodeToCell(cells, nodes, _nodes, n2c, grid);
 209   createNodeToNode(cells, nodes, _nodes, n2n, grid);
 210   createCellToCell(cells, c2c, grid);
 211   node_fixed.fill(nodes.size(), false);
 212   cell_fixed.fill(cells.size(), false);
 213   initMapping();
 214 };
 215
 216 template <class T>
 217 void Operation::setNodes(const T &nds)
 218 {
 219   nodes.resize(nds.size());
 220   qCopy(nds.begin(), nds.end(), nodes.begin());
 221   createNodeMapping(nodes, _nodes, grid);
 222   QSet<vtkIdType> cls;
 223   for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) {
 224     vtkIdType *pts, N_pts;
 225     grid->GetCellPoints(id_cell, N_pts, pts);
 226     for (int i_pts = 0; i_pts < N_pts; ++i_pts) {
 227       if (_nodes[pts[i_pts]] >= 0) {
 228         cls.insert(id_cell);
 229         break;
 230       };
 231     };
 232   };
 233   cells.resize(cls.size());
 234   qCopy(cls.begin(), cls.end(), cells.begin());
 235   createCellMapping(cells, _cells, grid);
 236   createNodeToCell(cells, nodes, _nodes, n2c, grid);
 237   createNodeToNode(cells, nodes, _nodes, n2n, grid);
 238   createCellToCell(cells, c2c, grid);
 239   node_fixed.fill(nodes.size(), false);
 240   cell_fixed.fill(cells.size(), false);
 241   initMapping();
 242 };
 243
 244 //////////////////////////////////////////////
 245 double CurrentVertexAvgDist(vtkIdType a_vertex,QVector< QSet< int > > &n2n,vtkUnstructuredGrid *a_grid);
 246 double CurrentMeshDensity(vtkIdType a_vertex,QVector< QSet< int > > &n2n,vtkUnstructuredGrid *a_grid);
 247 double DesiredVertexAvgDist(vtkIdType a_vertex,QVector< QSet< int > > &n2n,vtkUnstructuredGrid *a_grid);
 248 double DesiredMeshDensity(vtkIdType a_vertex,QVector< QSet< int > > &n2n,vtkUnstructuredGrid *a_grid);
 249
 250 #endif