/ - Diff - gvSIG projections - gvSIG

                 <scope>test</scope>
             </dependency>
             <dependency>
                 <groupId>org.jscience</groupId>
                 <artifactId>jscience</artifactId>
                 <version>4.3.1</version>
                 <groupId>javax.measure</groupId>
                 <artifactId>unit-api</artifactId>
                 <version>1.0</version>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>

     /* gvSIG. Desktop Geographic Information System.
+     *
      * Copyright ? 2007-2012 gvSIG Association
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.proj;
     import java.util.List;
     import org.gvsig.proj.catalogue.CRSCatalogManager;
     import org.gvsig.proj.catalogue.CRSDefinition;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     /**
      * {@link CoordinateReferenceSystemManager} API acceptance tests.
+     *
      * @author gvSIG Team
      */
     public abstract class CRSCatalogueManagerIT extends
         AbstractLibraryAutoInitTestCase {
         protected CRSCatalogManager manager;
         protected void doSetUp() throws Exception {
             manager = createProjectionManager();
+        }
         /**
          * Creates a {@link CoordinateReferenceSystemManager} instance.
+         *
          * @return the {@link CoordinateReferenceSystemManager} instance
          */
         protected abstract CRSCatalogManager createProjectionManager();
         /**
          * Returns the authority name to use to create the projections to test.
+         *
          * @return the authority name
          */
         protected abstract String getAuthorityName();
         /**
          * Returns the code to use to create the projections to test.
+         *
          * @return the code
          */
         protected abstract String getCode();
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getAuthorityNames()}
          * .
          */
         public void testGetAuthorityNames() {
             List names = manager.getAuthorityNames();
             assertNotNull(names);
             assertTrue("Authority names list is empty", names.size() > 0);
             for (int i = 0; i < names.size(); i++) {
                 if (!(names.get(i) instanceof String)) {
                     fail("At least one authority name is not a String");
+                }
+            }
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCodes(java.lang.String)}
          * .
          */
         public void testGetCodes() {
             List names = manager.getAuthorityNames();
             for (int i = 0; i < names.size(); i++) {
                 List codes = manager.getCodes((String) names.get(i));
                 for (int j = 0; j < codes.size(); j++) {
                     if (!(codes.get(i) instanceof String)) {
                         fail("At least one code of the authority " + names.get(i)
                             + " is not a String");
+                    }
+                }
+            }
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCoordinateReferenceSystem(java.lang.String, java.lang.String)}
          */
         public void testGetDefinition() throws Exception {
         	String code = getAuthorityName() + ":" + getCode();
             CRSDefinition projection =
                 manager.getCRSDefinition(code);
             //FIXME: assertEquals(getAuthorityName(), projection.getAuthorityName());
             //FIXME: assertEquals(getCode(), projection.getCode());
+        }
+    }

+    		}
     		@Override
     		public String registerCoordinateOperation(String wktDefinition, String description) {
     			// TODO Auto-generated method stub
     			return null;
+    		}
     		@Override
     		public String registerCoordinateTransformationPVT(String sourceCRS, String targetCRS, String description,
     				float xTraslation, float yTraslation, float zTraslation, float xRotation, float yRotation,
     				float zRotation, float scaleDifference) {
-...
     			return null;
+    		}
     		@Override
     		public TransformationDefinition getTransformationDefinitionFromWKT(String wkt) {
     			// TODO Auto-generated method stub
     			return null;
+    		}
     		@Override
     		public String registerTransformation(String wktDefinition, String description) {
     			// TODO Auto-generated method stub
     			return null;
+    		}
     		@Override
     		public CRSDefinition getCompoundCRS(CRSDefinition... crsList) {
     			// TODO Auto-generated method stub
     			return null;
+    		}
+        }
+    }

     /* gvSIG. Desktop Geographic Information System.
+     *
      * Copyright ? 2007-2012 gvSIG Association
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.proj;
     import java.util.List;
     import org.gvsig.proj.catalogue.CRSCatalogManager;
     import org.gvsig.proj.catalogue.CRSDefinition;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     /**
      * {@link CoordinateReferenceSystemManager} API acceptance tests.
+     *
      * @author gvSIG Team
      */
     public abstract class CRSCatalogManagerIT extends
         AbstractLibraryAutoInitTestCase {
         protected CRSCatalogManager manager;
         protected void doSetUp() throws Exception {
             manager = createProjectionManager();
+        }
         /**
          * Creates a {@link CoordinateReferenceSystemManager} instance.
+         *
          * @return the {@link CoordinateReferenceSystemManager} instance
          */
         protected abstract CRSCatalogManager createProjectionManager();
         /**
          * Returns the authority name to use to create the projections to test.
+         *
          * @return the authority name
          */
         protected abstract String getAuthorityName();
         /**
          * Returns the code to use to create the projections to test.
+         *
          * @return the code
          */
         protected abstract String getCode();
         /**
          * Test method for
          * {@link org.gvsig.proj.catalogue.CRSCatalogManager#getAuthorityNames()}
          * .
          */
         public void testGetAuthorityNames() {
             List names = manager.getAuthorityNames();
             assertNotNull(names);
             assertTrue("Authority names list is empty", names.size() > 0);
             for (int i = 0; i < names.size(); i++) {
                 if (!(names.get(i) instanceof String)) {
                     fail("At least one authority name is not a String");
+                }
+            }
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.catalogue.CRSCatalogManager#getCodes(java.lang.String)}
          * .
          */
         public void testGetCodes() {
             List names = manager.getAuthorityNames();
             for (int i = 0; i < names.size(); i++) {
                 List codes = manager.getCodes((String) names.get(i));
                 for (int j = 0; j < codes.size(); j++) {
                     if (!(codes.get(i) instanceof String)) {
                         fail("At least one code of the authority " + names.get(i)
                             + " is not a String");
+                    }
+                }
+            }
+        }
         /**
          * Test method for
          * {@linkorg.gvsig.proj.catalogue.CRSCatalogManager#getCoordinateReferenceSystem(java.lang.String)}
          */
         public void testGetDefinition() throws Exception {
         	String code = getAuthorityName() + ":" + getCode();
             CRSDefinition crs =
                 manager.getCRSDefinition(code);
             assertNotNull(crs);
             assertEquals(code, crs.getIdentifier());
             //FIXME: assertEquals(getAuthorityName(), projection.getAuthorityName());
             //FIXME: assertEquals(getCode(), projection.getCode());
+        }
+    }

     /* gvSIG. Desktop Geographic Information System.
+     *
      * Copyright ? 2007-2012 gvSIG Association
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.proj;
     import org.gvsig.proj.catalogue.CRSDefinition;
     import org.gvsig.proj.catalogue.TransformationDefinition;
     import org.gvsig.proj.catalogue.exception.NoninvertibleTransformException;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     /**
      * {@link CoordinateTransformation} API acceptance tests.
+     *
      * @author gvSIG Team
      */
     public abstract class CoordinateTransformationIT extends
         AbstractLibraryAutoInitTestCase {
         protected CRSDefinition source;
         protected CRSDefinition target;
         protected TransformationDefinition transformation;
         protected void doSetUp() throws Exception {
             source = createSourceProjection();
             target = createTargetProjection();
             transformation = createTransformation();
+        }
         /**
          * Creates the transformation to test
+         *
          * @return
          * @throws Exception
          */
         protected abstract TransformationDefinition createTransformation()
                 throws Exception;
         /**
          * Creates the source CRSDefinition, which must match the
          * source CRS of the transformation to test
          * @return
          * @throws Exception
          */
         protected abstract CRSDefinition createSourceProjection()
                 throws Exception;
         /**
          * Returns the name of the authority which defines the
          * transformation to be tested
+         *
          * @return
          */
         protected abstract String getAuthorityName();
         /**
          * Creates the target CRSDefinition, which must match the
          * target CRS of the transformation to test
          * @return
          * @throws Exception
          */
          protected abstract CRSDefinition createTargetProjection()
                 throws Exception;
          /**
           * Test method for
           * {@link org.gvsig.proj.catalogue.TransformationDefinition#getAuthorityName()}.
           */
          public void testGetAuthorityName() {
              assertEquals(getAuthorityName(), transformation.getAuthorityName());
+         }
          /**
           * Test method for
           * {@link org.gvsig.proj.catalogue.TransformationDefinition#getIdentifier()}.
           */
     //     public void testGetIdentifier() {
     //         assertEquals(getProjectedCode(), projCrsDef.getIdentifier());
     //     }
         /**
          * Test method for
          * {@link org.gvsig.proj.catalogue.TransformationDefinition#getSourceCRS()}.
          */
         public void testGetSourceProjection() {
             assertEquals(source, transformation.getSourceCRS());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.catalogue.TransformationDefinition#getTargetCRS()}.
          */
         public void testGetTargetProjection() {
             assertEquals(target, transformation.getTargetCRS());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.catalogue.TransformationDefinition#getInverse()}.
          * @throws NoninvertibleTransformException
          */
         public void testGetReverse() throws NoninvertibleTransformException {
         	TransformationDefinition inverseTransformation =
                 transformation.getInverse();
             assertEquals(target, inverseTransformation.getSourceCRS());
             assertEquals(source, inverseTransformation.getTargetCRS());
+        }
+    }

     /* gvSIG. Desktop Geographic Information System.
+     *
      * Copyright ? 2007-2012 gvSIG Association
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.proj;
     import org.gvsig.proj.catalogue.CRSCatalogLocator;
     import org.gvsig.proj.catalogue.CRSDefinition;
     import org.gvsig.proj.catalogue.exception.CoordinateReferenceSystemNotFoundException;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     /**
      * {@link CoordinateReferenceSystem} API acceptance tests.
+     *
      * @author gvSIG Team
      */
     public abstract class CRSDefinitionIT extends
         AbstractLibraryAutoInitTestCase {
         protected CRSDefinition projCrsDef;
         protected CRSDefinition geog2dCrsDef;
         protected void doSetUp() throws Exception {
         	projCrsDef = createProjection(getProjectedCode());
         	geog2dCrsDef = createProjection(getGeographic2DCode());
+        }
         /**
          * Creates a new {@link CoordinateReferenceSystem}.
+         *
          * @param authorityName
          * @param code
          * @return the created projection
          * @throws CoordinateReferenceSystemNotFoundException
          */
         protected CRSDefinition createProjection(
             String code) throws CoordinateReferenceSystemNotFoundException,
             Exception {
             return CRSCatalogLocator.getManager().getCRSDefinition(code);
+        }
         /**
          * Returns the code to use to create the projection to test, which
          * should be a projected CRS
+         *
          * @return the code
          */
         protected abstract String getProjectedCode();
         /**
          * Returns the code to use to create the projection to test, which
          * should be a geographic 2D CRS
+         *
          * @return the code
          */
         protected abstract String getGeographic2DCode();
         /**
          * Returns the name of the authority which defines the CRS to be
          * tested
+         *
          * @return
          */
         protected abstract String getAuthorityName();
         /**
          * Test method for
          * {@link org.gvsig.proj.catalogue.CRSDefinition#getAuthorityName()}.
          */
         public void testGetAuthorityName() {
             assertEquals(getAuthorityName(), projCrsDef.getAuthorityName());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.catalogue.CRSDefinition#getIdentifier()}.
          */
         public void testGetIdentifier() {
             assertEquals(getProjectedCode(), projCrsDef.getIdentifier());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystem#isProjected()}.
          */
         public void testIsProjected() {
             assertTrue(projCrsDef.isProjected());
             assertFalse(projCrsDef.isProjected());
+        }
+    }

          * @return the list of object identifiers, or an empty collection if there is none.
          */
         Set<String> getIdentifiers();
         /**
          * Gets the authority which defines this coordinate operation
          * (e.g. "EPSG", "ESRI", "USER"...).
+         *
          * If this transformation is defined by several
          * authorities, it returns the authority which was used to instantiate
          * the object, or the authority that more closely matches the information
          * used to instantiate the object (e.g. if derived from an WKT definition)
+         *
          * @return The authority name
          */
         String getAuthorityName();
         /**
          * Version of the coordinate transformation (i.e., instantiation due to the stochastic

     import java.util.List;
     import java.util.Set;
     import javax.measure.Unit;
     import javax.measure.quantity.Length;
     import org.gvsig.proj.catalogue.datum.Datum;
     import org.gvsig.proj.catalogue.ref.Extent;
-...
          * Gets a code that references an unambiguous definition of the coordinate reference
          * system for some authority. Examples: "EPSG:4326", "EPSG:25830".
+         *
          * Note that identifiers in the "USER:" namespace are an special case, as their
          * definition will be different for each user, so they don't reference an
          * unambiguous definition.
+         *
          * @return the identifier which was used to instantiate the object, or the
          * identifier that more closely matches the information used to instantiate
          * the object (e.g. if derived from an WKT definition)
-...
          * @return the list of object identifiers, or an empty collection if there is none.
          */
         Set<String> getIdentifiers();
         /**
          * Gets the authority which defines this coordinate references system
          * (e.g. "EPSG", "ESRI", "USER"...).
+         *
          * If the CRS is defined by several
          * authorities, it returns the authority which was used to instantiate
          * the object, or the authority that more closely matches the information
          * used to instantiate the object (e.g. if derived from an WKT definition)
+         *
          * @return The authority name
          */
         String getAuthorityName();
         /**
          * FIXME: GeoAPI
-...
          * The provided points are considered to be 2D points
          * (additional dimensions are ignored).
+         *
          * @return The distance between point1 and point2 in the same units as the
          * ellipsoid axis (for geodetic CRSs) or in the same units as defined by the
          * first axis dimension (for non-geodetic CRSs).
          * @param point1
          * @param point2
          * @param the unit in which the distance should be measure
+         *
          * @return The distance between point1 and point2 measured in the units
          * provided by the unit parameter.
          */
         double getDistance(double[] point1, double[] point2);
         double getDistance(double[] point1, double[] point2, Unit<Length> unit);
         /**
          * Calculates the distance between 2 points on the surface of the Earth.
-...
          * The provided points are considered to be 2D points
          * (additional dimensions are ignored).
+         *
          * @return The distance between point1 and point2 in the same units as the
          * ellipsoid axis (for geodetic CRSs) or in the same units as defined by the
          * first axis dimension (for non-geodetic CRSs).
          * @param point1
          * @param point2
          * @param the unit in which the distance should be measure
+         *
          * @return The distance between point1 and point2 measured in the units
          * provided by the unit parameter.
          */
         double getDistance(double[] point1, double[] point2, boolean useBaseCRS);
         double getDistance(double[] point1, double[] point2, boolean useBaseCRS, Unit<Length> unit);
+    }

      */
     package org.gvsig.proj.catalogue;
     import javax.measure.unit.Unit;
     import javax.measure.Unit;
     /**
      * Definition of a coordinate system axis

     package org.gvsig.proj.catalogue;
     /**
      * Defines the type of CRS
      * Defines the type of CRS.
+     *
      * @author Cesar Martinez Izquierdo
      */

     package org.gvsig.proj.catalogue.datum;
     import javax.measure.Unit;
     import javax.measure.quantity.Length;
     import javax.measure.unit.Unit;
     /**

      */
     package org.gvsig.proj.catalogue.datum;
     import javax.measure.Unit;
     import javax.measure.quantity.Angle;
     import javax.measure.unit.Unit;
     /**
      * A prime meridian defines the origin from which longitude values are determined.

     	 */
     	CRSDefinition getCRSDefinitionFromWKT(String wkt); // anyadir formato
     	/**
     	 * Creates a compound CRS by combining the provided individual
     	 * CRSDefinitions.
+    	 *
     	 * @param crsList The list of CRSDefinitions to compound
     	 * @return The definition of the compound CRS
+    	 *
     	 * @see CRSType#CompoundCRSType
     	 * @see CRSDefinition#getComponents()
     	 * @see CRSDefinition#getType()
     	 */
     	CRSDefinition getCompoundCRS(CRSDefinition... crsList);
     	/**
     	 * Gets the TransformationDefinition for the provided code
     	 * @param code The operation code (e.g. "EPSG:1633", "EPSG:1632")
+    	 *

     import java.util.List;
     import org.gvsig.proj.catalogue.CRSDefinition;
     import org.gvsig.proj.catalogue.TransformationDefinition;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     /**
-...
         protected abstract CoordinateReferenceSystemManager createProjectionManager();
         /**
          * Returns the authority name to use to create the projections to test.
          * Returns the WKT string to create the CRSs to test.
+         *
          * @return the authority name
          */
         protected abstract String getAuthorityName();
         protected abstract String getCoordinateReferenceSystemWKT();
         /**
          * Returns the code to use to create the projections to test.
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCoordinateReferenceSystem(java.lang.String)}
          */
         public void testGetCoordinateReferenceSystemFromWKT() throws Exception {
             CoordinateReferenceSystem crs =
                 manager.getCoordinateReferenceSystem(getCoordinateReferenceSystemWKT());
             assertNotNull(crs);
+        }
         /**
          * Returns the WKT string to create the CoordinateTransformation to test.
+         *
          * @return the code
          * @return the authority name
          */
         protected abstract String getCode();
         protected abstract String getCoordinateTransformationWKT();
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getAuthorityNames()}
          * .
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCoordinateTransformation(java.lang.String)}
          */
         public void testGetAuthorityNames() {
             List names = manager.getAuthorityNames();
             assertNotNull(names);
             assertTrue("Authority names list is empty", names.size() > 0);
             for (int i = 0; i < names.size(); i++) {
                 if (!(names.get(i) instanceof String)) {
                     fail("At least one authority name is not a String");
+                }
+            }
         public void testGetTransformationFromWKT() throws Exception {
             CoordinateTransformation ct =
                 manager.getCoordinateTransformation(getCoordinateTransformationWKT());
             assertNotNull(ct);
+        }
         /**
          * Returns the CRS definition to create the CRSs to test.
+         *
          * @return the authority name
          */
         protected abstract CRSDefinition getCoordinateReferenceSystemDefinition();
         /**
          * Returns the transformation definition to create the CoordinateTransformation
          * to test.
+         *
          * @return the authority name
          */
         protected abstract TransformationDefinition getTransformationDefinition();
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCodes(java.lang.String)}
          * .
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCoordinateReferenceSystem(CRSDefinition)}
          */
         public void testGetCodes() {
             List names = manager.getAuthorityNames();
             for (int i = 0; i < names.size(); i++) {
                 List codes = manager.getCodes((String) names.get(i));
                 for (int j = 0; j < codes.size(); j++) {
                     if (!(codes.get(i) instanceof String)) {
                         fail("At least one code of the authority " + names.get(i)
                             + " is not a String");
+                    }
+                }
+            }
         public void testGetProjectionFromDefinition() throws Exception {
         	CRSDefinition definition = getCoordinateReferenceSystemDefinition();
             CoordinateReferenceSystem crs =
                 manager.getCoordinateReferenceSystem(definition);
             assertNotNull(crs);
             assertEquals(definition, crs.getDefinition());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCoordinateReferenceSystem(java.lang.String, java.lang.String)}
          * {@link org.gvsig.proj.CoordinateReferenceSystemManager#getCoordinateTransformation(TransformationDefinition)}
          */
         public void testGetProjection() throws Exception {
             CoordinateReferenceSystem projection =
                 manager.getCoordinateReferenceSystem(getAuthorityName(), getCode());
             assertEquals(getAuthorityName(), projection.getAuthorityName());
             assertEquals(getCode(), projection.getCode());
         public void testGetTransformationFromDefinition() throws Exception {
         	TransformationDefinition definition = getTransformationDefinition();
             CoordinateTransformation ct =
                 manager.getCoordinateTransformation(definition);
             assertNotNull(ct);
             assertEquals(definition, ct.getDefinition());
+        }
+    }

         protected CoordinateReferenceSystem projection;
         protected void doSetUp() throws Exception {
             projection = createProjection(getAuthorityName(), getCode());
             projection = createProjection(getWKT());
+        }
         /**
          * Creates a new {@link CoordinateReferenceSystem}.
+         *
          * @param authorityName
          * @param code
          * @return the created projection
          * @throws CoordinateReferenceSystemNotFoundException
          */
         protected CoordinateReferenceSystem createProjection(String authorityName,
             String code) throws CoordinateReferenceSystemNotFoundException,
         protected CoordinateReferenceSystem createProjection(
             String wkt) throws CoordinateReferenceSystemNotFoundException,
             Exception {
             return CoordinateReferenceSystemLocator.getManager().getCoordinateReferenceSystem(
                 getAuthorityName(), getCode());
             		wkt);
+        }
         /**
          * Returns the authority name to use to create the projections to test.
          * Returns the code to use to create the projection to test.
+         *
          * @return the authority name
          */
         protected abstract String getAuthorityName();
         /**
          * Returns the code to use to create the projections to test.
+         *
          * @return the code
          */
         protected abstract String getCode();
         protected abstract String getWKT();
         /**
          * Returns as second code to use to create the projections to test
          * transformation creation.
+         *
          * @return the code
          */
         protected abstract String getCode2();
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystem#getAuthorityName()}.
          * {@link org.gvsig.proj.CoordinateReferenceSystem#getProjectedCode()}.
          * @throws Exception
          * @throws UnsupportedOperationException
          * @throws CoordinateReferenceSystemNotFoundException
          */
         public void testGetAuthorityName() {
             assertEquals(getAuthorityName(), projection.getAuthorityName());
         public void testCRSDeserialization() throws CoordinateReferenceSystemNotFoundException, UnsupportedOperationException, Exception {
             assertEquals(projection, createProjection(projection.getDefinition().toWKT()));
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystem#getCode()}.
          */
         public void testGetCode() {
             assertEquals(getCode(), projection.getCode());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystem#getReference()}.
          */
         public void testGetReference() {
             assertEquals(getAuthorityName() + ":" + getCode(),
                 projection.getReference());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystem#getDefinition()}.
          */
         public void testGetDefinition() {
             assertNotNull(projection.getDefinition());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystem#getTransformation(org.gvsig.proj.CoordinateReferenceSystem)}
          * .
          */
         public void testGetTransformation() throws Exception {
             CoordinateReferenceSystem targetProjection =
                 createProjection(getAuthorityName(), getCode2());
             CoordinateTransformation transformation =
                 projection.getTransformation(targetProjection);
             if (transformation == null) {
                 fail("Transformation from source projection " + projection + " to "
                     + targetProjection + " is null");
+            }
             assertEquals(projection, transformation.getSourceProjection());
             assertEquals(targetProjection, transformation.getTargetProjection());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateReferenceSystem#isProjected()}.
          */
         public void testIsProjected() {
             assertTrue(projection.isProjected());
+        }
+    }

      */
     package org.gvsig.proj;
     import java.util.Arrays;
     import org.gvsig.proj.catalogue.CRSDefinition;
     import org.gvsig.proj.catalogue.TransformationDefinition;
     import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;
     /**
-...
         protected CoordinateReferenceSystem source;
         protected CoordinateReferenceSystem target;
         protected CoordinateTransformation transformation;
         protected CoordinateReferenceSystemManager manager;
         protected void doSetUp() throws Exception {
             manager = createProjectionManager();
             source = createSourceProjection();
             target = createTargetProjection();
             transformation = source.getTransformation(target);
             transformation = createTransformationFromDefinition();
+        }
         /**
          * Creates a {@link CoordinateReferenceSystemManager} instance.
+         *
          * @return the {@link CoordinateReferenceSystemManager} instance
          */
         protected abstract CoordinateReferenceSystemManager createProjectionManager();
         /**
          * Returns the transformation definition to create the CoordinateTransformation
          * to test.
+         *
          * @return the authority name
          */
         protected abstract TransformationDefinition getTransformationDefinition();
         /**
          * Creates the transformation to be tested
          */
         public CoordinateTransformation createTransformationFromDefinition() throws Exception {
         	TransformationDefinition definition = getTransformationDefinition();
             return manager.getCoordinateTransformation(definition);
+        }
         protected abstract CoordinateReferenceSystem createSourceProjection()
             throws Exception;
-...
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateTransformation#getSourceProjection()}.
          * {@link org.gvsig.proj.CoordinateTransformation#getSource()}.
          */
         public void testGetSourceProjection() {
             assertEquals(source, transformation.getSourceProjection());
             assertEquals(source, transformation.getSource());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateTransformation#getTargetProjection()}.
          * {@link org.gvsig.proj.CoordinateTransformation#getTarget()}.
          */
         public void testGetTargetProjection() {
             assertEquals(target, transformation.getTargetProjection());
             assertEquals(target, transformation.getTarget());
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateTransformation#getReverse()}.
          * {@link org.gvsig.proj.CoordinateTransformation#getInverse()}.
          */
         public void testGetReverse() {
             CoordinateTransformation reverseTransformation =
                 transformation.getReverse();
             assertEquals(target, reverseTransformation.getSourceProjection());
             assertEquals(source, reverseTransformation.getTargetProjection());
                 transformation.getInverse();
             assertEquals(target, reverseTransformation.getSource());
             assertEquals(source, reverseTransformation.getTarget());
+        }
         /**
          * The input point to test the transformation
+         *
          * @return
          */
         public abstract double[] getInputPoint();
         /**
          * The output point to thest the transformation. This point
          * should be a known result of applying the transformation on
          * getInputPoint()
          * @return
          */
         public abstract double[] getResultPoint();
         /**
          * Gets the maximum numeric tolerance to accept the result of
          * the transformation as valid
+         *
          * @return
          */
         public abstract double getResultTolerance();
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateTransformation#apply(double[])}.
          */
         public void testApplyTransformationInline() {
         	double[] input = getInputPoint();
         	transformation.apply(input);
         	assertTrue(pointsEquals(getResultPoint(), input, getResultTolerance()));
+        }
         public boolean pointsEquals(double[] point1, double[] point2, double tolerance) {
         	for (int i=0; i<point1.length; i++) {
         		if (Math.abs(point1[i]-point2[i])>tolerance) {
         			return false;
+        		}
+        	}
         	return true;
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateTransformation#apply(double[])}.
          */
         public void testApplyTransformation() {
         	double[] input = getInputPoint();
         	double[] transformed = new double[input.length];
         	transformation.apply(input, transformed);
         	assertTrue(pointsEquals(getResultPoint(), transformed, getResultTolerance()));
+        }
         /**
          * Test method for
          * {@link org.gvsig.proj.CoordinateTransformation#getInverse()}
          * and
          * {@link org.gvsig.proj.CoordinateTransformation#apply(double[])}.
          */
         public void testApplyInverseTransformation() {
         	double[] input = getInputPoint();
         	double[] transformed = new double[input.length];
         	transformation.apply(input, transformed);
         	CoordinateTransformation reverseTransformation =
                     transformation.getInverse();
         	reverseTransformation.apply(transformed);
         	assertTrue(pointsEquals(input, transformed, getResultTolerance()));
+        }
+    }

     import junit.framework.TestCase;
     import org.gvsig.proj.catalogue.CRSDefinition;
     import org.gvsig.proj.catalogue.TransformationDefinition;
     import org.gvsig.tools.dynobject.DynObject;
     /**
-...
         public static class DummyProjectionManager implements
             CoordinateReferenceSystemManager {
             public List getAuthorityNames() {
                 // Nothing to do
                 return null;
+            }
     		@Override
     		public CoordinateReferenceSystem getCoordinateReferenceSystem(String wkt)
     				throws CoordinateReferenceSystemNotFoundException {
     			// TODO Auto-generated method stub
     			return null;
+    		}
             public List getCodes(String authorityName) {
                 // Nothing to do
                 return null;
+            }
     		@Override
     		public CoordinateReferenceSystem getCoordinateReferenceSystem(CRSDefinition definition)
     				throws CoordinateReferenceSystemNotFoundException {
     			// TODO Auto-generated method stub
     			return null;
+    		}
             public CoordinateReferenceSystem getCoordinateReferenceSystem(String authorityName,
                 String code) {
                 // Nothing to do
                 return null;
+            }
     		@Override
     		public CoordinateTransformation getCoordinateTransformation(String wkt)
     				throws CoordinateOperationNotFoundException {
     			// TODO Auto-generated method stub
     			return null;
+    		}
             public DynObject createParameters() {
                 // Nothing to do
                 return null;
+            }
     		@Override
     		public CoordinateTransformation getCoordinateTransformation(TransformationDefinition definition)
     				throws CoordinateOperationNotFoundException {
     			// TODO Auto-generated method stub
     			return null;
+    		}
             public void initialize(DynObject parameters) {
                 // Nothing to do
+            }
+        }
+    }

     /* gvSIG. Desktop Geographic Information System.
+     *
      * Copyright ? 2007-2018 gvSIG Association
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.proj;
     import org.gvsig.proj.catalogue.TransformationDefinition;
     /**
      * Representation of a conversion or transformation between map
      * {@link CoordinateReferenceSystem}s.
+     *
      * @see http://en.wikipedia.org/wiki/Map_projection
      * @see http://en.wikipedia.org/wiki/Coordinate_reference_system
      * @author gvSIG Team
      */
     public interface CoordinateOperation {
         /**
          * Returns the {@link CoordinateReferenceSystem} of the coordinates to be
          * converted from.
+         *
          * @return the coordinates original {@link CoordinateReferenceSystem}
          */
         CoordinateReferenceSystem getSource();
         /**
          * Returns the {@link CoordinateReferenceSystem} of the coordinates to be
          * converted to.
+         *
          * @return the coordinates target {@link CoordinateReferenceSystem}
          */
         CoordinateReferenceSystem getTarget();
         /**
          * Converts coordinates from their source projection to the target one.
+         *
          * @param point
          *            values of the coordinates to convert.
          *            The converted values will be written over the same array given
          *            as parameter
          */
         void apply(double[] point);
         /**
          * Converts coordinates from their source projection to the target one.
+         *
          * @param srcPoint
          *            values of the coordinates to convert.
          * @param srcPoint
          *            a target array to hold the converted coordinates
          */
         void apply(double[] srcPoint, double[] dstPoint);
         /**
          * Returns a {@link CoordinateTransformation} object which is able to
          * convert coordinates, but performing the opposite conversion, using this
          * transformation source projection as the target one, and using the
          * target projection as the source one.
+         *
          * @return a {@link CoordinateTransformation} for the opposite conversion
          */
         CoordinateOperation getInverse();
         /**
          * Gets the definition of the coordinate operation. The CoordinateOperationDefinition
          * fully defines the operation
+         *
          * @return
          */
         TransformationDefinition getDefinition();
+    }

     /* gvSIG. Desktop Geographic Information System.
+     *
      * Copyright ? 2007-2012 gvSIG Association
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.proj;
     /**
      * A geodetic datum (plural datums, not data) is a reference from which
      * measurements are made. In surveying and geodesy, a datum is a set of
      * reference points on the Earth's surface against which position measurements
      * are made and (often) an associated model of the shape of the Earth (reference
      * ellipsoid) to define a geographic coordinate system.
+     *
      * @see http://en.wikipedia.org/wiki/Datum_%28geodesy%29
      * @see http://en.wikipedia.org/wiki/Geodetic_system
+     *
      * @author <a href="http://www.disid.com">DiSiD Technologies S.L.</a>
      * @version $Rev$
      * @since 0.1.0
      */
     public interface Datum {
         /**
          * Returns the Datum short name, like the one used in ProJ4 definitions.
+         *
          * @return the short name.
          */
         public String getShortName();
         /**
          * Returns the Datum name.
+         *
          * @return the Datum name
          */
         public String getName();
         /**
          * Returns the {@link Ellipsoid} used in this Datum.
+         *
          * @return the related {@link Ellipsoid}
          */
         public Ellipsoid getEllipsoid();
+    }

     /* gvSIG. Desktop Geographic Information System.
+     *
      * Copyright ? 2007-2012 gvSIG Association
+     *
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.proj;
     /**
      * In geodesy, a reference ellipsoid is a mathematically-defined surface that
      * approximates the geoid, the truer figure of the Earth, or other planetary
      * body. Because of their relative simplicity, reference ellipsoids are used as
      * a preferred surface on which geodetic network computations are performed and
      * point coordinates such as latitude, longitude, and elevation are defined.
+     *
      * @see http://en.wikipedia.org/wiki/Reference_ellipsoid
+     *
      * @author <a href="http://www.disid.com">DiSiD Technologies S.L.</a>
      * @version $Rev$
      * @since 0.1.0
      */
     public interface Ellipsoid {
         /**
          * Returns the Ellipsoid short name, like the one used in ProJ4 definitions.
+         *
          * @return the Ellipsoid short name.
          */
         public String getShortName();
         /**
          * Return the name of the Ellipsoid.
+         *
          * @return the name of the Ellipsoid
          */
         public String getName();
         /**
          * Returns the the equatorial radius or semi-major axis value.
+         *
          * @return the equatorial radius or semi-major axis.
          */
         public double getSemiMajorAxis();
         /**
          * Returns the polar radius or semi-minor axis value.
+         *
          * @return the polar radius or semi-minor axis.
          */
         public double getSemiMinorAxis();
         /**
          * Returns the reciprocal flattening.
+         *
          * @return the reciprocal flattening.
          */
         public double getReciprocalFlattening();
+    }

     	/**
     	 * Returns a Coordinate Reference System.
+    	 *
     	 * @param authorityName
     	 *            name of the Authority who defines de Coordinate Reference
     	 *            System
     	 * @param code
     	 *            the code used by the Authority to identify the Coordinate
     	 *            Reference System
     	 * @return the projection
     	 * @param definition
     	 * @throws CoordinateReferenceSystemNotFoundException
     	 *             if there is not any Coordinate Reference System available in
     	 *             the library with the given reference
     	 */
     	CoordinateReferenceSystem getCoordinateReferenceSystem(
     			String authorityName, String code)
     					throws CoordinateReferenceSystemNotFoundException;
     	/**
     	 * Returns a Coordinate Reference System.
+    	 *
     	 * @param definition
     	 */
     	CoordinateReferenceSystem getCoordinateReferenceSystem(
     		CRSDefinition definition)
     			throws CoordinateReferenceSystemNotFoundException;
     	/**
     	 * Returns a Coordinate Operation
     	 * @param authorityName
     	 * @param code
     	 * Returns a Coordinate Transformation
     	 * @param wkt Well Known Text representation of the transformation
     	 * @return
     	 * @throws CoordinateReferenceSystemNotFoundException
     	 */
     	CoordinateOperation getCoordinateOperation(
     			String authorityName, String code)
     	CoordinateTransformation getCoordinateTransformation(
     			String wkt)
     					throws CoordinateOperationNotFoundException;
     	/**
     	 * Returns a Coordinate Operation
     	 * Returns a Coordinate Transformation
+    	 *
     	 * @param definition
     	 */

Application: gvSIG desktop » gvSIG projections

Revision 805