src/HYDROData/HYDROData_Image.cxx

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