X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Image.cxx;h=ca01c6555c646d0b7083e3a118b7a871688941f8;hb=0d9decc8762a829f1bdc69048fab08122e441ec0;hp=a41cc26415820521fa13192f7b5471a25bdacd61;hpb=061386caa71490489a0475540932d9f2e48d77dc;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_Image.cxx b/src/HYDROData/HYDROData_Image.cxx index a41cc264..ca01c655 100644 --- a/src/HYDROData/HYDROData_Image.cxx +++ b/src/HYDROData/HYDROData_Image.cxx @@ -1,20 +1,34 @@ -#include -#include + +#include "HYDROData_Image.h" + +#include "HYDROData_Document.h" +#include "HYDROData_Tool.h" +#include "HYDROData_OperationsFactory.h" #include #include +#include #include #include #include #include -#include +#include + +#include +#include + +#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"); + +#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() { } @@ -22,6 +36,201 @@ HYDROData_Image::~HYDROData_Image() { } +QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const +{ + QStringList aResList; + + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this ); + if ( aDocument.IsNull() ) + return aResList; + + QString aDocName = aDocument->GetDocPyName(); + QString anImageName = GetName(); + + aResList << QString( "%1 = %2.CreateObject( %3 );" ) + .arg( anImageName ).arg( aDocName ).arg( PYTHON_IMAGE_ID ); + aResList << QString( "%1.SetName( \"%2\" );" ) + .arg( anImageName ).arg( anImageName ); + + QString aFilePath = GetFilePath(); + if ( !aFilePath.isEmpty() ) + { + 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() ); + + aResList << QString( "cpb = QPointF( %1, %2 );" ) + .arg( aCartesianPointB.x() ).arg( aCartesianPointB.y() ); + + aResList << QString( "cpc = QPointF( %1, %2 );" ) + .arg( aCartesianPointC.x() ).arg( aCartesianPointC.y() ); + + 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 );" ); + } + else + { + // Image is composed from other image(s) + + QString anOperatorName = OperatorName(); + if ( !anOperatorName.isEmpty() ) + { + aResList << QString( "" ); + + aResList << QString( "%1.SetOperatorName( \"%2\" );" ) + .arg( anImageName ).arg( anOperatorName ); + + ImageComposer_Operator* anImageOp = HYDROData_OperationsFactory::Factory()->Operator( this ); + if ( anImageOp ) + { + // Dump operation arguments + QString anOpArgsArrayName; + QStringList anOpArgs = anImageOp->dumpArgsToPython( anOpArgsArrayName ); + if ( !anOpArgs.isEmpty() ) + { + aResList << QString( "" ); + aResList << anOpArgs; + + aResList << QString( "" ); + aResList << QString( "%1.SetArgs( %2 );" ) + .arg( anImageName ).arg( anOpArgsArrayName ); + } + } + } + + int aNbReferences = NbReferences(); + if ( aNbReferences > 0 ) + { + aResList << QString( "" ); + + for ( int i = 0; i < aNbReferences; ++i ) + { + Handle(HYDROData_Image) aRefImg = Handle(HYDROData_Image)::DownCast( Reference( i ) ); + setPythonReferenceObject( theTreatedObjects, aResList, aRefImg, "AppendReference" ); + } + } + + // Necessary to update image in case of composed operator + aResList << QString( "" ); + aResList << QString( "%1.Update( False );" ).arg( anImageName ); + } + + return aResList; +} + +void HYDROData_Image::Update( const bool theIsForce ) +{ + HYDROData_OperationsFactory* aFactory = HYDROData_OperationsFactory::Factory(); + + // Update image only if there is an operation + ImageComposer_Operator* anOp = aFactory->Operator( OperatorName() ); + if ( anOp ) + { + // Fill by arguments and process the operation + QVariant anObj1, anObj2; + int aNbReferences = NbReferences(); + + if ( aNbReferences > 0 ) + { + // First referenced object + Handle(HYDROData_Entity) aRefObj = Reference( 0 ); + if ( !aRefObj.IsNull() ) + { + anObj1 = aRefObj->GetDataVariant(); + if ( !anObj1.isNull() && anObj1.canConvert() ) + { + ImageComposer_Image anImage = anObj1.value(); + QTransform aTransform = anImage.transform(); + SetTrsf( aTransform ); + } + } + } + + if ( aNbReferences > 1 ) + { + // Second referenced object + Handle(HYDROData_Entity) aRefObj = Reference( 1 ); + if ( !aRefObj.IsNull() ) + anObj2 = aRefObj->GetDataVariant(); + } + + ImageComposer_Image aResImg = anOp->process( anObj1, anObj2 ); + SetImage( aResImg ); + } + + if ( theIsForce ) + { + 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 ); + } + } +} + +QVariant HYDROData_Image::GetDataVariant() +{ + QTransform aTransform = Trsf(); + + ImageComposer_Image anImage = Image(); + anImage.setTransform( aTransform ); + + QVariant aVarData; + aVarData.setValue( anImage ); + + return aVarData; +} + void HYDROData_Image::SetImage(const QImage& theImage) { if (theImage.isNull()) { @@ -44,6 +253,13 @@ void HYDROData_Image::SetImage(const QImage& theImage) SaveByteArray(0, aData, theImage.byteCount()); } +bool HYDROData_Image::LoadImage(const QString& theFilePath) +{ + QImage anImage( theFilePath ); + SetImage( anImage ); + return !anImage.isNull(); +} + QImage HYDROData_Image::Image() { Handle(TDataStd_IntegerArray) aParams; @@ -58,6 +274,23 @@ QImage HYDROData_Image::Image() return aResult; } +void HYDROData_Image::SetFilePath(const QString& theFilePath) +{ + TCollection_AsciiString anAsciiStr( theFilePath.toStdString().c_str() ); + TDataStd_AsciiString::Set( myLab.FindChild( DataTag_FilePath ), anAsciiStr ); +} + +QString HYDROData_Image::GetFilePath() const +{ + QString aRes; + + Handle(TDataStd_AsciiString) anAsciiStr; + if ( myLab.FindChild( DataTag_FilePath ).FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) ) + aRes = QString( anAsciiStr->Get().ToCString() ); + + return aRes; +} + void HYDROData_Image::SetTrsf(const QTransform& theTrsf) { // locate 9 coeffs of matrix into the real array @@ -77,7 +310,7 @@ void HYDROData_Image::SetTrsf(const QTransform& theTrsf) anArray->SetValue(9, theTrsf.m33()); } -QTransform HYDROData_Image::Trsf() +QTransform HYDROData_Image::Trsf() const { // get 9 coeffs of matrix from the real array Handle(TDataStd_RealArray) anArray; @@ -90,120 +323,112 @@ QTransform HYDROData_Image::Trsf() return aTrsf; } -void HYDROData_Image::SetTrsfPoints(const QPoint& thePointAIn, - const QPoint& thePointBIn, - const QPoint& thePointCIn, - const QPointF& thePointAOut, - const QPointF& thePointBOut, - const QPointF& thePointCOut) +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) { 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 = TDataStd_RealArray::Set(myLab.FindChild(DataTag_TrsfPoints), 1, 18); } - anArray->SetValue(1, thePointAIn.x()); - anArray->SetValue(2, thePointAIn.y()); - anArray->SetValue(3, thePointBIn.x()); - anArray->SetValue(4, thePointBIn.y()); - anArray->SetValue(5, thePointCIn.x()); - anArray->SetValue(6, thePointCIn.y()); - anArray->SetValue(7, thePointAOut.x()); - anArray->SetValue(8, thePointAOut.y()); - anArray->SetValue(9, thePointBOut.x()); - anArray->SetValue(10, thePointBOut.y()); - anArray->SetValue(11, thePointCOut.x()); - anArray->SetValue(12, thePointCOut.y()); -} - -void HYDROData_Image::TrsfPoints(QPoint& thePointAIn, - QPoint& thePointBIn, - QPoint& thePointCIn, - QPointF& thePointAOut, - QPointF& thePointBOut, - QPointF& thePointCOut) + 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 { Handle(TDataStd_RealArray) anArray; if (myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) { - thePointAIn = QPointF( anArray->Value(1), anArray->Value(2) ).toPoint(); - thePointBIn = QPointF( anArray->Value(3), anArray->Value(4) ).toPoint(); - thePointCIn = QPointF( anArray->Value(5), anArray->Value(6) ).toPoint(); - thePointAOut = QPointF( anArray->Value(7), anArray->Value(8) ); - thePointBOut = QPointF( anArray->Value(9), anArray->Value(10) ); - thePointCOut = QPointF( anArray->Value(11), anArray->Value(12) ); + 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) ); } } -void HYDROData_Image::AppendReference(Handle(HYDROData_Image) theReferenced) +bool HYDROData_Image::HasTrsfPoints() const { - Handle(TDataStd_ReferenceList) aRefs; - if (!myLab.FindAttribute(TDataStd_ReferenceList::GetID(), aRefs)) - aRefs = TDataStd_ReferenceList::Set(myLab); - aRefs->Append(theReferenced->Label()); + Handle(TDataStd_RealArray) anArray; + return myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray); } -int HYDROData_Image::NbReferences() +void HYDROData_Image::SetTrsfMode(const int theMode) { - Handle(TDataStd_ReferenceList) aRefs; - if (!myLab.FindAttribute(TDataStd_ReferenceList::GetID(), aRefs)) - return 0; - return aRefs->Extent(); + TDataStd_Integer::Set(myLab.FindChild(DataTag_TrsfMode), theMode); } -Handle(HYDROData_Image) HYDROData_Image::Reference(const int theIndex) const +int HYDROData_Image::TrsfMode() const { - Handle(TDataStd_ReferenceList) aRefs; - if (!myLab.FindAttribute(TDataStd_ReferenceList::GetID(), aRefs)) - return Handle(HYDROData_Image)(); - if (theIndex < 0 || theIndex >= aRefs->Extent()) - return Handle(HYDROData_Image)(); + Handle(TDataStd_Integer) aMode; + if(myLab.FindChild(DataTag_TrsfMode).FindAttribute(TDataStd_Integer::GetID(), aMode)) + return aMode->Get(); + return 0; +} + +void HYDROData_Image::AppendReference( const Handle(HYDROData_Entity)& theReferenced ) +{ + AddReferenceObject( theReferenced, 0 ); +} - TDF_ListIteratorOfLabelList anIter(aRefs->List()); - for(int anIndex = 0; anIndex != theIndex; anIter.Next(), anIndex++); - const TDF_Label& aRefLab = anIter.Value(); - return Handle(HYDROData_Image)::DownCast(HYDROData_Iterator::Object(aRefLab)); +int HYDROData_Image::NbReferences() const +{ + return NbReferenceObjects( 0 ); +} + +Handle(HYDROData_Entity) HYDROData_Image::Reference( const int theIndex ) const +{ + return GetReferenceObject( 0, theIndex ); } void HYDROData_Image::ChangeReference( - const int theIndex, Handle(HYDROData_Image) theReferenced) -{ - Handle(TDataStd_ReferenceList) aRefs; - if (!myLab.FindAttribute(TDataStd_ReferenceList::GetID(), aRefs)) - aRefs = TDataStd_ReferenceList::Set(myLab); - if (theIndex >= aRefs->Extent()) { // for too big index append it just to the end - AppendReference(theReferenced); - } else { // remove and insert new - TDF_ListIteratorOfLabelList anIter(aRefs->List()); - int anIndex = 0; - for(; anIndex != theIndex; anIter.Next(), anIndex++); - const TDF_Label& aRemovedLab = anIter.Value(); - anIter.Next(); - aRefs->Remove(aRemovedLab); - if (anIter.More()) - aRefs->InsertBefore(theReferenced->Label(), anIter.Value()); - else - aRefs->Append(theReferenced->Label()); - } + const int theIndex, Handle(HYDROData_Entity) theReferenced) +{ + SetReferenceObject( theReferenced, 0, theIndex ); } void HYDROData_Image::RemoveReference(const int theIndex) { - Handle(TDataStd_ReferenceList) aRefs; - if (!myLab.FindAttribute(TDataStd_ReferenceList::GetID(), aRefs)) - return; // no references, nothing to remove - if (aRefs->Extent() == 1 && theIndex == 0) { // remove all if only one - ClearReferences(); - return; - } - TDF_ListIteratorOfLabelList anIter(aRefs->List()); - int anIndex = 0; - for(; anIndex != theIndex && anIter.More(); anIter.Next(), anIndex++); - if (anIter.More()) - aRefs->Remove(anIter.Value()); + RemoveReferenceObject( 0, theIndex ); } void HYDROData_Image::ClearReferences() { - myLab.ForgetAttribute(TDataStd_ReferenceList::GetID()); + ClearReferenceObjects( 0 ); } void HYDROData_Image::SetOperatorName(const QString theOpName) @@ -212,7 +437,7 @@ void HYDROData_Image::SetOperatorName(const QString theOpName) TCollection_ExtendedString(theOpName.toLatin1().constData())); } -QString HYDROData_Image::OperatorName() +QString HYDROData_Image::OperatorName() const { Handle(TDataStd_Name) aName; if (myLab.FindChild(DataTag_Operator). @@ -228,7 +453,7 @@ void HYDROData_Image::SetArgs(const QByteArray& theArgs) SaveByteArray(DataTag_Operator, theArgs.constData(), theArgs.length()); } -QByteArray HYDROData_Image::Args() +QByteArray HYDROData_Image::Args() const { int aLen = 0; const char* aData = ByteArray(DataTag_Operator, aLen); @@ -246,7 +471,21 @@ void HYDROData_Image::MustBeUpdated(bool theFlag) } } -bool HYDROData_Image::MustBeUpdated() +bool HYDROData_Image::MustBeUpdated() const { return myLab.IsAttribute(GUID_MUST_BE_UPDATED); } + +void HYDROData_Image::SetIsSelfSplitted(bool theFlag) +{ + if (theFlag) { + TDataStd_UAttribute::Set(myLab, GUID_SELF_SPLITTED); + } else { + myLab.ForgetAttribute(GUID_SELF_SPLITTED); + } +} + +bool HYDROData_Image::IsSelfSplitted() const +{ + return myLab.IsAttribute(GUID_SELF_SPLITTED); +}