Java tutorial
/** * Copyright (c) 2003, www.pdfbox.org * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. Neither the name of pdfbox; nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * http://www.pdfbox.org * */ import java.awt.geom.AffineTransform; /** * This class will be used for matrix manipulation. * * @author <a href="mailto:ben@benlitchfield.com">Ben Litchfield</a> * @version $Revision: 1.14 $ */ public class Matrix implements Cloneable { private float[] single = { 1, 0, 0, 0, 1, 0, 0, 0, 1 }; /** * Constructor. */ public Matrix() { //default constructor } /** * Create an affine transform from this matrix's values. * * @return An affine transform with this matrix's values. */ public AffineTransform createAffineTransform() { AffineTransform retval = new AffineTransform(single[0], single[1], single[3], single[4], single[6], single[7]); return retval; } /** * Set the values of the matrix from the AffineTransform. * * @param af The transform to get the values from. */ public void setFromAffineTransform(AffineTransform af) { single[0] = (float) af.getScaleX(); single[1] = (float) af.getShearY(); single[3] = (float) af.getShearX(); single[4] = (float) af.getScaleY(); single[6] = (float) af.getTranslateX(); single[7] = (float) af.getTranslateY(); } /** * This will get a matrix value at some point. * * @param row The row to get the value from. * @param column The column to get the value from. * * @return The value at the row/column position. */ public float getValue(int row, int column) { return single[row * 3 + column]; } /** * This will set a value at a position. * * @param row The row to set the value at. * @param column the column to set the value at. * @param value The value to set at the position. */ public void setValue(int row, int column, float value) { single[row * 3 + column] = value; } /** * Return a single dimension array of all values in the matrix. * * @return The values ot this matrix. */ public float[][] getValues() { float[][] retval = new float[3][3]; retval[0][0] = single[0]; retval[0][1] = single[1]; retval[0][2] = single[2]; retval[1][0] = single[3]; retval[1][1] = single[4]; retval[1][2] = single[5]; retval[2][0] = single[6]; retval[2][1] = single[7]; retval[2][2] = single[8]; return retval; } /** * Return a single dimension array of all values in the matrix. * * @return The values ot this matrix. */ public double[][] getValuesAsDouble() { double[][] retval = new double[3][3]; retval[0][0] = single[0]; retval[0][1] = single[1]; retval[0][2] = single[2]; retval[1][0] = single[3]; retval[1][1] = single[4]; retval[1][2] = single[5]; retval[2][0] = single[6]; retval[2][1] = single[7]; retval[2][2] = single[8]; return retval; } /** * This will take the current matrix and multipy it with a matrix that is passed in. * * @param b The matrix to multiply by. * * @return The result of the two multiplied matrices. */ public Matrix multiply(Matrix b) { Matrix result = new Matrix(); float[] bMatrix = b.single; float[] resultMatrix = result.single; resultMatrix[0] = single[0] * bMatrix[0] + single[1] * bMatrix[3] + single[2] * bMatrix[6]; resultMatrix[1] = single[0] * bMatrix[1] + single[1] * bMatrix[4] + single[2] * bMatrix[7]; resultMatrix[2] = single[0] * bMatrix[2] + single[1] * bMatrix[5] + single[2] * bMatrix[8]; resultMatrix[3] = single[3] * bMatrix[0] + single[4] * bMatrix[3] + single[5] * bMatrix[6]; resultMatrix[4] = single[3] * bMatrix[1] + single[4] * bMatrix[4] + single[5] * bMatrix[7]; resultMatrix[5] = single[3] * bMatrix[2] + single[4] * bMatrix[5] + single[5] * bMatrix[8]; resultMatrix[6] = single[6] * bMatrix[0] + single[7] * bMatrix[3] + single[8] * bMatrix[6]; resultMatrix[7] = single[6] * bMatrix[1] + single[7] * bMatrix[4] + single[8] * bMatrix[7]; resultMatrix[8] = single[6] * bMatrix[2] + single[7] * bMatrix[5] + single[8] * bMatrix[8]; return result; } /** * Create a new matrix with just the scaling operators. * * @return A new matrix with just the scaling operators. */ public Matrix extractScaling() { Matrix retval = new Matrix(); retval.single[0] = this.single[0]; retval.single[4] = this.single[4]; return retval; } /** * Convenience method to create a scaled instance. * * @param x The xscale operator. * @param y The yscale operator. * @return A new matrix with just the x/y scaling */ public static Matrix getScaleInstance(float x, float y) { Matrix retval = new Matrix(); retval.single[0] = x; retval.single[4] = y; return retval; } /** * Create a new matrix with just the translating operators. * * @return A new matrix with just the translating operators. */ public Matrix extractTranslating() { Matrix retval = new Matrix(); retval.single[6] = this.single[6]; retval.single[7] = this.single[7]; return retval; } /** * Convenience method to create a translating instance. * * @param x The x translating operator. * @param y The y translating operator. * @return A new matrix with just the x/y translating. */ public static Matrix getTranslatingInstance(float x, float y) { Matrix retval = new Matrix(); retval.single[6] = x; retval.single[7] = y; return retval; } /** * Clones this object. * @return cloned matrix as an object. */ public Object clone() { Matrix clone = new Matrix(); System.arraycopy(single, 0, clone.single, 0, 9); return clone; } /** * This will copy the text matrix data. * * @return a matrix that matches this one. */ public Matrix copy() { return (Matrix) clone(); } /** * This will return a string representation of the matrix. * * @return The matrix as a string. */ public String toString() { StringBuffer result = new StringBuffer(""); result.append("[["); result.append(single[0] + ","); result.append(single[1] + ","); result.append(single[2] + "]["); result.append(single[3] + ","); result.append(single[4] + ","); result.append(single[5] + "]["); result.append(single[6] + ","); result.append(single[7] + ","); result.append(single[8] + "]]"); return result.toString(); } /** * Get the xscaling factor of this matrix. * @return The x-scale. */ public float getXScale() { float xScale = single[0]; /** * BM: if the trm is rotated, the calculation is a little more complicated * * The rotation matrix multiplied with the scaling matrix is: * ( x 0 0) ( cos sin 0) ( x*cos x*sin 0) * ( 0 y 0) * (-sin cos 0) = (-y*sin y*cos 0) * ( 0 0 1) ( 0 0 1) ( 0 0 1) * * So, if you want to deduce x from the matrix you take * M(0,0) = x*cos and M(0,1) = x*sin and use the theorem of Pythagoras * * sqrt(M(0,0)^2+M(0,1)^2) = * sqrt(x2*cos2+x2*sin2) = * sqrt(x2*(cos2+sin2)) = <- here is the trick cos2+sin2 is one * sqrt(x2) = * abs(x) */ if (!(single[1] == 0.0f && single[3] == 0.0f)) { xScale = (float) Math.sqrt(Math.pow(single[0], 2) + Math.pow(single[1], 2)); } return xScale; } /** * Get the y scaling factor of this matrix. * @return The y-scale factor. */ public float getYScale() { float yScale = single[4]; if (!(single[1] == 0.0f && single[3] == 0.0f)) { yScale = (float) Math.sqrt(Math.pow(single[3], 2) + Math.pow(single[4], 2)); } return yScale; } /** * Get the x position in the matrix. * @return The x-position. */ public float getXPosition() { return single[6]; } /** * Get the y position. * @return The y position. */ public float getYPosition() { return single[7]; } }