src/HYDROData/HYDROData_Image.cxx

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