BFLWingedEdge.cxx

Go to the documentation of this file.

//                                                                   //
//authors: Costas Andreopoulos, Elias Athanasopoulos, George Tzanakos//
//                Physics Department, University of Athens           //
//                                                  October 28, 1999 //

    
#include <fstream>
#include "TObjArray.h"

#include "BField/TIntList.h"
#include "BField/BFLNode.h"
#include "BField/BFLVtx.h"
#include "BField/BFLEdge.h"
#include "BField/BFLPolyg.h"
#include "BField/BFLWingedEdge.h"
    
ClassImp(BFLWingedEdge)

BFLWingedEdge::BFLWingedEdge(Long_t ngens):
fNPolygons(0)
{ 
 
  // number of edges/vertices/polygons is estimated from 
  //Euler's formula. --See Okabe/Boots/Sugihara p. 217.


  //fEdges    = new TObjArray(3*ngens + 10);
  //fVertices = new TObjArray(2*ngens + 10);
  //fPolygons = new TObjArray(ngens + 10);
  // Apparently this is not large enough in some cases, although it's
  // hard to see why this should be so, except perhaps in a truly
  // pathological case. Nonetheless, here goes...

  fEdges    = new TObjArray(3*ngens + 100);
  fVertices = new TObjArray(2*ngens + 100);
  fPolygons = new TObjArray(ngens + 100);


  fAvailableVtxIDs  = new TIntList();
  fAvailableEdgeIDs = new TIntList(); 

  fGenerators = 0;

  fANSYSTable = 0;
}

BFLWingedEdge::~BFLWingedEdge()
{ 
  fEdges->Delete();    
  delete fEdges;

  fVertices->Delete();
  delete fVertices;

  fPolygons->Delete(); 
  delete fPolygons;

  if(fGenerators) {
    fGenerators->Delete();
    delete fGenerators;
  }
  
  delete fAvailableVtxIDs;
  delete fAvailableEdgeIDs;  
}

void BFLWingedEdge::AddEdge(Int_t EdgeSlot) { 

  fEdges->AddAtAndExpand(new BFLEdge(EdgeSlot), EdgeSlot); 
  
  // The slot of this object at its container is by default its EdgeID  
  Int_t EdgeID = EdgeSlot;
  SetEdgeID(EdgeSlot,EdgeID);
}  

void BFLWingedEdge::AddPolyg(Int_t PolySlot) { 

  fPolygons->AddAtAndExpand(new BFLPolyg(PolySlot), PolySlot); 

  // The slot of this object at its container is by default its PolyID  
  Int_t PolyID = PolySlot;
  SetPolygID(PolySlot,PolyID);
}  

void BFLWingedEdge::AddVtx(Int_t VtxSlot) { 

  fVertices->AddAtAndExpand(new BFLVtx(VtxSlot), VtxSlot); 

  // The slot of this object at its container is by default its VtxID  
  Int_t VtxID = VtxSlot;
  SetVtxID(VtxSlot,VtxID);
}  

void BFLWingedEdge::AddAvailableVtxID(Int_t id)
{
  fAvailableVtxIDs -> Add(id);
  fAvailableVtxIDs -> Sort();
}

Int_t BFLWingedEdge::FirstAvailableVtxID(void) const
{
// Returns the first availabe vertex id to be assigned to a newly
// added vertex. This can not simply accomodated with a counter of
// existing vertices because when we delete a Voronoi substructure,
// vertices are deleted so unwanted gaps are introduced. We must
// refill these gaps before assigning new vertex ids.

  Int_t vtx;

  fAvailableVtxIDs->Sort();
  vtx = fAvailableVtxIDs->First();

  return vtx;
}

Int_t BFLWingedEdge::MaxAvailableVtxID(void) const
{
  fAvailableVtxIDs->Sort();
  return fAvailableVtxIDs->Last();
}

void BFLWingedEdge::DeleteFirstAvailableVtxID(void)
{
// Removes the first available vtx id

  Int_t NextID;

  fAvailableVtxIDs->Sort();
  if(fAvailableVtxIDs->NumberOfElements() == 1) {
    NextID = fAvailableVtxIDs->First() + 1;
    fAvailableVtxIDs->AddAt(NextID,1);
  }
  fAvailableVtxIDs->Remove( fAvailableVtxIDs->First() );
}


void BFLWingedEdge::AddAvailableEdgeID(Int_t id)
{
  fAvailableEdgeIDs -> Add(id); // if it doesn't already exists
  fAvailableEdgeIDs -> Sort();
}

Int_t BFLWingedEdge::FirstAvailableEdgeID(void) const
{
// Returns the first available edge id to be assigned to a newly
// added edge. The commends of the FirstAvailableVtxID() are 
// relevant.

  Int_t edge;

  fAvailableEdgeIDs->Sort();
  edge = fAvailableEdgeIDs->First();
  //fAvailableEdgeIDs->Remove(edge); ????

  return edge;
}

Int_t BFLWingedEdge::MaxAvailableEdgeID(void) const
{
  fAvailableEdgeIDs->Sort();
  return fAvailableEdgeIDs->Last();
}

void BFLWingedEdge::DeleteFirstAvailableEdgeID(void)
{
// Removes the first available vtx id

  Int_t NextID;
  
  fAvailableEdgeIDs->Sort();
  if(fAvailableEdgeIDs->NumberOfElements() == 1) {
    NextID = fAvailableEdgeIDs->First() + 1;
    fAvailableEdgeIDs->AddAt(NextID,1);
  }  
  fAvailableEdgeIDs->Remove( fAvailableEdgeIDs->First() );
}

void BFLWingedEdge::PrintEdges(void) 
{
  TIter next(fEdges);
  BFLEdge * edge;

  cout << "\n************ PRINTING VORONOI EDGES *************" << endl;

  while( (edge = (BFLEdge *)next()) ) {

     cout << "* -------------- Edge id : "<< edge->GetEdgeID() << endl;
     cout << "*Left Polygon......" << edge->GetLeftPolyg()     << endl;
     cout << "*Right Polygon....." << edge->GetRightPolyg()    << endl;
     cout << "*Start Vtx........." << edge->GetStartVtx()      << endl;
     cout << "*End Vtx..........." << edge->GetEndVtx()        << endl;
     cout << "*CW Successor......" << edge->GetCwSuccessor()   << endl;
     cout << "*CCW Successor....." << edge->GetCcwSuccessor()  << endl;
     cout << "*CW Predecessor...." << edge->GetCwPredecessor() << endl;
     cout << "*CCW Predecessor..." << edge->GetCcwPredecessor()<< endl;
  }
  cout << endl;
  delete edge;
}

void BFLWingedEdge::PrintVertices(void) 
{
  TIter next(fVertices);
  BFLVtx * vtx;
  char wght;

  cout << "\n********** PRINTING VORONOI VERTICES ***********" << endl;

  while( (vtx = (BFLVtx *)next()) ) {

     if(vtx->GetWeight()) wght = 'T';
     else wght = 'F';

     cout << "* --------------  Vtx id : "<< vtx->GetVtxID() << endl;
     cout << "*Incident Edge...." << vtx->GetEdgeAroundVtx() << endl;
     cout << "*Vertex Weight...." << wght                    << endl;
     cout << "*Vertex X........." << vtx->GetX()             << endl;
     cout << "*Vertex Y........." << vtx->GetY()             << endl;
  }
  cout << endl;
  delete vtx;  
}

void BFLWingedEdge::PrintPolygons(void) 
{
  TIter next(fPolygons);
  BFLPolyg * polyg;

  cout << "\n********** PRINTING VORONOI POLYGONS ***********" << endl;      

  while( (polyg = (BFLPolyg *)next()) ) {

     cout << "* ----------- Polyg id : "<< polyg->GetPolygID() << endl;
     cout << "*Edge Around...." << polyg->GetEdgeAroundPolyg() << endl;
  }
  cout << endl;
  delete polyg;  
}

void BFLWingedEdge::PrintVoronoi(Int_t PrintWhat)
{
  switch(PrintWhat){
  case(kEDGES):
     PrintEdges();
     break;
  case(kVERTICES):
     PrintVertices();
     break;
  case(kPOLYGONS):
     PrintPolygons();
     break;
  case(kALL):
     PrintEdges();
     PrintVertices();
     PrintPolygons();
     break;
  }
}

void BFLWingedEdge::Plot(void)
{
// This method generates a C macro that plots the Voronoi diagram
// and its generators on a ROOT Canvas.
//
  ofstream MACRO("VoronPlot.C",std::ios::out); 

  MACRO << "{" << endl;
  MACRO << "gROOT->Reset();" << endl;

  MACRO << "TCanvas * c = new TCanvas(\"c\",\"Vor\",20,20,800,600);" << endl;
  MACRO << "c->Range(-3000.,-3000.,3000.,3000.);" << endl;

  MACRO << "// Plotting Voronoi diagram " << endl;
  MACRO << "TLine * line = new TLine();" << endl;
  MACRO << "line->SetLineColor(9);" << endl;

  TIter next(fEdges);
  BFLEdge * edge;
  while( (edge = (BFLEdge *)next()) ) {

     Int_t svtxID = edge->GetStartVtx();
     Int_t evtxID = edge->GetEndVtx();

     BFLVtx * Svtx = GetVtxObj(svtxID);
     BFLVtx * Evtx = GetVtxObj(evtxID);

     Float_t xs = Svtx->GetX();
     Float_t ys = Svtx->GetY();
     Float_t xe = Evtx->GetX();
     Float_t ye = Evtx->GetY();

     MACRO << "line->DrawLine(" << xs << "," << ys << ","
                                <<  xe << "," << ye << ");" << endl; 
  }

  MACRO << "}" << endl;
}

void BFLWingedEdge::Save(const Char_t * filename)
{
  ofstream WEFILE(filename,std::ios::out); 

  // -------------------- saving edges  
  TIter nexte(fEdges);
  BFLEdge * edge;

  WEFILE << fEdges->GetLast() << endl;
  while( (edge = (BFLEdge *)nexte()) ) {

     WEFILE  << edge->GetEdgeID()         << endl;
     WEFILE  << edge->GetLeftPolyg()      << "\t\t" 
             << edge->GetRightPolyg()     << endl;
     WEFILE  << edge->GetStartVtx()       << "\t\t"
             << edge->GetEndVtx()         << endl;
     WEFILE  << edge->GetCwSuccessor()    << "\t\t" 
             << edge->GetCcwSuccessor()   << endl;
     WEFILE  << edge->GetCwPredecessor()  << "\t\t"
             << edge->GetCcwPredecessor() << endl;
  }
  delete edge;

  // -------------------- saving vertices
  TIter nextv(fVertices);
  BFLVtx * vtx;
  Int_t wght;

  WEFILE << fVertices->GetLast() << endl;
  while( (vtx = (BFLVtx *)nextv()) ) {

     if(vtx->GetWeight()) wght = 1;
     else wght = 0;

     WEFILE  << vtx->GetVtxID() << endl;
     WEFILE  << vtx->GetEdgeAroundVtx() << endl;
     WEFILE  << wght                    << endl;
     WEFILE  << vtx->GetX() << "\t\t" << vtx->GetY() << endl;
  }
  delete vtx;  

  // -------------------- saving polygons
  TIter nextp(fPolygons);
  BFLPolyg * polyg;

  WEFILE << fPolygons->GetLast() << endl;
  while( (polyg = (BFLPolyg *)nextp()) ) {

     WEFILE  << polyg->GetPolygID() << endl;
     WEFILE  << polyg->GetEdgeAroundPolyg() << endl;
  }
  delete polyg;  

}

void BFLWingedEdge::Load(const Char_t * filename)
{
  Int_t MaxEdge, MaxVertex, MaxPolygon;
  Int_t ID, LeftPolyg, RightPolyg, StartVtx, EndVtx;
  Int_t CwSuccessor, CcwSuccessor;
  Int_t CwPredecessor, CcwPredecessor;
  Int_t EdgeAroundVtx, EdgeAroundPolyg, wght;
  Float_t X, Y;
  ifstream WEFILE(filename,std::ios::in); 

  // delete old Voronoi diagram
  if(fEdges) {
    fEdges->Delete();
    delete fEdges;
  }
  if(fVertices) {
    fVertices->Delete();
    delete fVertices;
  }
  if(fPolygons) {
    fPolygons->Delete();
    delete fPolygons;
  }
  if(fAvailableVtxIDs) delete fAvailableVtxIDs;
  if(fAvailableEdgeIDs) delete fAvailableEdgeIDs;
  
  // allocate new containers
  fEdges    = new TObjArray(100);
  fVertices = new TObjArray(100);
  fPolygons = new TObjArray(100);  
  fAvailableVtxIDs  = new TIntList();
  fAvailableEdgeIDs = new TIntList(); 

  // -------------------- loading edges
  WEFILE >> MaxEdge; 
  do {
     WEFILE  >> ID;
     WEFILE  >> LeftPolyg      >> RightPolyg;     
     WEFILE  >> StartVtx       >> EndVtx;
     WEFILE  >> CwSuccessor    >> CcwSuccessor;
     WEFILE  >> CwPredecessor  >> CcwPredecessor;
     
     SetEdge(ID);
     SetRightPolyg(ID,RightPolyg);
     SetLeftPolyg(ID,LeftPolyg);
     SetStartVtx(ID,StartVtx);
     SetEndVtx(ID,EndVtx);
     SetCwPredecessor(ID,CwPredecessor);
     SetCcwPredecessor(ID,CcwPredecessor);
     SetCwSuccessor(ID,CwSuccessor);
     SetCcwSuccessor(ID,CcwSuccessor);
     
  } while(ID != MaxEdge);
  
  // -------------------- loading vertices
  WEFILE >> MaxVertex; 
  do {
     WEFILE  >> ID;
     WEFILE  >> EdgeAroundVtx;
     WEFILE  >> wght;
     WEFILE  >> X >> Y;
     
     SetVtx(ID);
     SetEdgeAroundVtx(ID,EdgeAroundVtx);
     if(wght) SetWeight(ID,kTRUE);
     else SetWeight(ID,kFALSE );
     SetX(ID,X);
     SetY(ID,Y);
  } while(ID != MaxVertex);

  // -------------------- loading polygons
  WEFILE >> MaxPolygon; 
  do {
     WEFILE  >> ID;
     WEFILE  >> EdgeAroundPolyg;
     
     SetPolyg(ID);
     SetEdgeAroundPolyg(ID,EdgeAroundPolyg);
  } while(ID != MaxPolygon);
}

void BFLWingedEdge::SaveNodalSet(const Char_t * filename) 
{
  ofstream NSFILE(filename,std::ios::out); 

  TIter next(fGenerators);
  BFLNode * generator;
  Int_t GeneratedCell = 1;
 
  NSFILE << GetNofPolygons() << endl;
  while( (generator = (BFLNode *) next()) ) {
     NSFILE << generator->GetNodeID() << "\t\t" 
            << GeneratedCell++        << "\t\t"
            << generator->GetX()      << "\t\t"
            << generator->GetY()      << endl;
  }
  delete generator; 
}

void BFLWingedEdge::LoadNodalSet(const Char_t * filename) 
{
  ifstream NSFILE(filename,std::ios::in); 
  Int_t igenerator, NGens, nID, VorCell;
  Float_t x, y;
  Int_t VorCellLast = -999;
  
  fGenerators = new TObjArray(100);
  
  NSFILE >> NGens;
  for(igenerator = 0; igenerator < NGens; igenerator++) {

     NSFILE >> nID >> VorCell >> x >> y;
     if (VorCell != VorCellLast) 
        fGenerators->AddAtAndExpand(new BFLNode(nID,x,y),VorCell-1);
     VorCellLast = VorCell;
  } 
}
 
Long_t BFLWingedEdge::Size(void)
{
  Long_t size = 0;

  TIter nextv(fVertices);
  BFLVtx * vtx;
  while( (vtx = (BFLVtx *)nextv()) ) size += sizeof(*vtx);

  TIter nexte(fEdges);
  BFLEdge * edge;
  while( (edge = (BFLEdge *)nexte()) ) size += sizeof(*edge);

  TIter nextp(fPolygons);
  BFLPolyg * polyg;
  while( (polyg = (BFLPolyg *)nextp()) ) size += sizeof(*polyg);

  delete vtx;
  delete edge;
  delete polyg;

  return size;
}

void BFLWingedEdge::LoadANSYSLookupTable(BfldGrid::Grid_t grid)
{
  if(fANSYSTable) delete fANSYSTable;
  fANSYSTable = new BFLAnsysLookup(grid);
}

---