Patch (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- ini.trakem2.persistence.DBObject
- - ini.trakem2.display.Displayable
  - - ini.trakem2.display.Patch

All Implemented Interfaces:: ImageData, Paintable

public final class Patch
extends Displayable
implements ImageData

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Patch.PatchImage

static class Patch.TransformProperties
- Nested classes/interfaces inherited from class ini.trakem2.display.Displayable
  Displayable.DataPackage, Displayable.DoEdit, Displayable.DoEdits, Displayable.DoTransforms, Displayable.SliderListener

Nested Classes
Modifier and Type	Class and Description
`static class`	`Patch.PatchImage`
`static class`	`Patch.TransformProperties`

Field Summary

Fields
Modifier and Type Field and Description

static DirectColorModel DCM

protected int meshResolution
- Fields inherited from class ini.trakem2.display.Displayable
  alpha, annotation, at, color, COMPOSITE_ADD, COMPOSITE_COLOR_YCBCR, COMPOSITE_DIFFERENCE, COMPOSITE_MULTIPLY, COMPOSITE_NORMAL, COMPOSITE_SUBTRACT, compositeModes, height, hs_linked, last_color, layer, linked_props, linked_props_origins, locked, props, TAG_ATTR1, TAG_ATTR2, title, visible, width
- Fields inherited from class ini.trakem2.persistence.DBObject
  id, project

Fields
Modifier and Type	Field and Description
`static DirectColorModel`	`DCM`
`protected int`	`meshResolution`

Constructor Summary

Constructors
Constructor and Description
`Patch(Project project, long id, HashMap<String,String> ht_attributes, HashMap<Displayable,String> ht_links)` Reconstruct from an XML entry.
`Patch(Project project, long id, String title, float width, float height, int o_width, int o_height, int type, boolean locked, double min, double max, AffineTransform at)` Reconstruct a Patch from the database.
`Patch(Project project, String title, double x, double y, ij.ImagePlus imp)` Construct a Patch from an image; most likely you will need to add the file path to the `imp` by calling `Loader.addedPatchFrom(String, Patch)`, as in this example: project.getLoader().addedPatchFrom("/path/to/file.png", thePatch);
`Patch(Project project, String title, float width, float height, int o_width, int o_height, int type, float alpha, Color color, boolean locked, double min, double max, AffineTransform at, String file_path)` Create a new Patch defining all necessary parameters; it is the responsibility of the caller to ensure that the parameters are in agreement with the image contained in the `file_path`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addAlphaMask(Area aw, int value)` Add the given area, in world coords, to the alpha mask, using the given fill value.
`void`	`addAlphaMask(Roi roi, int value)` Add the given roi, in world coords, to the alpha mask, using the given fill value.
`void`	`addAlphaMaskLocal(Area aLocal, int value)` Add the given area, in local coordinates, to the alpha mask, using the given fill value.
`Image`	`adjustChannels(Image awt)` Takes an image and scales its channels according to the values packed in this.channels.
`void`	`appendCoordinateTransform(CoordinateTransform ct)` Append a `CoordinateTransform` to the current `CoordinateTransformList`.
`void`	`appendFilters(IFilter[] fs)` Append an array of `IFilter` to the array of existing `IFilter`.
`protected void`	`approximateTransferPixel(int[] pvalue)` Transfer an 8-bit or RGB pixel to this image color space, interpolating; the pvalue is modified in place.
`void`	`cacheCurrentPath(String path)` Cache a proper, good, known path to the image wrapped by this Patch.
`boolean`	`checkAlphaMaskFile()`
`boolean`	`checkCoordinateTransformFile()`
`boolean`	`clearIntensityMap()`
`Displayable`	`clone(Project pr, boolean copy_id)` Performs a copy of this object, without the links, unlocked and visible, except for the image which is NOT duplicated.
`boolean`	`contains(double x_p, double y_p)` Considers the alpha mask.
`Patch.PatchImage`	`createCoordinateTransformedImage()`
`Image`	`createImage()`
`Image`	`createImage(ij.ImagePlus imp)`
`static Patch`	`createPatch(Project project, String filepath)` Create a new Patch and register the associated `filepath` with the project's loader.
`Patch.PatchImage`	`createTransformedImage()` Returns a PatchImage object containing the bottom-of-transformation-stack image and alpha mask, if any (except the AffineTransform, which is used for direct hw-accel screen rendering).
`protected static void`	`crosslink(Collection<Displayable> patches, boolean overlapping_only)`
`void`	`debug()`
`static void`	`exportDTD(StringBuilder sb_header, HashSet<String> hs, String indent)`
`void`	`exportXML(StringBuilder sb_body, String indent, XMLOptions options)` Opens and closes the tag and exports data.
`CoordinateTransform`	`fetchCoordinateTransform()` Read in the `CoordinateTransform` from a file whose name is crafted from the `ct_id` and this `Patch`'s `DBObject.id`.
`ij.process.ByteProcessor`	`getAlphaMask()` Return a new `ByteProcessor` representing the alpha mask, if any, over the pixel data.
`String`	`getAlphaMaskFilePath()`
`long`	`getAlphaMaskId()`
`Area`	`getArea()` Returns an Area in world coords representing the inside of this Patch.
`protected Area`	`getAreaForBucket(Layer l)` Use this instead of getAreaAt which calls getArea which is ...
`int`	`getChannelAlphas()`
`CoordinateTransform`	`getCoordinateTransform()` Obtain a copy of the `CoordinateTransform` that transfers image data to mipmap image data.
`Rectangle`	`getCoordinateTransformBoundingBox()` Get the bounding rectangle of the transformed image relative to the original image.
`protected static Rectangle`	`getCoordinateTransformBoundingBox(Patch p, CoordinateTransform ct)` Allow reusing a `CoordinateTransform` that was already loaded from a file.
`String`	`getCoordinateTransformFilePath()`
`long`	`getCoordinateTransformId()` A value of 0 indicates that there isn't one.
`String`	`getCurrentPath()` Returns the value of the field current_path, which may be null.
`String`	`getFilePath()` If this patch is part of a stack, the file path will contain the slice number attached to it, in the form -----#slice=10 for slice number 10.
`IFilter[]`	`getFilters()`
`CoordinateTransform`	`getFullCoordinateTransform()` Create a `CoordinateTransform` that incorporates both the `CoordinateTransform` of this `Patch` (if present) and its `AffineTransform`.
`String`	`getImageFilePath()` Returns the absolute path to the image file, as read by the OS.
`ij.ImagePlus`	`getImagePlus()` Fetches the ImagePlus from the cache; be warned: the returned ImagePlus may have been flushed, removed and then recreated if the program had memory needs that required flushing part of the cache; use @getImageProcessor to get the pixels guaranteed not to be ever null.
`ij.process.ImageProcessor`	`getImageProcessor()` Fetches the ImageProcessor from the cache, which will never be flushed or its pixels set to null.
`AffineTransform`	`getLocalAffine(double wx, double wy)` Return the local affine transformation for a passed location in world coordinates.
`double`	`getLocalScale(double wx, double wy)`
`double`	`getMax()`
`int`	`getMeshResolution()`
`double`	`getMin()`
`int`	`getOHeight()` The original height of the pixels in the source image file.
`String`	`getOriginalPath()` Returns the value of the field original_path, which may be null.
`int`	`getOWidth()` The original width of the pixels in the source image file.
`int`	`getPixel(double mag, int x, int y)` Magnification-dependent counterpart to ImageProcessor.getPixel(x, y).
`int[]`	`getPixel(double mag, int x, int y, int[] iArray)` Magnification-dependent counterpart to ImageProcessor.getPixel(x, y, iArray).
`int[]`	`getPixel(int x, int y, double mag)` Expects x,y in world coordinates.
`String`	`getPreprocessorScriptPath()`
`ArrayList<Patch>`	`getStackPatches()`
`Patch.TransformProperties`	`getTransformPropertiesCopy()`
`int`	`getType()` Returns the ImagePlus type of this Patch.
`boolean`	`hasAlphaChannel()` Whether there is an alpha mask or there is an outside mask caused by a `CoordinateTransform`.
`boolean`	`hasAlphaMask()` Whether there is an alpha mask for the pixel data.
`boolean`	`hasCoordinateTransform()`
`boolean`	`intersects(Displayable d)` Check if this perimeter's intersects that of the given Displayable.
`boolean`	`intersects(Displayable d, boolean sloppy)`
`boolean`	`isDeletable()`
`boolean`	`isPreprocessed()`
`protected boolean`	`isRoughlyInside(Layer l, Rectangle r)` If this Displayable intersects with @param r or almost intersects, then returns true.
`boolean`	`isStack()` Returns true if this Patch holds direct links to at least one other image in a different layer.
`void`	`keyPressed(KeyEvent ke)`
`boolean`	`linkPatches()` Override to cancel.
`static ij.process.ImageProcessor`	`makeFlatGrayImage(List<Patch> patches, Rectangle finalBox, int backgroundValue, double scale)` Deprecated.
`static ij.process.ImageProcessor`	`makeFlatImage(int type, Layer layer, Rectangle srcRect, double scale, Collection<Patch> patches, Color background)` Defaults to setMinAndMax = true.
`static ij.process.ImageProcessor`	`makeFlatImage(int type, Layer layer, Rectangle srcRect, double scale, Collection<Patch> patches, Color background, boolean setMinAndMax)` Creates an ImageProcessor of the specified type.
`PatchStack`	`makePatchStack()` Retuns a virtual ImagePlus with a virtual stack if necessary.
`boolean`	`maskBorder(int size)` Make the border have an alpha of zero.
`boolean`	`maskBorder(int left, int top, int right, int bottom)` Make the border have an alpha of zero.
`void`	`mousePressed(MouseEvent me, Layer la, int x_p, int y_p, double mag)`
`void`	`paint(Graphics2D g, Rectangle srcRect, double magnification, boolean active, int channels, Layer active_layer, List<Layer> _ignored)`
`void`	`paintOffscreen(Graphics2D g, Rectangle srcRect, double magnification, boolean active, int channels, Layer active_layer, List<Layer> layers)` Paints waiting for data to load, if necessary.
`void`	`paintSnapshot(Graphics2D g, Layer layer, List<Layer> layers, Rectangle srcRect, double mag)`
`boolean`	`paintsWithFalseColor()`
`void`	`preAppendCoordinateTransform(CoordinateTransform ct)` Pre-append a `CoordinateTransform` to the current `CoordinateTransformList`.
`void`	`prePaint(Graphics2D g, Rectangle srcRect, double magnification, boolean active, int channels, Layer active_layer, List<Layer> _ignored)` Paint first whatever is available, then request that the proper image be loaded and painted.
`boolean`	`remove(boolean check)` Remove only if linked to other Patches or to noone.
`boolean`	`revert()` Revert the ImagePlus to the one stored in original_path, if any; will revert all linked patches if this is part of a stack.
`String`	`set(ij.ImagePlus new_imp)` Set a new ImagePlus for this Patch.
`protected void`	`setAlpha(float alpha, boolean update)`
`boolean`	`setAlphaMask(ij.process.ByteProcessor bp)` Must call updateMipMaps() afterwards.
`void`	`setCoordinateTransform(CoordinateTransform ct)` Set a CoordinateTransform to this Patch.
`void`	`setCoordinateTransformSilently(CoordinateTransform ct)` For reconstruction purposes, overwrites the present `CoordinateTransform`, if any, with the given one.
`void`	`setFilters(IFilter[] fs)` Set an array of @{link `IFilter`, which are applied in order to the `ImageProcessor` after the preprocessor script is applied but before the rest of TrakEM2 sees the image.
`void`	`setMeshResolution(int meshResolution)` Change the resolution of meshes used to render patches transformed by a `CoordinateTransform`.
`void`	`setMinAndMax(double min, double max)` The min and max values are stored with the Patch, so that the image can be flushed away but the non-destructive contrast settings preserved.
`protected boolean`	`setNewCoordinateTransform(CoordinateTransform ct)` Writes the `CoordinateTransform` `t` to the trakem2.transforms/ directory, using the unique `ct_id` and this `Patch`'s `DBObject.id` to generate a file path for it.
`void`	`setPreprocessorScriptPath(String path)` After setting a preprocessor script, it is advisable that you call updateMipMaps() immediately.
`double[]`	`toPixelCoordinate(double world_x, double world_y)` Transfer a world coordinate (in pixels, uncalibrated) to the coordinate space of the original image.
`static double[]`	`toPixelCoordinate(double world_x, double world_y, AffineTransform aff, CoordinateTransform ct, int meshResolution, int o_width, int o_height)`
`Future<Boolean>`	`updateMipMaps()` Recreate mipmaps and flush away any cached ones.
`void`	`updatePixelProperties(ij.ImagePlus imp)` Update type, original dimensions and min,max from the ImagePlus.

Methods inherited from class ini.trakem2.display.Displayable
adjustProperties, areThereLayerCrossLinks, canSendTo, clone, clone, commonDTDChildren, contains, deselect, destroy, displacePoints, exportDTD, exportSVG, findById, findNearestPoint, findNearestPoint, getAffineTransform, getAffineTransformCopy, getAlpha, getAnnotation, getAreaAt, getBoundingBox, getBoundingBox, getBoundingBox, getBounds, getBounds, getBucketable, getColor, getComposite, getComposite, getCompositeMode, getHeight, getIntersection, getLayer, getLayerIds, getLayerSet, getLayersWithData, getLinked, getLinked, getLinkedBox, getLinkedGroup, getLinkedProperties, getLinkedProperties, getLinkedProperty, getLinkedProperty, getMinimalBoundingBox, getNameId, getPerimeter, getPerimeter, getProperties, getProperty, getProperty, getShortTitle, getTitle, getWidth, getX, getXMLSafeValue, getXMLSafeValue, getY, hasLinkedGroupWithinLayer, hasProperties, intersects, intersects, intersects, inverseTransformPoint, isLinked, isLinked, isLinked, isLocked, isLocked2, isOnlyLinkedTo, isOnlyLinkedTo, isOutOfRepaintingClip, isOutOfRepaintingClip, isVisible, link, link, makeAdjustPropertiesDialog, measure, mouseDragged, mouseReleased, mouseWheelMoved, paintAsBox, preConcatenate, preTransform, processAdjustPropertiesDialog, remove2, removeLinkedProperties, removeLinkedPropertiesFromOrigins, repaint, restXML, rotate, rotate, rotatePoints, scale, scale, scalePoints, setAffineTransform, setAlpha, setAnnotation, setColor, setCompositeMode, setDimensions, setDimensions, setLayer, setLayer, setLinkedProperties, setLinkedProperty, setLocation, setLocked, setProperty, setTitle, setVisible, setVisible, snapTo, softRemove, toString, transform, transformPoint, transformPoint, transformPoints, transformPoints, transformPoints, transformPoints, transformPoints, transformPoints, transformPoints, transformPoints, transformPoints, transformRectangle, translate, translate, unlink, unlink, unlinkAll, updateBucket, updateInDatabase, xmlError, xmlError

Methods inherited from class ini.trakem2.persistence.DBObject
addToDatabase, getId, getInfo, getProject, getUniqueIdentifier, removeFromDatabase, updateInDatabase

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

- Field Detail
  - meshResolution
```
protected int meshResolution
```
  - DCM
```
public static final DirectColorModel DCM
```
- Constructor Detail
  - Patch
```
public Patch(Project project,
             String title,
             double x,
             double y,
             ij.ImagePlus imp)
```
    Construct a Patch from an image; most likely you will need to add the file path to the imp by calling Loader.addedPatchFrom(String, Patch), as in this example: project.getLoader().addedPatchFrom("/path/to/file.png", thePatch);
  - Patch
```
public Patch(Project project,
             long id,
             String title,
             float width,
             float height,
             int o_width,
             int o_height,
             int type,
             boolean locked,
             double min,
             double max,
             AffineTransform at)
```
    Reconstruct a Patch from the database. The ImagePlus will be loaded when necessary.
  - Patch
```
public Patch(Project project,
             String title,
             float width,
             float height,
             int o_width,
             int o_height,
             int type,
             float alpha,
             Color color,
             boolean locked,
             double min,
             double max,
             AffineTransform at,
             String file_path)
```
    Create a new Patch defining all necessary parameters; it is the responsibility of the caller to ensure that the parameters are in agreement with the image contained in the file_path.
  - Patch
```
public Patch(Project project,
             long id,
             HashMap<String,String> ht_attributes,
             HashMap<Displayable,String> ht_links)
```
    Reconstruct from an XML entry.
- Method Detail
  - getMeshResolution
```
public int getMeshResolution()
```
  - setMeshResolution
```
public void setMeshResolution(int meshResolution)
```
    Change the resolution of meshes used to render patches transformed by a CoordinateTransform. The method has to update bounding box offsets introduced by the CoordinateTransform because the bounding box has been calculated using the mesh.
    
    Parameters:
    
    meshResolution -
  - createPatch
```
public static final Patch createPatch(Project project,
                                      String filepath)
                               throws Exception
```
    Create a new Patch and register the associated filepath with the project's loader. This method is intended for scripting, to avoid having to create a new Patch and then call Loader.addedPatchFrom(String, Patch), which is easy to forget.
    
    Returns:
    
    the new Patch.
    
    Throws:
    
    Exception - if the image cannot be loaded from the filepath, or it's an unsupported type such as a composite image or a hyperstack.
  - getOWidth
```
public int getOWidth()
```
    The original width of the pixels in the source image file.
  - getOHeight
```
public int getOHeight()
```
    The original height of the pixels in the source image file.
  - getImagePlus
```
public ij.ImagePlus getImagePlus()
```
    Fetches the ImagePlus from the cache; be warned: the returned ImagePlus may have been flushed, removed and then recreated if the program had memory needs that required flushing part of the cache; use @getImageProcessor to get the pixels guaranteed not to be ever null.
  - getImageProcessor
```
public ij.process.ImageProcessor getImageProcessor()
```
    Fetches the ImageProcessor from the cache, which will never be flushed or its pixels set to null. If you keep many of these, you may end running out of memory: I advise you to call this method everytime you need the processor.
  - updateMipMaps
```
public Future<Boolean> updateMipMaps()
```
    Recreate mipmaps and flush away any cached ones. This method is essentially the same as patch.getProject().getLoader().update(patch); which in turn it's the same as the following two calls: patch.getProject().getLoader().generateMipMaps(patch); patch.getProject().getLoader().decacheAWT(patch.getId()); If you want to update lots of Patch instances in parallel, consider also project.getLoader().generateMipMaps(ArrayList patches, boolean overwrite);
  - updatePixelProperties
```
public void updatePixelProperties(ij.ImagePlus imp)
```
    Update type, original dimensions and min,max from the ImagePlus. This is automatically done after a preprocessor script has modified the image.
  - set
```
public String set(ij.ImagePlus new_imp)
```
    Set a new ImagePlus for this Patch. The original path and image remain untouched. Any later image is deleted and replaced by the new one.
  - setMinAndMax
```
public void setMinAndMax(double min,
                         double max)
```
    The min and max values are stored with the Patch, so that the image can be flushed away but the non-destructive contrast settings preserved.
  - getMin
```
public double getMin()
```
  - getMax
```
public double getMax()
```
  - getType
```
public int getType()
```
    Returns the ImagePlus type of this Patch.
  - createImage
```
public Image createImage(ij.ImagePlus imp)
```
  - createImage
```
public Image createImage()
```
  - getChannelAlphas
```
public int getChannelAlphas()
```
  - adjustChannels
```
public final Image adjustChannels(Image awt)
```
    Takes an image and scales its channels according to the values packed in this.channels. This method is intended for fixing RGB images which are loaded from jpegs (the mipmaps), and which have then the full colorization of the original image present in their pixels array. Otherwise the channel opacity scaling makes no sense. If 0xffffffff == this.channels the awt is returned as is. If the awt is null returns null.
  - paintOffscreen
```
public void paintOffscreen(Graphics2D g,
                           Rectangle srcRect,
                           double magnification,
                           boolean active,
                           int channels,
                           Layer active_layer,
                           List<Layer> layers)
```
    Description copied from class: Displayable
    
    Paints waiting for data to load, if necessary.
    
    Overrides:
    
    paintOffscreen in class Displayable
  - paint
```
public void paint(Graphics2D g,
                  Rectangle srcRect,
                  double magnification,
                  boolean active,
                  int channels,
                  Layer active_layer,
                  List<Layer> _ignored)
```
    Specified by:
    
    paint in interface Paintable
    
    Overrides:
    
    paint in class Displayable
  - prePaint
```
public void prePaint(Graphics2D g,
                     Rectangle srcRect,
                     double magnification,
                     boolean active,
                     int channels,
                     Layer active_layer,
                     List<Layer> _ignored)
```
    Paint first whatever is available, then request that the proper image be loaded and painted.
    
    Specified by:
    
    prePaint in interface Paintable
    
    Overrides:
    
    prePaint in class Displayable
  - isDeletable
```
public boolean isDeletable()
```
    Specified by:
    
    isDeletable in class Displayable
  - remove
```
public boolean remove(boolean check)
```
    Remove only if linked to other Patches or to noone.
    
    Overrides:
    
    remove in class Displayable
  - isStack
```
public final boolean isStack()
```
    Returns true if this Patch holds direct links to at least one other image in a different layer. Doesn't check for total overlap.
  - makePatchStack
```
public PatchStack makePatchStack()
```
    Retuns a virtual ImagePlus with a virtual stack if necessary.
  - getStackPatches
```
public ArrayList<Patch> getStackPatches()
```
  - exportXML
```
public void exportXML(StringBuilder sb_body,
                      String indent,
                      XMLOptions options)
```
    Opens and closes the tag and exports data. The image is saved in the directory provided in @param any as a String.
    
    Overrides:
    
    exportXML in class Displayable
  - exportDTD
```
public static void exportDTD(StringBuilder sb_header,
                             HashSet<String> hs,
                             String indent)
```
  - clone
```
public Displayable clone(Project pr,
                         boolean copy_id)
```
    Performs a copy of this object, without the links, unlocked and visible, except for the image which is NOT duplicated.
    
    Specified by:
    
    clone in class Displayable
  - getTransformPropertiesCopy
```
public Patch.TransformProperties getTransformPropertiesCopy()
```
  - linkPatches
```
public boolean linkPatches()
```
    Override to cancel.
    
    Overrides:
    
    linkPatches in class Displayable
    
    Returns:
    
    whether the locking state changed.
  - paintSnapshot
```
public void paintSnapshot(Graphics2D g,
                          Layer layer,
                          List<Layer> layers,
                          Rectangle srcRect,
                          double mag)
```
    Overrides:
    
    paintSnapshot in class Displayable
  - crosslink
```
protected static void crosslink(Collection<Displayable> patches,
                                boolean overlapping_only)
```
  - getPixel
```
public int getPixel(double mag,
                    int x,
                    int y)
```
    Magnification-dependent counterpart to ImageProcessor.getPixel(x, y). Expects x,y in world coordinates. This method is intended for grabing an occasional pixel; to grab all pixels, see @getImageProcessor method.
  - getPixel
```
public int[] getPixel(double mag,
                      int x,
                      int y,
                      int[] iArray)
```
    Magnification-dependent counterpart to ImageProcessor.getPixel(x, y, iArray). Expects x,y in world coordinates. This method is intended for grabing an occasional pixel; to grab all pixels, see @getImageProcessor method.
  - getPixel
```
public int[] getPixel(int x,
                      int y,
                      double mag)
```
    Expects x,y in world coordinates. This method is intended for grabing an occasional pixel; to grab all pixels, see @getImageProcessor method.
  - approximateTransferPixel
```
protected void approximateTransferPixel(int[] pvalue)
```
    Transfer an 8-bit or RGB pixel to this image color space, interpolating; the pvalue is modified in place. For float images (GRAY32), the float value is packed into bits in pvalue[0], and can be recovered with Float.intBitsToFloat(pvalue[0]).
  - getFilePath
```
public final String getFilePath()
```
    If this patch is part of a stack, the file path will contain the slice number attached to it, in the form -----#slice=10 for slice number 10.
  - getImageFilePath
```
public final String getImageFilePath()
```
    Returns the absolute path to the image file, as read by the OS.
  - getCurrentPath
```
public final String getCurrentPath()
```
    Returns the value of the field current_path, which may be null. If not null, the value may contain the slice info in it if it's part of a stack.
  - cacheCurrentPath
```
public final void cacheCurrentPath(String path)
```
    Cache a proper, good, known path to the image wrapped by this Patch.
  - getOriginalPath
```
public String getOriginalPath()
```
    Returns the value of the field original_path, which may be null. If not null, the value may contain the slice info in it if it's part of a stack.
  - setAlpha
```
protected void setAlpha(float alpha,
                        boolean update)
```
    Overrides:
    
    setAlpha in class Displayable
  - debug
```
public void debug()
```
  - revert
```
public boolean revert()
```
    Revert the ImagePlus to the one stored in original_path, if any; will revert all linked patches if this is part of a stack.
  - setCoordinateTransformSilently
```
public void setCoordinateTransformSilently(CoordinateTransform ct)
```
    For reconstruction purposes, overwrites the present CoordinateTransform, if any, with the given one. This method has been repurposed to write the CoordinateTransform to disk and set a new ct_id that points to it.
  - setCoordinateTransform
```
public final void setCoordinateTransform(CoordinateTransform ct)
```
    Set a CoordinateTransform to this Patch. The resulting image of applying the coordinate transform does not need to be rectangular: an alpha mask will take care of the borders. You should call updateMipMaps() afterwards to update the mipmap images used for painting this Patch to the screen.
  - appendCoordinateTransform
```
public final void appendCoordinateTransform(CoordinateTransform ct)
```
    Append a CoordinateTransform to the current CoordinateTransformList. If there is no transform yet, it just sets it. If there is only one transform, it replaces it by a list containing both, the existing first.
  - preAppendCoordinateTransform
```
public final void preAppendCoordinateTransform(CoordinateTransform ct)
```
    Pre-append a CoordinateTransform to the current CoordinateTransformList. If there is no transform yet, it just sets it. If there is only one transform, it replaces it by a list containing both, the new one first.
  - getCoordinateTransformBoundingBox
```
public final Rectangle getCoordinateTransformBoundingBox()
```
    Get the bounding rectangle of the transformed image relative to the original image. TODO Currently, this is done in a very expensive way. The TransformMesh is built and its bounding rectangle is returned. Think about just storing this rectangle in the Patch instance.
    
    Returns:
  - getCoordinateTransformBoundingBox
```
protected static final Rectangle getCoordinateTransformBoundingBox(Patch p,
                                                                   CoordinateTransform ct)
```
    Allow reusing a CoordinateTransform that was already loaded from a file.
    
    Parameters:
    
    p -
    
    ct -
    
    Returns:
  - getCoordinateTransform
```
public final CoordinateTransform getCoordinateTransform()
```
    Obtain a copy of the CoordinateTransform that transfers image data to mipmap image data.
    
    Returns:
    
    A copy of the CoordinateTransform, or null if none.
    
    See Also:
    
    setCoordinateTransform(CoordinateTransform)
  - getFullCoordinateTransform
```
public final CoordinateTransform getFullCoordinateTransform()
```
    Create a CoordinateTransform that incorporates both the CoordinateTransform of this Patch (if present) and its AffineTransform. The returned CoordinateTransform directly transfers the Patch into world coordinates. An image can be rendered e.g. using TransformMeshMapping with an TransformMesh. Note that you may prefer to use TransformMesh which does not perform auto-boxing as opposed to TransformMesh in the mpicbg.trakem2 package.
    
    Returns:
  - createCoordinateTransformedImage
```
public final Patch.PatchImage createCoordinateTransformedImage()
```
  - createTransformedImage
```
public Patch.PatchImage createTransformedImage()
```
    Returns a PatchImage object containing the bottom-of-transformation-stack image and alpha mask, if any (except the AffineTransform, which is used for direct hw-accel screen rendering).
  - hasAlphaMask
```
public final boolean hasAlphaMask()
```
    Whether there is an alpha mask for the pixel data.
  - getAlphaMaskId
```
public long getAlphaMaskId()
```
  - getAlphaMaskFilePath
```
public String getAlphaMaskFilePath()
```
    Returns:
    
    The absolute file path to the file specifying the image that represents the alpha mask, or null if none.
  - hasAlphaChannel
```
public boolean hasAlphaChannel()
```
    Whether there is an alpha mask or there is an outside mask caused by a CoordinateTransform.
  - setAlphaMask
```
public boolean setAlphaMask(ij.process.ByteProcessor bp)
                     throws IllegalArgumentException
```
    Must call updateMipMaps() afterwards. Set it to null to remove it.
    
    Returns:
    
    true if the alpha mask file was written successfully.
    
    Throws:
    
    IllegalArgumentException
  - getAlphaMask
```
public ij.process.ByteProcessor getAlphaMask()
```
    Return a new ByteProcessor representing the alpha mask, if any, over the pixel data.
    
    Returns:
    
    null if there isn't one, or if the mask image could not be loaded.
  - checkAlphaMaskFile
```
public boolean checkAlphaMaskFile()
```
    Returns:
    
    True if alpha_mask_id == 0 or if the file is found, or false if not found.
  - paintsWithFalseColor
```
public boolean paintsWithFalseColor()
```
  - keyPressed
```
public void keyPressed(KeyEvent ke)
```
    Overrides:
    
    keyPressed in class Displayable
  - contains
```
public boolean contains(double x_p,
                        double y_p)
```
    Considers the alpha mask.
    
    Overrides:
    
    contains in class Displayable
  - setPreprocessorScriptPath
```
public void setPreprocessorScriptPath(String path)
```
    After setting a preprocessor script, it is advisable that you call updateMipMaps() immediately.
  - addAlphaMask
```
public void addAlphaMask(Roi roi,
                         int value)
```
    Add the given roi, in world coords, to the alpha mask, using the given fill value.
  - addAlphaMask
```
public void addAlphaMask(Area aw,
                         int value)
```
    Add the given area, in world coords, to the alpha mask, using the given fill value.
  - addAlphaMaskLocal
```
public void addAlphaMaskLocal(Area aLocal,
                              int value)
```
    Add the given area, in local coordinates, to the alpha mask, using the given fill value.
  - getPreprocessorScriptPath
```
public String getPreprocessorScriptPath()
```
  - isPreprocessed
```
public boolean isPreprocessed()
```
  - getArea
```
public Area getArea()
```
    Returns an Area in world coords representing the inside of this Patch. The fully alpha pixels are considered outside.
    
    Overrides:
    
    getArea in class Displayable
  - makeFlatImage
```
public static ij.process.ImageProcessor makeFlatImage(int type,
                                                      Layer layer,
                                                      Rectangle srcRect,
                                                      double scale,
                                                      Collection<Patch> patches,
                                                      Color background)
```
    Defaults to setMinAndMax = true.
  - makeFlatImage
```
public static ij.process.ImageProcessor makeFlatImage(int type,
                                                      Layer layer,
                                                      Rectangle srcRect,
                                                      double scale,
                                                      Collection<Patch> patches,
                                                      Color background,
                                                      boolean setMinAndMax)
```
    Creates an ImageProcessor of the specified type.
    
    Parameters:
    
    type - Any of ImagePlus.GRAY_8, GRAY_16, GRAY_32 or COLOR_RGB.
    
    srcRect - the box in world coordinates to make an image out of.
    
    scale - may be up to 1.0.
    
    patches - The list of patches to paint. The first gets painted first (at the bottom).
    
    background - The color with which to paint the outsides where no image paints into.
    
    setMinAndMax - defines whether the min and max of each Patch is set before pasting the Patch. For exporting while blending the display ranges (min,max) and respecting alpha masks, see ExportUnsignedShort.
  - makeFlatGrayImage
```
@Deprecated
public static final ij.process.ImageProcessor makeFlatGrayImage(List<Patch> patches,
                                                                            Rectangle finalBox,
                                                                            int backgroundValue,
                                                                            double scale)
```
    Deprecated.
    
    Return an ImageProcessor containing a flat 8-bit image for use in e.g. extracting features. If the image is smaller than 0.5 GB, then the AWT system in Loader.getFlatAWTImage will be used, with the quality flag as true. Otherwise, mipmaps will be used to generate an image with ExportUnsignedByte, of if mipmaps are not available, then an up to 2GB image will be generated with ExportUnsignedByte and then Gaussian-downsampled to the requested dimensions. This method is as safe as it gets, regarding the many caveats of alpha masks, min-max, and the 2GB array indexing limit of java-8.
    
    Parameters:
    
    patches -
    
    finalBox -
    
    backgroundValue -
    
    scale -
    
    Returns:
    
    null when the dimensions are larger than 2GB, or the image otherwise.
  - maskBorder
```
public boolean maskBorder(int size)
```
    Make the border have an alpha of zero.
  - maskBorder
```
public boolean maskBorder(int left,
                          int top,
                          int right,
                          int bottom)
```
    Make the border have an alpha of zero.
  - getAreaForBucket
```
protected Area getAreaForBucket(Layer l)
```
    Use this instead of getAreaAt which calls getArea which is ... dog slow for something like buckets.
    
    Overrides:
    
    getAreaForBucket in class Displayable
  - isRoughlyInside
```
protected boolean isRoughlyInside(Layer l,
                                  Rectangle r)
```
    Description copied from class: Displayable
    
    If this Displayable intersects with @param r or almost intersects, then returns true. This method is meant to be very fast, and err on the "yes" and never on the "no".
    
    Overrides:
    
    isRoughlyInside in class Displayable
  - intersects
```
public boolean intersects(Displayable d,
                          boolean sloppy)
```
  - intersects
```
public boolean intersects(Displayable d)
```
    Description copied from class: Displayable
    
    Check if this perimeter's intersects that of the given Displayable.
    
    Overrides:
    
    intersects in class Displayable
  - appendFilters
```
public void appendFilters(IFilter[] fs)
```
    Append an array of IFilter to the array of existing IFilter.
    
    Parameters:
    
    fs - The array of IFilter to use for this Patch.
    
    See Also:
    
    setFilters(IFilter[]), getFilters()
  - setFilters
```
public void setFilters(IFilter[] fs)
```
    Set an array of @{link IFilter, which are applied in order to the ImageProcessor after the preprocessor script is applied but before the rest of TrakEM2 sees the image.
    
    Parameters:
    
    fs - The array of IFilter to use for this Patch. Can be null.
    
    See Also:
    
    appendFilters(IFilter[]), getFilters()
  - getFilters
```
public IFilter[] getFilters()
```
    Returns:
    
    The array of IFilter of this Patch.
    
    See Also:
    
    appendFilters(IFilter[]), setFilters(IFilter[])
  - hasCoordinateTransform
```
public boolean hasCoordinateTransform()
```
  - getCoordinateTransformId
```
public long getCoordinateTransformId()
```
    A value of 0 indicates that there isn't one.
  - getCoordinateTransformFilePath
```
public String getCoordinateTransformFilePath()
```
    Returns:
    
    The absolute file path to the file specifying the CoordinateTransform, or null if none.
  - fetchCoordinateTransform
```
public CoordinateTransform fetchCoordinateTransform()
                                             throws Exception
```
    Read in the CoordinateTransform from a file whose name is crafted from the ct_id and this Patch's DBObject.id.
    
    Returns:
    
    A new instance of the CoordinateTransform of this Patch, or null if none.
    
    Throws:
    
    Exception - if the file could not be found or parsed or read.
  - setNewCoordinateTransform
```
protected boolean setNewCoordinateTransform(CoordinateTransform ct)
                                     throws Exception
```
    Writes the CoordinateTransform t to the trakem2.transforms/ directory, using the unique ct_id and this Patch's DBObject.id to generate a file path for it.
    
    Returns:
    
    true if it was written successfully.
    
    Throws:
    
    Exception - if the new file could not be written.
  - checkCoordinateTransformFile
```
public boolean checkCoordinateTransformFile()
```
    Returns:
    
    True if ct_id == 0 or if the file is found, or false if not found.
  - toPixelCoordinate
```
public double[] toPixelCoordinate(double world_x,
                                  double world_y)
                           throws NoninvertibleTransformException
```
    Transfer a world coordinate (in pixels, uncalibrated) to the coordinate space of the original image. The world coordinate is first transferred to this Patch space by inverting the AffineTransform and then, if there is a CoordinateTransform, that is inverted as well to reach the coordinate space of the original image.
    
    Parameters:
    
    world_x -
    
    world_y -
    
    Returns:
    
    A double[] array with the x,y values.
    
    Throws:
    
    NoninvertibleTransformException
  - toPixelCoordinate
```
public static final double[] toPixelCoordinate(double world_x,
                                               double world_y,
                                               AffineTransform aff,
                                               CoordinateTransform ct,
                                               int meshResolution,
                                               int o_width,
                                               int o_height)
                                        throws NoninvertibleTransformException
```
    Parameters:
    
    world_x - The X of the world coordinate (in pixels, uncalibrated)
    
    world_y - The Y of the world coordinate (in pixels, uncalibrated)
    
    aff - The AffineTransform of the Patch.
    
    ct - The CoordinateTransform of the Patch, if any (can be null).
    
    meshResolution - The precision demanded for approximating a transform with a TransformMesh.
    
    o_width - The width of the image underlying the Patch.
    
    o_height - The height of the image underlying the Patch.
    
    Returns:
    
    A double[] array with the x,y values.
    
    Throws:
    
    NoninvertibleTransformException
    
    See Also:
    
    toPixelCoordinate(double, double)
  - getLocalAffine
```
public AffineTransform getLocalAffine(double wx,
                                      double wy)
```
    Return the local affine transformation for a passed location in world coordinates. This affine transform is either the global affine transform of the patch or the combined affine transform of the local affine transform in the transform mesh and its global affine transform.
    
    Parameters:
    
    wx -
    
    wy -
    
    Returns:
  - getLocalScale
```
public double getLocalScale(double wx,
                            double wy)
```
  - mousePressed
```
public void mousePressed(MouseEvent me,
                         Layer la,
                         int x_p,
                         int y_p,
                         double mag)
```
    Overrides:
    
    mousePressed in class Displayable
  - clearIntensityMap
```
public boolean clearIntensityMap()
```

Class Patch

Nested Class Summary

Nested classes/interfaces inherited from class ini.trakem2.display.Displayable

Field Summary

Fields inherited from class ini.trakem2.display.Displayable

Fields inherited from class ini.trakem2.persistence.DBObject

Constructor Summary

Method Summary

Methods inherited from class ini.trakem2.display.Displayable

Methods inherited from class ini.trakem2.persistence.DBObject

Methods inherited from class java.lang.Object

Field Detail

meshResolution

DCM

Constructor Detail

Patch

Patch

Patch

Patch

Method Detail

getMeshResolution

setMeshResolution

createPatch

getOWidth

getOHeight

getImagePlus

getImageProcessor

updateMipMaps

updatePixelProperties

set

setMinAndMax

getMin

getMax

getType

createImage

createImage

getChannelAlphas

adjustChannels

paintOffscreen

paint

prePaint

isDeletable

remove

isStack

makePatchStack

getStackPatches

exportXML

exportDTD

clone

getTransformPropertiesCopy

linkPatches

paintSnapshot

crosslink

getPixel

getPixel

getPixel

approximateTransferPixel

getFilePath

getImageFilePath

getCurrentPath

cacheCurrentPath

getOriginalPath

setAlpha

debug

revert

setCoordinateTransformSilently

setCoordinateTransform

appendCoordinateTransform

preAppendCoordinateTransform

getCoordinateTransformBoundingBox

getCoordinateTransformBoundingBox

getCoordinateTransform

getFullCoordinateTransform

createCoordinateTransformedImage

createTransformedImage

hasAlphaMask

getAlphaMaskId

getAlphaMaskFilePath

hasAlphaChannel

setAlphaMask