add option to pin node positions to sfdp

Author: hexaeder

Project.toml

@@ -8,10 +8,12 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 GeometryBasics = "0.4"
 Requires = "1"
+StaticArrays = "1"
 julia = "1"
 
 [extras]

src/NetworkLayout.jl

@@ -4,6 +4,7 @@ using GeometryBasics
 using Requires
 using LinearAlgebra: norm
 using Random
+using StaticArrays
 
 export LayoutIterator
 
@@ -137,6 +138,66 @@ function make_symmetric!(A::AbstractMatrix)
     return A
 end
 
+"""
+Initialpos and pin can be given as diffent types (dicts, vectors, ...)
+Sanitize and transform them into
+
+    _initialpos :: Dict{Int,Point{dim,Ptype}}()
+    _pin        :: Dict{Int,SVector{dim,Bool}}()
+"""
+function _sanitize_initialpos_pin(dim, Ptype, initialpos, pin)
+    if !isempty(initialpos)
+        _initialpos = Dict{Int,Point{dim,Ptype}}(k => Point{dim,Ptype}(v) for (k, v) in pairs(initialpos))
+    else
+        _initialpos = Dict{Int,Point{dim,Ptype}}()
+    end
+
+    _pin = Dict{Int,SVector{dim,Bool}}()
+    for (k, v) in pairs(pin)
+        if v == nothing
+            continue
+        elseif v isa Bool
+            _pin[k] = SVector{dim,Bool}(v for i in 1:dim)
+        else # some container
+            if eltype(v) <: Bool
+                _pin[k] = v
+            else
+                # seems to be an initial position
+                _initialpos[k] = v
+                _pin[k] = SVector{dim,Bool}([true for i in 1:dim])
+            end
+        end
+    end
+    return _initialpos, _pin
+end
+
+"""
+From an point or a colletion of point like objects try to
+infer the PType and the dimension.
+
+i.e.
+    infer_pointtype([(1,2), (2.3, 4)]) == (2, Float64)
+"""
+infer_pointtype(::AbstractPoint{dim,t}) where {dim,t} = dim, t
+infer_pointtype(::NTuple{dim,t}) where {dim,t} = dim, t
+infer_pointtype(t::Tuple) = length(t), promote_type(typeof(t).parameters...)
+function infer_pointtype(v)
+    v = values(v) # needed for broadcast ofer dict
+    isempty(v) && throw(ArgumentError("Can not infer pointtype of empty container!"))
+    elt = isconcretetype(eltype(v)) ? eltype(v) : promote_type(typeof.(v)...)
+
+    if elt <: Number
+        return (length(v), elt)
+    else
+        ty = infer_pointtype.(v)
+        dims = getindex.(ty, 1)
+        if !all(isequal(first(dims)), dims)
+            throw(ArgumentError("Got container with different point dimesions!"))
+        end
+        (dims[1], promote_type(getindex.(ty, 2)...))
+    end
+end
+
 """
     @addcall
 

src/sfdp.jl

@@ -20,8 +20,15 @@ the nodes.
 - `iterations=100`: maximum number of iterations
 - `initialpos=Point{dim,Ptype}[]`
 
-  Provide list of initial positions. If length does not match Network size the initial
-  positions will be truncated or filled up with random values between [-1,1] in every coordinate.
+  Provide `Vector` or `Dict` of initial positions. All positions will be initialized
+  using random coordinates between [-1,1]. Random positions will be overwritten using
+  the key-val-pairs provided by this argument.
+
+- `pin=[]`: Pin node positions (won't be updated). Can be given as `Vector` or `Dict`
+   of node index -> value pairings. Values can be either
+    - `(12, 4.0)` : overwrite initial position and pin
+    - `true/false` : pin this position
+    - `(true, false, false)` : only pin certain coordinates
 
 - `seed=1`: Seed for random initial positions.
 """
@@ -30,44 +37,45 @@ the nodes.
     C::T
     K::T
     iterations::Int
-    initialpos::Vector{Point{Dim,Ptype}}
+    initialpos::Dict{Int,Point{Dim,Ptype}}
+    pin::Dict{Int,SVector{Dim,Bool}}
     seed::UInt
 end
 
 # TODO: check SFDP default parameters
-function SFDP(; dim=2, Ptype=Float64, tol=1.0, C=0.2, K=1.0, iterations=100, initialpos=Point{dim,Ptype}[],
+function SFDP(; dim=2, Ptype=Float64,
+              tol=1.0, C=0.2, K=1.0,
+              iterations=100,
+              initialpos=[], pin=[],
               seed=1)
     if !isempty(initialpos)
-        initialpos = Point.(initialpos)
-        Ptype = eltype(eltype(initialpos))
-        # TODO fix initial pos if list has points of multiple types
-        Ptype == Any && error("Please provide list of Point{N,T} with same T")
-        dim = length(eltype(initialpos))
+        dim, Ptype = infer_pointtype(initialpos)
+        Ptype = promote_type(Float32, Ptype) # make sure to get at least f32 if given as int
     end
-    return SFDP{dim,Ptype,typeof(tol)}(tol, C, K, iterations, initialpos, seed)
+    _initialpos, _pin = _sanitize_initialpos_pin(dim, Ptype, initialpos, pin)
+
+    return SFDP{dim,Ptype,typeof(tol)}(tol, C, K, iterations, _initialpos, _pin, seed)
 end
 
 function Base.iterate(iter::LayoutIterator{SFDP{Dim,Ptype,T}}) where {Dim,Ptype,T}
     algo, adj_matrix = iter.algorithm, iter.adj_matrix
     N = size(adj_matrix, 1)
-    M = length(algo.initialpos)
     rng = MersenneTwister(algo.seed)
-    startpos = Vector{Point{Dim,Ptype}}(undef, N)
-    # take the first
-    for i in 1:min(N, M)
-        startpos[i] = algo.initialpos[i]
-    end
-    # fill the rest with random points
-    for i in (M + 1):N
-        startpos[i] = 2 .* rand(rng, Point{Dim,Ptype}) .- 1
+    startpos = [2 .* rand(rng, Point{Dim,Ptype}) .- 1 for _ in 1:N]
+
+    for (k, v) in algo.initialpos
+        startpos[k] = v
     end
-    # iteratorstate: (#iter, energy, step, progress, old pos, stopflag)
-    return startpos, (1, typemax(T), one(T), 0, startpos, false)
+
+    pin = [get(algo.pin, i, SVector{Dim,Bool}(false for _ in 1:Dim)) for i in 1:N]
+
+    # iteratorstate: (#iter, energy, step, progress, old pos, pin, stopflag)
+    return startpos, (1, typemax(T), one(T), 0, startpos, pin, false)
 end
 
 function Base.iterate(iter::LayoutIterator{<:SFDP}, state)
     algo, adj_matrix = iter.algorithm, iter.adj_matrix
-    iter, energy0, step, progress, locs0, stopflag = state
+    iter, energy0, step, progress, locs0, pin, stopflag = state
     K, C, tol = algo.K, algo.C, algo.tol
 
     # stop if stopflag (tol reached) or nr of iterations reached
@@ -93,7 +101,8 @@ function Base.iterate(iter::LayoutIterator{<:SFDP}, state)
                                ((locs[j] .- locs[i]) / norm(locs[j] .- locs[i])))
             end
         end
-        locs[i] = locs[i] .+ step .* (force ./ norm(force))
+        mask = (!).(pin[i]) # where pin=true mask will multiply with 0
+        locs[i] = locs[i] .+ (step .* (force ./ norm(force))) .* mask
         energy = energy + norm(force)^2
     end
     step, progress = update_step(step, energy, energy0, progress)
@@ -103,7 +112,7 @@ function Base.iterate(iter::LayoutIterator{<:SFDP}, state)
         stopflag = true
     end
 
-    return locs, (iter + 1, energy, step, progress, locs, stopflag)
+    return locs, (iter + 1, energy, step, progress, locs, pin, stopflag)
 end
 
 # Calculate Attractive force

test/runtests.jl

@@ -3,6 +3,7 @@ using Graphs
 using GeometryBasics
 using DelimitedFiles: readdlm
 using SparseArrays: sparse
+using StaticArrays
 using Test
 
 function jagmesh()
@@ -357,4 +358,48 @@ jagmesh_adj = jagmesh()
                     6  2  4;
                     2  4  3]
     end
+
+    @testset "infer ptype" begin
+        using NetworkLayout: infer_pointtype
+        @test infer_pointtype(Point2f(1,2)) == (2, Float32)
+        @test infer_pointtype(Point2(1.0,2)) == (2, Float64)
+        @test infer_pointtype(Point(1,2,4)) == (3, Int64)
+        @test_throws ArgumentError infer_pointtype([(1,2), (2,3.2,1)])
+        @test infer_pointtype([(1,2), (2,3.2)]) == (2, Float64)
+
+        dany = Dict(1=>Point2(1,1), 4=>[1.0,2.0], 7=>(1.0, 4.0))
+        @test infer_pointtype(dany) == (2, Float64)
+
+        dany[2] = (1,2,3)
+        @test_throws ArgumentError infer_pointtype(dany)
+    end
+
+    @testset "Sanitize initialpos pin"  begin
+        using NetworkLayout: _sanitize_initialpos_pin
+        pos = [(0,0),(1,1),(2,2)]
+        pin = []
+        _pos, _pin = _sanitize_initialpos_pin(2, Float64, pos, pin)
+        @test _pos == Dict(pairs(Point2f.(pos)))
+        @test _pin == Dict{Int, SVector{2, Bool}}()
+
+        pos = [(0,0),(1,1),(2,2)]
+        pin = Dict(1=>(true,false), 3=>true, 2=>(3.0, 3.0))
+        _pos, _pin = _sanitize_initialpos_pin(2, Float64, pos, pin)
+        @test _pos == Dict(1=>Point2f(0,0), 2=>Point2f(3.0,3.0), 3=>Point2f(2.0,2.0))
+        @test _pin == Dict(1=>SVector(true,false), 2=>SVector(true,true), 3=>SVector(true,true))
+    end
+
+    @testset "test pin" begin
+        for algo in [sfdp]
+            g = complete_graph(10)
+            ep = algo(g; pin=[(0,0), (0,0)])
+            @test ep[1] == [0,0]
+            @test ep[2] == [0,0]
+
+            ep = algo(g; initialpos=Dict(4=>(0,0,0), 5=>(1,2,3)), pin=Dict(4=>true, 5=>(true, false, true)))
+            @test ep[4] == [0,0,0]
+            @test ep[5][[1,3]] == [1,3]
+            @test ep[5][2] != [2]
+        end
+    end
 end