RegularGrid: Add more constructors (#1066)

* 'RegularGrid': Add more constructors

* Update code

* Update code

* Update 'CartesianGrid' constructors

* Update code

* Update code order

* Add tests

Author: eliascarv

src/domains/meshes/cartesiangrid.jl

@@ -56,41 +56,19 @@ See also [`RegularGrid`](@ref).
 """
 const CartesianGrid{M<:𝔼,C<:Cartesian} = RegularGrid{M,C}
 
-function CartesianGrid(
-  origin::Point{<:𝔼},
-  spacing::NTuple{Dim,ℒ},
-  offset::Dims{Dim},
-  topology::GridTopology{Dim}
-) where {Dim,ℒ<:Len}
-  orig = Point(convert(Cartesian, coords(origin)))
-  RegularGrid(orig, spacing, offset, topology)
-end
-
-CartesianGrid(
-  origin::Point{<:𝔼},
-  spacing::NTuple{Dim,Len},
-  offset::Dims{Dim},
-  topology::GridTopology{Dim}
-) where {Dim} = CartesianGrid(origin, promote(spacing...), offset, topology)
-
 CartesianGrid(
-  origin::Point{<:𝔼},
+  origin::Point{𝔼{Dim}},
   spacing::NTuple{Dim,Number},
   offset::Dims{Dim},
   topology::GridTopology{Dim}
-) where {Dim} = CartesianGrid(origin, addunit.(spacing, u"m"), offset, topology)
+) where {Dim} = RegularGrid(_cartpoint(origin), spacing, offset, topology)
 
-function CartesianGrid(
+CartesianGrid(
   dims::Dims{Dim},
-  origin::Point,
+  origin::Point{𝔼{Dim}},
   spacing::NTuple{Dim,Number},
   offset::Dims{Dim}=ntuple(i -> 1, Dim)
-) where {Dim}
-  if !all(>(0), dims)
-    throw(ArgumentError("dimensions must be positive"))
-  end
-  CartesianGrid(origin, spacing, offset, GridTopology(dims))
-end
+) where {Dim} = RegularGrid(dims, _cartpoint(origin), spacing, offset)
 
 CartesianGrid(
   dims::Dims{Dim},
@@ -99,28 +77,14 @@ CartesianGrid(
   offset::Dims{Dim}=ntuple(i -> 1, Dim)
 ) where {Dim} = CartesianGrid(dims, Point(origin), spacing, offset)
 
-function CartesianGrid(start::Point, finish::Point, spacing::NTuple{Dim,ℒ}) where {Dim,ℒ<:Len}
-  dims = Tuple(ceil.(Int, (finish - start) ./ spacing))
-  origin = start
-  offset = ntuple(i -> 1, Dim)
-  CartesianGrid(dims, origin, spacing, offset)
-end
-
-CartesianGrid(start::Point, finish::Point, spacing::NTuple{Dim,Len}) where {Dim} =
-  CartesianGrid(start, finish, promote(spacing...))
-
-CartesianGrid(start::Point, finish::Point, spacing::NTuple{Dim,Number}) where {Dim} =
-  CartesianGrid(start, finish, addunit.(spacing, u"m"))
+CartesianGrid(start::Point{𝔼{Dim}}, finish::Point{𝔼{Dim}}, spacing::NTuple{Dim,Number}) where {Dim} =
+  RegularGrid(_cartpoint(start), _cartpoint(finish), spacing)
 
 CartesianGrid(start::NTuple{Dim,Number}, finish::NTuple{Dim,Number}, spacing::NTuple{Dim,Number}) where {Dim} =
   CartesianGrid(Point(start), Point(finish), spacing)
 
-function CartesianGrid(start::Point, finish::Point; dims::Dims=ntuple(i -> 100, embeddim(start)))
-  origin = start
-  spacing = Tuple((finish - start) ./ dims)
-  offset = ntuple(i -> 1, length(dims))
-  CartesianGrid(dims, origin, spacing, offset)
-end
+CartesianGrid(start::Point{𝔼{Dim}}, finish::Point{𝔼{Dim}}; dims::Dims{Dim}=ntuple(i -> 100, Dim)) where {Dim} =
+  RegularGrid(_cartpoint(start), _cartpoint(finish); dims)
 
 CartesianGrid(
   start::NTuple{Dim,Number},
@@ -136,3 +100,9 @@ function CartesianGrid(dims::Dims{Dim}) where {Dim}
 end
 
 CartesianGrid(dims::Int...) = CartesianGrid(dims)
+
+# -----------------
+# HELPER FUNCTIONS
+# -----------------
+
+_cartpoint(p) = Point(convert(Cartesian, coords(p)))

src/domains/meshes/regulargrid.jl

@@ -13,6 +13,16 @@ and cell spacing `spacing`. The three arguments must have the same length.
 A regular grid with dimensions `dims`, with lower left corner of element
 `offset` at `origin` and cell spacing `spacing`.
 
+    RegularGrid(start, finish, dims=dims)
+
+Alternatively, construct a regular grid from a `start` point to a `finish`
+with dimensions `dims`.
+
+    RegularGrid(start, finish, spacing)
+
+Alternatively, construct a regular grid from a `start` point to a `finish`
+point using a given `spacing`.
+
 ## Examples
 
 ```
@@ -44,13 +54,9 @@ function RegularGrid(
   offset::Dims{N},
   topology::GridTopology{N}
 ) where {M<:Manifold,C<:CRS,N}
-  if M <: 🌐 && !(C <: LatLon)
-    throw(ArgumentError("regular spacing on `🌐` requires `LatLon` coordinates"))
-  end
+  _checkorigin(origin)
 
-  T = CoordRefSystems.mactype(C)
   nc = CoordRefSystems.ncoords(C)
-  us = CoordRefSystems.units(C)
 
   if N ≠ nc
     throw(ArgumentError("""
@@ -59,9 +65,9 @@ function RegularGrid(
     """))
   end
 
-  sp = ntuple(i -> numconvert(T, withunit(spacing[i], us[i])), nc)
+  spac = _spacing(origin, spacing)
 
-  RegularGrid{M,C,N,typeof(sp)}(origin, sp, offset, topology)
+  RegularGrid{M,C,N,typeof(spac)}(origin, spac, offset, topology)
 end
 
 function RegularGrid(
@@ -76,6 +82,21 @@ function RegularGrid(
   RegularGrid(origin, spacing, offset, GridTopology(dims))
 end
 
+function RegularGrid(start::Point, finish::Point, spacing::NTuple{N,Number}) where {N}
+  _checkorigin(start)
+  svals, fvals = _startfinish(start, finish)
+  spac = _spacing(start, spacing)
+  dims = ceil.(Int, (fvals .- svals) ./ spac)
+  RegularGrid(dims, start, spac)
+end
+
+function RegularGrid(start::Point, finish::Point; dims::Dims=ntuple(i -> 100, CoordRefSystems.ncoords(crs(start))))
+  _checkorigin(start)
+  svals, fvals = _startfinish(start, finish)
+  spacing = (fvals .- svals) ./ dims
+  RegularGrid(dims, start, spacing)
+end
+
 spacing(g::RegularGrid) = g.spacing
 
 offset(g::RegularGrid) = g.offset
@@ -132,3 +153,38 @@ function Base.show(io::IO, ::MIME"text/plain", g::RegularGrid)
   println(io, "├─ maximum: ", maximum(g))
   print(io, "└─ spacing: ", spacing(g))
 end
+
+# -----------------
+# HELPER FUNCTIONS
+# -----------------
+
+function _checkorigin(origin)
+  if manifold(origin) <: 🌐 && !(crs(origin) <: LatLon)
+    throw(ArgumentError("regular spacing on `🌐` requires `LatLon` coordinates"))
+  end
+end
+
+function _spacing(origin, spacing)
+  C = crs(origin)
+  T = CoordRefSystems.mactype(C)
+  nc = CoordRefSystems.ncoords(C)
+  us = CoordRefSystems.units(C)
+  ntuple(i -> numconvert(T, withunit(spacing[i], us[i])), nc)
+end
+
+function _startfinish(start::Point{<:𝔼}, finish::Point{<:𝔼})
+  scoords = coords(start)
+  fcoords = convert(crs(start), coords(finish))
+  svals = CoordRefSystems.values(scoords)
+  fvals = CoordRefSystems.values(fcoords)
+  svals, fvals
+end
+
+function _startfinish(start::Point{<:🌐}, finish::Point{<:🌐})
+  slatlon = convert(LatLon, coords(start))
+  flatlon = convert(LatLon, coords(finish))
+  slon = flatlon.lon < slatlon.lon ? slatlon.lon - 360u"°" : slatlon.lon
+  svals = (slatlon.lat, slon)
+  fvals = (flatlon.lat, flatlon.lon)
+  svals, fvals
+end

test/meshes.jl

@@ -67,6 +67,31 @@
   @test grid[1, 1, 1] == grid[1]
   @test grid[10, 20, 30] == grid[6000]
 
+  # constructors with start and finish
+  grid = RegularGrid(merc(0, 0), merc(10, 10), T.((0.1, 0.1)))
+  @test size(grid) == (100, 100)
+  @test minimum(grid) == merc(0, 0)
+  @test maximum(grid) == merc(10, 10)
+  @test spacing(grid) == (T(0.1) * u"m", T(0.1) * u"m")
+
+  grid = RegularGrid(latlon(-50, 150), latlon(50, 30), T.((10, 12)))
+  @test size(grid) == (10, 20)
+  @test minimum(grid) == latlon(-50, 150)
+  @test maximum(grid) == latlon(50, 30)
+  @test spacing(grid) == (T(10) * u"°", T(12) * u"°")
+
+  grid = RegularGrid(merc(0, 0), merc(10, 10), dims=(100, 100))
+  @test size(grid) == (100, 100)
+  @test minimum(grid) == merc(0, 0)
+  @test maximum(grid) == merc(10, 10)
+  @test spacing(grid) == (T(0.1) * u"m", T(0.1) * u"m")
+
+  grid = RegularGrid(latlon(-50, 150), latlon(50, 30), dims=(10, 20))
+  @test size(grid) == (10, 20)
+  @test minimum(grid) == latlon(-50, 150)
+  @test maximum(grid) == latlon(50, 30)
+  @test spacing(grid) == (T(10) * u"°", T(12) * u"°")
+
   # spacing unit and numtype
   grid = RegularGrid((10, 20), Point(Polar(T(0) * u"cm", T(0) * u"rad")), (10.0 * u"mm", 1.0f0 * u"rad"))
   @test unit.(spacing(grid)) == (u"cm", u"rad")