MFC三维变换

最新推荐文章于 2023-07-14 22:23:24 发布
最新推荐文章于 2023-07-14 22:23:24 发布
阅读量1.7k 收藏 30
点赞数 8
文章标签： mfc c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49435172/article/details/120852990
版权
所需类

在这里插入图片描述

P2类
class CP2
{
public:
	CP2(void);
	virtual ~CP2(void);
	CP2(double x, double y);
	friend CP2 operator + (const CP2& p0, const CP2& p1);
	friend CP2 operator - (const CP2& p0, const CP2& p1);
	friend CP2 operator * (const CP2& p, double scalar);
	friend CP2 operator * (double scalar, const CP2& p);
	friend CP2 operator / (const CP2& p, double scalar);
	friend CP2 operator += (CP2& p0, CP2& p1);
	friend CP2 operator -= (CP2& p0, CP2& p1);
	friend CP2 operator *= (CP2& p0, double scalar);
	friend CP2 operator /= (CP2& p0, double scalar);
public:
	double x;
	double y;
	double w;
};
此处重载了运算符，方便后面定义矩阵运算
#include "pch.h"
#include "P2.h"

CP2::CP2(void)
{
	x = 0.0;
	y = 0.0;
	w = 1.0;
}

CP2::~CP2(void)
{
}

CP2::CP2(double x, double y)
{
	this->x = x;
	this->y = y;
	this->w = 1.0;
}

CP2 operator+(const CP2& p0, const CP2& p1)
{
	CP2 temp;
	temp.x = p0.x + p1.x;
	temp.y = p0.y + p1.y;
	temp.w = p0.w + p1.w;
	return temp;
}

CP2 operator-(const CP2& p0, const CP2& p1)
{
	CP2 temp;
	temp.x = p0.x - p1.x;
	temp.y = p0.y - p1.y;
	temp.w = p0.w - p1.w;
	return temp;
}

CP2 operator*(const CP2& p, double scalar)
{
	CP2 temp;
	temp.x = p.x * scalar;
	temp.y = p.y * scalar;
	temp.w = p.w * scalar;
	return temp;
}

CP2 operator*(double scalar, const CP2& p)
{
	CP2 temp;
	temp.x = scalar * p.x;
	temp.y = scalar * p.y;
	temp.w = scalar * p.w;
	return temp;
}

CP2 operator/(const CP2& p, double scalar)
{
	CP2 temp;
	temp.x = p.x / scalar;
	temp.y = p.y / scalar;
	temp.w = p.w / scalar;
	return temp;
}

CP2 operator+=(CP2& p0, CP2& p1)
{
	CP2 temp;
	temp.x = p0.x + p1.x;
	temp.y = p0.y + p1.y;
	temp.w = p0.w + p1.w;
	return temp;
}

CP2 operator-=(CP2& p0, CP2& p1)
{
	CP2 temp;
	temp.x = p0.x - p1.x;
	temp.y = p0.y - p1.y;
	temp.w = p0.w - p1.w;
	return temp;
	return CP2();
}

CP2 operator*=(CP2& p0, double scalar)
{
	CP2 temp;
	temp.x = p0.x * scalar;
	temp.y = p0.y * scalar;
	temp.w = p0.w * scalar;
	return temp;
}

CP2 operator/=(CP2& p0, double scalar)
{
	CP2 temp;
	temp.x = p0.x / scalar;
	temp.y = p0.y / scalar;
	temp.w = p0.w / scalar;
	return temp;
}
P3类继承P2
#pragma once
#include "P2.h"
class CP3:public CP2
{
public:
	CP3(void);
	virtual~CP3(void);
	CP3(double x, double y, double z);
public:
	double z;
};

#include "pch.h"
#include "P3.h"

CP3::CP3(void)
{
	x = 0; y = 0; z = 0; w = 1;
}

CP3::~CP3(void)
{
}

CP3::CP3(double x, double y, double z)
{
	this->z = z;
}
定义面类Facet
#pragma once
class CFacet
{
public:
	CFacet(void);
	virtual ~CFacet(void);
	void SetPtNumber(int Number);
public:
	int Number;
	int Index[4];//这里一个面有4个点
};

#include "pch.h"
#include "Facet.h"

CFacet::CFacet(void)
{
	Number = 0;
	for (int i = 0; i < 4; i++) {
		Index[i] = 0;
	}
}

CFacet::~CFacet(void)
{
}

void CFacet::SetPtNumber(int Number)
{
	this->Number = Number;
}
定义三维变换类Transform3
#pragma once
#include"P3.h"
#define PI 3.14159265
#include<math.h>
class CTransform3
{
public:
	CTransform3(void);
	virtual ~CTransform3(void);
	void SetMatrix(CP3* P, int ptNumber);//设置二维顶点数组
	void Identity(void);//单位矩阵
	void Translate(double tx, double ty, double tz);//平移
	void Scale(double sx, double sy, double sz);//放缩
	void Scale(double sx, double sy, double sz, CP3 p);//相对于任意点的比例变换
	void Scale(double s);//整体缩放
	void Scale(double s,CP3 p);//整体缩放
	void RotateX(double beta);//绕X轴旋转
	void RotateY(double beta);//绕Y轴旋转
	void RotateZ(double beta);//绕Z轴旋转
	void RotateX(double beta, CP3 p);//相对于任意点旋转
	void RotateY(double beta, CP3 p);//相对于任意点旋转
	void RotateZ(double beta, CP3 p);//相对于任意点旋转
	void ReflectX(void);
	void ReflectY(void);
	void ReflectZ(void);
	void ReflectXOY(void);
	void ReflectYOZ(void);
	void ReflectZOX(void);
	void ShearX(double b, double c);//错切
	void ShearY(double d, double f);//错切
	void ShearZ(double g, double h);//错切
	void MultiplyMatrix(void);//矩阵乘法
private:
	double M[4][4];
	CP3* P;
	int ptNumber;
};

#include "pch.h"
#include "Transform3.h"

CTransform3::CTransform3(void)
{
	P = nullptr;
	ptNumber = 0;
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			M[i][j] = 0.0;
		}
	}
}

CTransform3::~CTransform3(void)
{
}

void CTransform3::SetMatrix(CP3* P, int ptNumber)
{
	this->P = P;
	this->ptNumber = ptNumber;
}

void CTransform3::Identity(void)
{
	M[0][0] = 1.0; M[0][1] = 0.0; M[0][2] = 0.0, M[0][3] = 0.0;
	M[1][0] = 0.0; M[1][1] = 1.0; M[1][2] = 0.0, M[1][3] = 0.0;
	M[2][0] = 0.0; M[2][1] = 0.0; M[2][2] = 1.0, M[2][3] = 0.0;
	M[3][0] = 0.0; M[3][1] = 0.0; M[3][2] = 0.0, M[3][3] = 1.0;
}

void CTransform3::Translate(double tx, double ty, double tz)
{
	Identity();
	M[0][3] = tx;
	M[1][3] = ty;
	M[2][3] = tz;
	MultiplyMatrix();
}

void CTransform3::Scale(double sx, double sy, double sz)
{
	Identity();
	M[0][0] = sx;
	M[1][1] = sy;
	M[2][2] = sz;
	MultiplyMatrix();

}

void CTransform3::Scale(double sx, double sy, double sz, CP3 p)
{
	Translate(-p.x, -p.y, -p.z);
	Scale(sx, sy, sz);
	Translate(p.x, p.y, p.z);
}

void CTransform3::Scale(double s)
{
	Identity();
	M[0][0] = s;
	M[1][1] = s;
	M[2][2] = s;
	MultiplyMatrix();
}

void CTransform3::Scale(double s, CP3 p)
{
	Translate(-p.x, -p.y, -p.z);
	Scale(s);
	Translate(p.x, p.y, p.z);
}

void CTransform3::RotateX(double beta)
{
	Identity();
	beta = beta * PI / 180;
	M[1][1] = cos(beta);
	M[1][2] = -sin(beta);
	M[2][1] = sin(beta);
	M[2][2] = cos(beta);
	MultiplyMatrix();
}

void CTransform3::RotateY(double beta)
{
	Identity();
	beta = beta * PI / 180;
	M[0][0] = cos(beta);
	M[0][2] = sin(beta);
	M[2][0] = -sin(beta);
	M[2][2] = cos(beta);
	MultiplyMatrix();
}

void CTransform3::RotateZ(double beta)
{
	Identity();
	beta = beta * PI / 180;
	M[0][0] = cos(beta);
	M[0][1] = -sin(beta);
	M[1][0] = sin(beta);
	M[1][1] = cos(beta);
	MultiplyMatrix();
}

void CTransform3::RotateX(double beta, CP3 p)
{
	Translate(-p.x, -p.y, p.z);
	RotateX(beta);
	Translate(p.x, p.y, p.z);
}

void CTransform3::RotateY(double beta, CP3 p)
{
	Translate(-p.x, -p.y, p.z);
	RotateY(beta);
	Translate(p.x, p.y, p.z);
}

void CTransform3::RotateZ(double beta, CP3 p)
{
	Translate(-p.x, -p.y, p.z);
	RotateZ(beta);
	Translate(p.x, p.y, p.z);
}

void CTransform3::ReflectX(void)
{
	Identity();
	M[1][1] = -1;
	M[2][2] = -1;
	MultiplyMatrix();
}

void CTransform3::ReflectY(void)
{
	Identity();
	M[0][0] = -1;
	M[2][2] = -1;
	MultiplyMatrix();
}

void CTransform3::ReflectZ(void)
{
	Identity();
	M[0][0] = -1;
	M[1][1] = -1;
	MultiplyMatrix();
}

void CTransform3::ReflectXOY(void)
{
	Identity();
	M[2][2] = -1;
	MultiplyMatrix();
}

void CTransform3::ReflectYOZ(void)
{
	Identity();
	M[0][0] = -1;
	MultiplyMatrix();
}

void CTransform3::ReflectZOX(void)
{
	Identity();
	M[1][1] = -1;
	MultiplyMatrix();
}

void CTransform3::ShearX(double b, double c)
{
	Identity();
	M[0][1] = b;
	M[0][2] = c;
	MultiplyMatrix();
}

void CTransform3::ShearY(double d, double f)
{
	Identity();
	M[1][0] = d;
	M[1][2] = f;
	MultiplyMatrix();
}

void CTransform3::ShearZ(double g, double h)
{
	Identity();
	M[2][0] = g;
	M[2][1] = h;
	MultiplyMatrix();
}

void CTransform3::MultiplyMatrix(void)
{
	CP3* PTemp = new CP3[ptNumber];
	for (int i = 0; i < ptNumber; i++)
	{
		PTemp[i] = P[i];
	}
	for (int i = 0; i < ptNumber; i++)
	{
		P[i].x = M[0][0] * PTemp[i].x + M[0][1] * PTemp[i].y + M[0][2] * PTemp[i].z + M[0][3] * PTemp[i].w;
		P[i].y = M[1][0] * PTemp[i].x + M[1][1] * PTemp[i].y + M[1][2] * PTemp[i].z + M[1][3] * PTemp[i].w;
		P[i].z = M[2][0] * PTemp[i].x + M[2][1] * PTemp[i].y + M[2][2] * PTemp[i].z + M[2][3] * PTemp[i].w;
		P[i].w = M[3][0] * PTemp[i].x + M[3][1] * PTemp[i].y + M[3][2] * PTemp[i].z + M[3][3] * PTemp[i].w;
	}
	delete[]PTemp;

}
定义投影类Projection
#pragma once
#include"P3.h"
#include<math.h>
#define PI 3.141659265
class CProjection
{
public:
	CProjection(void);
	virtual ~CProjection(void);
	void SetEye(double R);
	void SetEye(double Phi, double Psi, double R, double d);
	void SetEye(double Phi, double Psi, double R);
	void SetEye(double Phi, double Psi);
	void InitialParameter(void);
	CP2 OrthogonalProjection(CP3 WorldPoint);
	CP2 ObliqueProjection(CP3 WorldPoint);
	CP2 PerspectiveProjection(CP3 WorldPoint);
public:
	CP3 EyePoint;
private:
	double k[8];
	double R, d, Phi, Psi;
};

#include "pch.h"
#include "Projection.h"

CProjection::CProjection(void)
{
	R = 1200, d = 800;
	Phi = 90.0, Psi = 0.0;
	InitialParameter();
}

CProjection::~CProjection(void)
{
}

void CProjection::SetEye(double R)
{
	EyePoint.z = R;
}

void CProjection::SetEye(double Phi, double Psi, double R, double d)
{
	this->Phi = Phi;
	this->Psi = Psi;
	this->R = R;
	this->d = d;
}

void CProjection::SetEye(double Phi, double Psi, double R)
{
	this->Phi = Phi;
	this->Psi = Psi;
	this->R = R;
}

void CProjection::SetEye(double Phi, double Psi)
{
	this->Phi = Phi;
	this->Psi = Psi;
}

void CProjection::InitialParameter(void)
{
	k[0] = sin(PI * Phi / 180);
	k[1] = cos(PI * Phi / 180);
	k[2] = sin(PI * Psi / 180);
	k[3] = cos(PI * Psi / 180);
	k[4] = k[0] * k[2];
	k[5] = k[0] * k[3];
	k[6] = k[1] * k[2];
	k[7] = k[1] * k[3];
	EyePoint.x = k[4] * R;
	EyePoint.y = k[1] * R;
	EyePoint.z = k[5] * R;

}

CP2 CProjection::OrthogonalProjection(CP3 WorldPoint)
{
	CP2 ScreenPoint;
	ScreenPoint.x = WorldPoint.x;
	ScreenPoint.y = WorldPoint.y;
	return ScreenPoint;
}

CP2 CProjection::ObliqueProjection(CP3 WorldPoint)
{
	CP2 ScreenPoint;
	double Cota = 0.5;
	double Beta = PI / 4;
	ScreenPoint.x = WorldPoint.x - WorldPoint.z * Cota * cos(Beta);
	ScreenPoint.y = WorldPoint.y - WorldPoint.z * Cota * cos(Beta);
	return ScreenPoint;
}

CP2 CProjection::PerspectiveProjection(CP3 WorldPoint)
{
	CP3 ViewPoint;
	ViewPoint.x = k[3] * WorldPoint.x - k[2] * WorldPoint.z;
	ViewPoint.y = -k[6] * WorldPoint.x + k[0] * WorldPoint.y - k[7] * WorldPoint.z;
	ViewPoint.z = -k[4] * WorldPoint.x - k[1] * WorldPoint.y - k[5] * WorldPoint.z + R;
	CP2 ScreenPoint;
	ScreenPoint.x = d * ViewPoint.x / ViewPoint.z;
	ScreenPoint.y = d * ViewPoint.y / ViewPoint.z;
	return ScreenPoint;
}
定义立方体类CCube
#include"P2.h"
#include"Projection.h"
#define ROUND(d) int(d+0.5)
class CCube
{
public:
	CCube(void);
	virtual ~CCube(void);
	void ReadPoint(void);
	void ReadFacet(void);
	CP3* GetVertexArrayName(void);
	void Draw(CDC* pDC);
	void Draw2(CDC* pDC);
	void Draw3(CDC* pDC);
public:
	CProjection projection;
private:
	CP3 P[8];
	CFacet F[6];
};

#include "pch.h"
#include "Cube.h"

CCube::CCube(void)
{
	projection.InitialParameter();
}

CCube::~CCube(void)
{
}

void CCube::ReadPoint(void)
{
	P[0].x = 0, P[0].y = 0, P[0].z = 0;
	P[1].x = 1, P[1].y = 0, P[1].z = 0;
	P[2].x = 1, P[2].y = 1, P[2].z = 0;
	P[3].x = 0, P[3].y = 1, P[3].z = 0;
	P[4].x = 0, P[4].y = 0, P[4].z = 1;
	P[5].x = 1, P[5].y = 0, P[5].z = 1;
	P[6].x = 1, P[6].y = 1, P[6].z = 1;
	P[7].x = 0, P[7].y = 1, P[7].z = 1;
}

void CCube::ReadFacet(void)
{
	F[0].Index[0] = 4; F[0].Index[1] = 5; F[0].Index[2] = 6; F[0].Index[3] = 7; 
	F[1].Index[0] = 0; F[1].Index[1] = 3; F[1].Index[2] = 2; F[1].Index[3] = 1; 
	F[2].Index[0] = 0; F[2].Index[1] = 4; F[2].Index[2] = 7; F[2].Index[3] = 3; 
	F[3].Index[0] = 1; F[3].Index[1] = 2; F[3].Index[2] = 6; F[3].Index[3] = 5; 
	F[4].Index[0] = 2; F[4].Index[1] = 3; F[4].Index[2] = 7; F[4].Index[3] = 6; 
	F[5].Index[0] = 0; F[5].Index[1] = 1; F[5].Index[2] = 5; F[5].Index[3] = 4; 
}

CP3* CCube::GetVertexArrayName(void)
{
	return P;
}

void CCube::Draw(CDC* pDC)
{
	CP2 ScreenPoint, temp;
	for (int nFacet = 0; nFacet < 6; nFacet++)
	{
		for (int nPoint = 0; nPoint < 4; nPoint++)
		{
			ScreenPoint = projection.OrthogonalProjection(P[F[nFacet].Index[nPoint]]);
			if (0 == nPoint)
			{
				pDC->MoveTo(ROUND(ScreenPoint.x), ROUND(ScreenPoint.y));
				temp = ScreenPoint;
			}
			else
			{
				pDC->LineTo(ROUND(ScreenPoint.x), ROUND(ScreenPoint.y));
			}
		}
		pDC->LineTo(ROUND(temp.x), ROUND(temp.y));
	}
}

void CCube::Draw2(CDC* pDC)
{
	CP2 ScreenPoint, temp;
	for (int nFacet = 0; nFacet < 6; nFacet++)
	{
		for (int nPoint = 0; nPoint < 4; nPoint++)
		{
			ScreenPoint = projection.ObliqueProjection(P[F[nFacet].Index[nPoint]]);
			if (0 == nPoint)
			{
				pDC->MoveTo(ROUND(ScreenPoint.x), ROUND(ScreenPoint.y));
				temp = ScreenPoint;
			}
			else
			{
				pDC->LineTo(ROUND(ScreenPoint.x), ROUND(ScreenPoint.y));
			}
		}
		pDC->LineTo(ROUND(temp.x), ROUND(temp.y));
	}
}

void CCube::Draw3(CDC* pDC)
{
	CP2 ScreenPoint, temp;
	for (int nFacet = 0; nFacet < 6; nFacet++)
	{
		for (int nPoint = 0; nPoint < 4; nPoint++)
		{
			ScreenPoint = projection.PerspectiveProjection(P[F[nFacet].Index[nPoint]]);
			if (0 == nPoint)
			{
				pDC->MoveTo(ROUND(ScreenPoint.x), ROUND(ScreenPoint.y));
				temp = ScreenPoint;
			}
			else
			{
				pDC->LineTo(ROUND(ScreenPoint.x), ROUND(ScreenPoint.y));
			}
		}
		pDC->LineTo(ROUND(temp.x), ROUND(temp.y));
	}
}

testview

// 操作
public:
	void DrawObject(CDC* pDC);
	void DoubleBuffer(CDC* pDC);//双缓冲
	enum class ProjectionType
	{
		PerspectiveProjection, ObliqueProjection, OrthogonalProjection, ViewTransform1, ViewTransform2
	}m_ProjectionType;//用于菜单控制

//声明所需变量
protected:
	CTransform3 transform;
	CCube cube;
	double Alpha, Beta;
	double Phi, Psi;
	double R, d;
	BOOL bPlay;
变量初始化
CTest4View::CTest4View() noexcept
{
	// TODO: 在此处添加构造代码
	R = 1200, d = 800;
	Phi =45.0, Psi = 45.0;
	Alpha = 0.0, Beta = 0.0;
	bPlay = FALSE;
	m_ProjectionType = ProjectionType::OrthogonalProjection;
	cube.projection.SetEye(Phi, Psi, R, d);
	cube.ReadPoint();
	cube.ReadFacet();
	transform.SetMatrix(cube.GetVertexArrayName(), 8);
	double nEdge = 100;
	transform.Scale(nEdge, nEdge, nEdge);
	transform.Translate(-nEdge / 2, -nEdge / 2, -nEdge / 2);
}
DrawObject
void CTest4View::DrawObject(CDC* pDC)
{
	if (m_ProjectionType == ProjectionType::OrthogonalProjection) {
		cube.Draw(pDC);
	}
	else if (m_ProjectionType == ProjectionType::ObliqueProjection) {
		cude.Draw2(pDC);
	}
	else
	{
		cube.Draw3(pDC);
	}
}
DoubleBuffer
void CTest4View::DoubleBuffer(CDC* pDC)
{
	CRect rect;
	GetClientRect(&rect);
	pDC->SetMapMode(MM_ANISOTROPIC);
	pDC->SetWindowExt(rect.Width(), rect.Height());
	pDC->SetViewportExt(rect.Width(), -rect.Height());
	pDC->SetViewportOrg(rect.Width() / 2, rect.Height() / 2);
	CDC memDC;
	memDC.CreateCompatibleDC(pDC);
	CBitmap NewBitmap, * pOldBitmap;
	NewBitmap.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
	pOldBitmap = memDC.SelectObject(&NewBitmap);
	memDC.FillSolidRect(rect, pDC->GetBkColor());
	rect.OffsetRect(-rect.Width() / 2, -rect.Height() / 2);
	memDC.SetMapMode(MM_ANISOTROPIC);
	memDC.SetWindowExt(rect.Width(), rect.Height());
	memDC.SetViewportExt(rect.Width(), -rect.Height());
	memDC.SetViewportOrg(rect.Width() / 2, rect.Height() / 2);
	DrawObject(&memDC);
	pDC->BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &memDC, -rect.Width() / 2, -rect.Height() / 2, SRCCOPY);
	memDC.SelectObject(pOldBitmap);
	NewBitmap.DeleteObject();
}
OnDraw
void CTest4View::OnDraw(CDC* pDC)
{
	CTest4Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	if (!pDoc)
		return;

	// TODO: 在此处为本机数据添加绘制代码
	DoubleBuffer(pDC);
}
菜单控制
void CTest4View::OnOrthogonalProjection()
{
	// TODO: 在此添加命令处理程序代码
	m_ProjectionType = ProjectionType::OrthogonalProjection;
}


void CTest4View::OnObliqueProjection()
{
	// TODO: 在此添加命令处理程序代码
	m_ProjectionType = ProjectionType::ObliqueProjection;
}


void CTest4View::OnPerspectiveProjection()
{
	// TODO: 在此添加命令处理程序代码
	m_ProjectionType = ProjectionType::PerspectiveProjection;
}
void CTest4View::OnViewTransform1()
{
	// TODO: 在此添加命令处理程序代码
	m_ProjectionType = ProjectionType::ViewTransform1;
}


void CTest4View::OnViewTransform2()
{
	// TODO: 在此添加命令处理程序代码
	m_ProjectionType = ProjectionType::ViewTransform2;
}

在这里插入图片描述
在这里插入图片描述

键盘响应事件
void CTest4View::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	if (!bPlay)
	{
		if (m_ProjectionType == ProjectionType::ViewTransform1)
		{
			switch (nChar)
			{
			case VK_UP: {
				R += 50;
				cube.projection.SetEye(Phi, Psi, R, d);
				break;
			}
			case VK_DOWN: {
				R -= 50;
				cube.projection.SetEye(Phi, Psi, R, d);
				break;
			}
			default: {
				break; }
			}
			Invalidate(FALSE);
		}
		else if(m_ProjectionType == ProjectionType::ViewTransform2)
		{
			switch (nChar)
			{
			case VK_UP: {
				Phi += 5;
				cube.projection.SetEye(Phi, Psi);
				cube.projection.InitialParameter();
				break;
			}
			case VK_DOWN: {
				Phi -= 5;
				cube.projection.SetEye(Phi, Psi);
				cube.projection.InitialParameter();
				break;
			}
			case VK_LEFT: {
				Psi += 5;
				cube.projection.SetEye(Phi, Psi);
				cube.projection.InitialParameter();
				break;
			}
			case VK_RIGHT: {
				Psi -= 5;
				cube.projection.SetEye(Phi, Psi);
				cube.projection.InitialParameter();
				break;
			}
			default: {
				break; }
			}
			Invalidate(FALSE);
		}
		else
		{
			switch (nChar)
			{
			case VK_UP: {
				Alpha = -5;
				transform.RotateX(Alpha);
				break;
			}
			case VK_DOWN: {
				Alpha = +5;
				transform.RotateX(Alpha);
				break;
			}
			case VK_LEFT: {
				Beta = -5;
				transform.RotateY(Beta);
				break;
			}
			case VK_RIGHT: {
				Beta = +5;
				transform.RotateY(Beta);
				break;
			}
			default: {
				break; }
			}
			Invalidate(FALSE);
		}
	}
	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}
#游侠#
关注
  • 8
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MFC下实现图形学之立方体平移、比例、旋转、投影变换算法
fuliangliang的Blog
11-07 1万+
//*********************************//绘制坐标系以及初始立方体//*********************************void CTransGraphicsView::OnDraw(CDC* pDC){ CTransGraphicsDoc* pDoc = GetDocument(); ASSERT_VALID(pDoc); HBRUSH hbrus
MFC中点类的实现
uchiha_rin的博客
12-24 476
二维点类： #include "RGB.h" class CP2 { public: CP2(void); virtual ~CP2(void); CP2(double x, double y); CP2(double x, double y, CRGB c); friend CP2 operator + (const CP2& p1, const CP2& p2);//运算符重载 friend CP2 operator - (const CP2& p1, const
三维变换算法(几何变换,投影变换)VC源代码(计算机图形学)
03-15
本代码演示了各种三维变换算法，包括：几何变换:平移、旋转、变比、对称、错切。投影变换：平行投影（三视图、正轴测图、斜轴测图）、透视图。。源代码可以在VC++6.0中编译通过。 关键字：三维变换,几何变换,投影变换
计算机图形学孔令德VS2022新建MFC项目基本操作-绘制金刚石图案
qq_41720628的博客
10-04 7206
计算机图形学孔令德VS2022新建MFC项目基本操作 绘制金刚石图案
MFC调用Opengl实现三维图形的旋转平移缩放
03-14
本例子实现画立方体的例子，多面体可以参考此程序，程序实现了三维立体图形的旋转，平移和缩放，旋转通过鼠标左键实现，平移通过方向键实现，缩放通过鼠标滚轮实现
VC++的MFC计算机图形学（点线多边形裁剪填充消隐二三维图形变换）
03-08
基于VC++6.0中MFC的计算机图形学程序，实现了画点画线画多边形，多边形的裁剪填充消隐，二、三维图形变换（对称，镜像，拉伸，放大缩小，动画等等）
计算机图形学——三维图形几何变换和投影转换（VC）
qq_56910425的博客
10-25 2776
三维图形几何变换和投影变换
计算机图形学(MFC)-三维图形变换(立方体)
03-24
- 三维变换的数学基础，包括矩阵运算和向量代数。 - 如何将变换矩阵应用于三维物体的顶点坐标。 - 使用OpenGL或Direct3D进行图形渲染的基本知识。 - 熟悉C++编程，尤其是面向对象编程的概念。 通过这个项目，你可以...
MFC计算机图形学-三维图形几何变换（斜等测画法）C/c++源码.rar
06-10
（系统会自己调分，我手动...大学计算机图形学课程作业代码，使用用斜等测图的绘制方法绘制三维几何图形，实现平移、比例、旋转、反射错切等变换。自用，代码完整。打包下载，可直接运行。c/c++语言MFC实现。支持vs。
MFC三维图形的扫描变换
02-06
总之，MFC三维图形的扫描变换是将复杂的三维几何体转化为屏幕上可见的二维图像的关键技术。理解和掌握这一过程，不仅能够帮助我们构建高效的图形应用程序，也是提升计算机图形学技能的重要一步。通过不断实践和学习...
计算机图形学实验——二维变换&三维变换
最新发布
m0_62378244的博客
07-14 1879
本文使用OpenGL在VS 2022中实现了二维及三维图形的基本变换和复合变换，给出了具体实现步骤、实验结果与相应的源代码。
VC++实现三维旋转(源码)
10-31
VC++实现三维旋转,显示调用OPENGL库,算法参考于计算机图形学
向量
kakaxi123z的博客
10-11 789
向量向量点乘 向量点乘 向量点乘的一些计算公式记录： 计算向量的长度： 向量的分量的平方后相加再开根号；比如 向量a（1，2，3） 12 +22+32=14 然后开根号 等于 3.74 那么 向量a的长度为：3.74 可用 |a| 表示向量的长度 计算向量单位化： 用向量/向量长度 2个单位向量可以用来表示两个方向，这两个方向可以进行比较（同方向还是不同方向）单位向量可判断方向 两个向量点乘： 结果是一个标量。如向量v1(1,2,3) v2(4,5,6)=4+10+18=32 公式 a * b =
三维图形变换与投影
火雨(Nick)
12-23 6477
三维图形变换与投影：Open GL，空间三维坐标系，空间球，立方体和三角形，4次齐次坐标，透视投影规格化裁剪算法实现三维图形裁剪。
计算机图形学中几何变换的定义,计算机图形学 实验7 三维几何变换（MFC中）
weixin_28783097的博客
07-26 804
实验目的：理解几何变换的意义掌握三维基本几何变换的算法实验内容：实验步骤：在本次试验中，我们实现透视投影和三维几何变换。我们首先定义一个立方体作为我们要进行变换的三维物体。定义顶点表和面表的数据结构定义三维坐标点的结构，面的结构：定义顶点表保存立方体顶点信息顶点 x坐标 y坐标 z坐标V0 x0＝-a y0＝-a z0＝-aV1 x1＝ a y1＝-a z1＝-aV2 x2＝ a y2＝ a z2...
三维图形几何变换与投影变换
baotu的博客
10-27 999
double y;double w;};CP2 P1;};y = 0.0;w = 1.0;}{}{ /*齐次坐标*/}{}{}{}{P0 = p0;}{P0.x = x;P0.y = y;}{CP2 p;p.x = x;
计算机图形学 实验7 三维几何变换（MFC中）
Confident_ZYL的博客
06-28 7333
实验目的： 理解几何变换的意义 掌握三维基本几何变换的算法 实验内容： 实验步骤： 在本次试验中，我们实现透视投影和三维几何变换。我们首先定义一个立方体作为我们要进行变换的三维物体。 定义顶点表和面表的数据结构 定义三维坐标点的结构，面的结构： 定义顶点表保存立方体顶点信息 顶点 x坐标 y坐标 z坐标 V0 x0＝-a y0＝-a z0＝-a V1 x1＝ a y1＝-a z1＝-a V2 x2＝ a y2＝ a z2＝-a V3 x3＝-a y3＝ a z3＝-a V4 x4＝-a y4
计算机图形学-三维变换和三维观察
weixin_51538888的博客
12-26 4139
三维变换矩阵： 三维空间点的变换---点的规范化齐次坐标矩阵与三维变换矩阵相乘 T3的四个子矩阵： 基本的图形几何变换：对点进行比例、对称、旋转和错切变换 平移： 透视： 整体比例： 关于旋转的方向：右手定则 绕x轴旋转（元素1-1为1）： 绕x轴旋转（元素2-2为1）： 绕x轴旋转（元素3-3为1）： 三维复合变换： 绕三维空间中任意轴旋转：与二维复合变换类似，先平移至轴过原点，然后旋转两次（先转到某个面上，再转到某条坐标轴上），最后对目标对象作变换；然后进行对..
计算机图形学 三维视图变换与投影变换（机械臂）
m0_57035151的博客
05-16 307
问题： 修改机械臂那个工程代码，使之变成以下操作方式：按1、2、3键选择3个球之一作为操作基点，用红色绘制该小球进行提示；用其余6个按键分别执行以选中的小球为基点的3对自由度的正反向旋转； 研究思路： 目前机械臂已经可以进行三个层次的自由旋转，我们需要实现的是设定按键选定任意一个小球来进行特定机械臂层次的3对自由度的正反向旋转，并使其可视化。 思路步骤： 1、键盘判定按下1、2、3三个按键→按下任意一个按键将其小球修改为红色 2、按下W\S\A\D\E\Q三对按键对3对自由度的旋转进行控制→比如在键盘判定A
mfc二维图形变换
05-24
MFC中可以使用GDI+库来进行二维图形变换。下面是一个简单的示例代码，可以实现平移、旋转、缩放等变换操作： ```c++ // 图形变换操作 void CMyView::Transform(CDC *pDC) { // 定义变换矩阵 Gdiplus::Matrix ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值