This is a method declared in the {@link IdentifiedObject} interface.
+ * It is implemented in this base class for the convenience of subclasses
+ * that indirectly implement {@code IdentifiedObject}.
+ */
+ public Set getIdentifiers() {
+ return Collections.emptySet();
+ }
+
+ /**
+ * {@return the scope of usage of this object}.
+ * If unknown, ISO 19111 requires that we return "not known".
+ *
+ * This method is not declared directly in the {@link IdentifiedObject} interface,
+ * but appears in datum and coordinate operation sub-interfaces.
+ */
+ public InternationalString getScope() {
+ return LocalizedString.UNKNOWN;
+ }
+
+ /**
+ * {@return the domain of validity of this object}.
+ * The default implementation assumes that there is none.
+ *
+ * This method is not declared directly in the {@link IdentifiedObject} interface,
+ * but appears in datum and coordinate operation sub-interfaces.
+ */
+ public Extent getDomainOfValidity() {
+ return null;
+ }
+
+ /**
+ * {@return optional remarks about this object}.
+ * The default implementation assumes that there is none.
+ *
+ * This is a method declared in the {@link IdentifiedObject} interface.
+ * It is implemented in this base class for the convenience of subclasses
+ * that indirectly implement {@code IdentifiedObject}.
+ */
+ public InternationalString getRemarks() {
+ return null;
+ }
+
+ /**
+ * {@return a WKT representation of this object}.
+ * The default implementation assumes that there is none.
+ *
+ * This is a method declared in the {@link IdentifiedObject} interface.
+ * It is implemented in this base class for the convenience of subclasses
+ * that indirectly implement {@code IdentifiedObject}.
+ */
+ public String toWKT() throws UnsupportedOperationException {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ /**
+ * {@return the string representation of the wrapped PROJ4J object}.
+ */
+ @Override
+ public String toString() {
+ return implementation().toString();
+ }
+
+ /**
+ * {@return a hash code value for this wrapper}.
+ */
+ @Override
+ public final int hashCode() {
+ return implementation().hashCode() ^ getClass().hashCode();
+ }
+
+ /**
+ * Compares this wrapper with the given object for equality. This method returns {@code true}
+ * if the two objects are wrappers of the same class wrapping equal PROJ4 implementations.
+ */
+ @Override
+ public final boolean equals(final Object other) {
+ if (other != null && other.getClass() == getClass()) {
+ return implementation().equals(((Wrapper) other).implementation());
+ }
+ return false;
+ }
+}
diff --git a/geoapi/src/main/java/org/locationtech/proj4j/geoapi/Wrappers.java b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/Wrappers.java
new file mode 100644
index 0000000..22b0b94
--- /dev/null
+++ b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/Wrappers.java
@@ -0,0 +1,315 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.locationtech.proj4j.geoapi;
+
+import org.locationtech.proj4j.CRSFactory;
+import org.locationtech.proj4j.CoordinateTransform;
+import org.locationtech.proj4j.CoordinateTransformFactory;
+import org.locationtech.proj4j.ProjCoordinate;
+import org.locationtech.proj4j.datum.AxisOrder;
+import org.locationtech.proj4j.proj.Projection;
+import org.opengis.geometry.DirectPosition;
+import org.opengis.parameter.ParameterValueGroup;
+import org.opengis.referencing.crs.CRSAuthorityFactory;
+import org.opengis.referencing.crs.GeographicCRS;
+import org.opengis.referencing.crs.ProjectedCRS;
+import org.opengis.referencing.crs.SingleCRS;
+import org.opengis.referencing.cs.CoordinateSystem;
+import org.opengis.referencing.datum.Ellipsoid;
+import org.opengis.referencing.datum.GeodeticDatum;
+import org.opengis.referencing.datum.PrimeMeridian;
+import org.opengis.referencing.operation.CoordinateOperation;
+import org.opengis.referencing.operation.CoordinateOperationFactory;
+
+
+/**
+ * Views of PROJ4J implementation classes as GeoAPI objects.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+public final class Wrappers {
+ /**
+ * Do not allow instantiation of this class.
+ */
+ private Wrappers() {
+ }
+
+ /**
+ * Wraps the given PROJ4J CRS factory behind the equivalent GeoAPI interface.
+ * The returned factory support only the creation of geographic and projected CRSs.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static CRSAuthorityFactory geoapi(final CRSFactory impl) {
+ return AuthorityFactoryWrapper.wrap(impl);
+ }
+
+ /**
+ * Returns the given authority factory as a PROJ4J implementation.
+ * This method returns the backing implementation.
+ *
+ * This is a convenience method for {@link Importer#convert(CRSAuthorityFactory)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap or convert, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static CRSFactory proj4j(final CRSAuthorityFactory src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J CRS behind the equivalent GeoAPI interface.
+ * The returned object is a view: if any {@code impl} value is changed after this method call,
+ * those changes will be reflected immediately in the returned view. Note that CRS objects
+ * should be immutable. Therefore, it is recommended to not apply any change on {@code impl}.
+ *
+ * There is one exception to above paragraph: this method determines immediately whether the given
+ * CRS is a {@link GeographicCRS} or {@link ProjectedCRS}. That type of the view cannot
+ * be changed after construction.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @param is3D whether to return a three-dimensional CRS instead of a two-dimensional one
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static SingleCRS geoapi(final org.locationtech.proj4j.CoordinateReferenceSystem impl, boolean is3D) {
+ return AbstractCRS.wrap(impl, is3D);
+ }
+
+ /**
+ * Returns the given CRS as a PROJ4J implementation.
+ * This method tries to return the backing implementation if possible,
+ * or otherwise copies the properties in a new PROJ4J instance.
+ *
+ * This is a convenience method for {@link Importer#convert(SingleCRS)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap or convert, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static org.locationtech.proj4j.CoordinateReferenceSystem proj4j(final SingleCRS src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J datum behind the equivalent GeoAPI interface.
+ * The returned object is a view: if any {@code impl} value is changed after this method call,
+ * those changes will be reflected immediately in the returned view. Note that CRS objects
+ * should be immutable. Therefore, it is recommended to not apply any change on {@code impl}.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static GeodeticDatum geoapi(final org.locationtech.proj4j.datum.Datum impl) {
+ return DatumWrapper.wrap(impl);
+ }
+
+ /**
+ * Returns the given datum as a PROJ4J implementation.
+ * This method tries to return the backing implementation if possible,
+ * or otherwise copies the properties in a new PROJ4J instance.
+ *
+ * This is a convenience method for {@link Importer#convert(GeodeticDatum)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap or convert, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static org.locationtech.proj4j.datum.Datum proj4j(final GeodeticDatum src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J ellipsoid behind the equivalent GeoAPI interface.
+ * The returned object is a view: if any {@code impl} value is changed after this method call,
+ * those changes will be reflected immediately in the returned view. Note that CRS objects
+ * should be immutable. Therefore, it is recommended to not apply any change on {@code impl}.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static Ellipsoid geoapi(final org.locationtech.proj4j.datum.Ellipsoid impl) {
+ return EllipsoidWrapper.wrap(impl);
+ }
+
+ /**
+ * Returns the given ellipsoid as a PROJ4J implementation.
+ * This method tries to return the backing implementation if possible,
+ * or otherwise copies the properties in a new PROJ4J instance.
+ *
+ * This is a convenience method for {@link Importer#convert(Ellipsoid)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap or convert, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static org.locationtech.proj4j.datum.Ellipsoid proj4j(final Ellipsoid src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J ellipsoid behind the equivalent GeoAPI interface.
+ * The returned object is a view: if any {@code impl} value is changed after this method call,
+ * those changes will be reflected immediately in the returned view. Note that CRS objects
+ * should be immutable. Therefore, it is recommended to not apply any change on {@code impl}.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static PrimeMeridian geoapi(final org.locationtech.proj4j.datum.PrimeMeridian impl) {
+ return PrimeMeridianWrapper.wrap(impl);
+ }
+
+ /**
+ * Returns the given prime meridian as a PROJ4J implementation.
+ * This method tries to return the backing implementation if possible,
+ * or an equivalent PROJ4J instance otherwise.
+ *
+ * This is a convenience method for {@link Importer#convert(PrimeMeridian)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static org.locationtech.proj4j.datum.PrimeMeridian proj4j(final PrimeMeridian src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J projection behind the equivalent GeoAPI interface.
+ * The returned object is a view: if any {@code impl} value is changed after this method call,
+ * those changes will be reflected immediately in the returned view. The view is bidirectional:
+ * setting a value in the returned parameters modify a property of the given projection.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static ParameterValueGroup geoapi(final Projection impl) {
+ return OperationMethodWrapper.wrap(impl);
+ }
+
+ /**
+ * Returns the given parameters as a PROJ4J implementation.
+ * This method tries to return the backing implementation if possible,
+ * or an equivalent PROJ4J instance otherwise.
+ *
+ * This is a convenience method for {@link Importer#convert(ParameterValueGroup)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static Projection proj4j(final ParameterValueGroup src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J coordinate operation factory behind the equivalent GeoAPI interface.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static CoordinateOperationFactory geoapi(final CoordinateTransformFactory impl) {
+ return OperationFactoryWrapper.wrap(impl);
+ }
+
+ /**
+ * Returns the given coordinate operation factory as a PROJ4J implementation.
+ * This method returns the backing implementation.
+ *
+ * This is a convenience method for {@link Importer#convert(CoordinateOperationFactory)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap or convert, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static CoordinateTransformFactory proj4j(final CoordinateOperationFactory src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J coordinate transform behind the equivalent GeoAPI interface.
+ * The returned object is a view: if any {@code impl} value is changed after this method call,
+ * those changes will be reflected immediately in the returned view. Note that referencing objects
+ * should be immutable. Therefore, it is recommended to not apply any change on {@code impl}.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @param is3D whether to return a three-dimensional operation instead of a two-dimensional one
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static CoordinateOperation geoapi(final CoordinateTransform impl, final boolean is3D) {
+ return TransformWrapper.wrap(impl, is3D);
+ }
+
+ /**
+ * Returns the given coordinate operation as a PROJ4J implementation.
+ * This method returns the backing implementation.
+ *
+ * This is a convenience method for {@link Importer#convert(CoordinateOperation)}
+ * on a default instance of {@code Importer}.
+ *
+ * @param src the object to unwrap or convert, or {@code null}
+ * @return the PROJ4J implementation, or {@code null} if the given object was null
+ * @throws UnconvertibleInstanceException if the given object cannot be unwrapped or converted
+ */
+ public static CoordinateTransform proj4j(final CoordinateOperation src) {
+ return Importer.DEFAULT.convert(src);
+ }
+
+ /**
+ * Wraps the given PROJ4J coordinate tuple behind the equivalent GeoAPI interface.
+ * The returned object is a view: if any {@code impl} value is changed after this method call,
+ * those changes will be reflected immediately in the returned view. Conversely, setting a value in the
+ * returned view set the corresponding value in the given implementation.
+ *
+ * @param impl the implementation to wrap, or {@code null}
+ * @return the view, or {@code null} if the given implementation was null
+ */
+ public static DirectPosition geoapi(final ProjCoordinate impl) {
+ return PositionWrapper.wrap(impl);
+ }
+
+ /**
+ * Returns the given position as a PROJ4J coordinate tuple.
+ * This method tries to return the backing implementation if possible,
+ * or otherwise copies the coordinate values in a new coordinate tuple.
+ *
+ * @param src the position to unwrap or convert, or {@code null}
+ * @return the coordinates, or {@code null} if the given object was null
+ */
+ public static ProjCoordinate proj4j(final DirectPosition src) {
+ return PositionWrapper.unwrapOrCopy(src);
+ }
+
+ /**
+ * Returns the axis order of the given coordinate system.
+ *
+ * @param cs the coordinate system for which to get the axis order, or {@code null}
+ * @return the axis order, or {@code null} if the given coordinate system was null
+ * @throws UnconvertibleInstanceException if the coordinate system uses an unsupported axis order
+ */
+ public static AxisOrder axisOrder(final CoordinateSystem cs) {
+ return (cs != null) ? AxisOrder.fromString(Importer.axisOrder(cs)) : null;
+ }
+}
diff --git a/geoapi/src/main/java/org/locationtech/proj4j/geoapi/package-info.java b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/package-info.java
new file mode 100644
index 0000000..c406d7a
--- /dev/null
+++ b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/package-info.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Wraps the PROJ4J classes behind the equivalent GeoAPI interfaces.
+ * This module provides a public class, {@link org.locationtech.proj4j.geoapi.Wrappers},
+ * with overloaded {@code geoapi(…)} methods. Those methods expected a PROJ4J object in
+ * argument and returns a view of that object as a GeoAPI type.
+ *
+ * Dependency to a Unit of Measurement library
+ * This module requires a JSR-385 (Units of Measurement) implementation
+ * to be present on the class-path or module-path.
+ * The choice of an implementation is left to the user. Some implementations are
+ * Indriya,
+ * Seshat and
+ * Apache SIS.
+ * The two latter support EPSG codes for units of measurement.
+ *
+ * Mutability
+ * No information is copied. All methods of the views delegate their work to the PROJ4J implementation.
+ * Consequently, since PROJ4J objects are mutable, changes to the wrapped PROJ4J object are immediately
+ * reflected in the view. However, it is not recommended to change a wrapped PROJ4J object as CRS should
+ * be immutable.
+ *
+ * There is one exception to the above paragraph: whether an object is a geographic or projected CRS.
+ * Because the type of a Java object cannot change dynamically, whether a CRS is geographic or projected
+ * is determined at {@code geoapi(CoordinateReferenceSystem)} invocation time.
+ *
+ * Serialization
+ * The serialization details are not committed API.
+ * Serialization is okay for exchanging objects between JVM running the same version of PROJ4J,
+ * but is not guaranteed to be compatible between different versions of PROJ4J. This module does not define
+ * {@code serialVersionUID} because the backing PROJ4J objects do not define those UID anyway.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+package org.locationtech.proj4j.geoapi;
diff --git a/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/AuthorityFactory.java b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/AuthorityFactory.java
new file mode 100644
index 0000000..cd40af0
--- /dev/null
+++ b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/AuthorityFactory.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.locationtech.proj4j.geoapi.spi;
+
+import java.util.Set;
+import org.locationtech.proj4j.CRSFactory;
+import org.locationtech.proj4j.geoapi.Wrappers;
+import org.opengis.metadata.citation.Citation;
+import org.opengis.referencing.IdentifiedObject;
+import org.opengis.referencing.crs.*;
+import org.opengis.util.FactoryException;
+import org.opengis.util.InternationalString;
+
+
+/**
+ * Registers PROJ4J wrappers as a CRS authority factory.
+ *
+ * Future evolution
+ * In a future version, it may not be possible anymore to instantiate this class.
+ * For now, we have to allow instantiation for compatibility with Java 8 services.
+ * If a future version of PROJ4J migrates to Java 9 module system, the only way to
+ * get the factory will by invoking the {@link #provider()} static method.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+public final class AuthorityFactory implements CRSAuthorityFactory {
+ /**
+ * The unique instance returned by {@link #provider()}.
+ */
+ private static final CRSAuthorityFactory INSTANCE = Wrappers.geoapi(new CRSFactory());
+
+ /**
+ * Where to delegate all operations.
+ */
+ private final CRSAuthorityFactory proxy;
+
+ /**
+ * Creates a new instance.
+ * WARNING: this constructor may not be accessible anymore in a future version.
+ * Do not invoke directly.
+ */
+ public AuthorityFactory() {
+ proxy = provider();
+ }
+
+ /**
+ * {@return the factory backed by PROJ4J}.
+ * This is the method that should be invoked when using Java 9+ module system.
+ */
+ public static CRSAuthorityFactory provider() {
+ return INSTANCE;
+ }
+
+ @Override
+ public Citation getVendor() {
+ return proxy.getVendor();
+ }
+
+ @Override
+ public CoordinateReferenceSystem createCoordinateReferenceSystem(String code) throws FactoryException {
+ return proxy.createCoordinateReferenceSystem(code);
+ }
+
+ @Override
+ public CompoundCRS createCompoundCRS(String code) throws FactoryException {
+ return proxy.createCompoundCRS(code);
+ }
+
+ @Override
+ public DerivedCRS createDerivedCRS(String code) throws FactoryException {
+ return proxy.createDerivedCRS(code);
+ }
+
+ @Override
+ public EngineeringCRS createEngineeringCRS(String code) throws FactoryException {
+ return proxy.createEngineeringCRS(code);
+ }
+
+ @Override
+ public GeographicCRS createGeographicCRS(String code) throws FactoryException {
+ return proxy.createGeographicCRS(code);
+ }
+
+ @Override
+ public GeocentricCRS createGeocentricCRS(String code) throws FactoryException {
+ return proxy.createGeocentricCRS(code);
+ }
+
+ @Override
+ public ImageCRS createImageCRS(String code) throws FactoryException {
+ return proxy.createImageCRS(code);
+ }
+
+ @Override
+ public ProjectedCRS createProjectedCRS(String code) throws FactoryException {
+ return proxy.createProjectedCRS(code);
+ }
+
+ @Override
+ public TemporalCRS createTemporalCRS(String code) throws FactoryException {
+ return proxy.createTemporalCRS(code);
+ }
+
+ @Override
+ public VerticalCRS createVerticalCRS(String code) throws FactoryException {
+ return proxy.createVerticalCRS(code);
+ }
+
+ @Override
+ public Citation getAuthority() {
+ return proxy.getAuthority();
+ }
+
+ @Override
+ public Set getAuthorityCodes(Class type) throws FactoryException {
+ return proxy.getAuthorityCodes(type);
+ }
+
+ @Override
+ public InternationalString getDescriptionText(String code) throws FactoryException {
+ return proxy.getDescriptionText(code);
+ }
+
+ @Override
+ public IdentifiedObject createObject(String code) throws FactoryException {
+ return proxy.createObject(code);
+ }
+}
diff --git a/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/OperationFactory.java b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/OperationFactory.java
new file mode 100644
index 0000000..133db2b
--- /dev/null
+++ b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/OperationFactory.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.locationtech.proj4j.geoapi.spi;
+
+import java.util.Map;
+import org.locationtech.proj4j.CoordinateTransformFactory;
+import org.locationtech.proj4j.geoapi.Wrappers;
+import org.opengis.metadata.citation.Citation;
+import org.opengis.parameter.ParameterValueGroup;
+import org.opengis.referencing.crs.CoordinateReferenceSystem;
+import org.opengis.referencing.operation.*;
+import org.opengis.util.FactoryException;
+
+
+/**
+ * Registers PROJ4J wrappers as an operation factory.
+ *
+ * Future evolution
+ * In a future version, it may not be possible anymore to instantiate this class.
+ * For now, we have to allow instantiation for compatibility with Java 8 services.
+ * If a future version of PROJ4J migrates to Java 9 module system, the only way to
+ * get the factory will by invoking the {@link #provider()} static method.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+public final class OperationFactory implements CoordinateOperationFactory {
+ /**
+ * The unique instance returned by {@link #provider()}.
+ */
+ private static final CoordinateOperationFactory INSTANCE = Wrappers.geoapi(new CoordinateTransformFactory());
+
+ /**
+ * Where to delegate all operations.
+ */
+ private final CoordinateOperationFactory proxy;
+
+ /**
+ * Creates a new instance.
+ * WARNING: this constructor may not be accessible anymore in a future version.
+ * Do not invoke directly.
+ */
+ public OperationFactory() {
+ proxy = provider();
+ }
+
+ /**
+ * {@return the factory backed by PROJ4J}.
+ * This is the method that should be invoked when using Java 9+ module system.
+ */
+ public static CoordinateOperationFactory provider() {
+ return INSTANCE;
+ }
+
+ @Override
+ public Citation getVendor() {
+ return proxy.getVendor();
+ }
+
+ @Override
+ public CoordinateOperation createOperation(CoordinateReferenceSystem sourceCRS, CoordinateReferenceSystem targetCRS) throws FactoryException {
+ return proxy.createOperation(sourceCRS, targetCRS);
+ }
+
+ @Override
+ public CoordinateOperation createOperation(CoordinateReferenceSystem sourceCRS, CoordinateReferenceSystem targetCRS, OperationMethod method) throws FactoryException {
+ return proxy.createOperation(sourceCRS, targetCRS, method);
+ }
+
+ @Override
+ public CoordinateOperation createConcatenatedOperation(Map properties, CoordinateOperation... operations) throws FactoryException {
+ return proxy.createConcatenatedOperation(properties, operations);
+ }
+
+ @Override
+ public Conversion createDefiningConversion(Map properties, OperationMethod method, ParameterValueGroup parameters) throws FactoryException {
+ return proxy.createDefiningConversion(properties, method, parameters);
+ }
+}
diff --git a/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/package-info.java b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/package-info.java
new file mode 100644
index 0000000..f54cff7
--- /dev/null
+++ b/geoapi/src/main/java/org/locationtech/proj4j/geoapi/spi/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Registration of PROJ4J wrappers as referencing services.
+ * Developers should not use this package directly, as it may change in any future version.
+ * In particular, it may be simplified if PROJ4J migrates to Java 9+ module system.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+package org.locationtech.proj4j.geoapi.spi;
diff --git a/geoapi/src/main/resources/META-INF/services/org.opengis.referencing.crs.CRSAuthorityFactory b/geoapi/src/main/resources/META-INF/services/org.opengis.referencing.crs.CRSAuthorityFactory
new file mode 100644
index 0000000..ea6f44b
--- /dev/null
+++ b/geoapi/src/main/resources/META-INF/services/org.opengis.referencing.crs.CRSAuthorityFactory
@@ -0,0 +1 @@
+org.locationtech.proj4j.geoapi.spi.AuthorityFactory
diff --git a/geoapi/src/main/resources/META-INF/services/org.opengis.referencing.operation.CoordinateOperationFactory b/geoapi/src/main/resources/META-INF/services/org.opengis.referencing.operation.CoordinateOperationFactory
new file mode 100644
index 0000000..dca2fb5
--- /dev/null
+++ b/geoapi/src/main/resources/META-INF/services/org.opengis.referencing.operation.CoordinateOperationFactory
@@ -0,0 +1 @@
+org.locationtech.proj4j.geoapi.spi.OperationFactory
diff --git a/geoapi/src/test/java/org/locationtech/proj4j/geoapi/ServicesTest.java b/geoapi/src/test/java/org/locationtech/proj4j/geoapi/ServicesTest.java
new file mode 100644
index 0000000..1d6f0a8
--- /dev/null
+++ b/geoapi/src/test/java/org/locationtech/proj4j/geoapi/ServicesTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.locationtech.proj4j.geoapi;
+
+import java.util.Iterator;
+import java.util.ServiceLoader;
+import org.junit.Test;
+import org.opengis.referencing.crs.CRSAuthorityFactory;
+import org.opengis.referencing.crs.CoordinateReferenceSystem;
+import org.opengis.referencing.operation.CoordinateOperationFactory;
+import org.opengis.util.FactoryException;
+
+import static org.locationtech.proj4j.CoordinateReferenceSystem.CS_GEO;
+import static org.junit.Assert.*;
+
+
+/**
+ * Tests fetching factory instances as services.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+public class ServicesTest {
+ /**
+ * Creates a new test case.
+ */
+ public ServicesTest() {
+ }
+
+ /**
+ * Returns the factory of the given type, making sure that there is exactly one instance.
+ */
+ private static F getSingleton(final Class service) {
+ Iterator it = ServiceLoader.load(service).iterator();
+ assertTrue(it.hasNext());
+ F factory = it.next();
+ assertFalse(it.hasNext());
+ return factory;
+ }
+
+ /**
+ * Tests the CRS authority factory.
+ * This method only checks that the object are non-null.
+ * More detailed checks are performed by {@link WrappersTest}.
+ *
+ * @throws FactoryException if an error occurred while creating an object.
+ */
+ @Test
+ public void testAuthorityFactory() throws FactoryException {
+ final CRSAuthorityFactory factory = getSingleton(CRSAuthorityFactory.class);
+ assertNotNull(factory.createGeographicCRS("EPSG:4326"));
+ assertNotNull(factory.createProjectedCRS ("EPSG:2154"));
+ }
+
+ /**
+ * Tests the operation authority factory.
+ * This method only checks that the object are non-null.
+ *
+ * @throws FactoryException if an error occurred while creating an object.
+ */
+ @Test
+ public void testOperationFactory() throws FactoryException {
+ final CoordinateOperationFactory factory = getSingleton(CoordinateOperationFactory.class);
+ final CoordinateReferenceSystem crs = Wrappers.geoapi(CS_GEO, false);
+ assertTrue(factory.createOperation(crs, crs).getMathTransform().isIdentity());
+ }
+}
diff --git a/geoapi/src/test/java/org/locationtech/proj4j/geoapi/TransformTest.java b/geoapi/src/test/java/org/locationtech/proj4j/geoapi/TransformTest.java
new file mode 100644
index 0000000..768ceac
--- /dev/null
+++ b/geoapi/src/test/java/org/locationtech/proj4j/geoapi/TransformTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.locationtech.proj4j.geoapi;
+
+import org.junit.Test;
+import org.opengis.referencing.operation.MathTransform;
+import org.opengis.referencing.operation.TransformException;
+import org.opengis.test.referencing.TransformTestCase;
+import org.opengis.util.FactoryException;
+
+
+/**
+ * Tests some coordinate operations.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+public class TransformTest extends TransformTestCase {
+ /**
+ * Creates a new test case.
+ */
+ public TransformTest() {
+ }
+
+ /**
+ * Creates a transform between the given pair of coordinate reference systems.
+ *
+ * @param source authority code of the input coordinate reference system
+ * @param target authority code of the output coordinate reference system
+ * @return a coordinate operation from {@code source} to {@code target}
+ * @throws FactoryException if the coordinate operation cannot be created
+ */
+ private static MathTransform transform(String source, String target) throws FactoryException {
+ return Services.findOperation(Services.createCRS(source), Services.createCRS(target)).getMathTransform();
+ }
+
+ /**
+ * Tests a projection from a geographic CRS to a projected CRS.
+ *
+ * @throws FactoryException if a CRS cannot be created
+ * @throws TransformException if an error occurred while testing the projection of a point
+ */
+ @Test
+ public void testProjection() throws FactoryException, TransformException {
+ transform = transform("EPSG:4326", "EPSG:2154");
+ tolerance = 1E-3;
+ verifyTransform(new double[] {3, 46.5}, // Coordinates to test (more can be added on this line).
+ new double[] {700000, 6600000}); // Expected result.
+
+ // Random coordinates.
+ final float[] coordinates = {
+ 3.0f, 46.5f,
+ 2.5f, 43.0f,
+ 3.5f, 46.0f,
+ 4.5f, 48.0f,
+ 1.5f, 41.0f,
+ 3.8f, 43.7f,
+ 3.1f, 42.1f,
+ };
+ verifyConsistency(coordinates);
+ verifyInverse(coordinates);
+ }
+}
diff --git a/geoapi/src/test/java/org/locationtech/proj4j/geoapi/WrappersTest.java b/geoapi/src/test/java/org/locationtech/proj4j/geoapi/WrappersTest.java
new file mode 100644
index 0000000..656a95f
--- /dev/null
+++ b/geoapi/src/test/java/org/locationtech/proj4j/geoapi/WrappersTest.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2025, PROJ4J contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.locationtech.proj4j.geoapi;
+
+import javax.measure.Unit;
+import javax.measure.quantity.Angle;
+import javax.measure.quantity.Length;
+import org.junit.Test;
+import org.locationtech.proj4j.CRSFactory;
+import org.locationtech.proj4j.ProjCoordinate;
+import org.locationtech.proj4j.datum.AxisOrder;
+import org.opengis.geometry.DirectPosition;
+import org.opengis.parameter.ParameterValue;
+import org.opengis.parameter.ParameterValueGroup;
+import org.opengis.referencing.crs.CRSAuthorityFactory;
+import org.opengis.referencing.crs.GeographicCRS;
+import org.opengis.referencing.crs.ProjectedCRS;
+import org.opengis.referencing.datum.GeodeticDatum;
+import org.opengis.referencing.datum.PrimeMeridian;
+import org.opengis.referencing.datum.Ellipsoid;
+import org.opengis.referencing.cs.CartesianCS;
+import org.opengis.referencing.cs.EllipsoidalCS;
+import org.opengis.referencing.cs.AxisDirection;
+import org.opengis.referencing.cs.CoordinateSystemAxis;
+import org.opengis.referencing.operation.MathTransform;
+import org.opengis.referencing.operation.OperationMethod;
+import org.opengis.referencing.operation.Projection;
+import org.opengis.referencing.operation.TransformException;
+import org.opengis.util.FactoryException;
+import org.opengis.test.Validators;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * Tests a few wrapper methods.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+public final class WrappersTest {
+ /**
+ * Creates a new test case.
+ */
+ public WrappersTest() {
+ }
+
+ /**
+ * {@return a factory to use for testing CRS creation}.
+ */
+ private static CRSAuthorityFactory crsFactory() {
+ return Wrappers.geoapi(new CRSFactory());
+ }
+
+ /**
+ * Tests the wrapping of a datum.
+ */
+ @Test
+ public void testDatum() {
+ GeodeticDatum datum = Wrappers.geoapi(org.locationtech.proj4j.datum.Datum.NZGD49);
+ assertEquals("New Zealand Geodetic Datum 1949", datum.getName().getCode());
+ assertEquals("nzgd49", datum.getAlias().iterator().next().toString());
+
+ Ellipsoid ellipsoid = datum.getEllipsoid();
+ assertEquals("International 1909 (Hayford)", ellipsoid.getName().getCode());
+ assertEquals("intl", ellipsoid.getAlias().iterator().next().toString());
+ assertEquals(6378388, ellipsoid.getSemiMajorAxis(), 0);
+ assertEquals(6356911.95, ellipsoid.getSemiMinorAxis(), 0.005);
+ assertEquals(297, ellipsoid.getInverseFlattening(), 5E-10);
+
+ // Verification by GeoAPI
+ Validators.validate(datum);
+ }
+
+ /**
+ * Tests the creation of a geographic CRS.
+ * This method verifies the datum (including its dependencies) and the coordinate system.
+ *
+ * @throws FactoryException if the CRS cannot be created
+ */
+ @Test
+ public void testGeographicCRS() throws FactoryException {
+ final Unit degree = Units.getInstance().degree;
+ final GeographicCRS crs = crsFactory().createGeographicCRS("EPSG:4326");
+ assertEquals("EPSG:4326", crs.getName().getCode());
+
+ /*
+ * First property of a CRS: the datum, which includes the ellipsoid and the prime meridian.
+ * Verify the name, Greenwich longitude, ellipsoid axis lengths and units of measurement.
+ */
+ final GeodeticDatum datum = crs.getDatum();
+ assertEquals("WGS84", datum.getName().getCode());
+
+ final PrimeMeridian pm = datum.getPrimeMeridian();
+ assertEquals("greenwich", pm.getName().getCode());
+ assertEquals(0, pm.getGreenwichLongitude(), 0);
+ assertEquals(degree, pm.getAngularUnit());
+
+ final Ellipsoid ellipsoid = datum.getEllipsoid();
+ assertEquals("WGS 84", ellipsoid.getName().getCode());
+ assertEquals(6378137, ellipsoid.getSemiMajorAxis(), 0);
+ assertEquals(6356752.31, ellipsoid.getSemiMinorAxis(), 0.005);
+ assertEquals(298.257223563, ellipsoid.getInverseFlattening(), 5E-10);
+
+ /*
+ * Second property of a CRS: its coordinate system.
+ * Verify axis name, abbreviation, direction and unit.
+ */
+ final EllipsoidalCS cs = crs.getCoordinateSystem();
+ assertEquals(AxisOrder.ENU, Wrappers.axisOrder(cs));
+ assertEquals(2, cs.getDimension());
+
+ CoordinateSystemAxis axis = cs.getAxis(0);
+ assertEquals("Geodetic longitude", axis.getName().getCode());
+ assertEquals("lon", axis.getAbbreviation());
+ assertEquals(AxisDirection.EAST, axis.getDirection());
+ assertEquals(degree, axis.getUnit());
+ assertSame(axis, cs.getAxis(0));
+
+ axis = cs.getAxis(1);
+ assertEquals("Geodetic latitude", axis.getName().getCode());
+ assertEquals("lat", axis.getAbbreviation());
+ assertEquals(AxisDirection.NORTH, axis.getDirection());
+ assertEquals(degree, axis.getUnit());
+ assertSame(axis, cs.getAxis(1));
+
+ // Verification by GeoAPI
+ Validators.validate(crs);
+ }
+
+ /**
+ * Tests the creation of a projected CRS.
+ * This method verifies the datum, the coordinate system and the projection parameters.
+ * Opportunistically tests the transformation of a point.
+ *
+ * @throws FactoryException if the CRS cannot be created
+ * @throws TransformException if an error occurred while testing the projection of a point
+ */
+ @Test
+ public void testProjectedCRS() throws FactoryException, TransformException {
+ final Unit degree = Units.getInstance().degree;
+ final Unit metre = Units.getInstance().metre;
+ final ProjectedCRS crs = crsFactory().createProjectedCRS("EPSG:2154");
+ assertEquals("EPSG:2154", crs.getName().getCode());
+
+ /*
+ * First property of a CRS: the datum, which includes the ellipsoid and the prime meridian.
+ * Verify the name, Greenwich longitude, ellipsoid axis lengths and units of measurement.
+ */
+ final GeodeticDatum datum = crs.getDatum();
+ final PrimeMeridian pm = datum.getPrimeMeridian();
+ assertEquals("greenwich", pm.getName().getCode());
+ assertEquals(0, pm.getGreenwichLongitude(), 0);
+ assertEquals(degree, pm.getAngularUnit());
+
+ final Ellipsoid ellipsoid = datum.getEllipsoid();
+ assertTrue(ellipsoid.getName().getCode().startsWith("GRS 1980"));
+ assertEquals(6378137, ellipsoid.getSemiMajorAxis(), 0);
+ assertEquals(6356752.31, ellipsoid.getSemiMinorAxis(), 0.005);
+ assertEquals(298.257222101, ellipsoid.getInverseFlattening(), 5E-10);
+
+ /*
+ * Second property of a CRS: its coordinate system.
+ * Verify axis name, abbreviation, direction and unit.
+ */
+ final CartesianCS cs = crs.getCoordinateSystem();
+ assertEquals(AxisOrder.ENU, Wrappers.axisOrder(cs));
+ assertEquals(2, cs.getDimension());
+
+ CoordinateSystemAxis axis = cs.getAxis(0);
+ assertEquals("Easting", axis.getName().getCode());
+ assertEquals("E", axis.getAbbreviation());
+ assertEquals(AxisDirection.EAST, axis.getDirection());
+ assertEquals(metre, axis.getUnit());
+ assertSame(axis, cs.getAxis(0));
+
+ axis = cs.getAxis(1);
+ assertEquals("Northing", axis.getName().getCode());
+ assertEquals("N", axis.getAbbreviation());
+ assertEquals(AxisDirection.NORTH, axis.getDirection());
+ assertEquals(metre, axis.getUnit());
+ assertSame(axis, cs.getAxis(1));
+
+ /*
+ * Property specific to a projected CRS: conversion from the base CRS.
+ * Verify parameters having a value different than their default value.
+ */
+ final GeographicCRS baseCRS = crs.getBaseCRS();
+ assertEquals(datum, baseCRS.getDatum());
+
+ final Projection conversionFromBase = crs.getConversionFromBase();
+ final OperationMethod method = conversionFromBase.getMethod();
+ assertArrayEquals(new String[] {
+ "central_meridian",
+ "latitude_of_origin",
+ "standard_parallel_1",
+ "standard_parallel_2",
+ "false_easting",
+ "false_northing"
+ }, method.getParameters().descriptors().stream().map((d) -> d.getName().getCode()).toArray());
+
+ final ParameterValueGroup pv = conversionFromBase.getParameterValues();
+ assertEquals( 46.5, pv.parameter("latitude_of_origin") .doubleValue(), 1E-12);
+ assertEquals( 3.0, pv.parameter("central_meridian") .doubleValue(), 1E-12);
+ assertEquals( 49.0, pv.parameter("standard_parallel_1").doubleValue(), 1E-12);
+ assertEquals( 44.0, pv.parameter("standard_parallel_2").doubleValue(), 1E-12);
+ assertEquals( 700000.0, pv.parameter("false_easting") .doubleValue(), 0);
+ assertEquals(6600000.0, pv.parameter("false_northing") .doubleValue(), 0);
+
+ // Test unit conversion.
+ final ParameterValue origin = pv.parameter("latitude_of_origin");
+ assertEquals(46.5, origin.doubleValue(degree), 1E-12);
+ assertEquals(Math.toRadians(46.5), origin.doubleValue(Units.getInstance().radian), 1E-12);
+
+ /*
+ * Test the transform of a point, then test the inverse operation.
+ */
+ final MathTransform tr = conversionFromBase.getMathTransform();
+ DirectPosition pt = Wrappers.geoapi(new ProjCoordinate(3, 46.5));
+ assertEquals(2, pt.getDimension());
+ pt = tr.transform(pt, pt);
+ assertEquals(2, pt.getDimension());
+ assertEquals( 700000, pt.getOrdinate(0), 1E-3);
+ assertEquals(6600000, pt.getOrdinate(1), 1E-3);
+ pt = tr.inverse().transform(pt, pt);
+ assertEquals(2, pt.getDimension());
+ assertEquals(46.5, pt.getOrdinate(1), 1E-9);
+ assertEquals( 3.0, pt.getOrdinate(0), 1E-9);
+
+ // Verification by GeoAPI
+ // Disabled because one of the test is a bit too strict. This is fixed in GeoAPI 3.1.
+ // Validators.validate(crs);
+ }
+}
diff --git a/pom.xml b/pom.xml
index 646adb4..ef34108 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
1.3.1-SNAPSHOT
pom
@@ -21,9 +21,182 @@
+
+ https://github.com/locationtech/proj4j.git
+ scm:git:https://github.com/locationtech/proj4j.git
+ HEAD
+
+
+
+
+ echeipesh
+ Eugene Cheipesh
+ https://github.com/echeipesh
+
+
+ lossyrob
+ Rob Emanuele
+ https://github.com/lossyrob
+
+
+ pomadchin
+ Grigory Pomadchin
+ https://github.com/pomadchin
+
+
+
+
+
+ Martin Davis
+ https://github.com/dr-jts
+
+
+
+
+
+
+ junit
+ junit
+ 4.13.2
+ test
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ 3.11.0
+
+ 8
+ true
+ UTF-8
+
+
+
+ true
+ maven-javadoc-plugin
+ 3.5.0
+
+
+ attach-javadocs
+
+ jar
+
+
+ true
+ false
+ false
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-source-plugin
+ 3.2.1
+
+
+ attach-sources
+
+ jar
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-surefire-plugin
+ 3.1.0
+
+
+
+
+ maven-deploy-plugin
+ 3.1.1
+
+ true
+ true
+
+
+
+ default-deploy
+ deploy
+
+ deploy
+
+
+
+
+
+
+
+
+
+ eclipse
+
+
+ repo.eclipse.org
+ Proj4J Repository - Releases
+ https://repo.eclipse.org/content/repositories/proj4j-releases/
+
+
+ repo.eclipse.org
+ Proj4J Repository - Snapshots
+ https://repo.eclipse.org/content/repositories/proj4j-snapshots/
+
+
+
+
+ central
+
+
+ ossrh
+ https://oss.sonatype.org/service/local/staging/deploy/maven2/
+
+
+ ossrh
+ https://oss.sonatype.org/content/repositories/snapshots
+
+
+
+
+
+ org.sonatype.plugins
+ nexus-staging-maven-plugin
+ 1.6.13
+ true
+
+ ossrh
+ https://oss.sonatype.org/
+ false
+
+
+
+ org.apache.maven.plugins
+ maven-gpg-plugin
+ 3.0.1
+
+
+ sign-artifacts
+ verify
+
+ sign
+
+
+
+
+
+
+
+
+
core
epsg
+ geoapi