Merge pull request #9 from dotnet-campus/t/sewzc/similarity_transformation

添加相似变换的应用变换方法

Author: lindexi

DotNetCampus.Numerics.Geometry.Tests/SimilarityTransformation2DTest.cs

@@ -30,6 +30,8 @@ public class SimilarityTransformation2DTest
         // 组合变换
         { new SimilarityTransformation2D(2, false, AngularMeasure.FromDegree(90), new Vector2D(1, 2)), new Point2D(1, 2), new Point2D(-3, 4) },
         { new SimilarityTransformation2D(2, false, AngularMeasure.FromDegree(90), new Vector2D(1, 2)), new Point2D(3, 4), new Point2D(-7, 8) },
+        { new SimilarityTransformation2D(2, true, AngularMeasure.FromDegree(90), new Vector2D(1, 2)), new Point2D(1, 2), new Point2D(5, 4) },
+        { new SimilarityTransformation2D(2, true, AngularMeasure.FromDegree(90), new Vector2D(1, 2)), new Point2D(3, 4), new Point2D(9, 8) },
     };
 
     #endregion
@@ -198,5 +200,31 @@ public void InverseTest(SimilarityTransformation2D similarityTransformation2D, P
         Assert.Equal(original, inverse.Transform(transformed), GeometryNumericsEqualHelper.IsAlmostEqual);
     }
 
+    [Theory(DisplayName = "测试应用另一个变换。")]
+    [MemberData(nameof(TestData))]
+    public void ApplyTest(SimilarityTransformation2D similarityTransformation2D, Point2D point, Point2D expected)
+    {
+        Debug.Assert(similarityTransformation2D != null, nameof(similarityTransformation2D) + " != null");
+
+        var newTransformation = SimilarityTransformation2D.Identity
+            .Apply(new SimilarityTransformation2D(similarityTransformation2D.Scaling, false, AngularMeasure.Zero, Vector2D.Zero))
+            .Apply(new SimilarityTransformation2D(1, similarityTransformation2D.IsYScaleNegative, AngularMeasure.Zero, Vector2D.Zero))
+            .Apply(new SimilarityTransformation2D(1, false, similarityTransformation2D.Rotation, Vector2D.Zero))
+            .Apply(new SimilarityTransformation2D(1, false, AngularMeasure.Zero, similarityTransformation2D.Translation));
+
+        Assert.Equal(expected, newTransformation.Transform(point), GeometryNumericsEqualHelper.IsAlmostEqual);
+    }
+
+    [Theory(DisplayName = "测试应用变换后再应用其逆变换。")]
+    [MemberData(nameof(TestData))]
+    public void ApplyInverseTest(SimilarityTransformation2D similarityTransformation2D, Point2D point, Point2D expected)
+    {
+        Debug.Assert(similarityTransformation2D != null, nameof(similarityTransformation2D) + " != null");
+
+        var newTransformation = similarityTransformation2D.Apply(similarityTransformation2D).Apply(similarityTransformation2D.Inverse());
+
+        Assert.Equal(expected, newTransformation.Transform(point), GeometryNumericsEqualHelper.IsAlmostEqual);
+    }
+
     #endregion
 }

DotNetCampus.Numerics.Geometry/AffineTransformation2D.cs

@@ -217,6 +217,9 @@ public AffineTransformation2D Translate(Vector2D offset)
     /// <summary>
     /// 应用另一个仿射变换到当前仿射变换。
     /// </summary>
+    /// <remarks>
+    /// 使用应用后的结果对目标进行变换时，相当于使用当前变换对目标进行变换，然后再使用 <paramref name="transformation"/> 对变换后的目标进行变换。
+    /// </remarks>
     /// <param name="transformation">要应用的仿射变换。</param>
     /// <returns>应用后的仿射变换。</returns>
     public AffineTransformation2D Apply(AffineTransformation2D transformation)
@@ -323,4 +326,4 @@ public static implicit operator Matrix3X3D(AffineTransformation2D affineTransfor
 /// <param name="Rotation">旋转角度。</param>
 /// <param name="Shearing">剪切系数。</param>
 /// <param name="Scaling">缩放参数。</param>
-public record AffineTransformation2DDecomposition(Vector2D Translation, AngularMeasure Rotation, double Shearing, Scaling2D Scaling);
+public record AffineTransformation2DDecomposition(Vector2D Translation, AngularMeasure Rotation, double Shearing, Scaling2D Scaling);

DotNetCampus.Numerics.Geometry/SimilarityTransformation2D.cs

@@ -110,7 +110,7 @@ public SimilarityTransformation2D Scale(double scale, bool isXScaleNegative, boo
         {
             Scaling = Scaling * scale.CheckPositive(),
             IsYScaleNegative = IsYScaleNegative ^ isXScaleNegative ^ isYScaleNegative,
-            Rotation = Rotation + AngularMeasure.Pi * (isXScaleNegative ? 1 : 0),
+            Rotation = Rotation + (isXScaleNegative ? AngularMeasure.Pi : AngularMeasure.Zero),
         };
     }
 
@@ -137,16 +137,32 @@ public SimilarityTransformation2D Translate(Vector2D translation)
     /// <summary>
     /// 将点进行相似变换。
     /// </summary>
-    /// <param name="point"></param>
-    /// <returns></returns>
+    /// <param name="point">要变换的点。</param>
+    /// <returns>变换后的点。</returns>
     public Point2D Transform(Point2D point)
+    {
+        return (Point2D)(Transform(point.ToVector()) + Translation);
+    }
+
+    /// <summary>
+    /// 将向量进行相似变换。与点的变换不同的是，向量的变换不会计算 <see cref="Translation"/>。
+    /// </summary>
+    /// <param name="vector">要变换的向量。</param>
+    /// <returns>变换后的向量。</returns>
+    public Vector2D Transform(Vector2D vector)
     {
         var sin = Rotation.Sin();
         var cos = Rotation.Cos();
-        return new Point2D(
-            Scaling * (cos * point.X - sin * point.Y) + Translation.X,
-            (IsYScaleNegative ? -1 : 1) * Scaling * (sin * point.X + cos * point.Y) + Translation.Y
-        );
+
+        return IsYScaleNegative
+            ? new Vector2D(
+                Scaling * (cos * vector.X + sin * vector.Y),
+                Scaling * (sin * vector.X - cos * vector.Y)
+            )
+            : new Vector2D(
+                Scaling * (cos * vector.X - sin * vector.Y),
+                Scaling * (sin * vector.X + cos * vector.Y)
+            );
     }
 
     /// <summary>
@@ -169,16 +185,38 @@ public SimilarityTransformation2D Inverse()
     {
         var sin = Rotation.Sin();
         var cos = Rotation.Cos();
+        var yScaleFactor = IsYScaleNegative ? -1 : 1;
         return this with
         {
             Scaling = 1 / Scaling,
-            Rotation = (-Rotation).Normalized,
+            Rotation = (yScaleFactor * -Rotation).Normalized,
+            IsYScaleNegative = IsYScaleNegative,
             Translation = new Vector2D(
                 -(cos * Translation.X + sin * Translation.Y) / Scaling,
-                (IsYScaleNegative ? -1 : 1) * (sin * Translation.X - cos * Translation.Y) / Scaling),
+                yScaleFactor * (sin * Translation.X - cos * Translation.Y) / Scaling),
         };
     }
 
+    /// <summary>
+    /// 应用另一个相似变换到当前相似变换上。
+    /// </summary>
+    /// <remarks>
+    /// 使用应用后的结果对目标进行变换时，相当于使用当前变换对目标进行变换，然后再使用 <paramref name="transformation"/> 对变换后的目标进行变换。
+    /// </remarks>
+    /// <param name="transformation">要应用的相似变换。</param>
+    /// <returns>应用后的相似变换。</returns>
+    public SimilarityTransformation2D Apply(SimilarityTransformation2D transformation)
+    {
+        ArgumentNullException.ThrowIfNull(transformation);
+
+        var yScaleFactor = transformation.IsYScaleNegative ? -1 : 1;
+        return new SimilarityTransformation2D(
+            Scaling * transformation.Scaling,
+            IsYScaleNegative ^ transformation.IsYScaleNegative,
+            yScaleFactor * Rotation + transformation.Rotation,
+            transformation.Transform(Translation) + transformation.Translation);
+    }
+
     #endregion
 }