Refactor PointPattern

Author: juliohm

Project.toml

@@ -7,13 +7,11 @@ version = "0.1.0"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 GeoStatsBase = "323cb8eb-fbf6-51c0-afd0-f8fba70507b2"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
-StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 Distributions = "0.21"
 GeoStatsBase = "0.7"
 RecipesBase = "0.7"
-StaticArrays = "0.12"
 julia = "1"
 
 [extras]

src/PointPatterns.jl

@@ -6,11 +6,10 @@ module PointPatterns
 
 using GeoStatsBase
 
-using Distributions: Uniform, Poisson, product_distribution
-using StaticArrays: SVector, MVector
+using Distributions
 using RecipesBase
 
-import GeoStatsBase: npoints, coordinates, coordinates!
+import GeoStatsBase: npoints, coordinates
 
 include("pattern.jl")
 include("processes.jl")
@@ -24,7 +23,6 @@ export
   PointPattern,
   npoints,
   coordinates,
-  coordinates!,
 
   # point processes
   PointProcess,

src/pattern.jl

@@ -20,60 +20,27 @@ PointPattern(coords::AbstractMatrix{T}) where {T} =
 PointPattern(coords::AbstractVector{NTuple{N,T}}) where {N,T} =
   PointPattern([c[i] for i in 1:N, c in coords])
 
-npoints(pp::PointPattern) = size(pp.coords, 2)
-
 """
-    coordinates(pp, ind)
+    npoints(pp)
 
-Return the coordinates of the `ind`-th point in the point pattern `pp`.
+Return number of points in spatial point pattern `pp`.
 """
-function coordinates(pp::PointPattern{T,N}, ind::Int) where {N,T}
-  x = MVector{N,T}(undef)
-  coordinates!(x, pp, ind)
-  x
-end
+npoints(pp::PointPattern) = size(pp.coords, 2)
 
 """
     coordinates(pp, inds)
 
-Return the coordinates of the points `inds` in the point pattern `pp`.
+Return the coordinates of the points at indices `inds` in
+the point pattern `pp`.
 """
-function coordinates(pp::PointPattern{T,N}, inds::AbstractVector{Int}) where {N,T}
-  X = Matrix{T}(undef, N, length(inds))
-  coordinates!(X, pp, inds)
-  X
-end
+coordinates(pp::PointPattern{T,N}, inds) where {N,T} = view(pp.coords, :, inds)
 
 """
     coordinates(pp)
 
 Return the coordinates of all points in point pattern `pp`.
 """
-coordinates(pp::PointPattern) = coordinates(pp, 1:npoints(pp))
-
-"""
-    coordinates!(buff, pp, inds)
-
-Non-allocating version of [`coordinates`](@ref)
-"""
-function coordinates!(buff::AbstractMatrix, pp::PointPattern,
-                      inds::AbstractVector{Int})
-  for j in 1:length(inds)
-    coordinates!(view(buff,:,j), pp, inds[j])
-  end
-end
-
-"""
-    coordinates!(buff, pp, ind)
-
-Non-allocating version of [`coordinates`](@ref).
-"""
-function coordinates!(buff::AbstractVector{T}, pp::PointPattern{T,N},
-                      ind::Int) where {N,T}
-  for i in 1:N
-    @inbounds buff[i] = pp.coords[i,ind]
-  end
-end
+coordinates(pp::PointPattern) = pp.coords
 
 # ------------
 # IO methods

src/thinning.jl

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

src/thinning/random.jl

@@ -11,6 +11,9 @@ struct RandomThinning{P<:Union{Real,Function}} <: AbstractThinning
   p::P
 end
 
+# -----------------------
+# thinning point process
+# -----------------------
 thin(p::PoissonProcess{<:Real}, t::RandomThinning{<:Real}) =
   PoissonProcess(t.p * p.λ)
 
@@ -22,3 +25,10 @@ thin(p::PoissonProcess{<:Real}, t::RandomThinning{<:Function}) =
 
 thin(p::PoissonProcess{<:Function}, t::RandomThinning{<:Real}) =
   PoissonProcess(u -> t.p * p.λ(u))
+
+# -----------------------
+# thinning point pattern
+# -----------------------
+function thin(pp::PointPattern{T,N}, t::RandomThinning{<:Real}) where {N,T}
+  # TODO
+end