Move to Meshes.jl

Author: juliohm

Project.toml

@@ -6,10 +6,10 @@ version = "0.2.6"
 [deps]
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 GeoStatsBase = "323cb8eb-fbf6-51c0-afd0-f8fba70507b2"
-RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
+Meshes = "eacbb407-ea5a-433e-ab97-5258b1ca43fa"
 
 [compat]
 Distributions = "0.21, 0.22, 0.23, 0.24"
 GeoStatsBase = "0.17"
-RecipesBase = "0.7, 0.8, 1.0"
-julia = "1.4"
+Meshes = "0.9"
+julia = "1.5"

src/PointPatterns.jl

@@ -4,26 +4,15 @@
 
 module PointPatterns
 
+using Meshes
 using GeoStatsBase
 
 using Distributions
-using RecipesBase
 
-import GeoStatsBase: coordinates
-
-include("pattern.jl")
 include("processes.jl")
 include("thinning.jl")
 
-# plot recipes
-include("plotrecipes/pattern.jl")
-
 export
-  # point pattern
-  PointPattern,
-  npoints,
-  coordinates,
-
   # point processes
   PointProcess,
   BinomialProcess,

src/pattern.jl

@@ -17,35 +17,35 @@ Tells whether or not the spatial point process `p` is homogeneous.
 ishomogeneous(p::PointProcess) = false
 
 """
-    rand(p, r, n=1; [algo])
+    rand(p, g, n=1; [algo])
 
 Generate `n` realizations of spatial point process `p`
-inside spatial region `r`. Optionally specify sampling
+inside geometry `g`. Optionally specify sampling
 algorithm `algo`.
 """
-Base.rand(p::PointProcess, r::AbstractGeometry, n::Int;
+Base.rand(p::PointProcess, g::Geometry, n::Int;
           algo=default_sampling_algorithm(p)) =
-  [rand_single(p, r, algo) for i in 1:n]
+  [rand_single(p, g, algo) for i in 1:n]
 
-Base.rand(p::PointProcess, r::AbstractGeometry;
+Base.rand(p::PointProcess, g::Geometry;
           algo=default_sampling_algorithm(p)) =
-  rand_single(p, r, algo)
+  rand_single(p, g, algo)
 
 """
-    rand_single(p, r, algo)
+    rand_single(p, g, algo)
 
 Generate a single realization of spatial point process
-`p` inside spatial region `r` with sampling `algo`.
+`p` inside geometry `g` with sampling `algo`.
 """
-rand_single(p::PointProcess, r::AbstractGeometry, algo) =
+rand_single(::PointProcess, ::Geometry, algo) =
   @error "not implemented"
 
 """
     default_sampling_algorithm(p)
 
 Default sampling algorithm for spatial point process `p`.
 """
-default_sampling_algorithm(p::PointProcess) = @error "not implemented"
+default_sampling_algorithm(::PointProcess) = @error "not implemented"
 
 """
     p₁ ∪ p₂
@@ -59,4 +59,4 @@ Base.union(p₁::PointProcess, p₂::PointProcess) = UnionProcess(p₁, p₂)
 #-----------------
 include("processes/binomial.jl")
 include("processes/poisson.jl")
-include("processes/union.jl")
+include("processes/union.jl")

src/plotrecipes/pattern.jl

@@ -17,14 +17,14 @@ struct BinomialSampling end
 
 default_sampling_algorithm(::BinomialProcess) = BinomialSampling()
 
-function rand_single(p::BinomialProcess, r::Rectangle{T,N},
-                     algo::BinomialSampling) where {N,T}
+function rand_single(p::BinomialProcess, b::Box{Dim,T},
+                     ::BinomialSampling) where {Dim,T}
   # region configuration
-  lo, up = extrema(r)
+  lo, up = coordinates.(extrema(b))
 
   # product of uniform distributions
-  U = product_distribution([Uniform(lo[i], up[i]) for i in 1:N])
+  U = product_distribution([Uniform(lo[i], up[i]) for i in 1:Dim])
 
   # return point pattern
-  PointPattern(rand(U, p.n))
+  PointSet(rand(U, p.n))
 end

src/processes.jl

@@ -24,27 +24,27 @@ default_sampling_algorithm(::PoissonProcess{<:Function}) = DiscretizedSampling()
 #------------------
 # HOMOGENEOUS CASE
 #------------------
-function rand_single(p::PoissonProcess{<:Real}, r::Rectangle{T,N},
-                     algo::ProductSampling) where {N,T}
+function rand_single(p::PoissonProcess{<:Real}, b::Box{Dim,T},
+                     ::ProductSampling) where {Dim,T}
   # region configuration
-  lo, up = extrema(r)
+  lo, up = coordinates.(extrema(b))
 
   # simulate number of points
-  λ = p.λ; V = volume(r)
+  λ = p.λ; V = measure(b)
   n = rand(Poisson(λ*V))
 
   # product of uniform distributions
-  U = product_distribution([Uniform(lo[i], up[i]) for i in 1:N])
+  U = product_distribution([Uniform(lo[i], up[i]) for i in 1:Dim])
 
   # return point pattern
-  PointPattern(rand(U, n))
+  PointSet(rand(U, n))
 end
 
 #--------------------
 # INHOMOGENEOUS CASE
 #--------------------
-function rand_single(p::PoissonProcess{<:Function}, r::Rectangle{T,N},
-                     algo::DiscretizedSampling) where {N,T}
+function rand_single(p::PoissonProcess{<:Function}, g::Box{Dim,T},
+                     algo::DiscretizedSampling) where {Dim,T}
   # discretize region
   # TODO
 
@@ -55,8 +55,8 @@ function rand_single(p::PoissonProcess{<:Function}, r::Rectangle{T,N},
   # TODO
 end
 
-function rand_single(p::PoissonProcess{<:Function}, r::Rectangle{T,N},
-                     algo::ThinnedSampling) where {N,T}
+function rand_single(p::PoissonProcess{<:Function}, b::Box{Dim,T},
+                     algo::ThinnedSampling) where {Dim,T}
   # Lewis-Shedler algorithm
   # TODO
 end

src/processes/binomial.jl

@@ -18,12 +18,12 @@ struct UnionSampling end
 
 default_sampling_algorithm(::UnionProcess) = UnionSampling()
 
-function rand_single(p::UnionProcess, r::AbstractGeometry, algo::UnionSampling)
+function rand_single(p::UnionProcess, ::Geometry, algo::UnionSampling)
   pp₁ = rand(p.p₁, r)
   pp₂ = rand(p.p₂, r)
 
   X = coordinates(pp₁)
   Y = coordinates(pp₂)
 
-  PointPattern(hcat(X, Y))
+  PointSet(hcat(X, Y))
 end

src/processes/poisson.jl

@@ -21,7 +21,7 @@ thin(p::PointProcess, t::AbstractThinning) = @error "not implemented"
 
 Thin spatial point pattern `pp` with thinning method `t`.
 """
-thin(pp::PointPattern, t::AbstractThinning) = @error "not implemented"
+thin(pp::PointSet, t::AbstractThinning) = @error "not implemented"
 
 #-----------------
 # IMPLEMENTATIONS

src/processes/union.jl

@@ -29,19 +29,19 @@ thin(p::PoissonProcess{<:Function}, t::RandomThinning{<:Real}) =
 # -----------------------
 # thinning point pattern
 # -----------------------
-function thin(pp::PointPattern{T,N}, t::RandomThinning{<:Real}) where {N,T}
-  draws = rand(Bernoulli(t.p), npoints(pp))
+function thin(pp::PointSet, t::RandomThinning{<:Real})
+  draws = rand(Bernoulli(t.p), nelements(pp))
   inds  = findall(isequal(1), draws)
-  PointPattern(coordinates(pp, inds))
+  PointSet(coordinates(pp, inds))
 end
 
-function thin(pp::PointPattern{T,N}, t::RandomThinning{<:Function}) where {N,T}
+function thin(pp::PointSet, t::RandomThinning{<:Function})
   inds = Vector{Int}()
-  for j in 1:npoints(pp)
+  for j in 1:nelements(pp)
     x = coordinates(pp, j)
     if rand(Bernoulli(t.p(x)))
       push!(inds, j)
     end
   end
-  PointPattern(coordinates(pp, inds))
+  PointSet(coordinates(pp, inds))
 end