X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Image.cxx;h=3556d543d3a04f24ae84648eb63d03f7012a7458;hb=c374597f70481110faa82dc189353d689d66bc0c;hp=8a94d751075b9b40b1b998b154324aee01b03ce9;hpb=41f291766eb87fc4ed3871fc89d3371581b8014d;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_Image.cxx b/src/HYDROData/HYDROData_Image.cxx index 8a94d751..3556d543 100644 --- a/src/HYDROData/HYDROData_Image.cxx +++ b/src/HYDROData/HYDROData_Image.cxx @@ -2,8 +2,9 @@ #include "HYDROData_Image.h" #include "HYDROData_Document.h" +#include "HYDROData_Lambert93.h" #include "HYDROData_Tool.h" -#include "HYDROOperations_Factory.h" +#include "HYDROData_OperationsFactory.h" #include #include @@ -19,15 +20,17 @@ #include -static const Standard_GUID GUID_MUST_BE_UPDATED("80f2bb81-3873-4631-8ddd-940d2119f000"); static const Standard_GUID GUID_SELF_SPLITTED("997995aa-5c19-40bf-9a60-ab4b70ad04d8"); +static const Standard_GUID GUID_HAS_LOCAL_POINTS("FD8841AA-FC44-42fa-B6A7-0F682CCC6F27"); +static const Standard_GUID GUID_HAS_GLOBAL_POINTS("330D0E81-742D-4ea3-92D4-484877CFA7C1"); #define PYTHON_IMAGE_ID "KIND_IMAGE" -IMPLEMENT_STANDARD_HANDLE(HYDROData_Image, HYDROData_Object) -IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Image, HYDROData_Object) +IMPLEMENT_STANDARD_HANDLE(HYDROData_Image, HYDROData_Entity) +IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Image, HYDROData_Entity) HYDROData_Image::HYDROData_Image() +: HYDROData_Entity() { } @@ -39,7 +42,7 @@ QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObject { QStringList aResList; - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this ); + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); if ( aDocument.IsNull() ) return aResList; @@ -57,62 +60,45 @@ QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObject aResList << QString( "" ); aResList << QString( "%1.LoadImage( \"%2\" );" ) .arg( anImageName ).arg( aFilePath ); - - // Dump transformation matrix for image aResList << QString( "" ); - QTransform aTrsf = Trsf(); - - aResList << QString( "trsf = QTransform( %1, %2, %3," ) - .arg( aTrsf.m11() ).arg( aTrsf.m12() ).arg( aTrsf.m13() ); - aResList << QString( " %1, %2, %3," ) - .arg( aTrsf.m21() ).arg( aTrsf.m22() ).arg( aTrsf.m23() ); - aResList << QString( " %1, %2, %3 );" ) - .arg( aTrsf.m31() ).arg( aTrsf.m32() ).arg( aTrsf.m33() ); - - aResList << QString( "%1.SetTrsf( trsf );" ).arg( anImageName ); - // Dump transformation points for image - aResList << QString( "" ); - - QPoint aPointA, aPointB, aPointC; - QPointF aLambertPointA, aLambertPointB, aLambertPointC; - QPointF aCartesianPointA, aCartesianPointB, aCartesianPointC; - TrsfPoints( aPointA, aPointB, aPointC, - aLambertPointA, aLambertPointB, aLambertPointC, - aCartesianPointA, aCartesianPointB, aCartesianPointC ); - - aResList << QString( "pa = QPoint( %1, %2 );" ) - .arg( aPointA.x() ).arg( aPointA.y() ); - - aResList << QString( "pb = QPoint( %1, %2 );" ) - .arg( aPointB.x() ).arg( aPointB.y() ); - - aResList << QString( "pc = QPoint( %1, %2 );" ) - .arg( aPointC.x() ).arg( aPointC.y() ); - - aResList << QString( "lpa = QPointF( %1, %2 );" ) - .arg( aLambertPointA.x() ).arg( aLambertPointA.y() ); - - aResList << QString( "lpb = QPointF( %1, %2 );" ) - .arg( aLambertPointB.x() ).arg( aLambertPointB.y() ); - aResList << QString( "lpc = QPointF( %1, %2 );" ) - .arg( aLambertPointC.x() ).arg( aLambertPointC.y() ); - - aResList << QString( "cpa = QPointF( %1, %2 );" ) - .arg( aCartesianPointA.x() ).arg( aCartesianPointA.y() ); + QString aGap = QString().fill( ' ', anImageName.size() + 16 ); - aResList << QString( "cpb = QPointF( %1, %2 );" ) - .arg( aCartesianPointB.x() ).arg( aCartesianPointB.y() ); + bool anIsByTwoPoints = IsByTwoPoints(); - aResList << QString( "cpc = QPointF( %1, %2 );" ) - .arg( aCartesianPointC.x() ).arg( aCartesianPointC.y() ); + QPoint aLocalPointA, aLocalPointB, aLocalPointC; + if ( GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC ) ) + { + aResList << QString( "%1.SetLocalPoints( QPoint( %2, %3 )," ) + .arg( anImageName ).arg( aLocalPointA.x() ).arg( aLocalPointA.y() ); + aResList << QString( aGap + "QPoint( %1, %2 )," ) + .arg( aLocalPointB.x() ).arg( aLocalPointB.y() ); + aResList << QString( aGap + "QPoint( %1, %2 ) );" ) + .arg( aLocalPointC.x() ).arg( aLocalPointC.y() ); + aResList << QString( "" ); + } - QString aGap = QString().fill( ' ', anImageName.size() + 16 ); - aResList << QString( "%1.SetTrsfPoints( pa, pb, pc," ).arg( anImageName ); - aResList << QString( aGap + "lpa, lpb, lpc," ); - aResList << QString( aGap + "cpa, cpb, cpc );" ); + HYDROData_Image::TransformationMode aTransformationMode; + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC; + if ( GetGlobalPoints( aTransformationMode, aTrsfPointA, aTrsfPointB, aTrsfPointC ) ) + { + aResList << QString( "%1.SetGlobalPoints( %2," ) + .arg( anImageName ).arg( aTransformationMode ); + aResList << QString( aGap + "QPointF( %1, %2 )," ) + .arg( aTrsfPointA.x() ).arg( aTrsfPointA.y() ); + aResList << QString( aGap + "QPointF( %1, %2 )," ) + .arg( aTrsfPointB.x() ).arg( aTrsfPointB.y() ); + aResList << QString( aGap + "QPointF( %1, %2 ) );" ) + .arg( aTrsfPointC.x() ).arg( aTrsfPointC.y() ); + + if ( aTransformationMode == ReferenceImage ) + { + Handle(HYDROData_Image) aRefImg = GetTrsfReferenceImage(); + setPythonReferenceObject( theTreatedObjects, aResList, aRefImg, "SetTrsfReferenceImage" ); + } + } } else { @@ -126,7 +112,8 @@ QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObject aResList << QString( "%1.SetOperatorName( \"%2\" );" ) .arg( anImageName ).arg( anOperatorName ); - ImageComposer_Operator* anImageOp = HYDROOperations_Factory::Factory()->Operator( this ); + ImageComposer_Operator* anImageOp = + HYDROData_OperationsFactory::Factory()->Operator( OperatorName() ); if ( anImageOp ) { // Dump operation arguments @@ -158,19 +145,18 @@ QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObject // Necessary to update image in case of composed operator aResList << QString( "" ); - aResList << QString( "%1.Update( False );" ).arg( anImageName ); + aResList << QString( "%1.Update();" ).arg( anImageName ); } return aResList; } -void HYDROData_Image::Update( const bool theIsForce ) +void HYDROData_Image::Update() { - HYDROOperations_Factory* aFactory = HYDROOperations_Factory::Factory(); + HYDROData_OperationsFactory* aFactory = HYDROData_OperationsFactory::Factory(); - // Update image only if there is an operation ImageComposer_Operator* anOp = aFactory->Operator( OperatorName() ); - if ( anOp ) + if ( anOp ) // Update image if there is an operation { // Fill by arguments and process the operation QVariant anObj1, anObj2; @@ -179,7 +165,7 @@ void HYDROData_Image::Update( const bool theIsForce ) if ( aNbReferences > 0 ) { // First referenced object - Handle(HYDROData_Object) aRefObj = Reference( 0 ); + Handle(HYDROData_Entity) aRefObj = Reference( 0 ); if ( !aRefObj.IsNull() ) { anObj1 = aRefObj->GetDataVariant(); @@ -195,7 +181,7 @@ void HYDROData_Image::Update( const bool theIsForce ) if ( aNbReferences > 1 ) { // Second referenced object - Handle(HYDROData_Object) aRefObj = Reference( 1 ); + Handle(HYDROData_Entity) aRefObj = Reference( 1 ); if ( !aRefObj.IsNull() ) anObj2 = aRefObj->GetDataVariant(); } @@ -203,17 +189,18 @@ void HYDROData_Image::Update( const bool theIsForce ) ImageComposer_Image aResImg = anOp->process( anObj1, anObj2 ); SetImage( aResImg ); } + else // Update image if it positioned relatively to other image + { + UpdateTrsf(); + } - if ( theIsForce ) + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( !aDocument.IsNull() ) { - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this ); - if ( !aDocument.IsNull() ) - { - // Change the states of this and all depended images - MustBeUpdated( true ); - HYDROData_Tool::SetMustBeUpdatedImages( aDocument ); - MustBeUpdated( false ); - } + // Change the states of this and all depended images + SetToUpdate( true ); + HYDROData_Tool::SetMustBeUpdatedImages( aDocument ); + SetToUpdate( false ); } } @@ -322,84 +309,365 @@ QTransform HYDROData_Image::Trsf() const return aTrsf; } -void HYDROData_Image::SetTrsfPoints(const QPoint& thePointA, - const QPoint& thePointB, - const QPoint& thePointC, - const QPointF& theLambertPointA, - const QPointF& theLambertPointB, - const QPointF& theLambertPointC, - const QPointF& theCartesianPointA, - const QPointF& theCartesianPointB, - const QPointF& theCartesianPointC) +void HYDROData_Image::UpdateTrsf() { - Handle(TDataStd_RealArray) anArray; - if (!myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) { - anArray = TDataStd_RealArray::Set(myLab.FindChild(DataTag_TrsfPoints), 1, 18); + QPoint aPointA, aPointB, aPointC; + if ( !GetLocalPoints( aPointA, aPointB, aPointC ) ) + return; + + TransformationMode aTrsfMode; + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC; + if ( !GetGlobalPoints( aTrsfMode, aTrsfPointA, aTrsfPointB, aTrsfPointC ) ) + return; + + QTransform aRefTransform; + Handle(HYDROData_Image) aRefImage = GetTrsfReferenceImage(); + + bool anIsRefImage = aTrsfMode == ReferenceImage; + if ( anIsRefImage ) + { + if ( aRefImage.IsNull() ) + return; + + aRefTransform = aRefImage->Trsf(); + } + + bool anIsByTwoPoints = IsByTwoPoints(); + + // Convert lambert coordinates to cartesian + if ( aTrsfMode == ManualLambert ) + { + double aXCart = 0, aYCart = 0; + + HYDROData_Lambert93::toXY( aTrsfPointA.x(), aTrsfPointA.y(), aXCart, aYCart ); + aTrsfPointA = QPointF( aXCart, aYCart ); + + HYDROData_Lambert93::toXY( aTrsfPointB.x(), aTrsfPointB.y(), aXCart, aYCart ); + aTrsfPointB = QPointF( aXCart, aYCart ); + + if ( !anIsByTwoPoints ) + { + HYDROData_Lambert93::toXY( aTrsfPointC.x(), aTrsfPointC.y(), aXCart, aYCart ); + aTrsfPointC = QPointF( aXCart, aYCart ); + } } - anArray->SetValue(1, thePointA.x()); - anArray->SetValue(2, thePointA.y()); - anArray->SetValue(3, thePointB.x()); - anArray->SetValue(4, thePointB.y()); - anArray->SetValue(5, thePointC.x()); - anArray->SetValue(6, thePointC.y()); - anArray->SetValue(7, theLambertPointA.x()); - anArray->SetValue(8, theLambertPointA.y()); - anArray->SetValue(9, theLambertPointB.x()); - anArray->SetValue(10, theLambertPointB.y()); - anArray->SetValue(11, theLambertPointC.x()); - anArray->SetValue(12, theLambertPointC.y()); - anArray->SetValue(13, theCartesianPointA.x()); - anArray->SetValue(14, theCartesianPointA.y()); - anArray->SetValue(15, theCartesianPointB.x()); - anArray->SetValue(16, theCartesianPointB.y()); - anArray->SetValue(17, theCartesianPointC.x()); - anArray->SetValue(18, theCartesianPointC.y()); -} - -void HYDROData_Image::TrsfPoints(QPoint& thePointA, - QPoint& thePointB, - QPoint& thePointC, - QPointF& theLambertPointA, - QPointF& theLambertPointB, - QPointF& theLambertPointC, - QPointF& theCartesianPointA, - QPointF& theCartesianPointB, - QPointF& theCartesianPointC) const + + // generate third points if needed + if ( anIsByTwoPoints ) + { + aPointC = generateThirdPoint( aPointA, aPointB, true ).toPoint(); + aTrsfPointC = generateThirdPoint( aTrsfPointA, aTrsfPointB, anIsRefImage ); + } + + int xa = aPointA.x(); + int ya = aPointA.y(); + int xb = aPointB.x(); + int yb = aPointB.y(); + int xc = aPointC.x(); + int yc = aPointC.y(); + + double xta = aTrsfPointA.x(); + double yta = aTrsfPointA.y(); + double xtb = aTrsfPointB.x(); + double ytb = aTrsfPointB.y(); + double xtc = aTrsfPointC.x(); + double ytc = aTrsfPointC.y(); + + // first, check that three input points don't belong to a single line + if( ( yb - ya ) * ( xc - xa ) == ( yc - ya ) * ( xb - xa ) ) + return; + + // the same check for the reference points + if( anIsRefImage && ( ( ytb - yta ) * ( xtc - xta ) == ( ytc - yta ) * ( xtb - xta ) ) ) + return; + + QTransform aTransform1( xa, ya, 1, xb, yb, 1, xc, yc, 1 ); + QTransform aTransform2( xta, yta, 1, xtb, ytb, 1, xtc, ytc, 1 ); + + bool anIsInvertible = false; + QTransform aTransform1Inverted = aTransform1.inverted( &anIsInvertible ); + if( !anIsInvertible ) + return; + + QTransform aResTransform = aTransform1Inverted * aTransform2; + if( anIsRefImage ) + aResTransform *= aRefTransform; + + SetTrsf( aResTransform ); +} + +bool HYDROData_Image::IsByTwoPoints() const +{ + if ( !HasLocalPoints() || !HasGlobalPoints() ) + return false; + + QPoint aPointA, aPointB, aPointC; + GetLocalPoints( aPointA, aPointB, aPointC ); + + return aPointC.x() < 0 && aPointC.y() < 0; +} + +bool HYDROData_Image::HasReferences() const +{ + Handle(HYDROData_Image) aRefImage = GetTrsfReferenceImage(); + int aNbReferences = NbReferences(); + + return !aRefImage.IsNull() || aNbReferences > 0; +} + +void HYDROData_Image::RemoveAllReferences() +{ + if ( !HasReferences() ) + return; + + Handle(HYDROData_Image) aRefImage = GetTrsfReferenceImage(); + if ( !aRefImage.IsNull() ) + { + RemoveTrsfReferenceImage(); + } + else + { + ClearReferences(); + SetOperatorName( "" ); + SetArgs( "" ); + SetIsSelfSplitted( false ); + } + + SetToUpdate( false ); + + bool anIsByTwoPoints = IsByTwoPoints(); + + QImage anImage = Image(); + if ( anImage.isNull() ) + return; + + // Set local points to default position + QPoint aLocalPointA = QPoint( 0, 0 ); + QPoint aLocalPointB = QPoint( anImage.width(), 0 ); + QPoint aLocalPointC = anIsByTwoPoints ? QPoint( INT_MIN, INT_MIN ) : QPoint( 0, anImage.height() ); + + SetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC, false ); + + // Calculate global points + QTransform aTransform = Trsf(); + + QPointF aTrsfPointA = QPointF( aTransform.map( aLocalPointA ) ); + QPointF aTrsfPointB = QPointF( aTransform.map( aLocalPointB ) ); + QPointF aTrsfPointC = anIsByTwoPoints ? QPointF( INT_MIN, INT_MIN ) : + QPointF( aTransform.map( aLocalPointC ) ); + + SetGlobalPoints( ManualCartesian, aTrsfPointA, aTrsfPointB, aTrsfPointC ); +} + +void HYDROData_Image::SetLocalPoints( const QPoint& thePointA, + const QPoint& thePointB, + const QPoint& thePointC, + const bool theIsUpdate ) { Handle(TDataStd_RealArray) anArray; - if (myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) { - thePointA = QPointF( anArray->Value(1), anArray->Value(2) ).toPoint(); - thePointB = QPointF( anArray->Value(3), anArray->Value(4) ).toPoint(); - thePointC = QPointF( anArray->Value(5), anArray->Value(6) ).toPoint(); - theLambertPointA = QPointF( anArray->Value(7), anArray->Value(8) ); - theLambertPointB = QPointF( anArray->Value(9), anArray->Value(10) ); - theLambertPointC = QPointF( anArray->Value(11), anArray->Value(12) ); - theCartesianPointA = QPointF( anArray->Value(13), anArray->Value(14) ); - theCartesianPointB = QPointF( anArray->Value(15), anArray->Value(16) ); - theCartesianPointC = QPointF( anArray->Value(17), anArray->Value(18) ); + if ( !myLab.FindChild( DataTag_TrsfPoints ).FindAttribute( TDataStd_RealArray::GetID(), anArray ) ) + anArray = TDataStd_RealArray::Set( myLab.FindChild( DataTag_TrsfPoints ), 1, 12 ); + + anArray->SetValue( 1, thePointA.x() ); + anArray->SetValue( 2, thePointA.y() ); + anArray->SetValue( 3, thePointB.x() ); + anArray->SetValue( 4, thePointB.y() ); + anArray->SetValue( 5, thePointC.x() ); + anArray->SetValue( 6, thePointC.y() ); + + TDataStd_UAttribute::Set( myLab.FindChild( DataTag_TrsfPoints ), GUID_HAS_LOCAL_POINTS ); + + if ( theIsUpdate ) + UpdateTrsf(); +} + +bool HYDROData_Image::GetLocalPoints( QPoint& thePointA, + QPoint& thePointB, + QPoint& thePointC ) const +{ + if ( !HasLocalPoints() ) + return false; + + Handle(TDataStd_RealArray) anArray; + myLab.FindChild( DataTag_TrsfPoints ).FindAttribute( TDataStd_RealArray::GetID(), anArray ); + + thePointA = QPointF( anArray->Value( 1 ), anArray->Value( 2 ) ).toPoint(); + thePointB = QPointF( anArray->Value( 3 ), anArray->Value( 4 ) ).toPoint(); + thePointC = QPointF( anArray->Value( 5 ), anArray->Value( 6 ) ).toPoint(); + + return true; +} + +bool HYDROData_Image::HasLocalPoints() const +{ + TDF_Label aLabel = myLab.FindChild( DataTag_TrsfPoints, false ); + if ( aLabel.IsNull() || !aLabel.IsAttribute( GUID_HAS_LOCAL_POINTS ) ) + return false; + + Handle(TDataStd_RealArray) anArray; + return aLabel.FindAttribute( TDataStd_RealArray::GetID(), anArray ); +} + + +void HYDROData_Image::SetGlobalPoints( const TransformationMode& theMode, + const QPointF& thePointA, + const QPointF& thePointB, + const QPointF& thePointC, + const bool theIsUpdate ) +{ + Handle(TDataStd_RealArray) anArray; + if ( !myLab.FindChild( DataTag_TrsfPoints ).FindAttribute( TDataStd_RealArray::GetID(), anArray ) ) + anArray = TDataStd_RealArray::Set( myLab.FindChild( DataTag_TrsfPoints ), 1, 12 ); + + anArray->SetValue( 7, thePointA.x() ); + anArray->SetValue( 8, thePointA.y() ); + anArray->SetValue( 9, thePointB.x() ); + anArray->SetValue( 10, thePointB.y() ); + anArray->SetValue( 11, thePointC.x() ); + anArray->SetValue( 12, thePointC.y() ); + + SetTrsfMode( theMode ); + + TDataStd_UAttribute::Set( myLab.FindChild( DataTag_TrsfPoints ), GUID_HAS_GLOBAL_POINTS ); + + if ( theIsUpdate ) + UpdateTrsf(); + + /* + if( anIsRefImage ) + { + aCPointA = QPointF( aTransform.map( aPointA ) ); + aCPointB = QPointF( aTransform.map( aPointB ) ); + aCPointC = QPointF( aTransform.map( aPointC ) ); + + // compute Lambert93 points + xca = aCPointA.x(); + yca = aCPointA.y(); + xcb = aCPointB.x(); + ycb = aCPointB.y(); + xcc = aCPointC.x(); + ycc = aCPointC.y(); + + double xla = 0, yla = 0, xlb = 0, ylb = 0, xlc = 0, ylc = 0; + HYDROData_Lambert93::toGeo( xca, yca, yla, xla ); + HYDROData_Lambert93::toGeo( xcb, ycb, ylb, xlb ); + HYDROData_Lambert93::toGeo( xcc, ycc, ylc, xlc ); + + aLPointA = QPointF( xla * 3600.0, yla * 3600.0 ); // convert degrees to seconds + aLPointB = QPointF( xlb * 3600.0, ylb * 3600.0 ); // convert degrees to seconds + aLPointC = QPointF( xlc * 3600.0, ylc * 3600.0 ); // convert degrees to seconds } + */ +} + +bool HYDROData_Image::GetGlobalPoints( TransformationMode& theMode, + QPointF& thePointA, + QPointF& thePointB, + QPointF& thePointC ) const +{ + if ( !HasGlobalPoints() ) + return false; + + theMode = GetTrsfMode(); + + Handle(TDataStd_RealArray) anArray; + myLab.FindChild( DataTag_TrsfPoints ).FindAttribute( TDataStd_RealArray::GetID(), anArray ); + + thePointA = QPointF( anArray->Value( 7 ), anArray->Value( 8 ) ); + thePointB = QPointF( anArray->Value( 9 ), anArray->Value( 10 ) ); + thePointC = QPointF( anArray->Value( 11 ), anArray->Value( 12 ) ); + + return true; } -bool HYDROData_Image::HasTrsfPoints() const +bool HYDROData_Image::HasGlobalPoints() const { + TDF_Label aLabel = myLab.FindChild( DataTag_TrsfPoints, false ); + if ( aLabel.IsNull() || !aLabel.IsAttribute( GUID_HAS_GLOBAL_POINTS ) ) + return false; + Handle(TDataStd_RealArray) anArray; - return myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray); + return aLabel.FindAttribute( TDataStd_RealArray::GetID(), anArray ); +} + +void HYDROData_Image::SetReferencePoints( const Handle(HYDROData_Image)& theRefImage, + const QPointF& thePointA, + const QPointF& thePointB, + const QPointF& thePointC, + const bool theIsUpdate ) +{ + SetTrsfReferenceImage( theRefImage ); + SetGlobalPoints( ReferenceImage, thePointA, thePointB, thePointC, theIsUpdate ); +} + +bool HYDROData_Image::GetReferencePoints( Handle(HYDROData_Image)& theRefImage, + QPointF& thePointA, + QPointF& thePointB, + QPointF& thePointC ) const +{ + if ( !HasReferencePoints() ) + return false; + + theRefImage = GetTrsfReferenceImage(); + + TransformationMode aMode; + GetGlobalPoints( aMode, thePointA, thePointB, thePointC ); + + return true; } -void HYDROData_Image::SetTrsfMode(const int theMode) +bool HYDROData_Image::HasReferencePoints() const { - TDataStd_Integer::Set(myLab.FindChild(DataTag_TrsfMode), theMode); + if ( !HasGlobalPoints() ) + return false; + + Handle(HYDROData_Image) aRefImage = GetTrsfReferenceImage(); + if ( aRefImage.IsNull() ) + return false; + + TransformationMode aTrsfMode = GetTrsfMode(); + if ( aTrsfMode != ReferenceImage ) + return false; + + return true; } -int HYDROData_Image::TrsfMode() const +void HYDROData_Image::SetTrsfMode( const TransformationMode& theMode ) { - Handle(TDataStd_Integer) aMode; - if(myLab.FindChild(DataTag_TrsfMode).FindAttribute(TDataStd_Integer::GetID(), aMode)) - return aMode->Get(); - return 0; + TDataStd_Integer::Set( myLab.FindChild( DataTag_TrsfMode ), (int)theMode ); } -void HYDROData_Image::AppendReference( const Handle(HYDROData_Object)& theReferenced ) +HYDROData_Image::TransformationMode HYDROData_Image::GetTrsfMode() const +{ + TransformationMode aResMode = ManualLambert; + + TDF_Label aLabel = myLab.FindChild( DataTag_TrsfPoints, false ); + if ( !aLabel.IsNull() ) + { + Handle(TDataStd_Integer) aMode; + if ( myLab.FindChild( DataTag_TrsfMode ).FindAttribute( TDataStd_Integer::GetID(), aMode ) ) + aResMode = (TransformationMode)aMode->Get(); + } + + return aResMode; +} + +void HYDROData_Image::SetTrsfReferenceImage( const Handle(HYDROData_Image)& theRefImage ) +{ + SetReferenceObject( theRefImage, DataTag_TrsfImage ); +} + +Handle(HYDROData_Image) HYDROData_Image::GetTrsfReferenceImage() const +{ + return Handle(HYDROData_Image)::DownCast( GetReferenceObject( DataTag_TrsfImage ) ); +} + +void HYDROData_Image::RemoveTrsfReferenceImage() +{ + return RemoveReferenceObject( DataTag_TrsfImage ); +} + +void HYDROData_Image::AppendReference( const Handle(HYDROData_Entity)& theReferenced ) { AddReferenceObject( theReferenced, 0 ); } @@ -409,13 +677,13 @@ int HYDROData_Image::NbReferences() const return NbReferenceObjects( 0 ); } -Handle(HYDROData_Object) HYDROData_Image::Reference( const int theIndex ) const +Handle(HYDROData_Entity) HYDROData_Image::Reference( const int theIndex ) const { return GetReferenceObject( 0, theIndex ); } void HYDROData_Image::ChangeReference( - const int theIndex, Handle(HYDROData_Object) theReferenced) + const int theIndex, Handle(HYDROData_Entity) theReferenced) { SetReferenceObject( theReferenced, 0, theIndex ); } @@ -461,20 +729,6 @@ QByteArray HYDROData_Image::Args() const return QByteArray(aData, aLen); } -void HYDROData_Image::MustBeUpdated(bool theFlag) -{ - if (theFlag) { - TDataStd_UAttribute::Set(myLab, GUID_MUST_BE_UPDATED); - } else { - myLab.ForgetAttribute(GUID_MUST_BE_UPDATED); - } -} - -bool HYDROData_Image::MustBeUpdated() const -{ - return myLab.IsAttribute(GUID_MUST_BE_UPDATED); -} - void HYDROData_Image::SetIsSelfSplitted(bool theFlag) { if (theFlag) { @@ -488,3 +742,28 @@ bool HYDROData_Image::IsSelfSplitted() const { return myLab.IsAttribute(GUID_SELF_SPLITTED); } + +QPointF HYDROData_Image::generateThirdPoint( const QPointF& thePointA, + const QPointF& thePointB, + const bool& theIsLocal ) const +{ + // Rotate vector to 90 degrees : clockwise - for local + // anticlockwise - for global + const double aTheta = theIsLocal ? -M_PI_2 : M_PI_2; + + QPointF aResPoint; + + // Move to (0,0) for correct rotation + double x = thePointB.x() - thePointA.x(); + double y = thePointB.y() - thePointA.y(); + + aResPoint.setX( x * cos( aTheta ) - y * sin( aTheta ) ); + aResPoint.setY( x * sin( aTheta ) + y * cos( aTheta ) ); + + // Move back to origin position + aResPoint.setX( aResPoint.x() + thePointA.x() ); + aResPoint.setY( aResPoint.y() + thePointA.y() ); + + return aResPoint; +} +