Class Image
Namespace: Aspose.Imaging
Assembly: Aspose.Imaging.dll (25.2.0)
The image is the base class for all type of images.
[JsonObject(MemberSerialization.OptIn)]
public abstract class Image : DataStreamSupporter, IDisposable, IObjectWithBoundsInheritance
object ← DisposableObject ← DataStreamSupporter ← Image
Derived
Implements
IDisposable, IObjectWithBounds
Inherited Members
DataStreamSupporter.timeout, DataStreamSupporter.CacheData(), DataStreamSupporter.Save(), DataStreamSupporter.Save(Stream), DataStreamSupporter.Save(string), DataStreamSupporter.Save(string, bool), DataStreamSupporter.SaveData(Stream), DataStreamSupporter.ReleaseManagedResources(), DataStreamSupporter.OnDataStreamContainerChanging(StreamContainer), DataStreamSupporter.DataStreamContainer, DataStreamSupporter.IsCached, DisposableObject.Dispose(), DisposableObject.ReleaseManagedResources(), DisposableObject.ReleaseUnmanagedResources(), DisposableObject.VerifyNotDisposed(), DisposableObject.Disposed, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()
Examples
Determine if the palette is used by the image.```csharp [C#]
using (var image = Image.Load(folder + "Sample.bmp"))
{
if (image.UsePalette)
{
Console.WriteLine("The palette is used by the image");
}
}
Resize image using specific Resize Type.```csharp
[C#]
using (var image = Image.Load("Photo.jpg"))
{
image.Resize(640, 480, ResizeType.CatmullRom);
image.Save("ResizedPhoto.jpg");
image.Resize(1024, 768, ResizeType.CubicConvolution);
image.Save("ResizedPhoto2.jpg");
var resizeSettings = new ImageResizeSettings
{
Mode = ResizeType.CubicBSpline,
FilterType = ImageFilterType.SmallRectangular
};
image.Resize(800, 800, resizeSettings);
image.Save("ResizedPhoto3.jpg");
}This example creates a new Image file at some disk location as specified by Source property of the BmpOptions instance. Several properties for BmpOptions instance are set before creating the actual image. Especially the Source property, that refers to the actual disk location in this case.```csharp [C#]
//Create an instance of BmpOptions and set its various properties
Aspose.Imaging.ImageOptions.BmpOptions bmpOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
bmpOptions.BitsPerPixel = 24;
//Create an instance of FileCreateSource and assign it as Source for the instance of BmpOptions
//Second Boolean parameter determines if the file to be created IsTemporal or not
bmpOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(@"C:\temp\output.bmp", false);
//Create an instance of Image and initialize it with instance of BmpOptions by calling Create method
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(bmpOptions, 500, 500))
{
//do some image processing
// save all changes
image.Save();
}
## Constructors
### <a id="Aspose_Imaging_Image__ctor"></a> Image\(\)
Initializes a new instance of the Aspose.Imaging.Image class.
```csharp
[JsonConstructor]
protected Image()Image(IColorPalette)
Initializes a new instance of the Aspose.Imaging.Image class.
protected Image(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
The color palette.
Properties
AutoAdjustPalette
Gets or sets a value indicating whether automatic adjust palette.
public bool AutoAdjustPalette { get; set; }Property Value
BackgroundColor
Gets or sets a value for the background color.
public virtual Color BackgroundColor { get; set; }Property Value
BitsPerPixel
Gets the image bits per pixel count.
public abstract int BitsPerPixel { get; }Property Value
Bounds
Gets the image bounds.
public Rectangle Bounds { get; }Property Value
BufferSizeHint
Gets or sets the buffer size hint which is defined max allowed size for all internal buffers.
public int BufferSizeHint { get; set; }Property Value
Container
Gets the Aspose.Imaging.Image container.
public Image Container { get; }Property Value
Remarks
If this property is not null it indicates the image is contained within another image.
FileFormat
Gets a value of file format
public virtual FileFormat FileFormat { get; }Property Value
HasBackgroundColor
Gets or sets a value indicating whether image has background color.
public virtual bool HasBackgroundColor { get; set; }Property Value
Height
Gets the image height.
public abstract int Height { get; }Property Value
InterruptMonitor
Gets or sets the interrupt monitor.
public InterruptMonitor InterruptMonitor { get; set; }Property Value
Palette
Gets or sets the color palette. The color palette is not used when pixels are represented directly.
public IColorPalette Palette { get; set; }Property Value
Size
Gets the image size.
public Size Size { get; }Property Value
Examples
This example shows how to load a DJVU image from a file stream and print information about the pages.```csharp [C#]
string dir = "c:\\temp\\";
// Load a DJVU image from a file stream.
using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
{
using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
{
System.Console.WriteLine("The total number of pages: {0}", djvuImage.Pages.Length);
System.Console.WriteLine("The active page number: {0}", djvuImage.ActivePage.PageNumber);
System.Console.WriteLine("The first page number: {0}", djvuImage.FirstPage.PageNumber);
System.Console.WriteLine("The last page number: {0}", djvuImage.LastPage.PageNumber);
foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
{
System.Console.WriteLine("--------------------------------------------------");
System.Console.WriteLine("Page number: {0}", djvuPage.PageNumber);
System.Console.WriteLine("Page size: {0}", djvuPage.Size);
System.Console.WriteLine("Page raw format: {0}", djvuPage.RawDataFormat);
}
}
}
//The output may look like this:
//The total number of pages: 2
//The active page number: 1
//The first page number: 1
//The last page number: 2
//--------------------------------------------------
//Page number: 1
//Page size: { Width = 2481, Height = 3508}
//Page raw format: RgbIndexed1Bpp, used channels: 1
//--------------------------------------------------
//Page number: 2
//Page size: { Width = 2481, Height = 3508}
//Page raw format: RgbIndexed1Bpp, used channels: 1
### <a id="Aspose_Imaging_Image_UsePalette"></a> UsePalette
Gets a value indicating whether the image palette is used.
```csharp
public virtual bool UsePalette { get; }Property Value
Examples
Determine if the palette is used by the image.```csharp [C#]
using (var image = Image.Load(folder + "Sample.bmp"))
{
if (image.UsePalette)
{
Console.WriteLine("The palette is used by the image");
}
}
### <a id="Aspose_Imaging_Image_Width"></a> Width
Gets the image width.
```csharp
public abstract int Width { get; }Property Value
Methods
CanLoad(string)
Determines whether image can be loaded from the specified file path.
public static bool CanLoad(string filePath)Parameters
filePath string
The file path.
Returns
true if image can be loaded from the specified file; otherwise, false.
Examples
This example determines whether image can be loaded from a file.```csharp [C#]
// Use an absolute path to the file
bool canLoad = Aspose.Imaging.Image.CanLoad(@"c:\temp\sample.gif");
### <a id="Aspose_Imaging_Image_CanLoad_System_String_Aspose_Imaging_LoadOptions_"></a> CanLoad\(string, LoadOptions\)
Determines whether image can be loaded from the specified file path and optionally using the specified open options.
```csharp
public static bool CanLoad(string filePath, LoadOptions loadOptions)Parameters
filePath string
The file path.
loadOptions LoadOptions
The load options.
Returns
true if image can be loaded from the specified file; otherwise, false.
CanLoad(Stream)
Determines whether image can be loaded from the specified stream.
public static bool CanLoad(Stream stream)Parameters
stream Stream
The stream to load from.
Returns
true if image can be loaded from the specified stream; otherwise, false.
Examples
This example determines whether image can be loaded from a file stream.```csharp [C#]
string dir = "c:\\temp\\";
bool canLoad;
// Use a file stream
using (System.IO.FileStream stream = System.IO.File.OpenRead(dir + "sample.bmp"))
{
canLoad = Aspose.Imaging.Image.CanLoad(stream);
}
// The following data is not a valid image stream, so CanLoad returns false.
byte[] imageData = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };
using (System.IO.MemoryStream stream = new System.IO.MemoryStream(imageData))
{
canLoad = Aspose.Imaging.Image.CanLoad(stream);
}
### <a id="Aspose_Imaging_Image_CanLoad_System_IO_Stream_Aspose_Imaging_LoadOptions_"></a> CanLoad\(Stream, LoadOptions\)
Determines whether image can be loaded from the specified stream and optionally using the specified <code class="paramref">loadOptions</code>.
```csharp
public static bool CanLoad(Stream stream, LoadOptions loadOptions)Parameters
stream Stream
The stream to load from.
loadOptions LoadOptions
The load options.
Returns
true if image can be loaded from the specified stream; otherwise, false.
CanSave(ImageOptionsBase)
Determines whether image can be saved to the specified file format represented by the passed save options.
public bool CanSave(ImageOptionsBase options)Parameters
options ImageOptionsBase
The save options to use.
Returns
true if image can be saved to the specified file format represented by the passed save options; otherwise, false.
Examples
This example shows how to determine whether image can be saved to the specified file format represented by the passed save options.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
Aspose.Imaging.ImageOptions.JpegOptions saveOptions = new Aspose.Imaging.ImageOptions.JpegOptions();
saveOptions.Quality = 50;
// Determine whether the image can be saved to Jpeg
bool canSave = image.CanSave(saveOptions);
}
### <a id="Aspose_Imaging_Image_Create_Aspose_Imaging_ImageOptionsBase_System_Int32_System_Int32_"></a> Create\(ImageOptionsBase, int, int\)
Creates a new image using the specified create options.
```csharp
public static Image Create(ImageOptionsBase imageOptions, int width, int height)Parameters
imageOptions ImageOptionsBase
The image options.
width int
The width.
height int
The height.
Returns
The newly created image.
Examples
This example creates a new Image file at some disk location as specified by Source property of the BmpOptions instance. Several properties for BmpOptions instance are set before creating the actual image. Especially the Source property, that refers to the actual disk location in this case.```csharp [C#]
//Create an instance of BmpOptions and set its various properties
Aspose.Imaging.ImageOptions.BmpOptions bmpOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
bmpOptions.BitsPerPixel = 24;
//Create an instance of FileCreateSource and assign it as Source for the instance of BmpOptions
//Second Boolean parameter determines if the file to be created IsTemporal or not
bmpOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(@"C:\temp\output.bmp", false);
//Create an instance of Image and initialize it with instance of BmpOptions by calling Create method
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(bmpOptions, 500, 500))
{
//do some image processing
// save all changes
image.Save();
}
### <a id="Aspose_Imaging_Image_Create_Aspose_Imaging_Image___"></a> Create\(Image\[\]\)
Creates a new image using the specified images as pages
```csharp
public static Image Create(Image[] images)Parameters
images Image[]
The images.
Returns
The Image as IMultipageImage
Create(MultipageCreateOptions)
Creates the specified multipage create options.
public static Image Create(MultipageCreateOptions multipageCreateOptions)Parameters
multipageCreateOptions MultipageCreateOptions
The multipage create options.
Returns
The multipage image
Create(string[], bool)
Creates the multipage image containing the specified files.
public static Image Create(string[] files, bool throwExceptionOnLoadError)Parameters
files string[]
The files.
throwExceptionOnLoadError bool
if set to true [throw exception on load error].
Returns
The multipage image
Create(string[])
Creates the multipage image containing the specified files.
public static Image Create(string[] files)Parameters
files string[]
The files.
Returns
The multipage image
Create(Image[], bool)
Creates a new image the specified images as pages.
public static Image Create(Image[] images, bool disposeImages)Parameters
images Image[]
The images.
disposeImages bool
if set to true [dispose images].
Returns
The Image as IMultipageImage
Crop(Rectangle)
Crops the specified rectangle.
public virtual void Crop(Rectangle rectangle)Parameters
rectangle Rectangle
The rectangle.
Examples
The following example crops a raster image. The cropping area is be specified via Aspose.Imaging.Rectangle.```csharp [C#]
string dir = @"c:\temp\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
// Crop the image. The cropping area is the rectangular central area of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
image.Crop(area);
// Save the cropped image to PNG
image.Save(dir + "sample.Crop.png");
}
### <a id="Aspose_Imaging_Image_Crop_System_Int32_System_Int32_System_Int32_System_Int32_"></a> Crop\(int, int, int, int\)
Crop image with shifts.
```csharp
public virtual void Crop(int leftShift, int rightShift, int topShift, int bottomShift)Parameters
leftShift int
The left shift.
rightShift int
The right shift.
topShift int
The top shift.
bottomShift int
The bottom shift.
Examples
The following example crops a raster image. The cropping area is specified via Left, Top, Right, Bottom margins.```csharp [C#]
string dir = @"c:\temp\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
// Crop again. Set a margin of 10% of the image size.
int horizontalMargin = rasterImage.Width / 10;
int verticalMargin = rasterImage.Height / 10;
image.Crop(horizontalMargin, horizontalMargin, verticalMargin, verticalMargin);
// Save the cropped image to PNG.
image.Save(dir + "sample.Crop.png");
}
### <a id="Aspose_Imaging_Image_Finalize"></a> \~Image\(\)
```csharp
protected ~Image()GetCanNotSaveMessage(ImageOptionsBase)
Gets the can not save message.
protected virtual string GetCanNotSaveMessage(ImageOptionsBase optionsBase)Parameters
optionsBase ImageOptionsBase
The image options.
Returns
The can not save message.
GetDefaultOptions(object[])
Gets the default options.
public virtual ImageOptionsBase GetDefaultOptions(object[] args)Parameters
args object[]
The arguments.
Returns
Default options
GetFileFormat(string)
Gets the file format.
public static FileFormat GetFileFormat(string filePath)Parameters
filePath string
The file path.
Returns
The determined file format.
Examples
This example shows how to determine the image format without loading the entire image from a file.```csharp [C#]
string dir = "c:\\temp\\";
// Use an absolute path to the file
Aspose.Imaging.FileFormat format = Aspose.Imaging.Image.GetFileFormat(dir + "sample.gif");
System.Console.WriteLine("The file format is {0}", format);
#### Remarks
The file format determined does not mean that the specified image may be loaded. Use one of the CanLoad method overloads to determine whether file may be loaded.
### <a id="Aspose_Imaging_Image_GetFileFormat_System_IO_Stream_"></a> GetFileFormat\(Stream\)
Gets the file format.
```csharp
public static FileFormat GetFileFormat(Stream stream)Parameters
stream Stream
The stream.
Returns
The determined file format.
Examples
This example shows how to determine the image format without loading the entire image from a file stream.```csharp [C#]
string dir = "c:\\temp\\";
// Use a file stream
using (System.IO.FileStream stream = System.IO.File.OpenRead(dir + "sample.bmp"))
{
Aspose.Imaging.FileFormat format = Aspose.Imaging.Image.GetFileFormat(stream);
System.Console.WriteLine("The file format is {0}", format);
}
// The following data is not a valid image stream, so GetFileFormat returns FileFormat.Undefined.
byte[] imageData = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };
using (System.IO.MemoryStream stream = new System.IO.MemoryStream(imageData))
{
Aspose.Imaging.FileFormat format = Aspose.Imaging.Image.GetFileFormat(stream);
System.Console.WriteLine("The file format is {0}", format);
}
#### Remarks
The file format determined does not mean that the specified image may be loaded. Use one of the CanLoad method overloads to determine whether stream may be loaded.
### <a id="Aspose_Imaging_Image_GetFitRectangle_Aspose_Imaging_Rectangle_"></a> GetFitRectangle\(Rectangle\)
Gets rectangle which fits the current image.
```csharp
protected Rectangle GetFitRectangle(Rectangle rectangle)Parameters
rectangle Rectangle
The rectangle to get fitting rectangle for.
Returns
The fitting rectangle
GetFitRectangle(Rectangle, int[])
Gets rectangle which fits the current bitmap taking into account the pixels passed. The passed pixels array count should be equal to the fitting rectangle size.
protected Rectangle GetFitRectangle(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
The rectangle to get fitting rectangle for.
pixels int[]
The 32-bit ARGB pixels array.
Returns
The fitting rectangle.
GetFittingRectangle(Rectangle, int, int)
Gets rectangle which fits the current image.
public static Rectangle GetFittingRectangle(Rectangle rectangle, int width, int height)Parameters
rectangle Rectangle
The rectangle to get fitting rectangle for.
width int
The object width.
height int
The object height.
Returns
The fitting rectangle or exception if no fitting rectangle can be found.
GetFittingRectangle(Rectangle, int[], int, int)
Gets rectangle which fits the current image.
public static Rectangle GetFittingRectangle(Rectangle rectangle, int[] pixels, int width, int height)Parameters
rectangle Rectangle
The rectangle to get fitting rectangle for.
pixels int[]
The 32-bit ARGB pixels.
width int
The object width.
height int
The object height.
Returns
The fitting rectangle or exception if no fitting rectangle can be found.
GetImage2Export(ImageOptionsBase, Rectangle, IImageExporter)
Gets the image to export.
[Obsolete("Will be changed by method with other signature")]
protected virtual Image GetImage2Export(ImageOptionsBase optionsBase, Rectangle boundsRectangle, IImageExporter exporter)Parameters
optionsBase ImageOptionsBase
The image options base.
boundsRectangle Rectangle
The bounds rectangle.
exporter IImageExporter
The exporter.
Returns
The image to export
GetOriginalOptions()
Gets the options based on the original file settings. This can be helpful to keep bit-depth and other parameters of the original image unchanged. For example, if we load a black-white PNG image with 1 bit per pixel and then save it using the Aspose.Imaging.DataStreamSupporter.Save(System.String) method, the output PNG image with 8-bit per pixel will be produced. To avoid it and save PNG image with 1-bit per pixel, use this method to get corresponding saving options and pass them to the Aspose.Imaging.Image.Save(System.String,Aspose.Imaging.ImageOptionsBase) method as the second parameter.
public virtual ImageOptionsBase GetOriginalOptions()Returns
The options based on the original file settings.
GetProportionalHeight(int, int, int)
Gets a proportional height.
public static int GetProportionalHeight(int width, int height, int newWidth)Parameters
width int
The width.
height int
The height.
newWidth int
The new width.
Returns
The proportional height.
GetProportionalWidth(int, int, int)
Gets a proportional width.
public static int GetProportionalWidth(int width, int height, int newHeight)Parameters
width int
The width.
height int
The height.
newHeight int
The new height.
Returns
The proportional width.
GetSerializedStream(ImageOptionsBase, Rectangle, out int)
Converts to aps.
public virtual Stream GetSerializedStream(ImageOptionsBase imageOptions, Rectangle clippingRectangle, out int pageNumber)Parameters
imageOptions ImageOptionsBase
The image options.
clippingRectangle Rectangle
The clipping rectangle.
pageNumber int
The page number.
Returns
The serialized stream
Load(string, LoadOptions)
Loads a new image from the specified file path or URL.
If filePath is a file path the method just opens the file.
If filePath is an URL, the method downloads the file, stores it as a temporary one, and opens it.
public static Image Load(string filePath, LoadOptions loadOptions)Parameters
filePath string
The file path or URL to load image from.
loadOptions LoadOptions
The load options.
Returns
The loaded image.
Load(string)
Loads a new image from the specified file path or URL.
If filePath is a file path the method just opens the file.
If filePath is an URL, the method downloads the file, stores it as a temporary one, and opens it.
public static Image Load(string filePath)Parameters
filePath string
The file path or URL to load image from.
Returns
The loaded image.
Examples
This example demonstrates the loading of an existing Image file into an instance of Aspose.Imaging.Image using file path specified```csharp [C#]
//Create Image instance and initialize it with an existing image file from disk location
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"C:\temp\sample.bmp"))
{
//do some image processing
}
### <a id="Aspose_Imaging_Image_Load_System_IO_Stream_Aspose_Imaging_LoadOptions_"></a> Load\(Stream, LoadOptions\)
Loads a new image from the specified stream.
```csharp
public static Image Load(Stream stream, LoadOptions loadOptions)Parameters
stream Stream
The stream to load image from.
loadOptions LoadOptions
The load options.
Returns
The loaded image.
Load(Stream)
Loads a new image from the specified stream.
public static Image Load(Stream stream)Parameters
stream Stream
The stream to load image from.
Returns
The loaded image.
Examples
This example demonstrates the use of System.IO.Stream objects to load an existing Image file```csharp [C#]
//Create an instance of FileStream
using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\sample.bmp", System.IO.FileMode.Open))
{
//Create an instance of Image class and load an existing file through FileStream object by calling Load method
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(stream))
{
//do some image processing.
}
}
### <a id="Aspose_Imaging_Image_OnPaletteChanged_Aspose_Imaging_IColorPalette_Aspose_Imaging_IColorPalette_"></a> OnPaletteChanged\(IColorPalette, IColorPalette\)
Called when palette is changed.
```csharp
protected virtual void OnPaletteChanged(IColorPalette oldPalette, IColorPalette newPalette)Parameters
oldPalette IColorPalette
The old palette.
newPalette IColorPalette
The new palette.
OnPaletteChanging(IColorPalette, IColorPalette)
Called when palette is changing.
protected virtual void OnPaletteChanging(IColorPalette oldPalette, IColorPalette newPalette)Parameters
oldPalette IColorPalette
The old palette.
newPalette IColorPalette
The new palette.
ReleaseManagedResources()
Releases the managed resources. Make sure no unmanaged resources are released here, since they may have been already released.
protected override void ReleaseManagedResources()RemoveMetadata()
Removes metadata.
public virtual void RemoveMetadata()Resize(int, int)
Resizes the image. The default Aspose.Imaging.ResizeType.NearestNeighbourResample is used.
public void Resize(int newWidth, int newHeight)Parameters
newWidth int
The new width.
newHeight int
The new height.
Examples
The following example shows how to resize a metafile (WMF and EMF).```csharp [C#]
string dir = "c:\\aspose.imaging\\issues\\net\\3280\\";
string[] fileNames = new[] { "image3.emf", "image4.wmf" };
foreach (string fileName in fileNames)
{
string inputFilePath = dir + fileName;
string outputFilePath = dir + "Downscale_" + fileName;
using (Aspose.Imaging.FileFormats.Emf.MetaImage image = (Aspose.Imaging.FileFormats.Emf.MetaImage)Aspose.Imaging.Image.Load(inputFilePath))
{
image.Resize(image.Width / 4, image.Height / 4);
image.Save(outputFilePath);
}
}
The following example shows how to resize SVG image and save it to PNG.```csharp
[C#]
string dir = "c:\\aspose.imaging\\net\\issues\\3549";
string[] fileNames = new string[]
{
"Logotype.svg",
"sample_car.svg",
"rg1024_green_grapes.svg",
"MidMarkerFigure.svg",
"embeddedFonts.svg"
};
Aspose.Imaging.PointF[] scales = new Aspose.Imaging.PointF[]
{
new Aspose.Imaging.PointF(0.5f, 0.5f),
new Aspose.Imaging.PointF(1f, 1f),
new Aspose.Imaging.PointF(2f, 2f),
new Aspose.Imaging.PointF(3.5f, 9.2f),
};
foreach (string inputFile in fileNames)
{
foreach (Aspose.Imaging.PointF scale in scales)
{
string outputFile = string.Format("{0}_{1}_{2}.png", inputFile, scale.X.ToString(System.Globalization.CultureInfo.InvariantCulture), scale.Y.ToString(System.Globalization.CultureInfo.InvariantCulture));
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(System.IO.Path.Combine(dir, inputFile)))
{
image.Resize((int)(image.Width * scale.X), (int)(image.Height * scale.Y));
image.Save(System.IO.Path.Combine(dir, outputFile), new Aspose.Imaging.ImageOptions.PngOptions());
}
}
}Resize(int, int, ResizeType)
Resizes the image.
public virtual void Resize(int newWidth, int newHeight, ResizeType resizeType)Parameters
newWidth int
The new width.
newHeight int
The new height.
resizeType ResizeType
The resize type.
Examples
Resize EPS image and export it to PNG format.```csharp [C#]
// Load EPS image
using (var image = Image.Load("AstrixObelix.eps"))
{
// Resize the image using the Mitchell cubic interpolation method
image.Resize(400, 400, ResizeType.Mitchell);
// Export image to PNG format
image.Save("ExportResult.png", new PngOptions());
}
Resize image using specific Resize Type.```csharp
[C#]
using (var image = Image.Load("Photo.jpg"))
{
image.Resize(640, 480, ResizeType.CatmullRom);
image.Save("ResizedPhoto.jpg");
image.Resize(1024, 768, ResizeType.CubicConvolution);
image.Save("ResizedPhoto2.jpg");
var resizeSettings = new ImageResizeSettings
{
Mode = ResizeType.CubicBSpline,
FilterType = ImageFilterType.SmallRectangular
};
image.Resize(800, 800, resizeSettings);
image.Save("ResizedPhoto3.jpg");
}This example loads a WMF image and resizes it using various resizing methods.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.wmf"))
{
// Scale up by 2 times using Nearest Neighbour resampling.
image.Resize(image.Width * 2, image.Height * 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.wmf"))
{
// Scale down by 2 times using Nearest Neighbour resampling.
image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.wmf"))
{
// Scale up by 2 times using Bilinear resampling.
image.Resize(image.Width * 2, image.Height * 2, Aspose.Imaging.ResizeType.BilinearResample);
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.wmf"))
{
// Scale down by 2 times using Bilinear resampling.
image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);
}
This example loads an image and resizes it using various resizing methods.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Nearest Neighbour resampling.
image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "upsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Nearest Neighbour resampling.
image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "downsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Bilinear resampling.
image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "upsample.bilinear.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Bilinear resampling.
image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "downsample.bilinear.gif");
}This example loads a raster image and resizes it using various resizing methods.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Nearest Neighbour resampling.
image.Resize(image.Width * 2, image.Height * 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "upsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Nearest Neighbour resampling.
image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "downsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Bilinear resampling.
image.Resize(image.Width * 2, image.Height * 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "upsample.bilinear.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Bilinear resampling.
image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "downsample.bilinear.gif");
}
This example loads a multi-page ODG image and resizes it using various resizing methods.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.odg"))
{
// 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.Image image = Aspose.Imaging.Image.Load(dir + "sample.odg"))
{
// 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.Image image = Aspose.Imaging.Image.Load(dir + "sample.odg"))
{
// 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.Image image = Aspose.Imaging.Image.Load(dir + "sample.odg"))
{
// 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());
}Using a segment mask to speed up the segmentation process```csharp [C#]
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be transparent.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
maskingOptions.ExportOptions = exportOptions;
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Size imageSize = image.Size;
// Reducing image size to speed up the segmentation process
image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Getting the foreground mask
using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
{
// Increase the size of the mask to the size of the original image
foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
// Applying the mask to the original image to obtain a foreground segment
using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
originImage.Save(dir + "BigImage_foreground.png", exportOptions);
}
}
}
}
### <a id="Aspose_Imaging_Image_Resize_System_Int32_System_Int32_Aspose_Imaging_ImageResizeSettings_"></a> Resize\(int, int, ImageResizeSettings\)
Resizes the image.
```csharp
public abstract void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
The new width.
newHeight int
The new height.
settings ImageResizeSettings
The resize settings.
Examples
Resize image using specific Resize Type.```csharp [C#]
using (var image = Image.Load("Photo.jpg"))
{
image.Resize(640, 480, ResizeType.CatmullRom);
image.Save("ResizedPhoto.jpg");
image.Resize(1024, 768, ResizeType.CubicConvolution);
image.Save("ResizedPhoto2.jpg");
var resizeSettings = new ImageResizeSettings
{
Mode = ResizeType.CubicBSpline,
FilterType = ImageFilterType.SmallRectangular
};
image.Resize(800, 800, resizeSettings);
image.Save("ResizedPhoto3.jpg");
}
Resize EPS image using advanced settings.```csharp
[C#]
// Load EPS image
using (var image = Image.Load("AstrixObelix.eps"))
{
// Resize the image using advanced resize settings
image.Resize(400, 400, new ImageResizeSettings
{
// Set the interpolation mode
Mode = ResizeType.LanczosResample,
// Set the type of the filter
FilterType = ImageFilterType.SmallRectangular,
// Sets the color compare method
ColorCompareMethod = ColorCompareMethod.Euclidian,
// Set the color quantization method
ColorQuantizationMethod = ColorQuantizationMethod.Popularity
});
// Export image to PNG format
image.Save("ExportResult.png", new PngOptions());
}This example loads an image and resizes it using various resizing settings.```csharp [C#]
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.Load(dir + "sample.gif"))
{
// Scale down by 2 times using adaptive resampling.
image.Resize(image.Width / 2, image.Height / 2, resizeSettings);
image.Save(dir + "downsample.adaptive.gif");
}
### <a id="Aspose_Imaging_Image_ResizeHeightProportionally_System_Int32_"></a> ResizeHeightProportionally\(int\)
Resizes the height proportionally. The default Aspose.Imaging.ResizeType.NearestNeighbourResample is used.
```csharp
public void ResizeHeightProportionally(int newHeight)Parameters
newHeight int
The new height.
ResizeHeightProportionally(int, ResizeType)
Resizes the height proportionally.
public virtual void ResizeHeightProportionally(int newHeight, ResizeType resizeType)Parameters
newHeight int
The new height.
resizeType ResizeType
Type of the resize.
Examples
This example loads an image and resizes it proportionally using various resizing methods. Only the height is specified, the width is calculated automatically.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Nearest Neighbour resampling.
image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "upsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Nearest Neighbour resampling.
image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "upsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Bilinear resampling.
image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "upsample.bilinear.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Bilinear resampling.
image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "downsample.bilinear.gif");
}
Using a segment mask to speed up the segmentation process```csharp
[C#]
// Masking export options
Aspose.Imaging.ImageOptions.PngOptions exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();
exportOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
exportOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
Aspose.Imaging.Masking.Options.MaskingOptions maskingOptions = new Aspose.Imaging.Masking.Options.MaskingOptions();
// Use GraphCut clustering.
maskingOptions.Method = Masking.Options.SegmentationMethod.GraphCut;
maskingOptions.Decompose = false;
maskingOptions.Args = new Aspose.Imaging.Masking.Options.AutoMaskingArgs();
// The backgroung color will be transparent.
maskingOptions.BackgroundReplacementColor = Aspose.Imaging.Color.Transparent;
maskingOptions.ExportOptions = exportOptions;
string dir = "c:\\temp\\";
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Size imageSize = image.Size;
// Reducing image size to speed up the segmentation process
image.ResizeHeightProportionally(600, Aspose.Imaging.ResizeType.HighQualityResample);
// Create an instance of the ImageMasking class.
Aspose.Imaging.Masking.ImageMasking masking = new Aspose.Imaging.Masking.ImageMasking(image);
// Divide the source image into several clusters (segments).
using (Aspose.Imaging.Masking.Result.MaskingResult maskingResult = masking.Decompose(maskingOptions))
{
// Getting the foreground mask
using (Aspose.Imaging.RasterImage foregroundMask = maskingResult[1].GetMask())
{
// Increase the size of the mask to the size of the original image
foregroundMask.Resize(imageSize.Width, imageSize.Height, Aspose.Imaging.ResizeType.NearestNeighbourResample);
// Applying the mask to the original image to obtain a foreground segment
using (Aspose.Imaging.RasterImage originImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "BigImage.jpg"))
{
Aspose.Imaging.Masking.ImageMasking.ApplyMask(originImage, foregroundMask, maskingOptions);
originImage.Save(dir + "BigImage_foreground.png", exportOptions);
}
}
}
}ResizeHeightProportionally(int, ImageResizeSettings)
Resizes the height proportionally.
public virtual void ResizeHeightProportionally(int newHeight, ImageResizeSettings settings)Parameters
newHeight int
The new height.
settings ImageResizeSettings
The image resize settings.
ResizeWidthProportionally(int)
Resizes the width proportionally. The default Aspose.Imaging.ResizeType.NearestNeighbourResample is used.
public void ResizeWidthProportionally(int newWidth)Parameters
newWidth int
The new width.
ResizeWidthProportionally(int, ResizeType)
Resizes the width proportionally.
public virtual void ResizeWidthProportionally(int newWidth, ResizeType resizeType)Parameters
newWidth int
The new width.
resizeType ResizeType
Type of the resize.
Examples
This example loads an image and resizes it proportionally using various resizing methods. Only the width is specified, the height is calculated automatically.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Nearest Neighbour resampling.
image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "upsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Nearest Neighbour resampling.
image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
image.Save(dir + "downsample.nearestneighbour.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale up by 2 times using Bilinear resampling.
image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "upsample.bilinear.gif");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using Bilinear resampling.
image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.BilinearResample);
image.Save(dir + "downsample.bilinear.gif");
}
### <a id="Aspose_Imaging_Image_ResizeWidthProportionally_System_Int32_Aspose_Imaging_ImageResizeSettings_"></a> ResizeWidthProportionally\(int, ImageResizeSettings\)
Resizes the width proportionally.
```csharp
public virtual void ResizeWidthProportionally(int newWidth, ImageResizeSettings settings)Parameters
newWidth int
The new width.
settings ImageResizeSettings
The image resize settings.
Rotate(float)
Rotate image around the center.
public virtual void Rotate(float angle)Parameters
angle float
The rotate angle in degrees. Positive values will rotate clockwise.
RotateFlip(RotateFlipType)
Rotates, flips, or rotates and flips the image.
public abstract void RotateFlip(RotateFlipType rotateFlipType)Parameters
rotateFlipType RotateFlipType
Type of the rotate flip.
Examples
This example demonstrates the use of Rotate operation on an image. Example loads an existing image file from some disk location and performs the Rotate operaation on the image according to the value of Enum Aspose.Imaging.RotateFlipType```csharp [C#]
//Create an instance of image class and initialize it with an existing image file through File path
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"C:\temp\sample.bmp"))
{
//Rotate the image at 180 degree about X axis
image.RotateFlip(Aspose.Imaging.RotateFlipType.Rotate180FlipX);
// save all changes.
image.Save();
}
This example loads an image, rotates it by 90 degrees clockwise and optionally flips the image horizontally and(or) vertically.```csharp
[C#]
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.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
image.RotateFlip(rotateFlipType);
image.Save(dir + "sample." + rotateFlipType + ".bmp");
}
}This example loads a ODG image, rotates it by 90 degrees clockwise and optionally flips the image horizontally and(or) vertically.```csharp [C#]
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.Image rotateFlipType in rotateFlipTypes)
{
// Rotate, flip and save to the output file.
using (Aspose.Imaging.Image image = (Aspose.Imaging.FileFormats.OpenDocument.OdImage)Aspose.Imaging.Image.Load(dir + "sample.odg"))
{
image.RotateFlip(rotateFlipType);
image.Save(dir + "sample." + rotateFlipType + ".png", new Aspose.Imaging.ImageOptions.PngOptions());
}
}
### <a id="Aspose_Imaging_Image_Save"></a> Save\(\)
Saves the image data to the underlying stream.
```csharp
public override sealed void Save()Examples
The following example shows how to save an entiree BMP image or part of it to a file or stream.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;
// Convert to a black-white image
bmpImage.BinarizeOtsu();
// Save to the same location with default options.
image.Save();
Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
// A palette contains only two colors: Black and White in this case.
saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.CreateMonochrome();
// For all monochrome images (including black-white ones) it is enough to allocate 1 bit per pixel.
saveOptions.BitsPerPixel = 1;
// Save to another location with the specified options.
image.Save(dir + "sample.bw.palettized.bmp", saveOptions);
// Save only the central part of the image.
Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Save(dir + "sample.bw.palettized.part.bmp", saveOptions, bounds);
// Save the entire image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions);
System.Console.WriteLine("The size of the whole image in bytes: {0}", stream.Length);
}
// Save the central part of the image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions, bounds);
System.Console.WriteLine("The size of the central part of the image in bytes: {0}", stream.Length);
}
}
//The output may look like this:
//The size of the whole image in bytes: 24062
//The size of the central part of the image in bytes: 6046
### <a id="Aspose_Imaging_Image_Save_System_String_"></a> Save\(string\)
Saves the image to the specified file location.
```csharp
public override void Save(string filePath)Parameters
filePath string
The file path to save the image to.
Save(string, ImageOptionsBase)
Saves the object’s data to the specified file location in the specified file format according to save options.
public virtual void Save(string filePath, ImageOptionsBase options)Parameters
filePath string
The file path.
options ImageOptionsBase
The options.
Examples
The following example loads a BMP image from a file, then saves the image to a PNG file.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
// Save the entire image to a PNG file.
Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
image.Save(dir + "output.png", saveOptions);
}
This example shows the simple steps to Save an Image. To demonstrate this operation, we load an existing file from some disk location, performs Rotate operation on the image and Save the image in PSD format using File Path```csharp
[C#]
string dir = "c:\\temp\\";
//Create an instance of image class and initialize it with an existing file through File path
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
//Rotate the image at 180 degree about X axis
image.RotateFlip(Aspose.Imaging.RotateFlipType.Rotate180FlipX);
//Save the Image as PSD to File Path with default PsdOptions settings
image.Save(dir + "output.psd", new Aspose.Imaging.ImageOptions.PsdOptions());
}The following example shows how to save an entiree BMP image or part of it to a file or stream.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;
// Convert to a black-white image
bmpImage.BinarizeOtsu();
// Save to the same location with default options.
image.Save();
Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
// A palette contains only two colors: Black and White in this case.
saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.CreateMonochrome();
// For all monochrome images (including black-white ones) it is enough to allocate 1 bit per pixel.
saveOptions.BitsPerPixel = 1;
// Save to another location with the specified options.
image.Save(dir + "sample.bw.palettized.bmp", saveOptions);
// Save only the central part of the image.
Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Save(dir + "sample.bw.palettized.part.bmp", saveOptions, bounds);
// Save the entire image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions);
System.Console.WriteLine("The size of the whole image in bytes: {0}", stream.Length);
}
// Save the central part of the image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions, bounds);
System.Console.WriteLine("The size of the central part of the image in bytes: {0}", stream.Length);
}
}
//The output may look like this:
//The size of the whole image in bytes: 24062
//The size of the central part of the image in bytes: 6046
### <a id="Aspose_Imaging_Image_Save_System_String_Aspose_Imaging_ImageOptionsBase_Aspose_Imaging_Rectangle_"></a> Save\(string, ImageOptionsBase, Rectangle\)
Saves the object's data to the specified file location in the specified file format according to save options.
```csharp
public virtual void Save(string filePath, ImageOptionsBase options, Rectangle boundsRectangle)Parameters
filePath string
The file path.
options ImageOptionsBase
The options.
boundsRectangle Rectangle
The destination image bounds rectangle. Set the empty rectangle for use sourse bounds.
Examples
The following example loads a BMP image from a file, then saves a rectangular part of the image to a PNG file.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
// Save the upper half of the image to a PNG file.
Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(0, 0, image.Width, image.Height / 2);
image.Save(dir + "output.png", saveOptions, bounds);
}
The following example shows how to save an entiree BMP image or part of it to a file or stream.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;
// Convert to a black-white image
bmpImage.BinarizeOtsu();
// Save to the same location with default options.
image.Save();
Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
// A palette contains only two colors: Black and White in this case.
saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.CreateMonochrome();
// For all monochrome images (including black-white ones) it is enough to allocate 1 bit per pixel.
saveOptions.BitsPerPixel = 1;
// Save to another location with the specified options.
image.Save(dir + "sample.bw.palettized.bmp", saveOptions);
// Save only the central part of the image.
Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Save(dir + "sample.bw.palettized.part.bmp", saveOptions, bounds);
// Save the entire image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions);
System.Console.WriteLine("The size of the whole image in bytes: {0}", stream.Length);
}
// Save the central part of the image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions, bounds);
System.Console.WriteLine("The size of the central part of the image in bytes: {0}", stream.Length);
}
}
//The output may look like this:
//The size of the whole image in bytes: 24062
//The size of the central part of the image in bytes: 6046Exceptions
options
Image saving failed.
Save(Stream, ImageOptionsBase)
Saves the image’s data to the specified stream in the specified file format according to save options.
public void Save(Stream stream, ImageOptionsBase optionsBase)Parameters
stream Stream
The stream to save the image’s data to.
optionsBase ImageOptionsBase
The save options.
Examples
The following example loads an image from a file, then saves the image to a PNG file stream.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
using (System.IO.Stream outputStream = System.IO.File.Open(dir + "output.png", System.IO.FileMode.Create))
{
// Save the entire image to a file stream.
image.Save(outputStream, saveOptions);
}
}
This example shows the process of Saving an Image to MemoryStream. To demonstrate this operation, example loads an existing file from some disk location, performs Rotate operation on the image and Save the image in PSD format```csharp
[C#]
//Create an instance of MemoryStream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
//Create an instance of image class and initialize it with an existing file through File path
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"C:\temp\sample.bmp"))
{
//Rotate the image at 180 degree about X axis
image.RotateFlip(Aspose.Imaging.RotateFlipType.Rotate180FlipX);
//Save the Image as PSD to MemoryStream with default PsdOptions settings
image.Save(stream, new Aspose.Imaging.ImageOptions.PsdOptions());
}
}The following example shows how to save an entiree BMP image or part of it to a file or stream.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;
// Convert to a black-white image
bmpImage.BinarizeOtsu();
// Save to the same location with default options.
image.Save();
Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
// A palette contains only two colors: Black and White in this case.
saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.CreateMonochrome();
// For all monochrome images (including black-white ones) it is enough to allocate 1 bit per pixel.
saveOptions.BitsPerPixel = 1;
// Save to another location with the specified options.
image.Save(dir + "sample.bw.palettized.bmp", saveOptions);
// Save only the central part of the image.
Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Save(dir + "sample.bw.palettized.part.bmp", saveOptions, bounds);
// Save the entire image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions);
System.Console.WriteLine("The size of the whole image in bytes: {0}", stream.Length);
}
// Save the central part of the image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions, bounds);
System.Console.WriteLine("The size of the central part of the image in bytes: {0}", stream.Length);
}
}
//The output may look like this:
//The size of the whole image in bytes: 24062
//The size of the central part of the image in bytes: 6046
#### Exceptions
[ArgumentNullException](https://learn.microsoft.com/dotnet/api/system.argumentnullexception)
optionsBase
[ArgumentException](https://learn.microsoft.com/dotnet/api/system.argumentexception)
Cannot save to the specified format as it is not supported at the moment.;optionsBase
[ImageSaveException](/imaging/aspose.imaging.coreexceptions.imagesaveexception)
Image export failed.
### <a id="Aspose_Imaging_Image_Save_System_IO_Stream_Aspose_Imaging_ImageOptionsBase_Aspose_Imaging_Rectangle_"></a> Save\(Stream, ImageOptionsBase, Rectangle\)
Saves the image's data to the specified stream in the specified file format according to save options.
```csharp
public virtual void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
The stream to save the image’s data to.
optionsBase ImageOptionsBase
The save options.
boundsRectangle Rectangle
The destination image bounds rectangle. Set the empty rectangle for use source bounds.
Examples
The following example loads an image from a file, then saves a rectangular part of the image to a PNG file stream.```csharp [C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(0, 0, image.Width, image.Height / 2);
using (System.IO.Stream outputStream = System.IO.File.Open(dir + "sample.output.png", System.IO.FileMode.Create))
{
// Save the upper half of the image to a file stream.
image.Save(outputStream, saveOptions, bounds);
}
}
The following example shows how to save an entiree BMP image or part of it to a file or stream.```csharp
[C#]
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
{
Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;
// Convert to a black-white image
bmpImage.BinarizeOtsu();
// Save to the same location with default options.
image.Save();
Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
// A palette contains only two colors: Black and White in this case.
saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.CreateMonochrome();
// For all monochrome images (including black-white ones) it is enough to allocate 1 bit per pixel.
saveOptions.BitsPerPixel = 1;
// Save to another location with the specified options.
image.Save(dir + "sample.bw.palettized.bmp", saveOptions);
// Save only the central part of the image.
Aspose.Imaging.Rectangle bounds = new Aspose.Imaging.Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Save(dir + "sample.bw.palettized.part.bmp", saveOptions, bounds);
// Save the entire image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions);
System.Console.WriteLine("The size of the whole image in bytes: {0}", stream.Length);
}
// Save the central part of the image to a memory stream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
image.Save(stream, saveOptions, bounds);
System.Console.WriteLine("The size of the central part of the image in bytes: {0}", stream.Length);
}
}
//The output may look like this:
//The size of the whole image in bytes: 24062
//The size of the central part of the image in bytes: 6046Exceptions
optionsBase
Cannot save to the specified format as it is not supported at the moment.;optionsBase
Image export failed.
SetPalette(IColorPalette, bool)
Sets the image palette.
public abstract void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
The palette to set.
updateColors bool
if set to true colors will be updated according to the new palette; otherwise color indexes remain unchanged. Note that unchanged indexes may crash the image on loading if some indexes have no corresponding palette entries.
UpdateContainer(Image)
Updates the container.
protected void UpdateContainer(Image container)Parameters
container Image
The container.