Class DicomImage

Class DicomImage

Nazwa przestrzeń: Aspose.Imaging.FileFormats.Dicom Zgromadzenie: Aspose.Imaging.dll (25.4.0)

Ta klasa wdraża cyfrowe obrazy i komunikacje w medycynie(DICOM) obsługuje format obrazu raster i oferuje kompleksowe rozwiązanie dlaPrzetwarzanie obrazów DICOM z precyzją i elastycznością.manipulować stronami obrazowymi, w tym operacjami uzyskania, dodania lub usuwania stron, orazsterowanie domyślnymi i aktywnymi stronami. z możliwościami pracy z kanałami alfa,włączone metadane XMP, resize, rotat, zbiórka, binaryzacja, dostosowanie, zastosowanie filtrów,i konwertować do innych formatów raster. ta API umożliwia programistom zarządzanieDICOM wyświetla efektywnie, jednocześnie spełniając różne wymagania aplikacyjne wZdjęcia medyczne w kontekście.

[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

Dziedziczeni członkowie

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

Zmień typ koloru w kompresji DICOM.

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

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

Użyj kompresji RLE w obrazie 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);
                                              }

Użyj kompresji JPEG 2000 w obrazie 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);
                                                    }

Użyj kompresji JPEG w obrazie 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);
                                               }

Ten przykład pokazuje, jak pobrać obraz DICOM z strumienia pliku.

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

Tworzenie multimedialnego obrazu Dicom.

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(Dykomopcje, int , int)

Inicjalizuj świeżą instancję klasy DicomImage bez wysiłku z tymkonstruktor, korzystając z parametrów dicomOptions. Idealny dla deweloperów oglądaćdo wchłaniania się do obiektów Aspose.Imaging.FileFormats.Dicom.Mimage szybko i efektywnie w ich projektach.

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

Parameters

dicomOptions DicomOptions

Opcje opcji dicom.

width int

i szerokości .

height int

i wysokość .

DicomImage(Strumień, LoadOptions)

Rozpocznij nową instancję klasy DicomImage płynnie, wykorzystując strumień iOpcje parametrów w tym konstruktorze. idealny dla deweloperów chętnych do rozpoczęciapracować z Aspose.Imaging.FileFormats.Dicom.DiomImage obiektów szybko i skutecznie w swoich projektach.

public DicomImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

w strumieniu .

loadOptions LoadOptions

Opcje opcji ładowania.

Examples

Ten przykład pokazuje, jak pobrać obraz DICOM z przepływu plików, aby pozostać w określonym limitie pamięci.

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)

Tworzenie nowej instancji klasy DicomImage za pomocą parametra strumieniaIdealny dla deweloperów, którzy szukają ukierunkowanego sposobu na inicjalizacjęAspose.Imaging.FileFormats.Dicom.DiomImage obiekty z istniejących strumieni danych w ich projektach.

public DicomImage(Stream stream)

Parameters

stream Stream

w strumieniu .

Examples

Ten przykład pokazuje, jak pobrać obraz DICOM z strumienia pliku.

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

Zarządzaj aktywną stroną obrazu z tą intuicyjną własnością. idealny dla deweloperówdążenie do dynamicznego przełączania między stronami w wielu stronach obrazów, zapewniając efektywnenawigacji i przetwarzania.

public DicomPage ActivePage { get; set; }

Wartość nieruchomości

DicomPage

Exceptions

DicomImageException

Aktywna strona nie może być ustawiona, ponieważ należy do innego obrazu.

ActivePageIndex

Odzyskuj indeks aktywnej strony bez wysiłku za pomocą tej intuicyjnej właściwości.Idealny dla deweloperów poszukujących szybkiego dostępu do bieżącego indeksu strony w wielu stronachZapewnienie efektywnej nawigacji i przetwarzania.

public int ActivePageIndex { get; }

Wartość nieruchomości

int

DicomPages

Dostęp do stron obrazu za pomocą tej intuicyjnej właściwości. idealny dla deweloperówdążenie do interakcji z poszczególnymi stronami wewnątrz obrazu, zapewniając bezprzewodowenawigacji i manipulacji.

public DicomPage[] DicomPages { get; }

Wartość nieruchomości

DicomPage [ ]

FileFormat

Przywróć wartość formatu pliku bez wysiłku z tą intuicyjną cechą.programistów poszukujących szybkiego dostępu do formatu pliku obrazu, zapewniając efektywnyobsługi i przetwarzania na podstawie typu pliku.

public override FileFormat FileFormat { get; }

Wartość nieruchomości

FileFormat

FileInfo

Odzyskuj cenne informacje o nagłówku z pliku DICOM bez wysiłku dzięki temuIdealny dla deweloperów poszukujących szybkiego dostępu do podstawowych szczegółówwłączone w plik DICOM, zapewniając skuteczną ekstrakcję i analizę danych.

public DicomImageInfo FileInfo { get; }

Wartość nieruchomości

DicomImageInfo

HasAlpha

Sprawdź, czy obraz ma kanał alfa bez wysiłku z tym intuicyjnymIdealny dla deweloperów, którzy chcą ustalić, czy obraz zawiera przejrzystośćzapewnienie dokładnej obsługi danych kanału alfa w zadaniach przetwarzania obrazu.

public override bool HasAlpha { get; }

Wartość nieruchomości

bool

PageCount

Odzyskuj całkowitą liczbę stron obrazu dzięki temu intuicyjnemu właściwości.Twórcy, którzy szukają szybkiego dostępu do liczby stron w obrazie, zapewniająSkuteczna nawigacja i zarządzanie.

public override int PageCount { get; }

Wartość nieruchomości

int

Pages

Dostęp do stron obrazu za pomocą tej intuicyjnej właściwości. idealny dla deweloperówdążenie do interakcji z poszczególnymi stronami wewnątrz obrazu, zapewniając bezprzewodową nawigacjęi manipulacji.

public override Image[] Pages { get; }

Wartość nieruchomości

Image [ ]

Methods

AddPage(RasterImage)

Rozszerz kolekcję obrazów, dodając nową stronę za pomocą tej intuicyjnej metody.Idealny dla deweloperów, którzy chcą dynamicznie dodawać strony do wielu obrazów stron,Zapewnienie bezprzewodowej ekspansji i organizacji treści obrazu.

public void AddPage(RasterImage page)

Parameters

page RasterImage

Strona do dodania.

Exceptions

ArgumentNullException

page’ is null.

AddPage()

Dodaj nową stronę do końca listy stron obrazu za pomocą tej prostej metody.Idealny dla deweloperów dążących do dynamicznego rozszerzenia obrazów wielokierunkowych, zapewniając bezprzewodoweIntegracja i organizacja treści obrazu.

public DicomPage AddPage()

Returns

DicomPage

Nowo utworzony Aspose.Imaging.FileFormats.Dicom.Page.

Examples

Tworzenie multimedialnego obrazu Dicom.

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)

Poprawa światła obrazu poprzez dostosowanie jasności , aparametryzowanej metody, która umożliwia deweloperom doskonale odtynąć jasność obrazów.Ta przyjazna dla użytkownika funkcja pozwala na bezwzględną manipulację obrazowością, oferując elastyczność i kontrolę nad estetyką wizualną.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Wartość jasności .

Examples

Poniższy przykład wykonuje poprawę jasności obrazu 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(Floty)

Wzmocnienie Aspose.Imaging.Image kontrast z tym przyjaznym dla użytkownika sposobem,które dostosowują różnicę między światłem a ciemnymi obszarami. poprawa jasności wizualnej iDefinicja bez wysiłku, zapewniając deweloperom intuicyjną kontrolę nadKontrast obrazu dla optymalnego renderowania.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Wartość kontrastu (w zakresie [-100; 100])

Examples

Poniższy przykład wykonuje naprawę kontrastu obrazu 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(Floty)

Poprawa jakości obrazu i dostosowanie go za pomocą korekty gamma, potężnej technikiIdealny dla deweloperów mających na celu optymalizację obrazuprezentacja, dostosowanie równowagi kolorów i zapewnienie spójnego renderowania między różnymiurządzenia i środowiska.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma dla współczynnika czerwonych, zielonych i niebieskich kanałów

Examples

Poniższy przykład wykonuje korektę gamma obrazu 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 float)

Dokonywanie precyzyjnych dostosowania kolorów poprzez zastosowanie korekty gamma niezależniedo czerwonych, zielonych i niebieskich składników obrazu. ta metoda zapewnia dokładnośćrównowaga kolorów i optymalna wydajność wizualna, catering dla deweloperów poszukujących granularówkontrola renderowania obrazu i dokładności koloru.

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

Parameters

gammaRed float

Gamma dla współczynnika czerwonego kanału

gammaGreen float

Gamma dla współczynnika zielonego kanału

gammaBlue float

Gamma dla współczynnika niebieskiego kanału

Examples

Poniższy przykład wykonuje korektę gamma obrazu DICOM, stosując różne współczynniki dla komponentów kolorowych.

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(podwójne, int)

Binaryzuj obrazy z adaptowym algorytmem granicowym Bradleyawytrzymałość obrazu dla poprawy wydajności. idealny dla deweloperów, którzy chcąautomatycznie segmentować obrazy w oparciu o lokalną różnicę jasności, zapewniającDokładna wykrywanie i ekstrakcja obiektów w różnych warunkach oświetlenia.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Różnica jasności pomiędzy pikselem a przeciętnym oknem s x s pixelówWystarczy skupić się wokół tego piksela.

windowSize int

Rozmiar okna s x s pikseli skoncentrowane wokół tego piksela

Examples

Poniższy przykład binaryzuje obraz DICOM z adaptowym algorytmem granicznym Bradleya o określonej wielkości okna.

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(byte)

Łatwo przekonwertować obraz w formacie binarnym za pomocą uprzednio zdefiniowanej granicyz tą prostą metodą. idealny dla deweloperów, którzy chcą ułatwić obrazPrzetwarzanie zadań poprzez segmentację obrazu na elementy przodu i tław oparciu o określone poziomy intensywności.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

W przypadku, gdy odpowiednia wartość szarowa piksela jest większa niż granica, wartości255 zostanie przydzielone do niego, 0 inaczej.

Examples

Poniższy przykład binaryzuje obraz DICOM z uprzednio zdefiniowaną granicą. obrazy binarizowane zawierają tylko 2 kolory - czarny i biały.

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()

Zastosuj granicę Otsu do binaryzacji obrazu, automatycznie określając optymalnywartość próg oparta na histogramie obrazu. doskonały dla deweloperów, którzy szukająniezawodna metoda segmentowania obrazów do obszarów przodu i tła zminimalna interwencja ręczna.

public override void BinarizeOtsu()

Examples

Poniższy przykład binaryzuje obraz DICOM z granicą Otsu. obrazy binarizowane zawierają tylko 2 kolory - czarny i biały.

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()

Ta metoda efektywnie szykuje dane, optymalizuje wydajność i zapewnia szybki dostępIdealny dla deweloperów, którzy chcą zwiększyć szybkość i wydajność swoichInteligentne zarządzanie zasobami danych.

public override void CacheData()

Examples

Poniższy przykład pokazuje, jak ukryć wszystkie strony obrazu 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)

Zrób obraz, aby usunąć niepożądane obszary i skupić się na istotnym treści z tymIdealny dla deweloperów, którzy chcą dostosować kompozycję wizualnąZdjęcia, aby zapewnić skuteczne przekazywanie pożądanej wiadomości.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

z rektangulą .

Examples

Poniższy przykład zawiera obraz DICOM. obszar gromadzenia jest określony za pośrednictwem 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, int)

Dostosuj obszar gromadzenia obrazu, stosując zmiany za pomocą tej wszechstronnej metody.Idealny dla deweloperów, którzy potrzebują precyzyjnej kontroli nad procesem gromadzenia, zapewniającWażne szczegóły są utrzymywane, jednocześnie eliminując niepotrzebne elementy.

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

Parameters

leftShift int

Po lewej zmianie.

rightShift int

Prawdziwa zmiana

topShift int

Najwyższa zmiana

bottomShift int

W dolnej zmianie.

Examples

W poniższym przykładzie rośnie obraz DICOM. obszar roślin jest określony za pośrednictwem lewicowych, górnych, prawych, dolnych marginesów.

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(DitheringMetoda, int, IColorPalette)

Poprawa bieżącego obrazu poprzez zastosowanie efektów dystrybucji z tym prostymIdealny dla deweloperów mających na celu dodanie tekstury i głębokości do obrazów,Poprawa jakości wzroku i ogólnej atrakcji.

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

Parameters

ditheringMethod DitheringMethod

Metoda dystrybucji .

bitsCount int

Ostatnie bity liczą na dystrybucję.

customPalette IColorPalette

Przygotowuje się paletę do Dithering.

Examples

Poniższy przykład ładuje obraz DICOM i wykonuje granicę i przepływ dystrybucji za pomocą różnych głębokości palety.

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)

Nieprzyjemnie poprawia konkretne obszary obrazu poprzez zastosowanie filtrów do wyznaczonychMetoda ta zapewnia programistom precyzyjną kontrolę nadmanipulacja obrazu, umożliwiając celowe dostosowania do osiągnięcia pożądanychEfekty wizualne z łatwością.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

z rektangulą .

options FilterOptionsBase

i opcji .

Examples

Poniższy przykład stosuje różne rodzaje filtrów do obrazu 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()

Łatwo przekształcić obrazy w ich grayscale reprezentacji, uproszczając wizualneanalizy i zadań przetwarzania. doskonały dla deweloperów dążących do poprawy jasności obrazu,zmniejszenie złożoności i ułatwienie efektywnych algorytmów opartych na grayscaledla różnych zastosowań.

public override void Grayscale()

Examples

Poniższy przykład przekształca kolorowy obraz DICOM w jego reprezentację grayscale. obrazy grafiki składają się wyłącznie z odcieni szary i przynoszą tylko informacje o intensywności.

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)

Wprowadź nową stronę do listy stron obrazu na określonym indeksie za pomocą tego intuicyjnegoIdealny dla deweloperów, którzy szukają dokładnej kontroli nad aranżacją stron wobrazów wielokierunkowych, zapewniając bezprzewodową organizację i dostosowanie treści obrazu.

public DicomPage InsertPage(int pageIndex)

Parameters

pageIndex int

Indeks strony.

Returns

DicomPage

Nowo utworzony Aspose.Imaging.FileFormats.Dicom.Page.

Examples

Tworzenie multimedialnego obrazu Dicom.

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()

Uwolnij zarządzane zasoby. upewnij się, że nie są one uwalniane tutaj, ponieważ mogą byćJest już uwalniany.

protected override void ReleaseManagedResources()

RemovePage(Int)

Usunąć stronę na określonym indeksie z listy stron za pomocą tej wygodnej metody.Idealny dla deweloperów poszukujących precyzyjnej kontroli nad zarządzaniem obrazami z wielu stron,zapewnienie bezprzewodowej organizacji i dostosowania treści obrazu.

public void RemovePage(int pageIndex)

Parameters

pageIndex int

Indeks strony.

Exceptions

ArgumentOutOfRangeException

pageIndex’ is out of range.

Resize(int, int, resizeType)

Dostosuj rozmiar obrazu za pomocą tej prostej metody. idealny dla deweloperówdążyć do dynamicznego odświeżania obrazów, zapewniając, że pasują bezprzewodowo do różnychkontekstów i layoutów w ich aplikacjach.

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

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

resizeType ResizeType

Ten rodzaj rewizji.

Examples

Ten przykład ładuje obraz DICOM i odtwarza go za pomocą różnych metod odświeżania.

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)

Dostosuj rozmiar obrazu za pomocą tej prostej metody odtwarzania.skrócenie lub powiększenie obrazu, ta funkcja zapewnia, że Twoje potrzeby odtwarzania są spełnioneefektywnie i precyzyjnie, dzięki czemu jest idealny dla deweloperów, którzy szukają szybkiego i łatwegoDostosowanie rozmiaru obrazu.

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

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

settings ImageResizeSettings

Zmiany w ustawieniach.

Examples

Ten przykład ładuje obraz DICOM i odtwarza go za pomocą różnych ustawień odświeżania.

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łumaczenie, ResizeType)

Dostosuj wysokość obrazu przy jednoczesnym utrzymaniu jego stosunku aspektowego do tegometoda przyjazna dla użytkownika. doskonała dla deweloperów, którzy chcą dynamicznie odtworzyć obrazyprzy zachowaniu ich proporcji, zapewniając optymalny wyświetlacz i użytecznośćw ich aplikacjach.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

Nowa wysokość .

resizeType ResizeType

Rodzaj rezygnacji.

Examples

Ten przykład ładuje obraz DICOM i odtwarza go proporcjonalnie przy użyciu różnych metod odświeżania.

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, resizeType)

Idealnie dla deweloperów, którzy chcą dostosować wymiary obrazu proporcjonalnie, zapewnić spójność i utrzymać proporcje oryginalnego zawartości.Porównywalna resizja będzie odświeżać każdy ramy zgodnie z stosunkiem newWidth’/width i newHeight’ / height.

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

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

resizeType ResizeType

Ten rodzaj rewizji.

ResizeWidthProportionally(Tłumaczenie, ResizeType)

Dostosuj szerokość obrazu przy jednoczesnym utrzymaniu jego stosunku aspektowego do tego wygodnegoIdealny dla deweloperów, którzy chcą proporcjonalnie odświeżyć obrazy, zapewniająckonsekwentne i wizualnie atrakcyjne wyniki w różnych środowiskach wyświetlania.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

Nowa szerokość .

resizeType ResizeType

Rodzaj rezygnacji.

Examples

Ten przykład ładuje obraz DICOM i odtwarza go proporcjonalnie przy użyciu różnych metod odświeżania.

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, Kolor)

Obróć obraz wokół jego centrum za pomocą tej wygodnej metody. idealny dla deweloperówdążenie do dynamicznego dostosowania orientacji obrazu, zapewniając optymalną prezentację idopasowanie do ich aplikacji.

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

Parameters

angle float

Kąt obrotowy w stopniach. wartości pozytywne będą obrotować zegarem.

resizeProportionally bool

Jeśli ustawisz na “prawdziwy”, zmienisz rozmiar obrazuw zależności od obrotowych projekcji rektangularnych (punktu węgielnego) w innym przypadku, które pozostawiają wymiary nie dotknięte i tylko wewnętrzne treści obrazów są obrotowane.

backgroundColor Color

Kolor z tła.

Examples

Ten przykład pokazuje, jak rotować wszystkie strony obrazu DICOM i zaoszczędzić je wszystkie do multi-frame TIFF obraz.

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)

Łatwo manipulować aktywnym ramy poprzez obrotowanie, flipping lub wykonywanie obu działańw tym samym czasie z tą prostą metodą. idealny dla deweloperów, którzy potrzebujądynamicznie dostosowywać orientację określonych ram w sekwencjach obrazu,Zapewniamy optymalną prezentację i dopasowanie.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Rodzaj rotacji flip.

Examples

Ten przykład ładuje obraz DICOM, rotuje go o 90 stopni w świetle zegara i opcjonalnie flips obraz horyzontalnie i (lub) pionowo.

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(Strumień, ImageOptionsBase, Rectangle)

Łatwo przechowywać dane obrazu do określonego strumienia w pożądanej formie plikuNiezależnie od tego, czy pracujesz z JPEG, PNG lub innym formatem,ta funkcja zapewnia, że Twoje dane obrazu są przechowywane skutecznie i dokładnie,sprawia, że jest idealny dla deweloperów, którzy chcą uprościć swoje procesy oszczędzania plików.

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

Parameters

stream Stream

Strumień do przechowywania danych obrazu do.

optionsBase ImageOptionsBase

Opcje oszczędnościowe.

boundsRectangle Rectangle

Zdjęcie docelowe ogranicza rektangle. ustawić pusty rektangle do użycia granic źródłowych.

Examples

Poniższy przykład pobiera obraz DICOM z pliku, a następnie przechowuje obraz do strumienia plików 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(strumień, ImageOptionsBase)

Przechowywać dane obiektu przez przechowywanie go do wyznaczonego pliku (indexer + nazwa plików)lokalizacja wraz z określonymi formatami plików i opcjami. idealny dla deweloperów, którzy chcąbezpieczne przechowywanie danych w różnych formach przy jednoczesnym utrzymaniu elastyczności i kontroliparametry oszczędnościowe.

public void SaveAll(string filePath, ImageOptionsBase options)

Parameters

filePath string

Droga do pliku.

options ImageOptionsBase

i opcji .

SaveData(Stream)

Oszczędzaj dane.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Przepływ do przechowywania danych do.

SetResolution(podwójne, podwójne)

Dostosuj rozdzielczość tego Aspose.Imaging.RasterImage z dokładnością za pomocą tegoIdealny dla deweloperów, którzy chcą dostosować rozdzielczość obrazu dospecyficzne wymagania, zapewniające optymalną jakość wyświetlania i zarządzanie rozmiarami plików.

public override void SetResolution(double dpiX, double dpiY)

Parameters

dpiX double

Rozdzielczość horyzontalna, w punktach na cala, Aspose.Imaging.RasterImage.

dpiY double

Rozdzielczość pionowa, w punktach na cala, Aspose.Imaging.RasterImage.

UpdateDimensions(i int, int)

Aktualizacja wymiarów obrazu.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Nowy widok obrazu.

newHeight int

Nowa wysokość obrazu.

 Polski