Class MagicWandTool

Class MagicWandTool

Namespace: Aspose.Imaging.MagicWand
Assembly: Aspose.Imaging.dll (25.2.0)

The class for magic wand algorithm main logic.

public class MagicWandTool : IPartialArgb32PixelLoader

Inheritance

objectMagicWandTool

Implements

IPartialArgb32PixelLoader

Inherited Members

object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Examples

The example shows how to select a simple area of an image based on tone and color of any pixel using Magic Wand tool.```csharp [C#]

                                                                                                                            var imageFilePath = "input.png"; 
                                                                                                                            using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
                                                                                                                            {
                                                                                                                                // Create a new mask using magic wand tool based on tone and color of pixel (120, 100) with custom threshold equal to 150
                                                                                                                                MagicWandTool
                                                                                                                                    .Select(image, new MagicWandSettings(120, 100) { Threshold = 150 })
                                                                                                                                    // Apply mask to the image
                                                                                                                                    .Apply();

                                                                                                                                // Save image with forced transparency color type option
                                                                                                                                image.Save(outputFilePath, new ImageOptions.PngOptions()
                                                                                                                                {
                                                                                                                                    ColorType = PngColorType.TruecolorWithAlpha
                                                                                                                                });
                                                                                                                            }

The example shows how to select a complicated area of an image using Magic Wand tool and the ability to interact with masks (invert, union, substract).```csharp
[C#]

                                                                                                                                                                  var imageFilePath = "input.png"; 
                                                                                                                                                                  using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
                                                                                                                                                                  {
                                                                                                                                                                      // Create a new mask using magic wand tool based on tone and color of pixel (845, 128)
                                                                                                                                                                      MagicWandTool.Select(image, new MagicWandSettings(845, 128))
                                                                                                                                                                          // Union the existing mask with the specified one created by magic wand tool
                                                                                                                                                                          .Union(new MagicWandSettings(416, 387))
                                                                                                                                                                          // Invert the existing mask
                                                                                                                                                                          .Invert()
                                                                                                                                                                          // Subtract the specified mask created by magic wand tool with specified threshold from the existing one 
                                                                                                                                                                          .Subtract(new MagicWandSettings(1482, 346) { Threshold = 69 })
                                                                                                                                                                          // Subtract four specified rectangle masks from the existing mask one by one
                                                                                                                                                                          .Subtract(new RectangleMask(0, 0, 800, 150))
                                                                                                                                                                          .Subtract(new RectangleMask(0, 380, 600, 220))
                                                                                                                                                                          .Subtract(new RectangleMask(930, 520, 110, 40))
                                                                                                                                                                          .Subtract(new RectangleMask(1370, 400, 120, 200))
                                                                                                                                                                          // Feather mask with specified settings
                                                                                                                                                                          .GetFeathered(new FeatheringSettings() { Size = 3 })
                                                                                                                                                                          // Apply mask to the image
                                                                                                                                                                          .Apply();

                                                                                                                                                                      // Save image
                                                                                                                                                                      image.Save(outputFilePath);
                                                                                                                                                                  }

Methods

Process(Rectangle, int[], Point, Point)

Processes the loaded pixels .

public void Process(Rectangle pixelsRectangle, int[] pixels, Point start, Point end)

Parameters

pixelsRectangle Rectangle

The pixels rectangle.

pixels int[]

The 32-bit ARGB pixels.

start Point

The start pixels point. If not equal to (left,top) meaning that it is not full rectangle we have.

end Point

The end pixels point. If not equal to (right,bottom) meaning that it is not full rectangle we have.

Select(RasterImage, MagicWandSettings)

Creates a new Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask based on Aspose.Imaging.MagicWand.MagicWandSettings and source Aspose.Imaging.RasterImage.

public static ImageBitMask Select(RasterImage source, MagicWandSettings settings)

Parameters

source RasterImage

Raster image for the algorithm to work over.

settings MagicWandSettings

Settings of magic wand algorithm used in creating mask.

Returns

ImageBitMask

New Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.