X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_2smeshpy.cxx;h=ccf63624030fd6a96767b3a0ce79b74a4c8c0c9a;hp=609abbe43e25ff729586e2271ebe2555e918c0dc;hb=9d11375af40826e967ab2c3bcb77d1f9d439c90c;hpb=4ff5bd61540272713e48de1eee75625028c32155

diff --git a/src/SMESH_I/SMESH_2smeshpy.cxx b/src/SMESH_I/SMESH_2smeshpy.cxx
index 609abbe43..ccf636240 100644
--- a/src/SMESH_I/SMESH_2smeshpy.cxx
+++ b/src/SMESH_I/SMESH_2smeshpy.cxx
@@ -17,7 +17,7 @@
 //  License along with this library; if not, write to the Free Software 
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
-//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
 //
 //
@@ -32,11 +32,16 @@
 
 #include "SMESH_2smeshpy.hxx"
 
-#include "SMESH_Gen_i.hxx"
 #include "utilities.h"
 #include "SMESH_PythonDump.hxx"
 #include "Resource_DataMapOfAsciiStringAsciiString.hxx"
 
+#include "SMESH_Gen_i.hxx"
+/* SALOME headers that include CORBA headers that include windows.h 
+ * that defines GetObject symbol as GetObjectA should stand before SALOME headers
+ * that declare methods named GetObject - to apply the same rules of GetObject renaming
+ * and thus to avoid mess with GetObject symbol on Windows */
+
 IMPLEMENT_STANDARD_HANDLE (_pyObject          ,Standard_Transient);
 IMPLEMENT_STANDARD_HANDLE (_pyCommand         ,Standard_Transient);
 IMPLEMENT_STANDARD_HANDLE (_pyGen             ,_pyObject);
@@ -54,6 +59,7 @@ IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis      ,_pyObject);
 IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm       ,_pyHypothesis);
 IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
 IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
 
 using namespace std;
 using SMESH::TPythonDump;
@@ -140,6 +146,7 @@ _pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod
     myID2AccessorMethod( theEntry2AccessorMethod )
 {
   myNbCommands = 0;
+  myHasPattern = false;
   // make that GetID() to return TPythonDump::SMESHGenName()
   GetCreationCmd()->GetString() += "=";
 }
@@ -148,7 +155,6 @@ _pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod
 /*!
  * \brief Convert a command using a specific converter
   * \param theCommand - the command to convert
-  * \retval bool - convertion result
  */
 //================================================================================
 
@@ -178,19 +184,37 @@ void _pyGen::AddCommand( const TCollection_AsciiString& theCommand)
     id_mesh->second->Process( aCommand );
     return;
   }
-  // SMESH_Hypothesis method
+  // SMESH_Hypothesis method?
   list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
   for ( ; hyp != myHypos.end(); ++hyp )
-    if ( !(*hyp)->IsAlgo() && objID == (*hyp)->GetID() )
+    if ( !(*hyp)->IsAlgo() && objID == (*hyp)->GetID() ) {
       (*hyp)->Process( aCommand );
+      return;
+    }
 
-  // Mesh provides SMESH_IDSource interface used in SMESH_MeshEditor.
-  // Add access to wrapped mesh
-  if ( objID == TPythonDump::MeshEditorName() ) {
-    // in all SMESH_MeshEditor's commands, a SMESH_IDSource is the first arg
-    id_mesh = myMeshes.find( aCommand->GetArg( 1 ));
-    if ( id_mesh != myMeshes.end() )
-      aCommand->SetArg( 1 , aCommand->GetArg( 1 ) + ".GetMesh()" );
+  // Add access to a wrapped mesh
+  AddMeshAccessorMethod( aCommand );
+
+  // Add access to a wrapped algorithm
+  AddAlgoAccessorMethod( aCommand );
+
+  // PAL12227. PythonDump was not updated at proper time; result is
+  //     aCriteria.append(SMESH.Filter.Criterion(17,26,0,'L1',26,25,1e-07,SMESH.EDGE,-1))
+  // TypeError: __init__() takes exactly 11 arguments (10 given)
+  char wrongCommand[] = "SMESH.Filter.Criterion(";
+  if ( int beg = theCommand.Location( wrongCommand, 1, theCommand.Length() ))
+  {
+    _pyCommand tmpCmd( theCommand.SubString( beg, theCommand.Length() ), -1);
+    // there must be 10 arguments, 5-th arg ThresholdID is missing,
+    const int wrongNbArgs = 9, missingArg = 5;
+    if ( tmpCmd.GetNbArgs() == wrongNbArgs )
+    {
+      for ( int i = wrongNbArgs; i > missingArg; --i )
+        tmpCmd.SetArg( i + 1, tmpCmd.GetArg( i ));
+      tmpCmd.SetArg(  missingArg, "''");
+      aCommand->GetString().Trunc( beg - 1 );
+      aCommand->GetString() += tmpCmd.GetString();
+    }
   }
 }
 
@@ -235,6 +259,15 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
     }
   }
 
+  // leave only one smeshgen.GetPattern() in the script
+  if ( theCommand->GetMethod() == "GetPattern" ) {
+    if ( myHasPattern ) {
+      theCommand->Clear();
+      return;
+    }
+    myHasPattern = true;
+  }
+
   // smeshgen.Method() --> smesh.smesh.Method()
   theCommand->SetObject( SMESH_2smeshpy::GenName() );
 }
@@ -262,6 +295,43 @@ void _pyGen::Flush()
     }
 }
 
+//================================================================================
+/*!
+ * \brief Add access method to mesh that is object or arg
+  * \param theCmd - command to add access method
+  * \retval bool - true if added
+ */
+//================================================================================
+
+bool _pyGen::AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const
+{
+  map< _pyID, Handle(_pyMesh) >::const_iterator id_mesh = myMeshes.begin();
+  for ( ; id_mesh != myMeshes.end(); ++id_mesh ) {
+    if ( theCmd->AddAccessorMethod( id_mesh->first, id_mesh->second->AccessorMethod() ))
+      return true;
+  }
+  return false;
+}
+
+//================================================================================
+/*!
+ * \brief Add access method to algo that is object or arg
+  * \param theCmd - command to add access method
+  * \retval bool - true if added
+ */
+//================================================================================
+
+bool _pyGen::AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const
+{
+  list< Handle(_pyHypothesis) >::const_iterator hyp = myHypos.begin();
+  for ( ; hyp != myHypos.end(); ++hyp ) {
+    if ( (*hyp)->IsAlgo() &&
+         theCmd->AddAccessorMethod( (*hyp)->GetID(), (*hyp)->AccessorMethod() ))
+      return true;
+  }
+  return false;
+}
+
 //================================================================================
 /*!
  * \brief Find hypothesis by ID (entry)
@@ -431,7 +501,8 @@ static bool sameGroupType( const _pyID&                   grpID,
  */
 //================================================================================
 
-_pyMesh::_pyMesh(const Handle(_pyCommand) theCreationCmd): _pyObject(theCreationCmd)
+_pyMesh::_pyMesh(const Handle(_pyCommand) theCreationCmd):
+  _pyObject(theCreationCmd), myHasEditor(false)
 {
   // convert my creation command
   Handle(_pyCommand) creationCmd = GetCreationCmd();
@@ -478,8 +549,11 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
     // set mesh to hypo
     const _pyID& hypID = theCommand->GetArg( 2 );
     Handle(_pyHypothesis) hyp = theGen->FindHyp( hypID );
-    if ( !hyp.IsNull() && hyp->GetMesh().IsEmpty() )
-      hyp->SetMesh( this->GetID() );
+    if ( !hyp.IsNull() ) {
+      myHypos.push_back( hyp );
+      if ( hyp->GetMesh().IsEmpty() )
+        hyp->SetMesh( this->GetID() );
+    }
   }
   else if ( method == "CreateGroupFromGEOM" ) {// (type, name, grp)
     _pyID grp = theCommand->GetArg( 3 );
@@ -509,7 +583,7 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
     while ( cmd != myAddHypCmds.end() )
     {
       // AddHypothesis(geom, hyp)
-      if ( hypID == (*cmd)->GetArg( 2 )) { // erase both commands
+      if ( hypID == (*cmd)->GetArg( 2 )) { // erase both (add and remove) commands
         theCommand->Clear();
         (*cmd)->Clear();
         cmd = myAddHypCmds.erase( cmd );
@@ -519,16 +593,31 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
         ++cmd;
       }
     }
-    if ( ! hasAddCmd ) {
+    Handle(_pyHypothesis) hyp = theGen->FindHyp( hypID );
+    if ( ! hasAddCmd ) { // hypo addition already wrapped
       // access to wrapped mesh
       AddMeshAccess( theCommand );
       // access to wrapped algo
-      Handle(_pyHypothesis) hyp = theGen->FindHyp( hypID );
       if ( !hyp.IsNull() && hyp->IsAlgo() && hyp->IsWrapped() )
         theCommand->SetArg( 2, theCommand->GetArg( 2 ) + ".GetAlgorithm()" );
     }
+    // remove hyp from myHypos
+    myHypos.remove( hyp );
+  }
+
+  // leave only one "  mesh_editor_<nb> = mesh.GetMeshEditor()"
+  else if ( theCommand->GetMethod() == "GetMeshEditor")
+  {
+    if ( myHasEditor )
+      theCommand->Clear();
+    else
+      AddMeshAccess( theCommand );
+    myHasEditor = true;
   }
-  else { // apply theCommand to the mesh wrapped by smeshpy mesh
+
+  // apply theCommand to the mesh wrapped by smeshpy mesh
+  else
+  {
     AddMeshAccess( theCommand );
   }
 }
@@ -617,6 +706,11 @@ void _pyMesh::Flush()
   }
   myAddHypCmds.clear();
   mySubmeshes.clear();
+
+  // flush hypotheses
+  list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
+  for ( ; hyp != myHypos.end(); ++hyp )
+    (*hyp)->Flush();
 }
 
 //================================================================================
@@ -648,127 +742,139 @@ Handle(_pyHypothesis) _pyHypothesis::NewHypothesis( const Handle(_pyCommand)& th
   Handle(_pyHypothesis) hyp, algo;
 
   // "theHypType"
-  const TCollection_AsciiString & hypTypeWithQuotes = theCreationCmd->GetArg( 1 );
-  if ( hypTypeWithQuotes.IsEmpty() )
+  const TCollection_AsciiString & hypTypeQuoted = theCreationCmd->GetArg( 1 );
+  if ( hypTypeQuoted.IsEmpty() )
     return hyp;
   // theHypType
   TCollection_AsciiString  hypType =
-    hypTypeWithQuotes.SubString( 2, hypTypeWithQuotes.Length() - 1 );
+    hypTypeQuoted.SubString( 2, hypTypeQuoted.Length() - 1 );
 
   algo = new _pyAlgorithm( theCreationCmd );
   hyp  = new _pyHypothesis( theCreationCmd );
 
   // 1D Regular_1D ----------
   if ( hypType == "Regular_1D" ) {
-    algo->myDim = 1;
-    algo->myCreationMethod = "Segment";
+    algo->SetDimMethodType( 1, "Segment");
   }
   else if ( hypType == "LocalLength" ) {
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "LocalLength";
-    hyp->myType = "Regular_1D";
-    hyp->myArgMethods.Append( "SetLength" );
+    hyp->SetDimMethodType( 1, "LocalLength", "Regular_1D");
+    hyp->AddArgMethod( "SetLength" );
   }
   else if ( hypType == "NumberOfSegments" ) {
     hyp = new _pyNumberOfSegmentsHyp( theCreationCmd );
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "NumberOfSegments";
-    hyp->myType = "Regular_1D";
-    hyp->myArgMethods.Append( "SetNumberOfSegments" );
-    hyp->myArgMethods.Append( "SetScaleFactor" );
+    hyp->SetDimMethodType( 1, "NumberOfSegments", "Regular_1D");
+    hyp->AddArgMethod( "SetNumberOfSegments" );
+    hyp->AddArgMethod( "SetScaleFactor" );
   }
   else if ( hypType == "Arithmetic1D" ) {
     hyp = new _pyComplexParamHypo( theCreationCmd );
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "Arithmetic1D";
-    hyp->myType = "Regular_1D";
+    hyp->SetDimMethodType( 1, "Arithmetic1D", "Regular_1D");
   }
   else if ( hypType == "StartEndLength" ) {
     hyp = new _pyComplexParamHypo( theCreationCmd );
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "StartEndLength";
-    hyp->myType = "Regular_1D";
+    hyp->SetDimMethodType( 1, "StartEndLength", "Regular_1D");
   }
   else if ( hypType == "Deflection1D" ) {
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "Deflection1D";
-    hyp->myArgMethods.Append( "SetDeflection" );
-    hyp->myType = "Regular_1D";
+    hyp->SetDimMethodType( 1, "Deflection1D", "Regular_1D");
+    hyp->AddArgMethod( "SetDeflection" );
   }
   else if ( hypType == "Propagation" ) {
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "Propagation";
-    hyp->myType = "Regular_1D";
+    hyp->SetDimMethodType( 1, "Propagation", "Regular_1D");
   }
   else if ( hypType == "QuadraticMesh" ) {
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "QuadraticMesh";
-    hyp->myType = "Regular_1D";
+    hyp->SetDimMethodType( 1, "QuadraticMesh", "Regular_1D");
   }
   else if ( hypType == "AutomaticLength" ) {
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "AutomaticLength";
-    hyp->myType = "Regular_1D";
-    hyp->myArgMethods.Append( "SetFineness");
+    hyp->SetDimMethodType( 1, "AutomaticLength", "Regular_1D");
+    hyp->AddArgMethod( "SetFineness");
   }
   // 1D Python_1D ----------
   else if ( hypType == "Python_1D" ) {
-    algo->myDim = 1;
-    algo->myCreationMethod = "Segment";
+    algo->SetDimMethodType( 1, "Segment");
     algo->myArgs.Append( "algo=smesh.PYTHON");
   }
   else if ( hypType == "PythonSplit1D" ) {
-    hyp->myDim = 1;
-    hyp->myCreationMethod = "PythonSplit1D";
-    hyp->myType = "Python_1D";
-    hyp->myArgMethods.Append( "SetNumberOfSegments");
-    hyp->myArgMethods.Append( "SetPythonLog10RatioFunction");
+    hyp->SetDimMethodType( 1, "PythonSplit1D", "Python_1D");
+    hyp->AddArgMethod( "SetNumberOfSegments");
+    hyp->AddArgMethod( "SetPythonLog10RatioFunction");
   }
   // 2D ----------
   else if ( hypType == "MEFISTO_2D" ) {
-    algo->myDim = 2;
-    algo->myCreationMethod = "Triangle";
+    algo->SetDimMethodType( 2, "Triangle");
   }
   else if ( hypType == "MaxElementArea" ) {
-    hyp->myDim = 2;
-    hyp->myCreationMethod = "MaxElementArea";
-    hyp->myType = "MEFISTO_2D";
-    hyp->myArgMethods.Append( "SetMaxElementArea");
+    hyp->SetDimMethodType( 2, "MaxElementArea", "MEFISTO_2D");
+    hyp->AddArgMethod( "SetMaxElementArea");
   }
   else if ( hypType == "LengthFromEdges" ) {
-    hyp->myDim = 2;
-    hyp->myCreationMethod = "LengthFromEdges";
-    hyp->myType = "MEFISTO_2D";
+    hyp->SetDimMethodType( 2, "LengthFromEdges", "MEFISTO_2D");
   }
   else if ( hypType == "Quadrangle_2D" ) {
-    algo->myDim = 2;
-    algo->myCreationMethod = "Quadrangle";
+    algo->SetDimMethodType( 2, "Quadrangle" );
   }
   else if ( hypType == "QuadranglePreference" ) {
-    hyp->myDim = 2;
-    hyp->myCreationMethod = "QuadranglePreference";
-    hyp->myType = "Quadrangle_2D";
+    hyp->SetDimMethodType( 2, "QuadranglePreference", "Quadrangle_2D");
   }
   // 3D ----------
   else if ( hypType == "NETGEN_3D") {
-    algo->myDim = 3;
-    algo->myCreationMethod = "Tetrahedron";
+    algo->SetDimMethodType( 3, "Tetrahedron" );
     algo->myArgs.Append( "algo=smesh.NETGEN" );
   }
   else if ( hypType == "MaxElementVolume") {
-    hyp->myDim = 3;
-    hyp->myCreationMethod = "MaxElementVolume";
-    hyp->myType = "NETGEN_3D";
-    hyp->myArgMethods.Append( "SetMaxElementVolume" );
+    hyp->SetDimMethodType( 3, "MaxElementVolume", "NETGEN_3D");
+    hyp->AddArgMethod( "SetMaxElementVolume" );
   }
   else if ( hypType == "GHS3D_3D" ) {
-    algo->myDim = 3;
-    algo->myCreationMethod = "Tetrahedron";
+    algo->SetDimMethodType( 3, "Tetrahedron");
     algo->myArgs.Append( "algo=smesh.GHS3D" );
   }
   else if ( hypType == "Hexa_3D" ) {
-    algo->myDim = 3;
-    algo->myCreationMethod = "Hexahedron";
+    algo->SetDimMethodType( 3, "Hexahedron");
+  }
+  // Repetitive ---------
+  else if ( hypType == "Projection_1D" ) {
+    algo->SetDimMethodType( 1, "Projection1D");
+  }
+  else if ( hypType == "ProjectionSource1D" ) {
+    hyp->SetDimMethodType( 1, "SourceEdge", "Projection_1D");
+    hyp->AddArgMethod( "SetSourceEdge");
+    hyp->AddArgMethod( "SetSourceMesh");
+    hyp->AddArgMethod( "SetVertexAssociation", 2 );
+  }
+  else if ( hypType == "Projection_2D" ) {
+    algo->SetDimMethodType( 2, "Projection2D");
+  }
+  else if ( hypType == "ProjectionSource2D" ) {
+    hyp->SetDimMethodType( 2, "SourceFace", "Projection_2D");
+    hyp->AddArgMethod( "SetSourceFace");
+    hyp->AddArgMethod( "SetSourceMesh");
+    hyp->AddArgMethod( "SetVertexAssociation", 4 );
+  }
+  else if ( hypType == "Projection_3D" ) {
+    algo->SetDimMethodType( 3, "Projection3D");
+  }
+  else if ( hypType == "ProjectionSource3D" ) {
+    hyp->SetDimMethodType( 3, "SourceShape3D", "Projection_3D");
+    hyp->AddArgMethod( "SetSource3DShape");
+    hyp->AddArgMethod( "SetSourceMesh");
+    hyp->AddArgMethod( "SetVertexAssociation", 4 );
+  }
+  else if ( hypType == "Prism_3D" ) {
+    algo->SetDimMethodType( 3, "Prism");
+  }
+  else if ( hypType == "RadialPrism_3D" ) {
+    algo->SetDimMethodType( 3, "Prism");
+  }
+  else if ( hypType == "NumberOfLayers" ) {
+    hyp->SetDimMethodType( 3, "NumberOfLayers", "RadialPrism_3D");
+    hyp->AddArgMethod( "SetNumberOfLayers" );
+  }
+  else if ( hypType == "LayerDistribution" ) {
+    hyp = new _pyLayerDistributionHypo( theCreationCmd );
+    hyp->SetDimMethodType( 3, "LayerDistribution", "RadialPrism_3D");
+//     hyp->AddArgMethod( "SetSource3DShape");
+//     hyp->AddArgMethod( "SetSourceMesh");
+//     hyp->AddArgMethod( "SetVertexAssociation", 4 );
   }
 
   if ( algo->GetDim() ) {
@@ -835,8 +941,6 @@ bool _pyHypothesis::Addition2Creation( const Handle(_pyCommand)& theCmd,
   for ( ; cmd != myUnknownCommands.end(); ++cmd ) {
     afterCmd->AddDependantCmd( *cmd );
   }
-  myArgCommands.clear();
-  myUnknownCommands.clear();
 
   return myIsWrapped;
 }
@@ -852,14 +956,17 @@ void _pyHypothesis::Process( const Handle(_pyCommand)& theCommand)
 {
   ASSERT( !myIsAlgo );
   // set args
+  int nbArgs = 0;
   for ( int i = 1; i <= myArgMethods.Length(); ++i ) {
     if ( myArgMethods( i ) == theCommand->GetMethod() ) {
-      while ( myArgs.Length() < i )
+      while ( myArgs.Length() < nbArgs + myNbArgsByMethod( i ))
         myArgs.Append( "[]" );
-      myArgs( i ) = theCommand->GetArg( 1 ); // arg value
+      for ( int iArg = 1; iArg <= myNbArgsByMethod( i ); ++iArg )
+        myArgs( nbArgs + iArg ) = theCommand->GetArg( iArg ); // arg value
       myArgCommands.push_back( theCommand );
       return;
     }
+    nbArgs += myNbArgsByMethod( i );
   }
   myUnknownCommands.push_back( theCommand );
 }
@@ -872,8 +979,44 @@ void _pyHypothesis::Process( const Handle(_pyCommand)& theCommand)
 
 void _pyHypothesis::Flush()
 {
-//   if ( IsWrapped() )
-//     GetCreationCmd()->Clear();
+  if ( IsWrapped() ) {
+  }
+  else {
+    list < Handle(_pyCommand) >::iterator cmd = myArgCommands.begin();
+    for ( ; cmd != myArgCommands.end(); ++cmd ) {
+      // Add access to a wrapped mesh
+      theGen->AddMeshAccessorMethod( *cmd );
+      // Add access to a wrapped algorithm
+      theGen->AddAlgoAccessorMethod( *cmd );
+    }
+    cmd = myUnknownCommands.begin();
+    for ( ; cmd != myUnknownCommands.end(); ++cmd ) {
+      // Add access to a wrapped mesh
+      theGen->AddMeshAccessorMethod( *cmd );
+      // Add access to a wrapped algorithm
+      theGen->AddAlgoAccessorMethod( *cmd );
+    }
+  }
+  // forget previous hypothesis modifications
+  myArgCommands.clear();
+  myUnknownCommands.clear();
+}
+
+//================================================================================
+/*!
+ * \brief clear creation, arg and unkown commands
+ */
+//================================================================================
+
+void _pyHypothesis::ClearAllCommands()
+{
+  GetCreationCmd()->Clear();
+  list<Handle(_pyCommand)>::iterator cmd = myArgCommands.begin();
+  for ( ; cmd != myArgCommands.end(); ++cmd )
+    ( *cmd )->Clear();
+  cmd = myUnknownCommands.begin();
+  for ( ; cmd != myUnknownCommands.end(); ++cmd )
+    ( *cmd )->Clear();
 }
 
 //================================================================================
@@ -896,6 +1039,127 @@ void _pyComplexParamHypo::Process( const Handle(_pyCommand)& theCommand)
   myArgCommands.push_back( theCommand );
 }
 
+//================================================================================
+/*!
+ * \brief Convert methods of 1D hypotheses to my own methods
+  * \param theCommand - The called hypothesis method
+ */
+//================================================================================
+
+void _pyLayerDistributionHypo::Process( const Handle(_pyCommand)& theCommand)
+{
+  if ( theCommand->GetMethod() != "SetLayerDistribution" )
+    return;
+
+  _pyID newName; // name for 1D hyp = "HypType" + "_Distribution"
+
+  const _pyID& hyp1dID = theCommand->GetArg( 1 );
+  Handle(_pyHypothesis) hyp1d = theGen->FindHyp( hyp1dID );
+  if ( hyp1d.IsNull() ) // apparently hypId changed at study restoration
+    hyp1d = my1dHyp;
+  else if ( !my1dHyp.IsNull() && hyp1dID != my1dHyp->GetID() ) {
+    // 1D hypo is already set, so distribution changes and the old
+    // 1D hypo is thrown away
+    my1dHyp->ClearAllCommands();
+  }
+  my1dHyp = hyp1d;
+  if ( my1dHyp.IsNull() )
+    return; // something wrong :(
+
+  // make a new name for 1D hyp = "HypType" + "_Distribution"
+  if ( my1dHyp->GetCreationCmd()->GetMethod() == "CreateHypothesis" ) {
+    // not yet converted creation cmd
+    TCollection_AsciiString hypTypeQuoted = my1dHyp->GetCreationCmd()->GetArg(1);
+    TCollection_AsciiString hypType = hypTypeQuoted.SubString( 2, hypTypeQuoted.Length() - 1 );
+    newName = hypType + "_Distribution";
+    my1dHyp->GetCreationCmd()->SetResultValue( newName );
+  }
+  else {
+    // already converted creation cmd
+    newName = my1dHyp->GetCreationCmd()->GetResultValue();
+  }
+
+  // as creation of 1D hyp was written later then it's edition,
+  // we need to find all it's edition calls and process them
+  list< Handle(_pyCommand) >& cmds = theGen->GetCommands();
+  list< Handle(_pyCommand) >::iterator cmdIt = cmds.begin();
+  for ( ; cmdIt != cmds.end(); ++cmdIt ) {
+    const _pyID& objID = (*cmdIt)->GetObject();
+    if ( objID == hyp1dID ) {
+      my1dHyp->Process( *cmdIt );
+      my1dHyp->GetCreationCmd()->AddDependantCmd( *cmdIt );
+      ( *cmdIt )->SetObject( newName );
+    }
+  }
+  if ( !myArgCommands.empty() )
+    myArgCommands.front()->Clear();
+  theCommand->SetArg( 1, newName );
+  myArgCommands.push_back( theCommand );
+  // copy hyp1d's creation method and args
+//   myCreationMethod = hyp1d->GetCreationMethod();
+//   myArgs           = hyp1d->GetArgs();
+//   // make them cleared at conversion
+//   myArgCommands = hyp1d->GetArgCommands();
+
+//   // to be cleared at convertion only
+//   myArgCommands.push_back( theCommand );
+}
+
+//================================================================================
+/*!
+ * \brief 
+  * \param theAdditionCmd - 
+  * \param theMesh - 
+  * \retval bool - 
+ */
+//================================================================================
+
+bool _pyLayerDistributionHypo::Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
+                                                  const _pyID&              theMesh)
+{
+  myIsWrapped = false;
+
+  if ( my1dHyp.IsNull() )
+    return false;
+
+  // set "SetLayerDistribution()" after addition cmd
+  theAdditionCmd->AddDependantCmd( myArgCommands.front() );
+
+  _pyID geom = theAdditionCmd->GetArg( 1 );
+
+  my1dHyp->SetMesh( theMesh );
+  if ( !my1dHyp->Addition2Creation( theAdditionCmd, theMesh ))
+    return false;
+
+  // clear "SetLayerDistribution()" cmd
+  myArgCommands.front()->Clear();
+
+  // Convert my creation => me = RadialPrismAlgo.Get3DHypothesis()
+
+  // find RadialPrism algo created on <geom> for theMesh
+  Handle(_pyHypothesis) algo = theGen->FindAlgo( geom, theMesh, this->GetType() );
+  if ( !algo.IsNull() ) {
+    GetCreationCmd()->SetObject( algo->GetID() );
+    GetCreationCmd()->SetMethod( "Get3DHypothesis" );
+    GetCreationCmd()->RemoveArgs();
+    theAdditionCmd->AddDependantCmd( GetCreationCmd() );
+    myIsWrapped = true;
+  }
+  return myIsWrapped;
+}
+
+//================================================================================
+/*!
+ * \brief 
+ */
+//================================================================================
+
+void _pyLayerDistributionHypo::Flush()
+{
+  //my1dHyp.Nullify();
+  //_pyHypothesis::Flush();
+}
+
 //================================================================================
 /*!
  * \brief additionally to Addition2Creation, clears SetDistrType() command
@@ -908,21 +1172,66 @@ void _pyComplexParamHypo::Process( const Handle(_pyCommand)& theCommand)
 bool _pyNumberOfSegmentsHyp::Addition2Creation( const Handle(_pyCommand)& theCmd,
                                                 const _pyID&              theMesh)
 {
-  if ( IsWrappable( theMesh ) && myArgs.Length() > 0 ) {
-    list<Handle(_pyCommand)>::iterator cmd = myUnknownCommands.begin();
-    for ( ; cmd != myUnknownCommands.end(); ++cmd ) {
-      // clear SetDistrType()
-      if ( (*cmd)->GetString().Location( "SetDistrType", 1, (*cmd)->Length() ))
-        (*cmd)->Clear();
+  if ( IsWrappable( theMesh ) && myArgs.Length() > 1 ) {
+    // scale factor (2-nd arg) is provided: clear SetDistrType(1) command
+    bool scaleDistrType = false;
+    list<Handle(_pyCommand)>::reverse_iterator cmd = myUnknownCommands.rbegin();
+    for ( ; cmd != myUnknownCommands.rend(); ++cmd ) {
+      if ( (*cmd)->GetMethod() == "SetDistrType" ) {
+        if ( (*cmd)->GetArg( 1 ) == "1" ) {
+          scaleDistrType = true;
+          (*cmd)->Clear();
+        }
+        else if ( !scaleDistrType ) {
+          // distribution type changed: remove scale factor from args
+          myArgs.Remove( 2, myArgs.Length() );
+          break;
+        }
+      }
     }
   }
   return _pyHypothesis::Addition2Creation( theCmd, theMesh );
 }
 
+//================================================================================
+/*!
+ * \brief remove repeated commands defining distribution
+ */
+//================================================================================
+
+void _pyNumberOfSegmentsHyp::Flush()
+{
+  // find number of the last SetDistrType() command
+  list<Handle(_pyCommand)>::reverse_iterator cmd = myUnknownCommands.rbegin();
+  int distrTypeNb = 0;
+  for ( ; !distrTypeNb && cmd != myUnknownCommands.rend(); ++cmd )
+    if ( (*cmd)->GetMethod() == "SetDistrType" )
+      distrTypeNb = (*cmd)->GetOrderNb();
+
+  // clear commands before the last SetDistrType()
+  list<Handle(_pyCommand)> * cmds[2] = { &myArgCommands, &myUnknownCommands };
+  for ( int i = 0; i < 2; ++i ) {
+    set<TCollection_AsciiString> uniqueMethods;
+    list<Handle(_pyCommand)> & cmdList = *cmds[i];
+    for ( cmd = cmdList.rbegin(); cmd != cmdList.rend(); ++cmd )
+    {
+      bool clear = ( (*cmd)->GetOrderNb() < distrTypeNb );
+      const TCollection_AsciiString& method = (*cmd)->GetMethod();
+      if ( !clear || method == "SetNumberOfSegments" ) {
+        bool isNewInSet = uniqueMethods.insert( method ).second;
+        clear = !isNewInSet;
+      }
+      if ( clear )
+        (*cmd)->Clear();
+    }
+    cmdList.clear();
+  }
+}
+
 //================================================================================
 /*!
  * \brief _pyAlgorithm constructor
-  * \param theCreationCmd - The command like "algo = smeshgen.CreateHypothesis(type,lib)"
+ * \param theCreationCmd - The command like "algo = smeshgen.CreateHypothesis(type,lib)"
  */
 //================================================================================
 
@@ -1236,10 +1545,17 @@ void _pyCommand::SetArg( int index, const TCollection_AsciiString& theArg)
   if ( pos < 1 ) // no index-th arg exist, append inexistent args
   {
     // find a closing parenthesis
-    pos = Length();
-    while ( pos > 0 && myString.Value( pos ) != ')' )
-      --pos;
-    if ( pos == 0 ) { // no parentheses at all
+    if ( int lastArgInd = GetNbArgs() ) {
+      pos = GetBegPos( ARG1_IND + lastArgInd  - 1 ) + GetArg( lastArgInd ).Length();
+      while ( pos > 0 && pos <= Length() && myString.Value( pos ) != ')' )
+        ++pos;
+    }
+    else {
+      pos = Length();
+      while ( pos > 0 && myString.Value( pos ) != ')' )
+        --pos;
+    }
+    if ( pos < 1 || myString.Value( pos ) != ')' ) { // no parentheses at all
       myString += "()";
       pos = Length();
     }
@@ -1280,8 +1596,8 @@ void _pyCommand::RemoveArgs()
 bool _pyCommand::SetDependentCmdsAfter() const
 {
   bool orderChanged = false;
-  list< Handle(_pyCommand)>::const_iterator cmd = myDependentCmds.begin();
-  for ( ; cmd != myDependentCmds.end(); ++cmd ) {
+  list< Handle(_pyCommand)>::const_reverse_iterator cmd = myDependentCmds.rbegin();
+  for ( ; cmd != myDependentCmds.rend(); ++cmd ) {
     if ( (*cmd)->GetOrderNb() < GetOrderNb() ) {
       orderChanged = true;
       theGen->SetCommandAfter( *cmd, this );
@@ -1290,3 +1606,55 @@ bool _pyCommand::SetDependentCmdsAfter() const
   }
   return orderChanged;
 }
+//================================================================================
+/*!
+ * \brief Insert accessor method after theObjectID
+  * \param theObjectID - id of the accessed object
+  * \param theAcsMethod - name of the method giving access to the object
+  * \retval bool - false if theObjectID is not found in the command string
+ */
+//================================================================================
+
+bool _pyCommand::AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod )
+{
+  if ( !theAcsMethod )
+    return false;
+  // start object search from the object, i.e. ignore result
+  GetObject();
+  int beg = GetBegPos( OBJECT_IND );
+  if ( beg < 1 || beg > Length() )
+    return false;
+  while (( beg = myString.Location( theObjectID, beg, Length() )))
+  {
+    // check that theObjectID is not just a part of a longer ID
+    int afterEnd = beg + theObjectID.Length();
+    Standard_Character c = myString.Value( afterEnd );
+    if ( !isalnum( c ) && c != ':' ) {
+      // insertion
+      int oldLen = Length();
+      myString.Insert( afterEnd, (char*) theAcsMethod );
+      myString.Insert( afterEnd, "." );
+      // update starting positions of the parts following the modified one
+      int posDelta = Length() - oldLen;
+      for ( int i = 1; i <= myBegPos.Length(); ++i ) {
+        if ( myBegPos( i ) > afterEnd )
+          myBegPos( i ) += posDelta;
+      }
+      return true;
+    }
+    beg = afterEnd; // is a part - next search
+  }
+  return false;
+}
+
+//================================================================================
+/*!
+ * \brief Return method name giving access to an interaface object wrapped by python class
+  * \retval const char* - method name
+ */
+//================================================================================
+
+const char* _pyObject::AccessorMethod() const
+{
+  return 0;
+}