BREPLib/Brep.h

Go to the documentation of this file.

#ifndef __JBXL_BREP_H_
#define __JBXL_BREP_H_


#ifdef WIN32
#pragma warning(disable:4251)
#endif


#include "ClassBox.h"

#include <list>
#include <algorithm>

#include "Vector.h"
#include "TVector.h"



namespace jbxl {


class  DllExport BREP_SOLID;
class  DllExport BREP_SHELL;
class  DllExport BREP_FACET;
class  DllExport BREP_CONTOUR;
class  DllExport BREP_EDGE;
class  DllExport BREP_WING;
class  DllExport BREP_VERTEX;
class  DllExport OctreeNode;

typedef std::list<BREP_SOLID*>   BREP_SOLID_LIST;
typedef std::list<BREP_SHELL*>   BREP_SHELL_LIST;
typedef std::list<BREP_FACET*>   BREP_FACET_LIST;
typedef std::list<BREP_CONTOUR*> BREP_CONTOUR_LIST;
typedef std::list<BREP_EDGE*>    BREP_EDGE_LIST;
typedef std::list<BREP_WING*>    BREP_WING_LIST;
typedef std::list<BREP_VERTEX*>  BREP_VERTEX_LIST;

DllExport BREP_WING* CreateWingWithoutContour(BREP_VERTEX* vertex1, BREP_VERTEX* vertex2);
DllExport BREP_WING* GetWingOtherSide(BREP_WING* wing);

DllExport BREP_EDGE* FindEdge(BREP_VERTEX* vertex1, BREP_VERTEX* vertex2);
DllExport BREP_EDGE* CreateEdge(BREP_VERTEX* v1, BREP_VERTEX* v2);

DllExport BREP_VERTEX*  AddVertex2Octree(BREP_VERTEX* vertex, OctreeNode* octree, bool dupli=false);
DllExport BREP_VERTEX** GetOctreeVertices(OctreeNode* octree, long int* vertexno);      // 要 free
DllExport long int OctreeGetter(OctreeNode* p, BREP_VERTEX** vtx, long int counter);

DllExport void ConnectWingToVertex(BREP_WING* wing);
DllExport void DestroyWing(BREP_WING* wing);
DllExport int  CompareVertex(BREP_VERTEX* v1, BREP_VERTEX* v2);

DllExport TVector<double>  Vertex2TVector(BREP_VERTEX* v);



// BREP_SOLID
//

class  DllExport BREP_SOLID 
{
public:
    unsigned int    facetno;            
    unsigned int    vertexno;           
    unsigned int    vertexid;           
    int             vcount;             

    BREP_SHELL_LIST shells;
    OctreeNode* octree;
    RBound<double>  rbound;

    BREP_CONTOUR_LIST contours;         
    BREP_WING_LIST    wings;            

    BREP_CONTOUR_LIST surplus_contours; 
    BREP_WING_LIST    shortage_wings;   

    std::string name;
    CVCounter*  counter;                

    bool        freed;                  

public:
    BREP_SOLID();
    virtual ~BREP_SOLID();

    void  FreeData(void);
    void  CloseData(void);
    void  ConnectShell(BREP_SHELL* shell);
    void  DisconnectShell(BREP_SHELL* shell);
};


inline void  freeBrepSolid(BREP_SOLID*& solid) { if(solid!=NULL){ solid->FreeData(); delete solid; solid=NULL;} }



// BREP_SHELL
//

class DllExport BREP_SHELL
{
public:
    BREP_SOLID*     solid;
    BREP_FACET_LIST facets;
    RBound<double>  rbound;

public:
    BREP_SHELL(BREP_SOLID* pr_solid);
    virtual ~BREP_SHELL();

    void CloseData();
    void ConnectFacet(BREP_FACET* facet);
    void DisconnectFacet(BREP_FACET* facet);
};



// BREP_FACET
//

class DllExport BREP_FACET
{
public:
    BREP_SHELL*     shell;
    BREP_CONTOUR_LIST outer_contours;

    Vector<double>  normal;
    RBound<double>  rbound;

    double          d;                  
    double          tolerance;

    bool            deletable;          
    bool            notdelete;          

public:
    BREP_FACET(BREP_SHELL* pr_shell);
    virtual ~BREP_FACET();

    void CloseData();
    void ConnectContour(BREP_CONTOUR* contour);
    void DisconnectContour(BREP_CONTOUR* contour);

    void ComputePlaneEquation();
};



// BREP_CONTOUR
//

class DllExport BREP_CONTOUR
{
public:
    BREP_FACET*     facet;
    BREP_WING*      wing;

    RBound<double>  rbound;
    Vector<double>  normal;

    TVector<double> directR;
    TVector<double> directS;
    TVector<double> directRS;

    int             dup_edge;               
    bool            collision;
    bool            hasCollisionVector;

public:
    BREP_CONTOUR(BREP_FACET* pr_facet);
    virtual ~BREP_CONTOUR();

    void CloseData();
    void ConnectWing(BREP_WING* wing);
    void DisconnectWing(BREP_WING* wing);
    void DestroyWings();

    void CloseFacet(BREP_FACET* facet, double& emax, double& dmin, double& dmax);
    void ComputeNormal();
    void ComputeDirectRS();

    BREP_WING* CreateWing(BREP_VERTEX* vertex1, BREP_VERTEX* vertex2);
};



// BREP_WING
//

class DllExport BREP_WING
{
public:
    BREP_VERTEX*    vertex;     
    BREP_WING*      prev;
    BREP_WING*      next;

    BREP_EDGE*      edge;
    BREP_CONTOUR*   contour;

public:
    BREP_WING(BREP_VERTEX* v);
    virtual ~BREP_WING() {}

    void CloseData() {}
};



// BREP_EDGE
//

class DllExport BREP_EDGE
{
public: 
    BREP_WING*      wing1;
    BREP_WING*      wing2;

    Vector<double>  center;
    BREP_EDGE_LIST* edge_list;  

    bool            complete;   
    double          tolerance;

public:
    BREP_EDGE(BREP_VERTEX* vertex1, BREP_VERTEX* vertex2);
    virtual ~BREP_EDGE();

    void CloseData();
};



// BREP_VERTEX
//

class DllExport BREP_VERTEX
{
public:
    BREP_WING_LIST  wing_list;

    Vector<double>  point;                  
    Vector<double>  normal;                 
    UVMap<double>   uvmap;                  

    // optional
    long int        index;                  
    bool            calc_normal;            

    double          distance2;
    double          tolerance;

    BREP_VERTEX_LIST*  forbidden_list;      

public:
    BREP_VERTEX();
    virtual ~BREP_VERTEX();

    void CloseData();
    void DisconnectWing(BREP_WING* wing);

    void ComputeNormal();
    void ComputeTolerance();
};



// OctreeNode
//

class DllExport OctreeNode
{
public:
    BREP_SOLID*  solid;

private:
    BREP_VERTEX* vertex;        
    OctreeNode*  child[8];

public:
    OctreeNode(BREP_VERTEX* new_vertex, BREP_SOLID* sld);
    ~OctreeNode();
 
    OctreeNode* AddWithUnique(BREP_VERTEX* new_vertex);

    OctreeNode* AddWithDuplicates(BREP_VERTEX* new_vertex);

    OctreeNode* FindSubtree(BREP_VERTEX* element);
    
    // 
    void ComputeVerticesNormal(void);

    //
    friend  BREP_VERTEX** GetOctreeVertices(OctreeNode* octree, long int* vertexno);
    friend  long int OctreeGetter(OctreeNode* p, BREP_VERTEX** vtx, long int counter);

    friend  BREP_VERTEX* AddVertex2Octree(BREP_VERTEX* vertex, OctreeNode* octree, bool dupli);
};


}       // namespace


#endif

---