src/HEXABLOCK/HexDocument_trans.cxx

   1
   2 // C++ : La clase principale de Hexa
   3
   4 // Copyright (C) 2009-2023  CEA, EDF
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include "HexDocument.hxx"
  23
  24 #include "HexEltBase.hxx"
  25 #include "HexVertex.hxx"
  26 #include "HexEdge.hxx"
  27 #include "HexQuad.hxx"
  28 #include "HexHexa.hxx"
  29
  30 #include "HexElements.hxx"
  31
  32 #include "HexVector.hxx"
  33 #include "HexMatrix.hxx"
  34 #include "HexCloner.hxx"
  35 #include "HexPropagation.hxx"
  36 #include "HexLaw.hxx"
  37
  38 #include "HexXmlWriter.hxx"
  39 #include "HexXmlTree.hxx"
  40 #include "HexGlobale.hxx"
  41
  42 BEGIN_NAMESPACE_HEXA
  43 // ========================================================= performTranslation
  44 int Document::performTranslation (Elements* elts, Vector* trans)
  45 {
  46    DumpStart ("performTranslation", elts << trans);
  47
  48    Matrix matrice;
  49    matrice.defTranslation (trans);
  50
  51    int    ier = elts->transform (&matrice);
  52
  53    DumpReturn (ier);
  54    return ier;
  55 }
  56 // ==================================================== performScale
  57 int Document::performScale (Elements* elts, Vertex* ver, double k)
  58 {
  59    DumpStart ("performScale", elts << ver << k);
  60
  61    Matrix matrice;
  62    matrice.defScale (ver, k);
  63
  64    int    ier = elts->transform (&matrice);
  65
  66    DumpReturn (ier);
  67    return ier;
  68 }
  69 // ==================================================== performRotation
  70 int Document::performRotation (Elements* elts, Vertex* ver, Vector* vec, double angle)
  71 {
  72    DumpStart ("performRotation", elts << ver << vec << angle);
  73
  74    Matrix matrice;
  75    matrice.defRotation (ver, vec, angle);
  76
  77    int    ier = elts->transform (&matrice);
  78
  79    DumpReturn (ier);
  80    return ier;
  81 }
  82 // ==================================================== performSymmetryPoint
  83 int Document::performSymmetryPoint (Elements* elts, Vertex* ver)
  84 {
  85    DumpStart ("performSymmetryPoint", elts << ver);
  86
  87    Matrix matrice;
  88    matrice.defSymmetryPoint (ver);
  89
  90    int    ier = elts->transform (&matrice);
  91
  92    DumpReturn (ier);
  93    return ier;
  94 }
  95 // ==================================================== performSymmetryPlane
  96 int Document::performSymmetryPlane (Elements* elts, Vertex* ver, Vector* vec)
  97 {
  98    DumpStart ("performSymmetryPlane", elts << ver << vec);
  99
 100    Matrix matrice;
 101    matrice.defSymmetryPlane (ver, vec);
 102
 103    int    ier = elts->transform (&matrice);
 104
 105    DumpReturn (ier);
 106    return ier;
 107 }
 108
 109 // ==================================================== performSymmetryLine
 110 int Document::performSymmetryLine (Elements* elts, Vertex* ver, Vector* vec)
 111 {
 112    DumpStart ("performSymmetryLine", elts << ver << vec);
 113
 114    Matrix matrice;
 115    matrice.defSymmetryLine (ver, vec);
 116
 117    int    ier = elts->transform (&matrice);
 118
 119    DumpReturn (ier);
 120    return ier;
 121 }
 122 // --------------------------------------------------------
 123 // --------------------------------------------------------
 124 // --------------------------------------------------------
 125 // ========================================================= clonerElements
 126 Elements* Document::clonerElements (Elements* table, Matrix* matrice)
 127 {
 128    Cloner    copieur (matrice);
 129    Elements* grille = copieur.clonerElements (table);
 130    return    grille;
 131 }
 132 // --------------------------------------------------------
 133 // --------------------------------------------------------
 134 // --------------------------------------------------------
 135 // ========================================================= makeTranslation
 136 Elements* Document::makeTranslation (Elements* table, Vector* trans)
 137 {
 138    DumpStart ("makeTranslation", table  << trans);
 139
 140    Matrix  matrice;
 141    matrice.defTranslation (trans);
 142
 143    Elements* grille = clonerElements (table, &matrice);
 144
 145    DumpReturn (grille);
 146    return  grille;
 147 }
 148 // ========================================================= makeScale
 149 Elements* Document::makeScale (Elements* table, Vertex* ver, double k)
 150 {
 151    DumpStart ("makeScale", table  << ver << k);
 152
 153    Matrix  matrice;
 154    matrice.defScale (ver, k);
 155
 156    Elements* grille = clonerElements (table, &matrice);
 157
 158    DumpReturn (grille);
 159    return    grille;
 160 }
 161 // ========================================================= makeRotation
 162 Elements* Document::makeRotation (Elements* table, Vertex* ver, Vector* vec,
 163                                   double angle)
 164 {
 165    DumpStart ("makeRotation", table  << ver << vec << angle);
 166
 167    Matrix  matrice;
 168    matrice.defRotation (ver, vec, angle);
 169
 170    Elements* grille = clonerElements (table, &matrice);
 171
 172    DumpReturn (grille);
 173    return    grille;
 174 }
 175 // ========================================================= makeSymmetryPoint
 176 Elements* Document::makeSymmetryPoint (Elements* table, Vertex* ver)
 177 {
 178    DumpStart ("makeSymmetryPoint", table  << ver);
 179
 180    Matrix  matrice;
 181    matrice.defSymmetryPoint (ver);
 182
 183    Elements* grille = clonerElements (table, &matrice);
 184
 185    DumpReturn (grille);
 186    return    grille;
 187 }
 188 // ========================================================= makeSymmetryLine
 189 Elements* Document::makeSymmetryLine (Elements* table, Vertex* ver, Vector* vec)
 190 {
 191    DumpStart ("makeSymmetryLine", table  << ver << vec);
 192
 193    Matrix  matrice;
 194    matrice.defSymmetryLine (ver, vec);
 195
 196    Elements* grille = clonerElements (table, &matrice);
 197
 198    DumpReturn (grille);
 199    return    grille;
 200 }
 201 // ========================================================= makeSymmetryPlane
 202 Elements* Document::makeSymmetryPlane (Elements* table, Vertex* ver, Vector* vec)
 203 {
 204    DumpStart ("makeSymmetryPlane", table  << ver << vec);
 205
 206    Matrix  matrice;
 207    matrice.defSymmetryPlane (ver, vec);
 208
 209    Elements* grille = clonerElements (table, &matrice);
 210
 211    DumpReturn (grille);
 212    return    grille;
 213 }
 214 // ----------------------------------------------------------------------
 215 // ------------ Destroy
 216 // ----------------------------------------------------------------------
 217 // ========================================================= removeHexa
 218 int Document::removeHexa (Hexa* cell)
 219 {
 220    DumpStart ("removeHexa", cell);
 221
 222    int ier = HOK;
 223    if (BadElement (cell))
 224       {
 225       ier = HERR;
 226       DumpReturn (ier);
 227       return ier;
 228       }
 229
 230    update ();
 231    Quads menage;
 232    for (int nro = 0 ; nro < HQ_MAXI ; ++nro)
 233        {
 234        Quad* quad = cell->getQuad (nro);
 235        if (EltIsValid(quad) && quad->getNbrParents()<=1)
 236           menage.push_back (quad);
 237        }
 238
 239    cell->remove ();
 240    int nbdel = menage.size();
 241    for (int nro = 0 ; nro < nbdel ; ++nro)
 242        menage[nro]->remove();
 243
 244    DumpReturn (HOK);
 245    return HOK;
 246 }
 247 // ========================================================= removeQuad
 248 int Document::removeQuad (Quad* cell)
 249 {
 250    DumpStart ("removeQuad", cell);
 251
 252    int ier = HOK;
 253    if (cell==NULL)
 254       ier = HERR;
 255    else
 256       cell->remove ();
 257
 258    DumpReturn (ier);
 259    return ier;
 260 }
 261 // ========================================================= removeElements
 262 int Document::removeElements (Elements* bloc)
 263 {
 264    DumpStart ("removeElements", bloc);
 265
 266    int ier = HOK;
 267
 268    if (bloc==NULL)
 269       ier = HERR;
 270    else
 271       bloc->remove ();
 272
 273    DumpReturn (ier);
 274    return ier;
 275 }
 276 // ====================================================== removeConnectedHexa
 277 int Document::removeConnectedHexa (Hexa* cell)
 278 {
 279    DumpStart ("removeConnectedHexa", cell);
 280
 281    int ier = HOK;
 282
 283    if (cell==NULL)
 284       ier = HERR;
 285    else
 286       {
 287       update ();
 288       cell->removeConnected ();
 289       }
 290
 291    DumpReturn (ier);
 292    return ier;
 293 }
 294 // ========================================================= dumpPropagation
 295 void Document::dumpPropagation ()
 296 {
 297    int nb = countPropagation ();
 298
 299    for (int nro=0 ; nro<nb ; nro++)
 300        {
 301        Propagation*  prop  = getPropagation (nro);
 302        const Edges&  table = prop->getEdges ();
 303        printf (" ____________________________________ Prop nro %d\n", nro);
 304        for (int ned=0 ; ned<(int)table.size() ; ned++)
 305            {
 306            bool way = table [ned]->getWay ();
 307
 308            table [ned]->printName (" = ");
 309            if (way)
 310               {
 311               printf (" +(");
 312               table [ned]->getVertex (0)->printName (", ");
 313               table [ned]->getVertex (1)->printName (")\n");
 314               }
 315           else
 316               {
 317               printf (" -(");
 318               table [ned]->getVertex (1)->printName (", ");
 319               table [ned]->getVertex (0)->printName (")\n");
 320               }
 321            }
 322        }
 323 }
 324 // ----------------------------------------------------------------------
 325 // ------------ reorderFaces
 326 // ----------------------------------------------------------------------
 327 // ========================================================= reorderFaces
 328 // ==== Ordonner les faces externes
 329 void Document::reorderFaces ()
 330 {
 331    majReferences ();
 332    for (EltBase* elt = doc_first_elt[EL_QUAD]->next (); elt!=NULL;
 333                  elt = elt->next())
 334        {
 335        Quad* quad = static_cast <Quad*> (elt);
 336        if (quad!=NULL && quad->isHere())
 337            quad->setOrientation ();
 338        }
 339
 340 }
 341 END_NAMESPACE_HEXA