#endif
// Static variables definition
+GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen = GEOM::GEOM_Gen::_nil();
CORBA::ORB_var SMESH_Gen_i::myOrb;
PortableServer::POA_var SMESH_Gen_i::myPoa;
SALOME_NamingService* SMESH_Gen_i::myNS = NULL;
*/
//=============================================================================
GEOM::GEOM_Gen_ptr SMESH_Gen_i::GetGeomEngine() {
- GEOM::GEOM_Gen_var aGeomEngine =
- GEOM::GEOM_Gen::_narrow( GetLCC()->FindOrLoad_Component("FactoryServer","GEOM") );
- return aGeomEngine._retn();
+ //CCRT GEOM::GEOM_Gen_var aGeomEngine =
+ //CCRT GEOM::GEOM_Gen::_narrow( GetLCC()->FindOrLoad_Component("FactoryServer","GEOM") );
+ //CCRT return aGeomEngine._retn();
+ if(CORBA::is_nil(myGeomGen))
+ {
+ Engines::Component_ptr temp=GetLCC()->FindOrLoad_Component("FactoryServer","GEOM");
+ myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
+ }
+ return myGeomGen;
}
//=============================================================================
return myShapeReader;
}
+//=============================================================================
+/*!
+ * SMESH_Gen_i::SetGeomEngine
+ *
+ * Set GEOM::GEOM_Gen reference
+ */
+//=============================================================================
+//GEOM::GEOM_Gen_ptr SMESH_Gen_i::SetGeomEngine( const char* containerLoc )
+void SMESH_Gen_i::SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo )
+{
+ //Engines::Component_ptr temp=GetLCC()->FindOrLoad_Component(containerLoc,"GEOM");
+ //myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
+ myGeomGen=GEOM::GEOM_Gen::_duplicate(geomcompo);
+ //return myGeomGen;
+}
+
//=============================================================================
/*!
* SMESH_Gen_i::SetEmbeddedMode
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
- if ( CORBA::is_nil( theSubObject ) )
+ if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
if ( CORBA::is_nil( theMesh ) )
try {
if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
{
- TopoDS_Shape shape = GeomObjectToShape( theSubObject );
+ TopoDS_Shape shape;
+ if(theMesh->HasShapeToMesh())
+ shape = GeomObjectToShape( theSubObject );
+ else
+ shape = SMESH_Mesh::PseudoShape();
+
::SMESH_Mesh& mesh = meshServant->GetImpl();
error_array->length( mesh.GetMeshDS()->MaxShapeIndex() );
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
- if ( CORBA::is_nil( theSubObject ) )
+ if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
if ( CORBA::is_nil( theMesh ) )
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
ASSERT( meshServant );
if ( meshServant ) {
- TopoDS_Shape myLocShape = GeomObjectToShape( theSubObject );
+ TopoDS_Shape myLocShape;
+ if(theMesh->HasShapeToMesh())
+ myLocShape = GeomObjectToShape( theSubObject );
+ else
+ myLocShape = SMESH_Mesh::PseudoShape();
+
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
list< ::SMESH_Gen::TAlgoStateError > error_list;
list< ::SMESH_Gen::TAlgoStateError >::iterator error;
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" );
- if ( CORBA::is_nil( theShapeObject ) )
+ if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SALOME::BAD_PARAM );
// Update Python script
TPythonDump() << "isDone = " << this << ".Compute( "
<< theMesh << ", " << theShapeObject << ")";
- TPythonDump() << "if not isDone: print 'Mesh', " << theMesh << ", ': computation failed'";
try {
// get mesh servant
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
ASSERT( meshServant );
if ( meshServant ) {
+ // NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
+ meshServant->CheckGeomGroupModif();
// get local TopoDS_Shape
- TopoDS_Shape myLocShape = GeomObjectToShape( theShapeObject );
+ TopoDS_Shape myLocShape;
+ if(theMesh->HasShapeToMesh())
+ myLocShape = GeomObjectToShape( theShapeObject );
+ else
+ myLocShape = SMESH_Mesh::PseudoShape();
// call implementation compute
::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
return myGen.Compute( myLocMesh, myLocShape);
}
}
- catch ( std::bad_alloc& exc ) {
- THROW_SALOME_CORBA_EXCEPTION( "Memory allocation problem",
- SALOME::INTERNAL_ERROR );
+ catch ( std::bad_alloc ) {
+ INFOS( "Compute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
INFOS( "Compute(): catch exception "<< S_ex.what() );
GEOM::GEOM_Object_var geom = FindGeometryByMeshElement(theMesh, theElementID);
if ( !geom->_is_nil() ) {
GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
- GEOM::GEOM_Gen_var geomGen = GetGeomEngine();
+ GEOM::GEOM_Gen_ptr geomGen = GetGeomEngine();
// try to find the corresponding SObject
SALOMEDS::SObject_var SObj = ObjectToSObject( myCurrentStudy, geom.in() );
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", SALOME::BAD_PARAM );
GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
- GEOM::GEOM_Gen_var geomGen = GetGeomEngine();
+ GEOM::GEOM_Gen_ptr geomGen = GetGeomEngine();
// get a core mesh DS
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
int id = myStudyContext->findId( string( objStr.in() ) );
::SMESH_Mesh& myLocMesh = myImpl->GetImpl();
SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
+ bool hasShape = myLocMesh.HasShapeToMesh();
// for each mesh open the HDF group basing on its id
char meshGrpName[ 30 ];
aDataset->WriteOnDisk( ( char* )( strHasData.c_str() ) );
aDataset->CloseOnDisk();
+ // ouv : NPAL12872
+ // for each mesh open the HDF group basing on its auto color parameter
+ char meshAutoColorName[ 30 ];
+ sprintf( meshAutoColorName, "AutoColorMesh %d", id );
+ int anAutoColor[1];
+ anAutoColor[0] = myImpl->GetAutoColor();
+ aSize[ 0 ] = 1;
+ aDataset = new HDFdataset( meshAutoColorName, aTopGroup, HDF_INT32, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk( anAutoColor );
+ aDataset->CloseOnDisk();
+
// write reference on a shape if exists
SALOMEDS::SObject_var myRef;
bool shapeRefFound = false;
// write applied hypotheses if exist
SALOMEDS::SObject_var myHypBranch;
found = gotBranch->FindSubObject( GetRefOnAppliedHypothesisTag(), myHypBranch );
- if ( found && !shapeRefFound ) { // remove applied hyps
+ if ( found && !shapeRefFound && hasShape) { // remove applied hyps
myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
}
- if ( found && shapeRefFound ) {
+ if ( found && (shapeRefFound || !hasShape) ) {
aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup );
aGroup->CreateOnDisk();
// write applied algorithms if exist
SALOMEDS::SObject_var myAlgoBranch;
found = gotBranch->FindSubObject( GetRefOnAppliedAlgorithmsTag(), myAlgoBranch );
- if ( found && !shapeRefFound ) { // remove applied algos
+ if ( found && !shapeRefFound && hasShape) { // remove applied algos
myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myAlgoBranch );
}
- if ( found && shapeRefFound ) {
+ if ( found && (shapeRefFound || !hasShape)) {
aGroup = new HDFgroup( "Applied Algorithms", aTopGroup );
aGroup->CreateOnDisk();
aDataset->WriteOnDisk( aUserName );
aDataset->CloseOnDisk();
+ // ouv : NPAL12872
+ // For each group, create a dataset named "Group <group_persistent_id> Color"
+ // and store the group's color into it
+ char grpColorName[ 30 ];
+ sprintf( grpColorName, "ColorGroup %d", anId );
+ SALOMEDS::Color aColor = myGroupImpl->GetColor();
+ double anRGB[3];
+ anRGB[ 0 ] = aColor.R;
+ anRGB[ 1 ] = aColor.G;
+ anRGB[ 2 ] = aColor.B;
+ aSize[ 0 ] = 3;
+ aDataset = new HDFdataset( grpColorName, aGroup, HDF_FLOAT64, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk( anRGB );
+ aDataset->CloseOnDisk();
+
// Store the group contents into MED file
if ( myLocMesh.GetGroup( myGroupImpl->GetLocalID() ) ) {
myWriter.Perform();
// maybe a shape was deleted in the study
- if ( !shapeRefFound && !mySMESHDSMesh->ShapeToMesh().IsNull() ) {
+ if ( !shapeRefFound && !mySMESHDSMesh->ShapeToMesh().IsNull() && hasShape) {
TopoDS_Shape nullShape;
myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data
}
}
// close hypotheses root HDF group
aTopGroup->CloseOnDisk();
+ aTopGroup = 0;
}
// --> then we should read&create algorithms
}
// close algorithms root HDF group
aTopGroup->CloseOnDisk();
+ aTopGroup = 0;
}
// --> the rest groups should be meshes
int newId = myStudyContext->findId( iorString );
myStudyContext->mapOldToNew( id, newId );
+ // ouv : NPAL12872
+ // try to read and set auto color flag
+ char aMeshAutoColorName[ 30 ];
+ sprintf( aMeshAutoColorName, "AutoColorMesh %d", id);
+ if( aTopGroup->ExistInternalObject( aMeshAutoColorName ) )
+ {
+ aDataset = new HDFdataset( aMeshAutoColorName, aTopGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ int* anAutoColor = new int[ size ];
+ aDataset->ReadFromDisk( anAutoColor );
+ aDataset->CloseOnDisk();
+ myNewMeshImpl->SetAutoColor( (bool)anAutoColor[0] );
+ }
+
// try to read and set reference to shape
GEOM::GEOM_Object_var aShapeObject;
if ( aTopGroup->ExistInternalObject( "Ref on shape" ) ) {
CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() );
if ( !CORBA::is_nil( hypObject ) ) {
SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject );
- if ( !anHyp->_is_nil() && !aShapeObject->_is_nil() )
+ if ( !anHyp->_is_nil() && (!aShapeObject->_is_nil()
+ || !myNewMeshImpl->HasShapeToMesh()) )
myNewMeshImpl->addHypothesis( aShapeObject, anHyp );
}
}
CORBA::Object_var hypObject = GetORB()->string_to_object( anIOR.c_str() );
if ( !CORBA::is_nil( hypObject ) ) {
SMESH::SMESH_Hypothesis_var anHyp = SMESH::SMESH_Hypothesis::_narrow( hypObject );
- if ( !anHyp->_is_nil() && !aShapeObject->_is_nil() )
+ if ( !anHyp->_is_nil() && (!aShapeObject->_is_nil()
+ || !myNewMeshImpl->HasShapeToMesh()) )
myNewMeshImpl->addHypothesis( aShapeObject, anHyp );
}
}
} // if ( hasData )
// Recompute State (as computed sub-meshes are restored from MED)
- if ( !aShapeObject->_is_nil() ) {
+ if ( !aShapeObject->_is_nil() || !myNewMeshImpl->HasShapeToMesh()) {
MESSAGE("Compute State Engine ...");
- TopoDS_Shape myLocShape = GeomObjectToShape( aShapeObject );
+ TopoDS_Shape myLocShape;
+ if(myNewMeshImpl->HasShapeToMesh())
+ myLocShape = GeomObjectToShape( aShapeObject );
+ else
+ myLocShape = SMESH_Mesh::PseudoShape();
+
myNewMeshImpl->GetImpl().GetSubMesh(myLocShape)->ComputeStateEngine
(SMESH_subMesh::SUBMESH_RESTORED);
MESSAGE("Compute State Engine finished");
SMESHDS_GroupBase* aGroupBaseDS = aLocalGroup->GetGroupDS();
aGroupBaseDS->SetStoreName( name_dataset );
+ // ouv : NPAL12872
+ // Read color of the group
+ char aGroupColorName[ 30 ];
+ sprintf( aGroupColorName, "ColorGroup %d", subid);
+ if ( aGroup->ExistInternalObject( aGroupColorName ) )
+ {
+ aDataset = new HDFdataset( aGroupColorName, aGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ double* anRGB = new double[ size ];
+ aDataset->ReadFromDisk( anRGB );
+ aDataset->CloseOnDisk();
+ SALOMEDS::Color aColor;
+ aColor.R = anRGB[0];
+ aColor.G = anRGB[1];
+ aColor.B = anRGB[2];
+ aGroupBaseDS->SetColor( aColor );
+ }
+
// Fill group with contents from MED file
SMESHDS_Group* aGrp = dynamic_cast<SMESHDS_Group*>( aGroupBaseDS );
if ( aGrp )
}
}
// close mesh group
- aTopGroup->CloseOnDisk();
+ if(aTopGroup)
+ aTopGroup->CloseOnDisk();
}
// close HDF file
aFile->CloseOnDisk();