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