readme.md

Aspose.Imaging.Cloud .NET API allows programmatically convert your gif animations to various image formats with high quality in your .NET application or Web service.

You can:

• convert gif animation to images;
• convert gif to other animated format;
• create storyboard, converting to pdf or other multi page format.

Interested ?

You may go further at : https://products.aspose.cloud/imaging/net/

gif-to-apng.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "apng";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "apng")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "apng";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "apng")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-bmp.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "bmp";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "bmp")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "bmp";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "bmp")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-dicom.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "dicom";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "dicom")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "dicom";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "dicom")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-jpeg.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "jpeg";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "jpeg")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "jpeg";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "jpeg")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-jpeg2000.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "jpeg2000";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "jpeg2000")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "jpeg2000";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "jpeg2000")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-jpg.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "jpg";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "jpg")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "jpg";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "jpg")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-pdf.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "pdf";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "pdf")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "pdf";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "pdf")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-png.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "png";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "png")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "png";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "png")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-psd.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "psd";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "psd")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "psd";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "psd")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-tga.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "tga";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "tga")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "tga";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "tga")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-tiff.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "tiff";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "tiff")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "tiff";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "tiff")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}

gif-to-webp.cs

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;

string ImageFileName = "example_image.gif";
string ImagesFolder = "ExampleImages";
string CloudFolder = "CloudImages";
string OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
var api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/// <summary>
/// Convert an image to another format.
/// </summary>
public void ConvertImageFromStorage()
{
    // Upload image to cloud storage
    using (var localInputImage = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudFolder, imageName), image);
        var result = api.UploadFile(uploadFileRequest);
        if (result.Errors?.Count > 0)
            throw new Exception($"Uploading errors count: {result.Errors.Count}");
    }

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
    // for possible output formats
    var format = "webp";
    var folder = CloudFolder; // Input file is saved at the desired folder in the storage
    string storage = null; // Cloud Storage name

    var request = new ConvertImageRequest(SampleImageFileName, format, folder, storage);
    using (var updatedImage = api.ConvertImage(request))
    {
        // Save the image file to output folder
        var convertedImageName = Path.ChangeExtension(ImageFileName, "webp")
        var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
        using (var fileStream = File.Create(path))
        {
            updatedImage.Seek(0, SeekOrigin.Begin);
            updatedImage.CopyTo(fileStream);
        }
    }
}

/// <summary>
/// Convert an image to another format. Image data is passed in a request stream.
/// </summary>
public void CreateConvertedImageFromRequest()
{
    using (var inputImageStream = File.OpenRead(Path.Combine(ImagesFolder, ImageFileName)))
    {
        // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#convert
        // for possible output formats
        var format = "webp";
        string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
        string storage = null; // Cloud Storage name

        var request = new CreateConvertedImageRequest(inputImageStream, format, outPath, storage);

        using (var updatedImage = api.CreateConvertedImage(request))
        {           
            // Save the image file to output folder
            var convertedImageName = Path.ChangeExtension(ImageFileName, "webp")
            var path = Path.GetFullPath(Path.Combine(OutputFolder, convertedImageName));
            using (var fileStream = File.Create(path))
            {
                updatedImage.Seek(0, SeekOrigin.Begin);
                updatedImage.CopyTo(fileStream);
            }
        }
    }
}