Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Instituto de Desarrollo Regional and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   Instituto de Desarrollo Regional (Universidad de Castilla La-Mancha)

 *   Campus Universitario s/n

 *   02071 Alabacete

 *   Spain

 *

 *   +34 967 599 200

 */

package es.idr.teledeteccion.connection;

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStreamReader;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.logging.Logger;

import org.geotools.referencing.factory.epsg.HSQLDataSource;

import org.geotools.referencing.factory.iau2000.FactoryUsingHSQL;

import org.hsqldb.jdbc.jdbcDataSource;

/**

 * Clase para la conexi?n con la base de datos de hsqldb.

 * Establece el driver necesario, as? como la cadena de

 * conexi?n a la base de datos de la EPSG y la IAU2000

 * 

 * @author Jos? Luis G?mez Mart?nez (jolugomar@gmail.com)

 *

 */

public class EpsgConnection extends jdbcDataSource {

	Connection connect;

	public EpsgConnection() {	

	/*	try {

			Class.forName("org.hsqldb.jdbcDriver");

		} catch (ClassNotFoundException e) {

			e.printStackTrace();

		}*/

	}

	public void setConnectionEPSG() {

		HSQLDataSource ds = new HSQLDataSource();

		try {

			connect = ds.getConnection();

		} catch (SQLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	/**

	 * Establece la conexi?n con la base de datos de la IAU2000

	 *

	 */

	public void setConnectionIAU2000() {

		setDatabase("jdbc:hsqldb:file:gvSIG/extensiones/org.gvsig.crs.extension/iau2000");

		setUser("sa");

		try {

			connect = super.getConnection();

		} catch (SQLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	/**

	 * Establece la conexi?n con la base de datos de ESRI

	 *

	 */

	public void setConnectionEsri() {

		setDatabase("jdbc:hsqldb:file:gvSIG/extensiones/org.gvsig.crs.extension/esri");

		setUser("sa");

		try {

			connect = super.getConnection();

		} catch (SQLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	/**

	 * Establece la conexi?n con la base de datos de USR

	 *

	 */

	public void setConnectionUsr() {

		setDatabase("jdbc:hsqldb:file:gvSIG/extensiones/org.gvsig.crs.extension/usr");

		setUser("sa");

		try {

			connect = super.getConnection();

		} catch (SQLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	public Connection getConnection(){

		return connect;

	}

	public void shutdown() throws SQLException {

        Statement st = connect.createStatement();

        // db writes out to files and performs clean shuts down

        // otherwise there will be an unclean shutdown

        // when program ends

        st.execute("SHUTDOWN");

        connect.close();    // if there are no other open connection

    }

	public synchronized void update(String expression) throws SQLException {

        Statement st = null;

        st = connect.createStatement();    // statements

        int i = st.executeUpdate(expression);    // run the query

        if (i == -1) {

            System.out.println("db error : " + expression);

        }

        st.close();

    }

	/*

	*//**

	 * Establece la conexi?n con la base de datos de la EPSG

	 *

	 *//*

	public void setConnectionEPSG() {

		try {			

			connect =  DriverManager.getConnection("jdbc:hsqldb:file:gvSIG/extensiones/org.gvsig.crs.extension/db_epsg", "sa", "");

		} catch (SQLException e1) {

			e1.printStackTrace();

		}

	}

	*//**

	 * Establece la conexi?n con la base de datos de la IAU2000

	 *

	 *//*

	public void setConnectionIAU2000() {

		try {			

			connect =  DriverManager.getConnection("jdbc:hsqldb:file:gvSIG/extensiones/org.gvsig.crs.extension/db_iau2000", "sa", "");			

		} catch (SQLException e1) {

			e1.printStackTrace();

		}

	}

	*//**

	 * Establece la conexi?n con la base de datos de ESRI

	 *

	 *//*

	public void setConnectionEsri() {

		try {			

			connect =  DriverManager.getConnection("jdbc:hsqldb:file:/home/jlgomez/gvSIGF2/_fwAndami/gvSIG/extensiones/org.gvsig.crs.extension/db_esri", "sa", "");			

		} catch (SQLException e1) {

			e1.printStackTrace();

		}

	}

	*//**

	 * Establece la conexi?n con la base de datos de USR

	 *

	 *//*

	public void setConnectionUsr() {

		try {			

			connect =  DriverManager.getConnection("jdbc:hsqldb:file:gvSIG/extensiones/org.gvsig.crs.extension/db_usr", "sa", "");			

		} catch (SQLException e1) {

			e1.printStackTrace();

		}

	}

	public Connection getConnection(){

		return connect;

	}

	public void shutdown() throws SQLException {

        Statement st = connect.createStatement();

        // db writes out to files and performs clean shuts down

        // otherwise there will be an unclean shutdown

        // when program ends

        st.execute("SHUTDOWN");

        connect.close();    // if there are no other open connection

    }*/

	 /**

     * Returns {@code true} if the database contains data. This method returns {@code false}

     * if an empty EPSG database has been automatically created by HSQL and not yet populated.

     */

    private static boolean dataExists(final Connection connection) throws SQLException {

        final ResultSet tables = connection.getMetaData().getTables(

                null, null, "IAU2000_%", new String[] {"TABLE"});

        final boolean exists = tables.next();

        tables.close();

        return exists;

    }

}

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Instituto de Desarrollo Regional and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   Instituto de Desarrollo Regional (Universidad de Castilla La-Mancha)

 *   Campus Universitario s/n

 *   02071 Alabacete

 *   Spain

 *

 *   +34 967 599 200

 */

package es.idr.teledeteccion.connection;

import java.io.Serializable;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

/**

 * Clase para realizar las consultas a las bases de datos utilizadas

 * 

 * @author Jos? Luis G?mez Mart?nez (jolugomar@gmail.com)

 *

 */

public class Query implements Serializable{

	/**

	 * 

	 */

	private static final long serialVersionUID = 1L;

	/**

	 * Acepta la sentencia y la conexi?n a la base de datos actual,

	 * realiza una selecci?n y devuelve los datos en un ResultSet

	 * @param sentence

	 * @param conn

	 * @return

	 */

	public static synchronized ResultSet select(String sentence, Connection conn){

		Statement st = null;

		ResultSet rs = null;

		try {

			st = conn.createStatement();

			rs = st.executeQuery(sentence);

			st.close();

		} catch (SQLException e) {

			e.printStackTrace();

		}		

		return rs;

	}	

}

package org.geotools.referencing.operation.projection;

import java.awt.geom.Point2D;

import java.util.Collection;

import javax.units.NonSI;

import org.opengis.parameter.ParameterDescriptorGroup;

import org.opengis.parameter.ParameterNotFoundException;

import org.opengis.parameter.ParameterValueGroup;

import org.geotools.metadata.iso.citation.CitationImpl;

import org.geotools.referencing.NamedIdentifier;

import org.geotools.resources.XMath;

import org.geotools.resources.cts.ResourceKeys;

import org.geotools.resources.cts.Resources;

import org.opengis.parameter.ParameterDescriptor;

import org.opengis.referencing.operation.Projection;

import org.opengis.referencing.operation.MathTransform;

public class IdrRobinson extends MapProjection {

    protected IdrRobinson(ParameterValueGroup parameters) throws ParameterNotFoundException {

		super(parameters);

        final Collection expected = getParameterDescriptors().descriptors();

	}

	public ParameterDescriptorGroup getParameterDescriptors() {

        return Provider.PARAMETERS;

	}

    public ParameterValueGroup getParameterValues() {

        final ParameterValueGroup values = super.getParameterValues();

        return values;

    }

	protected Point2D inverseTransformNormalized(double x, double y,

			Point2D ptDst) throws ProjectionException {

		// TODO Auto-generated method stub

		return null;

	}

	protected Point2D transformNormalized(double x, double y, Point2D ptDst)

			throws ProjectionException {

		// TODO Auto-generated method stub

		return null;

	}

	public static class Provider extends AbstractProvider {

	        static final ParameterDescriptorGroup PARAMETERS = createDescriptorGroup(new NamedIdentifier[] {

	                new NamedIdentifier(CitationImpl.OGC,      "Robinson"),

        			new NamedIdentifier(CitationImpl.EPSG,     "Robinson"),

                    new NamedIdentifier(new CitationImpl("IDR"), "IDR")//,

	                //new NamedIdentifier(CitationImpl.EPSG,     "9823")//,

//	                new NamedIdentifier(CitationImpl.GEOTOOLS, Vocabulary.formatInternational(

//	                                    VocabularyKeys.EQUIDISTANT_CYLINDRICAL_PROJECTION))

	            }, new ParameterDescriptor[] {

	                SEMI_MAJOR,       SEMI_MINOR,

	                CENTRAL_MERIDIAN,

	                FALSE_EASTING,    FALSE_NORTHING

	            });

			/*String[] parameterName={"central_meridian"};

			projectionParameterList.add(count,parameterName);

			addProjectionParameter(count,"standard_parallel_1");

			addProjectionParameter(count,"false_easting");

			addProjectionParameter(count,"false_northing");*/

	        /**

	         * Constructs a new provider.

	         */

	        public Provider() {

	            super(PARAMETERS);

	        }

	        /**

	         * Returns the operation type for this map projection.

	         */

	        protected Class getOperationType() {

	        	return Projection.class;

	        }

	        /**

	         * Creates a transform from the specified group of parameter values.

	         *

	         * @param  parameters The group of parameter values.

	         * @return The created math transform.

	         * @throws ParameterNotFoundException if a required parameter was not found.

	         */

	        public MathTransform createMathTransform(final ParameterValueGroup parameters)

	                throws ParameterNotFoundException

	        {

	        	return new IdrRobinson(parameters);

	        }

	    }

}

/*

 *    GeoTools - OpenSource mapping toolkit

 *    http://geotools.org

 *

 *   (C) 2005-2006, Geotools Project Managment Committee (PMC)

 *   

 *    This library is free software; you can redistribute it and/or

 *    modify it under the terms of the GNU Lesser General Public

 *    License as published by the Free Software Foundation;

 *    version 2.1 of the License.

 *

 *    This library is distributed in the hope that it will be useful,

 *    but WITHOUT ANY WARRANTY; without even the implied warranty of

 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *    Lesser General Public License for more details.

 */

package org.geotools.referencing.operation.projection;

// J2SE dependencies

import java.awt.geom.Point2D;

import java.util.Collection;

import javax.units.NonSI;

import javax.units.SI;

import javax.units.Unit;

import org.geotools.metadata.iso.citation.CitationImpl;

import org.geotools.referencing.NamedIdentifier;

import org.opengis.metadata.Identifier;

import org.opengis.parameter.ParameterDescriptor;

import org.opengis.parameter.ParameterDescriptorGroup;

import org.opengis.parameter.ParameterNotFoundException;

import org.opengis.parameter.ParameterValueGroup;

import org.opengis.referencing.operation.MathTransform;

import org.opengis.spatialschema.geometry.complex.Complex;

/**

 * Implementation of the NZMG (New Zealand Map Grid) projection.

 * <p>

 * This is an implementation of algorithm published by

 * <a href="http://www.govt.nz/record?recordid=28">Land Information New Zealand</a>.

 * The algorithm is documented <a href="http://www.linz.govt.nz/rcs/linz/6137/">here</a>.

 *

 * @since 2.2

 * @source $URL: http://svn.geotools.org/geotools/tags/2.3.0/module/referencing/src/org/geotools/referencing/operation/projection/NewZealandMapGrid.java $

 * @version $Id$

 * @author Justin Deoliveira

 * @author Martin Desruisseaux

 *

 * @todo The algorithm uses complex numbers, which is not very well supported in Java. This

 *       implementation uses {@linkplain Complex} as a support class. Various instances of

 *       {@link Complex} are created once for ever at {@code NewZealandMapGrid} construction

 *       time, in order to avoid creating up to 6 objects for every point to be projected.

 *       The downside is that transformation methods must be synchronized. The cost should

 *       be small for simple applications, but may become important for multi-thread applications.

 *       Furthermore, those fields raise a slight serialization issue.

 *       <p>

 *       The most efficient fix in Java would be to expand inline all {@link Complex} operations

 *       like {@link Complex#add add} (easy), {@link Complex#multiply multiply} (more tedious),

 *       <cite>etc.</cite>, until we get a code using only {@code double} primitives on the stack

 *       and no {@link Complex} objects on the heap (except the {@code A} and {@code B} constants).

 *       But it would make the code significantly more complex and difficult to read.

 *       <p>

 *       An elegant fix would have been "lightweight objects" allocated on the stack (something

 *       similar to {@code struct} in C#), if such thing existed in the Java language.

 */

public class IdrNewZealandMapGrid extends MapProjection {

    /**

     * For compatibility with different versions during deserialization.

     */

    private static final long serialVersionUID = 8394817836243729133L;

    /**

     * Coefficients for forward and inverse projection.

     */

    /*private static final Complex[] A = {

            new Complex(  0.7557853228,  0.0         ),

            new Complex(  0.249204646,   0.003371507 ),

            new Complex( -0.001541739,   0.041058560 ),

            new Complex( -0.10162907,    0.01727609  ),

            new Complex( -0.26623489,   -0.36249218  ),

            new Complex( -0.6870983,    -1.1651967   )

        };*/

    /**

     * Coefficients for inverse projection.

     */

    /*private static final Complex[] B = {

            new Complex(  1.3231270439,   0.0         ),

            new Complex( -0.577245789,   -0.007809598 ),

            new Complex(  0.508307513,   -0.112208952 ),

            new Complex( -0.15094762,     0.18200602  ),

            new Complex(  1.01418179,     1.64497696  ),

            new Complex(  1.9660549,      2.5127645   )

        };*/

    /**

     * Coefficients for inverse projection.

     */

    private static final double[] TPHI = new double[] {

            1.5627014243, 0.5185406398, -0.03333098, -0.1052906, -0.0368594, 0.007317,

            0.01220, 0.00394, -0.0013

        };

    /**

     * Coefficients for forward projection.

     */

    private static final double[] TPSI = new double[] {

            0.6399175073, -0.1358797613, 0.063294409, -0.02526853, 0.0117879,

            -0.0055161, 0.0026906, -0.001333, 0.00067, -0.00034

        };

    /**

     * A temporary complex number used during transform calculation. Created once for

     * ever in order to avoid new object creation for every point to be transformed.

     */

    /*private transient final Complex theta = new Complex();*/

    /**

     * An other temporary complex number created once for ever for the same reason than

     * {@link #theta}. This number is usually equals to some other complex number raised

     * to some power.

     */

    /*private transient final Complex power = new Complex();*/

    /**

     * An other temporary complex number created once for ever for the same reason than

     * {@link #theta}.

     *

     * @todo Need to reassign those fields on deserialization.

     */

    /*private transient final Complex z=new Complex(), t=new Complex(),

                                    num=new Complex(), denom=new Complex();*/

    /**

     * Constructs a new map projection with default parameter values.

     */

    protected IdrNewZealandMapGrid() {

        this((ParameterValueGroup) Provider.PARAMETERS.createValue());

    }

    /**

     * Constructs a new map projection from the supplied parameters.

     *

     * @param  parameters The parameter values in standard units.

     * @throws ParameterNotFoundException if a mandatory parameter is missing.

     */

    protected IdrNewZealandMapGrid(final ParameterValueGroup parameters)

            throws ParameterNotFoundException

    {

        super(parameters);

    }

    /**

     * {@inheritDoc}

     */

    public ParameterDescriptorGroup getParameterDescriptors() {

        return Provider.PARAMETERS;

    }

    /**

     * Must be overrided because {@link Provider} uses instances of

     * {@link ModifiedParameterDescriptor}. This hack was needed because the New Zeland map

     * projection uses particular default values for parameters like "False Easting", etc.

     */

    /*final boolean isExpectedParameter(final Collection expected, final ParameterDescriptor param) {

        return ModifiedParameterDescriptor.contains(expected, param);

    }*/

    /**

     * Transforms the specified (<var>x</var>,<var>y</var>) coordinate (units in radians)

     * and stores the result in {@code ptDst} (linear distance on a unit sphere).

     */

    protected synchronized Point2D transformNormalized(final double x, final double y,

                                                       final Point2D ptDst)

            throws ProjectionException

    {

        /*

    	final double dphi = (y - latitudeOfOrigin) * (180/Math.PI * 3600E-5);

        double dphi_pow_i = dphi;

        double dpsi       = 0;

        for (int i=0; i<TPSI.length; i++) {

            dpsi += (TPSI[i] * dphi_pow_i);

            dphi_pow_i *= dphi;

        }

        power.real = theta.real = dpsi;

        power.imag = theta.imag = x;

        z.multiply(A[0], power);

        for (int i=1; i<A.length; i++) {

            power.multiply(power, theta);

            z.addMultiply(z, A[i], power);

        }

        if (ptDst != null) {

            ptDst.setLocation(z.imag, z.real);

            return ptDst;

        }

        return new Point2D.Double(z.imag, z.real);

        */

        return new Point2D.Double(0.0, 0.0);

    }

    /**

     * Transforms the specified (<var>x</var>,<var>y</var>) coordinate

     * and stores the result in {@code ptDst}.

     */

    protected synchronized Point2D inverseTransformNormalized(final double x, final double y,

                                                              final Point2D ptDst)

            throws ProjectionException

    {

    	/*

        power.real = z.real = y;

        power.imag = z.imag = x;

        theta.multiply(B[0], z);

        for (int j=1; j<B.length; j++) {

            power.multiply(power, z);

            theta.addMultiply(theta, B[j], power);

        }

        // increasing the number of iterations through this loop decreases

        // the error in the calculation, but 3 iterations gives 10-3 accuracy

        for (int j=0; j<3; j++) {

            power.power(theta, 2);

            num.addMultiply(z, A[1], power);

            for (int k=2; k<A.length; k++) {

                power.multiply(power, theta);

                t.multiply(A[k], power);

                t.multiply(t, k);

                num.add(num, t);

            }

            power.real = 1;

            power.imag = 0;

            denom.copy(A[0]);

            for (int k=1; k<A.length; k++) {

                power.multiply(power, theta);

                t.multiply(A[k], power);

                t.multiply(t, k+1);

                denom.add(denom, t);

            }

            theta.divide(num, denom);

        }

        final double dpsi = theta.real;

        double dpsi_pow_i = dpsi;

        double dphi = TPHI[0] * dpsi;

        for (int i=1; i<TPHI.length; i++) {

            dpsi_pow_i *= dpsi;

            dphi += (TPHI[i] * dpsi_pow_i);

        }

        dphi = dphi / (180/Math.PI * 3600E-5) + latitudeOfOrigin;

        if (ptDst != null) {

            ptDst.setLocation(theta.imag, dphi);

            return ptDst;

        }

        return new Point2D.Double(theta.imag, dphi);

        */

        return new Point2D.Double(0.0,0.0);

    }

    /**

     * The {@link org.geotools.referencing.operation.MathTransformProvider} for

     * {@linkplain IdrNewZealandMapGrid New Zealand Map Grid}.

     *

     * @since 2.2

     * @version $Id$

     * @author Justin Deoliveira

     */

    public static class Provider extends AbstractProvider {

        /**

         * For compatibility with different versions during deserialization.

         */

        private static final long serialVersionUID = -7716733400419275656L;

        /**

         * The operation parameter descriptor for the {@link #semiMajor semiMajor} parameter value.

         * Valid values range is from 0 to infinity. This parameter is mandatory.

         *

         * @todo Would like to start range from 0 <u>exclusive</u>.

         */

        public static final ParameterDescriptor SEMI_MAJOR_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,  "semi_major"),

                    new NamedIdentifier(CitationImpl.EPSG, "semi-major axis")   //epsg does not specifically define this parameter

                },

                6378388.0, 6378388.0, 6378388.0, SI.METER);

        /**

         * The operation parameter descriptor for the {@link #semiMinor semiMinor} parameter value.

         * Valid values range is from 0 to infinity. This parameter is mandatory.

         *

         * @todo Would like to start range from 0 <u>exclusive</u>.

         */

        public static final ParameterDescriptor SEMI_MINOR_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,  "semi_minor"),

                    new NamedIdentifier(CitationImpl.EPSG, "semi-minor axis")   //epsg does not specifically define this parameter

                },

                6378388.0*(1-1/297.0), 6378388.0*(1-1/297.0), 6378388.0*(1-1/297.0), SI.METER);

        /**

         * The operation parameter descriptor for the {@link #centralMeridian centralMeridian}

         * parameter value. Valid values range is from -180 to 180. Default value is 0.

         */

        public static final ParameterDescriptor CENTRAL_MERIDIAN_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,     "central_meridian"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Longitude of natural origin"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Longitude of false origin"),

                    new NamedIdentifier(CitationImpl.ESRI,    "Longitude_Of_Origin"),

                    new NamedIdentifier(CitationImpl.ESRI,    "Longitude_Of_Center"),  //ESRI uses this in orthographic (not to be confused with Longitude_Of_Center in oblique mercator)

                    new NamedIdentifier(CitationImpl.GEOTIFF, "NatOriginLong")

                },

                173.0, 173.0, 173.0, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #latitudeOfOrigin latitudeOfOrigin}

         * parameter value. Valid values range is from -90 to 90. Default value is 0.

         */

        public static final ParameterDescriptor LATITUDE_OF_ORIGIN_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,  "latitude_of_origin"),

                    new NamedIdentifier(CitationImpl.EPSG, "Latitude of false origin"),

                    new NamedIdentifier(CitationImpl.EPSG, "Latitude of natural origin"),

                    new NamedIdentifier(CitationImpl.ESRI, "Latitude_Of_Center"),  //ESRI uses this in orthographic 

                    new NamedIdentifier(CitationImpl.GEOTIFF,  "NatOriginLat")

                },

                -41.0, -41.0, -41.0, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #falseEasting falseEasting}

         * parameter value. Valid values range is unrestricted. Default value is 0.

         */

        public static final ParameterDescriptor FALSE_EASTING_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,     "false_easting"),

                    new NamedIdentifier(CitationImpl.EPSG,    "False easting"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Easting at false origin"),

                    new NamedIdentifier(CitationImpl.GEOTIFF, "FalseEasting")

                },

                2510000.0, 2510000.0, 2510000.0, SI.METER);

        /**

         * The operation parameter descriptor for the {@link #falseNorthing falseNorthing}

         * parameter value. Valid values range is unrestricted. Default value is 0.

         */

        public static final ParameterDescriptor FALSE_NORTHING_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,     "false_northing"),

                    new NamedIdentifier(CitationImpl.EPSG,    "False northing"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Northing at false origin"),

                    new NamedIdentifier(CitationImpl.GEOTIFF, "FalseNorthing")

                },

                6023150.0, 6023150.0, 6023150.0, SI.METER);

        /**

         * The parameters group.

         */

        static final ParameterDescriptorGroup PARAMETERS = createDescriptorGroup(new Identifier[] {

                    new NamedIdentifier(CitationImpl.OGC,  "New_Zealand_Map_Grid"),

                    new NamedIdentifier(CitationImpl.EPSG, "New Zealand Map Grid"),

                    new NamedIdentifier(CitationImpl.EPSG, "27200"),

                    new NamedIdentifier(new CitationImpl("IDR"), "IDR")

                },

                new ParameterDescriptor[] {

                    SEMI_MAJOR_LOCAL,			SEMI_MINOR_LOCAL,

                    LATITUDE_OF_ORIGIN_LOCAL,   CENTRAL_MERIDIAN_LOCAL,

                    FALSE_EASTING_LOCAL,		FALSE_NORTHING_LOCAL

                });

        /*new ParameterDescriptor[] {

                new ModifiedParameterDescriptor(SEMI_MAJOR_L,         6378388.0),

                new ModifiedParameterDescriptor(SEMI_MINOR,         6378388.0*(1-1/297.0)),

                new ModifiedParameterDescriptor(LATITUDE_OF_ORIGIN,     -41.0),

                new ModifiedParameterDescriptor(CENTRAL_MERIDIAN,       173.0),

                new ModifiedParameterDescriptor(FALSE_EASTING,      2510000.0),

                new ModifiedParameterDescriptor(FALSE_NORTHING,     6023150.0)*/

        /**

         * Constructs a new provider. 

         */

        public Provider() {

            super(PARAMETERS);

        }    

        /**

         * Creates a transform from the specified group of parameter values. This method doesn't

         * check for the spherical case, since the New Zealand Map Grid projection is used with

         * the International 1924 ellipsoid.

         *

         * @param  parameters The group of parameter values.

         * @return The created math transform.

         * @throws ParameterNotFoundException if a required parameter was not found.

         */

        public MathTransform createMathTransform(final ParameterValueGroup parameters)

                throws ParameterNotFoundException

        {

            return new IdrNewZealandMapGrid(parameters);

        }

    }

}

/*

 * Geotools - OpenSource mapping toolkit

 * (C) 2005, Geotools Project Managment Committee (PMC)

 *

 *    This library is free software; you can redistribute it and/or

 *    modify it under the terms of the GNU Lesser General Public

 *    License as published by the Free Software Foundation; either

 *    version 2.1 of the License, or (at your option) any later version.

 *

 *    This library is distributed in the hope that it will be useful,

 *    but WITHOUT ANY WARRANTY; without even the implied warranty of

 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *    Lesser General Public License for more details.

 *

 *    You should have received a copy of the GNU Lesser General Public

 *    License along with this library; if not, write to the Free Software

 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 *

 *    This package contains formulas from the PROJ package of USGS.

 *    USGS's work is fully acknowledged here.

 */

/*

** libproj -- library of cartographic projections

** Some parts Copyright (c) 2003   Gerald I. Evenden

**

** Permission is hereby granted, free of charge, to any person obtaining

** a copy of this software and associated documentation files (the

** "Software"), to deal in the Software without restriction, including

** without limitation the rights to use, copy, modify, merge, publish,

** distribute, sublicense, and/or sell copies of the Software, and to

** permit persons to whom the Software is furnished to do so, subject to

** the following conditions:

**

** The above copyright notice and this permission notice shall be

** included in all copies or substantial portions of the Software.

**

** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

package org.geotools.referencing.operation.projection;

// J2SE dependencies and extensions

import java.awt.geom.Point2D;

import java.util.Collection;

import javax.units.NonSI;

import javax.units.SI;

import javax.units.Unit;

import org.geotools.metadata.iso.citation.CitationImpl;

import org.geotools.referencing.NamedIdentifier;

import org.geotools.referencing.operation.projection.IdrAzimuthalEquidistant.Provider;

import org.geotools.resources.cts.ResourceKeys;

import org.geotools.resources.cts.Resources;

import org.opengis.parameter.ParameterDescriptor;

import org.opengis.parameter.ParameterDescriptorGroup;

import org.opengis.parameter.ParameterNotFoundException;

import org.opengis.parameter.ParameterValueGroup;

import org.opengis.referencing.operation.CylindricalProjection;

import org.opengis.referencing.operation.MathTransform;

/**

 * Oblique Mercator Projection. A conformal, oblique, cylindrical projection 

 * with the cylinder touching the ellipsoid (or sphere) along a great circle 

 * path (the central line). The Mercator and Transverse Mercator projections 

 * can be thought of as special cases of the oblique mercator, where the central 

 * line is along the equator or a meridian, respectively. The Oblique Mercator 

 * projection has been used in Switzerland, Hungary, Madagascar, 

 * Malaysia, Borneo and the panhandle of Alaska.

 * <br><br>

 * 

 * The Oblique Mercator projection uses a (U,V) coordinate system, with the 

 * U axis along the central line. During the forward projection, coordinates 

 * from the ellipsoid are projected conformally to a sphere of constant total 

 * curvature, called the 'aposphere', before being projected onto the plane. 

 * The projection coordinates are further convented to a (X,Y) coordinate system 

 * by rotating the calculated (u,v) coordinates to give output (x,y) coordinates. 

 * The rotation value is usually the same as the projection azimuth (the angle, 

 * east of north, of the central line), but some cases allow a separate 

 * rotation parameter. 

 * <br><br>

 * 

 * There are two forms of the oblique mercator, differing in the origin of

 * their grid coordinates. The Hotine_Oblique_Mercator (EPSG code 9812) has grid 

 * coordinates start at the intersection of the central line and the equator of the 

 * aposphere. The Oblique_Mercator (EPSG code 9815) is the same, except the grid 

 * coordinates begin at the central point (where the latitude of center and 

 * central line intersect). ESRI separates these two case by appending

 * "Natural_Origin" (for the Hotine_Oblique_Mercator) and "Center" 

 * (for the Obique_Mercator) to the projection names.

 * <br><br>

 * 

 * Two different methods are used to specify the central line for the 

 * oblique mercator: 1) a central point and an azimuth, 

 * east of north, describing the central line and 

 * 2) two points on the central line. The EPSG does not use the two point method, 

 * while ESRI separates the two cases by putting "Azimuth" and "Two_Point" in 

 * their projection names. Both cases use the point where the "latitude_of_center" 

 * parameter crosses the central line as the projection's central point. 

 * The central meridian is not a projection parameter, and is instead calculated 

 * as the intersection between the central line and the equator of the aposphere. 

 * <br><br>

 *

 * For the azimuth method, the central latitude cannot be +- 90.0 degrees

 * and the central line cannot be at a maximum or minimum latitude at the central point.

 * In the two point method, the latitude of the first and second points cannot be

 * equal. Also, the latitude of the first point and central point cannot be

 * +- 90.0 degrees. Furthermore, the latitude of the first point cannot be 0.0 and 

 * the latitude of the second point cannot be - 90.0 degrees. A change of 

 * 10^-7 radians can allow calculation at these special cases. Snyder's restriction

 * of the central latitude being 0.0 has been removed, since the equaitons appear

 * to work correctly in this case.

 * <br><br>

 *

 * Azimuth values of 0.0 and +- 90.0 degrees are allowed (and used in Hungary

 * and Switzerland), though these cases would usually use a Mercator or 

 * Transverse Mercator projection instead. Azimuth values > 90 degrees cause

 * errors in the equations.

 * <br><br>

 * 

 * The oblique mercator is also called the "Rectified Skew Orthomorphic" (RSO). 

 * It appears is that the only difference from the oblique mercator is that

 * the RSO allows the rotation from the (U,V) to (X,Y) coordinate system to be different

 * from the azimuth. This separate parameter is called "rectified_grid_angle" (or 

 * "XY_Plane_Rotation" by ESRI) and is also included in the EPSG's parameters

 * for the Oblique Mercator and Hotine Oblique Mercator. 

 * The rotation parameter is optional in all the non-two point projections and will be

 * set to the azimuth if not specified.

 * <br><br>

 * 

 * Projection cases and aliases implemented by the {@link IdrObliqueMercator} are:

 * <ul>

 * <li>Oblique_Mercator (EPSG code 9815) - grid coordinates begin at the central point, has "rectified_grid_angle" parameter.</li>

 * <li>Hotine_Oblique_Mercator_Azimuth_Center (ESRI) - grid coordinates begin at the central point.</li>

 * <li>Rectified_Skew_Orthomorphic_Center (ESRI) - grid coordinates begin at the central point, has "rectified_grid_angle" parameter.</li>

 * 

 * <li>Hotine_Oblique_Mercator (EPSG code 9812) - grid coordinates begin at the interseciton of the central line and aposphere equator, has "rectified_grid_angle" parameter.</li>

 * <li>Hotine_Oblique_Mercator_Azimuth_Natural_Origin (ESRI) - grid coordinates begin at the interseciton of the central line and aposphere equator.</li>

 * <li>Rectified_Skew_Orthomorphic_Natural_Origin (ESRI) - grid coordinates begin at the interseciton of the central line and aposphere equator, has "rectified_grid_angle" parameter.</li>

 * 

 * <li>Hotine_Oblique_Mercator_Two_Point_Center (ESRI) - grid coordinates begin at the central point.</li>

 * <li>Hotine_Oblique_Mercator_Two_Point_Natural_Origin (ESRI) - grid coordinates begin at the interseciton of the central line and aposphere equator.</li>

 * </ul>

 * 

 * <strong>References:</strong>

 * <ul>

 *   <li><code>libproj4</code> is available at

 *       <A HREF="http://members.bellatlantic.net/~vze2hc4d/proj4/">libproj4 Miscellanea</A><br>

 *        Relevent files are: <code>PJ_omerc.c</code>, <code>pj_tsfn.c</code>,

 *        <code>pj_fwd.c</code>, <code>pj_inv.c</code> and <code>lib_proj.h</code></li>

 *   <li> John P. Snyder (Map Projections - A Working Manual,

 *        U.S. Geological Survey Professional Paper 1395, 1987)</li>

 *   <li> "Coordinate Conversions and Transformations including Formulas",

 *        EPSG Guidence Note Number 7 part 2, Version 24.</li>

 *   <li>Gerald Evenden, 2004, <a href="http://members.verizon.net/~vze2hc4d/proj4/omerc.pdf">

 *         Documentation of revised Oblique Mercator</a></li>

 * </ul>

 * 

 * @see <A HREF="http://mathworld.wolfram.com/MercatorProjection.html">Oblique Mercator projection on MathWorld</A>

 * @see <A HREF="http://www.remotesensing.org/geotiff/proj_list/hotine_oblique_mercator.html">hotine_oblique_mercator on Remote Sensing</A>

 * @see <A HREF="http://www.remotesensing.org/geotiff/proj_list/oblique_mercator.html">oblique_mercator on Remote Sensing</A>

 *

 * @version $Id$

 * @author  Rueben Schulz

 */

public class IdrObliqueMercator extends MapProjection {

	private final double scaleFactorLocal;

	private final double falseEastingLocal;

	private final double falseNorthingLocal;

	/**

     * Latitude of the projection centre. This is similar to the 

     * {@link #latitudeOfOrigin}, but the latitude of origin is the

     * Earth equator on aposphere for the oblique mercator. Needed

     * for WKT.

     */

    private final double latitudeOfCentre;

    /**

     * Longitude of the projection centre. This is <strong>NOT</strong> equal

     * to the {@link #centralMeridian}, which is the meridian where the

     * central line intersects the Earth equator on aposphere. Needed for

     * for non-two point WKT.

     */

    private final double longitudeOfCentre;

    /**

     * The azimuth of the central line passing throught the centre of the

     * projection, needed for for non-two point WKT. 

     */

    private double alpha_c; 

    /**

     * The rectified bearing of the central line, needed for non-two point WKT. Equals

     * {@link #alpha_c} if the "rectified_grid_angle" parameter value is not set.

     */

    private double rectGridAngle;

    /**

     * The latitude of the 1st point used to specify the central line, needed for two point

     * WKT. 

     */

    private final double latitudeOf1stPoint;

    /**

     * The longitude of the 1st point used to specify the central line, needed for two point

     * WKT. 

     */

    private final double longitudeOf1stPoint;

    /**

     * The latitude of the 2nd point used to specify the central line, needed for two point

     * WKT. 

     */

    private final double latitudeOf2ndPoint;

    /**

     * The longitude of the 2nd point used to specify the central line, needed for two point

     * WKT.  

     */

    private double longitudeOf2ndPoint;

    /**

     * Constants used in the transformation.

     */

    private double B, A, E;  

    /**

     * Convenience values equal to {@link #A} / {@link #B}, 

     * {@link #A}×{@link #B}, and {@link #B} / {@link #A}.

     */

    private final double ArB, AB, BrA;

    /**

     * v values when the input latitude is a pole.

     */

    private final double v_pole_n, v_pole_s;

    /**

     * Sine and Cosine values for gamma0 (the angle between the meridian

     * and central line at the intersection between the central line and 

     * the Earth equator on aposphere).

     */

    private final double singamma0, cosgamma0;

    /**

     * Sine and Cosine values for the rotation between (U,V) and 

     * (X,Y) coordinate systems

     */

    private final double sinrot, cosrot;

    /**

     * u value (in (U,V) coordinate system) of the central point. Used in the 

     * oblique mercater case. The v value of the central point is 0.0.

     */

    private double u_c;

    /**

     * <code>true</code> if using two points on the central line to specify 

     * the azimuth.

     */

    private final boolean twoPoint;

    /**

     * <code>true</code> for hotine oblique mercator, or <code>false</code> 

     * for the oblique mercator case. 

     */

    private final boolean hotine;

    /**

     * The {@link org.geotools.referencing.operation.MathTransformProvider}

     * for an {@link IdrObliqueMercator} projection.

     *

     * @see org.geotools.referencing.operation.DefaultMathTransformFactory

     *

     * @version $Id$

     * @author Rueben Schulz

     */

    public static class Provider extends AbstractProvider {

        public static final ParameterDescriptor SCALE_FACTOR_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,      "scale_factor"),

                    new NamedIdentifier(CitationImpl.EPSG,     "Scale factor on initial line"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Scale factor at natural origin"),

                    new NamedIdentifier(CitationImpl.GEOTIFF, "ScaleAtNatOrigin"),

                    new NamedIdentifier(CitationImpl.GEOTIFF, "ScaleAtCenter")

                },

                1, 0, Double.POSITIVE_INFINITY, Unit.ONE);

        public static final ParameterDescriptor FALSE_EASTING_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,     "false_easting"),

                    new NamedIdentifier(CitationImpl.EPSG,    "False easting"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Easting at projection centre"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Easting at false origin"),

                    new NamedIdentifier(CitationImpl.GEOTIFF, "FalseEasting")

                },

                0, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, SI.METER);

        public static final ParameterDescriptor FALSE_NORTHING_LOCAL = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,     "false_northing"),

                    new NamedIdentifier(CitationImpl.EPSG,    "False northing"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Northing at projection centre"),

                    new NamedIdentifier(CitationImpl.EPSG,    "Northing at false origin"),

                    new NamedIdentifier(CitationImpl.GEOTIFF, "FalseNorthing")

                },

                0, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, SI.METER);

    	/**

         * The operation parameter descriptor for the {@link #latitudeOfCentre}

         * parameter value. Valid values range is from -90 to 90. Default value is 0.

         */

        public static final ParameterDescriptor LAT_OF_CENTRE = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,      "latitude_of_center"),

                    new NamedIdentifier(CitationImpl.EPSG,     "Latitude of projection centre"),

                    new NamedIdentifier(CitationImpl.ESRI,     "Latitude_Of_Center"),

                    new NamedIdentifier(CitationImpl.GEOTIFF,  "CenterLat")

                },

                0, -90, 90, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #longitudeOfCentre}

         * parameter value. Valid values range is from -180 to 180. Default value is 0.

         */

        public static final ParameterDescriptor LONG_OF_CENTRE = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,      "longitude_of_center"),

                    new NamedIdentifier(CitationImpl.EPSG,     "Longitude of projection centre"),

                    new NamedIdentifier(CitationImpl.ESRI,     "Longitude_Of_Center"),

                    new NamedIdentifier(CitationImpl.GEOTIFF,  "CenterLong")

                },

                0, -180, 180, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #alpha_c}

         * parameter value. Valid values range is from -360 to -270, -90 to 90, 

         * and 270 to 360 degrees. Default value is 0.

         */

        public static final ParameterDescriptor AZIMUTH = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,      "azimuth"),

                    new NamedIdentifier(CitationImpl.ESRI,     "Azimuth"),

                    new NamedIdentifier(CitationImpl.EPSG,     "Azimuth of initial line"),

                    new NamedIdentifier(CitationImpl.GEOTIFF,  "AzimuthAngle")

                },

                0, -360, 360, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #rectGridAngle}

         * parameter value. It is an optional parameter with valid values ranging

         * from -360 to 360. Default value is {@link #alpha_c}.

         */

        public static final ParameterDescriptor RECTIFIED_GRID_ANGLE = createOptionalDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,      "rectified_grid_angle"),

                    new NamedIdentifier(CitationImpl.EPSG,     "Angle from Rectified to Skew Grid"),

                    new NamedIdentifier(CitationImpl.ESRI,     "XY_Plane_Rotation"),

                    new NamedIdentifier(CitationImpl.GEOTIFF,  "RectifiedGridAngle")

                },

                -360, 360, NonSI.DEGREE_ANGLE);

        /**

         * The parameters group.

         */

        static final ParameterDescriptorGroup PARAMETERS = createDescriptorGroup(new NamedIdentifier[] {

                new NamedIdentifier(CitationImpl.OGC,      "Oblique_Mercator"),

                new NamedIdentifier(CitationImpl.EPSG,     "Oblique Mercator"),

                new NamedIdentifier(CitationImpl.EPSG,     "9815"),

                new NamedIdentifier(CitationImpl.GEOTIFF,  "CT_ObliqueMercator"),

                new NamedIdentifier(CitationImpl.ESRI,     "Hotine_Oblique_Mercator_Azimuth_Center"),

                new NamedIdentifier(CitationImpl.ESRI,     "Rectified_Skew_Orthomorphic_Center"),

                new NamedIdentifier(CitationImpl.GEOTOOLS, Resources.formatInternational(

                                                           ResourceKeys.OBLIQUE_MERCATOR_PROJECTION)),

                new NamedIdentifier(new CitationImpl("IDR"), "IDR")

            }, new ParameterDescriptor[] {

                SEMI_MAJOR,          SEMI_MINOR,

                LONG_OF_CENTRE,      LAT_OF_CENTRE,

                AZIMUTH,             RECTIFIED_GRID_ANGLE,

                SCALE_FACTOR_LOCAL,

                FALSE_EASTING_LOCAL,       FALSE_NORTHING_LOCAL

            });

        /**

         * Constructs a new provider. 

         */

        public Provider() {

            super(PARAMETERS);

        }

        /**

         * Constructs a new provider. 

         */

        protected Provider(final ParameterDescriptorGroup params) {

            super(params);

        }

        /**

         * Returns the operation type for this map projection.

         */

        protected Class getOperationType() {

            return CylindricalProjection.class;

        }

        /**

         * Creates a transform from the specified group of parameter values.

         *

         * @param  parameters The group of parameter values.

         * @return The created math transform.

         * @throws ParameterNotFoundException if a required parameter was not found.

         */

        public MathTransform createMathTransform(final ParameterValueGroup parameters)

                throws ParameterNotFoundException

        {

            final Collection descriptors = PARAMETERS.descriptors();

            return new IdrObliqueMercator(parameters, descriptors, false, false);

        }

    }

    /**

     * The {@link org.geotools.referencing.operation.MathTransformProvider}

     * for a Hotine {@link IdrObliqueMercator} projection.

     *

     * @see org.geotools.referencing.operation.DefaultMathTransformFactory

     *

     * @version $Id$

     * @author Rueben Schulz

     */

    public static final class Provider_Hotine extends Provider {

        /**

         * The parameters group.

         */

        static final ParameterDescriptorGroup PARAMETERS = createDescriptorGroup(new NamedIdentifier[] {

                new NamedIdentifier(CitationImpl.OGC,      "Hotine_Oblique_Mercator"),

                new NamedIdentifier(CitationImpl.EPSG,     "Hotine Oblique Mercator"),

                new NamedIdentifier(CitationImpl.EPSG,     "9812"),

                new NamedIdentifier(CitationImpl.GEOTIFF,  "CT_ObliqueMercator_Hotine"),

                new NamedIdentifier(CitationImpl.ESRI,     "Hotine_Oblique_Mercator_Azimuth_Natural_Origin"),

                new NamedIdentifier(CitationImpl.ESRI,     "Rectified_Skew_Orthomorphic_Natural_Origin"),

                new NamedIdentifier(CitationImpl.GEOTOOLS, Resources.formatInternational(

                                                           ResourceKeys.OBLIQUE_MERCATOR_PROJECTION)),

                new NamedIdentifier(new CitationImpl("IDR"), "IDR")

            }, new ParameterDescriptor[] {

                SEMI_MAJOR,          SEMI_MINOR,

                LONG_OF_CENTRE,      LAT_OF_CENTRE,

                AZIMUTH,             RECTIFIED_GRID_ANGLE,

                SCALE_FACTOR_LOCAL,

                FALSE_EASTING_LOCAL,       FALSE_NORTHING_LOCAL

        });

        /**

         * Constructs a new provider. 

         */

        public Provider_Hotine() {

            super(PARAMETERS);

        }

        /**

         * Returns the operation type for this map projection.

         */

        protected Class getOperationType() {

            return CylindricalProjection.class;

        }

        /**

         * Creates a transform from the specified group of parameter values.

         *

         * @param  parameters The group of parameter values.

         * @return The created math transform.

         * @throws ParameterNotFoundException if a required parameter was not found.

         */

        public MathTransform createMathTransform(final ParameterValueGroup parameters)

                throws ParameterNotFoundException

        {

            final Collection descriptors = PARAMETERS.descriptors();

            return new IdrObliqueMercator(parameters, descriptors, true, false);

        }

    }

    /**

     * The {@link org.geotools.referencing.operation.MathTransformProvider}

     * for a {@link IdrObliqueMercator} projection, specified with

     * two points on the central line (instead of a central point and azimuth).

     *

     * @see org.geotools.referencing.operation.DefaultMathTransformFactory

     *

     * @version $Id$

     * @author Rueben Schulz

     */

    public static class Provider_TwoPoint extends Provider {

    		/**

         * The operation parameter descriptor for the {@link #latitudeOfCentre}

         * parameter value. Valid values range is from -90 to 90. Default value is 0.

         */

        public static final ParameterDescriptor LAT_OF_CENTRE = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.OGC,      "latitude_of_center"),

                    new NamedIdentifier(CitationImpl.EPSG,     "Latitude of projection centre"),

                    new NamedIdentifier(CitationImpl.ESRI,     "Latitude_Of_Center"),

                    new NamedIdentifier(CitationImpl.GEOTIFF,  "CenterLat")

                },

                0, -90, 90, NonSI.DEGREE_ANGLE);

    	    /**

         * The operation parameter descriptor for the {@link #latitudeOf1stPoint}

         * parameter value. Valid values range is from -90 to 90. Default value is 0.

         */

        public static final ParameterDescriptor LAT_OF_1ST_POINT = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.ESRI, "Latitude_Of_1st_Point")

                },

                0, -90, 90, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #longitudeOf1stPoint}

         * parameter value. Valid values range is from -180 to 180. Default value is 0.

         */

        public static final ParameterDescriptor LONG_OF_1ST_POINT = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.ESRI, "Longitude_Of_1st_Point")

                },

                0, -180, 180, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #latitudeOf2ndPoint}

         * parameter value. Valid values range is from -90 to 90. Default value is 0.

         */

        public static final ParameterDescriptor LAT_OF_2ND_POINT = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.ESRI, "Latitude_Of_2nd_Point")

                },

                0, -90, 90, NonSI.DEGREE_ANGLE);

        /**

         * The operation parameter descriptor for the {@link #longitudeOf2ndPoint}

         * parameter value. Valid values range is from -180 to 180. Default value is 0.

         */

        public static final ParameterDescriptor LONG_OF_2ND_POINT = createDescriptor(

                new NamedIdentifier[] {

                    new NamedIdentifier(CitationImpl.ESRI, "Longitude_Of_2nd_Point")

                },

                0, -180, 180, NonSI.DEGREE_ANGLE);

        /**

         * The parameters group.

         */

        static final ParameterDescriptorGroup PARAMETERS = createDescriptorGroup(new NamedIdentifier[] {

                new NamedIdentifier(CitationImpl.ESRI,     "Hotine_Oblique_Mercator_Two_Point_Center"),

                new NamedIdentifier(CitationImpl.GEOTOOLS, Resources.formatInternational(

                                                           ResourceKeys.OBLIQUE_MERCATOR_PROJECTION)),

                new NamedIdentifier(new CitationImpl("IDR"), "IDR")

            }, new ParameterDescriptor[] {

                SEMI_MAJOR,          SEMI_MINOR,

                LAT_OF_1ST_POINT,    LONG_OF_1ST_POINT,

                LAT_OF_2ND_POINT,    LONG_OF_2ND_POINT,

			   LAT_OF_CENTRE,       SCALE_FACTOR_LOCAL,

                FALSE_EASTING_LOCAL,       FALSE_NORTHING_LOCAL

            });

        /**

         * Constructs a new provider. 

         */

        public Provider_TwoPoint() {

            super(PARAMETERS);

        }

        /**

         * Constructs a new provider. 

         */

        protected Provider_TwoPoint(final ParameterDescriptorGroup params) {

            super(params);

        }

        /**

         * Returns the operation type for this map projection.

         */

        protected Class getOperationType() {

            return CylindricalProjection.class;

        }

        /**

         * Creates a transform from the specified group of parameter values.

         *

         * @param  parameters The group of parameter values.

         * @return The created math transform.

         * @throws ParameterNotFoundException if a required parameter was not found.

         */

        public MathTransform createMathTransform(final ParameterValueGroup parameters)

                throws ParameterNotFoundException

        {

            final Collection descriptors = PARAMETERS.descriptors();

            return new IdrObliqueMercator(parameters, descriptors, false, true);