sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1606173 - in /sis/branches/JDK8/core/sis-referencing/src: main/java/org/apache/sis/referencing/operation/transform/ test/java/org/apache/sis/referencing/operation/transform/ test/java/org/apache/sis/test/suite/
Date Fri, 27 Jun 2014 18:34:29 GMT
Author: desruisseaux
Date: Fri Jun 27 18:34:28 2014
New Revision: 1606173

URL: http://svn.apache.org/r1606173
Log:
Ported a test.

Added:
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransformTest.java
  (with props)
Modified:
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform2D.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransform.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java?rev=1606173&r1=1606172&r2=1606173&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
[UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
[UTF-8] Fri Jun 27 18:34:28 2014
@@ -951,7 +951,7 @@ public abstract class AbstractMathTransf
      * @see AbstractMathTransform2D#beforeFormat(List, int, boolean)
      * @see ConcatenatedTransform#getPseudoSteps()
      */
-    int beforeFormat(List<MathTransform> transforms, int index, boolean inverse) {
+    int beforeFormat(List<Object> transforms, int index, boolean inverse) {
         return index;
     }
 

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform2D.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform2D.java?rev=1606173&r1=1606172&r2=1606173&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform2D.java
[UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform2D.java
[UTF-8] Fri Jun 27 18:34:28 2014
@@ -26,7 +26,6 @@ import java.awt.geom.PathIterator;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.IllegalPathStateException;
 import org.opengis.referencing.operation.Matrix;
-import org.opengis.referencing.operation.MathTransform;
 import org.opengis.referencing.operation.MathTransform2D;
 import org.opengis.referencing.operation.TransformException;
 import org.opengis.referencing.operation.NoninvertibleTransformException;
@@ -340,11 +339,52 @@ public abstract class AbstractMathTransf
         }
 
         /**
+         * Transforms the specified {@code ptSrc} and stores the result in {@code ptDst}.
+         * The default implementation invokes {@link #transform(double[], int, double[],
int, boolean)}
+         * using a temporary array of doubles.
+         *
+         * @param  ptSrc The coordinate point to be transformed.
+         * @param  ptDst The coordinate point that stores the result of transforming {@code
ptSrc},
+         *               or {@code null} if a new point shall be created.
+         * @return The coordinate point after transforming {@code ptSrc} and storing the
result in {@code ptDst},
+         *         or in a new point if {@code ptDst} was null.
+         * @throws TransformException If the point can not be transformed.
+         *
+         * @see MathTransform2D#transform(Point2D, Point2D)
+         */
+        @Override
+        public Point2D transform(final Point2D ptSrc, final Point2D ptDst) throws TransformException
{
+            final double[] ord = new double[] {ptSrc.getX(), ptSrc.getY()};
+            transform(ord, 0, ord, 0, false);
+            if (ptDst != null) {
+                ptDst.setLocation(ord[0], ord[1]);
+                return ptDst;
+            } else {
+                return new Point2D.Double(ord[0], ord[1]);
+            }
+        }
+
+        /**
+         * Transforms the specified shape. The default implementation computes quadratic
curves
+         * using three points for each line segment in the shape. The returned object is
often
+         * a {@link Path2D}, but may also be a {@link Line2D} or a {@link QuadCurve2D} if
such
+         * simplification is possible.
+         *
+         * @param  shape Shape to transform.
+         * @return Transformed shape, or {@code shape} if this transform is the identity
transform.
+         * @throws TransformException if a transform failed.
+         */
+        @Override
+        public Shape createTransformedShape(final Shape shape) throws TransformException
{
+            return isIdentity() ? shape : AbstractMathTransform2D.createTransformedShape(this,
shape, null, null, false);
+        }
+
+        /**
          * Same work than {@link AbstractMathTransform2D#beforeFormat(List, int, boolean)}
          * but with the knowledge that this transform is an inverse transform.
          */
         @Override
-        final int beforeFormat(final List<MathTransform> transforms, final int index,
final boolean inverse) {
+        final int beforeFormat(final List<Object> transforms, final int index, final
boolean inverse) {
             return AbstractMathTransform2D.this.beforeFormat(transforms, index, !inverse);
         }
     }

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransform.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransform.java?rev=1606173&r1=1606172&r2=1606173&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransform.java
[UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransform.java
[UTF-8] Fri Jun 27 18:34:28 2014
@@ -38,6 +38,7 @@ import org.apache.sis.util.ComparisonMod
 import org.apache.sis.util.Utilities;
 import org.apache.sis.io.wkt.Convention;
 import org.apache.sis.io.wkt.Formatter;
+import org.apache.sis.io.wkt.FormattableObject;
 import org.apache.sis.util.resources.Errors;
 
 
@@ -409,11 +410,11 @@ class ConcatenatedTransform extends Abst
      * (<var>normalize</var>, <var>unitary projection</var>, <var>denormalize</var>)
tuples are replaced by single
      * (<var>projection</var>) elements, which does not need to be instances
of {@link MathTransform}.
      */
-    private List<MathTransform> getPseudoSteps() {
-        final List<MathTransform> transforms = new ArrayList<>();
+    private List<Object> getPseudoSteps() {
+        final List<Object> transforms = new ArrayList<>();
         getSteps(transforms);
         /*
-         * Pre-process the transforms before to format. Some steps may be* merged, or new
+         * Pre-process the transforms before to format. Some steps may be merged, or new
          * steps may be created. Do not move size() out of the loop, because it may change.
          */
         for (int i=0; i<transforms.size(); i++) {
@@ -430,7 +431,7 @@ class ConcatenatedTransform extends Abst
      *
      * @param transforms The list where to add concatenated transforms.
      */
-    private void getSteps(final List<MathTransform> transforms) {
+    private void getSteps(final List<? super MathTransform> transforms) {
         if (transform1 instanceof ConcatenatedTransform) {
             ((ConcatenatedTransform) transform1).getSteps(transforms);
         } else {
@@ -468,7 +469,7 @@ class ConcatenatedTransform extends Abst
      */
     private Parameterized getParameterised() {
         Parameterized param = null;
-        final List<MathTransform> transforms = getPseudoSteps();
+        final List<Object> transforms = getPseudoSteps();
         if (transforms.size() == 1 || Semaphores.query(Semaphores.PROJCS)) {
             for (final Object candidate : transforms) {
                 if (!(candidate instanceof Parameterized)) {
@@ -888,7 +889,7 @@ class ConcatenatedTransform extends Abst
      */
     @Override
     public String formatTo(final Formatter formatter) {
-        final List<MathTransform> transforms;
+        final List<? super MathTransform> transforms;
         if (formatter.getConvention() == Convention.INTERNAL) {
             transforms = getSteps();
         } else {
@@ -902,9 +903,13 @@ class ConcatenatedTransform extends Abst
         if (transforms.size() == 1) {
             return formatter.delegateTo(transforms.get(0));
         }
-        for (final MathTransform step : transforms) {
+        for (final Object step : transforms) {
             formatter.newLine();
-            formatter.append(step);
+            if (step instanceof FormattableObject) {
+                formatter.append((FormattableObject) step); // May not implement MathTransform.
+            } else {
+                formatter.append((MathTransform) step);
+            }
         }
         return "Concat_MT";
     }

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java?rev=1606173&r1=1606172&r2=1606173&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
[UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
[UTF-8] Fri Jun 27 18:34:28 2014
@@ -85,7 +85,7 @@ public class PassThroughTransform extend
      * The sub-transform to apply on the {@linkplain #getModifiedCoordinates() modified coordinates}.
      * This is often the sub-transform specified at construction time, but not necessarily.
      */
-    protected final MathTransform subTransform;
+    final MathTransform subTransform;
 
     /**
      * The inverse transform. This field will be computed only when needed,
@@ -275,6 +275,16 @@ public class PassThroughTransform extend
     }
 
     /**
+     * Returns the sub-transform to apply on the {@linkplain #getModifiedCoordinates() modified
coordinates}.
+     * This is often the sub-transform specified at construction time, but not necessarily.
+     *
+     * @return The sub-transform.
+     */
+    public final MathTransform getSubTransform() {
+        return subTransform;
+    }
+
+    /**
      * Tests whether this transform does not move any points. A {@code PassThroughTransform}
      * is identity if the {@linkplain #subTransform sub-transform} is also identity.
      *

Added: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransformTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransformTest.java?rev=1606173&view=auto
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransformTest.java
(added)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransformTest.java
[UTF-8] Fri Jun 27 18:34:28 2014
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.referencing.operation.transform;
+
+import org.opengis.referencing.operation.MathTransform;
+import org.opengis.referencing.operation.TransformException;
+import org.apache.sis.internal.referencing.j2d.AffineTransform2D;
+import org.apache.sis.referencing.operation.matrix.Matrix4;
+import org.apache.sis.test.DependsOn;
+import org.junit.Test;
+
+import static org.opengis.test.Assert.*;
+
+
+/**
+ * Tests the {@link ConcatenatedTransform} class.
+ *
+ * @author  Martin Desruisseaux (Geomatys)
+ * @since   0.5 (derived from geotk-3.00)
+ * @version 0.5
+ * @module
+ */
+@DependsOn(ProjectiveTransformTest.class)
+public final strictfp class ConcatenatedTransformTest extends MathTransformTestCase {
+    /**
+     * Tests the concatenation of two affine transforms than can be represented
+     * as a {@link ConcatenatedTransformDirect2D}.
+     *
+     * @throws TransformException Should never happen.
+     */
+    @Test
+    public void testDirect2D() throws TransformException {
+        final AffineTransform2D first = new AffineTransform2D();
+        first.translate(2,4);
+        first.freeze();
+
+        final AffineTransform2D second = new AffineTransform2D();
+        second.translate(0.25, 0.75);
+        second.freeze();
+
+        // Direct for 2D case.
+        tolerance = 1E-10;
+        transform = new ConcatenatedTransformDirect2D(first, second);
+        validate();
+        final double[] source = generateRandomCoordinates(CoordinateDomain.PROJECTED, 0);
+        final double[] target = new double[source.length];
+        first .transform(source, 0, target, 0, source.length/2);
+        second.transform(target, 0, target, 0, target.length/2);
+        verifyTransform(source, target);
+
+        // Non-direct for 2D case.
+        transform = new ConcatenatedTransform2D(first, second);
+        validate();
+        verifyTransform(source, target);
+
+        // Direct for general case - can't be validated.
+        transform = new ConcatenatedTransformDirect(first, second);
+        verifyTransform(source, target);
+
+        // Most general case - can't be validated.
+        transform = new ConcatenatedTransform(first, second);
+        verifyTransform(source, target);
+
+        // Optimized case.
+        transform = MathTransforms.concatenate(first, second);
+        assertInstanceOf("Expected optimized concatenation through matrix multiplication.",
AffineTransform2D.class, transform);
+        validate();
+        verifyTransform(source, target);
+    }
+
+    /**
+     * Tests the concatenation of two affine transforms than can not be represented as a
+     * {@link ConcatenatedTransformDirect}. The slower {@link ConcatenatedTransform} shall
be used.
+     *
+     * @throws TransformException Should never happen.
+     */
+    @Test
+    @org.junit.Ignore("Missing implementation of DimensionFilter.")
+    public void testGeneric() throws TransformException {
+        final MathTransform first = null; //MathTransforms.dimensionFilter(4, new int[] {1,3});
+
+        final AffineTransform2D second = new AffineTransform2D();
+        second.scale(0.5, 0.25);
+        second.freeze();
+
+        transform = new ConcatenatedTransform(first, second);
+        isInverseTransformSupported = false;
+        validate();
+        final double[] source = generateRandomCoordinates(CoordinateDomain.PROJECTED, 0);
+        final double[] target = new double[source.length / 2]; // Going from 4 to 2 dimensions.
+        first .transform(source, 0, target, 0, target.length/2);
+        second.transform(target, 0, target, 0, target.length/2);
+        verifyTransform(source, target);
+
+        // Optimized case.
+        transform = ConcatenatedTransform.create(first, second);
+        assertInstanceOf("Expected optimized concatenation through matrix multiplication.",
ProjectiveTransform.class, transform);
+        validate();
+        verifyTransform(source, target);
+    }
+
+    /**
+     * Tests the concatenation of a 3D affine transform with a pass-through transform.
+     * The {@link ConcatenatedTransform#create(MathTransform, MathTransform)} method
+     * should optimize this case.
+     */
+    @Test
+    public void testPassthrough() {
+        final MathTransform kernel = new PseudoTransform(2, 3); // Any non-linear transform.
+        final MathTransform passth = PassThroughTransform.create(0, kernel, 1);
+        final Matrix4 matrix = new Matrix4();
+        transform = ConcatenatedTransform.create(MathTransforms.linear(matrix), passth);
+        assertSame("Identity transform should be ignored.", passth, transform);
+        assertEquals("Source dimensions", 3, transform.getSourceDimensions());
+        assertEquals("Target dimensions", 4, transform.getTargetDimensions());
+        /*
+         * Put scale or offset factors only in the dimension to be processed by the sub-transform.
+         * The matrix should be concatenated to the sub-transform rather than to the passthrough
+         * transform.
+         */
+        matrix.m00 = 3;
+        matrix.m13 = 2;
+        transform = ConcatenatedTransform.create(MathTransforms.linear(matrix), passth);
+        assertInstanceOf("Expected a new passthrough transform.", PassThroughTransform.class,
transform);
+        final MathTransform subTransform = ((PassThroughTransform) transform).getSubTransform();
+        assertInstanceOf("Expected a new concatenated transform.", ConcatenatedTransform.class,
subTransform);
+        assertSame(kernel, ((ConcatenatedTransform) subTransform).transform2);
+        assertEquals("Source dimensions", 3, transform.getSourceDimensions());
+        assertEquals("Target dimensions", 4, transform.getTargetDimensions());
+        /*
+         * Put scale or offset factors is a passthrough dimension. Now, the affine transform
+         * can not anymore be concatenated with the sub-transform.
+         */
+        matrix.m22 = 4;
+        transform = ConcatenatedTransform.create(MathTransforms.linear(matrix), passth);
+        assertInstanceOf("Expected a new concatenated transform.", ConcatenatedTransform.class,
transform);
+        assertSame(passth, ((ConcatenatedTransform) transform).transform2);
+        assertEquals("Source dimensions", 3, transform.getSourceDimensions());
+        assertEquals("Target dimensions", 4, transform.getTargetDimensions());
+    }
+}

Propchange: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransformTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/ConcatenatedTransformTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain;charset=UTF-8

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java?rev=1606173&r1=1606172&r2=1606173&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java
[UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/test/suite/ReferencingTestSuite.java
[UTF-8] Fri Jun 27 18:34:28 2014
@@ -48,6 +48,7 @@ import org.junit.BeforeClass;
     org.apache.sis.referencing.operation.transform.ExponentialTransform1DTest.class,
     org.apache.sis.referencing.operation.transform.CopyTransformTest.class,
     org.apache.sis.referencing.operation.transform.PassThroughTransformTest.class,
+    org.apache.sis.referencing.operation.transform.ConcatenatedTransformTest.class,
     org.apache.sis.referencing.operation.transform.TransferFunctionTest.class,
 
     org.apache.sis.internal.referencing.FormulasTest.class,



Mime
View raw message