src/HYDROData/HYDROData_Image.cxx

   1
   2 #include "HYDROData_Image.h"
   3
   4 #include "HYDROData_Document.h"
   5 #include "HYDROData_Tool.h"
   6 #include "HYDROOperations_Factory.h"
   7
   8 #include <TDataStd_RealArray.hxx>
   9 #include <TDataStd_ByteArray.hxx>
  10 #include <TDataStd_IntegerArray.hxx>
  11 #include <TDataStd_ReferenceList.hxx>
  12 #include <TDataStd_Name.hxx>
  13 #include <TDataStd_UAttribute.hxx>
  14 #include <TDataStd_AsciiString.hxx>
  15
  16 #include <ImageComposer_Operator.h>
  17 #include <ImageComposer_MetaTypes.h>
  18
  19 #include <QStringList>
  20
  21 static const Standard_GUID GUID_MUST_BE_UPDATED("80f2bb81-3873-4631-8ddd-940d2119f000");
  22 static const Standard_GUID GUID_SELF_SPLITTED("997995aa-5c19-40bf-9a60-ab4b70ad04d8");
  23
  24 #define PYTHON_IMAGE_ID "KIND_IMAGE"
  25
  26 IMPLEMENT_STANDARD_HANDLE(HYDROData_Image, HYDROData_Object)
  27 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Image, HYDROData_Object)
  28
  29 HYDROData_Image::HYDROData_Image()
  30 {
  31 }
  32
  33 HYDROData_Image::~HYDROData_Image()
  34 {
  35 }
  36
  37 QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
  38 {
  39   QStringList aResList;
  40
  41   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this );
  42   if ( aDocument.IsNull() )
  43     return aResList;
  44
  45   QString aDocName = aDocument->GetDocPyName();
  46   QString anImageName = GetName();
  47
  48   aResList << QString( "%1 = %2.CreateObject( %3 );" )
  49               .arg( anImageName ).arg( aDocName ).arg( PYTHON_IMAGE_ID );
  50   aResList << QString( "%1.SetName( \"%2\" );" )
  51               .arg( anImageName ).arg( anImageName );
  52
  53   QString aFilePath = GetFilePath();
  54   if ( !aFilePath.isEmpty() )
  55   {
  56     aResList << QString( "" );
  57     aResList << QString( "%1.LoadImage( \"%2\" );" )
  58                 .arg( anImageName ).arg( aFilePath );
  59
  60     // Dump transformation matrix for image
  61     aResList << QString( "" );
  62
  63     QTransform aTrsf = Trsf();
  64
  65     aResList << QString( "trsf = QTransform( %1, %2, %3," )
  66                 .arg( aTrsf.m11() ).arg( aTrsf.m12() ).arg( aTrsf.m13() );
  67     aResList << QString( "                   %1, %2, %3," )
  68                 .arg( aTrsf.m21() ).arg( aTrsf.m22() ).arg( aTrsf.m23() );
  69     aResList << QString( "                   %1, %2, %3 );" )
  70                 .arg( aTrsf.m31() ).arg( aTrsf.m32() ).arg( aTrsf.m33() );
  71
  72     aResList << QString( "%1.SetTrsf( trsf );" ).arg( anImageName );
  73
  74     // Dump transformation points for image
  75     aResList << QString( "" );
  76
  77     QPoint aPointAIn,  aPointBIn,  aPointCIn;
  78     QPointF aPointAOut, aPointBOut, aPointCOut;
  79     TrsfPoints( aPointAIn,  aPointBIn,  aPointCIn,
  80                 aPointAOut, aPointBOut, aPointCOut );
  81
  82     aResList << QString( "a_in = QPoint( %1, %2 );" )
  83                 .arg( aPointAIn.x() ).arg( aPointAIn.y() );
  84
  85     aResList << QString( "b_in = QPoint( %1, %2 );" )
  86                 .arg( aPointBIn.x() ).arg( aPointBIn.y() );
  87
  88     aResList << QString( "c_in = QPoint( %1, %2 );" )
  89                 .arg( aPointCIn.x() ).arg( aPointCIn.y() );
  90
  91     aResList << QString( "a_out = QPointF( %1, %2 );" )
  92                 .arg( aPointAOut.x() ).arg( aPointAOut.y() );
  93
  94     aResList << QString( "b_out = QPointF( %1, %2 );" )
  95                 .arg( aPointBOut.x() ).arg( aPointBOut.y() );
  96
  97     aResList << QString( "c_out = QPointF( %1, %2 );" )
  98                 .arg( aPointCOut.x() ).arg( aPointCOut.y() );
  99
 100     QString aGap = QString().fill( ' ', anImageName.size() + 16 );
 101     aResList << QString( "%1.SetTrsfPoints( a_in,  b_in,  c_in," ).arg( anImageName );
 102     aResList << QString( aGap            + "a_out, b_out, c_out );" );
 103   }
 104   else
 105   {
 106     // Image is composed from other image(s)
 107
 108     QString anOperatorName = OperatorName();
 109     if ( !anOperatorName.isEmpty() )
 110     {
 111       aResList << QString( "" );
 112
 113       aResList << QString( "%1.SetOperatorName( \"%2\" );" )
 114                   .arg( anImageName ).arg( anOperatorName );
 115
 116       ImageComposer_Operator* anImageOp = HYDROOperations_Factory::Factory()->Operator( this );
 117       if ( anImageOp )
 118       {
 119         // Dump operation arguments
 120         QString anOpArgsArrayName;
 121         QStringList anOpArgs = anImageOp->dumpArgsToPython( anOpArgsArrayName );
 122         if ( !anOpArgs.isEmpty() )
 123         {
 124           aResList << QString( "" );
 125           aResList << anOpArgs;
 126
 127           aResList << QString( "" );
 128           aResList << QString( "%1.SetArgs( %2 );" )
 129                       .arg( anImageName ).arg( anOpArgsArrayName );
 130         }
 131       }
 132     }
 133
 134     int aNbReferences = NbReferences();
 135     if ( aNbReferences > 0 )
 136     {
 137       aResList << QString( "" );
 138
 139       for ( int i = 0; i < aNbReferences; ++i )
 140       {
 141         Handle(HYDROData_Image) aRefImg = Handle(HYDROData_Image)::DownCast( Reference( i ) );
 142         setPythonReferenceObject( theTreatedObjects, aResList, aRefImg, "AppendReference" );
 143       }
 144     }
 145
 146     // Necessary to update image in case of composed operator
 147     aResList << QString( "" );
 148     aResList << QString( "%1.Update( False );" ).arg( anImageName );
 149   }
 150
 151   return aResList;
 152 }
 153
 154 void HYDROData_Image::Update( const bool theIsForce )
 155 {
 156   HYDROOperations_Factory* aFactory = HYDROOperations_Factory::Factory();
 157
 158   // Update image only if there is an operation
 159   ImageComposer_Operator* anOp = aFactory->Operator( OperatorName() );
 160   if ( anOp )
 161   {
 162     // Fill by arguments and process the operation
 163     QVariant anObj1, anObj2;
 164     int aNbReferences = NbReferences();
 165
 166     if ( aNbReferences > 0 )
 167     {
 168       // First referenced object
 169       Handle(HYDROData_Object) aRefObj = Reference( 0 );
 170       if ( !aRefObj.IsNull() )
 171       {
 172         anObj1 = aRefObj->GetDataVariant();
 173         if ( !anObj1.isNull() && anObj1.canConvert<ImageComposer_Image>() )
 174         {
 175           ImageComposer_Image anImage = anObj1.value<ImageComposer_Image>();
 176           QTransform aTransform = anImage.transform();
 177           SetTrsf( aTransform );
 178         }
 179       }
 180     }
 181
 182     if ( aNbReferences > 1 )
 183     {
 184       // Second referenced object
 185       Handle(HYDROData_Object) aRefObj = Reference( 1 );
 186       if ( !aRefObj.IsNull() )
 187         anObj2 = aRefObj->GetDataVariant();
 188     }
 189
 190     ImageComposer_Image aResImg = anOp->process( anObj1, anObj2 );
 191     SetImage( aResImg );
 192   }
 193
 194   if ( theIsForce )
 195   {
 196     Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this );
 197     if ( !aDocument.IsNull() )
 198     {
 199       // Change the states of this and all depended images
 200       MustBeUpdated( true );
 201       HYDROData_Tool::SetMustBeUpdatedImages( aDocument );
 202       MustBeUpdated( false );
 203     }
 204   }
 205 }
 206
 207 QVariant HYDROData_Image::GetDataVariant()
 208 {
 209   QTransform aTransform = Trsf();
 210
 211   ImageComposer_Image anImage = Image();
 212   anImage.setTransform( aTransform );
 213
 214   QVariant aVarData;
 215   aVarData.setValue<ImageComposer_Image>( anImage );
 216
 217   return aVarData;
 218 }
 219
 220 void HYDROData_Image::SetImage(const QImage& theImage)
 221 {
 222   if (theImage.isNull()) {
 223     // for empty image remove all previously stored attributes
 224     myLab.ForgetAttribute(TDataStd_IntegerArray::GetID());
 225     myLab.ForgetAttribute(TDataStd_ByteArray::GetID());
 226     return;
 227   }
 228   // store width, height, bytes per line and format in integer array
 229   Handle(TDataStd_IntegerArray) aParams;
 230   if (!myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aParams)) {
 231     aParams = TDataStd_IntegerArray::Set(myLab, 1, 4);
 232   }
 233   aParams->SetValue(1, theImage.width());
 234   aParams->SetValue(2, theImage.height());
 235   aParams->SetValue(3, theImage.bytesPerLine());
 236   aParams->SetValue(4, (int)(theImage.format()));
 237   // store data of image in byte array
 238   const char* aData = (const char*)(theImage.bits());
 239   SaveByteArray(0, aData, theImage.byteCount());
 240 }
 241
 242 bool HYDROData_Image::LoadImage(const QString& theFilePath)
 243 {
 244   QImage anImage( theFilePath );
 245   SetImage( anImage );
 246   return !anImage.isNull();
 247 }
 248
 249 QImage HYDROData_Image::Image()
 250 {
 251   Handle(TDataStd_IntegerArray) aParams;
 252   if (!myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aParams))
 253     return QImage(); // return empty image if there is no array
 254   int aLen = 0;
 255   uchar* anArray = (uchar*)ByteArray(0, aLen);
 256   if (!aLen)
 257     return QImage(); // return empty image if there is no array
 258   QImage aResult(anArray, aParams->Value(1), aParams->Value(2),
 259                  aParams->Value(3), QImage::Format(aParams->Value(4)));
 260   return aResult;
 261 }
 262
 263 void HYDROData_Image::SetFilePath(const QString& theFilePath)
 264 {
 265   TCollection_AsciiString anAsciiStr( theFilePath.toStdString().c_str() );
 266   TDataStd_AsciiString::Set( myLab.FindChild( DataTag_FilePath ), anAsciiStr );
 267 }
 268
 269 QString HYDROData_Image::GetFilePath() const
 270 {
 271   QString aRes;
 272
 273   Handle(TDataStd_AsciiString) anAsciiStr;
 274   if ( myLab.FindChild( DataTag_FilePath ).FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) )
 275     aRes = QString( anAsciiStr->Get().ToCString() );
 276
 277   return aRes;
 278 }
 279
 280 void HYDROData_Image::SetTrsf(const QTransform& theTrsf)
 281 {
 282   // locate 9 coeffs of matrix into the real array
 283   Handle(TDataStd_RealArray) anArray;
 284   if (!myLab.FindAttribute(TDataStd_RealArray::GetID(), anArray)) {
 285     if (theTrsf.isIdentity()) return; // no need to store identity transformation
 286     anArray = TDataStd_RealArray::Set(myLab, 1, 9);
 287   }
 288   anArray->SetValue(1, theTrsf.m11());
 289   anArray->SetValue(2, theTrsf.m12());
 290   anArray->SetValue(3, theTrsf.m13());
 291   anArray->SetValue(4, theTrsf.m21());
 292   anArray->SetValue(5, theTrsf.m22());
 293   anArray->SetValue(6, theTrsf.m23());
 294   anArray->SetValue(7, theTrsf.m31());
 295   anArray->SetValue(8, theTrsf.m32());
 296   anArray->SetValue(9, theTrsf.m33());
 297 }
 298
 299 QTransform HYDROData_Image::Trsf() const
 300 {
 301   // get 9 coeffs of matrix from the real array
 302   Handle(TDataStd_RealArray) anArray;
 303   if (!myLab.FindAttribute(TDataStd_RealArray::GetID(), anArray))
 304     return QTransform(); // return identity if there is no array
 305   QTransform aTrsf(
 306     anArray->Value(1), anArray->Value(2), anArray->Value(3),
 307     anArray->Value(4), anArray->Value(5), anArray->Value(6),
 308     anArray->Value(7), anArray->Value(8), anArray->Value(9));
 309   return aTrsf;
 310 }
 311
 312 void HYDROData_Image::SetTrsfPoints(const QPoint& thePointAIn,
 313                                     const QPoint& thePointBIn,
 314                                     const QPoint& thePointCIn,
 315                                     const QPointF& thePointAOut,
 316                                     const QPointF& thePointBOut,
 317                                     const QPointF& thePointCOut)
 318 {
 319   Handle(TDataStd_RealArray) anArray;
 320   if (!myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) {
 321     anArray = TDataStd_RealArray::Set(myLab.FindChild(DataTag_TrsfPoints), 1, 12);
 322   }
 323   anArray->SetValue(1, thePointAIn.x());
 324   anArray->SetValue(2, thePointAIn.y());
 325   anArray->SetValue(3, thePointBIn.x());
 326   anArray->SetValue(4, thePointBIn.y());
 327   anArray->SetValue(5, thePointCIn.x());
 328   anArray->SetValue(6, thePointCIn.y());
 329   anArray->SetValue(7, thePointAOut.x());
 330   anArray->SetValue(8, thePointAOut.y());
 331   anArray->SetValue(9, thePointBOut.x());
 332   anArray->SetValue(10, thePointBOut.y());
 333   anArray->SetValue(11, thePointCOut.x());
 334   anArray->SetValue(12, thePointCOut.y());
 335 }
 336
 337 void HYDROData_Image::TrsfPoints(QPoint& thePointAIn,
 338                                  QPoint& thePointBIn,
 339                                  QPoint& thePointCIn,
 340                                  QPointF& thePointAOut,
 341                                  QPointF& thePointBOut,
 342                                  QPointF& thePointCOut) const
 343 {
 344   Handle(TDataStd_RealArray) anArray;
 345   if (myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) {
 346     thePointAIn = QPointF( anArray->Value(1), anArray->Value(2) ).toPoint();
 347     thePointBIn = QPointF( anArray->Value(3), anArray->Value(4) ).toPoint();
 348     thePointCIn = QPointF( anArray->Value(5), anArray->Value(6) ).toPoint();
 349     thePointAOut = QPointF( anArray->Value(7), anArray->Value(8) );
 350     thePointBOut = QPointF( anArray->Value(9), anArray->Value(10) );
 351     thePointCOut = QPointF( anArray->Value(11), anArray->Value(12) );
 352   }
 353 }
 354
 355 bool HYDROData_Image::HasTrsfPoints() const
 356 {
 357   Handle(TDataStd_RealArray) anArray;
 358   return myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray);
 359 }
 360
 361 void HYDROData_Image::AppendReference( const Handle(HYDROData_Object)& theReferenced )
 362 {
 363   AddReferenceObject( theReferenced, 0 );
 364 }
 365
 366 int HYDROData_Image::NbReferences() const
 367 {
 368   return NbReferenceObjects( 0 );
 369 }
 370
 371 Handle(HYDROData_Object) HYDROData_Image::Reference( const int theIndex ) const
 372 {
 373   return GetReferenceObject( 0, theIndex );
 374 }
 375
 376 void HYDROData_Image::ChangeReference(
 377     const int theIndex, Handle(HYDROData_Object) theReferenced)
 378 {
 379   SetReferenceObject( theReferenced, 0, theIndex );
 380 }
 381
 382 void HYDROData_Image::RemoveReference(const int theIndex)
 383 {
 384   RemoveReferenceObject( 0, theIndex );
 385 }
 386
 387 void HYDROData_Image::ClearReferences()
 388 {
 389   ClearReferenceObjects( 0 );
 390 }
 391
 392 void HYDROData_Image::SetOperatorName(const QString theOpName)
 393 {
 394   TDataStd_Name::Set(myLab.FindChild(DataTag_Operator),
 395     TCollection_ExtendedString(theOpName.toLatin1().constData()));
 396 }
 397
 398 QString HYDROData_Image::OperatorName() const
 399 {
 400   Handle(TDataStd_Name) aName;
 401   if (myLab.FindChild(DataTag_Operator).
 402         FindAttribute(TDataStd_Name::GetID(), aName)) {
 403     TCollection_AsciiString aStr(aName->Get());
 404     return QString(aStr.ToCString());
 405   }
 406   return QString();
 407 }
 408
 409 void HYDROData_Image::SetArgs(const QByteArray& theArgs)
 410 {
 411   SaveByteArray(DataTag_Operator, theArgs.constData(), theArgs.length());
 412 }
 413
 414 QByteArray HYDROData_Image::Args() const
 415 {
 416   int aLen = 0;
 417   const char* aData = ByteArray(DataTag_Operator, aLen);
 418   if (!aLen)
 419     return QByteArray();
 420   return QByteArray(aData, aLen);
 421 }
 422
 423 void HYDROData_Image::MustBeUpdated(bool theFlag)
 424 {
 425   if (theFlag) {
 426     TDataStd_UAttribute::Set(myLab, GUID_MUST_BE_UPDATED);
 427   } else {
 428     myLab.ForgetAttribute(GUID_MUST_BE_UPDATED);
 429   }
 430 }
 431
 432 bool HYDROData_Image::MustBeUpdated() const
 433 {
 434   return myLab.IsAttribute(GUID_MUST_BE_UPDATED);
 435 }
 436
 437 void HYDROData_Image::SetIsSelfSplitted(bool theFlag)
 438 {
 439   if (theFlag) {
 440     TDataStd_UAttribute::Set(myLab, GUID_SELF_SPLITTED);
 441   } else {
 442     myLab.ForgetAttribute(GUID_SELF_SPLITTED);
 443   }
 444 }
 445
 446 bool HYDROData_Image::IsSelfSplitted() const
 447 {
 448   return myLab.IsAttribute(GUID_SELF_SPLITTED);
 449 }