# PDRectangle.java

    /*
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You under the Apache License, Version 2.0
     * (the "License"); you may not use this file except in compliance with
     * the License.  You may obtain a copy of the License at
     *
     *      http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    package org.apache.pdfbox.pdmodel.common;

    import java.awt.geom.GeneralPath;
    import java.awt.geom.Point2D;
    import java.util.Arrays;
    import org.apache.pdfbox.cos.COSArray;
    import org.apache.pdfbox.cos.COSBase;
    import org.apache.pdfbox.cos.COSFloat;
    import org.apache.pdfbox.cos.COSNumber;

    import org.apache.fontbox.util.BoundingBox;

    import org.apache.pdfbox.util.Matrix;

    /**
     * A rectangle in a PDF document.
     *
     * @author Ben Litchfield
     */
    public class PDRectangle implements COSObjectable
    {
        /** user space units per inch */
        private static final float POINTS_PER_INCH = 72;

        /** user space units per millimeter */
        private static final float POINTS_PER_MM = 1 / (10 * 2.54f) * POINTS_PER_INCH;

        /** An immutable rectangle the size of U.S. Letter, 8.5" x 11". */
        @SuppressWarnings("java:S2390") // see also https://jira.sonarsource.com/browse/SONARJAVA-3580
        public static final PDRectangle LETTER = new PDImmutableRectangle(8.5f * POINTS_PER_INCH,
                                                                 11f *POINTS_PER_INCH);
        /**  An immutable rectangle the size of U.S. Legal, 8.5" x 14". */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle LEGAL = new PDImmutableRectangle(8.5f * POINTS_PER_INCH,
                                                                14f * POINTS_PER_INCH);
        /**  An immutable rectangle the size of A0 Paper. */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle A0 = new PDImmutableRectangle(841 * POINTS_PER_MM, 1189 * POINTS_PER_MM);

        /** An immutable rectangle the size of A1 Paper. */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle A1 = new PDImmutableRectangle(594 * POINTS_PER_MM, 841 * POINTS_PER_MM);

        /**  An immutable rectangle the size of A2 Paper. */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle A2 = new PDImmutableRectangle(420 * POINTS_PER_MM, 594 * POINTS_PER_MM);

        /** An immutable rectangle the size of A3 Paper.  */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle A3 = new PDImmutableRectangle(297 * POINTS_PER_MM, 420 * POINTS_PER_MM);

        /**  An immutable rectangle the size of A4 Paper. */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle A4 = new PDImmutableRectangle(210 * POINTS_PER_MM, 297 * POINTS_PER_MM);

        /** An immutable rectangle the size of A5 Paper. */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle A5 = new PDImmutableRectangle(148 * POINTS_PER_MM, 210 * POINTS_PER_MM);

        /**  An immutable rectangle the size of A6 Paper. */
        @SuppressWarnings("java:S2390")
        public static final PDRectangle A6 = new PDImmutableRectangle(105 * POINTS_PER_MM, 148 * POINTS_PER_MM);

        private final COSArray rectArray;

        /**
         * Constructor.
         *
         * Initializes to 0,0,0,0
         */
        public PDRectangle()
        {
            this(0.0f, 0.0f, 0.0f, 0.0f);
        }

        /**
         * Constructor.
         *
         * @param width The width of the rectangle.
         * @param height The height of the rectangle.
         */
        public PDRectangle( float width, float height )
        {
            this(0.0f, 0.0f, width, height);
        }

        /**
         * Constructor.
         *
         * @param x the x coordinate of the rectangle
         * @param y the y coordinate of the rectangle
         * @param width The width of the rectangle.
         * @param height The height of the rectangle.
         */
        public PDRectangle( float x, float y, float width, float height )
        {
            rectArray = new COSArray();
            rectArray.add( new COSFloat( x ) );
            rectArray.add( new COSFloat( y ) );
            rectArray.add( new COSFloat( x + width ) );
            rectArray.add( new COSFloat( y + height ) );
        }

        /**
         * Constructor.
         *
         * @param box the bounding box to be used for the rectangle
         */
        public PDRectangle( BoundingBox box )
        {
            rectArray = new COSArray();
            rectArray.add( new COSFloat( box.getLowerLeftX() ) );
            rectArray.add( new COSFloat( box.getLowerLeftY() ) );
            rectArray.add( new COSFloat( box.getUpperRightX() ) );
            rectArray.add( new COSFloat( box.getUpperRightY() ) );
        }

        /**
         * Constructor.
         *
         * @param array An array of numbers as specified in the PDF Reference for a rectangle type.
         */
        public PDRectangle( COSArray array )
        {
            float[] values = Arrays.copyOf(array.toFloatArray(), 4);
            rectArray = new COSArray();
            // we have to start with the lower left corner
            rectArray.add( new COSFloat( Math.min(values[0],values[2] )) );
            rectArray.add( new COSFloat( Math.min(values[1],values[3] )) );
            rectArray.add( new COSFloat( Math.max(values[0],values[2] )) );
            rectArray.add( new COSFloat( Math.max(values[1],values[3] )) );
        }

        /**
         * Method to determine if the x/y point is inside this rectangle.
         * @param x The x-coordinate to test.
         * @param y The y-coordinate to test.
         * @return True if the point is inside this rectangle.
         */
        public boolean contains( float x, float y )
        {
            float llx = getLowerLeftX();
            float urx = getUpperRightX();
            float lly = getLowerLeftY();
            float ury = getUpperRightY();
            return x >= llx && x <= urx &&
                   y >= lly && y <= ury;
        }

        /**
         * This will create a translated rectangle based off of this rectangle, such
         * that the new rectangle retains the same dimensions(height/width), but the
         * lower left x,y values are zero. <br>
         * 100, 100, 400, 400 (llx, lly, urx, ury ) <br>
         * will be translated to 0,0,300,300
         *
         * @return A new rectangle that has been translated back to the origin.
         */
        public PDRectangle createRetranslatedRectangle()
        {
            PDRectangle retval = new PDRectangle();
            retval.setUpperRightX( getWidth() );
            retval.setUpperRightY( getHeight() );
            return retval;
        }

        /**
         * This will get the underlying array for this rectangle.
         *
         * @return The cos array.
         */
        public COSArray getCOSArray()
        {
            return rectArray;
        }

        /**
         * This will get the lower left x coordinate.
         *
         * @return The lower left x.
         */
        public float getLowerLeftX()
        {
            return ((COSNumber)rectArray.get(0)).floatValue();
        }

        /**
         * This will set the lower left x coordinate.
         *
         * @param value The lower left x.
         */
        public void setLowerLeftX(float value)
        {
            rectArray.set(0, new COSFloat( value ) );
        }

        /**
         * This will get the lower left y coordinate.
         *
         * @return The lower left y.
         */
        public float getLowerLeftY()
        {
            return ((COSNumber)rectArray.get(1)).floatValue();
        }

        /**
         * This will set the lower left y coordinate.
         *
         * @param value The lower left y.
         */
        public void setLowerLeftY(float value)
        {
            rectArray.set(1, new COSFloat( value ) );
        }

        /**
         * This will get the upper right x coordinate.
         *
         * @return The upper right x .
         */
        public float getUpperRightX()
        {
            return ((COSNumber)rectArray.get(2)).floatValue();
        }

        /**
         * This will set the upper right x coordinate.
         *
         * @param value The upper right x .
         */
        public void setUpperRightX(float value)
        {
            rectArray.set(2, new COSFloat( value ) );
        }

        /**
         * This will get the upper right y coordinate.
         *
         * @return The upper right y.
         */
        public float getUpperRightY()
        {
            return ((COSNumber)rectArray.get(3)).floatValue();
        }

        /**
         * This will set the upper right y coordinate.
         *
         * @param value The upper right y.
         */
        public void setUpperRightY(float value)
        {
            rectArray.set(3, new COSFloat( value ) );
        }

        /**
         * This will get the width of this rectangle as calculated by
         * upperRightX - lowerLeftX.
         *
         * @return The width of this rectangle.
         */
        public float getWidth()
        {
            return getUpperRightX() - getLowerLeftX();
        }

        /**
         * This will get the height of this rectangle as calculated by
         * upperRightY - lowerLeftY.
         *
         * @return The height of this rectangle.
         */
        public float getHeight()
        {
            return getUpperRightY() - getLowerLeftY();
        }

        /**
         * Returns a path which represents this rectangle having been transformed by the given matrix.
         * Note that the resulting path need not be rectangular.
         */
        public GeneralPath transform(Matrix matrix)
        {
            float x1 = getLowerLeftX();
            float y1 = getLowerLeftY();
            float x2 = getUpperRightX();
            float y2 = getUpperRightY();

            Point2D.Float p0 = matrix.transformPoint(x1, y1);
            Point2D.Float p1 = matrix.transformPoint(x2, y1);
            Point2D.Float p2 = matrix.transformPoint(x2, y2);
            Point2D.Float p3 = matrix.transformPoint(x1, y2);

            GeneralPath path = new GeneralPath();
            path.moveTo(p0.getX(), p0.getY());
            path.lineTo(p1.getX(), p1.getY());
            path.lineTo(p2.getX(), p2.getY());
            path.lineTo(p3.getX(), p3.getY());
            path.closePath();
            return path;
        }

        /**
         * Convert this standard java object to a COS object.
         *
         * @return The cos object that matches this Java object.
         */
        @Override
        public COSBase getCOSObject()
        {
            return rectArray;
        }

        /**
         * Returns a general path equivalent to this rectangle. This method avoids the problems
         * caused by Rectangle2D not working well with -ve rectangles.
         */
        public GeneralPath toGeneralPath()
        {
            float x1 = getLowerLeftX();
            float y1 = getLowerLeftY();
            float x2 = getUpperRightX();
            float y2 = getUpperRightY();
            GeneralPath path = new GeneralPath();
            path.moveTo(x1, y1);
            path.lineTo(x2, y1);
            path.lineTo(x2, y2);
            path.lineTo(x1, y2);
            path.closePath();
            return path;
        }

        /**
         * This will return a string representation of this rectangle.
         *
         * @return This object as a string.
         */
        @Override
        public String toString()
        {
            return "[" + getLowerLeftX() + "," + getLowerLeftY() + "," +
                         getUpperRightX() + "," + getUpperRightY() +"]";
        }
    }