ROI4D

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

All Implemented Interfaces:

ChangeListener, XMLPersistent

Direct Known Subclasses:

ROI4DStack
```
public abstract class ROI4D
extends ROI
```
4D ROI base class.

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

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.String ID_C
- Fields inherited from class icy.roi.ROI
  DEFAULT_COLOR, DEFAULT_NORMAL_COLOR, DEFAULT_OPACITY, DEFAULT_STROKE, ID_CLASSNAME, ID_COLOR, ID_GROUPID, ID_ID, ID_NAME, ID_OPACITY, 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`

Constructor Summary

Constructors
Constructor and Description

ROI4D()

Constructors
Constructor and Description
`ROI4D()`

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 Rectangle4D`	`computeBounds4D()` Calculate and returns the 4D 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.
`abstract boolean`	`contains(double x, double y, double z, double t)` 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 t, double sizeX, double sizeY, double sizeZ, double sizeT)` Tests if the `ROI` entirely contains the specified 4D rectangular area.
`boolean`	`contains(double x, double y, double z, double t, double c, double sizeX, double sizeY, double sizeT, double sizeZ, double sizeC)` Tests if the `ROI` entirely contains the specified 5D rectangular area.
`boolean`	`contains(Point4D p)` Tests if a specified `Point4D` is inside the ROI.
`boolean`	`contains(Rectangle4D r)` Tests if the interior of the `ROI` entirely contains the specified `Rectangle4D`.
`boolean`	`contains(ROI roi)` Tests if the `ROI` entirely contains the specified `ROI`.
`BooleanMask4D`	`getBooleanMask(boolean inclusive)` Get the `BooleanMask4D` object representing the roi.
`BooleanMask2D`	`getBooleanMask2D(int z, int t, boolean inclusive)` Get the `BooleanMask2D` object representing the roi for the specified Z,T 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, int t, boolean inclusive)` Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z,T 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, int t, boolean inclusive)` Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z,T position.
`BooleanMask3D`	`getBooleanMask3D(int t, boolean inclusive)` Get the `BooleanMask3D` object representing the roi for specified T 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.
`BooleanMask4D`	`getBooleanMask4D(int z, int t, int c, boolean inclusive)` Returns the `BooleanMask4D` object representing the XYZT space content at specified Z, T, C position.
`Rectangle4D.Integer`	`getBounds()` Returns an integer `Rectangle4D` that completely encloses the `ROI`.
`Rectangle4D`	`getBounds4D()` 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
`Point4D.Integer`	`getPosition()` Returns the integer ROI position which normally correspond to the minimum point of the ROI bounds.
`Point4D`	`getPosition4D()` Returns the ROI position which normally correspond to the minimum point of the ROI bounds.
`static java.util.ArrayList<ROI4D>`	`getROI4DList(java.util.ArrayList<ROI> rois)` Deprecated. Use `getROI4DList(List)` instead.
`static java.util.List<ROI4D>`	`getROI4DList(java.util.List<ROI> rois)` Return all 4D ROI from the ROI list
`abstract boolean`	`intersects(double x, double y, double z, double t, double sizeX, double sizeY, double sizeZ, double sizeT)` Tests if the interior of the `ROI` intersects the interior of a specified 4D 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(Rectangle4D r)` Tests if the interior of the `ROI` intersects the interior of a specified `Rectangle4D`.
`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 c)` Return true if the ROI is active for the specified C coordinate
`boolean`	`loadFromXML(org.w3c.dom.Node node)` LOAD
`boolean`	`saveToXML(org.w3c.dom.Node node)` SAVE
`void`	`setBounds4D(Rectangle4D bounds)` Set the `ROI` 4D bounds.
`void`	`setBounds5D(Rectangle5D bounds)` Set the `ROI` bounds.
`void`	`setC(int value)` Sets C position of this 4D ROI.
`void`	`setPosition4D(Point4D position)` Set the `ROI` 4D position.
`void`	`setPosition5D(Point5D position)` Set the `ROI` position.
`void`	`translate(double dx, double dy, double dz, double dt)` Translate the ROI position by the specified delta X/Y/Z/T.

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, getLength, getName, getNameSuffix, getNumberOfContourPoints, getNumberOfPoints, getOpacity, getOverlay, getPainter, getPerimeter, getPosition5D, getPropertyValue, getROICount, getROIList, getROIList, getROIList, getROIsFromXML, getSelectedColor, getSequences, getShowName, getSimpleClassName, getStroke, getSubROI, getSubtraction, getUnion, getVolume, 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, 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_C
```
public static final java.lang.String ID_C
```
    See Also:
    Constant Field Values
- Constructor Detail
  - ROI4D
```
public ROI4D()
```
- Method Detail
  - getROI4DList
```
@Deprecated
public static java.util.ArrayList<ROI4D> getROI4DList(java.util.ArrayList<ROI> rois)
```
    Deprecated. Use getROI4DList(List) instead.
  - getROI4DList
```
public static java.util.List<ROI4D> getROI4DList(java.util.List<ROI> rois)
```
    Return all 4D 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(Point4D p)
```
    Tests if a specified Point4D is inside the ROI.
    
    Parameters:
    p - the specified Point4D to be tested
    
    Returns:
    true if the specified Point3D is inside the boundary of the ROI; false otherwise.
  - contains
```
public boolean contains(Rectangle4D r)
```
    Tests if the interior of the ROI entirely contains the specified Rectangle4D. 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 Rectangle4D.
    Parameters:
    r - The specified Rectangle4D
    
    Returns:
    true if the interior of the ROI entirely contains the Rectangle4D; false otherwise or, if the ROI contains the Rectangle4D 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, double, double)
  - contains
```
public abstract boolean contains(double x,
               double y,
               double z,
               double t)
```
    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
    t - the specified T coordinate to be tested
    
    Returns:
    true if the specified 4D coordinates are inside the ROI boundary; false otherwise.
  - contains
```
public abstract boolean contains(double x,
               double y,
               double z,
               double t,
               double sizeX,
               double sizeY,
               double sizeZ,
               double sizeT)
```
    Tests if the ROI entirely contains the specified 4D 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
    t - the T 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
    sizeT - size for T dimension of the specified rectangular area
    
    Returns:
    true if the interior of the ROI entirely contains the specified 4D rectangular area; false otherwise or, if the ROI contains the 4D 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 sizeT,
               double sizeZ,
               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
    sizeT - the Z size of the specified rectangular area
    sizeZ - 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(Rectangle4D r)
```
    Tests if the interior of the ROI intersects the interior of a specified Rectangle4D. The ROI.intersects() method allows a ROI implementation to conservatively return true when:
    - there is a high probability that the Rectangle4D 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 Rectangle4D does not intersect the ROI.
    Parameters:
    r - the specified Rectangle4D
    
    Returns:
    true if the interior of the ROI and the interior of the specified Rectangle4D 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, double, double)
  - intersects
```
public abstract boolean intersects(double x,
                 double y,
                 double z,
                 double t,
                 double sizeX,
                 double sizeY,
                 double sizeZ,
                 double sizeT)
```
    Tests if the interior of the ROI intersects the interior of a specified 4D rectangular area. The 4D 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 4D 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 4D 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
    t - the T 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
    sizeT - size for T 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.
  - computeBounds4D
```
public abstract Rectangle4D computeBounds4D()
```
    Calculate and returns the 4D bounding box of the ROI.
    This method is used by getBounds4D() 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 Rectangle4D.Integer getBounds()
```
    Returns an integer Rectangle4D that completely encloses the ROI. Note that there is no guarantee that the returned Rectangle4D is the smallest bounding box that encloses the ROI, only that the ROI lies entirely within the indicated Rectangle4D. The returned Rectangle4D might also fail to completely enclose the ROI if the ROI overflows the limited range of the integer data type. The getBounds4D method generally returns a tighter bounding box due to its greater flexibility in representation.
    
    Returns:
    an integer Rectangle4D that completely encloses the ROI.
  - getBounds4D
```
public Rectangle4D getBounds4D()
```
    Returns the bounding box of the ROI. Note that there is no guarantee that the returned Rectangle4D is the smallest bounding box that encloses the ROI, only that the ROI lies entirely within the indicated Rectangle4D.
    
    Returns:
    an instance of Rectangle4D that is a bounding box of the ROI.
  - getPosition
```
public Point4D.Integer getPosition()
```
    Returns the integer ROI position which normally correspond to the minimum point of the ROI bounds.
    
    See Also:
    getBounds()
  - getPosition4D
```
public Point4D getPosition4D()
```
    Returns the ROI position which normally correspond to the minimum point of the ROI bounds.
    
    See Also:
    getBounds4D()
  - 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
  - setBounds4D
```
public void setBounds4D(Rectangle4D bounds)
```
    Set the ROI 4D 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 4D 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
  - setPosition4D
```
public void setPosition4D(Point4D position)
```
    Set the ROI 4D 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 4D 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, double)
  - translate
```
public void translate(double dx,
             double dy,
             double dz,
             double dt)
```
    Translate the ROI position by the specified delta X/Y/Z/T.
    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
    dt - translation value to apply on T dimension
    See Also:
    canTranslate(), setPosition4D(Point4D)
  - 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,
                         int t,
                         boolean inclusive)
```
    Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z,T position.
    if the pixel (x,y) is contained in the roi Z,T position then result[(y * width) + x] = true
    if the pixel (x,y) is not contained in the roi Z,T position then result[(y * width) + x] =
    
    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
    t - T 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,
                         int t,
                         boolean inclusive)
```
    Get the boolean bitmap mask for the specified rectangular area of the roi and for the specified Z,T position.
    if the pixel (x,y) is contained in the roi Z,T position then result[(y * width) + x] = true
    if the pixel (x,y) is not contained in the roi Z,T 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
    t - T 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,
                             int t,
                             boolean inclusive)
```
    Get the BooleanMask2D object representing the roi for the specified Z,T position.
    It contains the rectangle mask bounds and the associated boolean array mask.
    if the pixel (x,y) is contained in the roi Z,T position then result.mask[(y * w) + x] = true
    if the pixel (x,y) is not contained in the roi Z,T position then result.mask[(y * w) + x] = false
    
    Parameters:
    z - Z position we want to retrieve the boolean mask
    t - T 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.
    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 ROI4D.
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
  - getBooleanMask3D
```
public BooleanMask3D getBooleanMask3D(int t,
                             boolean inclusive)
```
    Get the BooleanMask3D object representing the roi for specified T position.
    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.
  - getBooleanMask4D
```
public BooleanMask4D getBooleanMask4D(int z,
                             int t,
                             int c,
                             boolean inclusive)
```
    Returns the BooleanMask4D object representing the XYZT space content at specified Z, T, C position.
    
    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 or -1 to retrieve the whole T dimension
    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 ROI4D.
    inclusive - If true then all partially contained (intersected) pixels are included in the mask.
  - getBooleanMask
```
public BooleanMask4D getBooleanMask(boolean inclusive)
```
    Get the BooleanMask4D object representing the roi.
    It contains the 4D 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
  - 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 4D 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 c)
```
    Return true if the ROI is active for the specified C coordinate
  - 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

Icy Developer Documentation

Class ROI4D

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_C

Constructor Detail

ROI4D

Method Detail

getROI4DList

getROI4DList

getDefaultName

getDimension

contains

contains

contains

contains

contains

contains

contains

intersects

intersects

intersects

intersects

computeBounds4D

computeBounds5D

getBounds

getBounds4D

getPosition

getPosition4D

canSetBounds

setBounds4D

setBounds5D

canSetPosition

setPosition4D

setPosition5D

canTranslate

translate

getBooleanMask2D

getBooleanMask2D

getBooleanMask2D

getBooleanMask2D

getBooleanMask2D

getBooleanMask3D

getBooleanMask3D

getBooleanMask4D

getBooleanMask

computeNumberOfContourPoints

computeNumberOfPoints

getC

setC

isActiveFor

isActiveFor

loadFromXML

saveToXML

Icy Developer Documentation