C++实现数字媒体三维图像变换

必备环境

  • glut.h 头文件
  • glut32.lib 对象文件库
  • glut32.dll 动态连接库

程序说明

C++实现了用glut画物体对象的功能。并附带放大缩小,旋转,平移和在不同视角观察的功能。

操作说明

重要说明

define MAX_MODEL 20

程序最多支持创建20个对象,如需要创建更多的对象,请调高这个参数

define MAX_MODEL_NUM 4000

程序最多支持对象拥有4000个点和4000个面,如需要读入更复杂的对象,请调高这个参数

指令说明

  • reset :把变换矩阵重置为单位矩阵
  • scale :把变换矩阵进行相应的放大缩小
  • rotate : 把变换矩阵进行相应的旋转
  • translate : 把变换矩阵进行相应的平移
  • object : 根据变换矩阵创建一个对象
  • obverser : 设置摄像机的位置和对焦的焦点
  • viewport : 设置投影区域的变换矩阵
  • display : 显示所有的对象
  • clearData :清空所有的对象数据
  • clearScreen :清空屏幕
  • end : 结束程序

函数说明

void initial()

输出程序信息,并提示如何输入

void scale(float sx, float sy, float sz)

改变变换矩阵进行相应放大缩小

void rotate(float Xdegree, float Ydegree, float Zdegree)

改变变换矩阵进行相应的角度旋转

void translate(float tx, float ty, float tz)

改变变换矩阵进行相应的平移变换

void reset()

重置变换矩阵为单位矩阵

void viewport(float vxl, float vxr, float vyb, float vyt)

根据参数设置投影区域的变化矩阵WVM

void clearData()

清除全部对象的数据

void clearScreen()

清空整个视窗屏幕

void displayFunc(void)

视窗初始化和恢复的时候调用的函数

void ReadInput(bool& IsExit)

从标准输入输出中读取指令

void Matrix_Multi_Matrix(float a[][CTM_SIZE], float b[][CTM_SIZE], float c[][CTM_SIZE])

矩阵乘法,c = a * b

template void update_Matrix(T resource[][MTM_SIZE], T destination[][MTM_SIZE])

更新矩阵

void drawDot(int x, int y)

在视窗坐标系中绘制一个点

void DrawLine(int x0, int x1, int y0, int y1)

各个方向均可使用,绘制一条直线

void drawLine0(int x0, int x1, int y0, int y1)

绘制直线函数,决定调用哪一个直线函数

void drawLine1(int x0, int x1, int y0, int y1, bool xy_interchange)

绘制一号区域和五号区域的直线

void drawLine2(int x0, int x1, int y0, int y1, bool xy_interchange)

绘制二号区域和六号区域的直线

void drawLine3(int x0, int x1, int y0, int y1, bool xy_interchange)

绘制三号区域和七号区域的直线

void drawLine4(int x0, int x1, int y0, int y1, bool xy_interchange)

绘制四号区域和八号区域的直线

void ReadFile(bool& IsExit)

从文件中批量读取指令

void redraw()

重绘整个视窗,恢复显示的时候调用

template void printMatrix(T matrix, int row, int col, string str)*

打印矩阵函数,debug时使用

void object(string objectname)

创建从文件中一个对象并存储

void observer(float PX, float PY, float PZ, float CX, float CY, float CZ, float Tilt, float zNear, float zFar, float hFOV);

设置摄像机的位置和观察的焦点

void Eye_Transform(float PX, float PY, float PZ, float CX, float CY, float CZ, float Tilt)

设置从World_Space到Eye_Space的变化矩阵EM

void Project_Transform(float zNear, float zFar, float hFOV)

设置从Eye_Space到Project_Space的变化矩阵PM

void Cross_Multi(float destination[], float a[], float b[])

三维向量的叉乘运算

void UnitizeVector(float vector[])

单位化一个向量

程序截图

完整代码

#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <iomanip>
#include "glut.h"
using namespace std; #pragma region Data typedef float wvmtype;
#define MTM_SIZE 4
#define PI 3.14159265
#define MAX_MODEL 20
#define MAX_MODEL_NUM 4000
#define MAX_LINE 100 struct ASCModel_struct{
int num_vertex;
int num_face;
float vertex[MAX_MODEL_NUM][MTM_SIZE];
int face[MAX_MODEL_NUM][MTM_SIZE];
}ASCModel[MAX_MODEL]; struct line_data{
int x, y;
line_data* next;
line_data(int _x = -1, int _y = -1){
x = _x;
y = _y;
next = NULL;
}
}; struct line_structure{
int x0, x1, y0, y1;
}; float ModelingTransformMatrix[MTM_SIZE][MTM_SIZE]
= { { 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 } };
float Eye_Matirx[MTM_SIZE][MTM_SIZE];
float Project_Matrix[MTM_SIZE][MTM_SIZE];
float WzNear, WzFar, WhFOV;
wvmtype WVM[MTM_SIZE][MTM_SIZE]; line_structure line[MAX_LINE];
line_data line_start[MAX_LINE];
line_data* lcp;
line_data* temp;
int num_ASCModel = 0;
int num_line = 0; const float default_r = 0.0;
const float default_g = 0.0;
const float default_b = 0.0;
float r = 0.0;
float g = 1.0;
float b = 1.0;
const float alpha = 0.0; bool IsExit = false;
string Inputfile;
int height, width; #pragma endregion #pragma region FunctionDefinition void initial();
void displayFunc(void);
void ReadFile(bool& IsExit);
template<class T> void printMatrix(T* matrix, int row, int col, string str);
void Matrix_Multi_Matrix(float a[][MTM_SIZE], float b[][MTM_SIZE], float c[][MTM_SIZE]);
template<class T> void update_Matrix(T resource[][MTM_SIZE], T destination[][MTM_SIZE]);
void redraw();
void clearData();
void clearScreen();
void object(string objectname);
void reset();
void scale(float sx, float sy, float sz);
void rotate(float Xdegree, float Ydegree, float Zdegree);
void translate(float tx, float ty, float tz);
void observer(float PX, float PY, float PZ, float CX, float CY, float CZ,
float Tilt, float zNear, float zFar, float hFOV);
void Eye_Transform(float PX, float PY, float PZ, float CX, float CY, float CZ, float Tilt);
void Project_Transform(float zNear, float zFar, float hFOV);
void viewport(float vxl, float vxr, float vyb, float vyt);
void display();
void Cross_Multi(float destination[], float a[], float b[]);
void UnitizeVector(float vector[]);
void drawDot(int x, int y);
void DrawLine(int x0, int x1, int y0, int y1);
void drawLine0(int x0, int x1, int y0, int y1);
void drawLine1(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine2(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine3(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine4(int x0, int x1, int y0, int y1, bool xy_interchange); #pragma endregion #pragma region FunctionImplement // Print a Matrix
template<class T>
void printMatrix(T* matrix, int row, int col, string str){
cout << endl;
cout << "Matrix <<< " << str << " >>> = " << endl;
for(int i = 0; i < row; i++){
cout << "\t[";
for(int j = 0; j < col; j++){
cout.setf(ios::fixed);
cout << setw(5) << setprecision(2) << matrix[i][j] << ", ";
}
cout << " ]" << endl;
}
} // Two 4 * 4 Matrixs Multiplication
void Matrix_Multi_Matrix(float a[][MTM_SIZE], float b[][MTM_SIZE], float c[][MTM_SIZE]){
float temp[MTM_SIZE][MTM_SIZE]; float multi_sum = 0;
for(int i = 0; i < MTM_SIZE; i++){
for(int j = 0; j < MTM_SIZE; j++){
multi_sum = 0;
for(int k = 0; k < MTM_SIZE; k++){
multi_sum += b[k][j] * a[i][k];
}
temp[i][j] = multi_sum;
}
} // Fix to avoid input of Matrix_A is input of Matrix C
for(int i = 0; i < MTM_SIZE; i++){
for(int j = 0; j < MTM_SIZE; j++){
c[i][j] = temp[i][j];
}
}
} // update the current_matrix
template<class T>
void update_Matrix(T resource[][MTM_SIZE], T destination[][MTM_SIZE]){
for(int i = 0; i < MTM_SIZE; i++){
for(int j = 0; j < MTM_SIZE; j++){
destination[i][j] = resource[i][j];
}
}
} // draw a dot at location with integer coordinates (x,y)
void drawDot(int x, int y){
glBegin(GL_POINTS);
// set the color of dot
glColor3f(r, g, b);
// invert height because the opengl origin is at top-left instead of bottom-left
//glVertex2i(x, height - y);
glVertex2i(x, y); glEnd();
} // Draw a line in any direction
void DrawLine(int x0, int x1, int y0, int y1) {
int max_dis = abs(x1 - x0);
max_dis = max_dis > abs(y0 - y1) ? max_dis : abs(y0 - y1);
//lcp = temp;
if(max_dis != 0) {
for(int i = 0; i < max_dis; ++i) {
int new_p_x = x0 + i * (x1 - x0) / max_dis;
int new_p_y = y0 + i * (y1 - y0) / max_dis;
drawDot(new_p_x, new_p_y);
//lcp->next = new line_data(new_p_x, new_p_y);
//lcp = lcp->next;
}
}
glFlush();
return;
} // Judge to call which drawLine function to draw a line
void drawLine0(int x0, int x1, int y0, int y1){
int dx = x1 - x0;
int dy = y1 - y0;
if(dx >= 0 && dy > 0 && abs(dx) < abs(dy)){
drawLine1(x0, x1, y0, y1, false);
}
else if(dx > 0 && dy >= 0 && abs(dx) >= abs(dy)){
drawLine2(x0, x1, y0, y1, false);
}
else if(dx > 0 && dy <= 0 && abs(dx) > abs(dy)){
drawLine3(x0, x1, y0, y1, false);
}
else if(dx >= 0 && dy < 0 && abs(dx) <= abs(dy)){
drawLine4(x0, x1, y0, y1, false);
}
else if(dx <= 0 && dy < 0 && abs(dx) < abs(dy)){
drawLine1(x0, x1, y0, y1, true);
}
else if(dx < 0 && dy <= 0 && abs(dx) >= abs(dy)){
drawLine2(x0, x1, y0, y1, true);
}
else if(dx < 0 && dy >= 0 && abs(dx) > abs(dy)){
drawLine3(x0, x1, y0, y1, true);
}
else{
drawLine4(x0, x1, y0, y1, true);
}
//num_line++;
} // Draw line for dx>0 and dy>0
void drawLine1(int x0, int x1, int y0, int y1, bool xy_interchange){
if(xy_interchange){
int change = x0; x0 = x1; x1 = change;
change = y0; y0 = y1; y1 = change;
}
int x = x1;
int y = y1;
int a = y1 - y0;
int b = -(x1 - x0);
int d = -a - 2 * b;
int IncE = -2 * b;
int IncNE = -2 * a - 2 * b;
//line_start[num_line] = line_data(x, y);
//lcp = &line_start[num_line];
while(y >= y0){
lcp->next = new line_data(x, y);
lcp = lcp->next;
drawDot(x, y);
if(d <= 0){
y--;
d += IncE;
}
else{
x--;
y--;
d += IncNE;
}
}
glFlush();
return;
} // Draw line for dx>0 and dy<0
void drawLine2(int x0, int x1, int y0, int y1, bool xy_interchange){
if(xy_interchange){
int change = x0; x0 = x1; x1 = change;
change = y0; y0 = y1; y1 = change;
}
int x = x0;
int y = y0;
int a = y1 - y0;
int b = -(x1 - x0);
int d = 2 * a + b;
int IncE = 2 * a;
int IncNE = 2 * a + 2 * b;
//line_start[num_line] = line_data(x, y);
//lcp = &line_start[num_line];
while(x <= x1){
lcp->next = new line_data(x, y);
lcp = lcp->next;
drawDot(x, y);
if(d <= 0){
x++;
d += IncE;
}
else{
x++;
y++;
d += IncNE;
}
}
glFlush();
return;
} // Draw line for dx<0 and dy>0
void drawLine3(int x0, int x1, int y0, int y1, bool xy_interchange){
if(xy_interchange){
int change = x0; x0 = x1; x1 = change;
change = y0; y0 = y1; y1 = change;
}
int x = x0;
int y = y0;
int a = y0 - y1;
int b = -(x1 - x0);
int d = 2 * a + b;
int IncE = 2 * a;
int IncNE = 2 * a + 2 * b;
//line_start[num_line] = line_data(x, y);
//lcp = &line_start[num_line];
while(x <= x1){
lcp->next = new line_data(x, y);
lcp = lcp->next;
drawDot(x, y);
if(d <= 0){
x++;
d += IncE;
}
else{
x++;
y--;
d += IncNE;
}
}
glFlush();
return;
} // Draw line for dx<0 and dy<0
void drawLine4(int x0, int x1, int y0, int y1, bool xy_interchange){
if(xy_interchange){
int change = x0; x0 = x1; x1 = change;
change = y0; y0 = y1; y1 = change;
}
int x = x0;
int y = y0;
int a = y1 - y0;
int b = -(x1 - x0);
int d = a - 2 * b;
int IncE = -2 * b;
int IncNE = 2 * a - 2 * b;
//line_start[num_line] = line_data(x, y);
//lcp = &line_start[num_line];
while(y >= y1){
lcp->next = new line_data(x, y);
lcp = lcp->next;
drawDot(x, y);
if(d <= 0){
y--;
d += IncE;
}
else{
x++;
y--;
d += IncNE;
}
}
glFlush();
return;
} // Reset the ModelingTransformMatrix to default
void reset(){
for(int i = 0; i < MTM_SIZE; i++){
for(int j = 0; j < MTM_SIZE; j++){
if(i == j)
ModelingTransformMatrix[i][j] = 1.0;
else
ModelingTransformMatrix[i][j] = 0;
}
}
printMatrix(ModelingTransformMatrix, 4, 4, "ModelingTransformMatrix");
} // Multiply ModelingTransformMatrix by scaling matrix
void scale(float sx, float sy, float sz){
float scaling_matrix[MTM_SIZE][MTM_SIZE]
= { { sx, 0, 0, 0 },
{ 0, sy, 0, 0 },
{ 0, 0, sz, 0 },
{ 0, 0, 0, 1 } }; float new_matrix[MTM_SIZE][MTM_SIZE]; Matrix_Multi_Matrix(scaling_matrix, ModelingTransformMatrix, new_matrix); update_Matrix(new_matrix, ModelingTransformMatrix); printMatrix(ModelingTransformMatrix, 4, 4, "ModelingTransformMatrix");
} // Multiply ModelingTransformMatrix by rotate matrix
void rotate(float Xdegree, float Ydegree, float Zdegree){
float new_matrix[MTM_SIZE][MTM_SIZE]; if(Xdegree != 0){
float rad = Xdegree * PI / 180.0;
float rotation_matrix[MTM_SIZE][MTM_SIZE]
= { { 1, 0, 0, 0 },
{ 0, cos(rad), -sin(rad), 0 },
{ 0, sin(rad), cos(rad), 0 },
{ 0, 0, 0, 1 } }; Matrix_Multi_Matrix(rotation_matrix, ModelingTransformMatrix, new_matrix);
update_Matrix(new_matrix, ModelingTransformMatrix);
printMatrix(ModelingTransformMatrix, 4, 4, "ModelingTransformMatrix");
} if(Ydegree != 0){
float rad = Ydegree * PI / 180.0;
float rotation_matrix[MTM_SIZE][MTM_SIZE]
= { { cos(rad), 0, sin(rad), 0 },
{ 0, 1, 0, 0 },
{ -sin(rad), 0, cos(rad), 0 },
{ 0, 0, 0, 1 } }; Matrix_Multi_Matrix(rotation_matrix, ModelingTransformMatrix, new_matrix);
update_Matrix(new_matrix, ModelingTransformMatrix);
printMatrix(ModelingTransformMatrix, 4, 4, "ModelingTransformMatrix");
} if(Zdegree != 0){
float rad = Zdegree * PI / 180.0;
float rotation_matrix[MTM_SIZE][MTM_SIZE]
= { { cos(rad), -sin(rad), 0, 0 },
{ sin(rad), cos(rad), 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 } }; Matrix_Multi_Matrix(rotation_matrix, ModelingTransformMatrix, new_matrix);
update_Matrix(new_matrix, ModelingTransformMatrix);
printMatrix(ModelingTransformMatrix, 4, 4, "ModelingTransformMatrix");
}
} // Multiply ModelingTransformMatrix by translate matrix
void translate(float tx, float ty, float tz){
float translate_matrix[MTM_SIZE][MTM_SIZE]
= { { 1, 0, 0, tx },
{ 0, 1, 0, ty },
{ 0, 0, 1, tz },
{ 0, 0, 0, 1 } }; float new_matrix[MTM_SIZE][MTM_SIZE]; Matrix_Multi_Matrix(translate_matrix, ModelingTransformMatrix, new_matrix); update_Matrix(new_matrix, ModelingTransformMatrix); printMatrix(ModelingTransformMatrix, 4, 4, "ModelingTransformMatrix");
} // Read a ASCModel from file
void object(string objectname){
ifstream fin(objectname);
if(fin.is_open()){
cout << "\topen the " << objectname << " successfully" << endl;
}
else{
cout << "\tCan't open the " << objectname << endl;
return;
}
// get number of vertex and face first
fin >> ASCModel[num_ASCModel].num_vertex;
fin >> ASCModel[num_ASCModel].num_face;
// read vertex one by one
for(int i = 0; i<ASCModel[num_ASCModel].num_vertex; i++) {
for(int j = 0; j < 3; j++){
fin >> ASCModel[num_ASCModel].vertex[i][j];
}
ASCModel[num_ASCModel].vertex[i][3] = 1;//fix to multiplication
} int n;
// read face one by one
for(int i = 0; i<ASCModel[num_ASCModel].num_face; i++) {
fin >> n;
//if(i < 20) cout << "n = " << n << " , ";
for(int j = 0; j < n; j++){
fin >> ASCModel[num_ASCModel].face[i][j];
//if(i < 20) cout << ASCModel[num_ASCModel].face[i][j] << " ";
}
if(n < MTM_SIZE)
for(int j = n; j < MTM_SIZE; j++)
ASCModel[num_ASCModel].face[i][j] = -1;
//if(i < 20) cout << endl;
} // Convert Object-Space to World-Space
float multi_sum = 0;
float WorldSpace[MTM_SIZE];
for(int i = 0; i < ASCModel[num_ASCModel].num_vertex; i++){
for(int j = 0; j < MTM_SIZE; j++){
multi_sum = 0;
for(int k = 0; k < MTM_SIZE; k++){
multi_sum += ASCModel[num_ASCModel].vertex[i][k]
* ModelingTransformMatrix[j][k];
}
WorldSpace[j] = multi_sum;
}
// Update(cover) the Object-Space
for(int j = 0; j < MTM_SIZE; j++){
ASCModel[num_ASCModel].vertex[i][j] = WorldSpace[j];
}
} num_ASCModel++;
} // Set the observer
void observer(float PX, float PY, float PZ, float CX, float CY, float CZ,
float Tilt, float zNear, float zFar, float hFOV){ Eye_Transform(PX, PY, PZ, CX, CY, CZ, Tilt); Project_Transform(zNear, zFar, hFOV); WzNear = zNear;
WzFar = zFar;
WhFOV = hFOV;
} // Set up Eye_Transform_Matrix
void Eye_Transform(float PX, float PY, float PZ, float CX, float CY, float CZ, float Tilt){
float Eye_Translation_Matrix[MTM_SIZE][MTM_SIZE]
= { { 1, 0, 0, -PX },
{ 0, 1, 0, -PY },
{ 0, 0, 1, -PZ },
{ 0, 0, 0, 1 } };
printMatrix(Eye_Translation_Matrix, 4, 4, "Eye_Translation_Matrix"); float Eye_Mirror_Matrix[MTM_SIZE][MTM_SIZE]
= { { -1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 } };
printMatrix(Eye_Mirror_Matrix, 4, 4, "Eye_Mirror_Matrix"); float TiltDegree = Tilt * PI / 180.0;
float Eye_Tilt_Matrix[MTM_SIZE][MTM_SIZE]
= { { cos(TiltDegree), sin(TiltDegree), 0, 0 },
{ -sin(TiltDegree), cos(TiltDegree), 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 } };
printMatrix(Eye_Tilt_Matrix, 4, 4, "Eye_Tilt_Matrix"); float view_vector[3] = { CX - PX, CY - PY, CZ - PZ };
float top_vector[3] = { 0, 1, 0 }; float vector3[3];
memcpy(vector3, view_vector, sizeof(view_vector));
UnitizeVector(vector3);
float vector1[3];
Cross_Multi(vector1, top_vector, view_vector);
UnitizeVector(vector1);
float vector2[3];
Cross_Multi(vector2, vector3, vector1);
UnitizeVector(vector2); float GRM[MTM_SIZE][MTM_SIZE]
= { { vector1[0], vector1[1], vector1[2], 0 },
{ vector2[0], vector2[1], vector2[2], 0 },
{ vector3[0], vector3[1], vector3[2], 0 },
{ 0, 0, 0, 1 } };
printMatrix(GRM, 4, 4, "GRM"); float new_Eye_Matrix[MTM_SIZE][MTM_SIZE]
= { { 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 } };
Matrix_Multi_Matrix(Eye_Translation_Matrix, new_Eye_Matrix, new_Eye_Matrix);
Matrix_Multi_Matrix(GRM, new_Eye_Matrix, new_Eye_Matrix);
Matrix_Multi_Matrix(Eye_Mirror_Matrix, new_Eye_Matrix, new_Eye_Matrix);
Matrix_Multi_Matrix(Eye_Tilt_Matrix, new_Eye_Matrix, new_Eye_Matrix);
update_Matrix(new_Eye_Matrix, Eye_Matirx);
printMatrix(Eye_Matirx, 4, 4, "Eye_Matrix");
} // Set up Project_Transform_Matrix
void Project_Transform(float zNear, float zFar, float hFOV){
float PM4_3 = tan(hFOV * PI / 180.0);
float PM3_3 = (zFar / (zFar - zNear)) * PM4_3;
float PM3_4 = ((zNear * zFar) / (zNear - zFar)) * PM4_3;
float new_Project_Matrix[MTM_SIZE][MTM_SIZE]
= { { 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, PM3_3, PM3_4 },
{ 0, 0, PM4_3, 0 } };
update_Matrix(new_Project_Matrix, Project_Matrix);
} // Multiplication Cross for 3-dimensionality
void Cross_Multi(float destination[], float a[], float b[]){
destination[0] = a[1] * b[2] - a[2] * b[1];
destination[1] = a[2] * b[0] - a[0] * b[2];
destination[2] = a[0] * b[1] - a[1] * b[0];
} // Unitize a 3-dimensionality Vector
void UnitizeVector(float vector[]){
float diver = sqrt(vector[0] * vector[0] +
vector[1] * vector[1] +
vector[2] * vector[2]);
for(int i = 0; i < 3; i++){
vector[i] /= diver;
}
} // Set the view border
void viewport(float vxl, float vxr, float vyb, float vyt){
float Vlength = vxr - vxl;
float Vheight = vyt - vyb;
Project_Matrix[1][1] = Vlength / Vheight;// Set Ar
printMatrix(Project_Matrix, 4, 4, "Project_Matrix"); float wxl, wxr, wyb, wyt;
wxl = wyb = -1.0;
wxr = wyt = 1.0;
wvmtype scaling_x = (wvmtype)((vxr - vxl) / (wxr - wxl));
wvmtype scaling_y = (wvmtype)((vyt - vyb) / (wyt - wyb));
wvmtype shift_x = (wvmtype)(vxl - scaling_x * wxl);
wvmtype shift_y = (wvmtype)(vyb - scaling_y * wyb);
wvmtype new_WVM_Matrix[MTM_SIZE][MTM_SIZE]
= { { scaling_x, 0, shift_x, 0 },
{ 0, scaling_y, shift_y, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 } };
update_Matrix(new_WVM_Matrix, WVM);
printMatrix(WVM, 4, 4, "WVM Matrix");
} // Show all the object in final
void display(){
clearScreen();
clearData(); float multi_sum = 0;
float Matrix[MTM_SIZE];
ASCModel_struct Cur_ASCModel;
for(int index = 0; index < num_ASCModel; index++){
Cur_ASCModel = ASCModel[index];
line_start[num_line] = line_data(-1, -1);
lcp = &line_start[num_line]; cout << "World-Space:" << endl;
cout << Cur_ASCModel.vertex[0][0] << " "
<< Cur_ASCModel.vertex[0][1] << " "
<< Cur_ASCModel.vertex[0][2] << " "
<< Cur_ASCModel.vertex[0][3] << " " << endl; // Convert World-Space to Eye-Space
for(int i = 0; i < ASCModel[index].num_vertex; i++){
for(int j = 0; j < MTM_SIZE; j++){
multi_sum = 0;
for(int k = 0; k < MTM_SIZE; k++){
multi_sum += Cur_ASCModel.vertex[i][k]
* Eye_Matirx[j][k];
}
Matrix[j] = multi_sum;
}
// Update(cover) the Object-Space
for(int j = 0; j < MTM_SIZE; j++){
Cur_ASCModel.vertex[i][j] = Matrix[j];
}
}
cout << "Eye-Space:" << endl;
cout << Cur_ASCModel.vertex[0][0] << " "
<< Cur_ASCModel.vertex[0][1] << " "
<< Cur_ASCModel.vertex[0][2] << " "
<< Cur_ASCModel.vertex[0][3] << " " << endl; // Convert Eye-Space to Project-Space
for(int i = 0; i < ASCModel[index].num_vertex; i++){
for(int j = 0; j < MTM_SIZE; j++){
multi_sum = 0;
for(int k = 0; k < MTM_SIZE; k++){
multi_sum += Cur_ASCModel.vertex[i][k]
* Project_Matrix[j][k];
}
Matrix[j] = multi_sum;
}
// Update(cover) the Object-Space
for(int j = 0; j < MTM_SIZE; j++){
Cur_ASCModel.vertex[i][j] = Matrix[j] / Matrix[3];
}
Cur_ASCModel.vertex[i][2] = 1;//Fix to three-dimensional homogeneous
}
cout << "Project-Space:" << endl;
cout << Cur_ASCModel.vertex[0][0] << " "
<< Cur_ASCModel.vertex[0][1] << " "
<< Cur_ASCModel.vertex[0][2] << " "
<< Cur_ASCModel.vertex[0][3] << " " << endl; // Convert Project-Space to Screen-Space
for(int i = 0; i < ASCModel[index].num_vertex; i++){
for(int j = 0; j < MTM_SIZE; j++){
multi_sum = 0;
for(int k = 0; k < MTM_SIZE; k++){
multi_sum += Cur_ASCModel.vertex[i][k]
* WVM[j][k];
}
Matrix[j] = multi_sum;
}
// Update(cover) the Object-Space
for(int j = 0; j < MTM_SIZE; j++){
Cur_ASCModel.vertex[i][j] = Matrix[j];
}
}
cout << "Screen-Space:" << endl;
cout << Cur_ASCModel.vertex[0][0] << " "
<< Cur_ASCModel.vertex[0][1] << " "
<< Cur_ASCModel.vertex[0][2] << " "
<< Cur_ASCModel.vertex[0][3] << " " << endl; // Display
for(int i = 0; i < Cur_ASCModel.num_face; i++){
for(int j = 0; j < MTM_SIZE; j++){
bool vertice = (j < 3 && Cur_ASCModel.face[i][j + 1] == -1);
int j_next = (j == 3 || vertice) ? 0 : j + 1;
int x0 = Cur_ASCModel.vertex[Cur_ASCModel.face[i][j] - 1][0];
int x1 = Cur_ASCModel.vertex[Cur_ASCModel.face[i][j_next] - 1][0];
int y0 = Cur_ASCModel.vertex[Cur_ASCModel.face[i][j] - 1][1];
int y1 = Cur_ASCModel.vertex[Cur_ASCModel.face[i][j_next] - 1][1];
//DrawLine(x0, x1, y0, y1);
drawLine0(x0, x1, y0, y1);
if(vertice) break;
}
}
num_line++;
}
} // Redrwa the object
void redraw(){
line_data* rd_line;
for(int i = 0; i < num_line; i++){
rd_line = &line_start[i];
while(rd_line != NULL){
drawDot(rd_line->x, rd_line->y);
rd_line = rd_line->next;
}
}
glFlush();
} // Clear all the objects in store
void clearData(){
for(int i = 0; i < num_line; i++){
if(line_start[i].next != NULL){
lcp = line_start[i].next;
while(lcp != NULL){
temp = lcp;
lcp = lcp->next;
delete(temp);
}
}
}
num_line = 0;
} // Clear the screen
void clearScreen(){
glClearColor(default_r, default_g, default_b, alpha);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
} // Read the command from file
void ReadFile(bool& IsExit){
ifstream fin(Inputfile);
if(fin.is_open()){
cout << "open the file successfully" << endl;
}
else{
cout << "Can't not open the file" << endl;
IsExit = true;
return;
}
float sx, sy, sz;
float Xdegree, Ydegree, Zdegree;
float tx, ty, tz;
float vxl, vxr, vyt, vyb;
float PX, PY, PZ, CX, CY, CZ, Tilt, zNear, zFar, hFOV;
string command, comment, objectname;
while(!fin.eof()){
fin >> command;
cout <<"COMMAND -- " << command << " : " << endl;
if(command == "scale"){
fin >> sx >> sy >> sz;
scale(sx, sy, sz);
}
else if(command == "rotate"){
fin >> Xdegree >> Ydegree >>Zdegree;
rotate(Xdegree, Ydegree, Zdegree);
}
else if(command == "translate"){
fin >> tx >> ty >> tz;
translate(tx, ty, tz);
}
else if(command == "reset"){
reset();
}
else if(command == "object"){
fin >> objectname;
object(objectname);
}
else if(command == "observer"){
fin >> PX >> PY >> PZ;
fin >> CX >> CY >> CZ;
fin >> Tilt;
fin >> zNear >> zFar >> hFOV;
observer(PX, PY, PZ, CX, CY, CZ, Tilt, zNear, zFar, hFOV);
}
else if(command == "viewport"){
fin >> vxl >> vxr >> vyb >> vyt;
viewport(vxl, vxr, vyb, vyt);
}
else if(command == "display"){
display();
cout << "\tObjects display successfully" << endl;
}
else if(command == "clearData"){
clearData();
cout << "Data is cleared" << endl;
}
else if(command == "clearScreen"){
clearScreen();
cout << "Screen is cleared" << endl;
}
else if(command == "end"){
IsExit = true;
fin.close();
return;
}
else if(command == "#"){
getline(fin, comment);
cout << "\t" << comment << endl;
}
cout << endl;
}
} // Display function
void displayFunc(void){
// clear the entire window to the background color
glClear(GL_COLOR_BUFFER_BIT);
while(!IsExit){
glClearColor(default_r, default_g, default_b, alpha);
ReadFile(IsExit);
return;
} if(IsExit){
redraw();
}
return;
} // Print some formation and Set the parameter
void initial(){
cout << "Welcome GLUT painter" << endl;
cout << "Here are command key: (case insensitive)" << endl;
cout << "\treset - reset matrix to identity" << endl;
cout << "\tscale - scale the matrix" << endl;
cout << "\trotate - totate the matrix" << endl;
cout << "\ttranslate - translate the matrix" << endl;
cout << "\tobject - create an object" << endl;
cout << "\tobverser - set the camera position" << endl;
cout << "\tviewport - set the window to display" << endl;
cout << "\tdisplay - draw all the objects" << endl;
cout << "\tclearData - clear up data" << endl;
cout << "\tclearScreen - clear the screen" << endl;
cout << "\tend - Quit" << endl;
} #pragma endregion // Main
void main(int argc, char** argv) {
int winSizeX, winSizeY; //Set the programme parameter
Inputfile = (argc >= 2) ? (string(argv[1])) : "tilt1.in";
//Inputfile = (argc >= 2) ? (string(argv[1])) : "chair.in";
//Inputfile = (argc >= 2) ? (string(argv[1])) : "mytest.in";
height = winSizeX = (argc >= 3) ? (atoi(argv[2])) : 800;
width = winSizeY = (argc >= 4) ? (atoi(argv[3])) : 600; initial(); // initialize OpenGL utility toolkit (glut)
glutInit(&argc, argv); // single disply and RGB color mapping
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // set display mode
glutInitWindowSize(winSizeX, winSizeY); // set window size
glutInitWindowPosition(500, 100); // set window position on screen
glutCreateWindow("Lab3 Window"); // set window title // set up the mouse and keyboard callback functions
//glutKeyboardFunc(myKeyboard); // register the keyboard action function
//glutMouseFunc(Mymouse); // displayFunc is called whenever there is a need to redisplay the window,
// e.g., when the window is exposed from under another window or when the window is de-iconified
glutDisplayFunc(displayFunc); // register the redraw function // set background color
glClearColor(default_r, default_g, default_b, alpha); // set the background to white
glClear(GL_COLOR_BUFFER_BIT); // clear the buffer // misc setup
glMatrixMode(GL_PROJECTION); // setup coordinate system
glLoadIdentity();
gluOrtho2D(0, winSizeX, 0, winSizeY);
glShadeModel(GL_FLAT);
glFlush();
glutMainLoop();
}

测试文件

opengl经典测试——茶壶 titl1.in

使用了teapot.asc文件,上网搜索即可得到

scale 1 1 1
rotate 0 0 0
translate 0 0 0 object teapot.asc observer 0 10 10 0 0 0 0 1 1000 30 viewport 0 800 0 600 display end

opengl经典测试二——椅子 chair.in

使用了cube.asc文件,上网搜索即可得到

# makes a chair on a groundplane

# ground plane
scale 5 .2 5
translate 1 -.1 1
object cube.asc # leg of chair
reset
scale .05 .4 .05
translate 1.15 .2 1.15
object cube.asc # leg of chair
reset
scale .05 .4 .05
translate 1.15 .2 .85
object cube.asc # leg of chair
reset
scale .05 .4 .05
translate .85 .2 .85
object cube.asc # leg of chair
reset
scale .05 .4 .05
translate .85 .2 1.15
object cube.asc # seat of chair
reset
scale .3 .05 .3
translate 1 .425 1
object cube.asc # back of chair
reset
scale .3 .5 .1
translate 1 .7 .9
object cube.asc observer 2 .5 0 1 1 1 0 1 1000 30 viewport -.5 .5 -.5 .5 display observer 3 4 5 0 0 0 10 1 1000 30 viewport 0 800 0 600 display end

测试三为茶壶的变体,包含5份。

# teapot1.in
# #####################
# load a teapot object teapot.asc # set viewport viewport 0 800 0 600 # Eye (0,0,10) Look at (0,0,0) observer 0 0 10 0 0 0 0 1 100 45 display end
# ##################### # teapot2.in
# #####################
# load a teapot object teapot.asc # set viewport viewport 100 400 100 400 # Eye (0,0,10) Look at (0,0,0) observer 0 0 10 0 0 0 0 1 100 45 display end
# ##################### # teapot3.in
# #####################
# modeling trasnform translate 3 0 0 # load a teapot object teapot.asc # set viewport viewport 0 800 0 600 # Eye (0,0,10) Look at (0,0,0) observer 0 0 10 0 0 0 0 1 100 45 display end
# ##################### # teapot4.in
# #####################
# modeling trasnform translate 3 0 0 # load a teapot object teapot.asc # set viewport viewport 0 800 0 600 # Eye at(5,5,5) Look at (0,0,0) observer 5 5 5 0 0 0 0 1 100 45 display end
# ##################### # teapot5.in
# #####################
# modeling trasnform rotate 0 90 0 translate 3 0 0 # load a teapot object teapot.asc # set viewport viewport 0 800 0 600 # Eye (0,0,10) Look at (0,0,0) observer 5 5 5 0 0 0 0 1 100 45 display end
# #####################

综合测试批处理文件

记事本保存下面的代码为 xxx.bat 即可

3DCG_hw3.exe为VS编译生成的可执行文件名,可以选择更改批处理文件里面的名字,或更改自己的编译得到的可执行文件名。

# run sample

3DCG_hw3.exe tilt1.in

3DCG_hw3.exe chair.in

3DCG_hw3.exe teapot1.in

3DCG_hw3.exe teapot2.in

3DCG_hw3.exe teapot3.in

3DCG_hw3.exe teapot4.in

3DCG_hw3.exe teapot5.in

C++实现数字媒体三维图像变换的更多相关文章

  1. C++实现数字媒体三维图像渲染

    C++实现数字媒体三维图像渲染 必备环境 glut.h 头文件 glut32.lib 对象文件库 glut32.dll 动态连接库 程序说明 C++实现了用glut画物体对象的功能.并附带放大缩小,旋 ...

  2. C++实现数字媒体二维图像变换

    C++实现数字媒体二维图像变换 必备环境 glut.h 头文件 glut32.lib 对象文件库 glut32.dll 动态连接库 程序说明 C++实现了用glut画正方形,画三角形的功能.并附带放大 ...

  3. 开源数字媒体资产管理系统:Razuna

    Razuna以一个使用Java语言编写的开源的数字媒体资产管理(Digital Asset Management)系统.功能很强大,可以用于管理各种格式的数字媒体资源. Razuna在本机的安装配置还 ...

  4. 开源数字媒体资产管理系统:Razuna安装方法

    Razuna以一个使用Java语言编写的开源的数字媒体资产管理(Digital Asset Management)系统.在这里翻译一下它的安装步骤. Razuna包含以下版本: Razuna Stan ...

  5. 2013级计算机学院数字媒体专业李成梁(笛卡尔积,概率树状图)& 学生选课

    初中数学问这个向量 ( *  , 计算学院 , * , *  ) 任取一个向量来自计算机的概率     4*1*100*10000/ 8千万 限定在计科院数字媒体技术专业大二上期选课这个小的范围 学生 ...

  6. 杂项:TMT(数字媒体产业)

    ylbtech-杂项:TMT(数字媒体产业) TMT(Technology,Media,Telecom),是科技.媒体和通信三个英文单词的缩写的第一个字头,整合在一起.含义实际是未来(互联网)科技.媒 ...

  7. 三维视觉、SLAM方向全球顶尖实验室汇总

    本文作者 任旭倩,公众号:计算机视觉life,编辑成员 欧洲 英国伦敦大学帝国理工学院 Dyson 机器人实验室 http://www.imperial.ac.uk/dyson-robotics-la ...

  8. 19个三维GIS软件对比

    19个三维GIS软件对比 麦豆科研技术中心 days ago 我国GIS经过三十多年的发展,理论和技术日趋成熟,在传统二维GIS已不能满足应用需求的情况下,三维GIS应运而生,并成为GIS的重要发展方 ...

  9. iOS数字媒体开发浅析

    概述 自然界中的所有看到的听到的都是模拟信号,模拟信号是随时间连续变化,然而手机电脑等信息都属于数字媒体,它们所呈现的内容就是把自然界中这些模拟信号转换成数字信号然后再传递给我们.数字信号不是连续的是 ...

随机推荐

  1. Nginx服务器不支持PATH_INFO的问题及解决办法

    最近在写一个小程序,然后里面自己写了个URL的处理器,比如说访问index.php/article 那么就会自动加载进来article页面,访问index.php/home就会自动加载home页面. ...

  2. https双向认证demo

    阅读此文首先需要具备数据加解密,公钥,私钥,签名,证书等基础知识. 通信服务端:使用tomcat 通信客户端:使用apache httpclient 4.5.1 1. 服务端操作 . keytool ...

  3. C#_数组

     数组是相同数据类型的元素按一定顺序排列的集合,然后用一个变量名进行命名.新建控制台程序,声明一个静态方法 using System; using System.Collections.Gener ...

  4. 【转】利用MVC模式开发Java应用程序[组图]

    Java是一种面向对象的语言,是实现面向对象编程的强大工具.我们在实际编程中,应该运用并发挥其最大效能.但是,要利用面向对象编程思想,自己独立开 发出好的Java应用程序,非凡是大.中型程序,并不是一 ...

  5. Oracle学习笔记4 使用Navicat for Oracle 连接Oracle时出现错误:ORA-28547: connection to server failed, probable Oracle Net admin error

    出问题到的机器环境: Oracle 11gR2 64bit Navicat for Oracle 11.0.10 根据网上一些大神的做法及个人的一些推测,总结如下: 问题出现的原因:Navicat与O ...

  6. XenApp简单部署

    作者:MR.Yangwj 目录 XenApp简单部署... 1 一.         XenApp安装... 1 (一)      服务器配置任务... 9 1)     许可证服务器配置... 9 ...

  7. 后台获取ajax发送过来的值

    user.CityId = int.Parse(HttpContext.Request[ "bindArea"]); 以上为获取方法:

  8. MongoDB中的group

    在Mongodb的查询中,有类似于SQL中group by功能的group函数.两者的功能有些类似,但是区别也是比较明显的. 对于SQL来说,group by的作用就是安装依据列来将数据表中的记录分成 ...

  9. jquery里用each遍历的值存到数组和字符串

    $("img").each(function(){ var a = $(this).attr("src"); }); //遍历后存放到数组中..要用的时候再根据 ...

  10. eclipse如何创建web项目

    1.  打开eclipse,在File上New,然后选择Dynamic  Web  Project 2.  弹出的页面中如下图,在Project name中输入项目名称JavaWeb01,点击Next ...