小时钟加上探照灯

最新推荐文章于 2021-03-25 16:19:48 发布
最新推荐文章于 2021-03-25 16:19:48 发布
阅读量128 收藏
点赞数
分类专栏： OpenGl 文章标签： 360 Linq Windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuyuanchen/article/details/83634612
版权
今天，把小时钟在黑夜模式下添加了探照灯，完成了我电脑图学的第三个作业。 

  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 Tao.OpenGl;
using Tao.FreeGlut;
namespace homework3
{
    public partial class Form1 : Form
    {
        double second_rot = 0.0;
        double minit_rot = 0.0;
        double hour_rot = 0.0;
        double rot = 0.0;
        int status = 0;
        int light1_status = 1;
        int light2_status = 1;
        int light3_status = 1;
        int light4_status = 1;
        DateTime mydatetime = new DateTime();
        public Form1()
        {
            InitializeComponent();
            this.simpleOpenGlControl1.InitializeContexts();
            Glut.glutInit();
        }
        private void setVolume()
        {
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            double aspect = (double)this.simpleOpenGlControl1.Size.Width / (double)this.simpleOpenGlControl1.Size.Height;
            Glu.gluPerspective(45.0, aspect, 0.1, 100.0);
            Gl.glViewport(0, 0, this.simpleOpenGlControl1.Width, this.simpleOpenGlControl1.Height);

        }
        private void myInit()
        {
            Gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            float[] global_ambient = new float[] { 0.2f, 0.2f, 0.2f };
            float[] light0_ambient = new float[4] {0.2f,0.2f,0.2f,1.0f };
            float[] light0_diffuse = new float[4] {0.7f,0.7f,0.7f,1.0f };
            float[] light0_specular = new float[4] {0.9f,0.9f,0.9f,1.0f};


            Gl.glLightModelfv(Gl.GL_LIGHT_MODEL_AMBIENT, global_ambient);
            Gl.glLightfv(Gl.GL_LIGHT0 , Gl.GL_AMBIENT, light0_ambient);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, light0_diffuse);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_SPECULAR, light0_specular);

            Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_AMBIENT, light0_ambient);
            Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_DIFFUSE, light0_diffuse);
            Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_SPECULAR, light0_specular);

            Gl.glLightfv(Gl.GL_LIGHT2, Gl.GL_AMBIENT, light0_ambient);
            Gl.glLightfv(Gl.GL_LIGHT2, Gl.GL_DIFFUSE, light0_diffuse);
            Gl.glLightfv(Gl.GL_LIGHT2, Gl.GL_SPECULAR, light0_specular);

            Gl.glLightfv(Gl.GL_LIGHT3, Gl.GL_AMBIENT, light0_ambient);
            Gl.glLightfv(Gl.GL_LIGHT3, Gl.GL_DIFFUSE, light0_diffuse);
            Gl.glLightfv(Gl.GL_LIGHT3, Gl.GL_SPECULAR, light0_specular);

            Gl.glLightfv(Gl.GL_LIGHT4, Gl.GL_AMBIENT, light0_ambient);
            Gl.glLightfv(Gl.GL_LIGHT4, Gl.GL_DIFFUSE, light0_diffuse);
            Gl.glLightfv(Gl.GL_LIGHT4, Gl.GL_SPECULAR, light0_specular);

            Gl.glColorMaterial(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT_AND_DIFFUSE);
            Gl.glEnable(Gl.GL_COLOR_MATERIAL);
            Gl.glEnable(Gl.GL_LIGHTING);

            Gl.glEnable(Gl.GL_LIGHT0);
            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_NORMALIZE);

            status = 0;
        }

        private void simpleOpenGlControl1_Load(object sender, EventArgs e)
        {
            myInit();
            setVolume();
            mydatetime = DateTime.Now;
            second_rot = mydatetime.Second * 6.0;
            minit_rot = mydatetime.Minute * 6.0;
            hour_rot = mydatetime.Hour * 30+mydatetime.Minute*0.5;

        }

        private void simpleOpenGlControl1_Paint(object sender, PaintEventArgs e)
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            Glu.gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);


            float[] material_ambient = new float[4] { 0.2f, 0.2f, 0.2f, 1.0f };
            float[] material_diffuse = new float[4] { 0.7f, 0.7f, 0.7f, 1.0f };
            float[] material_specular = new float[4] { 0.8f, 0.8f, 0.8f, 1.0f };
            float[] light0_position = new float[4] { 0.0f, 0.0f, 5.0f,1.0f};
            float[] light0_direction = new float[3] { 0.0f, 0.0f, 0.0f };
            light0_direction[0] = light0_direction[0] - light0_position[0];
            light0_direction[1] = light0_direction[1] - light0_position[1];
            light0_direction[2] = light0_direction[2] - light0_position[2];

            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, light0_position);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_SPOT_DIRECTION, light0_direction);
            Gl.glMaterialfv(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT, material_ambient);
            Gl.glMaterialfv(Gl.GL_FRONT_AND_BACK, Gl.GL_DIFFUSE, material_diffuse);
            Gl.glMaterialfv(Gl.GL_FRONT_AND_BACK, Gl.GL_SPECULAR, material_specular);
            Gl.glMaterialf(Gl.GL_FRONT_AND_BACK, Gl.GL_SHININESS, 100.0f);

            Gl.glRotated(rot, 0.0, 1.0, 0.0);
            Gl.glColor3ub(0, 255, 0);
            Glut.glutSolidTorus(0.15, 1.5, 40, 40);

            Gl.glPushMatrix();
            Gl.glColor3ub(255, 255, 0);
            Gl.glScaled(1.0, 1.0, 0.1);
            Glut.glutSolidSphere(1.35, 40, 40);
            Gl.glPopMatrix();

            Gl.glPushAttrib(Gl.GL_LIGHTING_BIT);
            Gl.glTranslated(0.0, 0.0, 0.15);
            if (rot < 90 && rot > -90)
            {
                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(0.0, 1.15, 0.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(30 * Math.PI / 180.0), 1.15 * Math.Cos(30 * Math.PI / 180.0), 0.0);
                Gl.glRotated(30.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(60 * Math.PI / 180.0), 1.15 * Math.Cos(60 * Math.PI / 180.0), 0.0);
                Gl.glRotated(60.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15, 0.0, 0.0);
                Gl.glRotated(90.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(120 * Math.PI / 180.0), 1.15 * Math.Cos(120 * Math.PI / 180.0), 0.0);
                Gl.glRotated(120.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(150 * Math.PI / 180.0), 1.15 * Math.Cos(150 * Math.PI / 180.0), 0.0);
                Gl.glRotated(150.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(0, -1.15, 0.0);
                Gl.glRotated(180.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(210 * Math.PI / 180.0), 1.15 * Math.Cos(210 * Math.PI / 180.0), 0.0);
                Gl.glRotated(210.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(240 * Math.PI / 180.0), 1.15 * Math.Cos(240 * Math.PI / 180.0), 0.0);
                Gl.glRotated(240.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(270 * Math.PI / 180.0), 1.15 * Math.Cos(270 * Math.PI / 180.0), 0.0);
                Gl.glRotated(270.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(300 * Math.PI / 180.0), 1.15 * Math.Cos(300 * Math.PI / 180.0), 0.0);
                Gl.glRotated(300.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(330 * Math.PI / 180.0), 1.15 * Math.Cos(330 * Math.PI / 180.0), 0.0);
                Gl.glRotated(330.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(0, 0, 255);
                Gl.glRotated(-hour_rot, 0.0, 0.0, 1.0);
                Gl.glTranslated(0.0, 0.3, 0.0);

                Gl.glScaled(0.1, 1.0, 0.05);
                Glut.glutSolidCube(1.0);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(0, 0, 255);
                Gl.glRotated(-minit_rot, 0.0, 0.0, 1.0);
                Gl.glTranslated(0.0, 0.45, 0.0);
                Gl.glScaled(0.1, 1.8, 0.05);
                Glut.glutSolidCube(0.8);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 255);
                Gl.glRotated(-second_rot, 0.0, 0.0, 1.0);
                Gl.glTranslated(0.0, 0.5, 0.0);
                Gl.glScaled(0.05, 2.4, 0.05);
                Glut.glutSolidCube(0.6);
                Gl.glPopMatrix();
                Gl.glPopAttrib();

                if (light1_status == 0)
                {
                    float[] light_position = new float[4] { (float)(-1.4 * Math.Sin(120 * Math.PI / 180.0)), (float)(-1.4 * Math.Cos(120 * Math.PI / 180.0)), 0.1f, 1.0f };
                    float[] light_direction = new float[3] { 0.0f, 0.0f, 0.0f };
                    light_direction[0] = light_direction[0] - light_position[0];
                    light_direction[1] = light_direction[1] - light_position[1];
                    light_direction[2] = light_direction[2] - light_position[2];


                    Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, light_position);
                    Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_SPOT_DIRECTION, light_direction);
                    Gl.glLightf(Gl.GL_LIGHT1, Gl.GL_SPOT_CUTOFF, (float)(Math.Atan(0.25) * 180.0 / Math.PI));
                    Gl.glLightf(Gl.GL_LIGHT1, Gl.GL_SPOT_EXPONENT, 1.0f);
                    Gl.glEnable(Gl.GL_LIGHT1);

                }
                if (light2_status == 0)
                {
                    float[] light_position = new float[4] { (float)(-1.4 * Math.Sin(60 * Math.PI / 180.0)), (float)(-1.4 * Math.Cos(60 * Math.PI / 180.0)), 0.1f, 1.0f };
                    float[] light_direction = new float[3] { 0.0f, 0.0f, 0.0f };
                    light_direction[0] = light_direction[0] - light_position[0];
                    light_direction[1] = light_direction[1] - light_position[1];
                    light_direction[2] = light_direction[2] - light_position[2];


                    Gl.glLightfv(Gl.GL_LIGHT2, Gl.GL_POSITION, light_position);
                    Gl.glLightfv(Gl.GL_LIGHT2, Gl.GL_SPOT_DIRECTION, light_direction);
                    Gl.glLightf(Gl.GL_LIGHT2, Gl.GL_SPOT_CUTOFF, (float)(Math.Atan(0.25) * 180.0 / Math.PI));
                    Gl.glLightf(Gl.GL_LIGHT2, Gl.GL_SPOT_EXPONENT, 1.0f);


                    Gl.glEnable(Gl.GL_LIGHT2);


                }
                if (light3_status == 0)
                {
                    float[] light_position = new float[4] { (float)(-1.4 * Math.Sin(240 * Math.PI / 180.0)), (float)(-1.4 * Math.Cos(240 * Math.PI / 180.0)), 0.1f, 1.0f };
                    float[] light_direction = new float[3] { 0.0f, 0.0f, 0.0f };
                    light_direction[0] = light_direction[0] - light_position[0];
                    light_direction[1] = light_direction[1] - light_position[1];
                    light_direction[2] = light_direction[2] - light_position[2];

                    Gl.glLightfv(Gl.GL_LIGHT3, Gl.GL_POSITION, light_position);
                    Gl.glLightfv(Gl.GL_LIGHT3, Gl.GL_SPOT_DIRECTION, light_direction);
                    Gl.glLightf(Gl.GL_LIGHT3, Gl.GL_SPOT_CUTOFF, (float)(Math.Atan(0.25) * 180.0 / Math.PI));
                    Gl.glLightf(Gl.GL_LIGHT3, Gl.GL_SPOT_EXPONENT, 1.0f);


                    Gl.glEnable(Gl.GL_LIGHT3);

                }
                if (light4_status == 0)
                {
                    float[] light_position = new float[4] { (float)(-1.4 * Math.Sin(300 * Math.PI / 180.0)), (float)(-1.4 * Math.Cos(300 * Math.PI / 180.0)), 0.1f, 1.0f };
                    float[] light_direction = new float[3] { 0.0f, 0.0f, 0.0f };
                    light_direction[0] = light_direction[0] - light_position[0];
                    light_direction[1] = light_direction[1] - light_position[1];
                    light_direction[2] = light_direction[2] - light_position[2];


                    Gl.glLightfv(Gl.GL_LIGHT4, Gl.GL_POSITION, light_position);
                    Gl.glLightfv(Gl.GL_LIGHT4, Gl.GL_SPOT_DIRECTION, light_direction);
                    Gl.glLightf(Gl.GL_LIGHT4, Gl.GL_SPOT_CUTOFF, (float)(Math.Atan(0.25) * 180.0 / Math.PI));
                    Gl.glLightf(Gl.GL_LIGHT4, Gl.GL_SPOT_EXPONENT, 1.0f);


                    Gl.glEnable(Gl.GL_LIGHT4);


                }
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            second_rot += 6.0;
            if (second_rot % 360 == 0)
            {
                minit_rot += 6.0;
                hour_rot += 0.5;

            }
            this.simpleOpenGlControl1.Refresh();
        }

        private void simpleOpenGlControl1_KeyDown(object sender, KeyEventArgs e)
        {
            switch (e.KeyCode)
            {
                case Keys .D0:
                    if (status == 0)
                    {
                        Gl.glDisable(Gl.GL_LIGHT0);
                        status = 1;
                    }
                    else
                    {
                        Gl.glEnable(Gl.GL_LIGHT0);
                        Gl.glDisable(Gl.GL_LIGHT1);
                        status = 0;
                    }
                    break;
                  case Keys.Left:
                    if (rot >= 270 )
                        rot = -90;
                    rot += 5;

                    break;
                case Keys.Right:
                    if (rot <= -270)
                        rot = 90;
                    rot -= 5;
                    break;
                case Keys .D1:
                    if (light1_status == 1)
                   {


                       light1_status = 0;
                   }
                else 
                  {
                      Gl.glDisable(Gl.GL_LIGHT1);
                     light1_status = 1;
                  }
                    break;
                case Keys.D2:
                    if (light2_status == 1)
                    {
                        light2_status = 0;
                    }
                    else
                    {
                        Gl.glDisable(Gl.GL_LIGHT2);
                        light2_status = 1;
                    }
                    break;
                case Keys.D3:
                    if(light3_status==1)
                    {
                        light3_status = 0;
                    }
                    else
                    {
                        Gl.glDisable(Gl.GL_LIGHT3);
                        light3_status = 1;
                    }
                    break;
                case Keys.D4:
                    if (light4_status == 1)
                    {
                        light4_status = 0;
                    }
                    else 
                    {
                        Gl.glDisable(Gl.GL_LIGHT4);
                        light4_status = 1;
                    }
                    break;

            }
            this.simpleOpenGlControl1.Refresh();
        }

        private void 设定闹钟ToolStripMenuItem_Click(object sender, EventArgs e)
        {

        }   
    }
}

xuyuanchen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python中的异常、模块、文件
dreamer_hahaha
07-24 8375
异常 在程序开发中，如果对某些代码的执行不确定(程序的语法完全正确) 可以增加try来捕获异常 try: 尝试执行的代码 except: 出现错误的处理 例如： try: num = int(raw_input('请输入一个整数： ')) except: print '请输入正确的整数' # 无论是否输入错误额，程序都会正常得执行 print '...
nginx实现均衡负载、nginx第三方模块的添加
dreamer_hahaha
08-01 4249
nginx nginx的安装 下载nginx安装包并解压 tar zxf nginx-1.14.0.tar.gz 对nginx源码文件进行修改，隐藏版本号 cd /root/nginx-1.14.0/src/core/ vim nginx.h 14 #define NGINX_VER &quot;nginx/&quot; #不显示版本号 cd /root/nginx-1....
了不起的 Creator Shader修仙之路—探照灯效果详解
奎特尔星球
08-03 764
介绍探照灯效果就是指整个场景或者图片都是黑的，只有灯光照射的地方才是亮的。实现方式有很多种，我们这里用shader来实现，主要原因就是用shader来实现，效率更高，效果更好，并且拓展性...
unity探照灯跟随目标插件
09-06
该插件是一个unity 光效中的探照灯跟随目标移动照亮局部地方的插件脚本。里面有个demo可以运行。
探照灯效果 
10-15
注意影子的变化! 
文字探照灯flash
12-24
灯光晃动照射显示文字。不停的摆动，照射的文字显示，其他的不显示。
给小时钟打光
xuyuanchen的博客
05-26 134
在昨天的基础上，加入了灯光和旋转，当打入灯光后，时钟立刻就有了立体感，并且按0可以切换灯光的关闭和打开，左右键可以让时钟进行旋转。明天加上探照灯的功能。 [code="C#"] using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; u...
nginx配置文件中一些参数的应用
dreamer_hahaha
08-09 4143
编辑配置文件 vim /usr/local/lnmp/nginx/conf/nginx.conf server { listen 80; server_name www.westos.org; location / { root /www1; index index.html; } } server...
python中的数据存储-json
dreamer_hahaha
07-26 8620
很多程序都要求用户输入某种信息， 程序都把用户提供的信息存储在列表和字典等数据结构中， 用户关闭程序时，你几乎总是要保存他们的信息： 一种简单的方式是使用模块json来存储数据 (在python中使用json的时候，主要也就是使用json模块，json是以一种良好的格式来进行数据交互) 模块json让你能够将简单的python数据结构转存到文件中， 并在程序再次运行时加载该文件中的数据...
《考取HCIA证书看我就够了》第五篇：[HCIA-IoT]物联网技术之感知层技术概览
柠檬PH=2的博客
03-25 3609
系列文章目录 《考取HCIA证书，看我就够了》 1.华为职业认证体系及HCIA介绍 2.[HCIA-IoT]物联网起源与发展 3.[HCIA-IoT]物联网技术之网络层技术概览 4.[HCIA-IoT]物联网技术之平台层技术概览 5.[HCIA-IoT]物联网技术之感知层技术概览 6.[HCIA-IoT]华为物联网解决方案 如果你是第一次观看本系列文章，建议先阅读下之前的文章 本文目录系列文章目录前言一、感知层硬件技术1.1单片机技术1.1.1微型计算机技术概述1.1.2指令集1.1.3处理单元分类1.1
Unity基础系列（四）——构造分形（递归的实现细节）
公众号：壹种念头，知乎：放牛的星星
07-20 1071
点击蓝字关注我们吧！目录1 如何构建分形2 展示内容3 构造子节点4 塑造子节点5 创建多个子节点6 更多的子节点，更好的代码7 爆炸性生长8 添加颜色9、随机化Mesh10 使分形不...
canvas实现探照灯
suweim的博客
06-28 2775
canvas实现探照灯特效
Mnist数据集，用于人工智能相关基础模型的学习及编程练习
09-06
Mnist数据集，用于人工智能相关基础模型的学习及编程练习
水空两用无人机动力系统设计与研究.pdf
最新发布
09-06
水空两用无人机动力系统设计与研究.pdf
大神asp新闻发布系统毕业课程设计项目+论文
09-06
编号：55 摘要：随着计算机技术的广泛应用,在新闻发布中引入计算机管理技术,成为一个值得深入研究的问题。本系统采用ASP+ACCESS作为开发环境,本文首先概要的论述了ASP的有关知识与现状,之后，对本系统作了系统的描述,在此基础上，对系统的总体框架和数据库进行了设计，然后，对开发一个小型的新闻信息发布管理系统的各个关键模块实现进行了详细说明。 关键词： 新闻发布，新闻管理，asp，access 目 录 第一章 前　言 1 第二章 系统概述 2 2.1 开发背景 2 2.2 可行性分析 2 2.3 需求分析 3 2.4 asp技术概述 3 2.4.1 ASP的特点 3 2.4.2 ASP的工作原理 4 2.4.3 ASP环境的安装与配置 5 2.5 Access 2003 数据库工具概述 5 2.5.1选择Access2003 作为后台数据库 6 2.5.2 ADO开发数据库 6 第三章 总体设计 8 3.1 系统总体功能设计 8 3.2 系统数据库设计 9 3.2.1 超级管理员表(admin表)设计 9 3.2.2 新闻信息表(news表)设计 10 3.2.3 新闻栏目表(
矫正图像带的旋转角度信息和目标检测标签坐标也随之改变.zip
09-06
1 目标检测的定义 目标检测（Object Detection）的任务是找出图像中所有感兴趣的目标（物体），确定它们的类别和位置，是计算机视觉领域的核心问题之一。由于各类物体有不同的外观、形状和姿态，加上成像时光照、遮挡等因素的干扰，目标检测一直是计算机视觉领域最具有挑战性的问题。 目标检测任务可分为两个关键的子任务，目标定位和目标分类。首先检测图像中目标的位置（目标定位），然后给出每个目标的具体类别（目标分类）。输出结果是一个边界框（称为Bounding-box，一般形式为(x1,y1,x2,y2)，表示框的左上角坐标和右下角坐标），一个置信度分数（Confidence Score），表示边界框中是否包含检测对象的概率和各个类别的概率（首先得到类别概率，经过Softmax可得到类别标签）。 1.1 Two stage方法 目前主流的基于深度学习的目标检测算法主要分为两类：Two stage和One stage。Two stage方法将目标检测过程分为两个阶段。第一个阶段是 Region Proposal 生成阶段，主要用于生成潜在的目标候选框（Bounding-box proposals）。这个阶段通常使用卷积神经网络（CNN）从输入图像中提取特征，然后通过一些技巧（如选择性搜索）来生成候选框。第二个阶段是分类和位置精修阶段，将第一个阶段生成的候选框输入到另一个 CNN 中进行分类，并根据分类结果对候选框的位置进行微调。Two stage 方法的优点是准确度较高，缺点是速度相对较慢。 常见Tow stage目标检测算法有：R-CNN系列、SPPNet等。 1.2 One stage方法 One stage方法直接利用模型提取特征值，并利用这些特征值进行目标的分类和定位，不需要生成Region Proposal。这种方法的优点是速度快，因为省略了Region Proposal生成的过程。One stage方法的缺点是准确度相对较低，因为它没有对潜在的目标进行预先筛选。 常见的One stage目标检测算法有：YOLO系列、SSD系列和RetinaNet等。 2 常见名词解释 2.1 NMS(Non-Maximum Suppression) 目标检测模型一般会给出目标的多个预测边界框，对成百上千的预测边界框都进行调整肯定是不可行的,需要对这些结果先进行一个大体的挑选。NMS称为非极大值抑制，作用是从众多预测边界框中挑选出最具代表性的结果，这样可以加快算法效率，其主要流程如下： 设定一个置信度分数阈值，将置信度分数小于阈值的直接过滤掉 将剩下框的置信度分数从大到小排序，选中值最大的框 遍历其余的框，如果和当前框的重叠面积(IOU)大于设定的阈值（一般为0.7），就将框删除（超过设定阈值，认为两个框的里面的物体属于同一个类别） 从未处理的框中继续选一个置信度分数最大的，重复上述过程，直至所有框处理完毕 2.2 IoU(Intersection over Union) 定义了两个边界框的重叠度，当预测边界框和真实边界框差异很小时，或重叠度很大时，表示模型产生的预测边界框很准确。边界框A、B的IOU计算公式为: 2.3 mAP(mean Average Precision) mAP即均值平均精度，是评估目标检测模型效果的最重要指标，这个值介于0到1之间，且越大越好。mAP是AP(Average Precision)的平均值，那么首先需要了解AP的概念。想要了解AP的概念，还要首先了解目标检测中Precision和Recall的概念。 首先我们设置置信度阈值（Confidence Threshold）和IoU阈值（一般设置为0.5，也会衡量0.75以及0.9的mAP值）： 当一个预测边界框被认为是True Positive（TP）时，需要同时满足下面三个条件： Confidence Score > Confidence Threshold 预测类别匹配真实值(Ground truth)的类别 预测边界框的IoU大于设定的IoU阈值 不满足条件2或条件3，则认为是False Positive（FP）。当对应同一个真值有多个预测结果时，只有最高置信度分数的预测结果被认为是True Positive，其余被认为是False Positive。 Precision和Recall的概念如下图所示： Precision表示TP与预测边界框数量的比值 Recall表示TP与真实边界框数量的比值 改变不同的置信度阈值，可以获得多组Precision和Recall，Recall放X轴，Precision放Y轴，可以画出一个Precision-Recall曲线，简称P-R
DJI M210安装探照灯
12-27
根据提供的引用内容，以下是DJI M210安装探照灯的步骤： 1. 首先，确保你已经下载并安装了DJI Assistant2调参软件。你可以从大疆官网的下载页面（https://www.dji.com/cn/downloads/products/matrice-200-series-v2）获取该软件。 2. 使用双头USB线将飞行器和PC连接起来。双头USB线通常是白色的。 3. 打开DJI Assistant2软件，并登录你的DJI账号。 4. 在软件界面上，选择你的飞行器型号（M210 RTK V2）。 5. 在软件的菜单中，找到“设备”或“配置”选项，并选择“探照灯”。 6. 进入探照灯设置界面后，你可以选择安装探照灯的位置和方式。根据你的需求，选择合适的选项。 7. 完成设置后，点击“应用”或“保存”按钮，保存你的设置。 8. 断开飞行器和PC之间的USB连接。 通过以上步骤，你可以成功安装探照灯到DJI M210飞行器上。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值