X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_Shape.cxx;h=eb05a9b4dd816d214b3f9fb818d9e4a49b1d7e32;hb=81c9f5cdf82909d0aebd2c491c50fa7516cc80b7;hp=be595d23a983300fce1a56781c8fcdb0560f93d6;hpb=1a52e03c8344a46f0db70927bf8c445815fc7b2d;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_Shape.cxx b/src/HYDROGUI/HYDROGUI_Shape.cxx index be595d23..eb05a9b4 100644 --- a/src/HYDROGUI/HYDROGUI_Shape.cxx +++ b/src/HYDROGUI/HYDROGUI_Shape.cxx @@ -22,7 +22,13 @@ #include "HYDROGUI_Shape.h" +#include "HYDROGUI_DataObject.h" +#include "HYDROGUI_Tool.h" + #include +#include + +#include #include #include @@ -33,63 +39,406 @@ #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include #include #include +#include + +#include + #include #include #include #include +#include + #include +#include -HYDROGUI_Shape::HYDROGUI_Shape( const Handle(AIS_InteractiveContext)& theContext ) +HYDROGUI_Shape::HYDROGUI_Shape( const Handle(AIS_InteractiveContext)& theContext, + const Handle(HYDROData_Entity)& theObject, + const int theZLayer ) : myContext( theContext ), + myObject( theObject ), + myZLayer( theZLayer ), myIsHighlight( false ), - myZIndex( 0.0 ), - myFillingColor( Qt::green ), + myFillingColor( Qt::transparent ), myBorderColor( Qt::black ), - myHighlightColor( Qt::white ) + myHighlightColor( Qt::white ), + myIsToUpdate( false ), + myIsVisible( true ), + myDisplayMode( AIS_WireFrame ) { } HYDROGUI_Shape::~HYDROGUI_Shape() { - erase(); + erase( false ); if ( !myShape.IsNull() ) myShape.Nullify(); + + removeTextureFile(); } -void HYDROGUI_Shape::display() +void HYDROGUI_Shape::display( const bool theIsUpdateViewer ) { - if ( !myContext || myShape.IsNull() ) + if ( myContext.IsNull() || myShape.IsNull() || !isVisible() ) return; - myContext->Display( myShape ); + displayShape( theIsUpdateViewer ); } -void HYDROGUI_Shape::erase() +void HYDROGUI_Shape::erase( const bool theIsUpdateViewer ) { - if ( !myContext || myShape.IsNull() ) + if ( myContext.IsNull() || myShape.IsNull() ) + return; + + myContext->Erase( myShape, theIsUpdateViewer ); +} + +void HYDROGUI_Shape::update( const bool theIsUpdateViewer ) +{ + setIsToUpdate( false ); + + if ( myContext.IsNull() ) + return; + + bool isDeactivateSelection = false; + // Try to retrieve information from object + if ( !myObject.IsNull() ) + { + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myObject->Label() ); + + if ( myObject->IsKind( STANDARD_TYPE(HYDROData_ImmersibleZone) ) ) + { + Handle(HYDROData_ImmersibleZone) aZoneObj = + Handle(HYDROData_ImmersibleZone)::DownCast( myObject ); + + TopoDS_Shape aZoneShape = aZoneObj->GetTopShape(); + if ( !aZoneShape.IsNull() ) { + if ( aZoneShape.ShapeType() == TopAbs_FACE ) { + TopoDS_Face aZoneFace = TopoDS::Face( aZoneShape ); + setFace( aZoneFace, false, false ); + } else { + myTopoShape = aZoneShape; + myDisplayMode = myTextureFileName.isEmpty() ? AIS_Shaded : AIS_Shaded+2; + + buildShape(); + updateShape( false, false ); + } + } + + QColor aFillingColor = aZoneObj->GetFillingColor(); + QColor aBorderColor = aZoneObj->GetBorderColor(); + + setFillingColor( aFillingColor, false, false ); + setBorderColor( aBorderColor, false, false ); + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_PolylineXY) ) ) + { + Handle(HYDROData_PolylineXY) aPolyline = + Handle(HYDROData_PolylineXY)::DownCast( myObject ); + + TopoDS_Shape aPolylineShape = aPolyline->GetShape(); + + if ( !aPolylineShape.IsNull() ) { + if ( aPolylineShape.ShapeType() == TopAbs_WIRE ) { + TopoDS_Wire aPolylineWire = TopoDS::Wire( aPolylineShape ); + setWire( aPolylineWire, false, false ); + } else { + myTopoShape = aPolylineShape; + // Set shading mode to avoid that hilight presentation is equal to "normal" object presentation. + // Note that hilight presentation is always to be on top ( i.e. in the top Z layer ). + myDisplayMode = AIS_Shaded; + + buildShape(); + updateShape( false, false ); + } + } + + QColor aWireColor = aPolyline->GetWireColor(); + setBorderColor( aWireColor, false, false ); + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_Polyline3D) ) ) + { + Handle(HYDROData_Polyline3D) aPolyline = + Handle(HYDROData_Polyline3D)::DownCast( myObject ); + + TopoDS_Shape aPolylineShape = aPolyline->GetShape3D(); + + if ( !aPolylineShape.IsNull() ) { + if ( aPolylineShape.ShapeType() == TopAbs_WIRE ) { + TopoDS_Wire aPolylineWire = TopoDS::Wire( aPolylineShape ); + setWire( aPolylineWire, false, false ); + } else { + myTopoShape = aPolylineShape; + // Set shading mode to avoid that hilight presentation is equal to "normal" object presentation. + // Note that hilight presentation is always to be on top ( i.e. in the top Z layer ). + myDisplayMode = AIS_Shaded; + + buildShape(); + updateShape( false, false ); + } + } + + QColor aWireColor = aPolyline->GetBorderColor(); + setBorderColor( aWireColor, false, false ); + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_Zone) ) ) + { + Handle(HYDROData_Zone) aZone = + Handle(HYDROData_Zone)::DownCast( myObject ); + + TopoDS_Face aZoneFace = TopoDS::Face( aZone->GetShape() ); + + setFace( aZoneFace, false, false ); + if (aZone->IsMergingNeed() && aZone->GetMergeType() == HYDROData_Zone::Merge_UNKNOWN ) + { + // Red color for a zone with bathymetry conflict + setFillingColor( Qt::red ); + } + else + { + // Generate the filling color for zone + QStringList aGeomObjectsNames; + + HYDROData_SequenceOfObjects aRefObjects = aZone->GetGeometryObjects(); + HYDROData_SequenceOfObjects::Iterator anIter( aRefObjects ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Object) aRefbject = + Handle(HYDROData_Object)::DownCast( anIter.Value() ); + if ( aRefbject.IsNull() ) + continue; + + QString aRefObjectName = aRefbject->GetName(); + if ( aRefObjectName.isEmpty() ) + continue; + + aGeomObjectsNames.append( aRefObjectName ); + } + + setFillingColor( HYDROGUI_Tool::GenerateFillingColor( aDocument, aGeomObjectsNames ) ); + } + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_Image) ) ) + { + Handle(HYDROData_Image) anImageObj = + Handle(HYDROData_Image)::DownCast( myObject ); + + removeTextureFile(); + + QString aTextureFileName = generateTextureFileName( anImageObj ); + + QImage anImage = anImageObj->Image(); + QString aFilePath = anImageObj->GetFilePath(); + QTransform aTrsf = anImageObj->Trsf(); + + int aWidth = anImage.width(); + int aHeight = anImage.height(); + + QString anImageError = ""; + + QTransform anInversion = QTransform::fromScale( -1, -1 ); + anImage = anImage.transformed( anInversion * aTrsf, Qt::SmoothTransformation ); + + if ( anImage.isNull() ) + anImageError = QObject::tr( "IMAGE_TRANSFORMATION_CAN_NOT_BE_APPLYED" ); + else + { + // Workaround: Scale the texture image to the nearest width multiple 4 due to the CASCADE bug 23813 + int aTrsfWidth = anImage.width(); + int aDelta = aTrsfWidth % 4; + if ( aDelta > 0 ) + { + aTrsfWidth += ( 4 - aDelta ); + } + anImage = anImage.scaledToWidth( aTrsfWidth ); + + // temporary optimization, to reduce the saved image size (and the texture quality) + QImage anImageToSave = anImage; //RKV:reduceTexture( anImage, 500 ); + + bool isSaved = anImageToSave.save( aTextureFileName ); + if ( !isSaved ) + anImageError = QObject::tr( "FILE_CAN_NOT_BE_CREATED" ).arg( aTextureFileName ); + else + QFile::setPermissions( aTextureFileName, (QFile::Permissions)0x4FFFF ); + } + + if ( !anImageError.isEmpty() ) + { + SUIT_MessageBox::warning( 0, QObject::tr( "SHAPE_IMAGE_ERROR" ), + QObject::tr( "IMAGE_CAN_NOT_BE_CREATED" ) + anImageError ); + } + + QPointF aPoint1( 0, 0 ); // 1: top left + QPointF aPoint2( aWidth, 0 ); // 2: top right + QPointF aPoint3( aWidth, aHeight ); // 3: bottom right + QPointF aPoint4( 0, aHeight ); // 4: bottom left + + aPoint1 = aTrsf.map( aPoint1 ); + aPoint2 = aTrsf.map( aPoint2 ); + aPoint3 = aTrsf.map( aPoint3 ); + aPoint4 = aTrsf.map( aPoint4 ); + + QPolygonF aPolygon = QPolygonF() << aPoint1 << aPoint2 << aPoint3 << aPoint4; + QRectF aRect = aPolygon.boundingRect(); + + gp_Pnt aPnt1( aRect.topLeft().x(), aRect.topLeft().y(), 0 ); + gp_Pnt aPnt2( aRect.topRight().x(), aRect.topRight().y(), 0 ); + gp_Pnt aPnt3( aRect.bottomRight().x(), aRect.bottomRight().y(), 0 ); + gp_Pnt aPnt4( aRect.bottomLeft().x(), aRect.bottomLeft().y(), 0 ); + + Handle_HYDROData_Document aDoc = HYDROData_Document::Document( anImageObj->Label() ); + aDoc->Transform( aPnt1, true ); + aDoc->Transform( aPnt2, true ); + aDoc->Transform( aPnt3, true ); + aDoc->Transform( aPnt4, true ); + + TopoDS_Edge anEdge1 = BRepBuilderAPI_MakeEdge( aPnt1, aPnt2 ).Edge(); + TopoDS_Edge anEdge2 = BRepBuilderAPI_MakeEdge( aPnt2, aPnt3 ).Edge(); + TopoDS_Edge anEdge3 = BRepBuilderAPI_MakeEdge( aPnt3, aPnt4 ).Edge(); + TopoDS_Edge anEdge4 = BRepBuilderAPI_MakeEdge( aPnt4, aPnt1 ).Edge(); + + TopoDS_Wire aWire = BRepBuilderAPI_MakeWire( anEdge1, anEdge2, anEdge3, anEdge4 ).Wire(); + aWire.Closed( true ); + + setTextureFileName( aTextureFileName, false, false ); + setFace( aWire, false, false ); + isDeactivateSelection = true; + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_Profile) ) ) + { + Handle(HYDROData_Profile) aProfile = + Handle(HYDROData_Profile)::DownCast( myObject ); + + TopoDS_Wire aProfileWire; + + if ( aProfile->IsValid() ) { + TopoDS_Shape aProfileShape = aProfile->GetShape3D(); + + if ( !aProfileShape.IsNull() && + aProfileShape.ShapeType() == TopAbs_WIRE ) { + aProfileWire = TopoDS::Wire( aProfileShape ); + } + } + + setWire( aProfileWire, false, false ); + + QColor aWireColor = aProfile->GetBorderColor(); + setBorderColor( aWireColor, false, false ); + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_Stream) ) || + myObject->IsKind( STANDARD_TYPE(HYDROData_Channel) ) || + myObject->IsKind( STANDARD_TYPE(HYDROData_Obstacle) ) ) + { + Handle(HYDROData_Object) aGeomObject = + Handle(HYDROData_Object)::DownCast( myObject ); + + TopoDS_Shape anObjShape = aGeomObject->GetTopShape(); + + setShape( anObjShape, false, false ); + + QColor aFillingColor = aGeomObject->GetFillingColor(); + QColor aBorderColor = aGeomObject->GetBorderColor(); + + setFillingColor( aFillingColor, false, false ); + setBorderColor( aBorderColor, false, false ); + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_DummyObject3D) ) ) + { + Handle(HYDROData_DummyObject3D) anObject3D = + Handle(HYDROData_DummyObject3D)::DownCast( myObject ); + TopoDS_Shape aShape3D = anObject3D->GetShape(); + + setShape( aShape3D, false, false ); + + QColor aFillingColor = anObject3D->GetFillingColor(); + QColor aBorderColor = anObject3D->GetBorderColor(); + + setFillingColor( aFillingColor, false, false ); + setBorderColor( aBorderColor, false, false ); + } + else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_ShapesGroup) ) ) + { + Handle(HYDROData_ShapesGroup) aShapesGroup = + Handle(HYDROData_ShapesGroup)::DownCast( myObject ); + + TopTools_SequenceOfShape aShapes; + aShapesGroup->GetShapes( aShapes ); + + TopoDS_Compound aCompound; + BRep_Builder aCompoundBuilder; + aCompoundBuilder.MakeCompound( aCompound ); + + for ( int i = 1, n = aShapes.Length(); i <= n; ++i ) + { + const TopoDS_Shape& aShape = aShapes.Value( i ); + aCompoundBuilder.Add( aCompound, aShape ); + } + + setShape( aCompound, false, false ); + } + } + + if ( myShape.IsNull() || !isVisible() ) return; - myContext->Erase( myShape ); + displayShape( theIsUpdateViewer ); + + if (isDeactivateSelection) + myContext->Deactivate(myShape); } -void HYDROGUI_Shape::highlight( bool theIsHighlight ) +void HYDROGUI_Shape::setVisible( const bool theState, + const bool theIsUpdateViewer ) +{ + myIsVisible = theState; + + if ( myShape.IsNull() ) + return; + + if ( ( myIsVisible && myContext->IsDisplayed( myShape ) ) || + ( !myIsVisible && !myContext->IsDisplayed( myShape ) ) ) + return; + + if ( myIsVisible ) { + displayShape( theIsUpdateViewer ); + } + else + myContext->Erase( myShape, theIsUpdateViewer ); +} + +void HYDROGUI_Shape::highlight( bool theIsHighlight, bool isUpdateViewer ) { if ( myIsHighlight == theIsHighlight ) return; myIsHighlight = theIsHighlight; - if ( !myContext || myShape.IsNull() ) + if ( myContext.IsNull() || myShape.IsNull() ) return; colorShapeBorder( getActiveColor() ); - myContext->Display( myShape ); + displayShape( isUpdateViewer ); } bool HYDROGUI_Shape::isHighlighted() const @@ -97,37 +446,91 @@ bool HYDROGUI_Shape::isHighlighted() const return myIsHighlight; } -void HYDROGUI_Shape::setPath( const QPainterPath& thePath, - const bool theToDisplay ) +void HYDROGUI_Shape::setWire( const TopoDS_Wire& theWire, + const bool theToDisplay, + const bool theIsUpdateViewer ) { - myPath = thePath; + myTopoShape = theWire; + // To avoid that hilight presentation is equal to "normal" object presentation. + // Note that hilight presentation is always to be on top ( i.e. in the top Z layer ). + myDisplayMode = AIS_Shaded; + buildShape(); - updateShape( theToDisplay ); + updateShape( theToDisplay, theIsUpdateViewer ); } -QPainterPath HYDROGUI_Shape::getPath() const +void HYDROGUI_Shape::setFaces( const TopoDS_Compound& theWires, + const bool theToDisplay, + const bool theIsUpdateViewer ) { - return myPath; + TopExp_Explorer anExp( theWires, TopAbs_WIRE ); + TopoDS_Compound aCompound; + BRep_Builder aBuilder; + aBuilder.MakeCompound( aCompound ); + + for ( ; anExp.More(); anExp.Next() ) { + TopoDS_Wire aWire = TopoDS::Wire( anExp.Current() ); + if ( aWire.IsNull() ) { + continue; + } + + BRepBuilderAPI_MakeFace aMakeFace( aWire, Standard_True ); + aMakeFace.Build(); + if( aMakeFace.IsDone() ) { + aBuilder.Add( aCompound, aMakeFace.Face() ); + } + } + + myTopoShape = aCompound; + myDisplayMode = AIS_Shaded; + + buildShape(); + updateShape( theToDisplay, theIsUpdateViewer ); } -void HYDROGUI_Shape::setZIndex( const double theZIndex, - const bool theToDisplay ) +void HYDROGUI_Shape::setFace( const TopoDS_Wire& theWire, + const bool theToDisplay, + const bool theIsUpdateViewer ) { - myZIndex = theZIndex; + BRepBuilderAPI_MakeFace aFaceBuilder( theWire, Standard_True ); + aFaceBuilder.Build(); + if( aFaceBuilder.IsDone() ) + { + TopoDS_Face aFace = aFaceBuilder.Face(); + setFace( aFace, theToDisplay, theIsUpdateViewer ); + } +} + +void HYDROGUI_Shape::setFace( const TopoDS_Face& theFace, + const bool theToDisplay, + const bool theIsUpdateViewer ) +{ + myTopoShape = theFace; + myDisplayMode = myTextureFileName.isEmpty() ? AIS_Shaded : AIS_Shaded+2; + //Note: AIS_Shaded+2 is the same as AIS_ExactHLR + //TODO: it would be more suitable to use TexturedShape mode from GEOM_AISShape + buildShape(); - updateShape( theToDisplay ); + updateShape( theToDisplay, theIsUpdateViewer ); } -double HYDROGUI_Shape::getZIndex() const +void HYDROGUI_Shape::setShape( const TopoDS_Shape& theShape, + const bool theToDisplay, + const bool theIsUpdateViewer ) { - return myZIndex; + myTopoShape = theShape; + myDisplayMode = AIS_Shaded; + + buildShape(); + updateShape( theToDisplay, theIsUpdateViewer ); } void HYDROGUI_Shape::setFillingColor( const QColor& theColor, - const bool theToDisplay ) + const bool theToDisplay, + const bool theIsUpdateViewer ) { myFillingColor = theColor; - updateShape( theToDisplay ); + updateShape( theToDisplay, theIsUpdateViewer ); } QColor HYDROGUI_Shape::getFillingColor() const @@ -136,10 +539,11 @@ QColor HYDROGUI_Shape::getFillingColor() const } void HYDROGUI_Shape::setBorderColor( const QColor& theColor, - const bool theToDisplay ) + const bool theToDisplay, + const bool theIsUpdateViewer ) { myBorderColor = theColor; - updateShape( theToDisplay ); + updateShape( theToDisplay, theIsUpdateViewer ); } QColor HYDROGUI_Shape::getBorderColor() const @@ -157,41 +561,27 @@ QColor HYDROGUI_Shape::getHighlightColor() const return myHighlightColor; } -void HYDROGUI_Shape::makeEdge( BRepBuilderAPI_MakeWire& theWireBuilder, - gp_Pnt& theFirstPoint, - gp_Pnt& theLastPoint ) const +void HYDROGUI_Shape::setTextureFileName( const QString& theFileName, + const bool theToDisplay, + const bool theIsUpdateViewer ) { - BRepBuilderAPI_MakeEdge anEdgeBuilder( theFirstPoint, theLastPoint ); - anEdgeBuilder.Build(); - if ( anEdgeBuilder.IsDone() ) - { - TopoDS_Edge anEdge = anEdgeBuilder; - theWireBuilder.Add( anEdge ); - } + myTextureFileName = theFileName; + updateShape( theToDisplay, theIsUpdateViewer ); } -void HYDROGUI_Shape::makeWire( BRepBuilderAPI_MakeFace& theFaceBuilder, - BRepBuilderAPI_MakeWire& theWireBuilder, - bool& theIsComposed ) const +QString HYDROGUI_Shape::getTextureFileName() const { - theWireBuilder.Build(); - if ( theWireBuilder.IsDone() ) - { - TopoDS_Wire aBuildedWire = theWireBuilder; - if ( theIsComposed ) - { - theFaceBuilder.Add( aBuildedWire ); - } - else - { - theFaceBuilder = BRepBuilderAPI_MakeFace( aBuildedWire, true ); + return myTextureFileName; +} - theFaceBuilder.Build(); - theIsComposed = theFaceBuilder.IsDone(); - } - } +void HYDROGUI_Shape::setZLayer( const int theZLayer ) +{ + if ( myZLayer == theZLayer ) + return; - theWireBuilder = BRepBuilderAPI_MakeWire(); + myZLayer = theZLayer; + if ( !myShape.IsNull() && isVisible() && !myContext.IsNull() && myZLayer >= 0 ) + myContext->SetZLayer( myShape, myZLayer ); } void HYDROGUI_Shape::buildShape() @@ -199,101 +589,81 @@ void HYDROGUI_Shape::buildShape() // Erase previously created shape erase(); - if ( myPath.isEmpty() ) + if ( myTopoShape.IsNull() ) { + myShape.Nullify(); return; + } - BRepBuilderAPI_MakeFace aFaceBuilder; - BRepBuilderAPI_MakeWire aWireBuilder; - - // Build new shape from path - bool anIsComposed = false; - bool anIsStarted = false; - gp_Pnt aStartPoint( 0, 0, myZIndex ); - gp_Pnt aPrevPoint( 0, 0, myZIndex ); + QString aTextureFileName = getTextureFileName(); + bool anIsTexture = !aTextureFileName.isEmpty(); - for ( int i = 0; i < myPath.elementCount(); ++i ) + if ( anIsTexture ) { - const QPainterPath::Element& aPathElem = myPath.elementAt( i ); - - gp_Pnt aCurPoint( aPathElem.x, aPathElem.y, myZIndex ); - switch ( aPathElem.type ) - { - case QPainterPath::LineToElement: - { - // Just build the edge - makeEdge( aWireBuilder, aPrevPoint, aCurPoint ); - break; - } - case QPainterPath::CurveToElement: - { - // TODO - break; - } - case QPainterPath::MoveToElement: - { - if ( anIsStarted ) - { - // Compose face - if ( !aStartPoint.IsEqual( aPrevPoint, Precision::Confusion() ) ) - { - //Close wire - makeEdge( aWireBuilder, aPrevPoint, aStartPoint ); - } - - // Make face wiyth edge - makeWire( aFaceBuilder, aWireBuilder, anIsComposed ); - } - - anIsStarted = true; - aStartPoint = aCurPoint; - break; - } - default: - break; - } - - aPrevPoint = aCurPoint; + myShape = new AIS_TexturedShape( myTopoShape ); + } + else + { + myShape = new AIS_Shape( myTopoShape ); } - makeWire( aFaceBuilder, aWireBuilder, anIsComposed ); - - TopoDS_Face aResShape; - - aFaceBuilder.Build(); - if ( aFaceBuilder.IsDone() ) - aResShape = aFaceBuilder; + myShape->SetHLRAngleAndDeviation( 0.001 ); - myShape = new AIS_Shape( aResShape ); + if ( !myObject.IsNull() ) + myShape->SetOwner( myObject ); myShape->SetTransparency( 0 ); - myShape->SetDisplayMode( AIS_Shaded ); + myShape->SetDisplayMode( (AIS_DisplayMode)myDisplayMode ); - // Init default params for shape + if( anIsTexture ) + { + Handle(AIS_TexturedShape) aTexturedShape = + Handle(AIS_TexturedShape)::DownCast( myShape ); + + aTexturedShape->SetTextureFileName( HYDROGUI_Tool::ToAsciiString( aTextureFileName ) ); + aTexturedShape->SetTextureMapOn(); + // Just use the texture image as is + aTexturedShape->DisableTextureModulate(); + aTexturedShape->SetTextureRepeat( false ); // don't repeat the texture image on the face + } + + // Init default params for shape const Handle(AIS_Drawer)& anAttributes = myShape->Attributes(); if ( !anAttributes.IsNull() ) { Handle(Prs3d_IsoAspect) anIsoAspect = anAttributes->UIsoAspect(); - if ( !anIsoAspect.IsNull() ) + if ( !anIsoAspect.IsNull() ) { anIsoAspect->SetNumber( 0 ); - + anAttributes->SetUIsoAspect( anIsoAspect ); + } + anIsoAspect = anAttributes->VIsoAspect(); - if ( !anIsoAspect.IsNull() ) + if ( !anIsoAspect.IsNull() ) { anIsoAspect->SetNumber( 0 ); + anAttributes->SetVIsoAspect( anIsoAspect ); + } - Handle(Prs3d_ShadingAspect) aShadingAspect = anAttributes->ShadingAspect(); - if ( !aShadingAspect.IsNull() ) + if ( myDisplayMode == AIS_Shaded ) { - Graphic3d_MaterialAspect aMatAspect; - aMatAspect.SetAmbient( 1 ); - aMatAspect.SetDiffuse( 0 ); - - aShadingAspect->Aspect()->SetFrontMaterial( aMatAspect ); - aShadingAspect->Aspect()->SetBackMaterial( aMatAspect ); + Handle(Prs3d_ShadingAspect) aShadingAspect = anAttributes->ShadingAspect(); + if ( !aShadingAspect.IsNull() ) + { + Graphic3d_MaterialAspect aMatAspect( Graphic3d_NOM_PLASTIC ); + //aMatAspect.SetAmbient( 1 ); + //aMatAspect.SetDiffuse( 0 ); + + aShadingAspect->Aspect()->SetFrontMaterial( aMatAspect ); + aShadingAspect->Aspect()->SetBackMaterial( aMatAspect ); + } + } + else if ( myDisplayMode == AIS_WireFrame ) + { + anAttributes->SetWireDraw( true ); } } } -void HYDROGUI_Shape::updateShape( const bool theIsForce ) +void HYDROGUI_Shape::updateShape( const bool theToDisplay, + const bool theIsUpdateViewer ) { if ( myShape.IsNull() ) return; @@ -301,27 +671,43 @@ void HYDROGUI_Shape::updateShape( const bool theIsForce ) const Handle(AIS_Drawer)& anAttributes = myShape->Attributes(); if ( !anAttributes.IsNull() ) { - // Coloring face filling - Handle(Prs3d_ShadingAspect) aShadingAspect = anAttributes->ShadingAspect(); - if ( !aShadingAspect.IsNull() ) + if ( myDisplayMode == AIS_Shaded ) { - Quantity_Color aFillingColor( getQuantityColorVal( myFillingColor.red() ), - getQuantityColorVal( myFillingColor.green() ), - getQuantityColorVal( myFillingColor.blue() ), - Quantity_TOC_RGB ); + // Coloring face filling + Handle(Prs3d_ShadingAspect) aShadingAspect = anAttributes->ShadingAspect(); + if ( !aShadingAspect.IsNull() ) + { + Quantity_Color aFillingColor( getQuantityColorVal( myFillingColor.red() ), + getQuantityColorVal( myFillingColor.green() ), + getQuantityColorVal( myFillingColor.blue() ), + Quantity_TOC_RGB ); - aShadingAspect->SetColor( aFillingColor ); - aShadingAspect->SetTransparency( 1 - getQuantityColorVal( myFillingColor.alpha() ) ); + aShadingAspect->SetColor( aFillingColor ); + aShadingAspect->SetTransparency( 1 - getQuantityColorVal( myFillingColor.alpha() ) ); + } + } + else if ( myDisplayMode == AIS_WireFrame ) + { } // Coloring borders colorShapeBorder( getActiveColor() ); } - if ( !theIsForce || !myContext ) + if ( !theToDisplay || !isVisible() || myContext.IsNull() ) return; - myContext->Display( myShape ); + displayShape( theIsUpdateViewer ); +} + +void HYDROGUI_Shape::displayShape( const bool theIsUpdateViewer ) +{ + myContext->Display( myShape, Standard_False ); + + if ( myZLayer >= 0 ) + myContext->SetZLayer( myShape, myZLayer ); + + myContext->UpdateCurrentViewer(); } QColor HYDROGUI_Shape::getActiveColor() const @@ -343,25 +729,89 @@ void HYDROGUI_Shape::colorShapeBorder( const QColor& theColor ) if ( anAttributes.IsNull() ) return; - if ( theColor.alpha() == 0 ) + Quantity_Color aBorderColor( getQuantityColorVal( theColor.red() ), + getQuantityColorVal( theColor.green() ), + getQuantityColorVal( theColor.blue() ), + Quantity_TOC_RGB ); + + + if ( myTopoShape.ShapeType() == TopAbs_WIRE ) // Note that we display polylines in shaded mode + { + myShape->SetColor( aBorderColor ); + } else if ( myDisplayMode == AIS_Shaded ) + { + if ( theColor.alpha() == 0 ) + { + anAttributes->SetFaceBoundaryDraw( false ); + } + else + { + anAttributes->SetFaceBoundaryDraw( true ); + + Handle(Prs3d_LineAspect) aBoundaryAspect = anAttributes->FaceBoundaryAspect(); + if ( !aBoundaryAspect.IsNull() ) + { + aBoundaryAspect->SetColor( aBorderColor ); + anAttributes->SetFaceBoundaryAspect( aBoundaryAspect ); + } + Handle(Prs3d_LineAspect) aWireAspect = anAttributes->WireAspect(); + if ( !aWireAspect.IsNull() ) + { + aWireAspect->SetColor( aBorderColor ); + anAttributes->SetWireAspect( aWireAspect ); + } + } + } + else if ( myDisplayMode == AIS_WireFrame ) { - anAttributes->SetFaceBoundaryDraw( false ); + myShape->SetColor( aBorderColor ); } - else +} + +QString HYDROGUI_Shape::generateTextureFileName( const Handle(HYDROData_Entity)& theImageObj ) +{ + QString aResult; + if( !theImageObj.IsNull() ) { - Quantity_Color aBorderColor( getQuantityColorVal( theColor.red() ), - getQuantityColorVal( theColor.green() ), - getQuantityColorVal( theColor.blue() ), - Quantity_TOC_RGB ); + QString aTempDir = HYDROGUI_Tool::GetTempDir( true ); - anAttributes->SetFaceBoundaryDraw( true ); + int aStudyId = HYDROGUI_Tool::GetActiveStudyId(); + QString aPrefix = QString( "image_%1" ).arg( aStudyId ); - Handle(Prs3d_LineAspect) aBoundaryAspect = anAttributes->FaceBoundaryAspect(); - if ( !aBoundaryAspect.IsNull() ) - { - aBoundaryAspect->SetColor( aBorderColor ); - } + QString anEntry = HYDROGUI_DataObject::dataObjectEntry( theImageObj, false ); + anEntry.replace( ':', '_' ); + + QString anExtension = "bmp"; + + aResult = QString( "%1/%2_%3.%4" ).arg( aTempDir, aPrefix, anEntry, anExtension ); } + return aResult; } +void HYDROGUI_Shape::removeTextureFile() const +{ + QFile aFile( getTextureFileName() ); + if( aFile.exists() ) + aFile.remove(); +} +QImage HYDROGUI_Shape::reduceTexture( const QImage& theImage, const int theSizeLimit ) +{ + double aSizeLimit = (double)theSizeLimit; + double aWidth = (double)theImage.width(); + double aHeight = (double)theImage.height(); + if( aWidth > aSizeLimit || aHeight > aSizeLimit ) + { + if( aWidth > aHeight ) + { + aHeight /= ( aWidth / aSizeLimit ); + aWidth = aSizeLimit; + } + else + { + aWidth /= ( aHeight / aSizeLimit ); + aHeight = aSizeLimit; + } + } + return theImage.scaled( aWidth, aHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation ); +}