src/VISU_I/VISU_ColoredPrs3dCache_i.cc

   1 //  VISU OBJECT : interactive object for VISU entities implementation
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //  File   : VISU_ColoredPrs3dCache_i.cc
  24 //  Author : Oleg UVAROV
  25 //  Module : VISU
  26
  27 #include "VISU_ColoredPrs3dCache_i.hh"
  28
  29 #include "VISU_ColoredPrs3dHolder_i.hh"
  30 #include "VISU_ColoredPrs3dFactory.hh"
  31
  32 #include "VISU_ViewManager_i.hh"
  33 #include "VISU_View_i.hh"
  34 #include "VISU_Actor.h"
  35
  36 #include "VISU_PipeLine.hxx"
  37
  38 #include "SALOME_Event.hxx"
  39
  40 #include "VTKViewer_Algorithm.h"
  41 #include "SVTK_Functor.h"
  42
  43 #include "VVTK_ViewWindow.h"
  44 #include "SUIT_ResourceMgr.h"
  45
  46 #include <vtkRenderWindow.h>
  47
  48 #ifdef _DEBUG_
  49 static int MYDEBUG = 0;
  50 #else
  51 static int MYDEBUG = 0;
  52 #endif
  53
  54 namespace
  55 {
  56   //----------------------------------------------------------------------------
  57   inline
  58   bool
  59   IsSameField(const VISU::ColoredPrs3dHolder::BasicInput& theReferenceInput,
  60               const VISU::ColoredPrs3dHolder::BasicInput& thePrs3dInput)
  61   {
  62     return thePrs3dInput.myResult->_is_equivalent(theReferenceInput.myResult) &&
  63       thePrs3dInput.myEntity == theReferenceInput.myEntity &&
  64       !strcmp(thePrs3dInput.myFieldName.in(), theReferenceInput.myFieldName.in());
  65   }
  66
  67
  68   //----------------------------------------------------------------------------
  69   inline
  70   bool
  71   IsSameTimeStamp(const VISU::ColoredPrs3dHolder::BasicInput& theReferenceInput,
  72                   const VISU::ColoredPrs3dHolder::BasicInput& thePrs3dInput)
  73   {
  74     return IsSameField(theReferenceInput, thePrs3dInput) &&
  75       thePrs3dInput.myTimeStampNumber == theReferenceInput.myTimeStampNumber;
  76   }
  77
  78
  79   //----------------------------------------------------------------------------
  80   VISU::ColoredPrs3d_i*
  81   FindSameFieldPrs(const VISU::TColoredPrs3dHolderMap& theHolderMap,
  82                    const VISU::ColoredPrs3dHolder::BasicInput& theInput,
  83                    VISU::VISUType theType)
  84   {
  85     VISU::TColoredPrs3dHolderMap::const_iterator aHolderIter = theHolderMap.begin();
  86     VISU::TColoredPrs3dHolderMap::const_iterator aHolderIterEnd = theHolderMap.end();
  87     for(; aHolderIter != aHolderIterEnd; aHolderIter++){
  88       const VISU::TLastVisitedPrsList& aPrsList = aHolderIter->second;
  89       VISU::TLastVisitedPrsList::const_iterator aPrsIter = aPrsList.begin();
  90       VISU::TLastVisitedPrsList::const_iterator aPrsIterEnd = aPrsList.end();
  91       for(; aPrsIter != aPrsIterEnd; aPrsIter++){
  92         VISU::TPrs3dPtr aPrs3d = *aPrsIter;
  93         if(aPrs3d->GetType() != theType)
  94           break;
  95         VISU::ColoredPrs3dHolder::BasicInput_var anInput = aPrs3d->GetBasicInput();
  96         if(IsSameField(theInput, anInput))
  97           return aPrs3d;
  98       }
  99     }
 100     return NULL;
 101   }
 102
 103
 104   //----------------------------------------------------------------------------
 105   CORBA::Float
 106   EstimateMemorySize(const VISU::TColoredPrs3dHolderMap& theHolderMap,
 107                      const VISU::ColoredPrs3dHolder::BasicInput& theInput,
 108                      VISU::VISUType theType,
 109                      const size_t theRawEstimatedMemorySize)
 110   {
 111     VISU::ColoredPrs3d_i* aPrs3d = FindSameFieldPrs(theHolderMap, theInput, theType);
 112     if(aPrs3d)
 113       return aPrs3d->GetMemorySize();
 114     return CORBA::Float(theRawEstimatedMemorySize/(1024.0*1024.0)); // convert to Mb
 115   }
 116
 117
 118   //----------------------------------------------------------------------------
 119   bool
 120   SelectPrs3dToBeDeleted(CORBA::Float theRequiredMemory,
 121                          const std::string& theActiveHolderEntry,
 122                          const VISU::TColoredPrs3dHolderMap& theHolderMap,
 123                          VISU::TColoredPrs3dHolderMap& theColoredPrs3dHolderMap)
 124   {
 125     if( theRequiredMemory < 1.0 / VTK_LARGE_FLOAT )
 126       return false;
 127
 128     VISU::TColoredPrs3dHolderMap::const_iterator aHolderIter = theHolderMap.begin();
 129     VISU::TColoredPrs3dHolderMap::const_iterator aHolderIterEnd = theHolderMap.end();
 130
 131     // To calculate the maximum length of the cache history among all holders
 132     int anIteration = 0;
 133     for( ; aHolderIter != aHolderIterEnd; aHolderIter++ ){
 134       if( aHolderIter->first == theActiveHolderEntry )
 135         continue;
 136       const VISU::TLastVisitedPrsList& aPrsList = aHolderIter->second;
 137       anIteration = QMAX( aPrsList.size() - 1, anIteration );
 138     }
 139
 140     // To estimate what amount of memory can be obtained
 141     // by cleaning of non-active holder's presentation
 142     CORBA::Float aGatheredMemory = 0.0;
 143     for(; anIteration > 0; anIteration--){ // To take into account only non-devices
 144       aHolderIter = theHolderMap.begin();
 145       for(; aHolderIter != aHolderIterEnd; aHolderIter++ ){
 146         const std::string& aHolderEntry = aHolderIter->first;
 147         if( aHolderEntry == theActiveHolderEntry )
 148           continue;
 149         const VISU::TLastVisitedPrsList& aPrsList = aHolderIter->second;
 150         if( anIteration < aPrsList.size() ){
 151           VISU::TPrs3dPtr aPrs3d = aPrsList[anIteration];
 152           aGatheredMemory += aPrs3d->GetMemorySize();
 153           theColoredPrs3dHolderMap[aHolderEntry].push_back(aPrs3d);
 154           if( aGatheredMemory > theRequiredMemory )
 155             return true;
 156         }
 157       }
 158     }
 159
 160     // To estimate what amount of memory can be obtained
 161     // by cleaning of active holder's presentation
 162     if( theActiveHolderEntry != "" ){
 163       aHolderIter = theHolderMap.find( theActiveHolderEntry );
 164       if(aHolderIter == theHolderMap.end())
 165         return false;
 166
 167       const VISU::TLastVisitedPrsList& aPrsList = aHolderIter->second;
 168
 169       // To prefere "move" action instead of destroy / create presentation
 170       if(aPrsList.back()->GetMemorySize() >= theRequiredMemory)
 171         return false;
 172
 173       VISU::TLastVisitedPrsList::const_reverse_iterator aPrsIter = aPrsList.rbegin();
 174       // Do not porcess first item to avoid of the device destruction
 175       VISU::TLastVisitedPrsList::const_reverse_iterator aPrsIterEnd = aPrsList.rend()++;
 176       for(; aPrsIter != aPrsIterEnd; aPrsIter++){
 177         VISU::TPrs3dPtr aPrs3d = *aPrsIter;
 178         aGatheredMemory += aPrs3d->GetMemorySize();
 179         theColoredPrs3dHolderMap[theActiveHolderEntry].push_back(aPrs3d);
 180         if( aGatheredMemory > theRequiredMemory )
 181           return true;
 182       }
 183     }
 184
 185     return false;
 186   }
 187
 188
 189   //----------------------------------------------------------------------------
 190   void
 191   ErasePrs3d(VISU::TLastVisitedPrsList& thePrsList,
 192              const VISU::TPrs3dPtr& thePrs3d)
 193   {
 194     VISU::TLastVisitedPrsList::iterator anIter = thePrsList.begin();
 195     VISU::TLastVisitedPrsList::iterator aEndIter = thePrsList.end();
 196     for(; anIter != aEndIter; anIter++){
 197       VISU::TPrs3dPtr aPrs3d = *anIter;
 198       if(aPrs3d == thePrs3d)
 199         thePrsList.erase(anIter);
 200     }
 201   }
 202 }
 203
 204
 205 //----------------------------------------------------------------------------
 206 VISU::ColoredPrs3dCache_i
 207 ::ColoredPrs3dCache_i(SALOMEDS::Study_ptr theStudy,
 208                       bool thePublishInStudy):
 209   RemovableObject_i()
 210 {
 211   if(MYDEBUG) MESSAGE("ColoredPrs3dCache_i::ColoredPrs3dCache_i - this = "<<this);
 212   SetStudyDocument(theStudy);
 213
 214   SetName(GetFolderName(), false);
 215
 216   if( thePublishInStudy )
 217   {
 218     CORBA::String_var anIOR = GetID();
 219     SALOMEDS::SComponent_var aSComponent = VISU::FindOrCreateVisuComponent(theStudy);
 220     CORBA::String_var aFatherEntry = aSComponent->GetID();
 221     CreateAttributes(GetStudyDocument(), aFatherEntry.in(), "", anIOR.in(), GetName(), "", "", true);
 222   }
 223
 224   SUIT_ResourceMgr* aResourceMgr = VISU::GetResourceMgr();
 225
 226   int aMemoryMode = aResourceMgr->integerValue( "VISU", "cache_memory_mode", 0 );
 227   SetMemoryMode( aMemoryMode == 0 ? VISU::ColoredPrs3dCache::MINIMAL : VISU::ColoredPrs3dCache::LIMITED );
 228
 229   float aLimitedMemory = aResourceMgr->doubleValue( "VISU", "cache_memory_limit", 1024.0 );
 230   SetLimitedMemory( aLimitedMemory );
 231 }
 232
 233
 234 //----------------------------------------------------------------------------
 235 VISU::ColoredPrs3dCache_i
 236 ::~ColoredPrs3dCache_i()
 237 {
 238   if(MYDEBUG) MESSAGE("ColoredPrs3dCache_i::~ColoredPrs3dCache_i - this = "<<this);
 239 }
 240
 241
 242 //----------------------------------------------------------------------------
 243 const string VISU::ColoredPrs3dCache_i::myComment = "COLOREDPRS3DCACHE";
 244
 245 const char*
 246 VISU::ColoredPrs3dCache_i
 247 ::GetComment() const
 248 {
 249   return myComment.c_str();
 250 }
 251
 252
 253 //----------------------------------------------------------------------------
 254 CORBA::Float
 255 VISU::ColoredPrs3dCache_i
 256 ::GetMemorySize()
 257 {
 258   CORBA::Float aMemoryUsed = 0.0;
 259   TColoredPrs3dHolderMap::const_iterator aHolderIter = myHolderMap.begin();
 260   TColoredPrs3dHolderMap::const_iterator aHolderIterEnd = myHolderMap.end();
 261   for(; aHolderIter != aHolderIterEnd; aHolderIter++){
 262     const TLastVisitedPrsList& aPrsList = aHolderIter->second;
 263     TLastVisitedPrsList::const_iterator aPrsIter = aPrsList.begin();
 264     TLastVisitedPrsList::const_iterator aPrsIterEnd = aPrsList.end();
 265     for(; aPrsIter != aPrsIterEnd; aPrsIter++){
 266       if(TPrs3dPtr aPrs3d = *aPrsIter)
 267         aMemoryUsed += aPrs3d->GetMemorySize();
 268     }
 269   }
 270   return aMemoryUsed;
 271 }
 272
 273
 274 //----------------------------------------------------------------------------
 275 CORBA::Float
 276 VISU::ColoredPrs3dCache_i
 277 ::GetDeviceMemorySize()
 278 {
 279   CORBA::Float aMemoryUsed = 0.0;
 280   TColoredPrs3dHolderMap::const_iterator aHolderIter = myHolderMap.begin();
 281   TColoredPrs3dHolderMap::const_iterator aHolderIterEnd = myHolderMap.end();
 282   for(; aHolderIter != aHolderIterEnd; aHolderIter++){
 283     const TLastVisitedPrsList& aPrsList = aHolderIter->second;
 284     if(TPrs3dPtr aPrs3d = aPrsList.front())
 285       aMemoryUsed += aPrs3d->GetMemorySize();
 286   }
 287   return aMemoryUsed;
 288 }
 289
 290
 291 //----------------------------------------------------------------------------
 292 int
 293 VISU::ColoredPrs3dCache_i
 294 ::IsPossible(VISU::VISUType theType,
 295              const VISU::ColoredPrs3dHolder::BasicInput& theInput,
 296              CORBA::Float& theRequiredMemory,
 297              const std::string theHolderEntry)
 298 {
 299   size_t aRawEstimatedMemorySize = VISU::CheckIsPossible(theType, theInput, true);
 300   if(aRawEstimatedMemorySize > 0){
 301     if(GetMemoryMode() == VISU::ColoredPrs3dCache::LIMITED){
 302       CORBA::Float aMemoryUsed = GetMemorySize();
 303       CORBA::Float aMemoryLimit = GetLimitedMemory();
 304       CORBA::Float aMemoryNeeded = EstimateMemorySize(myHolderMap,
 305                                                       theInput,
 306                                                       theType,
 307                                                       aRawEstimatedMemorySize);
 308
 309       if( aMemoryUsed + aMemoryNeeded < aMemoryLimit )
 310         return true;
 311
 312       theRequiredMemory = aMemoryNeeded - ( aMemoryLimit - aMemoryUsed );
 313       TColoredPrs3dHolderMap aColoredPrs3dHolderMap;
 314       return SelectPrs3dToBeDeleted(theRequiredMemory,
 315                                     theHolderEntry,
 316                                     myHolderMap,
 317                                     aColoredPrs3dHolderMap);
 318     }
 319   }
 320   return aRawEstimatedMemorySize > 0;
 321 }
 322
 323
 324 //----------------------------------------------------------------------------
 325 VISU::ColoredPrs3dCache::EnlargeType
 326 VISU::ColoredPrs3dCache_i
 327 ::GetRequiredMemory(VISU::VISUType theType,
 328                     const VISU::ColoredPrs3dHolder::BasicInput& theInput,
 329                     CORBA::Float& theRequiredMemory)
 330 {
 331   VISU::ColoredPrs3dCache::EnlargeType anEnlargeType = VISU::ColoredPrs3dCache::NO_ENLARGE;
 332
 333   size_t aRawEstimatedMemorySize = VISU::CheckIsPossible(theType, theInput, true);
 334   if(aRawEstimatedMemorySize > 0){
 335     if(GetMemoryMode() == VISU::ColoredPrs3dCache::LIMITED){
 336       CORBA::Float aMemoryUsed = GetDeviceMemorySize();
 337       CORBA::Float aMemoryLimit = GetLimitedMemory();
 338       CORBA::Float aMemoryNeeded = EstimateMemorySize(myHolderMap,
 339                                                       theInput,
 340                                                       theType,
 341                                                       aRawEstimatedMemorySize);
 342       if( aMemoryUsed + aMemoryNeeded < aMemoryLimit )
 343         return anEnlargeType;
 344
 345       theRequiredMemory = int( aMemoryUsed + aMemoryNeeded ) + 1;
 346
 347       size_t aMb = 1024 * 1024;
 348       double aFreeMemory = double(VISU_PipeLine::GetAvailableMemory(2048*aMb)) / double(aMb);
 349       anEnlargeType = aMemoryNeeded < aFreeMemory ?
 350         VISU::ColoredPrs3dCache::ENLARGE : VISU::ColoredPrs3dCache::IMPOSSIBLE;
 351     }
 352   }
 353   return anEnlargeType;
 354 }
 355
 356
 357 //----------------------------------------------------------------------------
 358 VISU::ColoredPrs3dCache_i*
 359 VISU::ColoredPrs3dCache_i
 360 ::GetInstance_i(SALOMEDS::Study_ptr theStudy)
 361 {
 362   std::string aFolderName = VISU::ColoredPrs3dCache_i::GetFolderName();
 363   SALOMEDS::SObject_var aSObject = theStudy->FindObject(aFolderName.c_str());
 364   if(!CORBA::is_nil(aSObject)){
 365     CORBA::Object_var anObject = aSObject->GetObject();
 366     VISU::ColoredPrs3dCache_var aCache = VISU::ColoredPrs3dCache::_narrow(anObject);
 367     if(!CORBA::is_nil(aCache))
 368       return dynamic_cast<VISU::ColoredPrs3dCache_i*>(GetServant(aCache).in());
 369   }
 370
 371   return new VISU::ColoredPrs3dCache_i(theStudy);
 372 }
 373
 374
 375 VISU::ColoredPrs3dCache_ptr
 376 VISU::ColoredPrs3dCache_i
 377 ::GetInstance(SALOMEDS::Study_ptr theStudy)
 378 {
 379   VISU::ColoredPrs3dCache_i* aServant = GetInstance_i(theStudy);
 380   VISU::ColoredPrs3dCache_var anObject = aServant->_this();
 381   return anObject._retn();
 382 }
 383
 384
 385 //----------------------------------------------------------------------------
 386 VISU::ColoredPrs3dHolder_ptr
 387 VISU::ColoredPrs3dCache_i
 388 ::CreateHolder(VISU::VISUType theType,
 389                const VISU::ColoredPrs3dHolder::BasicInput& theInput)
 390 {
 391   if(MYDEBUG) cout << "CreateHolder " << theType << endl;
 392   CORBA::Float aRequiredMemory = 0.0;
 393   if(IsPossible(theType, theInput, aRequiredMemory, "")){
 394     if(VISU::ColoredPrs3d_i* aColoredPrs3d = CreateColoredPrs3d(theType, theInput)){
 395       VISU::ColoredPrs3dHolder_i* aHolder = new VISU::ColoredPrs3dHolder_i(*this);
 396       std::string aComment = std::string("myComment=") + aColoredPrs3d->GetComment();
 397       std::string aName = aColoredPrs3d->GenerateName().latin1();
 398       aHolder->PublishInStudy(aName, aColoredPrs3d->GetIconName(), aComment);
 399       RegisterInHolder(aColoredPrs3d, aHolder->GetEntry());
 400       if( aRequiredMemory > 1.0 / VTK_LARGE_FLOAT )
 401         ClearMemory( aRequiredMemory, aHolder->GetEntry() );
 402       return aHolder->_this();
 403     }
 404   }
 405   return VISU::ColoredPrs3dHolder::_nil();
 406 }
 407
 408
 409 //----------------------------------------------------------------------------
 410 void
 411 VISU::ColoredPrs3dCache_i
 412 ::SetMemoryMode(VISU::ColoredPrs3dCache::MemoryMode theMode)
 413 {
 414   VISU::ColoredPrs3dCache::MemoryMode aCurrentMode = GetMemoryMode();
 415
 416   if( aCurrentMode == VISU::ColoredPrs3dCache::LIMITED &&
 417       theMode == VISU::ColoredPrs3dCache::MINIMAL )
 418   {
 419     ClearCache();
 420   }
 421
 422   myMemoryMode = theMode;
 423   GetStudyDocument()->Modified();
 424 }
 425
 426 VISU::ColoredPrs3dCache::MemoryMode
 427 VISU::ColoredPrs3dCache_i
 428 ::GetMemoryMode()
 429 {
 430   return myMemoryMode;
 431 }
 432
 433
 434 //----------------------------------------------------------------------------
 435 void
 436 VISU::ColoredPrs3dCache_i
 437 ::SetLimitedMemory(CORBA::Float theMemorySize)
 438 {
 439   if( fabs( myLimitedMemory - theMemorySize ) < 1 / VTK_LARGE_FLOAT )
 440     return;
 441
 442   size_t aMb = 1024 * 1024;
 443   double aFreeMemory = double(VISU_PipeLine::GetAvailableMemory(2048*aMb)) / double(aMb);
 444   CORBA::Float aMemoryUsed = GetDeviceMemorySize();
 445   CORBA::Float aMemoryNeeded = theMemorySize - aMemoryUsed;
 446   if( aMemoryNeeded > aFreeMemory )
 447     return;
 448
 449   ClearCache(theMemorySize);
 450   myLimitedMemory = theMemorySize;
 451   GetStudyDocument()->Modified();
 452 }
 453
 454 CORBA::Float
 455 VISU::ColoredPrs3dCache_i
 456 ::GetLimitedMemory()
 457 {
 458   return myLimitedMemory;
 459 }
 460
 461
 462 void
 463 VISU::ColoredPrs3dCache_i
 464 ::RemoveFromStudy()
 465 {
 466   CORBA::String_var anIOR = GetID();
 467   SALOMEDS::SObject_var aSObject = GetStudyDocument()->FindObjectIOR(anIOR.in());
 468   VISU::RemoveFromStudy(aSObject, false, true);
 469   Destroy();
 470 }
 471
 472 std::string
 473 VISU::ColoredPrs3dCache_i
 474 ::GetFolderName()
 475 {
 476   return "3D Cache System";
 477 }
 478
 479 //----------------------------------------------------------------------------
 480 VISU::ColoredPrs3d_i*
 481 VISU::ColoredPrs3dCache_i
 482 ::CreateColoredPrs3d(VISU::VISUType theType,
 483                      VISU::ColoredPrs3dHolder::BasicInput theInput)
 484 {
 485   VISU::ColoredPrs3d_i* aPrs3d = VISU::CreatePrs3d_i(theType, GetStudyDocument(), ColoredPrs3d_i::ERegisterInCache);
 486   aPrs3d->SetResultObject( theInput.myResult );
 487   aPrs3d->SetMeshName( theInput.myMeshName );
 488   aPrs3d->SetEntity( theInput.myEntity );
 489   aPrs3d->SetFieldName( theInput.myFieldName );
 490   aPrs3d->SetTimeStampNumber( theInput.myTimeStampNumber );
 491   if(aPrs3d->Apply( false ))
 492     return aPrs3d;
 493   return NULL;
 494 }
 495
 496
 497 //----------------------------------------------------------------------------
 498 VISU::ColoredPrs3d_i*
 499 VISU::ColoredPrs3dCache_i
 500 ::RegisterInHolder(VISU::ColoredPrs3d_i* thePrs3d,
 501                    const std::string& theHolderEntry)
 502 {
 503   if(MYDEBUG) cout << "RegisterInHolder " << theHolderEntry.c_str() << " " << thePrs3d << endl;
 504   if(thePrs3d){
 505     TPrs3dPtr aPrs3d(thePrs3d);
 506     myHolderMap[theHolderEntry].push_front(aPrs3d);
 507     thePrs3d->SetHolderEntry( theHolderEntry );
 508     thePrs3d->Destroy();
 509   }
 510   return thePrs3d;
 511 }
 512
 513
 514 //----------------------------------------------------------------------------
 515 VISU::ColoredPrs3d_i*
 516 VISU::ColoredPrs3dCache_i
 517 ::CreatePrs(VISU::VISUType theType,
 518             VISU::ColoredPrs3dHolder::BasicInput theInput,
 519             VISU::ColoredPrs3dHolder_i* theHolder)
 520 {
 521   return RegisterInHolder(CreateColoredPrs3d(theType, theInput),
 522                           theHolder->GetEntry());
 523 }
 524
 525
 526 //----------------------------------------------------------------------------
 527 VISU::TLastVisitedPrsList&
 528 VISU::ColoredPrs3dCache_i
 529 ::GetLastVisitedPrsList(VISU::ColoredPrs3dHolder_i* theHolder)
 530 {
 531   return myHolderMap[theHolder->GetEntry()];
 532 }
 533
 534
 535 //----------------------------------------------------------------------------
 536 VISU::TPrs3dPtr
 537 VISU::ColoredPrs3dCache_i
 538 ::GetLastVisitedPrs(VISU::ColoredPrs3dHolder_i* theHolder)
 539 {
 540   const TLastVisitedPrsList& aList = GetLastVisitedPrsList(theHolder);
 541   if(MYDEBUG) cout << "GetLastVisitedPrs " << theHolder->GetEntry().c_str() << " " << aList.size() << endl;
 542   if( !aList.empty() )
 543     return aList.front();
 544   return VISU::TPrs3dPtr();
 545 }
 546
 547
 548 //----------------------------------------------------------------------------
 549 VISU::TPrs3dPtr
 550 VISU::ColoredPrs3dCache_i
 551 ::FindPrsByInput(TLastVisitedPrsList& theLastVisitedPrsList,
 552                  const VISU::ColoredPrs3dHolder::BasicInput& theInput)
 553 {
 554   TLastVisitedPrsList::iterator anIter = theLastVisitedPrsList.begin();
 555   TLastVisitedPrsList::iterator aEndIter = theLastVisitedPrsList.end();
 556   for(; anIter != aEndIter; anIter++){
 557     TPrs3dPtr aPrs3d = *anIter;
 558     VISU::ColoredPrs3dHolder::BasicInput_var anInput = aPrs3d->GetBasicInput();
 559     if(IsSameTimeStamp(theInput, anInput)){
 560       theLastVisitedPrsList.erase(anIter);
 561       return aPrs3d;
 562     }
 563   }
 564   return VISU::TPrs3dPtr();
 565 }
 566
 567 struct TFindActorEvent: public SALOME_Event
 568 {
 569   VISU::TPrs3dPtr myPrs3d;
 570   SVTK_ViewWindow* myViewWindow;
 571
 572   typedef VISU_Actor* TResult;
 573   TResult myResult;
 574
 575   TFindActorEvent(VISU::TPrs3dPtr thePrs3d, SVTK_ViewWindow* theViewWindow):
 576     myPrs3d(thePrs3d),
 577     myViewWindow(theViewWindow),
 578     myResult(NULL)
 579   {}
 580
 581   virtual
 582   void
 583   Execute()
 584   {
 585     myResult = VISU::FindActor(myViewWindow, myPrs3d);
 586   }
 587 };
 588
 589 struct TAddActorEvent: public SALOME_Event
 590 {
 591   VISU_Actor* myActor;
 592   SVTK_ViewWindow* myViewWindow;
 593 public:
 594   TAddActorEvent(VISU_Actor* theActor, SVTK_ViewWindow* theViewWindow):
 595     myActor(theActor),
 596     myViewWindow(theViewWindow)
 597   {}
 598   virtual void Execute(){
 599     myViewWindow->AddActor(myActor);
 600   }
 601 };
 602
 603 struct TRenderEvent: public SALOME_Event
 604 {
 605   SVTK_ViewWindow* myViewWindow;
 606 public:
 607   TRenderEvent(SVTK_ViewWindow* theViewWindow):
 608     myViewWindow(theViewWindow)
 609   {}
 610   virtual void Execute(){
 611     myViewWindow->getRenderWindow()->Render();
 612   }
 613 };
 614
 615 //----------------------------------------------------------------------------
 616 bool
 617 VISU::ColoredPrs3dCache_i
 618 ::UpdateLastVisitedPrs(VISU::ColoredPrs3dHolder_i* theHolder,
 619                        VISU::ColoredPrs3d_i* thePrs,
 620                        const VISU::ColoredPrs3dHolder::BasicInput& theInput,
 621                        VISU::View3D_ptr theView3D)
 622 {
 623   if(MYDEBUG) cout << "VISU::ColoredPrs3dCache_i::UpdateLastVisitedPrs" << endl;
 624   TPrs3dPtr aPrs3d;
 625   try{
 626     TPrs3dPtr aLastVisitedPrs3d = GetLastVisitedPrs(theHolder);
 627     TLastVisitedPrsList& aLastVisitedPrsList = GetLastVisitedPrsList(theHolder);
 628     bool anIsCheckPossible = GetMemoryMode() == VISU::ColoredPrs3dCache::LIMITED;
 629     std::string aHolderEntry = theHolder->GetEntry();
 630     VISU::VISUType aPrsType = theHolder->GetPrsType();
 631     CORBA::Float aRequiredMemory = 0.0;
 632     if(aPrs3d = FindPrsByInput(aLastVisitedPrsList, theInput)){
 633       aLastVisitedPrsList.push_front(aPrs3d);
 634       if(MYDEBUG) cout << "FindPrsByInput " << aPrs3d << endl;
 635     }else if(anIsCheckPossible && IsPossible(aPrsType, theInput, aRequiredMemory, aHolderEntry)){
 636       if( aRequiredMemory > 1.0 / VTK_LARGE_FLOAT )
 637         ClearMemory(aRequiredMemory, aHolderEntry);
 638       aPrs3d = CreatePrs(aPrsType, theInput, theHolder);
 639       if(MYDEBUG) cout << "Created " << aPrs3d << endl;
 640     }else{
 641       aPrs3d = aLastVisitedPrsList.back();
 642       aPrs3d->SetResultObject(theInput.myResult);
 643       aPrs3d->SetMeshName(theInput.myMeshName);
 644       aPrs3d->SetEntity(theInput.myEntity);
 645       aPrs3d->SetFieldName(theInput.myFieldName);
 646       aPrs3d->SetTimeStampNumber(theInput.myTimeStampNumber);
 647       aLastVisitedPrsList.pop_back();
 648       aLastVisitedPrsList.push_front(aPrs3d);
 649       if(MYDEBUG) cout << "Move only " << aPrs3d << endl;
 650     }
 651     //if(MYDEBUG) PrintCache();
 652
 653     aPrs3d->SameAs(thePrs);
 654     aPrs3d->UpdateActors();
 655     if(CORBA::is_nil(theView3D))
 656       return false;
 657
 658     PortableServer::ServantBase_var aServant = GetServant(theView3D);
 659     if(VISU::View3D_i* aView3d = dynamic_cast<VISU::View3D_i*>(aServant.in())){
 660       if(SUIT_ViewWindow* aView = aView3d->GetViewWindow()){
 661         if(SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>(aView)){
 662           // Find actor that corresponds to the holder
 663           VISU_Actor* anActor = ProcessEvent(new TFindActorEvent(aLastVisitedPrs3d,aViewWindow));
 664           //VISU_Actor* anActor = VISU::FindActor(aViewWindow, aLastVisitedPrs3d);
 665
 666           // If the holder was erased from view then do nothing
 667           if(anActor && !anActor->GetVisibility())
 668             return true;
 669
 670           if(!anActor)
 671           {
 672             anActor = aLastVisitedPrs3d->CreateActor();
 673             ProcessVoidEvent(new TAddActorEvent(anActor,aViewWindow));
 674             //aViewWindow->AddActor(anActor);
 675             anActor->SetVisibility(true);
 676           }
 677
 678           if(aPrs3d != aLastVisitedPrs3d)
 679           {
 680             // To erase non active presentation
 681             aLastVisitedPrs3d->SetActiveState(false);
 682             if(anActor)
 683               anActor->SetVisibility(false);
 684
 685             // To find the new one that corresponds to fresh presentation
 686             VISU_Actor* aNewActor = ProcessEvent(new TFindActorEvent(aPrs3d,aViewWindow));
 687             //VISU_Actor* aNewActor = VISU::FindActor(aViewWindow, aPrs3d);
 688             if(!aNewActor){
 689               aNewActor = aPrs3d->CreateActor();
 690               ProcessVoidEvent(new TAddActorEvent(aNewActor,aViewWindow));
 691               //aViewWindow->AddActor(aNewActor);
 692             }else
 693               aNewActor->SetVisibility(true);
 694             aNewActor->DeepCopy(anActor);
 695
 696             aPrs3d->SetActiveState(true);
 697           }
 698           ProcessVoidEvent(new TRenderEvent(aViewWindow));
 699           //aViewWindow->getRenderWindow()->Render();
 700           return true;
 701         }
 702       }
 703     }
 704   }catch(std::exception& exc){
 705     INFOS("Follow exception was occured :\n"<<exc.what());
 706   }catch(...){
 707     INFOS("Unknown exception was occured!");
 708   }
 709
 710   return false;
 711 }
 712
 713
 714 //----------------------------------------------------------------------------
 715 void
 716 VISU::ColoredPrs3dCache_i
 717 ::ClearCache(float theMemory)
 718 {
 719   CORBA::Float aCurrentMemory = GetMemorySize();
 720   ClearMemory( aCurrentMemory - theMemory, "" );
 721 }
 722
 723
 724 //----------------------------------------------------------------------------
 725 bool
 726 VISU::ColoredPrs3dCache_i
 727 ::ClearMemory(CORBA::Float theRequiredMemory,
 728               const std::string& theHolderEntry)
 729 {
 730   CORBA::Float aInitialMemorySize = GetMemorySize();
 731   TColoredPrs3dHolderMap aHolder2PrsToBeDeletedMap;
 732   SelectPrs3dToBeDeleted(theRequiredMemory, theHolderEntry, myHolderMap, aHolder2PrsToBeDeletedMap);
 733   TColoredPrs3dHolderMap::const_iterator aHolderIter = aHolder2PrsToBeDeletedMap.begin();
 734   TColoredPrs3dHolderMap::const_iterator anEndHolderIter = aHolder2PrsToBeDeletedMap.end();
 735   for(; aHolderIter != anEndHolderIter; aHolderIter++){
 736     const std::string aHolderEntry = aHolderIter->first;
 737     TColoredPrs3dHolderMap::iterator anHolderMapIter = myHolderMap.find(aHolderEntry);
 738     if(anHolderMapIter != myHolderMap.end()){
 739       TLastVisitedPrsList& aLastVisitedPrsList = anHolderMapIter->second;
 740
 741       const TLastVisitedPrsList& aPrsToBeDeletedList = aHolderIter->second;
 742       TLastVisitedPrsList::const_iterator anIter = aPrsToBeDeletedList.begin();
 743       TLastVisitedPrsList::const_iterator aEndIter = aPrsToBeDeletedList.end();
 744       for(; anIter != aEndIter; anIter++){
 745         TPrs3dPtr aPrs3d = *anIter;
 746         ErasePrs3d(aLastVisitedPrsList, aPrs3d);
 747       }
 748     }
 749   }
 750   CORBA::Float aCurrentMemory = GetMemorySize();
 751   return (aInitialMemorySize - aCurrentMemory >= theRequiredMemory);
 752 }
 753
 754
 755 //----------------------------------------------------------------------------
 756 void
 757 VISU::ColoredPrs3dCache_i
 758 ::PrintCache()
 759 {
 760   if(MYDEBUG)
 761   {
 762     cout << "--------------CACHE-----------------" << endl;
 763     cout << "Cache memory - " << GetMemorySize() << " Mb" << endl;
 764     TColoredPrs3dHolderMap::const_iterator aHolderIter = myHolderMap.begin();
 765     TColoredPrs3dHolderMap::const_iterator aHolderIterEnd = myHolderMap.end();
 766     for(; aHolderIter != aHolderIterEnd; aHolderIter++){
 767       const TLastVisitedPrsList& aPrsList = aHolderIter->second;
 768       TLastVisitedPrsList::const_iterator aPrsIter = aPrsList.begin();
 769       TLastVisitedPrsList::const_iterator aPrsIterEnd = aPrsList.end();
 770
 771       cout << "--------------------------" << endl;
 772       cout << "Holder - " << aHolderIter->first.c_str() << endl;
 773       cout << "Size   - " << aPrsList.size() << endl;
 774       for(; aPrsIter != aPrsIterEnd; aPrsIter++)
 775         if(TPrs3dPtr aPrs3d = *aPrsIter)
 776         {
 777           cout << aPrs3d << " (" << aPrs3d->GetMemorySize() << " Mb)";
 778           if(aPrsIter == aPrsList.begin())
 779             cout << " (device)";
 780           cout << endl;
 781         }
 782     }
 783     cout << "------------------------------------" << endl;
 784   }
 785 }
 786
 787
 788 //----------------------------------------------------------------------------
 789 void
 790 VISU::ColoredPrs3dCache_i
 791 ::RemoveHolder(VISU::ColoredPrs3dHolder_i* theHolder)
 792 {
 793   TColoredPrs3dHolderMap::iterator anIter = myHolderMap.find(theHolder->GetEntry());
 794   if(anIter != myHolderMap.end())
 795     myHolderMap.erase(anIter);
 796 }
 797
 798 //----------------------------------------------------------------------------
 799 void
 800 VISU::ColoredPrs3dCache_i
 801 ::ToStream(std::ostringstream& theStr)
 802 {
 803   Storable::DataToStream( theStr, "myMemoryMode", GetMemoryMode() );
 804   Storable::DataToStream( theStr, "myLimitedMemory", GetLimitedMemory() );
 805 }
 806
 807 //---------------------------------------------------------------
 808 VISU::Storable*
 809 VISU::ColoredPrs3dCache_i
 810 ::Restore(SALOMEDS::SObject_ptr theSObject,
 811           const Storable::TRestoringMap& theMap)
 812 {
 813   SetMemoryMode( (VISU::ColoredPrs3dCache::MemoryMode)VISU::Storable::FindValue( theMap, "myMemoryMode" ).toInt() );
 814   SetLimitedMemory( VISU::Storable::FindValue( theMap, "myLimitedMemory" ).toInt() );
 815
 816   return this;
 817 }
 818
 819 //---------------------------------------------------------------
 820 VISU::Storable*
 821 VISU::ColoredPrs3dCache_i
 822 ::StorableEngine(SALOMEDS::SObject_ptr theSObject,
 823                  const Storable::TRestoringMap& theMap,
 824                  const std::string& thePrefix,
 825                  CORBA::Boolean theIsMultiFile)
 826 {
 827   SALOMEDS::Study_var aStudy = theSObject->GetStudy();
 828   VISU::ColoredPrs3dCache_i* aCache = new VISU::ColoredPrs3dCache_i(aStudy, false);
 829   return aCache->Restore(theSObject, theMap);
 830 }