33、插入一段大学学的计算机，正儿八经的计算机图形学

1、breaseHam画圆算法

public void breasenCircle(int a,int b,int r) {
            int x0 = 0;
            int y0 = r;
            int y = y0;
            int x = x0;
            GL.Vertex2(x + a, y + b);
            double p = y * y - 2 * (r * r - (x + 1) * (x + 1)) + (y - 1) * (y - 1);
            while(x<=x0+(Math.Sqrt(2)/2)*r){
                if (p > 0)
                {
                    p = p + 4 * (x - y) + 10;
                    x = x + 1;
                    y = y - 1;
                    GL.Vertex2(x+a, y+b);
                    GL.Vertex2(y+a, x+b);
                    GL.Vertex2(x+a,-y+b);
                    GL.Vertex2(-y+a,x+b);
                    GL.Vertex2(-x+a,-y+b);
                    GL.Vertex2(-y+a,-x+b);
                    GL.Vertex2(-x+a, y+b);
                    GL.Vertex2(y+a, -x+b);
                }
                else
                {

                    p = p + 4 * x + 6;
                    x = x + 1;
                    GL.Vertex2(x+a, y+b);
                    GL.Vertex2(y+a, x+b);
                    GL.Vertex2(x+a, -y+b);
                    GL.Vertex2(-y+a, x+b);
                    GL.Vertex2(-x+a, -y+b);
                    GL.Vertex2(-y+a, -x+b);
                    GL.Vertex2(-x+a, y+b);
                    GL.Vertex2(y+a, -x+b);
                }

            }
        }

2、breaseHam画直线

public void Bresenhamline(int x0, int y0, int x1, int y1) {
            double dx = x1 - x0;
            double dy = y1 - y0;
            int x=x0;
            int y=y0;
            double b = (y0 * x1 - y1 * x0) / (x1 - x0);
            if (Math.Abs(dy / dx) <= 1)
            {
                double p = 2 * dx * y - 2 * dy * x - 2 * dy - 2 * b * dx + dx;
                while (Math.Abs(x1 - x) > 1)
                {
                    if (p > 0)
                    {
                        x = x + 1;
                        GL.Vertex2(x, y);
                        p = p - 2 * dy;
                    }
                    else
                    {
                        x = x + 1;
                        y = y + 1;
                        p = p + 2 * dx - 2 * dy;
                        GL.Vertex2(x, y);
                    }
                }
            }
            else {
                double p = 2 * x * dy - 2 * dx * y + dy - 2 * dx + 2 * dx * b;
                while (Math.Abs(y1 - y) > 1) {
                    if (p > 0)
                    {
                        y = y + 1;
                        GL.Vertex2(x, y);
                        p = p - 2 * dx;
                    }
                    else {
                        x = x + 1;
                        y = y + 1;
                        GL.Vertex2(x,y);
                        p = p + 2 * dy - 2 * dx;
                    }
                }

            }

        }

3、中点画线算法

public void midLine(int x0,int y0,int x1,int y1) {
            double a = y0 - y1;
            double b = x1 - x0;
            int x = x0;
            int y = y0;
            GL.Vertex2(x,y);
            if (Math.Abs(a / b) < 1)
            {
                double d = 2 * a + b;
                while (x < x1)
                {
                    if (d < 0)
                    {
                        x = x + 1;
                        y = y + 1;
                        GL.Vertex2(x, y);
                        d = d + a + b;
                    }
                    else
                    {
                        x = x + 1;
                        GL.Vertex2(x, y);
                        d = d + 2 * a;
                    }
                }
            }
            else {
                double d = a + 2 * b;
                while(y<y1){
                    if (d < 0)
                    {
                        y = y + 1;
                        GL.Vertex2(x, y);
                        d = d + 2 * b;
                    }
                    else
                    {
                        y = y + 1;
                        x = x + 1;
                        GL.Vertex2(x,y);
                        d = d + 2 * a + 2 * b;
                    }
                }
            }
        }

4、DDA画线算法

public void DDALine(int x0,int y0,int x1,int y1) {
              float dx, dy, y, k,x;
              dx = x1 - x0; dy = y1 - y0;
              k = dy / dx; y = y0; x = x0;
              if (k <= 1)
              {
                  for (x = x0; x < x1; x++)
                  {
                      GL.Vertex2(x, Math.Floor(y + 0.5));
                      y = y + k;
                  }
              }
              else {
                  for (y = y0; y < y1; y++)
                  {
                      GL.Vertex2(Math.Floor(x + 0.5), y);
                      x = x + 1 / k;
                  }
              }

        }

二、直线和圆的绘制

private void glControl1_Paint(object sender, PaintEventArgs e)
        {
            if (!loaded)
                return;
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
            GL.Color3(Color.Green);
            GL.Begin(BeginMode.Polygon);
            GL.Vertex2(1, 1);
            GL.Vertex2(20, 80);
            GL.Vertex2(30, 200);
            GL.Vertex2(50, 180);
            GL.Vertex2(60, 50);
            GL.End();
            allPaint8(50, 160, Color.Green, Color.Red);
            //paintGraphy();
            GL.End();
            glControl1.SwapBuffers();
        }
 //八联通递归填充算法
        public void allPaint8(int x, int y, Color boundry, Color fillColor)
        {

            if (Getpixel(x, y).ToArgb() != fillColor.ToArgb() && Getpixel(x, y).ToArgb() == boundry.ToArgb())
            {

                GL.Color3(fillColor);
                GL.Begin(BeginMode.Points);
                GL.Vertex2(x, y);
                GL.End();
                allPaint8(x - 1, y - 1, boundry, fillColor);
                allPaint4(x, y - 1, boundry, fillColor);
                allPaint8(x + 1, y - 1, boundry, fillColor);
                allPaint8(x - 1, y, boundry, fillColor);
                allPaint4(x + 1, y, boundry, fillColor);
                allPaint4(x, y + 1, boundry, fillColor);
                allPaint8(x - 1, y + 1, boundry, fillColor);
                allPaint8(x + 1, y + 1, boundry, fillColor);

            }

        }
 //四联通递归填充算法
        public void allPaint4(int x,int y,Color boundry,Color fillColor) {
            if (Getpixel(x, y).ToArgb()!= fillColor.ToArgb() && Getpixel(x, y).ToArgb()==boundry.ToArgb())
            {

                GL.Color3(fillColor);
                GL.Begin(BeginMode.Points);
                GL.Vertex2(x, y);
                GL.End();
                allPaint4(x - 1, y,boundry,fillColor);
                allPaint4(x, y + 1, boundry, fillColor);
                allPaint4(x + 1, y, boundry, fillColor);
                allPaint4(x, y - 1, boundry, fillColor);
            }

        }
多边形扫描线填充：

填充之前的图像如上所示：
填充之后的图像如下所示：

 private void glControl1_Paint(object sender, PaintEventArgs e)
        {
            if (!loaded)
                return;
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
            GL.Color3(Color.Green);
            GL.Begin(BeginMode.Points);
            GL.Vertex2(1, 1);
            GL.Vertex2(20, 80);
            GL.Vertex2(30, 200);
            GL.Vertex2(50, 180);
            GL.Vertex2(60, 50);
            GL.End();
            paintGraphy();
            GL.End();
            glControl1.SwapBuffers();
        }

//多边形扫描线算法
        public void paintGraphy() {
            NList nlist = new NList(1);
            GL.Vertex2(1, 1);
            GL.Vertex2(20, 80);
            nlist.Add(new Node(1, (20.0 - 1.0) / (80.0 - 1.0), 80));
            GL.Vertex2(30, 200);
            nlist.Add(new Node(20, (30.0 - 20.0) / (200.0 - 80.0), 200));
            GL.Vertex2(50, 180);
            nlist.Add(new Node(50, (50.0 - 30.0) / (180.0 - 200.0), 200));
            GL.Vertex2(60, 50);
            nlist.Add(new Node(60, (60.0 - 50.0) / (50.0 - 180.0), 180));
            nlist.Add(new Node(1, (60.0 - 1.0) / (50.0 - 1.0), 50));
            double t = 0;
            for (int i = 1; i <= 200; i++) {
                List<Point> listPoint = new List<Point>();

                for (int j = 0; j < nlist.myndL.Count; j++) {
                    if (j == 0) {
                        if (i > 1 && i <= nlist.myndL[0].ymax) {
                            listPoint.Add(new Point(nlist.myndL[j].x + i*nlist.myndL[0].dx, i));

                        }
                    }
                    else if (j == 1)
                    {
                        if (i > 1 && i <= nlist.myndL[1].ymax)
                        {
                            listPoint.Add(new Point(nlist.myndL[0].x + i*nlist.myndL[1].dx, i));

                        }

                    }
                    else if (j == 2) {
                        if (i > nlist.myndL[0].ymax && i <= nlist.myndL[j + 1].ymax) {
                            t = i - nlist.myndL[0].ymax;
                            listPoint.Add(new Point(nlist.myndL[j].x + t * nlist.myndL[j].dx, i));
                        }
                    }
                    else
                    {
                        double YMAX;
                        if (j + 1 == nlist.myndL.Count)
                        {
                            YMAX = nlist.myndL[1].ymax;
                        }
                        else {
                            YMAX=nlist.myndL[j + 1].ymax;
                        }
                        double valueJ_1 = Math.Min(YMAX, nlist.myndL[j].ymax);
                        double valueUp = Math.Max(YMAX, nlist.myndL[j].ymax);
                        if (i >valueJ_1 && i <= valueUp )
                        {
                            t = i - valueJ_1;
                            listPoint.Add(new Point(nlist.myndL[j].x + t * nlist.myndL[j].dx, i));

                        }
                    }

                }
                if (listPoint.Count == 2)
                {
                    Bresenhamline(listPoint[0].x, listPoint[0].y, listPoint[1].x, listPoint[1].y);
                }
            }
        }
1.    图形的二维旋转

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using OpenTK.Graphics.OpenGL;
namespace mywapp
{
    public partial class Form1 : Form
    {
        bool loaded = false;
        public Form1()
        {
            InitializeComponent();
        }

        private void glControl1_Load(object sender, EventArgs e)
        {
            loaded = true;
            GL.ClearColor(Color.White);
            SetupViewport();
        }
        private void SetupViewport()
        {
            int w = glControl1.Width;
            int h = glControl1.Height;
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadIdentity();
            GL.Ortho(0, w, 0, h, -1, 1); // Bottom-left corner pixel has coordinate (0, 0)
            GL.Viewport(0, 0, w, h); // Use all of the glControl painting area
        }

private void glControl1_Paint(object sender, PaintEventArgs e)
        {
            if (!loaded)
                return;
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
            GL.Color3(Color.Green);
            GL.Begin(BeginMode.LineLoop);
            GL.Vertex2(1, 1);
            GL.Vertex2(20, 80);
            GL.Vertex2(30, 200);
            GL.Vertex2(50, 180);
            GL.Vertex2(60, 50);
            List<Point> list = new List<Point>();
            list.Add(new Point(1, 1));
            list.Add(new Point(20,80));
            list.Add(new Point(30,200));
            list.Add(new Point(50, 180));
            list.Add(new Point(60, 50));
            List<Point> nlist = rotato2(-30, list);
            foreach (Point point in nlist) {
                GL.Vertex2(point.x,point.y);
            }
            GL.End();
            glControl1.SwapBuffers();
        }

//二维旋转
        private List<Point> rotato2(int angel, List<Point> points)
        {
            double o=(angel*Math.PI)/180.0;
            double[,] a = new double[,] { { Math.Cos(o), -Math.Sin(o) }, { Math.Sin(o), Math.Cos(o) } };
            foreach (Point point in points) {
                point.x = a[0, 0] * point.x + a[0, 1] * point.y;
                point.y = a[1, 0] * point.x + a[1, 1] * point.y;
            }
            return points;

        }
二维平移
将原图形在x轴上向右平移80个单位像素，在y轴上向上平移20个单位像素

//二维平移
        private List<Point> moveLocation(int x, int y, List<Point> points) {
            foreach (Point point in points)
            {
                point.x = point.x + x;
                point.y = point.y + y;
            }
            return points;
        }
二维缩放
将原图形放大了1.3倍之后，在x轴上向右平移了60个单位像素后，得到的图形：

//二维缩放
        private List<Point> changeSize2(double size, List<Point> points) {
            double[,] a = new double[,] { { size, 0 }, { 0, size } };
            foreach (Point point in points)
            {
                point.x = a[0, 0] * point.x + a[0, 1] * point.y;
                point.y = a[1, 0] * point.x + a[1, 1] * point.y;
            }
            return points;
        }

最后是超级牛逼的贝塞尔曲线

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using OpenTK.Graphics.OpenGL;
namespace mywapp
{
    public partial class Form1 : Form
    {
        bool loaded = false;
        public Form1()
        {
            InitializeComponent();
        }

        private void glControl1_Load(object sender, EventArgs e)
        {
            loaded = true;
            GL.ClearColor(Color.White);
            SetupViewport();
        }
        private void SetupViewport()
        {
            int w = glControl1.Width;
            int h = glControl1.Height;
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadIdentity();
            GL.Ortho(0, w, 0, h, -1, 1); // Bottom-left corner pixel has coordinate (0, 0)
            GL.Viewport(0, 0, w, h); // Use all of the glControl painting area
        }

        private void glControl1_Paint(object sender, PaintEventArgs e)
        {
            if (!loaded)
                return;
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
            GL.Color3(Color.Green);
            GL.Begin(BeginMode.Points);
            GL.Vertex2(10, 30);
            GL.Vertex2(40, 60);
            GL.Vertex2(70, 50);
            GL.Vertex2(120, 100);
            GL.End();
            int[,] shuzu = new int[4, 2] { { 10, 30 }, { 40, 60 }, { 70, 50 }, { 120, 110 } };
            drawBezierCurve(shuzu);
            glControl1.SwapBuffers();
        }

        //Bezier画曲线算法
        public void drawBezierCurve(int[,] shuzu)
        {
            int n = 0;
            if ((n = shuzu.GetLength(0)) < 2)
                return;
            for (double t = 0.0; t <= 1; t += 0.05 / n)
            {
                double[,] pshuzu = new double[1, 2] { { 0, 0 } };
                computeP(shuzu, n - 1, t, pshuzu);
                GL.Color3(Color.Red);
                GL.Begin(BeginMode.Points);
                GL.Vertex2(pshuzu[0, 0], pshuzu[0, 1]);
                GL.End();
            }
        }
        void computeP(int[,] pshuzu, int count, double u, double[,] p)
        {
            int i = 0;
            int k = 0;
            double[,] Pshuzu = new double[count + 1, 2];

            for (i = 0; i <= count; i++)
            {
                Pshuzu[i, 0] = pshuzu[i, 0];
                Pshuzu[i, 1] = pshuzu[i, 1];
            }
            for (k = 1; k <= count; k++)
            {
                for (i = 0; i <= count - k; i++)
                {
                    Pshuzu[i, 0] = ((1 - u) * Pshuzu[i, 0] + u * Pshuzu[i + 1, 0]);
                    Pshuzu[i, 1] = ((1 - u) * Pshuzu[i, 1] + u * Pshuzu[i + 1, 1]);
                }
            }
            p[0, 0] = Pshuzu[0, 0];
            p[0, 1] = Pshuzu[0, 1];
       }
}
}

今天是2016年10月18号，今天心情超级不开心

时间： 2024-10-13 19:21:11

33、插入一段大学学的计算机，正儿八经的计算机图形学的相关文章

代写大作业、代写大学计算机基础编程

代写大作业.代写大学计算机基础编程<大学计算机基础>常规班大作业题目 要求:从下列题目中,选择1道题目作为大作业,实现程序并撰写实验报告:文科学生可以选做任何题目,理科学生不可以选做"文科题目". 作业一 信息录入与查找系统 设计一个信息录入与查找系统,使其具有基本身份信息的录入功能,并能在录入的数据中根据一个或多个查找关键字查询出所有符合条件的人.具体要求如下: 1. 设计一个 GUI 界面,其中具有多个输入框,对应姓名.性别.年龄.血型.星座.身高.体重等数据:并有确定

SQL 数据插入、删除 大数据

--测试表 CREATE TABLE [dbo].[Employee] ( [EmployeeNo] INT PRIMARY KEY, [EmployeeName] [nvarchar](50) NULL, [CreateUser] [nvarchar](50) NULL, [CreateDatetime] [datetime] NULL );--1.循环插入 SET STATISTICS TIME ON; DECLARE @Index INT = 1; DECLARE @Timer DATET

阳振坤：数据库天然选择了计算机，但计算机天然并不适合数据库

原文链接:阳振坤:数据库天然选择了计算机,但计算机天然并不适合数据库 - OceanBase数据库的文章 - 知乎 https://zhuanlan.zhihu.com/p/38621134 原文地址:https://www.cnblogs.com/AKUN-FYK/p/12173509.html

redis插入单个较大的键值

1.前言: 在linux的命令行界面或者是进入到redis数据库中,在插入较大的键值时,由于命令行界面对于字符个数的限制,都不能完全将redis的键值粘贴上去,这个时通过shell脚本比较容易实现 2.涉及的文件 redis.sh  #执行插入键值的脚本 redis.txt  #存放键值数据的文件 3.注意 在复制redis键值数据到redis.txt文件中的时候注意空格 4.执行插入脚本redis.sh #!/bin/bash #name: redis.sh #Author: lipc #Da

大学学物理将来到底能干什么？

2012-02-09 11:17:49 来自: Quantum 我现在处在一个迷茫期. 在科大上大一,现在在核院,可能大二会转物理系,但是周围不停有人说学物理将来很难找到好工作. 我现在迷茫了,请大家提下建议. ------------------------------------------------------ 逸小天:可以来豆瓣工作,知道有个人叫卢十四么 孤鸿万里云:可以创办一个叫豆瓣的网站,知道有个人叫阿北么 云飞扬:也可以创办一个叫搜狐的网站,知道有个人叫张朝阳么 WAN :可以创

2.云计算&amp;大数据_linux基础知识(1)计算机为何物

一. 天降一物计算器,何许人也 1.计算机的武林 接受使用者输入指令与数据, 经由中央处理器的数学与逻辑单元运算处理后,以产生或储存成有用的信息 个人计算机,即服务于个人雇主的隐士高手,只要雇主指令得当,下能算数八卦,上能飞天遁地 2.深扒计算机五脏六腑:(运算器,控制器,存储,输入,输出) cpu:高手的脑回路(脑回路:算数逻辑单元与控制单元)------------------------------------------运算器,控制器 bus:总线.高手的七筋六脉,负责运转体内真气(运算

简单粗暴 每个servlet之前都插入一段代码解决 乱码问题

response.setHeader("content-type", "text/html;charset=UTF-8"); response.setCharacterEncoding("UTF-8"); request.setCharacterEncoding("UTF-8"); 原文地址:https://www.cnblogs.com/yirgaMonkey/p/9094140.html

【计算机组成原理】计算机系统概述

计算机结构: 1.硬件:组成计算机的各种设备实体,是物质基础 2.软件:各种程序和文件 计算机的基本功能: 数据加工 数据保存 数据传送 控制操作 五大功能部件: 运算器.控制器 存储器(高速缓存  主存储器  虚拟存储器) 输入.输出设备 这些设备和布局通过总线和接口连接为一台完整的计算机 tip:另一种分类:CPU  存储器 输入设备 输出设备   总线 运算器 核心是算术逻辑运算单位(ALU) 进行加减乘除等算术运算.逻辑运算. 计算机中采用二进制数 注:位数越多,计算的精度就越高,但是位

计算机组成原理(六)——计算机发展趋势

计算机发展趋势 巨型化 巨型化是指为了适应尖端科学技术的需要,发展高速度.大存储容量和功能强大的超级计算机.特别是在军事和科研教育方面对计算机的存储空间和运行速度等要求会越来越高.此外计算机的功能更加多元化. 微型化 随着微型处理器(CPU)的出现,计算机中开始使用微型处理器,使计算机体积缩小了,成本降低了.另一方面,软件行业的飞速发展提高了计算机内部操作系统的便捷度,计算机外部设备也趋于完善.四十年来,计算机的体积不断的缩小,台式电脑.笔记本电脑.掌上电脑.平板电脑体积逐步微型化.因此,未来计