www.pudn.com > buildct.zip > CHAIN.H, change:2004-02-25,size:8070b

#ifndef __FILECHAIN_H 
#define __FILECHAIN_H 
 
//#include <iostream.h> 
#include <stdio.h> 
#define NULL 0 
#define MAX 2000L 
#define BOUND2 1000 
//提取轮廓线特征点 
#define KEYLENGTH2 2500 
#define KEYAREA2 250L 
/*指示结点的状态 
0:初始值 
1:已连线 
2:线头，（通常一入一出） 
3: 
-1:不必处理（行头或,可能处理过了） 
*/ 
 
/* 
typedef struct tagPoint1 
{ 
    int x; 
    int y; 
}POINT; 
*/ 
class LineChain; 
class Chain; 
class ChainNode 
{ 
    friend Chain ; 
    friend LineChain; 
    private: 
    POINT data; 
 
    /*指示该结点的状态 
    0:初始值 
    1:已连线 
    2:线头，（通常一入一出） 
    3: 
    -1:不必处理（行头或,可能处理过了） 
    */ 
    int tag; 
    //link指示行间链接（竖向）,双向指针 
    ChainNode *link; 
    ChainNode *linkBack; 
    //横向 
    ChainNode *next; 
    // 
    public: 
    ChainNode(){data.x=0;data.y=0;link=NULL;linkBack=NULL;next=NULL;setTag(0);} 
    ChainNode(int x,int y){data.x=x;data.y=y;link=NULL;linkBack=NULL;next=NULL;setTag(0);} 
    ~ChainNode(){}; 
    int getX(){return data.x;} 
    int getY(){return data.y;} 
    void setXY(int x,int y) 
    {data.x=x;data.y=y;} 
    int getTag(){return tag;} 
    int setTag(int newTag) 
    {int oldtag=tag;tag=newTag;return oldtag;} 
    ChainNode *getLink(){return link;} 
    ChainNode *getBackLink(){return linkBack;} 
    int setLink(ChainNode *newlink) 
    { 
        if(newlink==NULL) 
        { 
            link=newlink; 
            return -1; 
        } 
        link=newlink;newlink->linkBack=this; 
        return 0; 
    } 
    ChainNode *getNext(){return next;} 
    //将node插到本结点为头的next链末尾，不考虑node的指针状态 
    int appendNode(ChainNode *node); 
    //将node插到本结点为头的link链后面，不考虑node的指针状态 
    int insertLinkAfter(ChainNode *node) 
    { 
        if(node==NULL)return -1; 
        ChainNode *p=this->link; 
        setLink(node); 
        node->setLink(p); 
        return 0; 
    } 
    //链接结点个数 
    int getLinkCount(); 
    //链表结点个数，计算一行的结点数 
    int getNextCount(); 
    long getDistance2(int x,int y) 
    { 
        long xx=getX()-x; 
        long yy=getY()-y; 
        return xx*xx+yy*yy; 
    } 
    //计算面积的2倍的绝对值     
    long getTwiceArea(ChainNode *b,ChainNode *c) 
    { 
        if(b==NULL ||c==NULL)return 0; 
        long xx1=b->getX()-getX(); 
        long yy1=b->getY()-getY(); 
        long xx2=c->getX()-getX(); 
        long yy2=c->getY()-getY(); 
        long area=yy1*xx2-xx1*yy2; 
        if(area<0)area=-area; 
        return area; 
    } 
     
    /*在轮廓线(link的封闭链)中查找最近点，若没有返回NULL*/ 
    ChainNode *getNearestInLink(int x,int y, long &dist2); 
}; 
class Chain 
{ 
    public: 
    Chain(){first=NULL;} 
    Chain(ChainNode *head) 
    {first=head;} 
    Chain(Chain *old) 
    { 
        if(old==NULL)first=NULL; 
        else 
        first=old->removeFirst(); 
    } 
    void setFirst(ChainNode *head) 
    { 
        erase(); 
        first=head; 
    } 
    ~Chain(); 
    int isEmpty()const{return first==0;} 
    //链接结点个数 
    int getLinkCount() 
    { 
        if(first==NULL)return 0; 
        return first->getLinkCount(); 
    } 
    //链表结点个数，计算一行的结点数 
    int getNextCount() 
    { 
        if(first==NULL)return 0; 
        return first->getNextCount(); 
    } 
    Chain &append(ChainNode *node); 
    ChainNode *getFirst(){return first;} 
 
    int linkNearestNodes(ChainNode *s,LineChain *lines); 
    //摘下first结点 
    ChainNode *removeFirst() 
    { ChainNode *node=first;first=NULL;return node;} 
    ChainNode *getLast(void); 
    //释放所有结点所占内存，first=NULL 
    void erase(void); 
    //释放非LINKED的节点所占内存,以节省内存空间 
    void freeNotLinked(); 
    //void Output(ostream &out)const; 
    void debugPrint(void); 
    void throwOutOfBounds() 
    {printf("throwOutOfBounds\n");} 
    private: 
    ChainNode *first;//指向第一个节点的指针 
 
    //私有方法 
    ChainNode *getPreHead(int y); 
    ChainNode *getTheHead(int y); 
    ChainNode *getNextHead(int y); 
    //ChainNode *getNearestNode(int x,int y,long &dist2); 
    //在整个链表中查找最近点 
    ChainNode *getNearestInChain(int x,int y, long &dist2); 
    //过滤相似行，减少处理量 
    // int postFiltering(); 
    /*      选择逆时针方向的点 */ 
    ChainNode *getClockWiseNearer(int x,int y, long &dist2); 
}; 
/** 
LineHeader: 轮廓线头结点 
Perimeter为轮廓线的周长，用于启发式计算累加周长构建三角面片算法，周长在拓扑检查时计算。 
 
*/ 
class LineHeader:public ChainNode 
{ 
public: 
	CRect bound;  
    double perimeter; 
	LineHeader(){} 
    BOOL isContained(int x,int y) 
	{ 
	   POINT pp; 
	   pp.x =x; 
	   pp.y =y; 
	   return bound.PtInRect (pp); 
	} 
	double getPerimeter() 
	{ 
		return perimeter;//(bound.right-bound.left+bound.bottom-bound.top)*2; 
	} 
}; 
class LineChain 
{ 
    public: 
    LineChain(){first=NULL;setLayerNo(0);} 
    LineChain(LineHeader *head) 
    {first=head;setLayerNo(0);} 
    LineChain(LineChain *old) 
    { 
        if(old==NULL)first=NULL; 
        else 
        first=old->removeFirst(); 
		setLayerNo(0); 
    } 
    void setFirst(LineHeader *head) 
    { 
        erase(); 
        first=head; 
    } 
    LineHeader *removeFirst() 
    { LineHeader *node=first;first=NULL;return node;} 
    ~LineChain() 
    {erase();} 
    int isEmpty()const{return first==0;} 
    //链接结点个数 
    int getCount() 
    { 
        if(first==NULL)return 0; 
        return first->getLinkCount(); 
    } 
 
    //创建一个链，指向node 
    LineChain &append(ChainNode *node); 
    LineHeader *getFirst(){return first;} 
    LineHeader *getTheHead(int index); 
    ChainNode *getTheData(int index); 
    ChainNode *getLast(void); 
    void erase(void); 
    //void Output(ostream &out)const; 
    void debugPrint(void); 
    CString simplePrint(); 
    void throwOutOfBounds() 
    {printf("throwOutOfBounds\n");} 
    int setLayerNo(int num) 
    { 
        int old=layerNum; 
        layerNum=num; 
        return old; 
    }; 
    int getLayerNo() 
    { 
        return layerNum; 
    } 
     
    private: 
    LineHeader *first;//指向第一个节点的指针 
    int layerNum; 
    public: 
    //检查拓扑完整性 
    int checkTopo(); 
    //int graphicsDebugPrint(); 
	int graphicsDebugPrint(CBitmap *pBmp); 
    //提取轮廓线上的特征点  
    ChainNode *getNearKeyNode(ChainNode *node,ChainNode *start); 
    ChainNode *getFittestLine(ChainNode *line); 
    
}; 
 
class Triangle; 
class TriangleFacet 
{ 
    friend Triangle; 
    private: 
    int x1,y1,z1,x2,y2,z2,x3,y3,z3; 
    TriangleFacet *next; 
    public: 
    TriangleFacet(int px1,int py1,int pz1,int px2,int py2,int pz2,int px3,int py3,int pz3) 
    { 
        x1=px1; 
        y1=py1; 
        z1=pz1; 
        x2=px2; 
        y2=py2; 
        z2=pz2; 
        x3=px3; 
        y3=py3; 
        z3=pz3; 
        next=NULL; 
    } 
    ~TriangleFacet(){} 
}; 
 
class Triangle 
{ 
    public: 
	    bool drawFacet(TriangleFacet * facet,CDC *pdc,int type); 
	    bool isAvailable(); 
	    void setAvailable(bool avail); 
    Triangle(){first=NULL;setAvailable(false);} 
    Triangle(TriangleFacet *head) 
    {first=head;setAvailable(false);} 
    //将node插到本结点为头的next链末尾，不考虑node的指针状态 
    int appendFacet(TriangleFacet *face); 
    int appendFacet(int x1,int y1,int z1,int x2,int y2,int z2,int x3,int y3,int z3) 
    { 
		return appendFacet(new TriangleFacet(x1,y1,z1*3,x2,y2,z2*3,x3,y3,z3*3)); 
	   
       //return appendFacet(new TriangleFacet(x1,y1,z1*10,x2,y2,z2*10,x3,y3,z3*10)); 
	  // return appendFacet(new TriangleFacet(x1,y1,z1,x2,y2,z2,x3,y3,z3)); 
       //printf("<%d,%d,%d %d,%d,%d %d,%d,%d>\n",x1,y1,z1,x2,y2,z2,x3,y3,z3); 
       //return 0; 
    } 
     
    ~Triangle(); 
    void debugPrint(); 
 
    void printToFile(char *outname); 
    CString simplePrint(); 
	int graphicsDebugPrint(CBitmap *pBmp,int type); 
 
    private: 
	    bool available; 
    TriangleFacet *first;//指向第一个节点的指针 
}; 
 
//extern int graphicsBufferPrint(unsigned char data[][IMAGEW/8]); 
#endif