コード例 #1
0
        private static byte[] CreateThumbnail(Service.Pattern pattern, int thumbnailWidth, int thumbnailHeight)
        {
            var size   = GetStitchSize((int)pattern.Width, (int)pattern.Height, thumbnailWidth, thumbnailHeight);
            var width  = pattern.Width * size;
            var height = pattern.Height * size;
            var bitmap = new SKBitmap((int)width, (int)height);
            var canvas = new SKCanvas(bitmap);

            canvas.Clear();

            foreach (var stitch in pattern.Stitches)
            {
                var configuration = pattern.Configurations[stitch.ConfigurationIndex];
                var paint         = new SKPaint {
                    Color = SKColor.Parse(configuration.HexColor)
                };
                var rect = new SKRect
                {
                    Left   = stitch.X * size,
                    Top    = stitch.Y * size,
                    Right  = (stitch.X + 1) * size,
                    Bottom = (stitch.Y + 1) * size
                };
                canvas.DrawRect(rect, paint);
            }

            var x     = (int)(width - thumbnailWidth) / 2;
            var y     = (int)(height - thumbnailHeight) / 2;
            var image = SKImage.FromBitmap(bitmap).Subset(SKRectI.Create(x, y, thumbnailWidth, thumbnailHeight));

            return(image.Encode(SKEncodedImageFormat.Png, 100).ToArray());
        }
コード例 #2
0
        private static Service.Pattern Convert(Pattern pattern)
        {
            // TODO: Cover property mapping with tests.
            var result = new Service.Pattern
            {
                Width  = pattern.Width,
                Height = pattern.Height,
                Canvas = new Service.Canvas
                {
                    Title = pattern.Canvas.Title
                },
                Info = new Service.Info
                {
                    Title     = pattern.Info.Title,
                    Author    = pattern.Info.Author,
                    Company   = pattern.Info.Company,
                    Copyright = pattern.Info.Copyright
                },
                Strands = new Service.Strands
                {
                    Backstitch   = pattern.Strands.BackStitch,
                    FrenchKnot   = pattern.Strands.FrenchKnot,
                    Full         = pattern.Strands.Full,
                    Half         = pattern.Strands.Half,
                    Petit        = pattern.Strands.Petit,
                    Quarter      = pattern.Strands.Quarter,
                    ThreeQuarter = pattern.Strands.ThreeQuarter
                }
            };

            foreach (var color in pattern.Colors)
            {
                result.Configurations.Add(new StitchConfiguration
                {
                    Symbol   = color.Symbol,
                    HexColor = "#" + color.Rgb.R.ToString("x2") + color.Rgb.G.ToString("x2") +
                               color.Rgb.B.ToString("x2")
                });
                if (!color.Strands.Equals(default(Strands)))
                {
                    result.Configurations[color.Index].Strands = new Service.Strands
                    {
                        Backstitch   = color.Strands.BackStitch,
                        FrenchKnot   = color.Strands.FrenchKnot,
                        Full         = color.Strands.Full,
                        Half         = color.Strands.Half,
                        Petit        = color.Strands.Petit,
                        Quarter      = color.Strands.Quarter,
                        ThreeQuarter = color.Strands.ThreeQuarter
                    }
                }
                ;
            }

            foreach (var stitch in pattern.Stitches)
            {
                result.Stitches.Add(new Service.Stitch
                {
                    X    = stitch.Offset / pattern.Height,
                    Y    = stitch.Offset % pattern.Height,
                    Type = (StitchType)Enum.Parse(typeof(StitchType), stitch.ItemType.ToString()),
                    ConfigurationIndex = stitch.Color.Index
                });
            }

            foreach (var backstitch in pattern.Backstitches)
            {
                result.Backstitches.Add(new Service.Backstitch
                {
                    X1 = backstitch.X1,
                    X2 = backstitch.X2,
                    Y1 = backstitch.Y1,
                    Y2 = backstitch.Y2,
                    ConfigurationIndex = backstitch.Color.Index
                });
            }

            foreach (var node in pattern.Nodes)
            {
                result.Elements.Add(new Element
                {
                    X    = node.X,
                    Y    = node.Y,
                    Type = (ElementType)Enum.Parse(typeof(ElementType), ((int)node.Type).ToString(), true),
                    ConfigurationIndex = node.Color.Index
                });
            }

            // TODO: Find out what to do with ThreadCountX and ThreadCountY.

            return(result);
        }