228 lines
8.5 KiB
C#
228 lines
8.5 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
//[DEBUG]
|
|
using System.Windows.Forms;
|
|
|
|
namespace Paint_2
|
|
{
|
|
internal class BezierPencil : PaintTool
|
|
{
|
|
private List<List<Point>> _drawings;
|
|
private List<List<Point>> _drawingsRedo;
|
|
private List<Color> _colors;
|
|
private List<Color> _colorsRedo;
|
|
private List<int> _widths;
|
|
private List<int> _widthsRedo;
|
|
private Color _color;
|
|
private string _name;
|
|
private int _width;
|
|
|
|
public List<List<Point>> Drawings { get => _drawings; set => _drawings = value; }
|
|
public List<List<Point>> DrawingsRedo { get => _drawingsRedo; set => _drawingsRedo = value; }
|
|
public List<Color> Colors { get => _colors; set => _colors = value; }
|
|
public List<Color> ColorsRedo { get => _colorsRedo; set => _colorsRedo = value; }
|
|
public List<int> Widths { get => _widths; set => _widths = value; }
|
|
public List<int> WidthsRedo { get => _widthsRedo; set => _widthsRedo = value; }
|
|
public Color Color { get => _color; set => _color = value; }
|
|
public string Name { get => _name; set => _name = value; }
|
|
public int Width { get => _width; set => _width = value; }
|
|
|
|
public BezierPencil(string name)
|
|
{
|
|
Drawings = new List<List<Point>>();
|
|
DrawingsRedo = new List<List<Point>>();
|
|
Colors = new List<Color>();
|
|
ColorsRedo = new List<Color>();
|
|
Widths = new List<int>();
|
|
WidthsRedo = new List<int>();
|
|
Name = name;
|
|
}
|
|
public void Add(Point point)
|
|
{
|
|
if (Drawings[Drawings.Count - 1].Count == 0)
|
|
{
|
|
Drawings[Drawings.Count - 1].Add(point);
|
|
}
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
Drawings = new List<List<Point>>();
|
|
DrawingsRedo = new List<List<Point>>();
|
|
Colors = new List<Color>();
|
|
ColorsRedo = new List<Color>();
|
|
Widths = new List<int>();
|
|
WidthsRedo = new List<int>();
|
|
}
|
|
|
|
public List<Color> GetLastColors(int colorNumber)
|
|
{
|
|
List<Color> result = new List<Color>();
|
|
if (Colors.Count <= colorNumber)
|
|
{
|
|
//We need to fill with black color
|
|
for (int i = Colors.Count; i > 0; i--)
|
|
{
|
|
result.Add(Colors[(Colors.Count) - i]);
|
|
}
|
|
for (int i = colorNumber - Colors.Count; i > 0; i--)
|
|
{
|
|
result.Add(Color.FromArgb(0x00, 0x00, 0x00));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = colorNumber; i > 0; i--)
|
|
{
|
|
result.Add(Colors[(Colors.Count) - i]);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
private Point LerpY(Point start, Point end, int x)
|
|
{
|
|
int newY = start.Y + (int)((float)(x - start.X) * (float)(((float)end.Y - (float)start.Y) / ((float)end.X - (float)start.X)));
|
|
return new Point(x, newY);
|
|
}
|
|
private Point LerpX(Point start, Point end, int y)
|
|
{
|
|
int newX = start.X + (int)((float)(y - start.Y) * (((float)end.Y - (float)start.Y) / ((float)end.X - (float)start.X)));
|
|
return new Point(newX, y);
|
|
}
|
|
public void Paint(Bitmap canvas)
|
|
{
|
|
Graphics gr = Graphics.FromImage(canvas);
|
|
int drawingCounter = 0;
|
|
Size pointSize;
|
|
|
|
List<Point> points = new List<Point>();
|
|
foreach (List<Point> drawing in Drawings)
|
|
{
|
|
if (drawing.Count > 0)
|
|
{
|
|
points.Add(drawing[0]);
|
|
}
|
|
}
|
|
if (points.Count > 0)
|
|
{
|
|
|
|
for (int i = 1; i <= points.Count; i++)
|
|
{
|
|
pointSize = new Size(Widths[i - 1], Widths[i - 1]);
|
|
gr.FillEllipse(new SolidBrush(Colors[i - 1]), new Rectangle(new Point(points[i - 1].X - pointSize.Width / 2, points[i - 1].Y - pointSize.Height / 2), pointSize));
|
|
|
|
if (i % 4 == 0)
|
|
{
|
|
//Drawing the first level of curve
|
|
Point p1 = points[i - 4];
|
|
Point p2 = points[i - 3];
|
|
Point p3 = points[i - 2];
|
|
Point p4 = points[i - 1];
|
|
|
|
gr.DrawLine(new Pen(Colors[i - 4], Widths[i - 4]), p1, p2);
|
|
gr.DrawLine(new Pen(Colors[i - 3], Widths[i - 3]), p2, p3);
|
|
gr.DrawLine(new Pen(Colors[i - 2], Widths[i - 2]), p3, p4);
|
|
|
|
//Drawing the second level of curve
|
|
|
|
// Calculate the lowest x change
|
|
int range = Math.Min(Math.Abs(p4.X - p3.X), Math.Min(Math.Abs(p2.X - p1.X), Math.Abs(p3.X - p2.X)));
|
|
float firstOffset = Math.Abs(p2.X - p1.X) / range;
|
|
float secondOffset = Math.Abs(p3.X - p2.X) / range;
|
|
float thirdOffset = Math.Abs(p4.X - p3.X) / range;
|
|
|
|
for (int i = 0;i < range;i++)
|
|
{
|
|
|
|
}
|
|
|
|
Point p1_2 = LerpY(p1, p2, p1.X +(int)(range / 2.0 * firstOffset));
|
|
Point p2_2 = LerpY(p2, p3, p2.X +(int)(range / 2.0 * secondOffset));
|
|
Point p3_2 = LerpY(p3, p4, p3.X +(int)(range / 2.0 * thirdOffset));
|
|
|
|
gr.DrawLine(new Pen(Colors[i - 1], Widths[i - 1]), p1_2, p2_2);
|
|
gr.DrawLine(new Pen(Colors[i - 1], Widths[i - 1]), p2_2, p3_2);
|
|
|
|
//Drawing the thirs level of curve
|
|
range = Math.Min(Math.Abs(p2_2.X - p1_2.X), Math.Abs(p3_2.X - p2_2.X));
|
|
firstOffset = Math.Abs(p2_2.X - p1_2.X) / range;
|
|
secondOffset = Math.Abs(p3_2.X - p2_2.X) / range;
|
|
|
|
Point p1_3 = LerpY(p1_2, p2_2, p1_2.X + (int)(range / 2.0 * firstOffset));
|
|
Point p2_3 = LerpY(p2_2, p3_2, p2_2.X + (int)(range / 2.0 * secondOffset));
|
|
|
|
gr.DrawLine(new Pen(Color.Pink, 5), p1_3, p2_3);
|
|
|
|
//Drawing the bezier point
|
|
range = Math.Abs(p2_3.X - p1_3.X);
|
|
firstOffset = Math.Abs(p2_3.X - p1_3.X) / range;
|
|
|
|
Point p1_4 = LerpY(p1_3, p2_3, p1_3.X + (int)(range / 2.0 * firstOffset));
|
|
gr.FillEllipse(new SolidBrush(Color.AliceBlue), new Rectangle(new Point(p1_4.X - pointSize.Width / 2, p1_4.Y - pointSize.Height / 2), pointSize));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void Start(Color color, int width)
|
|
{
|
|
Color = color;
|
|
Width = width;
|
|
List<Point> points = new List<Point>();
|
|
Drawings.Add(points);
|
|
Colors.Add(Color);
|
|
Widths.Add(Width);
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
//Implement the bezier curve algorythm (if there are enough points)
|
|
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return Name;
|
|
}
|
|
|
|
public void Undo()
|
|
{
|
|
int last = Drawings.Count - 1;
|
|
if (Drawings.Count > 1)
|
|
{
|
|
DrawingsRedo.Add(Drawings[last]);
|
|
Drawings.RemoveAt(Drawings.Count - 1);
|
|
ColorsRedo.Add(Colors[last]);
|
|
Colors.RemoveAt(Colors.Count - 1);
|
|
WidthsRedo.Add(Widths[last]);
|
|
Widths.RemoveAt(Widths.Count - 1);
|
|
}
|
|
else
|
|
{
|
|
DrawingsRedo.Add(Drawings[0]);
|
|
Drawings.Clear();
|
|
ColorsRedo.Add(Colors[0]);
|
|
Colors.Clear();
|
|
WidthsRedo.Add(Widths[0]);
|
|
Widths.Clear();
|
|
}
|
|
}
|
|
|
|
public void Redo()
|
|
{
|
|
if (DrawingsRedo.Count > 0 && WidthsRedo.Count > 0 && ColorsRedo.Count > 0)
|
|
{
|
|
Drawings.Add(DrawingsRedo[DrawingsRedo.Count - 1]);
|
|
DrawingsRedo.RemoveAt(DrawingsRedo.Count - 1);
|
|
Colors.Add(ColorsRedo[ColorsRedo.Count - 1]);
|
|
ColorsRedo.RemoveAt(ColorsRedo.Count - 1);
|
|
Widths.Add(WidthsRedo[WidthsRedo.Count - 1]);
|
|
WidthsRedo.RemoveAt(WidthsRedo.Count - 1);
|
|
}
|
|
}
|
|
}
|
|
}
|