-// Copyright (C) 2007-2015 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
-//
+// 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
#include "HYDROGUI_Operations.h"
#include "HYDROGUI_PrsImage.h"
#include "HYDROGUI_Tool.h"
+#include "HYDROGUI_Tool2.h"
#include "HYDROGUI_UpdateFlags.h"
#include "HYDROGUI_Shape.h"
#include "HYDROGUI_VTKPrs.h"
#include <HYDROData_Profile.h>
#include <HYDROData_Lambert93.h>
#include <HYDROData_Polyline3D.h>
+#include <HYDROData_StricklerTable.h>
#include <HYDROData_OperationsFactory.h>
bool anIsImageHasRefs = false;
bool anIsFusedImage = false;
bool anIsCutImage = false;
- bool anIsSplittedImage = false;
+ bool anIsSplitImage = false;
bool anIsMustObjectBeUpdated = false;
bool anIsPolyline = false;
bool anIsPolyline3D = false;
bool anIsRegion = false;
bool anIsZone = false;
bool anIsObstacle = false;
+ bool anIsStricklerTable = false;
+ bool anIsLandCoverMap = false;
bool anIsStream = false;
bool anIsChannel = false;
bool anIsDigue = false;
anIsVisibleInSelection |= aVisibility;
anIsHiddenInSelection |= !aVisibility;
- if ( anObject->CanBeUpdated() && anObject->IsMustBeUpdated() )
+ if ( anObject->CanBeUpdated() && anObject->IsMustBeUpdated( HYDROData_Entity::Geom_All ) )
{
anIsMustObjectBeUpdated = true;
}
else if( anOperatorName == ImageComposer_CutOperator::Type() )
anIsCutImage = true;
else if( anOperatorName == ImageComposer_CropOperator::Type() )
- anIsSplittedImage = true;
+ anIsSplitImage = true;
}
}
}
anIsBathymetry = true;
else if( anObjectKind == KIND_OBSTACLE )
anIsObstacle = true;
+ else if( anObjectKind == KIND_STRICKLER_TABLE )
+ anIsStricklerTable = true;
+ else if( anObjectKind == KIND_LAND_COVER_MAP )
+ anIsLandCoverMap = true;
else if( anObjectKind == KIND_STREAM )
{
anIsStream = true;
anIsDigue = true;
else if( anObjectKind == KIND_DUMMY_3D )
anIsDummyObject3D = true;
- else if( anObjectKind == KIND_SHAPES_GROUP || anObjectKind == KIND_SPLITTED_GROUP )
+ else if( anObjectKind == KIND_SHAPES_GROUP || anObjectKind == KIND_SPLIT_GROUP )
anIsGroup = true;
}
if ( !anIsObjectCanBeColored )
- anIsObjectCanBeColored = HYDROGUI_SetColorOp::CanObjectBeColored( anObject );
+ anIsObjectCanBeColored = HYDROGUI_SetColorOp::CanObjectBeColored( anObject, this );
}
// Check if all selected objects are profiles
theMenu->addAction( action( CreateBoxId ) );
theMenu->addAction( action( CreateCylinderId ) );
break;
+ case KIND_STRICKLER_TABLE:
+ theMenu->addAction( action( ImportStricklerTableFromFileId ) );
+ break;
+ case KIND_LAND_COVER_MAP:
+ theMenu->addAction( action( CreateLandCoverMapId ) );
+ theMenu->addAction( action( ImportLandCoverMapId ) );
+ break;
case KIND_CALCULATION:
theMenu->addAction( action( CreateCalculationId ) );
break;
case KIND_POLYLINEXY:
+ theMenu->addAction( action( ImportPolylineId ) );
theMenu->addAction( action( CreatePolylineId ) );
break;
case KIND_POLYLINE:
theMenu->addAction( action( EditFusedImageId ) );
else if( anIsCutImage )
theMenu->addAction( action( EditCutImageId ) );
- else if( anIsSplittedImage )
- theMenu->addAction( action( EditSplittedImageId ) );
+ else if( anIsSplitImage )
+ theMenu->addAction( action( EditSplitImageId ) );
}
//RKV: BUG#98: theMenu->addAction( action( ObserveImageId ) );
theMenu->addAction( action( CutImagesId ) );
theMenu->addAction( action( SplitImageId ) );
theMenu->addSeparator();
+ theMenu->addAction( action( RecognizeContoursId ) );
+ theMenu->addSeparator();
}
else if( anIsBathymetry )
{
{
theMenu->addAction( action( EditPolylineId ) );
theMenu->addSeparator();
+ theMenu->addAction( action( SplitPolylinesId ) );
+ theMenu->addAction( action( MergePolylinesId ) );
+ theMenu->addSeparator();
}
else if( anIsPolyline3D )
{
theMenu->addAction( action( TranslateObstacleId ) );
theMenu->addSeparator();
}
+ else if( anIsStricklerTable )
+ {
+ theMenu->addAction( action( EditStricklerTableId ) );
+ theMenu->addAction( action( ExportStricklerTableFromFileId ) );
+ theMenu->addAction( action( DuplicateStricklerTableId ) );
+ theMenu->addSeparator();
+
+ Handle(HYDROData_StricklerTable) aTable =
+ Handle(HYDROData_StricklerTable)::DownCast( aSeq.First() );
+ QString aCurrentTable =
+ HYDROGUI_DataObject::dataObjectEntry( getLandCoverColoringTable( anActiveViewId ) );
+ bool isUsed = aCurrentTable == HYDROGUI_DataObject::dataObjectEntry( aTable );
+
+ if ( !isUsed && !getObjectShapes( anActiveViewId, KIND_LAND_COVER_MAP ).isEmpty() ) {
+ theMenu->addAction( action( LandCoverScalarMapModeOnId ) );
+ theMenu->addSeparator();
+ }
+ }
+ else if( anIsLandCoverMap )
+ {
+ theMenu->addAction( action( AddLandCoverId ) );
+ theMenu->addAction( action( RemoveLandCoverId ) );
+ theMenu->addSeparator();
+ theMenu->addAction( action( SplitLandCoverId ) );
+ theMenu->addAction( action( MergeLandCoverId ) );
+ theMenu->addAction( action( ChangeLandCoverTypeId ) );
+ theMenu->addSeparator();
+ //
+ theMenu->addAction( action( ExportToShapeFileID ) );
+ theMenu->addSeparator();
+ }
else if( anIsVisualState && anIsObjectBrowser )
{
theMenu->addAction( action( SaveVisualStateId ) );
theMenu->addSeparator();
}
+ if ( anIsStream || anIsChannel || anIsDigue || anIsObstacle )
+ {
+ theMenu->addAction( action( PolylineExtractionId ) );
+ theMenu->addSeparator();
+ }
+
// Add set color action for geometrical objects
if ( anIsObjectCanBeColored )
{
theMenu->addAction( action( SetColorId ) );
theMenu->addSeparator();
}
+
+ // Add transparency action for land cover map objects
+ if ( anIsLandCoverMap )
+ {
+ theMenu->addAction( action( SetTransparencyId ) );
+ theMenu->addSeparator();
+ }
} else if ( anAllAreProfiles ) {
theMenu->addAction( action( SelectedGeoreferencementId ) );
theMenu->addSeparator();
}
+ bool anIsPoly = anIsPolyline || anIsPolyline3D;
+ if (anIsPoly && !anIsLandCoverMap)
+ theMenu->addAction( action( ExportToShapeFileID ) );
+
// Add copy action
QAction* aCopyAction = action( CopyId );
if( aCopyAction && aCopyAction->isEnabled() ) {
anIsImmersibleZone || anIsZone || anIsRegion ||
anIsBathymetry || anIsObstacle || anIsStream ||
anIsChannel || anIsDigue || anIsDummyObject3D ||
- anIsValidProfile || anIsGroup )
+ anIsValidProfile || anIsGroup || anIsLandCoverMap )
{
if( anIsHiddenInSelection )
theMenu->addAction( action( ShowId ) );
theMenu->addSeparator();
theMenu->addAction( action( SetZLevelId ) );
theMenu->addSeparator();
+
+ if ( isLandCoversScalarMapModeOn( anActiveViewId ) ) {
+ theMenu->addAction( action( LandCoverScalarMapModeOffId ) );
+ theMenu->addSeparator();
+ }
}
if( anIsObjectBrowser || anIsGraphicsView || anIsOCCView || anIsVTKView )
if( isRoot )
theMenu->addAction( action( EditLocalCSId ) );
+
+ if( anIsObjectBrowser && anOwners.size()==1 )
+ {
+ if( aSeq.Size() > 0 )
+ {
+ Handle( HYDROData_Object ) anObject = Handle( HYDROData_Object )::DownCast( aSeq.First() );
+ if( !anObject.IsNull() )
+ {
+ theMenu->addSeparator();
+ theMenu->addAction( action( SubmersibleId ) );
+ action( SubmersibleId )->setCheckable( true );
+ action( SubmersibleId )->setChecked( anObject->IsSubmersible() );
+ }
+ }
+ }
}
void HYDROGUI_Module::createPreferences()
int viewerGroup = addPreference( tr( "PREF_GROUP_VIEWER" ), genTab );
addPreference( tr( "PREF_VIEWER_AUTO_FITALL" ), viewerGroup,
LightApp_Preferences::Bool, "HYDRO", "auto_fit_all" );
+
+ int StricklerTableGroup = addPreference( tr( "PREF_GROUP_STRICKLER_TABLE" ), genTab );
+ int defaultStricklerCoef = addPreference( tr( "PREF_DEFAULT_STRICKLER_COEFFICIENT" ), StricklerTableGroup,
+ LightApp_Preferences::DblSpin, "preferences", "default_strickler_coefficient" );
+ setPreferenceProperty( defaultStricklerCoef, "precision", 2 );
+ setPreferenceProperty( defaultStricklerCoef, "min", 0.00 );
+ setPreferenceProperty( defaultStricklerCoef, "max", 1000000.00 );
+ setPreferenceProperty( defaultStricklerCoef, "step", 0.01 );
+
+ int polylinesGroup = addPreference( tr( "PREF_GROUP_POLYLINES" ), genTab );
+ int polylineArrow = addPreference( tr( "PREF_POLYLINE_ARROW" ), polylinesGroup,
+ LightApp_Preferences::Selector, "polyline", "arrow_type" );
+
+ QList<QVariant> indices;
+ indices.append( 0 );
+ indices.append( 1 );
+ indices.append( 2 );
+ setPreferenceProperty( polylineArrow, "indexes", indices );
+ QList<QVariant> arrow_types;
+ arrow_types.append( tr( "No" ) );
+ arrow_types.append( tr( "Triangle" ) );
+ arrow_types.append( tr( "Cone" ) );
+ setPreferenceProperty( polylineArrow, "strings", arrow_types );
+
+ int polylineSize = addPreference( tr( "PREF_POLYLINE_ARROW_SIZE" ), polylinesGroup,
+ LightApp_Preferences::IntSpin, "polyline", "arrow_size" );
+}
+
+void HYDROGUI_Module::preferencesChanged( const QString& theSection, const QString& thePref )
+{
+ if ( theSection == "preferences" && thePref == "default_strickler_coefficient" )
+ {
+ SUIT_ResourceMgr* resMgr = application()->resourceMgr();
+ Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( application()->activeStudy()->id() );
+ if ( resMgr && !aDoc.IsNull() )
+ aDoc->SetDefaultStricklerCoefficient( resMgr->doubleValue( theSection, thePref, 0 ) );
+ }
+ else if( theSection == "polyline" )
+ {
+ //TODO: update polylines
+ }
+ else
+ LightApp_Module::preferencesChanged( theSection, thePref );
+}
+
+QCursor HYDROGUI_Module::getPrefEditCursor() const
+{
+ int aCursorType = SUIT_Session::session()->resourceMgr()->integerValue("preferences", "type_of_cursor", (int)CT_CrossCursor );
+ if ( aCursorType >= Qt::BlankCursor)
+ aCursorType++;
+ QCursor aCursor = QCursor( Qt::CursorShape(aCursorType) );
+ return aCursor;
}
void HYDROGUI_Module::update( const int flags )
if( theObject.IsNull() )
return false;
+ if( theViewId < 0 )
+ {
+ //search in all
+ foreach( int aViewId, myObjectStateMap.keys() )
+ {
+ if( isObjectVisible( aViewId, theObject ) )
+ return true;
+ }
+ return false;
+ }
+
ViewId2Entry2ObjectStateMap::const_iterator anIter1 = myObjectStateMap.find( theViewId );
if( anIter1 != myObjectStateMap.end() )
{
if ( hydroObject )
{
SUIT_AbstractModel* treeModel = dynamic_cast<SUIT_AbstractModel*>( getApp()->objectBrowser()->model() );
- QString id = hydroObject->text( hydroObject->customData( Qtx::IdType ).toInt() );
- Qtx::VisibilityState visState = treeModel->visibilityState( id );
- if ( visState != Qtx::UnpresentableState )
+ if ( treeModel )
+ {
+ QString id = hydroObject->text( hydroObject->customData( Qtx::IdType ).toInt() );
+ Qtx::VisibilityState visState = treeModel->visibilityState( id );
+ if ( visState != Qtx::UnpresentableState )
treeModel->setVisibilityState( id, theState ? Qtx::ShownState : Qtx::HiddenState );
+ }
+ }
+
+ if ( theObject->GetKind() == KIND_BATHYMETRY && theState ) {
+ setLandCoversScalarMapModeOff( theViewId );
+ } else if ( theObject->GetKind() == KIND_LAND_COVER_MAP && theState ) {
+ getOCCDisplayer()->SetToUpdateColorScale();
}
}
}
}
/////////////////// END OF VTKPrs PROCESSING
+void HYDROGUI_Module::clearCache()
+{
+ myObjectStateMap.clear();
+}
+
CAM_DataModel* HYDROGUI_Module::createDataModel()
{
return new HYDROGUI_DataModel( this );
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 ) )
aViewFrame->installEventFilter( this );
GraphicsView_ViewPort* aViewPort = aViewFrame->getViewPort();
+ aViewPort->setInteractionFlag( GraphicsView_ViewPort::GlobalWheelScaling );
connect( aViewPort, SIGNAL( vpMouseEvent( QGraphicsSceneMouseEvent* ) ),
this, SLOT( onViewPortMouseEvent( QGraphicsSceneMouseEvent* ) ) );
setObjectVisible( HYDROGUI_Tool::GetActiveViewId( this ), hydroObject->modelObject(), vis );
- update( UF_OCCViewer | ( visState == Qtx::ShownState ? UF_FitAll : 0 ) );
+ update( UF_OCCViewer | UF_VTKViewer | ( 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 );
+}
+
+void HYDROGUI_Module::setObjectRemoved( const Handle(HYDROData_Entity)& theObject )
+{
+ if ( theObject.IsNull() || !theObject->IsRemoved() ) {
+ return;
+ }
+
+ if ( theObject->GetKind() == KIND_STRICKLER_TABLE ) {
+ Handle(HYDROData_StricklerTable) aTable =
+ Handle(HYDROData_StricklerTable)::DownCast( theObject );
+ QList<int> aViewIds;
+ QMutableMapIterator<int, Handle(HYDROData_StricklerTable)> anIter( myLandCoverColoringMap );
+ while ( anIter.hasNext() ) {
+ if ( HYDROGUI_DataObject::dataObjectEntry( anIter.next().value() ) ==
+ HYDROGUI_DataObject::dataObjectEntry( aTable ) ) {
+ anIter.remove();
+ }
+ }
+ }
}