src/SMESHDS/SMESHDS_Command.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   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.
  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 //  SMESH SMESHDS : management of mesh data and SMESH document
  23 //  File   : SMESH_Command.cxx
  24 //  Author : Yves FRICAUD, OCC
  25 //  Module : SMESH
  26 //  $Header:
  27 //
  28 #include "SMESHDS_Command.hxx"
  29
  30 #include "utilities.h"
  31
  32 using namespace std;
  33
  34 //=======================================================================
  35 //function : Constructor
  36 //purpose  :
  37 //=======================================================================
  38 SMESHDS_Command::SMESHDS_Command(const SMESHDS_CommandType aType):myType(aType),
  39 myNumber(0)
  40 {
  41 }
  42
  43 //=======================================================================
  44 //function : Destructor
  45 //purpose  :
  46 //=======================================================================
  47 SMESHDS_Command::~SMESHDS_Command()
  48 {
  49 }
  50
  51 //=======================================================================
  52 //function :
  53 //purpose  :
  54 //=======================================================================
  55 void SMESHDS_Command::AddNode(int NewNodeID, double x, double y, double z)
  56 {
  57         if (!myType == SMESHDS_AddNode)
  58         {
  59                 MESSAGE("SMESHDS_Command::AddNode : Bad Type");
  60                 return;
  61         }
  62         myIntegers.push_back(NewNodeID);
  63         myReals.push_back(x);
  64         myReals.push_back(y);
  65         myReals.push_back(z);
  66         myNumber++;
  67 }
  68
  69 //=======================================================================
  70 //function :
  71 //purpose  :
  72 //=======================================================================
  73 void SMESHDS_Command::MoveNode(int NodeID, double x, double y, double z)
  74 {
  75         if (!myType == SMESHDS_MoveNode)
  76         {
  77                 MESSAGE("SMESHDS_Command::MoveNode : Bad Type");
  78                 return;
  79         }
  80         myIntegers.push_back(NodeID);
  81         myReals.push_back(x);
  82         myReals.push_back(y);
  83         myReals.push_back(z);
  84         myNumber++;
  85 }
  86
  87 //=======================================================================
  88 //function :
  89 //purpose  :
  90 //=======================================================================
  91 void SMESHDS_Command::Add0DElement(int New0DElementID, int idnode)
  92 {
  93   if (!myType == SMESHDS_Add0DElement)
  94   {
  95     MESSAGE("SMESHDS_Command::Add0DElement : Bad Type");
  96     return;
  97   }
  98   myIntegers.push_back(New0DElementID);
  99   myIntegers.push_back(idnode);
 100   myNumber++;
 101 }
 102
 103 //=======================================================================
 104 //function :
 105 //purpose  :
 106 //=======================================================================
 107 void SMESHDS_Command::AddEdge(int NewEdgeID, int idnode1, int idnode2)
 108 {
 109         if (!myType == SMESHDS_AddEdge)
 110         {
 111                 MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
 112                 return;
 113         }
 114         myIntegers.push_back(NewEdgeID);
 115         myIntegers.push_back(idnode1);
 116         myIntegers.push_back(idnode2);
 117         myNumber++;
 118 }
 119
 120 //=======================================================================
 121 //function :
 122 //purpose  :
 123 //=======================================================================
 124 void SMESHDS_Command::AddFace(int NewFaceID,
 125         int idnode1, int idnode2, int idnode3)
 126 {
 127         if (!myType == SMESHDS_AddTriangle)
 128         {
 129                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 130                 return;
 131         }
 132         myIntegers.push_back(NewFaceID);
 133         myIntegers.push_back(idnode1);
 134         myIntegers.push_back(idnode2);
 135         myIntegers.push_back(idnode3);
 136         myNumber++;
 137 }
 138
 139 //=======================================================================
 140 //function :
 141 //purpose  :
 142 //=======================================================================
 143 void SMESHDS_Command::AddFace(int NewFaceID,
 144         int idnode1, int idnode2, int idnode3, int idnode4)
 145 {
 146         if (!myType == SMESHDS_AddQuadrangle)
 147         {
 148                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 149                 return;
 150         }
 151         myIntegers.push_back(NewFaceID);
 152         myIntegers.push_back(idnode1);
 153         myIntegers.push_back(idnode2);
 154         myIntegers.push_back(idnode3);
 155         myIntegers.push_back(idnode4);
 156         myNumber++;
 157 }
 158
 159 //=======================================================================
 160 //function :
 161 //purpose  :
 162 //=======================================================================
 163 void SMESHDS_Command::AddVolume(int NewVolID,
 164         int idnode1, int idnode2, int idnode3, int idnode4)
 165 {
 166         if (!myType == SMESHDS_AddTetrahedron)
 167         {
 168                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 169                 return;
 170         }
 171         myIntegers.push_back(NewVolID);
 172         myIntegers.push_back(idnode1);
 173         myIntegers.push_back(idnode2);
 174         myIntegers.push_back(idnode3);
 175         myIntegers.push_back(idnode4);
 176         myNumber++;
 177 }
 178
 179 //=======================================================================
 180 //function :
 181 //purpose  :
 182 //=======================================================================
 183 void SMESHDS_Command::AddVolume(int NewVolID,
 184         int idnode1, int idnode2, int idnode3, int idnode4, int idnode5)
 185 {
 186         if (!myType == SMESHDS_AddPyramid)
 187         {
 188                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 189                 return;
 190         }
 191         myIntegers.push_back(NewVolID);
 192         myIntegers.push_back(idnode1);
 193         myIntegers.push_back(idnode2);
 194         myIntegers.push_back(idnode3);
 195         myIntegers.push_back(idnode4);
 196         myIntegers.push_back(idnode5);
 197         myNumber++;
 198 }
 199
 200 //=======================================================================
 201 //function :
 202 //purpose  :
 203 //=======================================================================
 204 void SMESHDS_Command::AddVolume(int NewVolID,
 205         int idnode1,
 206         int idnode2, int idnode3, int idnode4, int idnode5, int idnode6)
 207 {
 208         if (!myType == SMESHDS_AddPrism)
 209         {
 210                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 211                 return;
 212         }
 213         myIntegers.push_back(NewVolID);
 214         myIntegers.push_back(idnode1);
 215         myIntegers.push_back(idnode2);
 216         myIntegers.push_back(idnode3);
 217         myIntegers.push_back(idnode4);
 218         myIntegers.push_back(idnode5);
 219         myIntegers.push_back(idnode6);
 220         myNumber++;
 221 }
 222
 223 //=======================================================================
 224 //function :
 225 //purpose  :
 226 //=======================================================================
 227 void SMESHDS_Command::AddVolume(int NewVolID,
 228         int idnode1,
 229         int idnode2,
 230         int idnode3,
 231         int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
 232 {
 233         if (!myType == SMESHDS_AddHexahedron)
 234         {
 235                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 236                 return;
 237         }
 238         myIntegers.push_back(NewVolID);
 239         myIntegers.push_back(idnode1);
 240         myIntegers.push_back(idnode2);
 241         myIntegers.push_back(idnode3);
 242         myIntegers.push_back(idnode4);
 243         myIntegers.push_back(idnode5);
 244         myIntegers.push_back(idnode6);
 245         myIntegers.push_back(idnode7);
 246         myIntegers.push_back(idnode8);
 247         myNumber++;
 248 }
 249
 250 //=======================================================================
 251 //function : AddPolygonalFace
 252 //purpose  :
 253 //=======================================================================
 254 void SMESHDS_Command::AddPolygonalFace (const int        ElementID,
 255                                         std::vector<int> nodes_ids)
 256 {
 257   if (!myType == SMESHDS_AddPolygon) {
 258     MESSAGE("SMESHDS_Command::AddPolygonalFace : Bad Type");
 259     return;
 260   }
 261   myIntegers.push_back(ElementID);
 262
 263   int i, nbNodes = nodes_ids.size();
 264   myIntegers.push_back(nbNodes);
 265   for (i = 0; i < nbNodes; i++) {
 266     myIntegers.push_back(nodes_ids[i]);
 267   }
 268
 269   myNumber++;
 270 }
 271
 272 //=======================================================================
 273 //function : AddPolyhedralVolume
 274 //purpose  :
 275 //=======================================================================
 276 void SMESHDS_Command::AddPolyhedralVolume (const int        ElementID,
 277                                            std::vector<int> nodes_ids,
 278                                            std::vector<int> quantities)
 279 {
 280   if (!myType == SMESHDS_AddPolyhedron) {
 281     MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
 282     return;
 283   }
 284   myIntegers.push_back(ElementID);
 285
 286   int i, nbNodes = nodes_ids.size();
 287   myIntegers.push_back(nbNodes);
 288   for (i = 0; i < nbNodes; i++) {
 289     myIntegers.push_back(nodes_ids[i]);
 290   }
 291
 292   int nbFaces = quantities.size();
 293   myIntegers.push_back(nbFaces);
 294   for (i = 0; i < nbFaces; i++) {
 295     myIntegers.push_back(quantities[i]);
 296   }
 297
 298   myNumber++;
 299 }
 300
 301 //=======================================================================
 302 //function :
 303 //purpose  :
 304 //=======================================================================
 305 void SMESHDS_Command::RemoveNode(int NodeID)
 306 {
 307         if (!myType == SMESHDS_RemoveNode)
 308         {
 309                 MESSAGE("SMESHDS_Command::RemoveNode : Bad Type");
 310                 return;
 311         }
 312         myIntegers.push_back(NodeID);
 313         myNumber++;
 314 }
 315
 316 //=======================================================================
 317 //function :
 318 //purpose  :
 319 //=======================================================================
 320 void SMESHDS_Command::RemoveElement(int ElementID)
 321 {
 322         if (!myType == SMESHDS_RemoveElement)
 323         {
 324                 MESSAGE("SMESHDS_Command::RemoveElement : Bad Type");
 325                 return;
 326         }
 327         myIntegers.push_back(ElementID);
 328         myNumber++;
 329 }
 330
 331 //=======================================================================
 332 //function : ChangeElementNodes
 333 //purpose  :
 334 //=======================================================================
 335
 336 void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
 337 {
 338   if (!myType == SMESHDS_ChangeElementNodes)
 339   {
 340     MESSAGE("SMESHDS_Command::ChangeElementNodes : Bad Type");
 341     return;
 342   }
 343   myIntegers.push_back(ElementID);
 344   myIntegers.push_back(nbnodes);
 345   for ( int i = 0; i < nbnodes; i++ )
 346     myIntegers.push_back( nodes[ i ] );
 347
 348   myNumber++;
 349 }
 350
 351 //=======================================================================
 352 //function : ChangePolyhedronNodes
 353 //purpose  :
 354 //=======================================================================
 355 void SMESHDS_Command::ChangePolyhedronNodes (const int ElementID,
 356                                              std::vector<int> nodes_ids,
 357                                              std::vector<int> quantities)
 358 {
 359   if (myType != SMESHDS_ChangePolyhedronNodes)
 360   {
 361     MESSAGE("SMESHDS_Command::ChangePolyhedronNodes : Bad Type");
 362     return;
 363   }
 364   myIntegers.push_back(ElementID);
 365
 366   int i, nbNodes = nodes_ids.size();
 367   myIntegers.push_back(nbNodes);
 368   for (i = 0; i < nbNodes; i++) {
 369     myIntegers.push_back(nodes_ids[i]);
 370   }
 371
 372   int nbFaces = quantities.size();
 373   myIntegers.push_back(nbFaces);
 374   for (i = 0; i < nbFaces; i++) {
 375     myIntegers.push_back(quantities[i]);
 376   }
 377
 378   myNumber++;
 379 }
 380
 381 //=======================================================================
 382 //function : Renumber
 383 //purpose  :
 384 //=======================================================================
 385
 386 void SMESHDS_Command::Renumber (const bool isNodes, const int startID, const int deltaID)
 387 {
 388   if (!myType == SMESHDS_Renumber)
 389   {
 390     MESSAGE("SMESHDS_Command::Renumber : Bad Type");
 391     return;
 392   }
 393   myIntegers.push_back(isNodes);
 394   myIntegers.push_back(startID);
 395   myIntegers.push_back(deltaID);
 396   myNumber++;
 397 }
 398
 399 //=======================================================================
 400 //function :
 401 //purpose  :
 402 //=======================================================================
 403 SMESHDS_CommandType SMESHDS_Command::GetType()
 404 {
 405         return myType;
 406 }
 407
 408 //=======================================================================
 409 //function :
 410 //purpose  :
 411 //=======================================================================
 412 int SMESHDS_Command::GetNumber()
 413 {
 414         return myNumber;
 415 }
 416
 417 //=======================================================================
 418 //function :
 419 //purpose  :
 420 //=======================================================================
 421 const list < int >&SMESHDS_Command::GetIndexes()
 422 {
 423         return myIntegers;
 424 }
 425
 426 //=======================================================================
 427 //function :
 428 //purpose  :
 429 //=======================================================================
 430 const list < double >&SMESHDS_Command::GetCoords()
 431 {
 432         return myReals;
 433 }
 434
 435
 436 //********************************************************************
 437 //*****             Methods for quadratic elements              ******
 438 //********************************************************************
 439
 440 //=======================================================================
 441 //function : AddEdge
 442 //purpose  :
 443 //=======================================================================
 444 void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
 445 {
 446   if (!myType == SMESHDS_AddQuadEdge) {
 447     MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
 448     return;
 449   }
 450   myIntegers.push_back(NewEdgeID);
 451   myIntegers.push_back(n1);
 452   myIntegers.push_back(n2);
 453   myIntegers.push_back(n12);
 454   myNumber++;
 455 }
 456
 457 //=======================================================================
 458 //function : AddFace
 459 //purpose  :
 460 //=======================================================================
 461 void SMESHDS_Command::AddFace(int NewFaceID,
 462                               int n1, int n2, int n3,
 463                               int n12, int n23, int n31)
 464 {
 465   if (!myType == SMESHDS_AddQuadTriangle) {
 466     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 467     return;
 468   }
 469   myIntegers.push_back(NewFaceID);
 470   myIntegers.push_back(n1);
 471   myIntegers.push_back(n2);
 472   myIntegers.push_back(n3);
 473   myIntegers.push_back(n12);
 474   myIntegers.push_back(n23);
 475   myIntegers.push_back(n31);
 476   myNumber++;
 477 }
 478
 479 //=======================================================================
 480 //function : AddFace
 481 //purpose  :
 482 //=======================================================================
 483 void SMESHDS_Command::AddFace(int NewFaceID,
 484                               int n1, int n2, int n3, int n4,
 485                               int n12, int n23, int n34, int n41)
 486 {
 487   if (!myType == SMESHDS_AddQuadQuadrangle) {
 488     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 489     return;
 490   }
 491   myIntegers.push_back(NewFaceID);
 492   myIntegers.push_back(n1);
 493   myIntegers.push_back(n2);
 494   myIntegers.push_back(n3);
 495   myIntegers.push_back(n4);
 496   myIntegers.push_back(n12);
 497   myIntegers.push_back(n23);
 498   myIntegers.push_back(n34);
 499   myIntegers.push_back(n41);
 500   myNumber++;
 501 }
 502
 503 //=======================================================================
 504 //function : AddVolume
 505 //purpose  :
 506 //=======================================================================
 507 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
 508                                 int n12, int n23, int n31,
 509                                 int n14, int n24, int n34)
 510 {
 511   if (!myType == SMESHDS_AddQuadTetrahedron) {
 512     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 513     return;
 514   }
 515   myIntegers.push_back(NewVolID);
 516   myIntegers.push_back(n1);
 517   myIntegers.push_back(n2);
 518   myIntegers.push_back(n3);
 519   myIntegers.push_back(n4);
 520   myIntegers.push_back(n12);
 521   myIntegers.push_back(n23);
 522   myIntegers.push_back(n31);
 523   myIntegers.push_back(n14);
 524   myIntegers.push_back(n24);
 525   myIntegers.push_back(n34);
 526   myNumber++;
 527 }
 528
 529 //=======================================================================
 530 //function : AddVolume
 531 //purpose  :
 532 //=======================================================================
 533 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 534                                 int n3, int n4, int n5,
 535                                 int n12, int n23, int n34, int n41,
 536                                 int n15, int n25, int n35, int n45)
 537 {
 538   if (!myType == SMESHDS_AddQuadPyramid) {
 539     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 540     return;
 541   }
 542   myIntegers.push_back(NewVolID);
 543   myIntegers.push_back(n1);
 544   myIntegers.push_back(n2);
 545   myIntegers.push_back(n3);
 546   myIntegers.push_back(n4);
 547   myIntegers.push_back(n5);
 548   myIntegers.push_back(n12);
 549   myIntegers.push_back(n23);
 550   myIntegers.push_back(n34);
 551   myIntegers.push_back(n41);
 552   myIntegers.push_back(n15);
 553   myIntegers.push_back(n25);
 554   myIntegers.push_back(n35);
 555   myIntegers.push_back(n45);
 556   myNumber++;
 557 }
 558
 559 //=======================================================================
 560 //function : AddVolume
 561 //purpose  :
 562 //=======================================================================
 563 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 564                                 int n3, int n4, int n5,int n6,
 565                                 int n12, int n23, int n31,
 566                                 int n45, int n56, int n64,
 567                                 int n14, int n25, int n36)
 568 {
 569   if (!myType == SMESHDS_AddQuadPentahedron) {
 570     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 571     return;
 572   }
 573   myIntegers.push_back(NewVolID);
 574   myIntegers.push_back(n1);
 575   myIntegers.push_back(n2);
 576   myIntegers.push_back(n3);
 577   myIntegers.push_back(n4);
 578   myIntegers.push_back(n5);
 579   myIntegers.push_back(n6);
 580   myIntegers.push_back(n12);
 581   myIntegers.push_back(n23);
 582   myIntegers.push_back(n31);
 583   myIntegers.push_back(n45);
 584   myIntegers.push_back(n56);
 585   myIntegers.push_back(n64);
 586   myIntegers.push_back(n14);
 587   myIntegers.push_back(n25);
 588   myIntegers.push_back(n36);
 589   myNumber++;
 590 }
 591
 592 //=======================================================================
 593 //function : AddVolume
 594 //purpose  :
 595 //=======================================================================
 596 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 597                                 int n4, int n5, int n6, int n7, int n8,
 598                                 int n12, int n23, int n34, int n41,
 599                                 int n56, int n67, int n78, int n85,
 600                                 int n15, int n26, int n37, int n48)
 601 {
 602   if (!myType == SMESHDS_AddQuadHexahedron) {
 603     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 604     return;
 605   }
 606   myIntegers.push_back(NewVolID);
 607   myIntegers.push_back(n1);
 608   myIntegers.push_back(n2);
 609   myIntegers.push_back(n3);
 610   myIntegers.push_back(n4);
 611   myIntegers.push_back(n5);
 612   myIntegers.push_back(n6);
 613   myIntegers.push_back(n7);
 614   myIntegers.push_back(n8);
 615   myIntegers.push_back(n12);
 616   myIntegers.push_back(n23);
 617   myIntegers.push_back(n34);
 618   myIntegers.push_back(n41);
 619   myIntegers.push_back(n56);
 620   myIntegers.push_back(n67);
 621   myIntegers.push_back(n78);
 622   myIntegers.push_back(n85);
 623   myIntegers.push_back(n15);
 624   myIntegers.push_back(n26);
 625   myIntegers.push_back(n37);
 626   myIntegers.push_back(n48);
 627   myNumber++;
 628 }
 629