allow matlab-tree to better handle arbitrary data types

@tree/changeparent.m

@@ -0,0 +1,41 @@
+function obj = changeparent(obj, selectedNode, newParent)
+% Assign a given node to a new parent
+%
+% obj = changeparent(obj, selectedNode, newParent)
+%
+%
+% EXAMPLE:
+% move node 100 to a new parent (300)
+%
+% myTree = myTree.changeparent(100,300)
+%
+%
+% Rob Campbell - 2016
+
+    % Do not proceed if newParent is a child of the selected node. 
+    % Proceeding will cause this part of the tree to be deleted. 
+    if any(obj.getchildren(selectedNode) == newParent)
+        disp('tree.changeparent -- newParent can not be a child of selectedNode')
+        return
+    end
+
+    %Get a subtree
+    subTree=obj.subtree(selectedNode);
+
+    %Graft the subtree to the new location
+    modifiedTree = obj.graft(newParent,subTree);
+
+    %Remove the sub-tree (must remove afterwards or sometimes the graft is to the wrong place)
+    modifiedTree = modifiedTree.chop(selectedNode);    
+
+    % Do not return the tree if the number of nodes has changed. 
+    % This can happen if the changeparent operation breaks the tree, since the broken part just gets deleted
+    if length(modifiedTree.Node) ~= length(obj.Node)
+        disp('tree.changeparent -- can not perform operation: it would change the number of nodes in the tree')
+    else
+        obj=modifiedTree;
+    end
+
+
+
+end

@tree/chop.m

@@ -1,5 +1,10 @@
 function obj = chop(obj, node)
 %% CHOP  Remove the target node and all subnodes from the given tree.
+%
+%
+% e.g. 
+% nodeIndex=34;
+% myTree.chop(nodeIndex)
 
     iterator = obj.depthfirstiterator(node);
 
@@ -8,12 +13,12 @@
 
     % Remove unwanted nodes
     np ( iterator ) = [];
-    
+
     % Shift parent value: if a parent were after some nodes we removed, we
     % need to shift its value by an amount equal to the number of parent we
     % removed, and that were BEFORE the target parent
-    for i = 1 : numel(np)
-        np(i) = np(i) - sum(np(i) > iterator);
+    for ii = 1 : numel(np)
+        np(ii) = np(ii) - sum(np(ii) > iterator);
     end
 
     obj.Parent = np;

@tree/depthfirstiterator.m

@@ -16,7 +16,7 @@
 % % Create a copy of the tree that holds the order of iteration
 % lineage = tree.example;
 % itOrder = tree(lineage, 'clear'); % Copy the tree structure only
-% iterator = itOrder.depthFirstIterator;
+% iterator = itOrder.depthfirstiterator;
 % index = 1;
 % for i = iterator
 %   itOrder = itOrder.set(i, index);
@@ -27,7 +27,7 @@
 % EXAMPLE 2
 % % List the content of a subtree of the tree
 % lineage = tree.example;
-% iterator = lineage.depthFirstIterator(19);
+% iterator = lineage.depthfirstiterator(19);
 % content = cell(numel(iterator), 1);
 % index = 1;
 % for i = iterator
@@ -46,7 +46,8 @@
     IDs = recurse(startNode);
 
     function val = recurse(node)
-
+        showWarning=0;
+
         val = node;
         if obj.isleaf(node)
             return
@@ -57,15 +58,24 @@
            if sorted && numel(children) > 1
 
                contents = obj.Node(children);
-               [~, sorting_array] = sortrows(contents);
-               children = children(sorting_array);
+               try
+                  [~, sorting_array] = sortrows(contents);
+                  children = children(sorting_array);
+                catch
+                  if showWarning
+                      fprintf('%s: Failed to sort tree contents. Data type likely not sortable\n',mfilename)
+                  end
+                  children=children(1:length(contents));
+                end
 
            end
-
-           cellval = cell(numel(children), 1);
-           for i = 1 : numel(children)
-               cellval{i} = recurse(children(i));
+
+
+           cellval = cell(numel(children), 1); %prealloacte a cell array
+           for ii = 1 : numel(children)
+               cellval{ii} = recurse(children(ii)); %recursive function call
            end
+
            val = [ val cellval{:} ] ;
 
         end

@tree/dumptree.m

@@ -0,0 +1,40 @@
+function str = dumptree(obj, nodeFunc)
+%% DUMPTREE  Dump the contents of the tree to a string.
+%
+% Each line of the string (lines terminated by newline) is one node.
+% Each line is in the format:
+% node_index , node_parent , node_contents
+%
+% If the node_contents is a string then the it is simply printed. 
+% If node_contents is anything else, then the user must supply
+% a function handle (nodeFunc) that tells dumptree how to handle
+% the data. 
+%
+% Examples
+% myTree.dumptree(@(n) sprintf('%d,%d,%d',n.xVoxel,n.yVoxel,n.zVoxel))
+% myTree.dumptree(@treeDumperFncInPathSomewhere)
+% myTree.dumptree()
+% dumpTree(myTree)
+% 
+% Rob Campbell, Basel, 2015
+
+
+if nargin<2
+    nodeFunc=[];
+    if ~isstr(obj.Node{1})
+        fprintf('Node data are not a string but nodeFunc was not defined.\nAborting\n\n')
+        return
+    end
+end
+
+
+str= '';
+for ii=1:obj.nnodes
+    if isempty(nodeFunc)
+        nodeData =  obj.Node{ii};
+    else
+        nodeData = nodeFunc(obj.Node{ii});
+    end
+
+    str = [str,sprintf('%d,%d,%s\n',ii,obj.Parent(ii),nodeData)];
+end

@tree/findpath.m

@@ -20,11 +20,22 @@
 %   index = index + 1;
 % end
 % disp(pt.tostring)
+%
+%
+
+
 
+
     if n1 == n2
 
         path = n1;
 
+    elseif n2 == 1
+        path = obj.pathtoroot(n1);
+
+    elseif n1 == 1
+        path = fliplr(obj.pathtoroot(n2));
+
     elseif any( n2 == obj.depthfirstiterator(n1) )
         % n2 is in the children of n1
         path = [ n1 descend(n1) ];

@tree/getsegments.m

@@ -0,0 +1,48 @@
+function segments = getsegments(obj, linkSegments, nodeID, segments)
+%% GETSEGMENTS  Return a cell array containing all unique segments of the tree
+%
+% segments = getsegments(obj, linkSegments)
+%
+% Options
+% If linkSegments is 1, then the branch node is added to each returned segement. This makes
+% it possible to plot the data without gaps appearing. This is the default. 
+% If linkSegments is 0, then the no duplicate points are returned.
+%
+% Examples
+% segments = myTree.getsegments %for plotting a tree without repeats
+% segments = myTree.getsegments(0) %for returning segments without redundant nodes
+% 
+%
+% Rob Campbell, Basel, 2015
+
+
+if nargin<2
+    linkSegments=1;
+end
+
+if nargin<3
+    nodeID = 1;
+    segments = {};
+end
+
+if linkSegments & nodeID>1
+    thisPath = [obj.getparent(nodeID)];
+else
+    thisPath = [];
+end
+
+while length(nodeID)==1 %Loop until we get to a branch point
+    thisPath = [thisPath,nodeID];
+    nodeID = obj.getchildren(nodeID);
+end
+
+%Store this segment
+segments = [segments,thisPath];
+
+%Go into the branches with a recursive function call
+for ii=1:length(nodeID)
+    segments=obj.getsegments(linkSegments,nodeID(ii),segments);
+end
+
+
+

@tree/graft.m

@@ -1,14 +1,24 @@
 function obj = graft(obj, ID, othertree)
-%% GRAFT   Graft another tree at the specified node of this tree.
-
+% Graft another tree at the specified node of this tree.
+%
+% obj = graft(obj, node, othertree) 
+% Returns a new tree made of the current tree with the new tree (othertree) attached at node "ID".
+%
+%
+% EXAMPLE:
+% graft "differentTree" to "myTree" at node 200
+%
+% myTree = myTree.graft(200,differentTree)
+%
+%
+% Jean-Yves Tinevez - 2013
 
     nNodes = numel(obj.Parent);
 
     otParents = othertree.Parent;
-    % Shift other parent indices
-    otParents = otParents + nNodes;
-    % Make the other root a child of the target node
-    otParents(1) = ID;
+
+    otParents = otParents + nNodes; % Shift other parent indices
+    otParents(1) = ID; % Make the other root a child of the target node
 
     % Concatenate
     newParents = [ obj.Parent ; otParents ];

@tree/pathtoroot.m

@@ -0,0 +1,30 @@
+function path = pathtoroot(obj, n)
+%% PATHTOROOT  Path from node "n" to the tree root. 
+%
+% This is a special case of findpath(), which simply needs to follow a tree back 
+% by looking at node's parent. Since a node can only have one parent, this is 
+% trivial. It's about 50 times faster than calling findpath(1,myNode), since we don't need 
+% to exhaustively search the tree for the fastest path.
+%
+
+
+
+    if n == 1
+
+        path = n;
+        return
+
+    else
+
+        p=obj.Parent(n);
+        path=[n,p];
+        while p ~= 1
+            p=obj.Parent(p);
+            path(end+1)=p; % For very large trees it might hekp to pre-allocate then prune back. But right now it doesn't seem worth it.
+        end
+
+
+
+    end
+
+

@tree/plot.m

@@ -295,10 +295,13 @@
             % The label = content
             content = obj.get(i);
             if isempty(content)
-                content = '�';
+                content = 'o';
             end
-            if ~ischar(content)
-                content = num2str(content);
+
+            if isnumeric(content)
+                content = num2str(content)
+            else
+                content=class(content);
             end
 
             ht = text(x1, y2, contentfun(content), ...  A hack to have text displayed above bars

@tree/private/contentToString.m

@@ -4,6 +4,7 @@
         % Nothing -> print the void symbol
         str = '�';
     elseif ~ischar(content)
+
         if numel(content) == 1
             % Scalar stuff we most probably be able to print
             if islogical(content)
@@ -30,9 +31,14 @@
                 % Cell with one element -> append cell and print element
                 str = ['cell:' contentToString(content{1}) ];
 
-            else
-                % Scalar number -> print it
+            elseif isnumeric(content)
+
+                % number -> print it
                 str = num2str(content);
+
+            else 
+                %unknown or a struct so print this instead
+                str = class(content);
             end
 
         else

@tree/removenode.m

@@ -1,4 +1,5 @@
 function obj = removenode(obj , node)
+% remove selected node and return tree with this node missing
 
     if node <= 1
         error('MATLAB:tree:removenode', ...