ROI3D

java.lang.Object
- icy.roi.ROI
- - icy.roi.ROI3D

All Implemented Interfaces:

ChangeListener, XMLPersistent

Direct Known Subclasses:

ROI3DShape, ROI3DStack
```
public abstract class ROI3D
extends ROI
```
3D ROI base class

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class ROI3D.ROI3DPainter
- Nested classes/interfaces inherited from class icy.roi.ROI
  ROI.ROIGroupId, ROI.ROIIdComparator, ROI.ROINameComparator, ROI.ROIPainter

Nested Classes
Modifier and Type	Class and Description
`class`	`ROI3D.ROI3DPainter`

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.String ID_C

static java.lang.String ID_T
- Fields inherited from class icy.roi.ROI
  DEFAULT_COLOR, DEFAULT_NORMAL_COLOR, DEFAULT_OPACITY, DEFAULT_STROKE, defaultColor, defaultOpacity, defaultShowName, defaultStroke, ID_CLASSNAME, ID_COLOR, ID_GROUPID, ID_ID, ID_NAME, ID_OPACITY, ID_PROPERTIES, ID_READONLY, ID_ROI, ID_SELECTED, ID_SHOWNAME, ID_STROKE, idComparator, nameComparator, PROPERTY_COLOR, PROPERTY_CREATING, PROPERTY_GROUPID, PROPERTY_ICON, PROPERTY_NAME, PROPERTY_OPACITY, PROPERTY_READONLY, PROPERTY_SHOWNAME, PROPERTY_STROKE, ROI_CHANGED_ALL, ROI_CHANGED_POSITION

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`ID_C`
`static java.lang.String`	`ID_T`

Constructor Summary

Constructors
Constructor and Description

ROI3D()

Constructors
Constructor and Description
`ROI3D()`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`canSetBounds()` Returns `true` if this ROI accepts bounds change through the `ROI.setBounds5D(Rectangle5D)` method.
`boolean`	`canSetPosition()` Returns `true` if this ROI accepts position change through the `ROI.setPosition5D(Point5D)` method.
`boolean`	`canTranslate()` Returns `true` if the ROI support translate operation.
`abstract Rectangle3D`	`computeBounds3D()` Calculate and returns the 3D bounding box of the `ROI`.
`Rectangle5D`	`computeBounds5D()` Calculate and returns the bounding box of the `ROI`.
`double`	`computeNumberOfContourPoints()` Compute and returns the number of point (pixel) composing the ROI contour.
`double`	`computeNumberOfPoints()` Compute and returns the number of point (pixel) contained in the ROI.
`double`	`computeSurfaceArea(Sequence sequence)` Compute the surface area in um2 given the pixel size informations from the specified Sequence.
`abstract boolean`	`contains(double x, double y, double z)` Tests if the specified coordinates are inside the `ROI`.
`boolean`	`contains(double x, double y, double z, double t, double c)` Tests if a specified 5D point is inside the ROI.
`abstract boolean`	`contains(double x, double y, double z, double sizeX, double sizeY, double sizeZ)` Tests if the `ROI` entirely contains the specified 3D rectangular area.
`boolean`	`contains(double x, double y, double z, double t, double c, double sizeX, double sizeY, double sizeZ, double sizeT, double sizeC)` Tests if the `ROI` entirely contains the specified 5D rectangular area.
`boolean`	`contains(Point3D p)` Tests if a specified `Point3D` is inside the ROI.
`boolean`	`contains(Rectangle3D r)` Tests if the interior of the `ROI` entirely contains the specified `Rectangle3D`.
`boolean`	`contains(ROI roi)` Tests if the `ROI` entirely contains the specified `ROI`.
`BooleanMask3D`	`getBooleanMask(boolean inclusive)` Get the `BooleanMask3D` object representing the roi.
`BooleanMask2D`	`getBooleanMask2D(int z, boolean inclusive)` Get the `BooleanMask2D` object representing the roi for the specified Z position.
`BooleanMask2D`	`getBooleanMask2D(int z, int t, int c, boolean inclusive)` Returns the `BooleanMask2D` object representing the XY plan content at specified Z, T, C position.
`boolean[]`	`getBooleanMask2D(int x, int y, int width, int height, int z, boolean inclusive)` Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z position.
`boolean[]`	`getBooleanMask2D(int x, int y, int width, int height, int z, int t, int c, boolean inclusive)` Returns the boolean array mask for the specified rectangular region at specified C, Z, T position.
`boolean[]`	`getBooleanMask2D(java.awt.Rectangle rect, int z, boolean inclusive)` Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z position.
`BooleanMask3D`	`getBooleanMask3D(int z, int t, int c, boolean inclusive)` Returns the `BooleanMask3D` object representing the XYZ volume content at specified Z, T, C position.
`Rectangle3D.Integer`	`getBounds()` Returns an integer `Rectangle3D` that completely encloses the `ROI`.
`Rectangle3D`	`getBounds3D()` Returns the bounding box of the `ROI`.
`int`	`getC()` Returns the C position.
`java.lang.String`	`getDefaultName()`
`int`	`getDimension()` Returns the number of dimension of the ROI: 2 for ROI2D 3 for ROI3D 4 for ROI4D 5 for ROI5D
`double`	`getLength(Sequence sequence)` Computes and returns the length/perimeter of the ROI in um given the pixel size informations from the specified Sequence.
`Point3D.Integer`	`getPosition()` Returns the integer ROI position which normally correspond to the minimum point of the ROI bounds.
`Point3D`	`getPosition3D()` Returns the high precision ROI position which normally correspond to the minimum point of the ROI bounds.
`static java.util.ArrayList<ROI3D>`	`getROI3DList(java.util.ArrayList<ROI> rois)` Deprecated. Use `getROI3DList(List)` instead.
`static java.util.List<ROI3D>`	`getROI3DList(java.util.List<ROI> rois)` Return all 3D ROI from the ROI list
`double`	`getSurfaceArea()` Deprecated. Use `ROI.getNumberOfContourPoints()` instead.
`double`	`getSurfaceArea(Sequence sequence)` Returns surface area of the 3D ROI in um2 given the pixel size informations from the specified Sequence.
`int`	`getT()` Returns the T position.
`double`	`getVolume()` Deprecated. Use `ROI.getNumberOfPoints()` instead.
`abstract boolean`	`intersects(double x, double y, double z, double sizeX, double sizeY, double sizeZ)` Tests if the interior of the `ROI` intersects the interior of a specified 3D rectangular area.
`boolean`	`intersects(double x, double y, double z, double t, double c, double sizeX, double sizeY, double sizeZ, double sizeT, double sizeC)` Tests if the interior of the `ROI` intersects the interior of a specified rectangular area.
`boolean`	`intersects(Rectangle3D r)` Tests if the interior of the `ROI` intersects the interior of a specified `Rectangle3D`.
`boolean`	`intersects(ROI roi)` Tests if the current `ROI` intersects the specified `ROI`.
`boolean`	`isActiveFor(IcyCanvas canvas)` Return true if the ROI is active for the specified canvas.
`boolean`	`isActiveFor(int t, int c)` Return true if the ROI is active for the specified T, C coordinates
`boolean`	`isOverEdge(IcyCanvas canvas, double x, double y, double z)` Returns true if specified point coordinates overlap the ROI edge.
`boolean`	`isOverEdge(IcyCanvas canvas, double x, double y, double z, double t, double c)` Returns true if specified point coordinates overlap the ROI edge.
`boolean`	`isOverEdge(IcyCanvas canvas, Point3D p)` Returns true if specified point coordinates overlap the ROI edge.
`boolean`	`isOverEdge(IcyCanvas canvas, Point5D p)` Returns true if specified point coordinates overlap the ROI edge.
`boolean`	`loadFromXML(org.w3c.dom.Node node)` LOAD
`boolean`	`saveToXML(org.w3c.dom.Node node)` SAVE
`void`	`setBounds3D(Rectangle3D bounds)` Set the `ROI` 3D bounds.
`void`	`setBounds5D(Rectangle5D bounds)` Set the `ROI` bounds.
`void`	`setC(int value)` Sets C position of this 3D ROI.
`void`	`setPosition3D(Point3D position)` Set the `ROI` 3D position.
`void`	`setPosition5D(Point5D position)` Set the `ROI` position.
`void`	`setT(int value)` Sets T position of this 3D ROI.
`void`	`translate(double dx, double dy, double dz)` Translate the ROI position by the specified delta X/Y/Z.

Methods inherited from class icy.roi.ROI
add, addListener, attachTo, beginUpdate, canvasToImageDeltaX, canvasToImageDeltaY, canvasToImageLogDeltaX, canvasToImageLogDeltaX, canvasToImageLogDeltaX, canvasToImageLogDeltaX, canvasToImageLogDeltaY, canvasToImageLogDeltaY, canvasToImageLogDeltaY, canvasToImageLogDeltaY, contains, contains, copyFrom, create, create, create, create, createFromXML, delete, delete, detachFrom, detachFromAll, detachFromAll, endUpdate, exclusiveAdd, focusChanged, getAdjustedStroke, getAdjustedStroke, getBooleanMask2D, getBounds5D, getClassName, getColor, getCopy, getDefaultColor, getDefaultOpacity, getDefaultShowName, getDefaultStroke, getDisplayColor, getExclusiveUnion, getFirstSequence, getFocusedColor, getGroupId, getIcon, getId, getIntersection, getName, getNameSuffix, getNumberOfContourPoints, getNumberOfPoints, getOpacity, getOverlay, getPainter, getPerimeter, getPosition5D, getProperties, getProperty, getPropertyValue, getROICount, getROIList, getROIList, getROIList, getROIsFromXML, getSelectedColor, getSequences, getShowName, getSimpleClassName, getStroke, getSubROI, getSubtraction, getUnion, hasSelectedPoint, internalFocus, internalSelect, internalUnfocus, internalUnselect, intersect, intersects, isAttached, isCreating, isDefaultName, isEditable, isEmpty, isFocused, isReadOnly, isSelected, isUpdating, loadFromXML, loadROIsFromXML, merge, mergeWith, nameChanged, onChanged, painterChanged, propertyChanged, remove, remove, removeListener, roiChanged, roiChanged, roiChanged, saveROIsToXML, selectionChanged, setColor, setCreating, setDefaultColor, setDefaultOpacity, setDefaultShowName, setDefaultStroke, setEditable, setFocused, setGroupId, setIcon, setMousePos, setName, setOpacity, setProperty, setPropertyValue, setReadOnly, setROIsFromXML, setSelected, setSelected, setSelectedColor, setShowName, setStroke, subtract, unselectAllPoints

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

- Field Detail
  - ID_T
```
public static final java.lang.String ID_T
```
    See Also:
    Constant Field Values
  - ID_C
```
public static final java.lang.String ID_C
```
    See Also:
    Constant Field Values
- Constructor Detail
  - ROI3D
```
public ROI3D()
```
- Method Detail
  - getROI3DList
```
@Deprecated
public static java.util.ArrayList<ROI3D> getROI3DList(java.util.ArrayList<ROI> rois)
```
    Deprecated. Use getROI3DList(List) instead.
  - getROI3DList
```
public static java.util.List<ROI3D> getROI3DList(java.util.List<ROI> rois)
```
    Return all 3D ROI from the ROI list
  - getDefaultName
```
public java.lang.String getDefaultName()
```
    Overrides:
    
    getDefaultName in class ROI
    
    Returns:
    the default name for this ROI class
  - getDimension
```
public final int getDimension()
```
    Description copied from class: ROI
    
    Returns the number of dimension of the ROI:
    2 for ROI2D
    3 for ROI3D
    4 for ROI4D
    5 for ROI5D
    
    Specified by:
    
    getDimension in class ROI
  - contains
```
public boolean contains(Point3D p)
```
    Tests if a specified Point3D is inside the ROI.
    
    Parameters:
    p - the specified Point3D to be tested
    
    Returns:
    true if the specified Point3D is inside the boundary of the ROI; false otherwise.
  - contains
```
public boolean contains(Rectangle3D r)
```
    Tests if the interior of the ROI entirely contains the specified Rectangle3D. The ROI.contains() method allows a implementation to conservatively return false when:
    - the intersect method returns true and
    - the calculations to determine whether or not the ROI entirely contains the Rectangle3D are prohibitively expensive.
    This means that for some ROIs this method might return false even though the ROI contains the Rectangle3D.
    Parameters:
    r - The specified Rectangle3D
    
    Returns:
    true if the interior of the ROI entirely contains the Rectangle3D; false otherwise or, if the ROI contains the Rectangle3D and the intersects method returns true and the containment calculations would be too expensive to perform.
    See Also:
    contains(double, double, double, double, double, double)
  - contains
```
public abstract boolean contains(double x,
               double y,
               double z)
```
    Tests if the specified coordinates are inside the ROI.
    
    Parameters:
    x - the specified X coordinate to be tested
    y - the specified Y coordinate to be tested
    z - the specified Z coordinate to be tested
    
    Returns:
    true if the specified 3D coordinates are inside the ROI boundary; false otherwise.
  - contains
```
public abstract boolean contains(double x,
               double y,
               double z,
               double sizeX,
               double sizeY,
               double sizeZ)
```
    Tests if the ROI entirely contains the specified 3D rectangular area. All coordinates that lie inside the rectangular area must lie within the ROI for the entire rectangular area to be considered contained within the ROI.
    The ROI.contains() method allows a ROI implementation to conservatively return false when:
    - the intersect method returns true and
    - the calculations to determine whether or not the ROI entirely contains the rectangular area are prohibitively expensive.
    This means that for some ROIs this method might return false even though the ROI contains the rectangular area.
    Parameters:
    x - the X coordinate of the minimum corner position of the specified rectangular area
    y - the Y coordinate of the minimum corner position of the specified rectangular area
    z - the Z coordinate of the minimum corner position of the specified rectangular area
    sizeX - size for X dimension of the specified rectangular area
    sizeY - size for Y dimension of the specified rectangular area
    sizeZ - size for Z dimension of the specified rectangular area
    
    Returns:
    true if the interior of the ROI entirely contains the specified 3D rectangular area; false otherwise or, if the ROI contains the 3D rectangular area and the intersects method returns true and the containment calculations would be too expensive to perform.
  - contains
```
public boolean contains(double x,
               double y,
               double z,
               double t,
               double c)
```
    Description copied from class: ROI
    
    Tests if a specified 5D point is inside the ROI.
    
    Specified by:
    
    contains in class ROI
    
    Returns:
    true if the specified Point5D is inside the boundary of the ROI; false otherwise.
  - contains
```
public boolean contains(double x,
               double y,
               double z,
               double t,
               double c,
               double sizeX,
               double sizeY,
               double sizeZ,
               double sizeT,
               double sizeC)
```
    Description copied from class: ROI
    Tests if the ROI entirely contains the specified 5D rectangular area. All coordinates that lie inside the rectangular area must lie within the ROI for the entire rectangular area to be considered contained within the ROI.
    The ROI.contains() method allows a ROI implementation to conservatively return false when:
    - the intersect method returns true and
    - the calculations to determine whether or not the ROI entirely contains the rectangular area are prohibitively expensive.
    This means that for some ROIs this method might return false even though the ROI contains the rectangular area.
    Specified by:
    
    contains in class ROI
    
    Parameters:
    x - the X coordinate of the start corner of the specified rectangular area
    y - the Y coordinate of the start corner of the specified rectangular area
    z - the Z coordinate of the start corner of the specified rectangular area
    t - the T coordinate of the start corner of the specified rectangular area
    c - the C coordinate of the start corner of the specified rectangular area
    sizeX - the X size of the specified rectangular area
    sizeY - the Y size of the specified rectangular area
    sizeZ - the Z size of the specified rectangular area
    sizeT - the T size of the specified rectangular area
    sizeC - the C size of the specified rectangular area
    
    Returns:
    true if the interior of the ROI entirely contains the specified rectangular area; false otherwise or, if the ROI contains the rectangular area and the intersects method returns true and the containment calculations would be too expensive to perform.
  - contains
```
public boolean contains(ROI roi)
```
    Description copied from class: ROI
    
    Tests if the ROI entirely contains the specified ROI. WARNING: this method may be "pixel accurate" only depending the internal implementation.
    
    Overrides:
    
    contains in class ROI
    
    Returns:
    true if the current ROI entirely contains the specified ROI; false otherwise.
  - intersects
```
public boolean intersects(Rectangle3D r)
```
    Tests if the interior of the ROI intersects the interior of a specified Rectangle3D. The ROI.intersects() method allows a ROI implementation to conservatively return true when:
    - there is a high probability that the Rectangle3D and the ROI intersect, but
    - the calculations to accurately determine this intersection are prohibitively expensive.
    This means that for some ROIs this method might return true even though the Rectangle3D does not intersect the ROI.
    Parameters:
    r - the specified Rectangle3D
    
    Returns:
    true if the interior of the ROI and the interior of the specified Rectangle3D intersect, or are both highly likely to intersect and intersection calculations would be too expensive to perform; false otherwise.
    See Also:
    intersects(double, double, double,double, double, double)
  - intersects
```
public abstract boolean intersects(double x,
                 double y,
                 double z,
                 double sizeX,
                 double sizeY,
                 double sizeZ)
```
    Tests if the interior of the ROI intersects the interior of a specified 3D rectangular area. The 3D rectangular area is considered to intersect the ROI if any point is contained in both the interior of the ROI and the specified rectangular area.
    The ROI.intersects() method allows a ROI implementation to conservatively return true when:
    - there is a high probability that the 3D rectangular area and the ROI intersect, but
    - the calculations to accurately determine this intersection are prohibitively expensive.
    This means that for some ROIs this method might return true even though the 3D rectangular area does not intersect the ROI.
    Parameters:
    x - the X coordinate of the minimum corner position of the specified rectangular area
    y - the Y coordinate of the minimum corner position of the specified rectangular area
    z - the Z coordinate of the minimum corner position of the specified rectangular area
    sizeX - size for X dimension of the specified rectangular area
    sizeY - size for Y dimension of the specified rectangular area
    sizeZ - size for Z dimension of the specified rectangular area
    
    Returns:
    true if the interior of the ROI and the interior of the rectangular area intersect, or are both highly likely to intersect and intersection calculations would be too expensive to perform; false otherwise.
  - intersects
```
public boolean intersects(double x,
                 double y,
                 double z,
                 double t,
                 double c,
                 double sizeX,
                 double sizeY,
                 double sizeZ,
                 double sizeT,
                 double sizeC)
```
    Description copied from class: ROI
    Tests if the interior of the ROI intersects the interior of a specified rectangular area. The rectangular area is considered to intersect the ROI if any point is contained in both the interior of the ROI and the specified rectangular area.
    The ROI.intersects() method allows a ROI implementation to conservatively return true when:
    - there is a high probability that the rectangular area and the ROI intersect, but
    - the calculations to accurately determine this intersection are prohibitively expensive.
    This means that for some ROIs this method might return true even though the rectangular area does not intersect the ROI.
    Specified by:
    
    intersects in class ROI
    
    Returns:
    true if the interior of the ROI and the interior of the rectangular area intersect, or are both highly likely to intersect and intersection calculations would be too expensive to perform; false otherwise.
  - intersects
```
public boolean intersects(ROI roi)
```
    Description copied from class: ROI
    
    Tests if the current ROI intersects the specified ROI.
    Note that this method may be "pixel accurate" only depending the internal implementation.
    
    Overrides:
    
    intersects in class ROI
    
    Returns:
    true if ROI intersect, false otherwise.
  - computeBounds3D
```
public abstract Rectangle3D computeBounds3D()
```
    Calculate and returns the 3D bounding box of the ROI.
    This method is used by getBounds3D() which should try to cache the result as the bounding box calculation can take some computation time for complex ROI.
  - computeBounds5D
```
public Rectangle5D computeBounds5D()
```
    Description copied from class: ROI
    
    Calculate and returns the bounding box of the ROI.
    This method is used by ROI.getBounds5D() which should try to cache the result as the bounding box calculation can take some computation time for complex ROI.
    
    Specified by:
    
    computeBounds5D in class ROI
  - getBounds
```
public Rectangle3D.Integer getBounds()
```
    Returns an integer Rectangle3D that completely encloses the ROI. Note that there is no guarantee that the returned Rectangle3D is the smallest bounding box that encloses the ROI, only that the ROI lies entirely within the indicated Rectangle3D. The returned Rectangle3D might also fail to completely enclose the ROI if the ROI overflows the limited range of the integer data type. The getBounds3D method generally returns a tighter bounding box due to its greater flexibility in representation.
    
    Returns:
    an integer Rectangle3D that completely encloses the ROI.
  - getBounds3D
```
public Rectangle3D getBounds3D()
```
    Returns the bounding box of the ROI. Note that there is no guarantee that the returned Rectangle3D is the smallest bounding box that encloses the ROI, only that the ROI lies entirely within the indicated Rectangle3D.
    
    Returns:
    an instance of Rectangle3D that is a bounding box of the ROI.
  - getPosition
```
public Point3D.Integer getPosition()
```
    Returns the integer ROI position which normally correspond to the minimum point of the ROI bounds.
    
    See Also:
    getBounds()
  - getPosition3D
```
public Point3D getPosition3D()
```
    Returns the high precision ROI position which normally correspond to the minimum point of the ROI bounds.
    
    See Also:
    getBounds3D()
  - canSetBounds
```
public boolean canSetBounds()
```
    Description copied from class: ROI
    
    Returns true if this ROI accepts bounds change through the ROI.setBounds5D(Rectangle5D) method.
    
    Specified by:
    
    canSetBounds in class ROI
  - setBounds3D
```
public void setBounds3D(Rectangle3D bounds)
```
    Set the ROI 3D bounds.
    Note that not all ROI supports bounds modification and you should call canSetBounds() first to test if the operation is supported.
    
    Parameters:
    bounds - new ROI 3D bounds
  - setBounds5D
```
public void setBounds5D(Rectangle5D bounds)
```
    Description copied from class: ROI
    
    Set the ROI bounds.
    Note that not all ROI supports bounds modification and you should call ROI.canSetBounds() first to test if the operation is supported.
    
    Specified by:
    
    setBounds5D in class ROI
    
    Parameters:
    bounds - new ROI bounds
  - canSetPosition
```
public boolean canSetPosition()
```
    Description copied from class: ROI
    
    Returns true if this ROI accepts position change through the ROI.setPosition5D(Point5D) method.
    
    Specified by:
    
    canSetPosition in class ROI
  - setPosition3D
```
public void setPosition3D(Point3D position)
```
    Set the ROI 3D position.
    Note that not all ROI supports position modification and you should call canSetPosition() first to test if the operation is supported.
    
    Parameters:
    position - new ROI 3D position
  - setPosition5D
```
public void setPosition5D(Point5D position)
```
    Description copied from class: ROI
    
    Set the ROI position.
    Note that not all ROI supports position modification and you should call ROI.canSetPosition() first to test if the operation is supported.
    
    Specified by:
    
    setPosition5D in class ROI
    
    Parameters:
    position - new ROI position
  - canTranslate
```
public boolean canTranslate()
```
    Returns true if the ROI support translate operation.
    
    See Also:
    translate(double, double, double)
  - translate
```
public void translate(double dx,
             double dy,
             double dz)
```
    Translate the ROI position by the specified delta X/Y/Z.
    Note that not all ROI support this operation so you should test it by calling canTranslate() first.
    
    Parameters:
    dx - translation value to apply on X dimension
    dy - translation value to apply on Y dimension
    dz - translation value to apply on Z dimension
    See Also:
    canTranslate(), setPosition3D(Point3D)
  - getBooleanMask2D
```
public boolean[] getBooleanMask2D(int x,
                         int y,
                         int width,
                         int height,
                         int z,
                         int t,
                         int c,
                         boolean inclusive)
```
    Description copied from class: ROI
    
    Returns the boolean array mask for the specified rectangular region at specified C, Z, T position.
    
    If pixel (x1, y1, c, z, t) is contained in the roi:
    result[((y1 - y) * width) + (x1 - x)] = true
    If pixel (x1, y1, c, z, t) is not contained in the roi:
    result[((y1 - y) * width) + (x1 - x)] = false
    
    Overrides:
    
    getBooleanMask2D in class ROI
    
    Parameters:
    x - the X coordinate of the upper-left corner of the specified rectangular region
    y - the Y coordinate of the upper-left corner of the specified rectangular region
    width - the width of the specified rectangular region
    height - the height of the specified rectangular region
    z - Z position we want to retrieve the boolean mask
    t - T position we want to retrieve the boolean mask
    c - C position we want to retrieve the boolean mask
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
    
    Returns:
    the boolean bitmap mask
  - getBooleanMask2D
```
public boolean[] getBooleanMask2D(int x,
                         int y,
                         int width,
                         int height,
                         int z,
                         boolean inclusive)
```
    Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z position.
    if the pixel (x,y) is contained in the roi Z position then result[(y * width) + x] = true
    if the pixel (x,y) is not contained in the roi Z position then result[(y * width) + x] = false
    
    Parameters:
    x - the X coordinate of the upper-left corner of the specified rectangular area
    y - the Y coordinate of the upper-left corner of the specified rectangular area
    width - the width of the specified rectangular area
    height - the height of the specified rectangular area
    z - Z position we want to retrieve the boolean mask
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
    
    Returns:
    the boolean bitmap mask
  - getBooleanMask2D
```
public boolean[] getBooleanMask2D(java.awt.Rectangle rect,
                         int z,
                         boolean inclusive)
```
    Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z position.
    if the pixel (x,y) is contained in the roi Z position then result[(y * width) + x] = true
    if the pixel (x,y) is not contained in the roi Z position then result[(y * width) + x] = false
    
    Parameters:
    rect - 2D rectangular area we want to retrieve the boolean mask
    z - Z position we want to retrieve the boolean mask
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
  - getBooleanMask2D
```
public BooleanMask2D getBooleanMask2D(int z,
                             int t,
                             int c,
                             boolean inclusive)
```
    Description copied from class: ROI
    
    Returns the BooleanMask2D object representing the XY plan content at specified Z, T, C position.
    
    If pixel (x, y, c, z, t) is contained in the roi:
    mask[(y - bounds.y) * bounds.width) + (x - bounds.x)] = true
    If pixel (x, y, c, z, t) is not contained in the roi:
    mask[(y - bounds.y) * bounds.width) + (x - bounds.x)] = false
    
    Overrides:
    
    getBooleanMask2D in class ROI
    
    Parameters:
    z - Z position we want to retrieve the boolean mask.
    Set it to -1 to retrieve the mask whatever is the Z position of ROI2D.
    t - T position we want to retrieve the boolean mask.
    Set it to -1 to retrieve the mask whatever is the T position of ROI2D/ROI3D.
    c - C position we want to retrieve the boolean mask.
    Set it to -1 to retrieve the mask whatever is the C position of ROI2D/ROI3D/ROI4D.
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
  - getBooleanMask2D
```
public BooleanMask2D getBooleanMask2D(int z,
                             boolean inclusive)
```
    Get the BooleanMask2D object representing the roi for the specified Z position.
    It contains the rectangle mask bounds and the associated boolean array mask.
    if the pixel (x,y) is contained in the roi Z position then result.mask[(y * w) + x] = true
    if the pixel (x,y) is not contained in the roi Z position then result.mask[(y * w) + x] = false
    
    Parameters:
    z - Z position we want to retrieve the boolean mask
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
  - getBooleanMask3D
```
public BooleanMask3D getBooleanMask3D(int z,
                             int t,
                             int c,
                             boolean inclusive)
```
    Returns the BooleanMask3D object representing the XYZ volume content at specified Z, T, C position.
    It contains the 3D rectangle mask bounds and the associated boolean array mask.
    
    Parameters:
    z - Z position we want to retrieve the boolean mask or -1 to retrieve the whole Z dimension
    t - T position we want to retrieve the boolean mask.
    Set it to -1 to retrieve the mask whatever is the T position of this ROI3D.
    c - C position we want to retrieve the boolean mask.
    Set it to -1 to retrieve the mask whatever is the C position of this ROI3D.
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
  - getBooleanMask
```
public BooleanMask3D getBooleanMask(boolean inclusive)
```
    Get the BooleanMask3D object representing the roi.
    It contains the 3D rectangle mask bounds and the associated boolean array mask.
    
    Parameters:
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
  - computeNumberOfContourPoints
```
public double computeNumberOfContourPoints()
```
    Description copied from class: ROI
    
    Compute and returns the number of point (pixel) composing the ROI contour.
    
    Specified by:
    
    computeNumberOfContourPoints in class ROI
  - computeNumberOfPoints
```
public double computeNumberOfPoints()
```
    Description copied from class: ROI
    
    Compute and returns the number of point (pixel) contained in the ROI.
    
    Specified by:
    
    computeNumberOfPoints in class ROI
  - computeSurfaceArea
```
public double computeSurfaceArea(Sequence sequence)
```
    Compute the surface area in um2 given the pixel size informations from the specified Sequence.
    Generic implementation of surface area computation using the number of contour point (approximation).
    This method should be overridden whenever possible to provide faster and accurate calculation.
  - getSurfaceArea
```
public double getSurfaceArea(Sequence sequence)
```
    Returns surface area of the 3D ROI in um2 given the pixel size informations from the specified Sequence.
    
    See Also:
    computeSurfaceArea(Sequence), ROI.getNumberOfContourPoints()
  - getLength
```
public double getLength(Sequence sequence)
                 throws java.lang.UnsupportedOperationException
```
    Description copied from class: ROI
    
    Computes and returns the length/perimeter of the ROI in um given the pixel size informations from the specified Sequence.
    Generic implementation of length computation uses the number of contour point (approximation). This method should be overridden whenever possible to provide faster and accurate calculation.
    Throws a UnsupportedOperationException if the operation is not supported for this ROI.
    
    Overrides:
    
    getLength in class ROI
    
    Throws:
    
    java.lang.UnsupportedOperationException
    See Also:
    ROI.getNumberOfContourPoints()
  - getSurfaceArea
```
@Deprecated
public double getSurfaceArea()
```
    Deprecated. Use ROI.getNumberOfContourPoints() instead.
    
    Return surface area of the 3D ROI in pixels.
    This is basically the number of pixel representing ROI edges.
    
    See Also:
    ROI.getNumberOfContourPoints(), computeNumberOfContourPoints()
  - getVolume
```
@Deprecated
public double getVolume()
```
    Deprecated. Use ROI.getNumberOfPoints() instead.
    
    Return volume of the 3D ROI in pixels.
    This is basically the number of pixel contained in the ROI.
    
    Overrides:
    
    getVolume in class ROI
    
    See Also:
    ROI.getNumberOfPoints(), computeNumberOfPoints()
  - getT
```
public int getT()
```
    Returns the T position.
    -1 is a special value meaning the ROI is set on all T frames (infinite T dimension).
  - setT
```
public void setT(int value)
```
    Sets T position of this 3D ROI.
    You cannot set the ROI on a negative T position as -1 is a special value meaning the ROI is set on all T frames (infinite T dimension).
  - getC
```
public int getC()
```
    Returns the C position.
    -1 is a special value meaning the ROI is set on all C channels (infinite C dimension).
  - setC
```
public void setC(int value)
```
    Sets C position of this 3D ROI.
    You cannot set the ROI on a negative C position as -1 is a special value meaning the ROI is set on all C channels (infinite C dimension).
  - isActiveFor
```
public boolean isActiveFor(IcyCanvas canvas)
```
    Description copied from class: ROI
    
    Return true if the ROI is active for the specified canvas.
    
    Specified by:
    
    isActiveFor in class ROI
  - isActiveFor
```
public boolean isActiveFor(int t,
                  int c)
```
    Return true if the ROI is active for the specified T, C coordinates
  - isOverEdge
```
public boolean isOverEdge(IcyCanvas canvas,
                 Point3D p)
```
    Returns true if specified point coordinates overlap the ROI edge.
    Use contains(Point3D) to test for content overlap instead.
  - isOverEdge
```
public boolean isOverEdge(IcyCanvas canvas,
                 double x,
                 double y,
                 double z)
```
    Returns true if specified point coordinates overlap the ROI edge.
    Use contains(double, double, double) to test for content overlap instead.
    We provide a default implementation to not break compatibility.
  - isOverEdge
```
public boolean isOverEdge(IcyCanvas canvas,
                 Point5D p)
```
    Returns true if specified point coordinates overlap the ROI edge.
    Use ROI.contains(Point5D) to test for content overlap instead.
  - isOverEdge
```
public boolean isOverEdge(IcyCanvas canvas,
                 double x,
                 double y,
                 double z,
                 double t,
                 double c)
```
    Returns true if specified point coordinates overlap the ROI edge.
    Use contains(double, double, double, double, double) to test for content overlap instead.
  - loadFromXML
```
public boolean loadFromXML(org.w3c.dom.Node node)
```
    Description copied from interface: XMLPersistent
    
    LOAD
    
    Specified by:
    
    loadFromXML in interface XMLPersistent
    
    Overrides:
    
    loadFromXML in class ROI
  - saveToXML
```
public boolean saveToXML(org.w3c.dom.Node node)
```
    Description copied from interface: XMLPersistent
    
    SAVE
    
    Specified by:
    
    saveToXML in interface XMLPersistent
    
    Overrides:
    
    saveToXML in class ROI

Class ROI3D

Nested Class Summary

Nested classes/interfaces inherited from class icy.roi.ROI

Field Summary

Fields inherited from class icy.roi.ROI

Constructor Summary

Method Summary

Methods inherited from class icy.roi.ROI

Methods inherited from class java.lang.Object

Field Detail

ID_T

ID_C

Constructor Detail

ROI3D

Method Detail

getROI3DList

getROI3DList

getDefaultName

getDimension

contains

contains

contains

contains

contains

contains

contains

intersects

intersects

intersects

intersects

computeBounds3D

computeBounds5D

getBounds

getBounds3D

getPosition

getPosition3D

canSetBounds

setBounds3D

setBounds5D

canSetPosition

setPosition3D

setPosition5D

canTranslate

translate

getBooleanMask2D

getBooleanMask2D

getBooleanMask2D

getBooleanMask2D

getBooleanMask2D

getBooleanMask3D

getBooleanMask

computeNumberOfContourPoints

computeNumberOfPoints

computeSurfaceArea

getSurfaceArea

getLength

getSurfaceArea

getVolume

getT

setT

getC

setC

isActiveFor

isActiveFor

isOverEdge

isOverEdge

isOverEdge

isOverEdge

loadFromXML

saveToXML