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         if ( aRefImg.IsNull() )
 143           continue;
 144
 145         QString aRefImgName = aRefImg->GetName();
 146
 147         // The definition of reference image must be dumped before this
 148         if ( !theTreatedObjects.contains( aRefImgName ) )
 149         {
 150           // Write definition of reference image
 151           QStringList aRefImgDump = aRefImg->DumpToPython( theTreatedObjects );
 152           if ( aRefImgDump.isEmpty() )
 153             continue;
 154
 155           QStringList aTmpList = aResList;
 156           aResList = aRefImgDump;
 157
 158           aResList.append( "" );
 159           aResList.append( aTmpList );
 160
 161           theTreatedObjects.insert( aRefImgName, aRefImg );
 162         }
 163
 164         aResList << QString( "%1.AppendReference( %2 );" )
 165                     .arg( anImageName ).arg( aRefImgName );
 166       }
 167     }
 168
 169     // Necessary to update image in case of composed operator
 170     aResList << QString( "" );
 171     aResList << QString( "%1.Update( False );" ).arg( anImageName );
 172   }
 173
 174   return aResList;
 175 }
 176
 177 void HYDROData_Image::Update( const bool theIsForce )
 178 {
 179   HYDROOperations_Factory* aFactory = HYDROOperations_Factory::Factory();
 180
 181   // Update image only if there is an operation
 182   ImageComposer_Operator* anOp = aFactory->Operator( OperatorName() );
 183   if ( anOp )
 184   {
 185     // Fill by arguments and process the operation
 186     QVariant anObj1, anObj2;
 187     int aNbReferences = NbReferences();
 188
 189     if ( aNbReferences > 0 )
 190     {
 191       // First referenced object
 192       Handle(HYDROData_Object) aRefObj = Reference( 0 );
 193       if ( !aRefObj.IsNull() )
 194       {
 195         anObj1 = aRefObj->GetDataVariant();
 196         if ( !anObj1.isNull() && anObj1.canConvert<ImageComposer_Image>() )
 197         {
 198           ImageComposer_Image anImage = anObj1.value<ImageComposer_Image>();
 199           QTransform aTransform = anImage.transform();
 200           SetTrsf( aTransform );
 201         }
 202       }
 203     }
 204
 205     if ( aNbReferences > 1 )
 206     {
 207       // Second referenced object
 208       Handle(HYDROData_Object) aRefObj = Reference( 1 );
 209       if ( !aRefObj.IsNull() )
 210         anObj2 = aRefObj->GetDataVariant();
 211     }
 212
 213     ImageComposer_Image aResImg = anOp->process( anObj1, anObj2 );
 214     SetImage( aResImg );
 215   }
 216
 217   if ( theIsForce )
 218   {
 219     Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this );
 220     if ( !aDocument.IsNull() )
 221     {
 222       // Change the states of this and all depended images
 223       MustBeUpdated( true );
 224       HYDROData_Tool::SetMustBeUpdatedImages( aDocument );
 225       MustBeUpdated( false );
 226     }
 227   }
 228 }
 229
 230 QVariant HYDROData_Image::GetDataVariant()
 231 {
 232   QTransform aTransform = Trsf();
 233
 234   ImageComposer_Image anImage = Image();
 235   anImage.setTransform( aTransform );
 236
 237   QVariant aVarData;
 238   aVarData.setValue<ImageComposer_Image>( anImage );
 239
 240   return aVarData;
 241 }
 242
 243 void HYDROData_Image::SetImage(const QImage& theImage)
 244 {
 245   if (theImage.isNull()) {
 246     // for empty image remove all previously stored attributes
 247     myLab.ForgetAttribute(TDataStd_IntegerArray::GetID());
 248     myLab.ForgetAttribute(TDataStd_ByteArray::GetID());
 249     return;
 250   }
 251   // store width, height, bytes per line and format in integer array
 252   Handle(TDataStd_IntegerArray) aParams;
 253   if (!myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aParams)) {
 254     aParams = TDataStd_IntegerArray::Set(myLab, 1, 4);
 255   }
 256   aParams->SetValue(1, theImage.width());
 257   aParams->SetValue(2, theImage.height());
 258   aParams->SetValue(3, theImage.bytesPerLine());
 259   aParams->SetValue(4, (int)(theImage.format()));
 260   // store data of image in byte array
 261   const char* aData = (const char*)(theImage.bits());
 262   SaveByteArray(0, aData, theImage.byteCount());
 263 }
 264
 265 bool HYDROData_Image::LoadImage(const QString& theFilePath)
 266 {
 267   QImage anImage( theFilePath );
 268   SetImage( anImage );
 269   return !anImage.isNull();
 270 }
 271
 272 QImage HYDROData_Image::Image()
 273 {
 274   Handle(TDataStd_IntegerArray) aParams;
 275   if (!myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aParams))
 276     return QImage(); // return empty image if there is no array
 277   int aLen = 0;
 278   uchar* anArray = (uchar*)ByteArray(0, aLen);
 279   if (!aLen)
 280     return QImage(); // return empty image if there is no array
 281   QImage aResult(anArray, aParams->Value(1), aParams->Value(2),
 282                  aParams->Value(3), QImage::Format(aParams->Value(4)));
 283   return aResult;
 284 }
 285
 286 void HYDROData_Image::SetFilePath(const QString& theFilePath)
 287 {
 288   TCollection_AsciiString anAsciiStr( theFilePath.toStdString().c_str() );
 289   TDataStd_AsciiString::Set( myLab.FindChild( DataTag_FilePath ), anAsciiStr );
 290 }
 291
 292 QString HYDROData_Image::GetFilePath() const
 293 {
 294   QString aRes;
 295
 296   Handle(TDataStd_AsciiString) anAsciiStr;
 297   if ( myLab.FindChild( DataTag_FilePath ).FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) )
 298     aRes = QString( anAsciiStr->Get().ToCString() );
 299
 300   return aRes;
 301 }
 302
 303 void HYDROData_Image::SetTrsf(const QTransform& theTrsf)
 304 {
 305   // locate 9 coeffs of matrix into the real array
 306   Handle(TDataStd_RealArray) anArray;
 307   if (!myLab.FindAttribute(TDataStd_RealArray::GetID(), anArray)) {
 308     if (theTrsf.isIdentity()) return; // no need to store identity transformation
 309     anArray = TDataStd_RealArray::Set(myLab, 1, 9);
 310   }
 311   anArray->SetValue(1, theTrsf.m11());
 312   anArray->SetValue(2, theTrsf.m12());
 313   anArray->SetValue(3, theTrsf.m13());
 314   anArray->SetValue(4, theTrsf.m21());
 315   anArray->SetValue(5, theTrsf.m22());
 316   anArray->SetValue(6, theTrsf.m23());
 317   anArray->SetValue(7, theTrsf.m31());
 318   anArray->SetValue(8, theTrsf.m32());
 319   anArray->SetValue(9, theTrsf.m33());
 320 }
 321
 322 QTransform HYDROData_Image::Trsf() const
 323 {
 324   // get 9 coeffs of matrix from the real array
 325   Handle(TDataStd_RealArray) anArray;
 326   if (!myLab.FindAttribute(TDataStd_RealArray::GetID(), anArray))
 327     return QTransform(); // return identity if there is no array
 328   QTransform aTrsf(
 329     anArray->Value(1), anArray->Value(2), anArray->Value(3),
 330     anArray->Value(4), anArray->Value(5), anArray->Value(6),
 331     anArray->Value(7), anArray->Value(8), anArray->Value(9));
 332   return aTrsf;
 333 }
 334
 335 void HYDROData_Image::SetTrsfPoints(const QPoint& thePointAIn,
 336                                     const QPoint& thePointBIn,
 337                                     const QPoint& thePointCIn,
 338                                     const QPointF& thePointAOut,
 339                                     const QPointF& thePointBOut,
 340                                     const QPointF& thePointCOut)
 341 {
 342   Handle(TDataStd_RealArray) anArray;
 343   if (!myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) {
 344     anArray = TDataStd_RealArray::Set(myLab.FindChild(DataTag_TrsfPoints), 1, 12);
 345   }
 346   anArray->SetValue(1, thePointAIn.x());
 347   anArray->SetValue(2, thePointAIn.y());
 348   anArray->SetValue(3, thePointBIn.x());
 349   anArray->SetValue(4, thePointBIn.y());
 350   anArray->SetValue(5, thePointCIn.x());
 351   anArray->SetValue(6, thePointCIn.y());
 352   anArray->SetValue(7, thePointAOut.x());
 353   anArray->SetValue(8, thePointAOut.y());
 354   anArray->SetValue(9, thePointBOut.x());
 355   anArray->SetValue(10, thePointBOut.y());
 356   anArray->SetValue(11, thePointCOut.x());
 357   anArray->SetValue(12, thePointCOut.y());
 358 }
 359
 360 void HYDROData_Image::TrsfPoints(QPoint& thePointAIn,
 361                                  QPoint& thePointBIn,
 362                                  QPoint& thePointCIn,
 363                                  QPointF& thePointAOut,
 364                                  QPointF& thePointBOut,
 365                                  QPointF& thePointCOut) const
 366 {
 367   Handle(TDataStd_RealArray) anArray;
 368   if (myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray)) {
 369     thePointAIn = QPointF( anArray->Value(1), anArray->Value(2) ).toPoint();
 370     thePointBIn = QPointF( anArray->Value(3), anArray->Value(4) ).toPoint();
 371     thePointCIn = QPointF( anArray->Value(5), anArray->Value(6) ).toPoint();
 372     thePointAOut = QPointF( anArray->Value(7), anArray->Value(8) );
 373     thePointBOut = QPointF( anArray->Value(9), anArray->Value(10) );
 374     thePointCOut = QPointF( anArray->Value(11), anArray->Value(12) );
 375   }
 376 }
 377
 378 bool HYDROData_Image::HasTrsfPoints() const
 379 {
 380   Handle(TDataStd_RealArray) anArray;
 381   return myLab.FindChild(DataTag_TrsfPoints).FindAttribute(TDataStd_RealArray::GetID(), anArray);
 382 }
 383
 384 void HYDROData_Image::AppendReference( const Handle(HYDROData_Object)& theReferenced )
 385 {
 386   AddReferenceObject( theReferenced, 0 );
 387 }
 388
 389 int HYDROData_Image::NbReferences() const
 390 {
 391   return NbReferenceObjects( 0 );
 392 }
 393
 394 Handle(HYDROData_Object) HYDROData_Image::Reference( const int theIndex ) const
 395 {
 396   return GetReferenceObject( 0, theIndex );
 397 }
 398
 399 void HYDROData_Image::ChangeReference(
 400     const int theIndex, Handle(HYDROData_Object) theReferenced)
 401 {
 402   SetReferenceObject( theReferenced, 0, theIndex );
 403 }
 404
 405 void HYDROData_Image::RemoveReference(const int theIndex)
 406 {
 407   RemoveReferenceObject( 0, theIndex );
 408 }
 409
 410 void HYDROData_Image::ClearReferences()
 411 {
 412   ClearReferenceObjects( 0 );
 413 }
 414
 415 void HYDROData_Image::SetOperatorName(const QString theOpName)
 416 {
 417   TDataStd_Name::Set(myLab.FindChild(DataTag_Operator),
 418     TCollection_ExtendedString(theOpName.toLatin1().constData()));
 419 }
 420
 421 QString HYDROData_Image::OperatorName() const
 422 {
 423   Handle(TDataStd_Name) aName;
 424   if (myLab.FindChild(DataTag_Operator).
 425         FindAttribute(TDataStd_Name::GetID(), aName)) {
 426     TCollection_AsciiString aStr(aName->Get());
 427     return QString(aStr.ToCString());
 428   }
 429   return QString();
 430 }
 431
 432 void HYDROData_Image::SetArgs(const QByteArray& theArgs)
 433 {
 434   SaveByteArray(DataTag_Operator, theArgs.constData(), theArgs.length());
 435 }
 436
 437 QByteArray HYDROData_Image::Args() const
 438 {
 439   int aLen = 0;
 440   const char* aData = ByteArray(DataTag_Operator, aLen);
 441   if (!aLen)
 442     return QByteArray();
 443   return QByteArray(aData, aLen);
 444 }
 445
 446 void HYDROData_Image::MustBeUpdated(bool theFlag)
 447 {
 448   if (theFlag) {
 449     TDataStd_UAttribute::Set(myLab, GUID_MUST_BE_UPDATED);
 450   } else {
 451     myLab.ForgetAttribute(GUID_MUST_BE_UPDATED);
 452   }
 453 }
 454
 455 bool HYDROData_Image::MustBeUpdated() const
 456 {
 457   return myLab.IsAttribute(GUID_MUST_BE_UPDATED);
 458 }
 459
 460 void HYDROData_Image::SetIsSelfSplitted(bool theFlag)
 461 {
 462   if (theFlag) {
 463     TDataStd_UAttribute::Set(myLab, GUID_SELF_SPLITTED);
 464   } else {
 465     myLab.ForgetAttribute(GUID_SELF_SPLITTED);
 466   }
 467 }
 468
 469 bool HYDROData_Image::IsSelfSplitted() const
 470 {
 471   return myLab.IsAttribute(GUID_SELF_SPLITTED);
 472 }