Balloon (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- java.lang.Thread
- - sc.fiji.balloonSegmentation.structure.Balloon

All Implemented Interfaces:

Runnable
```
public class Balloon
extends Thread
```

Nested Class Summary
- Nested classes/interfaces inherited from class java.lang.Thread
  Thread.State, Thread.UncaughtExceptionHandler

Field Summary

Fields
Modifier and Type	Field and Description
`double`	`area`
`int`	`div_x0`
`int`	`div_x1`
`int`	`div_y0`
`int`	`div_y1`
`boolean`	`docontact`
`int[]`	`FIX`
`ArrayList<Double>`	`history_radius`
`int`	`id`
`int`	`id_line`
`int`	`id_mother`
`boolean`	`is_growing`
`double`	`Ixx`
`double`	`Ixy`
`double`	`Iyy`
`double`	`lx`
`double`	`ly`
`int`	`n_generation`
`int`	`n0`
`double`	`PixLevel`
`PolygonRoi`	`Proi`
`double`	`radius`
`double`	`radius_min`
`double`	`Radius0`
`double`	`sig_vol`
`Matrix`	`StrainTensor`
`double[]`	`StrainValues`
`Matrix`	`StrainVector`
`int`	`x0`
`double[]`	`XX`
`int`	`y0`
`double[]`	`YY`

Fields inherited from class java.lang.Thread
MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

Constructor Summary

Constructors
Constructor and Description
`Balloon(int[] Ax, int[] Ay, int ID, ij.process.ImageProcessor ip, BalloonPopulation BP, int rgbchannel)` Balloon Constructor with of previously shaped structure: need list spatial coordinates (x,y) of the vertices of the envelop and ID of the balloon to be given
`Balloon(int x, int y, int ID, ij.process.ImageProcessor ip, BalloonPopulation BP, int rgbchannel)` Balloon Constructor used before inflation: need initial spatial coordinates (x,y) and ID of the balloon to be given

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double[]`	`add(double[] a, double[] b)` Math vector operators: addition of 2 vectors a+b (I made this before I start using JAMA library)
`double`	`angle(double x1, double y1, double x2, double y2)` Math vector operators: determine angle between v2 (x2, y2) and v1 (x1,y1) (I made this before I start using JAMA library)
`int[][]`	`Cexpand(boolean is_interface)` expand prospectively the balloon for visualization contact
`boolean`	`contact(double x, double y, int bx0, int by0)` test if a vertex of coorinate (x,y) is in contact with the given balloon
`boolean`	`contain(double x, double y, int bx0, int by0)` test if a vertex of coorinate (x,y) is contained in given balloon
`double[]`	`cross(double[] a, double[] b)` Math vector operators: cross product of vector a by vector b in R3 (I made this before I start using JAMA library)
`double`	`dist(double[] a, double[] b)` Math vector operators: distance between 2 points (I made this before I start using JAMA library)
`double`	`dot(double[] a, double[] b)` Math vector operators: dot product (I made this before I start using JAMA library)
`void`	`encastre(int i)`
`void`	`Fill_balloon(ij.ImagePlus i1)` Decorates the balloon according to field and tensor values in the cell
`void`	`Fill_balloon(ij.ImagePlus i1, int level)` Decorates the balloon according to field and tensor values in the cell
`void`	`fix(int i)` Fix the vertex i (e.g.
`Point`	`getPoint()` Get a Point at the center of the cell
`int[]`	`getXXi()` get X coordinates of the balloon as a array of integer
`int[]`	`getYYi()` get Y coordinates of the balloon as a array of integer
`void`	`Inflate_inc()` perform a time step of the physical engine.
`void`	`init_opt()` rest prior to optimisation step (snake)
`void`	`init()` Init function used to re-init ballons (called with InitiateGrowingRegion() but without the constructor)
`void`	`InitiateGrowingRegion()` Initiatiation Balloons as circles before inflation
`void`	`loadProperties()`
`void`	`mass_geometry()` Finding the center of mass of the balloon and quadratic moments of the balloons
`double`	`norm(double[] a)` Math vector operators: norm2 of vector a (I made this before I start using JAMA library)
`double`	`norm(double x, double y)` Math vector operators: norm2 of vector (I made this before I start using JAMA library)
`double[]`	`normalized(double[] a)` Math vector operators: return the normalized vector (I made this before I start using JAMA library)
`void`	`Optimize_inc()` perform a time step for optimal positioning of the balloon (snake)
`double[]`	`prod(double[] a, double b)` Math vector operators: multiplication of a vector a by a scala b (I made this before I start using JAMA library)
`double[]`	`prod(double[] a, double[] b)` Math vector operators: componentwise multiplication of vector a and vector b (I made this before I start using JAMA library)
`void`	`refineStructure()` reshape balloon prior to optimisation step (snake)
`void`	`run()` Load properties from file
`void`	`setXX(int[] X)` set X coordinates of the balloon
`void`	`setYY(int[] Y)` set X coordinates of the balloon
`double[]`	`sub(double[] a, double[] b)` Math vector operators: substraction a-b (I made this before I start using JAMA library)
`void`	`translateTo(int x, int y)` translate current balloon to (x,y)

Methods inherited from class java.lang.Thread
activeCount, checkAccess, clone, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, toString, yield

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

- Field Detail
  - n0
```
public int n0
```
  - Radius0
```
public double Radius0
```
  - id
```
public int id
```
  - XX
```
public double[] XX
```
  - YY
```
public double[] YY
```
  - FIX
```
public int[] FIX
```
  - x0
```
public int x0
```
  - y0
```
public int y0
```
  - Proi
```
public PolygonRoi Proi
```
  - PixLevel
```
public double PixLevel
```
  - Ixx
```
public double Ixx
```
  - Iyy
```
public double Iyy
```
  - Ixy
```
public double Ixy
```
  - lx
```
public double lx
```
  - ly
```
public double ly
```
  - area
```
public double area
```
  - radius
```
public double radius
```
  - radius_min
```
public double radius_min
```
  - docontact
```
public boolean docontact
```
  - sig_vol
```
public double sig_vol
```
  - StrainVector
```
public Matrix StrainVector
```
  - StrainValues
```
public double[] StrainValues
```
  - StrainTensor
```
public Matrix StrainTensor
```
  - id_mother
```
public int id_mother
```
  - n_generation
```
public int n_generation
```
  - id_line
```
public int id_line
```
  - div_x0
```
public int div_x0
```
  - div_y0
```
public int div_y0
```
  - div_x1
```
public int div_x1
```
  - div_y1
```
public int div_y1
```
  - is_growing
```
public boolean is_growing
```
  - history_radius
```
public ArrayList<Double> history_radius
```
- Constructor Detail
  - Balloon
```
public Balloon(int x,
               int y,
               int ID,
               ij.process.ImageProcessor ip,
               BalloonPopulation BP,
               int rgbchannel)
```
    Balloon Constructor used before inflation: need initial spatial coordinates (x,y) and ID of the balloon to be given
  - Balloon
```
public Balloon(int[] Ax,
               int[] Ay,
               int ID,
               ij.process.ImageProcessor ip,
               BalloonPopulation BP,
               int rgbchannel)
```
    Balloon Constructor with of previously shaped structure: need list spatial coordinates (x,y) of the vertices of the envelop and ID of the balloon to be given
- Method Detail
  - init
```
public void init()
```
    Init function used to re-init ballons (called with InitiateGrowingRegion() but without the constructor)
  - run
```
public void run()
```
    Load properties from file
    
    Specified by:
    
    run in interface Runnable
    
    Overrides:
    
    run in class Thread
  - loadProperties
```
public void loadProperties()
```
  - InitiateGrowingRegion
```
public void InitiateGrowingRegion()
```
    Initiatiation Balloons as circles before inflation
  - Inflate_inc
```
public void Inflate_inc()
```
    perform a time step of the physical engine. Computes the deformation of the balloon according to pressure and resistance generated by the image topography
  - Optimize_inc
```
public void Optimize_inc()
```
    perform a time step for optimal positioning of the balloon (snake)
  - init_opt
```
public void init_opt()
```
    rest prior to optimisation step (snake)
  - refineStructure
```
public void refineStructure()
```
    reshape balloon prior to optimisation step (snake)
  - translateTo
```
public void translateTo(int x,
                        int y)
```
    translate current balloon to (x,y)
  - contact
```
public boolean contact(double x,
                       double y,
                       int bx0,
                       int by0)
```
    test if a vertex of coorinate (x,y) is in contact with the given balloon
  - contain
```
public boolean contain(double x,
                       double y,
                       int bx0,
                       int by0)
```
    test if a vertex of coorinate (x,y) is contained in given balloon
  - Cexpand
```
public int[][] Cexpand(boolean is_interface)
```
    expand prospectively the balloon for visualization contact
  - fix
```
public void fix(int i)
```
    Fix the vertex i (e.g. contact with another balloon)
  - encastre
```
public void encastre(int i)
```
  - mass_geometry
```
public void mass_geometry()
```
    Finding the center of mass of the balloon and quadratic moments of the balloons
  - Fill_balloon
```
public void Fill_balloon(ij.ImagePlus i1)
```
    Decorates the balloon according to field and tensor values in the cell
  - Fill_balloon
```
public void Fill_balloon(ij.ImagePlus i1,
                         int level)
```
    Decorates the balloon according to field and tensor values in the cell
  - getPoint
```
public Point getPoint()
```
    Get a Point at the center of the cell
  - setXX
```
public void setXX(int[] X)
```
    set X coordinates of the balloon
  - setYY
```
public void setYY(int[] Y)
```
    set X coordinates of the balloon
  - getXXi
```
public int[] getXXi()
```
    get X coordinates of the balloon as a array of integer
  - getYYi
```
public int[] getYYi()
```
    get Y coordinates of the balloon as a array of integer
  - cross
```
public double[] cross(double[] a,
                      double[] b)
```
    Math vector operators: cross product of vector a by vector b in R3 (I made this before I start using JAMA library)
  - prod
```
public double[] prod(double[] a,
                     double[] b)
```
    Math vector operators: componentwise multiplication of vector a and vector b (I made this before I start using JAMA library)
  - prod
```
public double[] prod(double[] a,
                     double b)
```
    Math vector operators: multiplication of a vector a by a scala b (I made this before I start using JAMA library)
  - dot
```
public double dot(double[] a,
                  double[] b)
```
    Math vector operators: dot product (I made this before I start using JAMA library)
  - add
```
public double[] add(double[] a,
                    double[] b)
```
    Math vector operators: addition of 2 vectors a+b (I made this before I start using JAMA library)
  - sub
```
public double[] sub(double[] a,
                    double[] b)
```
    Math vector operators: substraction a-b (I made this before I start using JAMA library)
  - dist
```
public double dist(double[] a,
                   double[] b)
```
    Math vector operators: distance between 2 points (I made this before I start using JAMA library)
  - norm
```
public double norm(double x,
                   double y)
```
    Math vector operators: norm2 of vector (I made this before I start using JAMA library)
  - norm
```
public double norm(double[] a)
```
    Math vector operators: norm2 of vector a (I made this before I start using JAMA library)
  - normalized
```
public double[] normalized(double[] a)
```
    Math vector operators: return the normalized vector (I made this before I start using JAMA library)
  - angle
```
public double angle(double x1,
                    double y1,
                    double x2,
                    double y2)
```
    Math vector operators: determine angle between v2 (x2, y2) and v1 (x1,y1) (I made this before I start using JAMA library)

Class Balloon

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread

Field Summary

Fields inherited from class java.lang.Thread

Constructor Summary

Method Summary

Methods inherited from class java.lang.Thread

Methods inherited from class java.lang.Object

Field Detail

n0

Radius0

id

XX

YY

FIX

x0

y0

Proi

PixLevel

Ixx

Iyy

Ixy

lx

ly

area

radius

radius_min

docontact

sig_vol

StrainVector

StrainValues

StrainTensor

id_mother

n_generation

id_line

div_x0

div_y0

div_x1

div_y1

is_growing

history_radius

Constructor Detail

Balloon

Balloon

Method Detail

init

run

loadProperties

InitiateGrowingRegion

Inflate_inc

Optimize_inc

init_opt

refineStructure

translateTo

contact

contain

Cexpand

fix

encastre

mass_geometry

Fill_balloon

Fill_balloon

getPoint

setXX

setYY

getXXi

getYYi

cross

prod

prod

dot

add

sub

dist

norm

norm

normalized

angle