การใส่ Vector Mask ในเลเยอร์

ภาพรวมของ Vector Mask ในเลเยอร์

Vector mask เป็นเส้นทางที่ไม่ขึ้นอยู่กับความละเอียดที่ตัดข้อความของเลเยอร์ออกไป การใส่ vector mask มักจะแม่นยำกว่าการสร้างด้วยเครื่องมือที่ใช้ pixel คุณสร้าง vector mask ด้วยเครื่องมือด้ามหรือรูปร่าง

Aspose.PSD รองรับการเรนเดอร์และการใช้ vector mask คุณสามารถแก้ไข vector mask โดยการแก้ไขของ Vector Paths

เส้นทาง Vector ใน Aspose.PSD

การเข้าถึงเส้นทาง vector ใน Aspose.PSD ได้ผ่าน VsmsResouce และ VmskResouce ที่เป็นคลาสลูกของ VectorPathDataResource

วิธีแก้ไขเส้นทาง vector?

โครงสร้างเส้นทาง vector

โครงสร้างหลักในการจัดการเส้นทางคือ VectorPathRecord. แต่เพื่อความสะดวกของคุณ โครงสร้างต่อไปนี้ถูกแนะนำ

สำหรับการแก้ไขเส้นทาง vector อย่างสะดวก คุณควรใช้คลาส VectorPath ซึ่งมีเมทอดสำหรับการแก้ไขข้อมูล vector ในทรัพยากรที่ได้มาจาก VectorPathDataResource

เริ่มต้นด้วยการสร้างออบเจ็กต์ของประเภท VectorPath

สำหรับความสะดวก คุณสามารถใช้เมทอดแบบสแตติก VectorDataProvider.CreateVectorPathForLayer มันจะค้นหาทรัพยากร vector ในเลเยอร์นำเข้าและสร้างออบเจ็กต์ VectorPath จากนั้น

หลังจากการแก้ไขทั้งหมด คุณสามารถปรับใช้ออบเจ็กต์ VectorPath กับการเปลี่ยนแปลงกลับไปยังเลเยอร์โดยใช้เมทอดแบบสแตติก VectorDataProvider.UpdateLayerFromVectorPath

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string fileName = "PathExample.psd";

using (var psdImage = (PsdImage)Image.Load(fileName))
{
    // Choose a layer with vector data that you want to edit.
    Layer layer = psdImage.Layers[1];

    // Now we can use VectorPath instance and manipulate path data.
    VectorPath vectorPath = VectorDataProvider.CreateVectorPathForLayer(layer);

    // Apply changes from 'vectorPath' field to the layer.
    VectorDataProvider.UpdateLayerFromVectorPath(layer, vectorPath);
}

ประเภท VectorPath มีรายการของ PathShape องค์ประกอบและระบุภาพเวกเตอร์ทั้งหมดที่สามารถประกอบด้วยรูปร่างหรือหลายรูปร่าง

แต่ละ PathShape เป็นรูปร่างเวกเตอร์ที่ประกอบด้วยเซ็ตอิสระของจุดเบเซียร์

จุดเบเซียร์คือวัตถุของประเภท BezierKnot ซึ่งพื้นฐานของรูปตัวลูกปัจจุบัน

ตัวอย่างโค้ดต่อไปนี้แสดงถึงวิธีเข้าถึงเรขาภิคตาและจุด

// Accessing a figure and points.
PathShape pathShape = vectorPath.Shapes[0];
BezierKnot firstKnot = pathShape.Points[0];

วิธีสร้างรูปร่าง?

เพื่อแก้ไขรูปร่าง ต้องเรียกมาร์กเจ็ตที่มีอยู่จาก VectorPath.Shapes ลิสต์ หรือเพิ่มรูปร่างใหม่โดยการสร้างอินสแตนซ์ PathShape และเพิ่มลงใน Shapes ลิสต์

// Adds new one shape
vectorPath.Shapes.Add(new PathShape());
// or gets an existing
PathShape pathShape = vectorPath.Shapes[0];

วิธีเพิ่มจุด (ข้อความ)?

คุณสามารถจัดการจุดของรูปร่างเป็นสมาชิกของรายการปกติโดยใช้คุณสมบัติ PathShape.Points เช่น คุณสามารถเพิ่มจุดรูปร่าง:

// Add new shape with points
PathShape newShape = new PathShape();
newShape.Points.Add(new BezierKnot(new PointF(65, 175), true));
newShape.Points.Add(new BezierKnot(new PointF(65, 210), true));
newShape.Points.Add(new BezierKnot(new PointF(190, 210), true));
newShape.Points.Add(new BezierKnot(new PointF(190, 175), true));
vectorPath.Shapes.Add(newShape);

BezierKnot ประกอบด้วยจุด Anchor และจุด Control สองประการ

ถ้าจุด Anchor และจุด Control มีค่าเดียวกัน แล้วโหนดนั้นจะมีมุมแห้ง

เพื่อเปลี่ยนตำแหน่งจุด Anchor พร้อมกับจุดควบคุม (คล้ายกับวิธีที่เกิดขึ้นใน Photoshop) BezierKnot มีเมทอด Shift

ตัวอย่างโค้ดต่อไปนี้แสดงการเลื่อนเบเซียร์น็อตทั้งหมดขึ้นตามแนวตั้งโดยพิกยอด Y

คุณสามารถจัดการจุดของรูปร่างเป็นสมาชิกของรายการปกติโดยใช้คุณสมบัติ PathShape.Points เช่น คุณสามารถเพิ่มจุดรูปร่าง:

pathShape.Points[0].Shift(0, 25);

คุณสมบัติของ PathShape

การแก้ไข PathShape ไม่จำกัดในการแก้ไขหลัก ประเภทนี้ยังมีคุณสมบัติอื่น ๆ อีก

PathOperations (การปฏิบัติ Boolean)

คุณสมบัติ PathOperations เป็นการปฏิบัติบูลีเลียน การเปลี่ยนค่าในการกำหนดว่ารูปร่างหลาย ๆ ชิ้นถูกผสมเข้าด้วยกันอย่างไร

มีค่าผลเลือกต่อไปนี้:

• 0 = ไม่รวมรูปร่างทับกัน (การปฏิบัติ XOR)
• 1 = รวมรูปร่าง (การปฏิบัติ OR)
• 2 = ลบรูปร่างด้านหน้า (การปฏิบัติ NOT)
• 3 = ตัดพื้นที่รูปร่าง (การปฏิบัติ AND)

คุณสมบัติ IsClosed

นอกจากนี้ ใช้อินสแตนซ์ของคุณสมบัติ PathShape.IsClosed เราสามารถกำหนดว่าจุดเริ่มและจุดสุดท้ายของรูปร่างเชื่อมกันหรือไม่

รูปร่างที่ปิด	รูปร่างที่เปิด
	

FillColor Property

รูปร่างใดก็สามารถมีสีของตัวเอง ดังนั้นคุณสามารถเปลี่ยนสีสตรีมทั้งหมดของเส้นทางเวกเตอร์ด้วยคุณสมบัติ VectorPath.FillColor

คุณสามารถจัดการจุดของรูปร่างเป็นสมาชิกของรายการปกติโดยใช้คุณสมบัติ PathShape.Points เช่น คุณสามารถเพิ่มจุดรูปร่าง:

vectorPath.FillColor = Color.Violet;

ที่นี่คุณจะพบรหัสต้นฉบับของ VectorDataProvider และคลาสที่เกี่ยวข้อง:

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET


private static void CreatingVectorPathExample(string outputPsd = "outputPsd.psd")
{
    using (var psdImage = (PsdImage)Image.Create(new PsdOptions() { Source = new StreamSource(new MemoryStream()), }, 500, 500))
    {
        FillLayer layer = FillLayer.CreateInstance(FillType.Color);
        psdImage.AddLayer(layer);

        VectorPath vectorPath = VectorDataProvider.CreateVectorPathForLayer(layer);
        vectorPath.FillColor = Color.IndianRed;
        PathShape shape = new PathShape();
        shape.Points.Add(new BezierKnot(new PointF(50, 150), true));
        shape.Points.Add(new BezierKnot(new PointF(100, 200), true));
        shape.Points.Add(new BezierKnot(new PointF(0, 200), true));
        vectorPath.Shapes.Add(shape);
        VectorDataProvider.UpdateLayerFromVectorPath(layer, vectorPath, true);

        psdImage.Save(outputPsd);
    }
}

#region Vector path editor (Here placed classes for edit vector paths).

/// <summary>
/// The class that provides work between <see cref="Layer"/> and <see cref="VectorPath"/>.
/// </summary>
public static class VectorDataProvider
{
    /// <summary>
    /// Creates the <see cref="VectorPath"/> instance based on resources from input layer.
    /// </summary>
    /// <param name="psdLayer">The psd layer.</param>
    /// <returns>the <see cref="VectorPath"/> instance based on resources from input layer.</returns>
    public static VectorPath CreateVectorPathForLayer(Layer psdLayer)
    {
        ValidateLayer(psdLayer);

        Size imageSize = psdLayer.Container.Size;

        VectorPathDataResource pathResource = FindVectorPathDataResource(psdLayer, true);
        SoCoResource socoResource = FindSoCoResource(psdLayer, true);
        VectorPath vectorPath = new VectorPath(pathResource, imageSize);
        if (socoResource != null)
        {
            vectorPath.FillColor = socoResource.Color;
        }

        return vectorPath;
    }

    /// <summary>
    /// Updates the input layer resources from <see cref="VectorPath"/> instance, or replace by new path resource and updates.
    /// </summary>
    /// <param name="psdLayer">The psd layer.</param>
    /// <param name="vectorPath">The vector path.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    public static void UpdateLayerFromVectorPath(Layer psdLayer, VectorPath vectorPath, bool createIfNotExist = false)
    {
        ValidateLayer(psdLayer);

        VectorPathDataResource pathResource = FindVectorPathDataResource(psdLayer, createIfNotExist);
        VogkResource vogkResource = FindVogkResource(psdLayer, createIfNotExist);
        SoCoResource socoResource = FindSoCoResource(psdLayer, createIfNotExist);

        Size imageSize = psdLayer.Container.Size;
        UpdateResources(pathResource, vogkResource, socoResource, vectorPath, imageSize);

        ReplaceVectorPathDataResourceInLayer(psdLayer, pathResource, vogkResource, socoResource);
    }

    /// <summary>
    /// Removes the vector path data from input layer.
    /// </summary>
    /// <param name="psdLayer">The psd layer.</param>
    public static void RemoveVectorPathDataFromLayer(Layer psdLayer)
    {
        List<LayerResource> oldResources = new List<LayerResource>(psdLayer.Resources);
        List<LayerResource> newResources = new List<LayerResource>();
        for (int i = 0; i < oldResources.Count; i++)
        {
            LayerResource resource = oldResources[i];

            if (resource is VectorPathDataResource || resource is VogkResource || resource is SoCoResource)
            {
                continue;
            }
            else
            {
                newResources.Add(resource);
            }
        }

        psdLayer.Resources = newResources.ToArray();
    }

    /// <summary>
    /// Updates resources data from <see cref="VectorPath"/> instance.
    /// </summary>
    /// <param name="pathResource">The path resource.</param>
    /// <param name="vogkResource">The vector origination data resource.</param>
    /// <param name="socoResource">The solid color resource.</param>
    /// <param name="vectorPath">The vector path.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    private static void UpdateResources(VectorPathDataResource pathResource, VogkResource vogkResource, SoCoResource socoResource, VectorPath vectorPath, Size imageSize)
    {
        pathResource.Version = vectorPath.Version;
        pathResource.IsNotLinked = vectorPath.IsNotLinked;
        pathResource.IsDisabled = vectorPath.IsDisabled;
        pathResource.IsInverted = vectorPath.IsInverted;

        List<VectorShapeOriginSettings> originSettings = new List<VectorShapeOriginSettings>();
        List<VectorPathRecord> path = new List<VectorPathRecord>();
        path.Add(new PathFillRuleRecord(null));
        path.Add(new InitialFillRuleRecord(vectorPath.IsFillStartsWithAllPixels));
        for (ushort i = 0; i < vectorPath.Shapes.Count; i++)
        {
            PathShape shape = vectorPath.Shapes[i];
            shape.ShapeIndex = i;
            path.AddRange(shape.ToVectorPathRecords(imageSize));
            originSettings.Add(new VectorShapeOriginSettings() { IsShapeInvalidated = true, OriginIndex = i });
        }

        pathResource.Paths = path.ToArray();
        vogkResource.ShapeOriginSettings = originSettings.ToArray();

        socoResource.Color = vectorPath.FillColor;
    }

    /// <summary>
    /// Replaces resources in layer by updated or new ones.
    /// </summary>
    /// <param name="psdLayer">The psd layer.</param>
    /// <param name="pathResource">The path resource.</param>
    /// <param name="vogkResource">The vector origination data resource.</param>
    /// <param name="socoResource">The solid color resource.</param>
    private static void ReplaceVectorPathDataResourceInLayer(Layer psdLayer, VectorPathDataResource pathResource, VogkResource vogkResource, SoCoResource socoResource)
    {
        bool pathResourceExist = false;
        bool vogkResourceExist = false;
        bool socoResourceExist = false;

        List<LayerResource> resources = new List<LayerResource>(psdLayer.Resources);
        for (int i = 0; i < resources.Count; i++)
        {
            LayerResource resource = resources[i];
            if (resource is VectorPathDataResource)
            {
                resources[i] = pathResource;
                pathResourceExist = true;
            }
            else if (resource is VogkResource)
            {
                resources[i] = vogkResource;
                vogkResourceExist = true;
            }
            else if (resource is SoCoResource)
            {
                resources[i] = socoResource;
                socoResourceExist = true;
            }
        }

        if (!pathResourceExist)
        {
            resources.Add(pathResource);
        }

        if (!vogkResourceExist)
        {
            resources.Add(vogkResource);
        }

        if (!socoResourceExist)
        {
            resources.Add(socoResource);
        }

        psdLayer.Resources = resources.ToArray();
    }

    /// <summary>
    /// Finds the <see cref="VectorPathDataResource"/> resource in input layer resources.
    /// </summary>
    /// <param name="psdLayer">The psd layer.</param>
    /// <param name="createIfNotExist">If resource not exists, then for <see cref="true"/> creates a new resource, otherwise return <see cref="null"/>.</param>
    /// <returns>The <see cref="VectorPathDataResource"/> resource.</returns>
    private static VectorPathDataResource FindVectorPathDataResource(Layer psdLayer, bool createIfNotExist = false)
    {
        VectorPathDataResource pathResource = null;
        foreach (var resource in psdLayer.Resources)
        {
            if (resource is VectorPathDataResource)
            {
                pathResource = (VectorPathDataResource)resource;
                break;
            }
        }

        if (createIfNotExist && pathResource == null)
        {
            pathResource = new VmskResource();
        }

        return pathResource;
    }

    /// <summary>
    /// Finds the <see cref="VogkResource"/> resource in input layer resources.
    /// </summary>
    /// <param name="psdLayer">The psd layer.</param>
    /// <param name="createIfNotExist">If resource not exists, then for <see cref="true"/> creates a new resource, otherwise return <see cref="null"/>.</param>
    /// <returns>The <see cref="VogkResource"/> resource.</returns>
    private static VogkResource FindVogkResource(Layer psdLayer, bool createIfNotExist = false)
    {
        VogkResource vogkResource = null;
        foreach (var resource in psdLayer.Resources)
        {
            if (resource is VogkResource)
            {
                vogkResource = (VogkResource)resource;
                break;
            }
        }

        if (createIfNotExist && vogkResource == null)
        {
            vogkResource = new VogkResource();
        }

        return vogkResource;
    }

    /// <summary>
    /// Finds the <see cref="SoCoResource"/> resource in input layer resources.
    /// </summary>
    /// <param name="psdLayer">The psd layer.</param>
    /// <param name="createIfNotExist">If resource not exists, then for <see cref="true"/> creates a new resource, otherwise return <see cref="null"/>.</param>
    /// <returns>The <see cref="SoCoResource"/> resource.</returns>
    private static SoCoResource FindSoCoResource(Layer psdLayer, bool createIfNotExist = false)
    {
        SoCoResource socoResource = null;
        foreach (var resource in psdLayer.Resources)
        {
            if (resource is SoCoResource)
            {
                socoResource = (SoCoResource)resource;
                break;
            }
        }

        if (createIfNotExist && socoResource == null)
        {
            socoResource = new SoCoResource();
        }

        return socoResource;
    }

    /// <summary>
    /// Validates the layer to work with <see cref="VectorDataProvider"/> class.
    /// </summary>
    /// <param name="layer"></param>
    /// <exception cref="ArgumentNullException"></exception>
    private static void ValidateLayer(Layer layer)
    {
        if (layer == null)
        {
            throw new ArgumentNullException("The layer is NULL.");
        }

        if (layer.Container == null || layer.Container.Size.IsEmpty)
        {
            throw new ArgumentNullException("The layer should have a Container with no empty size.");
        }
    }
}

/// <summary>
/// The Bezier curve knot, it contains one anchor point and two control points.
/// </summary>
public class BezierKnot
{
    /// <summary>
    /// Image to path point ratio.
    /// </summary>
    private const int ImgToPsdRatio = 256 * 65535;

    /// <summary>
    /// Initializes a new instance of the <see cref="BezierKnot" /> class.
    /// </summary>
    /// <param name="anchorPoint">The anchor point.</param>
    /// <param name="controlPoint1">The first control point.</param>
    /// <param name="controlPoint2">THe second control point.</param>
    /// <param name="isLinked">The value indicating whether this knot is linked.</param>
    public BezierKnot(PointF anchorPoint, PointF controlPoint1, PointF controlPoint2, bool isLinked)
    {
        this.AnchorPoint = anchorPoint;
        this.ControlPoint1 = controlPoint1;
        this.ControlPoint2 = controlPoint2;
        this.IsLinked = isLinked;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="BezierKnot" /> class based on <see cref="BezierKnotRecord"/>.
    /// </summary>
    /// <param name="bezierKnotRecord">The <see cref="BezierKnotRecord"/>.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    public BezierKnot(BezierKnotRecord bezierKnotRecord, Size imageSize)
    {
        this.IsLinked = bezierKnotRecord.IsLinked;
        this.ControlPoint1 = ResourcePointToPointF(bezierKnotRecord.Points[0], imageSize);
        this.AnchorPoint = ResourcePointToPointF(bezierKnotRecord.Points[1], imageSize);
        this.ControlPoint2 = ResourcePointToPointF(bezierKnotRecord.Points[2], imageSize);
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="BezierKnot" /> class.
    /// </summary>
    /// <param name="anchorPoint">The point to be anchor and control points.</param>
    /// <param name="isLinked">The value indicating whether this knot is linked.</param>
    public BezierKnot(PointF anchorPoint, bool isLinked)
    : this(anchorPoint, anchorPoint, anchorPoint, isLinked)
    {
    }

    /// <summary>
    /// Gets or sets a value indicating whether this instance is linked.
    /// </summary>
    public bool IsLinked { get; set; }

    /// <summary>
    /// Gets or sets the first control point.
    /// </summary>
    public PointF ControlPoint1 { get; set; }

    /// <summary>
    /// Gets or sets the anchor point.
    /// </summary>
    public PointF AnchorPoint { get; set; }

    /// <summary>
    /// Gets or sets the second control point.
    /// </summary>
    public PointF ControlPoint2 { get; set; }

    /// <summary>
    /// Creates the instance of <see cref="BezierKnotRecord"/> based on this instance.
    /// </summary>
    /// <param name="isClosed">Indicating whether this knot is in closed shape.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    /// <returns>The instance of <see cref="BezierKnotRecord"/> based on this instance.</returns>
    public BezierKnotRecord ToBezierKnotRecord(bool isClosed, Size imageSize)
    {
        BezierKnotRecord record = new BezierKnotRecord();
        record.Points = new Point[]
        {
            PointFToResourcePoint(this.ControlPoint1, imageSize),
            PointFToResourcePoint(this.AnchorPoint, imageSize),
            PointFToResourcePoint(this.ControlPoint2, imageSize),
        };
        record.IsLinked = this.IsLinked;
        record.IsClosed = isClosed;

        return record;
    }

    /// <summary>
    /// Shifts this knot points by input values.
    /// </summary>
    /// <param name="xOffset">The x offset.</param>
    /// <param name="yOffset">The y offset.</param>
    public void Shift(float xOffset, float yOffset)
    {
        this.ControlPoint1 = new PointF(this.ControlPoint1.X + xOffset, this.ControlPoint1.Y + yOffset);
        this.AnchorPoint = new PointF(this.AnchorPoint.X + xOffset, this.AnchorPoint.Y + yOffset);
        this.ControlPoint2 = new PointF(this.ControlPoint2.X + xOffset, this.ControlPoint2.Y + yOffset);
    }

    /// <summary>
    /// Converts point values from resource to normal.
    /// </summary>
    /// <param name="point">The point with values from resource.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    /// <returns>The converted to normal point.</returns>
    private static PointF ResourcePointToPointF(Point point, Size imageSize)
    {
        return new PointF(point.Y / (ImgToPsdRatio / imageSize.Width), point.X / (ImgToPsdRatio / imageSize.Height));
    }

    /// <summary>
    /// Converts normal point values to resource point.
    /// </summary>
    /// <param name="point">The point.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    /// <returns>The point with values for resource.</returns>
    private static Point PointFToResourcePoint(PointF point, Size imageSize)
    {
        return new Point((int)Math.Round(point.Y * (ImgToPsdRatio / imageSize.Height)), (int)Math.Round(point.X * (ImgToPsdRatio / imageSize.Width)));
    }
}

/// <summary>
/// The figure from the knots of the Bezier curve.
/// </summary>
public class PathShape
{
    /// <summary>
    /// Initializes a new instance of the <see cref="PathShape" /> class.
    /// </summary>
    public PathShape()
    {
        this.Points = new List<BezierKnot>();
        this.PathOperations = PathOperations.CombineShapes;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="PathShape" /> class based on <see cref="VectorPathRecord"/>'s.
    /// </summary>
    /// <param name="lengthRecord">The length record.</param>
    /// <param name="bezierKnotRecords">The bezier knot records.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    public PathShape(LengthRecord lengthRecord, List<BezierKnotRecord> bezierKnotRecords, Size imageSize)
    : this()
    {
        this.IsClosed = lengthRecord.IsClosed;
        this.PathOperations = lengthRecord.PathOperations;
        this.ShapeIndex = lengthRecord.ShapeIndex;
        this.InitFromResources(bezierKnotRecords, imageSize);
    }

    /// <summary>
    /// Gets or sets a value indicating whether this instance is closed.
    /// </summary>
    /// <value>
    ///   <c>true</c> if this instance is closed; otherwise, <c>false</c>.
    /// </value>
    public bool IsClosed { get; set; }

    /// <summary>
    /// Gets or sets the path operations (Boolean operations).
    /// </summary>
    public PathOperations PathOperations { get; set; }

    /// <summary>
    /// Gets or sets the index of current path shape in layer.
    /// </summary>
    public ushort ShapeIndex { get; set; }

    /// <summary>
    /// Gets the points of the Bezier curve.
    /// </summary>
    public List<BezierKnot> Points { get; private set; }

    /// <summary>
    /// Creates the <see cref="VectorPathRecord"/> records based on this instance.
    /// </summary>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    /// <returns>Returns one <see cref="LengthRecord"/> and <see cref="BezierKnotRecord"/> for each point in this instance.</returns>
    public IEnumerable<VectorPathRecord> ToVectorPathRecords(Size imageSize)
    {
        List<VectorPathRecord> shapeRecords = new List<VectorPathRecord>();

        LengthRecord lengthRecord = new LengthRecord();
        lengthRecord.IsClosed = this.IsClosed;
        lengthRecord.BezierKnotRecordsCount = this.Points.Count;
        lengthRecord.PathOperations = this.PathOperations;
        lengthRecord.ShapeIndex = this.ShapeIndex;
        shapeRecords.Add(lengthRecord);

        foreach (var bezierKnot in this.Points)
        {
            shapeRecords.Add(bezierKnot.ToBezierKnotRecord(this.IsClosed, imageSize));
        }

        return shapeRecords;
    }

    /// <summary>
    /// Initializes a values based on input records.
    /// </summary>
    /// <param name="bezierKnotRecords">The bezier knot records.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    private void InitFromResources(IEnumerable<BezierKnotRecord> bezierKnotRecords, Size imageSize)
    {
        List<BezierKnot> newPoints = new List<BezierKnot>();

        foreach (var record in bezierKnotRecords)
        {
            newPoints.Add(new BezierKnot(record, imageSize));
        }

        this.Points = newPoints;
    }
}

/// <summary>
/// The class that contains vector paths.
/// </summary>
public class VectorPath
{
    /// <summary>
    /// Initializes a new instance of the <see cref="VectorPath" /> class based on <see cref="VectorPathDataResource"/>.
    /// </summary>
    /// <param name="vectorPathDataResource">The vector path data resource.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    public VectorPath(VectorPathDataResource vectorPathDataResource, Size imageSize)
    {
        this.InitFromResource(vectorPathDataResource, imageSize);
    }

    /// <summary>
    /// Gets or sets a value indicating whether is fill starts with all pixels.
    /// </summary>
    /// <value>
    /// The is fill starts with all pixels.
    /// </value>
    public bool IsFillStartsWithAllPixels { get; set; }

    /// <summary>
    /// Gets the vector shapes.
    /// </summary>
    public List<PathShape> Shapes { get; private set; }

    /// <summary>
    /// Gets or sets the vector path fill color.
    /// </summary>
    public Color FillColor { get; set; }

    /// <summary>
    /// Gets or sets the version.
    /// </summary>
    /// <value>
    /// The version.
    /// </value>
    public int Version { get; set; }

    /// <summary>
    /// Gets or sets a value indicating whether this instance is disabled.
    /// </summary>
    /// <value>
    ///   <c>true</c> if this instance is disabled; otherwise, <c>false</c>.
    /// </value>
    public bool IsDisabled { get; set; }

    /// <summary>
    /// Gets or sets a value indicating whether this instance is not linked.
    /// </summary>
    /// <value>
    ///   <c>true</c> if this instance is not linked; otherwise, <c>false</c>.
    /// </value>
    public bool IsNotLinked { get; set; }

    /// <summary>
    /// Gets or sets a value indicating whether this instance is inverted.
    /// </summary>
    /// <value>
    ///   <c>true</c> if this instance is inverted; otherwise, <c>false</c>.
    /// </value>
    public bool IsInverted { get; set; }

    /// <summary>
    /// Initializes a values based on input <see cref="VectorPathDataResource"/> resource.
    /// </summary>
    /// <param name="resource">The vector path data resource.</param>
    /// <param name="imageSize">The image size to correct converting point coordinates.</param>
    private void InitFromResource(VectorPathDataResource resource, Size imageSize)
    {
        List<PathShape> newShapes = new List<PathShape>();
        InitialFillRuleRecord initialFillRuleRecord = null;
        LengthRecord lengthRecord = null;
        List<BezierKnotRecord> bezierKnotRecords = new List<BezierKnotRecord>();

        foreach (var pathRecord in resource.Paths)
        {
            if (pathRecord is LengthRecord)
            {
                if (bezierKnotRecords.Count > 0)
                {
                    newShapes.Add(new PathShape(lengthRecord, bezierKnotRecords, imageSize));
                    lengthRecord = null;
                    bezierKnotRecords.Clear();
                }

                lengthRecord = (LengthRecord)pathRecord;
            }
            else if (pathRecord is BezierKnotRecord)
            {
                bezierKnotRecords.Add((BezierKnotRecord)pathRecord);
            }
            else if (pathRecord is InitialFillRuleRecord)
            {
                initialFillRuleRecord = (InitialFillRuleRecord)pathRecord;
            }
        }

        if (bezierKnotRecords.Count > 0)
        {
            newShapes.Add(new PathShape(lengthRecord, bezierKnotRecords, imageSize));
            lengthRecord = null;
            bezierKnotRecords.Clear();
        }

        this.IsFillStartsWithAllPixels = initialFillRuleRecord != null ? initialFillRuleRecord.IsFillStartsWithAllPixels : false;
        this.Shapes = newShapes;

        this.Version = resource.Version;
        this.IsNotLinked = resource.IsNotLinked;
        this.IsDisabled = resource.IsDisabled;
        this.IsInverted = resource.IsInverted;
    }
}

#endregion