-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <SVTK_Prs.h>
#include <SVTK_ViewModel.h>
+#include <OCCViewer_ViewWindow.h>
+#include <OCCViewer_ViewPort3d.h>
+
// OCCT Includes
#include <AIS_Drawer.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
+#include <Aspect_ColorScale.hxx>
#include <Prs3d_IsoAspect.hxx>
#include <Prs3d_PointAspect.hxx>
#include <StdSelect_TypeOfEdge.hxx>
// Function : getEntry
// Purpose :
//================================================================
-static std::string getEntry( GEOM::GEOM_Object_ptr object )
+static std::string getEntry( GEOM::GEOM_BaseObject_ptr object )
{
SUIT_Session* session = SUIT_Session::session();
SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
// Function : getName
// Purpose :
//================================================================
-static std::string getName( GEOM::GEOM_Object_ptr object )
+static std::string getName( GEOM::GEOM_BaseObject_ptr object )
{
SUIT_Session* session = SUIT_Session::session();
SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
#endif
myViewFrame = 0;
+
+ myFieldDataType = GEOM::FDT_Double;
+ myFieldDimension = 0;
+ myFieldStepRangeMin = 0;
+ myFieldStepRangeMax = 0;
}
//=================================================================
* not using dialog boxes.
*/
//=================================================================
-void GEOM_Displayer::Display( GEOM::GEOM_Object_ptr theObj, const bool updateViewer )
+void GEOM_Displayer::Display( GEOM::GEOM_BaseObject_ptr theObj, const bool updateViewer )
{
if ( theObj->_is_nil() )
return;
* Erase geometry object in the current viewer
*/
//=================================================================
-void GEOM_Displayer::Erase( GEOM::GEOM_Object_ptr theObj,
+void GEOM_Displayer::Erase( GEOM::GEOM_BaseObject_ptr theObj,
const bool forced,
const bool updateViewer )
{
*/
//=================================================================
void GEOM_Displayer::Redisplay( const Handle(SALOME_InteractiveObject)& theIO,
- const bool updateViewer )
+ const bool updateViewer,
+ const bool checkActiveViewer )
{
// Remove the object permanently (<forced> == true)
SUIT_Session* ses = SUIT_Session::session();
SALOME_View* view = dynamic_cast<SALOME_View*>(vmodel);
if ( view )
{
- if ( view->isVisible( theIO ) || view == GetActiveView() )
+ if ( view->isVisible( theIO ) || ( checkActiveViewer && view == GetActiveView() ) )
{
Erase( theIO, true, false, view );
Display( theIO, updateViewer, view );
// - wireframe color
Handle(Prs3d_LineAspect) anAspect = AISShape->Attributes()->LineAspect();
anAspect->SetColor( HasColor() ? (Quantity_NameOfColor)GetColor() :
- SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::WireframeColor ) ).value<QColor>() ) );
+ SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::WireframeColor ) ).value<QColor>() ) );
AISShape->Attributes()->SetLineAspect( anAspect );
// - unfree boundaries color
anAspect = AISShape->Attributes()->UnFreeBoundaryAspect();
anAspect->SetColor( HasColor() ? (Quantity_NameOfColor)GetColor() :
- SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::WireframeColor ) ).value<QColor>() ) );
+ SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::WireframeColor ) ).value<QColor>() ) );
AISShape->Attributes()->SetUnFreeBoundaryAspect( anAspect );
// - free boundaries color
anAspect = AISShape->Attributes()->FreeBoundaryAspect();
anAspect->SetColor( HasColor() ? (Quantity_NameOfColor)GetColor() :
- SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::FreeBndColor ) ).value<QColor>() ) );
+ SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::FreeBndColor ) ).value<QColor>() ) );
AISShape->Attributes()->SetFreeBoundaryAspect( anAspect );
// - standalone edges color
anAspect = AISShape->Attributes()->WireAspect();
anAspect->SetColor( HasColor() ? (Quantity_NameOfColor)GetColor() :
- SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::LineColor ) ).value<QColor>() ) );
+ SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::LineColor ) ).value<QColor>() ) );
AISShape->Attributes()->SetWireAspect( anAspect );
// - color for edges in shading+edges mode
// set display mode
AISShape->SetDisplayMode( HasDisplayMode() ?
- // predefined display mode, manually set to displayer via GEOM_Displayer::SetDisplayMode() function
- GetDisplayMode() :
- // display mode from properties
- propMap.value( GEOM::propertyName( GEOM::DisplayMode ) ).toInt() );
+ // predefined display mode, manually set to displayer via GEOM_Displayer::SetDisplayMode() function
+ GetDisplayMode() :
+ // display mode from properties
+ propMap.value( GEOM::propertyName( GEOM::DisplayMode ) ).toInt() );
// set display vectors flag
AISShape->SetDisplayVectors( propMap.value( GEOM::propertyName( GEOM::EdgesDirection ) ).toBool() );
AISShape->SetOwnDeviationCoefficient( qMax( propMap.value( GEOM::propertyName( GEOM::Deflection ) ).toDouble(), GEOM::minDeflection() ) );
// set texture
+ bool textureAdded = false;
if ( HasTexture() ) {
// predefined display texture, manually set to displayer via GEOM_Displayer::SetTexture() function
AISShape->SetTextureFileName( TCollection_AsciiString( GetTexture().c_str() ) );
+ if ( ! entry.isEmpty() ) {
+ // check that study is active
+ SalomeApp_Study* study = getActiveStudy();
+ if ( study ) {
+ // Store the texture in object properties for next displays
+ study->setObjectProperty( aMgrId, entry, GEOM::propertyName( GEOM::Texture ), QString( GetTexture().c_str() ) );
+ study->setObjectProperty( aMgrId, entry, GEOM::propertyName( GEOM::DisplayMode ), 3 );
+
+ // Update porpeties map
+ propMap = getObjectProperties( study, entry, myViewFrame );
+ }
+ }
+ textureAdded = true;
+ }
+ else {
+ // Texture from properties
+ QString aTexture = propMap.value( GEOM::propertyName( GEOM::Texture ) ).toString();
+ if ( !aTexture.isEmpty() ) {
+ AISShape->SetTextureFileName( TCollection_AsciiString( aTexture.toStdString().c_str() ) );
+ textureAdded = true;
+ }
+ }
+
+ if ( textureAdded ){
AISShape->SetTextureMapOn();
AISShape->DisableTextureModulate();
- AISShape->SetDisplayMode( 3 );
}
// set line width
AISShape->SetWidth( HasWidth() ?
- // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
- GetWidth() :
- // libe width from properties
- propMap.value( GEOM::propertyName( GEOM::LineWidth ) ).toInt() );
+ // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
+ GetWidth() :
+ // libe width from properties
+ propMap.value( GEOM::propertyName( GEOM::LineWidth ) ).toInt() );
// set top-level flag
AISShape->setTopLevel( propMap.value( GEOM::propertyName( GEOM::TopLevel ) ).toBool() );
anAspect->SetScale( aScaleOfMarker );
anAspect->SetTypeOfMarker( (Aspect_TypeOfMarker)( aTypeOfMarker-1 ) );
anAspect->SetColor( HasColor() ?
- // predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
- (Quantity_NameOfColor)GetColor() :
- // color from properties
- SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::PointColor ) ).value<QColor>() ) );
+ // predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
+ (Quantity_NameOfColor)GetColor() :
+ // color from properties
+ SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::PointColor ) ).value<QColor>() ) );
AISShape->Attributes()->SetPointAspect( anAspect );
}
else if ( aList.size() == 1 ) {
#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
Handle(TColStd_HArray1OfByte) aTexture =
#else
- Handle(Graphic3d_HArray1OfBytes) aTexture =
+ Handle(Graphic3d_HArray1OfBytes) aTexture =
#endif
- GeometryGUI::getTexture( study, textureId, aWidth, aHeight );
+ GeometryGUI::getTexture( study, textureId, aWidth, aHeight );
if ( !aTexture.IsNull() ) {
- static int TextureId = 0;
- Handle(Prs3d_PointAspect) aTextureAspect =
- new Prs3d_PointAspect( HasColor() ?
+#if OCC_VERSION_LARGE > 0x06060000 // Porting to OCCT higher 6.6.0 version
+ Handle(Prs3d_PointAspect) aTextureAspect =
+ new Prs3d_PointAspect( HasColor() ?
+ // predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
+ (Quantity_NameOfColor)GetColor() :
+ // color from properties
+ SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::PointColor ) ).value<QColor>() ),
+ aWidth, aHeight,
+ aTexture );
+#else
+ int TextureId = 0;
+ Handle(Prs3d_PointAspect) aTextureAspect =
+ new Prs3d_PointAspect( HasColor() ?
// predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
(Quantity_NameOfColor)GetColor() :
- // color from properties
- SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::PointColor ) ).value<QColor>() ),
+ // color from properties
+ SalomeApp_Tools::color( propMap.value( GEOM::propertyName( GEOM::PointColor ) ).value<QColor>() ),
++TextureId,
- aWidth, aHeight,
- aTexture );
- AISShape->Attributes()->SetPointAspect( aTextureAspect );
+ aWidth, aHeight,
+ aTexture );
+#endif
+ AISShape->Attributes()->SetPointAspect( aTextureAspect );
}
}
}
+ // set field step data
+ AISShape->setFieldStepInfo( myFieldDataType,
+ myFieldDimension,
+ myFieldStepData,
+ myFieldStepName,
+ myFieldStepRangeMin,
+ myFieldStepRangeMax );
+
if ( create && !isTemporary && aMgrId != -1 ) {
// set properties to the study
study->setObjectPropMap( aMgrId, entry, propMap );
// set line width
actor->SetWidth( HasWidth() ?
- // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
- GetWidth() :
- // libe width from properties
- propMap.value( GEOM::propertyName( GEOM::LineWidth ) ).toInt() );
+ // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
+ GetWidth() :
+ // libe width from properties
+ propMap.value( GEOM::propertyName( GEOM::LineWidth ) ).toInt() );
// set display vectors flag
actor->SetVectorMode( propMap.value( GEOM::propertyName( GEOM::EdgesDirection ) ).toBool() );
* Calls Redisplay() method for each object in the given list
*/
//=================================================================
-void GEOM_Displayer::Redisplay( const SALOME_ListIO& theIOList, const bool updateViewer )
+void GEOM_Displayer::Redisplay( const SALOME_ListIO& theIOList,
+ const bool updateViewer,
+ const bool checkActiveViewer )
{
SALOME_ListIteratorOfListIO Iter( theIOList );
for ( ; Iter.More(); Iter.Next() )
- Redisplay( Iter.Value(), false );
+ Redisplay( Iter.Value(), false, checkActiveViewer );
if ( updateViewer )
UpdateViewer();
if ( occPrs->IsNull() )
{
- // new presentation is being created
+ // new presentation is being created
aTrh = new GEOM_AISTrihedron( aPlc );
occPrs->AddObject( aTrh );
}
else
{
- // presentation is being updated
+ // presentation is being updated
AIS_ListOfInteractive aList;
occPrs->GetObjects( aList );
AIS_ListIteratorOfListOfInteractive anIter( aList );
for ( ; anIter.More() && aTrh.IsNull(); anIter.Next() ) {
aTrh = Handle(GEOM_AISTrihedron)::DownCast( anIter.Value() );
- }
+ }
}
-
+
if ( !aTrh.IsNull() ) {
- // predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
+ // predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
if ( HasColor() )
aTrh->SetColor( (Quantity_NameOfColor)GetColor() );
- // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
+ // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
if ( HasWidth() )
aTrh->SetWidth( GetWidth() );
-
+
if ( !myIO.IsNull() )
{
aTrh->setIO( myIO );
aTrh->SetOwner( myIO );
}
- aTrh->SetComponent( aPlc );
- aTrh->SetToUpdate();
+ aTrh->SetComponent( aPlc );
+ aTrh->SetToUpdate();
}
occPrs->SetToActivate( ToActivate() );
}
{
// create presentation (specific for vectors)
Handle(GEOM_AISShape) AISShape = ( myType == GEOM_VECTOR ) ? new GEOM_AISVector( myShape, "" )
- : new GEOM_AISShape ( myShape, "" );
+ : new GEOM_AISShape ( myShape, "" );
+
+ if( myType == GEOM_FIELD_STEP )
+ AISShape->SetHilightMode( GEOM_AISShape::CustomHighlight );
// update shape properties
updateShapeProperties( AISShape, true );
occPrs->SetToActivate( ToActivate() );
if ( AISShape->isTopLevel() && GEOM_AISShape::topLevelDisplayMode() == GEOM_AISShape::TopShowAdditionalWActor ) {
- // 21671: EDF 1829 GEOM : Bring to front selected objects (continuation):
-
- // create additional wireframe shape
- Handle(GEOM_TopWireframeShape) aWirePrs = new GEOM_TopWireframeShape(myShape);
- aWirePrs->SetWidth(AISShape->Width());
- if ( !myIO.IsNull() ) {
- aWirePrs->setIO( myIO );
- aWirePrs->SetOwner( myIO );
- }
-
- // add shape to the presentation
- occPrs->AddObject( aWirePrs );
+ // 21671: EDF 1829 GEOM : Bring to front selected objects (continuation):
+
+ // create additional wireframe shape
+ Handle(GEOM_TopWireframeShape) aWirePrs = new GEOM_TopWireframeShape(myShape);
+ aWirePrs->SetWidth(AISShape->Width());
+ if ( !myIO.IsNull() ) {
+ aWirePrs->setIO( myIO );
+ aWirePrs->SetOwner( myIO );
+ }
+
+ // add shape to the presentation
+ occPrs->AddObject( aWirePrs );
}
}
// if presentation is found -> set again shape for it
AIS_ListIteratorOfListOfInteractive Iter( IOList );
for ( ; Iter.More(); Iter.Next() )
{
- Handle(GEOM_AISShape) AISShape = Handle(GEOM_AISShape)::DownCast( Iter.Value() );
- if ( AISShape.IsNull() )
- continue;
+ Handle(GEOM_AISShape) AISShape = Handle(GEOM_AISShape)::DownCast( Iter.Value() );
+ if ( AISShape.IsNull() )
+ continue;
- // re-set shape (it might be changed)
- if ( AISShape->Shape() != myShape )
- AISShape->Set( myShape );
+ // re-set shape (it might be changed)
+ if ( AISShape->Shape() != myShape )
+ AISShape->Set( myShape );
- // update shape properties
- updateShapeProperties( AISShape, false );
+ // update shape properties
+ updateShapeProperties( AISShape, false );
- // force updating
- AISShape->UpdateSelection();
- AISShape->SetToUpdate();
+ // force updating
+ AISShape->UpdateSelection();
+ AISShape->SetToUpdate();
}
}
}
GEOM_VTKTrihedron* aTrh = 0;
if ( vtkPrs->IsNull() ) {
- // new presentation is being created
- aTrh = GEOM_VTKTrihedron::New();
- vtkPrs->AddObject( aTrh );
+ // new presentation is being created
+ aTrh = GEOM_VTKTrihedron::New();
+ vtkPrs->AddObject( aTrh );
}
else {
- // presentation is being updated
- vtkActorCollection* actors = vtkPrs->GetObjects();
- if ( actors ) {
- actors->InitTraversal();
- vtkActor* a = actors->GetNextActor();
- while ( a && !aTrh ) {
- aTrh = GEOM_VTKTrihedron::SafeDownCast( a );
- a = actors->GetNextActor();
- }
- }
+ // presentation is being updated
+ vtkActorCollection* actors = vtkPrs->GetObjects();
+ if ( actors ) {
+ actors->InitTraversal();
+ vtkActor* a = actors->GetNextActor();
+ while ( a && !aTrh ) {
+ aTrh = GEOM_VTKTrihedron::SafeDownCast( a );
+ a = actors->GetNextActor();
+ }
+ }
}
if ( aTrh ) {
- // predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
- if ( HasColor() ) {
- Quantity_Color aColor( (Quantity_NameOfColor)GetColor() );
- aTrh->SetColor( aColor.Red(), aColor.Green(), aColor.Blue() );
- }
+ // predefined color, manually set to displayer via GEOM_Displayer::SetColor() function
+ if ( HasColor() ) {
+ Quantity_Color aColor( (Quantity_NameOfColor)GetColor() );
+ aTrh->SetColor( aColor.Red(), aColor.Green(), aColor.Blue() );
+ }
#ifdef VTK_TRIHEDRON_WIDTH
- //
- // VSR: currently isn't supported
- //
- // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
+ //
+ // VSR: currently isn't supported
+ //
+ // predefined line width, manually set to displayer via GEOM_Displayer::SetLineWidth() function
if ( HasWidth() )
aTrh->SetWidth( GetWidth() );
#endif
if ( !myIO.IsNull() )
- aTrh->setIO( myIO );
+ aTrh->setIO( myIO );
- aTrh->SetPlacement( aPlc );
+ aTrh->SetPlacement( aPlc );
}
}
}
// presentation is being updated
vtkActorCollection* actors = vtkPrs->GetObjects();
if ( actors ) {
- actors->InitTraversal();
- vtkActor* a = actors->GetNextActor();
- while ( a ) {
- GEOM_Actor* actor = GEOM_Actor::SafeDownCast( a );
- if ( actor ) {
- // update actor properties
- updateActorProperties( actor, false );
- a = actors->GetNextActor();
- }
- }
+ actors->InitTraversal();
+ vtkActor* a = actors->GetNextActor();
+ while ( a ) {
+ GEOM_Actor* actor = GEOM_Actor::SafeDownCast( a );
+ if ( actor ) {
+ // update actor properties
+ updateActorProperties( actor, false );
+ a = actors->GetNextActor();
+ }
+ }
}
}
}
CORBA::Object_var object = GeometryGUI::ClientSObjectToObject(SO);
if ( !CORBA::is_nil( object ) )
{
- // downcast to GEOM object
- GEOM::GEOM_Object_var GeomObject = GEOM::GEOM_Object::_narrow( object );
- if ( !GeomObject->_is_nil() )
+ // downcast to GEOM base object
+ GEOM::GEOM_BaseObject_var GeomBaseObject = GEOM::GEOM_BaseObject::_narrow( object );
+ if ( !GeomBaseObject->_is_nil() )
{
- // finally set shape
- setShape( GEOM_Client::get_client().GetShape( GeometryGUI::GetGeomGen(), GeomObject ) );
- myType = GeomObject->GetType();
+ myType = GeomBaseObject->GetType();
+
+ // downcast to GEOM object
+ GEOM::GEOM_Object_var GeomObject = GEOM::GEOM_Object::_narrow( GeomBaseObject );
+ if ( myType == GEOM_FIELD_STEP )
+ {
+ // get the GEOM object from the field's shape
+ GEOM::GEOM_FieldStep_var GeomFieldStep = GEOM::GEOM_FieldStep::_narrow( GeomBaseObject );
+ if ( !GeomFieldStep->_is_nil() )
+ {
+ GEOM::GEOM_Field_var GeomField = GeomFieldStep->GetField();
+ if ( !GeomField->_is_nil() )
+ GeomObject = GeomField->GetShape();
+ }
+
+ // read the field step information
+ readFieldStepInfo( GeomFieldStep );
+ }
+
+ if ( !GeomObject->_is_nil() )
+ {
+ // finally set shape
+ setShape( GEOM_Client::get_client().GetShape( GeometryGUI::GetGeomGen(), GeomObject ) );
+ }
}
}
}
{
myIO.Nullify();
myShape.Nullify();
+
+ myFieldDataType = GEOM::FDT_Double;
+ myFieldDimension = 0;
+ myFieldStepData.clear();
+ myFieldStepName.Clear();
+ myFieldStepRangeMin = 0;
+ myFieldStepRangeMax = 0;
}
//=================================================================
}
}
}
+ UpdateColorScale(false,false);
+}
+
+void GEOM_Displayer::AfterErase( SALOME_View* v, const SALOME_OCCPrs* p )
+{
+ LightApp_Displayer::AfterErase( v, p );
+ UpdateColorScale(false,false);
}
//=================================================================
myShape = theShape;
}
+void GEOM_Displayer::setFieldStepInfo( const GEOM::field_data_type theFieldDataType,
+ const int theFieldDimension,
+ const QList<QVariant>& theFieldStepData,
+ const TCollection_AsciiString& theFieldStepName,
+ const double theFieldStepRangeMin,
+ const double theFieldStepRangeMax )
+{
+ myFieldDataType = theFieldDataType;
+ myFieldDimension = theFieldDimension;
+ myFieldStepData = theFieldStepData;
+ myFieldStepName = theFieldStepName;
+ myFieldStepRangeMin = theFieldStepRangeMin;
+ myFieldStepRangeMax = theFieldStepRangeMax;
+}
+
bool GEOM_Displayer::canBeDisplayed( const QString& entry, const QString& viewer_type ) const
{
- return viewer_type == SOCC_Viewer::Type() || viewer_type == SVTK_Viewer::Type();
+ _PTR(SObject) anObj = getStudy()->studyDS()->FindObjectID( (const char*)entry.toLatin1() );
+ GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(GeometryGUI::ClientSObjectToObject(anObj)); // enable displaying of GEOM objects
+ GEOM::GEOM_FieldStep_var aFieldStepObj = GEOM::GEOM_FieldStep::_narrow(GeometryGUI::ClientSObjectToObject(anObj)); // enable displaying of GEOM field steps
+ GEOM::GEOM_Gen_var aCompObj = GEOM::GEOM_Gen::_narrow(GeometryGUI::ClientSObjectToObject(anObj)); // enable displaying of whole GEOM component
+ return ( !CORBA::is_nil( aGeomObj ) || !CORBA::is_nil( aFieldStepObj ) || !CORBA::is_nil( aCompObj ) ) &&
+ (viewer_type == SOCC_Viewer::Type() || viewer_type == SVTK_Viewer::Type());
}
int GEOM_Displayer::SetDisplayMode( const int theMode )
}
PropMap GEOM_Displayer::getObjectProperties( SalomeApp_Study* study,
- const QString& entry,
- SALOME_View* view )
+ const QString& entry,
+ SALOME_View* view )
{
// get default properties for the explicitly specified default view type
PropMap propMap = GEOM_Displayer::getDefaultPropertyMap();
PropMap storedMap = study->getObjectPropMap( viewId, entry );
// overwrite default properties from stored ones (that are specified)
for ( int prop = GEOM::Visibility; prop <= GEOM::LastProperty; prop++ ) {
- if ( storedMap.contains( GEOM::propertyName( (GEOM::Property)prop ) ) )
- propMap.insert( GEOM::propertyName( (GEOM::Property)prop ),
- storedMap.value( GEOM::propertyName( (GEOM::Property)prop ) ) );
+ if ( storedMap.contains( GEOM::propertyName( (GEOM::Property)prop ) ) )
+ propMap.insert( GEOM::propertyName( (GEOM::Property)prop ),
+ storedMap.value( GEOM::propertyName( (GEOM::Property)prop ) ) );
}
// ... specific processing for color
// ... current implementation is to use same stored color for all aspects
// ... (TODO) possible future improvements about free boundaries, standalone edges etc colors can be here
if ( storedMap.contains( GEOM::propertyName( GEOM::Color ) ) ) {
- propMap.insert( GEOM::propertyName( GEOM::ShadingColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
- propMap.insert( GEOM::propertyName( GEOM::WireframeColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
- propMap.insert( GEOM::propertyName( GEOM::LineColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
- propMap.insert( GEOM::propertyName( GEOM::FreeBndColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
- propMap.insert( GEOM::propertyName( GEOM::PointColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
+ propMap.insert( GEOM::propertyName( GEOM::ShadingColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
+ propMap.insert( GEOM::propertyName( GEOM::WireframeColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
+ propMap.insert( GEOM::propertyName( GEOM::LineColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
+ propMap.insert( GEOM::propertyName( GEOM::FreeBndColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
+ propMap.insert( GEOM::propertyName( GEOM::PointColor ), storedMap.value( GEOM::propertyName( GEOM::Color ) ) );
}
if ( !entry.isEmpty() ) {
- // get CORBA reference to geom object
- _PTR(SObject) SO( study->studyDS()->FindObjectID( entry.toStdString() ) );
- if ( SO ) {
- CORBA::Object_var object = GeometryGUI::ClientSObjectToObject( SO );
- if ( !CORBA::is_nil( object ) ) {
- GEOM::GEOM_Object_var geomObject = GEOM::GEOM_Object::_narrow( object );
- // check that geom object has color properly set
- bool hasColor = false;
- SALOMEDS::Color aSColor = getColor( geomObject, hasColor );
- // set color from geometry object (only once, if it is not yet set in GUI)
- // current implementation is to use same color for all aspects
- // (TODO) possible future improvements about free boundaries, standalone edges etc colors can be here
- if ( hasColor && !storedMap.contains( GEOM::propertyName( GEOM::Color ) ) ) {
- QColor objColor = QColor::fromRgbF( aSColor.R, aSColor.G, aSColor.B );
- propMap.insert( GEOM::propertyName( GEOM::ShadingColor ), objColor );
- propMap.insert( GEOM::propertyName( GEOM::WireframeColor ), objColor );
- propMap.insert( GEOM::propertyName( GEOM::LineColor ), objColor );
- propMap.insert( GEOM::propertyName( GEOM::FreeBndColor ), objColor );
- propMap.insert( GEOM::propertyName( GEOM::PointColor ), objColor );
- }
- // check that object has point marker properly set
- GEOM::marker_type mType = geomObject->GetMarkerType();
- GEOM::marker_size mSize = geomObject->GetMarkerSize();
- int mTextureId = geomObject->GetMarkerTexture();
- bool hasMarker = ( mType > GEOM::MT_NONE && mType < GEOM::MT_USER && mSize > GEOM::MS_NONE && mSize <= GEOM::MS_70 ) ||
- ( mType == GEOM::MT_USER && mTextureId > 0 );
- // set point marker from geometry object (only once, if it is not yet set in GUI)
- if ( hasMarker && !storedMap.contains( GEOM::propertyName( GEOM::PointMarker ) ) ) {
- if ( mType > GEOM::MT_NONE && mType < GEOM::MT_USER ) {
- // standard type
- propMap.insert( GEOM::propertyName( GEOM::PointMarker ),
- QString( "%1%2%3" ).arg( (int)mType ).arg( GEOM::subSectionSeparator() ).arg( (int)mSize ) );
- }
- else if ( mType == GEOM::MT_USER ) {
- // custom texture
- propMap.insert( GEOM::propertyName( GEOM::PointMarker ), QString::number( mTextureId ) );
- }
- }
- }
- }
+ // get CORBA reference to geom object
+ _PTR(SObject) SO( study->studyDS()->FindObjectID( entry.toStdString() ) );
+ if ( SO ) {
+ CORBA::Object_var object = GeometryGUI::ClientSObjectToObject( SO );
+ if ( !CORBA::is_nil( object ) ) {
+ GEOM::GEOM_Object_var geomObject = GEOM::GEOM_Object::_narrow( object );
+ if ( !CORBA::is_nil( geomObject ) ) { // to check
+ // check that geom object has color properly set
+ bool hasColor = false;
+ SALOMEDS::Color aSColor = getColor( geomObject, hasColor );
+ // set color from geometry object (only once, if it is not yet set in GUI)
+ // current implementation is to use same color for all aspects
+ // (TODO) possible future improvements about free boundaries, standalone edges etc colors can be here
+ if ( hasColor && !storedMap.contains( GEOM::propertyName( GEOM::Color ) ) ) {
+ QColor objColor = QColor::fromRgbF( aSColor.R, aSColor.G, aSColor.B );
+ propMap.insert( GEOM::propertyName( GEOM::ShadingColor ), objColor );
+ propMap.insert( GEOM::propertyName( GEOM::WireframeColor ), objColor );
+ propMap.insert( GEOM::propertyName( GEOM::LineColor ), objColor );
+ propMap.insert( GEOM::propertyName( GEOM::FreeBndColor ), objColor );
+ propMap.insert( GEOM::propertyName( GEOM::PointColor ), objColor );
+ }
+ // check that object has point marker properly set
+ GEOM::marker_type mType = geomObject->GetMarkerType();
+ GEOM::marker_size mSize = geomObject->GetMarkerSize();
+ int mTextureId = geomObject->GetMarkerTexture();
+ bool hasMarker = ( mType > GEOM::MT_NONE && mType < GEOM::MT_USER && mSize > GEOM::MS_NONE && mSize <= GEOM::MS_70 ) ||
+ ( mType == GEOM::MT_USER && mTextureId > 0 );
+ // set point marker from geometry object (only once, if it is not yet set in GUI)
+ if ( hasMarker && !storedMap.contains( GEOM::propertyName( GEOM::PointMarker ) ) ) {
+ if ( mType > GEOM::MT_NONE && mType < GEOM::MT_USER ) {
+ // standard type
+ propMap.insert( GEOM::propertyName( GEOM::PointMarker ),
+ QString( "%1%2%3" ).arg( (int)mType ).arg( GEOM::subSectionSeparator() ).arg( (int)mSize ) );
+ }
+ else if ( mType == GEOM::MT_USER ) {
+ // custom texture
+ propMap.insert( GEOM::propertyName( GEOM::PointMarker ), QString::number( mTextureId ) );
+ }
+ }
+ }
+ }
+ }
}
}
}
// - nb isos (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::NbIsos ),
- QString( "%1%2%3" ).
- arg( resMgr->integerValue( "Geometry", "iso_number_u", 1 ) ).
- arg( GEOM::subSectionSeparator() ).
- arg( resMgr->integerValue( "Geometry", "iso_number_v", 1 ) ) );
+ QString( "%1%2%3" ).
+ arg( resMgr->integerValue( "Geometry", "iso_number_u", 1 ) ).
+ arg( GEOM::subSectionSeparator() ).
+ arg( resMgr->integerValue( "Geometry", "iso_number_v", 1 ) ) );
// - transparency (opacity = 1-transparency)
propMap.insert( GEOM::propertyName( GEOM::Transparency ), 0.0 );
// - display mode (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::DisplayMode ),
- resMgr->integerValue( "Geometry", "display_mode", 0 ) );
+ resMgr->integerValue( "Geometry", "display_mode", 0 ) );
// - show edges direction flag (false by default)
propMap.insert( GEOM::propertyName( GEOM::EdgesDirection ), false );
// - shading color (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::ShadingColor ),
- colorFromResources( "shading_color", QColor( 255, 255, 0 ) ) );
+ colorFromResources( "shading_color", QColor( 255, 255, 0 ) ) );
// - wireframe color (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::WireframeColor ),
- colorFromResources( "wireframe_color", QColor( 255, 255, 0 ) ) );
+ colorFromResources( "wireframe_color", QColor( 255, 255, 0 ) ) );
// - standalone edges color (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::LineColor ),
- colorFromResources( "line_color", QColor( 255, 0, 0 ) ) );
+ colorFromResources( "line_color", QColor( 255, 0, 0 ) ) );
// - free boundaries color (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::FreeBndColor ),
- colorFromResources( "free_bound_color", QColor( 0, 255, 0 ) ) );
+ colorFromResources( "free_bound_color", QColor( 0, 255, 0 ) ) );
// - points color (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::PointColor ),
- colorFromResources( "point_color", QColor( 255, 255, 0 ) ) );
+ colorFromResources( "point_color", QColor( 255, 255, 0 ) ) );
// - isos color (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::IsosColor ),
- colorFromResources( "isos_color", QColor( 200, 200, 200 ) ) );
+ colorFromResources( "isos_color", QColor( 200, 200, 200 ) ) );
// - outlines color (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::OutlineColor ),
- colorFromResources( "edges_in_shading_color", QColor( 180, 180, 180 ) ) );
+ colorFromResources( "edges_in_shading_color", QColor( 180, 180, 180 ) ) );
// - deflection coefficient (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::Deflection ),
- resMgr->doubleValue( "Geometry", "deflection_coeff", 0.001 ) );
+ resMgr->doubleValue( "Geometry", "deflection_coeff", 0.001 ) );
// - material (take default value from preferences)
Material_Model material;
// - edge width (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::LineWidth ),
- resMgr->integerValue( "Geometry", "edge_width", 1 ) );
+ resMgr->integerValue( "Geometry", "edge_width", 1 ) );
// - isos width (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::IsosWidth ),
- resMgr->integerValue( "Geometry", "isolines_width", 1 ) );
+ resMgr->integerValue( "Geometry", "isolines_width", 1 ) );
// - point marker (take default value from preferences)
propMap.insert( GEOM::propertyName( GEOM::PointMarker ),
- QString( "%1%2%3" ).
- arg( resMgr->integerValue( "Geometry", "type_of_marker", 1 ) + 1 ).
- arg( GEOM::subSectionSeparator() ).
- arg( resMgr->integerValue( "Geometry", "marker_scale", 1 ) ) );
+ QString( "%1%2%3" ).
+ arg( resMgr->integerValue( "Geometry", "type_of_marker", 1 ) + 1 ).
+ arg( GEOM::subSectionSeparator() ).
+ arg( resMgr->integerValue( "Geometry", "marker_scale", 1 ) ) );
// - top-level flag (false by default)
propMap.insert( GEOM::propertyName( GEOM::TopLevel ), false );
hasColor = aSColor.R >= 0 && aSColor.G >= 0 && aSColor.B >= 0;
if ( !hasColor ) {
#ifdef GENERAL_AUTOCOLOR // auto-color for all sub-shapes
- bool general_autocolor = true;
+ bool general_autocolor = true;
#else // auto-color for groups only
- bool general_autocolor = false;
+ bool general_autocolor = false;
#endif // GENERAL_AUTOCOLOR
- if ( general_autocolor || theGeomObject->GetType() == GEOM_GROUP ) {
- GEOM::GEOM_Object_var aMainObject = theGeomObject->GetMainShape();
- if ( !CORBA::is_nil( aMainObject ) && aMainObject->GetAutoColor() ) {
+ if ( general_autocolor || theGeomObject->GetType() == GEOM_GROUP ) {
+ GEOM::GEOM_Object_var aMainObject = theGeomObject->GetMainShape();
+ if ( !CORBA::is_nil( aMainObject ) && aMainObject->GetAutoColor() ) {
#ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
- aSColor = getPredefinedUniqueColor();
- hasColor = true;
+ aSColor = getPredefinedUniqueColor();
+ hasColor = true;
#else // old algorithm for auto-colors
- QList<SALOMEDS::Color> aReservedColors;
- CORBA::String_var IOR = app->orb()->object_to_string( aMainObject );
- _PTR(SObject) aMainSObject( aStudy->FindObjectIOR( IOR.in() ) );
- if ( aMainSObject ) {
- _PTR(ChildIterator) it( aStudy->NewChildIterator( aMainSObject ) );
- for ( ; it->More(); it->Next() ) {
- _PTR(SObject) aChildSObject( it->Value() );
- GEOM::GEOM_Object_var aChildObject =
- GEOM::GEOM_Object::_narrow(GeometryGUI::ClientSObjectToObject(aChildSObject));
- if ( CORBA::is_nil( aChildObject ) )
- continue;
-
- SALOMEDS::Color aReservedColor = aChildObject->GetColor();
- if ( aReservedColor.R >= 0 && aReservedColor.G >= 0 && aReservedColor.B >= 0 )
- aReservedColors.append( aReservedColor );
- }
- }
- aSColor = getUniqueColor( aReservedColors );
- hasColor = true;
+ QList<SALOMEDS::Color> aReservedColors;
+ CORBA::String_var IOR = app->orb()->object_to_string( aMainObject );
+ _PTR(SObject) aMainSObject( aStudy->FindObjectIOR( IOR.in() ) );
+ if ( aMainSObject ) {
+ _PTR(ChildIterator) it( aStudy->NewChildIterator( aMainSObject ) );
+ for ( ; it->More(); it->Next() ) {
+ _PTR(SObject) aChildSObject( it->Value() );
+ GEOM::GEOM_Object_var aChildObject =
+ GEOM::GEOM_Object::_narrow(GeometryGUI::ClientSObjectToObject(aChildSObject));
+ if ( CORBA::is_nil( aChildObject ) )
+ continue;
+
+ SALOMEDS::Color aReservedColor = aChildObject->GetColor();
+ if ( aReservedColor.R >= 0 && aReservedColor.G >= 0 && aReservedColor.B >= 0 )
+ aReservedColors.append( aReservedColor );
+ }
+ }
+ aSColor = getUniqueColor( aReservedColors );
+ hasColor = true;
#endif // SIMPLE_AUTOCOLOR
- }
- }
+ }
+ }
}
}
}
view->Repaint();
}
}
+
+void GEOM_Displayer::readFieldStepInfo( GEOM::GEOM_FieldStep_var theGeomFieldStep )
+{
+ if( theGeomFieldStep->_is_nil() )
+ return;
+
+ GEOM::GEOM_Field_var aGeomField = theGeomFieldStep->GetField();
+ if( aGeomField->_is_nil() )
+ return;
+
+ GEOM::GEOM_Object_var aGeomFieldShape = aGeomField->GetShape();
+ if( aGeomFieldShape->_is_nil() )
+ return;
+
+ TCollection_AsciiString aFieldStepName( theGeomFieldStep->GetName() );
+ TCollection_AsciiString aFieldName( aGeomField->GetName() );
+ TCollection_AsciiString aShapeName( aGeomFieldShape->GetName() );
+
+ aFieldStepName = aShapeName + "\n" + aFieldName + "\n" + aFieldStepName;
+
+ GEOM::field_data_type aFieldDataType = aGeomField->GetDataType();
+
+ int aFieldDimension = aGeomField->GetDimension();
+
+ GEOM::string_array_var aFieldComponents = aGeomField->GetComponents();
+ int aFieldNbComponents = aFieldComponents->length();
+
+ QList<QVariant> aFieldStepData;
+ if( aFieldDataType == GEOM::FDT_Bool )
+ {
+ GEOM::GEOM_BoolFieldStep_var aGeomBoolFieldStep = GEOM::GEOM_BoolFieldStep::_narrow( theGeomFieldStep );
+ if ( !aGeomBoolFieldStep->_is_nil() )
+ {
+ GEOM::short_array_var aValues = aGeomBoolFieldStep->GetValues();
+ for( size_t i = 0, n = aValues->length(); i < n; i++ )
+ aFieldStepData << (bool)aValues[i];
+ }
+ }
+ else if( aFieldDataType == GEOM::FDT_Int )
+ {
+ GEOM::GEOM_IntFieldStep_var aGeomIntFieldStep = GEOM::GEOM_IntFieldStep::_narrow( theGeomFieldStep );
+ if ( !aGeomIntFieldStep->_is_nil() )
+ {
+ GEOM::ListOfLong_var aValues = aGeomIntFieldStep->GetValues();
+ for( size_t i = 0, n = aValues->length(); i < n; i++ )
+ aFieldStepData << (qlonglong)aValues[i];
+ }
+ }
+ else if( aFieldDataType == GEOM::FDT_Double )
+ {
+ GEOM::GEOM_DoubleFieldStep_var aGeomDoubleFieldStep = GEOM::GEOM_DoubleFieldStep::_narrow( theGeomFieldStep );
+ if ( !aGeomDoubleFieldStep->_is_nil() )
+ {
+ GEOM::ListOfDouble_var aValues = aGeomDoubleFieldStep->GetValues();
+ for( size_t i = 0, n = aValues->length(); i < n; i++ )
+ aFieldStepData << (double)aValues[i];
+ }
+ }
+ else if( aFieldDataType == GEOM::FDT_String )
+ {
+ GEOM::GEOM_StringFieldStep_var aGeomStringFieldStep = GEOM::GEOM_StringFieldStep::_narrow( theGeomFieldStep );
+ if ( !aGeomStringFieldStep->_is_nil() )
+ {
+ GEOM::string_array_var aValues = aGeomStringFieldStep->GetValues();
+ for( size_t i = 0, n = aValues->length(); i < n; i++ )
+ aFieldStepData << QString( aValues[i] );
+ }
+ }
+
+ double aFieldStepRangeMin = 0, aFieldStepRangeMax = 0;
+ aFieldStepData = groupFieldData( aFieldStepData,
+ aFieldNbComponents,
+ aFieldDataType == GEOM::FDT_String,
+ aFieldStepRangeMin,
+ aFieldStepRangeMax );
+
+ setFieldStepInfo( aFieldDataType,
+ aFieldDimension,
+ aFieldStepData,
+ aFieldStepName,
+ aFieldStepRangeMin,
+ aFieldStepRangeMax );
+}
+
+QList<QVariant> GEOM_Displayer::groupFieldData( const QList<QVariant>& theFieldStepData,
+ const int theFieldNbComponents,
+ const bool theIsString,
+ double& theFieldStepRangeMin,
+ double& theFieldStepRangeMax )
+{
+ QList<QVariant> aResultList;
+ theFieldStepRangeMin = 0;
+ theFieldStepRangeMax = 0;
+
+ if( theFieldStepData.isEmpty() || theFieldNbComponents < 1 )
+ return aResultList;
+
+ int aNbSubShapes = theFieldStepData.count() / theFieldNbComponents;
+
+ QList<QVariant> aGroupedList;
+
+ bool anIsBoolean = false;
+ for( int aSubShape = 0; aSubShape < aNbSubShapes; aSubShape++ )
+ {
+ double aNorm = 0;
+ QStringList aStringList;
+
+ int aBaseIndex = aSubShape * theFieldNbComponents;
+ for( int aComponent = 0; aComponent < theFieldNbComponents; aComponent++ )
+ {
+ int anIndex = aComponent + aBaseIndex;
+
+ const QVariant& aVariant = theFieldStepData[ anIndex ];
+ if( theIsString )
+ {
+ if( aVariant.type() == QVariant::String )
+ aStringList << aVariant.toString();
+ }
+ else
+ {
+ double aValue = 0;
+ if( aVariant.type() == QVariant::Bool )
+ {
+ aValue = aVariant.toBool() ? 1.0 : 0.0;
+ aNorm += aValue;
+ anIsBoolean = true;
+ }
+ else
+ {
+ if( aVariant.type() == QVariant::Int )
+ aValue = double( aVariant.toInt() );
+ else if( aVariant.type() == QVariant::Double )
+ aValue = aVariant.toDouble();
+ aNorm += aValue * aValue;
+ }
+ }
+ }
+
+ if( theIsString )
+ aGroupedList << aStringList.join( "\n" );
+ else
+ {
+ if( anIsBoolean )
+ aNorm /= theFieldNbComponents;
+ else
+ aNorm = pow( aNorm, 0.5 );
+
+ if( aGroupedList.isEmpty() )
+ theFieldStepRangeMin = theFieldStepRangeMax = aNorm;
+ else
+ {
+ theFieldStepRangeMin = Min( theFieldStepRangeMin, aNorm );
+ theFieldStepRangeMax = Max( theFieldStepRangeMax, aNorm );
+ }
+
+ aGroupedList << aNorm;
+ }
+ }
+
+ if( anIsBoolean )
+ {
+ theFieldStepRangeMin = 0.0;
+ theFieldStepRangeMax = 1.0;
+ }
+
+ SUIT_Session* session = SUIT_Session::session();
+ SUIT_ResourceMgr* resMgr = session->resourceMgr();
+ Standard_Integer aNbIntervals = resMgr->integerValue( "Geometry", "scalar_bar_nb_intervals", 20 );
+
+ QListIterator<QVariant> anIter( aGroupedList );
+ while( anIter.hasNext() )
+ {
+ const QVariant& aVariant = anIter.next();
+ if( theIsString )
+ aResultList << aVariant;
+ else
+ {
+ QColor aQColor;
+ Quantity_Color aColor;
+ if( FindColor( aVariant.toDouble(), theFieldStepRangeMin, theFieldStepRangeMax, anIsBoolean ? 2 : aNbIntervals, aColor ) )
+ aQColor = QColor::fromRgbF( aColor.Red(), aColor.Green(), aColor.Blue() );
+ aResultList << aQColor;
+ }
+ }
+ return aResultList;
+}
+
+// Note: the method is copied from Aspect_ColorScale class
+Standard_Integer GEOM_Displayer::HueFromValue( const Standard_Integer aValue,
+ const Standard_Integer aMin,
+ const Standard_Integer aMax )
+{
+ Standard_Integer minLimit( 0 ), maxLimit( 230 );
+
+ Standard_Integer aHue = maxLimit;
+ if ( aMin != aMax )
+ aHue = (Standard_Integer)( maxLimit - ( maxLimit - minLimit ) * ( aValue - aMin ) / ( aMax - aMin ) );
+
+ aHue = Min( Max( minLimit, aHue ), maxLimit );
+
+ return aHue;
+}
+
+// Note: the method is copied from Aspect_ColorScale class
+Standard_Boolean GEOM_Displayer::FindColor( const Standard_Real aValue,
+ const Standard_Real aMin,
+ const Standard_Real aMax,
+ const Standard_Integer ColorsCount,
+ Quantity_Color& aColor )
+{
+ if( aValue<aMin || aValue>aMax || aMax<aMin )
+ return Standard_False;
+
+ else
+ {
+ Standard_Real IntervNumber = 0;
+ if( aValue<aMin )
+ IntervNumber = 0;
+ else if( aValue>aMax )
+ IntervNumber = ColorsCount-1;
+ else if( Abs( aMax-aMin ) > Precision::Approximation() )
+ IntervNumber = Floor( Standard_Real( ColorsCount ) * ( aValue - aMin ) / ( aMax - aMin ) ); // 'Ceiling' replaced with 'Floor'
+
+ Standard_Integer Interv = Standard_Integer( IntervNumber );
+
+ aColor = Quantity_Color( HueFromValue( Interv, 0, ColorsCount - 1 ), 1.0, 1.0, Quantity_TOC_HLS );
+
+ return Standard_True;
+ }
+}
+
+void GEOM_Displayer::UpdateColorScale( const bool theIsRedisplayFieldSteps, const bool updateViewer )
+{
+ SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( myApp->activeStudy() );
+ if( !aStudy )
+ return;
+
+ SOCC_Viewer* aViewModel = dynamic_cast<SOCC_Viewer*>( GetActiveView() );
+ if( !aViewModel )
+ return;
+
+ Handle(V3d_Viewer) aViewer = aViewModel->getViewer3d();
+ if( aViewer.IsNull() )
+ return;
+
+ aViewer->InitActiveViews();
+ if( !aViewer->MoreActiveViews() )
+ return;
+
+ Handle(V3d_View) aView = aViewer->ActiveView();
+ if( aView.IsNull() )
+ return;
+
+ Standard_Boolean anIsDisplayColorScale = Standard_False;
+ TCollection_AsciiString aColorScaleTitle;
+ Standard_Real aColorScaleMin = 0, aColorScaleMax = 0;
+ Standard_Boolean anIsBoolean = Standard_False;
+
+ SALOME_ListIO aSelectedObjects;
+ myApp->selectionMgr()->selectedObjects( aSelectedObjects );
+ if( aSelectedObjects.Extent() == 1 )
+ {
+ Handle(SALOME_InteractiveObject) anIO = aSelectedObjects.First();
+ if( !anIO.IsNull() )
+ {
+ SOCC_Prs* aPrs = dynamic_cast<SOCC_Prs*>( aViewModel->CreatePrs( anIO->getEntry() ) );
+ if( aPrs )
+ {
+ AIS_ListOfInteractive aList;
+ aPrs->GetObjects( aList );
+ AIS_ListIteratorOfListOfInteractive anIter( aList );
+ for( ; anIter.More(); anIter.Next() )
+ {
+ Handle(GEOM_AISShape) aShape = Handle(GEOM_AISShape)::DownCast( anIter.Value() );
+ if( !aShape.IsNull() )
+ {
+ GEOM::field_data_type aFieldDataType;
+ int aFieldDimension;
+ QList<QVariant> aFieldStepData;
+ TCollection_AsciiString aFieldStepName;
+ double aFieldStepRangeMin, aFieldStepRangeMax;
+ aShape->getFieldStepInfo( aFieldDataType,
+ aFieldDimension,
+ aFieldStepData,
+ aFieldStepName,
+ aFieldStepRangeMin,
+ aFieldStepRangeMax );
+ if( !aFieldStepData.isEmpty() && aFieldDataType != GEOM::FDT_String )
+ {
+ anIsDisplayColorScale = Standard_True;
+ aColorScaleTitle = aFieldStepName;
+ aColorScaleMin = aFieldStepRangeMin;
+ aColorScaleMax = aFieldStepRangeMax;
+ anIsBoolean = aFieldDataType == GEOM::FDT_Bool;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if( anIsDisplayColorScale )
+ {
+ Handle(Aspect_ColorScale) aColorScale = aView->ColorScale();
+ if( !aColorScale.IsNull() )
+ {
+ SUIT_Session* session = SUIT_Session::session();
+ SUIT_ResourceMgr* resMgr = session->resourceMgr();
+
+ Standard_Real anXPos = resMgr->doubleValue( "Geometry", "scalar_bar_x_position", 0.05 );
+ Standard_Real anYPos = resMgr->doubleValue( "Geometry", "scalar_bar_y_position", 0.1 );
+ Standard_Real aWidth = resMgr->doubleValue( "Geometry", "scalar_bar_width", 0.2 );
+ Standard_Real aHeight = resMgr->doubleValue( "Geometry", "scalar_bar_height", 0.5 );
+ Standard_Integer aTextHeight = resMgr->integerValue( "Geometry", "scalar_bar_text_height", 14 );
+ Standard_Integer aNbIntervals = resMgr->integerValue( "Geometry", "scalar_bar_nb_intervals", 20 );
+
+ aColorScale->SetXPosition( anXPos );
+ aColorScale->SetYPosition( anYPos );
+ aColorScale->SetWidth( aWidth );
+ aColorScale->SetHeight( aHeight );
+
+ aColorScale->SetTextHeight( aTextHeight );
+ aColorScale->SetNumberOfIntervals( anIsBoolean ? 2 : aNbIntervals );
+
+ aColorScale->SetTitle( aColorScaleTitle );
+ aColorScale->SetRange( aColorScaleMin, aColorScaleMax );
+ }
+ if( !aView->ColorScaleIsDisplayed() )
+ aView->ColorScaleDisplay();
+ }
+ else
+ {
+ if( aView->ColorScaleIsDisplayed() )
+ aView->ColorScaleErase();
+ }
+
+ if( theIsRedisplayFieldSteps )
+ {
+ _PTR(Study) aStudyDS = aStudy->studyDS();
+ QList<SUIT_ViewManager*> vmList;
+ myApp->viewManagers( vmList );
+ for( QList<SUIT_ViewManager*>::Iterator vmIt = vmList.begin(); vmIt != vmList.end(); vmIt++ )
+ {
+ if( SUIT_ViewManager* aViewManager = *vmIt )
+ {
+ const ObjMap anObjects = aStudy->getObjectMap( aViewManager->getGlobalId() );
+ for( ObjMap::ConstIterator objIt = anObjects.begin(); objIt != anObjects.end(); objIt++ )
+ {
+ _PTR(SObject) aSObj( aStudyDS->FindObjectID( objIt.key().toLatin1().constData() ) );
+ if( aSObj )
+ {
+ CORBA::Object_var anObject = GeometryGUI::ClientSObjectToObject( aSObj );
+ if( !CORBA::is_nil( anObject ) )
+ {
+ GEOM::GEOM_FieldStep_var aFieldStep = GEOM::GEOM_FieldStep::_narrow( anObject );
+ if( !aFieldStep->_is_nil() )
+ {
+ CORBA::String_var aStepEntry = aFieldStep->GetStudyEntry();
+ Handle(SALOME_InteractiveObject) aStepIO =
+ new SALOME_InteractiveObject( aStepEntry.in(), "GEOM", "TEMP_IO" );
+ Redisplay( aStepIO, false, false );
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if(updateViewer)
+ UpdateViewer();
+}
