vtkNURSubdivisionFilter.h

/*================================*/
/*================================*/
// .NAME vtkNURSubdivisionFilter - Subdivision filter for non uniform catmull-clark subdivision
// .SECTION Description
// The vtkNURSubdivisionFilter provides a class for subdivision using a
// non uniform catmull clarke scheme. It allows the definition of edge-weights
// to additionally form the shape and to create sharp features and edges

// .SECTION Further Work
// This implementation only works on quad meshes as input. Furthermore the 
// performance is very poor and there are still some calcutation mistakes
// of sharp edges during the subdivision. These mistakes might occur because
// of the deviding by zero problem which is not adressed in sufficeint detail
// in the paper "Non Recursive Subdivision Surfaces" by Sederberg et al.
// A reader routine for userdefined edge weights is also still needed.
 
// .SECTION See Also
// vtkApproximatingSubdivisionFilter 

#ifndef _vtkNURSubdivisionFilter_h_
#define _vtkNURSubdivisionFilter_h_

#include "vtkApproximatingSubdivisionFilter.h"
#include "vtkEdgeTable.h"
#include "vtkLookupTable.h"

class vtkPolyData;
class vtkIntArray;
class vtkPoints;
class vtkIdList;

class CWeightTable;

class /*VTK_GRAPHICS_EXPORT*/ vtkNURSubdivisionFilter : public vtkApproximatingSubdivisionFilter
{
 public:
  static vtkNURSubdivisionFilter *New();
  
  vtkTypeRevisionMacro(vtkNURSubdivisionFilter,vtkApproximatingSubdivisionFilter);

  void SetEdgeData(vtkEdgeTable *edges);

 protected:
  vtkNURSubdivisionFilter () {  nKnownEdgepoints=0;   // no edges known 
                KnownEdgepoints=NULL; // edgetable empty
                WeightTable = NULL;   // no wheigths known
                };

  ~vtkNURSubdivisionFilter () {};
  void Execute();
  void GenerateSubdivisionPoints (vtkPolyData *inputDS, vtkIntArray *edgeData,
                                  vtkPoints *outputPts,
                                  vtkPointData *outputPD);
  void GenerateFacePoints();  

  void GenerateEdgePoints();  
  
  void GenerateVertexPoints();  

  float GetNewFEWeigth(vtkIdType FaceId, vtkIdType p1, vtkIdType p2); 

  float GetNewEEWeigth(vtkIdType EdgeIdForm, vtkIdType EdgeIdTo); 

private:
  float dijk(vtkIdType pi, vtkIdType pj, short k);

  float alpha(vtkIdType pi, vtkIdType pj);


  vtkIdType LookupEdge(vtkIdType pi, vtkIdType pj); // lookup if we already know an edgepoint

  void EnterEdge(vtkIdType pi, vtkIdType pj, vtkIdType Id); // 

  vtkIdType *KnownEdgepoints; // 

  vtkIdType nKnownEdgepoints;   // 

  vtkNURSubdivisionFilter(const vtkNURSubdivisionFilter&); // Not implemented.
  void operator=(const vtkNURSubdivisionFilter&);          // Not implemented.

  CWeightTable  *WeightTable,   // Table that holds the weight information
          *TmpWeightTable;  // temporary table used to calculate new weights

  vtkCellArray  *InputFaces_;
  vtkPoints   *NewFacePoints_;  // holds all new calculated facepoints for all faces
  vtkPoints   *NewEdgePoints_;  // temporarily holds the new calculated edgepoints for one face

  vtkPolyData   *input_;      
  vtkPoints   *outputPts_;    // holds output points
  vtkCellArray  *outputPolys_;    // holds output polygons
};


// class to hold data for the edge weights
class CWeightTable 
{
public:

  CWeightTable(vtkIdType NumberOfEdges) 
  {
    // allocate memory
    Data = (float *) malloc(sizeof(float)*NumberOfEdges);
    EdgeIds = (vtkIdType *) malloc(2*sizeof(vtkIdType)*NumberOfEdges);
    counter = 0;
  }   

  ~CWeightTable() {
    // free memory
    free(Data);
    free(EdgeIds);
  }

  float Lookup(vtkIdType pi, vtkIdType pj)
  {
    int i=0;
    vtkIdType *K = EdgeIds;
    // see if we already have this edge in our table
    while (i<counter) 
    {       
      if ( ((K[0] == pi) && (K[1] == pj)) ||
         ((K[1] == pi) && (K[0] == pj)) )
      {
        // if we know this edge we return the weigth.
        return Data[i];
      }
      K += 2;
      i++;
    }
    // if we do not know the edge we return 1 (uniform catmull-clark)
    return 1;
  }

  void Insert(vtkIdType pi, vtkIdType pj, float weight)
  {
    int i=0;
    vtkIdType *K = EdgeIds;
    
    while (i<counter) 
    {
      // see if we already know the edge weight 
      K += 2;
      if ( ((K[0] == pi) && (K[1] == pj)) ||
         ((K[1] == pi) && (K[0] == pj)) )
      {
        return;
      }
      i++;
    }
    // if not enter the new weight
    K[0] = pi;
    K[1] = pj;
    Data[counter]=weight;
    counter++;
  }

  void printself() {
    for (int i=0; i < counter; i++)
      printf("E[%i]-[%i, %i]: %f\n", i, EdgeIds[2*i], EdgeIds[2*i+1], Data[i]);
  }

private:
  vtkIdType counter;  // counts how many weights we know
  float *Data;    // holds the edgeweights
  vtkIdType *EdgeIds; // holds the edges by saving two point ids
};
#endif

---