Image Resizer and Thumbnail Generator (java, written by Claude Code)

Claude Code wrote this java project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Image Resizer and Thumbnail Generator

Write a program that resizes images and generates thumbnails at multiple configurable sizes, supporting different resampling algorithms, crop modes, and batch processing of entire directories.

FUNCTIONAL REQUIREMENTS:
- Accept an image file path as a command-line argument
- Resize to exact dimensions via --size flag (WxH format, e.g., --size 1920x1080)
- Resize by percentage via --scale flag (e.g., --scale 50 for 50% of original size)
- Support multiple resampling algorithms selectable via --algorithm flag: nearest neighbor, bilinear, bicubic, and Lanczos
- Support three resize modes via --mode flag: fit (scale within bounds preserving aspect ratio), fill (scale to cover bounds then center-crop), and stretch (distort to exact dimensions)
- Generate a set of standard thumbnails via --thumbnails flag: small (150x150), medium (300x300), large (600x600), all center-cropped squares
- Support custom thumbnail sizes via --thumb-sizes flag (comma-separated, e.g., --thumb-sizes 64x64,128x128,256x256)
- Add optional padding/border around resized images via --padding flag (pixels) and --border-color flag (hex color)
- Support batch processing of all images in a directory via --batch flag, with --recursive to include subdirectories
- Print processing details to console: original dimensions, new dimensions, algorithm used, output file path, processing time per image
- Save resized images to a directory specified by --output flag (default: resized/ subdirectory)
- If no input is given, generate a sample 2000x1500 test image with fine details (grid lines, text at various sizes, gradient bands), then resize it using each algorithm and each mode to demonstrate the visual differences
- Handle errors: invalid dimensions, unsupported image formats, memory limits for very large images

Create a complete Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

package com.imageresizer;

import org.imgscalr.Scalr;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Image Resizer and Thumbnail Generator
 *
 * Resizes images using multiple algorithms (bilinear, bicubic, Lanczos),
 * supports crop modes, and batch processing of directories.
 *
 * Dependencies: imgscalr 4.2, javax.imageio (JDK built-in)
 */
public class ImageResizer {

    private static final Set<String> SUPPORTED_EXTENSIONS = new HashSet<>(
            Arrays.asList("jpg", "jpeg", "png", "bmp", "gif", "tiff", "tif", "wbmp")
    );

    /**
     * Supported resampling algorithms mapped to imgscalr methods.
     */
    public enum Algorithm {
        BILINEAR(Scalr.Method.BALANCED),
        BICUBIC(Scalr.Method.QUALITY),
        LANCZOS(Scalr.Method.ULTRA_QUALITY),
        FAST(Scalr.Method.SPEED);

        private final Scalr.Method scalrMethod;

        Algorithm(Scalr.Method scalrMethod) {
            this.scalrMethod = scalrMethod;
        }

        public Scalr.Method getScalrMethod() {
            return scalrMethod;
        }
    }

    /**
     * Crop modes determining where to anchor the crop region.
     */
    public enum CropMode {
        CENTER, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT, SMART
    }

    /**
     * Resize a single image file.
     *
     * @param inputPath     Path to the source image.
     * @param outputPath    Path for the output image.
     * @param targetWidth   Desired width.
     * @param targetHeight  Desired height.
     * @param algorithm     Resampling algorithm.
     * @param cropMode      Optional crop mode (null to maintain aspect ratio).
     * @param maintainAspect Keep aspect ratio if no crop mode.
     * @return ResizeResult with details of the operation.
     */
    public static ResizeResult resizeImage(String inputPath, String outputPath,
                                            int targetWidth, int targetHeight,
                                            Algorithm algorithm, CropMode cropMode,
                                            boolean maintainAspect) throws IOException {
        File inputFile = new File(inputPath);
        BufferedImage original = ImageIO.read(inputFile);
        if (original == null) {
            throw new IOException("Could not read image: " + inputPath);
        }

        int origWidth = original.getWidth();
        int origHeight = original.getHeight();
        long originalSize = inputFile.length();

        BufferedImage result;

        if (cropMode != null) {
            result = resizeAndCrop(original, targetWidth, targetHeight, algorithm, cropMode);
        } else if (maintainAspect) {
            result = Scalr.resize(original, algorithm.getScalrMethod(),
                    Scalr.Mode.AUTOMATIC, targetWidth, targetHeight);
        } else {
            result = Scalr.resize(original, algorithm.getScalrMethod(),
                    Scalr.Mode.FIT_EXACT, targetWidth, targetHeight);
        }

        File outputFile = new File(outputPath);
        outputFile.getParentFile().mkdirs();
        String format = getExtension(outputPath);
        if (format.equals("jpg")) format = "jpeg";
        ImageIO.write(result, format, outputFile);

        long newSize = outputFile.length();
        original.flush();
        result.flush();

        return new ResizeResult(inputPath, outputPath, origWidth, origHeight,
                result.getWidth(), result.getHeight(), originalSize, newSize, algorithm.name());
    }

    /**
     * Resize the image to cover the target area, then crop according to the crop mode.
     */
    private static BufferedImage resizeAndCrop(BufferedImage img, int targetWidth,
                                                int targetHeight, Algorithm algorithm,
                                                CropMode cropMode) {
        int origWidth = img.getWidth();
        int origHeight = img.getHeight();

        double scaleW = (double) targetWidth / origWidth;
        double scaleH = (double) targetHeight / origHeight;
        double scale = Math.max(scaleW, scaleH);

        int interimW = Math.max(targetWidth, (int) (origWidth * scale));
        int interimH = Math.max(targetHeight, (int) (origHeight * scale));

        BufferedImage resized = Scalr.resize(img, algorithm.getScalrMethod(),
                Scalr.Mode.FIT_EXACT, interimW, interimH);

        int[] cropBox = calculateCropBox(resized.getWidth(), resized.getHeight(),
                targetWidth, targetHeight, cropMode);

        return Scalr.crop(resized, cropBox[0], cropBox[1], targetWidth, targetHeight);
    }

    /**
     * Calculate crop offsets based on the crop mode.
     */
    private static int[] calculateCropBox(int imgWidth, int imgHeight,
                                           int targetWidth, int targetHeight,
                                           CropMode mode) {
        int left, top;

        switch (mode) {
            case CENTER:
                left = (imgWidth - targetWidth) / 2;
                top = (imgHeight - targetHeight) / 2;
                break;
            case TOP_LEFT:
                left = 0;
                top = 0;
                break;
            case TOP_RIGHT:
                left = imgWidth - targetWidth;
                top = 0;
                break;
            case BOTTOM_LEFT:
                left = 0;
                top = imgHeight - targetHeight;
                break;
            case BOTTOM_RIGHT:
                left = imgWidth - targetWidth;
                top = imgHeight - targetHeight;
                break;
            case SMART:
                left = (imgWidth - targetWidth) / 2;
                top = Math.max(0, (imgHeight - targetHeight) / 3);
                break;
            default:
                left = (imgWidth - targetWidth) / 2;
                top = (imgHeight - targetHeight) / 2;
        }

        left = Math.max(0, left);
        top = Math.max(0, top);

        return new int[]{left, top};
    }

    /**
     * Generate a square thumbnail from an image.
     */
    public static ResizeResult generateThumbnail(String inputPath, String outputPath,
                                                  int size, Algorithm algorithm) throws IOException {
        return resizeImage(inputPath, outputPath, size, size, algorithm, CropMode.CENTER, false);
    }

    /**
     * Batch resize all supported images in a directory.
     */
    public static List<ResizeResult> batchResize(String inputDir, String outputDir,
                                                  int targetWidth, int targetHeight,
                                                  Algorithm algorithm, CropMode cropMode,
                                                  boolean maintainAspect) throws IOException {
        List<File> images = getSupportedImages(inputDir);
        List<ResizeResult> results = new ArrayList<>();

        System.out.printf("Found %d image(s) to process.%n", images.size());

        for (File img : images) {
            try {
                String outputPath = Paths.get(outputDir, img.getName()).toString();
                ResizeResult result = resizeImage(img.getAbsolutePath(), outputPath,
                        targetWidth, targetHeight, algorithm, cropMode, maintainAspect);
                results.add(result);
                System.out.printf("  Resized: %s (%dx%d -> %dx%d)%n",
                        img.getName(), result.origWidth, result.origHeight,
                        result.newWidth, result.newHeight);
            } catch (Exception e) {
                System.err.printf("  Error processing %s: %s%n", img.getName(), e.getMessage());
            }
        }

        return results;
    }

    /**
     * Batch generate thumbnails for all images in a directory.
     */
    public static List<ResizeResult> batchThumbnails(String inputDir, String outputDir,
                                                      int size, Algorithm algorithm) throws IOException {
        List<File> images = getSupportedImages(inputDir);
        List<ResizeResult> results = new ArrayList<>();

        System.out.printf("Generating thumbnails for %d image(s)...%n", images.size());

        for (File img : images) {
            try {
                String outputPath = Paths.get(outputDir, "thumb_" + img.getName()).toString();
                ResizeResult result = generateThumbnail(img.getAbsolutePath(), outputPath, size, algorithm);
                results.add(result);
                System.out.printf("  Thumbnail: %s (%dx%d)%n",
                        img.getName(), result.newWidth, result.newHeight);
            } catch (Exception e) {
                System.err.printf("  Error: %s: %s%n", img.getName(), e.getMessage());
            }
        }

        return results;
    }

    /**
     * Collect all supported image files from a directory.
     */
    private static List<File> getSupportedImages(String directory) throws IOException {
        List<File> images = new ArrayList<>();
        Path dirPath = Paths.get(directory);

        if (!Files.isDirectory(dirPath)) {
            throw new IOException("Not a directory: " + directory);
        }

        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dirPath)) {
            for (Path entry : stream) {
                if (Files.isRegularFile(entry)) {
                    String ext = getExtension(entry.toString()).toLowerCase();
                    if (SUPPORTED_EXTENSIONS.contains(ext)) {
                        images.add(entry.toFile());
                    }
                }
            }
        }

        images.sort((a, b) -> a.getName().compareToIgnoreCase(b.getName()));
        return images;
    }

    private static String getExtension(String filename) {
        int dot = filename.lastIndexOf('.');
        return (dot >= 0) ? filename.substring(dot + 1).toLowerCase() : "";
    }

    private static String formatSize(long bytes) {
        String[] units = {"B", "KB", "MB", "GB"};
        double size = bytes;
        int unitIndex = 0;
        while (size >= 1024 && unitIndex < units.length - 1) {
            size /= 1024;
            unitIndex++;
        }
        return String.format("%.1f %s", size, units[unitIndex]);
    }

    /**
     * Result of a resize operation.
     */
    public static class ResizeResult {
        public final String inputPath;
        public final String outputPath;
        public final int origWidth;
        public final int origHeight;
        public final int newWidth;
        public final int newHeight;
        public final long originalSize;
        public final long newSize;
        public final String algorithm;

        public ResizeResult(String inputPath, String outputPath,
                           int origWidth, int origHeight, int newWidth, int newHeight,
                           long originalSize, long newSize, String algorithm) {
            this.inputPath = inputPath;
            this.outputPath = outputPath;
            this.origWidth = origWidth;
            this.origHeight = origHeight;
            this.newWidth = newWidth;
            this.newHeight = newHeight;
            this.originalSize = originalSize;
            this.newSize = newSize;
            this.algorithm = algorithm;
        }

        @Override
        public String toString() {
            return String.format("%s: %dx%d -> %dx%d (%s -> %s) [%s]",
                    new File(inputPath).getName(),
                    origWidth, origHeight, newWidth, newHeight,
                    formatSize(originalSize), formatSize(newSize), algorithm);
        }
    }

    /**
     * CLI entry point.
     */
    public static void main(String[] args) {
        if (args.length < 1) {
            printUsage();
            return;
        }

        String command = args[0].toLowerCase();

        try {
            switch (command) {
                case "resize":
                    handleResize(args);
                    break;
                case "thumbnail":
                    handleThumbnail(args);
                    break;
                case "batch":
                    handleBatch(args);
                    break;
                case "batch-thumbnails":
                    handleBatchThumbnails(args);
                    break;
                default:
                    System.err.println("Unknown command: " + command);
                    printUsage();
            }
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            System.exit(1);
        }
    }

    private static void handleResize(String[] args) throws IOException {
        if (args.length < 5) {
            System.err.println("Usage: resize <input> <output> <width> <height> [algorithm] [crop-mode]");
            return;
        }
        String input = args[1];
        String output = args[2];
        int width = Integer.parseInt(args[3]);
        int height = Integer.parseInt(args[4]);
        Algorithm algo = args.length > 5 ? Algorithm.valueOf(args[5].toUpperCase()) : Algorithm.LANCZOS;
        CropMode crop = args.length > 6 ? CropMode.valueOf(args[6].toUpperCase()) : null;

        ResizeResult result = resizeImage(input, output, width, height, algo, crop, crop == null);
        System.out.println("Resized: " + result);
    }

    private static void handleThumbnail(String[] args) throws IOException {
        if (args.length < 3) {
            System.err.println("Usage: thumbnail <input> <output> [size] [algorithm]");
            return;
        }
        String input = args[1];
        String output = args[2];
        int size = args.length > 3 ? Integer.parseInt(args[3]) : 150;
        Algorithm algo = args.length > 4 ? Algorithm.valueOf(args[4].toUpperCase()) : Algorithm.LANCZOS;

        ResizeResult result = generateThumbnail(input, output, size, algo);
        System.out.println("Thumbnail: " + result);
    }

    private static void handleBatch(String[] args) throws IOException {
        if (args.length < 5) {
            System.err.println("Usage: batch <input-dir> <output-dir> <width> <height> [algorithm] [crop-mode]");
            return;
        }
        String inputDir = args[1];
        String outputDir = args[2];
        int width = Integer.parseInt(args[3]);
        int height = Integer.parseInt(args[4]);
        Algorithm algo = args.length > 5 ? Algorithm.valueOf(args[5].toUpperCase()) : Algorithm.LANCZOS;
        CropMode crop = args.length > 6 ? CropMode.valueOf(args[6].toUpperCase()) : null;

        List<ResizeResult> results = batchResize(inputDir, outputDir, width, height, algo, crop, crop == null);
        System.out.printf("%nBatch complete: %d image(s) processed.%n", results.size());
    }

    private static void handleBatchThumbnails(String[] args) throws IOException {
        if (args.length < 3) {
            System.err.println("Usage: batch-thumbnails <input-dir> <output-dir> [size] [algorithm]");
            return;
        }
        String inputDir = args[1];
        String outputDir = args[2];
        int size = args.length > 3 ? Integer.parseInt(args[3]) : 150;
        Algorithm algo = args.length > 4 ? Algorithm.valueOf(args[4].toUpperCase()) : Algorithm.LANCZOS;

        List<ResizeResult> results = batchThumbnails(inputDir, outputDir, size, algo);
        System.out.printf("%nGenerated %d thumbnail(s).%n", results.size());
    }

    private static void printUsage() {
        System.out.println("Image Resizer and Thumbnail Generator");
        System.out.println();
        System.out.println("Commands:");
        System.out.println("  resize <input> <output> <width> <height> [algorithm] [crop-mode]");
        System.out.println("  thumbnail <input> <output> [size] [algorithm]");
        System.out.println("  batch <input-dir> <output-dir> <width> <height> [algorithm] [crop-mode]");
        System.out.println("  batch-thumbnails <input-dir> <output-dir> [size] [algorithm]");
        System.out.println();
        System.out.println("Algorithms: BILINEAR, BICUBIC, LANCZOS, FAST");
        System.out.println("Crop modes: CENTER, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT, SMART");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.imageresizer</groupId>
    <artifactId>image-resizer</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>Image Resizer and Thumbnail Generator</name>
    <description>
        Resizes images using multiple algorithms (bilinear, bicubic, Lanczos),
        supports crop modes and batch processing.
    </description>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- imgscalr: Java image scaling library -->
        <dependency>
            <groupId>org.imgscalr</groupId>
            <artifactId>imgscalr-lib</artifactId>
            <version>4.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.imageresizer.ImageResizer</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.imageresizer.ImageResizer</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

# Image Resizer and Thumbnail Generator (Java / imgscalr)

A command-line tool for resizing images and generating thumbnails using imgscalr
with multiple resampling quality levels, crop modes, and batch processing.

## Dependencies

- **imgscalr 4.2** - Pure-Java image scaling library with multiple quality modes.
- **javax.imageio** - Built-in JDK library for reading and writing image formats.

## Build

```bash
mvn clean package
```

## Usage

### Resize a single image

```bash
java -jar target/image-resizer-1.0.0.jar resize input.jpg output.jpg 800 600 LANCZOS
```

### Generate a thumbnail

```bash
java -jar target/image-resizer-1.0.0.jar thumbnail input.jpg thumb.jpg 150
```

### Batch resize

```bash
java -jar target/image-resizer-1.0.0.jar batch ./input_dir ./output_dir 1024 768 BICUBIC
```

### Batch thumbnails

```bash
java -jar target/image-resizer-1.0.0.jar batch-thumbnails ./input_dir ./thumbs 200
```

## Algorithms

| Algorithm  | imgscalr Method    | Description                    |
|------------|--------------------|--------------------------------|
| `FAST`     | SPEED              | Fastest, lowest quality        |
| `BILINEAR` | BALANCED           | Balanced speed/quality         |
| `BICUBIC`  | QUALITY            | High quality                   |
| `LANCZOS`  | ULTRA_QUALITY      | Best quality (default)         |

## Crop Modes

CENTER, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT, SMART