src/SMESHDS/SMESHDS_Command.cxx

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