anchor.diff:     }, Additional),
     maps:merge(To, #{connections => [New | Connections]}).
   
  -push_region_connection(Source, Target, {N, W, D}, Additional, Vizcerl) ->
  +push_region_connection(Source, Target, {N, W, D}, Additional, Vizceral) ->
     %% Will crash on nonexisting
  -  pull_region(Source, Vizcerl),
  -  pull_region(Target, Vizcerl),
  -  push_connection(Source, Target, {N, W, D}, Additional, Vizcerl).
  +  pull_region(Source, Vizceral),
  +  pull_region(Target, Vizceral),
  +  push_connection(Source, Target, {N, W, D}, Additional, Vizceral).
  +
  +push_focused_connection(Source, Target, RegionName, {N, W, D}, Additional, Vizceral) ->
  +    {Region, NewV} = pull_region(RegionName, Vizceral),
  +    NewR = push_connection(Source, Target, {N,W,D}, Additional, Region),
  +    push_region("", NewR, NewV).
  +
  +%% ---------------------- Focused ---------------------
  +push_focused(Name, Region, Vizceral) ->
  +    push_focused(Name, Region, #{} ,Vizceral).
  +push_focused(Name, RegionName, Additional, Vizceral) ->
  +    #{nodes := Nodes} = Vizceral,
  +    {[Region], Rest} = lists:partition(
  +                         fun(A) ->
  +                                 maps:get(name, A) == namify(RegionName)
  +                         end, Nodes),
  +    NewRegion = push_node(focused, Name, Additional, Region),
  +    maps:merge(Vizceral, #{nodes => [NewRegion | Rest]}).
  
positive.code:     {noreply, State#state{subscribers = [Pid|Subs]}};
  handle_cast({unsubscribe, Pid}, State = #state{subscribers = Subs}) ->
      {noreply, State#state{subscribers = lists:delete(Pid, Subs)}};
  handle_cast(_Msg, State) ->
      {noreply, State}.
  
  handle_info({data, _, _}, State = #state{subscribers = Subs,
                                           counters = OldCounters}) ->
      %% traverse all connected nodes and read their net_kernel counters
      NewCounters = get_traffic_counters(),
  
      %% start creating a map, which represents the Vizceral JSON document
      %% region named "INTERNET" is mandatory
      V1 = push_region(<<"INTERNET">>, new()),
  
      %% add as many regions as there are nodes in the cluster
      V2 = lists:foldl(fun({Node,_,_}, V) ->
                               NodeBin = atom_to_binary(Node, latin1),
                               push_region(NodeBin, V)
                       end, V1, NewCounters),
  
      %% add links between "INTERNET" and all nodes
      %% and compute delta between old and new net_kernel counters
      V3 = lists:foldl(
             fun({Node, NewIn, NewOut}, V) ->
                     NodeBin = atom_to_binary(Node, latin1),
                     {OldIn, OldOut} = get_in_out(Node, OldCounters),
                     push_region_connection(<<"INTERNET">>, NodeBin,
                                            {NewOut-OldOut, NewIn-OldIn, 0},
                                            #{}, V)
             end, V2, NewCounters),
  
      %% push an update to all subscribed WebSockets
      JSON = epl_json:encode(V3, <<"traffic-info">>),
  
      [Pid ! {data, JSON} || Pid <- Subs],
      {noreply, State#state{counters = NewCounters}}.
  
  terminate(_Reason, _State) ->
      ok.
  
negative.code: 
  binarify(Name) when is_list(Name) ->
      list_to_binary(Name);
  binarify(Name) when is_atom(Name) ->
      atom_to_binary(Name, latin1);
  binarify(Name) when is_pid(Name) ->
      list_to_binary(pid_to_list(Name));
  binarify(Name) when is_port(Name) ->
      list_to_binary(erlang:port_to_list(Name));
  binarify(Name) when is_binary(Name) ->
      Name.
  
  
  namify(Name) when is_binary(Name) ->
      Name1 = binary:replace(binarify(Name), <<"@">>, <<"_at_">>),
      Name2 = binary:replace(binarify(Name1), <<"<">>, <<"">>),
      Name3 = binary:replace(binarify(Name2), <<">">>, <<"">>),
      binary:replace(binarify(Name3), <<".">>, <<"_">>, [global]);
  namify(Name) ->
      namify(binarify(Name)).
  
  
  
  %% ---------------------- Regions ---------------------
  push_region(Name, Vizceral) ->
      push_region(Name, #{}, Vizceral).
  push_region(Name, Additional, Vizceral) ->
      A = maps:merge(#{
                        connections => [],
                        maxVolume => 5000
                      },
                     Additional),
      push_node(region, Name, A, Vizceral).
  
  pull_region(Name, Vizceral) ->
      {Region, Newlist} = pull_node(Name, Vizceral),
      {Region, maps:merge(Vizceral, #{nodes => Newlist})}.
  
  %% ---------------------- Nodes -----------------------
  push_node(Renderer, Name, Additional, Entity) ->
  