Modificando Imágenes

Difuminado para Imágenes Raster

El dithering es una técnica de crear la ilusión de nuevos colores y tonos variando el patrón de puntos que realmente crean una imagen. Es el medio más común de reducir el rango de colores de las imágenes a 256 (o menos) colores. Aspose.PSD proporciona soporte de dithering para la clase RasterImage al introducir el método Dither que acepta dos parámetros. El primero es de tipo DitheringMethod que se aplica con dos opciones posibles: FloydSteinbergDithering y ThresholdDithering. El segundo parámetro para el método Dither es BitCount en entero. BitCount define el tamaño de muestreo para el resultado del dithering. El valor predeterminado es 1 que representa blanco y negro, mientras que los valores permitidos son 1, 4, 8 generando paletas con 2, 4 y 256 colores respectivamente.

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

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + @"SampleImage_out.bmp";

// Load an existing image into an instance of RasterImage class
using (var image = (PsdImage)Image.Load(sourceFile))
{
    // Peform Floyd Steinberg dithering on the current image and Save the resultant image
    image.Dither(DitheringMethod.ThresholdDithering, 4);
    image.Save(destName, new BmpOptions());
}

Ajuste de Brillo, Contraste y Gamma

Los ajustes de color en imágenes digitales son una de las características básicas que la mayoría de las bibliotecas de procesamiento de imágenes proporcionan. Los ajustes de color se pueden categorizar de la siguiente manera.

1. El brillo se refiere a la claridad u oscuridad de un color. Aumentar el brillo de una imagen ilumina todos los colores mientras que disminuir el brillo oscurece todos los colores.
2. El contraste se refiere a hacer que los objetos o detalles dentro de una imagen sean más evidentes. Aumentar el contraste de una imagen incrementa la diferencia entre las áreas claras y oscuras para que las áreas claras se vuelvan más claras y las áreas oscuras más oscuras. Disminuir el contraste hará que las áreas más claras y oscuras se mantengan aproximadamente iguales pero la imagen en general se vuelve más homogénea.
3. Gamma optimiza el contraste y brillo de la iluminación indirecta que está iluminando un objeto en la imagen.

Ajuste de Brillo

Aspose.PSD para la API de .NET proporciona el método AdjustBrightness para la clase RasterImage que se puede usar para ajustar el brillo de la imagen pasando un valor entero como parámetro. El valor de parámetro más alto denota una imagen más brillante. Aquí se muestra la imagen original y la imagen resultante para comparación.

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

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + @"AdjustBrightness_out.tiff";

using (var image = (PsdImage)Image.Load(sourceFile))
{
    RasterCachedImage rasterImage = image;

    // Set the brightness value. The accepted values of brightness are in the range [-255, 255].
    rasterImage.AdjustBrightness(-50);

    TiffOptions tiffOptions = new TiffOptions(TiffExpectedFormat.Default);
    rasterImage.Save(destName, tiffOptions);
}

Ajuste de Contraste

El método AdjustContrast expuesto por la clase RasterImage se puede usar para ajustar el contraste de una imagen pasando un valor flotante como parámetro.

El valor del parámetro más alto denota un mayor contraste en la imagen dada. Aquí se muestra la imagen original y la imagen resultante para comparación.

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

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + @"AdjustContrast_out.tiff";

// Load an existing image into an instance of RasterImage class
using (var image = Image.Load(sourceFile))
{
    // Cast object of Image to RasterImage
    RasterImage rasterImage = (RasterImage)image;
    // Check if RasterImage is cached and Cache RasterImage for better performance
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Adjust the contrast
    rasterImage.AdjustContrast(50);

    // Create an instance of TiffOptions for the resultant image, Set various properties for the object of TiffOptions and Save the resultant image to TIFF format
    TiffOptions tiffOptions = new TiffOptions(TiffExpectedFormat.Default);
    tiffOptions.BitsPerSample = new ushort[] { 8, 8, 8 };
    tiffOptions.Photometric = TiffPhotometrics.Rgb;
    rasterImage.Save(destName, tiffOptions);
}

Ajuste de Gamma

El método AdjustGamma expuesto por la clase RasterImage tiene dos versiones. Una de las sobrecargas acepta un valor flotante y realiza la corrección Gamma para los coeficientes de los canales rojo, azul y verde. Mientras que la otra sobrecarga acepta tres parámetros flotantes que representan cada coeficiente de color por separado. El siguiente ejemplo de código demuestra cómo ajustar el Gamma en una imagen.

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

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + @"AdjustGamma_out.tiff";

// Load an existing image into an instance of RasterImage class
using (var image = Image.Load(sourceFile))
{
    // Cast object of Image to RasterImage
    RasterImage rasterImage = (RasterImage)image;

    // Check if RasterImage is cached and Cache RasterImage for better performance
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Adjust the gamma
    rasterImage.AdjustGamma(2.2f, 2.2f, 2.2f);

    // Create an instance of TiffOptions for the resultant image,  Set various properties for the object of TiffOptions and Save the resultant image to TIFF format
    TiffOptions tiffOptions = new TiffOptions(TiffExpectedFormat.Default);
    tiffOptions.BitsPerSample = new ushort[] { 8, 8, 8 };
    tiffOptions.Photometric = TiffPhotometrics.Rgb;
    rasterImage.Save(destName, tiffOptions);

}

Desenfocar una Imagen

Este artículo demuestra el uso de Aspose.PSD para .NET para realizar el efecto de desenfoque en una imagen. Las API de Aspose.PSD han expuesto métodos eficientes y fáciles de usar para lograr este objetivo. Aspose.PSD para .NET ha expuesto la clase GaussianBlurFilterOptions para crear un efecto de desenfoque sobre la marcha. La clase GaussianBlurFilterOptions necesita valores de radio y sigma para crear un efecto de desenfoque en una imagen. Los pasos para realizar el cambio de tamaño son tan simples como se muestra a continuación.

1. Cargar una imagen usando el método de fábrica Load expuesto por la clase Image.
2. Convertir la imagen en RasterImage.
3. Crear una instancia de la clase GaussianBlurFilterOptions con el constructor predeterminado o proporcionar valores de radio y sigma en el constructor.
4. Llamar al método RasterImage.Filter especificando el rectángulo como límites de la imagen y la instancia de la clase GaussianBlurFilterOptions.
5. Guardar los resultados.

El siguiente ejemplo de código demuestra cómo crear un efecto de desenfoque en una imagen.

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

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + @"BlurAnImage_out.gif";

// Load an existing image into an instance of RasterImage class
using (var image = Image.Load(sourceFile))
{
    // Convert the image into RasterImage, 
    //Pass Bounds[rectangle] of image and GaussianBlurFilterOptions instance to Filter method and Save the results
    RasterImage rasterImage = (RasterImage)image;

    rasterImage.Filter(rasterImage.Bounds, new GaussianBlurFilterOptions(15, 15));

    rasterImage.Save(destName, new GifOptions());
}

Verificar la Transparencia de la Imagen

Este artículo demuestra el uso de Aspose.PSD para .NET para verificar la transparencia de la imagen. Los pasos para verificar la transparencia de la imagen son tan simples como se muestran a continuación.

1. Cargar una imagen usando el método de fábrica Load expuesto por la clase Image.
2. Verificar la opacidad de la imagen; si la opacidad es cero, la imagen es transparente.
3. El siguiente ejemplo de código demuestra cómo verificar si la imagen es transparente o no.

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

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + @"AdjustBrightness_out.tiff";

// Load an existing image into an instance of RasterImage class
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    float opacity = image.ImageOpacity;
    Console.WriteLine(opacity);
    if (opacity == 0)
    {
        // The image is fully transparent.
    }
}

Implementar un Compresor GIF con Pérdida

Utilizando Aspose.PSD para .NET, los desarrolladores pueden establecer una diferencia de píxeles. La compresión de GIF se basa en un “diccionario” de secuencias de píxeles observadas. Un codificador normal busca en el diccionario la secuencia más larga de píxeles que coincidan exactamente con los píxeles de la imagen. El codificador con pérdida selecciona la secuencia más larga de píxeles que es “lo suficientemente similar” a los píxeles de la imagen. A continuación se muestra la demostración de código de dicha funcionalidad.

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

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + @"anim_lossy-200.gif";

GifOptions gifExport = new GifOptions();

// Load an existing image into an instance of RasterImage class
using (var image = Image.Load(sourceFile))
{
    gifExport.MaxDiff = 80;
    image.Save("anim_lossy-80.gif", gifExport);
    gifExport.MaxDiff = 200;
    image.Save(destName, gifExport);
}

Implementar el Remuestreo Bicúbico

El remuestreo significa que se están cambiando las dimensiones de los píxeles de una imagen. Cuando se reduce la resolución, se están eliminando píxeles y, por lo tanto, se está eliminando información y detalle de la imagen. Cuando se aumenta la resolución, se están agregando píxeles. Photoshop agrega estos píxeles utilizando interpolación. Este artículo demuestra cómo se puede realizar el Remuestreo Bicúbico utilizando Aspose.PSD para .NET.

A continuación se muestra la demostración de código de dicha funcionalidad.

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

string destNameCubicConvolution = dataDir + "ResamplerCubicConvolutionStripes_after.psd";

// Load an existing image into an instance of PsdImage class
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    image.Resize(300, 300, ResizeType.CubicConvolution);
    image.Save(destNameCubicConvolution, new PsdOptions(image));
}

string destNameCatmullRom = dataDir + "ResamplerCatmullRomStripes_after.psd";

// Load an existing image into an instance of PsdImage class
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    image.Resize(300, 300, ResizeType.CatmullRom);
    image.Save(destNameCatmullRom, new PsdOptions(image));
}

string destNameMitchell = "ResamplerMitchellStripes_after.psd";

// Load an existing image into an instance of PsdImage class
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    image.Resize(300, 300, ResizeType.Mitchell);
    image.Save(destNameMitchell, new PsdOptions(image));
}

string destNameCubicBSpline = "ResamplerCubicBSplineStripes_after.psd";

// Load an existing image into an instance of PsdImage class
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    image.Resize(300, 300, ResizeType.CubicBSpline);
    image.Save(destNameCubicBSpline, new PsdOptions(image));
}

string destNameSinC = "ResamplerSinCStripes_after.psd";

// Load an existing image into an instance of PsdImage class
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    image.Resize(300, 300, ResizeType.SinC);
    image.Save(destNameSinC, new PsdOptions(image));
}

string destNameBell = "ResamplerBellStripes_after.psd";

// Load an existing image into an instance of PsdImage class
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    image.Resize(300, 300, ResizeType.Bell);
    image.Save(destNameBell, new PsdOptions(image));
}

Capa de Ajuste del Equilibrio de Color

Este artículo demuestra el uso de Aspose.PSD para .NET para realizar la capa de ajuste del equilibrio de color en una imagen. La capa de ajuste del equilibrio de color le brinda la capacidad de realizar ajustes en la coloración de sus imágenes. Presenta los tres canales de color y sus colores complementarios y puede ajustar el equilibrio de estos pares para cambiar la apariencia de una foto.

A continuación se muestra la demostración de código de dicha funcionalidad.

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

var outputPath = dataDir + "ColorBalance_out.psd";
using (var im = (FileFormats.Psd.PsdImage)Image.Load(filePath))
{
    foreach (var layer in im.Layers)
    {
        var cbLayer = layer as ColorBalanceAdjustmentLayer;
        if (cbLayer != null)
        {
            cbLayer.ShadowsCyanRedBalance = 30;
            cbLayer.ShadowsMagentaGreenBalance = -15;
            cbLayer.ShadowsYellowBlueBalance = 40;
            cbLayer.MidtonesCyanRedBalance = -90;
            cbLayer.MidtonesMagentaGreenBalance = -25;
            cbLayer.MidtonesYellowBlueBalance = 20;
            cbLayer.HighlightsCyanRedBalance = -30;
            cbLayer.HighlightsMagentaGreenBalance = 67;
            cbLayer.HighlightsYellowBlueBalance = -95;
            cbLayer.PreserveLuminosity = true;
        }
    }

    im.Save(outputPath);
}

Capa de Ajuste de Inversión

Este artículo demuestra cómo se puede realizar la capa de ajuste de inversión utilizando Aspose.PSD para .NET. Una capa de ajuste es un tipo especial de capa utilizado principalmente para la corrección del color. En lugar de tener un contenido propio, ajustan la información en las capas debajo de ellas. La capa de ajuste de inversión produce un efecto de negativo en una foto al invertir los colores de una imagen.

A continuación se muestra la demostración de código de dicha funcionalidad.

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

var outputPath = dataDir + "InvertStripes_after.psd";
using (var im = (PsdImage)Image.Load(filePath))
{
    im.AddInvertAdjustmentLayer();
    im.Save(outputPath);
}