Javadoc

Author: garydgregory

src/main/java/org/apache/commons/imaging/common/RationalNumber.java

@@ -51,6 +51,8 @@ public String toString() {
 
     // int-precision tolerance
     private static final double TOLERANCE = 1E-8;
+
+    /** Shallow size constant. */
     public static final int SHALLOW_SIZE = 32;
 
     static RationalNumber factoryMethod(long n, long d) {
@@ -170,17 +172,21 @@ public static RationalNumber valueOf(double value) {
     // of 32 bit unsigned integers. Since Java does not have an
     // unsigned type, this class widens the type to long in order
     // to avoid unintended negative numbers.
+
+    /** The numerator value. */
     public final long numerator;
 
+    /** The divisor value. */
     public final long divisor;
 
+    /** Whether this is an unsigned type. */
     public final boolean unsignedType;
 
     /**
-     * Constructs an instance based on signed integers
+     * Constructs an instance based on signed integers.
      *
-     * @param numerator a 32-bit signed integer
-     * @param divisor   a non-zero 32-bit signed integer
+     * @param numerator a 32-bit signed integer.
+     * @param divisor   a non-zero 32-bit signed integer.
      */
     public RationalNumber(final int numerator, final int divisor) {
         this.numerator = numerator;
@@ -278,6 +284,11 @@ public RationalNumber negate() {
         return new RationalNumber(-n, d, false);
     }
 
+    /**
+     * Converts to display string.
+     *
+     * @return the display string.
+     */
     public String toDisplayString() {
         if (numerator % divisor == 0) {
             return Long.toString(numerator / divisor);

src/main/java/org/apache/commons/imaging/common/RgbBufferedImageFactory.java

@@ -19,7 +19,18 @@
 
 import java.awt.image.BufferedImage;
 
+/**
+ * Factory for creating RGB buffered images.
+ */
 public class RgbBufferedImageFactory implements BufferedImageFactory {
+
+    /**
+     * Constructs a new instance.
+     */
+    public RgbBufferedImageFactory() {
+        // Default constructor
+    }
+
     @Override
     public BufferedImage getColorBufferedImage(final int width, final int height, final boolean hasAlpha) {
         if (hasAlpha) {

src/main/java/org/apache/commons/imaging/common/SimpleBufferedImageFactory.java

@@ -19,7 +19,18 @@
 
 import java.awt.image.BufferedImage;
 
+/**
+ * Simple factory for creating buffered images.
+ */
 public class SimpleBufferedImageFactory implements BufferedImageFactory {
+
+    /**
+     * Constructs a new instance.
+     */
+    public SimpleBufferedImageFactory() {
+        // Default constructor
+    }
+
     @Override
     public BufferedImage getColorBufferedImage(final int width, final int height, final boolean hasAlpha) {
         if (hasAlpha) {

src/main/java/org/apache/commons/imaging/formats/jpeg/segments/SofnSegment.java

@@ -31,13 +31,34 @@
 
 public final class SofnSegment extends AbstractSegment {
 
+    /**
+     * JPEG component information.
+     */
     public static class Component {
+
+        /** Shallow size constant. */
         static final int SHALLOW_SIZE = 32;
+
+        /** Component identifier. */
         public final int componentIdentifier;
+
+        /** Horizontal sampling factor. */
         public final int horizontalSamplingFactor;
+
+        /** Vertical sampling factor. */
         public final int verticalSamplingFactor;
+
+        /** Quantization table destination selector. */
         public final int quantTabDestSelector;
 
+        /**
+         * Constructs a component.
+         *
+         * @param componentIdentifier the component identifier.
+         * @param horizontalSamplingFactor the horizontal sampling factor.
+         * @param veritcalSamplingFactor the vertical sampling factor.
+         * @param quantTabDestSelector the quantization table destination selector.
+         */
         public Component(final int componentIdentifier, final int horizontalSamplingFactor, final int veritcalSamplingFactor, final int quantTabDestSelector) {
             this.componentIdentifier = componentIdentifier;
             this.horizontalSamplingFactor = horizontalSamplingFactor;
@@ -47,13 +68,29 @@ public Component(final int componentIdentifier, final int horizontalSamplingFact
     }
 
     private static final Logger LOGGER = Logger.getLogger(SofnSegment.class.getName());
+
+    /** Image width. */
     public final int width;
+
+    /** Image height. */
     public final int height;
+
+    /** Number of components. */
     public final int numberOfComponents;
+
+    /** Precision. */
     public final int precision;
 
     private final Component[] components;
 
+    /**
+     * Constructs a SOFn segment.
+     *
+     * @param marker the marker.
+     * @param segmentData the segment data.
+     * @throws IOException if an I/O error occurs.
+     * @throws ImagingException if an imaging error occurs.
+     */
     public SofnSegment(final int marker, final byte[] segmentData) throws IOException, ImagingException {
         this(marker, segmentData.length, new ByteArrayInputStream(segmentData));
     }

src/main/java/org/apache/commons/imaging/formats/jpeg/segments/SosSegment.java

@@ -28,12 +28,30 @@
 
 public final class SosSegment extends AbstractSegment {
 
+    /**
+     * JPEG SOS component information.
+     */
     public static class Component {
+
+        /** Shallow size constant. */
         static final int SHALLOW_SIZE = 24;
+
+        /** Scan component selector. */
         public final int scanComponentSelector;
+
+        /** DC coding table selector. */
         public final int dcCodingTableSelector;
+
+        /** AC coding table selector. */
         public final int acCodingTableSelector;
 
+        /**
+         * Constructs a component.
+         *
+         * @param scanComponentSelector the scan component selector.
+         * @param dcCodingTableSelector the DC coding table selector.
+         * @param acCodingTableSelector the AC coding table selector.
+         */
         public Component(final int scanComponentSelector, final int dcCodingTableSelector, final int acCodingTableSelector) {
             this.scanComponentSelector = scanComponentSelector;
             this.dcCodingTableSelector = dcCodingTableSelector;
@@ -42,14 +60,31 @@ public Component(final int scanComponentSelector, final int dcCodingTableSelecto
     }
 
     private static final Logger LOGGER = Logger.getLogger(SosSegment.class.getName());
+
+    /** Number of components. */
     public final int numberOfComponents;
+
     private final Component[] components;
+
+    /** Start of spectral selection. */
     public final int startOfSpectralSelection;
+
+    /** End of spectral selection. */
     public final int endOfSpectralSelection;
+
+    /** Successive approximation bit high. */
     public final int successiveApproximationBitHigh;
 
+    /** Successive approximation bit low. */
     public final int successiveApproximationBitLow;
 
+    /**
+     * Constructs a SOS segment.
+     *
+     * @param marker the marker.
+     * @param segmentData the segment data.
+     * @throws IOException if an I/O error occurs.
+     */
     public SosSegment(final int marker, final byte[] segmentData) throws IOException {
         this(marker, segmentData.length, new ByteArrayInputStream(segmentData));
     }

src/main/java/org/apache/commons/imaging/formats/png/PngImagingParameters.java

@@ -27,6 +27,7 @@
  */
 public class PngImagingParameters extends XmpImagingParameters<PngImagingParameters> {
 
+    /** Default bit depth value. */
     public static final byte DEFAULT_BIT_DEPTH = 8;
 
     /**
@@ -62,22 +63,54 @@ public class PngImagingParameters extends XmpImagingParameters<PngImagingParamet
      */
     private List<? extends AbstractPngText> textChunks;
 
+    /**
+     * Constructs a new instance.
+     */
+    public PngImagingParameters() {
+        // Default constructor
+    }
+
+    /**
+     * Gets the bit depth.
+     *
+     * @return the bit depth.
+     */
     public byte getBitDepth() {
         return bitDepth;
     }
 
+    /**
+     * Gets the physical scale.
+     *
+     * @return the physical scale.
+     */
     public PhysicalScale getPhysicalScale() {
         return physicalScale;
     }
 
+    /**
+     * Gets the text chunks.
+     *
+     * @return the text chunks.
+     */
     public List<? extends AbstractPngText> getTextChunks() {
         return textChunks != null ? Collections.unmodifiableList(textChunks) : null;
     }
 
+    /**
+     * Checks if forcing indexed color.
+     *
+     * @return true if forcing indexed color, false otherwise.
+     */
     public boolean isForceIndexedColor() {
         return forceIndexedColor;
     }
 
+    /**
+     * Checks if forcing true color.
+     *
+     * @return true if forcing true color, false otherwise.
+     */
     public boolean isForceTrueColor() {
         return forceTrueColor;
     }
@@ -91,21 +124,45 @@ public boolean isPredictorEnabled() {
         return predictorEnabled;
     }
 
+    /**
+     * Sets the bit depth.
+     *
+     * @param bitDepth the bit depth.
+     * @return this instance.
+     */
     public PngImagingParameters setBitDepth(final byte bitDepth) {
         this.bitDepth = bitDepth;
         return asThis();
     }
 
+    /**
+     * Sets whether to force indexed color.
+     *
+     * @param forceIndexedColor whether to force indexed color.
+     * @return this instance.
+     */
     public PngImagingParameters setForceIndexedColor(final boolean forceIndexedColor) {
         this.forceIndexedColor = forceIndexedColor;
         return asThis();
     }
 
+    /**
+     * Sets whether to force true color.
+     *
+     * @param forceTrueColor whether to force true color.
+     * @return this instance.
+     */
     public PngImagingParameters setForceTrueColor(final boolean forceTrueColor) {
         this.forceTrueColor = forceTrueColor;
         return asThis();
     }
 
+    /**
+     * Sets the physical scale.
+     *
+     * @param physicalScale the physical scale.
+     * @return this instance.
+     */
     public PngImagingParameters setPhysicalScale(final PhysicalScale physicalScale) {
         this.physicalScale = physicalScale;
         return asThis();
@@ -124,6 +181,12 @@ public PngImagingParameters setPredictorEnabled(final boolean predictorEnabled)
         return asThis();
     }
 
+    /**
+     * Sets the text chunks.
+     *
+     * @param textChunks the text chunks.
+     * @return this instance.
+     */
     public PngImagingParameters setTextChunks(final List<? extends AbstractPngText> textChunks) {
         this.textChunks = Collections.unmodifiableList(textChunks);
         return asThis();

src/main/java/org/apache/commons/imaging/formats/png/scanlinefilters/ScanlineFilter.java

@@ -20,8 +20,20 @@
 
 import org.apache.commons.imaging.ImagingException;
 
+/**
+ * Interface for PNG scanline filtering.
+ */
 public interface ScanlineFilter {
 
+    /**
+     * Unfilters a scanline.
+     *
+     * @param src the source bytes.
+     * @param dst the destination bytes.
+     * @param up the previous scanline bytes.
+     * @throws ImagingException if an imaging error occurs.
+     * @throws IOException if an I/O error occurs.
+     */
     void unfilter(byte[] src, byte[] dst, byte[] up) throws ImagingException, IOException;
 
 }

src/main/java/org/apache/commons/imaging/formats/png/scanlinefilters/ScanlineFilterAverage.java

@@ -20,9 +20,18 @@
 
 import org.apache.commons.imaging.ImagingException;
 
+/**
+ * PNG scanline filter using average of left and up pixels.
+ */
 public class ScanlineFilterAverage implements ScanlineFilter {
+
     private final int bytesPerPixel;
 
+    /**
+     * Constructs a new instance.
+     *
+     * @param bytesPerPixel the number of bytes per pixel.
+     */
     public ScanlineFilterAverage(final int bytesPerPixel) {
         this.bytesPerPixel = bytesPerPixel;
     }

src/main/java/org/apache/commons/imaging/formats/png/scanlinefilters/ScanlineFilterNone.java

@@ -20,8 +20,18 @@
 
 import org.apache.commons.imaging.ImagingException;
 
+/**
+ * PNG scanline filter with no filtering (direct copy).
+ */
 public class ScanlineFilterNone implements ScanlineFilter {
 
+    /**
+     * Constructs a new instance.
+     */
+    public ScanlineFilterNone() {
+        // Default constructor
+    }
+
     @Override
     public void unfilter(final byte[] src, final byte[] dst, final byte[] up) throws ImagingException, IOException {
         System.arraycopy(src, 0, dst, 0, src.length);