Пример #1
0
        void Merge(string addImageName)
        {
            SixLabors.ImageSharp.Image baseImage = SixLabors.ImageSharp.Image.Load(Path.Combine(temp_path, pictureBox1.Name));
            SixLabors.ImageSharp.Image addImage  = SixLabors.ImageSharp.Image.Load(Path.Combine(temp_path, addImageName));

            SixLabors.ImageSharp.Point toRight = new SixLabors.ImageSharp.Point(x: baseImage.Width, y: 0);
            SixLabors.ImageSharp.Point topLeft = new SixLabors.ImageSharp.Point(x: 0, y: 0);

            SixLabors.ImageSharp.Image newImage = new SixLabors.ImageSharp.Image <Rgba32>(baseImage.Width + addImage.Width, baseImage.Height);

            newImage = newImage.Clone(ipc =>
            {
                ipc.DrawImage(baseImage, topLeft, 1);
                ipc.DrawImage(addImage, toRight, 1);
            });
            using (MemoryStream memoryStream = new MemoryStream())
            {
                SixLabors.ImageSharp.Formats.IImageEncoder imageEncoder = newImage.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance);

                newImage.Save(memoryStream, imageEncoder);

                (new Bitmap(memoryStream)).Save(Path.Combine(temp_path, "generated.png"));
                Merge_Execution(new Bitmap(memoryStream));
            }
        }
Пример #2
0
        protected override void OnSave(Document input, Stream output, SaveConfigToken token, Surface scratchSurface, ProgressEventHandler callback)
        {
            /// Up to date raw data.
            using (RenderArgs renderArgs = new RenderArgs(scratchSurface))
            {
                input.Render(renderArgs, true);
            }
            var bitmap = scratchSurface.CreateAliasedBitmap();

            byte[] rawData;
            using (var memoryStream = new MemoryStream())
            {
                bitmap.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Png);
                memoryStream.Position = 0;
                rawData = memoryStream.ToArray();
            }

            SixLabors.ImageSharp.Image <SixLabors.ImageSharp.PixelFormats.Rgba32> fullImage = SixLabors.ImageSharp.Image.Load(rawData);

            var originalMetaData = input.Metadata.GetUserValue(MetadataNames.DMI_RawData);

            DMISharp.DMIFile dmi;
            if (!String.IsNullOrEmpty(originalMetaData))
            {
                //Modyfing loaded DMI - preserve states info, apply frame changes and state name changes
                byte[] originalRawData = Convert.FromBase64String(originalMetaData);
                dmi = new DMISharp.DMIFile(new MemoryStream(originalRawData));

                /// Update every state image from current document
                var frameNumber = 0;
                foreach (var state in dmi.States)
                {
                    for (int frame = 0; frame < state.Frames; frame++)
                    {
                        for (int dir = 0; dir < state.Dirs; dir++)
                        {
                            var         offset    = CalculateOffset(frameNumber, input.Width, input.Height, dmi.Metadata.FrameWidth, dmi.Metadata.FrameHeight);
                            Point2Int32 dstOffset = new Point2Int32(offset.X, offset.Y);
                            RectInt32   srcRect   = new RectInt32(dstOffset, new SizeInt32(dmi.Metadata.FrameWidth, dmi.Metadata.FrameHeight));
                            var         newFrame  = fullImage.Clone(x => x.Crop(new SixLabors.ImageSharp.Rectangle(offset.X, offset.Y, dmi.Metadata.FrameWidth, dmi.Metadata.FrameHeight)));
                            state.SetFrame(newFrame, (DMISharp.StateDirection)dir, frame);
                            frameNumber += 1;
                        }
                    }
                }
                ///Update state names if they changed
                foreach (var layer in input.Layers)
                {
                    var stateName = layer.Metadata.GetUserValue(MetadataNames.DMI_StateName);
                    if (!String.IsNullOrEmpty(stateName))
                    {
                        var originalState = dmi.States.Where(state => state.Name == stateName).FirstOrDefault();
                        originalState.Name = layer.Name;
                    }
                }
            }
            else
            {
                //Creating DMI from scratch - generate icon state per layer, assume square frames, single dir and no animations
                var framesPerLine = (int)Math.Ceiling(Math.Sqrt(input.Layers.Count));
                var frameWidth    = input.Width / framesPerLine;
                var frameHeight   = input.Height / framesPerLine;
                dmi = new DMISharp.DMIFile(frameWidth, frameHeight);
                var stateCounter = 0;
                foreach (var layer in input.Layers)
                {
                    var offset   = CalculateOffset(stateCounter, input.Width, input.Height, frameWidth, frameHeight);
                    var newFrame = fullImage.Clone(x => x.Crop(new SixLabors.ImageSharp.Rectangle(offset.X, offset.Y, frameWidth, frameHeight)));
                    var newState = new DMISharp.DMIState(layer.Name, DMISharp.DirectionDepth.One, 1, frameWidth, frameHeight);
                    newState.SetFrame(newFrame, 0);
                    dmi.AddState(newState);
                    stateCounter += 1;
                }
            }
            dmi.Save(output);
        }
Пример #3
0
        void Image_Edit(int option)
        {
            if (pictureBox1.Name.ToLower() != "picturebox1")
            {
                SixLabors.ImageSharp.Image baseImage = SixLabors.ImageSharp.Image.Load(Path.Combine(temp_path, pictureBox1.Name));
                SixLabors.ImageSharp.Image newImage  = baseImage.Clone(ipc =>
                {
                    switch (option)
                    {
                    case 1:
                        ipc.Grayscale();
                        break;

                    case 2:
                        ipc.Brightness(0.9f);
                        break;

                    case 3:
                        ipc.Brightness(1.1f);
                        break;

                    case 4:
                        ipc.Contrast(1.1f);
                        //ipc.ColorBlindness(ColorBlindnessMode.Achromatomaly);
                        //ipc.ColorBlindness(ColorBlindnessMode.Achromatopsia);
                        //ipc.ColorBlindness(ColorBlindnessMode.Deuteranomaly);
                        //ipc.ColorBlindness(ColorBlindnessMode.Deuteranopia);
                        //ipc.ColorBlindness(ColorBlindnessMode.Protanomaly);
                        //ipc.ColorBlindness(ColorBlindnessMode.Protanopia);
                        //ipc.ColorBlindness(ColorBlindnessMode.Tritanomaly);
                        //ipc.ColorBlindness(ColorBlindnessMode.Tritanopia);
                        break;

                    case 5:
                        ipc.Contrast(0.9f);
                        break;

                    case 6:
                        ipc.Flip(FlipMode.Horizontal);
                        break;

                    case 7:
                        ipc.Flip(FlipMode.Vertical);
                        break;

                    case 8:
                        ipc.GaussianSharpen();
                        break;

                    case 9:
                        ipc.EntropyCrop();
                        break;

                    case 10:
                        ipc.Dither();
                        break;

                    case 11:
                        ipc.AdaptiveThreshold();
                        break;
                    }
                });
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    SixLabors.ImageSharp.Formats.IImageEncoder imageEncoder = newImage.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance);

                    newImage.Save(memoryStream, imageEncoder);

                    (new Bitmap(memoryStream)).Save(Path.Combine(temp_path, "generated.png"));
                    Merge_Execution(new Bitmap(memoryStream));
                }
            }
        }
Пример #4
0
        void Image_Edit(int option)
        {
            if (mainForm.PictureBoxName.ToLower() != "picturebox1")
            {
                SixLabors.ImageSharp.Image baseImage = SixLabors.ImageSharp.Image.Load(Path.Combine(temp_path, mainForm.PictureBoxName));
                SixLabors.ImageSharp.Image newImage  = baseImage.Clone(ipc =>
                {
                    switch (option)
                    {
                    case 1: ipc.Grayscale(); break;

                    case 2: ipc.Brightness(1.1f); break;

                    case 3: ipc.Brightness(0.9f); break;

                    case 4: ipc.Contrast(1.1f); break;

                    case 5: ipc.Contrast(0.9f); break;

                    case 6: ipc.Flip(FlipMode.Horizontal); break;

                    case 7: ipc.Flip(FlipMode.Vertical); break;

                    case 8: ipc.GaussianSharpen(); break;

                    case 9: ipc.EntropyCrop(); break;

                    case 10: ipc.Dither(); break;

                    case 11: ipc.AdaptiveThreshold(); break;

                    case 12: ipc.HistogramEqualization(); break;

                    case 13: ipc.Invert(); break;

                    case 14: ipc.Kodachrome(); break;

                    case 15: ipc.Lomograph(); break;

                    case 16: ipc.OilPaint(); break;

                    case 17: ipc.Pixelate(); break;

                    case 18: ipc.Polaroid(); break;

                    case 19: ipc.Sepia(); break;

                    case 20: ipc.Vignette(); break;

                    case 21: ipc.Glow(SixLabors.ImageSharp.Color.White); break;

                    case 22: ipc.Glow(SixLabors.ImageSharp.Color.Black); break;

                    case 23: ipc.Hue(20); break;

                    case 24: ipc.Hue(-20); break;

                    case 25: ipc.Saturate(1.4f); break;

                    case 26: ipc.Saturate(0.6f); break;

                    case 27: ipc.Skew(5, 0); break;

                    case 28: ipc.Skew(-5, 0); break;

                    case 29: ipc.Skew(0, 5); break;

                    case 30: ipc.Skew(0, -5); break;

                    case 31: ipc.ColorBlindness(ColorBlindnessMode.Achromatomaly); break;

                    case 32: ipc.ColorBlindness(ColorBlindnessMode.Achromatopsia); break;

                    case 33: ipc.ColorBlindness(ColorBlindnessMode.Deuteranomaly); break;

                    case 34: ipc.ColorBlindness(ColorBlindnessMode.Deuteranopia); break;

                    case 35: ipc.ColorBlindness(ColorBlindnessMode.Protanomaly); break;

                    case 36: ipc.ColorBlindness(ColorBlindnessMode.Protanopia); break;

                    case 37: ipc.ColorBlindness(ColorBlindnessMode.Tritanomaly); break;

                    case 38: ipc.ColorBlindness(ColorBlindnessMode.Tritanopia); break;
                    }
                });
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    SixLabors.ImageSharp.Formats.IImageEncoder imageEncoder = newImage.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance);

                    newImage.Save(memoryStream, imageEncoder);

                    (new Bitmap(memoryStream)).Save(Path.Combine(temp_path, "generated.png"));
                    mainForm.Merge_Execution(new Bitmap(memoryStream));
                }
            }
        }