-#include <HYDROData_Image.h>
-#include <HYDROData_Iterator.h>
+
+#include "HYDROData_Image.h"
+
+#include "HYDROData_Document.h"
+#include "HYDROData_Tool.h"
+#include "HYDROData_OperationsFactory.h"
#include <TDataStd_RealArray.hxx>
-#include <TDataStd_IntegerArray.hxx>
#include <TDataStd_ByteArray.hxx>
+#include <TDataStd_Integer.hxx>
+#include <TDataStd_IntegerArray.hxx>
#include <TDataStd_ReferenceList.hxx>
-#include <TDF_ListIteratorOfLabelList.hxx>
+#include <TDataStd_Name.hxx>
+#include <TDataStd_UAttribute.hxx>
+#include <TDataStd_AsciiString.hxx>
+
+#include <ImageComposer_Operator.h>
+#include <ImageComposer_MetaTypes.h>
+
+#include <QStringList>
+
+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()
{
}
{
}
+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>() )
+ {
+ ImageComposer_Image anImage = anObj1.value<ImageComposer_Image>();
+ 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<ImageComposer_Image>( anImage );
+
+ return aVarData;
+}
+
void HYDROData_Image::SetImage(const QImage& theImage)
{
if (theImage.isNull()) {
aParams->SetValue(3, theImage.bytesPerLine());
aParams->SetValue(4, (int)(theImage.format()));
// store data of image in byte array
- Handle(TDataStd_ByteArray) aData;
- int aLen = theImage.byteCount();
- if (!myLab.FindAttribute(TDataStd_ByteArray::GetID(), aData)) {
- aData = TDataStd_ByteArray::Set(myLab, 1, aLen);
- }
- // copy bytes one by one
- const uchar* aBits = theImage.bits();
- if (aData->Length() != aLen) {
- Handle(TColStd_HArray1OfByte) aNewData = new TColStd_HArray1OfByte(1, aLen);
- for(int a = 0; a < aLen; a++)
- aNewData->SetValue(a + 1, aBits[a]);
- aData->ChangeArray(aNewData);
- } else {
- for(int a = 0; a < aLen; a++)
- aData->SetValue(a + 1, aBits[a]);
- }
+ const char* aData = (const char*)(theImage.bits());
+ 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;
- Handle(TDataStd_ByteArray) aData;
- if (!myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aParams) ||
- !myLab.FindAttribute(TDataStd_ByteArray::GetID(), aData))
+ if (!myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aParams))
+ return QImage(); // return empty image if there is no array
+ int aLen = 0;
+ uchar* anArray = (uchar*)ByteArray(0, aLen);
+ if (!aLen)
return QImage(); // return empty image if there is no array
- /*
- // make uchar array one by one
- int aLen = aData->Upper();
- uchar* anArray = new uchar[aLen];
- for(int a = 0; a < aLen; a++)
- anArray[a] = aData->Value(a + 1);
- // recreate image from integer parameters and array of bytes
- QImage aResult(anArray, aParams->Value(1), aParams->Value(2),
- aParams->Value(3), QImage::Format(aParams->Value(4)));
- delete [] anArray; <- this is wrong, because QImage references to this array
- */
- uchar* anArray = (uchar*)(void*)(&(aData->InternalArray()->ChangeArray1().ChangeValue(1)));
QImage aResult(anArray, aParams->Value(1), aParams->Value(2),
aParams->Value(3), QImage::Format(aParams->Value(4)));
-
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
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;
return aTrsf;
}
-void HYDROData_Image::AppendReference(Handle(HYDROData_Image) theReferenced)
+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_ReferenceList) aRefs;
- if (!myLab.FindAttribute(TDataStd_ReferenceList::GetID(), aRefs))
- aRefs = TDataStd_ReferenceList::Set(myLab);
- aRefs->Append(theReferenced->Label());
+ Handle(TDataStd_RealArray) anArray;
+ if (!myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) {
+ anArray = TDataStd_RealArray::Set(myLab.FindChild(DataTag_TrsfPoints), 1, 18);
+ }
+ 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());
}
-int HYDROData_Image::NbReferences()
+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_ReferenceList) aRefs;
- if (!myLab.FindAttribute(TDataStd_ReferenceList::GetID(), aRefs))
- return 0;
- return aRefs->Extent();
+ 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) );
+ }
}
-Handle(HYDROData_Image) HYDROData_Image::Reference(const int theIndex) const
+bool HYDROData_Image::HasTrsfPoints() 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_RealArray) anArray;
+ return myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray);
+}
- 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));
+void HYDROData_Image::SetTrsfMode(const int theMode)
+{
+ TDataStd_Integer::Set(myLab.FindChild(DataTag_TrsfMode), theMode);
+}
+
+int HYDROData_Image::TrsfMode() const
+{
+ 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 );
+}
+
+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)
+{
+ TDataStd_Name::Set(myLab.FindChild(DataTag_Operator),
+ TCollection_ExtendedString(theOpName.toLatin1().constData()));
+}
+
+QString HYDROData_Image::OperatorName() const
+{
+ Handle(TDataStd_Name) aName;
+ if (myLab.FindChild(DataTag_Operator).
+ FindAttribute(TDataStd_Name::GetID(), aName)) {
+ TCollection_AsciiString aStr(aName->Get());
+ return QString(aStr.ToCString());
+ }
+ return QString();
+}
+
+void HYDROData_Image::SetArgs(const QByteArray& theArgs)
+{
+ SaveByteArray(DataTag_Operator, theArgs.constData(), theArgs.length());
+}
+
+QByteArray HYDROData_Image::Args() const
+{
+ int aLen = 0;
+ const char* aData = ByteArray(DataTag_Operator, aLen);
+ if (!aLen)
+ return QByteArray();
+ 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) {
+ TDataStd_UAttribute::Set(myLab, GUID_SELF_SPLITTED);
+ } else {
+ myLab.ForgetAttribute(GUID_SELF_SPLITTED);
+ }
+}
+
+bool HYDROData_Image::IsSelfSplitted() const
+{
+ return myLab.IsAttribute(GUID_SELF_SPLITTED);
}