Aspose.Imaging by Aspose

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

---

API Diff between 21.5.0 and 24.2.0

154 Additions 249 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, 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 class CustomLineCap
  • protected bool Equals(CustomLineCap other)
• public abstract class DataStreamSupporter : DisposableObject
  • protected virtual void DoAfterSave(Stream stream)
• public class EmbeddedImage : DisposableObject
• public enum FileFormat
  • BigTiff = 2147483648
  • Emz = 67108864
  • FOdg = 536870912
  • Ico = 256
  • Pdf = 128
  • Svgz = 268435456
  • Unknown = 0
  • Undefined = 0
  • Wmz = 134217728
• 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
  • protected static void DoAfterCreate(ref long maximum, long imageSize)
  • protected static void DoAfterLoad(ref long maximum, Stream stream)
  • protected virtual bool DoUseRecursion(ImageOperation operation)
• public interface IMultipageImage
  • Image DefaultPage { get; }
• public interface IRasterImageArgb64PixelLoader : IRasterImageRawDataLoader
• public class LoadOptions :    
  • public void AddCustomFontSource(CustomFontSource source, object[] args)
• public abstract class ObjectWithBounds
  • protected bool Equals(ObjectWithBounds other)
• 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 abstract class RasterCachedMultipageImage : RasterCachedImage, IMultipageImage
  • public abstract Image DefaultPage { get; }
• public abstract class RasterImage : Image, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader,    
  • 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 abstract class Shape : ObjectWithBounds
  • protected bool Equals(Shape other)
• public abstract class ShapeSegment
  • protected bool Equals(ShapeSegment other)
• 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.Brushes

• public sealed class LinearGradientBrush : LinearGradientBrushBase
  • public LinearGradientBrush(RectangleF 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(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(RectangleF rect, Color color1, Color color2, float angle, bool isAngleScalable)
• public sealed class TextureBrush : TransformBrush
  • public TextureBrush(Image image, Rectangle destinationRectangle, ImageAttributes imageAttributes)
  • public TextureBrush(Image image, Rectangle destinationRectangle)
  • public TextureBrush(Image image, RectangleF 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, WrapMode wrapMode)
  • public TextureBrush(Image image, WrapMode wrapMode, RectangleF destinationRectangle)
  • public TextureBrush(Image image, WrapMode wrapMode, Rectangle destinationRectangle)
  • public TextureBrush(Image image, RectangleF destinationRectangle)
  • public TextureBrush(Image image, Rectangle destinationRectangle)
  • public TextureBrush(Image image, Rectangle destinationRectangle, ImageAttributes imageAttributes)

Aspose.Imaging.CoreExceptions

• public class IncorrectPasswordException : Exception

Aspose.Imaging.CustomFontHandler

• public class CustomFontData

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

Aspose.Imaging.FileFormats.BigTiff

• public sealed class BigTiffImage : TiffImage

Aspose.Imaging.FileFormats.Cdr.Const

• public enum CdrColorModel
  • Model0x0e = 14

Aspose.Imaging.FileFormats.Cdr.Objects

• public class CdrBmp : CdrDictionaryItem
  • public byte[] Data { get; set; }
• public class CdrParagraph : CdrGraphicObject
  • public double Height { get; set; }
  • public double Width { get; set; }
• public class CdrPattern : CdrDictionaryItem
  • public byte[] Data { get; set; }
• public class CdrTransforms : CdrObject
  • public List<#=z8IyVxSo$W47Bkr_wIDTU9Qc=> Transforms { get; set; }
  • public List<​​> Transforms { get; set; }

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.Specs

• public class CmxArrowSpec : CmxPathSpec
  • protected bool Equals(CmxArrowSpec other)
• public class CmxEllipseSpec : ICmxObjectSpec
  • protected bool Equals(CmxEllipseSpec other)
• public class CmxImageSpec : ICmxObjectSpec
  • protected bool Equals(CmxImageSpec other)
• public class CmxPathPointSpec
  • protected bool Equals(CmxPathPointSpec other)
• public class CmxPathSpec : ICmxObjectSpec
  • 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 class ClipboardRecord : VectorPathRecord
• public class InitialFillRuleRecord : VectorPathRecord
• public interface IVectorPathData
• public class LengthRecord : VectorPathRecord
• public class PathFillRuleRecord : VectorPathRecord
• public enum PathOperations
• public abstract class VectorPathRecord
• public class VectorPathRecordFactory
• public enum VectorPathType

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 TiffImage TiffPreview { get; }
  • public WmfImage WmfPreview { get; }
  • public static EpsBinaryImage op_Explicit(EpsInterchangeImage basicImage)
  • public EpsInterchangeImage ConvertToInterchange()
• public abstract class EpsImage : VectorImage
  • public RectangleF BoundingBox { get; }
  • public Rectangle BoundingBoxPx { get; }
  • public Point BoundingBoxBottomLeft { get; }
  • public string BoundingBoxString { get; }
  • public Point BoundingBoxTopRight { get; }
  • public string CreationDateString { get; }
  • public int? PageNumber { get; }
  • public int? PagesCount { get; }
  • public JpegImage PhotoshopThumbnail { get; }
  • public int PreviewImageCount { get; }
  • public Image[] PreviewImages { get; }
  • public EpsPreviewFormat PreviewToExport { get; set; }
  • public Image GetPreviewImage(EpsPreviewFormat format = 0)
  • public IEnumerable<Image> GetPreviewImages()
  • protected EpsImage(bool initialize)
  • protected abstract void FinalizePhotoshopThumbnail()
  • protected abstract List<Image> GetPreviewImages()
  • protected Image RenderPostScript(ImageOptionsBase optionsBase = null)
  • protected abstract void ResizePreviewImages(int newWidth, int newHeight, ResizeType resizeType)
  • protected abstract void SetSpecificRasterPreview(Image image)
• public class EpsInterchangeImage : EpsImage
  • public int PreviewHeight { get; }
  • public int PreviewWidth { get; }
  • public RasterImage RasterPreview { get; }
  • public static EpsInterchangeImage op_Explicit(EpsBinaryImage basicImage)
  • public EpsBinaryImage ConvertToBinary()
• public class EpsLoadOptions : LoadOptions
  • public EpsPreviewFormat PreviewExportFormat { get; set; }
• public enum EpsPreviewFormat
  • PostScriptRendering = 4

Aspose.Imaging.FileFormats.Gif

• public sealed class GifImage : RasterCachedMultipageImage,    , IMultipageImage, IMultipageImageExt
  • public int LoopsCount { get; set; }
  • public void ResizeFullFrame(int newWidth, int newHeight, ResizeType resizeType)
  • public void SetFrameTime(ushort time)

Aspose.Imaging.FileFormats.Gif.Blocks

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

Aspose.Imaging.FileFormats.Ico

• public class IcoImage : RasterCachedMultipageImage, IMultipageImageExt, IMultipageImage

Aspose.Imaging.FileFormats.OpenDocument

• public class OdgImage : OdImage
  • public OdgImage(StreamContainer streamContainer, LoadOptions options)
• public abstract class OdImage : VectorMultipageImage,  ​ 
  • 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.Psd

• public enum VectorDataCompositionMode

Aspose.Imaging.FileFormats.Psd.Layers.LayerResources.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 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(byte[] data)
• public class LengthRecord : VectorPathRecord
  • public bool IsClosed { get; set; }
  • public bool IsOpen { get; set; }
  • public ushort RecordCount { get; set; }
  • public LengthRecord()
  • public LengthRecord(byte[] data)
• public class PathFillRuleRecord : VectorPathRecord
  • public PathFillRuleRecord()
  • public PathFillRuleRecord(byte[] data)
• 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.Tiff

• public abstract class TiffDataType : IComparable
  • public abstract ulong Count { get; }
  • public virtual ulong DataSize { get; }
  • public virtual byte ElementSize { get; }
  • public uint AlignedDataSize { get; }
  • public abstract uint Count { get; }
  • public abstract uint DataSize { get; }
  • public virtual ulong GetAdditionalDataSize(byte sizeOfTagValue)
  • public ulong GetAlignedDataSize(byte sizeOfTagValue)

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, 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 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 class TiffStreamReader
  • protected virtual int[] ProcessReadDataInt(byte[] data)
  • protected virtual long[] ProcessReadDataLong(byte[] data)
  • protected virtual int[] ProcessReadDataLong(byte[] data)
  • protected virtual uint[] ProcessReadDataUInt(byte[] data)
  • protected virtual ulong[] ProcessReadDataULong(byte[] data)
  • protected virtual uint[] ProcessReadDataULong(byte[] data)
  • public long ReadLong(long position)
  • public long[] ReadLongArray(long position, long count)
  • public int ReadSInt(long position)
  • public int[] ReadSIntArray(long position, long count)
  • public int ReadSLong(long position)
  • public int[] ReadSLongArray(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 uint ReadULong(long position)
  • public uint[] ReadULongArray(long position, long count)
• public class TiffStreamWriter :    
  • protected virtual void ProcessWriteDataInt(int[] data, byte[] dest)
  • protected virtual void ProcessWriteDataLong(long[] data, byte[] dest)
  • protected virtual void ProcessWriteDataLong(int[] data, byte[] dest)
  • protected virtual void ProcessWriteDataUInt(uint[] data, byte[] dest)
  • protected virtual void ProcessWriteDataULong(ulong[] data, byte[] dest)
  • protected virtual void ProcessWriteDataULong(uint[] data, byte[] dest)
  • public void Write(MemoryStream stream)
  • 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)
  • 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)

Aspose.Imaging.FileFormats.Tiff.FileManagement.BigTiff

• public class BigTiffReader : TiffStreamReader
• public class BigTiffReaderBE : TiffBigEndianStreamReader
• public class BigTiffWriter : TiffStreamWriter
• public class BigTiffWriterBE : TiffBigEndianStreamWriter

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 class TiffLong8Type : TiffCommonArrayType
• public class TiffSLong8Type : TiffCommonArrayType
• public sealed class TiffUnknownType : TiffDataType
  • public ulong OffsetOrValue { get; }
  • public uint OffsetOrValue { get; }
  • public TiffUnknownType(TiffStreamReader stream, ushort tagType, ushort tagId, ulong count, ulong offsetOrValue)
  • public TiffUnknownType(TiffStreamReader stream, ushort tagType, ushort tagId, uint count, uint offsetOrValue)

Aspose.Imaging.FileFormats.Webp

• public class WebPFrameBlock : RasterCachedImage, IAnimationFrame, IFrame
  • public bool UseAlphaBlending { get; set; }

Aspose.Imaging.FileFormats.Wmf.Objects

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

Aspose.Imaging.ImageFilters.ComplexUtils

• public struct Complex : IEquatable<Complex>

Aspose.Imaging.ImageFilters.Convolution

• public class ConvolutionFilter

Aspose.Imaging.ImageFilters.FilterOptions

• public abstract class ConvolutionFilterOptions : FilterOptionsBase
  • protected const byte MinSize = 3
  • public virtual double[,] Kernel { get; }
  • public ConvolutionFilterOptions(double[,] kernel, double factor = 1, int bias = 0)
• public abstract class DeconvolutionFilterOptions : FilterOptionsBase
  • public virtual Complex[,] Kernel { get; }
  • public DeconvolutionFilterOptions(double[,] kernel)
  • public DeconvolutionFilterOptions(Complex[,] kernel)
• public class GaussianBlurFilterOptions : ConvolutionFilterOptions
  • protected const double DefaultSigma = 1
  • protected const byte DefaultSize = 5
  • public virtual int Size { get; set; }
• public abstract class GaussianDeconvolutionFilterOptions : DeconvolutionFilterOptions, #=z$YkRPllE0lb5cJJWYxAZ2XdF7YDwK080KrRjXa4BB4OXxpbMrm97JhH_G_Q8rViPMV7spO3Gw_nNNhkE3MVKsF0=, #=zxt9RI6PROUscgqZ5UiQ0El6fI6H1Jm5Jcw$0p7Bm$pkyttWvnZMKQVUntW$xwMEFhRXvA7I=
• public class GaussWienerFilterOptions : DeconvolutionFilterOptions
  • public int Radius { get; set; }
  • public double Smooth { get; set; }
• public class MotionWienerFilterOptions : DeconvolutionFilterOptions
  • public int Length { get; set; }
  • public double Smooth { get; set; }
• public class SharpenFilterOptions : ConvolutionFilterOptions
  • 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 class DngLoadOptions : LoadOptions
  • public bool AdjustWhiteBalance { get; set; }
• public class OdLoadOptions : LoadOptions

Aspose.Imaging.ImageOptions

• public sealed class BigTiffOptions : TiffOptions
• public class GifOptions : ImageOptionsBase
  • public Color BackgroundColor { get; set; }
  • public bool HasTransparentColor { get; set; }
  • public int LoopsCount { get; set; }
• public class GraphicsOptions
  • public InterpolationMode InterpolationMode { get; set; }
  • public SmoothingMode SmoothingMode { get; set; }
  • public TextRenderingHint TextRenderingHint { get; set; }
  • public GraphicsOptions()
• public class IcoOptions : ImageOptionsBase
• public enum PdfImageCompressionOptions
• public class PdfOptions : ImageOptionsBase
  • public bool UseOriginalImageResolution { get; set; }
• public class PsdOptions : ImageOptionsBase
  • public PsdVectorizationOptions VectorizationOptions { get; set; }
• public class PsdVectorizationOptions
• public class TiffOptions : ImageOptionsBase
  • public bool DisableIccExport { get; set; }
  • public ushort[] ExtraSamples { get; }
  • public ulong[] StripByteCounts { get; set; }
  • public ulong[] StripOffsets { get; set; }
  • public uint[] StripByteCounts { get; set; }
  • public uint[] StripOffsets { get; set; }
  • public int TagCount { get; }
  • public ulong[] TileByteCounts { get; set; }
  • public uint[] TileByteCounts { get; set; }
  • public ulong[] TileOffsets { get; set; }
  • public uint[] TileOffsets { get; set; }
  • public bool RemoveTags(TiffTags[] tags)
• public class TiffOptionsUtils
  • public TiffOptionsUtils()
  • public static int GetValidTagsCount(TiffDataType[] tags)
• public class VectorRasterizationOptions : ImageOptionsBase
  • public Dictionary<string, string> ReplaceTextMapping { get; set; }

Aspose.Imaging.MagicWand

• public enum ColorComparisonMode
• public struct ColorYUV
• public enum FloodFillDirectionalMode
• public class MagicWandSettings
• public class MagicWandTool : IPartialArgb32PixelLoader
• public static class RasterImageExtension

Aspose.Imaging.MagicWand.ImageMasks

• public class CircleMask : ImageMask
• public class EmptyImageMask : ImageMask
• public enum FeatheringMode
• public class FeatheringSettings
• public interface IImageMask : ICloneable
• public class ImageBitMask : ImageMask
• public class ImageGrayscaleMask : IImageMask, ICloneable
• public abstract class ImageMask : IImageMask, ICloneable
• public class RectangleMask : ImageMask

Aspose.Imaging.Masking

• public class ImageMasking
  • public IMaskingAsyncTask DecomposeAsync(MaskingOptions options)
  • public IAsyncTask DecomposeAsync(MaskingOptions options)
• public interface IMaskingAsyncTask : IAsyncTask, IAsyncResult, IDisposable
• public interface IMaskingSession : IDisposable
  • IMaskingAsyncTask DecomposeAsync()
  • IAsyncTask DecomposeAsync()
  • IMaskingAsyncTask ImproveDecompositionAsync(IMaskingArgs maskingArguments)
  • IAsyncTask ImproveDecompositionAsync(IMaskingArgs maskingArguments)

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

Aspose.Imaging.Watermark.Options

• public class ContentAwareFillWatermarkOptions : WatermarkOptions
• public class TeleaWatermarkOptions : WatermarkOptions
• public abstract class 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