vtkQuadrilateralSubdivision.h

// .NAME vtkQuadrilateralSubdivision - implementation of the Kobbelt subdivision method.
// .SECTION Description
// This class implements the paper "Interpolatory Subdivision on Open Quadrilateral Nets
// with Arbitrary Topology". It provides methods to convert an arbitrary net into a 
// quadrilateral net and implements the Kobbelt-subdivision algorithm.
// .SECTION Caveats
// Nothing known
// .SECTION see also
// vtk3DSImporter vtkPolyData

#ifndef __vtkQuadrilateralSubdivision_h
#define __vtkQuadrilateralSubdivision_h

// C/C++ includes
#include <iostream>
#include <vector>

// VTK includes
#include "vtkObjectFactory.h"
#include "vtkPolyData.h"
#include "vtkCellArray.h"
#include "vtkIdList.h"
#include "vtkPointData.h"
#include "vtkEdgeTable.h"
#include "vtk3DSOurImporter.h"

using namespace std;

class VTK_EXPORT vtkQuadrilateralSubdivision : public vtkObject
{
public:
        static vtkQuadrilateralSubdivision *New();
        vtkTypeMacro(vtkQuadrilateralSubdivision,vtkObject);
        //void PrintSelf(ostream& os, vtkIndent indent);

        // Description:
        // Set which serial port to use, 1 through 4. Default: 1.
        // user calls SetSerialPort(int portNumber)
        vtkSetMacro(SerialPort, int); // you call SetSerialPort(int PortNumber)
        vtkGetMacro(SerialPort, int); // you call GetSerialPort()

        // Description:
        // Due to the Kobbelt algorithm can handle only quadrilateral nets, it
        // is a conversion provided that convert arbitrary nets into quadrilateral ones.
        // The Geometry is given by vtkPolyData.
        void ConvertCatmullClark(vtkPolyData *polyData);

        // Description:
        // Due to the Kobbelt algorithm can handle only quadrilateral nets, it
        // is a conversion provided that convert arbitrary nets into quadrilateral ones.
        // The Geometry is given by vtk3DSMesh, because more meshes can be loaded by
        // the vtk3DSImporter class.
        void ConvertCatmullClark(vtk3DSMesh *meshList);

        // Description:
        // The weight specified here is needed to define the precision of the interpolation.
        // It ranges from > 0 to < 2(sqrt(5)-1). By default it is set to 1, which leads to 
        // a cubix presision.
        void SetWeight(double w);

        // Description:
        // This method does one subdivision step, explained in the paper.
        // The Geometry is given by vtkPolyData.
        void KobbeltSubdivision(vtkPolyData *polyData);
        
        // Description:
        // This method does one subdivision step, explained in the paper.
        // The Geometry is given by vtk3DSMesh, because more meshes can be loaded by
        // the vtk3DSImporter class.
        void KobbeltSubdivision(vtk3DSMesh *meshList);

        
        void buildLinks(vtk3DSMesh *meshList);


        //BTX
        // This section does not get wrapped, use btx, etx syntax to 
        // prevent the wrapping of methods you don't want wrapped.
        // This is usefull when debugging the wrapping portion of the 
        // process.
        // ...
        // ...
        // ...
        //ETX

private:
        vtkQuadrilateralSubdivision(); // constructor
        ~vtkQuadrilateralSubdivision(); // destructor
        vtkQuadrilateralSubdivision(const vtkQuadrilateralSubdivision&) {}; // copy constructor
        void operator=(const vtkQuadrilateralSubdivision&) {}; // copy assignment


        vtkIdType FetchPointForLKi(vtkPolyData *polyData, vtkIdType cellId, 
                        vtkIdType point, vtkIdType edgePoint, vtkIdType &nextCellId);

protected: 
        int SerialPort; 

        double m_dWeight;

        double m_dAlpha;
        double m_dBeta;
        double m_dGamma;
        double m_dDelta;


        // Description:
        // All input-parameters have to be initialized x[3] float arrays. The return value
        // then will be also x[3] and the new edgepoint, calculated by the 4-point rule, 
        // described in the Kobbelt-paper. The points have to be consecutive points, whereas
        // the new interpolated point will be on the edge between p2 and p3.
        float *Regular4PointRule(float *p1, float *p2, float *p3, float *p4);
        float *NonRegular4PointRule(float *p1, float *p2, float *p3, float *p4);

        // Description:
        // If we have a edge between p1 and p2 and are interested in the edge-intperpolation-point,
        // then pPointIDs is filled with all need ki and li (see formula in the paper.
        // The new virtual point is returned.
        // For ordering in the pPointIDs see GetSurroundingLKiPoints.
        float *GetVirtualPoint3(vtkPoints *points, vtkIdType  *pPointIDs);
        float *GetVirtualPoint5(vtkPoints *points, vtkIdType  *pPointIDs);


        // Description:
        // ask tron
        // parameters:
        //              pointer to a vtkPolyData
        //              the cell id of the cell
        //              the point id of p
        //              the point id of l(i)
        // return order: l(i), k(i-1), l(i-1), k(i-2), k(i), l(i+1), 
        //                      k(i+1), l(i+2), k(i+2)
        vtkIdType *GetSurroundingLKiPoints(vtkPolyData *polyData, 
                        vtkIdType cellId, vtkIdType p, vtkIdType li);

        // Description:
        // We have a face with the points i-1, i, i+1, i+2, then we want to calculate the edgepoint
        // between i and i+1: this methods returns the point before i successive with i and i+1. 
        // Therefore we nee the previous point i-1 and its neighbouring faces!!
        vtkIdType GetRegularPointInLine(vtkPolyData *polyData,vtkIdType cellId, 
                        vtkIdType point, vtkIdType prevPoint);
        vtkIdType GetRegularPointInLineIdx(vtkPolyData *polyData,vtkCellArray* edgePolys,
                        vtkIdType cellId, vtkIdType point, vtkIdType prevPoint);

        // Description:
        // Calculate the edgepoints for a whole polyData and store the points and faces, whereas
        // the faces are only temporal.
        void GenerateEdgePoints(vtkPolyData *polyData, vtkPoints* &newPoints, vtkCellArray* &edgePolys);

        void GenerateFacePoints(vtkPolyData *polyData, vtkPoints* &newPoints, vtkPoints* &allPoints, vtkCellArray* edgePolys, vtkCellArray* &newPolys);
};


#endif //#ifndef __vtkQuadrilateralSubdivision_h

---