Клас чотирикутника

4.3. Клас чотирикутника

Цей клас зберігає та обробляє дані чотирикутника.

#pragma once

#include "IDrawable.h"

#include "GLPoint.h"

#include "GLSegment.h"

#include "Exceptions.h"

ref class GLRectangle : IDrawable

{

public:

GLRectangle();

~GLRectangle() {};

//створення нового чотирикутника

void Set(GLPoint^ pt1, GLPoint^ pt2, GLPoint^ pt3, GLPoint^ pt4);

void Set(array<GLPoint^>^ pts);

//функція малювання

virtual void Draw() override;

double Square();

double Perimeter();

bool IsOnPlane();

private:

//чи розташовані всі вершини у одній площині

bool _isOnPlane;

double _square;

double _perimeter;

void countIsONPlane();

void countSquare();

void countPerimeter();

static double countPolygonSquare(GLPoint^ p1, GLPoint^p2, GLPoint^ p3);

array<GLPoint^>^ _points;

array<GLSegment^>^ _sides;

};

#include "GLRectangle.h"

GLRectangle::GLRectangle() {}

void GLRectangle::Set(GLPoint^ pt1, GLPoint^ pt2, GLPoint^ pt3, GLPoint^ pt4)

{

array<GLPoint^>^ points = gcnew array<GLPoint^>(4);

points[0] = pt1;

points[1] = pt2;

points[2] = pt3;

points[3] = pt4;

this->Set(points);

}

void GLRectangle::Set(array<GLPoint^>^ pts)

{

if (pts->Length != 4)

return;

this->_square = 0;

this->_points = pts;

for (int i = 3; i > 0; i--)

for (int j = 0; j < i; j++)

if (_points[i]->Equal(_points[j]))

throw gcnew MyException::InvalidRectangleException(this);

this->Flat = _points[0]->Flat;

this->_sides = gcnew array<GLSegment^>(4);

for (int i = 0; i < 4; i++)

{

_sides[i] = gcnew GLSegment(_points[i % 4], _points[(i + 1) % 4]);

_sides[i]->Flat = _points[0]->Flat;

//перевіряємо, що фігура має 4 кути

GLSegment^ checkerNear = gcnew GLSegment(_points[i % 4], _points[(i + 1) % 4]);

GLSegment^ checkerFar = gcnew GLSegment(_points[i % 4], _points[(i + 2) % 4]);

if (checkerFar->Contains(_points[(i + 1) % 4]) || checkerNear->Contains(_points[(i + 2) % 4]) || checkerNear->Contains(_points[(i + 3) % 4]))

{

this->_isOnPlane = true;

this->_square = -1;

}

}

countPerimeter();

if (_square == 0)

{

countIsONPlane();

if (this->_isOnPlane)

countSquare();

else

this->_square = -1;

}

}

void GLRectangle::Draw()

{

glBegin(GL_LINE_LOOP);

glColor3f(_r, _g, _b);

if (Flat)

{

for(int i = 0; i < 4; i++)

glVertex2f(_points[i]->X, _points[i]->Y);

}

else

{

for (int i = 0; i < 4; i++)

glVertex3f(_points[i]->X, _points[i]->Y, _points[i]->Z);

}

glEnd();

}

double GLRectangle::Square()

{

return this->_square;

}

double GLRectangle::Perimeter()

{

return this->_perimeter;

}

bool GLRectangle::IsOnPlane()

{

return this->_isOnPlane;

}

void GLRectangle::countIsONPlane()

{

//визначник матриці площини чотирикутника

double surfaceDet =

_points[0]->X * (_points[3]->Z * (_points[1]->Y - _points[2]->Y)

- _points[1]->Y * _points[2]->Z + _points[1]->Z * (_points[2]->Y - _points[3]->Y)

+ _points[3]->Y * _points[2]->Z) +

_points[1]->X * (_points[3]->Z * (_points[2]->Y - _points[0]->Y)

+ _points[0]->Y * _points[2]->Z - _points[2]->Y * _points[0]->Z + _points[3]->Y

* (_points[0]->Z - _points[2]->Z)) +

_points[2]->X * (_points[3]->Z * (_points[0]->Y - _points[1]->Y) - _points[0]->Y

* _points[1]->Z + _points[1]->Y * _points[0]->Z - _points[3]->Y * _points[0]->Z

+ _points[3]->Y * _points[1]->Z) +

_points[3]->X * _points[0]->Y * (_points[1]->Z - _points[2]->Z) + _points[3]->X

* (_points[1]->Y * (_points[2]->Z - _points[0]->Z) + _points[2]->Y * _points[0]->Z

- _points[2]->Y * _points[1]->Z);

//якщо визначник нуль, то всі чотири точки у одній площині

if (Math::Abs(surfaceDet) < Constants::DELTA)

this->_isOnPlane = true;

else

this->_isOnPlane = false;

}

void GLRectangle::countSquare()

{

//якщо чотирикутник самоперетинаючий

GLSegment::CrossAnswer^ cross1 = _sides[0]->Cross(_sides[2]);

GLSegment::CrossAnswer^ cross2 = _sides[1]->Cross(_sides[3]);

if (cross1->Type == GLSegment::CrossAnswer::CrossType::POINT)

{

double p1 = countPolygonSquare(_points[0], cross1->Point1, _points[3]);

double p2 = countPolygonSquare(_points[1], cross1->Point1, _points[2]);

if (Math::Abs(p1) < Constants::DELTA || Math::Abs(p2) < Constants::DELTA)

{

this->_square = 0.;

return;

}

this->_square = p1 + p2;

return;

}

else if (cross2->Type == GLSegment::CrossAnswer::CrossType::POINT)

{

double p1 = countPolygonSquare(_points[0], cross2->Point1, _points[1]);

double p2 = countPolygonSquare(_points[2], cross2->Point1, _points[3]);

if (Math::Abs(p1) < Constants::DELTA || Math::Abs(p2) < Constants::DELTA)

{

this->_square = 0.;

return;

}

this->_square = p1 + p2;

return;

}

else

{

this->_square =

countPolygonSquare(_points[0], _points[1], _points[2]) +

countPolygonSquare(_points[0], _points[3], _points[2]);

return;

}

}

void GLRectangle::countPerimeter()

{

double perim = 0;

for (int i = 0; i < 4; i++)

perim += _sides[i]->Magnitude();

this->_perimeter = perim;

}

double GLRectangle::countPolygonSquare(GLPoint^ p1, GLPoint^p2, GLPoint^ p3)

{

//сторони

double a = GLSegment::Magnitude(p1, p2);

double b = GLSegment::Magnitude(p2, p3);

double c = GLSegment::Magnitude(p3, p1);

//півпериметр

double p = (a + b + c) / 2;

return Math::Sqrt(p * (p - a) * (p - b) * (p - c));

}