Logo Search packages:      
Sourcecode: opencascade version File versions  Download package

SelectMgr_ViewerSelector.cxx

// Copyright:   Matra-Datavision 1995
// File:        SelectMgr_ViewerSelector.cxx
// Created:     Wed Feb 15 13:54:24 1995
// Author:      Roberc Coublanc
//              <rob>
// Modified by  ...
//              ROB JAN/07/98 : Improve Storage of detected entities
//              AGV OCT/23/03 : Optimize the method SortResult() (OCC4201)

#include <SelectMgr_ViewerSelector.ixx>
#include <SelectMgr_CompareResults.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Lin.hxx>
#include <Bnd_HArray1OfBox2d.hxx>
#include <Bnd_Array1OfBox2d.hxx>
#include <Precision.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TCollection_AsciiString.hxx>
#include <SelectBasics_ListIteratorOfListOfBox2d.hxx>
#include <SelectBasics_SensitiveEntity.hxx>
#include <SelectBasics_EntityOwner.hxx>
#include <SelectBasics_ListOfBox2d.hxx>
#include <SelectMgr_DataMapIteratorOfDataMapOfIntegerSensitive.hxx>
#include <SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation.hxx>
#include <SelectMgr_SortCriterion.hxx>
#include <Select3D_SensitiveEntity.hxx>
#include <SortTools_QuickSortOfInteger.hxx>
#include <OSD_Environment.hxx>

static Standard_Boolean SELDebugModeOn ()
{
  static OSD_Environment seldb("SELDEBUGMODE");
  return !seldb.Value().IsEmpty();
}

//==================================================
// Function: Initialize
// Purpose :
//==================================================
SelectMgr_ViewerSelector::SelectMgr_ViewerSelector():
toupdate(Standard_True),
tosort(Standard_True),
mytolerance(0.),
myCurRank(0),
lastx (Precision::Infinite()),
lasty (Precision::Infinite()),
myUpdateSortPossible( Standard_True )
{
//  OSD_Environment DBM("DEBUGMODE");
//  SelectMgr_debugmode = DBM.Value().IsEmpty();
}


//==================================================
// Function: Activate
// Purpose :
//==================================================
void SelectMgr_ViewerSelector::
Activate (const Handle(SelectMgr_Selection)& aSelection,
          const Standard_Boolean AutomaticProj)
{
  tosort = Standard_True;
  
  if (!myselections.IsBound(aSelection))
    {
      myselections.Bind(aSelection,0);
    } 
  else if (myselections(aSelection)!=0)
    {
      myselections(aSelection)= 0;
    }
  if(AutomaticProj)
    Convert(aSelection);
}


//==================================================
// Function: Deactivate
// Purpose :
//==================================================
void SelectMgr_ViewerSelector::
Deactivate (const Handle(SelectMgr_Selection)& aSel)
{
  if(myselections.IsBound(aSel))
    {myselections(aSel)=1;
     tosort = Standard_True;}
}





//==================================================
// Function: Sleep
// Purpose :
//==================================================
00098 void SelectMgr_ViewerSelector::Sleep()
{ SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation It(myselections);
  for (;It.More();It.Next()){
    if(It.Value()==0) myselections(It.Key())= 2;
  }
  UpdateSort();
}
//=======================================================================
//function : Sleep
//purpose  : 
//=======================================================================

void SelectMgr_ViewerSelector::Sleep(const Handle(SelectMgr_SelectableObject)& SO)
{ 
  
  for(SO->Init();SO->More();SO->Next()){
    if(myselections.IsBound(SO->CurrentSelection())){
      myselections(SO->CurrentSelection()) = 2;
    }
  }
  UpdateSort();
}


//==================================================
// Function: Awake
// Purpose :
//==================================================
00126 void SelectMgr_ViewerSelector::Awake(const Standard_Boolean AutomaticProj)
{
  SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation It(myselections);
  for (;It.More();It.Next()){
    if(It.Value()==2)
      myselections(It.Key())=0;
    if(AutomaticProj)
      UpdateConversion();
    UpdateSort();
  }
}

void SelectMgr_ViewerSelector::Awake(const Handle(SelectMgr_SelectableObject)& SO,
                                     const Standard_Boolean AutomaticProj)
{
  for(SO->Init();SO->More();SO->Next()){
    if(myselections.IsBound(SO->CurrentSelection())){
      myselections(SO->CurrentSelection()) =0;
      if(AutomaticProj)
        Convert(SO->CurrentSelection());
    }
  }
  
}
//==================================================
// Function: Clear
// Purpose :
//==================================================
00154 void SelectMgr_ViewerSelector::Clear()
{
  myentities.Clear();
  myselections.Clear();
  toupdate = Standard_True;
  tosort = Standard_True;
  mystored.Clear();
  lastx = Precision::Infinite();
  lasty = Precision::Infinite();

}

//==================================================
// Function: UpdateConversion
// Purpose :
//==================================================
00170 void SelectMgr_ViewerSelector::UpdateConversion()
{
  if(SELDebugModeOn())
    cout<<"\t\t\t\t\t SelectMgr_VS::UpdateConversion"<<endl;

  SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation It(myselections);
  for(;It.More();It.Next()){
    //Convert only if active...
    if(It.Value()==0)
      Convert(It.Key());
  }
  toupdate = Standard_False;
  tosort = Standard_True;
}


//==================================================
// Function: Convert
// Purpose :
//==================================================
void SelectMgr_ViewerSelector::
00191 Convert (const Handle(SelectMgr_Selection)& /*aSel*/) {tosort=Standard_True;}


//==================================================
// Function: UpdateSort
// Purpose :
//==================================================
void SelectMgr_ViewerSelector::UpdateSort()
{
  if( !myUpdateSortPossible )
     return;

  if(SELDebugModeOn())
    cout<<"\t\t\t\t\t SelectMgr_ViewerSelector::UpdateSort()"<<endl;
  mystored.Clear();
  myentities.Clear();
  myactivenb = NbBoxes();
  
  if(myactivenb > 0) {
    Standard_Boolean NoClip = myclip.IsVoid();
    Handle(Bnd_HArray1OfBox2d) refToTab = new Bnd_HArray1OfBox2d(1,myactivenb);
    Bnd_Array1OfBox2d & tab = refToTab->ChangeArray1();
    Standard_Real xmin=Precision::Infinite(),ymin=Precision::Infinite(),xmax=-Precision::Infinite(),ymax=-Precision::Infinite();
    Standard_Real curxmin,curymin,curxmax,curymax;
//    Standard_Integer boxindex=0,indexsel=0,indexprim=0;
    Standard_Integer boxindex=0;
    
    SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation It;
    SelectBasics_ListIteratorOfListOfBox2d LIt;
    Handle(SelectMgr_Selection) curEntity;
    Standard_Real ScaleFactor;
    for(It.Initialize(myselections);It.More();It.Next()){
      if(It.Value()== 0)
        { curEntity = It.Key();
          for(curEntity->Init();curEntity->More();curEntity->Next())
            {     
              static SelectBasics_ListOfBox2d BoxList;
              BoxList.Clear();
              curEntity->Sensitive()->Areas(BoxList);
              ScaleFactor = curEntity->Sensitive()->SensitivityFactor();

              
              for(LIt.Initialize(BoxList);LIt.More();LIt.Next()){
                boxindex++;

                tab.SetValue(boxindex,LIt.Value());
                
                tab(boxindex).SetGap(mytolerance*ScaleFactor);
                myentities.Bind(boxindex,curEntity->Sensitive());
#ifdef DEB
                Bnd_Box2d lastb =
#endif
                                  tab(boxindex);
                if(NoClip){
                  if (!tab(boxindex).IsVoid()) {
                    tab(boxindex).Get(curxmin,curymin,curxmax,curymax);
                    if(curxmin<xmin) xmin=curxmin;
                    if(curxmax>xmax) xmax=curxmax;
                    if(curymin<ymin) ymin=curymin;
                    if(curymax>ymax) ymax=curymax;
                  }
                }
              }
            }
        }
    }
    
    
    if(NoClip) {myclip.SetVoid();myclip.Update(xmin,ymin,xmax,ymax);}
    myselector.Initialize(myclip, mytolerance,refToTab);
    tosort = Standard_False;
    if(NoClip) myclip.SetVoid();
  }
}


//==================================================
// Function: Remove
// Purpose :
//==================================================
void SelectMgr_ViewerSelector::
00272 Remove(const Handle(SelectMgr_Selection)& aSel)
{
  if (myselections.IsBound(aSel))
    { myselections.UnBind(aSel);
      tosort = Standard_True;
    }
}

//==================================================
// Function: SetSensitivity
// Purpose :
//==================================================
00284 void SelectMgr_ViewerSelector::SetSensitivity(const Standard_Real aVal)
{mytolerance = aVal;
 tosort=Standard_True;}

//==================================================
// Function: SetClipping
// Purpose :
//==================================================
00292 void SelectMgr_ViewerSelector::SetClipping(const Standard_Real Xc,
                                          const Standard_Real Yc,
                                          const Standard_Real Height,
                                          const Standard_Real Width)
{
  Bnd_Box2d aClip;
  aClip.Set(gp_Pnt2d(Xc-Width/2, Yc-Height/2));
  aClip.Add(gp_Pnt2d(Xc+Width/2, Yc+Height/2));
  myclip = aClip;
  tosort = Standard_True;
}


//==================================================
// Function: SetClipping
// Purpose :
//==================================================
00309 void SelectMgr_ViewerSelector::SetClipping (const Bnd_Box2d& abox)
{myclip = abox;
 tosort = Standard_True;
}

//==================================================
// Function: InitSelect
// Purpose :
//==================================================
00318 void SelectMgr_ViewerSelector::InitSelect(const Standard_Real Xr,
                                          const Standard_Real Yr)
{
  Standard_OutOfRange_Raise_if(Abs(Xr-Precision::Infinite())<=Precision::Confusion() ||
                               Abs(Yr-Precision::Infinite())<=Precision::Confusion(),
                               " Infinite values in IniSelect");
  mystored.Clear();
  myprim.Clear();
  if (toupdate) UpdateConversion();
  if (tosort) UpdateSort();
  if(myactivenb!=0){
    myselector.InitSelect(Xr,Yr);
    if(myselector.More()) {lastx = Xr;lasty=Yr;}
    LoadResult();
  }
}

//==================================================
// Function: InitSelect
// Purpose :
//==================================================
00339 void SelectMgr_ViewerSelector::InitSelect(const Bnd_Box2d& aBox)
{
  mystored.Clear();
  if(toupdate) UpdateConversion();
  if (tosort) UpdateSort();
  if (myactivenb!=0){
    myselector.InitSelect(aBox);
    LoadResult(aBox);
  }
}

//==================================================
// Function: InitSelect
// Purpose :
//==================================================
00354 void SelectMgr_ViewerSelector::InitSelect(const Standard_Real Xmin,
                                          const Standard_Real Ymin,
                                          const Standard_Real Xmax,
                                          const Standard_Real Ymax)
{
  mystored.Clear();
  
  if (toupdate) UpdateConversion();
  if (tosort)   UpdateSort();
  if (myactivenb!=0){
    Bnd_Box2d aBox;
    aBox.Update(Xmin,Ymin,Xmax,Ymax);
    myselector.InitSelect(aBox);
    LoadResult(aBox);
  }
}

//==================================================
// Function: InitSelect
// Purpose : Polyline Selection
//==================================================
00375 void SelectMgr_ViewerSelector::InitSelect(const TColgp_Array1OfPnt2d& aPoly)
{
  mystored.Clear();
  
  if (toupdate) UpdateConversion();
  if (tosort)   UpdateSort();
  if (myactivenb!=0){
  // on utilise les Bnd box dans un premier temps  
    Bnd_Box2d aBox;
    Standard_Integer NbPnt = aPoly.Length();
    Standard_Integer i;
    for(i=1;i<=NbPnt;i++) {
      aBox.Update(aPoly(i).X(),aPoly(i).Y());
    }
    myselector.InitSelect(aBox);
    LoadResult(aPoly);
//    LoadResult(aBox);
  }
}


//==================================================
// Function: LoadResult
// Purpose : on laisse tomber pour l'instant la taille 
//          de la primitive dans les criteres de tri...
//          On prend la priorite, la profondeur et 
//         la distance mini au CDG ou Bords...
//==================================================
void SelectMgr_ViewerSelector::
LoadResult()
{
//  Handle(SelectMgr_EntityOwner)  OWNR;  
  if(myselector.More())
    {
//      Standard_Boolean Found(Standard_False);
      Standard_Real DMin;
      Standard_Integer nument;
      for(;myselector.More();myselector.Next()){
        nument = myselector.Value();
        const Handle(SelectBasics_SensitiveEntity)& SE = myentities(nument);
        if (SE->Matches(lastx,lasty,mytolerance,DMin)) { 
          const Handle(SelectBasics_EntityOwner)& OWNR = SE->OwnerId();

          if(!OWNR.IsNull()){
            Standard_Real TheDepth = SE->Depth();
            Standard_Integer Prior = OWNR->Priority();
            
            if(mystored.Contains(OWNR)){
              SelectMgr_SortCriterion& Crit = mystored.ChangeFromKey(OWNR);
              if(DMin<Crit.MinDist()) 
                Crit.SetMinDist(DMin);
              if(Abs(TheDepth)> Precision::Confusion()){
                if(TheDepth <= Crit.Depth())
                  Crit.SetDepth(TheDepth);
              }
              if(Prior>Crit.Priority())
                Crit.SetPriority(Prior);
            }
            else{
              SelectMgr_SortCriterion SC(Prior,TheDepth,DMin);
              mystored.Add(OWNR,SC);
              myprim.Append(nument);
            }
          }
        }
      }
      SortResult();
    }
  if(SELDebugModeOn()){
    cout<<"\tSelectMgr_VS:: Resultat du move"<<endl;
    cout<<"\tNb Detectes :"<<mystored.Extent()<<endl;
    for(Standard_Integer i=1;i<=mystored.Extent();i++){
      const SelectMgr_SortCriterion& Crit = mystored(myIndexes->Value(i));
      cout<<"\t"<<i<<" - Prior"<<Crit.Priority()<<" - prof :"<<Crit.Depth()<<"  - Dist. :"<<Crit.MinDist()<<endl;
    }
  }
}
//==================================================
// Function: LoadResult
// Purpose :
//==================================================
void SelectMgr_ViewerSelector::LoadResult(const Bnd_Box2d& abox)
{
  mystored.Clear();

//  Handle(SelectMgr_EntityOwner)  OWNR;  
  if(myselector.More())
    { Standard_Real xmin,ymin,xmax,ymax;
      abox.Get(xmin,ymin,xmax,ymax);
//      Standard_Boolean Found(Standard_False);
//      Standard_Real DMin=0.;
      Standard_Integer nument;
      for(;myselector.More();myselector.Next()){
        nument = myselector.Value();
        const Handle(SelectBasics_SensitiveEntity)& SE = myentities(nument);
        if (SE->Matches(xmin,ymin,xmax,ymax,0.0)){
          const Handle(SelectBasics_EntityOwner)& OWNR = SE->OwnerId();
          if(!OWNR.IsNull()){
            if(!mystored.Contains(OWNR)){
              SelectMgr_SortCriterion SC(OWNR->Priority(),Precision::Infinite(),Precision::Infinite());
              mystored.Add(OWNR,SC);
              myprim.Append(nument);
            }
          }
        }
      }

      // pas de tri a faire dans le cas d'une selection par rectangle elastique (BUG ANALYST)
      if(mystored.IsEmpty()) return; 
      if(myIndexes.IsNull()) 
        myIndexes = new TColStd_HArray1OfInteger(1,mystored.Extent()); 
      else if(mystored.Extent() !=myIndexes->Length()) 
        myIndexes = new TColStd_HArray1OfInteger (1,mystored.Extent()); 
      
      // pour travailler plus vite... 
      TColStd_Array1OfInteger& thearr = myIndexes->ChangeArray1(); 
      for(Standard_Integer I=1;I<=mystored.Extent();I++) 
        thearr(I)=I; 
    } 
}
//==================================================
// Function: LoadResult
// Purpose :
//==================================================
void SelectMgr_ViewerSelector::LoadResult(const TColgp_Array1OfPnt2d& aPoly)
{
  mystored.Clear();
  Bnd_Box2d aBox;
  Standard_Integer NbPnt = aPoly.Length();
  Standard_Integer i;
  for(i=1;i<=NbPnt;i++) {
    aBox.Update(aPoly(i).X(),aPoly(i).Y());
  }
  Standard_Integer NB=0;
//  Handle(SelectMgr_EntityOwner)  OWNR;  
  if(myselector.More())
    { 
      Standard_Integer nument;

      for(;myselector.More();myselector.Next()){
        NB++;
        nument = myselector.Value();
        const Handle(SelectBasics_SensitiveEntity)& SE = myentities(nument);
        if (SE->Matches(aPoly,aBox,0.0)){
          const Handle(SelectBasics_EntityOwner)& OWNR = SE->OwnerId();
          if(!OWNR.IsNull()){
            if(!mystored.Contains(OWNR)){
              SelectMgr_SortCriterion SC(OWNR->Priority(),Precision::Infinite(),Precision::Infinite());
              mystored.Add(OWNR,SC);
              myprim.Append(nument);
            }
          }
        }
      }

      if(mystored.IsEmpty()) return; 
      if(myIndexes.IsNull()) 
        myIndexes = new TColStd_HArray1OfInteger(1,mystored.Extent()); 
      else if(mystored.Extent() !=myIndexes->Length()) 
        myIndexes = new TColStd_HArray1OfInteger (1,mystored.Extent()); 
      
      // pour travailler plus vite... 
      TColStd_Array1OfInteger& thearr = myIndexes->ChangeArray1(); 
      for(Standard_Integer I=1;I<=mystored.Extent();I++) 
        thearr(I)=I; 
    }
}


//==================================================
// Function: HasStored
// Purpose :
//==================================================
Standard_Boolean SelectMgr_ViewerSelector::
00549 HasStored ()
{
  if(Abs(lastx-Precision::Infinite())<=Precision::Confusion()) return Standard_False;
  if(Abs(lasty-Precision::Infinite())<=Precision::Confusion()) return Standard_False;
  InitSelect(lastx,lasty);
  Init();
  return More();
}




//==================================================
// Function: Picked
// Purpose :
//==================================================
Handle(SelectMgr_EntityOwner) SelectMgr_ViewerSelector
::Picked() const
{
  Standard_Integer RankInMap = myIndexes->Value(myCurRank);
  const Handle(SelectBasics_EntityOwner)& toto = mystored.FindKey(RankInMap);
  Handle(SelectMgr_EntityOwner) Ownr = *((Handle(SelectMgr_EntityOwner)*) &toto);
  return Ownr;
}



//=======================================================================
//function : More
//purpose  : 
//=======================================================================
00580 Standard_Boolean SelectMgr_ViewerSelector::More() 
{
  if(mystored.Extent()==0) return Standard_False;
  if(myCurRank==0) return Standard_False;
  return myCurRank <= myIndexes->Length();
}

//==================================================
// Function: OnePicked
// Purpose : only the best one is chosen
//           depend on priority and mindist...
//==================================================

Handle(SelectMgr_EntityOwner) SelectMgr_ViewerSelector
::OnePicked()
{
  
  Init();
  if(More()){
    Standard_Integer RankInMap = myIndexes->Value(1);
    const Handle(SelectBasics_EntityOwner)& toto = mystored.FindKey(RankInMap);
    Handle(SelectMgr_EntityOwner) Ownr = *((Handle(SelectMgr_EntityOwner)*) &toto);
    return Ownr;
  }
  
  Handle (SelectMgr_EntityOwner) NullObj; //returns a null Handle if there was not successfull pick...
  return NullObj;
}


//=======================================================================
//function : NbPicked
//purpose  : 
//=======================================================================

00615 Standard_Integer SelectMgr_ViewerSelector::NbPicked() const
{
  return mystored.Extent();
}
//=======================================================================
//function : Picked
//purpose  : 
//=======================================================================
Handle(SelectMgr_EntityOwner) SelectMgr_ViewerSelector::Picked(const Standard_Integer aRank) const
{
  
  Handle(SelectMgr_EntityOwner) Own; 
  if (aRank<1 || aRank>NbPicked())
    return Own;
  Standard_Integer Indx = myIndexes->Value(aRank);
  
  
  const Handle(SelectBasics_EntityOwner)& toto = mystored.FindKey(Indx);
  Own = *((Handle(SelectMgr_EntityOwner)*) &toto);
  return Own;
}
//=======================================================================
//function : Primitive
//purpose  : 
//=======================================================================
Handle(SelectBasics_SensitiveEntity) SelectMgr_ViewerSelector::Primitive
                                        (const Standard_Integer /*Index*/) const
{
  return myentities(myprim(myCurRank));
}


//==================================================
// Function: LastPosition
// Purpose :
//==================================================
00651 void SelectMgr_ViewerSelector::LastPosition(Standard_Real& Xlast,
                                            Standard_Real& YLast) const
{   Xlast = lastx;YLast = lasty;} 



//===================================================
//
//       INTERNAL METHODS ....
//
//==================================================




//==================================================
// Function: NbBoxes
// Purpose :
//==================================================
Standard_Integer SelectMgr_ViewerSelector::NbBoxes()
{
  SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation It(myselections);
//  Standard_Integer Nbb=0, first,last;
  Standard_Integer Nbb=0;
  
  for(;It.More();It.Next()){
    if(It.Value()==0){
      for(It.Key()->Init();It.Key()->More();It.Key()->Next())
        {Nbb+= It.Key()->Sensitive()->MaxBoxes();}
    }
  }
  return Nbb;
}




//==================================================
// Function: Contains
// Purpose : 
//==================================================
Standard_Boolean SelectMgr_ViewerSelector::
Contains(const Handle(SelectMgr_SelectableObject)& anObject) const
{
  for (anObject->Init();anObject->More();anObject->Next()){
    if(myselections.IsBound(anObject->CurrentSelection()))
      return Standard_True;
  }
  return Standard_False;
}



//==================================================
// Function: ActiveModes
// Purpose : return all the  modes with a given state for an object
//==================================================


Standard_Boolean SelectMgr_ViewerSelector::
00711 Modes(const Handle(SelectMgr_SelectableObject)& SO,
      TColStd_ListOfInteger& TheActiveList,
      const SelectMgr_StateOfSelection WantedState) const 
{
  Standard_Boolean Found= Standard_False;
  for(SO->Init();SO->More();SO->Next()){
    if(myselections.IsBound(SO->CurrentSelection())){
      if(WantedState==SelectMgr_SOS_Any)
        TheActiveList.Append(SO->CurrentSelection()->Mode());
      else if( myselections(SO->CurrentSelection())==WantedState) 
        TheActiveList.Append(SO->CurrentSelection()->Mode());
      
      if(!Found) Found=Standard_True;
    }
  }
  return Found;
}


Standard_Boolean SelectMgr_ViewerSelector::
00731 IsActive(const Handle(SelectMgr_SelectableObject)& SO,
         const Standard_Integer aMode) const
{
  for(SO->Init();SO->More();SO->Next()){
    if(aMode==SO->CurrentSelection()->Mode()){
      if(myselections.IsBound(SO->CurrentSelection()) && 
         myselections(SO->CurrentSelection())==SelectMgr_SOS_Activated) 
        return Standard_True;
      else return Standard_False;
    }
  }
  return Standard_False;
}


Standard_Boolean SelectMgr_ViewerSelector::
00747 IsInside(const Handle(SelectMgr_SelectableObject)& SO,
         const Standard_Integer aMode) const
{
  for(SO->Init();SO->More();SO->Next()){
    if(aMode==SO->CurrentSelection()->Mode()){
      if(myselections.IsBound(SO->CurrentSelection())) return Standard_True;
      else return Standard_False;
      
    }
  }
  return Standard_False;
}


//=======================================================================
//function : Status
//purpose  : 
//=======================================================================

00766 SelectMgr_StateOfSelection SelectMgr_ViewerSelector::Status(const Handle(SelectMgr_Selection)& aSel) const 
{
  if(!myselections.IsBound(aSel)) return SelectMgr_SOS_Unknown;
//JR/Hp
  Standard_Integer ie = myselections(aSel) ;
  return SelectMgr_StateOfSelection( ie );
//  return SelectMgr_StateOfSelection(myselections(aSel));

}



//=======================================================================
//function : Dump
//purpose  : 
//=======================================================================

void SelectMgr_ViewerSelector::Dump(Standard_OStream& S) const
{
  S<<"=========================="<<endl;
  S<<" SelectMgr_ViewerSelector "<<endl;
  S<<"=========================="<<endl;
  S<<" "<<endl;
}



//==================================================
// Function: Status
// Purpose : gives Information about selectors
//==================================================

TCollection_AsciiString SelectMgr_ViewerSelector::
Status(const Handle(SelectMgr_SelectableObject)& SO) const
{
  TCollection_AsciiString Status("Status Objet :\n\t");
  Standard_Boolean Found= Standard_False;
  for(SO->Init();SO->More();SO->Next()){
    if(myselections.IsBound(SO->CurrentSelection()))
      {
        Found = Standard_True;
        Status = Status + "Mode " + 
          TCollection_AsciiString(SO->CurrentSelection()->Mode()) +
            " present - " ;
        if(myselections(SO->CurrentSelection())) 
          Status = Status + " Actif \n\t";
        else
          Status = Status + " Inactif \n\t";
      }
  }
  
  if(!Found) Status = Status + "Non Present dans le selecteur\n\n";
  return Status;
}


TCollection_AsciiString SelectMgr_ViewerSelector::
00823 Status () const 
{
  // les primitives sensibles presentes 
  //------------------------------------
  TCollection_AsciiString Status("\t\tSelector Status :\n\t");
  // les selections
  //---------------
  Standard_Integer NbActive =0,NbPrim=0;
  Status = Status + "Number of already computed selections : " + 
    TCollection_AsciiString(myselections.Extent());

  SelectMgr_DataMapIteratorOfDataMapOfSelectionActivation It(myselections);
  for(;It.More();It.Next())
    {
      if(It.Value()==0) {NbActive++;
                      for(It.Key()->Init();It.Key()->More();It.Key()->Next()){NbPrim++;}
                    }
    }
  Status = Status + " - " + TCollection_AsciiString(NbActive) + " activated ones\n\t";
  Status = Status + "Number of active sensitive primitives : " + 
    TCollection_AsciiString(NbPrim)+"\n\t";
  Status = Status + "Real stored Pick Tolerance : " + TCollection_AsciiString(mytolerance) +"\n\t";
  if(toupdate) {
  Status = Status + "\nWARNING : those informations will be obsolete for the next Pick\n"
    +"to get the real status of the selector - make One pick and call Status again\n";
    }
  return Status;
}

//=======================================================================
//function : SortResult
//purpose  :  on a un certain nombre d'entites rangees avec leur critere 
//            (profondeur, taille, priorite , distance de la souris 
//            par rapport aux bords ou au CDG de la primitive detectee.
//            on va trier :
//             les priorites maxi.
//             puis un savant dosage entre profondeur et distance...
// enfin on stocke dans myindexes les rangs en fonction de ce tri.
// il ne reste plus qu'a lire 
//=======================================================================
00863 void SelectMgr_ViewerSelector::SortResult()
{
  if(mystored.IsEmpty()) return;

  const Standard_Integer anExtent = mystored.Extent();
  if(myIndexes.IsNull() || anExtent != myIndexes->Length())
    myIndexes = new TColStd_HArray1OfInteger (1, anExtent);
  
  // pour travailler plus vite...
  TColStd_Array1OfInteger& thearr = myIndexes->ChangeArray1();

  // on charge les index de 1 a N
  Standard_Integer I ;
  for (I=1; I <= anExtent; I++)
    thearr(I)=I;
  
// OCC4201 (AGV): This loop is inefficient on large arrays, so I replace it
//                with a standard sort algo
//  // on trie suivant les criteres  (i) (Owner) (SortCriterion)
//  Standard_Boolean OKSort;
//  Standard_Integer temp,indx,indx1;
//  Standard_Integer tmprim;
//  // merci lbr...
//  do{
//    OKSort =Standard_True;
//    for(I=1;I<thearr.Length();I++){
//      indx = thearr(I);
//      indx1 = thearr(I+1);
//      if(mystored(indx) < mystored(indx1)){
//      OKSort = Standard_False;
//
//      temp = thearr(I+1);
//      thearr(I+1) = thearr (I);
//      thearr(I) = temp;
//
//      tmprim = myprim(I+1);
//      myprim(I+1) = myprim(I);
//      myprim(I) = tmprim;
//
//      }
//    }
//  } while (OKSort==Standard_False);
//
// OCC4201 (AGV): debut

  SortTools_QuickSortOfInteger::Sort (thearr,
                                      SelectMgr_CompareResults(mystored));
  TColStd_Array1OfInteger myPrimArr (1, myprim.Length());
  for (I = 1; I <= myPrimArr.Length(); I++)
    myPrimArr (I) = myprim (I);
  for (I = 1; I <= thearr.Length(); I++) {
    const Standard_Integer ind = thearr(I);
    if (ind > 0 && ind <= myPrimArr.Upper())
      myprim (I) = myPrimArr (ind);
  }
// OCC4201 (AGV): fin
  // ne nous restera plus qu'a recuperer les proprietaires correspondant aux index tries...
  
}


//=======================================================================
//function :
//purpose  : 
//=======================================================================
Standard_Boolean SelectMgr_ViewerSelector::IsUpdateSortPossible() const
{
  return myUpdateSortPossible;
}

//=======================================================================
//function :
//purpose  : 
//=======================================================================
void SelectMgr_ViewerSelector::SetUpdateSortPossible( const Standard_Boolean possible )
{
  myUpdateSortPossible = possible;
}

Generated by  Doxygen 1.6.0   Back to index