VesselTree (WOImageJ API)

java.lang.Object
- woSource.math.VesselTree

```
public class VesselTree
extends java.lang.Object
```
WO VesselTree is a class/data structure to describe a tree structure containing many branches.

WO 8/17/2012 abandoning the idea of permitting only 2 children and labeling them as 2n and 2n + 1, instead each branch carries indices to their parent and each parent carries indices for all children.

See Also:

VesselBranch, VesselSegm

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`VesselTree.OptBrNodThread` This class is defined to run function OptBrNodes in // WO 4/11/2012 All threads work with the same global origImg, but they only access this image and do not change it.
`class`	`VesselTree.OptBrRadThread` This class is defined to run function OptBrRadius in // WO 4/11/2012 This works by defining a unique Roi for each thread to work on.

Field Summary

Fields
Modifier and Type	Field and Description
`VesselBranch[]`	`Branches`
`protected boolean`	`isByte`
`byte[][][]`	`isotropicSimTreeImg`
`int`	`Label`
`protected int`	`maskDepth`
`protected int`	`maskHeight`
`protected int`	`maskWidth`
`int`	`maxActiveBranchIndex`
`protected float`	`maxBrLength`
`protected float`	`maxBrRadius`
`protected float`	`maxBrTort`
`protected int`	`maxInitBranches`
`float`	`maxPathLength`
`protected int`	`minBranchLength`
`protected float`	`mmPerPixelXY`
`protected float`	`mmPerPixelZ`
`int`	`nBranches`
`int`	`nLevels`
`int`	`nLoopPts`
`boolean`	`OneMainBranch`
`protected short[][][]`	`origImg`
`protected byte[][][]`	`origImgByte`
`byte[][][]`	`simTreeImg`
`boolean`	`skelWasChanged`
`protected boolean[][][]`	`TreeMask`
`int[]`	`TreeTop`
`protected boolean`	`useTaper`
`boolean`	`withContrast`

Constructor Summary

Constructors
Constructor and Description
`VesselTree(float mmPPxy, float mmPPz)`
`VesselTree(int nbr, float mmPPxy, float mmPPz)`
`VesselTree(int nbrLabel, VesselTree A)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addBranch(int parentBr, int suggestedLevel)`
`void`	`addBranchAndChildren(int parentBr, VesselTree origVT, int origIndexAt)` WO 11/20/2012 Add the branch from a separate vessel tree (OrigVT) with it's index 'origIndexAt' as a new child of this tree's branch parentBr, and its decendants recursively.
`void`	`adjustNodalParam(int brAt, int nodeAt, int paramAt, float adjustBy)` change the nodal param and recompute the smooth points that the sim image is based on.
`boolean`	`branchExists(int br)`
`void`	`clear()`
`Point3Dint`	`clipBranchRadiusIncreases(int brAt, float parRadRatioThresh, float branchRadRatioThresh)` returns first break point along this branch Intended to find fibrotic regions in lung volume hit during vessel traversal
`Point3Dint[]`	`clipRadiusIncreases(float parRadRatioThresh, float branchRadRatioThresh)` Found that parRadRatioThresh of 1.5 and radIncrRatio of 2 worked OK for 2D test data.
`void`	`Copy(VesselTree A)`
`void`	`createIsotropicSimImage(int depth, int width, int ht)`
`void`	`createIsotropicSimImage(int depth, int width, int ht, float radiusExpansion)`
`void`	`createSimImage(int depth, int width, int ht)`
`void`	`createSimImage(int depth, int width, int ht, float radiusExpansion)`
`void`	`createSimImage(int depth, int width, int ht, float radiusExpansion, boolean createEndCaps)`
`void`	`createSimImage(int depth, int width, int ht, float radiusExpansion, Rectangle3D roi)`
`void`	`createSimImage(int depth, int width, int ht, float radiusExpansion, Rectangle3D roi, boolean createEndCaps)`
`void`	`createSimImage(int depth, int width, int ht, Rectangle3D roi)`
`java.lang.String`	`createSTL()` goal is to create an stl file to be used for CAD and 3D printing of the vessel tree.
`boolean`	`deleteBranch_MergeSiblingToParent(int indexAt)` returns true if merged.
`void`	`deleteBranchAndChildren(int indexAt)` This deletes the branch with Branches array index 'indexAt' and its decendants recursively.
`void`	`Draw(ArrayDisplay ad)`
`void`	`Draw(ArrayDisplay ad, boolean drawAsRadius)`
`VesselTree`	`Duplicate()`
`void`	`extend(int extension)`
`int`	`findFarthestFalseConnection()` Intent is to find children whose angle from each other is large (>110 degrees) AND whose radius is larger than the parent.
`int`	`findFarthestFalseConnection(boolean exclude1BadLevel)`
`void`	`floodfillMaskFromTop()` 12/24/2012 intent is for after adding diskOntoMask or after split tree into 2 sub-trees, then need to regenerate the tree masks.
`int[]`	`getAncesterList(int brat)` 7/8/2014 intent is to return a list of indices for the parent-ancesters of branch brat
`int[]`	`getBranchChildren(int parentIndex)`
`boolean[][][]`	`getBranchNodeROI(int brAt, int nodeAt, int depth, int width, int height)` Intent is to create a mask that contains the region of influence for a given branch node over which to compute the correlation (NCCC) to the original image, for optimizing the nodal parameters.
`byte[][][]`	`getBranchNodeSimImage(int brAt, int nodeAt, Rectangle3D nodROI)` Intent is to create the similated vessel image only over the node of interest, over which to compute the correlation (NCCC) to the original image, for optimizing the nodal parameters.
`int`	`getBranchWithStartLoc(int x, int y, int z)`
`float[][][][]`	`getFittedCenterlinePts_mm()` goal is to retrieve the fitted centerline points for all branches, including the bifurcation model from parent to child, to look for errors (bending) in the centerline fits.
`byte[][][]`	`getIsotropicSimImage(int depth, int width, int ht)`
`float`	`getLargestBranchLength()`
`float`	`getLargestBranchRadius()`
`float[][]`	`getLengthHistogram(int nBins)`
`int[]`	`getLongestBranchPath()` 9/2/2012 intent is to find the longest branch path, starting from the farthest branch and tracing backwards via parents.
`VesselBranch`	`getMostRecentBranch()`
`int`	`getMostRecentIndex()`
`int`	`getNbranches()`
`int`	`getNbranchesAtLevel(int level)`
`int`	`getNlevels()`
`float[][]`	`getRadiusHistogram(int nBins)`
`byte[][][]`	`getSimImage(int depth, int width, int ht)` Compute the simImg if it doesn't exist already.
`byte[][][]`	`getSimImage(int depth, int width, int ht, Rectangle3D roi)`
`int`	`getTopBranchIndex()`
`float[][]`	`getTortuosityHistogram(int nBins)`
`boolean[][][]`	`getTreeMask()`
`int[]`	`getTreeTop()`
`Point3Dint`	`getTreeTopPt3D()`
`float`	`getVolume()` compute vascular volume as sum_brs{br_len*br_area)
`void`	`insertDiskOntoMask(int brAt, int insertPt)`
`void`	`insertDiskOntoMask(int brAt, java.lang.String where)` 12/24/2012 intent is to place a break int the mask to permit separation of mask into sub-tree masks.
`void`	`insertDiskOntoMask(Point3Dint loc)`
`boolean`	`isPointInTree(Point3Dint testPt)`
`void`	`OptBranchNode(int brAt, int nodeAt, int iterAt)` optimize over each node's 6 parameters X,Y,Z, DXDS, DYDS, DZDS driven by NCCC to the original image, If at the first node and the branch has a parent then do not opt over the coord params because those are already being optimized when the parent's last node's coords are optimized.
`void`	`OptBranchRadius(int brAt, int iterAt)` optimize over the branch radius, driven by NCCC to the original image.
`void`	`OptBranchTaper(int brAt, int iterAt)` optimize over the branch radius taper, driven by NCCC to the original image.
`void`	`OptNodes(int iterAt)` WO 4/16/2012 parallel version.
`void`	`OptRadii(int iter)` WO 4/11/2012 parallel version.
`void`	`OptToImage(byte[][][] targetImg)` 4/34/2013 optimize over each branch params.
`void`	`OptToImage(short[][][] targetImg)` 4/34/2013 optimize over each branch params.
`boolean`	`plugMaskAtPoint(int brAt, int brPtIndex)` 1/8/2012 intent is to void pixels in the mask image to block the mask at branch point brPtIndex.
`java.lang.String`	`PrintSimTreeParams()`
`void`	`printTreeHierarchy()`
`boolean`	`ReadSimTreeParams(java.lang.String path)`
`void`	`reCreateSimImage()`
`void`	`resetALevel(int parIndex, int parLevel)`
`void`	`resetLevels()`
`void`	`setBrBGImages(int depth, int width, int height)` create background images.
`void`	`setTreeMask(boolean[][][] M)`
`void`	`shiftInZ(int zshift)`
`void`	`smoothTreeBranches()` 4/2/2013 Intent is to create smooth fits to the branches for future simulated vessel calc.
`java.lang.String`	`toString()`
`java.lang.String`	`toString(boolean summaryOnly)`
`void`	`trimStubs()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - Branches
```
public VesselBranch[] Branches
```
  - nBranches
```
public int nBranches
```
  - maxActiveBranchIndex
```
public int maxActiveBranchIndex
```
  - maxInitBranches
```
protected int maxInitBranches
```
  - minBranchLength
```
protected int minBranchLength
```
  - Label
```
public int Label
```
  - nLevels
```
public int nLevels
```
  - TreeTop
```
public int[] TreeTop
```
  - skelWasChanged
```
public boolean skelWasChanged
```
  - simTreeImg
```
public byte[][][] simTreeImg
```
  - isotropicSimTreeImg
```
public byte[][][] isotropicSimTreeImg
```
  - TreeMask
```
protected boolean[][][] TreeMask
```
  - maskDepth
```
protected int maskDepth
```
  - maskWidth
```
protected int maskWidth
```
  - maskHeight
```
protected int maskHeight
```
  - mmPerPixelXY
```
protected float mmPerPixelXY
```
  - mmPerPixelZ
```
protected float mmPerPixelZ
```
  - maxBrRadius
```
protected float maxBrRadius
```
  - maxBrLength
```
protected float maxBrLength
```
  - maxBrTort
```
protected float maxBrTort
```
  - maxPathLength
```
public float maxPathLength
```
  - OneMainBranch
```
public boolean OneMainBranch
```
  - origImg
```
protected short[][][] origImg
```
  - origImgByte
```
protected byte[][][] origImgByte
```
  - isByte
```
protected boolean isByte
```
  - useTaper
```
protected boolean useTaper
```
  - withContrast
```
public boolean withContrast
```
  - nLoopPts
```
public int nLoopPts
```
- Constructor Detail
  - VesselTree
```
public VesselTree(float mmPPxy,
                  float mmPPz)
```
  - VesselTree
```
public VesselTree(int nbr,
                  float mmPPxy,
                  float mmPPz)
```
  - VesselTree
```
public VesselTree(int nbrLabel,
                  VesselTree A)
```
- Method Detail
  - Copy
```
public void Copy(VesselTree A)
```
  - Duplicate
```
public VesselTree Duplicate()
```
  - clear
```
public void clear()
```
  - addBranch
```
public void addBranch(int parentBr,
                      int suggestedLevel)
```
  - branchExists
```
public boolean branchExists(int br)
```
  - getMostRecentBranch
```
public VesselBranch getMostRecentBranch()
```
  - getMostRecentIndex
```
public int getMostRecentIndex()
```
  - getTopBranchIndex
```
public int getTopBranchIndex()
```
  - getBranchWithStartLoc
```
public int getBranchWithStartLoc(int x,
                                 int y,
                                 int z)
```
  - deleteBranch_MergeSiblingToParent
```
public boolean deleteBranch_MergeSiblingToParent(int indexAt)
```
    returns true if merged.
    If removing 1 of only 2 children, merge the parent branch with the one remaining child.
    reassign branch points accordingly.
    
    Parameters:
    
    indexAt - index to Branches[] of the child branch being deleted.
  - deleteBranchAndChildren
```
public void deleteBranchAndChildren(int indexAt)
```
    This deletes the branch with Branches array index 'indexAt' and its decendants recursively.
    In most cases (all that I have used so far) the branch being deleted has no children.
    WO 8/17/2012 just set npts==0 and null the children and don't worry about saving the memory space by shifting th array up.
  - addBranchAndChildren
```
public void addBranchAndChildren(int parentBr,
                                 VesselTree origVT,
                                 int origIndexAt)
```
    WO 11/20/2012 Add the branch from a separate vessel tree (OrigVT) with it's index 'origIndexAt' as a new child of this tree's branch parentBr, and its decendants recursively.
  - extend
```
public void extend(int extension)
```
  - getVolume
```
public float getVolume()
```
    compute vascular volume as sum_brs{br_len*br_area)
  - getTreeTop
```
public int[] getTreeTop()
```
  - getTreeTopPt3D
```
public Point3Dint getTreeTopPt3D()
```
  - isPointInTree
```
public boolean isPointInTree(Point3Dint testPt)
```
  - resetLevels
```
public void resetLevels()
```
  - resetALevel
```
public void resetALevel(int parIndex,
                        int parLevel)
```
  - getNlevels
```
public int getNlevels()
```
  - getNbranches
```
public int getNbranches()
```
  - getNbranchesAtLevel
```
public int getNbranchesAtLevel(int level)
```
  - getBranchChildren
```
public int[] getBranchChildren(int parentIndex)
```
  - clipRadiusIncreases
```
public Point3Dint[] clipRadiusIncreases(float parRadRatioThresh,
                                        float branchRadRatioThresh)
```
    Found that parRadRatioThresh of 1.5 and radIncrRatio of 2 worked OK for 2D test data.
    Criteria for selecting candidates: search along each branch and identify where radius increases by more than 50% over avg of all previous points.
    I previously preselected candidate branches where child avg radius was > parent, but this missed a nodule at the end of a long branch (so average was still small) in a 2D test data set.
    
    Returns:
    
    list of break points [branch index][point index].
  - clipBranchRadiusIncreases
```
public Point3Dint clipBranchRadiusIncreases(int brAt,
                                            float parRadRatioThresh,
                                            float branchRadRatioThresh)
```
    returns first break point along this branch
    Intended to find fibrotic regions in lung volume hit during vessel traversal
    
    Parameters:
    
    brAt: - index of branch in tree
    
    parRadRatioThresh: - cut-off ratio of radii of distal portion of branch to parent. For vessel segmentation this is set in GUI.
    
    branchRadRatioThresh: - cut-off ratio of radii distal vs. proximal portion of branch. For vessel segmentation this is set in GUI.
  - trimStubs
```
public void trimStubs()
```
  - plugMaskAtPoint
```
public boolean plugMaskAtPoint(int brAt,
                               int brPtIndex)
```
    1/8/2012 intent is to void pixels in the mask image to block the mask at branch point brPtIndex.
    Code borrowed from ArrayDisplay.overlay3Ddisk().
  - insertDiskOntoMask
```
public void insertDiskOntoMask(int brAt,
                               java.lang.String where)
```
    12/24/2012 intent is to place a break int the mask to permit separation of mask into sub-tree masks.
    Code taken from ArrayDisplay.overlayDisk().
  - insertDiskOntoMask
```
public void insertDiskOntoMask(Point3Dint loc)
```
  - insertDiskOntoMask
```
public void insertDiskOntoMask(int brAt,
                               int insertPt)
```
  - floodfillMaskFromTop
```
public void floodfillMaskFromTop()
```
    12/24/2012 intent is for after adding diskOntoMask or after split tree into 2 sub-trees, then need to regenerate the tree masks.
  - getTreeMask
```
public boolean[][][] getTreeMask()
```
  - setTreeMask
```
public void setTreeMask(boolean[][][] M)
```
  - smoothTreeBranches
```
public void smoothTreeBranches()
```
    4/2/2013 Intent is to create smooth fits to the branches for future simulated vessel calc. Invoking Branches.computeNodes() fits the nodal params to the skeleton points, erasing any changes made during an optimization step.
  - findFarthestFalseConnection
```
public int findFarthestFalseConnection()
```
    Intent is to find children whose angle from each other is large (>110 degrees) AND whose radius is larger than the parent. From all the possible false connections, start with the one with the smallest branch radius (farthest down the tree), fix this one, then continue on to the next one.
    Will go through this function repeatedly until all false connections are covered.
    
    Parameters:
    
    boolean - exclude1BadLevel [false] intended for when have already corrected all loops and are looking to split tres. This excludes splitting if only 1 branch > parent, rather than 2 or more in a row up the tree are bad. This is intended to give some robustness to noise, but fails if you happen to be at one branch from the top of a falsely connected tree.
  - findFarthestFalseConnection
```
public int findFarthestFalseConnection(boolean exclude1BadLevel)
```
  - getLongestBranchPath
```
public int[] getLongestBranchPath()
```
    9/2/2012 intent is to find the longest branch path, starting from the farthest branch and tracing backwards via parents.
    question is whether I should change the tree structure to match, or just mark the path tree top, first branch is level #1, so the reach should include the 1st branch.
  - getAncesterList
```
public int[] getAncesterList(int brat)
```
    7/8/2014 intent is to return a list of indices for the parent-ancesters of branch brat
  - getLengthHistogram
```
public float[][] getLengthHistogram(int nBins)
```
  - getLargestBranchLength
```
public float getLargestBranchLength()
```
  - getLargestBranchRadius
```
public float getLargestBranchRadius()
```
  - getRadiusHistogram
```
public float[][] getRadiusHistogram(int nBins)
```
  - getTortuosityHistogram
```
public float[][] getTortuosityHistogram(int nBins)
```
  - Draw
```
public void Draw(ArrayDisplay ad)
```
  - Draw
```
public void Draw(ArrayDisplay ad,
                 boolean drawAsRadius)
```
  - reCreateSimImage
```
public void reCreateSimImage()
```
  - createSimImage
```
public void createSimImage(int depth,
                           int width,
                           int ht)
```
  - createSimImage
```
public void createSimImage(int depth,
                           int width,
                           int ht,
                           float radiusExpansion)
```
  - createSimImage
```
public void createSimImage(int depth,
                           int width,
                           int ht,
                           float radiusExpansion,
                           boolean createEndCaps)
```
  - createSimImage
```
public void createSimImage(int depth,
                           int width,
                           int ht,
                           Rectangle3D roi)
```
  - createSimImage
```
public void createSimImage(int depth,
                           int width,
                           int ht,
                           float radiusExpansion,
                           Rectangle3D roi)
```
  - createSimImage
```
public void createSimImage(int depth,
                           int width,
                           int ht,
                           float radiusExpansion,
                           Rectangle3D roi,
                           boolean createEndCaps)
```
  - createIsotropicSimImage
```
public void createIsotropicSimImage(int depth,
                                    int width,
                                    int ht)
```
  - createIsotropicSimImage
```
public void createIsotropicSimImage(int depth,
                                    int width,
                                    int ht,
                                    float radiusExpansion)
```
  - getSimImage
```
public byte[][][] getSimImage(int depth,
                              int width,
                              int ht)
```
    Compute the simImg if it doesn't exist already.
    Requires having already invoked smoothTreeBranches(). Don't want to call it here in case the nodal params were set outside in an optimization routine.
  - getSimImage
```
public byte[][][] getSimImage(int depth,
                              int width,
                              int ht,
                              Rectangle3D roi)
```
  - getIsotropicSimImage
```
public byte[][][] getIsotropicSimImage(int depth,
                                       int width,
                                       int ht)
```
  - getBranchNodeSimImage
```
public byte[][][] getBranchNodeSimImage(int brAt,
                                        int nodeAt,
                                        Rectangle3D nodROI)
```
    Intent is to create the similated vessel image only over the node of interest, over which to compute the correlation (NCCC) to the original image, for optimizing the nodal parameters.
    This is put in VesselTree because the ROI may extend to the parent or children of the current branch
  - getBranchNodeROI
```
public boolean[][][] getBranchNodeROI(int brAt,
                                      int nodeAt,
                                      int depth,
                                      int width,
                                      int height)
```
    Intent is to create a mask that contains the region of influence for a given branch node over which to compute the correlation (NCCC) to the original image, for optimizing the nodal parameters.
    This is put in VesselTree because the ROI may extend to the parent or children of the current branch
    Creating an Roi larger than the vessel by generating a simulated image with the branch radius increased by (rad*1.8f +1), and then setting as On any (byte)pixel with value >= 1. Same extention as used by VesselBranch.calcRoiAndMask(()
  - adjustNodalParam
```
public void adjustNodalParam(int brAt,
                             int nodeAt,
                             int paramAt,
                             float adjustBy)
```
    change the nodal param and recompute the smooth points that the sim image is based on.
    If at an end node also change the attached parent/sibling or children
    
    Parameters:
    
    adjustBy - in [pixels] if adjusting a coord parameter. Is unit-less for slopes
  - OptToImage
```
public void OptToImage(byte[][][] targetImg)
```
    4/34/2013 optimize over each branch params. driven by NCCC to the original image.
  - OptToImage
```
public void OptToImage(short[][][] targetImg)
```
    4/34/2013 optimize over each branch params. driven by NCCC to the original image
  - setBrBGImages
```
public void setBrBGImages(int depth,
                          int width,
                          int height)
```
    create background images. Want to do for all branches prior to adjusting any params.
  - OptRadii
```
public void OptRadii(int iter)
```
    WO 4/11/2012 parallel version. Invoking a separate thread for each branch, where the outcome is to change the values in the global Nodes[][] array.
  - OptNodes
```
public void OptNodes(int iterAt)
```
    WO 4/16/2012 parallel version. Invoking a seaprate thread for each branch, where the outcome is to change the values in the global Nodes[][] array.
  - OptBranchRadius
```
public void OptBranchRadius(int brAt,
                            int iterAt)
```
    optimize over the branch radius, driven by NCCC to the original image.
    At the bifurcation point between a parent and its children all node position xyz values move together, so make the convention here that if you are at the first node and you have a parent, then do not opt over the coords of the first node, but do opt over the slopes. The first node coords will be opt'd when the parent's last node is optimized.
  - OptBranchTaper
```
public void OptBranchTaper(int brAt,
                           int iterAt)
```
    optimize over the branch radius taper, driven by NCCC to the original image.
  - OptBranchNode
```
public void OptBranchNode(int brAt,
                          int nodeAt,
                          int iterAt)
```
    optimize over each node's 6 parameters X,Y,Z, DXDS, DYDS, DZDS driven by NCCC to the original image,
    If at the first node and the branch has a parent then do not opt over the coord params because those are already being optimized when the parent's last node's coords are optimized. At each birfucation all coords are moved together.
    Do opt over the nodal slopes.
    There are a maximum of 4 nodes per branch, where node refers to FEM nomeclature of point along branch.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toString
```
public java.lang.String toString(boolean summaryOnly)
```
  - PrintSimTreeParams
```
public java.lang.String PrintSimTreeParams()
```
  - ReadSimTreeParams
```
public boolean ReadSimTreeParams(java.lang.String path)
```
  - getFittedCenterlinePts_mm
```
public float[][][][] getFittedCenterlinePts_mm()
```
    goal is to retrieve the fitted centerline points for all branches, including the bifurcation model from parent to child, to look for errors (bending) in the centerline fits. The fitted bifurcatin pts are in mm while the regular branch smooth pts are in pixels, so need to converty those.
  - createSTL
```
public java.lang.String createSTL()
```
    goal is to create an stl file to be used for CAD and 3D printing of the vessel tree. STL files in ASCII format are essentially a triangular mesh.
    
    Returns:
    
    string containing the stl formatting for this tree
  - printTreeHierarchy
```
public void printTreeHierarchy()
```
  - shiftInZ
```
public void shiftInZ(int zshift)
```

Class VesselTree

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

Branches

nBranches

maxActiveBranchIndex

maxInitBranches

minBranchLength

Label

nLevels

TreeTop

skelWasChanged

simTreeImg

isotropicSimTreeImg

TreeMask

maskDepth

maskWidth

maskHeight

mmPerPixelXY

mmPerPixelZ

maxBrRadius

maxBrLength

maxBrTort

maxPathLength

OneMainBranch

origImg

origImgByte

isByte

useTaper

withContrast

nLoopPts

Constructor Detail

VesselTree

VesselTree

VesselTree

Method Detail

Copy

Duplicate

clear

addBranch

branchExists

getMostRecentBranch

getMostRecentIndex

getTopBranchIndex

getBranchWithStartLoc

deleteBranch_MergeSiblingToParent

deleteBranchAndChildren

addBranchAndChildren

extend

getVolume

getTreeTop

getTreeTopPt3D

isPointInTree

resetLevels

resetALevel

getNlevels

getNbranches

getNbranchesAtLevel

getBranchChildren

clipRadiusIncreases

clipBranchRadiusIncreases

trimStubs

plugMaskAtPoint

insertDiskOntoMask

insertDiskOntoMask

insertDiskOntoMask

floodfillMaskFromTop

getTreeMask

setTreeMask

smoothTreeBranches

findFarthestFalseConnection

findFarthestFalseConnection

getLongestBranchPath

getAncesterList

getLengthHistogram

getLargestBranchLength