Описание интерфейса

На рисунках представлены главное окно программы и дочернее окно-канва (далее канва), на котором и производится рисование:

Рисунок 9. Главное окно программы

Рисунок 10. Окно-канва(канва)

В интерфейс главного окна программы входят:

• Выпадающее меню со значение по умолчанию «<Select fractal to draw>», в котором выбирается тип синтезируемого фрактала.

• Кнопка «Draw It!» выполняет рисование фрактала по входным данным с формы.

• Кнопка «Clean Canvas!» очищает канву.

• Кнопка «Show Canvas!» показывает канву в ее текущем состоянии. Если канва уже видна, кнопка заменяется на «Hide Canvas!», которая скрывает канву.

• Набор полей ввода для указания координат исходных точек фракталов для 0-ой итерации. Набор может варьироваться в зависимости от требований фрактала. В случае изменения набора ненужные поля пропадут, а пользователь будет оповещен об изменении и правилах ввода координат. Поля ввода однотипных координат расположены друг под другом, т.е. координата точки будет расположена под координатой точки . Значением по умолчанию для полей ввода является подсказка с предназначением этих полей.

• Поле ввода глубины фрактала.

• Подписи с подсказками:

o Максимальное значение величин.

o Выделенная подсказка говорит «Если вы забыли назначение какого-нибудь поля, удалите значение внутри него, и вы увидите подсказку для него».

Кроме вышеперечисленных полей на форме также присутствуют по умолчанию скрытое поле радиуса основной окружности (для Кругового фрактала) и поле стороны среднего квадрата (для Ковра Серпинского):

Рисунок 11. Главное окно программы с альтернативным набором входных данных

В интерфейс канвы входят следующие элементы:

• Непосредственно канва, на которой будет производиться рисование.

• Меню сохранения изображения. Изображение сохранится по выбранному пользователем адресу в формате *.BMP.

Интерфейс канвы представлен на рисунке 10.

Рисунок 12. Программа с заполненной формой и синтезированным изображением

Заключение

В рамках данного курсового проекта представлены и подробно описаны некоторые виды фракталов, а также алгоритмы их построения. Были рассмотрены проблемы, связанные с синтезом изображений, а также пути их решения.

Результатом выполнения курсового проекта является программный продукт, написанный на языке C++ в среде разработки CodeGear C++ Builder 2009.

В приложении приведены исходные коды, описывающие поля и методы Основной формы, в том числе алгоритмы синтеза фракталов и дополнительные функции, используемые ими.

Список литературы

1. ^[1]Википедия. Свободная энциклопедия.

http://ru.wikipedia.org/

2. ^[2] Visual Basic.

http://rusproject.narod.ru/

3. Wikipedia. The Free Encyclopedia.

http://en.wikipedia.org/

4. Российский общеобразовательный портал.

http://edu.of.ru/

Приложение

#pragma hdrstop

#pragma package(smart_init)

#pragma resource "*.dfm"

#include <vcl.h>

#include "Unit1.h"

#include "Unit2.h"

#include <math.h>

#include <algorithm>

TMainForm *MainForm;

__fastcall TMainForm::TMainForm(TComponent* Owner)

: TForm(Owner)

{

}

const double TO_RAD = 3.141592 / 180;

const int MAGIC_VALUE = 42;

const int ANGLE30 = 30;

const int ANGLE45 = 45;

const int ANGLE60 = 60;

const char AX[] = "<point A coordinate X>";

const char AY[] = "<point A coordinate Y>";

const char BX[] = "<point B coordinate X>";

const char BY[] = "<point B coordinate Y>";

const char FDEPTH[] = "<fractal depth>";

const char CCENTRX[] = "<circle center X>";

const char CCENTRY[] = "<circle center Y>";

const char CRAD[] = "<circle radius>";

const char RECTPOINTX[] = "<center top-left point X>";

const char RECTPOINTY[] = "<center top-left point Y>";

const char RECTSIDE[] = "<center rect side size>";

const char CARPETHINT[] = "Fill form with size of center rectangle side and coordinates of top-left point of this.";

const char CIRCLEHINT[] = "Fill form with large circle center coordinates and radius of this.";

const char NOSELECTION[] = "Please, select fractal type to draw.";

const char VALIDATIONFAILED[] = "There was error while processing data. Please, try to fill form again correctly.";

const char NEQY[] = "Ay must equals By. Please fix it and try again";

const char SIZELIMIT[] = "Size limit excepted. Please, check your input data.";

const int MAX_X = 1024;

const int MAX_Y = 600;

point nullPoint;

/**

* getRadAngle

* Cosine and Sine takes angle in radians!!!

*

* @param int angle: in degrees

* @return double: in radians

*/

double getRadAngle(double angle)

{

return angle * TO_RAD;

}

/**

* getPoint

* Return point with user-defined coordinates

*

* @param double dx: user-defined x

* @param double dy: user-defined y

* @return point result

*/

point getPoint(double dx, double dy)

{

point result;

result.x = dx;

result.y = dy;

return result;

}

/**

* getLength

* Returns distance between two points

*

* @param point a

* @param point b

* @return double

*/

double getLength(point a, point b)

{

return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));

}

/**

* getNewCoord

* Return new point in old coordinates

* x = x' * cosine(alpha) - y' * sine(alpha) + x0

* y = x' * sine(alpha) - y' * cosine(alpha) + y0

*

* @param point p

* @param double angle: dg

* @param double X: move

* @param double Y: move

* @return point result

*/

point getNewCoord(point p, double angle, double xOld, double yOld)

{

point result;

result.x = p.x * cos(getRadAngle(angle))

- p.y * sin(getRadAngle(angle)) + xOld;

result.y = p.x * sin(getRadAngle(angle))

+ p.y * cos(getRadAngle(angle)) + yOld;

return result;

}

/**

* ptGetXn

* Return coordinates of points in step

*

* p5

*

* p3 p4

*

*

* p1 p2

*

* @param double size: size of square side

* @return point result: coordinate

*/

point ptGetX3(double size)

{

point result;

result.x = 0;

result.y = - size;

return result;

}

point ptGetX4(double size)

{

point result;

result.x = size;

result.y = - size;

return result;

}

point ptGetX5(double size)

{

point result;

result.x = size / 2;

result.y = - size - size / 2;

return result;

}

/**

* pithagorasTree

* Draws fractal Pithagoras Tree in Canvas of CanvasForm

*

* @param point p1: root point

* @param point p2: root point

* @param double angle: angle between line p1-p2 and OX

* @param int level: depth of tree

* @return void

*/

void TMainForm::pithagorasTree(point p1, point p2, double angle,int level)

{

if (level -- < 1) {

return;

}

double size = getLength(p1, p2);

point

p3 = getNewCoord(ptGetX3(size), angle, p1.x, p1.y),

p4 = getNewCoord(ptGetX4(size), angle, p1.x, p1.y),

p5 = getNewCoord(ptGetX5(size), angle, p1.x, p1.y)

;

CanvasForm->img->Canvas->MoveTo(p1.x, p1.y);

CanvasForm->img->Canvas->LineTo(p2.x, p2.y);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->LineTo(p4.x, p4.y);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->LineTo(p3.x, p3.y);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->LineTo(p1.x, p1.y);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->MoveTo(p3.x, p3.y);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->LineTo(p5.x, p5.y);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->LineTo(p4.x, p4.y);

canvasStatus(MAGIC_VALUE);

pithagorasTree(p3, p5, angle - ANGLE45, level);

pithagorasTree(p5, p4, angle + ANGLE45, level);

}

/**

* cantorSet

* Draws fractal Cantor Set in Canvas of CanvasForm

*

* @param point p1: begin of level0 line

* @param point p2: end of level0 line

* @param int level: depth of set

* @return void

*/

void TMainForm::cantorSet(point p1, point p2, int level)

{

CanvasForm->img->Canvas->MoveTo(p1.x, p1.y);

CanvasForm->img->Canvas->Brush->Color = clBlack;

CanvasForm->img->Canvas->Rectangle(p1.x, p1.y, p2.x, p2.y + 20);

canvasStatus(MAGIC_VALUE);

if ((level -- < 1) || (getLength(p1, p2) < 1)) {

return;

}

point p1l, p2l, p1r, p2r;

p1l.x = p1.x;

p1l.y = p2.y + 40;

p2l.x = p1.x + (getLength(p1, p2) / 3);

p2l.y = p2.y + 40;

p1r.x = p2.x - (getLength(p1, p2) / 3);

p1r.y = p2.y + 40;

p2r.x = p2.x;

p2r.y = p2.y + 40;

cantorSet(p1l, p2l, level);

cantorSet(p1r, p2r, level);

}

/**

* kochCurve

* Draws fractal Koch Curve in Canvas of CanvasForm

*

* @param point p1: begin of level0 line

* @param point p2: end of level0 line

* @param double angle: angle between line p1-p2 and OX

* @param int level: depth of curve

* @return void

*/

void TMainForm::kochCurve(point p1, point p2, double angle, int level)

{

if (level -- < 1) {

CanvasForm->img->Canvas->MoveTo(p1.x, p1.y);

CanvasForm->img->Canvas->LineTo(p2.x, p2.y);

canvasStatus(MAGIC_VALUE);

return;

}

point p3 = getNewCoord(

getPoint(getLength(p1, p2) / 3, 0),

angle,

p1.x,

p1.y

),

p4 = getNewCoord(

getPoint(getLength(p1, p2) / 3 * 2, 0),

angle,

p1.x,

p1.y

),

p5 = getNewCoord(

getPoint(

getLength(p3, p4) / 2,

- (getLength(p3, p4) / 2) * tan(getRadAngle(ANGLE60))

),

angle,

p3.x,

p3.y

);

CanvasForm->img->Canvas->Rectangle(std::min(p1.x, p2.x), std::max(p1.y, p2.y), std::max(p1.x, p2.x), std::min(p1.y, p2.y));

CanvasForm->img->Canvas->MoveTo(p1.x, p1.y);

CanvasForm->img->Canvas->LineTo(p3.x, p3.y);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->MoveTo(p4.x, p4.y);

CanvasForm->img->Canvas->LineTo(p2.x, p2.y);

canvasStatus(MAGIC_VALUE);

kochCurve(p1, p3, angle, level);

kochCurve(p4, p2, angle, level);

kochCurve(p3, p5, angle - ANGLE60, level);

kochCurve(p5, p4, angle + ANGLE60, level);

}

/**

* dragonCurve

* Draws fractal Dragon Curve in Canvas of CanvasForm

*

* @param point p1: begin of level0 line

* @param point p2: end of level0 line

* @param int level: depth of curve

* @return void

*/

void TMainForm::dragonCurve(point p1, point p2, int level)

{

if (level == 0){

CanvasForm->img->Canvas->MoveTo(p1.x, p1.y);

CanvasForm->img->Canvas->LineTo(p2.x, p2.y);

canvasStatus(MAGIC_VALUE);

return;

}

point p = getPoint(

(p1.x + p2.x) / 2 + (p2.y - p1.y) / 2,

(p1.y + p2.y) / 2 - (p2.x - p1.x) / 2

);

dragonCurve(p2, p, level - 1);

dragonCurve(p1, p, level - 1);

}

/**

* rounds

* Draws Round Fractal in Canvas of CanvasForm

*

* @param point p1: coordinates of level0 round's center

* @param point p2: end of level0 line

* @param int level: depth of curve

* @return void

*/

void TMainForm::rounds(point p, int r, int level)

{

CanvasForm->img->Canvas->Brush->Color = clWhite;

CanvasForm->img->Canvas->Ellipse(p.x - r, p.y - r, p.x + r, p.y + r);

canvasStatus(MAGIC_VALUE);

if (level -- < 1) {

return;

}

r /= 3;

CanvasForm->img->Canvas->Ellipse(p.x - r, p.y - r, p.x + r, p.y + r);

canvasStatus(MAGIC_VALUE);

rounds(getPoint(p.x, p.y), r, level);

CanvasForm->img->Canvas->Ellipse(p.x - r, (p.y - 2 * r) - r, p.x + r, (p.y - 2 * r) + r);

canvasStatus(MAGIC_VALUE);

rounds(getPoint(p.x, p.y - 2 * r), r, level);

CanvasForm->img->Canvas->Ellipse(p.x - r, (p.y + 2 * r) - r, p.x + r, (p.y + 2 * r) + r);

canvasStatus(MAGIC_VALUE);

rounds(getPoint(p.x, p.y + 2 * r), r, level);

CanvasForm->img->Canvas->Ellipse(

p.x - 2 * r * cos(getRadAngle(ANGLE30)) - r,

p.y - 2 * r * sin(getRadAngle(ANGLE30)) - r,

p.x - 2 * r * cos(getRadAngle(ANGLE30)) + r,

p.y - 2 * r * sin(getRadAngle(ANGLE30)) + r

);

canvasStatus(MAGIC_VALUE);

rounds(

getPoint(p.x - 2 * r * cos(getRadAngle(ANGLE30)),

p.y - 2 * r * sin(getRadAngle(ANGLE30))),

r,

level

);

CanvasForm->img->Canvas->Ellipse(

p.x + 2 * r * cos(getRadAngle(ANGLE30)) - r,

p.y - 2 * r * sin(getRadAngle(ANGLE30)) - r,

p.x + 2 * r * cos(getRadAngle(ANGLE30)) + r,

p.y - 2 * r * sin(getRadAngle(ANGLE30)) + r

);

canvasStatus(MAGIC_VALUE);

rounds(

getPoint(p.x + 2 * r * cos(getRadAngle(ANGLE30)),

p.y - 2 * r * sin(getRadAngle(ANGLE30))),

r,

level

);

CanvasForm->img->Canvas->Ellipse(

p.x - 2 * r * cos(getRadAngle(ANGLE30)) - r,

p.y + 2 * r * sin(getRadAngle(ANGLE30)) - r,

p.x - 2 * r * cos(getRadAngle(ANGLE30)) + r,

p.y + 2 * r * sin(getRadAngle(ANGLE30)) + r

);

canvasStatus(MAGIC_VALUE);

rounds(

getPoint(p.x - 2 * r * cos(getRadAngle(ANGLE30)),

p.y + 2 * r * sin(getRadAngle(ANGLE30))),

r,

level

);

CanvasForm->img->Canvas->Ellipse(

p.x + 2 * r * cos(getRadAngle(ANGLE30)) - r,

p.y + 2 * r * sin(getRadAngle(ANGLE30)) - r,

p.x + 2 * r * cos(getRadAngle(ANGLE30)) + r,

p.y + 2 * r * sin(getRadAngle(ANGLE30)) + r

);

canvasStatus(MAGIC_VALUE);

rounds(

getPoint(p.x + 2 * r * cos(getRadAngle(ANGLE30)),

p.y + 2 * r * sin(getRadAngle(ANGLE30))),

r,

level

);

}

/**

* rounds

* Draws fractal Sierpinski Carpet in Canvas of CanvasForm

*

* @param point p1: coordinates of top-left point of central rectangle

* @param int size: size of rectangle side

* @param int level: depth of carpet

* @return void

*/

void TMainForm::sierpinskiCarpet(point a, double size, int level)

{

if (level -- < 1) {

return;

}

CanvasForm->img->Canvas->Brush->Color = clBlack;

CanvasForm->img->Canvas->Rectangle(a.x, a.y, a.x + size, a.y + size);

canvasStatus(MAGIC_VALUE);

CanvasForm->img->Canvas->Rectangle(

a.x - size / 3,

a.y - size / 3,

a.x - size / 3 * 2,

a.y - size / 3 * 2

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x - size / 3 * 2, a.y - size / 3 * 2),

size / 3,

level

);

CanvasForm->img->Canvas->Rectangle(

a.x + size / 3,

a.y - size / 3,

a.x + size / 3 * 2,

a.y - size / 3 * 2

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x + size / 3, a.y - size / 3 * 2),

size / 3,

level

);

CanvasForm->img->Canvas->Rectangle(

a.x + size / 3 * 4,

a.y - size / 3,

a.x + size / 3 * 5,

a.y - size / 3 * 2

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x + size / 3 * 4, a.y - size / 3 * 2),

size / 3,

level

);

CanvasForm->img->Canvas->Rectangle(

a.x - size / 3,

a.y + size / 3,

a.x - size / 3 * 2,

a.y + size / 3 * 2

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x - size / 3 * 2, a.y + size / 3),

size / 3,

level

);

CanvasForm->img->Canvas->Rectangle(

a.x + size / 3 * 4,

a.y + size / 3,

a.x + size / 3 * 5,

a.y + size / 3 * 2

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x + size / 3 * 4, a.y + size / 3),

size / 3,

level

);

CanvasForm->img->Canvas->Rectangle(

a.x - size / 3,

a.y + size / 3 * 4,

a.x - size / 3 * 2,

a.y + size / 3 * 5

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x - size / 3 * 2, a.y + size / 3 * 4),

size / 3,

level

);

CanvasForm->img->Canvas->Rectangle(

a.x + size / 3,

a.y + size / 3 * 4,

a.x + size / 3 * 2,

a.y + size / 3 * 5

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x + size / 3, a.y + size / 3 * 4),

size / 3,

level

);

CanvasForm->img->Canvas->Rectangle(

a.x + size / 3 * 4,

a.y + size / 3 * 4,

a.x + size / 3 * 5,

a.y + size / 3 * 5

);

canvasStatus(MAGIC_VALUE);

sierpinskiCarpet(

getPoint(a.x + size / 3 * 4, a.y + size / 3 * 4),

size / 3,

level

);

}

/**

* validate

* Check form fill

*

* @param int type: to check B or r

* @return bool: true if is valid

*/

bool TMainForm::validate(int type)

{

if ((eAx->Text[1] == '<') || (eAy->Text[1] == '<') ||

(fractLevel->Text[1] == '<')) {

return false;

}

switch (type) {

case 1: {

if ((eBx->Text[1] == '<') || (eBy->Text[1] == '<')) {

return false;

}

break;

}

case 2: {

if (eRad->Text[1] == '<') {

return false;

}

break;

}

default: {break;};

};

return true;

}

/**

* canvasStatus

* Changes Canvas Form Visible value

*

* @param int type: 0 for button, 1 for action

* @return void

*/

void TMainForm::canvasStatus(int type)

{

if (type == 0) {

if (CanvasForm->Visible == false) {

CanvasForm->Left = Left + Width + 20;

CanvasForm->Visible = true;

hideCanvasButton->Caption = "Hide Canvas!";

} else {

CanvasForm->Visible = false;

hideCanvasButton->Caption = "Show Canvas!";

}

} else {

CanvasForm->img->Refresh();

CanvasForm->Refresh();

CanvasForm->Left = Left + Width + 20;

CanvasForm->Visible = true;

hideCanvasButton->Caption = "Hide Canvas!";

}

}

void __fastcall TMainForm::FormCreate(TObject *Sender)

{

nullPoint.x = 0;

nullPoint.y = 0;

}

void __fastcall TMainForm::fractListDropDown(TObject *Sender)

{

addOptPanel->Top = 130;

Height += 84;

}

void __fastcall TMainForm::fractListCloseUp(TObject *Sender)

{

addOptPanel->Top = 46;

Height -= 84;

}

void __fastcall TMainForm::eAxChange(TObject *Sender)

{

if (fractList->ItemIndex == 5) {

if (eAx->Text.Length() == 0 &&!eAx->Focused()) {

eAx->Text = CCENTRX;

}

} else if (fractList->ItemIndex == 6) {

if (eAx->Text.Length() == 0 &&!eAx->Focused()) {

eAx->Text = RECTPOINTX;

}

} else {

if (eAx->Text.Length() == 0 &&!eAx->Focused()) {

eAx->Text = AX;

}

}

}

void __fastcall TMainForm::eAxClick(TObject *Sender)

{

if (fractList->ItemIndex == 5) {

if (eAx->Text == CCENTRX) {

eAx->Text = "";

}

} else if (fractList->ItemIndex == 6) {

if (eAx->Text == RECTPOINTX) {

eAx->Text = "";

}

} else {

if (eAx->Text == AX) {

eAx->Text = "";

}

}

}

void __fastcall TMainForm::eAyChange(TObject *Sender)

{

if (fractList->ItemIndex == 5) {

if (eAy->Text.Length() == 0 &&!eAy->Focused()) {

eAy->Text = CCENTRY;

}

} else if (fractList->ItemIndex == 6) {

if (eAy->Text.Length() == 0 &&!eAy->Focused()) {

eAy->Text = RECTPOINTY;

}

} else {

if (eAy->Text.Length() == 0 &&!eAy->Focused()) {

eAy->Text = AY;

}

}

}

void __fastcall TMainForm::eAyClick(TObject *Sender)

{

if (fractList->ItemIndex == 5) {

if (eAy->Text == CCENTRY) {

eAy->Text = "";

}

} else if (fractList->ItemIndex == 6) {

if (eAy->Text == RECTPOINTY) {

eAy->Text = "";

}

} else {

if (eAy->Text == AY) {

eAy->Text = "";

}

}

}

void __fastcall TMainForm::eBxChange(TObject *Sender)

{

if (eBx->Text.Length() == 0 &&!eBx->Focused()) {

eBx->Text = BX;

}

}

void __fastcall TMainForm::eBxClick(TObject *Sender)

{

if (eBx->Text == BX) {

eBx->Text = "";

}

}

void __fastcall TMainForm::eByChange(TObject *Sender)

{

if (eBy->Text.Length() == 0 &&!eBy->Focused()) {

eBy->Text = BY;

}

}

void __fastcall TMainForm::eByClick(TObject *Sender)

{

if (eBy->Text == BY) {

eBy->Text = "";

}

}

void __fastcall TMainForm::fractLevelChange(TObject *Sender)

{

if (fractLevel->Text.Length() == 0 &&!fractLevel->Focused()) {

fractLevel->Text = FDEPTH;

}

}

void __fastcall TMainForm::fractLevelClick(TObject *Sender)

{

if (fractLevel->Text == FDEPTH) {

fractLevel->Text = "";

}

}

void __fastcall TMainForm::eRadChange(TObject *Sender)

{

if (eRad->Text.Length() == 0 &&!eRad->Focused()) {

if (fractList->ItemIndex == 4) {

eRad->Text = CRAD;

} else {

eRad->Text = RECTSIDE;

}

}

}

void __fastcall TMainForm::eRadClick(TObject *Sender)

{

if (eRad->Text == CRAD || eRad->Text == RECTSIDE) {

eRad->Text = "";

}

}

void __fastcall TMainForm::drawButtonClick(TObject *Sender)

{

point a;

point b;

int r;

int level;

switch (fractList->ItemIndex) {

case 1: {

if (!validate(1)) {

ShowMessage(VALIDATIONFAILED);

return;

}

a.x = eAx->Text.ToDouble();

a.y = CanvasForm->ClientHeight - eAy->Text.ToDouble();

b.x = eBx->Text.ToDouble();

b.y = CanvasForm->ClientHeight - eBy->Text.ToDouble();

if (a.x > b.x) {

std::swap(a, b);

}

if ((a.x > MAX_X) || (b.x > MAX_X) || (a.y > MAX_Y) || (b.y > MAX_Y)) {

ShowMessage(SIZELIMIT);

return;

}

if (a.y!= b.y) {

ShowMessage(NEQY);

return;

}

canvasStatus(1);

level = fractLevel->Text.ToInt();

lbProcess->Visible = true;

Refresh();

cantorSet(a, b, level);

lbProcess->Visible = false;

break;

}

case 2: {

if (!validate(1)) {

ShowMessage(VALIDATIONFAILED);

return;

}

a.x = eAx->Text.ToDouble();

a.y = CanvasForm->ClientHeight - eAy->Text.ToDouble();

b.x = eBx->Text.ToDouble();

b.y = CanvasForm->ClientHeight - eBy->Text.ToDouble();

if (a.x > b.x) {

std::swap(a, b);

}

if ((a.x > MAX_X) || (b.x > MAX_X) || (a.y > MAX_Y) || (b.y > MAX_Y)) {

ShowMessage(SIZELIMIT);

return;

}

canvasStatus(1);

level = fractLevel->Text.ToInt();

lbProcess->Visible = true;

Refresh();

dragonCurve(a, b, level);

lbProcess->Visible = false;

break;

}

case 3: {

if (!validate(1)) {

ShowMessage(VALIDATIONFAILED);

return;

}

a.x = eAx->Text.ToDouble();

a.y = CanvasForm->ClientHeight - eAy->Text.ToDouble();

b.x = eBx->Text.ToDouble();

b.y = CanvasForm->ClientHeight - eBy->Text.ToDouble();

if (a.x > b.x) {

std::swap(a, b);

}

if ((a.x > MAX_X) || (b.x > MAX_X) || (a.y > MAX_Y) || (b.y > MAX_Y)) {

ShowMessage(SIZELIMIT);

return;

}

if (a.y!= b.y) {

ShowMessage(NEQY);

return;

}

canvasStatus(1);

level = fractLevel->Text.ToInt();

lbProcess->Visible = true;

Refresh();

kochCurve(a, b, 0, level);

lbProcess->Visible = false;

break;

}

case 4: {

if (!validate(1)) {

ShowMessage(VALIDATIONFAILED);

return;

}

a.x = eAx->Text.ToDouble();

a.y = CanvasForm->ClientHeight - eAy->Text.ToDouble();

b.x = eBx->Text.ToDouble();

b.y = CanvasForm->ClientHeight - eBy->Text.ToDouble();

if (a.x > b.x) {

std::swap(a, b);

}

if ((a.x > MAX_X) || (b.x > MAX_X) || (a.y > MAX_Y) || (b.y > MAX_Y)) {

ShowMessage(SIZELIMIT);

return;

}

if (a.y!= b.y) {

ShowMessage(NEQY);

return;

}

canvasStatus(1);

level = fractLevel->Text.ToInt();

lbProcess->Visible = true;

Refresh();

pithagorasTree(a, b, 0, level);

lbProcess->Visible = false;

break;

}

case 5: {

if (!validate(2)) {

ShowMessage(VALIDATIONFAILED);

return;

}

a.x = eAx->Text.ToDouble();

a.y = CanvasForm->ClientHeight - eAy->Text.ToDouble();

if ((a.x > MAX_X) || (a.y > MAX_Y)) {

ShowMessage(SIZELIMIT);

return;

}

canvasStatus(1);

r = eRad->Text.ToInt();

level = fractLevel->Text.ToInt();

lbProcess->Visible = true;

Refresh();

rounds(a, r, level);

lbProcess->Visible = false;

break;

}

case 6: {

if (!validate(2)) {

ShowMessage(VALIDATIONFAILED);

return;

}

a.x = eAx->Text.ToDouble();

a.y = CanvasForm->ClientHeight - eAy->Text.ToDouble();

if ((a.x > MAX_X) || (a.y > MAX_Y)) {

ShowMessage(SIZELIMIT);

return;

}

canvasStatus(1);

r = eRad->Text.ToInt();

level = fractLevel->Text.ToInt();

lbProcess->Visible = true;

Refresh();

sierpinskiCarpet(a, r, level);

lbProcess->Visible = false;

break;

}

default: {

ShowMessage(NOSELECTION);

fractList->ItemIndex = 0;

return;

}

};

}

void __fastcall TMainForm::cleanCanvasButtonClick(TObject *Sender)

{

CanvasForm->img->Canvas->Brush->Color = clWhite;

CanvasForm->img->Canvas->FillRect(TRect(0, 0, CanvasForm->img->Width, CanvasForm->img->Height));

CanvasForm->Refresh();

}

void __fastcall TMainForm::hideCanvasButtonClick(TObject *Sender)

{

canvasStatus(0);

}

void __fastcall TMainForm::fractListChange(TObject *Sender)

{

switch (fractList->ItemIndex) {

case 0: {

break;

}

case 5: {

eBx->Visible = false;

eBy->Visible = false;

eRad->Visible = true;

if (eAx->Text[1] == '<') eAx->Text = CCENTRX;

if (eAy->Text[1] == '<') eAy->Text = CCENTRY;

if (eRad->Text[1] == '<') eRad->Text = CRAD;

ShowMessage(CIRCLEHINT);

break;

}

case 6: {

eBx->Visible = false;

eBy->Visible = false;

eRad->Visible = true;

if (eAx->Text[1] == '<') eAx->Text = RECTPOINTX;

if (eAy->Text[1] == '<') eAy->Text = RECTPOINTY;

if (eRad->Text[1] == '<') eRad->Text = RECTSIDE;

ShowMessage(CARPETHINT);

break;

}

default: {

eRad->Visible = false;

eBx->Visible = true;

eBy->Visible = true;

if (eBx->Text[1] == '<') eBx->Text = BX;

if (eBy->Text[1] == '<') eBy->Text = BY;

break;

}

};

}

Поиск по сайту: