1 // Copyright (C) 2008 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
4 // This library is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU Lesser General Public
6 // License as published by the Free Software Foundation; either
7 // version 2.1 of the License.
9 // This library is distributed in the hope that it will be useful
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 // Lesser General Public License for more details.
14 // You should have received a copy of the GNU Lesser General Public
15 // License along with this library; if not, write to the Free Software
16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 // File : SMESH_NoteBook.cxx
21 // Author : Roman NIKOLAEV
23 #include "SMESH_2smeshpy.hxx"
24 #include "SMESH_NoteBook.hxx"
25 #include "SMESH_Gen_i.hxx"
26 #include "SMESH_PythonDump.hxx"
28 #include <Resource_DataMapOfAsciiStringAsciiString.hxx>
29 #include <TColStd_SequenceOfAsciiString.hxx>
30 #include <TColStd_HSequenceOfInteger.hxx>
36 static int MYDEBUG = 0;
38 static int MYDEBUG = 0;
44 void SetVariable(Handle(_pyCommand) theCommand,const ObjectStates* theStates, int position, int theArgNb);
46 //================================================================================
50 //================================================================================
51 ObjectStates::ObjectStates(TCollection_AsciiString theType)
57 //================================================================================
61 //================================================================================
62 ObjectStates::~ObjectStates()
66 //================================================================================
68 * \brief Add new object state
69 * \param theState - Object state (vector of notebook variable)
71 //================================================================================
72 void ObjectStates::AddState(const TState &theState)
74 _states.push_back(theState);
77 //================================================================================
79 * \brief Return current object state
80 * \\retval state - Object state (vector of notebook variable)
82 //================================================================================
83 TState ObjectStates::GetCurrectState() const
85 if(_states.size() > _dumpstate)
86 return _states[_dumpstate];
92 //================================================================================
96 //================================================================================
97 TAllStates ObjectStates::GetAllStates() const
102 //================================================================================
106 //================================================================================
107 void ObjectStates::IncrementState()
112 //================================================================================
116 //================================================================================
117 TCollection_AsciiString ObjectStates::GetObjectType() const{
122 //================================================================================
126 //================================================================================
127 LayerDistributionStates::LayerDistributionStates():
128 ObjectStates("LayerDistribution")
131 //================================================================================
135 //================================================================================
136 LayerDistributionStates::~LayerDistributionStates()
141 //================================================================================
143 * \brief AddDistribution
145 //================================================================================
146 void LayerDistributionStates::AddDistribution(const TCollection_AsciiString& theDistribution)
148 _distributions.insert(pair<TCollection_AsciiString,TCollection_AsciiString>(theDistribution,""));
151 //================================================================================
153 * \brief HasDistribution
155 //================================================================================
156 bool LayerDistributionStates::HasDistribution(const TCollection_AsciiString& theDistribution) const
158 return _distributions.find(theDistribution) != _distributions.end();
161 //================================================================================
163 * \brief SetDistributionType
165 //================================================================================
166 bool LayerDistributionStates::SetDistributionType(const TCollection_AsciiString& theDistribution,
167 const TCollection_AsciiString& theType)
169 TDistributionMap::iterator it = _distributions.find(theDistribution);
170 if(it == _distributions.end())
172 (*it).second = theType;
176 //================================================================================
178 * \brief GetDistributionType
180 //================================================================================
181 TCollection_AsciiString LayerDistributionStates::
182 GetDistributionType(const TCollection_AsciiString& theDistribution) const
184 TDistributionMap::const_iterator it = _distributions.find(theDistribution);
185 return (it == _distributions.end()) ? TCollection_AsciiString() : (*it).second;
188 //================================================================================
192 //================================================================================
193 SMESH_NoteBook::SMESH_NoteBook()
198 //================================================================================
202 //================================================================================
203 SMESH_NoteBook::~SMESH_NoteBook()
205 TVariablesMap::const_iterator it = _objectMap.begin();
206 for(;it!=_objectMap.end();it++) {
212 //================================================================================
214 * \brief Replace parameters of the functions on the Salome NoteBook Variables
215 * \param theString - Input string
216 * \retval TCollection_AsciiString - Convertion result
218 //================================================================================
219 void SMESH_NoteBook::ReplaceVariables()
221 for(int i=0;i<_commands.size();i++) {
222 Handle(_pyCommand) aCmd = _commands[i];
223 TCollection_AsciiString aMethod = aCmd->GetMethod();
224 TCollection_AsciiString aObject = aCmd->GetObject();
225 TCollection_AsciiString aResultValue = aCmd->GetResultValue();
227 cout<<"Command before : "<< aCmd->GetString()<<endl;
228 cout<<"Method : "<< aMethod<<endl;
229 cout<<"Object : "<< aObject<<endl;
230 cout<<"Result : "<< aResultValue<<endl;
233 // check if method modifies the object itself
234 TVariablesMap::const_iterator it = _objectMap.find(aObject);
235 if(it == _objectMap.end()) // check if method returns a new object
236 it = _objectMap.find(aResultValue);
238 if(it == _objectMap.end()) { // check if method modifies a mesh using mesh editor
239 TMeshEditorMap::const_iterator meIt = myMeshEditors.find(aObject);
240 if(meIt != myMeshEditors.end()) {
241 TCollection_AsciiString aMesh = (*meIt).second;
242 it = _objectMap.find(aMesh);
246 if(it == _objectMap.end()) { // additional check for pattern mapping
247 if(aMethod.IsEqual("ApplyToMeshFaces") ||
248 aMethod.IsEqual("ApplyToHexahedrons"))
249 it = _objectMap.find(aCmd->GetArg(1));
252 if(it != _objectMap.end()) {
254 cout << "Found object : " << (*it).first << endl;
255 ObjectStates *aStates = (*it).second;
256 // Case for LocalLength hypothesis
257 if(aStates->GetObjectType().IsEqual("LocalLength") && aStates->GetCurrectState().size() >= 2) {
258 if(aMethod.IsEqual("SetLength")) {
259 if(!aStates->GetCurrectState().at(0).IsEmpty() )
260 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
261 aStates->IncrementState();
263 else if(aMethod.IsEqual("SetPrecision")) {
264 if(!aStates->GetCurrectState().at(1).IsEmpty() )
265 aCmd->SetArg(1,aStates->GetCurrectState().at(1));
266 aStates->IncrementState();
270 // Case for SegmentLengthAroundVertex hypothesis
271 else if(aStates->GetObjectType().IsEqual("SegmentLengthAroundVertex")
272 && aStates->GetCurrectState().size() >= 1) {
273 if(aMethod == "SetLength") {
274 if(!aStates->GetCurrectState().at(0).IsEmpty() )
275 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
276 aStates->IncrementState();
280 // Case for Arithmetic1D and StartEndLength hypothesis
281 else if(aStates->GetObjectType().IsEqual("Arithmetic1D") ||
282 aStates->GetObjectType().IsEqual("StartEndLength")) {
283 if(aMethod == "SetLength" &&
284 aStates->GetCurrectState().size() >= 2) {
285 if(aCmd->GetArg(2) == "1" && !aStates->GetCurrectState().at(0).IsEmpty())
286 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
287 else if(!aStates->GetCurrectState().at(1).IsEmpty())
288 aCmd->SetArg(1,aStates->GetCurrectState().at(1));
289 aStates->IncrementState();
293 //Case for Deflection1D hypothesis
294 else if(aStates->GetObjectType().IsEqual("Deflection1D")){
295 if(aMethod == "SetDeflection" && aStates->GetCurrectState().size() >= 1) {
296 if(!aStates->GetCurrectState().at(0).IsEmpty() )
297 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
298 aStates->IncrementState();
302 // Case for LayerDistribution hypothesis (not finished yet)
303 else if(aStates->GetObjectType() == "LayerDistribution") {
304 if(aMethod == "SetLayerDistribution"){
305 LayerDistributionStates* aLDStates = (LayerDistributionStates*)(aStates);
306 aLDStates->AddDistribution(aCmd->GetArg(1));
308 cout<<"Add Distribution :"<<aCmd->GetArg(1)<<endl;
312 // Case for MaxElementArea hypothesis
313 else if(aStates->GetObjectType().IsEqual("MaxElementArea")){
314 if(aMethod == "SetMaxElementArea" && aStates->GetCurrectState().size() >= 1) {
315 if(!aStates->GetCurrectState().at(0).IsEmpty() )
316 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
317 aStates->IncrementState();
321 // Case for MaxElementVolume hypothesis
322 else if(aStates->GetObjectType().IsEqual("MaxElementVolume")){
323 if(aMethod == "SetMaxElementVolume" && aStates->GetCurrectState().size() >= 1) {
324 if(!aStates->GetCurrectState().at(0).IsEmpty() )
325 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
326 aStates->IncrementState();
330 // Case for NETGEN_Parameters_2D or NETGEN_Parameters_2D hypothesis
331 else if(aStates->GetObjectType().IsEqual("NETGEN_Parameters_2D") ||
332 aStates->GetObjectType().IsEqual("NETGEN_Parameters")){
333 if(aMethod == "SetMaxSize" && aStates->GetCurrectState().size() >= 1) {
334 if(!aStates->GetCurrectState().at(0).IsEmpty() )
335 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
336 aStates->IncrementState();
338 else if(aMethod == "SetGrowthRate" && aStates->GetCurrectState().size() >= 2) {
339 if(!aStates->GetCurrectState().at(1).IsEmpty() )
340 aCmd->SetArg(1,aStates->GetCurrectState().at(1));
341 aStates->IncrementState();
343 else if(aMethod == "SetNbSegPerEdge" && aStates->GetCurrectState().size() >= 3) {
344 if(!aStates->GetCurrectState().at(2).IsEmpty() )
345 aCmd->SetArg(1,aStates->GetCurrectState().at(2));
346 aStates->IncrementState();
348 else if(aMethod == "SetNbSegPerRadius" && aStates->GetCurrectState().size() >= 4) {
349 if(!aStates->GetCurrectState().at(3).IsEmpty() )
350 aCmd->SetArg(1,aStates->GetCurrectState().at(3));
351 aStates->IncrementState();
355 // Case for NETGEN_SimpleParameters_3D or NETGEN_SimpleParameters_2D hypothesis
356 else if(aStates->GetObjectType().IsEqual("NETGEN_SimpleParameters_3D") ||
357 aStates->GetObjectType().IsEqual("NETGEN_SimpleParameters_2D")){
359 if((aMethod == "SetNumberOfSegments" || aMethod == "SetLocalLength") &&
360 aStates->GetCurrectState().size() >= 1) {
361 if(!aStates->GetCurrectState().at(0).IsEmpty() )
362 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
363 aStates->IncrementState();
365 else if(aMethod == "SetMaxElementArea" && aStates->GetCurrectState().size() >= 2) {
366 if(!aStates->GetCurrectState().at(1).IsEmpty() )
367 aCmd->SetArg(1,aStates->GetCurrectState().at(1));
368 aStates->IncrementState();
370 else if(aMethod == "SetMaxElementVolume" && aStates->GetCurrectState().size() >= 3) {
371 if(!aStates->GetCurrectState().at(2).IsEmpty() )
372 aCmd->SetArg(1,aStates->GetCurrectState().at(2));
373 aStates->IncrementState();
375 else if(aMethod == "LengthFromEdges" || aMethod == "LengthFromFaces"){
376 aStates->IncrementState();
380 // Case for NumberOfLayers hypothesis
381 else if(aStates->GetObjectType().IsEqual("NumberOfLayers")){
382 if(aMethod == "SetNumberOfLayers" && aStates->GetCurrectState().size() >= 1) {
383 if(!aStates->GetCurrectState().at(0).IsEmpty() )
384 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
385 aStates->IncrementState();
389 // Case for NumberOfSegments hypothesis
390 else if(aStates->GetObjectType().IsEqual("NumberOfSegments")){
391 if(aMethod == "SetNumberOfSegments" && aStates->GetCurrectState().size() >= 1) {
392 if(!aStates->GetCurrectState().at(0).IsEmpty() )
393 aCmd->SetArg(1,aStates->GetCurrectState().at(0));
394 if(aStates->GetCurrectState().size()==1)
395 aStates->IncrementState();
397 else if (aMethod == "SetScaleFactor" && aStates->GetCurrectState().size() >= 2) {
398 if(!aStates->GetCurrectState().at(1).IsEmpty() )
399 aCmd->SetArg(1,aStates->GetCurrectState().at(1));
400 aStates->IncrementState();
404 else if(aStates->GetObjectType().IsEqual("Mesh")) {
405 TState aCurrentState = aStates->GetCurrectState();
406 int aCurrentStateSize = aCurrentState.size();
407 if(aMethod.IsEqual("Translate") ||
408 aMethod.IsEqual("TranslateMakeGroups") ||
409 aMethod.IsEqual("TranslateMakeMesh") ||
410 aMethod.IsEqual("TranslateObject") ||
411 aMethod.IsEqual("TranslateObjectMakeGroups") ||
412 aMethod.IsEqual("TranslateObjectMakeMesh")) {
413 bool isVariableFound = false;
415 for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
416 if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
422 if(aCurrentStateSize == 3) { // translation by dx, dy, dz
423 for(int j = 0; j < aCurrentStateSize; j++) {
424 if(!aCurrentState.at(j).IsEmpty()) {
425 isVariableFound = true;
426 aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
430 else if(aCurrentStateSize == 6) { // translation by x1, x2, y1, y2, z1, z2
431 // TODO: limitation until operations on the variables will be introduced
433 isVariableFound = true;
434 for(int j = 0; j < 3; j++) {
435 TCollection_AsciiString anArg = aCmd->GetArg(anArgIndex+j);
436 TCollection_AsciiString aValue1 = aCurrentState.at(2*j), aValue2 = aCurrentState.at(2*j+1);
437 bool aV1 = !aValue1.IsEmpty();
438 bool aV2 = !aValue2.IsEmpty();
439 double aValue, aCurrentValue = anArg.IsRealValue() ? anArg.RealValue() : 0;
441 if(!GetReal(aValue1, aValue))
443 aValue2 = TCollection_AsciiString( aValue + aCurrentValue );
445 else if(!aV1 && aV2) {
446 if(!GetReal(aValue2, aValue))
448 aValue1 = TCollection_AsciiString( aValue - aCurrentValue );
450 else if(!aV1 && !aV2) {
451 aValue1 = TCollection_AsciiString( 0 );
452 aValue2 = TCollection_AsciiString( aCurrentValue );
454 aCmd->SetArg(anArgIndex+j, aValue1 + ", " + aValue2 );
459 if(isVariableFound) {
460 TCollection_AsciiString aDim;
461 if(aCurrentStateSize == 6)
463 aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr"+aDim);
464 aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
466 aStates->IncrementState();
468 else if(aMethod.IsEqual("Rotate") ||
469 aMethod.IsEqual("RotateMakeGroups") ||
470 aMethod.IsEqual("RotateMakeMesh") ||
471 aMethod.IsEqual("RotateObject") ||
472 aMethod.IsEqual("RotateObjectMakeGroups") ||
473 aMethod.IsEqual("RotateObjectMakeMesh") ||
474 aMethod.IsEqual("RotationSweep") ||
475 aMethod.IsEqual("RotationSweepObject") ||
476 aMethod.IsEqual("RotationSweepObject1D") ||
477 aMethod.IsEqual("RotationSweepObject2D") ||
478 aMethod.IsEqual("RotationSweepMakeGroups") ||
479 aMethod.IsEqual("RotationSweepObjectMakeGroups") ||
480 aMethod.IsEqual("RotationSweepObject1DMakeGroups") ||
481 aMethod.IsEqual("RotationSweepObject2DMakeGroups") ||
482 aMethod.IsEqual("Mirror") ||
483 aMethod.IsEqual("MirrorMakeMesh") ||
484 aMethod.IsEqual("MirrorMakeGroups") ||
485 aMethod.IsEqual("MirrorObject") ||
486 aMethod.IsEqual("MirrorObjectMakeMesh") ||
487 aMethod.IsEqual("MirrorObjectMakeGroups")) {
488 bool isSubstitute = false;
490 for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
491 if(aCmd->GetArg(i).IsEqual("SMESH.AxisStruct")) {
497 for(int j = 0; j < aCurrentStateSize; j++) {
498 if(!aCurrentState.at(j).IsEmpty()) {
499 if(j < 6) // 0-5 - axis struct, 6 - angle (rotation & sweep), 7-8 - nbSteps and tolerance (sweep)
501 aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
506 aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".AxisStructStr");
507 aStates->IncrementState();
509 else if(aMethod.IsEqual("AddNode") ||
510 aMethod.IsEqual("MoveClosestNodeToPoint")) {
511 for(int j = 0; j < aCurrentStateSize; j++) {
512 if(!aCurrentState.at(j).IsEmpty())
513 aCmd->SetArg(j+1, aCurrentState.at(j));
515 aStates->IncrementState();
517 else if(aMethod.IsEqual("MoveNode")) {
518 for(int j = 0; j < aCurrentStateSize; j++) {
519 if(!aCurrentState.at(j).IsEmpty())
520 aCmd->SetArg(j+2, aCurrentState.at(j));
522 aStates->IncrementState();
524 else if(aMethod.IsEqual("ExtrusionSweep") ||
525 aMethod.IsEqual("ExtrusionSweepObject") ||
526 aMethod.IsEqual("ExtrusionSweepObject1D") ||
527 aMethod.IsEqual("ExtrusionSweepObject2D") ||
528 aMethod.IsEqual("ExtrusionSweepMakeGroups") ||
529 aMethod.IsEqual("ExtrusionSweepObjectMakeGroups") ||
530 aMethod.IsEqual("ExtrusionSweepObject1DMakeGroups") ||
531 aMethod.IsEqual("ExtrusionSweepObject2DMakeGroups")) {
532 bool isSubstitute = false;
534 for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
535 if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
541 for(int j = 0; j < aCurrentStateSize; j++) {
542 if(!aCurrentState.at(j).IsEmpty()) {
543 if(j < 3) // 0-2 - dir struct, 3 - number of steps
545 aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
550 aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
551 aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
553 aStates->IncrementState();
555 else if(aMethod.IsEqual("ExtrusionAlongPath") ||
556 aMethod.IsEqual("ExtrusionAlongPathObject") ||
557 aMethod.IsEqual("ExtrusionAlongPathObject1D") ||
558 aMethod.IsEqual("ExtrusionAlongPathObject2D") ||
559 aMethod.IsEqual("ExtrusionAlongPathMakeGroups") ||
560 aMethod.IsEqual("ExtrusionAlongPathObjectMakeGroups") ||
561 aMethod.IsEqual("ExtrusionAlongPathObject1DMakeGroups") ||
562 aMethod.IsEqual("ExtrusionAlongPathObject2DMakeGroups") ||
563 /* workaround for a bug in the command parsing algorithm */
564 aCmd->GetString().Search("ExtrusionAlongPathMakeGroups") != -1 ||
565 aCmd->GetString().Search("ExtrusionAlongPathObjectMakeGroups") != -1 ||
566 aCmd->GetString().Search("ExtrusionAlongPathObject1DMakeGroups") != -1 ||
567 aCmd->GetString().Search("ExtrusionAlongPathObject2DMakeGroups") != -1 ) {
568 int aNbAngles = aCurrentStateSize-3; // State looks like "Angle1:...:AngleN:X:Y:Z"
569 bool isSubstitute = false;
571 for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
572 if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
573 anArgIndex = i-1-aNbAngles;
579 for(; j < aNbAngles; j++) {
580 if(!aCurrentState.at(j).IsEmpty()) {
581 aCmd->SetArg(anArgIndex+j-1, aCurrentState.at(j));
584 for(; j < aNbAngles+3; j++) {
585 if(!aCurrentState.at(j).IsEmpty()) {
587 aCmd->SetArg(anArgIndex+j+2, aCurrentState.at(j));
592 aCmd->SetArg(anArgIndex + aNbAngles + 1,
593 TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
594 aStates->IncrementState();
596 else if(aMethod.IsEqual("TriToQuad") ||
597 aMethod.IsEqual("Concatenate") ||
598 aMethod.IsEqual("ConcatenateWithGroups")) {
599 if(aCurrentStateSize && !aCurrentState.at(0).IsEmpty())
600 aCmd->SetArg(aCmd->GetNbArgs(), aCurrentState.at(0));
601 aStates->IncrementState();
603 else if(aMethod.IsEqual("Smooth") ||
604 aMethod.IsEqual("SmoothObject") ||
605 aMethod.IsEqual("SmoothParametric") ||
606 aMethod.IsEqual("SmoothParametricObject")) {
607 int anArgIndex = aCmd->GetNbArgs() - 2;
608 for(int j = 0; j < aCurrentStateSize; j++) {
609 if(!aCurrentState.at(j).IsEmpty())
610 aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
612 aStates->IncrementState();
614 else if(aMethod.IsEqual("ApplyToMeshFaces") ||
615 aMethod.IsEqual("ApplyToHexahedrons")) {
616 int anArgIndex = aCmd->GetNbArgs()-1;
617 for(int j = 0; j < aCurrentStateSize; j++)
618 if(!aCurrentState.at(j).IsEmpty())
619 aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
620 aStates->IncrementState();
626 cout << "Object not found" << endl;
629 cout<<"Command after: "<< aCmd->GetString()<<endl;
633 ProcessLayerDistribution();
635 //================================================================================
637 * \brief Private method
639 //================================================================================
640 void SMESH_NoteBook::InitObjectMap()
642 /* ouv: temporarily disabled
643 SMESH_Gen_i *aGen = SMESH_Gen_i::GetSMESHGen();
647 SALOMEDS::Study_ptr aStudy = aGen->GetCurrentStudy();
648 if(aStudy->_is_nil())
651 SALOMEDS::SObject_var aSO = aStudy->FindComponent(aGen->ComponentDataType());
652 if(CORBA::is_nil(aSO))
655 SALOMEDS::ChildIterator_var Itr = aStudy->NewChildIterator(aSO);
657 for(Itr->InitEx(true); Itr->More(); Itr->Next()) {
658 SALOMEDS::SObject_var aSObject = Itr->Value();
659 SALOMEDS::GenericAttribute_var anAttr;
660 if ( aSObject->FindAttribute(anAttr, "AttributeString")) {
661 aParameters = SALOMEDS::AttributeString::_narrow(anAttr)->Value();
662 SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(aParameters);
664 cout<<"Entry : "<< aSObject->GetID()<<endl;
665 cout<<"aParameters : "<<aParameters<<endl;
667 TCollection_AsciiString anObjType;
668 CORBA::Object_var anObject = SMESH_Gen_i::SObjectToObject(aSObject);
669 SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow(anObject);
670 if(!aHyp->_is_nil()) {
671 anObjType = TCollection_AsciiString(aHyp->GetName());
673 else if(SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow(anObject)) {
674 anObjType = TCollection_AsciiString("Mesh");
677 cout<<"The object Type : "<<anObjType<<endl;
678 ObjectStates *aState = NULL;
679 if(anObjType == "LayerDistribution") {
680 aState = new LayerDistributionStates();
683 aState = new ObjectStates(anObjType);
685 for(int i = 0; i < aSections->length(); i++) {
687 SALOMEDS::ListOfStrings aListOfVars = aSections[i];
688 for(int j = 0;j<aListOfVars.length();j++) {
689 TCollection_AsciiString aVar(aListOfVars[j].in());
690 if(!aVar.IsEmpty() && aStudy->IsVariable(aVar.ToCString())) {
691 aVar.InsertBefore(1,"\"");
692 aVar.InsertAfter(aVar.Length(),"\"");
694 aVars.push_back(aVar);
696 cout<<"Variable: '"<<aVar<<"'"<<endl;
699 aState->AddState(aVars);
701 _objectMap.insert(pair<TCollection_AsciiString,ObjectStates*>(TCollection_AsciiString(aSObject->GetID()),aState));
707 //================================================================================
711 //================================================================================
712 void SMESH_NoteBook::AddCommand(const TCollection_AsciiString& theString)
715 cout<<theString<<endl;
716 Handle(_pyCommand) aCommand = new _pyCommand( theString, -1);
717 _commands.push_back(aCommand);
719 if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation
720 myMeshEditors.insert( make_pair( aCommand->GetResultValue(),
721 aCommand->GetObject() ) );
725 //================================================================================
729 //================================================================================
730 void SMESH_NoteBook::ProcessLayerDistribution()
732 // 1) Find all LayerDistribution states
733 vector<LayerDistributionStates*> aLDS;
734 TVariablesMap::const_iterator it = _objectMap.begin();
735 for(;it != _objectMap.end();it++) {
736 LayerDistributionStates* aLDStates = dynamic_cast<LayerDistributionStates*>(((*it).second));
737 if(aLDStates!=NULL) {
738 aLDS.push_back(aLDStates);
745 // 2) Initialize all type of 1D Distribution hypothesis
746 for(int i=0;i<_commands.size();i++){
747 for(int j =0;j < aLDS.size();j++){
748 TCollection_AsciiString aResultValue = _commands[i]->GetResultValue();
749 if(_commands[i]->GetMethod() == "CreateHypothesis" &&
750 aLDS[j]->HasDistribution(aResultValue)){
751 TCollection_AsciiString aType = _commands[i]->GetArg(1);
752 aType.RemoveAll('\'');
753 aLDS[j]->SetDistributionType(aResultValue,aType);
757 // 3) ... and replase variables ...
759 for(int i=0;i<_commands.size();i++){
760 for(int j =0;j < aLDS.size();j++){
761 TCollection_AsciiString anObject = _commands[i]->GetObject();
763 if(aLDS[j]->HasDistribution(anObject)) {
764 TCollection_AsciiString aType = aLDS[j]->GetDistributionType(anObject);
765 TCollection_AsciiString aMethod = _commands[i]->GetMethod();
766 if(aType == "LocalLength") {
767 if(aMethod == "SetLength") {
768 SetVariable(_commands[i], aLDS[j],0,1);
769 aLDS[j]->IncrementState();
771 else if(aMethod == "SetPrecision") {
772 SetVariable(_commands[i], aLDS[j],1,1);
773 aLDS[j]->IncrementState();
777 // Case for NumberOfSegments hypothesis
778 else if(aType == "NumberOfSegments"){
779 if(aMethod == "SetNumberOfSegments") {
780 SetVariable(_commands[i], aLDS[j],0,1);
781 if(aLDS[j]->GetCurrectState().size()==1)
782 aLDS[j]->IncrementState();
784 else if (aMethod == "SetScaleFactor") {
785 SetVariable(_commands[i], aLDS[j],1,1);
786 aLDS[j]->IncrementState();
790 else if( aType == "Deflection1D" ){
791 if(aMethod == "SetDeflection"){
792 SetVariable(_commands[i], aLDS[j],0,1);
793 aLDS[j]->IncrementState();
796 // Case for Arithmetic1D and StartEndLength hypothesis
797 else if(aType == "Arithmetic1D" || aType == "StartEndLength") {
798 if(aMethod == "SetLength") {
799 int anArgNb = (_commands[i]->GetArg(2) == "1") ? 0 : 1;
800 SetVariable(_commands[i], aLDS[j],anArgNb,1);
801 aLDS[j]->IncrementState();
808 //================================================================================
810 * \brief Return result script
812 //================================================================================
813 TCollection_AsciiString SMESH_NoteBook::GetResultScript() const
815 TCollection_AsciiString aResult;
816 for(int i=0;i<_commands.size();i++)
817 aResult+=_commands[i]->GetString()+"\n";
821 //================================================================================
823 * \brief Return value of the variable
825 //================================================================================
826 bool SMESH_NoteBook::GetReal(const TCollection_AsciiString& theVarName, double& theValue)
830 /* ouv: temporarily disabled
831 SMESH_Gen_i *aGen = SMESH_Gen_i::GetSMESHGen();
835 SALOMEDS::Study_ptr aStudy = aGen->GetCurrentStudy();
836 if(aStudy->_is_nil())
839 TCollection_AsciiString aVarName = theVarName;
840 aVarName.RemoveAll('\"');
842 if(aVarName.IsEmpty())
845 const char* aName = aVarName.ToCString();
846 if(aStudy->IsVariable(aName) && (aStudy->IsReal(aName) || aStudy->IsInteger(aName))) {
847 theValue = aStudy->GetReal(aVarName.ToCString());
856 * Set variable of the ObjectStates from position to the _pyCommand
857 * method as nbArg argument
859 void SetVariable(Handle(_pyCommand) theCommand, const ObjectStates* theStates, int position, int theArgNb)
861 if(theStates->GetCurrectState().size() > position)
862 if(!theStates->GetCurrectState().at(position).IsEmpty())
863 theCommand->SetArg(theArgNb,theStates->GetCurrectState().at(position));