### Async Image Resizing and Rotation with AsyncScalr

Source: https://context7.com/rkalla/imgscalr/llms.txt

Demonstrates asynchronous image resizing and rotation using AsyncScalr. It shows how to submit operations that return Future objects, allowing for non-blocking execution. The code includes examples of retrieving results, handling timeouts, and performing batch processing. It also shows how to properly shut down the internal ExecutorService.

```java
import org.imgscalr.AsyncScalr;
import org.imgscalr.Scalr.Method;
import org.imgscalr.Scalr.Rotation;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

// Configure thread count via system property (default is 2)
// Set before class loads: -Dimgscalr.async.threadCount=4

BufferedImage srcImage = ImageIO.read(new File("large_photo.jpg"));

// Submit async resize operation (returns immediately)
Future<BufferedImage> futureThumb = AsyncScalr.resize(srcImage, 150);
Future<BufferedImage> futureMedium = AsyncScalr.resize(srcImage, Method.QUALITY, 800);
Future<BufferedImage> futureRotated = AsyncScalr.rotate(srcImage, Rotation.CW_90);

// Do other work while images process...
System.out.println("Processing images asynchronously...");

// Block and get results when needed
BufferedImage thumbnail = futureThumb.get();
BufferedImage medium = futureMedium.get();
BufferedImage rotated = futureRotated.get();

// With timeout
BufferedImage withTimeout = AsyncScalr.resize(srcImage, 300).get(30, TimeUnit.SECONDS);

// Save results
ImageIO.write(thumbnail, "PNG", new File("async_thumb.png"));
ImageIO.write(medium, "PNG", new File("async_medium.png"));

// Batch processing example
File[] sourceFiles = new File("images/").listFiles();
Future<BufferedImage>[] futures = new Future[sourceFiles.length];

for (int i = 0; i < sourceFiles.length; i++) {
    BufferedImage img = ImageIO.read(sourceFiles[i]);
    futures[i] = AsyncScalr.resize(img, Method.QUALITY, 200);
}

// Collect all results
for (int i = 0; i < futures.length; i++) {
    BufferedImage result = futures[i].get();
    ImageIO.write(result, "PNG", new File("thumbnails/thumb_" + i + ".png"));
}

// Clean shutdown when application exits
ExecutorService service = AsyncScalr.getService();
service.shutdown();
service.awaitTermination(60, TimeUnit.SECONDS);
```

--------------------------------

### Cropping Images with imgscalr

Source: https://context7.com/rkalla/imgscalr/llms.txt

Covers extracting rectangular regions from images using top-left or coordinate-based offsets. Includes examples for creating centered square crops and chaining crop/resize operations.

```java
import org.imgscalr.Scalr;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("photo.jpg"));
BufferedImage croppedSimple = Scalr.crop(srcImage, 200, 200);
BufferedImage croppedOffset = Scalr.crop(srcImage, 50, 50, 300, 200);
BufferedImage croppedWithOp = Scalr.crop(srcImage, 100, 100, 400, 300, Scalr.OP_ANTIALIAS);
int size = Math.min(srcImage.getWidth(), srcImage.getHeight());
int x = (srcImage.getWidth() - size) / 2;
int y = (srcImage.getHeight() - size) / 2;
BufferedImage centeredSquare = Scalr.crop(srcImage, x, y, size, size);
BufferedImage squareThumbnail = Scalr.resize(Scalr.crop(srcImage, x, y, size, size), 150);
ImageIO.write(squareThumbnail, "PNG", new File("square_thumbnail.png"));
srcImage.flush();
```

--------------------------------

### Control scaling quality with Scalr.Method

Source: https://context7.com/rkalla/imgscalr/llms.txt

Shows how to explicitly control the scaling algorithm using Scalr.Method, ranging from SPEED for performance to ULTRA_QUALITY for high-fidelity thumbnail generation.

```java
import org.imgscalr.Scalr;
import org.imgscalr.Scalr.Method;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("photo.jpg"));

BufferedImage fastResult = Scalr.resize(srcImage, Method.SPEED, 800);
BufferedImage balancedResult = Scalr.resize(srcImage, Method.BALANCED, 800);
BufferedImage qualityResult = Scalr.resize(srcImage, Method.QUALITY, 150);
BufferedImage ultraResult = Scalr.resize(srcImage, Method.ULTRA_QUALITY, 100);
BufferedImage autoResult = Scalr.resize(srcImage, Method.AUTOMATIC, 500);

ImageIO.write(ultraResult, "PNG", new File("ultra_quality_thumbnail.png"));
srcImage.flush();
```

--------------------------------

### Scalr.resize - Basic Image Resizing

Source: https://context7.com/rkalla/imgscalr/llms.txt

Demonstrates basic image resizing using Scalr.resize. It shows how to resize an image to fit within specified dimensions while maintaining its original proportions, with options for automatic or explicit dimension control.

```APIDOC
## Scalr.resize - Basic Image Resizing

### Description
Scales an image to fit within specified dimensions while maintaining original proportions. The method automatically selects the optimal scaling algorithm based on image size and orientation, or you can explicitly specify a Method and Mode for precise control.

### Method
Scalr.resize

### Endpoint
N/A (Java Library Method)

### Parameters
N/A (Java Method Parameters)

### Request Example
```java
import org.imgscalr.Scalr;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

// Load source image
BufferedImage srcImage = ImageIO.read(new File("original.jpg"));

// Simple resize to fit within 150px (auto-maintains proportions)
BufferedImage thumbnail = Scalr.resize(srcImage, 150);
ImageIO.write(thumbnail, "PNG", new File("thumbnail.png"));

// Resize with explicit width and height (proportions maintained based on orientation)
BufferedImage medium = Scalr.resize(srcImage, 640, 480);
ImageIO.write(medium, "PNG", new File("medium.png"));

// One-liner for quick thumbnail generation
ImageIO.write(Scalr.resize(ImageIO.read(new File("input.jpg")), 150), "PNG", new File("output.png"));

// Clean up source image when done
srcImage.flush();
```

### Response
#### Success Response (200)
Returns a `BufferedImage` object representing the resized image.

#### Response Example
```java
// The result is a BufferedImage object, not a direct JSON response.
// Example of writing the BufferedImage to a file:
ImageIO.write(resizedImage, "PNG", new File("output.png"));
```
```

--------------------------------

### Add Padding and Borders with Scalr.pad

Source: https://context7.com/rkalla/imgscalr/llms.txt

Demonstrates how to add uniform padding to images using Scalr.pad. It supports solid, transparent, and semi-transparent colors, and can be combined with resize operations to create framed thumbnails.

```java
import org.imgscalr.Scalr;
import javax.imageio.ImageIO;
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("photo.jpg"));

// Add 8 pixels of black padding on all sides
BufferedImage paddedBlack = Scalr.pad(srcImage, 8);

// Add padding with custom color
BufferedImage paddedWhite = Scalr.pad(srcImage, 10, Color.WHITE);

// Add padding with transparent color
Color transparent = new Color(0, 0, 0, 0);
BufferedImage paddedTransparent = Scalr.pad(srcImage, 15, transparent);

// Combine resize and pad for framed thumbnails
BufferedImage framedThumbnail = Scalr.pad(
    Scalr.resize(srcImage, 150),
    5,
    Color.DARK_GRAY
);

ImageIO.write(framedThumbnail, "PNG", new File("framed_thumbnail.png"));
srcImage.flush();
```

--------------------------------

### Resize images with Scalr.resize

Source: https://context7.com/rkalla/imgscalr/llms.txt

Demonstrates basic image resizing using the Scalr.resize method. It covers simple width-based scaling and explicit dimension constraints while maintaining aspect ratios.

```java
import org.imgscalr.Scalr;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("original.jpg"));

BufferedImage thumbnail = Scalr.resize(srcImage, 150);
ImageIO.write(thumbnail, "PNG", new File("thumbnail.png"));

BufferedImage medium = Scalr.resize(srcImage, 640, 480);
ImageIO.write(medium, "PNG", new File("medium.png"));

ImageIO.write(Scalr.resize(ImageIO.read(new File("input.jpg")), 150), "PNG", new File("output.png"));

srcImage.flush();
```

--------------------------------

### Resizing Images with Dimension Control using imgscalr

Source: https://context7.com/rkalla/imgscalr/llms.txt

Demonstrates how to use Scalr.resize with different modes like AUTOMATIC, FIT_TO_WIDTH, and FIT_EXACT. It shows how to control aspect ratio and force specific dimensions for image processing.

```java
import org.imgscalr.Scalr;
import org.imgscalr.Scalr.Mode;
import org.imgscalr.Scalr.Method;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("photo.jpg"));
BufferedImage auto = Scalr.resize(srcImage, Mode.AUTOMATIC, 400, 300);
BufferedImage fitWidth = Scalr.resize(srcImage, Mode.FIT_TO_WIDTH, 200, 200);
BufferedImage fitHeight = Scalr.resize(srcImage, Mode.FIT_TO_HEIGHT, 200, 200);
BufferedImage bestFit = Scalr.resize(srcImage, Mode.BEST_FIT_BOTH, 300, 200);
BufferedImage exact = Scalr.resize(srcImage, Mode.FIT_EXACT, 640, 480);
BufferedImage combined = Scalr.resize(srcImage, Method.QUALITY, Mode.FIT_TO_WIDTH, 250);
ImageIO.write(fitWidth, "PNG", new File("fixed_width.png"));
srcImage.flush();
```

--------------------------------

### Configuring imgscalr with System Properties

Source: https://context7.com/rkalla/imgscalr/llms.txt

Explains how to configure imgscalr's behavior at runtime using Java system properties. This includes enabling debug logging, customizing log prefixes, tuning the number of threads for asynchronous operations, and accessing predefined quality/speed thresholds for image scaling.

```java
// Enable debug logging (outputs timing and operation details to System.out)
// Set via JVM argument: -Dimgscalr.debug=true
System.setProperty("imgscalr.debug", "true");

// Customize log prefix (default is "[imgscalr] ")
// Set via JVM argument: -Dimgscalr.logPrefix=[IMGSCALR]
System.setProperty("imgscalr.logPrefix", "[IMGSCALR] ");

// Configure AsyncScalr thread count (default is 2)
// Set via JVM argument: -Dimgscalr.async.threadCount=4
// Recommendation: Set to number of CPU cores on dedicated image processing servers
System.setProperty("imgscalr.async.threadCount", "4");

// Access threshold constants for custom logic
int qualityThreshold = Scalr.THRESHOLD_QUALITY_BALANCED;  // 800px
int speedThreshold = Scalr.THRESHOLD_BALANCED_SPEED;       // 1600px
// AUTOMATIC uses QUALITY for <= 800px, BALANCED for <= 1600px, SPEED for larger
```

--------------------------------

### Image Processing Workflow

Source: https://context7.com/rkalla/imgscalr/llms.txt

Demonstrates the complete workflow for loading, resizing, cropping, applying effects, and saving images using the Scalr static API.

```APIDOC
## Scalr.resize

### Description
Resizes an image to a specific target size using a defined processing method and mode.

### Method
Static Method

### Endpoint
Scalr.resize(BufferedImage src, Method method, int targetSize)

### Parameters
#### Path Parameters
- **src** (BufferedImage) - Required - The source image to resize.
- **method** (Scalr.Method) - Required - The processing method (e.g., QUALITY, ULTRA_QUALITY).
- **targetSize** (int) - Required - The target width/height in pixels.

### Request Example
BufferedImage result = Scalr.resize(original, Method.QUALITY, 1200);

### Response
#### Success Response (200)
- **BufferedImage** - The resized image object.

## Scalr.crop

### Description
Crops a specific rectangular region from the source image.

### Method
Static Method

### Endpoint
Scalr.crop(BufferedImage src, int x, int y, int width, int height)

### Parameters
#### Path Parameters
- **src** (BufferedImage) - Required - The source image.
- **x, y** (int) - Required - The top-left corner coordinates.
- **width, height** (int) - Required - Dimensions of the crop area.

### Request Example
BufferedImage cropped = Scalr.crop(original, 0, 0, 100, 100);

### Response
#### Success Response (200)
- **BufferedImage** - The cropped image object.
```

--------------------------------

### Scalr.resize with Method - Quality Control

Source: https://context7.com/rkalla/imgscalr/llms.txt

Explains how to control the image scaling quality using different `Scalr.Method` options, from `SPEED` to `ULTRA_QUALITY`, and the `AUTOMATIC` method for intelligent selection.

```APIDOC
## Scalr.resize with Method - Quality Control

### Description
Specifies the scaling algorithm to use, ranging from SPEED (fastest, lower quality) to ULTRA_QUALITY (slowest, best results for thumbnails). The AUTOMATIC method intelligently selects based on image size using built-in thresholds.

### Method
Scalr.resize(BufferedImage src, Scalr.Method method, int targetSize)

### Endpoint
N/A (Java Library Method)

### Parameters
#### Method Parameters
- **src** (BufferedImage) - Required - The source image to resize.
- **method** (Scalr.Method) - Required - The scaling quality mode (e.g., SPEED, BALANCED, QUALITY, ULTRA_QUALITY, AUTOMATIC).
- **targetSize** (int) - Required - The target dimension (width or height) to resize to.

### Request Example
```java
import org.imgscalr.Scalr;
import org.imgscalr.Scalr.Method;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("photo.jpg"));

// SPEED: Fastest, use for large images or when quality isn't critical
BufferedImage fastResult = Scalr.resize(srcImage, Method.SPEED, 800);

// BALANCED: Good compromise between speed and quality
BufferedImage balancedResult = Scalr.resize(srcImage, Method.BALANCED, 800);

// QUALITY: High quality, uses incremental scaling for downscaling
BufferedImage qualityResult = Scalr.resize(srcImage, Method.QUALITY, 150);

// ULTRA_QUALITY: Best quality for thumbnails, uses 3.5x more incremental steps
// Excellent for images with diagonal lines that would otherwise look jagged
BufferedImage ultraResult = Scalr.resize(srcImage, Method.ULTRA_QUALITY, 100);

// AUTOMATIC: Let imgscalr decide based on target size thresholds
// Uses QUALITY for <= 800px, BALANCED for <= 1600px, SPEED for larger
BufferedImage autoResult = Scalr.resize(srcImage, Method.AUTOMATIC, 500);

ImageIO.write(ultraResult, "PNG", new File("ultra_quality_thumbnail.png"));
srcImage.flush();
```

### Response
#### Success Response (200)
Returns a `BufferedImage` object representing the resized image with the specified quality settings.

#### Response Example
```java
// The result is a BufferedImage object, not a direct JSON response.
// Example of writing the BufferedImage to a file:
ImageIO.write(ultraResult, "PNG", new File("ultra_quality_thumbnail.png"));
```
```

--------------------------------

### System Properties Configuration

Source: https://context7.com/rkalla/imgscalr/llms.txt

Configuration options for tuning the imgscalr library behavior via JVM system properties.

```APIDOC
## CONFIGURATION System Properties

### Description
Configure imgscalr runtime behavior, including debug logging and thread pool sizing for asynchronous operations. Properties must be set before class loading.

### Parameters
- **imgscalr.debug** (boolean) - Optional - Enable debug logging to System.out.
- **imgscalr.logPrefix** (string) - Optional - Custom prefix for log messages.
- **imgscalr.async.threadCount** (int) - Optional - Number of threads in the internal ExecutorService (default: 2).
```

--------------------------------

### Apply Image Operations with Scalr.apply

Source: https://context7.com/rkalla/imgscalr/llms.txt

Shows how to safely apply BufferedImageOps to images using Scalr.apply. This method handles potential JDK bugs and supports built-in filters like anti-aliasing, brightness adjustments, grayscale conversion, and custom convolution kernels.

```java
import org.imgscalr.Scalr;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("photo.jpg"));

// Apply built-in filters
BufferedImage antialiased = Scalr.apply(srcImage, Scalr.OP_ANTIALIAS);
BufferedImage grayscale = Scalr.apply(srcImage, Scalr.OP_GRAYSCALE);

// Apply multiple ops in sequence
BufferedImage multiple = Scalr.apply(srcImage,
    Scalr.OP_GRAYSCALE,
    Scalr.OP_DARKER,
    Scalr.OP_ANTIALIAS
);

// Apply custom sharpen kernel
float[] sharpenKernel = { 0, -1, 0, -1, 5, -1, 0, -1, 0 };
BufferedImageOp sharpenOp = new ConvolveOp(
    new Kernel(3, 3, sharpenKernel),
    ConvolveOp.EDGE_NO_OP,
    null
);
BufferedImage sharpened = Scalr.apply(srcImage, sharpenOp);

ImageIO.write(sharpened, "PNG", new File("processed_thumbnail.png"));
srcImage.flush();
```

--------------------------------

### Perform Complex Image Processing Workflow with imgscalr

Source: https://context7.com/rkalla/imgscalr/llms.txt

Demonstrates a comprehensive workflow using imgscalr to resize, crop, apply grayscale effects, and add borders to images. It includes best practices for resource management by calling flush() on BufferedImage objects to prevent memory leaks.

```java
import org.imgscalr.Scalr;
import org.imgscalr.Scalr.Method;
import javax.imageio.ImageIO;
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ImageProcessor {
    public static void processImage(File input, File outputDir) throws IOException {
        BufferedImage original = ImageIO.read(input);
        try {
            BufferedImage small = Scalr.resize(original, Method.ULTRA_QUALITY, 150);
            int size = Math.min(original.getWidth(), original.getHeight());
            int x = (original.getWidth() - size) / 2;
            int y = (original.getHeight() - size) / 2;
            BufferedImage squareCrop = Scalr.crop(original, x, y, size, size);
            BufferedImage squareThumb = Scalr.resize(squareCrop, Method.ULTRA_QUALITY, 100);
            squareCrop.flush();
            ImageIO.write(small, "PNG", new File(outputDir, "small.png"));
            ImageIO.write(squareThumb, "PNG", new File(outputDir, "square.png"));
            small.flush();
            squareThumb.flush();
        } finally {
            original.flush();
        }
    }
}
```

--------------------------------

### Rotating and Flipping Images with imgscalr

Source: https://context7.com/rkalla/imgscalr/llms.txt

Explains how to apply rotation (90, 180, 270 degrees) and horizontal or vertical flipping to images. It also shows how to apply additional BufferedImageOps during the rotation process.

```java
import org.imgscalr.Scalr;
import org.imgscalr.Scalr.Rotation;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

BufferedImage srcImage = ImageIO.read(new File("photo.jpg"));
BufferedImage rotated90 = Scalr.rotate(srcImage, Rotation.CW_90);
BufferedImage rotated180 = Scalr.rotate(srcImage, Rotation.CW_180);
BufferedImage rotated270 = Scalr.rotate(srcImage, Rotation.CW_270);
BufferedImage flippedH = Scalr.rotate(srcImage, Rotation.FLIP_HORZ);
BufferedImage flippedV = Scalr.rotate(srcImage, Rotation.FLIP_VERT);
BufferedImage rotatedWithOp = Scalr.rotate(srcImage, Rotation.CW_90, Scalr.OP_ANTIALIAS);
ImageIO.write(rotated90, "PNG", new File("rotated_90.png"));
srcImage.flush();
```

--------------------------------

### Scalr.resize

Source: https://context7.com/rkalla/imgscalr/llms.txt

Resizes an image using specific modes to control how dimensions are calculated and applied.

```APIDOC
## POST /Scalr/resize

### Description
Resizes a BufferedImage based on the provided Mode and dimensions. Supports automatic orientation handling, fixed width/height, and exact dimension forcing.

### Method
POST

### Endpoint
Scalr.resize(BufferedImage src, Mode mode, int width, int height)

### Parameters
#### Path Parameters
- **src** (BufferedImage) - Required - The source image to resize.
- **mode** (Scalr.Mode) - Required - The resizing mode (AUTOMATIC, FIT_TO_WIDTH, FIT_TO_HEIGHT, BEST_FIT_BOTH, FIT_EXACT).
- **width** (int) - Required - Target width.
- **height** (int) - Required - Target height.

### Request Example
Scalr.resize(srcImage, Mode.FIT_TO_WIDTH, 200, 200);

### Response
#### Success Response (200)
- **result** (BufferedImage) - The resized image object.
```

--------------------------------

### AsyncScalr Operations

Source: https://context7.com/rkalla/imgscalr/llms.txt

Methods for performing non-blocking image resizing and rotation operations.

```APIDOC
## ASYNC AsyncScalr.resize

### Description
Asynchronously resizes an image to the specified dimensions or target size. Returns a Future object that will eventually contain the processed BufferedImage.

### Method
ASYNC

### Endpoint
AsyncScalr.resize(BufferedImage src, int targetSize)

### Parameters
#### Request Body
- **src** (BufferedImage) - Required - The source image to be resized.
- **targetSize** (int) - Required - The target width/height for the resize operation.

### Response
#### Success Response (200)
- **Future<BufferedImage>** - A handle to the resulting resized image.

## ASYNC AsyncScalr.rotate

### Description
Asynchronously rotates an image by a specified degree. Returns a Future object for the rotated image.

### Method
ASYNC

### Endpoint
AsyncScalr.rotate(BufferedImage src, Rotation rotation)

### Parameters
#### Request Body
- **src** (BufferedImage) - Required - The source image to be rotated.
- **rotation** (Rotation) - Required - The rotation enum (e.g., CW_90, CW_180, CW_270).

### Response
#### Success Response (200)
- **Future<BufferedImage>** - A handle to the resulting rotated image.
```

--------------------------------

### Scalr.rotate

Source: https://context7.com/rkalla/imgscalr/llms.txt

Applies rotation or flipping operations to an image.

```APIDOC
## POST /Scalr/rotate

### Description
Rotates an image by 90, 180, or 270 degrees clockwise, or performs horizontal/vertical flips.

### Method
POST

### Endpoint
Scalr.rotate(BufferedImage src, Rotation rotation)

### Parameters
#### Path Parameters
- **src** (BufferedImage) - Required - The source image.
- **rotation** (Scalr.Rotation) - Required - The rotation type (CW_90, CW_180, CW_270, FLIP_HORZ, FLIP_VERT).

### Request Example
Scalr.rotate(srcImage, Rotation.CW_90);

### Response
#### Success Response (200)
- **result** (BufferedImage) - The rotated or flipped image object.
```

--------------------------------

### Scalr.crop

Source: https://context7.com/rkalla/imgscalr/llms.txt

Extracts a rectangular region from an image.

```APIDOC
## POST /Scalr/crop

### Description
Extracts a specific rectangular area from a source image, optionally starting from specific coordinates.

### Method
POST

### Endpoint
Scalr.crop(BufferedImage src, int x, int y, int width, int height)

### Parameters
#### Path Parameters
- **src** (BufferedImage) - Required - The source image.
- **x** (int) - Required - Starting x coordinate.
- **y** (int) - Required - Starting y coordinate.
- **width** (int) - Required - Width of crop area.
- **height** (int) - Required - Height of crop area.

### Request Example
Scalr.crop(srcImage, 50, 50, 300, 200);

### Response
#### Success Response (200)
- **result** (BufferedImage) - The cropped image object.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.