aMap->SetReal( theType, theCoefficient );
}
+void HYDROData_StricklerTable::GetCoefficientRange( double& theMin, double& theMax ) const
+{
+ theMin = 0;
+ theMax = 0;
+
+ Handle(TDataStd_NamedData) aMap = Map();
+ Standard_Boolean isFirst = Standard_True;
+ for ( TDataStd_DataMapIteratorOfDataMapOfStringReal it( aMap->GetRealsContainer() ); it.More(); it.Next() ) {
+ Standard_Real aValue = it.Value();
+ if ( theMin == 0 || aValue < theMin ) {
+ theMin = aValue;
+ }
+ if ( theMax == 0 || aValue > theMax ) {
+ theMax = aValue;
+ }
+ }
+}
+
TColStd_SequenceOfExtendedString HYDROData_StricklerTable::GetTypes() const
{
TColStd_SequenceOfExtendedString aSeq;
return aSeq;
}
+bool HYDROData_StricklerTable::HasType( const TCollection_ExtendedString& theType ) const
+{
+ Handle(TDataStd_NamedData) aMap = Map();
+
+ return !aMap.IsNull() && aMap->HasReal( theType );
+}
+
void HYDROData_StricklerTable::Clear()
{
Handle(TDataStd_NamedData) aMap = Map();
HYDRODATA_EXPORT double Get( const TCollection_ExtendedString& theType, double theDefault ) const;
HYDRODATA_EXPORT void Set( const TCollection_ExtendedString& theType, double theCoefficient );
+ HYDRODATA_EXPORT void GetCoefficientRange( double& theMin, double& theMax ) const;
+
HYDRODATA_EXPORT TColStd_SequenceOfExtendedString GetTypes() const;
+ HYDRODATA_EXPORT bool HasType( const TCollection_ExtendedString& theType ) const;
+
HYDRODATA_EXPORT void Clear();
HYDRODATA_EXPORT virtual QStringList DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const;
HYDROGUI_ObjListBox.h
HYDROGUI_RecognizeContoursDlg.h
HYDROGUI_RecognizeContoursOp.h
+ HYDROGUI_LandCoverColoringOp.h
)
QT4_WRAP_CPP(PROJECT_HEADERS_MOC ${PROJECT_HEADERS})
HYDROGUI_ObjListBox.cxx
HYDROGUI_RecognizeContoursDlg.cxx
HYDROGUI_RecognizeContoursOp.cxx
+ HYDROGUI_LandCoverColoringOp.cxx
)
add_definitions(
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// 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.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "HYDROGUI_LandCoverColoringOp.h"
+
+#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OCCDisplayer.h"
+#include "HYDROGUI_Operations.h"
+#include "HYDROGUI_Tool.h"
+#include "HYDROGUI_UpdateFlags.h"
+
+#include <HYDROData_Iterator.h>
+#include <HYDROData_Bathymetry.h>
+#include <HYDROData_StricklerTable.h>
+
+#include <LightApp_Application.h>
+
+#include <OCCViewer_ViewModel.h>
+#include <OCCViewer_ViewManager.h>
+
+
+HYDROGUI_LandCoverColoringOp::HYDROGUI_LandCoverColoringOp( HYDROGUI_Module* theModule, int theId )
+: HYDROGUI_Operation( theModule ),
+ myId( theId )
+{
+ QString aName;
+ switch( myId )
+ {
+ case LandCoverScalarMapModeOnId: aName = tr( "LC_SCALARMAP_COLORING_ON" ); break;
+ case LandCoverScalarMapModeOffId: aName = tr( "LC_SCALARMAP_COLORING_OFF" ); break;
+ default: break;
+ }
+ setName( aName );
+}
+
+HYDROGUI_LandCoverColoringOp::~HYDROGUI_LandCoverColoringOp()
+{
+}
+
+void HYDROGUI_LandCoverColoringOp::startOperation()
+{
+ HYDROGUI_Operation::startOperation();
+
+ HYDROGUI_Module* aModule = module();
+
+ LightApp_Application* anApp = module()->getApp();
+ OCCViewer_ViewManager* aViewManager =
+ dynamic_cast<OCCViewer_ViewManager*>( anApp->getViewManager( OCCViewer_Viewer::Type(), true ) );
+
+ size_t aViewId = (size_t)aViewManager->getViewModel();
+
+ Handle(HYDROData_StricklerTable) aTable;
+
+ if ( myId == LandCoverScalarMapModeOnId ) {
+ aTable = Handle(HYDROData_StricklerTable)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) );
+ if ( !aTable.IsNull() ) {
+ aModule->setLandCoverColoringTable( aViewId, aTable );
+ }
+ } else if ( myId == LandCoverScalarMapModeOffId ) {
+ aModule->setLandCoversScalarMapModeOff( aViewId );
+ }
+
+ // Hide bathymetries
+ HYDROData_Iterator anIterator( doc(), KIND_BATHYMETRY );
+ for( ; anIterator.More(); anIterator.Next() ) {
+ Handle(HYDROData_Bathymetry) aBath =
+ Handle(HYDROData_Bathymetry)::DownCast( anIterator.Current() );
+ if ( !aBath.IsNull() && aModule->isObjectVisible( aViewId, aBath ) ) {
+ aModule->setObjectVisible( aViewId, aBath, false );
+ }
+ }
+
+ aModule->getOCCDisplayer()->SetToUpdateColorScale();
+ aModule->update( UF_OCCViewer );
+ commit();
+}
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// 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.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef HYDROGUI_LandCoverColoringOp_H
+#define HYDROGUI_LandCoverColoringOp_H
+
+#include "HYDROGUI_Operation.h"
+
+/**
+ * \class HYDROGUI_LandCoverColoringOp
+ * \brief The class intended for scalar map coloring of Land Covers
+ */
+class HYDROGUI_LandCoverColoringOp : public HYDROGUI_Operation
+{
+ Q_OBJECT
+
+public:
+
+ HYDROGUI_LandCoverColoringOp( HYDROGUI_Module* theModule, int theId );
+ virtual ~HYDROGUI_LandCoverColoringOp();
+
+protected:
+ virtual void startOperation();
+
+private:
+ int myId;
+};
+
+#endif
#include <HYDROData_Profile.h>
#include <HYDROData_Lambert93.h>
#include <HYDROData_Polyline3D.h>
+#include <HYDROData_StricklerTable.h>
#include <HYDROData_OperationsFactory.h>
}
if ( !anIsObjectCanBeColored )
- anIsObjectCanBeColored = HYDROGUI_SetColorOp::CanObjectBeColored( anObject );
+ anIsObjectCanBeColored = HYDROGUI_SetColorOp::CanObjectBeColored( anObject, this );
}
// Check if all selected objects are profiles
theMenu->addAction( action( ExportStricklerTableFromFileId ) );
theMenu->addAction( action( DuplicateStricklerTableId ) );
theMenu->addSeparator();
+
+ if ( !isLandCoversScalarMapModeOn( anActiveViewId ) ) {
+ theMenu->addAction( action( LandCoverScalarMapModeOnId ) );
+ theMenu->addSeparator();
+ }
}
else if( anIsLandCover )
{
theMenu->addSeparator();
theMenu->addAction( action( SetZLevelId ) );
theMenu->addSeparator();
+
+ if ( isLandCoversScalarMapModeOn( anActiveViewId ) ) {
+ theMenu->addAction( action( LandCoverScalarMapModeOffId ) );
+ theMenu->addSeparator();
+ }
}
if( anIsObjectBrowser || anIsGraphicsView || anIsOCCView || anIsVTKView )
if ( visState != Qtx::UnpresentableState )
treeModel->setVisibilityState( id, theState ? Qtx::ShownState : Qtx::HiddenState );
}
+
+ if ( theObject->GetKind() == KIND_BATHYMETRY && theState ) {
+ setLandCoversScalarMapModeOff( theViewId );
+ }
}
}
if ( anOCCViewManager )
{
OCCViewer_Viewer* anOCCViewer = anOCCViewManager->getOCCViewer();
- if ( anOCCViewer )
- removeViewShapes( (size_t)anOCCViewer );
+ if ( anOCCViewer ) {
+ int aViewerId = (size_t)anOCCViewer;
+ removeViewShapes( aViewerId );
+ setLandCoversScalarMapModeOff( aViewerId );
+ }
}
if ( getVTKDisplayer()->IsApplicable( theViewManager ) )
update( UF_OCCViewer | ( visState == Qtx::ShownState ? UF_FitAll : 0 ) );
}
+
+Handle(HYDROData_StricklerTable) HYDROGUI_Module::getLandCoverColoringTable( const int theViewId ) const
+{
+ Handle(HYDROData_StricklerTable) aTable;
+
+ if ( myLandCoverColoringMap.contains( theViewId ) ) {
+ aTable = myLandCoverColoringMap.value( theViewId );
+ }
+
+ return aTable;
+}
+
+void HYDROGUI_Module::setLandCoverColoringTable( const int theViewId,
+ const Handle(HYDROData_StricklerTable)& theTable )
+{
+ if ( !theTable.IsNull() ) {
+ myLandCoverColoringMap.insert( theViewId, theTable );
+ }
+}
+
+void HYDROGUI_Module::setLandCoversScalarMapModeOff( const int theViewId )
+{
+ myLandCoverColoringMap.remove( theViewId );
+}
+
+bool HYDROGUI_Module::isLandCoversScalarMapModeOn( const int theViewId ) const
+{
+ return myLandCoverColoringMap.contains( theViewId );
+}
class SUIT_ViewWindow;
class SUIT_ViewManager;
+class Handle(HYDROData_StricklerTable);
+
class HYDROGUI_DataModel;
class HYDROGUI_Displayer;
class HYDROGUI_OCCDisplayer;
typedef QList<HYDROGUI_VTKPrs*> ListOfVTKPrs;
typedef QMap<int,ListOfVTKPrs> ViewId2ListOfVTKPrs;
+ typedef QMap<int, Handle(HYDROData_StricklerTable)> ViewId2StricklerTable;
+
public:
HYDROGUI_Module();
virtual ~HYDROGUI_Module();
*/
QCursor getPrefEditCursor() const;
+ /**
+ * Returns Strickler table used for Land Cover scalar map coloring in the given view.
+ * @param theViewId the view id
+ * @return the Strickler table used for scalar map coloring of Land Covers in the given view;
+ null - if scalar map coloring is off for the view
+ */
+ Handle(HYDROData_StricklerTable) getLandCoverColoringTable( const int theViewId ) const;
+
+ /**
+ * Set Strickler table to be used for Land Cover scalar map coloring in the given view.
+ * @param theViewId the view id
+ * @param theTable the Strickler table
+ */
+ void setLandCoverColoringTable( const int theViewId,
+ const Handle(HYDROData_StricklerTable)& theTable );
+ /**
+ * Set Land Cover scalar map coloring mode off for the given view.
+ * @param theViewId the view id
+ */
+ void setLandCoversScalarMapModeOff( const int theViewId );
+
+ /**
+ * Check if Land Cover scalar map coloring mode is on in the given view.
+ * @param theViewId the view id
+ * @return true if the mode is on, false if the mode is off
+ */
+ bool isLandCoversScalarMapModeOn( const int theViewId ) const;
+
protected:
CAM_DataModel* createDataModel();
bool myIsUpdateEnabled;
QStringList myGeomObjectsToImport; ///< entries of GEOM objects to be imported
+
+ ViewId2StricklerTable myLandCoverColoringMap;
};
#endif
#include "HYDROGUI_Operation.h"
#include "HYDROGUI_DataObject.h"
#include "HYDROGUI_ZLayers.h"
+
#include <HYDROData_Bathymetry.h>
+#include <HYDROData_LandCover.h>
+#include <HYDROData_StricklerTable.h>
#include <AIS_InteractiveContext.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
{
if( !myToUpdateColorScale )
return;
-
+
OCCViewer_ViewWindow* aWnd = dynamic_cast<OCCViewer_ViewWindow*>( theViewer->getViewManager()->getActiveView() );
Handle(V3d_View) aView = aWnd->getViewPort()->getView();
-
+
int aViewerId = (size_t)theViewer;//TODO: check if viewer id is correct
- QList<HYDROGUI_Shape*> aShapes = module()->getObjectShapes( aViewerId, KIND_BATHYMETRY );
+ bool isLandCoverColoringOn = module()->isLandCoversScalarMapModeOn( aViewerId );
+
+ QList<HYDROGUI_Shape*> aLandCoverShapes = module()->getObjectShapes( aViewerId, KIND_LAND_COVER );
+ QList<HYDROGUI_Shape*> aBathShapes = module()->getObjectShapes( aViewerId, KIND_BATHYMETRY );
- bool isDisplayColorScale = !aShapes.empty();
+ bool isDisplayColorScale = !aBathShapes.empty() || isLandCoverColoringOn;
Standard_Real anXPos = 0.05; //TODO
Standard_Real anYPos = 0.1; //TODO
Standard_Real aWidth = 0.2; //TODO
Standard_Integer aNbIntervals = 20; //TODO
TCollection_ExtendedString aColorScaleTitle = "";//TODO
- Standard_Real aColorScaleMin = 0, aColorScaleMax = 1, aMin, aMax;
- bool isFirst = true;
- foreach( HYDROGUI_Shape* aShape, aShapes )
- {
- HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
- if( !aBathShape || !aBathShape->isVisible() )
- continue;
+ Standard_Real aColorScaleMin = 0, aColorScaleMax = 1;
+
+ // Get range
+ Handle(HYDROData_StricklerTable) aTable;
+ TColStd_SequenceOfExtendedString aTableTypes;
+ if ( isLandCoverColoringOn ) {
+ aTable = module()->getLandCoverColoringTable( aViewerId );
+ if ( !aTable.IsNull() ) {
+ aColorScaleTitle = TCollection_ExtendedString( aTable->GetName().toLatin1().constData() );
+ aTable->GetCoefficientRange( aColorScaleMin, aColorScaleMax );
+ aTableTypes = aTable->GetTypes();
+ }
+ } else {
+ Standard_Real aMin, aMax;
+ bool isFirst = true;
+ foreach( HYDROGUI_Shape* aShape, aBathShapes )
+ {
+ HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
+ if( !aBathShape || !aBathShape->isVisible() )
+ continue;
- aBathShape->GetRange( aMin, aMax );
+ aBathShape->GetRange( aMin, aMax );
- if( isFirst || aMin < aColorScaleMin )
- aColorScaleMin = aMin;
- if( isFirst || aMax > aColorScaleMax )
- aColorScaleMax = aMax;
+ if( isFirst || aMin < aColorScaleMin )
+ aColorScaleMin = aMin;
+ if( isFirst || aMax > aColorScaleMax )
+ aColorScaleMax = aMax;
- isFirst = false;
+ isFirst = false;
+ }
}
+ Handle(Aspect_ColorScale) aColorScale;
if( isDisplayColorScale )
{
- Handle(Aspect_ColorScale) aColorScale = aView->ColorScale();
+ aColorScale = aView->ColorScale();
if( !aColorScale.IsNull() )
{
aColorScale->SetXPosition( anXPos );
aColorScale->SetTitle( aColorScaleTitle );
aColorScale->SetRange( aColorScaleMin, aColorScaleMax );
- foreach( HYDROGUI_Shape* aShape, aShapes )
- {
- HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
- if( !aBathShape || !aBathShape->isVisible() )
- continue;
+ if ( !isLandCoverColoringOn ) {
+ foreach( HYDROGUI_Shape* aShape, aBathShapes ) {
+ HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
+ if( !aBathShape || !aBathShape->isVisible() )
+ continue;
- aBathShape->UpdateWithColorScale( aColorScale );
+ aBathShape->UpdateWithColorScale( aColorScale );
+ }
}
}
if( !aView->ColorScaleIsDisplayed() )
aView->ColorScaleErase();
}
+ bool isScaleColoringOn = isDisplayColorScale && !aColorScale.IsNull();
+ foreach( HYDROGUI_Shape* aShape, aLandCoverShapes ) {
+ if ( !aShape || !aShape->isVisible() ) {
+ continue;
+ }
+
+ Handle(HYDROData_LandCover) aLandCover =
+ Handle(HYDROData_LandCover)::DownCast( aShape->getObject() );
+
+ if ( aLandCover.IsNull() ) {
+ continue;
+ }
+
+ QColor aUndefinedColor( Qt::gray );
+ QColor aColor = isLandCoverColoringOn ? aUndefinedColor : aLandCover->GetFillingColor();
+
+ if ( isLandCoverColoringOn && !aTable.IsNull() ) {
+ TCollection_ExtendedString aStricklerType =
+ aLandCover->GetStricklerType().toLatin1().constData();
+
+ if ( aTable->HasType( aStricklerType ) ) {
+ double aStricklerCoeff = aTable->Get( aStricklerType, 0 );
+ Quantity_Color aShapeColor;
+ if ( aColorScale->FindColor( aStricklerCoeff, aShapeColor ) ) {
+ aColor = QColor( aShapeColor.Red() * 255,
+ aShapeColor.Green() * 255,
+ aShapeColor.Blue() * 255 );
+ }
+ }
+ }
+
+ //@MZN aShape->update( false, false );
+ aShape->setFillingColor( aColor, true, true );
+ }
+
myToUpdateColorScale = false;
}
void purgeObjects( const int theViewerId );
void UpdateColorScale( const OCCViewer_Viewer* );
-
+
private:
/**
* \brief Creates new OCC shape.
#include "HYDROGUI_ExportSinusXOp.h"
#include "HYDROGUI_MergePolylinesOp.h"
#include "HYDROGUI_SplitPolylinesOp.h"
+#include "HYDROGUI_LandCoverColoringOp.h"
#include <HYDROData_Document.h>
#include <HYDROData_Obstacle.h>
createAction( SplitPolylinesId, "SPLIT_POLYLINES", "SPLIT_POLYLINES_ICO" );
createAction( MergePolylinesId, "MERGE_POLYLINES", "MERGE_POLYLINES_ICO" );
+
+ createAction( LandCoverScalarMapModeOnId, "LC_SCALARMAP_COLORING_ON" );
+ createAction( LandCoverScalarMapModeOffId, "LC_SCALARMAP_COLORING_OFF" );
}
void HYDROGUI_Module::createMenus()
case MergePolylinesId:
anOp = new HYDROGUI_MergePolylinesOp( aModule );
break;
+ case LandCoverScalarMapModeOnId:
+ case LandCoverScalarMapModeOffId:
+ anOp = new HYDROGUI_LandCoverColoringOp( aModule, theId );
+ break;
}
if( !anOp )
SplitPolylinesId,
MergePolylinesId,
+
+ LandCoverScalarMapModeOnId,
+ LandCoverScalarMapModeOffId
};
#endif
#include <GraphicsView_Viewer.h>
#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OCCDisplayer.h"
#include "HYDROGUI_Operations.h"
#include "HYDROGUI_Tool.h"
#include "HYDROGUI_UpdateFlags.h"
anUpdateFlags |= UF_FitAll;
}
+ aModule->getOCCDisplayer()->SetToUpdateColorScale(); //@MZN
+
// Set VTK viewer active if show a bathymetry
if ( aVTKMgr )
{
#include "HYDROGUI_StricklerTableDlg.h"
#include "HYDROGUI_DataObject.h"
+#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OCCDisplayer.h"
#include "HYDROGUI_Operations.h"
#include "HYDROGUI_Tool.h"
+#include "HYDROGUI_UpdateFlags.h"
#include <HYDROData_Document.h>
{
QString anEntry = HYDROGUI_DataObject::dataObjectEntry( aStricklerTableObj );
theBrowseObjectsEntries.append( anEntry );
+ } else {
+ module()->getOCCDisplayer()->SetToUpdateColorScale();
}
- theUpdateFlags |= UF_ObjBrowser;
+ theUpdateFlags |= UF_ObjBrowser | UF_OCCViewer;
return true;
}
<translation>Recognize contours</translation>
</message>
+ <message>
+ <source>MEN_LC_SCALARMAP_COLORING_ON</source>
+ <translation>Use as scalar scale</translation>
+ </message>
+ <message>
+ <source>DSK_LC_SCALARMAP_COLORING_ON</source>
+ <translation>Use the table as a scalar scale for Land Covers coloring</translation>
+ </message>
+ <message>
+ <source>STB_LC_SCALARMAP_COLORING_ON</source>
+ <translation>Use as scalar scale</translation>
+ </message>
+
+ <message>
+ <source>MEN_LC_SCALARMAP_COLORING_OFF</source>
+ <translation>Scalar map mode off</translation>
+ </message>
+ <message>
+ <source>DSK_LC_SCALARMAP_COLORING_OFF</source>
+ <translation>Turn off Land Covers scalar map coloring mode</translation>
+ </message>
+ <message>
+ <source>STB_LC_SCALARMAP_COLORING_OFF</source>
+ <translation>Scalar map mode off</translation>
+ </message>
+
</context>
<context>
