Mastering Image Rotation in Java

Images are everywhere, and ensuring they’re displayed in the correct orientation is crucial for a positive user experience. According to Venngage, over 50% of marketers agree that visual content is essential to their marketing strategy, highlighting the importance of images.

Mastering image manipulation techniques is essential for Java developers. While various cloud-based solutions offer image processing features, sometimes you need more control. In this article, we’ll examine how to rotate images in Java. We’ll guide you through the process, from loading an image to achieving perfect rotation, allowing you to ensure that your applications always showcase visuals in the best possible way.

In this article:

• Rotating an Image in Java
  • Prerequisites
  • Loading an Image
  • Implementing Rotation

Rotating an Image in Java

Cloudinary, a powerful cloud-based media management platform, simplifies image rotation for Java developers. Rotating images using traditional Java libraries can sometimes lead to minor quality loss, especially with repeated rotations. Instead of losing quality, Cloudinary utilizes advanced algorithms to perform lossless rotations, ensuring your images retain their crispness.

For applications dealing with a high volume of image uploads and rotations, Cloudinary’s cloud-based infrastructure takes the load off your servers. Cloudinary handles the processing efficiently, allowing you to focus on your core application logic.

Prerequisites

Before diving into image rotation with Cloudinary in your Java project, you must ensure you have the latest version of Java installed on your System. If you don’t have Java installed, download and install the latest Java Development Kit (JDK) from the official Oracle website.

Next, you will need a code editor to manage your project. No matter your preferred code editor, ensure you have a way to manage your Java project’s build process. Popular IDEs like IntelliJ streamline this, but editors like VS Code will need a separate tool. To do this, you must install the “Extension Pack for Java” from the VS Code marketplace. So open up and head over to the Extensions tab. Click on the search bar, search for the Extension pack, and install it.

Finally, to use Cloudinary’s image rotation features in your Java project, you’ll need a Cloudinary account. If you haven’t already, you can sign up for free. For now, we will use our Cloudinary API credentials, so head over to Cloudinary and log in to your account.

Next, click the Programmable Media button to head to your Cloudinary Programmable Media Dashboard. There, you’ll find your API credentials, such as your Cloud Name, API Key, and API Secret. Copy these credentials and store them in your clipboard, as we’ll need them to connect to Cloudinary’s cloud.

With this, we are ready to begin creating our Java Project.

Loading an Image for Rotation

Before we can load an image for rotation, we will need to set up our Java project. To do this, open up a new window in Visual Studio Code. Here, we will start by clicking on the Create Java Project button and selecting Maven as the project type:

Next, select the No Archetype… option to create a new basic Maven project directly for you to build:

Now, give your project a group id, which will help you uniquely identify this project across all projects, helping you keep track:

Next, name your project by adding an artifact ID. Here, we have named our project “imagerotation”:

Finally, choose the directory where you want to save your project:

Before we can load an image, we need to import the Cloudinary Java SDK to help us rotate our images.

To do this, head over to pom.xml file located in the main directory of our project. Here, we will add a <dependency> tag and add the Cloudinary SDK as a dependency of our project:

        
            com.cloudinary
            cloudinary-http44
            1.37.0
        

Now, we can begin loading our image. So open up your Main.Java file located in src\main\java\com\imagerotation directory. Here, we will start by adding some imports from the Cloudinary SDK, as well as imports that will help us open our PDF files:

// Import necessary libraries
import com.cloudinary.Cloudinary;
import com.cloudinary.Transformation;
import com.cloudinary.utils.ObjectUtils;

import java.io.File;
import java.io.IOException;
import java.util.Map;

Next, we will start by defining our Cloudinary API in the main() function:

public class Main {
    public static void main(String[] args) {
        // Initialize Cloudinary with your cloud name, API key, and API secret
        Cloudinary cloudinary = new Cloudinary(ObjectUtils.asMap(
                "cloud_name", "your_cloud_name",
                "api_key", "your_api_key",
                "api_secret", "your_api_secret"));

Make sure to replace "your_cloud_name", "your_api_key", and "your_api_secret" with your actual Cloudinary credentials.

Next, we will specify a file to upload to our Cloudinary cloud. Here, we will upload cld-sample.jpg from the Cloudinary demo cloud. Additionally, we will define a Map variable called uploadResult that will help us store the result of our API call.

  // Specify the file to upload
File toUpload = new File("cld-sample.jpg");
Map<String, Object> uploadResult = null;

Finally, we will create a try-catch block that will call in the cloudinary.upload() function to upload our image to the Cloudinary cloud. Here, we will use the uploadResult map to store the result of our API call and extract the public ID of our image. We will finally use the public ID to generate a URL for our image. Here is what our main function looks like:

public static void main(String[] args) {
        // Initialize Cloudinary with your cloud name, API key, and API secret
        Cloudinary cloudinary = new Cloudinary(ObjectUtils.asMap(
                "cloud_name", "your_cloud_name",
                "api_key", "your_api_key",
                "api_secret", "your_api_secret"));

        // Specify the file to upload
        File toUpload = new File("cld-sample.jpg");
        Map<String, Object> uploadResult = null;

        try {
            // Upload the file to Cloudinary and store the result
            uploadResult = cloudinary.uploader().upload(toUpload, ObjectUtils.asMap("resource_type", "image"));

            // Get the public ID of the uploaded file
            String publicId = (String) uploadResult.get("public_id");

            // Generate a URL for the uploaded image with no transformations
            String transformedImage = cloudinary.url().format("jpg").generate(publicId);

            // Print the URL of the transformed image
            System.out.println(transformedImage);


        } catch (IOException e) {
            // Print the stack trace for any IOExceptions
            e.printStackTrace();
        }
    }

Now, all we need to do is run our project by pressing Crtl+F5 or clicking the Play button at the top-right corner of your screen. This will generate your image URL:

You can verify that your image has been uploaded by opening up your URL or heading to the Assets tab in the Media Library.

Implementing the Rotation Algorithm

Now that we know how to upload our image, let’s transform it by adding rotations. To do this, we will start by creating a new function called rotateImage that will take in three parameters: our cloudinary API, the public ID of our image, and finally, the angle of our rotation.

public static void rotateImage(Cloudinary cloudinary, String publicId, int angle) {
    }

Next, we create a new transformation, t, where we define our angle of rotation.

Transformation t = new Transformation().angle(angle);

Finally, we use the cloudinary.url().transformation() function to rotate our uploaded image. We then print the URL in the terminal. Here is what our complete rotateImage() function looks like:

public static void rotateImage(Cloudinary cloudinary, String publicId, int angle) {
        Transformation t = new Transformation().angle(angle);
        String rotatedImage = cloudinary.url().transformation(t).format("jpg")
                .generate(publicId);
        System.out.println("Image rotated by " + angle + " degrees: " + rotatedImage);
    }

Now, we can call this function inside our main() function to rotate our image. For now, we will be rotating our image in 3 different ways:

...
  // Rotate the image by a specific angle
  rotateImage(cloudinary, publicId, 45);
  rotateImage(cloudinary, publicId, -45);
  rotateImage(cloudinary, publicId, 90);
...

Here is what our complete Main.java file looks like:

// Import necessary libraries
import com.cloudinary.Cloudinary;
import com.cloudinary.Transformation;
import com.cloudinary.utils.ObjectUtils;

import java.io.File;
import java.io.IOException;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // Initialize Cloudinary with your cloud name, API key, and API secret
        Cloudinary cloudinary = new Cloudinary(ObjectUtils.asMap(
                "cloud_name", "your_cloud_name",
                "api_key", "your_api_key",
                "api_secret", "your_api_secret"));

        // Specify the file to upload
        File toUpload = new File("cld-sample.jpg");
        Map<String, Object> uploadResult = null;

        try {
            // Upload the file to Cloudinary and store the result
            uploadResult = cloudinary.uploader().upload(toUpload, ObjectUtils.asMap("resource_type", "image"));

            // Get the public ID of the uploaded file
            String publicId = (String) uploadResult.get("public_id");

            // Generate a URL for the uploaded image with no transformations
            String transformedImage = cloudinary.url().format("jpg").generate(publicId);

            // Print the URL of the transformed image
            System.out.println(transformedImage);

            // Rotate the image by a specific angle
            rotateImage(cloudinary, publicId, 45);
            rotateImage(cloudinary, publicId, -45);
            rotateImage(cloudinary, publicId, 90);

        } catch (IOException e) {
            // Print the stack trace for any IOExceptions
            e.printStackTrace();
        }

    }

    public static void rotateImage(Cloudinary cloudinary, String publicId, int angle) {
        Transformation t = new Transformation().angle(angle);
        String rotatedImage = cloudinary.url().transformation(t).format("jpg")
                .generate(publicId);
        System.out.println("Image rotated by " + angle + " degrees: " + rotatedImage);
    }
}

Now, all we need to do is run our code.

Here is what our 45-degree rotated image looks like:

Final Thoughts

The ability to rotate images within your Java projects is valuable, regardless of your programming skill. As user interfaces become increasingly complex and user experience remains important, ensuring your images look good and fit your visual theme is key.

Traditional Java libraries can sometimes introduce minor quality loss during image rotation, especially with repeated operations. Cloudinary, on the other hand, utilizes advanced algorithms to perform lossless rotations, ensuring your images retain their crispness and visual fidelity. Beyond basic rotation, mastering image manipulation techniques in Java unlocks a wider range of functionalities.

By leveraging Cloudinary’s tools alongside Java, you can effortlessly resize, crop, and adjust visual elements while maintaining exceptional image quality. This allows you to optimize images for projects and provide the best experience to your users while ensuring peak application performance.

So what are you waiting for? Sign up for a free account today to start creating stunning applications while guaranteeing the best performance possible.

More from Cloudinary:

8 Image Transformations Developers Can Make On The Fly – Learning By Example

Optimizing Image Optimization Using AI