对于单个模型（长方体为例）进行面投影时的消隐

最新推荐文章于 2024-02-07 22:58:31 发布
最新推荐文章于 2024-02-07 22:58:31 发布
阅读量284 收藏 2
点赞数
原文链接：http://www.cnblogs.com/feiquan/p/8213875.html
版权 
作者：feiquan

出处：http://www.cnblogs.com/feiquan/

版权声明：本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

大家写文都不容易，请尊重劳动成果~ 这里谢谢大家啦(*/ω＼*)

　　首先，我们需要存储一个立方体的相关信息。

　　 创建类Point_3V来存放三维点，Line_2V来存放二维点，Line来存放三维线，Line_2V来存放二维线，face_2V来存放二维面，face来存放三维面，cube来定义一个矩形。以上的二维都是用来平行投影时使用的，三维则是存放在三维空间中真实存在的矩形的信息，且这几个三维类之间使用了类的继承来实现。

　　有关面的检测，使用了背面检测法。

　　有关面的填充，使用了种子填充。

　　代码如下：

　　

//3V_Point三维点
class Point_3V{
public:
    double x,y,z;
    bool v;

    Point_3V(){
        x=0;y=0;z=0;
        v=false;
    }
    Point_3V(double a,double b,double c){
        x=a;y=b;z=c;
        v=false;
    }
    Point_3V(double a,CPoint p){
        x=a;y=p.x;z=p.y;
        v=false;
    }
    Point_3V(CPoint p,double a){
        x=p.x;y=p.y;z=a;
        v=false;
    }
    void set_Point(double a,double b,double c){
        x=a;y=b;z=c;
    }
    void set_Point(Point_3V p){
        x=p.x;y=p.y;z=p.z;
    }
    void set_Point(Point_3V *p){
        x=p->x;y=p->y;z=p->z;
    }
    //投影一个三维点,返回投影点
    CPoint reflect_Point_3V(Point_3V v,CPoint move){
        CPoint p2;
        double  a,b;
        a=this->x-v.x/v.z*this->z+move.x;
        b=this->y-v.y/v.z*this->z+move.y;
        
        p2.SetPoint((int)a,(int)b);
        return p2;
    }
};

//二维线
class Line_2V{
public :
    CPoint start,end;
    Line_2V(){
        start.SetPoint(0,0);
        end.SetPoint(0,0);
    }
    Line_2V(CPoint x,CPoint y ){
        start=x;end=y;
    }
    void fill(CDC *p){
        p->MoveTo(start);
        p->LineTo(end);
    }
};

//基于点填充线(不会开辟新空间)
class Line :public Point_3V 
{
public :
    Point_3V *start;
    Point_3V end;
    bool v;
    Line(){
        start=new Point_3V[1];
        v=false;
    }
    Line(int a,int b,int c ,Point_3V e ):Point_3V(a,b,c),start(this),end(e){
        v=false;
    }
    Line( int s_x,int s_y,int s_z,int e_x,int e_y,int e_z):Point_3V(s_x,s_y,s_z),start(this),end(e_x,e_y,e_z){
        v=false;
    }
    Line(Line *p){
        this->start=p->start;
        this->end=p->end;
        v=false;
    }
    //三维线投影
    Line_2V reflect_Line(Point_3V v,CPoint move,bool draw,CDC  *p){
        CPoint s=start->reflect_Point_3V(v,move);
        CPoint e=end.reflect_Point_3V(v,move);
        Line_2V temp(s,e);
        if(draw)temp.fill(p);
        return temp;
    }
    void set_Line(int s_x,int s_y,int s_z,int e_x,int e_y,int e_z){
        this->start->set_Point(s_x,s_y,s_z);
        this->end.set_Point(e_x,e_y,e_z);
    }
    void set_Line(Point_3V s,Point_3V e){
        this->x=s.x;
        this->y=s.y;
        this->z=s.z;
        this->v=s.v;
        this->start->set_Point(s);
        this->end.set_Point(e);
    }
};

class face_2V{
public :
    //逆时针
    Line_2V a,b,c,d;
    face_2V(){

    }
    face_2V(Line_2V i,Line_2V j,Line_2V k,Line_2V l ){
        a=i;b=j;c=k;d=l;
    }

    void B(int x,int y,int c1_fill,int c2,CDC *p){
        
        //种子填充
        int center=p->GetPixel(x,y);
        if(center!=c1_fill&&center!=c2){
            p->SetPixel(x,y,c1_fill);
            B(x+1,y,c1_fill,c2,p);B(x-1,y,c1_fill,c2,p);
            B(x,y+1,c1_fill,c2,p);B(x,y-1,c1_fill,c2,p);
        }
    }

    void fill(int c1_fill,int c2,CDC *p){
        a.fill(p);b.fill(p);c.fill(p);d.fill(p);
        B(((a.start.x+c.start.x)/2),((a.start.y+c.start.y )/2), c1_fill, c2,p);
    }
};

//基于点填充面(不会开辟新空间)
class face :public Line{
public :
    Point_3V *p;//逆时针
    Line *l1,l2,l3,l4;//l1只能是指针,为了是其与点公用一个存储空间
    bool v;
    face(){
        p=new Point_3V[4];
        l1=new Line[1];
        v=false;
    }
    face(Point_3V *q[4]){
        this->start=q[0];
        this->end=*q[1];

        p=new Point_3V[4];
        l1=new Line[1];
        
        v=false;
        l1->set_Line(p[0],p[1]);
        l2.set_Line(p[1],p[2]);
        l3.set_Line(p[2],p[4]);
        l4.set_Line(p[4],p[0]);
    }
    face(Point_3V a,Point_3V b,Point_3V c,Point_3V d){
        p=new Point_3V[4];
        l1=new Line[1];
        p[0]=a;p[0]=b,p[0]=c,p[0]=d;
        v=false;

        l1->set_Line(p[0],p[1]);
        l2.set_Line(p[1],p[2]);
        l3.set_Line(p[2],p[4]);
        l4.set_Line(p[4],p[0]);
    }
    face( face *p1){
        p=new Point_3V[4];
        l1=new Line[1];
        this->start=p1->start;
        this->end=p1->end;

        p[0]=p1->p[0];
        p[1]=p1->p[1];

        l1->set_Line(p[0],p[1] );
        v=false;
    }
    face(int s_x,int s_y,int s_z,int e_x,int e_y,int e_z,Line p2,Line p3,Line p4):Line(s_x,s_y,s_z,e_x,e_y,e_z),l1(this),l2(p2),l3(p3),l4(p4){
        p=new Point_3V[4];
        l1=new Line[1];
        v=false;
    }
    void set_Point(Point_3V q[4]){
        for(int i=0;i<4;i++){
            p[i]=q[i];
        }
    }
    void set_Line(){
        l1->set_Line(p[0],p[1]);
        l2.set_Line(p[1],p[2]);
        l3.set_Line(p[2],p[4]);
        l4.set_Line(p[4],p[0]);
    }
    void set_Face(Point_3V q[4]){
        for(int i=0;i<4;i++){
            p[i]=q[i];
        }
        l1->set_Line(p[0],p[1]);
        l2.set_Line(p[1],p[2]);
        l3.set_Line(p[2],p[4]);
        l4.set_Line(p[4],p[0]);
    }
    void set_Face(Point_3V q1,Point_3V q2,Point_3V q3,Point_3V q4){
        p[0]=q1;
        p[1]=q2;
        p[2]=q3;
        p[3]=q4;

        l1->set_Line(p[0],p[1]);
        l2.set_Line(p[1],p[2]);
        l3.set_Line(p[2],p[3]);
        l4.set_Line(p[3],p[0]);
    }
    //三维向量的向量积
    Point_3V xiangliangji( Point_3V a ,Point_3V b){
        //矩阵形式,和i,j,k是否为偶数或奇数有关,切记
        return Point_3V(a.y*b.z-a.z*b.y,-(a.x*b.z-a.z*b.x),a.x*b.y-a.y*b.x);
    }

    //三维向量的点乘
    double diancheng( Point_3V a ,Point_3V b){
        double temp=a.x*b.x+a.y*b.y+a.z*b.z;
        return temp;
    }

    //求一个面的法向量,输入一个面按逆时针方向的所有点的数组
    Point_3V n( face *one_face){
        Point_3V a,b,n;
        if(one_face->p!=NULL){
            a.set_Point(one_face->p[1].x-one_face->p[0].x,one_face->p[1].y-one_face->p[0].y,one_face->p[1].z-one_face->p[0].z);
            b.set_Point(one_face->p[2].x-one_face->p[0].x,one_face->p[2].y-one_face->p[0].y,one_face->p[2].z-one_face->p[0].z);
            n=xiangliangji(a,b);
            return n;
        }else{
            return n;
        }
    }

    //判断一个面是否可见,如果一个面可见,则这个面上的四个点也可见
    bool view_face(face *one_face, Point_3V v){
            double cos,a_mo,b_mo;

            //求一个面的法向量
            Point_3V fa;
            fa=n(one_face);

            double a_temp=pow((double)fa.x,2)+pow((double)fa.y,2)+pow((double)fa.z,2);
            a_mo=sqrt(a_temp);
            double b_temp=pow(v.x,2)+pow(v.y,2)+pow(v.z,2);
            b_mo=sqrt(b_temp);
            double fz=diancheng(fa,v);
            double fm=a_mo*b_mo;
            cos=fz/fm;
            if(cos<=0){
                one_face->v=true;
                //判断这个多边形体的各个点是否可见
                for(int j=0;j<4;j++){
                    one_face->p[j].v=true;
                }
                return true;
            }else{
                return false;
            }
    }
    
    //3V面投影
    void reflect_Face(Point_3V v,CPoint move,bool draw_Line,bool fill_face,int c1_fill,int c2,CDC  *p){
        if(view_face(this,v)){
            Line_2V l2_1=l1->reflect_Line(v,move,draw_Line,p);
            Line_2V l2_2=l2.reflect_Line(v,move,draw_Line,p);
            Line_2V l2_3=l3.reflect_Line(v,move,draw_Line,p);
            Line_2V l2_4=l4.reflect_Line(v,move,draw_Line,p);
            if(fill_face){
                face_2V f2(l2_1,l2_2,l2_3,l2_4);
                f2.fill(c1_fill,c2,p);
            }
        }
    }

};


//多边形 p+f-l=2
class cube{
private:
    bool isCube;
public :
    int point_num,face_num,line_num;
    Point_3V p[8];
    Line l[12];
    face f[6];
    cube(){
        point_num=0;
        face_num=0;
        line_num=0;
    }
    cube(int point_nums,int line_nums,int face_nums){
        if(point_nums+face_nums-line_nums==2){//公式
            point_num=point_nums;
            face_num=face_nums;
            line_num=line_nums;
            /*p=new Point_3V[point_num];

            l=new Line[line_num];

            f=new face[face_num];*/

            isCube=true;
        }else{
        cube();
        isCube=false;
        }
    }

    void set_Point(Point_3V *point){
        for(int i=0;i<point_num;i++){
            p[i]=point[i];
        }

    }

    void set_cube(Point_3V *point){
        set_Point(point);

        //上下 左右 前后 
        f[0].set_Face(p[0],p[1],p[2],p[3]);//上
        f[1].set_Face( p[7],p[6],p[5],p[4]);//下 

        f[2].set_Face(p[0],p[4],p[5],p[1]);//左
        f[3].set_Face(p[3],p[2],p[6],p[7]);//右 


        f[4].set_Face(p[1],p[5],p[6],p[2]);//前
        f[5].set_Face(p[0],p[3],p[7],p[4]);//后 
    }
    
    void reflect_Cube(Point_3V v,CPoint move,bool draw_Line,bool fill_face,int *c1_fill,int c2,CDC  *p){
        f[0].reflect_Face(v,move,draw_Line,fill_face,c1_fill[0],c2,p);
        f[1].reflect_Face(v,move,draw_Line,fill_face,c1_fill[1],c2,p);

        f[2].reflect_Face(v,move,draw_Line,fill_face,c1_fill[2],c2,p);
        f[3].reflect_Face(v,move,draw_Line,fill_face,c1_fill[3],c2,p);

        f[4].reflect_Face(v,move,draw_Line,fill_face,c1_fill[4],c2,p);
        f[5].reflect_Face(v,move,draw_Line,fill_face,c1_fill[5],c2,p);
    }

    void fill( int p){
        switch(p){
        case 0: {point_num=2+line_num-face_num;} break; //已知其它两个，求点
        case 1:{line_num=point_num+face_num-2;}break;//已知其它两个，求线
        case 2:{face_num=2+line_num-point_num;}break;//已知其它两个，求面
        }
    }

};
void CMy1View::OnDraw(CDC* pDC)
{
    CMy1Doc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    if (!pDoc)
        return;

    // TODO: 在此处为本机数据添加绘制代码

    Point_3V  p[8]={ 
        Point_3V(0,0,100),//0
        Point_3V(100,0,100),//1
        Point_3V(100,100,100),//2
        Point_3V(0,100,100),//3
        Point_3V(0,0,0),//4
        Point_3V(100,0,0),//5
        Point_3V(100,100,0),//6
        Point_3V(0,100,0)//7
    };

    //偏移量
    CPoint move;
    move.SetPoint(200,200);

    //视点
    Point_3V v(1,1.2,1);

    //颜色
    int color[6]={RGB(255,0,0),RGB(0,255,0),RGB(0,0,255),RGB(255,255,0),RGB(255,0,255),RGB(0,255,255)};
    //cube
    int point_num=8,face_num=12,line_num=6;
    cube cb(point_num,face_num,line_num);
    cb.set_cube(p);
    cb.reflect_Cube(v,move,true,false,color,0,pDC);//线框模式
    //cb.reflect_Cube(v,move,true,true,color,0,pDC);//填充模式
}

实验结果：

                                     

 　　　　　　　　　　　　　线框                                                      填充

 

实验总结：

l  创建类Point_3V来存放三维点，Line_2V来存放二维点，Line来存放三维线，Line_2V来存放二维线，face_2V来存放二维面，face来存放三维面，cube来定义一个矩形。以上的二维都是用来平行投影时使用的，三维则是存放在三维空间中真实存在的矩形的信息，且这几个三维类之间使用了类的继承来实现。

l  矩形点的输入顺序应该按照逆时针来输入，这是因为每个面的法向量有两种结果，但是使用背面检测法，只有朝向立方体的外部才为正方向，所以按照逆时针得出这个面上两个不共线的向量，然后求出两者的叉积就可以正确得出面的法向量。

l  立方体投影的实现思路是（假设数据已经正确输入）：

    cube(8点，12棱，6面)-> reflect_Cube(进行立方体的投影)-> f[i].reflect_Face(进行    每个面的投影) -> view_face（判断这个面是否可见，如果可见则将这个面上的4点设置为可    见;如果不可见则判断下个面是否可见） ->l2.reflect_Line(进行一个面4条线条线的投 影)-> end.reflect_Point_3V（进行这条线的两个点投影）->判断是否画线(如果为真，画   线；否则不画)

l  在创建每一个三维真实的点，线，面时默认不可见，由于使用了，类的继承，所以比如要创建线时，要保证这条线的起点是从基类三维点继承过来的信息，所以应该使用指针，那么在线的构造函数中就应该为这个指针动态的创建一个空间，否则程序执行时，会无法访问这个指针的空间。

l  在进行编程时，数学功底要扎实，我在进行两个向量的叉积运算时，未考虑到矩阵奇、偶列的符号不同，所以导致结果为下图所示，最后通过断点测试才知道这个原因。

 

 

面填充时的思路：

将中OnDraw（）函数里的cb.reflect_Cube(v,move,true,false,color,0,pDC);

    换位cb.reflect_Cube(v,move,true,true,color,0,pDC);就好。

实验总结：

    不同颜色的面使用了数组中存放不同的颜色信息来实现，填充方式使用了种子填充，种子的位置使用了四边形的中心坐标。

实验参考文献：

http://www.docin.com/touch_new/preview_new.do?id=489294049&html=1

 补充：

建议大家在使用种子填充时，使用VC6.0,不要用VS，VS会报错：（大家如果有好的方法来解决这个问题，请联系我：2283320260@qq.com）

欢迎大家一起讨论

转载于:https://www.cnblogs.com/feiquan/p/8213875.html

【计算机图形学】三维图形投影和消隐（正等轴测投影图 & 消隐图构造）
m0_65787507的博客
04-29 1675
【计算机图形学】三维图形投影和消隐（正等轴测投影图 & 消隐图构造）
立方体的绘制与消隐
05-25
mfc实现立方体的绘制与消隐
多视投影几何中的消隐点
SLAM的博客
10-18 4208
消隐点 三维立体空间中，一组平行的直线不会相交，或者可以说相交于同一无穷远点，该无穷远点在相机的透视投影作用下会在图像平面中成像，成像点成为消隐点。 消隐点（vanishing points，VP） 图像上的一组消隐点对应一组平行直线，也就是说图像上过同一消隐点的一组直线一定存在平行关系。消隐点体现了一组平行直线的3D方向信息。 也就是说，本来方方正正的立方体在透视投影的作用下，在成像平面变得不...
立方体投影
12-03
qt下 一张包含立方图结构的图像 在新的视角下 立方体物体的新投影位置
【图形学】投影和消隐简介
最新发布
m0_72895175的博客
02-07 1101
对于物体上任意一点的三维坐标P(x,y,z),投影后的三维坐标为P′x′y′z′,那么正交投影的方程为⎩⎨⎧​x′xy′yz′0​。
立方体点云光线投射（消隐）结果1
08-08
因为使用的是“点云”，无面片信息，所以当点云稀疏时，消隐结果有瑕疵：远处的点可能透过近处的“面”（实际不存在面的概念）出现在视野中。以下结果图演示的是，求解每一
长方体拟合到单个RGB图像的鲁棒学习
13070长方体再访：学习鲁棒的3D形状拟合到单个RGB图像Florian Kluger1，Hanno Ackermann1，Eric Brachmann2，Michael Ying Yang3，BodoRosenhahn11汉诺威莱布尼茨大学，2Niantic，3特温特大学摘要人类感知和构建周围...
九年级数学下册第二十九章投影与视图29.3课题学习制作立体模型课时训练新版新人教版
08-06
这涉及到对图形的分割、计算单个模型的表面积，以及优化策略的运用。 以上知识点的掌握，有助于学生在实际操作中构建和理解立体模型，同时也为解决相关的数学问题提供理论基础。在教学过程中，教师可以通过实例和...
基于投影卷积网络的三维形状分割
1基于投影卷积网络的三维形状分割Evangelos Kalogerakis1Melinos Averkiou2Subhransu Maji1SiddharthaChaudhuri31马萨诸塞大学阿默斯特分校2塞浦路斯大学3孟买IIT摘要本文介绍了一种用于将3D对象分割成其标记的语义...
VCNet：一种利用生成模型进行体积填充的深度学习方法
视觉信息学6（2022）62VCNet：一种用于体积填充的生成模型韩军，王朝利Department of Computer Science Engineering，University of Notre Dame，Notre Dame，IN 46556，United Statesar t i cl e i nf o文章历史...
立方体消隐
05-07
实现一个立方体的消影演示。 要求: 可以用键盘操纵立方体的旋转（比如左键按一下向左水平旋转某一角度，上下键做垂直旋转）或者鼠标左键控制（比如向右拖动则图形向右旋转某一固定角度，其余角度同理）。 不可以用OpenGL直接画Cube实现消影过程。必须自行写算法实现，否则为0分。 立方体的6个面分别用不同颜色标注，方便进行区分。
图形学实验-立方体线框模型透视投影
05-03
图形学实验-立方体线框模型透视投影图形学实验-立方体线框模型透视投影图形学实验-立方体线框模型透视投影
图形学图形消隐
05-04
关于图形 的二次图形消隐和相关文档 长方体的自隐藏线消隐上机指导 1. 实验目的与要求：掌握长方体的表面模型的建立；掌握三维图形的显示流程；掌握长方体自消隐的算法。 2. 实验步骤： （1）长方体表面模型的定义 三维齐次坐标结构的定义，面结构的定义，面结构中添加可见性属性；顶点表的定义，面表、与顶点表的关系。 （2）几何变换的实现 分别对顶点进行绕X轴旋转和绕Y轴旋转，旋转角度为参数，以实现轴测投影。 （3）消隐 计算每个面的外法向量，与视向量进行点积，给该面的可见性属性赋值。 （4）投影变换的实现 平行投影中正投影的投影变换公式及矩阵，要求以XOY平面为投影平面，Z轴正方向为视线方向。 （3）窗口-视区变换的实现 窗口大小的选取——一般将所有图形都取在窗口内；注意投影变换时投影平面的选取，投影平面上的坐标与视区坐标x，y的对应。 （4）图形显示 显示面表中的每一个面，对于不可见面用虚线绘制该面各边，对于可见面用实线绘制各边。 3. 具体任务 在已给出程序Draw3D2中，在视图类中分别添加绕X轴旋转和绕Y轴旋转的函数void RotateX（int angle）和void RotateY（int angle）；在视图类中添加计算外法向量的函数HOMOCOORD GetN（HOMOCOORD p1, HOMOCOORD p2, HOMOCOORD p3）,其返回值为外法向量。注意面结构中添加的可见性属性，注意显示图形时对于不可见和可见面的处理。 4. 说明 绕X轴的旋转变化的公式实现： 考虑到旋转变化不影响w分量，可得 其他变换类似。对顶点表每个顶点进行更新。 计算外法向量函数的： P1，p2，p3为面上逆时针依次相连的三个顶点，由此外法向量N=（p2-p1）×（p3-p2）； 若令x1=p2.x-p1.x, y1=p2.y-p1.y, z1=p2.z-p1.z; x2=p3.x-p2.x, y2=p3.x-p2.x, z2=p3.x-p2.x; 则外法向量可以由下列行列式求出 即
OpenGL 立方体平行斜投影的绘制(鼠标控制方向)
03-27
绘制一个长方体的平行斜投影，投影在z=0平面上，使用鼠标控制转向，三维旋转，没有键盘的东西，有需要请自取。
用C语言设计实体光照模型-课程设计报告.doc
07-09
具体实现时，要定义顶点表和面表，以便表示长方体并进行旋转。通过计算每个面的外法向量和可见性，可以判断面是否朝向光源。对于可见面，需要计算环境光和点光源的漫反射分量，这涉及到光强的计算和角度的比较。环境...
【计算机图形学】三维图形投影和消隐（三视图构造）
m0_65787507的博客
04-29 2218
【计算机图形学】三维图形投影和消隐（三视图构造）
(转载)深入探索透视投影变换
weixin_30896825的博客
09-13 217
转载来的文章:http://www.ategpu.com/2009/10/06/%E6%B7%B1%E5%85%A5%E6%8E%A2%E7%B4%A2%E9%80%8F%E8%A7%86%E6%8A%95%E5%BD%B1%E5%8F%98%E6%8D%A2.html 好文章，记得刚开始接触ogl时，阅读过此文，当时看的云里雾里。现在看来，不禁要称赞作者，能写的如此详细。感谢作者的好文！ 深...
cesium创建长方体、立方体的三种方式
0月影星云0的博客
04-23 3967
第一种 viewer.entities.add({ id: `box`, name : `box`, position: Cesium.Cartesian3.fromDegrees(经度值, 纬度值, 离地面高度值), box : { dimensions : new Cesium.Cartesian3(方体长度值, 方体宽度值, 方体高度值), material : Cesium.Color.fromCssColorString(“#ffff
Cesium 渐变长方体实现-Shader
一路走一路学，总会不落后
02-01 849
/ position in eye coordinates 获取eyePosition。// normal in eye coordinates 获取eyeNormal。1.1 在cesium中，可通过vec4 p = czm_computePosition();3.1由于获取道德是模型坐标，并不是东北上坐标，所以不能直接使用坐标y值表示模型高度。3.2模型高度计算： 通过矢量长度计算公式算出点模型坐标内点到地心原点的距离。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值