Lisoveliy/FractalTree
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Previous commit

Browse Source
This commit is contained in:
Pavel-Savely Savianok 2024-08-30 16:48:26 +03:00
parent 0e330bc47d
commit 4e18d216e6
7 changed files with 117 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
FractalTree/CairoWindow.cs
View File

@ -1,85 +0,0 @@
using Gtk;
using CairoObjective;
using System.Linq;
using System.Diagnostics;
namespace FractalTree
{
class CairoWindow : Window
{
DrawingArea drawing = new DrawingArea();
DrawObjects.Grid grid;
int Scaler = 50;
int offsetX = 0;
int offsetY = 0;
public CairoWindow(string title) : base(title)
{
Fullscreen();
DeleteEvent += delegate { Application.Quit(); };
drawing.Drawn += OnDrawn;
KeyPressEvent += CairoWindow_KeyPressEvent;
Add(drawing);
ShowAll();
Line.DefaultSize = 2;
}
private void CairoWindow_KeyPressEvent(object o, KeyPressEventArgs args)
{
if(args.Event.Key == Gdk.Key.equal)
{
Trace.WriteLine("+");
Scaler++;
QueueDraw();
}
if (args.Event.Key == Gdk.Key.minus && Scaler > 1)
{
Trace.WriteLine("-");
Scaler--;
QueueDraw();
}
if (args.Event.Key == Gdk.Key.a)
{
Trace.WriteLine("←");
offsetX-=10;
QueueDraw();
}
if (args.Event.Key == Gdk.Key.d)
{
Trace.WriteLine("→");
offsetX+=10;
QueueDraw();
}
if (args.Event.Key == Gdk.Key.w)
{
Trace.WriteLine("↑");
offsetY += 10;
QueueDraw();
}
if (args.Event.Key == Gdk.Key.s)
{
Trace.WriteLine("↓");
offsetY -= 10;
QueueDraw();
}
}
private void OnDrawn(object sender, DrawnArgs args)
{
MainDrawer();
}
private void MainDrawer()
{
grid = new(AllocatedWidth, AllocatedHeight, Scaler, offsetX, offsetY);
Set.Context = Gdk.CairoHelper.Create(drawing.GdkWindow);
Set.Background(new Cairo.Color(0, 0, 0));
foreach(CairoObjective.DrawObjects.Line gridline in grid.LinesHorizontal)
{
Line.Make(gridline, new Cairo.Color(1,1,1));
}
foreach (CairoObjective.DrawObjects.Line gridline in grid.LinesVertical)
{
Line.Make(gridline, new Cairo.Color(1, 1, 1));
}
}
}
}

49
FractalTree/DrawObjects/Grid.cs
View File

@ -1,49 +0,0 @@
using CairoObjective.DrawObjects;
using System;
using System.Diagnostics;
namespace FractalTree.DrawObjects
{
internal class Grid
{
public Line[] LinesHorizontal;
public Line[] LinesVertical;
int Scaler;
int Width;
int Height;
int offsetX;
int offsetY;
/// <summary>
/// Make Grid Array of lines
/// </summary>
/// <param name="Width">Width of Window</param>
/// <param name="Height">Height of Window</param>
/// <param name="Scaler">Pixels Per Lines</param>
public Grid(int Width, int Height, int Scaler, int offsetX, int offsetY)
{
this.Width = Width;
this.Height = Height;
this.Scaler = Scaler;
this.offsetX = offsetX;
this.offsetY = offsetY;
LinesHorizontal = new Line[this.Width / Scaler + 1];
LinesVertical = new Line[this.Height / Scaler + 1];
MakeHorizontal();
MakeVertical();
}
private void MakeHorizontal()
{
for(int i = 0; i < Width / Scaler + 1; i++)
{
LinesHorizontal[i] = new Line(i * Scaler + offsetX, 0, i * Scaler, Height);
}
}
private void MakeVertical()
{
for (int i = 0; i < Height / Scaler + 1; i++)
{
LinesVertical[i] = new Line(0, i * Scaler, Width, i * Scaler);
}
}
}
}

19
FractalTree/FractalTree.csproj
View File

@ -1,19 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>WinExe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>disable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="CairoSharp" Version="3.24.24.38" />
<PackageReference Include="GtkSharp" Version="3.24.24.38" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\CairoObjective\CairoObjective.csproj" />
</ItemGroup>
</Project>

15
FractalTree/Program.cs
View File

@ -1,15 +0,0 @@
using Gtk;
namespace FractalTree
{
internal class Program
{
static void Main()
{
Application.Init();
//Create the Window
new CairoWindow("Window");
Application.Run();
}
}
}

72
FractalTreeGtk/CairoWindow.cs
View File

@ -2,69 +2,85 @@
using CairoObjective; using CairoObjective;
using FractalTreeGtk.Draw; using FractalTreeGtk.Draw;
using System; using System;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics; using System.Diagnostics;
using Key = Gdk.Key;
namespace FractalTreeGtk namespace FractalTreeGtk
{ {
internal class CairoWindow : Window internal class CairoWindow : Window
{ {
static int fractallevels = 2; private int FractalLevels { get; set; } = 2;
DrawingArea drawing = new DrawingArea(); readonly DrawingArea _drawing = new DrawingArea();
Fractal fractal; Fractal _fractal = null!;
public CairoWindow(string title) : base(title) {
public CairoWindow(string title) : base(title)
{
Fullscreen(); Fullscreen();
drawing.Drawn += Drawing_Drawn; _drawing.Drawn += Render;
Add(drawing); Add(_drawing);
ShowAll(); ShowAll();
KeyPressEvent += CairoWindow_KeyPressEvent; KeyPressEvent += CairoWindow_KeyPressEvent;
CreateNewFractal(); GenerateFractal();
} }
public void CreateNewFractal()
private void GenerateFractal()
{ {
fractal = new Fractal(fractallevels, this); Trace.WriteLine("Generating fractal");
_fractal = new Fractal(FractalLevels, this);
} }
private void CairoWindow_KeyPressEvent(object o, KeyPressEventArgs args) private void CairoWindow_KeyPressEvent(object o, KeyPressEventArgs args)
{ {
if(args.Event.Key == Gdk.Key.equal) switch (args.Event.Key)
{ {
++fractallevels; case Key.equal: //Increase fractal levels
CreateNewFractal(); case Key.plus:
} FractalLevels++;
if (args.Event.Key == Gdk.Key.minus && fractallevels > 1) GenerateFractal();
{ break;
--fractallevels; case Key.minus: //Decrease fractal levels
CreateNewFractal(); if (FractalLevels > 1)
{
FractalLevels--;
GenerateFractal();
}
break;
case Key.r: //Regenerate fractal
GenerateFractal();
break;
} }
} }
private void Drawing_Drawn(object o, DrawnArgs args) private void Render(object o, DrawnArgs args)
{ {
long branches = 0; long branches = 0;
Text.CenterText = false; Text.CenterText = false;
args.Cr.Translate(AllocatedWidth / 2, AllocatedHeight); args.Cr.Translate(AllocatedWidth / 2f, AllocatedHeight);
Set.Context = args.Cr; Set.Context = args.Cr;
Set.Background(new Cairo.Color(0, 0, 0)); Set.Background(new Cairo.Color(0, 0, 0));
foreach (CairoObjective.DrawObjects.Line[] lines in (CairoObjective.DrawObjects.Line[][])fractal.Fractallines) foreach (CairoObjective.DrawObjects.Line[] lines in
_fractal.FractalLines as CairoObjective.DrawObjects.Line[][])
{ {
try try
{ {
foreach (CairoObjective.DrawObjects.Line line in lines) { foreach (CairoObjective.DrawObjects.Line line in lines)
{
branches++; branches++;
Line.Make(line); Line.Make(line);
} }
} }
catch (NullReferenceException) catch (NullReferenceException e)
{ {
Trace.WriteLine("Hello Null"); Trace.WriteLine(e);
break; break;
} }
} }
Text.Make($"Total Branches: {branches}", -(AllocatedWidth / 2) + 1, -29, 21, new Cairo.Color(0, 0, 0)); Text.Make($"Total Branches: {branches}", -(AllocatedWidth / 2) + 1, -29, 21, new Cairo.Color(0, 0, 0));
Text.Make($"Levels: {fractallevels}", -(AllocatedWidth / 2) + 1, -4, 21, new Cairo.Color(0, 0, 0)); Text.Make($"Levels: {FractalLevels}", -(AllocatedWidth / 2) + 1, -4, 21, new Cairo.Color(0, 0, 0));
Text.Make($"Total Branches: {branches}", -(AllocatedWidth / 2), -30, new Cairo.Color(0.1, 1, 0.1)); Text.Make($"Total Branches: {branches}", -(AllocatedWidth / 2), -30, 21, new Cairo.Color(0.1, 1, 0.1));
Text.Make($"Levels: {fractallevels}", -(AllocatedWidth / 2), -5, new Cairo.Color(0.1,1,0.1)); Text.Make($"Levels: {FractalLevels}", -(AllocatedWidth / 2), -5, 21, new Cairo.Color(0.1, 1, 0.1));
} }
} }
} }

14
FractalTreeGtk/Draw/Branch.cs
View File

@ -1,15 +1,13 @@
using System.Numerics; namespace FractalTreeGtk.Draw
namespace FractalTreeGtk.Draw
{ {
internal class Branch : CairoObjective.DrawObjects.Line internal class Branch : CairoObjective.DrawObjects.Line
{ {
public bool left; public readonly bool IsLeft;
public double degree; public readonly double Degree;
public Branch(double x1, double y1, double x2, double y2, bool left, double degree) : base(x1, y1, x2, y2) public Branch(double x1, double y1, double x2, double y2, bool isLeft, double degree) : base(x1, y1, x2, y2)
{ {
this.left = left; IsLeft = isLeft;
this.degree = degree; Degree = degree;
} }
} }
} }

155
FractalTreeGtk/Draw/Fractal.cs
View File

@ -1,125 +1,100 @@
using System; using System;
using System.ComponentModel.DataAnnotations;
using System.Threading;
using System.Threading.Tasks;
namespace FractalTreeGtk.Draw namespace FractalTreeGtk.Draw
{ {
internal class Fractal internal class Fractal
{ {
public bool Drawing = true; private readonly CairoWindow _window;
CairoWindow window; private double Length { get; set; } = new Random().Next(70, 90);
double Length = 100; private int MaxLevels { get; set; }
double MainDegree = 0.4; private int CurrentLevel { get; set; } = 0;
int levels; public bool IsDrawing { private set; get; }
int level = 0; private double Degree => new Random().Next(30, 50) / 100f;
double deltaLength = 5; private double DeltaLength => new Random().Next(0, 50) / 100f;
public Branch[][] Fractallines;
public Fractal(int levels, CairoWindow window) public Branch[][] FractalLines { get; }
public Fractal(int maxLevels, CairoWindow window)
{ {
this.window = window; _window = window;
this.levels = levels; MaxLevels = maxLevels;
Fractallines = new Branch[levels + 1][]; FractalLines = new Branch[maxLevels + 1][];
CreateBranch(); CreateBranch();
} }
private void CreateBranch() private void CreateBranch()
{ {
Fractallines[level] = new Branch[Convert.ToInt32(Math.Pow(2, level))]; FractalLines[CurrentLevel] = new Branch[Convert.ToInt32(Math.Pow(2, CurrentLevel))];
for (int i = 0; i < Fractallines[level].Length; i++) for (int i = 0; i < FractalLines[CurrentLevel].Length; i++)
{ {
Fractallines[level][i] = new Branch(0, 0, 0, -Length, true, 0); FractalLines[CurrentLevel][i] = new Branch(0, 0, 0, -Length, true, 0);
} }
level++;
NextLevel(); CurrentLevel++;
NextLevel();
} }
private void NextLevel() private void NextLevel()
{ {
window.QueueDraw(); _window.QueueDraw();
Length -= deltaLength; var len = DeltaLength;
window.QueueDraw(); if (Length < DeltaLength)
Fractallines[level] = new Branch[Convert.ToInt32(Math.Pow(2, level))]; Length = DeltaLength;
else
Length -= DeltaLength;
_window.QueueDraw();
FractalLines[CurrentLevel] = new Branch[Convert.ToInt32(Math.Pow(2, CurrentLevel))];
int x = 0; int x = 0;
for (int i = 0; i < Fractallines[level - 1].Length; i++) for (int i = 0; i < FractalLines[CurrentLevel - 1].Length; i++)
{ {
double Degree = Fractallines[level - 1][i].degree; double degree = FractalLines[CurrentLevel - 1][i].Degree;
if (Fractallines[level - 1][i].left) if (FractalLines[CurrentLevel - 1][i].IsLeft)
{ {
double leftdegree = MainDegree + Degree; double leftdegree = Degree + degree;
double rightdegree = -MainDegree + Degree; double rightdegree = -Degree + degree;
Fractallines[level][x] = new Branch( FractalLines[CurrentLevel][x] = new Branch(
Fractallines[level - 1][i].X2, FractalLines[CurrentLevel - 1][i].X2,
Fractallines[level - 1][i].Y2, FractalLines[CurrentLevel - 1][i].Y2,
-(Math.Sin(leftdegree) * Length) + Fractallines[level - 1][i].X2, -(Math.Sin(leftdegree) * Length) + FractalLines[CurrentLevel - 1][i].X2,
-(Math.Cos(leftdegree) * Length) + Fractallines[level - 1][i].Y2, -(Math.Cos(leftdegree) * Length) + FractalLines[CurrentLevel - 1][i].Y2,
true, true,
leftdegree); leftdegree);
Fractallines[level][++x] = new Branch( FractalLines[CurrentLevel][++x] = new Branch(
Fractallines[level - 1][i].X2, FractalLines[CurrentLevel - 1][i].X2,
Fractallines[level - 1][i].Y2, FractalLines[CurrentLevel - 1][i].Y2,
-(Math.Sin(rightdegree) * Length) + Fractallines[level - 1][i].X2, -(Math.Sin(rightdegree) * Length) + FractalLines[CurrentLevel - 1][i].X2,
-(Math.Cos(rightdegree) * Length) + Fractallines[level - 1][i].Y2, -(Math.Cos(rightdegree) * Length) + FractalLines[CurrentLevel - 1][i].Y2,
false, false,
rightdegree); rightdegree);
} }
else else
{ {
double leftdegree = -(MainDegree - Degree); double leftdegree = -(Degree - degree);
double rightdegree = -(-MainDegree - Degree); double rightdegree = -(-Degree - degree);
Fractallines[level][x] = new Branch( FractalLines[CurrentLevel][x] = new Branch(
Fractallines[level - 1][i].X2, FractalLines[CurrentLevel - 1][i].X2,
Fractallines[level - 1][i].Y2, FractalLines[CurrentLevel - 1][i].Y2,
-(Math.Sin(leftdegree) * Length) + Fractallines[level - 1][i].X2, -(Math.Sin(leftdegree) * Length) + FractalLines[CurrentLevel - 1][i].X2,
-(Math.Cos(leftdegree) * Length) + Fractallines[level - 1][i].Y2, -(Math.Cos(leftdegree) * Length) + FractalLines[CurrentLevel - 1][i].Y2,
true, true,
leftdegree); leftdegree);
Fractallines[level][++x] = new Branch( FractalLines[CurrentLevel][++x] = new Branch(
Fractallines[level - 1][i].X2, Fractallines[level - 1][i].Y2, FractalLines[CurrentLevel - 1][i].X2, FractalLines[CurrentLevel - 1][i].Y2,
-(Math.Sin(rightdegree) * Length) + FractalLines[CurrentLevel - 1][i].X2,
-(Math.Sin(rightdegree) * Length) + Fractallines[level - 1][i].X2, -(Math.Cos(rightdegree) * Length) + FractalLines[CurrentLevel - 1][i].Y2,
-(Math.Cos(rightdegree) * Length) + Fractallines[level - 1][i].Y2, false,
false, rightdegree);
rightdegree);
} }
x++; x++;
} }
level++;
if (level <= levels) CurrentLevel++;
if (CurrentLevel <= MaxLevels)
{ {
NextLevel(); NextLevel();
} }
else Drawing = false; else IsDrawing = false;
} }
//private int SumOfBranches()
//{
// double sum = 0;
// for (int i = 0; i <= levels; i++)
// {
// sum += Math.Pow(2, i);
// }
// return (int)sum;
//}
//private void Branch()
//{
// for(int i = 0; i < Convert.ToInt32(Math.Pow(2, level)); i+=2)
// {
// int z = i;
// if(i == 0)
// {
// z = 1;
// }
// Lines[iter + i] = new Branch(
// Lines[iter - z].X2, Lines[iter - z].Y2,
// -(Math.Sin(deg) * Length) + Lines[iter - z].X2, -(Math.Cos(deg) * Length) + Lines[iter - z].Y2
// );
// Lines[iter + i + 1] = new Branch(
// Lines[iter - z].X2, Lines[iter - z].Y2,
// -(Math.Sin(-deg) * Length) + Lines[iter - z].X2, -(Math.Cos(-deg) * Length) + Lines[iter - z].Y2
// );
// deg += 0.05;
// }
// iter += Convert.ToInt32(Math.Pow(2, level));
// level++;
//}
} }
} }