bugfix tests and CI

Author: rafaqz

.github/workflows/CI.yml

@@ -51,8 +51,15 @@ jobs:
           python-version: '3.x'
       - run: pip install jupyter
       - uses: julia-actions/setup-julia@v2
+      - run: sudo apt-get update && sudo apt-get install -y xvfb libgl1-mesa-dri
+      - run: |
+          Xvfb :0 -screen 0 1024x768x24 &
+          sleep 3
+        env:
+          DISPLAY: ':0'
       - uses: julia-actions/julia-docdeploy@v1
         env:
+          DISPLAY: ':0'
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # For authentication with GitHub Actions token
           DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }} # For authentication with SSH deploy key
           JULIA_DEBUG: "Documenter"

src/measures/edge_betweenness.jl

@@ -30,7 +30,7 @@ needs_edgebetweenness_workspace(::EdgeBetweenness, ::RSP) = true
     QuoteNode(Symbol(nameof(m), :_, nameof(W)))
 
 # At the ConnectedGraph level we return a SparseMatrixCSC
-function allocate_connectedgraph_output(
+function _allocate_connectedgraph_output(
     l::Union{ConnectedGraphLevel,TargetLevel},
     ::ReturnCustomSparse,
     m::EdgeBetweenness,

src/measures/eigmax.jl

@@ -23,7 +23,7 @@ returntrait(::EigMax) = ReturnCustom()
 needs_eigmax(::EigMax, ::RSP) = true
 
 # Allocate sqauare matrix of target * target size
-function allocate_gridgraph_output(
+function _allocate_gridgraph_output(
     ::ReturnCustom,
     m::EigMax,
     ::GridGraph,
@@ -33,7 +33,7 @@ function allocate_gridgraph_output(
     o = Vector{T}(undef, length(connectedgraphs))
     return MeasureOutput(m, o)
 end
-function allocate_connectedgraph_output(
+function _allocate_connectedgraph_output(
     ::ConnectedGraphLevel,
     ::ReturnCustom,
     m::EigMax,

src/measures/sensitivity.jl

@@ -299,8 +299,8 @@ function _compute_sensitivity_precursors(::PowerMeanProximity, cgi::ConnectedGra
 
     edge_bet = EdgeBetweenness(custom_weighted)
     node_bet = Betweenness(custom_weighted)
-    edge_output = allocate_connectedgraph_output(finallevel, edge_bet, cgi).output
-    node_output = allocate_connectedgraph_output(finallevel, node_bet, cgi).output
+    edge_output = _allocate_connectedgraph_output(finallevel, edge_bet, cgi).output
+    node_output = _allocate_connectedgraph_output(finallevel, node_bet, cgi).output
 
     # Compute EdgeBetweenness
     compute_connectedgraph!(edge_output, edge_bet, cgi)

src/measures/shared.jl

@@ -70,16 +70,19 @@ function num_vec_workspaces(problem::ConScapeProblem)
     # Base of 10 covers target_precalculation needs:
     # Z (2), Zⁱ (1), Y (1), K (2 with proximity measure), M (1), plus buffer
     base = 10
-    return base + sum(m -> num_vec_workspaces(m, mov), values(mes); init=0)
+    return base + _sum_over_measures(num_vec_workspaces, mes, mov)
 end
 
 function num_sp_workspaces(problem::ConScapeProblem)
     mov = movement(problem)
     mes = measures(problem)
     base = num_sp_workspaces_base(mov, solver(problem))
-    return base + sum(m -> num_sp_workspaces(m, mov), values(mes); init=0)
+    return base + _sum_over_measures(num_sp_workspaces, mes, mov)
 end
 
+_sum_over_measures(f, mes::NamedTuple, mov) = sum(m -> f(m, mov), values(mes); init=0)
+_sum_over_measures(f, m::Measure, mov) = f(m, mov)
+
 # Define the default output Level for that initialisation object
 defaultfinallevel(::GridGraphInit) = GridGraphLevel()
 defaultfinallevel(::ConnectedGraphInit) = ConnectedGraphLevel()

src/output.jl

@@ -13,13 +13,18 @@ const ReturnAssigned = Union{ReturnAssignedSparse,ReturnAssignedDense}
 allocate_gridgraph_output(problem::ConScapeProblem, args...) =
     allocate_gridgraph_output(measures(problem), args...)
 allocate_gridgraph_output(measures::Union{Tuple,NamedTuple}, args...) =
-    map(m -> allocate_gridgraph_output(m, args...)::MeasureOutput, measures)
-allocate_gridgraph_output(m::Measure, args...) =
-    allocate_gridgraph_output(returntrait(m), m, args...)
+    map(m -> _allocate_gridgraph_output(m, args...)::MeasureOutput, measures)
+# Single Measure: wrap in NamedTuple for consistent internal handling
+function allocate_gridgraph_output(m::Measure, args...)
+    mo = _allocate_gridgraph_output(m, args...)
+    return NamedTuple{(Symbol(m),)}((mo,))
+end
 
-allocate_gridgraph_output(rt::ReturnTrait, m::Measure, ggi::GridGraphInit) =
-    allocate_gridgraph_output(rt, m, gridgraph(ggi), connectedgraphs(ggi))
-function allocate_gridgraph_output(
+_allocate_gridgraph_output(m::Measure, args...) =
+    _allocate_gridgraph_output(returntrait(m), m, args...)
+_allocate_gridgraph_output(rt::ReturnTrait, m::Measure, ggi::GridGraphInit) =
+    _allocate_gridgraph_output(rt, m, gridgraph(ggi), connectedgraphs(ggi))
+function _allocate_gridgraph_output(
     ::ReturnScalarSum,
     m::Measure,
     ::GridGraph,
@@ -28,7 +33,7 @@ function allocate_gridgraph_output(
     return MeasureOutput(m, zeros(Float64, length(connectedgraphs)))
 end
 # We need to zero out all connected subgraphs
-function allocate_gridgraph_output(
+function _allocate_gridgraph_output(
     ::ReturnSpatial,
     m::Measure,
     gridgraph::GridGraph,
@@ -37,7 +42,7 @@ function allocate_gridgraph_output(
     o = fill(NaN, size(gridgraph))
     return MeasureOutput(m, o)
 end
-function allocate_gridgraph_output(
+function _allocate_gridgraph_output(
     ::ReturnAssignedDense,
     m::Measure,
     gridgraph::GridGraph,
@@ -46,7 +51,7 @@ function allocate_gridgraph_output(
     o = Vector{Matrix{Float64}}(undef, length(connectedgraphs))
     return MeasureOutput(m, o)
 end
-function allocate_gridgraph_output(
+function _allocate_gridgraph_output(
     ::ReturnSparseGraph,
     m::Measure,
     gridgraph::GridGraph,
@@ -59,12 +64,18 @@ end
 allocate_connectedgraph_output(l::Level, problem::ConScapeProblem, args...) =
     allocate_connectedgraph_output(l, measures(problem), args...)
 allocate_connectedgraph_output(l::Level, measures::Union{Tuple,NamedTuple}, args...) =
-    map(m -> allocate_connectedgraph_output(l, m, args...)::MeasureOutput, measures)
-allocate_connectedgraph_output(l::Level, m::Measure, args...)::MeasureOutput =
-    allocate_connectedgraph_output(l, returntrait(m), m, args...)
-allocate_connectedgraph_output(l::Level, m::Measure, cgi::ConnectedGraphInit)::MeasureOutput =
-    allocate_connectedgraph_output(l, returntrait(m), m, gridgraph(cgi), connectedgraph(cgi))
-function allocate_connectedgraph_output(
+    map(m -> _allocate_connectedgraph_output(l, m, args...)::MeasureOutput, measures)
+# Single Measure: wrap in NamedTuple for consistent internal handling
+function allocate_connectedgraph_output(l::Level, m::Measure, args...)
+    mo = _allocate_connectedgraph_output(l, m, args...)
+    return NamedTuple{(Symbol(m),)}((mo,))
+end
+
+_allocate_connectedgraph_output(l::Level, m::Measure, args...)::MeasureOutput =
+    _allocate_connectedgraph_output(l, returntrait(m), m, args...)
+_allocate_connectedgraph_output(l::Level, m::Measure, cgi::ConnectedGraphInit)::MeasureOutput =
+    _allocate_connectedgraph_output(l, returntrait(m), m, gridgraph(cgi), connectedgraph(cgi))
+function _allocate_connectedgraph_output(
     l::Union{ConnectedGraphLevel,TargetLevel},
     ::ReturnSpatial,
     m::Measure,
@@ -76,7 +87,7 @@ function allocate_connectedgraph_output(
     o[sourceids(connectedgraph)] .= 0.0
     return MeasureOutput(m, o)
 end
-function allocate_connectedgraph_output(
+function _allocate_connectedgraph_output(
     l::Union{ConnectedGraphLevel,TargetLevel},
     ::ReturnScalarSum,
     m::Measure,
@@ -87,7 +98,7 @@ function allocate_connectedgraph_output(
     return MeasureOutput(m, o)
 end
 # Return a sparse matrix for ReturnAssignedSparse at ConnectedGraphLevel
-function allocate_connectedgraph_output(
+function _allocate_connectedgraph_output(
     l::ConnectedGraphLevel,
     ::ReturnAssignedSparse,
     m::Measure,
@@ -98,7 +109,7 @@ function allocate_connectedgraph_output(
     return MeasureOutput(m, o)
 end
 # Return a sparse vector for ReturnAssignedSparse at TargetLevel
-function allocate_connectedgraph_output(
+function _allocate_connectedgraph_output(
     l::TargetLevel,
     ::ReturnAssignedSparse,
     m::Measure,
@@ -109,7 +120,7 @@ function allocate_connectedgraph_output(
     return MeasureOutput(m, o)
 end
 # Return a dense matrix for ReturnAssignedDense at ConnectedGraphLevel
-function allocate_connectedgraph_output(
+function _allocate_connectedgraph_output(
     l::ConnectedGraphLevel,
     ::ReturnAssignedDense,
     m::Measure,
@@ -120,7 +131,7 @@ function allocate_connectedgraph_output(
     return MeasureOutput(m, o)
 end
 # Return a dense vector for ReturnAssignedDense at TargetLevel
-function allocate_connectedgraph_output(
+function _allocate_connectedgraph_output(
     l::TargetLevel,
     ::ReturnAssignedDense,
     m::Measure,

src/precalculation.jl

@@ -32,7 +32,8 @@ num_sp_workspaces_base(::MovementMode, ::Any) = 0
 anymeasure(f, measures::NamedTuple, mov::MovementMode) =
     anymeasure(f, values(measures), mov)
 anymeasure(f, measures::Tuple{Vararg{Measure}}, mov::MovementMode) =
-    any(map(m -> f(m, mov), measures)) 
+    any(map(m -> f(m, mov), measures))
+anymeasure(f, m::Measure, mov::MovementMode) = f(m, mov) 
 
 # TODO: Move these to a precalculation.jl file with the computation precalculations
 function sparse_precalculation(problem::ConScapeProblem{<:RSP}, graph::ConnectedGraph, workspaces::WorkspaceCollection)
@@ -238,7 +239,7 @@ function dense_precalculation(::ConnectedGraphInit)
     (;)
 end
 
-function _get_eigmax(measures::NamedTuple)::EigMax
+function _get_eigmax(measures::NamedTuple)::Union{EigMax,Nothing}
     all_eigmax = map(_get_eigmax, values(measures))
     return reduce(all_eigmax; init=nothing) do out, cur
         if !(isnothing(out) || isnothing(cur))
@@ -247,9 +248,9 @@ function _get_eigmax(measures::NamedTuple)::EigMax
         isnothing(out) ? cur : out
     end
 end
-_get_eigmax(m::EigMax) = m
-_get_eigmax(m::SensitivityAnalysis) = metric(m) isa EigMax ? metric(m) : nothing
-_get_eigmax(m::Measure) = nothing
+_get_eigmax(m::EigMax)::EigMax = m
+_get_eigmax(m::SensitivityAnalysis)::Union{EigMax,Nothing} = metric(m) isa EigMax ? metric(m) : nothing
+_get_eigmax(m::Measure)::Nothing = nothing
 
 ###########################################################################################
 # Variable generation for ConnectedGraphInit

src/problem.jl

@@ -75,7 +75,7 @@ solve(targetinit)
 ```
 """
 struct ConScapeProblem{
-    MM<:MovementMode,M<:NamedTuple,S<:Solver,G<:Union{Int,Nothing},CF,LF,N,SW<:StepWeight,MP<:Union{Nothing,String}
+    MM<:MovementMode,M<:Union{Measure,NamedTuple},S<:Solver,G<:Union{Int,Nothing},CF,LF,N,SW<:StepWeight,MP<:Union{Nothing,String}
 } <: AbstractProblem
     movement::MM
     measures::M
@@ -87,18 +87,16 @@ struct ConScapeProblem{
     stepweight::SW
     mmap_path::MP
     function ConScapeProblem(
-        movement::MM, m::M, solver::S, grain::G, costfunction::CF, 
+        movement::MM, m::M, solver::S, grain::G, costfunction::CF,
         likelyhoodfunction::LF, neighbors::N, stepweight::NW, mmap_path::MP
     ) where {MM,M,S,G,CF,LF,N,NW,MP}
-        m1 = if m isa Measure
-            NamedTuple{(Symbol(m),)}((m,))
-        elseif m isa Tuple
+        m1 = if m isa Tuple
             NamedTuple{map(Symbol, m)}(m)
         else
             m
         end
         return new{MM,typeof(m1),S,G,CF,LF,N,NW,MP}(
-            movement, m1, solver, grain, costfunction, 
+            movement, m1, solver, grain, costfunction,
             likelyhoodfunction, neighbors, stepweight, mmap_path
         )
     end

src/utils/utils.jl

@@ -134,7 +134,10 @@ _get_cost(rast::RasterStack) = _keys_or_nothing(rast, (:cost, :stepcost))
 _maybe_rasterstack(ggi) = _maybe_rasterstack(measures_outputs(ggi), ggi)
 function _maybe_rasterstack(measures_outputs, ggi)
     out = _maybe_raster(measures_outputs, ggi)
-    if all(map(o -> o isa Raster, out))
+    # Unwrap single-measure results if the problem was defined with a single Measure
+    if measures(problem(ggi)) isa Measure
+        return only(out)
+    elseif all(map(o -> o isa Raster, out))
         return RasterStack(out)
     else
         return out
@@ -210,7 +213,7 @@ end
 function setmeasures(ggi::GridGraphInit, m::MeasureNamedTuple)
     problem = setmeasures(ConScape.problem(ggi), m)
     outputs = map(measures(problem)) do m
-        allocate_gridgraph_output(m, ggi)
+        _allocate_gridgraph_output(m, ggi)
     end
     return ConstructionBase.setproperties(ggi, (; problem, outputs))
 end
@@ -219,7 +222,7 @@ function setmeasures(cgi::ConnectedGraphInit, m::MeasureNamedTuple;
 )
     problem = setmeasures(ConScape.problem(cgi), m)
     outputs = map(measures(problem)) do m
-        allocate_connectedgraph_output(finallevel, m, cgi)
+        _allocate_connectedgraph_output(finallevel, m, cgi)
     end
     return ConnectedGraphInit(
         problem,