Простой векторный графический редактор (разбор полётов)

    /// <summary>
    /// Сериализуемая обертка над GraphicsPath
    /// </summary>
    public class SerializableGraphicsPath
    {
        public GraphicsPath Path = new GraphicsPath();
 
        //....
 
        public static implicit operator GraphicsPath(SerializableGraphicsPath path)
        {
            return path.Path;
        }
 
        public static implicit operator SerializableGraphicsPath(GraphicsPath path)
        {
            return new SerializableGraphicsPath() {Path = path};
        }
    }

            var sp = new SerializableGraphicsPath();
            GraphicsPath p = sp;
 
            //или
            Graphics gr = ...;
            gr.DrawPath(Pens.Black, sp);

    [Serializable]
    public class SerializableGraphicsMatrix : ISerializable
    {
        public Matrix Matrix = new Matrix();
 
        public SerializableGraphicsMatrix()
        {
        }
 
        public SerializableGraphicsMatrix(SerializationInfo info, StreamingContext context)
        {
            if (info.MemberCount ==6)
            {
                var el = (float[])info.GetValue("e", typeof(float[]));
                Matrix = new Matrix(el[0], el[1], el[2], el[3], el[4], el[5]);
            }
            else
                Matrix = new Matrix();
        }
 
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (Matrix.Elements.Length <= 0) return;
            info.AddValue("e", Matrix.Elements);
        }
    }

fig.Transform.Scale(100, 100);

    /// <summary>
    /// Класс-основа для задания геометрии фигуры
    /// </summary>
    [Serializable]
    public abstract class Geometry
    {
        /// <summary>
        /// Предоставление пути для рисования фигуры
        /// </summary>
        public abstract GraphicsPath Path { get; }
 
        /// <summary>
        /// Допустимые операции над геометрией
        /// </summary>
        public abstract AllowedOperations AllowedOperations { get; }
    }

    /// <summary>
    /// Допустимые операции над геометрией
    /// </summary>
    [Serializable]
    [Flags]
    public enum AllowedOperations : uint
    {
        None    = 0x0,
        Scale   = 0x1, //can be scaled
        Size    = 0x2, //can change size by vert and horiz
        Rotate  = 0x4, //can be rotated
        Select  = 0x8, //can be selected
        All     = 0xffffffff,
    }

    /// <summary>
    /// Строит компоненты фигуры
    /// </summary>
    public class FigureBuilder
    {
        public void BuildSquareGeometry(Figure figure)
        {
            var path = new SerializableGraphicsPath();
            path.Path.AddRectangle(new RectangleF(-0.5f, -0.5f, 1, 1));
            figure.Geometry = new PrimitiveGeometry(path, AllowedOperations.All ^ AllowedOperations.Size);
        }
 
        public void BuildRectangleGeometry(Figure figure)
        {
            var path = new SerializableGraphicsPath();
            path.Path.AddRectangle(new RectangleF(-0.5f, -0.5f, 1, 1));
            figure.Geometry = new PrimitiveGeometry(path, AllowedOperations.All);
        }
 
        //.....
    }

    /// <summary>
    /// Набор выделенных фигур и операции над ними
    /// </summary>
    public class Selection : Figure
    {
        private HashSet<Figure> Selected = new HashSet<Figure>();
 
        public void Clear()
        {
            Selected.Clear();
            GrabGeometry();
        }
 
        public void Add(Figure fig)
        {
            Selected.Add(fig);
            GrabGeometry();
        }
 
        public void Remove(Figure fig)
        {
            Selected.Remove(fig);
            GrabGeometry();
        }
 
        /// <summary>
        /// Копирование геометрий выделенных фигур в свою геометрию
        /// </summary>
        private void GrabGeometry()
        {
            //grab geometry of selected figures
            var path = new GraphicsPath();
            foreach (var fig in Selected)
                path.AddPath(fig.GetTransformedPath(), false);
 
            //draw frame around selected figures
            var bounds = path.GetBounds();
            path.AddRectangle(bounds);
 
            // choose allowed operations
            // if selected only one figure - just use its AllowedOperations
            // otherwise - allow all operations
            var allowedOperations = Selected.Count == 1 ? Selected.First().Geometry.AllowedOperations : AllowedOperations.All;
 
            //assign geometry
            Geometry = new PrimitiveGeometry(path, allowedOperations);
 
            //reset transform to Identical matrix
            Transform = new Matrix();
        }
 
        /// <summary>
        /// Применение своего Transform к Transform выделенных фигур
        /// </summary>
        public void PushTransformToSelectedFigures()
        {
            foreach (var fig in Selected)
                fig.Transform.Matrix.Multiply(Transform);
 
            GrabGeometry();
        }
    }

public GraphicsPath GetTransformedPath()
{
    // создаём копию геометрии фигуры
    var path = (GraphicsPath)Geometry.Path.Clone();
    
    ... здесь нужно к (Matrix)Transform как-то применить ограничения, указанные
        в наборе флагов AllowedOperations...
 
    // трансформируем её при помощи Трансформера
    path.Transform(Transform);
    return path;
}

fig.Transform.Matrix.Multiply(Transform);

fig.Transform.Matrix.Multiply(Transform, MatrixOrder.Append);

[TestMethod]
public void SelectionFigureTestMethod()
{
    var builder = new FigureBuilder();
    var list = new List<Figure>(); 
    var section = new Selection();
    var colors = new [] {Color.White, Color.Red, Color.Green, Color.Yellow, Color.Blue};
    for (var i = 0; i < 5; i++)
    {
        var fig = new Figure();
        list.Add(fig);
        fig.Style.FillStyle.Color = colors[i];
        fig.Transform.Matrix.Translate(100 + i*10, 50 + i*10);
        fig.Transform.Matrix.Scale(160, 80);
        builder.BuildPolygoneGeometry(fig);
    }
    section.Clear();
    foreach (var figure in list)
        section.Add(figure);
    // пробуем отрисовывать
    using (var bmp = new Bitmap(320, 240))
    {
        using (var canvas = Graphics.FromImage(bmp))
        {
            using (var pen = new Pen(Color.Gray))
            {
                pen.DashStyle = DashStyle.DashDotDot;
                canvas.DrawRectangle(pen, 0, 0, 319, 239);
            }
            foreach (var figure in list)
                figure.Renderer.Render(canvas, figure);
            bmp.Save("RenderedFiveFigures.bmp");
            section.Renderer.Render(canvas, section);
            bmp.Save("RenderedFiveFiguresWithSelection.bmp");
            section.Remove(list[2]);
            section.Renderer.Render(canvas, section);
            bmp.Save("RenderedFourFiguresWithSelection.bmp");
        }
    }
}

        [TestMethod]
        public void SelectionTest()
        {
            //создаем первую фигуру
            var builder = new FigureBuilder();
            var fig1 = new Figure();
            fig1.Transform.Matrix.Translate(50, 50);
            fig1.Transform.Matrix.Scale(100, 100);
            builder.BuildEllipseGeometry(fig1);
 
            //создаем вторую фигуру
            var fig2 = new Figure();
            fig2.Transform.Matrix.Translate(150, 150);
            fig2.Transform.Matrix.Scale(100, 100);
            builder.BuildRectangleGeometry(fig2);
 
            //рисуем до выделения
            Draw("c:\\1.png", fig1, fig2);
 
            //создаем selection
            var selection = new Selection();
            selection.Style.BorderStyle.Width = 1;
            selection.Style.BorderStyle.Color = Color.Magenta;
 
            //выделяем фигуры 
            selection.Add(fig1);
            selection.Add(fig2);
 
            //рисуем после выделения
            Draw("c:\\2.png", fig1, fig2, selection);
 
            //вращаем и выделенные фигуры
            Matrix m = selection.Transform;
            m.RotateAt(45, new PointF(100, 100));
            selection.PushTransformToSelectedFigures();
 
            //рисуем после вращения выделенных фигур
            Draw("c:\\3.png", fig1, fig2, selection);
 
            //перемещаем выделенные фигуры
            m = selection.Transform;
            m.Translate(0, 100);
            selection.PushTransformToSelectedFigures();
 
            //рисуем после перемещения выделенных фигур
            Draw("c:\\4.png", fig1, fig2, selection);
 
            //снимаем выделение, отрисовываем результат
            selection.Clear();
            Draw("c:\\5.png", fig1, fig2, selection);
        }
 
        private static void Draw(string fileName, params Figure[] figures)
        {
            using (var bmp = new Bitmap(400, 400))
            {
                using (var canvas = Graphics.FromImage(bmp))
                {
                    canvas.Clear(Color.White);
                    foreach(var fig in figures)
                        fig.Renderer.Render(canvas, fig);
                }
                bmp.Save(fileName);
            }
        }

/// <summary>
/// Применение своего Transform к Transform выделенных фигур
/// </summary>
public void PushTransformToSelectedFigures()
{
    foreach (var fig in _selected)
        fig.Transform.Multiply(Transform);
 
    GrabGeometry();
}

        /// <summary>
        /// Переводит точку из локальных нормализированных координат (0,0)-(1,1) в мировые координаты
        /// </summary>
        PointF ToWorldCoordinates(PointF p)
        {
            var bounds = GetTransformedPath().GetBounds();
            return new PointF(bounds.Left + p.X * bounds.Width, bounds.Top + p.Y * bounds.Height);
        }
 
        public void Translate(float offsetX, float offsetY)
        {
            var m = new Matrix();
            m.Translate(offsetX, offsetY);
            //
            Transform = m;
        }
 
        public void Scale(float scaleX, float scaleY, PointF anchor)
        {
            //можем менять размер?
            var allowSize = Geometry.AllowedOperations.HasFlag(AllowedOperations.Size);
            var allowScale = Geometry.AllowedOperations.HasFlag(AllowedOperations.Scale);
 
            if (!allowScale && !allowSize)
                return;//не можем менять размеры
 
            if (allowScale && !allowSize)
                //можем шкалировать, но с сохранением аспекта
                //сохраняем аспект
                scaleX = scaleY = Math.Max(scaleX, scaleY);
 
            //считаем якорь в мировых координатах
            var worldAnchor = ToWorldCoordinates(anchor);
 
            //шкалируем относительно якоря
            var m = new Matrix();
            m.Translate(worldAnchor.X, worldAnchor.Y);    //переводим центр координат в якорь
            m.Scale(scaleX, scaleY);                      //масштабируем
            m.Translate(-worldAnchor.X, -worldAnchor.Y);  //возвращаем центр координат
 
            //
            Transform = m;
        }
 
        public void Skew(float skewX, float skewY, PointF anchor)
        {
            //считаем якорь в мировых координатах
            var worldAnchor = ToWorldCoordinates(anchor);
 
            //сдвигаем относительно якоря
            var m = new Matrix();
            m.Translate(worldAnchor.X, worldAnchor.Y);    //переводим центр координат в якорь
            m.Shear(skewX, skewY);                        //сдвигаем
            m.Translate(-worldAnchor.X, -worldAnchor.Y);  //возвращаем центр координат
 
            //
            Transform = m;
        }
 
        public void Rotate(float angle, PointF center)
        {
            //можем вращать?
            var allowRotate = Geometry.AllowedOperations.HasFlag(AllowedOperations.Rotate);
 
            if (!allowRotate)
                return;//не можем вращать
 
            //считаем якорь в мировых координатах
            var worldAnchor = ToWorldCoordinates(center);
 
            //вращаем относительно якоря
            var m = new Matrix();
            m.RotateAt(angle, worldAnchor);      //вращаем
 
            //
            Transform = m;
        }

        [TestMethod]
        public void SelectionTest2()
        {
            //создаем первую фигуру
            var builder = new FigureBuilder();
            var fig1 = new Figure();
            fig1.Transform.Matrix.Translate(150, 150);
            fig1.Transform.Matrix.Scale(30, 30);
            builder.BuildEllipseGeometry(fig1);
 
            //создаем вторую фигуру
            var fig2 = new Figure();
            fig2.Transform.Matrix.Translate(200, 200);
            fig2.Transform.Matrix.Scale(30, 30);
            builder.BuildRectangleGeometry(fig2);
 
            //рисуем до выделения
            Draw("c:\\1.png", fig1, fig2);
 
            //создаем selection
            var selection = new Selection();
            selection.Style.BorderStyle.Width = 1;
            selection.Style.BorderStyle.Color = Color.Magenta;
 
            //выделяем фигуры 
            selection.Add(fig1);
            selection.Add(fig2);
 
            //ресайз по X относительно левого края
            selection.Scale(2, 1, new PointF(0, 0.5f));
            selection.PushTransformToSelectedFigures();
            //рисуем
            Draw("c:\\2.png", fig1, fig2, selection);
 
            //ресайз по Y относительно нижнего края
            selection.Scale(1, 2, new PointF(0.5f, 1));
            selection.PushTransformToSelectedFigures();
            //рисуем
            Draw("c:\\3.png", fig1, fig2, selection);
 
            //вращение относительно центра
            selection.Rotate(45, new PointF(0.5f, 0.5f));
            selection.PushTransformToSelectedFigures();
            //рисуем
            Draw("c:\\4.png", fig1, fig2, selection);
 
            //сдвиг
            selection.Translate(100, 100);
            selection.PushTransformToSelectedFigures();
            //рисуем
            Draw("c:\\5.png", fig1, fig2, selection);
 
            //skew по X относительно нижней границы
            selection.Skew(0.5f, 0, new PointF(0.5f, 1));
            selection.PushTransformToSelectedFigures();
            //рисуем
            Draw("c:\\6.png", fig1, fig2, selection);
 
            //результат
            selection.Clear();
            Draw("c:\\7.png", fig1, fig2, selection);
        }