Class ImageMask

Class ImageMask

Nombre del espacio: Aspose.Imaging.MagicWand.ImageMasks Asamblea: Aspose.Imaging.dll (25.4.0)

Describe una máscara de imagen binaria.

public abstract class ImageMask : IImageMask, ICloneable

Inheritance

object ImageMask

Derived

CircleMask ,y, EmptyImageMask ,y, ImageBitMask ,y, RectangleMask

Implements

IImageMask ,y, ICloneable

Miembros heredados

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

Examples

El ejemplo muestra cómo seleccionar una zona complicada de una imagen utilizando la herramienta Magic Wand y la capacidad de interactuar con las máscaras (invert, union, substrato).

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);
                                                                                                                                                                  }

Constructors

ImageMask(El int, int)

Inicializa una nueva instancia de la clase Aspose.Imaging.MagicWand.ImageMasks.ImageMask con la anchura y altura especificadas.

protected ImageMask(int width, int height)

Parameters

width int

La extensión de la máscara.

height int

La altura de la máscara.

Properties

Bounds

Obtenga los límites, en píxeles, de esta máscara.

public Rectangle Bounds { get; }

Valor de la propiedad

Rectangle

Height

Obtenga la altura, en píxeles, de esta máscara.

public int Height { get; protected set; }

Valor de la propiedad

int

SelectionBounds

Recoge los límites de la parte seleccionada de la máscara, en píxeles.

public abstract Rectangle SelectionBounds { get; }

Valor de la propiedad

Rectangle

Source

Obtenga la imagen de fuente utilizada para crear esta máscara, si existe.

public RasterImage Source { get; protected set; }

Valor de la propiedad

RasterImage

Width

Obtenga la anchura, en píxeles, de esta máscara.

public int Width { get; protected set; }

Valor de la propiedad

int

Este[El int, int]

Obtenga la opacidad del pixel especificado.

public abstract bool this[int x, int y] { get; }

Valor de la propiedad

bool

Methods

Apply()

Aplicar la máscara actual a la fuente Aspose.Imaging.RasterImage, si existe.

public void Apply()

Examples

El ejemplo muestra cómo seleccionar una simple área de una imagen basada en el tono y el color de cualquier pixel utilizando la herramienta Magic Wand.

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
                                                                                                                                    });
                                                                                                                                }

Exceptions

NullReferenceException

Encuentro cuando la imagen de fuente no está definida.

ApplyTo(RasterImage)

Aplicar la máscara actual a la especificada Aspose.Imaging.RasterImage.

public void ApplyTo(RasterImage image)

Parameters

image RasterImage

Imagen para aplicar la máscara a.

Exceptions

ArgumentNullException

Se desprende cuando la imagen no está definida.

Clone()

Crea un nuevo objeto que es una copia de la instancia actual.

public abstract object Clone()

Returns

object

Un nuevo objeto que es una copia de esta instancia.

Crop(Size)

Máscaras con el tamaño especificado.

public ImageMask Crop(Size size)

Parameters

size Size

El tamaño especificado.

Returns

ImageMask

Una imagen de mascota.

Crop(El int, int)

Máscaras con la anchura y altura especificadas.

public ImageMask Crop(int width, int height)

Parameters

width int

La amplitud especificada.

height int

La altura especificada.

Returns

ImageMask

Una imagen de mascota.

Crop(Rectangle)

La máscara con el rectángulo especificado.

public abstract ImageMask Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

El rectángulo especificado.

Returns

ImageMask

Una imagen de mascota.

ExclusiveDisjunction(ImageMask)

Recibe la disunción exclusiva de la máscara actual con el suministro.

public ImageBitMask ExclusiveDisjunction(ImageMask mask)

Parameters

mask ImageMask

Las máscaras ofrecidas

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

ExclusiveDisjunction(MagicWandSettings)

Obtendrá la exclusiva disunción de la máscara actual con el resultado de la selección mágica de la cintura aplicada a la fuente de la máscara.

public ImageBitMask ExclusiveDisjunction(MagicWandSettings settings)

Parameters

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Exceptions

ArgumentNullException

Se desprende cuando la imagen de fuente no se define en la máscara.

ExclusiveDisjunction(SiguienteSiguienteSiguienteMagicWandSettings)

Recibe la disunción exclusiva de la máscara actual con el resultado de la selección mágica de la cuna aplicada a la imagen proporcionada.

public ImageBitMask ExclusiveDisjunction(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imágenes de Wanda Mágica.

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

GetByteOpacity(El int, int)

Obtenga la opacidad del pixel especificado con precisión de byte.

public byte GetByteOpacity(int x, int y)

Parameters

x int

El coordenado x del pixel.

y int

El y-coordenado del pixel.

Returns

byte

Valor de byte, que representa la opacidad del pixel especificado.

GetFeathered(FeatheringSettings)

Obtenga una máscara de grisa con la frontera cubierta con los ajustes especificados.

public ImageGrayscaleMask GetFeathered(FeatheringSettings settings = null)

Parameters

settings FeatheringSettings

Sustituciones de Feathering.

Returns

ImageGrayscaleMask

Aspose.Imaging.MagicWand.ImageMasks.ImageGrayscaleMask con una frontera agotada.

Inflate(Int)

Inflata esta máscara por la cantidad especificada.

public abstract ImageMask Inflate(int size)

Parameters

size int

La cantidad que se debe infundir esta máscara.

Returns

ImageMask

Una imagen de mascota.

Intersect(ImageMask)

Recibe la intersección de la máscara actual con la proporcionada.

public ImageBitMask Intersect(ImageMask mask)

Parameters

mask ImageMask

Las máscaras ofrecidas

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Intersect(MagicWandSettings)

Obtenga la intersección de la máscara actual con el resultado de la selección mágica de la cintura aplicada a la fuente de la máscara.

public ImageBitMask Intersect(MagicWandSettings settings)

Parameters

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Exceptions

ArgumentNullException

Se desprende cuando la imagen de fuente no se define en la máscara.

Intersect(SiguienteSiguienteSiguienteMagicWandSettings)

Obtenga la intersección de la máscara actual con el resultado de la selección mágica de la vela aplicada a la imagen proporcionada.

public ImageBitMask Intersect(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imágenes de Wanda Mágica.

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Invert()

Recibe la inversión de la máscara actual.

public ImageBitMask Invert()

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Examples

El ejemplo muestra cómo seleccionar una zona complicada de una imagen utilizando la herramienta Magic Wand y la capacidad de interactuar con las máscaras (invert, union, substrato).

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);
                                                                                                                                                                  }

IsOpaque(El int, int)

Verifica si el pixel especificado es opaco.

public bool IsOpaque(int x, int y)

Parameters

x int

El coordenado x del pixel.

y int

El y-coordenado del pixel.

Returns

bool

cierto si el píxel especificado es opaco; de lo contrario, falso.

IsTransparent(El int, int)

Verifica si el pixel especificado es transparente.

public bool IsTransparent(int x, int y)

Parameters

x int

El coordenado x del pixel.

y int

El y-coordenado del pixel.

Returns

bool

cierto si el píxel especificado es transparente; de lo contrario, falso.

Subtract(ImageMask)

Recibe la subtracción de la máscara proporcionada de la corriente.

public ImageBitMask Subtract(ImageMask mask)

Parameters

mask ImageMask

Las máscaras ofrecidas

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Examples

El ejemplo muestra cómo seleccionar una zona complicada de una imagen utilizando la herramienta Magic Wand y la capacidad de interactuar con las máscaras (invert, union, substrato).

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);
                                                                                                                                                                  }

Subtract(MagicWandSettings)

Obtenga el resultado de la selección magica de la cintura aplicada a la fuente de la máscara actual subtraída de la máscara.

public ImageBitMask Subtract(MagicWandSettings settings)

Parameters

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Exceptions

ArgumentNullException

Se desprende cuando la imagen de fuente no se define en la máscara.

Subtract(SiguienteSiguienteSiguienteMagicWandSettings)

Obtenga el resultado de la selección magica de la ventana aplicada a la imagen proporcionada subtraída de la máscara actual.

public ImageBitMask Subtract(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imágenes de Wanda Mágica.

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Union(ImageMask)

Recibe la unión de la máscara actual con la proporcionada.

public ImageBitMask Union(ImageMask mask)

Parameters

mask ImageMask

Las máscaras ofrecidas

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Examples

El ejemplo muestra cómo seleccionar una zona complicada de una imagen utilizando la herramienta Magic Wand y la capacidad de interactuar con las máscaras (invert, union, substrato).

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);
                                                                                                                                                                  }

Union(MagicWandSettings)

Obtenga la unión de la máscara actual con el resultado de la selección mágica que se aplica a la fuente de la máscara.

public ImageBitMask Union(MagicWandSettings settings)

Parameters

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Exceptions

ArgumentNullException

Se desprende cuando la imagen de fuente no se define en la máscara.

Union(SiguienteSiguienteSiguienteMagicWandSettings)

Obtenga la unión de la máscara actual con el resultado de la selección mágica que se aplica a la imagen proporcionada.

public ImageBitMask Union(RasterImage image, MagicWandSettings settings)

Parameters

image RasterImage

Imágenes de Wanda Mágica.

settings MagicWandSettings

La magia de los ajustes.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Operators

Operador +(Imágenes, Imágenes)

La unión de dos máscaras.

public static ImageBitMask operator +(ImageMask a, ImageMask b)

Parameters

a ImageMask

La primera máscara.

b ImageMask

La segunda máscara.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Operador(Imágenes, Imágenes)

Disunción exclusiva de dos máscaras.

public static ImageBitMask operator ^(ImageMask a, ImageMask b)

Parameters

a ImageMask

La primera máscara.

b ImageMask

La segunda máscara.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Operador explicito ImageGrayscaleMask(ImageMask)

Aspose.Imaging.MagicWand.ImageMasks.ImageGrayscaleMask operador de casting.

public static explicit operator ImageGrayscaleMask(ImageMask mask)

Parameters

mask ImageMask

El valor de la máscara.

Returns

ImageGrayscaleMask

El nuevo Aspose.Imaging.MagicWand.ImageMasks.ImageGrayscaleMask.

Operador !(ImageMask)

La máscara invertida.

public static ImageBitMask operator !(ImageMask a)

Parameters

a ImageMask

La máscara debe ser invertida.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Operador *(Imágenes, Imágenes)

Intersección de dos máscaras.

public static ImageBitMask operator *(ImageMask a, ImageMask b)

Parameters

a ImageMask

La primera máscara.

b ImageMask

La segunda máscara.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

Operador -(Imágenes, Imágenes)

Subtrae la segunda máscara desde el primero.

public static ImageBitMask operator -(ImageMask a, ImageMask b)

Parameters

a ImageMask

La primera máscara.

b ImageMask

La segunda máscara.

Returns

ImageBitMask

Nuevos Aspose.Imaging.MagicWand.ImageMasks.ImageBitMask.

 Español