精华内容
下载资源
问答
  • 1、第一章 绪论构成图形的要素有两个: 几何要素:刻画对象的轮廓、形状等 非几何要素:刻画对象的颜色、材质等计算机中表示图形的方法-点阵表示枚举出图形中所有的点(强调图形由点构成)简称为图像(数字图像)-参数...

    《计算机图形学复习大纲》由会员分享,可在线阅读,更多相关《计算机图形学复习大纲(6页珍藏版)》请在人人文库网上搜索。

    1、第一章 绪论构成图形的要素有两个: 几何要素:刻画对象的轮廓、形状等 非几何要素:刻画对象的颜色、材质等计算机中表示图形的方法-点阵表示枚举出图形中所有的点(强调图形由点构成)简称为图像(数字图像)-参数表示由图形的形状参数(方程或分析表达式的系数,线段的端点坐标等)+属性参数(颜色、线型等)来表示图形简称为图形:什么是计算机图形学定义:计算机图形学是研究怎样用数字计算机生成、处理和显示图形的一门学科。如何在计算机中表示图形、以及利用计算机进行图形的计算、处理和显示的相关原理与算法,构成了计算机图形学的主要研究内容。第二章 图形设备与系统图形输出包括图形的显示和图形的绘制,图形显示指的是在屏幕。

    2、上输出图形图形绘制通常指把图形画在纸上,也称硬拷贝,打印机和绘图仪是两种最常用的硬拷贝设备行频、帧频水平扫描频率为行频。垂直扫描频率为帧频。逐行扫描、隔行扫描隔行扫描方式是先扫偶数行扫描线,再扫奇数行扫描线。象素整个屏幕被扫描线分成 n 行,每行有 m 个点,每个点为一个象素。整个屏幕有 m n 个象素。分辨率是指CRT在水平或垂直方向的单位长度上能分辨出的最大光点(象素)数,分为水平分辨率和垂直分辨率。通常用屏幕上象素的数目来表示。比如上述的 n 行,每行 m 点的屏幕分辨率为 m n 。分辨率越高,相邻象素点之间的距离越小,显示的字符或图像也就越清晰。分辨率受显示器生产工艺、扫描频率以及显。

    3、示存储器容量的限制。第三章 直线、圆、椭圆的生成直线段的扫描转换算法有:DDA算法、 中点画线法、 Bresenham画线算法什么是DDA算法,采用DDA算法画直线段P0(0,0)-P1(5,2)。什么是中点画线法,用中点画线法P0(0,0) P1(5,2)Bresenham算法的特点是: 1 不必计算直线之斜率,因此不做除法; 2 不用浮点数,只用整数; 3 只做整数加减法和乘2运算,而乘2运算可以用 硬件移位实现. Bresenham算法速度很快,并适于用硬件实现. DDA算法的特点: 浮点数运算 不易硬件实现 中点画线法特点: 只有整数运算,不含乘除法 可用硬件实现第四章 二维填充图元的。

    4、生成多边形分为凸多边形、凹多边形、含内环的多边形:多边形的表示方法:顶点表示:用多边形顶点的序列来刻划多边形。直观、几何意义强、占内存少;不能直接用于面着色。点阵表示:用位于多边形内的象素的集合来刻划多边形。失去了许多重要的几何信息;便于运用帧缓冲存储器表示图形,易于面着色多边形的扫描转换:把多边形的顶点表示转换为点阵表示,也就是从多边形的给定边界出发,求出位于其内部的各个象素,并给帧缓冲器内的各个对应元素设置相应的灰度和颜色,通常称这种转换为多边形的扫描转换。三种方法:逐点判断;扫描线算法;边界标志法什么是逐点判断算法:逐个像素判别其是否位于多边形内部判断一个点是否位于多边形内部:射线法从当。

    5、前像素发射一条射线,计算射线与多边形的交点个数内部:奇数个交点外部:偶数个交点逐点判断算法的不足:速度慢:几十万甚是几百万像素的多边形内外判断,大量的求交、乘除运算,没有考虑像素之间的联系多边形扫描转换算法考虑到了三种连贯性:区域的连贯性、扫描线连贯性和边的连贯性多边形扫描转换算法的优点:充分利用多边形的区域、扫描线和边的连贯性,避免了反复求交的大量运算多边形扫描转换算法的不足:算法的数据结构和程序结构复杂对各种表的维持和排序开销太大,适合软件实现而不适合硬件实现什么是4-连通,8-连通:什么是四连通区域:区域内任意两个像素,从一个像素出发,可以通过上、下、左、右四种运动,到达另一个像素什么是。

    6、八连通区域:区域内任意两个像素,从一个像素出发,可以通过水平、垂直、正对角线、反对角线八种运动,到达另一个像素四连通和八连通区域的关系:四连通区域属于八连通区域 (反之不成立)四连通区域的边界是八连通区域八连通区域的边界是四连通区域第五章裁剪什么是裁剪:确定图形中哪些部分落在显示区之内,哪些落在显示区之外,以便只显示落在显示区内的那部分图形。这个选择过程称为裁剪直线裁剪的常见方法: 直接求交算法、Cohen-Sutherland算法、中点算法、梁友栋barskey算法。多边形裁剪有哪些方法:Sutherland-Hodgman算法、Weiler-Athenton算法、第六章 图形变换用户域:程。

    7、序员用来定义草图的整个自然空间窗口区:用户指定的任一区域视图区:任何小于或等于屏幕域的区域视图区用设备坐标定义在屏幕域中、窗口区显示在视图区,需做窗口区到视图区的坐标转换。图形变换是计算机图形学基础内容之一,包括:几何变换,投影变换,视窗变换线性变换,属性不变,拓扑关系不变。图形的几何变换:对图形的几何信息经过几何变换后产生新的图形。图形几何变换的两种形式:1.图形不变,坐标系改变;2.图形改变,坐标系不变第七章 曲线曲面的生成表示曲线和曲面的基本方法有两种:参数法和非参数法。(1)非参数法y=f(x) 显函数(不能表示封闭或多值的曲线)f(x,y)=0 隐函数(方程的根很难求)(2)参数法x。

    8、=f(t) y=g(t) 求导很方便,不会出现计算上的困难主要三类拟合曲线: Ferguson曲线 三次Bezier曲线 B样条曲线Bezier曲线与B样条曲线的区别:对于特征多边形的逼近性二次B样条曲线优于三次B样条曲线三次Bezier曲线优于二次Bezier曲线相邻曲线段之间的连续性二次B样条曲线只达到一阶导数连续三次B样条曲线则达到二阶导数连续角点的修改对曲线形状的影响Bezier曲线:修改一个角点将影响整条曲线的形状。B样条曲线:修改一个角点只影响该角点所在位置前后三段曲线的形状。常见的拟合曲面有三种: Coons曲面, Bezier曲面, B样条曲面,Bezier曲线的de Casteljau递推计算公式。

    展开全文
  • 方法一:Green公式Green公式揭示了平面区域的二重积分和封闭曲线上的线积分的关系。其中L+表示沿着封闭区域的边界曲线正向。 并且由Green公式的推导过程我们知道: 这里若L=-y,可以保证(1)式子在区域中恒正,且...

    方法一:Green公式

    Green公式揭示了平面区域的二重积分和封闭曲线上的线积分的关系。

    其中L+表示沿着封闭区域的边界曲线正向。 

    并且由Green公式的推导过程我们知道:

     

    这里若L=-y,可以保证(1)式子在区域中恒正,且等于封闭区域面积。

    同理,M=x,也可以保证(2)式子在区域中恒正,且等于封闭区域面积。

    所以我们只需沿着多边形的边求曲线积分,若积分为正,则是沿着边界曲线正方向(逆时针),反之为顺时针,且所得绝对值为多边形面积。

    NOTE:边界曲线的正向即沿着边界曲线,单连通区域总在边界曲线的左边。(这里边界曲线正向,即我们所看到的逆时针方向)

     

    这里假设我们程序中的多边形点为(x0,y0), (x1,y1), (x2,y2), . . . (xn-1,yn-1)

    我们来计算沿着点(x0,y0), (x1,y1), (x2,y2), . . . (xn-1,yn-1)的曲线积分。

    其中对于每段分割线段,y取( yn + yn+1)  / 2 , dx=xn+1 - xn   

    d=0;
    for(int i=0;i<n-1;i++)
    {
        d+= -0.5*(y[i+1]+y[i])*(x[i+1]-x[i]);
    }
    if(d>0)
        std::cout<<"counter clockwise"<<std::endl;
    else
        std::cout<<"clockwise"<<std::endl;

    牛客练习赛18

    链接: https://www.nowcoder.com/acm/contest/110/B
    来源:牛客网

    为了让所有选手都感到开心,Nowcoder练习赛总会包含一些非常基本的问题。 比如说:
    按顺时针或逆时针方向给你一个简单的多边形的顶点坐标,请回答此多边形是顺时针还是逆时针。

    输入描述:

    输入包含N + 1行。
    第一行包含一个整数N,表示简单多边形的顶点数。
    在下面的N行中,第i行包含两个整数xi,yi,表示简单多边形中的第i个顶点的坐标。
    

    输出描述:

    如果简单多边形按顺时针顺序给出,则在一行中输出“clockwise”(不带引号)。 否则,打印"counterclockwise''(不带引号)。
    #include<iostream>
    using namespace std;
    int x[35], y[35];
    int main(){
        int N;
        cin >> N;
        for (int i = 0; i < N; i++)
           cin >> x[i] >> y[i];
        int d = 0;
        for (int i = 0; i < N - 1; i++)
            d += -0.5 * (y[i + 1] + y[i]) * (x[i + 1] - x[i]);
        if(d > 0)
            cout << "counterclockwise"<< endl;
        else
            cout << "clockwise" << endl;
    
    }
    

    方法二:端点判断

    这个方法比较简单,遍历所有点,找到x最大的点Pm(该点一定在最右端曲线的“凸起”部分上),然后取该点前后各一个点Pm-1、Pm+1,组成向量(Pm-1,Pm)、(Pm,Pm+1)。然后进行向量叉乘即可判断出顺时针或逆时针。

    如图,规定向量叉乘使用“右手定则”

    +表示该点Pm和前后两个点组成的两个向量(Pm-1,Pm)、(Pm,Pm+1),叉乘得到的向量指向z轴负方向;

    -表示(Pm-1,Pm)x(Pm,Pm+1)得到的向量指向z轴方向。

    NOTE:这里必须进行遍历寻找凸点,否则若多边形含有凹的部分,并且选取的点于凹部分中,会得到相反的结果。

    转至:https://www.cnblogs.com/kyokuhuang/p/4250526.html
    展开全文
  • 判断多边形是否相交 ,当前认为一个点相交也是相交,可针对凹多边形和凸边型等多复杂的多边形进行相交判断,采用java实现,因为网上java实现的比较少,所以这里写下如何实现,适用于碰撞检测,地图等等应用场景

    判断两个多边形是否相交 ,当前认为一个点相交也是相交,可针对凹多边形和凸边型等多复杂的多边形进行相交判断,采用java实现,因为网上java实现的比较少,所以这里写下如何实现,适用于碰撞检测,地图等等应用场景

    入口方法:intersectionJudgment

    package org.dxl;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.experimental.Accessors;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.List;
    
    /**
     * * @projectName launcher2
     * * @title Test
     * * @package org.dxl
     * * @description  判断两个多边形是否相交
     * * @author IT_CREAT     
     * * @date  2020 2020/11/5/005 22:06  
     * * @version
     */
    @Slf4j
    public class Test {
        /*
        第一步:快速排除,以某一个多边形参照物,沿着此多边形画矩形,用矩形将多边形包起来,
        在判断另一个多边形是否在这个矩形框中存在顶点,没有就说明另一个矩形一定在参照矩形框的外围。
        第二步:利用的是向量叉乘求两线段是否相交,这种求法是求的绝对相交(交叉相交),只要存在多边形任意两线段相交,就一定相交,
        同时还有一种情况,就是平行或者在延长线及线段上,这时候需要排除平行和在延长线上的情况
        第三步:用点射法求某一个顶点是否在某个多边形内部,这里需要同时同时判断多变形1上的所有点都在多边形2的内部或者边线段上,
        或者是反向多边形2的所有点在多边形1的内部或边线上,二者满足其一即可;
        */
        public static void main(String[] args) {
            Point point = new Point(0, 0.5);
            Polygon polygon = new Polygon().setPoints(Arrays.asList(
                    new Point(0, 0),
                    new Point(0, 0.5),
                    new Point(0.5, 0.5),
                    new Point(0.5, 0)
            ));
            // 点是否在内部
            boolean b = pointInPolygon(point, getLineSegment(polygon));
            System.out.println(b);
    
            Polygon polygon1 = new Polygon().setPoints(Arrays.asList(
                    new Point(-1, -1),
                    new Point(-1, 1),
                    new Point(1, 1),
                    new Point(1, -1)
            ));
            // 两个多边形相交
            System.out.println(intersectionJudgment(polygon, polygon1));
        }
    
        /**
         * 多边形相交判断(有一个点相交也认为相交)
         *
         * @param polygon1 多边形1
         * @param polygon2 多边形2
         * @return boolean
         */
        public static boolean intersectionJudgment(Polygon polygon1, Polygon polygon2) {
            if (isExistNull(polygon1, polygon2)) {
                return false;
            }
            if (isExistNullOrEmpty(polygon1.getPoints(), polygon2.getPoints())) {
                return false;
            }
            // 1、快速判断,如果不想交,则返回不相交
            if (!fastExclude(polygon1, polygon2)) {
                return false;
            }
            // 获取多边形线段集合
            List<LineSegment> lineSegment1 = getLineSegment(polygon1);
            List<LineSegment> lineSegment2 = getLineSegment(polygon2);
            // 存在线段集合任意一方为空,则不想交
            if (isExistNullOrEmpty(lineSegment1, lineSegment2)) {
                return false;
            }
            // 2、向量叉乘判断多边形是否存在线段相交,存在相交则返回相交
            if (crossJudgment(lineSegment1, lineSegment2)) {
                return true;
            }
            // 3、包含关系判断,分别两次判断,判断polygon1是否在polygon2内部和polygon2是否在polygon1内部,满足其一即可
            boolean isInclude = includeRelation(polygon1, lineSegment2);
            if (isInclude) {
                return true;
            }
            return includeRelation(polygon2, lineSegment1);
        }
    
        /**
         * 1、快速判断多边形是否相交
         *
         * @param polygon1 多边形1
         * @param polygon2 多边形2
         * @return boolean
         */
        private static boolean fastExclude(Polygon polygon1, Polygon polygon2) {
            // 多边形1
            double polygon1MaxX = polygon1.getPoints().get(0).getX();
            double polygon1MinX = polygon1.getPoints().get(0).getX();
            double polygon1MaxY = polygon1.getPoints().get(0).getY();
            double polygon1MinY = polygon1.getPoints().get(0).getY();
            for (Point point : polygon1.getPoints()) {
                polygon1MaxX = Math.max(polygon1MaxX, point.getX());
                polygon1MinX = Math.min(polygon1MinX, point.getX());
                polygon1MaxY = Math.max(polygon1MaxY, point.getY());
                polygon1MinY = Math.min(polygon1MinY, point.getY());
            }
    
            // 多边形2
            double polygon2MaxX = polygon2.getPoints().get(0).getX();
            double polygon2MinX = polygon2.getPoints().get(0).getX();
            double polygon2MaxY = polygon2.getPoints().get(0).getY();
            double polygon2MinY = polygon2.getPoints().get(0).getY();
            for (Point point : polygon2.getPoints()) {
                polygon2MaxX = Math.max(polygon2MaxX, point.getX());
                polygon2MinX = Math.min(polygon2MinX, point.getX());
                polygon2MaxY = Math.max(polygon2MaxY, point.getY());
                polygon2MinY = Math.min(polygon2MinY, point.getY());
            }
    
            // 我这里是人为临界点的点-点,点-线也是属于相交,(如过你认为不是,加上等于条件,也就是最大和最小出现任意相等也是不想交)
            // 1、多边形1的最大x比多边形2最小x还小,说明多边形1在多边形2左边,不可能相交
            // 2、多边形1的最小x比多边形2最大x还大,说明多边形1在多边形2右边,不可能相交
            // 3、多边形1的最大y比多边形2最小y还小,说明多边形1在多边形2下边,不可能相交
            // 4、多边形1的最小y比多边形2最大y还小,说明多边形1在多边形2上边,不可能相交
            return !(polygon1MaxX < polygon2MinX)
                    && !(polygon1MinX > polygon2MaxX)
                    && !(polygon1MaxY < polygon2MinY)
                    && !(polygon1MinY > polygon2MaxY);
        }
    
        /**
         * 获取线段集合
         *
         * @param polygon 多边形
         * @return 线段集合
         */
        private static List<LineSegment> getLineSegment(Polygon polygon) {
            List<LineSegment> lineSegments = new ArrayList<>();
            List<Point> points = polygon.getPoints();
            // 依次链接,形成线段
            for (int i = 0; i < points.size() - 1; i++) {
                Point previousElement = points.get(i);
                Point lastElement = points.get(i + 1);
                lineSegments.add(new LineSegment(previousElement, lastElement));
            }
            // 最后一组线段(最后一个点和初始点形成最后一条线段,形成闭环)
            if (lineSegments.size() > 0) {
                Point previousElement = points.get(points.size() - 1);
                Point lastElement = points.get(0);
                lineSegments.add(new LineSegment(previousElement, lastElement));
            }
            return lineSegments;
        }
    
        /**
         * 2、线段集合之间是否存在相交关系
         *
         * @param lineSegments1 线段集合1(其中一个多边形的线段集合)
         * @param lineSegments2 线段集合2(另一个多边形的线段集合)
         * @return boolean
         */
        private static boolean crossJudgment(List<LineSegment> lineSegments1, List<LineSegment> lineSegments2) {
            for (LineSegment lineSegment1 : lineSegments1) {
                for (LineSegment lineSegment2 : lineSegments2) {
                    // 任意一组线段相交及多边形相交,返回相交
                    if (calculationLineSegmentCrossing(lineSegment1, lineSegment2)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        /**
         * 线段是否相交(向量叉乘判断)
         *
         * @param lineSegment1 线段1
         * @param lineSegment2 线段2
         * @return boolean
         */
        private static boolean calculationLineSegmentCrossing(LineSegment lineSegment1, LineSegment lineSegment2) {
            // 如果存在任意一点在对方线段上,则相交
            if (isPointOnline(lineSegment1, lineSegment2)) {
                return true;
            }
            // 当不存端点在线段上,则进行交叉相交判断
            // A点
            Point aPoint = lineSegment1.getPrePoint();
            // B点
            Point bPoint = lineSegment1.getLastPoint();
            // C点
            Point cPoint = lineSegment2.getPrePoint();
            // D点
            Point dPoint = lineSegment2.getLastPoint();
            // AB向量叉乘AC向量
            double bc = crossProduct(aPoint, bPoint, aPoint, cPoint);
            // AB向量叉乘AD向量
            double bd = crossProduct(aPoint, bPoint, aPoint, dPoint);
            // CD向量叉乘CA向量
            double da = crossProduct(cPoint, dPoint, cPoint, aPoint);
            // CD向量叉乘CB向量
            double db = crossProduct(cPoint, dPoint, cPoint, bPoint);
            return bc * bd < 0 && da * db < 0;
        }
    
        /**
         * 两线段是否存在点在对方线段上
         *
         * @param lineSegment1 线段1
         * @param lineSegment2 线段2
         * @return boolean
         */
        private static boolean isPointOnline(LineSegment lineSegment1, LineSegment lineSegment2) {
            return isExistTrue(new boolean[]{
                    isCollinearIntersection(lineSegment1.getPrePoint(), lineSegment2),
                    isCollinearIntersection(lineSegment1.getLastPoint(), lineSegment2),
                    isCollinearIntersection(lineSegment2.getPrePoint(), lineSegment1),
                    isCollinearIntersection(lineSegment2.getLastPoint(), lineSegment1)});
        }
    
        /**
         * 点是否在线段上
         *
         * @param point            点
         * @param lineSegmentStart 线段起始点
         * @param lineSegmentEnd   线段尾点
         * @return boolean
         */
        private static boolean isCollinearIntersection(Point point, Point lineSegmentStart, Point lineSegmentEnd) {
            // 排除在延长线上的情况
            if (point.getX() >= Math.min(lineSegmentStart.getX(), lineSegmentEnd.getX())
                    && point.getX() <= Math.max(lineSegmentStart.getX(), lineSegmentEnd.getX())
                    && point.getY() >= Math.min(lineSegmentStart.getY(), lineSegmentEnd.getY())
                    && point.getY() <= Math.max(lineSegmentStart.getY(), lineSegmentEnd.getY())) {
                // 任意两点之间形成的向量叉乘等于0,表示在线段上或延长线上(三点共线)
                return crossProduct(point, lineSegmentStart, point, lineSegmentEnd) == 0;
            }
            return false;
        }
    
        /**
         * 点是否在线段上
         *
         * @param point       点
         * @param lineSegment 线段
         * @return boolean
         */
        private static boolean isCollinearIntersection(Point point, LineSegment lineSegment) {
            return isCollinearIntersection(point, lineSegment.getPrePoint(), lineSegment.getLastPoint());
        }
    
        /**
         * 3、多边形polygon的所有点是都在另一个多边形内部(包含关系)
         *
         * @param polygon      被包含(内部)多边形
         * @param lineSegments 包含(外部)多边形所有线段集合
         * @return boolean
         */
        private static boolean includeRelation(Polygon polygon, List<LineSegment> lineSegments) {
            List<Point> points = polygon.getPoints();
            // 所有点在内部或者线段上才算包含,返回包含关系,只要一个不满足,则返回不包含关系
            for (Point point : points) {
                if (!pointInPolygon(point, lineSegments)) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 判断某个点是否在多边形内部
         *
         * @param point        点
         * @param lineSegments 多边形线段集合
         * @return boolean
         */
        private static boolean pointInPolygon(Point point, List<LineSegment> lineSegments) {
            // 点坐标
            double x = point.getX();
            double y = point.getY();
            // 交点个数
            int intersectionNum = 0;
            // 判断射线与多边形的交点个数
            for (LineSegment seg : lineSegments) {
                // 如果点在多边形边线上,则算在多边形内部
                if (isCollinearIntersection(point, seg.getPrePoint(), seg.getLastPoint())) {
                    return true;
                }
                double maxY = Math.max(seg.getPrePoint().getY(), seg.getLastPoint().getY());
                double minY = Math.min(seg.getPrePoint().getY(), seg.getLastPoint().getY());
                if (y >= minY && y < maxY) {
                    // 计算交点X坐标
                    double intersectionPointX = (y - seg.getPrePoint().getY()) * (seg.getLastPoint().getX() - seg.getPrePoint().getX())
                            / (seg.getLastPoint().getY() - seg.getPrePoint().getY()) + seg.getPrePoint().getX();
                    if (x > intersectionPointX) {
                        intersectionNum++;
                    }
                }
            }
            return intersectionNum % 2 != 0;
        }
    
        /**
         * 向量叉乘
         *
         * @param point1Start 向量1起点
         * @param point1End   向量1尾点
         * @param point2Start 向量2起点
         * @param point2End   向量2尾点
         * @return 向量叉乘结果
         */
        private static double crossProduct(Point point1Start, Point point1End, Point point2Start, Point point2End) {
            // 向量a
            double aVectorX = point1End.getX() - point1Start.getX();
            double aVectorY = point1End.getY() - point1Start.getY();
            // 向量b
            double bVectorX = point2End.getX() - point2Start.getX();
            double bVectorY = point2End.getY() - point2Start.getY();
            // 向量a叉乘向量b
            return aVectorX * bVectorY - bVectorX * aVectorY;
        }
    
        /**
         * 是否存在空对象
         *
         * @param objects 对象集合
         * @return boolean
         */
        private static boolean isExistNull(Object... objects) {
            for (Object object : objects) {
                if (object == null) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 是否存在空集合
         *
         * @param collections 集合对象
         * @return boolean
         */
        private static boolean isExistNullOrEmpty(Collection<?>... collections) {
            for (Collection<?> collection : collections) {
                if (collection == null || collection.isEmpty()) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 是否存在true
         *
         * @param booleans 布尔集合
         * @return boolean
         */
        private static boolean isExistTrue(boolean[] booleans) {
            for (boolean bool : booleans) {
                if (bool) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 点
         */
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        private static class Point {
            private double x;
            private double y;
        }
    
        /**
         * 线段
         */
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        private static class LineSegment {
            private Point prePoint;
            private Point lastPoint;
        }
    
        /**
         * 多边形
         */
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        @Accessors(chain = true)
        private static class Polygon {
            private List<Point> points;
        }
    }
    

     

    展开全文
  • 5.物体的多边形表示

    千次阅读 2019-12-07 15:57:30
    ♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥♥,.*,....1.物体的多边形表示 ...2.多边形表示方法——OBJ格式 3.三角形网格表示 4.多边形表示的优势与不足 ♥,.*,.♥...

    ♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥

    目录:

    1.物体的多边形表示

    2.多边形表示方法——OBJ格式

    3.三角形网格表示

    4.多边形表示的优势与不足

    ♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥

    1.物体的多边形表示

    物体的多边形表示

    物体的多边形表示就是利用大量的平面片(如三角形、四边形等)来表示物体。

    2.多边形表示——OBJ格式

    基础知识

    (1)顶点坐标系(x,y,z)

    存储面片的顶点。

    (2)纹理坐标系(u,v)

    控制纹理映射时纹理在表面上的位置。例如物体某个部位的颜色不同。

    (3)法向表(n_{_{x}},n_{_{y}},n_{_{z}})

    控制物体绘制时的着色光滑程度。

    如果顶点法向作为面片法向,则得到的图形是棱角分明的。

    如果顶点法向是周围面片法向的平均,则得到的图形是光滑的。

    (4)面表

    由指向顶点、纹理坐标以及法向的指针组成。

    OBJ格式

    OBJ是一种3D模型文件,主要支持多边形模型,并且支持三个点以上的面。

    OBJ文件由一行行文本组成,注释行以“#”开头。

    每行(除空行)以关键字开头,关键字说明数据的类型。多行使用“\”连接。

    关键字有:

    顶点数据(Vertex data)

    v 几何体顶点 (Geometric vertices)

    vt 贴图坐标点 (Texture vertices)

    vn 顶点法线 (Vertex normals)

    vp 参数空格顶点 (Parameter space vertices)

    deg (Degree)

    bmat 基础矩阵 (Basis matrix)

    step 步尺寸 (Step size)

    cstype 曲线或表面类型 (Curve or surface type)

    p (Point)

    l 线 (Line)

    f (Face)

    curv 曲线 (Curve)

    curv2 2D曲线 (2D curve)

    surf 表面 (Surface)

    自由形态曲线(Free-form curve)/表面主体陈述(surface body statements):

    parm 参数值 (Parameter values )

    trim 外部修剪循环 (Outer trimming loop)

    hole 内部整修循环 (Inner trimming loop)

    scrv 特殊曲线 (Special curve)

    sp 特殊的点 (Special point)

    end 结束陈述 (End statement)

    con 连接 (Connect)

    成组(Grouping):

    g 组名称 (Group name)

    s 光滑组 (Smoothing group)

    mg 合并组 (Merging group)

    o 对象名称 (Object name)

    bevel 导角插值 (Bevel interpolation) 

    c_interp 颜色插值 (Color interpolation) 

    d_interp 溶解插值 (Dissolve interpolation)

    lod 细节层次 (Level of detail) 

    usemtl 材质名称 (Material name) 

    mtllib 材质库 (Material library) 

    shadow_obj 投射阴影 (Shadow casting) 

    trace_obj 光线跟踪 (Ray tracing) 

    ctech 曲线近似

    stech 表面近似技术

    3.三角形网格表示

    (1)边界表示

    边界表示(Boundary Representation)也称为BRep表示。

    物体可以表示为面的并集,面也可以有曲面加上边界表示,边界是边的并集,边又由点组成。

    即:

    顶点+边+面=拓扑信息

    顶点位置+边形状+曲面参数=几何信息

    (2)边界表示的数据结构

    边界表示的数据结构有很多种,主要有半边数据结构、翼边数据结构、辐射变数据结构等。

    a.半边数据结构

    可定向的二维流形及其子集。

    每条边被记为两条半边。

    记录每条半边的:

    • 起始定点的指针
    • 邻接面的指针(如果为边界,指针为NULL)
    • 下一条半边
    • 相邻的半边
    • 前一条半边(可选)

    面:边界上的一条半边

    顶点:坐标值+指向以此顶点为起始端点的半边

    算法数据结构为:

    struct HE_edge

    {

    HE_vert* vert; // vertex at the end of the half-edge

    HE_edge* pair; // oppositely oriented adjacent half-edge

    HE_face* face; // face the half-edge borders

    HE_edge* next; // next half-edge around the face

    };

    b.半边数据结构表示实例

    半边数据结构

    计算顶点的坐标和以该顶点起始的半边:

    顶点

    坐标

    以此为起点的半边

    v1

    (x1, y1, z1)

    e2,1

    v2

    (x2, y2, z2)

    e1,1

    v3

    (x3, y3, z3)

    e4,1

    v4

    (x4, y4, z4)

    e7,1

    v5

    (x5, y5, z5)

    e5,1

    统计面和半边:

    半边

    f1

    e1,1

    f2

    e3,2

    f3

    e4,2

    则:

    半边

    起点

    相邻半边

    下条半边

    前条半边

    e3,1

    v3

    e3,2

    f1

    e1,1

    e2,1

    e3,2

    v2

    e3,1

    f2

    e4,1

    e5,1

    e4,1

    v3

    e4,2

    f2

    e5,1

    e3,2

    e4,2

    v5

    e4,1

    f3

    e6,1

    e7,1

    c.其他关于半边数据结构

    优势:查询时间和操作时间均为O(1)

    缺点:信息冗余

    4.多边形表示的优势与不足

    优势:

    • 表示简单
    • 可以表示具有任意拓扑的物体
    • 可以表示具有丰富细节的物体
    • 大部分图形硬件支持多边形物体的加速绘制

    不足:

    • 逼近表示,难以满足放大要求
    • 难以用传统方法修改物体外形
    • 缺乏解析表达式,几何属性计算困难
    • 数据量庞大,数据冗余

     

    Click 下一篇文章:6.物体的几何表示——参数曲面+参数曲线

     

    ♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥

    广告时间:

    本宝宝开通了一个公众号,记录日常的深度学习和强化学习笔记。希望大家可以共同进步,嘻嘻嘻!爱你呦!

    KeepYourAims

    展开全文
  • 多边形的填充,算法原理,特殊情况的处理办法。
  • 填空题媒体在计算机领域中有两种含义:一是指存储信息的(实体),二是指表示和传播信息的(载体)。多媒体技术的媒体指的是(后者)。通常“媒体”可分为以下五种类型:(感觉)媒体、(表示 )媒体、(显示)媒体、(存储)媒体...
  • 在计算机图形学中,多边形有两种重要的表示方法:顶点表示和点阵表示。顶点表示是用多边形的顶点序列来表示多边形。这种表示直观、几何意义强、占内存少,易于进行几何变换,但由于它没有明确指出哪些象素在多边形内...
  • 拓扑多边形自动构建的一快速算法2 浙 江 测 绘 2001年拓扑多边形 自动构建的一快速算法闫浩文 祝方雄(宁波市测绘设计研究院 宁波 315041)摘要:本文提 出了一基于方位角计算的多 次方位角计算,籍此就可以搜索...
  • } (3)剔除多边形表面 在三维空间中,一个多边形虽然有两个面,但我们无法看见背面的那些多边形,而一些多边形虽然是正面的,但被其他多边形所遮挡。如果将无法看见的多边形和可见的多边形同等对待,无疑会降低...
  • 算法:凸多边形最优三角剖分

    千次阅读 多人点赞 2019-10-31 18:20:49
    (1)凸多边形的三角剖分:将凸多边形分割成互不相交的三角形的弦的集合T。 (2)最优剖分:给定凸多边形P,以及定义在由多边形的边和弦组成的三角形上的权函数w。要求确定该凸多边形的三角剖分,使得该三角剖分中诸...
  • 用turtle库画多边形方法小汇总

    千次阅读 2020-02-29 11:02:26
    学习中参阅一些资料,发现用turtle库画多边形方法有多种,其中有的思路比较巧妙. 1.用直线和角度画正n边形 from turtle import * width(2) n=eval(input('请输入边数')) for i in range(n): fd(100) left(360...
  • 提取条纹中心线是线条结构中的关键步骤光扫描视觉测量系统。... 一幅图像的平均时间不超过5毫秒,并且通过提出的方法获得的点云的完整性和光滑度比其他两种方法要好。 这证明了有效性方法的实用性。
  • 多边形扩展算法

    千次阅读 2017-06-20 16:35:15
    多边形扩展算法,c++实现
  • 泰森多边形构建原理

    2021-02-27 22:43:05
    泰森多边形定义泰森多边形是荷兰气候学家 A.H.Thiessen 提出的一根据离散分布的气象站的降雨量来计算平均降雨量的方法,即将所有相邻气象站连成三角形,作这些三角形各边的垂直平分线,于是每个气象站周围的若干...
  • ♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,....3.多边形的扫描转换(扫描线算法) 4.多边形的扫描转换与区域填充比较 ♥,....
  • 图形学初步----------多边形填充算法

    万次阅读 多人点赞 2018-11-05 14:24:12
    多边形在计算机中顶点表示和点阵表示两种。 顶点表示 就是用多边形的顶点序列来表示多边形。点阵表示是用位于多边形内的象素集合来表示多边形。顶点表示占内存少,几何意义强,易于进行几何变换;而 点阵表示 ...
  • 泰森多边形算法原理

    万次阅读 2018-03-08 16:21:20
    荷兰气候学家A·H·Thiessen提出了一根据离散分布的气象站的降雨量来计算平均降雨量的方法,即将所有相邻气象站连成三角形,作这些三角形各边的垂直平分线,于是每个气象站周围的若干垂直平分线便围成一个多边形.....
  • 常见凸多边形判断方法

    万次阅读 2013-08-21 21:15:33
    多边形的判定方法 在计算几何和地理信息系统中,多边形的凹凸性判定十分重要。那么什么是凹多边形和凸多边形呢?首先,我们从直观上来理解,凸多边形就是多边形任意个顶点的连线在多边形内,那么凹多边形就是...
  • 1.描述:一个由n个顶点构成的多边形。每个顶点被赋予一个整数值,每条边被赋予一个运算符“+”或“*”。所有边依次用整数从1到n编号。游戏第1步,将一条边删除。随后n-1步按以下方式操作:(1)选择一条边E以及由E...
  • arcpy泰森多边形法计算面雨量工具

    千次阅读 2019-10-22 20:24:36
    在水利部门或气象部门中面平均降水量是降雨中很重要的指标,传统计算多用使用算术平均法,泰森多边形法和等值线法,后两种计算方法在传统的计算中很难计算,但使用用GIS十分方便计算,可以是任意区域的任意一场降雨...
  • 当n=4时,有两种划分方法 当n=5时,5种划分方法 ........ 【求解思路】 仅仅考虑和两点连成的边,那么在最终的划分中必定属于一个划分三角形的2个顶点。 依据第三个顶点进行分类讨论: 若第三个顶点为 ...
  • 提出一基于Morphing技术的多边形连续尺度地图表达模型。依据多边形的凸壳多叉树建立了多边形特征点的层次结构;基于临近性原则及特征点前后弧段形状的对照关系实现个关键尺度的同一多边形要素各层次特征点的匹配...
  • 本文主要介绍了一基于多边形顶点遍历的简单多边形裁剪算法,它有效降低了任意多边形裁剪复杂度。通过记录交点及其前驱、后继信息,生成结果多边形,该算法简化了交点的数据结构,节省了存储空间,降低了算法的时间...
  • 一、名词解释1.图形:能够在人们视觉系统中形成视觉印象的对象称为图形,包括自然景物和人工绘图。...5.构造实体几何表示法:用简单的实体(也称为体素)通过集合运算组合成所需的物体的方法称为构造...
  • 百度百科泰森多边形又叫冯洛诺伊图(Voronoi diagram),得名于Georgy Voronoi,是由一组由连接邻点线段的垂直平分线组成的连续多边形组成。泰森多边形是对空间平面的一剖分,其特点是多边形内的任何位置离该...
  • 多边形分解成三角形算法, 耳切法

    千次阅读 2019-11-08 17:08:11
    灰色表示该区域位于外部多边形和内部多边形之间,橙色是其中的一部分,在图4.1中,组成的三角形全部位于(外部-内部)多边形的一部分,4.2中,外部多边形被裁剪到了多个三角形中,只有部分子集三角形才算的上是外部...
  • 物体轮廓线的多边形拟合物体轮廓线的多边形拟合1 2魏炎初 张建军(清华大学信息网络工程研究中心)摘要:本文讨论了在给定数字轮廓线顶点...而传统的方法是以拟和多边形和原图的面积差距最小。2)本文认为每一个点具...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,722
精华内容 11,888
关键字:

多边形有两种表示方法

友情链接: traceMode.rar