#endif
// Static variables definition
-GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen=GEOM::GEOM_Gen::_nil();
+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;
* Get GEOM::GEOM_Gen reference
*/
//=============================================================================
-GEOM::GEOM_Gen_ptr SMESH_Gen_i::GetGeomEngine()
-{
- if (CORBA::is_nil(myGeomGen))
+GEOM::GEOM_Gen_ptr SMESH_Gen_i::GetGeomEngine() {
+ //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);
+ myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
}
return myGeomGen;
}
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() );
::SMESH_Mesh & mesh = meshServant->GetImpl();
SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
// find the element in mesh
- if ( const SMDS_MeshElement * elem = meshDS->FindElement( theElementID ) )
+ if ( const SMDS_MeshElement * elem = meshDS->FindElement( theElementID ) ) {
// find a shape id by the element
if ( int shapeID = ::SMESH_MeshEditor( &mesh ).FindShape( elem )) {
// get a geom object by the shape id
GEOM::GEOM_Object_var geom = ShapeToGeomObject( meshDS->IndexToShape( shapeID ));
if ( geom->_is_nil() ) {
+ // try to find a published sub-shape
+ SALOMEDS::SObject_var mainSO = ObjectToSObject( myCurrentStudy, mainShape );
+ SALOMEDS::ChildIterator_var it;
+ if ( !mainSO->_is_nil() )
+ it = myCurrentStudy->NewChildIterator( mainSO );
+ if ( !it->_is_nil() ) {
+ for ( it->InitEx(true); it->More(); it->Next() ) {
+ GEOM::GEOM_Object_var subGeom =
+ GEOM::GEOM_Object::_narrow( SObjectToObject( it->Value() ));
+ if ( !subGeom->_is_nil() ) {
+ GEOM::ListOfLong_var subList = subGeom->GetSubShapeIndices();
+ if ( subList->length() == 1 && shapeID == subList[0] ) {
+ geom = subGeom;
+ break;
+ }
+ }
+ }
+ }
+ }
+ if ( geom->_is_nil() ) {
+ // explode
GEOM::GEOM_IShapesOperations_var op =
geomGen->GetIShapesOperations( GetCurrentStudyID() );
if ( !op->_is_nil() )
return geom._retn();
}
}
+ }
}
return GEOM::GEOM_Object::_nil();
}
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();
+ Quantity_Color aColor( anRGB[0], anRGB[1], anRGB[2], Quantity_TOC_RGB );
+ 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();
delete myStudyContextMap[ studyId ];
myStudyContextMap.erase( studyId );
}
+
+ // delete SMESH_Mesh's
+ StudyContextStruct* context = myGen.GetStudyContext( studyId );
+ map< int, SMESH_Mesh* >::iterator i_mesh = context->mapMesh.begin();
+ for ( ; i_mesh != context->mapMesh.end(); ++i_mesh )
+ delete i_mesh->second;
+ // delete SMESHDS_Mesh's
+ // it's too long on big meshes
+// if ( context->myDocument ) {
+// delete context->myDocument;
+// context->myDocument = 0;
+// }
+
return;
}
