VesselBranch (WOImageJ API)

java.lang.Object
- woSource.math.VesselBranch

public class VesselBranch
extends java.lang.Object

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`availDOF`
`protected float`	`avgRad`
`byte[][][]`	`BGimage`
`protected int[]`	`children`
`boolean`	`contrastWasUsed`
`float[][]`	`fittedBifurCenterlinePts_mm`
`boolean[][][]`	`imgMask`
`protected float`	`length`
`protected int`	`level`
`int`	`maxNNodes`
`int`	`maxPts`
`protected float`	`mmPerPixelXY`
`protected float`	`mmPerPixelZ`
`protected int`	`myIndex`
`protected int`	`NangleSteps`
`protected int`	`nChildren`
`protected int`	`NinterPts`
`int`	`nnodes`
`float[][]`	`Nodes`
`protected int`	`nPhiPts`
`int`	`npts`
`int`	`nsmpts`
`int`	`nSmPtsPerElement`
`protected int`	`parClipEndPtIndex`
`protected int`	`parentIndex`
`protected float`	`parThetaOffset`
`Point3Dint[]`	`pts`
`float`	`relativeWallBrightness`
`float`	`relativeWallThickness`
`Rectangle3D`	`Roi`
`protected int`	`selfClipEndPtIndex`
`protected int`	`selfClipFrontPtIndex`
`float[][]`	`smoothPts`
`float[][][]`	`SurfPts`
`protected float`	`taper`
`protected float[][][]`	`tmpSurfPts`
`protected float`	`tortuosity`
`boolean`	`wasTraversed`

Constructor Summary

Constructors
Constructor and Description
`VesselBranch()`
`VesselBranch(int brat, int par, int lev, float mmPPxy, float mmPPz)`
`VesselBranch(int thisIndex, VesselBranch A)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addChild(int index)`
`void`	`addPt(int x, int y, int z, float radius)`
`void`	`addPt(Point3Dint A)`
`float`	`calcAvgRadius()`
`float`	`calcAvgRadius(int skip)`
`float`	`calcAvgRadius(int skip, int totpts)`
`void`	`calcRoiAndMask(int depth, int width, int height, VesselBranch parentBr)` Intent is to create a mask the contains the region around a given branch node over which to compute the correlation (NCCC) to the original image, for optimizing the branch radius.
`void`	`clear()`
`void`	`computeNodes()` fit a smooth curve through the centerline points
`float[]`	`computeSeriesPtTangent(float[][] A, int ptat)` WO 9/3/2015 compute tangent to the the array of points passed in, in mm Intended for tangent for smoothPts, but generalized also for fitted bifurcation pts.
`void`	`computeSmoothPts(float[] parentBrLastNode)` Fit a smooth curve through the centerline points.
`float`	`computeSmoothPtsLen()`
`float[]`	`computeSmoothPtTangent(int smp)` compute tangent to the smoothPts, in mm
`void`	`CopyAll(VesselBranch A)`
`void`	`CopyPts(VesselBranch A)`
`int`	`createBifurcationMesh(VesselBranch parentBr)` goal to create the surface mesh that interpolates from the parent to this child.
`byte[][][]`	`createElemSimImage(byte[][][] simImg, int elemAt, float radiusAt, float taperAt, Rectangle3D curRoi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createElemSimImage(byte[][][] simImg, int elemAt, float radiusAt, Rectangle3D curRoi, VesselBranch parentBr)`
`byte[][][]`	`createElemSimImage(byte[][][] simImg, int elemAt, Rectangle3D curRoi, VesselBranch parentBr)` WO 3/18/2013 intent is to create an image from the current vessel info for use later as a template to match for the vessel tree.
`byte[][][]`	`createElemSimImage(byte[][][] simImg, int elemAt, Rectangle3D curRoi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createIsotropicSimImage(byte[][][] isoSimImg, float radiusAt, VesselBranch parentBr)`
`byte[][][]`	`createIsotropicSimImage(byte[][][] isoSimImg, float radiusAt, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createIsotropicSimImage(byte[][][] isoSimImg, VesselBranch parentBr)` goal is to create a sim image that can be used to generate a 3D physical model via a 3D printer of the vessel tree.
`byte[][][]`	`createSimImage(byte[][][] simImg, boolean doAsSubImg, int smPtStart, int smPtEnd, float radiusAt, float taperAt, Rectangle3D roi, VesselBranch parentBr, boolean withContrast, boolean fitEnds)` intent is to use the branch smoothed centerline (in pixel units) and passed in radius (in mm) to create a simulated image, based on the known voxel dimensions.
`byte[][][]`	`createSimImage(byte[][][] simImg, float radiusAt, float taperAt, Rectangle3D roi, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(byte[][][] simImg, float radiusAt, float taperAt, Rectangle3D roi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(byte[][][] simImg, float radiusAt, float taperAt, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(byte[][][] simImg, float radiusAt, float taperAt, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(byte[][][] simImg, float radiusAt, Rectangle3D roi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(byte[][][] simImg, float radiusAt, Rectangle3D roi, VesselBranch parentBr, boolean withContrast, boolean fitEnds)`
`byte[][][]`	`createSimImage(byte[][][] simImg, int smPtStart, int smPtEnd, float radiusAt, float taperAt, Rectangle3D roi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(byte[][][] simImg, int smPtStart, int smPtEnd, float radiusAt, float taperAt, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(byte[][][] simImg, int smPtStart, int smPtEnd, float radiusAt, float taperAt, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(byte[][][] simImg, int smPtStart, int smPtEnd, VesselBranch parentBr)` This relies on the smoothPts and the avgRadius to create a simulated image, up to and including smPtEnd
`byte[][][]`	`createSimImage(byte[][][] simImg, int smPtStart, int smPtEnd, VesselBranch parentBr, boolean withContrast)` This relies on the smoothPts and the avgRadius to create a simulated image, up to and including smPtEnd
`byte[][][]`	`createSimImage(byte[][][] simImg, Rectangle3D roi, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(byte[][][] simImg, Rectangle3D roi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(byte[][][] simImg, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(byte[][][] simImg, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(float radiusAt, float taperAt, Rectangle3D roi, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(float radiusAt, float taperAt, Rectangle3D roi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(int depth, int width, int height, float radiusAt, float taperAt, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(int depth, int width, int height, float radiusAt, float taperAt, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(int depth, int width, int height, VesselBranch parentBr)` intent is to use the branch smoothed centerline and passed in radius to create a simulated image, based on the known voxel dimensions.
`byte[][][]`	`createSimImage(int depth, int width, int height, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`createSimImage(Rectangle3D roi, VesselBranch parentBr)`
`byte[][][]`	`createSimImage(Rectangle3D roi, VesselBranch parentBr, boolean withContrast)`
`java.lang.String`	`createSTL()` goal is to create an stl file to be used for CAD and 3D printing of the vessel tree.
`java.lang.String`	`createSTL(VesselBranch parentBr)`
`float[][][]`	`createSurfMesh()` goal is to create an surface mesh of the fitted tubular structure to help with stl file and simulated CT.
`float[][][]`	`createSurfMesh(VesselBranch parentBr)`
`void`	`deleteAllChildrenFromList()`
`void`	`deleteChildFromList(int chindex)`
`void`	`deleteFirstPt()`
`void`	`deleteLastPt()`
`void`	`Draw(ArrayDisplay ad)`
`void`	`Draw(ArrayDisplay ad, boolean drawAsRadius)`
`void`	`Draw(ArrayDisplay ad, boolean drawAsRadius, int colorIndex)`
`void`	`extend(int extension)`
`float`	`getBendingAngle(int ptat)`
`float[][]`	`getBifurcationCenterline(VesselBranch parentBr)` goal to create the surface mesh that interpolates from the parent to this child.
`int[]`	`getChildrenIndices()`
`float[]`	`getEndVector()`
`float[]`	`getEndVector(int skip)` want unit vector[mm] pointing outward (toward children) from last point in branch that best fits through the last NvecPts(global, =5), for computing bifurcation angle.
`Point3Dint`	`getFirstPoint()`
`float[]`	`getFrontVector()`
`float[]`	`getFrontVector(int skip)` gives unit vector pointing distally down current branch from first point in branch that best fits through the first NvecPts(global, =5).
`int`	`getIndex()`
`Point3Dint`	`getLastPoint()`
`float`	`getLength_pixels()`
`float`	`getLength()`
`int`	`getLevel()`
`Point3Dint`	`getMiddlePoint()`
`int`	`getNendSkipPts(float childRad)`
`int`	`getNfrontSkipPts(float parRad)`
`byte[][][]`	`getNodeSimImage(int nodeAt, float radiusAt, float taperAt, Rectangle3D curRoi, VesselBranch parentBr, boolean withContrast)`
`byte[][][]`	`getNodeSimImage(int nodeAt, float radiusAt, Rectangle3D curRoi, VesselBranch parentBr)`
`byte[][][]`	`getNodeSimImage(int nodeAt, Rectangle3D curRoi, VesselBranch parentBr)`
`byte[][][]`	`getNodeSimImage(int nodeAt, Rectangle3D curRoi, VesselBranch parentBr, boolean withContrast)`
`int`	`getParentIndex()`
`Point3Dint`	`getPoint(int ptat)`
`float`	`getPtSep(int brPtAt, int nextPtAt)`
`float`	`getPtSep(int brPtAt, Point3Dint nextPt)`
`float[][]`	`getSmoothPts(float[] parentBrLastNode)`
`Rectangle3D`	`getSmoothPtsBoundingBox(float currad)`
`float[][][]`	`getSurfMesh()`
`float[]`	`getTangent(int ptat)`
`float`	`getTortuosity()`
`float`	`getVolume()`
`boolean`	`hasChildren()`
`boolean`	`isPointInBranch(Point3Dint testPt)`
`void`	`listChildren()`
`java.lang.String`	`listPoints()`
`java.lang.String`	`printNodalParams()` intended to printout to file the fitted nodal values and radius that describes the model of the branch
`boolean`	`readNodalParams(java.io.BufferedReader r)` intended to read in the lines of code (created above) from the openned file r and set the branch params to match
`float`	`retrieveAvgRadius()`
`void`	`reversePoints()`
`void`	`setBGSimImage(byte[][][] simbg)`
`void`	`setLevel(int curlevel)`
`void`	`setParentIndex(int newParent)`
`void`	`shiftInZ(int zshift)`
`java.lang.String`	`toString()`

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

Field Detail

myIndex
```
protected int myIndex
```

parentIndex
```
protected int parentIndex
```

nChildren
```
protected int nChildren
```

children
```
protected int[] children
```

wasTraversed
```
public boolean wasTraversed
```

pts
```
public Point3Dint[] pts
```

npts
```
public int npts
```

maxPts
```
public int maxPts
```

level
```
protected int level
```

avgRad
```
protected float avgRad
```

length
```
protected float length
```

tortuosity
```
protected float tortuosity
```

mmPerPixelXY
```
protected float mmPerPixelXY
```

mmPerPixelZ
```
protected float mmPerPixelZ
```

taper
```
protected float taper
```

nnodes
```
public int nnodes
```

maxNNodes
```
public int maxNNodes
```

availDOF
```
protected int availDOF
```

Nodes
```
public float[][] Nodes
```

nsmpts
```
public int nsmpts
```

nSmPtsPerElement
```
public int nSmPtsPerElement
```

smoothPts
```
public float[][] smoothPts
```

fittedBifurCenterlinePts_mm

public float[][] fittedBifurCenterlinePts_mm

parClipEndPtIndex
```
protected int parClipEndPtIndex
```

selfClipFrontPtIndex
```
protected int selfClipFrontPtIndex
```

selfClipEndPtIndex
```
protected int selfClipEndPtIndex
```

tmpSurfPts
```
protected float[][][] tmpSurfPts
```

parThetaOffset
```
protected float parThetaOffset
```

NinterPts
```
protected int NinterPts
```

NangleSteps
```
protected int NangleSteps
```

nPhiPts
```
protected int nPhiPts
```

Roi
```
public Rectangle3D Roi
```

BGimage
```
public byte[][][] BGimage
```

imgMask
```
public boolean[][][] imgMask
```

SurfPts
```
public float[][][] SurfPts
```

contrastWasUsed
```
public boolean contrastWasUsed
```

relativeWallThickness
```
public float relativeWallThickness
```

relativeWallBrightness
```
public float relativeWallBrightness
```

Constructor Detail

VesselBranch
```
public VesselBranch()
```

VesselBranch

public VesselBranch(int brat,
                    int par,
                    int lev,
                    float mmPPxy,
                    float mmPPz)

VesselBranch

public VesselBranch(int thisIndex,
                    VesselBranch A)

Method Detail
- clear
```
public void clear()
```
- CopyAll
```
public void CopyAll(VesselBranch A)
```
- CopyPts
```
public void CopyPts(VesselBranch A)
```
- addPt
```
public void addPt(int x,
                  int y,
                  int z,
                  float radius)
```
- addPt
```
public void addPt(Point3Dint A)
```
- extend
```
public void extend(int extension)
```
- deleteLastPt
```
public void deleteLastPt()
```
- deleteFirstPt
```
public void deleteFirstPt()
```
- getFirstPoint
```
public Point3Dint getFirstPoint()
```
- getPoint
```
public Point3Dint getPoint(int ptat)
```
- getMiddlePoint
```
public Point3Dint getMiddlePoint()
```
- getLastPoint
```
public Point3Dint getLastPoint()
```
- reversePoints
```
public void reversePoints()
```
- isPointInBranch
```
public boolean isPointInBranch(Point3Dint testPt)
```
- getLevel
```
public int getLevel()
```
- setLevel
```
public void setLevel(int curlevel)
```
- getIndex
```
public int getIndex()
```
- getParentIndex
```
public int getParentIndex()
```
- setParentIndex
```
public void setParentIndex(int newParent)
```
- hasChildren
```
public boolean hasChildren()
```
- getChildrenIndices
```
public int[] getChildrenIndices()
```
- listChildren
```
public void listChildren()
```
- addChild
```
public void addChild(int index)
```
- deleteChildFromList
```
public void deleteChildFromList(int chindex)
```
- deleteAllChildrenFromList
```
public void deleteAllChildrenFromList()
```
- getNfrontSkipPts
```
public int getNfrontSkipPts(float parRad)
```
- getNendSkipPts
```
public int getNendSkipPts(float childRad)
```
- calcAvgRadius
```
public float calcAvgRadius()
```
- calcAvgRadius
```
public float calcAvgRadius(int skip)
```
- calcAvgRadius
```
public float calcAvgRadius(int skip,
                           int totpts)
```
  Parameters:
  
  int - skipfront, totpts where if (skip_totpts) < npts, then it omits pts at the end also
- retrieveAvgRadius
```
public float retrieveAvgRadius()
```
- getLength
```
public float getLength()
```
  Returns:
  
  total length[mm] of branch along centerline
- getLength_pixels
```
public float getLength_pixels()
```
- getPtSep
```
public float getPtSep(int brPtAt,
                      int nextPtAt)
```
  Returns:
  
  distance[mm] between 2 points (straight dist; not along arc)
  @param brPtAt index (0..npt-1) to point of interest on this branch
  @param nextPtAt index (0..npt-1) to another point on this branch
- getPtSep
```
public float getPtSep(int brPtAt,
                      Point3Dint nextPt)
```
  Returns:
  
  distance[mm] between 2 points (straight dist; not along arc)
  @param brPtAt index (0..npt-1) to point of interest on this branch
  @param nextPt is Point3Dint, intended to possibly be a point on another branch
- getVolume
```
public float getVolume()
```
- getTortuosity
```
public float getTortuosity()
```
- getTangent
```
public float[] getTangent(int ptat)
```
  Returns:
  
  tangent vector in mm as x,y,z pointing distally down branch
- getBendingAngle
```
public float getBendingAngle(int ptat)
```
  Returns:
  
  absolute value of bending angle [radians] at this point along branch (returns -1 if branch too short to calc)
- getFrontVector
```
public float[] getFrontVector()
```
- getFrontVector
```
public float[] getFrontVector(int skip)
```
  gives unit vector pointing distally down current branch from first point in branch that best fits through the first NvecPts(global, =5).
  If do not have >= 3 points for regression, use vector through last 2 branch points.
  e.g. for computing bifurcation angle
  
  Parameters:
  
  skip - how many initial points to skip before starting to compute vector (default=0)
- getEndVector
```
public float[] getEndVector()
```
- getEndVector
```
public float[] getEndVector(int skip)
```
  want unit vector[mm] pointing outward (toward children) from last point in branch that best fits through the last NvecPts(global, =5), for computing bifurcation angle.
  
  Parameters:
  
  skip - how many initial points to skip before starting to compute vector (default=0)
- computeNodes
```
public void computeNodes()
```
  fit a smooth curve through the centerline points
- computeSmoothPtTangent
```
public float[] computeSmoothPtTangent(int smp)
```
  compute tangent to the smoothPts, in mm
- computeSeriesPtTangent
```
public float[] computeSeriesPtTangent(float[][] A,
                                      int ptat)
```
  WO 9/3/2015 compute tangent to the the array of points passed in, in mm Intended for tangent for smoothPts, but generalized also for fitted bifurcation pts.
- computeSmoothPts
```
public void computeSmoothPts(float[] parentBrLastNode)
```
  Fit a smooth curve through the centerline points.
  If this branch has only 1 point, then create a 2nd smoothPt midway between this point and the parent's last point.
  Found that the values change slightly on the 2nd run (elem lengths change slightly, so should run through twice initially) 9/20/2013 but if in pixel units then do not need the length so can skip this part.
  Sets smoothPts which are in pixel units. 2/9/2015 for branch.npts=2, nsmpts = 9, but the first 4 or 5 lie within the first pixel, although the smoothPts each are given (float) subpixel locations.
  
  Parameters:
  
  parentBrlastNode - (==parentBr.Nodes[parentBr.nnodes-1]) if npts==1 then use trajectory to parent's last point to generate 2 smooth points.
- getSmoothPts
```
public float[][] getSmoothPts(float[] parentBrLastNode)
```
- computeSmoothPtsLen
```
public float computeSmoothPtsLen()
```
  Returns:
  
  length of path along smooth points, in mm
- getSmoothPtsBoundingBox
```
public Rectangle3D getSmoothPtsBoundingBox(float currad)
```
- Draw
```
public void Draw(ArrayDisplay ad)
```
- Draw
```
public void Draw(ArrayDisplay ad,
                 boolean drawAsRadius)
```
- Draw
```
public void Draw(ArrayDisplay ad,
                 boolean drawAsRadius,
                 int colorIndex)
```
- createElemSimImage
```
public byte[][][] createElemSimImage(byte[][][] simImg,
                                     int elemAt,
                                     Rectangle3D curRoi,
                                     VesselBranch parentBr)
```
  WO 3/18/2013 intent is to create an image from the current vessel info for use later as a template to match for the vessel tree. This generates the image for just the 'element', defined as the branch region between the 2 bounding nodes. "Element" and "nodes" nomenclature comes from FEM.
  Note that if you change a nodal parameter as part of an optimization, then you must also change the smoothPts before calling createElemSimImage() for the nodal change to have an effect.
  
  Parameters:
  
  simImg - informs of image size, but also accumalates values over multiple calls.
  
  elemAt - index of branch element, bounded by node with the same index, and the next node.
  
  (optional) - radiusAt (default is current radius). Intent is to permit setting a later radius to generate region of interest mask.
  
  boolean - withContrast: flag for whether contrast was used in this image. If true sim image will include ring of lower contrast material of radius increased by relativeWallThickness and pixel intensity relativeWallBrightness.
  
  Returns:
  
  simImg cumulative/max of set in simImg and the values generated within
- createElemSimImage
```
public byte[][][] createElemSimImage(byte[][][] simImg,
                                     int elemAt,
                                     Rectangle3D curRoi,
                                     VesselBranch parentBr,
                                     boolean withContrast)
```
- createElemSimImage
```
public byte[][][] createElemSimImage(byte[][][] simImg,
                                     int elemAt,
                                     float radiusAt,
                                     Rectangle3D curRoi,
                                     VesselBranch parentBr)
```
- createElemSimImage
```
public byte[][][] createElemSimImage(byte[][][] simImg,
                                     int elemAt,
                                     float radiusAt,
                                     float taperAt,
                                     Rectangle3D curRoi,
                                     VesselBranch parentBr,
                                     boolean withContrast)
```
- getNodeSimImage
```
public byte[][][] getNodeSimImage(int nodeAt,
                                  Rectangle3D curRoi,
                                  VesselBranch parentBr)
```
- getNodeSimImage
```
public byte[][][] getNodeSimImage(int nodeAt,
                                  Rectangle3D curRoi,
                                  VesselBranch parentBr,
                                  boolean withContrast)
```
- getNodeSimImage
```
public byte[][][] getNodeSimImage(int nodeAt,
                                  float radiusAt,
                                  Rectangle3D curRoi,
                                  VesselBranch parentBr)
```
- getNodeSimImage
```
public byte[][][] getNodeSimImage(int nodeAt,
                                  float radiusAt,
                                  float taperAt,
                                  Rectangle3D curRoi,
                                  VesselBranch parentBr,
                                  boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(int depth,
                                 int width,
                                 int height,
                                 VesselBranch parentBr)
```
  intent is to use the branch smoothed centerline and passed in radius to create a simulated image, based on the known voxel dimensions.
  Passing in radius to be used so that can easily generated a region of interest mask by passing in a larger radius. Default radius, if not specified, is the current radius.
  Breaking up smooth points as each reflects a node.
  
  Parameters:
  
  int - depth, width, height: dimensions of simulated image to be created
  
  float - radiusAt: (default is current branch radius)
  
  float - taperAt: (dflt = taper) decrease in radius along length of branch as %difference (0..1.0) between end radii and with the taper effect = 0 in the middle of the branch, thus front radius = radius- 0.5*taper.
  
  Rectangle3D - roi: limits search and size of output simImage to this Roi
  
  boolean - withContrast: flag for whether contrast was used in this image. If true sim image will include ring of lower contrast material of radius increased by relativeWallThickness and pixel intensity relativeWallBrightness.
  
  boolean - createEndCaps: flag to create a hemisphere (or hemi-disk in 2D) at the distal end of each branch. Turning this Off to make mask of just the branch lumin and preserve the ends.
  
  Returns:
  
  byte image of size = roi
- createSimImage
```
public byte[][][] createSimImage(int depth,
                                 int width,
                                 int height,
                                 float radiusAt,
                                 float taperAt,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(Rectangle3D roi,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(float radiusAt,
                                 float taperAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 Rectangle3D roi,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 int smPtStart,
                                 int smPtEnd,
                                 VesselBranch parentBr)
```
  This relies on the smoothPts and the avgRadius to create a simulated image, up to and including smPtEnd
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 float radiusAt,
                                 float taperAt,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 float radiusAt,
                                 float taperAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 int smPtStart,
                                 int smPtEnd,
                                 float radiusAt,
                                 float taperAt,
                                 VesselBranch parentBr)
```
- createSimImage
```
public byte[][][] createSimImage(int depth,
                                 int width,
                                 int height,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(int depth,
                                 int width,
                                 int height,
                                 float radiusAt,
                                 float taperAt,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(float radiusAt,
                                 float taperAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 int smPtStart,
                                 int smPtEnd,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
  This relies on the smoothPts and the avgRadius to create a simulated image, up to and including smPtEnd
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 float radiusAt,
                                 float taperAt,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 float radiusAt,
                                 float taperAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 float radiusAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 float radiusAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast,
                                 boolean fitEnds)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 int smPtStart,
                                 int smPtEnd,
                                 float radiusAt,
                                 float taperAt,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 int smPtStart,
                                 int smPtEnd,
                                 float radiusAt,
                                 float taperAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast)
```
- createSimImage
```
public byte[][][] createSimImage(byte[][][] simImg,
                                 boolean doAsSubImg,
                                 int smPtStart,
                                 int smPtEnd,
                                 float radiusAt,
                                 float taperAt,
                                 Rectangle3D roi,
                                 VesselBranch parentBr,
                                 boolean withContrast,
                                 boolean fitEnds)
```
  intent is to use the branch smoothed centerline (in pixel units) and passed in radius (in mm) to create a simulated image, based on the known voxel dimensions.
  Passing in radius to be used so that can easily generate a region of interest mask by passing in a larger radius. Default radius, if not specified, is the current radius.
  Breaking up smooth points as each reflects a node.
  12/10/2014 adding lighter ring for larger vessels to represent the wall thickness. This relies on the smoothPts and the avgRadius to create a simulated image, up to and including smPtEnd. 8/11/2015 incorporating bifurcation region model for STL in simImg calc.
  
  Parameters:
  
  byte[][][] - simImg: cumulative simulated image to be created or added to.
  
  boolean - doAsSubImg: flag indicating that the image to be created is a sub-image of a full image. If On then the coords of all branch points will need to be shifted by roi.x, roi.y, roi.z to accomodate the sub-image coordinate system. The dimensions of the roi must equal that of the passed-in sub-image.
  
  int - smPtStart, smPtEnd: can limit ROI to section of branch defined the by smoothpoint. Used usually to limit to a node for optimization of nodal parameters. (default is entire branch length). However, if doBifurModel==true then will reset these to match the start and beginning of the fitted centerline region.
  
  float - radiusAt[mm]: (default is current branch radius)
  
  float - taperAt: (dflt = taper) decrease in radius along length of branch as %difference (0..1.0) between end radii and with the taper effect = 0 in the middle of the branch, thus front radius = radius- 0.5*taper.
  
  Rectangle3D - roi: limits search and size of output simImage to this Roi. If Roi == null, then will create one based on the branch smooth points and current radius
  
  boolean - withContrast: flag for whether contrast was used in this image. If true sim image will include ring of lower contrast material of radius increased by relativeWallThickness and pixel intensity relativeWallBrightness.
  
  boolean - fitEnds: flag to create a smooth bifurcation model or a hemisphere (or hemi-disk in 2D) at the distal end of each branch. (not used) @param boolean highSampling: flag to use much finer smoothPts. When creating a simulated mesh want to have very high sampling along the central axis, while for creating a surface mesh need only a coarse resolution (a point every 2 pixels).
  
  Returns:
  
  byte image of size = roi
- createIsotropicSimImage
```
public byte[][][] createIsotropicSimImage(byte[][][] isoSimImg,
                                          VesselBranch parentBr)
```
  goal is to create a sim image that can be used to generate a 3D physical model via a 3D printer of the vessel tree. I want to make the slice thickness of the resulting image to be the same mm as the in-plane pixels
  
  Parameters:
  
  simImg[][][] - assume the dimensions dwh = those of the larger, isotropic image
  
  radiusAt - default=current radius. Give option to create an expanded radius version for mask creation.
  
  Returns:
  
  binary image with number of slices adjusted (increased typically) to make isotropic
- createIsotropicSimImage
```
public byte[][][] createIsotropicSimImage(byte[][][] isoSimImg,
                                          float radiusAt,
                                          VesselBranch parentBr)
```
- createIsotropicSimImage
```
public byte[][][] createIsotropicSimImage(byte[][][] isoSimImg,
                                          float radiusAt,
                                          VesselBranch parentBr,
                                          boolean withContrast)
```
- getSurfMesh
```
public float[][][] getSurfMesh()
```
- createSurfMesh
```
public float[][][] createSurfMesh()
```
  goal is to create an surface mesh of the fitted tubular structure to help with stl file and simulated CT. Uses the smoothPts as the pts along the axis on which to compute the radial projections.
  10/16/2013 starting each child branch mesh from the parent's last point, to prevent disconnected branches.
  Create spherical cap on distal end. Children should intersect parent's spherical cap.
  11/1/2013 still have problem of occasional twisting of mesh from one smoothPt to the next.
  11/6/2013 theory of twists is if along the branch at one location the tangent is close to but with slope just
  less than the test vector (5,7,3), and the next point has tangent just greater than the test vector, the
  local X-axis may be 180-deg between the two. Implemented solution is to define a test vec specifically for each
  branch that is perpendicular to the avg tangent of the branch. This should work unless the branch has a 90-degree
  bend directly into the new test vec.
  2/14/2014 The hemi-spherical cap does not look good/realistic. Implemented creating a curved branch connection between the parent and each child with a tapered tube connecting them. The parent end, and child fronts are clipped 3 smooth points and the curved centerline fit using hermit interpolation. Linking directly the last STL mesh ring of the parent with each child to remove small gaps.
  Want hemispheres only on terminating branch ends.
  8/7/2014 3D printout fell apart. Need to solidly close up the connection between branches.
  But biggest problem is/was that whereas I computed and printed to the STL output file the coords of the vector normal to each surface triangle, some CAD programs (netfabb basic, and the 3D printer) ignore the passed-in normal vector and instead compute the outward normal based on the order of the vertices. And I had not paid attension to the order hence about half the time the order was incorrect so the normal pointed inwards. This is now fixed.
  The bifurcation mesh to parent starts at parentbr.smoothPts[endPtIndex] and ends at (curbr)smoothPts[selfClipFrontIndex -1].
  To improve connection between parent and child, define the theta of the child mesh points to match that of the parent. Also for now making the nThetaSteps the same for all branches to avoid gaps at connections.
  If this branch has children, then will create a bifurcation mesh to them, starting up from the end of the smoothPts array at the index selfClipEndPtIndex that must = the 'parClipEndPtIndex' gotten when running the children's getBifurCenterline().
  
  Returns:
  
  float[axial pts][circumferential pts][XYZ] containing the surface mesh in mm units for this branch
- createSurfMesh
```
public float[][][] createSurfMesh(VesselBranch parentBr)
```
- getBifurcationCenterline
```
public float[][] getBifurcationCenterline(VesselBranch parentBr)
```
  goal to create the surface mesh that interpolates from the parent to this child. In the future would like to create a single mesh for both children rather than having 2 child meshes that superpose.
  This gets the fitted centerline between the child to the parent starting from parentBr.smoothPts[parClipEndPtIndex] to (current branch) smoothPts[selfClipFrontPtIndex], inclusive of those points. So the parent fitted surface mesh ends with an uncapped/open end, with a ring around parentBr.smoothPts[parClipEndPtIndex], and the bifurcation mesh starts with an uncapped/open end, with a ring at those same parent mesh points.
  The bifurcation centerline goes to smoothPts[selfClipFrontPtIndex] but the bifurcation mesh ends as an open ring at smoothPts[selfClipFrontPtIndex-1].
  9/4/2015 setting length of bifurcation region (distance up into parent/child) equal to the radius of the vessel. Thus if it is a big vessel then give a longer extension. The parameters below are the same as for the surface mesh.
  
  Parameters:
  
  parentBr -
  
  NangleSteps, - nPhiPts, NinterPts all from the createSurfMesh()
  
  Returns:
  
  bifurCenterlinePts_mm[NinterPts][xyz]
- createBifurcationMesh
```
public int createBifurcationMesh(VesselBranch parentBr)
```
  goal to create the surface mesh that interpolates from the parent to this child. In the future would like to create a single mesh for both children rather than having 2 child meshes that superpose.
  The bifurcation centerline goes to smoothPts[selfClipFrontPtIndex] but the bifurcation mesh ends as an open ring at smoothPts[selfClipFrontPtIndex-1] so that the regular branch smoothPts mesh interfaces with it without overlap.
  
  Parameters:
  
  parentBr -
  
  NangleSteps, - nPhiPts, NinterPts all from the createSurfMesh()
  
  Returns:
  
  surfPtIndex = index to end of tmpSurfPts array.
- 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.
  8/12/2014 The 3D printer and many CAD programs (solidworks, MiniMagic) do not use the entered facet normal values but instead compute the normal based on the triangle vertices and the right-hand rule.
  Unfortunately I had these reversed for almost all of the theta steps in my first version.
  
  Returns:
  
  string containing the stl formatting for this branch
- createSTL
```
public java.lang.String createSTL(VesselBranch parentBr)
```
- calcRoiAndMask
```
public void calcRoiAndMask(int depth,
                           int width,
                           int height,
                           VesselBranch parentBr)
```
  Intent is to create a mask the contains the region around a given branch node over which to compute the correlation (NCCC) to the original image, for optimizing the branch radius.
- setBGSimImage
```
public void setBGSimImage(byte[][][] simbg)
```
- toString
```
public java.lang.String toString()
```
  Overrides:
  
  toString in class java.lang.Object
- listPoints
```
public java.lang.String listPoints()
```
- printNodalParams
```
public java.lang.String printNodalParams()
```
  intended to printout to file the fitted nodal values and radius that describes the model of the branch
- readNodalParams
```
public boolean readNodalParams(java.io.BufferedReader r)
```
  intended to read in the lines of code (created above) from the openned file r and set the branch params to match
- shiftInZ
```
public void shiftInZ(int zshift)
```

Class VesselBranch

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

myIndex

parentIndex

nChildren

children

wasTraversed

pts

npts

maxPts

level

avgRad

length

tortuosity

mmPerPixelXY

mmPerPixelZ

taper

nnodes

maxNNodes

availDOF

Nodes

nsmpts

nSmPtsPerElement

smoothPts

fittedBifurCenterlinePts_mm

parClipEndPtIndex

selfClipFrontPtIndex

selfClipEndPtIndex

tmpSurfPts

parThetaOffset

NinterPts

NangleSteps

nPhiPts

Roi

BGimage

imgMask

SurfPts

contrastWasUsed

relativeWallThickness

relativeWallBrightness

Constructor Detail

VesselBranch

VesselBranch

VesselBranch

Method Detail

clear

CopyAll

CopyPts

addPt

addPt

extend

deleteLastPt

deleteFirstPt

getFirstPoint

getPoint

getMiddlePoint

getLastPoint

reversePoints

isPointInBranch

getLevel

setLevel

getIndex

getParentIndex

setParentIndex

hasChildren

getChildrenIndices

listChildren

addChild

deleteChildFromList

deleteAllChildrenFromList

getNfrontSkipPts

getNendSkipPts

calcAvgRadius

calcAvgRadius

calcAvgRadius

retrieveAvgRadius