monoTriangulationBackend.cc File Reference

#include "monoTriangulation.h"
#include "polyUtil.h"
#include "backend.h"

Include dependency graph for monoTriangulationBackend.cc:

Go to the source code of this file.

Functions
void	monoTriangulationRec (Real *topVertex, Real *botVertex, vertexArray *inc_chain, Int inc_current, vertexArray *dec_chain, Int dec_current, Backend *backend)
void	monoTriangulationFunBackend (Arc_ptr loop, Int(*compFun)(Real *, Real *), Backend *backend)
void	monoTriangulationRecFunBackend (Real *topVertex, Real *botVertex, vertexArray *inc_chain, Int inc_current, vertexArray *dec_chain, Int dec_current, Int(*compFun)(Real *, Real *), Backend *backend)

Function Documentation

monoTriangulationFunBackend()

void monoTriangulationFunBackend	(	Arc_ptr	loop,
		Int(*)(Real *, Real *)	compFun,
		Backend *	backend
	)

Definition at line 253 of file monoTriangulationBackend.cc.

{
  Int i;
  /*find the top vertex, bottom vertex, inccreasing chain, and decreasing chain,
   *then call monoTriangulationRec
   */
  Arc_ptr tempV;
  Arc_ptr topV;
  Arc_ptr botV;
  topV = botV = loop;
  for(tempV = loop->next; tempV != loop; tempV = tempV->next)
    {
      if(compFun(topV->tail(), tempV->tail())<0) {
    topV = tempV;
      }
      if(compFun(botV->tail(), tempV->tail())>0) {
    botV = tempV;
      }
    }

  /*creat increase and decrease chains*/
  vertexArray inc_chain(20); /*this is a dynamic array*/
  for(i=1; i<=topV->pwlArc->npts-2; i++) { /*the first vertex is the top vertex which doesn't belong to inc_chain*/
    inc_chain.appendVertex(topV->pwlArc->pts[i].param);
  }
  for(tempV = topV->next; tempV != botV; tempV = tempV->next)
    {
      for(i=0; i<=tempV->pwlArc->npts-2; i++){
    inc_chain.appendVertex(tempV->pwlArc->pts[i].param);
      }
    }
  
  vertexArray dec_chain(20);
  for(tempV = topV->prev; tempV != botV; tempV = tempV->prev)
    {
      for(i=tempV->pwlArc->npts-2; i>=0; i--){
    dec_chain.appendVertex(tempV->pwlArc->pts[i].param);
      }
    }
  for(i=botV->pwlArc->npts-2; i>=1; i--){ 
    dec_chain.appendVertex(tempV->pwlArc->pts[i].param);
  }
  
  monoTriangulationRecFunBackend(topV->tail(), botV->tail(), &inc_chain, 0, &dec_chain, 0, compFun, backend);

}  

Referenced by Slicer::slice_new().

monoTriangulationRec()

void monoTriangulationRec	(	Real *	topVertex,
		Real *	botVertex,
		vertexArray *	inc_chain,
		Int	inc_current,
		vertexArray *	dec_chain,
		Int	dec_current,
		Backend *	backend
	)

Definition at line 159 of file monoTriangulationBackend.cc.

{
  assert( inc_chain != NULL && dec_chain != NULL);
  assert( ! (inc_current>=inc_chain->getNumElements() &&
         dec_current>=dec_chain->getNumElements()));
  Int inc_nVertices;
  Int dec_nVertices;
  Real** inc_array ;
  Real** dec_array ;
  Int i;
  assert( ! ( (inc_chain==NULL) && (dec_chain==NULL)));

  if(inc_current>=inc_chain->getNumElements()) /*no more vertices on inc_chain*/
    {

      dec_array = dec_chain->getArray();
      dec_nVertices = dec_chain->getNumElements();      
      reflexChain rChain(20,0);
      /*put the top vertex into the reflex chain*/
      rChain.processNewVertex(topVertex, backend);
      /*process all the vertices on the dec_chain*/
      for(i=dec_current; i<dec_nVertices; i++){
    rChain.processNewVertex(dec_array[i], backend);
      }
      /*process the bottom vertex*/
      rChain.processNewVertex(botVertex, backend);

    }
  else if(dec_current>= dec_chain->getNumElements()) /*no more vertices on dec_chain*/
    {
      inc_array = inc_chain->getArray();
      inc_nVertices= inc_chain->getNumElements();
      reflexChain rChain(20,1);
      /*put the top vertex into the reflex chain*/
      rChain.processNewVertex(topVertex, backend);
      /*process all the vertices on the inc_chain*/
      for(i=inc_current; i<inc_nVertices; i++){
    rChain.processNewVertex(inc_array[i], backend);
      }
      /*process the bottom vertex*/
      rChain.processNewVertex(botVertex, backend);
    }
  else /*neither chain is empty*/
    {
      inc_array = inc_chain -> getArray();
      dec_array = dec_chain -> getArray();
      inc_nVertices= inc_chain->getNumElements();
      dec_nVertices= dec_chain->getNumElements();
      /*if top of inc_chain is 'lower' than top of dec_chain, process all the 
       *vertices on the dec_chain which are higher than top of inc_chain
       */
      if(compV2InY(inc_array[inc_current], dec_array[dec_current]) <= 0)
    {

      reflexChain rChain(20, 0);
      rChain.processNewVertex(topVertex, backend);
      for(i=dec_current; i<dec_nVertices; i++)
        {
          if(compV2InY(inc_array[inc_current], dec_array[i]) <= 0)
        rChain.processNewVertex(dec_array[i], backend);
          else 
        break;
        }
      rChain.outputFan(inc_array[inc_current], backend);
      monoTriangulationRec(dec_array[i-1], botVertex, 
                   inc_chain, inc_current,
                   dec_chain, i,
                   backend);
    }
      else /*compV2InY(inc_array[inc_current], dec_array[dec_current]) > 0*/
    {

      reflexChain rChain(20, 1);
      rChain.processNewVertex(topVertex, backend);
      for(i=inc_current; i<inc_nVertices; i++)
        {
          if(compV2InY(inc_array[i], dec_array[dec_current]) >0)        
        rChain.processNewVertex(inc_array[i], backend);       
          else
        break;
        }
      rChain.outputFan(dec_array[dec_current], backend);
      monoTriangulationRec(inc_array[i-1], botVertex, 
                   inc_chain, i,
                   dec_chain, dec_current,
                   backend);
    }
    }/*end case neither is empty*/
}

Referenced by monoTriangulationLoop(), monoTriangulationRec(), and sampleMonoPolyRec().

monoTriangulationRecFunBackend()

void monoTriangulationRecFunBackend	(	Real *	topVertex,
		Real *	botVertex,
		vertexArray *	inc_chain,
		Int	inc_current,
		vertexArray *	dec_chain,
		Int	dec_current,
		Int(*)(Real *, Real *)	compFun,
		Backend *	backend
	)

Definition at line 303 of file monoTriangulationBackend.cc.

{
  assert( inc_chain != NULL && dec_chain != NULL);
  assert( ! (inc_current>=inc_chain->getNumElements() &&
         dec_current>=dec_chain->getNumElements()));
  Int inc_nVertices;
  Int dec_nVertices;
  Real** inc_array ;
  Real** dec_array ;
  Int i;
  assert( ! ( (inc_chain==NULL) && (dec_chain==NULL)));

  if(inc_current>=inc_chain->getNumElements()) /*no more vertices on inc_chain*/
    {

      dec_array = dec_chain->getArray();
      dec_nVertices = dec_chain->getNumElements();      
      reflexChain rChain(20,0);
      /*put the top vertex into the reflex chain*/
      rChain.processNewVertex(topVertex, backend);
      /*process all the vertices on the dec_chain*/
      for(i=dec_current; i<dec_nVertices; i++){
    rChain.processNewVertex(dec_array[i], backend);
      }
      /*process the bottom vertex*/
      rChain.processNewVertex(botVertex, backend);

    }
  else if(dec_current>= dec_chain->getNumElements()) /*no more vertices on dec_chain*/
    {
      inc_array = inc_chain->getArray();
      inc_nVertices= inc_chain->getNumElements();
      reflexChain rChain(20,1);
      /*put the top vertex into the reflex chain*/
      rChain.processNewVertex(topVertex, backend);
      /*process all the vertices on the inc_chain*/
      for(i=inc_current; i<inc_nVertices; i++){
    rChain.processNewVertex(inc_array[i], backend);
      }
      /*process the bottom vertex*/
      rChain.processNewVertex(botVertex, backend);
    }
  else /*neither chain is empty*/
    {
      inc_array = inc_chain -> getArray();
      dec_array = dec_chain -> getArray();
      inc_nVertices= inc_chain->getNumElements();
      dec_nVertices= dec_chain->getNumElements();
      /*if top of inc_chain is 'lower' than top of dec_chain, process all the 
       *vertices on the dec_chain which are higher than top of inc_chain
       */
      if(compFun(inc_array[inc_current], dec_array[dec_current]) <= 0)
    {

      reflexChain rChain(20, 0);
      rChain.processNewVertex(topVertex, backend);
      for(i=dec_current; i<dec_nVertices; i++)
        {
          if(compFun(inc_array[inc_current], dec_array[i]) <= 0)
        rChain.processNewVertex(dec_array[i], backend);
          else 
        break;
        }
      rChain.outputFan(inc_array[inc_current], backend);
      monoTriangulationRecFunBackend(dec_array[i-1], botVertex, 
                   inc_chain, inc_current,
                   dec_chain, i,
                   compFun,
                   backend);
    }
      else /*compFun(inc_array[inc_current], dec_array[dec_current]) > 0*/
    {

      reflexChain rChain(20, 1);
      rChain.processNewVertex(topVertex, backend);
      for(i=inc_current; i<inc_nVertices; i++)
        {
          if(compFun(inc_array[i], dec_array[dec_current]) >0)      
        rChain.processNewVertex(inc_array[i], backend);       
          else
        break;
        }
      rChain.outputFan(dec_array[dec_current], backend);
      monoTriangulationRecFunBackend(inc_array[i-1], botVertex, 
                   inc_chain, i,
                   dec_chain, dec_current,
                   compFun,
                   backend);
    }
    }/*end case neither is empty*/
}

Referenced by monoTriangulationFunBackend(), and monoTriangulationRecFunBackend().