SbPolyhedronPolygonXSect::Internals Class Reference

Collaboration diagram for SbPolyhedronPolygonXSect::Internals:

Public Types
typedef std::pair< int, int >	Edge
typedef PolygonTriangulator::Triangle	Triangle
typedef PolygonTriangulator::Triangles	Triangles

Public Member Functions
	Internals (SbPolyhedronPolygonXSect *sbp)
	~Internals ()
void	setData (const std::vector< double > *xx, const std::vector< double > *yy, const double &dz)
void	triangulate ()
void	initEdgeClassificationsAndNeighbours ()
void	addExtraVertices ()
void	allocateMemoryAndDefineVertexCoordinates ()
void	defineFacesTopology ()
bool	isinternaledge (const Edge &edge, const std::map< Edge, std::vector< Triangles::const_iterator > > &edge2triangles_map) const
Edge	GetEdge (const Triangle *tr, const unsigned &i, const bool &oriented=false) const
void	setupface (const unsigned &face_id, const std::vector< unsigned > &v) const
void	setupExternalFace (const unsigned &id_extedge, const unsigned &prev_edgeface, const unsigned &next_edgeface, const unsigned &idfirstvertex, const unsigned &idsecondvertex, const unsigned &id_triangleface, const unsigned &n, std::vector< unsigned > &faceinfo) const
void	getSurroundingValues (const std::vector< unsigned > &numbercycle, const unsigned &centralValue, unsigned &prevValue, unsigned &nextValue) const
unsigned	top2bottomvertexid (const unsigned &topid) const
unsigned	top2bottomfaceid (const unsigned &topid) const

Public Attributes
double	dz
const std::vector< double > *	x
const std::vector< double > *	y
unsigned	n
unsigned	ntriangles
SbPolyhedronPolygonXSect *	sbpolyhedron
PolygonTriangulator *	poly
std::set< Edge >	edges_internal
std::set< Edge >	edges_external
std::map< Edge, const Triangle * >	neighbourmap
std::set< Edge >	edges_with_extra_vertex
unsigned	nextraexternalvertices
unsigned	nextrainternalvertices
std::map< Edge, unsigned >	edgewithextravertex_2_id
std::map< Edge, unsigned >	externaledgewithextravertex_2_2ndedgeid

Detailed Description

Definition at line 1906 of file SbPolyhedron.cxx.

Member Typedef Documentation

Edge

typedef std::pair<int,int> SbPolyhedronPolygonXSect::Internals::Edge

Definition at line 1909 of file SbPolyhedron.cxx.

Triangle

typedef PolygonTriangulator::Triangle SbPolyhedronPolygonXSect::Internals::Triangle

Definition at line 1910 of file SbPolyhedron.cxx.

Triangles

typedef PolygonTriangulator::Triangles SbPolyhedronPolygonXSect::Internals::Triangles

Definition at line 1911 of file SbPolyhedron.cxx.

Constructor & Destructor Documentation

Internals()

SbPolyhedronPolygonXSect::Internals::Internals ( SbPolyhedronPolygonXSect *  sbp )

inline

Definition at line 1914 of file SbPolyhedron.cxx.

                                           :dz(0),x(0),y(0),n(0),ntriangles(0),sbpolyhedron(sbp),poly(0),
                        nextraexternalvertices(0),
                        nextrainternalvertices(0){};

~Internals()

SbPolyhedronPolygonXSect::Internals::~Internals ( )

inline

Definition at line 1917 of file SbPolyhedron.cxx.

{ delete poly; }

Member Function Documentation

addExtraVertices()

void SbPolyhedronPolygonXSect::Internals::addExtraVertices

(

)

Definition at line 2051 of file SbPolyhedron.cxx.

                                                         {
 
 
  std::set<const Triangle*> triangles_with_extra_vertex;//Eventually, all triangles should end up here.
 
  Triangles::const_iterator itt=poly->triangles()->begin();
  Triangles::const_iterator ittE=poly->triangles()->end();
  for(; itt!=ittE; ++itt) {
    unsigned ninternaledges(0);
    for (unsigned iedge=0;iedge<3;++iedge) {
      Edge eun = GetEdge(&(*itt),iedge,false/*unoriented!*/);
      if (edges_internal.find(eun)!=edges_internal.end())
    ++ninternaledges;
    }
    if (ninternaledges<3)
      continue;
 
 
    //Check the three edges to find a neighbour that has not already become a quadrilateral.
    unsigned iedge(0);
    for (;iedge<3;++iedge) {
      Edge e = GetEdge(&(*itt),iedge,true/*oriented!*/);
      const Triangle* trneighbour = neighbourmap[e];
      assert(trneighbour);//fixme
      if (triangles_with_extra_vertex.insert(trneighbour).second) {
    triangles_with_extra_vertex.insert(&(*itt));
    Edge eun = GetEdge(&(*itt),iedge,false/*unoriented*/);
    edges_with_extra_vertex.insert(eun);
    ++nextrainternalvertices;
    break;
      }
    }
    assert(iedge<3);//If we cannot add a vertex to a triangle with 3 internal edges, then we have a problem...
  }
 
  itt=poly->triangles()->begin();
  for(; itt!=ittE; ++itt) {
    Triangle* triangle = const_cast<Triangle*>( &(*itt) );
    if (triangles_with_extra_vertex.find(triangle)!=triangles_with_extra_vertex.end())
      continue;
    for (unsigned iedge=0;iedge<3;++iedge) {
      Edge eun = GetEdge(&(*itt),iedge,false/*unoriented!*/);
      //only look at external edges
      if (edges_external.find(eun)==edges_external.end())
    continue;
      assert(edges_with_extra_vertex.find(eun)==edges_with_extra_vertex.end());//fixme
      triangles_with_extra_vertex.insert(triangle);
      edges_with_extra_vertex.insert(eun);
      ++nextraexternalvertices;
      break;
    }
  }
  assert(ntriangles==triangles_with_extra_vertex.size());
}

allocateMemoryAndDefineVertexCoordinates()

void SbPolyhedronPolygonXSect::Internals::allocateMemoryAndDefineVertexCoordinates

(

)

Definition at line 2118 of file SbPolyhedron.cxx.

                                                                                 {
 
   const unsigned nfaces = 2*ntriangles+n+nextraexternalvertices;
   const unsigned nvertices = 2*(n+nextraexternalvertices+nextrainternalvertices);
   sbpolyhedron->AllocateMemory(nvertices,nfaces);
 
 
  //Make edgewithextravertex_2_id map.
  std::set<Edge>::const_iterator itl = edges_with_extra_vertex.begin();
  std::set<Edge>::const_iterator itlE = edges_with_extra_vertex.end();
  unsigned il = 2*n;
  unsigned ielev = 3*n-4;
  for (;itl!=itlE;++itl) {
    edgewithextravertex_2_id[*itl]=++il;
    if (edges_external.find(*itl)!=edges_external.end()) {
      externaledgewithextravertex_2_2ndedgeid[*itl]=++ielev;
    }
  }
  //Now place the vertices:
 
  //First the original n vertices at +dz
  for (unsigned i = 0; i<n; ++i)
    sbpolyhedron->m_pV[i+1] = HVPoint3D(x->at(i),y->at(i),dz);
  //Then the original n vertices at -dz
  for (unsigned i = 0; i<n; ++i)
    sbpolyhedron->m_pV[i+1+n] = HVPoint3D(x->at(i),y->at(i),-dz);
  //Extra vertices at +dz.
  std::map<Edge,unsigned>::const_iterator itlid = edgewithextravertex_2_id.begin();
  std::map<Edge,unsigned>::const_iterator itlidE = edgewithextravertex_2_id.end();
  for (; itlid!=itlidE; ++itlid) {
    double xx = 0.5*(x->at(itlid->first.first-1)+x->at(itlid->first.second-1));
    double yy = 0.5*(y->at(itlid->first.first-1)+y->at(itlid->first.second-1));
    sbpolyhedron->m_pV[itlid->second] = HVPoint3D(xx,yy,dz);
  }
  //Extra vertices at -dz.
  itlid = edgewithextravertex_2_id.begin();
  for (; itlid!=itlidE; ++itlid) {
    double xx = 0.5*(x->at(itlid->first.first-1)+x->at(itlid->first.second-1));
    double yy = 0.5*(y->at(itlid->first.first-1)+y->at(itlid->first.second-1));
    sbpolyhedron->m_pV[itlid->second+edgewithextravertex_2_id.size()] = HVPoint3D(xx,yy,-dz);
  }
 
}

defineFacesTopology()

void SbPolyhedronPolygonXSect::Internals::defineFacesTopology

(

)

Definition at line 2243 of file SbPolyhedron.cxx.

                                                            {
  //This is definitely the most tricky part to get right...
 
  //Make triangle_2_id map.
  std::map<const Triangle*,unsigned> triangle_2_id;
  Triangles::const_iterator itt=poly->triangles()->begin();
  Triangles::const_iterator ittE=poly->triangles()->end();
  unsigned itri = 0;
  for(; itt!=ittE; ++itt) {
    Triangle* triangle = const_cast<Triangle*>( &(*itt) );
    triangle_2_id[triangle]=++itri;
  }
  assert(triangle_2_id.size()==ntriangles);
 
  //Loop over the external edges, and get a list of edge face id's.
  std::vector<unsigned> edgeface_ids;
  std::map<Edge,unsigned> edge_2_firstid;
  std::map<Edge,unsigned> edge_2_secondid;
  for (unsigned i = 1; i<=n;++i) {
    Edge eun((i==n?1:i),(i==n?n:i+1));
    edgeface_ids.push_back(2*n-4+i);
    edge_2_firstid[eun]=edgeface_ids.back();
    bool hasextravertex=
      (edges_with_extra_vertex.find(eun)!=edges_with_extra_vertex.end());
    if (hasextravertex) {
      edgeface_ids.push_back(externaledgewithextravertex_2_2ndedgeid[eun]);
      edge_2_secondid[eun]=edgeface_ids.back();
    }
  }
 
  std::vector<unsigned> faceinfo_top, faceinfo_bottom(8), faceinfo_sides;
  itt = poly->triangles()->begin();
  for(; itt!=ittE; ++itt) {
    unsigned triangleid = triangle_2_id[&(*itt)];
 
    for (unsigned iedge=0;iedge<3;++iedge) {
      Edge e = GetEdge(&(*itt),iedge,true/*oriented!*/);
      Edge eun = GetEdge(&(*itt),iedge,false/*unoriented!*/);
 
      bool hasextravertex(edges_with_extra_vertex.find(eun)!=edges_with_extra_vertex.end());
      bool isinternal(edges_external.find(eun)==edges_external.end());
      //add for the triangle.
      faceinfo_top.push_back(e.first);
      if (isinternal) {
    assert(neighbourmap[e]);//fixme
    assert(triangle_2_id.find(neighbourmap[e])!=triangle_2_id.end());
    faceinfo_top.push_back(triangle_2_id[neighbourmap[e]]);
    if (hasextravertex) {
      faceinfo_top.push_back(edgewithextravertex_2_id[eun]);
      faceinfo_top.push_back(triangle_2_id[neighbourmap[e]]);//NB: Same neighbourface again!
      //      assert(false&&"need to implement extravertex for internal edges");
      //fixme!
    }
      } else {
    assert(edge_2_firstid.find(eun)!=edge_2_firstid.end());
    unsigned firstsideid = edge_2_firstid[eun];
    faceinfo_top.push_back(firstsideid);
    if (hasextravertex) {
      faceinfo_top.push_back(edgewithextravertex_2_id[eun]);
      assert(edge_2_secondid.find(eun)!=edge_2_secondid.end());
      faceinfo_top.push_back(edge_2_secondid[eun]);
    }
    unsigned prev_edgeface,next_edgeface;
    getSurroundingValues(edgeface_ids, firstsideid,prev_edgeface, next_edgeface);
    unsigned firstvertexid = e.first;
    unsigned secondvertexid = (hasextravertex? edgewithextravertex_2_id[eun] : e.second);
    setupExternalFace(firstsideid,prev_edgeface, next_edgeface,firstvertexid,secondvertexid,
              /*firstvertexid+n,secondvertexid + (hasextravertex?externaledgewithextravertex_2_2ndedgeid.size():n),*/
            triangleid,n,faceinfo_sides);
    if (hasextravertex) {
      firstsideid=next_edgeface;
      getSurroundingValues(edgeface_ids, firstsideid,prev_edgeface, next_edgeface);
      firstvertexid=secondvertexid;
      secondvertexid=e.second;
      setupExternalFace(firstsideid,prev_edgeface, next_edgeface,
                edgewithextravertex_2_id[eun],secondvertexid,
                /*edgewithextravertex_2_id[eun]+externaledgewithextravertex_2_2ndedgeid.size(),secondvertexid+n,*/
                triangleid,n,faceinfo_sides);
    }
 
      }
    }//End edge loop
 
    assert(faceinfo_bottom.size()==8);//fixme
    assert(faceinfo_top.size()==8);//fixme
    faceinfo_bottom[0]=top2bottomvertexid(faceinfo_top[0]);
    faceinfo_bottom[1]=top2bottomfaceid(faceinfo_top[7]);
    faceinfo_bottom[2]=top2bottomvertexid(faceinfo_top[6]);
    faceinfo_bottom[3]=top2bottomfaceid(faceinfo_top[5]);
    faceinfo_bottom[4]=top2bottomvertexid(faceinfo_top[4]);
    faceinfo_bottom[5]=top2bottomfaceid(faceinfo_top[3]);
    faceinfo_bottom[6]=top2bottomvertexid(faceinfo_top[2]);
    faceinfo_bottom[7]=top2bottomfaceid(faceinfo_top[1]);
 
    //Actually setup triangle faces.
    setupface(triangleid,faceinfo_top);
    setupface(triangleid+ntriangles,faceinfo_bottom);
    faceinfo_top.clear();
  }//End triangle loop
 
}

GetEdge()

SbPolyhedronPolygonXSect::Internals::Edge SbPolyhedronPolygonXSect::Internals::GetEdge	(	const Triangle *	tr,
		const unsigned &	i,
		const bool &	oriented = false
	)		const

Definition at line 2178 of file SbPolyhedron.cxx.

                                                                                                                                                     {
  assert(i<=2);
  if (i==2)
    return oriented ? Edge((*tr)[2],(*tr)[0]) : Edge((*tr)[0],(*tr)[2]);
  else
    return Edge((*tr)[i],(*tr)[i+1]);
}

getSurroundingValues()

void SbPolyhedronPolygonXSect::Internals::getSurroundingValues	(	const std::vector< unsigned > &	numbercycle,
		const unsigned &	centralValue,
		unsigned &	prevValue,
		unsigned &	nextValue
	)		const

Definition at line 2211 of file SbPolyhedron.cxx.

{
  //First, find the index of the centralValue
  unsigned int i;
  for (  i=0/*fixme, not O(n)*/;i<numbercycle.size();++i)
    if (numbercycle.at(i)==centralValue)
      break;
  //Sanity check that the central value was found
  assert(i<numbercycle.size());//fixme
  prevValue = ( i==0 ? numbercycle.back() : numbercycle.at(i-1) );
  nextValue = ( i==numbercycle.size()-1 ? numbercycle.front() : numbercycle.at(i+1) );
 
}

initEdgeClassificationsAndNeighbours()

void SbPolyhedronPolygonXSect::Internals::initEdgeClassificationsAndNeighbours

(

)

Definition at line 2000 of file SbPolyhedron.cxx.

                                                                             {
  //Goal: classify edges as external/internal, get ability to find neighbours.
 
  //As a help, we create a map of edges->triangles. We define an edge
  //as a pair of int's, where the first should always be lower than
  //the second (otherwise the edges 2-4 and 4-2 would seem different):
  std::map<Edge,std::vector<PolygonTriangulator::Triangles::const_iterator> > edge2triangles_map;
  std::set<Edge> alledges;
  Triangles::const_iterator itt=poly->triangles()->begin();
  Triangles::const_iterator ittE=poly->triangles()->end();
  for(; itt!=ittE; ++itt)
    for (unsigned iedge=0;iedge<3;++iedge) {
      Edge eun = GetEdge(&(*itt),iedge,false/*unoriented!*/);
      if (edge2triangles_map.find(eun)==edge2triangles_map.end()) {
    alledges.insert(eun);
      }
      edge2triangles_map[eun].push_back(itt);
    }
 
 
  //set of external/internal edges:
  std::set<Edge>::const_iterator itedges = alledges.begin();
  std::set<Edge>::const_iterator itedgesE = alledges.end();
  for (;itedges!=itedgesE;++itedges) {
    if (isinternaledge((*itedges),edge2triangles_map))
      edges_internal.insert(*itedges);
    else
      edges_external.insert(*itedges);
  }
 
  //Neighbourmap:
  itt=poly->triangles()->begin();
  for(; itt!=ittE; ++itt)
    for (unsigned iedge=0;iedge<3;++iedge) {
      Edge e = GetEdge(&(*itt),iedge,true/*oriented!*/);
      Edge eun =  GetEdge(&(*itt),iedge,false/*unoriented!*/);
      assert(edge2triangles_map.find(eun)!=edge2triangles_map.end());//fixme
      if (edges_external.find(eun)!=edges_external.end()) {
    neighbourmap[e]=0;
    neighbourmap[eun]=0;
      } else {
    assert(edge2triangles_map[eun].size()==2);//fixme
    const Triangle* triangle = static_cast<const Triangle*>( &(*itt) );
    const Triangle* triangle1 = static_cast<const Triangle*>( &(*(edge2triangles_map[eun].front())) );
    const Triangle* triangle2 = static_cast<const Triangle*>( &(*(edge2triangles_map[eun].back())) );
    neighbourmap[e]=(triangle==triangle1?triangle2:triangle1);
      }
    }
}

isinternaledge()

bool SbPolyhedronPolygonXSect::Internals::isinternaledge	(	const Edge &	edge,
		const std::map< Edge, std::vector< Triangles::const_iterator > > &	edge2triangles_map
	)		const

Definition at line 2164 of file SbPolyhedron.cxx.

                                                                                                            {
 
  Edge reverse_edge(edge.second,edge.first);
  unsigned k = 0;
  std::map<Edge,std::vector<Triangles::const_iterator> >::const_iterator it = edge2triangles_map.find(edge);
  if (it!=edge2triangles_map.end()) k += it->second.size();
  it = edge2triangles_map.find(reverse_edge);
  if (it!=edge2triangles_map.end()) k += it->second.size();
  return k==2;
 
}

setData()

void SbPolyhedronPolygonXSect::Internals::setData	(	const std::vector< double > *	xx,
		const std::vector< double > *	yy,
		const double &	dz
	)

Definition at line 1982 of file SbPolyhedron.cxx.

{
  n = xx->size();
  ntriangles = n-2;
  assert (n==yy->size()&&n>2);//fixme n>2, and special code for n==3.
  dz = the_dz;
  x = xx;
  y = yy;
  nextraexternalvertices = nextrainternalvertices = 0;
}

setupExternalFace()

void SbPolyhedronPolygonXSect::Internals::setupExternalFace	(	const unsigned &	id_extedge,
		const unsigned &	prev_edgeface,
		const unsigned &	next_edgeface,
		const unsigned &	idfirstvertex,
		const unsigned &	idsecondvertex,
		const unsigned &	id_triangleface,
		const unsigned &	n,
		std::vector< unsigned > &	faceinfo
	)		const

Definition at line 2194 of file SbPolyhedron.cxx.

                                                                                                                    {
  faceinfo.clear();
  faceinfo.push_back(idfirstvertex);//point
  faceinfo.push_back(prev_edgeface);//neighbour face
  faceinfo.push_back(top2bottomvertexid(idfirstvertex));//point
  faceinfo.push_back(id_triangleface+n-2);//neighbour face
  faceinfo.push_back(top2bottomvertexid(idsecondvertex));//point
  faceinfo.push_back(next_edgeface);//neighbour face
  faceinfo.push_back(idsecondvertex);//point
  faceinfo.push_back(id_triangleface);//neighbour face
  setupface(id_extedge,faceinfo);
}

setupface()

void SbPolyhedronPolygonXSect::Internals::setupface	(	const unsigned &	face_id,
		const std::vector< unsigned > &	v
	)		const

Definition at line 2187 of file SbPolyhedron.cxx.

                                                                                                            {
  assert(v.size()==8);
  sbpolyhedron->m_pF[face_id] = SbFacet(v.at(0),v.at(1),v.at(2),v.at(3),v.at(4),v.at(5),v.at(6),v.at(7));
}

top2bottomfaceid()

unsigned SbPolyhedronPolygonXSect::Internals::top2bottomfaceid

(

const unsigned &

topid

)

const

Definition at line 2235 of file SbPolyhedron.cxx.

                                                                                        {
  if (topid<=ntriangles)
    return topid+ntriangles;//triangle
  return topid;//side face
}

top2bottomvertexid()

unsigned SbPolyhedronPolygonXSect::Internals::top2bottomvertexid

(

const unsigned &

topid

)

const

Definition at line 2228 of file SbPolyhedron.cxx.

                                                                                          {
  if (topid<=n)
    return topid+n;//original vertex
  return topid+nextraexternalvertices+nextrainternalvertices;//added extra vertex;
}

triangulate()

void SbPolyhedronPolygonXSect::Internals::triangulate

(

)

Definition at line 1994 of file SbPolyhedron.cxx.

{
  poly = new PolygonTriangulator(*x,*y);
}

Member Data Documentation

dz

double SbPolyhedronPolygonXSect::Internals::dz

Definition at line 1926 of file SbPolyhedron.cxx.

edges_external

std::set<Edge> SbPolyhedronPolygonXSect::Internals::edges_external

Definition at line 1937 of file SbPolyhedron.cxx.

edges_internal

std::set<Edge> SbPolyhedronPolygonXSect::Internals::edges_internal

Definition at line 1936 of file SbPolyhedron.cxx.

edges_with_extra_vertex

std::set<Edge> SbPolyhedronPolygonXSect::Internals::edges_with_extra_vertex

Definition at line 1939 of file SbPolyhedron.cxx.

edgewithextravertex_2_id

std::map<Edge,unsigned> SbPolyhedronPolygonXSect::Internals::edgewithextravertex_2_id

Definition at line 1942 of file SbPolyhedron.cxx.

externaledgewithextravertex_2_2ndedgeid

std::map<Edge,unsigned> SbPolyhedronPolygonXSect::Internals::externaledgewithextravertex_2_2ndedgeid

Definition at line 1943 of file SbPolyhedron.cxx.

n

unsigned SbPolyhedronPolygonXSect::Internals::n

Definition at line 1929 of file SbPolyhedron.cxx.

neighbourmap

std::map<Edge,const Triangle*> SbPolyhedronPolygonXSect::Internals::neighbourmap

Definition at line 1938 of file SbPolyhedron.cxx.

nextraexternalvertices

unsigned SbPolyhedronPolygonXSect::Internals::nextraexternalvertices

Definition at line 1940 of file SbPolyhedron.cxx.

nextrainternalvertices

unsigned SbPolyhedronPolygonXSect::Internals::nextrainternalvertices

Definition at line 1941 of file SbPolyhedron.cxx.

ntriangles

unsigned SbPolyhedronPolygonXSect::Internals::ntriangles

Definition at line 1930 of file SbPolyhedron.cxx.

poly

PolygonTriangulator* SbPolyhedronPolygonXSect::Internals::poly

Definition at line 1934 of file SbPolyhedron.cxx.

sbpolyhedron

SbPolyhedronPolygonXSect* SbPolyhedronPolygonXSect::Internals::sbpolyhedron

Definition at line 1931 of file SbPolyhedron.cxx.

x

const std::vector<double>* SbPolyhedronPolygonXSect::Internals::x

Definition at line 1927 of file SbPolyhedron.cxx.

y

const std::vector<double>* SbPolyhedronPolygonXSect::Internals::y

Definition at line 1928 of file SbPolyhedron.cxx.

---

The documentation for this class was generated from the following file:

• SbPolyhedron.cxx