|
Читайте также: |
Плюсы:
· Быстрая скорость работы
· Большая коллекция фракталов
· Наличие настроек
Минусы:
· Не обнаружены
Интерфейс:
1.3 Постановка задачи
В задачу курсового проекта входит:
· Разработать программное средство на языке С++ способное выполнять построение фракталов.
· Программное средство должно выполнять следующие функции:
o Построение фрактала
o Отображение хода построения фрактала
o Копирование фрактала в буфер обмена
o Очистка рабочей области
· Реализовать понятный и удобный для пользователя интерфейс программного средства.
Таким образом, задача данного курсового проекта сводится к разработке программного средства, способного строить простые геометрические фракталы и выводить их на экран, отображая при этом ход построения, а также обеспечению возможности дальнейшей работы с полученным изображением фрактала, например в среде Adobe Photoshop для получения конечного изображения, необходимого для создания, например логотипа, витража и т.д.
2. Разработка программы для рисования фракталов
2.1 Виды реализуемых фракталов
В программе планируется реализовать следующие виды простых геометрических фракталов:
· Квадрат Серпинского
· 
· Треугольник Серпинского
· Спиральный квадрат
· Фрактал на основе треугольников
· Фрактал на основе квадратов
· Бинарное дерево
· H-фрактал
· Дерево, реализованное в виде окружности
Так же планируется реализовать алгебраический фрактал:
· Множество Мандельброта
2.2 Требования к программе для построения фракталов
Необходимо написать программу на С++, которая смогла бы строить фракталы и предоставлять возможность дальнейшей работы с нарисованным фракталом, например посредством копирования изображения в буфер обмена. В связи с этим к программе предъявляются следующие требования:
1. Интерфейс.
Интерфейс программного средства будет содержать рабочую область, в которой и будет отображаться построение фрактала и сам фрактал. Так же должно быть меню, в котором будут находиться пункты, соответствующие выполняемым функциям. Так же в процессе вызова некоторых функций, пользователю будет представлена возможность ввода дополнительных параметров настроек изображения.
2. Функциональность.
Данная программа должна выполнять следующие требования:
o Предоставлять пользователю выбор фрактала для построения из меню
o Строить фрактал с выводом промежуточных кадров
o Давать возможность скопировать полученное изображение в буфер обмена
o Иметь возможность очистить рабочую область
3. Оптимальность используемых алгоритмов. Все используемые алгоритмы протестированы на оптимальность, дальнейшее их улучшение имеет смысла.
4. Совместимость. Данное программное средство совместимо с операционными системами семейства Windows, такими как XP и Windows7.
5. Среда разработки. Средой разработки данного программного средства выбран C++ Buider 2010 от Borland. Выбор остановился на этой среде разработки потому, как в ней реализовано множество полезных классов, как для работы с графикой, так и для работы с формой и меню. В данном проекте нам пригодятся классы TMainMenu – отвечает за отображение меню и обработку нажатий клавиш меню, класс TImage – класс при помощи которого фракталы будут отображаться в рабочей области.
2.3 Принцип работы
В основе всех фракталов находится класс Fractal, от которого наследуются все остальные фракталы, в классе Fractal имеется метод Draw(), который перекрывается в классах наследниках.
Упрощенная схема работы приложения будет выглядеть так:
|
|
Пользователь выбирает пункт меню, нажимает его, выполняется обработка события в ходе которого создается класс нужного нам фрактала, и у объекта данного класса вызывается метод Draw(), который благодаря классу TImage рисует выбранный фрактал в рабочей области.
В программе имеются вспомогательные функции: Копировать в буфер обмена, очистить рабочую область, about и exit, который не отображены в данных схемах.
3. Методика работы с полученной программой
Интерфейс полученной программы состоит из Меню, и рабочей области, которая по умолчанию пуста.
Основное меню выбора фракталов:
Продемонстрируем работу с программой:
Выберем пункт меню BinaryTree. В появившихся диалоговых окнах введем нужные нам параметры, такие как угол наклона к оси X, угол наклона к оси Y (угол вводится как Pi/(введённое число)), глубина рекурсии (чем меньше число – тем больше ветвлений будет иметь дерево, например при 1 – дерево будет очень «кучерявым», при 3 – на порядок меньше). Введем параметры, угол наклона к оси X = Pi/3, угол наклона к оси Y = Pi/5, глубина рекурсии = 3; На экране отобразится процесс построения бинарного дерева. По окончанию построения можно скопировать изображение в буфер обмена, выбрав пункт в меню.
Вот результат работы программы.
Аналогичным образом работают и остальные пункты меню.
Вот например, фрактал на основе квадратов
Продемонстрируем практическую часть курсового проекта, как было сказано ранее, сгенерированные изображения можно использовать для их последующей обработки и получения конечного изображения, которое нам необходимо.
В примере мы построим фрактал TreeCircle, скопируем его в буфер обмена, и продолжим его редактирование в среде Adobe Photoshop.
Запустим нашу программу, выберем пункт меню TreeCircle, введем информацию которую программа запрашивает, количество ветвлений = 4, количество отростков = 5, радиус = 80, коэффициент уменьшения 5, т.е 0.5 в итоге.
Результат построения фрактала вы видите ниже:
Вставляем изображение в Adobe Photoshop и даем волю фантазии.
Результат полета фантазии вы видите на экране. Без нашей программы реализация данной задумки была бы очень проблематична.
Заключение
В результате работы над курсовым проектом было разработано программное средство для построения фракталов.
В ходе работы над проектом было изучено много информации по теме фракталов и фрактальной математики. Были рассмотрены принципы построения геометрических фракталов, и выбраны наиболее интересные и оптимальные варианты для их последующей реализации в алгоритмах программы.
Для каждого фрактала был создан отдельный класс, который содержал методы и переменные для построения выбранного фрактала.
Так же были рассмотрены аналоги данной программы: Apophysis 7x, Fractal Fripperies Fractal Explorer, Fractal Editor, FractInt. Проанализированы их плюсы и недостатки, и выбраны именно те качества, которые мы хотели видеть в своей программе. Это понятный пользователю интерфейс, возможность выбора фрактала из списка для дальнейшего его построение. Так же в отличие от всех аналогов, наше программное средство в процессе построения фрактала выводит его промежуточные состояния, то есть наглядно демонстрирует принцип работы алгоритмов построения. Была добавлена возможность копирования полученного изображения в буфер обмена для дальнейшей работы с изображением.
Были изучены возможности работы с графикой в среде С++, а именно работа с компонентами среды разработки C++ Builder от Borland.
Разработанное программное средство представляет собой законченный продукт, готовый к использованию. Однако при желании функционал программы можно расширить, добавив новые функции, например сохранение полученного изображения в файл, или, например сделать фракталы цветными, можно написать алгоритмы для построения новых фракталов, так как в программе реализованы далеко не все возможные фракталы. Так же в качестве улучшения можно рассматривать переход от 2D изображений фракталов к 3D. Многие из фракталов очень красиво «строятся», поэтому можно рассматривать использование программы в качестве заставки на рабочий стол.
Список использованных источников
1. Морозов А.Д. Введение в теорию фракталов. Москва-Ижевск: Институт компьютерных исследований, 2002, 160с.
2. Пайтген Х.-О. Рихтер П.Х. Красота фракталов. Образы комплексных динамических систем. Издательство: Мир Год: 1993 Страниц: 206
3. Фрактальная геометрия природы Б.Мандельброт Издательство: Институт компьютерных исследований, 2002, Страниц: 656
4. Сайт http://fractalworld.xaoc.ru – теория и принципы алгоритмов
5. Cайт http://Wikipedia.org - теория
6. Сайт http://fractals.narod.ru/ - множество литературы по фракталам
Приложение 1. Исходный код
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Menus.hpp>
#include <ExtCtrls.hpp>
#include <Keyboard.hpp>
#include "BinaryTree.h"
#include "Mandelbrot.h"
#include "SquareSerpinsky.h"
#include "TriangleSerpinsky.h"
#include "SpiralSquare.h"
#include "HFractal.h"
#include "TreeCircle.h"
#include "TriangleFract.h"
#include "Square.h"
//---------------------------------------------------------------------------
class TForm1: public TForm
{
__published: // IDE-managed Components
TMainMenu *MainMenu1;
TMenuItem *File1;
TMenuItem *Edit1;
TMenuItem *Fractals1;
TMenuItem *About1;
TMenuItem *Exit1;
TMenuItem *About2;
TImage *Image1;
TMenuItem *est1;
TMenuItem *CopytoClipboard1;
TMenuItem *riangle1;
TMenuItem *Clear1;
TMenuItem *riangleSerpinsky1;
TMenuItem *SpiralSquare1;
TMenuItem *SquareSerpinsky1;
TMenuItem *HFractal1;
TMenuItem *reeCircle1;
TMenuItem *MandelBrot1;
TMenuItem *BinaryTree1;
void __fastcall About2Click(TObject *Sender);
void __fastcall CopytoClipboard1Click(TObject *Sender);
void __fastcall riangle1Click(TObject *Sender);
void __fastcall Clear1Click(TObject *Sender);
void __fastcall Exit1Click(TObject *Sender);
void __fastcall riangleSerpinsky1Click(TObject *Sender);
void __fastcall SpiralSquare1Click(TObject *Sender);
void __fastcall est1Click(TObject *Sender);
void __fastcall SquareSerpinsky1Click(TObject *Sender);
void __fastcall HFractal1Click(TObject *Sender);
void __fastcall reeCircle1Click(TObject *Sender);
void __fastcall FormResize(TObject *Sender);
void __fastcall MandelBrot1Click(TObject *Sender);
void __fastcall BinaryTree1Click(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit2.h"
#include "Conio.h"
#include "Unit1.h"
#include "Math.h"
#include "String.h"
#include <vcl\Clipbrd.hpp>
#define DEPTH 100
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
TImage *Image1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
//Показываем about
void __fastcall TForm1::About2Click(TObject *Sender)
{
Form2->Show();
}
//---------------------------------------------------------------------------
//Очиска экрана
void ClearImage(TImage *Image1)
{
Image1->Canvas->Pen->Color = clWhite;
Image1->Canvas->FillRect(Rect(0,0,Image1->Width,Image1->Height));
Image1->Canvas->Pen->Color = clBlack;
Image1->Canvas->Pen->Width = 1;
}
//---------------------------------------------------------------------------
//Копируем изображение в буфер обмена
void __fastcall TForm1::CopytoClipboard1Click(TObject *Sender)
{
Clipboard()->Assign(Image1->Picture);
}
//---------------------------------------------------------------------------
//Рисуем фрактал на основе треугольников
void __fastcall TForm1::riangle1Click(TObject *Sender)
{
ClearImage(Image1);
TriangleFract Triangle(Image1);
Triangle.Draw();
}
//---------------------------------------------------------------------------
//Очистка экрана
void __fastcall TForm1::Clear1Click(TObject *Sender)
{
ClearImage(Image1);
}
//---------------------------------------------------------------------------
// Закрыть программу
void __fastcall TForm1::Exit1Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
// Фрактал "Треугольник Серпинского"
void __fastcall TForm1::riangleSerpinsky1Click(TObject *Sender)
{
AnsiString iteration = InputBox("Введите количество итераций","Количество итераций","");
int iter = iteration.ToInt();
ClearImage(Image1);
TriangleSerpinsky Triangle(220,10,450,450,10,450,iter,Image1);
Triangle.Draw();
}
//---------------------------------------------------------------------------
// Фрактал "Спиральный Квадрат"
void __fastcall TForm1::SpiralSquare1Click(TObject *Sender)
{
ClearImage(Image1);
SpiralSquare Spiral(Image1);
Spiral.Draw();
}
//---------------------------------------------------------------------------
// Рисуем фрактал на основе квадратов
void __fastcall TForm1::est1Click(TObject *Sender)
{
ClearImage(Image1);
Square Squar(Image1);
Squar.Draw();
}
//---------------------------------------------------------------------------
//Квадрат Серпинского
void __fastcall TForm1::SquareSerpinsky1Click(TObject *Sender)
{
AnsiString iteration = InputBox("Введите количество итераций","Количество итераций","");
int iter = iteration.ToInt();
ClearImage(Image1);
SquareSerpinsky Square(Image1,iter);
Square.Draw();
}
//---------------------------------------------------------------------------
// Н-образный фрактал
void __fastcall TForm1::HFractal1Click(TObject *Sender)
{
ClearImage(Image1);
HFractal Fract(Image1);
Fract.Draw();
}
//---------------------------------------------------------------------------
// Дерево в виде круга
void __fastcall TForm1::reeCircle1Click(TObject *Sender)
{
ClearImage(Image1);
AnsiString branching1 = InputBox("Введите количество ветвлений","Количество ветвлений = ","");
int branch1 = branching1.ToInt();
AnsiString branching2 = InputBox("Введите количество отростков","Количество отростков= ","");
int branch2 = branching2.ToInt();
AnsiString strradius = InputBox("Введите радиус","Радиус = ","");
int radius = strradius.ToInt();
AnsiString sizeline = InputBox("Введите коэффицент уменьшения","Коэффицент(0,5=5/10-введите 5) = ","");
double sizelines = (double)sizeline.ToInt()/10;
TreeCircle Circle(branch1,branch2,radius,sizelines,Image1);
Circle.Draw(); Circle.Draw();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
{
Image1->Width = Form1->Width-16;
Image1->Height = Form1->Height-58;
}
//---------------------------------------------------------------------------
// Легендарное множество Мандельброта
void __fastcall TForm1::MandelBrot1Click(TObject *Sender)
{
ClearImage(Image1);
Mandelbrot Fract(Image1);
Fract.Draw();
}
//---------------------------------------------------------------------------
// Не могло обойтись и без Бинарного дерева
void __fastcall TForm1::BinaryTree1Click(TObject *Sender)
{
AnsiString angleX = InputBox("Введите угол относительно X","Угол = Pi/ ","");
int anglX = angleX.ToDouble();
AnsiString angleY = InputBox("Введите угол относительно Y","Угол = Pi/ ","");
int anglY = angleY.ToDouble();
AnsiString rekurs = InputBox("Введите глубину рекурсии","Рекурсия = ","");
int recurs = rekurs.ToInt();
ClearImage(Image1);
BinaryTree Tree(Image1->Width/2,Image1->Height-20,Image1->Height/3,pi/2,anglX,anglY,recurs,Image1);
Tree.Draw();
}
//---------------------------------------------------------------------------
Класс Fractal
//---------------------------------------------------------------------------
#ifndef FractalH
#define FractalH
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Menus.hpp>
#include <ExtCtrls.hpp>
#include <Keyboard.hpp>
#include <Math.h>
#define pi 3.14
//---------------------------------------------------------------------------
class Fractal
{
TImage* Image1;
public:
void Draw();
void Line(int x, int y, int x1, int y1, TImage* Image1);
void Pixel(int x, int y, int color, TImage *Image1);
Fractal(TImage *Image1);
~Fractal();
};
#endif
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
void Fractal::Line(int x, int y, int xl, int yl, TImage* Image1)
{
Image1->Canvas->MoveTo(x,y);
Image1->Canvas->LineTo(xl,yl);
}
//---------------------------------------------------------------------------
void Fractal::Pixel(int x, int y, int color, TImage *Image1)
{
switch (color)
{
case 0: Image1->Canvas->Pixels[x][y] = clBlack; break;
case 1: Image1->Canvas->Pixels[x][y] = clOlive; break;
case 2: Image1->Canvas->Pixels[x][y] = clYellow; break;
case 3: Image1->Canvas->Pixels[x][y] = clRed; break;
case 4: Image1->Canvas->Pixels[x][y] = clAqua; break;
case 5: Image1->Canvas->Pixels[x][y] = clFuchsia; break;
case 6: Image1->Canvas->Pixels[x][y] = clGray; break;
case 7: Image1->Canvas->Pixels[x][y] = clRed; break;
case 8: Image1->Canvas->Pixels[x][y] = clGray; break;
case 9: Image1->Canvas->Pixels[x][y] = clBlue; break;
case 10: Image1->Canvas->Pixels[x][y] = clGreen; break;
case 11: Image1->Canvas->Pixels[x][y] = clRed; break;
case 12: Image1->Canvas->Pixels[x][y] = clAqua; break;
case 13: Image1->Canvas->Pixels[x][y] = clFuchsia;break;
case 14: Image1->Canvas->Pixels[x][y] = clGreen; break;
case 15: Image1->Canvas->Pixels[x][y] = clWhite; break;
case 16: Image1->Canvas->Pixels[x][y] = clBlack; break;
default:
Image1->Canvas->Pixels[x][y] = clBlack; break;
}
}
//---------------------------------------------------------------------------
void Fractal::Draw()
{
}
//---------------------------------------------------------------------------
Fractal::Fractal(TImage* Image)
{
Image1 = Image;
}
//---------------------------------------------------------------------------
Fractal::~Fractal(){}
//---------------------------------------------------------------------------
Класс BinaryTree
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
class BinaryTree: public Fractal
{
TImage *Image1;
double xcoord;
double ycoord;
double L;
double angle;
double angleX;
double angleY;
double recursion;
public:
void Draw();
void DrawBinaryTree(double x, double y, double L, double a,double n, double m, int max, TImage *Image1);
void Line(int x, int y, int x1, int y1, TImage* Image1);
void Pixel(int x, int y, int color, TImage *Image1);
BinaryTree(double xcord, double ycord, double l, double angl, double anglX, double anglY, double recurs, TImage* Image);
~BinaryTree();
};
//---------------------------------------------------------------------------
#include "BinaryTree.h"
#include <Math.h>
//---------------------------------------------------------------------------
BinaryTree::BinaryTree(double xcord, double ycord, double l, double angl, double anglX, double anglY, double recurs, TImage* Image):Fractal(Image)
{
xcoord = xcord;
ycoord = ycord;
L = l;
angle = angl;
angleX = anglX;
angleY = anglY;
recursion = recurs;
Image1 = Image;
}
//---------------------------------------------------------------------------
BinaryTree::~BinaryTree(){}
//---------------------------------------------------------------------------
void BinaryTree::Draw()
{
DrawBinaryTree(xcoord, ycoord, L, angle, angleX, angleY, recursion, Image1);
}
//---------------------------------------------------------------------------
void BinaryTree::DrawBinaryTree(double xcord, double ycord, double L, double angl, double angleX, double angleY, int recurs, TImage *Image1)
{
if(L > recurs)
{
L*=0.7;
Image1->Canvas->MoveTo(xcord,ycord);
Image1->Canvas->LineTo((int)(xcord+L*cos(angl)),(int)(ycord-L*sin(angl)));
xcord=xcord+L*cos(angl);
ycord=ycord-L*sin(angl);
Image1->Refresh();
DrawBinaryTree(xcord,ycord,L,angl+pi/angleX,angleX,angleY,recurs,Image1);
DrawBinaryTree(xcord,ycord,L,angl-pi/angleY,angleX,angleY,recurs,Image1);
}
}
//---------------------------------------------------------------------------
Класс Mandelbrot
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
class Mandelbrot: public Fractal
{
TImage *Image1;
public:
void Draw();
Mandelbrot(TImage *Image);
~Mandelbrot();
};
//---------------------------------------------------------------------------
#include "Mandelbrot.h"
//---------------------------------------------------------------------------
Mandelbrot::Mandelbrot(TImage* Image):Fractal(Image)
{
Image1 = Image;
}
//---------------------------------------------------------------------------
Mandelbrot::~Mandelbrot(){}
//---------------------------------------------------------------------------
void Mandelbrot::Draw()
{
float zi, zr, ci, cr, tmp;
for(int i=-236;i<236;i++)
{
ci=((float)i)/200.0;
for(int j=-342;j<130;j++)
{
cr=((float)j)/200.0;
zi=zr=0.0;
for(int k=0;k<100;k++)
{
tmp=zr*zr-zi*zi;
zi=2*zr*zi+ci;
zr=tmp+cr;
if (zr*zr+zi*zi>1.0E16) break;
if (k<100)
Pixel(i+236,j+342,k%3+1,Image1);
else Pixel(i+236,j+342,11,Image1);
}
}
Image1->Refresh();
}
}
//---------------------------------------------------------------------------
Класс SpiralSquare
//---------------------------------------------------------------------------
#ifndef SpiralSquare
//#define SpiralSquare
#include "Fractal.h"
//---------------------------------------------------------------------------
class SpiralSquare: public Fractal
{
TImage* Image1;
double x0;
double y0;
double d;
double u;
double l;
double min;
double angle;
public:
void Draw();
void Rectangle(double d, double u, int x0, int y0, TImage* Image1);
SpiralSquare(TImage* Image1);
~SpiralSquare();
};
#endif
//---------------------------------------------------------------------------
#include "SpiralSquare.h"
#include <Math.h>
//---------------------------------------------------------------------------
void SpiralSquare::Rectangle(double d, double u, int x0, int y0, TImage* Image1)
{
int x1, y1, x2, y2, x3, y3, x4, y4;
x1 = (x0 + d * cos(u + pi/4));
y1 = (y0 + d * sin(u + pi/4));
x2 = (x0 + d * cos(u + 3*pi/4));
y2 = (y0 + d * sin(u + 3*pi/4));
x3 = (x0 + d * cos(u + 5*pi/4));
y3 = (y0 + d * sin(u + 5*pi/4));
x4 = (x0 + d * cos(u + 7*pi/4));
y4 = (y0 + d * sin(u + 7*pi/4));
Line(x1, y1, x2, y2, Image1);
Line(x2, y2, x3, y3, Image1);
Line(x3, y3, x4, y4, Image1);
Line(x4, y4, x1, y1, Image1);
}
//---------------------------------------------------------------------------
void SpiralSquare::Draw()
{
const double min = 1;
const double da = pi/20;
int y0 = Image1->Height/2;
int x0 = Image1->Width/2;
double l = Image1->Height*0.7;
double a = 0;
do
{
Rectangle(l, a, x0, y0, Image1);
a = a + da;
l = l * sin(pi/4) / sin(3*pi/4 - da);
} while(!(l <= min));
}
//---------------------------------------------------------------------------
SpiralSquare::SpiralSquare(TImage* Image):Fractal(Image1)
{
Image1 = Image;
}
//---------------------------------------------------------------------------
SpiralSquare::~SpiralSquare(){}
//---------------------------------------------------------------------------
Класс Square
//---------------------------------------------------------------------------
#ifndef SquareH
#include "Fractal.h"
//---------------------------------------------------------------------------
class Square: public Fractal
{
TImage *Image1;
public:
Square(TImage *Image);
~Square();
void DrawQuadr(double x, double y, double Size, TImage *Image1);
void Draw();
};
#endif
//---------------------------------------------------------------------------
#include "Square.h"
//---------------------------------------------------------------------------
void Square::DrawQuadr(double x, double y, double Size, TImage *Image1)
{
const Min = 2;
Image1->Canvas->Pen->Color = clBlack;
if (Size > Min)
{
int s = Size / 2;
DrawQuadr(x - Size, y + Size, s, Image1);
DrawQuadr(x - Size, y - Size, s, Image1);
DrawQuadr(x + Size, y + Size, s, Image1);
DrawQuadr(x + Size, y - Size, s, Image1);
}
int x1=x-Size;
int y1=y-Size;
int x2=x+Size;
int y2=y+Size;
Image1->Refresh();
Image1->Canvas->Rectangle(x1,y1,x2,y2);
Image1->Canvas->FillRect(Rect(x1+1,y1+1,x2-1,y2-1));
}
//---------------------------------------------------------------------------
void Square::Draw()
{
DrawQuadr(Image1->Width/2,Image1->Height/2,Image1->Height/4,Image1);
}
//---------------------------------------------------------------------------
Square::Square(TImage *Image):Fractal(Image)
{
Image1 = Image;
}
//---------------------------------------------------------------------------
Square::~Square(){}
//---------------------------------------------------------------------------
Класс SquareSerpinsky
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
class SquareSerpinsky: public Fractal
{
TImage *Image1;
int Iter;
public:
void Serpinsky(double x1, double y1, double x2, double y2, int n, TImage *Image1);
void Draw();
SquareSerpinsky(TImage *Image, int iter);
~SquareSerpinsky();
};
//---------------------------------------------------------------------------
#include "SquareSerpinsky.h"
//---------------------------------------------------------------------------
void SquareSerpinsky::Serpinsky(double x1, double y1, double x2, double y2, int n, TImage *Image1)
{
double x1n, y1n, x2n, y2n;
if (n > 0)
{
x1n = 2*x1/3 + x2 / 3;
x2n = x1/3 + 2*x2 / 3;
y1n = 2*y1/3 + y2 / 3;
y2n = y1/3+2*y2 / 3;
Image1->Canvas->Rectangle(ceil(x1n), ceil(y1n), ceil(x2n), ceil(y2n));
Image1->Refresh();
Serpinsky(x1, y1, x1n, y1n, n-1,Image1);
Serpinsky(x1n, y1, x2n, y1n, n-1,Image1);
Serpinsky(x2n, y1, x2, y1n, n-1,Image1);
Serpinsky(x1, y1n, x1n, y2n, n-1,Image1);
Serpinsky(x2n, y1n, x2, y2n, n-1,Image1);
Serpinsky(x1, y2n, x1n, y2, n-1,Image1);
Serpinsky(x1n, y2n, x2n, y2, n-1,Image1);
Serpinsky(x2n, y2n, x2, y2, n-1,Image1);
}
}
//---------------------------------------------------------------------------
void SquareSerpinsky::Draw()
{
Image1->Canvas->Rectangle(0, 0, Image1->Width, Image1->Height);
Serpinsky(0, 0, Image1->Width, Image1->Height, Iter, Image1);
}
//---------------------------------------------------------------------------
SquareSerpinsky::SquareSerpinsky(TImage *Image, int iter):Fractal(Image)
{
Image1 = Image;
Iter = iter;
}
//---------------------------------------------------------------------------
SquareSerpinsky::~SquareSerpinsky(){}
//---------------------------------------------------------------------------
Класс TriangleSerpinsky
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
class TriangleSerpinsky: public Fractal
{
TImage *Image1;
int x1,x2,x3,y1,y2,y3,iter;
public:
void Triangle(int x1, int y1, int x2, int y2, int x3, int y3, TImage *Image1);
void DrawSerpinsky (int x1, int y1, int x2, int y2, int x3, int y3, int n, TImage* Image1);
void Draw();
TriangleSerpinsky(int X1, int Y1, int X2, int Y2, int X3, int Y3, int Iter, TImage *Image);
~TriangleSerpinsky();
};
//---------------------------------------------------------------------------
#include "TriangleSerpinsky.h"
//---------------------------------------------------------------------------
void TriangleSerpinsky::Triangle(int x1, int y1, int x2, int y2, int x3, int y3, TImage *Image1)
{
Line(x1,y1,x2,y2,Image1);
Line(x2,y2,x3,y3,Image1);
Line(x3,y3,x1,y1,Image1);
}
//---------------------------------------------------------------------------
void TriangleSerpinsky::DrawSerpinsky (int x1, int y1, int x2, int y2, int x3, int y3, int n, TImage* Image1)
{
double x1n, y1n, x2n, y2n, x3n, y3n;
if (n > 0)
{
x1n = (x1 + x2) / 2;
y1n = (y1 + y2) / 2;
x2n = (x2 + x3) / 2;
y2n = (y2 + y3) / 2;
x3n = (x3 + x1) / 2;
y3n = (y3 + y1) / 2;
Triangle(x1n, y1n, x2n, y2n, x3n, y3n,Image1);
DrawSerpinsky(x1, y1, x1n, y1n, x3n, y3n, n - 1, Image1);
DrawSerpinsky(x2, y2, x1n, y1n, x2n, y2n, n - 1, Image1);
DrawSerpinsky(x3, y3, x2n, y2n, x3n, y3n, n - 1, Image1);
Image1->Refresh();
}
}
//---------------------------------------------------------------------------
void TriangleSerpinsky::Draw()
{
Triangle(x1,y1,x2,y2,x3,y3,Image1);
DrawSerpinsky(x1,y1,x2,y2,x3,y3,iter,Image1);
}
//---------------------------------------------------------------------------
TriangleSerpinsky::TriangleSerpinsky(int X1, int Y1, int X2, int Y2, int X3, int Y3, int Iter, TImage *Image):Fractal(Image)
{
x1 = X1;
y1 = Y1;
x2 = X2;
y2 = Y2;
x3 = X3;
y3 = Y3;
iter = Iter;
Image1 = Image;
}
//---------------------------------------------------------------------------
TriangleSerpinsky::~TriangleSerpinsky(){}
//---------------------------------------------------------------------------
Класс HFractal
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
class HFractal: public Fractal
{
TImage *Image1;
public:
void DrawFractal(int x, int y, int l, TImage *Image1);
void Draw();
HFractal(TImage *Image);
~HFractal();
};
//---------------------------------------------------------------------------
#include "HFractal.h"
//---------------------------------------------------------------------------
void HFractal::DrawFractal(int x, int y, int l, TImage *Image1)
{
if (l > 4)
{
l = l / 2;
Line(x, y, x+l, y,Image1);
Line(x, y, x-l, y,Image1);
Line(x + l, y, x + l, y - l / 2,Image1);
Line(x + l, y, x + l, y + l / 2,Image1);
Line(x - l, y, x - l, y - l / 2,Image1);
Line(x - l, y, x - l, y + l / 2,Image1);
Image1->Refresh();
DrawFractal(x + l, y - l / 2, l,Image1);
DrawFractal(x + l, y + l / 2, l,Image1);
DrawFractal(x - l, y - l / 2, l,Image1);
DrawFractal(x - l, y + l / 2, l,Image1);
}
}
//---------------------------------------------------------------------------
void HFractal::Draw()
{
DrawFractal(Image1->Width/2,Image1->Height/2,Image1->Width/2,Image1);
}
//---------------------------------------------------------------------------
HFractal::HFractal(TImage *Image):Fractal(Image)
{
Image1 = Image;
}
//---------------------------------------------------------------------------
HFractal::~HFractal(){}
//---------------------------------------------------------------------------
Класс TreeCircle
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
class TreeCircle: public Fractal
{
TImage *Image1;
int branching;
int branchs;
int radius;
public:
void LinePolar(double r1, double a1, double r2, double a2,TImage *Image1);
double Radius(double s, double r, int i);
double Angle(int d, int i, int j);
void DrawTreeCircle(int n, int d,double r, int s, TImage *Image1);
void Draw();
TreeCircle(int Branching, int Branchs, int Radius, TImage *Image);
~TreeCircle();
};
//---------------------------------------------------------------------------
#include "TreeCircle.h"
//---------------------------------------------------------------------------
void TreeCircle::LinePolar(double radius1, double a1, double radius2, double a2,TImage *Image1)
{
Line(ceil(Image1->Width/2 + radius1 * cos(a1)),ceil(Image1->Height/2 - radius1 * sin(a1)),
ceil(Image1->Width/2 + radius2 * cos(a2)),ceil(Image1->Height/2 - radius2 * sin(a2)), Image1);
}
//---------------------------------------------------------------------------
double TreeCircle::Radius(double size, double radius, int i)
{
return size * (1 - pow(radius, i)) / (1 - radius);
}
//---------------------------------------------------------------------------
double TreeCircle::Angle(int d, int i, int j)
{
return 2 * pi / pow(d, i) * (j - (pow(d, i) - 1) / 2);
}
//---------------------------------------------------------------------------
void TreeCircle::DrawTreeCircle(int branchings, int branchs,double size, int radius, TImage *Image1)
{
int i, j;
double radius1, radius2, angle1, angle2;
for (i=1;i<branchings;i++)
{
radius1 = Radius(radius, size, i);
radius2 = Radius(radius, size, i - 1);
for (j=0;j<ceil(pow(branchings,i));j++)
{
angle1 = Angle(branchs, i, j);
angle2 = Angle(branchs, i - 1, j / branchs);
LinePolar(radius1, angle1, radius2, angle2, Image1);
Image1->Refresh();
}
}
}
//---------------------------------------------------------------------------
void TreeCircle::Draw()
{
DrawTreeCircle(branching, branchs, size, radius, Image1);
}
//---------------------------------------------------------------------------
TreeCircle::TreeCircle(int Branching, int Branchs, int Radius, double Size, TImage *Image):Fractal(Image)
{
Image1 = Image;
branching = Branching;
branchs = Branchs;
radius = Radius;
size = Size;
}
TreeCircle::~TreeCircle(){}Класс TriangleFract
//---------------------------------------------------------------------------
#include "Fractal.h"
//---------------------------------------------------------------------------
class TriangleFract: public Fractal
{
TImage *Image1;
public:
TriangleFract(TImage *Image);
~TriangleFract();
void Triangle(int xc, int yc, int l, TImage *Image1);
void DrawTriangle(int x, int y,int Size, TImage *Image1);
void Draw();
};
//---------------------------------------------------------------------------
#include "TriangleFract.h"
//---------------------------------------------------------------------------
void TriangleFract::Triangle(int xc, int yc, int l, TImage *Image1)
{
int x1 = xc;
int y1 = yc - l;
int x2 = xc + ceil(l*cos(pi/6));
int y2 = yc + ceil(l*sin(pi/6));
int x3 = xc - ceil(l*cos(pi/6));
int y3 = yc + ceil(l*sin(pi/6));
Image1->Canvas->Pen->Color = clBlack;
Line(x1,y1,x2,y2,Image1);
Line(x2,y2,x3,y3,Image1);
Line(x3,y3,x1,y1,Image1);
Image1->Canvas->FloodFill(xc,yc,clBlack,fsSurface);
Image1->Canvas->Pen->Color = clBlack;
Line(x1,y1,x2,y2,Image1);
Line(x2,y2,x3,y3,Image1);
Line(x3,y3,x1,y1,Image1);
Image1->Refresh();
}
//---------------------------------------------------------------------------
void TriangleFract::DrawTriangle(int x, int y,int Size, TImage *Image1)
{
const MinSize = 0;
if (Size > MinSize)
{
int s = Size / 2;
DrawTriangle(x, y - Size, s, Image1);
DrawTriangle(x + ceil(Size * cos(pi/6)), y + ceil(Size*sin(pi/6)), s, Image1);
DrawTriangle(x - ceil(Size * cos(pi/6)), y + ceil(Size*sin(pi/6)), s, Image1);
}
Triangle(x, y, Size, Image1);
}
//---------------------------------------------------------------------------
void TriangleFract::Draw()
{
DrawTriangle(Image1->Width/2,Image1->Height/2+0.25*Image1->Height/2,120,Image1);
}
//---------------------------------------------------------------------------
TriangleFract::TriangleFract(TImage *Image):Fractal(Image)
{
Image1 = Image;
}
//---------------------------------------------------------------------------
TriangleFract::~TriangleFract(){}
//---------------------------------------------------------------------------
Дата добавления: 2015-12-08; просмотров: 54 | Нарушение авторских прав