Class DicomImage

Class DicomImage

Nom dels espais: Aspose.Imaging.FileFormats.Dicom Assemblea: Aspose.Imaging.dll (25.4.0)

Aquesta classe implementa la imatge digital i les comunicacions en la medicina(DICOM) suporta el format d’imatge raster i ofereix una solució integral perprocessar imatges DICOM amb precisió i flexibilitat.manipular les pàgines d’imatge, incloent-hi les operacions per obtenir, afegir, o eliminar-les, icontrol de les pàgines estàndard i actives. amb capacitats per treballar amb canals alfa,Embed XMP metadades, resideix, girar, cultiu, binaris, ajustar, aplicar filtres,i convertir-se en altres formats de raster. Aquesta API permet als desenvolupadors gestionarDICOM imatges eficaçment alhora que satisfà diversos requisits d’aplicació enImatge mèdica de contextos.

[JsonObject(MemberSerialization.OptIn)]
public sealed class DicomImage : RasterCachedMultipageImage, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadata, IMultipageImageExt, IMultipageImage

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage RasterCachedMultipageImage DicomImage

Implements

IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata , IMultipageImageExt , IMultipageImage

Membres heretats

RasterCachedMultipageImage.AdjustBrightness(int) , RasterCachedMultipageImage.AdjustContrast(float) , RasterCachedMultipageImage.AdjustGamma(float, float, float) , RasterCachedMultipageImage.AdjustGamma(float) , RasterCachedMultipageImage.Blend(Point, RasterImage, Rectangle, byte) , RasterCachedMultipageImage.BinarizeFixed(byte) , RasterCachedMultipageImage.BinarizeBradley(double, int) , RasterCachedMultipageImage.BinarizeBradley(double) , RasterCachedMultipageImage.BinarizeOtsu() , RasterCachedMultipageImage.Crop(Rectangle) , RasterCachedMultipageImage.Crop(int, int, int, int) , RasterCachedMultipageImage.Dither(DitheringMethod, int, IColorPalette) , RasterCachedMultipageImage.Grayscale() , RasterCachedMultipageImage.NormalizeHistogram() , RasterCachedMultipageImage.Rotate(float, bool, Color) , RasterCachedMultipageImage.RotateFlip(RotateFlipType) , RasterCachedMultipageImage.RotateFlipAll(RotateFlipType) , RasterCachedMultipageImage.Resize(int, int, ResizeType) , RasterCachedMultipageImage.Resize(int, int, ImageResizeSettings) , RasterCachedMultipageImage.ResizeWidthProportionally(int, ResizeType) , RasterCachedMultipageImage.ResizeHeightProportionally(int, ResizeType) , RasterCachedMultipageImage.ReplaceColor(int, byte, int) , RasterCachedMultipageImage.ReplaceNonTransparentColors(int) , RasterCachedMultipageImage.Filter(Rectangle, FilterOptionsBase) , RasterCachedMultipageImage.NormalizeAngle(bool, Color) , RasterCachedMultipageImage.CacheData() , RasterCachedMultipageImage.GetSerializedStream(ImageOptionsBase, Rectangle, out int) , RasterCachedMultipageImage.Height , RasterCachedMultipageImage.Width , RasterCachedMultipageImage.BitsPerPixel , RasterCachedMultipageImage.IsCached , RasterCachedMultipageImage.PageCount , RasterCachedMultipageImage.Pages , RasterCachedMultipageImage.HasAlpha , RasterCachedMultipageImage.HasTransparentColor , RasterCachedMultipageImage.ImageOpacity , RasterCachedMultipageImage.BackgroundColor , RasterCachedMultipageImage.XmpData , RasterCachedMultipageImage.PageExportingAction , RasterCachedImage.CacheData() , RasterCachedImage.Blend(Point, RasterImage, Rectangle, byte) , RasterCachedImage.Resize(int, int, ResizeType) , RasterCachedImage.Resize(int, int, ImageResizeSettings) , RasterCachedImage.RotateFlip(RotateFlipType) , RasterCachedImage.Rotate(float, bool, Color) , RasterCachedImage.Crop(Rectangle) , RasterCachedImage.Dither(DitheringMethod, int, IColorPalette) , RasterCachedImage.Grayscale() , RasterCachedImage.NormalizeHistogram() , RasterCachedImage.BinarizeFixed(byte) , RasterCachedImage.BinarizeOtsu() , RasterCachedImage.BinarizeBradley(double, int) , RasterCachedImage.BinarizeBradley(double) , RasterCachedImage.AdjustBrightness(int) , RasterCachedImage.AdjustContrast(float) , RasterCachedImage.AdjustGamma(float, float, float) , RasterCachedImage.AdjustGamma(float) , RasterCachedImage.IsCached , RasterImage.RemoveMetadata() , RasterImage.Save(Stream, ImageOptionsBase, Rectangle) , RasterImage.GetModifyDate(bool) , RasterImage.Dither(DitheringMethod, int) , RasterImage.Dither(DitheringMethod, int, IColorPalette) , RasterImage.GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings) , RasterImage.GetDefaultArgb32Pixels(Rectangle) , RasterImage.GetDefaultRawData(Rectangle, RawDataSettings) , RasterImage.GetArgb32Pixel(int, int) , RasterImage.GetPixel(int, int) , RasterImage.SetArgb32Pixel(int, int, int) , RasterImage.SetPixel(int, int, Color) , RasterImage.ReadScanLine(int) , RasterImage.ReadArgb32ScanLine(int) , RasterImage.WriteScanLine(int, Color[]) , RasterImage.WriteArgb32ScanLine(int, int[]) , RasterImage.LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.LoadPartialPixels(Rectangle, IPartialPixelLoader) , RasterImage.LoadArgb32Pixels(Rectangle) , RasterImage.LoadArgb64Pixels(Rectangle) , RasterImage.LoadPartialArgb64Pixels(Rectangle, IPartialArgb64PixelLoader) , RasterImage.LoadPixels(Rectangle) , RasterImage.LoadCmykPixels(Rectangle) , RasterImage.LoadCmyk32Pixels(Rectangle) , RasterImage.LoadRawData(Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.LoadRawData(Rectangle, Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.SaveRawData(byte[], int, Rectangle, RawDataSettings) , RasterImage.SaveArgb32Pixels(Rectangle, int[]) , RasterImage.SavePixels(Rectangle, Color[]) , RasterImage.SaveCmykPixels(Rectangle, CmykColor[]) , RasterImage.SaveCmyk32Pixels(Rectangle, int[]) , RasterImage.SetResolution(double, double) , RasterImage.SetPalette(IColorPalette, bool) , RasterImage.Resize(int, int, ImageResizeSettings) , RasterImage.Rotate(float, bool, Color) , RasterImage.Rotate(float) , RasterImage.BinarizeFixed(byte) , RasterImage.BinarizeOtsu() , RasterImage.BinarizeBradley(double) , RasterImage.BinarizeBradley(double, int) , RasterImage.Blend(Point, RasterImage, Rectangle, byte) , RasterImage.Blend(Point, RasterImage, byte) , RasterImage.Grayscale() , RasterImage.NormalizeHistogram() , RasterImage.AdjustBrightness(int) , RasterImage.AdjustContrast(float) , RasterImage.AdjustGamma(float, float, float) , RasterImage.AdjustGamma(float) , RasterImage.GetSkewAngle() , RasterImage.NormalizeAngle() , RasterImage.NormalizeAngle(bool, Color) , RasterImage.Filter(Rectangle, FilterOptionsBase) , RasterImage.ReplaceColor(Color, byte, Color) , RasterImage.ReplaceColor(int, byte, int) , RasterImage.ReplaceNonTransparentColors(Color) , RasterImage.ReplaceNonTransparentColors(int) , RasterImage.ToBitmap() , RasterImage.PremultiplyComponents , RasterImage.UseRawData , RasterImage.UpdateXmpData , RasterImage.XmpData , RasterImage.RawIndexedColorConverter , RasterImage.RawCustomColorConverter , RasterImage.RawFallbackIndex , RasterImage.RawDataSettings , RasterImage.UsePalette , RasterImage.RawDataFormat , RasterImage.RawLineSize , RasterImage.IsRawDataAvailable , RasterImage.HorizontalResolution , RasterImage.VerticalResolution , RasterImage.HasTransparentColor , RasterImage.HasAlpha , RasterImage.TransparentColor , RasterImage.ImageOpacity , Image.CanLoad(string) , Image.CanLoad(string, LoadOptions) , Image.CanLoad(Stream) , Image.CanLoad(Stream, LoadOptions) , Image.Create(ImageOptionsBase, int, int) , Image.Create(Image[]) , Image.Create(MultipageCreateOptions) , Image.Create(string[], bool) , Image.Create(string[]) , Image.Create(Image[], bool) , Image.GetFileFormat(string) , Image.GetFileFormat(Stream) , Image.GetFittingRectangle(Rectangle, int, int) , Image.GetFittingRectangle(Rectangle, int[], int, int) , Image.Load(string, LoadOptions) , Image.Load(string) , Image.Load(Stream, LoadOptions) , Image.Load(Stream) , Image.GetProportionalWidth(int, int, int) , Image.GetProportionalHeight(int, int, int) , Image.RemoveMetadata() , Image.CanSave(ImageOptionsBase) , Image.Resize(int, int) , Image.Resize(int, int, ResizeType) , Image.Resize(int, int, ImageResizeSettings) , Image.GetDefaultOptions(object[]) , Image.GetOriginalOptions() , Image.ResizeWidthProportionally(int) , Image.ResizeHeightProportionally(int) , Image.ResizeWidthProportionally(int, ResizeType) , Image.ResizeHeightProportionally(int, ResizeType) , Image.ResizeWidthProportionally(int, ImageResizeSettings) , Image.ResizeHeightProportionally(int, ImageResizeSettings) , Image.RotateFlip(RotateFlipType) , Image.Rotate(float) , Image.Crop(Rectangle) , Image.Crop(int, int, int, int) , Image.Save() , Image.Save(string) , Image.Save(string, ImageOptionsBase) , Image.Save(string, ImageOptionsBase, Rectangle) , Image.Save(Stream, ImageOptionsBase) , Image.Save(Stream, ImageOptionsBase, Rectangle) , Image.GetSerializedStream(ImageOptionsBase, Rectangle, out int) , Image.SetPalette(IColorPalette, bool) , Image.BitsPerPixel , Image.Bounds , Image.Container , Image.Height , Image.Palette , Image.UsePalette , Image.Size , Image.Width , Image.InterruptMonitor , Image.BufferSizeHint , Image.AutoAdjustPalette , Image.HasBackgroundColor , Image.FileFormat , Image.BackgroundColor , DataStreamSupporter.CacheData() , DataStreamSupporter.Save() , DataStreamSupporter.Save(Stream) , DataStreamSupporter.Save(string) , DataStreamSupporter.Save(string, bool) , DataStreamSupporter.DataStreamContainer , DataStreamSupporter.IsCached , DisposableObject.Dispose() , DisposableObject.Disposed , object.GetType() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

Canviar el tipus de color en la compressió DICOM.

using (var inputImage = Image.Load("original.jpg"))
                                                  {
                                                      var options = new DicomOptions { ColorType = ColorType.Grayscale8Bit };

                                                      inputImage.Save("original_8Bit.dcm", options);
                                                  }

Utilitza la compressió RLE en la imatge DICOM.

using (var inputImage = Image.Load("original.jpg"))
                                              {
                                                  var options = new DicomOptions
                                                  {
                                                      ColorType = ColorType.Rgb24Bit,
                                                      Compression = new Compression { Type = CompressionType.Rle }
                                                  };

                                                  inputImage.Save("original_RLE.dcm", options);
                                              }

Utilitza la compressió JPEG 2000 en la imatge DICOM.

using (var inputImage = Image.Load("original.jpg"))
                                                    {
                                                        var options = new DicomOptions
                                                        {
                                                            ColorType = ColorType.Rgb24Bit,
                                                            Compression = new Compression
                                                            {
                                                                Type = CompressionType.Jpeg2000,
                                                                Jpeg2000 = new Jpeg2000Options
                                                                {
                                                                    Codec = Jpeg2000Codec.Jp2,
                                                                    Irreversible = false
                                                                }
                                                            }
                                                        };

                                                        inputImage.Save("original_JPEG2000.dcm", options);
                                                    }

Utilitza la compressió JPEG en la imatge DICOM.

using (var inputImage = Image.Load("original.jpg"))
                                               {
                                                   var options = new DicomOptions
                                                   {
                                                       ColorType = ColorType.Rgb24Bit,
                                                       Compression = new Compression
                                                       {
                                                           Type = CompressionType.Jpeg,
                                                           Jpeg = new JpegOptions
                                                           {
                                                               CompressionType = JpegCompressionMode.Baseline,
                                                               SampleRoundingMode = SampleRoundingMode.Truncate,
                                                               Quality = 50
                                                           }
                                                       }
                                                   };

                                                   inputImage.Save("original_JPEG.dcm", options);
                                               }

Aquest exemple mostra com carregar una imatge DICOM d’un flux de fitxers.

string dir = "c:\\temp\\";

                                                                           // Load a DICOM image from a file stream.
                                                                           using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.dicom"))
                                                                           {
                                                                               using (Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = new Aspose.Imaging.FileFormats.Dicom.DicomImage(stream))
                                                                               {
                                                                                   // Save each page as an individual PNG image.                    
                                                                                   foreach (Aspose.Imaging.FileFormats.Dicom.DicomPage dicomPage in dicomImage.DicomPages)
                                                                                   {
                                                                                       // Generate a file name based on the page index.
                                                                                       string fileName = string.Format("sample.{0}.png", dicomPage.Index);

                                                                                       // A DICOM page is a raster image, so all allowed operations with a raster image are applicable to a DICOM page.
                                                                                       dicomPage.Save(dir + fileName, new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }
                                                                               }
                                                                           }

Creació d’una imatge multipàgina.

using (DicomImage image = (DicomImage)Image.Create(
                                                   new DicomOptions() { Source = new StreamSource(new MemoryStream()) },
                                                   100,
                                                   100))
                                           {
                                               // Draw something using vector graphics
                                               Graphics graphics = new Graphics(image);
                                               graphics.FillRectangle(new SolidBrush(Color.BlueViolet), image.Bounds);
                                               graphics.FillRectangle(new SolidBrush(Color.Aqua), 10, 20, 50, 20);
                                               graphics.FillEllipse(new SolidBrush(Color.Orange), 30, 50, 70, 30);

                                               // Save the pixels of the drawn image. They are now on the first page of the Dicom image.
                                               int[] pixels = image.LoadArgb32Pixels(image.Bounds);

                                               // Add a few pages after, making them darker
                                               for (int i = 1; i < 5; i++)
                                               {
                                                   DicomPage page = image.AddPage();
                                                   page.SaveArgb32Pixels(page.Bounds, pixels);
                                                   page.AdjustBrightness(i * 30);
                                               }

                                               // Add a few pages in front of the main page, making them brighter
                                               for (int i = 1; i < 5; i++)
                                               {
                                                   DicomPage page = image.InsertPage(0);
                                                   page.SaveArgb32Pixels(page.Bounds, pixels);
                                                   page.AdjustBrightness(-i * 30);
                                               }

                                               // Save the created multi-page image to the output file
                                               image.Save("MultiPage.dcm");
                                           }

Constructors

DicomImage(DICOMOPCIONS, int i int)

Iniciar una nova instància de la classe DicomImage sense esforç amb aquestconstructor, utilitzant paràmetres dicomOptions. perfecte per als desenvolupadors mirantper immersar-se en els objectes de Aspose.Imaging.FileFormats.Dicom.DicomImage de manera ràpida i eficient als seus projectes.

public DicomImage(DicomOptions dicomOptions, int width, int height)

Parameters

dicomOptions DicomOptions

Les opcions de dicom.

width int

La seva amplada.

height int

La seva alçada.

DicomImage(Projecció, LoadOptions)

Iniciar una nova instància de la classe DicomImage de forma suau utilitzant un flux icàrregaOpcions paràmetres en aquest constructor. Ideal per als desenvolupadors que vulguin començartreballar amb els objectes Aspose.Imaging.FileFormats.Dicom.DicomImage de manera ràpida i eficaç en els seus projectes.

public DicomImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

El corrent.

loadOptions LoadOptions

Opcions de càrrega.

Examples

Aquest exemple mostra com carregar una imatge DICOM d’un flux de fitxers per quedar-se dins del límit de memòria especificat.

string dir = "c:\\temp\\";

                                                                                                                     // Load a DICOM image from a file stream.
                                                                                                                     using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "multiframe.dicom"))
                                                                                                                     {
                                                                                                                         // The max allowed size for all internal buffers is 256KB.
                                                                                                                         Aspose.Imaging.LoadOptions loadOptions = new Aspose.Imaging.LoadOptions();
                                                                                                                         loadOptions.BufferSizeHint = 256 * 1024;

                                                                                                                         using (Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = new Aspose.Imaging.FileFormats.Dicom.DicomImage(stream, loadOptions))
                                                                                                                         {
                                                                                                                             // Save each page as an individual PNG image.
                                                                                                                             foreach (Aspose.Imaging.FileFormats.Dicom.DicomPage dicomPage in dicomImage.DicomPages)
                                                                                                                             {
                                                                                                                                 // Generate a file name based on the page index.
                                                                                                                                 string fileName = string.Format("multiframe.{0}.png", dicomPage.Index);

                                                                                                                                 // A DICOM page is a raster image, so all allowed operations with a raster image are applicable to a DICOM page.
                                                                                                                                 dicomPage.Save(dir + fileName, new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                             }
                                                                                                                         }
                                                                                                                     }

DicomImage(Stream)

Crear una nova instància de la classe DicomImage utilitzant un paràmetre de fluxPerfecte per als desenvolupadors que busquen una manera estricta d’iniciarAspose.Imaging.FileFormats.Dicom.DicomImage objectes de fluxos de dades existents en els seus projectes.

public DicomImage(Stream stream)

Parameters

stream Stream

El corrent.

Examples

Aquest exemple mostra com carregar una imatge DICOM d’un flux de fitxers.

string dir = "c:\\temp\\";

                                                                           // Load a DICOM image from a file stream.
                                                                           using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.dicom"))
                                                                           {
                                                                               using (Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = new Aspose.Imaging.FileFormats.Dicom.DicomImage(stream))
                                                                               {
                                                                                   // Save each page as an individual PNG image.                    
                                                                                   foreach (Aspose.Imaging.FileFormats.Dicom.DicomPage dicomPage in dicomImage.DicomPages)
                                                                                   {
                                                                                       // Generate a file name based on the page index.
                                                                                       string fileName = string.Format("sample.{0}.png", dicomPage.Index);

                                                                                       // A DICOM page is a raster image, so all allowed operations with a raster image are applicable to a DICOM page.
                                                                                       dicomPage.Save(dir + fileName, new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }
                                                                               }
                                                                           }

Properties

ActivePage

Gestionar la pàgina activa de la imatge amb aquesta propietat intuïtiva. ideal per als desenvolupadorstractar de canviar dinàmicament entre les pàgines dins d’imatges multipàgins, assegurant l’eficiènciaNavegació i processament.

public DicomPage ActivePage { get; set; }

Valor de la propietat

DicomPage

Exceptions

DicomImageException

La pàgina activa no es pot configurar ja que pertany a una altra imatge.

ActivePageIndex

Retirar l’índex de la pàgina activa sense esforç amb aquesta propietat intuïtiva.Ideal per als desenvolupadors que busquen accés ràpid a l’índex de pàgina actual dins de múltiples pàginesImatges, assegurant una eficiència de navegació i processament.

public int ActivePageIndex { get; }

Valor de la propietat

int

DicomPages

Accés a les pàgines de la imatge amb aquesta propietat intuïtiva. Ideal per als desenvolupadorstractar d’interactuar amb les pàgines individuals dins de la imatge, assegurant-se sense segellNavegació i manipulació.

public DicomPage[] DicomPages { get; }

Valor de la propietat

DicomPage []

FileFormat

Recuperar el valor del format de fitxers sense esforç amb aquesta propietat intuïtiva.desenvolupadors que busquen accés ràpid al format del fitxer d’imatge, garantint una eficiènciaGestió i processament basat en el tipus de fitxer.

public override FileFormat FileFormat { get; }

Valor de la propietat

FileFormat

FileInfo

Recuperar informació valuosa del títol del fitxer DICOM sense esforç amb aquestPropietat intuïtiva. Ideal per als desenvolupadors que busquen accés ràpid als detalls essencialsencapsulada dins del fitxer DICOM, assegurant l’extracció i anàlisi de dades eficients.

public DicomImageInfo FileInfo { get; }

Valor de la propietat

DicomImageInfo

HasAlpha

Recorda si la imatge té un canal alfa sense esforç amb aquest intuïtiuIdeal per als desenvolupadors que busquen determinar si la imatge conté transparènciainformació, assegurant el tractament precís de les dades del canal alfa en les tasques de processament d’imatge.

public override bool HasAlpha { get; }

Valor de la propietat

bool

PageCount

Retreu el nombre total de pàgines de la imatge amb aquesta propietat intuïtiva.desenvolupadors que busquen accés ràpid al nombre de pàgines dins d’una imatge, garantintLa navegació i la gestió eficients.

public override int PageCount { get; }

Valor de la propietat

int

Pages

Accés a les pàgines de la imatge amb aquesta propietat intuïtiva. Ideal per als desenvolupadorsBuscant interactuar amb les pàgines individuals dins de la imatge, assegurant la navegació sense segelli la manipulació.

public override Image[] Pages { get; }

Valor de la propietat

Image []

Methods

AddPage(RasterImage)

Expandeix la teva col·lecció d’imatges afegint una nova pàgina amb aquest mètode intuïtiu.Ideal per als desenvolupadors que busquen afegir de manera dinàmica pàgines a imatges multipages,Garantir l’expansió i organització de continguts d’imatges.

public void AddPage(RasterImage page)

Parameters

page RasterImage

La pàgina per afegir.

Exceptions

ArgumentNullException

page’ is null.

AddPage()

Afegeix una nova pàgina al final de la llista de pàgines de l’imatge amb aquest mètode senzill.Ideal per als desenvolupadors que busquen expandir dinàmicament les imatges de múltiples pàgines, assegurant-se sense segellIntegració i organització del contingut d’imatge.

public DicomPage AddPage()

Returns

DicomPage

El nou creat Aspose.Imaging.FileFormats.Dicom.Page.

Examples

Creació d’una imatge multipàgina.

using (DicomImage image = (DicomImage)Image.Create(
                                                   new DicomOptions() { Source = new StreamSource(new MemoryStream()) },
                                                   100,
                                                   100))
                                           {
                                               // Draw something using vector graphics
                                               Graphics graphics = new Graphics(image);
                                               graphics.FillRectangle(new SolidBrush(Color.BlueViolet), image.Bounds);
                                               graphics.FillRectangle(new SolidBrush(Color.Aqua), 10, 20, 50, 20);
                                               graphics.FillEllipse(new SolidBrush(Color.Orange), 30, 50, 70, 30);

                                               // Save the pixels of the drawn image. They are now on the first page of the Dicom image.
                                               int[] pixels = image.LoadArgb32Pixels(image.Bounds);

                                               // Add a few pages after, making them darker
                                               for (int i = 1; i < 5; i++)
                                               {
                                                   DicomPage page = image.AddPage();
                                                   page.SaveArgb32Pixels(page.Bounds, pixels);
                                                   page.AdjustBrightness(i * 30);
                                               }

                                               // Add a few pages in front of the main page, making them brighter
                                               for (int i = 1; i < 5; i++)
                                               {
                                                   DicomPage page = image.InsertPage(0);
                                                   page.SaveArgb32Pixels(page.Bounds, pixels);
                                                   page.AdjustBrightness(-i * 30);
                                               }

                                               // Save the created multi-page image to the output file
                                               image.Save("MultiPage.dcm");
                                           }

AdjustBrightness(Int)

Millora la lluminació de la imatge amb l’ajust de brightness", mètode aparametritzat que permet als desenvolupadors tonyir de forma finesa la luminositat de les imatges.Aquesta funció amable a l’usuari permet al desenvolupador manipular sense cap mena d’imatge, oferint flexibilitat i control sobre les estètiques visuals.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Valor de la llum.

Examples

L’exemple següent realitza la correcció de brillantor d’una imatge DICOM.

string dir = "c:\\temp\\";

                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                 {
                                                                                     Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                     // Set the brightness value. The accepted values of brightness are in the range [-255, 255].
                                                                                     dicomImage.AdjustBrightness(50);
                                                                                     dicomImage.Save(dir + "sample.AdjustBrightness.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                 }

AdjustContrast(Float)

Millora Aspose.Imaging.Image contraste amb aquest mètode amable per a l’usuari,que ajusta la disparitat entre les àrees llum i fosca. millora la claredat visual idefinició sense esforç, proporcionant als desenvolupadors un control intuïtiu sobreContrast d’imatge per a un rendiment òptim.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Valor de contrast (en rang [-100; 100])

Examples

L’exemple següent realitza la correcció de contrast d’una imatge DICOM.

string dir = "c:\\temp\\";

                                                                               using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                               {
                                                                                   Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                   // Set the contrast value. The accepted values of contrast are in the range [-100f, 100f].
                                                                                   dicomImage.AdjustContrast(50f);
                                                                                   dicomImage.Save(dir + "sample.AdjustContrast.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                               }

AdjustGamma(Float)

Millorar la qualitat de la imatge i ajustar-la amb la correcció gamma, una potent tècnicaPerfecte per als desenvolupadors que busquen optimitzar la imatgepresentació, ajustar l’equilibri de colors, i assegurar un rendiment consistent entre diferentsdispositius i entorns.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma per a canals vermell, verd i blau coeficient

Examples

L’exemple següent realitza la correcció gamma d’una imatge DICOM.

string dir = "c:\\temp\\";

                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                            {
                                                                                Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                // Set gamma coefficient for red, green and blue channels.
                                                                                dicomImage.AdjustGamma(2.5f);
                                                                                dicomImage.Save(dir + "sample.AdjustGamma.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                            }

AdjustGamma(Float, float i flot)

Obtenir ajustaments de color precisos mitjançant l’aplicació de la correcció gamma independentmentper als components vermells, verds i blaus d’una imatge. aquest mètode garanteix la precisióbalanç de colors i rendiment visual òptim, catering per als desenvolupadors que busquen granularsControl sobre la renderització de la imatge i la precisió del color.

public override void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)

Parameters

gammaRed float

Gamma per al coeficient de canals vermells

gammaGreen float

Gamma per al coeficient de canals verds

gammaBlue float

Gamma per al coeficient de canal blau

Examples

L’exemple següent realitza la correcció gamma d’una imatge DICOM aplicant diferents coeficients per a components de color.

string dir = "c:\\temp\\";

                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                 {
                                                                                                                                     Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                                     // Set individual gamma coefficients for red, green and blue channels.
                                                                                                                                     dicomImage.AdjustGamma(1.5f, 2.5f, 3.5f);
                                                                                                                                     dicomImage.Save(dir + "sample.AdjustGamma.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                 }

BinarizeBradley(El doble, int)

Binaritza les imatges amb l’algoritme d’adaptació de la frontera de Bradley, el qual és integralimatge límit per a millores de rendiment. ideal per als desenvolupadors que busquenSegmenta automàticament les imatges basades en variacions locals de brillantor, garantintDetecció i extracció exacta d’objectes en diferents condicions de llum.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

La diferència de brillantor entre el píxel i la mitjana d’una s x s finestra de píxelscentrada al voltant d’aquest pixel.

windowSize int

La mida de la finestra s x s dels píxels centrat al voltant d’aquest píxel

Examples

L’exemple següent binaritza una imatge DICOM amb l’algoritme d’adaptació amb el límit de la finestra especificada. imatges binàries contenen només 2 colors - negre i blanc.

string dir = "c:\\temp\\";

                                                                                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                                                 {
                                                                                                                                                                                                     Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                                                                                                     // Binarize the image with a brightness difference of 5. The brightness is a difference between a pixel and the average of an 10 x 10 window of pixels centered around this pixel.
                                                                                                                                                                                                     dicomImage.BinarizeBradley(5, 10);
                                                                                                                                                                                                     dicomImage.Save(dir + "sample.BinarizeBradley5_10x10.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                                                 }

BinarizeFixed(El byte)

Convertir fàcilment la imatge en un format binari utilitzant un límit predefinitIdeal per als desenvolupadors que busquen simplificar la imatgeProcessar les tasques segmentant la imatge en components de fons i frontalbasat en els nivells d’intensitat especificats.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Si el valor gris corresponent d’un píxel és més gran que el límit, un valor255 serà assignat a ella, 0 d’una altra manera.

Examples

L’exemple següent binaritza una imatge DICOM amb el límit predefinit. imatges binàries contenen només 2 colors - negre i blanc.

string dir = "c:\\temp\\";

                                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                 {
                                                                                                                                                     Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                                                     // Binarize the image with a threshold value of 127.
                                                                                                                                                     // If a corresponding gray value of a pixel is greater than 127, a value of 255 will be assigned to it, 0 otherwise.
                                                                                                                                                     dicomImage.BinarizeFixed(127);
                                                                                                                                                     dicomImage.Save(dir + "sample.BinarizeFixed.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                 }

BinarizeOtsu()

Aplica el límit Otsu per binaritzar la imatge, determinant automàticament l’optimalvalor límit basat en l’histograma de la imatge. perfecte per als desenvolupadors que busquenUn mètode fiable per segmentar les imatges en regions de fons i frontal ambIntervenció manual mínima.

public override void BinarizeOtsu()

Examples

L’exemple següent binaritza una imatge DICOM amb el límit Otsu. imatges binàries contenen només 2 colors - negre i blanc.

string dir = "c:\\temp\\";

                                                                                                                                          using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                          {
                                                                                                                                              Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                                              // Binarize the image with Otsu thresholding.
                                                                                                                                              dicomImage.BinarizeOtsu();
                                                                                                                                              dicomImage.Save(dir + "sample.BinarizeOtsu.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                          }

CacheData()

Aquest mètode cache eficaçment les dades, optimitza el rendiment i garanteix accés ràpidIdeal per als desenvolupadors que busquen millorar la velocitat i l’eficiència del seuAplicacions mitjançant la gestió intel·ligent de recursos de dades.

public override void CacheData()

Examples

L’exemple següent mostra com cache totes les pàgines d’una imatge DICOM.

string dir = "c:\\temp\\";

                                                                               // Load an image from a DICOM file.
                                                                               using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                               {
                                                                                   // This call caches all the pages so that no additional data loading will be performed from the underlying data stream.
                                                                                   image.CacheData();

                                                                                   // Or you can cache the pages individually.
                                                                                   foreach (Aspose.Imaging.FileFormats.Dicom.DicomPage page in image.DicomPages)
                                                                                   {
                                                                                       page.CacheData();
                                                                                   }
                                                                               }

Crop(Rectangle)

Cultivar la imatge per eliminar àrees indesitjades i centrar-se en el contingut essencial amb aquestIdeal per als desenvolupadors que busquen personalitzar la composició visual deimatges, assegurant que transmetin eficaçment el missatge desitjat.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

El rectangle

Examples

L’exemple següent cultiva una imatge DICOM. La zona de cultiu s’especifica a través de Aspose.Imaging.Rectangle.

string dir = "c:\\temp\\";

                                                                                                                     using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                     {
                                                                                                                         Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                         // Crop the image. The cropping area is the rectangular central area of the image.
                                                                                                                         Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(dicomImage.Width / 4, dicomImage.Height / 4, dicomImage.Width / 2, dicomImage.Height / 2);
                                                                                                                         dicomImage.Crop(area);

                                                                                                                         // Save the cropped image to PNG
                                                                                                                         dicomImage.Save(dir + "sample.Crop.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                     }

Crop(Int, int, int, int)

Ajustar l’àrea de gravació de la imatge aplicant canvis amb aquest mètode versàtil.Ideal per als desenvolupadors que necessiten un control precís sobre el procés de recaptació, assegurantEls detalls importants es conserven mentre s’eliminen els elements innecessaris.

public override void Crop(int leftShift, int rightShift, int topShift, int bottomShift)

Parameters

leftShift int

El canvi de esquerra.

rightShift int

El canvi correcte.

topShift int

El canvi superior.

bottomShift int

El canvi de baix.

Examples

L’exemple següent cultiva una imatge DICOM. La zona de cultiu s’especifica a través de les marges esquerra, superior, dreta, baix.

string dir = @"c:\temp\";

                                                                                                                          using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                          {
                                                                                                                              Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                              // Crop again. Set a margin of 10% of the image size.
                                                                                                                              int horizontalMargin = dicomImage.Width / 10;
                                                                                                                              int verticalMargin = dicomImage.Height / 10;
                                                                                                                              dicomImage.Crop(horizontalMargin, horizontalMargin, verticalMargin, verticalMargin);

                                                                                                                              // Save the cropped image to PNG.
                                                                                                                              dicomImage.Save(dir + "sample.Crop.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                          }

Dither(DitheringMetode, int, IColorPalette)

Millorar la imatge actual mitjançant l’aplicació d’efectes de difusió amb aquest senzillPerfecte per als desenvolupadors que busquen afegir textura i profunditat a les imatges,Millorar la seva qualitat visual i l’atracció general.

public override void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)

Parameters

ditheringMethod DitheringMethod

El mètode de difusió.

bitsCount int

Els bits finals compten per a la difusió.

customPalette IColorPalette

El costum de la paleta per a la difusió.

Examples

L’exemple següent carrega una imatge DICOM i realitza la difusió del límit i el fluid mitjançant diferents profunditats de la paleta.

string dir = "c:\\temp\\";

                                                                                                                              using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                              {
                                                                                                                                  Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                                  // Perform threshold dithering using 4-bit color palette which contains 16 colors.
                                                                                                                                  // The more bits specified the higher quality and the bigger size of the output image.
                                                                                                                                  // Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
                                                                                                                                  dicomImage.Dither(Aspose.Imaging.DitheringMethod.ThresholdDithering, 4, null);

                                                                                                                                  dicomImage.Save(dir + "sample.ThresholdDithering4.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                              }

                                                                                                                              using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                              {
                                                                                                                                  Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                                  // Perform floyd dithering using 1-bit color palette which contains only 2 colors - black and white.
                                                                                                                                  // The more bits specified the higher quality and the bigger size of the output image.
                                                                                                                                  // Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
                                                                                                                                  dicomImage.Dither(Aspose.Imaging.DitheringMethod.FloydSteinbergDithering, 1, null);

                                                                                                                                  dicomImage.Save(dir + "sample.FloydSteinbergDithering1.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                              }

Filter(Rectangle, FilterOptionsBase)

Millorar sense esforç les àrees específiques de la imatge aplicant filtres a les assignades.Aquest mètode proporciona als desenvolupadors un control precís sobremanipulació d’imatge, permetent ajustaments objectius per aconseguir el desitjatEfectes visuals amb facilitat.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

El rectangle

options FilterOptionsBase

Les opcions.

Examples

L’exemple següent aplica diversos tipus de filtres a una imatge DICOM.

string dir = "c:\\temp\\";

                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                   {
                                                                                       Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                       // Apply a median filter with a rectangle size of 5 to the entire image.
                                                                                       dicomImage.Filter(dicomImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MedianFilterOptions(5));
                                                                                       dicomImage.Save(dir + "sample.MedianFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }

                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                   {
                                                                                       Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                       // Apply a bilateral smoothing filter with a kernel size of 5 to the entire image.
                                                                                       dicomImage.Filter(dicomImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.BilateralSmoothingFilterOptions(5));
                                                                                       dicomImage.Save(dir + "sample.BilateralSmoothingFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }

                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                   {
                                                                                       Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                       // Apply a Gaussian blur filter with a radius of 5 and a sigma value of 4.0 to the entire image.
                                                                                       dicomImage.Filter(dicomImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions(5, 4.0));
                                                                                       dicomImage.Save(dir + "sample.GaussianBlurFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }

                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                   {
                                                                                       Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                       // Apply a Gauss-Wiener filter with a radius of 5 and a smooth value of 4.0 to the entire image.
                                                                                       dicomImage.Filter(dicomImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussWienerFilterOptions(5, 4.0));
                                                                                       dicomImage.Save(dir + "sample.GaussWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }

                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                   {
                                                                                       Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                       // Apply a motion wiener filter with a length of 5, a smooth value of 4.0 and an angle of 90.0 degrees to the entire image.
                                                                                       dicomImage.Filter(dicomImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
                                                                                       dicomImage.Save(dir + "sample.MotionWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }

                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                   {
                                                                                       Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                       // Apply a sharpen filter with a kernel size of 5 and a sigma value of 4.0 to the entire image.
                                                                                       dicomImage.Filter(dicomImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.SharpenFilterOptions(5, 4.0));
                                                                                       dicomImage.Save(dir + "sample.SharpenFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                   }

Grayscale()

Fàcilment transformar les imatges en la seva representació griscal, simplificant la visiótasques d’anàlisi i processament. perfecte per als desenvolupadors que busquen millorar la claredat de la imatge,Reduir la complexitat i facilitar algoritmes eficients basats en grayscalesper a diverses aplicacions.

public override void Grayscale()

Examples

L’exemple següent transforma una imatge de color DICOM en la seva representació de graes. Les imatges de Graes es componen exclusivament de ombres de gris i porten només informació d’intensitat.

string dir = "c:\\temp\\";

                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                                                    {
                                                                                                                                                                                                        Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                                                                                                                                        dicomImage.Grayscale();
                                                                                                                                                                                                        dicomImage.Save(dir + "sample.Grayscale.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                                                    }

InsertPage(Int)

Insereix una nova pàgina a la llista de pàgines de la imatge en un indicador especificat amb aquest intuïtiuIdeal per als desenvolupadors que busquen control precís sobre l’arrendament de les pàgines enImatges de múltiples pàgines, assegurant l’organització i la personalització de continguts d’imatges.

public DicomPage InsertPage(int pageIndex)

Parameters

pageIndex int

Índex de la pàgina.

Returns

DicomPage

El nou creat Aspose.Imaging.FileFormats.Dicom.Page.

Examples

Creació d’una imatge multipàgina.

using (DicomImage image = (DicomImage)Image.Create(
                                                   new DicomOptions() { Source = new StreamSource(new MemoryStream()) },
                                                   100,
                                                   100))
                                           {
                                               // Draw something using vector graphics
                                               Graphics graphics = new Graphics(image);
                                               graphics.FillRectangle(new SolidBrush(Color.BlueViolet), image.Bounds);
                                               graphics.FillRectangle(new SolidBrush(Color.Aqua), 10, 20, 50, 20);
                                               graphics.FillEllipse(new SolidBrush(Color.Orange), 30, 50, 70, 30);

                                               // Save the pixels of the drawn image. They are now on the first page of the Dicom image.
                                               int[] pixels = image.LoadArgb32Pixels(image.Bounds);

                                               // Add a few pages after, making them darker
                                               for (int i = 1; i < 5; i++)
                                               {
                                                   DicomPage page = image.AddPage();
                                                   page.SaveArgb32Pixels(page.Bounds, pixels);
                                                   page.AdjustBrightness(i * 30);
                                               }

                                               // Add a few pages in front of the main page, making them brighter
                                               for (int i = 1; i < 5; i++)
                                               {
                                                   DicomPage page = image.InsertPage(0);
                                                   page.SaveArgb32Pixels(page.Bounds, pixels);
                                                   page.AdjustBrightness(-i * 30);
                                               }

                                               // Save the created multi-page image to the output file
                                               image.Save("MultiPage.dcm");
                                           }

Exceptions

ArgumentOutOfRangeException

pageIndex’ is out of range.

ReleaseManagedResources()

Assegureu-vos que no es lliuren recursos no gestionats aquí, ja que poden haver estatJa està alliberat.

protected override void ReleaseManagedResources()

RemovePage(Int)

Eliminar la pàgina a l’índex especificat de la llista de pàgines amb aquest mètode convenient.Ideal per als desenvolupadors que busquen control precís sobre la gestió d’imatges de múltiples pàgines,Assegurar l’organització i la personalització de continguts d’imatges.

public void RemovePage(int pageIndex)

Parameters

pageIndex int

Índex de la pàgina.

Exceptions

ArgumentOutOfRangeException

pageIndex’ is out of range.

Resize(Int, int, ResizeTyp)

Ajustar la mida de la imatge amb aquest mètode senzill. Ideal per als desenvolupadorstractar de residir dinàmicament les imatges, assegurant-se que s’adaptin sense cap mena de segell a diversescontextos i layouts dins de les seves aplicacions.

public override void Resize(int newWidth, int newHeight, ResizeType resizeType)

Parameters

newWidth int

La nova amplada.

newHeight int

La nova alçada.

resizeType ResizeType

El tipus de residus.

Examples

Aquest exemple carrega una imatge DICOM i la resisa utilitzant diversos mètodes de resissió.

string dir = "c:\\temp\\";

                                                                                          using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                          {
                                                                                              // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                              image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                              // Save to PNG with default options.
                                                                                              image.Save(dir + "upsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                          }

                                                                                          using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                          {
                                                                                              // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                              image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                              // Save to PNG with default options.
                                                                                              image.Save(dir + "downsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                          }

                                                                                          using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                          {
                                                                                              // Scale up by 2 times using Bilinear resampling.
                                                                                              image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                              // Save to PNG with default options.
                                                                                              image.Save(dir + "upsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                          }

                                                                                          using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                          {
                                                                                              // Scale down by 2 times using Bilinear resampling.
                                                                                              image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                              // Save to PNG with default options.
                                                                                              image.Save(dir + "downsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                          }

Resize(Int, int, ImageResizeSettings)

Ajustar la mida de la seva imatge amb aquest mètode senzill de resignació.Reduir o ampliar la teva imatge, aquesta funció garanteix que les teves necessitats de resignació són satisfeteseficient i precisament, fent-ho perfecte per als desenvolupadors que busquen ràpid i fàcilAjustaments de mida de la imatge.

public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)

Parameters

newWidth int

La nova amplada.

newHeight int

La nova alçada.

settings ImageResizeSettings

La restauració de les instal·lacions.

Examples

Aquest exemple carrega una imatge DICOM i la resisa utilitzant diverses configuracions de resissió.

string dir = "c:\\temp\\";

                                                                                           Aspose.Imaging.ImageResizeSettings resizeSettings = new Aspose.Imaging.ImageResizeSettings();

                                                                                           // The adaptive algorithm based on weighted and blended rational function and lanczos3 interpolation.
                                                                                           resizeSettings.Mode = Aspose.Imaging.ResizeType.AdaptiveResample;

                                                                                           // The small rectangular filter
                                                                                           resizeSettings.FilterType = Aspose.Imaging.ImageFilterType.SmallRectangular;

                                                                                           // The number of colors in the palette.
                                                                                           resizeSettings.EntriesCount = 256;

                                                                                           // The color quantization is not used
                                                                                           resizeSettings.ColorQuantizationMethod = ColorQuantizationMethod.None;

                                                                                           // The euclidian method
                                                                                           resizeSettings.ColorCompareMethod = ColorCompareMethod.Euclidian;

                                                                                           using (Aspose.Imaging.Image image = (Aspose.Imaging.Image)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                           {
                                                                                               Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = (Aspose.Imaging.FileFormats.Dicom.DicomImage)image;

                                                                                               // Scale down by 2 times using adaptive resampling.
                                                                                               dicomImage.Resize(image.Width / 2, image.Height / 2, resizeSettings);

                                                                                               // Save to PNG
                                                                                               dicomImage.Save(dir + "downsample.adaptive.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                           }

ResizeHeightProportionally(Títol, Resistència)

Ajustar l’altura de la imatge mentre manté el seu aspecte proporcional amb aquestMètode amable per a l’usuari. perfecte per als desenvolupadors que busquen reservar dinàmicament les imatgesmantenir les seves proporcions, assegurant l’exposició òptima i la usabilitaten les seves aplicacions.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

La nova alçada.

resizeType ResizeType

Tipus de recorregut.

Examples

Aquest exemple carrega una imatge DICOM i la resisa proporcionalment utilitzant diversos mètodes de resissió. Només s’especifica l’alçada, la amplada es calcula automàticament.

string dir = "c:\\temp\\";

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                  image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "upsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                  image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "downsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale up by 2 times using Bilinear resampling.
                                                                                                                                                                                  image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "upsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale down by 2 times using Bilinear resampling.
                                                                                                                                                                                  image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "downsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

ResizeProportional(Int, int, ResizeTyp)

Ideal per als desenvolupadors que busquen ajustar les dimensions de la imatge proporcionalment, assegurar la coherència i preservar les proporcions del contingut original.La resignació proporcional revisarà cada quadre segons la proporció de newWidth’/width i <class de codis=“paramref>newHeight”/height.

public void ResizeProportional(int newWidth, int newHeight, ResizeType resizeType)

Parameters

newWidth int

La nova amplada.

newHeight int

La nova alçada.

resizeType ResizeType

El tipus de residus.

ResizeWidthProportionally(Títol, Resistència)

Ajustar l’amplada de la imatge mentre manté el seu ratio d’aspecte amb aquest convenientIdeal per als desenvolupadors que busquen resumir les imatges proporcionalment, assegurantresultats consistents i visualment atractius en diferents entorns de pantalla.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

La nova amplada.

resizeType ResizeType

Tipus de recorregut.

Examples

Aquest exemple carrega una imatge DICOM i la resisa proporcionalment utilitzant diversos mètodes de resissió. Només s’especifica la amplada, la altura es calcula automàticament.

string dir = "c:\\temp\\";

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                  image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "upsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                  image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "downsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale up by 2 times using Bilinear resampling.
                                                                                                                                                                                  image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "upsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

                                                                                                                                                                              using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                                              {
                                                                                                                                                                                  // Scale down by 2 times using Bilinear resampling.
                                                                                                                                                                                  image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.BilinearResample);                

                                                                                                                                                                                  // Save to PNG with the default options.
                                                                                                                                                                                  image.Save(dir + "downsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                              }

Rotate(Float, bool i color)

Rota la imatge al voltant del seu centre amb aquest mètode convenient. Ideal per als desenvolupadorstractar d’ajustar l’orientació de la imatge dinàmicament, assegurant la presentació òptima iAlineació dins de les seves aplicacions.

public override void Rotate(float angle, bool resizeProportionally, Color backgroundColor)

Parameters

angle float

L’angle de rotació en graus. els valors positius giraran de manera horària.

resizeProportionally bool

si s’estableix a ’true’ haurà canviat la mida de la imatge segons les projeccions rectangles (punts de cor) girades en altres casos que deixen les dimensions sense tocar i només interiors els continguts d’imatge es giren.

backgroundColor Color

El color del fons.

Examples

Aquest exemple mostra com girar totes les pàgines d’una imatge DICOM i salvar-les totes a una imatge TIFF multi-frame.

string dir = "c:\\temp\\";

                                                                                                                     // Load a DICOM image from a file stream.
                                                                                                                     using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "multiframe.dicom"))
                                                                                                                     {
                                                                                                                         using (Aspose.Imaging.FileFormats.Dicom.DicomImage dicomImage = new Aspose.Imaging.FileFormats.Dicom.DicomImage(stream))
                                                                                                                         {
                                                                                                                             // Rotate the image around the center by 60 degrees clockwise.
                                                                                                                             // Use gray as the background color.
                                                                                                                             dicomImage.Rotate(60, true, Aspose.Imaging.Color.Gray);

                                                                                                                             Aspose.Imaging.ImageOptions.TiffOptions createOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);
                                                                                                                             createOptions.Compression = Aspose.Imaging.FileFormats.Tiff.Enums.TiffCompressions.Deflate;

                                                                                                                             // Note that if the image is colorful, it will be automatically converted to the grayscale format according to the options below
                                                                                                                             createOptions.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.MinIsBlack;
                                                                                                                             createOptions.BitsPerSample = new ushort[] { 8 };

                                                                                                                             // Create an array of TIFF frames.
                                                                                                                             // The number of the frames is equal to the number of the DJVU pages.
                                                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame[] tiffFrames = new Aspose.Imaging.FileFormats.Tiff.TiffFrame[dicomImage.DicomPages.Length];

                                                                                                                             // Save each page as an individual TIFF frame.
                                                                                                                             foreach (Aspose.Imaging.FileFormats.Dicom.DicomPage dicomPage in dicomImage.DicomPages)
                                                                                                                             {
                                                                                                                                 // Create a TIFF frame based on the DICOM page.
                                                                                                                                 tiffFrames[dicomPage.Index] = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(dicomPage, createOptions);
                                                                                                                             }

                                                                                                                             // Compose a TIFF image from the frames.
                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = new Aspose.Imaging.FileFormats.Tiff.TiffImage(tiffFrames))
                                                                                                                             {
                                                                                                                                 // Save to a file.
                                                                                                                                 tiffImage.Save(dir + "multiframe.tif");
                                                                                                                             }
                                                                                                                         }
                                                                                                                     }

RotateFlip(RotateFlipType)

Fàcilment manipular el marc actiu girant, flipping o realitzant ambdues accionssimultàniament amb aquest mètode senzill. ideal per als desenvolupadors que necessitenajustar dinàmicament l’orientació dels quadres específics dins de les seves seqüències d’imatge,Garantir una presentació i alineació òptima.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

El tipus de flip rotat.

Examples

Aquest exemple carrega una imatge DICOM, la gira per 90 graus d’hora i opcionalment flipa la imatge horitzontalment i/o verticalment.

string dir = "c:\\temp\\";

                                                                                                                                               Aspose.Imaging.RotateFlipType[] rotateFlipTypes = new Aspose.Imaging.RotateFlipType[]
                                                                                                                                               {
                                                                                                                                                   Aspose.Imaging.RotateFlipType.Rotate90FlipNone,
                                                                                                                                                   Aspose.Imaging.RotateFlipType.Rotate90FlipX,
                                                                                                                                                   Aspose.Imaging.RotateFlipType.Rotate90FlipXY,
                                                                                                                                                   Aspose.Imaging.RotateFlipType.Rotate90FlipY,
                                                                                                                                               };

                                                                                                                                               foreach (Aspose.Imaging.RotateFlipType rotateFlipType in rotateFlipTypes)
                                                                                                                                               {
                                                                                                                                                   // Rotate, flip and save to the output file.
                                                                                                                                                   using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                                                                   {
                                                                                                                                                       image.RotateFlip(rotateFlipType);
                                                                                                                                                       image.Save(dir + "sample." + rotateFlipType + ".png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                   }
                                                                                                                                               }

Save(Flux, ImageOptionsBase, Rectangle)

S’emmagatzema fàcilment les dades d’imatge a un flux especificat en el format de fitxer desitjatSi vostè treballa amb JPEG, PNG, o un altre format,Aquesta funció garanteix que les teves dades d’imatge s’emmagatzemen de manera eficient i precisa,fer-ho ideal per als desenvolupadors que busquen simplificar els seus processos d’estalvi de fitxers.

public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)

Parameters

stream Stream

El flux per salvar les dades de la imatge a.

optionsBase ImageOptionsBase

Les opcions d’estalvi.

boundsRectangle Rectangle

L’imatge de destinació limita el rectangle. Establir el recte buit per utilitzar els límits de font.

Examples

L’exemple següent carrega una imatge DICOM d’un arxiu, i després salva la imatge a un flux de fitxers PNG.

string dir = "c:\\temp\\";

                                                                                                            using (Aspose.Imaging.FileFormats.Dicom.DicomImage image = (Aspose.Imaging.FileFormats.Dicom.DicomImage)Aspose.Imaging.Image.Load(dir + "sample.dicom"))
                                                                                                            {
                                                                                                                Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(0, 0, image.Width / 2, image.Height / 2);
                                                                                                                using (System.IO.Stream outputStream = System.IO.File.Open(dir + "output.png", System.IO.FileMode.Create))
                                                                                                                {
                                                                                                                    // Save the upper-left quarter of the image to a file stream.
                                                                                                                    image.Save(outputStream, saveOptions, bounds);
                                                                                                                }
                                                                                                            }

SaveAll(Llistat, ImageOptionsBase)

Conservar les dades de l’objecte guardant-les al fitxer designat (indicador + nom de fitxers)ubicació juntament amb el format de fitxer especificat i les opcions. Ideal per als desenvolupadors que busquenemmagatzema de forma segura les dades en diversos formats, mantenint la flexibilitat i el controlParàmetres d’estalvi.

public void SaveAll(string filePath, ImageOptionsBase options)

Parameters

filePath string

El camí del fitxer.

options ImageOptionsBase

Les opcions.

SaveData(Stream)

Estalvia les dades.

protected override void SaveData(Stream stream)

Parameters

stream Stream

El flux per salvar les dades a.

SetResolution(doble, doble)

Ajustar la resolució d’aquest Aspose.Imaging.RasterImage amb precisió utilitzant aquestIdeal per als desenvolupadors que busquen adaptar la resolució d’imatge arequisits específics, assegurant la qualitat de pantalla òptima i la gestió de la mida del fitxer.

public override void SetResolution(double dpiX, double dpiY)

Parameters

dpiX double

La resolució horitzontal, en punts per polz, de la Aspose.Imaging.RasterImage.

dpiY double

La resolució vertical, en punts per polz, de la Aspose.Imaging.RasterImage.

UpdateDimensions(Int, Int)

Actualitza les dimensions de la imatge.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

La nova imatge d’amplada.

newHeight int

Alçada de la nova imatge.

 Català