Лабораторная работа2 / Bezie

#include <cassert>

struct Point
{
	Point() {}
	Point(double xx, double yy, double zz) : x(xx), y(yy), z(zz) {}
	
	Point operator -(const Point& o)
	{
		double xx, yy, zz;
		xx = x - o.x;
		yy = y - o.y;
		zz = z - o.z;
		return Point(xx, yy, zz);
	}
	double x, y, z;
};


class BezieCurve
{
	friend class BezieSurface;
public:
	BezieCurve() : ready(false) {}
	BezieCurve(const Point& p1, const Point& p2,
		const Point& p3, const Point& p4)
	{ SetCurve(p1, p2, p3, p4); }

	void SetCurve(const Point& p1, const Point& p2,
		const Point& p3, const Point& p4)
	{
		ready = true;

		P[0] = p1;
		P[1] = p2;
		P[2] = p3;
		P[3] = p4;
	}
	Point GetAt(double t)
	{
		assert(ready);
		double x, y, z;
		x = y = z = 0;

		double M[4][4] = { {-1, 3, -3, 1}, {3, -6, 3, 0}, 
		{-3, 3, 0, 0}, {1, 0, 0, 0} };
		double T[4] = { t * t * t, t * t, t, 1 };
		double R[4] = { 0 };

		int i, j;
		for (i = 0; i < 4; i++)
			for (j = 0; j < 4; j++)
				R[i] += T[j] * M[j][i];
		for (i = 0; i < 4; i++) {
			x += R[i] * P[i].x;
			y += R[i] * P[i].y;
			z += R[i] * P[i].z;
		}

		return Point(x, y, z);
	}
	
private:
	bool ready;
	Point P[4];
};


class BezieSurface
{
public:
	BezieSurface() : ready(false) {}
	BezieSurface(const BezieCurve& bc1, const BezieCurve& bc2,
		const BezieCurve& bc3)
	{
		SetSurface(bc1, bc2, bc3);
	}
	void SetSurface(const BezieCurve bc1, const BezieCurve bc2,
		const BezieCurve& bc3)
	{
		ready = true;

		U = bc1;
		V = bc2;
		W = bc3;
	}
	Point GetAt(double u, double v)
	{
		assert(ready);

		Point r1 = V.P[0] - V.P[1];
		Point r2 = V.P[3] - V.P[2];
		Point pt[4];
		pt[0] = U.GetAt(u);
		pt[3] = W.GetAt(u);
		pt[1] = pt[0] - r1;
		pt[2] = pt[3] - r2;

		BezieCurve bc(pt[0], pt[1], pt[2], pt[3]);
		Point result = bc.GetAt(v);

		return result;
	}

private:
	bool ready;
	BezieCurve U, V, W;
};