精华内容
下载资源
问答
  • 组合模式定义: Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly. ...定义参加组合对象的共有方
  •  计算机视觉是一门关于如何运用照相机和计算机来获取我们所需,被拍摄对象的数据与信息学问。形象地说,就是给计算机安装上眼睛(照相机)和大脑(算法),让计算机能够感知环境。我们中国人成语"眼见为实"和...
    定义:
        计算机视觉是使用计算机及相关设备对生物视觉的一种模拟。它的主要任务就是通过对采集的图片或视频进行处理以获得相应场景的三维信息,就像人类和许多其他类生物每天所做的那样。
        计算机视觉是一门关于如何运用照相机和计算机来获取我们所需的,被拍摄对象的数据与信息的学问。形象地说,就是给计算机安装上眼睛(照相机)和大脑(算法),让计算机能够感知环境。我们中国人的成语"眼见为实"和西方人常说的"One picture is worth ten thousand words"表达了视觉对人类的重要性。不难想象,具有视觉的机器的应用前景能有多么地宽广。
        计算机视觉既是工程领域,也是科学领域中的一个富有挑战性重要研究领域。计算机视觉是一门综合性的学科,它已经吸引了来自各个学科的研究者参加到对它的研究之中。其中包括计算机科学和工程、信号处理、物理学、应用数学和统计学,神经生理学和认知科学等。

    原理:

        计算机视觉就是用各种成象系统代替视觉器官作为输入敏感手段,由计算机来代替大脑完成处理和解释。计算机视觉的最终研究目标就是使计算机能象人那样通过视觉观察和理解世界,具有自主适应环境的能力。要经过长期的努力才能达到的目标。因此,在实现最终目标以前,人们努力的中期目标是建立一种视觉系统,这个系统能依据视觉敏感和反馈的某种程度的智能完成一定的任务。例如,计算机视觉的一个重要应用领域就是自主车辆的视觉导航,还没有条件实现象人那样能识别和理解任何环境,完成自主导航的系统。因此,人们努力的研究目标是实现在高速公路上具有道路跟踪能力,可避免与前方车辆碰撞的视觉辅助驾驶系统。这里要指出的一点是在计算机视觉系统中计算机起代替人脑的作用,但并不意味着计算机必须按人类视觉的方法完成视觉信息的处理。计算机视觉可以而且应该根据计算机系统的特点来进行视觉信息的处理。但是,人类视觉系统是迄今为止,人们所知道的功能最强大和完善的视觉系统。如在以下的章节中会看到的那样,对人类视觉处理机制的研究将给计算机视觉的研究提供启发和指导。因此,用计算机信息处理的方法研究人类视觉的机理,建立人类视觉的计算理论,也是一个非常重要和信人感兴趣的研究领域。这方面的研究被称为计算视觉(Computational Vision)。计算视觉可被认为是计算机视觉中的一个研究领域。

    目前应用: 

        人类正在进入信息时代,计算机将越来越广泛地进入几乎所有领域。一方面是更多未经计算机专业训练的人也需要应用计算机,而另一方面是计算机的功能越来越强,使用方法越来越复杂。这就使人在进行交谈和通讯时的灵活性与在使用计算机时所要求的严格和死板之间产生了尖锐的矛盾。人可通过视觉和听觉,语言与外界交换信息,并且可用不同的方式表示相同的含义,而计算机却要求严格按照各种程序语言来编写程序,只有这样计算机才能运行。为使更多的人能使用复杂的计算机,必须改变过去的那种让人来适应计算机,来死记硬背计算机的使用规则的情况。而是反过来让计算机来适应人的习惯和要求,以人所习惯的方式与人进行信息交换,也就是让计算机具有视觉、听觉和说话等能力。这时计算机必须具有逻辑推理和决策的能力。具有上述能力的计算机就是智能计算机。
        智能计算机不但使计算机更便于为人们所使用,同时如果用这样的计算机来控制各种自动化装置特别是智能机器人,就可以使这些自动化系统和智能机器人具有适应环境,和自主作出决策的能力。这就可以在各种场合取代人的繁重工作,或代替人到各种危险和恶劣环境中完成任务。
        应用范围从任务,比如工业机器视觉系统,比方说,检查瓶子上的生产线加速通过,研究为人工智能和计算机或机器人,可以理解他们周围的世界。计算机视觉和机器视觉领域有显著的重叠。计算机视觉涉及的被用于许多领域自动化图像分析的核心技术。机器视觉通常指的是结合自动图像分析与其他方法和技术,以提供自动检测和机器人指导在工业应用中的一个过程。在许多计算机视觉应用中,计算机被预编程,以解决特定的任务,但基于学习的方法现在正变得越来越普遍。计算机视觉应用的实例包括用于系统:
    (1)控制过程,比如,一个工业机器人 ;
    (2)导航,例如,通过自主汽车或移动机器人;
    (3)检测的事件,如,对视频监控和人数统计 ;
    (4)组织信息,例如,对于图像和图像序列的索引数据库;
    (5)造型对象或环境,如,医学图像分析系统或地形模型;
    (6)相互作用,例如,当输入到一个装置,用于计算机人的交互;
    (7)自动检测,例如,在制造业的应用程序。
        其中最突出的应用领域是医疗计算机视觉和医学图像处理。这个区域的特征的信息从图像数据中提取用于使患者的医疗诊断的目的。通常,图像数据是在形式显微镜图像,X射线图像,血管造影图像,超声图像和断层图像。的信息,可以从这样的图像数据中提取的一个例子是检测的肿瘤,动脉粥样硬化或其他恶性变化。它也可以是器官的尺寸,血流量等。这种应用领域还支持通过提供新的信息,医学研究的测量例如,对脑的结构,或约医学治疗的质量。计算机视觉在医疗领域的应用还包括增强是由人类的解释,例如超声图像或X射线图像,以降低噪声的影响的图像。
        第二个应用程序区域中的计算机视觉是在工业,有时也被称为机器视觉,在那里信息被提取为支撑的制造工序的目的。一个例子是质量控制,其中的信息或最终产品被以找到缺陷自动检测。另一个例子是,被拾取的位置和细节取向测量由机器人臂。机器视觉也被大量用于农业的过程,从散装材料,这个过程被称为去除不想要的东西,食物的光学分拣。
    军事上的应用很可能是计算机视觉最大的地区之一。最明显的例子是探测敌方士兵或车辆和导弹制导。更先进的系统为导弹制导发送导弹的区域,而不是一个特定的目标,并且当导弹到达基于本地获取的图像数据的区域的目标做出选择。现代军事概念,如“战场感知”,意味着各种传感器,包括图像传感器,提供了丰富的有关作战的场景,可用于支持战略决策的信息。在这种情况下,数据的自动处理,用于减少复杂性和融合来自多个传感器的信息,以提高可靠性。
        一个较新的应用领域是自主车,其中包括潜水,陆上车辆(带轮子,轿车或卡车的小机器人),高空作业车和无人机(UAV)。自主化水平,从完全独立的(无人)的车辆范围为汽车,其中基于计算机视觉的系统支持驱动程序或在不同情况下的试验。完全自主的汽车通常使用计算机视觉进行导航时,即知道它在哪里,或用于生产的环境(地图SLAM)和用于检测障碍物。它也可以被用于检测特定任务的特定事件,例如,一个UAV寻找森林火灾。支承系统的例子是障碍物警报系统中的汽车,以及用于飞行器的自主着陆系统。数家汽车制造商已经证明了系统的汽车自动驾驶,但该技术还没有达到一定的水平,就可以投放市场。有军事自主车型,从先进的导弹,无人机的侦察任务或导弹的制导充足的例子。太空探索已经正在使用计算机视觉,自主车比如,美国宇航局的火星探测漫游者和欧洲航天局的ExoMars火星漫游者。
        其他应用领域包括:
    (1)支持视觉特效制作的电影和广播,例如,摄像头跟踪(运动匹配)。
    (2)监视。

    计算机视觉整个系统:

        计算机视觉系统的结构形式很大程度上依赖于其具体应用方向。有些是独立工作的,用于解决具体的测量或检测问题;也有些作为某个大型复杂系统的组成部分出现,比如和机械控制系统,数据库系统,人机接口设备协同工作。计算机视觉系统的具体实现方法同时也由其功能决定——是预先固定的抑或是在运行过程中自动学习调整。尽管如此,有些功能却几乎是每个计算机系统都需要具备的:


    图像获取

    一幅数字图像是由一个或多个图像感知器产生,这里的感知器可以是各种光敏摄像机,包括遥感设备,X射线断层摄影仪,雷达,超声波接收器等。取决于不同的感知器,产生的图片可以是普通的二维图像,三维图组或者一个图像序列。图片的像素值往往对应于光在一个或多个光谱段上的强度(灰度图或彩色图),但也可以是相关的各种物理数据,如声波,电磁波或核磁共振的深度,吸收度或反射度。


    预处理
    在对图像实施具体的计算机视觉方法来提取某种特定的信息前,一种或一些预处理往往被采用来使图像满足后继方法的要求。例如:
    二次取样保证图像坐标的正确;
    平滑去噪来滤除感知器引入的设备噪声;
    提高对比度来保证实现相关信息可以被检测到;

    调整尺度空间使图像结构适合局部应用。


    特征提取
    从图像中提取各种复杂度的特征。例如:
    线,边缘提取;
    局部化的特征点检测如边角检测,斑点检测;

    更复杂的特征可能与图像中的纹理形状或运动有关。


    检测分割
    在图像处理过程中,有时会需要对图像进行分割来提取有价值的用于后继处理的部分,例如
    筛选特征点;

    分割一或多幅图片中含有特定目标的部分。


    高级处理
    到了这一步,数据往往具有很小的数量,例如图像中经先前处理被认为含有目标物体的部分。这时的处理包括:
    验证得到的数据是否符合前提要求;
    估测特定系数,比如目标的姿态,体积;
    对目标进行分类。

    高级处理有理解图像内容的含义,是计算机视觉中的高阶处理,主要是在图像分割的基础上再经行对分割出的图像块进行理解,例如进行识别等操作。


    原文地址:http://www.peileyuan.com/topics/296


    展开全文
  • java图的邻接表实现两种方式实例应用分析 本篇博客来谈一谈图的邻接表实现的两种方式,首先我们明确一点“学会图的邻接表实现的关键点在于“:你所建立的图的邻接表的对象是什么! 首先我们看一下《算法导论》...

                        java图的邻接表实现两种方式及实例应用分析

    本篇博客来谈一谈图的邻接表实现的两种方式,首先我们明确一点“学会图的邻接表实现的关键点在于“:你所建立的图的邻接表的对象是什么!

    首先我们看一下《算法导论》中关于图的邻接表的定义:图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成,其中每个列表对应于V中的一个顶点,对于每一个u∈V,邻接表Adj[u]包含所有满足条件(u,v)∈E的顶点v,亦即,Adj[u]包含图G中所有和顶点u相邻的顶点。(或者他也可能指向这些顶点的指针),每个邻接表中的顶点一般以任意的顺序存储。(注意一下这句话!)

    图的邻接表表示如下图所示: 

    这里写图片描述

    定义总是比较晦涩难懂的,下面我们从如何实现图的邻接表表示来谈一谈! 
    1、邻接表构建图是必须需要一个Graph对象,也就是图对象!该对象包含属性有:顶点数、边数以及图的顶点集合;

    2、正如上面所说,邻接链表的对象首先我们需要确定邻接表的对象,可以用顶点作为邻接链表的对象,自然也可以用边作为邻接链表的对象!下面将分别对这两种方式进行讲解!


    一、邻接链表使用顶点作为对象构建图

    1、Graph对象类

    /**
     * 自定义图类
     * @author King
     */
    public class Graph1 {
        Vertex1[] vertexArray=new Vertex1[100];
        int verNum=0;
        int edgeNum=0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2、Vertex对象类

    /**
     * 图的顶点类
     * @author King
     */
    public class Vertex1 {
        String verName;
        Vertex1 nextNode;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3、图的实现类

    import java.util.Scanner;
    
    public class CreateGraph3 {
    
        /**
         * 根据用户输入的string类型的顶点返回该顶点
         * @param graph 图
         * @param str 输入数据
         * @return返回一个顶点
         */
        public Vertex1 getVertex(Graph1 graph,String str){
            for(int i=0;i<graph.verNum;i++){
                if(graph.vertexArray[i].verName.equals(str)){
                    return graph.vertexArray[i];
                }
            }
            return null;
        }
    
        /**
         * 根据用户输入的数据初始化一个图,以邻接表的形式构建!
         * @param graph 生成的图
         */
        public void initialGraph(Graph1 graph){
            @SuppressWarnings("resource")
            Scanner scan=new Scanner(System.in);
            System.out.println("请输入顶点数和边数:");
            graph.verNum=scan.nextInt();
            graph.edgeNum=scan.nextInt();
    
            System.out.println("请依次输入定点名称:");
            for(int i=0;i<graph.verNum;i++){
                Vertex1 vertex=new Vertex1();
                String name=scan.next();
                vertex.verName=name;
                vertex.nextNode=null;
                graph.vertexArray[i]=vertex;
            }
    
            System.out.println("请依次输入图的便边:");
            for(int i=0;i<graph.edgeNum;i++){
                String preV=scan.next();
                String folV=scan.next();
    
                Vertex1 v1=getVertex(graph,preV);
                if(v1==null)
                    System.out.println("输入边存在图中没有的顶点!");
    
    //下面代码是图构建的核心:链表操作
                Vertex1 v2=new Vertex1();
                v2.verName=folV;
                v2.nextNode=v1.nextNode;
                v1.nextNode=v2;
    
    //紧接着下面注释的代码加上便是构建无向图的,不加则是构建有向图的!
    //          Vertex1 reV2=getVertex(graph,folV);
    //          if(reV2==null)
    //              System.out.println("输入边存在图中没有的顶点!");
    //          Vertex1 reV1=new Vertex1();
    //          reV1.verName=preV;
    //          reV1.nextNode=reV2.nextNode;
    //          reV2.nextNode=reV1;
            }
        }
    
        /**
         * 输入图的邻接表
         * @param graph 待输出的图
         */
        public void outputGraph(Graph1 graph){
            System.out.println("输出图的邻接链表为:");
            for(int i=0;i<graph.verNum;i++){
                Vertex1 vertex=graph.vertexArray[i];
                System.out.print(vertex.verName);
    
                Vertex1 current=vertex.nextNode;
                while(current!=null){
                    System.out.print("-->"+current.verName);
                    current=current.nextNode;
                }
                System.out.println();
            }
        }
    
        public static void main(String[] args) {
            Graph1 graph=new Graph1();
            CreateGraph3 createGraph=new CreateGraph3();
            createGraph.initialGraph(graph);
            createGraph.outputGraph(graph);
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91

    二、邻接链表使用边作为对象构建图

    1、Graph对象类

    import java.util.ArrayList;
    
    public class Graph {
    
        ArrayList<Vertex> vertexList=new ArrayList<Vertex>();
        int vertexNum=0;
        int edgeNum=0;
        public Graph(){}
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2、Edge对象类

    /**
     * 图的边对象类
     * @author King
     */
    public class Edge {
        int edgeName;
        Edge next;
    
        public Edge(){
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3、Vertex对象类<这里顶点对象只是辅助边构建图,不是作为邻接链表的对象>

    /**
     * 图的点对象类
     * @author King
     */
    public class Vertex {
        String vertexName;
        Edge firstEdge=new Edge();
        public Vertex(){
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    4、图的实现类

    import java.util.Scanner;
    /**
     * 通过构建边和点的对象来创建图
     * @author King
     */
    public class CreateGraph {
    
        /**
         * 根据顶点信息String,返回边的对象
         * @param graph 图
         * @param str 顶点名称
         * @return 返回的是边对象的标签
         */
        public int vtoe(Graph graph,String str){
            for(int i=0;i<graph.vertexNum;i++){
                if(graph.vertexList.get(i).vertexName.equals(str)){
                    return i;
                }
            }
            return -1;
        }
    
        /**
         * 该函数用于图的初始化的实现
         * @param graph 图
         */
        public void initialGraph(Graph graph){
            @SuppressWarnings("resource")
            Scanner scan=new Scanner(System.in);
            System.out.println("请输入顶点数和边数:");
            graph.vertexNum=scan.nextInt();
            graph.edgeNum=scan.nextInt();
    
            System.out.println("请依次输入定点名称:");
            for(int i=0;i<graph.vertexNum;i++){
                Vertex vertex=new Vertex();
                String name=scan.next();
                vertex.vertexName=name;
                vertex.firstEdge=null;
                graph.vertexList.add(vertex);
            }
    
            System.out.println("请依次输入每个边:");
            for(int i=0;i<graph.edgeNum;i++){
                String preV=scan.next();
                String folV=scan.next();
                int v1=vtoe(graph,preV);
                int v2=vtoe(graph,folV);
                if(v1==-1 || v2==-1)
                    System.out.println("输入顶点数据错误!");
    
    //下面代码是图构建的核心:链表操作
                Edge edge1=new Edge();
                edge1.edgeName=v2;
                edge1.next=graph.vertexList.get(v1).firstEdge;
                graph.vertexList.get(v1).firstEdge=edge1;
    
    //          下面代码加上便是构建无向图,不加便是构建有向图
    //          Edge edge2=new Edge();
    //          edge2.edgeName=v1;
    //          edge2.next=graph.vertexList.get(v2).firstEdge;
    //          graph.vertexList.get(v2).firstEdge=edge2;
            }
        }
    
        /**
         * 输出图的邻接链表表示
         * @param graph 图
         */
        public void outputGraph(Graph graph){
            Edge edge=new Edge();
            for(int i=0;i<graph.vertexNum;i++){
                System.out.print(graph.vertexList.get(i).vertexName);
    
                edge=graph.vertexList.get(i).firstEdge;
                while(edge!=null){
                    System.out.print("-->"+graph.vertexList.get(edge.edgeName).vertexName);
                    edge=edge.next;
                }
                System.out.println();
            }
        }
    
        public static void main(String[] args) {
            CreateGraph createGraph=new CreateGraph();
            Graph graph=new Graph();
            createGraph.initialGraph(graph);
            createGraph.outputGraph(graph);
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90

    5、以上面给出的图片中图为例运行结果展示: 

    这里写图片描述


    三、使用邻接表构建图的实例

    问题:随机生成一个图(可以是有向图或是无向图),图的顶点大概100个左右,若是有向图则边大概2000条左右,若是无向图则边大概1000条左右!并计算出边的入度和出度

    代码: 
    1、Graph类

    public class GraphRandom {
    
        VertexRandom[] vertexArray=new VertexRandom[200];
        int verNum=0;
        int edgeNum=0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2、Vertexl类

    public class VertexRandom {
    
        int verName;
        int inRadius,outRadius;
        VertexRandom nextNode;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3、随机图实现类

    import java.util.Scanner;
    /**
     * 随机生成一个图,计算每个顶点的入度和出度
     * @author King
     *
     */
    public class CreateGraph2 {
    
        /**
         * 由顶点名称返回顶点集合中的该顶点
         * @param graph 图
         * @param name 顶点名称
         * @return返回顶点对象
         */
        public VertexRandom getVertex(GraphRandom graph,int name){
            for(int i=0;i<graph.verNum;i++){
                if(graph.vertexArray[i].verName==name){
                    return graph.vertexArray[i];
                }
            }
            return null;
        }
    
        /**
         * 该顶点通过顶点和边构建图
         * @param graph 图
         */
        public void randomSpanning(GraphRandom graph){
            @SuppressWarnings("resource")
            Scanner scan=new Scanner(System.in);
            System.out.println("请输入随机图的顶点个数:");
            graph.verNum=scan.nextInt();
    
            for(int i=1;i<=graph.verNum;i++){
                VertexRandom vertex=new VertexRandom();
                vertex.verName=i;
                vertex.nextNode=null;
                graph.vertexArray[i-1]=vertex;
            }
    
            int number=(int)(Math.random()*200+1000);
            System.out.println("随机生成的边的数量为:"+number);
            graph.edgeNum=number;
    
            for(int i=0;i<graph.edgeNum;i++){
                int preV=(int)(Math.random()*100+1);
                int folV=(int)(Math.random()*100+1);
                while(folV==preV){
                    folV=(int)(Math.random()*100+1);
                }
    
                VertexRandom vertex1=getVertex(graph,preV);
                if(vertex1==null)
                    System.out.println("随机图中没有该顶点!");
                VertexRandom vertex2=new VertexRandom();
                vertex2.verName=folV;
                vertex2.nextNode=vertex1.nextNode;
                vertex1.nextNode=vertex2;
    
    //          下面用于计算顶点的出度和入度的
                vertex1.outRadius++;
                VertexRandom v2=getVertex(graph,folV);
                if(v2==null)
                    System.out.println("随机图中没有该顶点!");
                v2.inRadius++;
    
    //          加上下面代码用于产生无向图
    //          VertexRandom reVertex2=getVertex(graph,folV);
    //          if(reVertex2==null)
    //              System.out.println("随机图中没有该顶点!");
    //          VertexRandom reVertex1=new VertexRandom();
    //          reVertex1.verName=preV;
    //          reVertex1.nextNode=reVertex2.nextNode;
    //          reVertex2.nextNode=reVertex1;
            }
        }
    
        /**
         * 输出图的邻接链表
         * @param graph 图
         */
        public void outputGraph(GraphRandom graph){
            System.out.println("输出图的邻接链表为:");
            for(int i=0;i<graph.verNum;i++){
                VertexRandom vertex=graph.vertexArray[i];
                System.out.print(vertex.verName);
    
                VertexRandom current=vertex.nextNode;
                while(current!=null){
                    System.out.print("-->"+current.verName);
                    current=current.nextNode;
                }
                System.out.println();
            }
        }
    
        /**
         * 输出图的入度和出度
         * @param graph 图
         */
        public void IORadius(GraphRandom graph){
            for(int i=0;i<graph.verNum;i++){
                System.out.print("顶点"+(i+1)+"的出度为:"+graph.vertexArray[i].outRadius);
                System.out.println(",入度为:"+graph.vertexArray[i].inRadius);
            }
        }
    
        public static void main(String[] args) {
            GraphRandom graph=new GraphRandom();
            CreateGraph2 createGraph2=new CreateGraph2();
            createGraph2.randomSpanning(graph);
            createGraph2.outputGraph(graph);
            createGraph2.IORadius(graph);
        }
    }

    展开全文
  • 前言本篇来谈一谈图的邻接表实现的两种方式,首先我们明确一点“学会图的邻接表实现的关键点在于“:你所建立的图的邻接表的对象是什么!首先我们看一下《算法导论》中关于图的邻接表的定义:图G=(V,E)的邻接表表示...

    前言

    本篇来谈一谈图的邻接表实现的两种方式,首先我们明确一点“学会图的邻接表实现的关键点在于“:你所建立的图的邻接表的对象是什么!

    首先我们看一下《算法导论》中关于图的邻接表的定义:

    图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成,其中每个列表对应于V中的一个顶点,对于每一个u∈V,邻接表Adj[u]包含所有满足条件(u,v)∈E的顶点v,亦即,Adj[u]包含图G中所有和顶点u相邻的顶点。(或者他也可能指向这些顶点的指针),每个邻接表中的顶点一般以任意的顺序存储。

    图的邻接表表示如下图所示:

    7a4cdc3442399eb38a4ffd42adce6f1c.png

    定义总是比较晦涩难懂的,下面我们从如何实现图的邻接表表示来谈一谈!

    1、邻接表构建图是必须需要一个Graph对象,也就是图对象!该对象包含属性有:顶点数、边数以及图的顶点集合;

    2、正如上面所说,邻接链表的对象首先我们需要确定邻接表的对象,可以用顶点作为邻接链表的对象,自然也可以用边作为邻接链表的对象!下面将分别对这两种方式进行讲解!

    一、邻接链表使用顶点作为对象构建图

    1、Graph对象类

    /**

    * 自定义图类

    * @author King

    */

    public class Graph1 {

    Vertex1[] vertexArray=new Vertex1[100];

    int verNum=0;

    int edgeNum=0;

    }

    2、Vertex对象类

    /**

    * 图的顶点类

    * @author King

    */

    public class Vertex1 {

    String verName;

    Vertex1 nextNode;

    }

    3、图的实现类

    import java.util.Scanner;

    public class CreateGraph3 {

    /**

    * 根据用户输入的string类型的顶点返回该顶点

    * @param graph 图

    * @param str 输入数据

    * @return返回一个顶点

    */

    public Vertex1 getVertex(Graph1 graph,String str){

    for(int i=0;i

    if(graph.vertexArray[i].verName.equals(str)){

    return graph.vertexArray[i];

    }

    }

    return null;

    }

    /**

    * 根据用户输入的数据初始化一个图,以邻接表的形式构建!

    * @param graph 生成的图

    */

    public void initialGraph(Graph1 graph){

    @SuppressWarnings("resource")

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入顶点数和边数:");

    graph.verNum=scan.nextInt();

    graph.edgeNum=scan.nextInt();

    System.out.println("请依次输入定点名称:");

    for(int i=0;i

    Vertex1 vertex=new Vertex1();

    String name=scan.next();

    vertex.verName=name;

    vertex.nextNode=null;

    graph.vertexArray[i]=vertex;

    }

    System.out.println("请依次输入图的便边:");

    for(int i=0;i

    String preV=scan.next();

    String folV=scan.next();

    Vertex1 v1=getVertex(graph,preV);

    if(v1==null)

    System.out.println("输入边存在图中没有的顶点!");

    //下面代码是图构建的核心:链表操作

    Vertex1 v2=new Vertex1();

    v2.verName=folV;

    v2.nextNode=v1.nextNode;

    v1.nextNode=v2;

    //紧接着下面注释的代码加上便是构建无向图的,不加则是构建有向图的!

    // Vertex1 reV2=getVertex(graph,folV);

    // if(reV2==null)

    // System.out.println("输入边存在图中没有的顶点!");

    // Vertex1 reV1=new Vertex1();

    // reV1.verName=preV;

    // reV1.nextNode=reV2.nextNode;

    // reV2.nextNode=reV1;

    }

    }

    /**

    * 输入图的邻接表

    * @param graph 待输出的图

    */

    public void outputGraph(Graph1 graph){

    System.out.println("输出图的邻接链表为:");

    for(int i=0;i

    Vertex1 vertex=graph.vertexArray[i];

    System.out.print(vertex.verName);

    Vertex1 current=vertex.nextNode;

    while(current!=null){

    System.out.print("-->"+current.verName);

    current=current.nextNode;

    }

    System.out.println();

    }

    }

    public static void main(String[] args) {

    Graph1 graph=new Graph1();

    CreateGraph3 createGraph=new CreateGraph3();

    createGraph.initialGraph(graph);

    createGraph.outputGraph(graph);

    }

    }

    二、邻接链表使用边作为对象构建图

    1、Graph对象类

    import java.util.ArrayList;

    public class Graph {

    ArrayList vertexList=new ArrayList();

    int vertexNum=0;

    int edgeNum=0;

    public Graph(){}

    }

    2、Edge对象类

    /**

    * 图的边对象类

    * @author King

    */

    public class Edge {

    int edgeName;

    Edge next;

    public Edge(){

    }

    }

    3、Vertex对象类

    /**

    * 图的点对象类

    * @author King

    */

    public class Vertex {

    String vertexName;

    Edge firstEdge=new Edge();

    public Vertex(){

    }

    }

    4、图的实现类

    import java.util.Scanner;

    /**

    * 通过构建边和点的对象来创建图

    * @author King

    */

    public class CreateGraph {

    /**

    * 根据顶点信息String,返回边的对象

    * @param graph 图

    * @param str 顶点名称

    * @return 返回的是边对象的标签

    */

    public int vtoe(Graph graph,String str){

    for(int i=0;i

    if(graph.vertexList.get(i).vertexName.equals(str)){

    return i;

    }

    }

    return -1;

    }

    /**

    * 该函数用于图的初始化的实现

    * @param graph 图

    */

    public void initialGraph(Graph graph){

    @SuppressWarnings("resource")

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入顶点数和边数:");

    graph.vertexNum=scan.nextInt();

    graph.edgeNum=scan.nextInt();

    System.out.println("请依次输入定点名称:");

    for(int i=0;i

    Vertex vertex=new Vertex();

    String name=scan.next();

    vertex.vertexName=name;

    vertex.firstEdge=null;

    graph.vertexList.add(vertex);

    }

    System.out.println("请依次输入每个边:");

    for(int i=0;i

    String preV=scan.next();

    String folV=scan.next();

    int v1=vtoe(graph,preV);

    int v2=vtoe(graph,folV);

    if(v1==-1 || v2==-1)

    System.out.println("输入顶点数据错误!");

    //下面代码是图构建的核心:链表操作

    Edge edge1=new Edge();

    edge1.edgeName=v2;

    edge1.next=graph.vertexList.get(v1).firstEdge;

    graph.vertexList.get(v1).firstEdge=edge1;

    // 下面代码加上便是构建无向图,不加便是构建有向图

    // Edge edge2=new Edge();

    // edge2.edgeName=v1;

    // edge2.next=graph.vertexList.get(v2).firstEdge;

    // graph.vertexList.get(v2).firstEdge=edge2;

    }

    }

    /**

    * 输出图的邻接链表表示

    * @param graph 图

    */

    public void outputGraph(Graph graph){

    Edge edge=new Edge();

    for(int i=0;i

    System.out.print(graph.vertexList.get(i).vertexName);

    edge=graph.vertexList.get(i).firstEdge;

    while(edge!=null){

    System.out.print("-->"+graph.vertexList.get(edge.edgeName).vertexName);

    edge=edge.next;

    }

    System.out.println();

    }

    }

    public static void main(String[] args) {

    CreateGraph createGraph=new CreateGraph();

    Graph graph=new Graph();

    createGraph.initialGraph(graph);

    createGraph.outputGraph(graph);

    }

    }

    5、以上面给出的图片中图为例运行结果展示:

    1246b3df6f44e7db873c8f47d44a91ab.png

    三、使用邻接表构建图的实例

    问题:随机生成一个图(可以是有向图或是无向图),图的顶点大概100个左右,若是有向图则边大概2000条左右,若是无向图则边大概1000条左右!并计算出边的入度和出度

    代码:

    1、Graph类

    public class GraphRandom {

    VertexRandom[] vertexArray=new VertexRandom[200];

    int verNum=0;

    int edgeNum=0;

    }

    2、Vertexl类

    public class VertexRandom {

    int verName;

    int inRadius,outRadius;

    VertexRandom nextNode;

    }

    3、随机图实现类

    import java.util.Scanner;

    /**

    * 随机生成一个图,计算每个顶点的入度和出度

    * @author King

    *

    */

    public class CreateGraph2 {

    /**

    * 由顶点名称返回顶点集合中的该顶点

    * @param graph 图

    * @param name 顶点名称

    * @return返回顶点对象

    */

    public VertexRandom getVertex(GraphRandom graph,int name){

    for(int i=0;i

    if(graph.vertexArray[i].verName==name){

    return graph.vertexArray[i];

    }

    }

    return null;

    }

    /**

    * 该顶点通过顶点和边构建图

    * @param graph 图

    */

    public void randomSpanning(GraphRandom graph){

    @SuppressWarnings("resource")

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入随机图的顶点个数:");

    graph.verNum=scan.nextInt();

    for(int i=1;i<=graph.verNum;i++){

    VertexRandom vertex=new VertexRandom();

    vertex.verName=i;

    vertex.nextNode=null;

    graph.vertexArray[i-1]=vertex;

    }

    int number=(int)(Math.random()*200+1000);

    System.out.println("随机生成的边的数量为:"+number);

    graph.edgeNum=number;

    for(int i=0;i

    int preV=(int)(Math.random()*100+1);

    int folV=(int)(Math.random()*100+1);

    while(folV==preV){

    folV=(int)(Math.random()*100+1);

    }

    VertexRandom vertex1=getVertex(graph,preV);

    if(vertex1==null)

    System.out.println("随机图中没有该顶点!");

    VertexRandom vertex2=new VertexRandom();

    vertex2.verName=folV;

    vertex2.nextNode=vertex1.nextNode;

    vertex1.nextNode=vertex2;

    // 下面用于计算顶点的出度和入度的

    vertex1.outRadius++;

    VertexRandom v2=getVertex(graph,folV);

    if(v2==null)

    System.out.println("随机图中没有该顶点!");

    v2.inRadius++;

    // 加上下面代码用于产生无向图

    // VertexRandom reVertex2=getVertex(graph,folV);

    // if(reVertex2==null)

    // System.out.println("随机图中没有该顶点!");

    // VertexRandom reVertex1=new VertexRandom();

    // reVertex1.verName=preV;

    // reVertex1.nextNode=reVertex2.nextNode;

    // reVertex2.nextNode=reVertex1;

    }

    }

    /**

    * 输出图的邻接链表

    * @param graph 图

    */

    public void outputGraph(GraphRandom graph){

    System.out.println("输出图的邻接链表为:");

    for(int i=0;i

    VertexRandom vertex=graph.vertexArray[i];

    System.out.print(vertex.verName);

    VertexRandom current=vertex.nextNode;

    while(current!=null){

    System.out.print("-->"+current.verName);

    current=current.nextNode;

    }

    System.out.println();

    }

    }

    /**

    * 输出图的入度和出度

    * @param graph 图

    */

    public void IORadius(GraphRandom graph){

    for(int i=0;i

    System.out.print("顶点"+(i+1)+"的出度为:"+graph.vertexArray[i].outRadius);

    System.out.println(",入度为:"+graph.vertexArray[i].inRadius);

    }

    }

    public static void main(String[] args) {

    GraphRandom graph=new GraphRandom();

    CreateGraph2 createGraph2=new CreateGraph2();

    createGraph2.randomSpanning(graph);

    createGraph2.outputGraph(graph);

    createGraph2.IORadius(graph);

    }

    }

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • 前言本篇来谈一谈图的邻接表实现的两种方式,首先我们明确一点“学会图的邻接表实现的关键点在于“:你所建立的图的邻接表的对象是什么!首先我们看一下《算法导论》中关于图的邻接表的定义:图G=(V,E)的邻接表表示...

    前言

    本篇来谈一谈图的邻接表实现的两种方式,首先我们明确一点“学会图的邻接表实现的关键点在于“:你所建立的图的邻接表的对象是什么!

    首先我们看一下《算法导论》中关于图的邻接表的定义:

    图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成,其中每个列表对应于V中的一个顶点,对于每一个u∈V,邻接表Adj[u]包含所有满足条件(u,v)∈E的顶点v,亦即,Adj[u]包含图G中所有和顶点u相邻的顶点。(或者他也可能指向这些顶点的指针),每个邻接表中的顶点一般以任意的顺序存储。

    图的邻接表表示如下图所示:

    9cb932b840ac374a53f2649d72e9d6a9.png

    定义总是比较晦涩难懂的,下面我们从如何实现图的邻接表表示来谈一谈!

    1、邻接表构建图是必须需要一个Graph对象,也就是图对象!该对象包含属性有:顶点数、边数以及图的顶点集合;

    2、正如上面所说,邻接链表的对象首先我们需要确定邻接表的对象,可以用顶点作为邻接链表的对象,自然也可以用边作为邻接链表的对象!下面将分别对这两种方式进行讲解!

    一、邻接链表使用顶点作为对象构建图

    1、Graph对象类

    /**

    * 自定义图类

    * @author King

    */

    public class Graph1 {

    Vertex1[] vertexArray=new Vertex1[100];

    int verNum=0;

    int edgeNum=0;

    }

    2、Vertex对象类

    /**

    * 图的顶点类

    * @author King

    */

    public class Vertex1 {

    String verName;

    Vertex1 nextNode;

    }

    3、图的实现类

    import java.util.Scanner;

    public class CreateGraph3 {

    /**

    * 根据用户输入的string类型的顶点返回该顶点

    * @param graph 图

    * @param str 输入数据

    * @return返回一个顶点

    */

    public Vertex1 getVertex(Graph1 graph,String str){

    for(int i=0;i

    if(graph.vertexArray[i].verName.equals(str)){

    return graph.vertexArray[i];

    }

    }

    return null;

    }

    /**

    * 根据用户输入的数据初始化一个图,以邻接表的形式构建!

    * @param graph 生成的图

    */

    public void initialGraph(Graph1 graph){

    @SuppressWarnings("resource")

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入顶点数和边数:");

    graph.verNum=scan.nextInt();

    graph.edgeNum=scan.nextInt();

    System.out.println("请依次输入定点名称:");

    for(int i=0;i

    Vertex1 vertex=new Vertex1();

    String name=scan.next();

    vertex.verName=name;

    vertex.nextNode=null;

    graph.vertexArray[i]=vertex;

    }

    System.out.println("请依次输入图的便边:");

    for(int i=0;i

    String preV=scan.next();

    String folV=scan.next();

    Vertex1 v1=getVertex(graph,preV);

    if(v1==null)

    System.out.println("输入边存在图中没有的顶点!");

    //下面代码是图构建的核心:链表操作

    Vertex1 v2=new Vertex1();

    v2.verName=folV;

    v2.nextNode=v1.nextNode;

    v1.nextNode=v2;

    //紧接着下面注释的代码加上便是构建无向图的,不加则是构建有向图的!

    // Vertex1 reV2=getVertex(graph,folV);

    // if(reV2==null)

    // System.out.println("输入边存在图中没有的顶点!");

    // Vertex1 reV1=new Vertex1();

    // reV1.verName=preV;

    // reV1.nextNode=reV2.nextNode;

    // reV2.nextNode=reV1;

    }

    }

    /**

    * 输入图的邻接表

    * @param graph 待输出的图

    */

    public void outputGraph(Graph1 graph){

    System.out.println("输出图的邻接链表为:");

    for(int i=0;i

    Vertex1 vertex=graph.vertexArray[i];

    System.out.print(vertex.verName);

    Vertex1 current=vertex.nextNode;

    while(current!=null){

    System.out.print("-->"+current.verName);

    current=current.nextNode;

    }

    System.out.println();

    }

    }

    public static void main(String[] args) {

    Graph1 graph=new Graph1();

    CreateGraph3 createGraph=new CreateGraph3();

    createGraph.initialGraph(graph);

    createGraph.outputGraph(graph);

    }

    }

    二、邻接链表使用边作为对象构建图

    1、Graph对象类

    import java.util.ArrayList;

    public class Graph {

    ArrayList vertexList=new ArrayList();

    int vertexNum=0;

    int edgeNum=0;

    public Graph(){}

    }

    2、Edge对象类

    /**

    * 图的边对象类

    * @author King

    */

    public class Edge {

    int edgeName;

    Edge next;

    public Edge(){

    }

    }

    3、Vertex对象类

    /**

    * 图的点对象类

    * @author King

    */

    public class Vertex {

    String vertexName;

    Edge firstEdge=new Edge();

    public Vertex(){

    }

    }

    4、图的实现类

    import java.util.Scanner;

    /**

    * 通过构建边和点的对象来创建图

    * @author King

    */

    public class CreateGraph {

    /**

    * 根据顶点信息String,返回边的对象

    * @param graph 图

    * @param str 顶点名称

    * @return 返回的是边对象的标签

    */

    public int vtoe(Graph graph,String str){

    for(int i=0;i

    if(graph.vertexList.get(i).vertexName.equals(str)){

    return i;

    }

    }

    return -1;

    }

    /**

    * 该函数用于图的初始化的实现

    * @param graph 图

    */

    public void initialGraph(Graph graph){

    @SuppressWarnings("resource")

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入顶点数和边数:");

    graph.vertexNum=scan.nextInt();

    graph.edgeNum=scan.nextInt();

    System.out.println("请依次输入定点名称:");

    for(int i=0;i

    Vertex vertex=new Vertex();

    String name=scan.next();

    vertex.vertexName=name;

    vertex.firstEdge=null;

    graph.vertexList.add(vertex);

    }

    System.out.println("请依次输入每个边:");

    for(int i=0;i

    String preV=scan.next();

    String folV=scan.next();

    int v1=vtoe(graph,preV);

    int v2=vtoe(graph,folV);

    if(v1==-1 || v2==-1)

    System.out.println("输入顶点数据错误!");

    //下面代码是图构建的核心:链表操作

    Edge edge1=new Edge();

    edge1.edgeName=v2;

    edge1.next=graph.vertexList.get(v1).firstEdge;

    graph.vertexList.get(v1).firstEdge=edge1;

    // 下面代码加上便是构建无向图,不加便是构建有向图

    // Edge edge2=new Edge();

    // edge2.edgeName=v1;

    // edge2.next=graph.vertexList.get(v2).firstEdge;

    // graph.vertexList.get(v2).firstEdge=edge2;

    }

    }

    /**

    * 输出图的邻接链表表示

    * @param graph 图

    */

    public void outputGraph(Graph graph){

    Edge edge=new Edge();

    for(int i=0;i

    System.out.print(graph.vertexList.get(i).vertexName);

    edge=graph.vertexList.get(i).firstEdge;

    while(edge!=null){

    System.out.print("-->"+graph.vertexList.get(edge.edgeName).vertexName);

    edge=edge.next;

    }

    System.out.println();

    }

    }

    public static void main(String[] args) {

    CreateGraph createGraph=new CreateGraph();

    Graph graph=new Graph();

    createGraph.initialGraph(graph);

    createGraph.outputGraph(graph);

    }

    }

    5、以上面给出的图片中图为例运行结果展示:

    c1becda00da59bfeeef5322b659b6b25.png

    三、使用邻接表构建图的实例

    问题:随机生成一个图(可以是有向图或是无向图),图的顶点大概100个左右,若是有向图则边大概2000条左右,若是无向图则边大概1000条左右!并计算出边的入度和出度

    代码:

    1、Graph类

    public class GraphRandom {

    VertexRandom[] vertexArray=new VertexRandom[200];

    int verNum=0;

    int edgeNum=0;

    }

    2、Vertexl类

    public class VertexRandom {

    int verName;

    int inRadius,outRadius;

    VertexRandom nextNode;

    }

    3、随机图实现类

    import java.util.Scanner;

    /**

    * 随机生成一个图,计算每个顶点的入度和出度

    * @author King

    *

    */

    public class CreateGraph2 {

    /**

    * 由顶点名称返回顶点集合中的该顶点

    * @param graph 图

    * @param name 顶点名称

    * @return返回顶点对象

    */

    public VertexRandom getVertex(GraphRandom graph,int name){

    for(int i=0;i

    if(graph.vertexArray[i].verName==name){

    return graph.vertexArray[i];

    }

    }

    return null;

    }

    /**

    * 该顶点通过顶点和边构建图

    * @param graph 图

    */

    public void randomSpanning(GraphRandom graph){

    @SuppressWarnings("resource")

    Scanner scan=new Scanner(System.in);

    System.out.println("请输入随机图的顶点个数:");

    graph.verNum=scan.nextInt();

    for(int i=1;i<=graph.verNum;i++){

    VertexRandom vertex=new VertexRandom();

    vertex.verName=i;

    vertex.nextNode=null;

    graph.vertexArray[i-1]=vertex;

    }

    int number=(int)(Math.random()*200+1000);

    System.out.println("随机生成的边的数量为:"+number);

    graph.edgeNum=number;

    for(int i=0;i

    int preV=(int)(Math.random()*100+1);

    int folV=(int)(Math.random()*100+1);

    while(folV==preV){

    folV=(int)(Math.random()*100+1);

    }

    VertexRandom vertex1=getVertex(graph,preV);

    if(vertex1==null)

    System.out.println("随机图中没有该顶点!");

    VertexRandom vertex2=new VertexRandom();

    vertex2.verName=folV;

    vertex2.nextNode=vertex1.nextNode;

    vertex1.nextNode=vertex2;

    // 下面用于计算顶点的出度和入度的

    vertex1.outRadius++;

    VertexRandom v2=getVertex(graph,folV);

    if(v2==null)

    System.out.println("随机图中没有该顶点!");

    v2.inRadius++;

    // 加上下面代码用于产生无向图

    // VertexRandom reVertex2=getVertex(graph,folV);

    // if(reVertex2==null)

    // System.out.println("随机图中没有该顶点!");

    // VertexRandom reVertex1=new VertexRandom();

    // reVertex1.verName=preV;

    // reVertex1.nextNode=reVertex2.nextNode;

    // reVertex2.nextNode=reVertex1;

    }

    }

    /**

    * 输出图的邻接链表

    * @param graph 图

    */

    public void outputGraph(GraphRandom graph){

    System.out.println("输出图的邻接链表为:");

    for(int i=0;i

    VertexRandom vertex=graph.vertexArray[i];

    System.out.print(vertex.verName);

    VertexRandom current=vertex.nextNode;

    while(current!=null){

    System.out.print("-->"+current.verName);

    current=current.nextNode;

    }

    System.out.println();

    }

    }

    /**

    * 输出图的入度和出度

    * @param graph 图

    */

    public void IORadius(GraphRandom graph){

    for(int i=0;i

    System.out.print("顶点"+(i+1)+"的出度为:"+graph.vertexArray[i].outRadius);

    System.out.println(",入度为:"+graph.vertexArray[i].inRadius);

    }

    }

    public static void main(String[] args) {

    GraphRandom graph=new GraphRandom();

    CreateGraph2 createGraph2=new CreateGraph2();

    createGraph2.randomSpanning(graph);

    createGraph2.outputGraph(graph);

    createGraph2.IORadius(graph);

    }

    }

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持谷谷点程序。

    展开全文
  • 一、程序分析的定义所谓程序分析,是用固定的记号、图表,把一连串的过程或作业方法表示出来,以期得到关于对象物的变化作业者行为系列情报分析图表的总称。二、程序分析的符号程序分析的对象:生产制造过程 生产...
  • 滤镜称得上是SVG最强大功能了,它允许你给图形(图形元素和容器元素)添加各种专业软件中才有滤镜特效。这样你就很容易在客户端...所以引用滤镜效果过程就是在源图形上应用相关滤镜原子操作,最后生成一个新
  • 图的矩阵表示——无向图有向图的关联矩阵作者 邢雪芬摘要:图论的内容丰富多彩,应用广泛,在许多学科中都有涉及图论的内容,篇是关于图论的一些小诠释,图的矩阵表示,无向图有向图定义的声明和部分例题的证明...
  • 1、绘图编程 1、绘制线条 我们可以利用MFC提供...我们只需要定义一个CClientDC对象,然后就可以利用该对象提供函数进行绘图操作了。CClientDC对象构造时接收一个参数,即:要进行图像绘制窗口指针对象。...
  • VB程序设计及应用

    热门讨论 2012-11-26 14:07:12
    中文名: VB程序设计及应用 作者: 李淑华图书分类: 软件 资源格式: PDF 版本: 文字版 出版社: 高等教育出版社书号: 7-04-014767-X发行时间: 2004年04月 地区: 大陆 语言: 简体中文 简介: 内容简介: 本书是新...
  • HTML5不仅仅定义了拖拽事件类型,还在事件对象中规范了一个重量级的对象:dataTransfer,借助它,我们可以实现数据传输、拖拽图案设定、拖拽文件上传,可通过event.dataTransfer来访问该对象. 数据传输 需要借助...
  • HTML5不仅仅定义了拖拽事件类型,还在事件对象中规范了一个重量级的对象:dataTransfer,借助它,我们可以实现数据传输、拖拽图案设定、拖拽文件上传,可通过event.dataTransfer来访问该对象. 数据传输 需要借助...
  • 图像(image)的定义是:在一般意义下,一幅图像是一个物体或对象(object)的另一种表示。亦即图像是其所表示物体或对象信息的一个直接描述和浓缩表示。简而言之,即图像是物体在平面坐标上的直观再现。一幅图像...
  • 4.5 use case图的应用 4.5.1 use case的确定 4.5.2 建立use case模型 第5章 对象类图与对象图 5.1 对象类图 5.1.1 对象类 5.1.2 属性 5.1.3 操作 5.2 对象类的关联 5.2.1 对象类的关联 ...
  • UML的结构:  UML包括九种图,如下:  图片   其中各个图的作用如下: ... 用例图:用来描述用户的需求,从... 静态图包括类图跟对象图  类图(Class diagrams):用于定义系统中的类,包括 描述类的内部结
  •  下面先来看看ucosiii文件结构:这个从下至上就是从底层到上层一个结构,总来说就是三层:CPU配置与移植,内核服务,功能裁剪及应用任务。当然这个是盗秉火对应手册里。既然别人做了这么好总结...
  • 更多内容关注公众号:SAP Technical 各位可以关注我的公众号:SAP Technical GUI Status与GUI Title用于自定义工具栏按钮及Report程序标题栏显示内容,可以通过SE81或直接在SE38中... 1)GUI Status的定义及应...
  • 将某张图片灰度化是图像处理基础步骤。请利用所学相关知识,将一张彩色图片灰度化处理,功能要求如下所示: ... 在所有方法外,定义一个Image img对象,用于存储载入图片。  为“载入
  • 背景属性深入理解动画综合应用 1.背景类常用属性应用 background-color 背景颜色 设置或检索对象的背景颜色,默认值:transparent; 同时定义了背景颜色和背景图像时,背景图像覆盖在背景颜色之上; CSS中,颜色...
  • 4.7.1 层次原理图的定义及结构 4.7.2 自上而下的层次原理图设计 4.7.3 自下而上的层次原理图设计 4.8 原理图的编译与检查 4.8.1 原理图编译的设置 4.8.2 原理图的编译 4.9 BOM表 4.10 原理图的打印输出 4.11 常用...
  • BIM模型建立是完成BIM项目重中之重,那模型建立标准可以说是关乎着项目是否能够顺利进行关键钥匙,今天就聊聊bim模型建立及应用标准是什么?一、BIM建筑建模标准预铸及预制建筑组件可以在BIM模型中以对象...
  • 定义定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类实例化延迟到其子类。 类型:创建类模式 工厂方法模式分为三种: 11、普通工厂模式,就是建立一个工厂类,对实现...
  • 开放地理空间联盟(OGC)是一个由250多家公司、机构和...在其发布OpenGIS® Implementation Standard for Geographic information -Simple feature access-Part 1: Common architecture中定义了几何对象模型。如...
  • 5.2.1 对象的定义 5.2.2 对象成员变量的引用 5.2.3 对象方法的调用 5.3 成员变量 5.3.1 成员变量的定义 5.3.2 成员变量修饰符 5.4 方法 5.4.1 方法声明 5.4.2 方法调用 5.4.3 方法参数的传递 5.4.4 方法修饰符 本章...
  • BIM模型建立是完成BIM项目重中之重,那模型建立标准可以说是关乎着项目是否能够顺利进行关键钥匙,今天就聊聊bim模型建立及应用标准是什么?一、BIM建筑建模标准预铸及预制建筑组件可以在BIM模型中以对象...
  • 使多个对象有机会处理请求,从而避免请求发送者和接受者之间耦合关系。将这些对象连成一条链,并演着这条链传递该请求,直到有一个对象处理它为止。 UML Handler:定义职责接口,通常在内部定义处理请求...
  • 适配器模式的定义与理解 将一个接口转换成客户希望的另一个接口,使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。在适配器模式中,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,338
精华内容 535
关键字:

对象图的定义及应用