src/VISU_I/VISU_ColoredPrs3dCache_i.cc

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