Deprecate transform(), replace with call.

Author: Andy Ferris

README.md

@@ -7,15 +7,15 @@ networks of coordinate system transformations. Transformations can be easily
 applied, inverted, composed, and differentiated (both with respect to the
 input coordinates and with respect to transformation parameters such as rotation
 angle). Transformations are designed to be light-weight and efficient enough
-for, e.g., real-time  graphical applications, while support for both explicit
+for, e.g., real-time graphical applications, while support for both explicit
 and automatic differentiation makes it easy to perform optimization and
 therefore ideal for computer vision applications such as SLAM (simultaneous
 localization and mapping).
 
 The package provide two main pieces of functionality
 
 1. Primarily, an interface for defining `Transformation`s and applying
-   (`transform()`), inverting (`inv()`), composing (`∘` or `compose()`) and
+   (by calling), inverting (`inv()`), composing (`∘` or `compose()`) and
    differentiating (`transform_deriv()` and `transform_deriv_params()`) them.
 
 2. A small set of built-in, composable, primitive transformations for
@@ -29,27 +29,27 @@ Let's rotate a 2D point:
 x = Point(1.0, 2.0) # Point is provided by FixedSizeArrays
 rot = Rotation2D(0.3) # a rotation by 0.3 radians anticlockwise about the origin
 
-y = transform(rot, x)
+y = rot(x)
 ```
 
 We can either apply transformations in turn,
 ```julia
 trans = Translation(3.5, 1.5)
 
-z = transform(trans, transform(rot, x))
+z = trans(rot(x))
 ```
 or build a composed transformation:
 ```julia
 composed = trans ∘ rot # or compose(trans, rot)
 
-transform(composed, x) == z
+composed(x) == z
 ```
 
 We can invert it:
 ```julia
 composed_inv = inv(composed)
 
-transform(composed_inv, z) == x
+composed_inv(z) == x
 ```
 
 Finally, we can construct a matrix describing how the components of `z`

REQUIRE

@@ -1,3 +1,4 @@
 julia 0.4
+Compat
 FixedSizeArrays 0.2.2
 Rotations

src/CoordinateTransformations.jl

@@ -1,5 +1,6 @@
 module CoordinateTransformations
 
+using Compat
 using FixedSizeArrays
 export Point # Use Point{N, T} from FixedSizedArrays for Cartesian frames
 

src/commontransformations.jl

@@ -16,11 +16,11 @@ Translation(x,y) = Translation(Vec(x,y))
 Translation(x,y,z) = Translation(Vec(x,y,z))
 Base.show(io::IO, trans::Translation) = print(io, "Translation$((trans.dx...))")
 
-function transform(trans::Translation, x)
+@compat function (trans::Translation)(x)
     x + trans.dx
 end
 
-transform(trans::Translation, x::Tuple) = Tuple(Vec(x) + trans.dx)
+@compat (trans::Translation)(x::Tuple) = Tuple(Vec(x) + trans.dx)
 
 Base.inv(trans::Translation) = Translation(-trans.dx)
 
@@ -60,28 +60,28 @@ function Rotation2D(a)
 end
 
 # A variety of specializations for all occassions!
-function transform(trans::Rotation2D, x::FixedVector{2})
+@compat function (trans::Rotation2D)(x::FixedVector{2})
     (sincos, x2) = promote(Vec(trans.sin, trans.cos), x)
     (typeof(x2))(x[1]*sincos[2] - x[2]*sincos[1], x[1]*sincos[1] + x[2]*sincos[2])
 end
 
-transform(trans::Rotation2D, x::NTuple{2})             = (x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos)
-transform{T1,T2}(trans::Rotation2D{T1}, x::Vector{T2}) = [x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos]
+@compat (trans::Rotation2D)(x::NTuple{2})             = (x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos)
+@compat (trans::Rotation2D{T1}){T1,T2}(x::Vector{T2}) = [x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos]
 
 # E.g. for ArrayFire, this might work better than the below?
-function transform{T1,T2}(trans::Rotation2D{T1}, x::AbstractVector{T2})
+@compat function (trans::Rotation2D{T1}){T1,T2}(x::AbstractVector{T2})
     out = similar(x, promote_type(T1,T2))
     out[1] = x[1]*trans.cos - x[2]*trans.sin
     out[2] = x[1]*trans.sin + x[2]*trans.cos
     return out
 end
 
-function transform(trans::Rotation2D, x)
+@compat function (trans::Rotation2D)(x)
     [ trans.cos -trans.sin;
       trans.sin  trans.cos ] * x
 end
 
-function transform(trans::Rotation2D, x::Polar)
+@compat function (trans::Rotation2D)(x::Polar)
     Polar(x.r, x.θ + trans.angle)
 end
 
@@ -163,16 +163,16 @@ Base.isapprox(a::Rotation, b::Rotation; kwargs...) = isapprox(a.matrix, b.matrix
 Base.isapprox{T}(a::Rotation{T}, b::Rotation{T}; kwargs...) = isapprox(a.matrix, b.matrix; kwargs...) && isapprox(a.rotation, b.rotation; kwargs...)
 Base.isapprox(a::Rotation{Void}, b::Rotation{Void}; kwargs...) = isapprox(a.matrix, b.matrix; kwargs...)
 
-function transform(trans::Rotation, x)
+@compat function (trans::Rotation)(x)
     trans.matrix * x
 end
 
-function transform(trans::Rotation, x::FixedVector{3})
+@compat function (trans::Rotation)(x::FixedVector{3})
     (m, x2) = promote(trans.matrix, x)
     (typeof(x2))(m * Vec(x2))
 end
 
-transform(trans::Rotation, x::Tuple) = Tuple(transform(trans, Vec(x)))
+@compat (trans::Rotation)(x::Tuple) = Tuple(trans(Vec(x)))
 
 transform_deriv(trans::Rotation, x) = trans.matrix # It's a linear transformation, so this is easy!
 
@@ -323,13 +323,13 @@ Base.show(io::IO, r::RotationYZ) = print(io, "RotationYZ($(r.angle))")
 Base.show(io::IO, r::RotationZX) = print(io, "RotationZX($(r.angle))")
 
 # It's a little fiddly to support all possible point container types, but this should do a good majority of them!
-transform(trans::RotationXY, x::Vector) =    [x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos, x[3]]
-transform(trans::RotationXY, x::NTuple{3}) = (x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos, x[3])
-function transform(trans::RotationXY, x::FixedVector{3})
+@compat (trans::RotationXY)(x::Vector) =    [x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos, x[3]]
+@compat (trans::RotationXY)(x::NTuple{3}) = (x[1]*trans.cos - x[2]*trans.sin, x[1]*trans.sin + x[2]*trans.cos, x[3])
+@compat function (trans::RotationXY)(x::FixedVector{3})
     (sincos, x2) = promote(Vec(trans.sin, trans.cos), x)
     (typeof(x2))(x[1]*sincos[2] - x[2]*sincos[1], x[1]*sincos[1] + x[2]*sincos[2], x2[3])
 end
-function transform{T}(trans::RotationXY{T}, x)
+@compat function (trans::RotationXY{T}){T}(x)
     Z = zero(T)
     I = one(T)
 
@@ -338,13 +338,13 @@ function transform{T}(trans::RotationXY{T}, x)
     Z          Z         I ] * x
 end
 
-transform(trans::RotationYZ, x::Vector) =    [x[1], x[2]*trans.cos - x[3]*trans.sin, x[2]*trans.sin + x[3]*trans.cos]
-transform(trans::RotationYZ, x::NTuple{3}) = (x[1], x[2]*trans.cos - x[3]*trans.sin, x[2]*trans.sin + x[3]*trans.cos)
-function transform(trans::RotationYZ, x::FixedVector{3})
+@compat (trans::RotationYZ)(x::Vector) =    [x[1], x[2]*trans.cos - x[3]*trans.sin, x[2]*trans.sin + x[3]*trans.cos]
+@compat (trans::RotationYZ)(x::NTuple{3}) = (x[1], x[2]*trans.cos - x[3]*trans.sin, x[2]*trans.sin + x[3]*trans.cos)
+@compat function (trans::RotationYZ)(x::FixedVector{3})
     (sincos, x2) = promote(Vec(trans.sin, trans.cos), x)
     (typeof(x2))(x2[1], x[2]*sincos[2] - x[3]*sincos[1], x[2]*sincos[1] + x[3]*sincos[2])
 end
-function transform{T}(trans::RotationYZ{T}, x)
+@compat function (trans::RotationYZ{T}){T}(x)
     Z = zero(T)
     I = one(T)
 
@@ -353,13 +353,13 @@ function transform{T}(trans::RotationYZ{T}, x)
      Z trans.sin  trans.cos] * x
 end
 
-transform(trans::RotationZX, x::Vector) =    [x[3]*trans.sin + x[1]*trans.cos, x[2], x[3]*trans.cos - x[1]*trans.sin]
-transform(trans::RotationZX, x::NTuple{3}) = (x[3]*trans.sin + x[1]*trans.cos, x[2], x[3]*trans.cos - x[1]*trans.sin)
-function transform(trans::RotationZX, x::FixedVector{3})
+@compat (trans::RotationZX)(x::Vector) =    [x[3]*trans.sin + x[1]*trans.cos, x[2], x[3]*trans.cos - x[1]*trans.sin]
+@compat (trans::RotationZX)(x::NTuple{3}) = (x[3]*trans.sin + x[1]*trans.cos, x[2], x[3]*trans.cos - x[1]*trans.sin)
+@compat function (trans::RotationZX)(x::FixedVector{3})
     (sincos, x2) = promote(Vec(trans.sin, trans.cos), x)
     (typeof(x2))(x[3]*sincos[1] + x[1]*sincos[2], x2[2], x[3]*sincos[2] - x[1]*sincos[1])
 end
-function transform{T}(trans::RotationZX{T}, x)
+@compat function (trans::RotationZX{T}){T}(x)
     Z = zero(T)
     I = one(T)
 

src/coordinatesystems.jl

@@ -21,7 +21,7 @@ immutable CartesianFromPolar <: Transformation; end
 Base.show(io::IO, trans::PolarFromCartesian) = print(io, "PolarFromCartesian()")
 Base.show(io::IO, trans::CartesianFromPolar) = print(io, "CartesianFromPolar()")
 
-function transform(::PolarFromCartesian, x)
+@compat function (::PolarFromCartesian)(x)
     length(x) == 2 || error("Polar transform takes a 2D coordinate")
 
     Polar(sqrt(x[1]*x[1] + x[2]*x[2]), atan2(x[2], x[1]))
@@ -38,7 +38,7 @@ function transform_deriv(::PolarFromCartesian, x)
 end
 transform_deriv_params(::PolarFromCartesian, x) = error("PolarFromCartesian has no parameters")
 
-function transform(::CartesianFromPolar, x::Polar)
+@compat function (::CartesianFromPolar)(x::Polar)
     Point(x.r * cos(x.θ), x.r * sin(x.θ))
 end
 function transform_deriv(::CartesianFromPolar, x::Polar)
@@ -105,7 +105,7 @@ Base.show(io::IO, trans::CylindricalFromSpherical) = print(io, "CylindricalFromS
 Base.show(io::IO, trans::SphericalFromCylindrical) = print(io, "SphericalFromCylindrical()")
 
 # Cartesian <-> Spherical
-function transform(::SphericalFromCartesian, x)
+@compat function (::SphericalFromCartesian)(x)
     length(x) == 3 || error("Spherical transform takes a 3D coordinate")
 
     Spherical(sqrt(x[1]*x[1] + x[2]*x[2] + x[3]*x[3]), atan2(x[2],x[1]), atan(x[3]/sqrt(x[1]*x[1] + x[2]*x[2])))
@@ -126,7 +126,7 @@ function transform_deriv(::SphericalFromCartesian, x)
 end
 transform_deriv_params(::SphericalFromCartesian, x) = error("SphericalFromCartesian has no parameters")
 
-function transform(::CartesianFromSpherical, x::Spherical)
+@compat function (::CartesianFromSpherical)(x::Spherical)
     Point(x.r * cos(x.θ) * cos(x.ϕ), x.r * sin(x.θ) * cos(x.ϕ), x.r * sin(x.ϕ))
 end
 function transform_deriv{T}(::CartesianFromSpherical, x::Spherical{T})
@@ -142,7 +142,7 @@ end
 transform_deriv_params(::CartesianFromSpherical, x::Spherical) = error("CartesianFromSpherical has no parameters")
 
 # Cartesian <-> Cylindrical
-function transform(::CylindricalFromCartesian, x)
+@compat function (::CylindricalFromCartesian)(x)
     length(x) == 3 || error("Cylindrical transform takes a 3D coordinate")
 
     Cylindrical(sqrt(x[1]*x[1] + x[2]*x[2]), atan2(x[2],x[1]), x[3])
@@ -161,7 +161,7 @@ function transform_deriv(::CylindricalFromCartesian, x)
 end
 transform_deriv_params(::CylindricalFromCartesian, x) = error("CylindricalFromCartesian has no parameters")
 
-function transform(::CartesianFromCylindrical, x::Cylindrical)
+@compat function (::CartesianFromCylindrical)(x::Cylindrical)
     Point(x.r * cos(x.θ), x.r * sin(x.θ), x.z)
 end
 function transform_deriv{T}(::CartesianFromCylindrical, x::Cylindrical{T})
@@ -174,21 +174,21 @@ end
 transform_deriv_params(::CartesianFromPolar, x::Cylindrical) = error("CartesianFromCylindrical has no parameters")
 
 # Spherical <-> Cylindrical (TODO direct would be faster)
-function transform(::CylindricalFromSpherical, x::Spherical)
-    transform(CylindricalFromCartesian() , transform(CartesianFromSpherical(), x))
+@compat function (::CylindricalFromSpherical)(x::Spherical)
+    CylindricalFromCartesian()(CartesianFromSpherical()(x))
 end
 function transform_deriv(::CylindricalFromSpherical, x::Spherical)
-    M1 = transform_deriv(CylindricalFromCartesian(), transform(CartesianFromSpherical(), x))
+    M1 = transform_deriv(CylindricalFromCartesian(), CartesianFromSpherical()(x))
     M2 = transform_deriv(CartesianFromSpherical(), x)
     return M1*M2
 end
 transform_deriv_params(::CylindricalFromSpherical, x::Spherical) = error("CylindricalFromSpherical has no parameters")
 
-function transform(::SphericalFromCylindrical, x::Cylindrical)
-    transform(SphericalFromCartesian() , transform(CartesianFromCylindrical(), x))
+@compat function (::SphericalFromCylindrical)(x::Cylindrical)
+    SphericalFromCartesian()(CartesianFromCylindrical()(x))
 end
 function transform_deriv(::SphericalFromCylindrical, x::Cylindrical)
-    M1 = transform_deriv(SphericalFromCartesian(), transform(CartesianFromCylindrical(), x))
+    M1 = transform_deriv(SphericalFromCartesian(), CartesianFromCylindrical()(x))
     M2 = transform_deriv(CartesianFromCylindrical(), x)
     return M1*M2
 end

src/core.jl

@@ -8,30 +8,21 @@
 """
 The `Transformation` supertype defines a simple interface for performing
 transformations. Subtypes should be able to apply a coordinate system
-transformation on the correct data types by overloading `transform()`, and
+transformation on the correct data types by overloading the call method, and
 usually would have the corresponding inverse transformation defined by `Base.inv()`.
 Efficient compositions can optionally be defined by `compose()` (equivalently `∘`).
 """
 abstract Transformation
 
+Base.@deprecate transform(transformation::Transformation, x) transformation(x)
+
 """
 The `IdentityTransformation` is a singleton `Transformation` that returns the
 input unchanged, similar to `identity`.
 """
 immutable IdentityTransformation <: Transformation; end
 
-"""
-    transform(trans::Transformation, x)
-
-A transformation `trans` is explicitly applied to data x, returning the
-coordinates in the new coordinate system.
-"""
-function transform(trans::Transformation, x)
-    error("The transform of datatype $(typeof(x)) is not defined for transformation $trans.")
-end
-
-@inline transform(::IdentityTransformation, x) = x
-
+@compat @inline (::IdentityTransformation)(x) = x
 
 """
 A `ComposedTransformation` simply executes two transformations successively, and
@@ -44,8 +35,8 @@ end
 
 Base.show(io::IO, trans::ComposedTransformation) = print(io, "($(trans.t1) ∘ $(trans.t2))")
 
-@inline function transform(trans::ComposedTransformation, x)
-    transform(trans.t1, transform(trans.t2, x))
+@compat @inline function (trans::ComposedTransformation)(x)
+    trans.t1(trans.t2(x))
 end
 
 """
@@ -66,7 +57,7 @@ compose(trans::IdentityTransformation, ::IdentityTransformation) = trans
 compose(::IdentityTransformation, trans::Transformation) = trans
 compose(trans::Transformation, ::IdentityTransformation) = trans
 
-const ∘ = compose
+const ∘ = compose # TODO watch JuliaLang/julia#17184 and #17155 for v0.5 compatibility
 
 
 """
@@ -93,7 +84,7 @@ transform_deriv(::Transformation, x) = error("Differential matrix of transform $
 transform_deriv(::IdentityTransformation, x) = I
 
 function transform_deriv(trans::ComposedTransformation, x)
-    x2 = transform(trans.t2, x)
+    x2 = trans.t2(x)
     m1 = transform_deriv(trans.t1, x2)
     m2 = transform_deriv(trans.t2, x)
     return m1 * m2
@@ -111,7 +102,7 @@ transform_deriv(::Transformation, x) = error("Differential matrix of parameters
 transform_deriv_params(::IdentityTransformation, x) = error("IdentityTransformation has no parameters")
 
 function transform_deriv_params(trans::ComposedTransformation, x)
-    x2 = transform(trans.t2, x)
+    x2 = trans.t2(x)
     m1 = transform_deriv(trans.t1, x2)
     p2 = transform_deriv_params(trans.t2, x)
     p1 = transform_deriv_params(trans.t1, x2)