Aspose.Imaging by Aspose

<PackageReference Include="Aspose.Imaging" Version="24.3.0" />

---

API Diff between 24.3.0 and 20.8.0

751 Additions 125 Removals

Aspose.Imaging

• public abstract class Brush : DisposableObject
  • protected bool Equals(Brush other)
• public static class CmykColorHelper
  • public static byte[] ToCmykaBytes(int[] argbPixels, int startIndex, int length)
  • public static byte[] ToCmykaIccBytes(int[] pixels, int startIndex, int length, Stream rgbIccStream, Stream cmykIccStream)
  • public static int[] ToCmykIcc(int[] pixels, Stream rgbIccStream, Stream cmykIccStream)
  • public static int[] ToCmykIcc(int[] pixels)
  • public static int ToCmykIcc(int argb)
  • public static int ToCmykIcc(int argb, Stream rgbIccStream, Stream cmykIccStream)
  • public static int[] ToPsdCmykIcc(int[] pixels, Stream rgbIccStream, Stream cmykIccStream)
  • public static int[] ToPsdCmykIcc(int[] pixels)
  • public static int ToPsdCmykIcc(int argb)
  • public static int ToPsdCmykIcc(int pixel, Stream rgbIccStream, Stream cmykIccStream)
• public static class ColorPaletteHelper
  • public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount, PaletteMiningMethod paletteMiningMethod)
  • public static IColorPalette GetCloseImagePalette(RasterImage image, Rectangle destBounds, int entriesCount, bool useImagePalette, Color alphaBlendInColor)
  • public static IColorPalette GetCloseImagePalette(RasterImage image, Rectangle destBounds, int entriesCount, bool useImagePalette, Color alphaBlendInColor, bool keepTransparency)
  • public static IColorPalette GetCloseTransparentImagePalette(RasterImage image, int entriesCount)
• public sealed delegate CustomFontSource : MulticastDelegate
  • public CustomFontSource(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(object[] args, AsyncCallback callback, object object)
  • public virtual CustomFontData[] EndInvoke(IAsyncResult result)
  • public virtual CustomFontData[] Invoke(object[] args)
• public class CustomLineCap
  • protected bool Equals(CustomLineCap other)
• public abstract class DataStreamSupporter : DisposableObject
  • protected int Timeout
  • protected int timeout
  • protected virtual void DoAfterSave(Stream stream)
• public class EmbeddedImage : DisposableObject
  • public Image Image { get; }
• public enum FileFormat
  • BigTiff = 2147483648
  • Dxf = 33554432
  • Emz = 67108864
  • FOdg = 536870912
  • Ico = 256
  • Pdf = 128
  • Svgz = 268435456
  • Tga = 16777216
  • Undefined = 0
  • Unknown = 0
  • Wmz = 134217728
• public static class FontSettings
  • public static bool GetSystemAlternativeFont { get; set; }
• public sealed class Graphics
  • public ImageOptionsBase PaintableImageOptions { get; set; }
  • public SizeF MeasureString(string text, Font font, SizeF layoutArea, StringFormat stringFormat)
• public interface IAnimationFrame
  • bool UseAlphaBlending { get; }
• public abstract class Image : DataStreamSupporter, IObjectWithBounds, #=zgVGi8dddf2KDrBpwXNtIE7c$Rzhvm6HsMcdGeYeyPzPO, #=zJC7_UdDPJf7Rv1IJX$dSG2sl2L9fFOXPIvXIGqY=
  • public virtual bool UsePalette { get; }
  • protected static void DoAfterCreate(ref long maximum, long imageSize)
  • protected static void DoAfterLoad(ref long maximum, Stream stream)
  • public static Image Create(Image[] images)
  • public static Image Create(Image[] images, bool disposeImages)
  • protected virtual bool DoUseRecursion(ImageOperation operation)
  • protected virtual Image GetImage2Export(ImageOptionsBase optionsBase, Rectangle boundsRectangle)
  • protected virtual Image GetImage2Export(ImageOptionsBase optionsBase, Rectangle boundsRectangle, IImageExporter exporter)
• public interface IMultipageImage
  • Image DefaultPage { get; }
• public interface IMultipageImageExt : IMultipageImage
  • void AddPage(RasterImage page)
• public interface IRasterImageArgb64PixelLoader : IRasterImageRawDataLoader
  • void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)
• public class LoadOptions : #=zJC7_UdDPJf7Rv1IJX$dSG2sl2L9fFOXPIvXIGqY=
  • public void AddCustomFontSource(CustomFontSource source, object[] args)
• public abstract class ObjectWithBounds
  • protected bool Equals(ObjectWithBounds other)
• public enum PaletteMiningMethod
  • ColorClustering = 1
  • Histogram = 2
  • UseCurrentPalette = 0
• public class Pen : TransparencySupporter
  • protected bool Equals(Pen other)
• public class PixelDataFormat
  • public static PixelDataFormat Grayscale
  • public static readonly PixelDataFormat Grayscale16
  • public static PixelDataFormat Grayscale { get; }
• public struct Point
  • public static void FromLong(long packedPoint, out int x, out int y)
  • public long ToLong()
• public enum ProcessingType
  • Default = 0
  • Interlaced8 = 1
• public abstract class RasterCachedMultipageImage : RasterCachedImage, IMultipageImage
  • public abstract Image DefaultPage { get; }
• public abstract class RasterImage : Image, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, #=zRU7Eij5IwikWSPXpb18X3etNbG4V4M$6nw==
  • public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)
  • public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)
  • public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)
  • protected abstract void SavePixelsInternal(Rectangle rectangle, int[] pixels)
• public class RemoveBackgroundSettings
  • public RectangleF? Bounds { get; set; }
  • public Color? Color1 { get; set; }
  • public Color? Color2 { get; set; }
  • public int? DetectionLevel { get; set; }
  • public RemoveBackgroundSettings()
• public abstract class Shape : ObjectWithBounds
  • protected bool Equals(Shape other)
• public abstract class ShapeSegment
  • protected bool Equals(ShapeSegment other)
• public class StreamContainer : DisposableObject, #=zswfsZHK7I4Gld6tytcT3lzrdGx0GV4bK6DVVYZUqH6DAFqm81Q==
  • protected readonly long StartPosition
  • protected long startPosition
• public sealed class StringFormat : DisposableObject
  • public PointF CustomCharIdent { get; set; }
• public enum StringFormatFlags
  • ExactAlignment = 32768
• public class TransparencySupporter
  • protected bool Equals(TransparencySupporter other)
• public abstract class VectorImage : Image, IObjectWithSizeF
  • public virtual EmbeddedImage[] GetEmbeddedImages()
  • public void RemoveBackground()
  • public void RemoveBackground(RemoveBackgroundSettings settings)

Aspose.Imaging.AsyncTask

• public interface IAsyncTask : IAsyncResult, IDisposable
  • AsyncTaskProgress Progress { get; }
  • ProgressEventHandler ProgressEventHandler { get; set; }
  • void SetProgressCallback(ProgressCallback progressCallback)
• public interface IAsyncTaskState
  • AsyncTaskProgress Progress { get; }
  • void SetProgress(int progressPercentage)
  • EventType Progress { get; }
  • void IncrementProgressMaxValue(int value)
  • void IndicateProgress(EventType eventType)
• public sealed delegate ProgressCallback : MulticastDelegate

Aspose.Imaging.Brushes

• public sealed class LinearGradientBrush : LinearGradientBrushBase
  • public LinearGradientBrush()
  • public LinearGradientBrush(Point point1, Point point2, Color color1, Color color2)
  • public LinearGradientBrush(PointF point1, PointF point2, Color color1, Color color2)
  • public LinearGradientBrush(Rectangle rect, Color color1, Color color2, float angle)
  • public LinearGradientBrush(RectangleF rect, Color color1, Color color2, float angle)
  • public LinearGradientBrush(Rectangle rect, Color color1, Color color2, float angle, bool isAngleScalable)
  • public LinearGradientBrush(Rectangle rect, Color color1, Color color2, float angle, bool isAngleScalable)
  • public LinearGradientBrush(RectangleF rect, Color color1, Color color2, float angle)
  • public LinearGradientBrush(Rectangle rect, Color color1, Color color2, float angle)
  • public LinearGradientBrush(PointF point1, PointF point2, Color color1, Color color2)
  • public LinearGradientBrush(Point point1, Point point2, Color color1, Color color2)
  • public LinearGradientBrush()
• public sealed class TextureBrush : TransformBrush
  • public TextureBrush(Image image)
  • public TextureBrush(Image image, WrapMode wrapMode)
  • public TextureBrush(Image image, WrapMode wrapMode, RectangleF destinationRectangle)
  • public TextureBrush(Image image, WrapMode wrapMode, Rectangle destinationRectangle)
  • public TextureBrush(Image image, Rectangle destinationRectangle, ImageAttributes imageAttributes)
  • public TextureBrush(Image image, Rectangle destinationRectangle)
  • public TextureBrush(Image image, WrapMode wrapMode, Rectangle destinationRectangle)
  • public TextureBrush(Image image, WrapMode wrapMode, RectangleF destinationRectangle)
  • public TextureBrush(Image image, WrapMode wrapMode)
  • public TextureBrush(Image image)
  • public TextureBrush(Image image, Rectangle destinationRectangle)
  • public TextureBrush(Image image, Rectangle destinationRectangle, ImageAttributes imageAttributes)

Aspose.Imaging.CoreExceptions

• public class IncorrectPasswordException : Exception
  • public IncorrectPasswordException(string message)
  • public IncorrectPasswordException(string message, Exception innerException)

Aspose.Imaging.CustomFontHandler

• public class CustomFontData
  • public byte[] FontData { get; }
  • public string FontName { get; }
  • public CustomFontData(string fontName, byte[] fontData)

Aspose.Imaging.Exif

• public class ExifData : TiffDataTypeController
  • public string Make { get; set; }
  • public MakerNote[] MakerNotes { get; }
• public sealed class JpegExifData : ExifData
  • public string Make { get; set; }
• public class MakerNote
  • public string Name { get; }
  • public string Value { get; }

Aspose.Imaging.Extensions

• public static class FontExtensions
  • public static Font ToGdiFont(Font font, GraphicsUnit fontUnit)
  • public static Font ToGdiFont(Font font, GraphicsUnit fontUnit)

Aspose.Imaging.FileFormats.Apng

• public class ApngFrame : RasterCachedImage, IAnimationFrame
  • public bool UseAlphaBlending { get; }
• public sealed class ApngImage : RasterCachedMultipageImage, IMultipageImageExt, IMultipageImage
  • public void AddPage(RasterImage page)

Aspose.Imaging.FileFormats.BigTiff

• public sealed class BigTiffImage : TiffImage
  • public BigTiffImage(TiffFrame frame)
  • public BigTiffImage(TiffFrame[] frames)

Aspose.Imaging.FileFormats.Cdr.Const

• public enum CdrColorModel
  • Model0x0e = 14

Aspose.Imaging.FileFormats.Cdr.Objects

• public class CdrArtisticText : CdrGraphicObject
  • public int TextIndex { get; set; }
• public class CdrBmp : CdrDictionaryItem
  • public byte[] Data { get; set; }
• public class CdrDocument : CdrObjectContainer
  • public List<short> ClipIds { get; set; }
  • public int LastTextIndex { get; set; }
  • public SortedDictionary<short, CdrListObjects> PowerClips { get; set; }
  • public List<CdrSpnd> TextIndexes { get; }
  • public Dictionary<int, CdrText> Texts { get; }
  • public CdrTextCollection Texts { get; }
• public abstract class CdrGraphicObject : CdrObject
  • public short ClipId { get; set; }
• public class CdrListObjects : CdrObjectContainer
  • public int OpacityFillId { get; set; }
• public abstract class CdrObjectContainer : CdrObject
  • public bool Hidden { get; set; }
• public class CdrParagraph : CdrGraphicObject
  • public double Height { get; set; }
  • public double Width { get; set; }
  • public int TextIndex { get; set; }
• public class CdrPattern : CdrDictionaryItem
  • public byte[] Data { get; set; }
• public class CdrStyle : CdrDictionaryItem
  • public CdrStyle Copy()
• public class CdrTransforms : CdrObject
  • public List<   > Transforms { get; set; }
  • public List<#=zLlgIJC7JLyiRDwvS6F5hUws=> Transforms { get; set; }

Aspose.Imaging.FileFormats.Cdr.Types

• public class CdrTextCollection
  • public CdrTextCollection()
  • public void Add(int key, CdrText cdrText)
  • public CdrText[] GetText(int key)

Aspose.Imaging.FileFormats.Cmx.ObjectModel

• public abstract class CmxContainer : ICmxContainer, ICmxDocElement
  • protected bool Equals(CmxContainer other)
• public class CmxGroup : CmxContainer
  • protected bool Equals(CmxGroup other)
• public class CmxLayer : CmxContainer
  • protected bool Equals(CmxLayer other)
• public class CmxObject : ICmxDocElement
  • protected bool Equals(CmxObject other)
• public class CmxPage
  • protected bool Equals(CmxPage other)
• public class CmxProcedure : CmxContainer
  • protected bool Equals(CmxProcedure other)

Aspose.Imaging.FileFormats.Cmx.ObjectModel.Enums

• public enum ColorModels
  • BGR = 12
  • LAB255 = 13

Aspose.Imaging.FileFormats.Cmx.ObjectModel.Specs

• public class CmxArrowSpec : CmxPathSpec
  • protected bool Equals(CmxArrowSpec other)
• public class CmxEllipseSpec : ICmxObjectSpec
  • public RectangleF BoundingBox { get; set; }
  • protected bool Equals(CmxEllipseSpec other)
• public class CmxImageSpec : ICmxObjectSpec
  • public bool IsCmx3Image { get; set; }
  • protected bool Equals(CmxImageSpec other)
• public class CmxPathPointSpec
  • protected bool Equals(CmxPathPointSpec other)
• public class CmxPathSpec : ICmxObjectSpec
  • public int Type { get; set; }
  • protected bool Equals(CmxPathSpec other)
• public class CmxRasterImage : ICmxObjectSpec
  • protected bool Equals(CmxRasterImage other)
• public class CmxRectangleSpec : ICmxObjectSpec
  • protected bool Equals(CmxRectangleSpec other)
• public class CmxTextBlockSpec : ICmxObjectSpec
  • protected bool Equals(CmxTextBlockSpec other)

Aspose.Imaging.FileFormats.Cmx.ObjectModel.Styles

• public class CmxColor
  • protected bool Equals(CmxColor other)
• public class CmxFillStyle
  • protected bool Equals(CmxFillStyle other)
• public class CmxGradient
  • protected bool Equals(CmxGradient other)
• public class CmxImageFill
  • protected bool Equals(CmxImageFill other)
• public class CmxOutline
  • protected bool Equals(CmxOutline other)
• public class CmxParagraphStyle
  • protected bool Equals(CmxParagraphStyle other)

Aspose.Imaging.FileFormats.Core.VectorPaths

• public class BezierKnotRecord : VectorPathRecord
  • public bool IsClosed { get; set; }
  • public bool IsLinked { get; set; }
  • public bool IsOpen { get; set; }
  • public PointF[] PathPoints { get; set; }
  • public Point[] Points { get; set; }
  • public BezierKnotRecord()
  • public BezierKnotRecord(byte[] data)
• public class ClipboardRecord : VectorPathRecord
  • public RectangleF BoundingRect { get; set; }
  • public float Resolution { get; set; }
  • public ClipboardRecord()
  • public ClipboardRecord(byte[] data)
• public class InitialFillRuleRecord : VectorPathRecord
  • public bool IsFillStartsWithAllPixels { get; set; }
  • public InitialFillRuleRecord()
  • public InitialFillRuleRecord(bool isFillStartsWithAllPixels)
  • public InitialFillRuleRecord(byte[] data)
• public interface IVectorPathData
  • bool IsDisabled { get; set; }
  • bool IsInverted { get; set; }
  • bool IsNotLinked { get; set; }
  • VectorPathRecord[] Paths { get; set; }
  • int Version { get; set; }
• public class LengthRecord : VectorPathRecord
  • public int BezierKnotRecordsCount { get; set; }
  • public bool IsClosed { get; set; }
  • public bool IsOpen { get; set; }
  • public PathOperations PathOperations { get; set; }
  • public ushort RecordCount { get; set; }
  • public ushort ShapeIndex { get; set; }
  • public LengthRecord(byte[] data)
  • public LengthRecord()
• public class PathFillRuleRecord : VectorPathRecord
  • public PathFillRuleRecord()
  • public PathFillRuleRecord(byte[] data)
• public enum PathOperations
  • CombineShapes = 1
  • ExcludeOverlappingShapes = 0
  • IntersectShapeAreas = 3
  • SubtractFrontShape = 2
• public abstract class VectorPathRecord
  • public abstract VectorPathType Type { get; }
  • protected VectorPathRecord()
• public class VectorPathRecordFactory
  • public VectorPathRecordFactory()
  • public VectorPathRecord ProducePathRecord(byte[] data)
• public enum VectorPathType
  • ClipboardRecord = 7
  • ClosedSubpathBezierKnotLinked = 1
  • ClosedSubpathBezierKnotUnlinked = 2
  • ClosedSubpathLengthRecord = 0
  • InitialFillRuleRecord = 8
  • OpenSubpathBezierKnotLinked = 4
  • OpenSubpathBezierKnotUnlinked = 5
  • OpenSubpathLengthRecord = 3
  • PathFillRuleRecord = 6

Aspose.Imaging.FileFormats.Dicom

• public enum ColorType
  • Grayscale16Bit = 1
  • Grayscale8Bit = 0
  • Rgb24Bit = 2
• public class Compression
  • public JpegOptions Jpeg { get; set; }
  • public Jpeg2000Options Jpeg2000 { get; set; }
  • public CompressionType Type { get; set; }
  • public Compression()
• public enum CompressionType
  • Jpeg = 1
  • Jpeg2000 = 2
  • None = 0
  • Rle = 3
• public sealed class DicomImage : RasterCachedMultipageImage, IMultipageImageExt, IMultipageImage
  • public void AddPage(RasterImage page)

Aspose.Imaging.FileFormats.Emf

• public sealed class EmfImage : MetaImage
  • public EmfImage(int width, int height)

Aspose.Imaging.FileFormats.Emf.Emf.Records

• public sealed class EmfSetMapMode : EmfRecord
  • public EmfSetMapMode()

Aspose.Imaging.FileFormats.Emf.Graphics

• public abstract class MetafileRecorderGraphics2D
  • public void DrawImage(Stream stream, Rectangle destRect, GraphicsUnit srcUnit)

Aspose.Imaging.FileFormats.Eps

• public class EpsBinaryImage : EpsImage
• public sealed class EpsImage : VectorImage
  • public Point BoundingBoxBottomLeft { get; }
  • public string BoundingBoxString { get; }
  • public Point BoundingBoxTopRight { get; }
  • public RectangleF BoundingBox { get; }
  • public Rectangle BoundingBoxPx { get; }
  • public string CreationDateString { get; }
  • public int? PageNumber { get; }
  • public int? PagesCount { get; }
  • public JpegImage PhotoshopThumbnail { get; }
  • public EpsPreviewFormat PreviewToExport { get; set; }
  • public int PreviewImageCount { get; }
  • public Image[] PreviewImages { get; }
  • protected EpsImage(bool initialize)
  • protected abstract void FinalizePhotoshopThumbnail()
  • protected abstract List<Image> GetPreviewImages()
  • protected Image RenderPostScript(ImageOptionsBase optionsBase = null)
  • protected abstract void SetSpecificRasterPreview(Image image)
  • public Image GetPreviewImage(EpsPreviewFormat format = 0)
  • public IEnumerable<Image> GetPreviewImages()
• public class EpsInterchangeImage : EpsImage
• public class EpsLoadOptions : LoadOptions
  • public EpsPreviewFormat PreviewExportFormat { get; set; }
• public enum EpsPreviewFormat
  • PostScriptRendering = 4

Aspose.Imaging.FileFormats.Gif

• public sealed class GifImage : RasterCachedMultipageImage, IMultipageImageExt, IMultipageImage, #=zlfWtl_vgzlf0he3aqQ5ry6E3qqMlCE1iBjgV0gb11qZH
  • public bool IsInterlaced { get; }
  • public int LoopsCount { get; set; }
  • public void AddPage(RasterImage page)
  • public void ResizeFullFrame(int newWidth, int newHeight, ResizeType resizeType)
  • public void SetFrameTime(ushort time)

Aspose.Imaging.FileFormats.Gif.Blocks

• public sealed class GifFrameBlock : RasterCachedImage, IGifBlock, IAnimationFrame, #=zlfWtl_vgzlf0he3aqQ5ry6E3qqMlCE1iBjgV0gb11qZH
  • public bool IsInterlaced { get; }
  • public bool UseAlphaBlending { get; }

Aspose.Imaging.FileFormats.Ico

• public class IcoImage : RasterCachedMultipageImage, IMultipageImageExt, IMultipageImage
  • public IcoImage(int width, int height, IcoOptions options)
  • public IcoImage(Image image, IcoOptions icoOptions)
  • public void AddPage(RasterImage page)
  • public void AddPage(Image page)
  • public void AddPage(Image page, IcoOptions icoOptions)
  • public void RemovePage(int index)

Aspose.Imaging.FileFormats.OpenDocument

• public class OdgImage : OdImage
  • public OdgImage(StreamContainer streamContainer, LoadOptions options)
• public abstract class OdImage : VectorMultipageImage, #=zfQ6sFbneMiq5TtagK5RAdV0XpQEZa5aSa0Clwn7vihRL
  • public OdImage(StreamContainer streamContainer, LoadOptions options)
• public class OtgImage : OdImage
  • public OtgImage(StreamContainer streamContainer, LoadOptions loadOptions)

Aspose.Imaging.FileFormats.OpenDocument.Enums

• public enum OdTextAlignModeFlags
  • Justify = 4

Aspose.Imaging.FileFormats.Pdf

• public class PdfCoreOptions
  • public PdfImageCompressionOptions Compression { get; set; }

Aspose.Imaging.FileFormats.Png

• public class PngImage : RasterCachedImage, #=zlfWtl_vgzlf0he3aqQ5ry6E3qqMlCE1iBjgV0gb11qZH
  • public bool IsInterlaced { get; }

Aspose.Imaging.FileFormats.Psd

• public enum VectorDataCompositionMode
  • SeparateLayers = 1
  • SingleSmartObject = 0

Aspose.Imaging.FileFormats.Psd.Layers.LayerResources.VectorPaths

• public class BezierKnotRecord : VectorPathRecord
• public class ClipboardRecord : VectorPathRecord
• public class InitialFillRuleRecord : VectorPathRecord
• public class LengthRecord : VectorPathRecord
• public class PathFillRuleRecord : VectorPathRecord
• public abstract class VectorPathRecord
• public class VectorPathRecordFactory
• public enum VectorPathType

Aspose.Imaging.FileFormats.Tga

• public class TgaImage : RasterCachedImage
  • public string AuthorComments { get; set; }
  • public string AuthorName { get; set; }
  • public int BytesPerPixel { get; }
  • public DateTime? DateTimeStamp { get; set; }
  • public ushort GammaValueDenominator { get; }
  • public ushort GammaValueNumerator { get; }
  • public bool HasColorMap { get; }
  • public string ImageId { get; set; }
  • public bool IsGrayScale { get; }
  • public string JobNameOrId { get; set; }
  • public TimeSpan? JobTime { get; set; }
  • public ushort PixelAspectRatioDenominator { get; }
  • public ushort PixelAspectRatioNumerator { get; }
  • public string SoftwareId { get; set; }
  • public string SoftwareVersion { get; set; }
  • public char SoftwareVersionLetter { get; set; }
  • public ushort SoftwareVersionNumber { get; set; }
  • public ushort XOrigin { get; set; }
  • public ushort YOrigin { get; set; }
  • public TgaImage(string path)
  • public TgaImage(RasterImage rasterImage)
  • public TgaImage(Stream stream)
  • public static bool op_Equality(TgaImage first, TgaImage second)
  • public static bool op_Inequality(TgaImage first, TgaImage second)
  • public TgaImage Clone()
  • public void Clone(TgaImage tgaImage)
  • public bool Equals(TgaImage other)

Aspose.Imaging.FileFormats.Tiff

• public abstract class TiffDataType : IComparable
  • public uint AlignedDataSize { get; }
  • public abstract uint Count { get; }
  • public abstract uint DataSize { get; }
  • public abstract ulong Count { get; }
  • public virtual ulong DataSize { get; }
  • public virtual byte ElementSize { get; }
  • public virtual ulong GetAdditionalDataSize(byte sizeOfTagValue)
  • public ulong GetAlignedDataSize(byte sizeOfTagValue)
• public class TiffImage : RasterCachedMultipageImage, IMultipageImageExt, IMultipageImage
  • public virtual void AddPage(RasterImage page)

Aspose.Imaging.FileFormats.Tiff.Enums

• public enum TiffDataTypes
  • IFD8 = 18
  • Long8 = 16
  • SLong8 = 17
• public enum TiffExpectedFormat
  • TiffDeflateCmyk = 11
  • TiffDeflateCmyka = 12
  • TiffLzwCmyka = 5
  • TiffNoCompressionCmyk = 19
  • TiffNoCompressionCmyka = 20

Aspose.Imaging.FileFormats.Tiff.FileManagement

• public static class TiffStreamFactory
  • public static TiffStreamReader GetTiffReader(StreamContainer stream, TiffByteOrder byteOrder)
  • public static TiffStreamReader GetTiffReader(byte[] bytes, int bytesOffset, int dataLength, TiffByteOrder byteOrder)
  • public static TiffStreamWriter GetTiffWriter(StreamContainer stream, TiffByteOrder byteOrder)
  • public static TiffStreamReader GetTiffReader(StreamContainer stream, TiffByteOrder byteOrder, bool isBigTiff = false)
  • public static TiffStreamReader GetTiffReader(byte[] bytes, int bytesOffset, int dataLength, TiffByteOrder byteOrder, bool isBigTiff = false)
  • public static TiffStreamWriter GetTiffWriter(StreamContainer stream, TiffByteOrder byteOrder, bool isBigTiff = false)
• public class TiffStreamReader : #=zng3S2m_DBE_10iPkCYei79btiKgVu2$tq0dmEPh8tXQo2os$Xpo1aRU=
  • protected virtual int[] ProcessReadDataLong(byte[] data)
  • protected virtual int[] ProcessReadDataInt(byte[] data)
  • protected virtual long[] ProcessReadDataLong(byte[] data)
  • protected virtual uint[] ProcessReadDataULong(byte[] data)
  • protected virtual uint[] ProcessReadDataUInt(byte[] data)
  • protected virtual ulong[] ProcessReadDataULong(byte[] data)
  • public long ReadLong(long position)
  • public long[] ReadLongArray(long position, long count)
  • public int ReadSLong(long position)
  • public int[] ReadSLongArray(long position, long count)
  • public int ReadSInt(long position)
  • public int[] ReadSIntArray(long position, long count)
  • public uint ReadULong(long position)
  • public uint[] ReadULongArray(long position, long count)
  • public uint ReadUInt(long position)
  • public uint[] ReadUIntArray(long position, long count)
  • public ulong ReadULong(long position)
  • public ulong[] ReadULongArray(long position, long count)
• public class TiffStreamWriter : #=zng3S2m_DBE_10iPkCYei79btiKgVu2$tq0dmEPh8tXQo2os$Xpo1aRU=, #=zswfsZHK7I4Gld6tytcT3lzrdGx0GV4bK6DVVYZUqH6DAFqm81Q==
  • protected virtual void ProcessWriteDataLong(int[] data, byte[] dest)
  • protected virtual void ProcessWriteDataInt(int[] data, byte[] dest)
  • protected virtual void ProcessWriteDataLong(long[] data, byte[] dest)
  • protected virtual void ProcessWriteDataULong(uint[] data, byte[] dest)
  • protected virtual void ProcessWriteDataUInt(uint[] data, byte[] dest)
  • protected virtual void ProcessWriteDataULong(ulong[] data, byte[] dest)
  • public void Write(MemoryStream stream)
  • public void WriteDouble(double data)
  • public void WriteDoubleArray(double[] data)
  • public void WriteFloat(float data)
  • public void WriteFloatArray(float[] data)
  • public void WriteRational(TiffRational data)
  • public void WriteRationalArray(TiffRational[] data)
  • public void WriteSByte(sbyte data)
  • public void WriteSByteArray(sbyte[] data)
  • public void WriteSlong(int data)
  • public void WriteSLongArray(int[] data)
  • public void WriteSRational(TiffSRational data)
  • public void WriteSRationalArray(TiffSRational[] data)
  • public void WriteSShort(short data)
  • public void WriteSShortArray(short[] data)
  • public void WriteUByte(byte data)
  • public void WriteULong(uint data)
  • public void WriteULongArray(uint[] data)
  • public void WriteUShort(ushort data)
  • public void WriteUShortArray(ushort[] data)
  • public void Write(double data)
  • public void Write(double[] data)
  • public void Write(float data)
  • public void Write(float[] data)
  • public void Write(TiffRational data)
  • public void Write(TiffSRational data)
  • public void Write(TiffRational[] data)
  • public void Write(TiffSRational[] data)
  • public void Write(sbyte data)
  • public void Write(sbyte[] data)
  • public void Write(int[] data)
  • public void Write(short data)
  • public void Write(short[] data)
  • public void Write(int data)
  • public void Write(byte data)
  • public void Write(uint data)
  • public void Write(uint[] data)
  • public void Write(ushort data)
  • public void Write(ushort[] data)
  • public void Write(long data)
  • public void Write(long[] data)
  • public void Write(ulong data)
  • public void Write(ulong[] data)

Aspose.Imaging.FileFormats.Tiff.FileManagement.BigTiff

• public class BigTiffReader : TiffStreamReader
  • public BigTiffReader(byte[] data)
  • public BigTiffReader(StreamContainer streamContainer)
  • public BigTiffReader(byte[] data, int startIndex)
  • public BigTiffReader(byte[] data, int startIndex, int dataLength)
• public class BigTiffReaderBE : TiffBigEndianStreamReader
  • public BigTiffReaderBE(byte[] data)
  • public BigTiffReaderBE(StreamContainer streamContainer)
  • public BigTiffReaderBE(byte[] data, int startIndex)
  • public BigTiffReaderBE(byte[] data, int startIndex, int dataLength)
• public class BigTiffWriter : TiffStreamWriter
  • public BigTiffWriter(StreamContainer writer)
• public class BigTiffWriterBE : TiffBigEndianStreamWriter
  • public BigTiffWriterBE(StreamContainer writer)

Aspose.Imaging.FileFormats.Tiff.PathResources

• public class PathResource
  • public List<VectorPathRecord> Records { get; set; }
  • public List<VectorPathRecord> Records { get; set; }

Aspose.Imaging.FileFormats.Tiff.TiffTagTypes

• public abstract class TiffCommonArrayType : TiffDataType
  • public abstract uint ElementSize { get; }
• public class TiffIfd8Type : TiffLong8Type
  • public TiffIfd8Type(ushort tagId)
  • public TiffIfd8Type(TiffTags tagId)
• public class TiffLong8Type : TiffCommonArrayType
  • public ulong[] Values { get; set; }
  • public TiffLong8Type(ushort tagId)
  • public TiffLong8Type(TiffTags tagId)
• public class TiffSLong8Type : TiffCommonArrayType
  • public long[] Values { get; set; }
  • public TiffSLong8Type(ushort tagId)
  • public TiffSLong8Type(TiffTags tagId)
• public sealed class TiffUnknownType : TiffDataType
  • public uint OffsetOrValue { get; }
  • public ulong OffsetOrValue { get; }
  • public TiffUnknownType(TiffStreamReader stream, ushort tagType, ushort tagId, uint count, uint offsetOrValue)
  • public TiffUnknownType(TiffStreamReader stream, ushort tagType, ushort tagId, ulong count, ulong offsetOrValue)

Aspose.Imaging.FileFormats.Webp

• public class WebPFrameBlock : RasterCachedImage, IFrame, IAnimationFrame
  • public bool UseAlphaBlending { get; set; }
• public sealed class WebPImage : RasterCachedMultipageImage, IMultipageImageExt, IMultipageImage
  • public void AddPage(RasterImage page)

Aspose.Imaging.FileFormats.Wmf.Objects

• public class WmfDeviceIndependentBitmap : MetaObject
  • public MemoryStream CachedImage { get; set; }
  • public byte[] CachedImage { get; set; }

Aspose.Imaging.ImageFilters.ComplexUtils

• public struct Complex : IEquatable<Complex>
  • public static readonly Complex I
  • public static readonly Complex One
  • public static readonly int SizeOfComplex
  • public static readonly int SizeOfDouble
  • public static readonly Complex Zero
  • public double Im { get; set; }
  • public double Magnitude { get; }
  • public double Phase { get; }
  • public double Re { get; set; }
  • public double SquaredMagnitude { get; }
  • public Complex(double real, double imaginary)
  • public Complex(Complex c)
  • public static Complex Add(Complex a, Complex b)
  • public static Complex Add(Complex a, double s)
  • public static void Add(Complex a, Complex b, ref Complex result)
  • public static void Add(Complex a, double s, ref Complex result)
  • public static bool ApproxEqual(Complex a, Complex b)
  • public static bool ApproxEqual(Complex a, Complex b, double tolerance)
  • public static Complex Cos(Complex a)
  • public static Complex Divide(Complex a, Complex b)
  • public static Complex Divide(Complex a, double s)
  • public static Complex Divide(double s, Complex a)
  • public static void Divide(Complex a, Complex b, ref Complex result)
  • public static void Divide(Complex a, double s, ref Complex result)
  • public static void Divide(double s, Complex a, ref Complex result)
  • public static Complex Exp(Complex a)
  • public static Complex Log(Complex a)
  • public static Complex Multiply(Complex a, Complex b)
  • public static Complex Multiply(Complex a, double s)
  • public static void Multiply(Complex a, Complex b, ref Complex result)
  • public static void Multiply(Complex a, double s, ref Complex result)
  • public static Complex Negate(Complex a)
  • public static Complex op_Addition(Complex a, Complex b)
  • public static Complex op_Addition(Complex a, double s)
  • public static Complex op_Addition(double s, Complex a)
  • public static Complex op_Division(Complex a, Complex b)
  • public static Complex op_Division(Complex a, double s)
  • public static Complex op_Division(double s, Complex a)
  • public static bool op_Equality(Complex a, Complex b)
  • public static Complex op_Explicit(double value)
  • public static Complex op_Explicit(float value)
  • public static bool op_Inequality(Complex a, Complex b)
  • public static Complex op_Multiply(Complex a, Complex b)
  • public static Complex op_Multiply(double s, Complex a)
  • public static Complex op_Multiply(Complex a, double s)
  • public static Complex op_Subtraction(Complex a, Complex b)
  • public static Complex op_Subtraction(Complex a, double s)
  • public static Complex op_Subtraction(double s, Complex a)
  • public static Complex op_UnaryNegation(Complex a)
  • public static Complex Parse(string s)
  • public static Complex Sin(Complex a)
  • public static Complex Sqrt(Complex a)
  • public static Complex Subtract(Complex a, Complex b)
  • public static Complex Subtract(Complex a, double s)
  • public static Complex Subtract(double s, Complex a)
  • public static void Subtract(Complex a, Complex b, ref Complex result)
  • public static void Subtract(Complex a, double s, ref Complex result)
  • public static void Subtract(double s, Complex a, ref Complex result)
  • public static Complex Tan(Complex a)
  • public static bool TryParse(string s, out Complex result)
  • public Complex Clone()
  • public bool Equals(Complex other)

Aspose.Imaging.ImageFilters.Convolution

• public class ConvolutionFilter
  • public static double[,] Emboss3x3 { get; }
  • public static double[,] Emboss5x5 { get; }
  • public static double[,] Sharpen3x3 { get; }
  • public static double[,] Sharpen5x5 { get; }
  • public static double[,] GetBlurBox(int size)
  • public static double[,] GetBlurMotion(int size, double angle)
  • public static double[,] GetGaussian(int size, double sigma)
  • public static Complex[,] ToComplex(double[,] kernel)

Aspose.Imaging.ImageFilters.FilterOptions

• public class ConvolutionFilterOptions : FilterOptionsBase, #=zywPjyh0hz7RI2ur1SM2o2GdXz$RmGIK0BelfGj$LA0SibJipEI9ORZ5vfh_jLtGCug==, #=zZGmd8vnLYOXK435ejAWz0K_GzEy3_AW69E575SudaNYzxNyxi6fhfTs=<double[,]>
  • protected const byte MinSize = 3
  • public virtual double[,] Kernel { get; }
  • public ConvolutionFilterOptions(double[,] kernel, double factor = 1, int bias = 0)
• public class DeconvolutionFilterOptions : FilterOptionsBase, #=ztU7GiIPahk7Ms1c0o9ejIus0jFQ45$6U$w6lOYjieNr0n4MNX52NwH1DhmRhVMSLHfywBfk=, #=zZGmd8vnLYOXK435ejAWz0K_GzEy3_AW69E575SudaNYzxNyxi6fhfTs=<Complex[,]>
  • public virtual Complex[,] Kernel { get; }
  • public DeconvolutionFilterOptions(double[,] kernel)
  • public DeconvolutionFilterOptions(Complex[,] kernel)
• public class GaussianBlurFilterOptions : ConvolutionFilterOptions, #=zkzMj7QSQ7s97xG4_mKKHTWOpNC4lHpKxmf$ZhIzjS0W1CITyuSDbSXH6THAf7ygE9X5V6wTUDonUTRmhbq$26xg=, #=z5shzx4qFa_eFFaIm3ee7bEJpaQA9DnoxiHQ_1W9rbf0$YejJhDO11OlDrIpyh0xa42yIZWo=
  • protected const double DefaultSigma = 1
  • protected const byte DefaultSize = 5
  • public virtual int Size { get; set; }
• public abstract class GaussianDeconvolutionFilterOptions : DeconvolutionFilterOptions, #=zkzMj7QSQ7s97xG4_mKKHTWOpNC4lHpKxmf$ZhIzjS0W1CITyuSDbSXH6THAf7ygE9X5V6wTUDonUTRmhbq$26xg=, #=z5shzx4qFa_eFFaIm3ee7bEJpaQA9DnoxiHQ_1W9rbf0$YejJhDO11OlDrIpyh0xa42yIZWo=
  • public int Radius { get; set; }
  • public double Sigma { get; set; }
  • public int Size { get; set; }
  • public GaussianDeconvolutionFilterOptions(int size, double sigma)
  • protected GaussianDeconvolutionFilterOptions()
• public class GaussWienerFilterOptions : GaussianDeconvolutionFilterOptions
  • public int Radius { get; set; }
  • public double Smooth { get; set; }
• public class MotionWienerFilterOptions : GaussianDeconvolutionFilterOptions
  • public int Length { get; set; }
  • public double Smooth { get; set; }
• public class SharpenFilterOptions : GaussianBlurFilterOptions
  • public double Sigma { get; set; }
  • public int Size { get; set; }

Aspose.Imaging.ImageLoadOptions

• public class CdrLoadOptions : LoadOptions
  • public bool OptimalMemoryUsage { get; set; }
• public class CmxLoadOptions : LoadOptions
  • public bool OptimalMemoryUsage { get; set; }
  • public CmxLoadOptions()
• public class DngLoadOptions : LoadOptions
  • public bool AdjustWhiteBalance { get; set; }
• public class Jpeg2000LoadOptions : LoadOptions
  • public int MaximumDecodingTimeForTile { get; set; }
• public class OdLoadOptions : LoadOptions
  • public string Password { get; set; }
  • public OdLoadOptions()

Aspose.Imaging.ImageOptions

• public sealed class BigTiffOptions : TiffOptions
  • public BigTiffOptions(TiffExpectedFormat expectedFormat)
  • public BigTiffOptions(TiffOptions options)
  • public BigTiffOptions(TiffDataType[] tags)
  • public BigTiffOptions(TiffExpectedFormat expectedFormat, TiffByteOrder byteOrder)
• public class CdrRasterizationOptions : VectorRasterizationOptions
  • public PositioningTypes Positioning { get; set; }
  • public float ScaleX { get; set; }
  • public float ScaleY { get; set; }
• public class CmxRasterizationOptions : VectorRasterizationOptions
  • public PositioningTypes Positioning { get; set; }
• public class DicomOptions : ImageOptionsBase
  • public ColorType ColorType { get; set; }
  • public Compression Compression { get; set; }
• public class DxfOptions : ImageOptionsBase
  • public byte BezierPointCount { get; set; }
  • public bool ConvertTextBeziers { get; set; }
  • public bool TextAsLines { get; set; }
  • public DxfOptions()
• public class EpsRasterizationOptions : VectorRasterizationOptions
  • public EpsPreviewFormat PreviewToExport { get; set; }
• public class GifOptions : ImageOptionsBase
  • public Color BackgroundColor { get; set; }
  • public bool HasTransparentColor { get; set; }
  • public int LoopsCount { get; set; }
• public class GraphicsOptions
• public class IcoOptions : ImageOptionsBase
  • public int BitsPerPixel { get; set; }
  • public FileFormat Format { get; set; }
  • public IcoOptions()
  • public IcoOptions(FileFormat format, int bitsPerPixel = 32)
• public enum MultiPageMode
  • TimeInterval = 3
• public class MultiPageOptions
  • public VectorRasterizationOptions[] PageRasterizationOptions { get; set; }
  • public TimeInterval TimeInterval { get; set; }
• public enum PdfImageCompressionOptions
  • Auto = 0
  • Ccitt3 = 7
  • Ccitt4 = 8
  • Flate = 3
  • Jpeg = 6
  • LzwBaselinePredictor = 4
  • LzwOptimizedPredictor = 5
  • None = 1
  • Rle = 2
• public class PdfOptions : ImageOptionsBase
  • public bool UseOriginalImageResolution { get; set; }
• public class PngOptions : ImageOptionsBase
  • public const int DefaultCompressionLevel = 6
• public class PsdOptions : ImageOptionsBase
  • public PsdVectorizationOptions VectorizationOptions { get; set; }
• public class PsdVectorizationOptions
  • public VectorDataCompositionMode VectorDataCompositionMode { get; set; }
  • public PsdVectorizationOptions()
• public class TgaOptions : ImageOptionsBase
  • public TgaOptions()
  • public TgaOptions(TgaOptions tgaOptions)
• public class TiffOptions : ImageOptionsBase
  • public int CompressedQuality { get; set; }
  • public bool DisableIccExport { get; set; }
  • public ushort[] ExtraSamples { get; }
  • public uint[] StripByteCounts { get; set; }
  • public uint[] StripOffsets { get; set; }
  • public ulong[] StripByteCounts { get; set; }
  • public ulong[] StripOffsets { get; set; }
  • public int TagCount { get; }
  • public uint[] TileByteCounts { get; set; }
  • public ulong[] TileByteCounts { get; set; }
  • public uint[] TileOffsets { get; set; }
  • public ulong[] TileOffsets { get; set; }
  • public bool RemoveTags(TiffTags[] tags)
• public class TiffOptionsUtils
• public class TimeInterval
  • public uint From { get; set; }
  • public uint To { get; set; }
  • public TimeInterval(uint from, uint to)
• public class VectorRasterizationOptions : ImageOptionsBase
  • public PositioningTypes Positioning { get; set; }
  • public Dictionary<string, string> ReplaceTextMapping { get; set; }

Aspose.Imaging.MagicWand

• public enum ColorComparisonMode
  • Custom = 3
  • RgbDefault = 0
  • YuvDefault = 1
  • YuvLessLumaSensitive = 2
• public struct ColorYUV
  • public double U { get; }
  • public double V { get; }
  • public double Y { get; }
  • public ColorYUV(int Y, int U, int V)
  • public ColorYUV(Color color)
• public enum FloodFillDirectionalMode
  • EightDirectional = 1
  • FourDirectional = 0
• public class MagicWandSettings
  • public sealed delegate ColorComparison : MulticastDelegate
  • public Rectangle AreaOfInterest { get; set; }
  • public ColorComparisonMode ColorCompareMode { get; set; }
  • public ColorComparison ColorComparisonDelegate { get; set; }
  • public bool ContiguousMode { get; set; }
  • public FloodFillDirectionalMode DirectionalMode { get; set; }
  • public Point Point { get; }
  • public int Threshold { get; set; }
  • public MagicWandSettings(Point point)
  • public MagicWandSettings(int x, int y)
• public class MagicWandTool : IPartialArgb32PixelLoader
  • public static ImageBitMask Select(RasterImage source, MagicWandSettings settings)
  • public void Process(Rectangle pixelsRectangle, int[] pixels, Point start, Point end)
• public static class RasterImageExtension
  • public static void ApplyMask(RasterImage image, IImageMask mask)
  • public static ImageBitMask SelectMask(RasterImage source, MagicWandSettings settings = null)

Aspose.Imaging.MagicWand.ImageMasks

• public class CircleMask : ImageMask
  • public CircleMask(int x, int y, int radius)
  • public CircleMask(Point center, int radius)
• public class EmptyImageMask : ImageMask
  • public EmptyImageMask(int width, int height)
• public enum FeatheringMode
  • Adjusted = 2
  • MathematicallyCorrect = 1
  • None = 0
• public class FeatheringSettings
  • public FeatheringMode Mode { get; set; }
  • public int Size { get; set; }
  • public FeatheringSettings()
• public interface IImageMask : ICloneable
  • Rectangle Bounds { get; }
  • int Height { get; }
  • Rectangle SelectionBounds { get; }
  • RasterImage Source { get; }
  • int Width { get; }
  • byte GetByteOpacity(int x, int y)
  • bool IsOpaque(int x, int y)
  • bool IsTransparent(int x, int y)
• public class ImageBitMask : ImageMask
  • public ImageBitMask(int width, int height)
  • public ImageBitMask(RasterImage image)
  • public static ImageBitMask op_Addition(ImageBitMask a, ImageBitMask b)
  • public static ImageBitMask op_ExclusiveOr(ImageBitMask a, ImageBitMask b)
  • public static ImageBitMask op_LogicalNot(ImageBitMask a)
  • public static ImageBitMask op_Multiply(ImageBitMask a, ImageBitMask b)
  • public static ImageBitMask op_Subtraction(ImageBitMask a, ImageBitMask b)
  • public void SetMaskPixel(int x, int y, bool value)
• public class ImageGrayscaleMask : IImageMask, ICloneable
  • public Rectangle Bounds { get; }
  • public int Height { get; }
  • public byte this[int x, int y] { get; set; }
  • public Rectangle SelectionBounds { get; }
  • public RasterImage Source { get; }
  • public int Width { get; }
  • public ImageGrayscaleMask(int width, int height)
  • public ImageGrayscaleMask(RasterImage image)
  • public static ImageGrayscaleMask op_Addition(ImageGrayscaleMask a, ImageGrayscaleMask b)
  • public static ImageGrayscaleMask op_ExclusiveOr(ImageGrayscaleMask a, ImageGrayscaleMask b)
  • public static ImageGrayscaleMask op_LogicalNot(ImageGrayscaleMask a)
  • public static ImageGrayscaleMask op_Multiply(ImageGrayscaleMask a, ImageGrayscaleMask b)
  • public static ImageGrayscaleMask op_Subtraction(ImageGrayscaleMask a, ImageGrayscaleMask b)
  • public void Apply()
  • public void ApplyTo(RasterImage image)
  • public object Clone()
  • public ImageGrayscaleMask Crop(Size size)
  • public ImageGrayscaleMask Crop(int width, int height)
  • public ImageGrayscaleMask Crop(Rectangle rectangle)
  • public ImageGrayscaleMask ExclusiveDisjunction(ImageGrayscaleMask mask)
  • public byte GetByteOpacity(int x, int y)
  • public ImageGrayscaleMask Intersect(ImageGrayscaleMask mask)
  • public ImageGrayscaleMask Invert()
  • public bool IsOpaque(int x, int y)
  • public bool IsTransparent(int x, int y)
  • public ImageGrayscaleMask Subtract(ImageGrayscaleMask mask)
  • public ImageGrayscaleMask Union(ImageGrayscaleMask mask)
• public abstract class ImageMask : IImageMask, ICloneable
  • public Rectangle Bounds { get; }
  • public int Height { get; protected set; }
  • public abstract bool this[int x, int y] { get; }
  • public abstract Rectangle SelectionBounds { get; }
  • public RasterImage Source { get; protected set; }
  • public int Width { get; protected set; }
  • protected ImageMask(int width, int height)
  • public static ImageBitMask op_Addition(ImageMask a, ImageMask b)
  • public static ImageBitMask op_ExclusiveOr(ImageMask a, ImageMask b)
  • public static ImageGrayscaleMask op_Explicit(ImageMask mask)
  • public static ImageBitMask op_LogicalNot(ImageMask a)
  • public static ImageBitMask op_Multiply(ImageMask a, ImageMask b)
  • public static ImageBitMask op_Subtraction(ImageMask a, ImageMask b)
  • public void Apply()
  • public void ApplyTo(RasterImage image)
  • public abstract object Clone()
  • public ImageMask Crop(Size size)
  • public ImageMask Crop(int width, int height)
  • public abstract ImageMask Crop(Rectangle rectangle)
  • public ImageBitMask ExclusiveDisjunction(ImageMask mask)
  • public ImageBitMask ExclusiveDisjunction(MagicWandSettings settings)
  • public ImageBitMask ExclusiveDisjunction(RasterImage image, MagicWandSettings settings)
  • public byte GetByteOpacity(int x, int y)
  • public ImageGrayscaleMask GetFeathered(FeatheringSettings settings = null)
  • public abstract ImageMask Inflate(int size)
  • public ImageBitMask Intersect(ImageMask mask)
  • public ImageBitMask Intersect(MagicWandSettings settings)
  • public ImageBitMask Intersect(RasterImage image, MagicWandSettings settings)
  • public ImageBitMask Invert()
  • public bool IsOpaque(int x, int y)
  • public bool IsTransparent(int x, int y)
  • public ImageBitMask Subtract(ImageMask mask)
  • public ImageBitMask Subtract(MagicWandSettings settings)
  • public ImageBitMask Subtract(RasterImage image, MagicWandSettings settings)
  • public ImageBitMask Union(ImageMask mask)
  • public ImageBitMask Union(MagicWandSettings settings)
  • public ImageBitMask Union(RasterImage image, MagicWandSettings settings)
• public class RectangleMask : ImageMask
  • public RectangleMask(int x, int y, int width, int height)
  • public RectangleMask(Rectangle selectedArea)

Aspose.Imaging.Masking

• public class ImageMasking
  • public static void ApplyMask(RasterImage targetImage, RasterImage mask, MaskingOptions maskingOptions)
  • public MaskingResult[] Decompose(MaskingOptions options)
  • public IAsyncTask DecomposeAsync(MaskingOptions options)
  • public MaskingResult Decompose(MaskingOptions options)
  • public IMaskingAsyncTask DecomposeAsync(MaskingOptions options)
  • public IMaskingSession LoadSession(Stream stream)
  • public IMaskingSession LoadSession(string filePath)
• public interface IMaskingAsyncTask : IAsyncTask, IAsyncResult, IDisposable
  • string GetError()
  • MaskingResult GetMaskingResult()
• public interface IMaskingSession : IDisposable
  • MaskingResult[] Decompose()
  • IAsyncTask DecomposeAsync()
  • MaskingResult[] ImproveDecomposition(IMaskingArgs maskingArguments)
  • IAsyncTask ImproveDecompositionAsync(IMaskingArgs maskingArguments)
  • MaskingResult Decompose()
  • IMaskingAsyncTask DecomposeAsync()
  • MaskingResult ImproveDecomposition(IMaskingArgs maskingArguments)
  • IMaskingAsyncTask ImproveDecompositionAsync(IMaskingArgs maskingArguments)
  • void Save(Stream stream)
  • void Save(string filePath)

Aspose.Imaging.Masking.Options

• public class AssumedObjectData
  • public Rectangle Bounds { get; set; }
  • public DetectedObjectType Type { get; set; }
  • public AssumedObjectData()
  • public AssumedObjectData(DetectedObjectType type, Rectangle bounds)
  • public AssumedObjectData(string type, Rectangle bounds)
• public class AutoMaskingGraphCutOptions : GraphCutMaskingOptions
  • public List<AssumedObjectData> AssumedObjects { get; set; }
  • public bool CalculateDefaultStrokes { get; set; }
  • public Point[] DefaultBackgroundStrokes { get; }
  • public Point[] DefaultForegroundStrokes { get; }
  • public Rectangle[] DefaultObjectsRectangles { get; }
  • public ProgressEventHandler PrecalculationProgressEventHandler { get; set; }
  • public AutoMaskingGraphCutOptions()
• public enum DetectedObjectType
  • Human = 0
  • Other = 1
• public class GraphCutMaskingOptions : MaskingOptions
  • public int FeatheringRadius { get; set; }
  • public GraphCutMaskingOptions()

Aspose.Imaging.Masking.Result

• public interface IMaskingLayer
  • int ObjectNumber { get; }
  • RasterImage GetImage()
  • RasterImage GetMask()
• public abstract class MaskingResult : DisposableObject, IEnumerable<IMaskingLayer>, IEnumerable
  • protected readonly Rectangle MaskingArea
  • public int ObjectNumber { get; }
  • protected MaskingResult(MaskingOptions maskingOptions, int objectNumber)
  • public abstract Image GetImage()
  • protected readonly RasterImage OriginImage
  • public IMaskingLayer this[int index] { get; }
  • public abstract IMaskingLayer[] Layers { get; }
  • public int Length { get; }
  • protected MaskingResult(MaskingOptions maskingOptions, RasterImage originImage, Rectangle maskingArea)
  • public IEnumerator<IMaskingLayer> GetEnumerator()

Aspose.Imaging.Multithreading

• public interface IInterruptMonitor
  • bool IsInterrupted { get; }
  • void Interrupt()
• public class InterruptMonitor : IInterruptMonitor
  • public static InterruptMonitor ThreadLocalInstance { get; set; }
  • public static IInterruptMonitor ThreadLocalInstance { get; set; }

Aspose.Imaging.PaletteHelper

• public class AdjustPalette
  • public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount, ColorQuantizationMethod colorQuantizationMethod, ColorCompareMethod colorCompareMethod)

Aspose.Imaging.ShapeSegments

• public class LineSegment : ShapeSegment
  • protected bool Equals(LineSegment other)

Aspose.Imaging.Shapes

• public class EllipseShape : RectangleShape
  • protected bool Equals(EllipseShape other)
• public class PieShape : EllipseShape
  • protected bool Equals(PieShape other)
• public class PolygonShape : Shape, IOrderedShape
  • protected bool Equals(PolygonShape other)
• public abstract class RectangleProjectedShape : Shape
  • protected bool Equals(RectangleProjectedShape other)
• public class RectangleShape : RectangleProjectedShape
  • protected bool Equals(RectangleShape other)

Aspose.Imaging.Sources

• public sealed class StreamSource : Source
  • public StreamSource()

Aspose.Imaging.Watermark

• public static class WatermarkRemover
  • public static RasterImage PaintOver(RasterImage source, WatermarkOptions options)

Aspose.Imaging.Watermark.Options

• public class ContentAwareFillWatermarkOptions : WatermarkOptions
  • public Rectangle InterestArea { get; set; }
  • public int MaxPaintingAttempts { get; set; }
  • public byte PatchSize { get; set; }
  • public ContentAwareFillWatermarkOptions(Point[] mask)
  • public ContentAwareFillWatermarkOptions(GraphicsPath mask)
• public class TeleaWatermarkOptions : WatermarkOptions
  • public int HalfPatchSize { get; set; }
  • public TeleaWatermarkOptions(Point[] mask)
  • public TeleaWatermarkOptions(GraphicsPath mask)
• public abstract class WatermarkOptions
  • public GraphicsPath GraphicsPathMask { get; set; }
  • public IEnumerable<Point> Mask { get; set; }
  • public ProgressEventHandler PrecalculationProgressEventHandler { get; set; }
  • protected WatermarkOptions()

Aspose.Imaging.Xmp

• public static class Namespaces
  • public const string Dicom = "https://dicom.nema.org/medical/dicom/"

Aspose.Imaging.Xmp.Schemas.Dicom

• public sealed class DicomPackage : XmpPackage
  • public DicomPackage()
  • public void SetEquipmentInstitution(string equipmentInstitution)
  • public void SetEquipmentManufacturer(string equipmentManufacturer)
  • public void SetPatientBirthDate(string patientBirthDate)
  • public void SetPatientId(string patientId)
  • public void SetPatientName(string patientName)
  • public void SetPatientSex(string patientSex)
  • public void SetSeriesDateTime(string seriesDateTime)
  • public void SetSeriesDescription(string seriesDescription)
  • public void SetSeriesModality(string seriesModality)
  • public void SetSeriesNumber(string seriesNumber)
  • public void SetStudyDateTime(string studyDateTime)
  • public void SetStudyDescription(string studyDescription)
  • public void SetStudyId(string studyId)
  • public void SetStudyPhysician(string studyPhysician)