罗磐

颜色、光照、材料属性（openGL）

0.颜色

a.颜色坐标系

b.颜色设置与着色

void colortriangle()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glShadeModel(GL_SMOOTH);
	glBegin(GL_TRIANGLES);
		/************************************颜色设置及着色**************************************************
			1、void glColorXt(red, green, blue, alpha);
				其中x代表参数个数，可以是3个值代表rgb颜色，或者使4个值分别代表rgba。alpha成分用来代表透明度。
				t代表参数的类型，可以是b,d,f,i,s,ub,ui,us对应的类型是byte,double,float,integer,short,unsigned byte, unsigned integer,unsigned short。
				glColor3f指定各个颜色成分的强度值的范围为0.0到1.0之间。
				glColor3ub则可以指定各个颜色成分的强度值的范围在0-255之间。
			2、着色分为两种
				GL_FLAT：图元是点（画的是线什么的情况下），使用最后一个点的颜色作为线（其他图）颜色
				GL_SMOOTH：图元是点（画的是线什么的情况下），均衡，颜色渐变（两顶点间） 
		****************************************************************************************************/ 
		glColor3ub((GLubyte)255,(GLubyte)0,(GLubyte)0);							//ub:unsign byte
		glVertex3f(0.0f,100.0f,0.0f);
		glColor3ub((GLubyte)0,(GLubyte)255,(GLubyte)0);
		glVertex3f(100.0f,-35.0f,0.0f);
		glColor3ub((GLubyte)0,(GLubyte)0,(GLubyte)255);
		glVertex3f(-100.0f,-35.0f,0.0f);
	glEnd();
	glFlush();
}

c.看到的颜色是光照颜色和材料属性综合的结果

若光源颜色为( LR , LG , LB )，材质颜色为( MR , MG , MB )，最终颜色为( LR*MR , LG*MG , LB*MB )。(B1+B2)*MB )。因此，材料的颜色成分决定了入射光被反射的百分比。

栗子：光源颜色为(0.5, 0.5, 0.5)，材料的颜色为(0.5, 1.0, 0.5)那么最终的颜色是(0.5*0.5, 0.5*1.0, 0.5*0.5) = (0.25, 0.5, 0.25) 。

1.光照

我们观察到的实物的颜色除了，实物本身的颜色外，还包括实物的材质和光照对观察的影响。

a.光照类型

环境光、散射光、镜面光的强度都会衰减（这也是为什么在设置光照的同事还要设置光照位置的一个原因），只有发射光和全局环境光的强度没有衰减。

环境光：

环境光没有特定的方向。环境光的光线充满着整个场景。场景中的物体都被环境光从各个方向照射着。环境光的特点是：照射在物体上的光来自周围各个方向，又均匀地向各个方向反射。

全局环境光栗子

//明亮的白光
GLfloat ambientLight[] = {1.0f, 1.0f, 1.0f, 1.0f};
//开启光照
glEnable(GL_LIGHTING);
//设置全局环境光为白光
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight);

漫反射光：

漫放射光是一组来自特定方向，具有方向性的光。根据入射光线的角度在表面上均匀地向各个方向反射。漫反射的特点是：光源来自一个方向，反射光均匀地射向各个方向。漫反射光采用点光源照射物体。点光源是位于空间某个位置的一个点，向周围所有的方向上辐射等光强的光。在点光源的照射下，物体表面的不同部分亮度不同，亮度的大小依赖于它的朝向以及它与点光源之间的距离。

镜面光：

镜面光与漫反射光一样是具有方向性的。高强度的镜面光会在被照射的物体的表面上形成亮点。对于理想的高光泽度反射面，反射角等于入射角时，光线才会被反射，即只有在等于入射角的反射角方向上，观察者才能看到反射光。对于这种理想的反射面，镜面反射的光强要比环境光和漫反射的光强高出很多倍，这时，如果观察者正好处在P点的镜面反射方向上，就会看到一个比周围亮得多的高光点。

b.光照与法线

作用于定义：

物体的法线向量决定了它相对于光源的方向（区别于材料颜色属性定义时使用的多边形正面和反面；这个法线定义方向，是光照用的）。对于物体的每个顶点，opengl使用法线判断这个顶点从每个光源接受的光线数量。

为每个顶点定义法线向量：

OpenGL中，既可以为每个多边形只指定一条法线（多边形各顶点的法线方向相同），也可以为每个多边形指定多条法线（多边形顶点的法线方向有不同）。在OpenGL中，除了顶点之外，不能为多边形其他地方分配法线。

法线向量：

物体的法线向量定义了它的表面在空间中的朝向，即，定义了表面相对于光源的方向。因为OpenGL是使用法线向量来确定一个物体表面的某个顶点所接受的光照的。如果不想使用OpenGL的光照功能，就可以免去为顶点指定法线向量这个步骤。GLUT工具库中某些模型的法线向量已经内部给定好啦，如glutWireCube()等，所绘制的模型各个顶点的法线向量已经系统给出了，又如绘制一个球Sphere等。

指定法线向量：

glNormal*()函数是把当前法线向量这个状态量设置为这个函数的参数所指示的向量值。后续顶点glVertex*()的法线向量将默认为此时法线向量状态量所保存的向量值。通常，顶点常具有不同的法线向量，因此常需要交替调用这两个函数。

在一个表面的顶点上，将会有两条向量垂直于这个表面，这两条向量指向相反的方向，而指向外侧的向量才为当前表面的法线向量。法线向量只表示方向，不表示大小（即与长度无关）。理论上可以为顶点指定任意大小的法线向量，但在OpenGL执行光照操作时，会将顶点的法线向量规范化（单位化），而这样必然会降低程序的性能，所以一般应由我们自己提供各个顶点的规范化法线向量。
如果只是对模型进行移动、旋转操作，法线向量的长度将不会发生变化，而如果对模型进行缩放操作，长度则将变化。如果需要OpenGL对法线向量进行规范化，就需要启用这个功能，glEnable(GL_NORMALIZE)，默认这个功能是关闭的。
如果所进行的缩放是均匀缩放，则可以使用glEnable(GL_RESCALE_NORMAL)，这样性能相比较GL_NORMALIZE更优。默认情况下，GL_RESCALE_NORMAL也是被禁用的。

2.材料

a.材料属性

当我们使用光照时，我们通过材料的反射属性来描述它的颜色，我们为三种光源指定材料相应的反射属性。一个材料可能会很好的反射镜面光，却吸收了大多数的漫反射和环境光。

b.材料的属性设置

1）在指定的多边形前调用glMaterial函数。

void glMaterial{if}(GLenum face, GLenum pname, TYPE param);

参数：face：正面还是反面应用材料属性设置；pname：材料属性；param，参数
//灰色的材料属性
GLfloat gray[] = {0.75f, 0.75f, 0.75f, 1.0f};

glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);
glBegin(GL_TRIANGLES);
    glVertex3f(-15.0f, 0.0f, 30.0f);
    glVertex3f(0.0f, 15.0f, 30.0f);
    glVertex3f(0.0f, 0.0f, -56.0f);
glEnd();
2）材料的颜色追踪
开启GL_COLOR_MATERIAL；设置追踪面和追踪的材料属性glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);；之后就可以通过glColor来设置颜色了
//开启颜色追踪
glEnable(GL_COLOR_MATERIAL);
//设置颜色追踪的材料属性以及多边形的面
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

//设置颜色
glColor3f(0.75f, 0.75f, 0.75f);
glBegin(GL_TRIANGLES);
    glVertex3f(-15.0f, 0.0f, 30.0f);
    glVertex3f(0.0f, 15.0f, 30.0f);
    glVertex3f(0.0f, 0.0f, -56.0f);
glEnd();

3.综合栗子

a.综合栗子1-----材料颜色属性：

#include "grapg.h"

static GLfloat xRot=0.0f;
static GLfloat yRot=0.0f;
void setuprc_000()
{
	GLfloat ambientLight[]={0.5f,0.5f,0.5f,1.0f};
	glEnable(GL_DEPTH_TEST);													//开启深度测试 
	glEnable(GL_CULL_FACE);														//开启隐藏面，因为后面设置了材料的颜色追踪，只追踪正面，所以要先剔除反面，在把反面用正面的方式画上去 
	glFrontFace(GL_CCW);														//设置逆时针为正面
	
	glEnable(GL_COLOR_MATERIAL);												//开启材料的颜色追踪
	glEnable(GL_LIGHTING);														//开启光照
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ambientLight);						//设置全局环境光
	glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);							//设置材料的颜色追踪 
	
	glClearColor(0.0f,0.0f,0.0f,1.0f); 
}

void aircraft()
{	
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glPushMatrix();
		glRotatef(xRot, 1.0f, 0.0f, 0.0f);
    	glRotatef(yRot, 0.0f, 1.0f, 0.0f);

    	glBegin(GL_TRIANGLES);
    	//机头
    		glColor3f(1.0f, 1.0f, 1.0f);
      		glVertex3f(-15.0f, 0.0f, 30.0f);
      		glVertex3f(15.0f, 0.0f, 30.0f);
      		glVertex3f(0.0f, 0.0f, 60.0f);

      		glColor3f(0.0f, 0.0f, 0.0f);
      		glVertex3f(-15.0f, 0.0f, 30.0f);
      		glVertex3f(0.0f, 0.0f, 60.0f);
      		glVertex3f(0.0f, 15.0f, 30.0f);

      		glColor3f(1.0f, 0.0f, 0.0f);
      		glVertex3f(0.0f, 0.0f, 60.0f);
      		glVertex3f(15.0f, 0.0f, 30.0f);
      		glVertex3f(0.0f, 15.0f, 30.0f);
      //机身
      		glColor3f(0.0f, 1.0f, 0.0f);
      		glVertex3f(-15.0f, 0.0f, 30.0f);
      		glVertex3f(0.0f, 15.0f, 30.0f);
      		glVertex3f(0.0f, 0.0f, -53.0f);

      		glColor3f(1.0f, 1.0f, 0.0f);
      		glVertex3f(0.0f, 15.0f, 30.0f);
      		glVertex3f(15.0f, 0.0f, 30.0f);
      		glVertex3f(0.0f, 0.0f, -53.0f);

      		glColor3f(0.5f, 0.5f, 0.3f);
      		glVertex3f(15.0f, 0.0f, 30.0f);
      		glVertex3f(-15.0f, 0.0f, 30.0f);
      		glVertex3f(0.0f, 0.0f, -53.0f);

      //机尾巴
      		glColor3f(0.3f, 1.0f, 0.2f);
      		glVertex3f(0.0f, 0.0f, -53.0f);
      		glVertex3f(0.0f, 0.0f, -70.0f);
      		glVertex3f(0.0f, 15.0f, -70.0f);

      		glColor3f(0.7f, 0.5f, 0.3f);
      		glVertex3f(-15.0f, 0.0f, -70.0f);
      		glVertex3f(0.0f, 0.0f, -53.0f);
      		glVertex3f(0.0f, 0.0f, -70.0f);

      		glColor3f(0.2f, 0.2f, 0.8f);
      		glVertex3f(15.0f, 0.0f, -70.0f);
      		glVertex3f(0.0f, 0.0f, -70.0f);
      		glVertex3f(0.0f, 0.0f, -53.0f);

      //由于背面被消除，背面再画一次
      		glColor3f(0.3f, 1.0f, 0.2f);
      		glVertex3f(0.0f, 0.0f, -70.0f);
      		glVertex3f(0.0f, 0.0f, -53.0f);
      		glVertex3f(0.0f, 15.0f, -70.0f);
      
      		glColor3f(0.7f, 0.5f, 0.3f);
      		glVertex3f(0.0f, 0.0f, -53.0f);
      		glVertex3f(-15.0f, 0.0f, -70.0f);
      		glVertex3f(0.0f, 0.0f, -70.0f);

      		glColor3f(0.2f, 0.2f, 0.8f);
      		glVertex3f(0.0f, 0.0f, -70.0f);
      		glVertex3f(15.0f, 0.0f, -70.0f);
      		glVertex3f(0.0f, 0.0f, -53.0f);

      // 左翼 
      		glColor3ub(128,128,128);
      		glVertex3f(0.0f,2.0f,27.0f);
      		glVertex3f(-60.0f, 2.0f, -8.0f);
      		glVertex3f(60.0f, 2.0f, -8.0f);

      		glColor3ub(64,64,64);
      		glVertex3f(60.0f, 2.0f, -8.0f);
      		glVertex3f(0.0f, 7.0f, -8.0f);
      		glVertex3f(0.0f,2.0f,27.0f);

      		glColor3ub(192,192,192);
      		glVertex3f(60.0f, 2.0f, -8.0f);
      		glVertex3f(-60.0f, 2.0f, -8.0f);
      		glVertex3f(0.0f,7.0f,-8.0f);

      //右翼 
      		glColor3ub(64,64,64);
      		glVertex3f(0.0f,2.0f,27.0f);
      		glVertex3f(0.0f, 7.0f, -8.0f);
      		glVertex3f(-60.0f, 2.0f, -8.0f);
    	glEnd();
  	glPopMatrix();
  	glutSwapBuffers();	
}

void specialkeys(int key,int x,int y)
{
	if(key == GLUT_KEY_UP)
    	xRot-= 5.0f;
	if(key == GLUT_KEY_DOWN)
    	xRot += 5.0f;
	if(key == GLUT_KEY_LEFT)
    	yRot -= 5.0f;
	if(key == GLUT_KEY_RIGHT)
    	yRot += 5.0f;
  	if(key > 356.0f)
    	xRot = 0.0f;
  	if(key < -1.0f)
    	xRot = 355.0f;
  	if(key > 356.0f)
    	yRot = 0.0f;
	if(key < -1.0f)
    	yRot = 355.0f;
	glutPostRedisplay();//标记重绘 
} 

void reshape(int w,int h)						
{								
	GLfloat nRange = 100.0f; 
 	if (h == 0)   
 	{ 
	 	h = 1; 
 	}
 	glViewport(0, 0, w, h);
 	glMatrixMode(GL_PROJECTION);												//设置当前矩阵为投影矩阵  
	glLoadIdentity();															//将当前用户坐标系重置   
	GLfloat aspect = (GLfloat)w/(GLfloat)h; 
	if (w<=h)																	//设置投影    
	{ 
		glOrtho(-nRange, nRange, -nRange/aspect, nRange/aspect, -nRange, nRange);//参数为：x轴左、右；y轴下、上；z轴里、外 
	} 
	else 
	{
		glOrtho(-nRange*aspect, nRange*aspect, -nRange, nRange, -nRange, nRange);//重新定义了裁剪区域，但保持纵横比不变 
	}
	glMatrixMode(GL_MODELVIEW);													 //将当前矩阵设置为模型视图矩阵 
	glLoadIdentity(); 
}

int main_light_material()
{
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(800,600);
  glutCreateWindow("test");
  glutReshapeFunc(reshape);
  glutSpecialFunc(specialkeys);
  glutDisplayFunc(aircraft);
  setuprc_000();
  glutMainLoop();
  return 0;
}

b.综合栗子2------光照与法线设置:

#include "grapg.h"
static GLfloat xRot=0.0f;
static GLfloat yRot=0.0f;
void countnormal(GLfloat normal[],GLfloat p1[],GLfloat p2[],GLfloat p3[])		//叉乘计算平面法线向量 
{
	GLfloat v1[]={0.0f,0.0f,0.0f};
	GLfloat v2[]={0.0f,0.0f,0.0f};	
	v1[0]=p2[0]-p1[0];
	v1[1]=p2[1]-p1[1];
	v1[2]=p2[2]-p1[2];
	v2[0]=p3[0]-p1[0];
	v2[1]=p3[1]-p1[1];
	v2[2]=p3[2]-p1[2];
	normal[0]=v1[1]*v2[2]-v1[2]*v2[1];
	normal[1]=v1[2]*v2[0]-v1[0]*v2[2];
	normal[2]=v1[0]*v2[1]-v1[1]*v2[0];
}
void aircraft_001()
{
	GLfloat normal[]={0.0f,0.0f,0.0f};
	GLfloat p1[]={0.0f,0.0f,0.0f};
	GLfloat p2[]={0.0f,0.0f,0.0f};
	GLfloat p3[]={0.0f,0.0f,0.0f};

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glPushMatrix();
		glRotatef(xRot, 1.0f, 0.0f, 0.0f);
    	glRotatef(yRot, 0.0f, 1.0f, 0.0f);
		glColor3ub(128,128,128);
    	glBegin(GL_TRIANGLES);
    	//机头
    		p1[0]=-15.0f;p1[1]=0.0f;p1[2]=30.0f;
    		p2[0]=15.0f;p2[1]=0.0f;p2[2]=30.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=60.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);							//因为此处均是三角形，为平面，所以指定一个法线向量就行 
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=-15.0f;p1[1]=0.0f;p1[2]=30.0f;
    		p2[0]=0.0f;p2[1]=0.0f;p2[2]=60.0f;
    		p3[0]=0.0f;p3[1]=15.0f;p3[2]=30.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=0.0f;p1[1]=0.0f;p1[2]=60.0f;
    		p2[0]=15.0f;p2[1]=0.0f;p2[2]=30.0f;
    		p3[0]=0.0f;p3[1]=15.0f;p3[2]=30.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);
      //机身
      		p1[0]=-15.0f;p1[1]=0.0f;p1[2]=30.0f;
    		p2[0]=0.0f;p2[1]=15.0f;p2[2]=30.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=-53.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=0.0f;p1[1]=15.0f;p1[2]=30.0f;
    		p2[0]=15.0f;p2[1]=0.0f;p2[2]=30.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=-53.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=15.0f;p1[1]=0.0f;p1[2]=30.0f;
    		p2[0]=-15.0f;p2[1]=0.0f;p2[2]=30.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=-53.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      //机尾巴
      		p1[0]=0.0f;p1[1]=0.0f;p1[2]=-53.0f;
    		p2[0]=0.0f;p2[1]=0.0f;p2[2]=-70.0f;
    		p3[0]=0.0f;p3[1]=15.0f;p3[2]=-70.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=-15.0f;p1[1]=0.0f;p1[2]=-70.0f;
    		p2[0]=0.0f;p2[1]=0.0f;p2[2]=-53.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=-70.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=15.0f;p1[1]=0.0f;p1[2]=-70.0f;
    		p2[0]=0.0f;p2[1]=0.0f;p2[2]=-70.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=-53.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      //由于背面被消除，背面再画一次
      		p1[0]=0.0f;p1[1]=0.0f;p1[2]=-70.0f;
    		p2[0]=0.0f;p2[1]=0.0f;p2[2]=-53.0f;
    		p3[0]=0.0f;p3[1]=15.0f;p3[2]=-70.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);
      
      		p1[0]=0.0f;p1[1]=0.0f;p1[2]=-53.0f;
    		p2[0]=-15.0f;p2[1]=0.0f;p2[2]=-70.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=-70.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=0.0f;p1[1]=0.0f;p1[2]=-70.0f;
    		p2[0]=15.0f;p2[1]=0.0f;p2[2]=-70.0f;
    		p3[0]=0.0f;p3[1]=0.0f;p3[2]=-53.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      // 左翼 
      		p1[0]=0.0f;p1[1]=2.0f;p1[2]=27.0f;
    		p2[0]=-60.0f;p2[1]=2.0f;p2[2]=-8.0f;
    		p3[0]=60.0f;p3[1]=2.0f;p3[2]=-8.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=60.0f;p1[1]=2.0f;p1[2]=-8.0f;
    		p2[0]=0.0f;p2[1]=7.0f;p2[2]=-8.0f;
    		p3[0]=0.0f;p3[1]=2.0f;p3[2]=27.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);

      		p1[0]=60.0f;p1[1]=2.0f;p1[2]=-8.0f;
    		p2[0]=-60.0f;p2[1]=2.0f;p2[2]=-8.0f;
    		p3[0]=0.0f;p3[1]=7.0f;p3[2]=-8.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);
      //右翼 
      		p1[0]=0.0f;p1[1]=2.0f;p1[2]=27.0f;
    		p2[0]=0.0f;p2[1]=7.0f;p2[2]=-8.0f;
    		p3[0]=-60.0f;p3[1]=2.0f;p3[2]=-8.0f;
    		countnormal(normal,p1,p2,p3);
    		glNormal3f(normal[0],normal[1],normal[2]);
      		glVertex3f(p1[0],p1[1],p1[2]);
      		glVertex3f(p2[0],p2[1],p2[2]);
      		glVertex3f(p3[0],p3[1],p3[2]);
      		glVertex3f(0.0f,2.0f,27.0f);
      		glVertex3f(0.0f, 7.0f, -8.0f);
      		glVertex3f(-60.0f, 2.0f, -8.0f);
    	glEnd();
  	glPopMatrix();
  	glutSwapBuffers();	
}

void setuprc_001()
{
	GLfloat ambientLight[]={0.3f,0.3f,0.3f,1.0f};								//环境光rgba
	GLfloat diffuseLight[]={0.7f,0.7f,0.7f,1.0f};								//漫射光 
	GLfloat specular[]={1.0f,1.0f,1.0f,1.0f};
	glEnable(GL_DEPTH_TEST);													//开启深度测试 
	glEnable(GL_CULL_FACE);														//开启隐藏面，因为后面设置了材料的颜色追踪，只追踪正面，所以要先剔除反面，在把反面用正面的方式画上去 
	glFrontFace(GL_CCW);														//设置逆时针为正面
	
	glEnable(GL_LIGHTING);														//开启光照
	glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);								//设置光照 
	glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
	glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
	glEnable(GL_LIGHT0);
	
	GLfloat specref[]={1.0f,1.0f,1.0f,1.0f};
	glEnable(GL_COLOR_MATERIAL);
	glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);							//设置材料的颜色追踪 
	glMaterialfv(GL_FRONT,GL_SPECULAR,specref);
	//GL_SHININESS属性。该属性只有一个值，称为“镜面指数”，取值范围是0到128。
	//该值越小，表示材质越粗糙，点光源发射的光线照射到上面，也可以产生较大的亮点。
	//该值越大，表示材质越类似于镜面，光源照射到上面后，产生较小的亮点。
	glMateriali(GL_FRONT,GL_SHININESS,128);
	
	glClearColor(0.0f,0.0f,1.0f,1.0f); 
	glEnable(GL_NORMALIZE);														//开启自动标准化法线向量 
}

void specialkeys_001(int key,int x,int y)
{
	if(key == GLUT_KEY_UP)
    	xRot-= 5.0f;
	if(key == GLUT_KEY_DOWN)
    	xRot += 5.0f;
	if(key == GLUT_KEY_LEFT)
    	yRot -= 5.0f;
	if(key == GLUT_KEY_RIGHT)
    	yRot += 5.0f;
  	if(key > 356.0f)
    	xRot = 0.0f;
  	if(key < -1.0f)
    	xRot = 355.0f;
  	if(key > 356.0f)
    	yRot = 0.0f;
	if(key < -1.0f)
    	yRot = 355.0f;
	glutPostRedisplay();														//标记重绘 
} 

void reshape_001(int w,int h)						
{								
	GLfloat faspect;
	GLfloat lightPos[] = { -50.f, 50.0f, 100.0f, 1.0f };
	if(h == 0)
    	h = 1;
  	glViewport(0, 0, w, h);														//视口大小设置 
  	glMatrixMode(GL_PROJECTION);												//设置投影 
  	glLoadIdentity();
 	faspect = (GLfloat) w / (GLfloat) h;
  	gluPerspective(45.0f, faspect, 1.0f, 225.0f);

  	glMatrixMode(GL_MODELVIEW);
  	glLoadIdentity();

  	glLightfv(GL_LIGHT0,GL_POSITION,lightPos);									//设置光源位置 
  	glTranslatef(0.0f, 0.0f, -150.0f);
}

int main_light_material()
{
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(800,600);
  glutCreateWindow("test");
  glutReshapeFunc(reshape_001);
  glutSpecialFunc(specialkeys_001);
  glutDisplayFunc(aircraft_001);
  setuprc_001();
  glutMainLoop();
  return 0;
}

遥感影像的切片处理 sand&wich 计算机视觉 python 图像处理
在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
Python实现下载当前年份的谷歌影像 sand&wich python 开发语言
在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
Python实现TIFF 文件转换为 PNG 和 JPG 格式 sand&wich python 开发语言
在日常的图像处理工作中，可能会遇到需要将TIFF格式的图像转换为其他格式的情况，例如PNG和JPG。下面，本文将介绍如何使用Python和GDAL库实现这一功能。准备工作在开始之前，请确保已经安装了必要的库：GDAL（GeospatialDataAbstractionLibrary）可以使用以下命令安装GDAL：pipinstallgdal代码实现以下是一个将TIFF文件转换为PNG文件的示例代码
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
计算机视觉中，Pooling的作用 Wils0nEdwards 计算机视觉人工智能
在计算机视觉中，Pooling（池化）是一种常见的操作，主要用于卷积神经网络（CNN）中。它通过对特征图进行下采样，减少数据的空间维度，同时保留重要的特征信息。Pooling的作用可以归纳为以下几个方面：1.降低计算复杂度与内存需求Pooling操作通过对特征图进行下采样，减少了特征图的空间分辨率（例如，高度和宽度）。这意味着网络需要处理的数据量会减少，从而降低了计算量和内存需求。这对大型神经网络
OpenCV图像处理技术（Python）——入门森屿_ opencv
©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
opencv学习：图像旋转的两种方法，旋转后的图片进行模板匹配代码实现夜清寒风学习 opencv 机器学习人工智能计算机视觉
图像旋转在图像处理中，rotate和rot90是两种常见的图像旋转方法，它们在功能和使用上有一些区别。下面我将分别介绍这两种方法，并解释它们的主要区别rot90方法rot90方法是NumPy提供的一种数组旋转函数，它主要用于对二维数组（如图像）进行90度的旋转。这个方法比较简单，只支持90度的倍数旋转，不支持任意角度旋转。使用NumPy进行旋转使用NumPy的rot90函数对模板图像进行旋转操作。
Python OpenCV图像处理：从基础到高级的全方位指南极客代码玩转Python 开发语言 python opencv 图像处理计算机视觉
目录第一部分：PythonOpenCV图像处理基础1.1OpenCV简介1.2PythonOpenCV安装1.3实战案例：图像显示与保存1.4注意事项第二部分：PythonOpenCV图像处理高级技巧2.1图像变换2.2图像增强2.3图像复原第三部分：PythonOpenCV图像处理实战项目3.1图像滤波3.2图像分割3.3图像特征提取第四部分：PythonOpenCV图像处理注意事项与优化策略4
服务器状态监控php源码,服务器状态监控_监控Linux服务器网站状态的SHELL脚本温糯米服务器状态监控php源码
摘要腾兴网为您分享:监控Linux服务器网站状态的SHELL脚本，蜗牛集市，同花顺，探客宝，手柄助手等软件知识，以及日期倒计时插件，云南省教育资源公共，rui手机桌面，小屁孩桌面便签，合金装备崛起复仇，朝夕日历，photoshop图像处理软件,一年级学生每日计划表，悟空找房，饿了吗外卖商家版，逃生，中国民宿网，realpolitiks，交通安全知识竞赛，雅思流利说等软件it资讯，欢迎关注腾兴网。1
CV、NLP、数据控掘推荐、量化海的那边- AI算法自然语言处理人工智能
下面是对CV（计算机视觉）、NLP（自然语言处理）、数据挖掘推荐和量化的简要概述及其应用领域的介绍：1.CV（计算机视觉，ComputerVision）定义：计算机视觉是一门让计算机能够从图像或视频中提取有用信息，并做出决策的学科。它通过模拟人类的视觉系统来识别、处理和理解视觉信息。主要任务：图像分类：识别图像中的物体并分类，比如猫、狗、车等。目标检测：在图像或视频中定位并识别多个对象，如人脸检测
多模态Transformer之文本与图像联合建模 - Transformer教程 shandianfk_com ChatGPT Transformer transformer 深度学习人工智能
大家好，今天我们来聊聊一个既前沿又有趣的话题——多模态Transformer，特别是文本与图像的联合建模。对于很多小伙伴来说，Transformer这个词已经不陌生了，但它不仅仅应用于自然语言处理，还能在图像处理、甚至是多模态数据的处理上大显身手。接下来，我会带大家深入了解什么是多模态Transformer，以及它是如何实现文本与图像的联合建模的。Transformer简介首先，我们简单回顾一下T
Matlab2024a安装教程是阿宇呢信息可视化开发语言
MATLAB是一款商业数学软件，用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境，主要包括MATLAB和Simulink两大部分，可以进行矩阵运算、绘制函数和数据、实现算法、创建用户界面、连接其他编程语言的程序等，主要应用于工程计算、控制设计、信号处理与通讯、图像处理、信号检测、金融建模设计与分析等领域。1.解压安装包：①鼠标右击【MATLABR2024a(64bit)
Python计算机视觉编程第三章图像到图像的映射一只小小程序猿计算机视觉 python opencv
目录单应性变换直接线性变换算法仿射变换图像扭曲图像中的图像分段仿射扭曲创建全景图RANSAC拼接图像单应性变换单应性变换是将一个平面内的点映射到另一个平面内的二维投影变换。在这里，平面是指图像或者三维中的平面表面。单应性变换具有很强的实用性，比如图像配准、图像纠正和纹理扭曲，以及创建全景图像。单应性变换本质上是一种二维到二维的映射，可以将一个平面内的点映射到另一个平面上的对应点。代码如下：impo
DIODE：超高分辨率室内室外数据集（猫脸码客第186期）猫脸码客: catCode2024 开源数据集猫脸码客开源数据集超高分辨率室内室外数据集
亲爱的读者们，您是否在寻找某个特定的数据集，用于研究或项目实践？欢迎您在评论区留言，或者通过公众号私信告诉我，您想要的数据集的类型主题。小编会竭尽全力为您寻找，并在找到后第一时间与您分享。在计算机视觉和深度学习领域，深度信息作为三维空间感知的重要组成部分，对于实现高级视觉任务如场景理解、机器人导航、增强现实等具有至关重要的作用。然而，获取准确且密集的深度数据一直是一个挑战，尤其是在同时涵盖室内和室
深度学习入门篇：PyTorch实现手写数字识别 AI_Guru人工智能深度学习 pytorch 人工智能
深度学习作为机器学习的一个分支，近年来在图像识别、自然语言处理等领域取得了显著的成就。在众多的深度学习框架中，PyTorch以其动态计算图、易用性强和灵活度高等特点，受到了广泛的喜爱。本篇文章将带领大家使用PyTorch框架，实现一个手写数字识别的基础模型。手写数字识别简介手写数字识别是计算机视觉领域的一个经典问题，目的是让计算机能够识别并理解手写数字图像。这个问题通常作为深度学习入门的练习，因为
图像处理的作用（6幅图诗）静月园
静月园著2020年1月️4日1自然力出现的图形画面，即无序，又有形。奇妙令人联想无限。好象理石花纹，又类似草木树植。2为何要如此色彩？好奇怪哦！自然的物态鬼斧神工。3孩童们信手涂鸦，但是脑控制了手的动作，所绘画的物体形状代表了孩子们对环境人物的所看，所听，所理解的形状。脑的心理活动影像，被转换成手的动作输出到笔尖的移动动作上，于是我们看到了简单的结构形状图。而对于我们的写作者来说，我们的作家脑内有
OpenCV高阶操作富士达幸运星 opencv 人工智能计算机视觉
在图像处理与计算机视觉领域，OpenCV（OpenSourceComputerVisionLibrary）无疑是最为强大且广泛使用的工具之一。从基础的图像读取、1.图片的上下，采样下采样（Downsampling）下采样通常用于减小图像的尺寸，从而减少图像中的像素数。这个过程可以通过多种方法实现，但最常见的是通过图像金字塔中的pyrDown函数（在OpenCV中）或其他类似的滤波器（如平均池化、最
深入掌握大模型精髓：《实战AI大模型》带你全面理解大模型开发！努力的光头强人工智能 langchain prompt transformer 深度学习
今天，人工智能技术的快速发展和广泛应用已经引起了大众的关注和兴趣，它不仅成为技术发展的核心驱动力，更是推动着社会生活的全方位变革。特别是作为AI重要分支的深度学习，通过不断刷新的表现力已引领并定义了一场科技革命。大型深度学习模型（简称AI大模型）以其强大的表征能力和卓越的性能，在自然语言处理、计算机视觉、推荐系统等领域均取得了突破性的进展。尤其随着AI大模型的广泛应用，无数领域因此受益。AI大模型
opencv 之实战项目识别银行卡上的数字 SEVEN-YEARS opencv 计算机视觉人工智能
OpenCV之实战项目：识别银行卡上的数字引言在日常生活中，银行卡的识别是一个常见的需求，特别是在金融领域。本实战项目旨在使用OpenCV库来识别银行卡上的数字。我们将通过模板匹配的方法，结合图像处理技术，来准确识别银行卡上的数字序列。项目准备本项目需要安装Python和OpenCV库。确保已经安装了必要的库，并准备好银行卡图像和数字模板图像。实验素材定义函数importcv2defsort_co
【图像压缩】奇异值分解SVD灰色图像压缩（可设置压缩比）【含Matlab源码 4358期】 Matlab武动乾坤 Matlab图像处理（进阶版）matlab
✅博主简介：热爱科研的Matlab仿真开发者，修心和技术同步精进，Matlab项目合作可私信。个人主页：海神之光代码获取方式：海神之光Matlab王者学习之路—代码获取方式⛳️座右铭：行百里者，半于九十。更多Matlab仿真内容点击Matlab图像处理（进阶版）路径规划（Matlab）神经网络预测与分类（Matlab）优化求解（Matlab）语音处理（Matlab）信号处理（Matlab）车间调度
计算机视觉—照相机（下） zidea
封面焦距(FieldofView)同一位置相机用不同焦距，28mmFieldofView就变小，85mm时候的Fieldofview也就是只有28度视野，每一个物体在通常尺寸的胶片上像素也就是越多，chromaticAberration焦距和是波长相关，不同颜色光聚焦在不同位置。这种现象在物体边缘尤为明显。颜色颜色说简单也简单，说复杂也复杂，我们在高中物理已经知道可见光是电磁波，不同颜色对应不同波
Python OpenCV精讲系列 - 高级图像处理技术（五）极客代码 Python OpenCV精讲 python opencv 图像处理开发语言人工智能计算机视觉
⚡️⚡️专栏：PythonOpenCV精讲⚡️⚡️本专栏聚焦于Python结合OpenCV库进行计算机视觉开发的专业教程。通过系统化的课程设计，从基础概念入手，逐步深入到图像处理、特征检测、物体识别等多个领域。适合希望在计算机视觉方向上建立坚实基础的技术人员及研究者。每一课不仅包含理论讲解，更有实战代码示例，助力读者快速将所学应用于实际项目中，提升解决复杂视觉问题的能力。无论是入门者还是寻求技能进
K-means 算法的介绍与应用小魏冬琅 matlab 算法 kmeans 机器学习
目录引言K-means算法的基本原理表格总结：K-means算法的主要步骤K-means算法的MATLAB实现优化方法与改进K-means算法的应用领域表格总结：K-means算法的主要应用领域结论引言K-means算法是一种经典的基于距离的聚类算法，在数据挖掘、模式识别、图像处理等多个领域中得到了广泛应用。其核心思想是将相似的数据对象聚类到同一个簇中，而使得簇内对象的相似度最大、簇间的相似度最小
计算机视觉中的数据增强方法总结 CV技术指南(公众号) CV技术总结计算机视觉深度学习卷积神经网络
前言：在计算机视觉方向，数据增强的本质是人为地引入人视觉上的先验知识，可以很好地提升模型的性能，目前基本成为模型的标配。最近几年逐渐出了很多新的数据增强方法，在本文将对数据增强做一个总结。本文介绍了数据增强的作用，数据增强的分类，数据增强的常用方法，一些特殊的方法，如Cutout，RandomErasing，Mixup，Hide-and-Seek，CutMix，GridMask，FenceMask
计算机视觉中，什么是Hide-and-Seek？ Wils0nEdwards 计算机视觉人工智能
是的，Hide-and-Seek技术主要是在弱监督学习领域中使用的，它的核心思想是通过随机遮掩输入图像的一部分，强迫模型学习更全面的特征，而不是仅仅依赖显著的局部信息。由于弱监督场景下的监督信号有限，例如只有少量的点标注、粗略标注或没有任何标注，模型容易过度依赖于图像中最显著的部分，而忽略其他信息。这种现象会导致模型只关注容易识别的局部特征，而无法理解物体的整体结构或捕捉更多的背景信息。1.Hid
基于VGG的猫狗识别卑微小鹿 tensorflow tensorflow
由于猫和狗的数据在这里，所以就做了一下分类的神经网络1、首先进行图像处理：importcsvimportglobimportosimportrandomos.environ['TF_CPP_MIN_LOG_LEVEL']='2'importtensorflowastffromtensorflowimportkerasfromtensorflow.kerasimportlayersimportnum
MATLAB车牌定位和识别系统清风明月来几时图像算法处理 matlab 开发语言
有很多方法可以实现MATLAB车牌的定位和识别系统。以下是一种可能的实现步骤：车牌定位：使用图像处理技术（如边缘检测、区域生长或颜色分割）来检测图像中的车牌区域。使用形态学操作来排除不符合车牌形状的区域。对车牌区域进行裁剪或调整大小，以便后续的识别。车牌识别：将车牌图像转换为灰度图像。使用图像处理技术（如二值化、滤波或增强）来减少噪音并突出字符。使用字符分割算法将车牌中的字符分开。使用特征提取方法
MATLAB车牌识别系统清风明月来几时图像算法处理 matlab 开发语言
MATLAB车牌识别系统是一个基于MATLAB开发的用于识别和提取车牌信息的系统。该系统使用图像处理和机器学习算法来实现车牌的定位和字符识别。以下是一个基本的MATLAB车牌识别系统的工作流程：图像预处理：首先，将输入的图像进行预处理，包括灰度化、高斯平滑、边缘检测等操作，以提高后续的车牌定位和字符识别的准确性。车牌定位：在预处理后的图像中，使用形态学运算和边缘检测算法来寻找车牌的位置。这可以通过
直方图匹配（Histogram Matching）姜太公钓鲸233 计算机视觉人工智能机器学习
直方图匹配（HistogramMatching），也被称为直方图规定化（HistogramSpecification）或直方图修正（HistogramEqualization），是一种图像处理技术，用于调整图像的直方图，以使其与某个目标直方图相匹配。目标直方图通常是用户定义的或者是希望获得的期望分布。直方图匹配的目标是改变图像的像素值分布，从而使其在视觉上更接近目标直方图。这对于图像增强、风格迁移
项目中枚举与注解的结合使用飞翔的马甲 java enum annotation
前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。一、枚举 1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。
【Scala十七】Scala核心十一：下划线_的用法 bit1129 scala
下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义 1. 在高阶函数中使用 scala> val list = List(-3,8,7,9) list: List[Int] = List(-3, 8, 7, 9) scala> list.filter(_ > 7) r
web缓存基础：术语、http报头和缓存策略 dalan_123 Web
对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
crontab 问题周凡杨 linux crontab unix
一： 0481-079 Reached a symbol that is not expected. 背景： */5 * * * * /usr/IBMIHS/rsync.sh
让tomcat支持2级域名共享session g21121 session
tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。打开tomcat下conf下context.xml文件找到Context标签,修改为如下内容如果你的域名是www.test.com <Context sessionCookiePath="/path&q
web报表工具FineReport常用函数的用法总结（数学和三角函数）老A不折腾 Web finereport 总结
ABS ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 Number:需要求出绝对值的任意实数。示例: ABS(-1.5)等于1.5。 ABS(0)等于0。 ABS(2.5)等于2.5。 ACOS ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 Number:需要返回角
linux 启动java进程 sh文件墙头上一根草 linux shell jar
#!/bin/bash #初始化服务器的进程PId变量 user_pid=0; robot_pid=0; loadlort_pid=0; gateway_pid=0; ######### #检查相关服务器是否启动成功 #说明： #使用JDK自带的JPS命令及grep命令组合，准确查找pid #jps 加 l 参数，表示显示java的完整包路径 #使用awk，分割出pid
我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory aijuans Spring 3 系列
如何使用ApplicationContext替换BeanFactory？ package onlyfun.caterpillar.device; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import
Linux 内存使用方法详细解析 annan211 linux 内存 Linux内存解析
来源 http://blog.jobbole.com/45748/ 我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。 Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
数据库的单表查询常用命令及使用方法(-) 百合不是茶 oracle 函数单表查询
创建数据库; --建表 create table bloguser(username varchar2(20),userage number(10),usersex char(2)); 创建bloguser表,里面有三个字段 &nbs
多线程基础知识 bijian1013 java 多线程 thread java多线程
一．进程和线程进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 “多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。线程：是进程内部单一的一个顺序控制流。线程和进程 a. 每个进程都有独立的
fastjson简单使用实例 bijian1013 fastjson
一.简介阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：
【RPC框架Burlap】Spring集成Burlap bit1129 spring
Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成
【Mahout一】基于Mahout 命令参数含义 bit1129 Mahout
1. mahout seqdirectory $ mahout seqdirectory --input (-i) input Path to job input directory(原始文本文件). --output (-o) output The directory pathna
linux使用flock文件锁解决脚本重复执行问题 ronin47 linux lock　重复执行
linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。例如： <? // test .php
java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 bylijinnan java
public class OcuppyMoreThanHalf { /** * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 * two solutions: * 1.O(n) * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性 * 2.O(nlogn) * 排序。中间
linux 系统相关命令 candiio linux
系统参数 cat /proc/cpuinfo cpu相关参数 cat /proc/meminfo 内存相关参数 cat /proc/loadavg 负载情况性能参数 1）top M：按内存使用排序 P：按CPU占用排序 1：显示各CPU的使用情况 k：kill进程 o：更多排序规则回车：刷新数据 2）ulimit ulimit -a：显示本用户的系统限制参
[经营与资产]保持独立性和稳定性对于软件开发的重要意义 comsci 软件开发
一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中那么软件开发者原有的设计思想和开发路线
在CentOS5.5上编译OpenJDK6 Cwind linux OpenJDK
几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。 0. OpenJDK介绍 OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
java乱码问题 dashuaifu java乱码问题 js中文乱码
swfupload上传文件参数值为中文传递到后台接收中文乱码在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 然后在servlet中String t
cygwin很多命令显示command not found的解决办法 dcj3sjt126com cygwin
cygwin很多命令显示command not found的解决办法修改cygwin.BAT文件如下 @echo off D: set CYGWIN=tty notitle glob set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
[介绍]从 Yii 1.1 升级 dcj3sjt126com PHP yii2
2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
Linux SSH免登录配置总结 eksliang ssh-keygen Linux SSH免登录认证 Linux SSH互信
转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。生成公钥与私钥有两种加密方式，第一种是
手势滑动销毁Activity gundumw100 android
老是效仿ios，做android的真悲催！有需求：需要手势滑动销毁一个Activity 怎么办尼？自己写？不用~，网上先问一下百度。结果： http://blog.csdn.net/xiaanming/article/details/20934541 首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
JavaScript变换表格边框颜色 ini JavaScript html Web html5 css
效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： <html> <head> <meta charset="utf-8"> <title>表格边框变换颜色代码-何问起</title> </head> <body&
Kafka Rest : Confluent kane_xie kafka REST confluent
最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。环境声明：Ubu
Calender不是单例 men4661273 单例 Calender
在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。测试： Calendar c1 =
线程内存和主内存之间联系 qifeifei java thread
1， java多线程共享主内存中变量的时候，一共会经过几个阶段， lock:将主内存中的变量锁定，为一个线程所独占。 unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。 read:将主内存中的变量值读到工作内存当中。 load:将read读取的值保存到工作内存中的变量副本中。
schedule和scheduleAtFixedRate tangqi609567707 java timer schedule
原文地址：http://blog.csdn.net/weidan1121/article/details/527307 import java.util.Timer;import java.util.TimerTask;import java.util.Date; /** * @author vincent */public class TimerTest {
erlang 部署 wudixiaotie erlang
1.如果在启动节点的时候报这个错： {"init terminating in do_boot",{'cannot load',elf_format,get_files}} 则需要在reltool.config中加入 {app, hipe, [{incl_cond, exclude}]}, 2.当generate时，遇到： ERROR

颜色、光照、材料属性（openGL）

你可能感兴趣的:(计算机图形学,图像处理,计算机视觉)