Tutorial: Performing Multiple Operations on Images in a Single API Call

Learning Objectives

In this tutorial, you’ll learn how to:

Combine multiple image processing operations in a single API call
Perform scaling, cropping, flipping, and format conversion together
Optimize your API usage for better performance
Implement these combined operations both with and without cloud storage

Prerequisites

Before you begin this tutorial, make sure you have:

An Aspose Cloud account (obtain a free trial here)
Your Client ID and Client Secret from the dashboard
Basic understanding of REST API concepts
Your preferred development environment set up (.NET, Java, or cURL)
Completed previous tutorials in this series (recommended)

Practical Use Case

Combining multiple image operations in a single call is essential for:

Optimizing image processing workflows by reducing API calls
Creating thumbnails that are cropped, resized, and properly oriented
Processing batches of images with consistent transformations
Building efficient image processing pipelines for web applications
Reducing latency in real-time image processing applications

Tutorial Steps

Step 1: Understanding the UpdateImage API

Aspose.Imaging Cloud provides two API endpoints for performing multiple operations in a single call:

With Storage (GET method): Upload your image to Cloud Storage first, then process it using its name.
- Endpoint: GET /imaging/{name}/updateImage
Without Storage (POST method): Directly send your image in the request body.
- Endpoint: POST /imaging/updateImage

Both methods allow you to specify multiple operations including:

Resizing (new width and height)
Cropping (x, y, width, height)
Rotation and flipping (rotateFlipMethod)
Format conversion (format)

Step 2: Authentication

Before making API calls, you need to obtain a JWT token:

curl -v "https://api.aspose.cloud/connect/token" \
-X POST \
-d 'grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET' \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Accept: application/json"

Save the returned JWT token for use in subsequent API calls.

Step 3: Perform Multiple Operations (With Storage)

3.1 First, upload your image to cloud storage

curl -X PUT "https://api.aspose.cloud/v3/imaging/storage/file/Sample.psd" \
-H "Authorization: Bearer YOUR_JWT_TOKEN" \
-H "Content-Type: application/octet-stream" \
-T /path/to/your/Sample.psd

3.2 Apply multiple operations at once

curl -v "https://api.aspose.cloud/v3/imaging/Sample.psd/updateImage?format=png&newWidth=300&newHeight=300&x=10&y=10&rectWidth=200&rectHeight=200&rotateFlipMethod=Rotate90FlipX" \
-X GET \
-H "Content-Type: application/json" \
-H "Accept: multipart/form-data" \
-H "Authorization: Bearer YOUR_JWT_TOKEN" \
-o processed_image.png

In this example:

We’re resizing the image to 300x300 pixels
We’re cropping a rectangle starting at (10, 10) with size 200x200
We’re rotating the image 90° clockwise and flipping it horizontally
We’re converting from PSD to PNG format

Step 4: Perform Multiple Operations (Without Storage)

For quick processing without storing the image first:

curl -v "https://api.aspose.cloud/v3/imaging/updateImage?format=png&newWidth=300&newHeight=300&x=10&y=10&rectWidth=200&rectHeight=200&rotateFlipMethod=Rotate90FlipX" \
-X POST \
-T /path/to/your/Sample.psd \
-H "Content-Type: application/json" \
-H "Accept: multipart/form-data" \
-H "Authorization: Bearer YOUR_JWT_TOKEN" \
-o processed_image.png

Step 5: Understanding the Operation Order

When combining multiple operations, it’s important to understand the order in which they are applied:

Resize is applied first (if specified)
Crop is applied second (if specified)
RotateFlip is applied third (if specified)
Format conversion is applied last

This sequence can impact your results, so plan your parameters accordingly.

Try It Yourself

Now it’s your turn! Choose an image from your computer and try:

Resizing it to 400x400 pixels
Cropping a 300x300 rectangle from position (50, 50)
Rotating it 180 degrees
Converting it to JPEG format
Trying both the storage and non-storage methods

Remember to replace the placeholder values with your actual image path, JWT token, and desired parameters.

SDK Implementation Examples

C# (.NET) Example

// Update an image with multiple operations in cloud storage
public static void UpdateImageInCloud()
{
    // Get your clientId and clientSecret from https://dashboard.aspose.cloud/
    var imagingApi = new ImagingApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
    
    try
    {
        // Upload an image to cloud storage (required for this example)
        string localInputImage = "Sample.psd";
        string uploadedImageName = "Sample.psd";
        
        using (FileStream imageStream = new FileStream(localInputImage, FileMode.Open))
        {
            UploadFileRequest uploadRequest = 
                new UploadFileRequest(uploadedImageName, imageStream);
            imagingApi.UploadFile(uploadRequest);
        }
        
        // Set multiple operation parameters
        int newWidth = 300;
        int newHeight = 300;
        int x = 10;
        int y = 10;
        int rectWidth = 200;
        int rectHeight = 200;
        string rotateFlipMethod = "Rotate90FlipX";
        string format = "png";
        
        // Create request for the update operation
        UpdateImageRequest request = new UpdateImageRequest(
            uploadedImageName, format, 
            newWidth, newHeight, 
            x, y, rectWidth, rectHeight,
            rotateFlipMethod);
            
        // Perform the update operation
        using (var resultStream = imagingApi.UpdateImage(request))
        {
            // Save the processed image to a local file
            using (FileStream fileStream = 
                new FileStream("processed_image.png", FileMode.Create))
            {
                resultStream.CopyTo(fileStream);
            }
        }
        
        Console.WriteLine("Image has been successfully processed with multiple operations!");
    }
    catch (Exception ex)
    {
        Console.WriteLine("Error: " + ex.Message);
    }
}

Java Example

// Update an image with multiple operations in the request body
public static void updateImageWithoutStorage() throws Exception 
{
    // Get your clientId and clientSecret from https://dashboard.aspose.cloud/
    ImagingApi imagingApi = new ImagingApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
    
    try 
    {
        // Specify the local image file path
        String localInputImage = "Sample.psd";
        
        // Set multiple operation parameters
        int newWidth = 300;
        int newHeight = 300;
        int x = 10;
        int y = 10;
        int rectWidth = 200;
        int rectHeight = 200;
        String rotateFlipMethod = "Rotate90FlipX";
        String format = "png";
        
        // Read the image into a byte array
        byte[] imageData = Files.readAllBytes(Paths.get(localInputImage));
        
        // Create request for update operation
        CreateUpdatedImageRequest request = new CreateUpdatedImageRequest(
            imageData, format, 
            newWidth, newHeight, 
            x, y, rectWidth, rectHeight,
            rotateFlipMethod, null);
        
        // Perform the update operation
        byte[] resultImage = imagingApi.createUpdatedImage(request);
        
        // Save the processed image to a local file
        Files.write(Paths.get("processed_image.png"), resultImage);
        
        System.out.println("Image has been successfully processed with multiple operations!");
    } 
    catch (Exception e) 
    {
        System.out.println("Error: " + e.getMessage());
        e.printStackTrace();
    }
}

Troubleshooting Tips

Authentication Errors: Ensure your Client ID and Client Secret are correct and your subscription is active.
404 Not Found: Check if the image path in cloud storage is correct.
Parameter Conflicts: Ensure your parameters make sense together. For example, make sure the crop rectangle is within the bounds of the resized image.
Operation Order: Remember the operations are applied in a specific order (resize, crop, rotate/flip, format). Plan your parameters accordingly.
Format Support: Some operations may not be supported for all formats. Check the format support documentation for compatibility.

What You’ve Learned

In this tutorial, you’ve learned how to:

Authenticate with the Aspose.Imaging Cloud API
Combine multiple image operations in a single API call
Understand the order in which operations are applied
Implement combined operations with both storage and non-storage approaches
Process images efficiently for improved performance

Further Practice

To strengthen your understanding, try these additional exercises:

Create a batch processor that applies the same set of operations to multiple images
Experiment with different combinations of operations to see how they interact
Create a function that intelligently determines crop and resize parameters based on the source image
Build a simple image transformation tool that uses the combined operations API

Next Tutorial

Ready to learn more? Continue to our Grayscale Image Conversion Tutorial to discover how to convert images to grayscale.

Helpful Resources

Have questions about this tutorial? Feel free to visit our forum for assistance.