Image Augmentation API - Proposal

[Samyssmile]

Augmentation Builder Concept

This concept utilizes the builder pattern to create a more modular and flexible approach to constructing an image augmentation sequence.

Example Usage

Augmentation Sequence Builder Concept

This concept utilizes the builder pattern to create a more modular and flexible approach to constructing an image augmentation sequence.

Example Usage

Image originalImage = ImageIO.read(new File("path/to/image.jpg"));

AugmentationSequence augmentationSequence = new AugmentationSequenceBuilder()
    .addAugmentation(new RotateAugmentation(90))
    .addAugmentation(new ScaleAugmentation(0.5, 0.5))
    .addAugmentation(new FlipAugmentation(FlipDirection.HORIZONTAL))
    .addAugmentation(new ColorAdjustmentAugmentation(brightness, contrast, saturation, hue))
    .addAugmentation(new NoiseAugmentation(NoiseType.GAUSSIAN, 0.1))
    .addAugmentation(new ResizeAugmentation(300, 300))
    .build();

Image augmentedImage = augmentationSequence.applyTo(originalImage);
ImageIO.write(augmentedImage, "jpg", new File("path/to/augmented_image.jpg"));

Augmentation Interface and Abstract Class

Below are the interface and abstract class definitions for the image augmentation pipeline. These provide a framework for implementing various image augmentations.

AugmentationSequence Interface

The AugmentationSequence interface defines the methods that must be implemented for an augmentation sequence to be applied to single images or a batch of images.

package org.edux.augmentation;

import java.awt.image.BufferedImage;
import java.util.List;

/**
 * Interface for an image augmentation sequence.
 */
public interface AugmentationSequence {

    /**
     * Applies the series of augmentations defined in the sequence to an image.
     *
     * @param image The image to be augmented.
     * @return The augmented image.
     */
    BufferedImage applyTo(BufferedImage image);

    /**
     * Applies the series of augmentations defined in the sequence to a list of images.
     *
     * @param images The list of images to be augmented.
     * @return The list of augmented images.
     */
    List<BufferedImage> applyToAll(List<BufferedImage> images);
}


/**
 * Abstract class for augmentation operations. All specific augmentation classes should extend this.
 */
public abstract class AbstractAugmentationSequence {

    /**
     * Applies the augmentation to an image.
     *
     * @param image The image to augment.
     * @return The augmented image.
     */
    public abstract BufferedImage apply(BufferedImage image);
}

Structure Draft for Image Augmentation API

The draft below outlines the proposed structure for the image augmentation API, detailing the organization of packages and their respective roles.

Packages:

org.edux.core:

• Core library functions, utilities, and data definitions.

org.edux.augmentation:

• Main augmentation classes and interfaces.
• Enums for defining standard augmentation parameters like flip directions and noise types.

org.edux.augmentation.transforms:

• Specific classes for transformation operations such as rotation, scaling, etc.

org.edux.augmentation.effects:

• Specific classes for effects like noise, filtering, color adjustments, etc.

org.edux.augmentation.io:

• Classes for input/output operations, for loading and saving images.

org.edux.augmentation.utils:

• Helper classes, for example, for mathematical operations or image conversions.

Each package is designed to encapsulate a specific aspect of the image augmentation process, which promotes a modular design and ease of maintenance.

/**
 * Builder class for creating an augmentation sequence.
 */
public class AugmentationBuilder {
    private List<AbstractAugmentation> augmentations;

    public AugmentationBuilder() {
        this.augmentations = new ArrayList<>();
    }

    /**
     * Adds an augmentation to the sequence.
     *
     * @param augmentation The augmentation operation to add.
     * @return The builder instance for chaining.
     */
    public AugmentationBuilder addAugmentation(AbstractAugmentation augmentation) {
        this.augmentations.add(augmentation);
        return this;
    }

    /**
     * Builds the final Augmentation sequence from the added operations.
     *
     * @return The composite Augmentation object containing all added operations.
     */
    public Augmentation build() {
        return new CompositeAugmentation(augmentations);
    }
}

Enums for Different Augmentation Settings

These enums are designed to provide standardized options for various augmentation operations that can be applied to images in the augmentation pipeline.

package org.edux.augmentation.enums;

/**
 * Enum for flip directions.
 */
public enum FlipDirection {
    HORIZONTAL, // For flipping the image horizontally
    VERTICAL    // For flipping the image vertically
}

package org.edux.augmentation.enums;

/**
 * Enum for types of noise to apply to images.
 */
public enum NoiseType {
    GAUSSIAN,     // For applying Gaussian noise
    SALT_PEPPER,  // For applying salt-and-pepper noise
    POISSON       // For applying Poisson noise
}

[acsolle66]

Hi
What if we implemented an AugmentationPipelineBuilder class ? Just a rough scheme about my idea:

public class AugmentationPipelineBuilder {
  public AugmentationPipelineBuilder addAugmentation(AbstractAugmentationClass augmentation){};
  public AugmentationPipeline build(){};
}

public interface AugmentationPipeline {
  BufferedImage applyTo(BufferedImage image);
}

public class AbstractAugmentationClass {
  // have not figured out yet 
}

This way we wouldn't need to modify the AugmentationPipeline if we want to add some new augmentation in the future. What do you think ?

[acsolle66]

One comment for consideration. I think we should name the interface something like AugmentationSeries/Sequence/Pipeline etc... Maybe just a mistake but the addAugmentation should be included in the interface or am I missing something?
For now it is everything from my side.
Edit: I was tired. I understand now why...

[Samyssmile]

Good point, edited.