Merge pull request #5 from Circuitscape/vl/dev

LightGraphs => Graphs, GeoData => Rasters, some changes to type names

Author: vlandau

Project.toml

@@ -4,11 +4,13 @@ authors = ["Vincent A. Landau <[email protected]>"]
 version = "0.0.1"
 
 [deps]
-GeoData = "9b6fcbb8-86d6-11e9-1ce7-23a6bb139a78"
-LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
+Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
+Rasters = "a3a2b9e3-a471-40c9-b274-f788e487c689"
 SimpleWeightedGraphs = "47aef6b3-ad0c-573a-a1e2-d07658019622"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
+Graphs = "1.4"
+Rasters = "0.1"
 julia = "1.6"

README.md

@@ -5,12 +5,12 @@
 [![docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://docs.circuitscape.org/SpatialGraphs.jl/latest) | [![Build Status](https://github.com/Circuitscape/SpatialGraphs.jl/workflows/CI/badge.svg)](https://github.com/Circuitscape/SpatialGraphs.jl/actions?query=workflow%3ACI) [![codecov](https://codecov.io/gh/Circuitscape/SpatialGraphs.jl/branch/main/graph/badge.svg?token=67OX4UPWOL)](https://codecov.io/gh/Circuitscape/SpatialGraphs.jl)
 
 SpatialGraphs.jl introduces the `AbstractSpatialGraph`. `AbstractSpatialGraphs` 
-are a subtype of `LightGraphs.AbstractGraph`, and can be weighted or directed. 
-AbstractSpatialGraphs are AbstractGraphs, so methods from LightGraphs.jl work right
+are a subtype of `Graphs.AbstractGraph`, and can be weighted or directed. 
+AbstractSpatialGraphs are AbstractGraphs, so methods from Graphs.jl work right
 out of the box.
 
 `AbstractSpatialGraph`s themselves contain an `AbstractGraph` in addition to 
 metadata that details the spatial location of each vertex in the
 graph. At this time, only raster-based graph types have been developed (and 
-vertex locations are stored in a `GeoData.GeoArray`), but there are plans to 
+vertex locations are stored in a `Rasters.Raster`), but there are plans to 
 implement graph types for vector data as well.

docs/src/graphtypes.md

@@ -1,7 +1,7 @@
 # [Graph Types in SpatialGraphs.jl](@id graph_types)
 
 At this time, only raster-based graph types have been developed (and 
-vertex locations are stored in a `GeoData.GeoArray`), but there are plans to 
+vertex locations are stored in a `Rasters.Raster`), but there are plans to 
 eventually implement graph types for vector data as well.
 
 ## Abstract Types
@@ -12,9 +12,9 @@ an `AbstractGraph`.
 AbstractSpatialGraph
 ```
 
-The `AbstractRasterGraph` type is as subtype of `AbstractSpatialGraph`. All
+The `AbstractRasterGraph` type is a subtype of `AbstractSpatialGraph`. All
 `AbstractRasterGraph` subtypes contain a field called `vertex_raster`, which is 
-a `GeoData.GeoArray` that describes the spatial locations for the vertices in 
+a `Rasters.Raster` that describes the spatial locations for the vertices in 
 the graph. If your graph has 10 vertices, then the corresponding `vertex_raster` 
 must have 10 unique values, starting at 1 (which corresponds to the first vertex
 in the graph) and going up to 10 (which corresponds to the tenth vertex in the 
@@ -30,8 +30,8 @@ SpatialGraphs.jl has raster graph types for undirected, directed, unweighted,
 and weighted graphs, each detailed below.
 
 ```@docs
-SimpleRasterGraph
-SimpleRasterDiGraph
+RasterGraph
+RasterDiGraph
 WeightedRasterGraph
 WeightedRasterDiGraph
 ```

docs/src/index.md

@@ -1,10 +1,10 @@
 # SpatialGraphs.jl
 
 SpatialGraphs.jl introduces the `AbstractSpatialGraph`. `AbstractSpatialGraphs` 
-are a subtype of `LightGraphs.AbstractGraph`, and can be weighted or directed.
+are a subtype of `Graphs.AbstractGraph`, and can be weighted or directed.
 SpatialGraphs.jl is useful for turning spatial data into graphs. This can be
 useful for landscape connectivity analysis, hydrology, and other spatial
 network processes. AbstractSpatialGraphs are AbstractGraphs, so methods from 
-LightGraphs.jl work right out of the box. Go to [Graph Types](@ref graph_types) 
+Graphs.jl work right out of the box. Go to [Graph Types](@ref graph_types) 
 for more details on the graph types implemented in this package.
 

docs/src/userguide.md

@@ -7,7 +7,7 @@ data.
 
 ### Simple Graphs
 ```@docs
-simplerastergraph
+rastergraph
 make_simple_raster_graph
 ```
 

src/SpatialGraphs.jl

@@ -1,6 +1,6 @@
 module SpatialGraphs
 
-using LightGraphs, SimpleWeightedGraphs, SparseArrays, GeoData
+using Graphs, SimpleWeightedGraphs, SparseArrays, Rasters
 
 include("structs.jl")
 include("graph_interface.jl")
@@ -9,12 +9,12 @@ include("utils.jl")
 include("show.jl")
 
 ## Types and Structs
-export AbstractSpatialGraph, AbstractRasterGraph, SimpleRasterGraph,
-       SimpleRasterDiGraph, WeightedRasterGraph, WeightedRasterDiGraph
+export AbstractSpatialGraph, AbstractRasterGraph, RasterGraph,
+       RasterDiGraph, WeightedRasterGraph, WeightedRasterDiGraph
 
 ## Raster graph
 export make_weighted_raster_graph, weightedrastergraph,
-    make_simple_raster_graph, simplerastergraph
+    make_simple_raster_graph, rastergraph
 
 
 end # module

src/graph_interface.jl

@@ -1,6 +1,6 @@
-## Methods for the LightGraphs ad SimpleWeightedGraphs interfaces
-## With these methods defined, functions from LightGraphs should "just work"
-import LightGraphs: 
+## Methods for the Graphs ad SimpleWeightedGraphs interfaces
+## With these methods defined, functions from Graphs should "just work"
+import Graphs: 
     nv, ne, vertices, edges, eltype, edgetype, has_edge, has_vertex,
     inneighbors, outneighbors, is_directed, add_edge!
 
@@ -9,7 +9,7 @@ import SimpleWeightedGraphs:
 
 import Base: zero
 
-### LightGraphs interface
+### Graphs interface
 nv(g::AbstractSpatialGraph) = nv(g.graph)
 ne(g::AbstractSpatialGraph) = ne(g.graph)
 vertices(g::AbstractSpatialGraph) = vertices(g.graph)
@@ -22,13 +22,13 @@ inneighbors(g::AbstractSpatialGraph, v) = inneighbors(g.graph, v)
 outneighbors(g::AbstractSpatialGraph, v) = outneighbors(g.graph, v)
 is_directed(g::AbstractSpatialGraph) = is_directed(g.graph)
 function Base.zero(g::AbstractRasterGraph)
-    if g.graph isa SimpleGraph
-        SimpleRasterGraph(
+    if g.graph isa Graph
+        RasterGraph(
             zero(typeof(g.graph)),
             g.vertex_raster
         )
-    elseif g.graph isa SimpleDiGraph
-        SimpleRasterDiGraph(
+    elseif g.graph isa DiGraph
+        RasterDiGraph(
             zero(typeof(g.graph)),
             g.vertex_raster
         )

src/rastergraphs.jl

@@ -1,35 +1,35 @@
 """
-    make_vertex_raster(A::GeoArray)
+    make_vertex_raster(A::Raster)
 
 Constuct a vertex raster (a raster where the value of each pixel corresponds
-to its ID in a graph, and 0s correspond to NoData). Returns a GeoArray. This 
+to its ID in a graph, and 0s correspond to NoData). Returns a Raster. This 
 function is recommended for internal use only.
 
 ## Parameters
-`A`: The GeoArray from which a graph will be built, which is used as the
+`A`: The Raster from which a graph will be built, which is used as the
 reference for building the vertex raster. Pixels with NoData (`A.missingval`)
 are skipped (no vertex is assigned). Pixels with NoData will get a value of 0 in
 the vertex raster.
 """
-function make_vertex_raster(A::GeoData.GeoArray)
+function make_vertex_raster(A::Raster)
     # Make an array of unique node identifiers
     nodemap = zeros(Int64, size(A.data))
     is_node = (A.data .!= A.missingval) .&
         ((!).(isnan.(A.data)))
 
     nodemap[is_node] = 1:sum(is_node)
 
-    nodemap = GeoData.GeoArray(nodemap, dims(A))
+    nodemap = Raster(nodemap, dims(A))
 
     nodemap
 end
 
 
 """
     weightedrastergraph(
-        weight_raster::GeoArray;
+        weight_raster::Raster;
         directed::Bool = false,
-        condition_raster::GeoArray = weight_raster,
+        condition_raster::Raster = weight_raster,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false,
         connect_using_avg_weights::Bool = true
@@ -42,7 +42,7 @@ on vertices, edge weights are calculated as the average of the weights for each
 vertex.
 
 ## Parameters
-`weight_raster`: A GeoData.GeoArray contained values that, where applicable 
+`weight_raster`: A Rasters.Raster contained values that, where applicable 
 based on other arguments, determines which pixels to connect and the edge 
 weights between pixels. Any pixel in `weight_raster` with a value not equal to 
 `weight_raster.missingval` will be assigned a vertex in the graph (corresponding
@@ -90,9 +90,9 @@ neighbors) of the weights  in `weight_raster` is used.
 
 """
 function weightedrastergraph(
-        weight_raster::GeoArray;
+        weight_raster::Raster;
         directed::Bool = false,
-        condition_raster::GeoArray = weight_raster,
+        condition_raster::Raster = weight_raster,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false,
         connect_using_avg_weights::Bool = true
@@ -119,18 +119,18 @@ function weightedrastergraph(
 end
 
 """
-    simplerastergraph(
-        raster::GeoArray;
+    RasterGraph(
+        raster::Raster;
         directed::Bool = true,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false
     )
 
-Construct a `SimpleRasterGraph` or `SimpleRasterDiGraph` (if 
+Construct a `RasterGraph` or `RasterDiGraph` (if 
 `directed = true`) from a raster dataset.
 
 ## Parameters
-`raster`: A GeoData.GeoArray on which to base the graph. Any pixel in `raster` 
+`raster`: A Rasters.Raster on which to base the graph. Any pixel in `raster` 
 with a value not equal to `raster.missingval` will be assigned a vertex
 in the graph (corresponding to its centroid). The values in the raster can also
 be used to determine which vertices to connect. See `condition` below for more
@@ -161,8 +161,8 @@ connected. Note that when determining weights between diagonal neighbors, the
 increased distance between them (as compared to the distance between cardinal
 neighbors) is accounted for.
 """
-function simplerastergraph(
-        raster::GeoArray;
+function rastergraph(
+        raster::Raster;
         condition::Function = is_data,
         directed::Bool = true,
         cardinal_neighbors_only::Bool = false,
@@ -177,20 +177,20 @@ function simplerastergraph(
     )
 
     if directed
-        sg = SimpleRasterDiGraph(g, v)
+        sg = RasterDiGraph(g, v)
     else
-        sg = SimpleRasterGraph(g, v)
+        sg = RasterGraph(g, v)
     end
 
     return sg
 end
 
 """
     make_weighted_raster_graph(
-        weight_raster::GeoArray,
-        vertex_raster::GeoArray;
+        weight_raster::Raster,
+        vertex_raster::Raster;
         directed::Bool = false,
-        condition_raster::GeoArray = weight_raster,
+        condition_raster::Raster = weight_raster,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false,
         connect_using_avg_weights::Bool = true,
@@ -206,13 +206,13 @@ vertex. Since edges are between rather than on vertices, edge weights are
 calculated as the average of the weights for each vertex being connected.
 
 ## Parameters
-`weight_raster`: A `GeoData.GeoArray` containing values that, where applicable 
+`weight_raster`: A `Rasters.Raster` containing values that, where applicable 
 based on other arguments, determine which pixels to connect and the edge 
 weights between pixels. Any pixel in `weight_raster` with a value not equal to 
 `weight_raster.missingval` will be assigned a vertex in the graph (corresponding
 to its centroid). 
 
-`vertex_raster`: A `GeoData.GeoArray` with integer values ranging from 1:n, 
+`vertex_raster`: A `Rasters.Raster` with integer values ranging from 1:n, 
 where n is the number of unique vertices in the graph. 
 
 ## Arguments
@@ -256,10 +256,10 @@ of vertices, how should the weight be chosen? Defaults to `min`. See the docs
 for `SparseArrays.sparse()` for more information.
 """
 function make_weighted_raster_graph(
-        weight_raster::GeoArray,
-        vertex_raster::GeoArray;
+        weight_raster::Raster,
+        vertex_raster::Raster;
         directed::Bool = false,
-        condition_raster::GeoArray = weight_raster,
+        condition_raster::Raster = weight_raster,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false,
         connect_using_avg_weights::Bool = true,
@@ -289,8 +289,8 @@ end
 
 """
     make_simple_raster_graph(
-        raster::GeoArray,
-        vertex_raster::GeoArray;
+        raster::Raster,
+        vertex_raster::Raster;
         directed::Bool = false,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false,
@@ -305,13 +305,13 @@ in the graph, and `raster` is used to construct the graph and determine which
 vertices to connect.
 
 ## Parameters
-`raster`: A GeoData.GeoArray on which to base the graph. Any pixel in `raster` 
+`raster`: A Rasters.Raster on which to base the graph. Any pixel in `raster` 
 with a value not equal to `raster.missingval` will be assigned a vertex
 in the graph (corresponding to its centroid). The values in the raster can also
 be used to determine which vertices to connect. See `condition` below for more
 information.
 
-`vertex_raster`: A `GeoData.GeoArray` with integer values ranging from 1:n, 
+`vertex_raster`: A `Rasters.Raster` with integer values ranging from 1:n, 
 where n is the number of unique vertices in the graph. 
 
 ## Arguments
@@ -355,8 +355,8 @@ of vertices, how should the weight be chosen? Defaults to `min`. See the docs
 for `SparseArrays.sparse()` for more information.
 """
 function make_simple_raster_graph(
-        raster::GeoArray,
-        vertex_raster::GeoArray;
+        raster::Raster,
+        vertex_raster::Raster;
         directed::Bool = false,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false,
@@ -378,11 +378,11 @@ end
 
 
 function make_raster_graph(
-        raster::GeoArray,
-        vertex_raster::GeoArray;
+        raster::Raster,
+        vertex_raster::Raster;
         directed::Bool = false,
         weighted::Bool = true,
-        condition_raster::GeoArray = raster,
+        condition_raster::Raster = raster,
         condition::Function = is_data,
         cardinal_neighbors_only::Bool = false,
         connect_using_avg_weights::Bool = true,
@@ -410,7 +410,7 @@ function make_raster_graph(
     # Add the edges
     # Only need to do neighbors down or to the right for undirected graphs
     # because edge additions will be redundant.
-    # Cardinal directions are in quotes since sometimes GeoArray are permuted
+    # Cardinal directions are in quotes since sometimes Raster are permuted
     # such that the top row doesn't necessarily correspond to the northern-most
     # pixels
     for row in 1:dims[1]
@@ -587,7 +587,7 @@ function make_raster_graph(
             )
         else
             n_nodes = max(maximum(sources), maximum(destinations))
-            g = SimpleDiGraph(
+            g = DiGraph(
                 sparse(sources, destinations, 1, n_nodes, n_nodes, combine)
             )
         end
@@ -601,7 +601,7 @@ function make_raster_graph(
             )
         else
             n_nodes = max(maximum(sources), maximum(destinations))
-            g = SimpleGraph(
+            g = Graph(
                 sparse(
                     vcat(sources, destinations),
                     vcat(destinations, sources),

src/show.jl

@@ -12,8 +12,8 @@ function show(io::IO, g::AbstractRasterGraph)
     )
     printstyled(" with dimensions:\n", color=:light_black)
 
-    x_dim = dims(g.vertex_raster, XDim)
-    y_dim = dims(g.vertex_raster, YDim)
+    x_dim = dims(g.vertex_raster, X)
+    y_dim = dims(g.vertex_raster, Y)
     printstyled("    X", color=:cyan)
     print(
         ": range($(minimum(x_dim)), $(maximum(x_dim)), step=$(x_dim.val[2] - x_dim.val[1]))\n"