| Modifier and Type | Method and Description |
|---|---|
Patch |
PatchBottle.unBottle(MessageXC xc) |
| Modifier and Type | Method and Description |
|---|---|
Bottle<Patch> |
PatchBottler.bottle(Object o,
MessageXC xc) |
| Constructor and Description |
|---|
PatchBottle(Patch patch) |
| Modifier and Type | Field and Description |
|---|---|
protected Filter<Patch> |
FSAlignListener.patchFilter |
| Modifier and Type | Method and Description |
|---|---|
protected void |
FSAlignListener.imageCheck(Patch p) |
protected void |
FSAlignListener.imageDigest(Patch p) |
| Modifier and Type | Field and Description |
|---|---|
protected List<Patch> |
GroupingMode.originalPatches |
| Modifier and Type | Method and Description |
|---|---|
static Patch |
Patch.createPatch(Project project,
String filepath)
Create a new Patch and register the associated
filepath
with the project's loader. |
| Modifier and Type | Method and Description |
|---|---|
ArrayList<Patch> |
Layer.getPatches(boolean visible_only) |
ArrayList<Patch> |
Patch.getStackPatches() |
Coordinate<Patch> |
Layer.toPatchCoordinate(double world_x,
double world_y)
Transfer the world coordinate specified by
world_x,world_y
in pixels, to the local coordinate of the Patch immediately present under it. |
| Modifier and Type | Method and Description |
|---|---|
protected static Rectangle |
Patch.getCoordinateTransformBoundingBox(Patch p,
CoordinateTransform ct)
Allow reusing a
CoordinateTransform that was already loaded from a file. |
static String |
Display3D.makeTitle(Patch p) |
static void |
Display3D.showOrthoslices(Patch p) |
static void |
Display3D.showVolume(Patch p) |
static Bureaucrat |
Display.snap(Patch patch)
Snap a Patch to the most overlapping Patch, if any.
|
| Modifier and Type | Method and Description |
|---|---|
Bureaucrat |
Display.applyPatchTask(List<Patch> patches,
String taskTitle,
Operation<Boolean,Patch> task,
Filter<Patch> filter)
Meant for tasks that require setting an undo and regenerating mipmaps.
|
Bureaucrat |
Display.applyPatchTask(List<Patch> patches,
String taskTitle,
Operation<Boolean,Patch> task,
Filter<Patch> filter)
Meant for tasks that require setting an undo and regenerating mipmaps.
|
Bureaucrat |
Display.applyPatchTask(List<Patch> patches,
String taskTitle,
Operation<Boolean,Patch> task,
Filter<Patch> filter)
Meant for tasks that require setting an undo and regenerating mipmaps.
|
static ij.process.ImageProcessor |
Patch.makeFlatGrayImage(List<Patch> patches,
Rectangle finalBox,
int backgroundValue,
double scale)
Deprecated.
|
static ij.process.ImageProcessor |
Patch.makeFlatImage(int type,
Layer layer,
Rectangle srcRect,
double scale,
Collection<Patch> patches,
Color background)
Defaults to setMinAndMax = true.
|
static ij.process.ImageProcessor |
Patch.makeFlatImage(int type,
Layer layer,
Rectangle srcRect,
double scale,
Collection<Patch> patches,
Color background,
boolean setMinAndMax)
Creates an ImageProcessor of the specified type.
|
static Bureaucrat |
Display.removeAlphaMasks(Collection<Patch> patches) |
Bureaucrat |
Display.removeCoordinateTransforms(List<Patch> patches) |
Bureaucrat |
Display.removeScalingRotationShear(List<Patch> patches) |
Bureaucrat |
Display.setCoordinateTransform(List<Patch> patches,
CoordinateTransform ct,
boolean append)
Deprecated.
Use
Display.setCoordinateTransform(List, CoordinateTransform, int) instead which implements pre-appending as a third mode. |
Bureaucrat |
Display.setCoordinateTransform(List<Patch> patches,
CoordinateTransform ct,
int existingTransform) |
Bureaucrat |
Display.setMeshResolution(List<Patch> patches,
int meshResolution) |
| Constructor and Description |
|---|
TransformProperties(Patch p) |
| Modifier and Type | Method and Description |
|---|---|
Patch |
PatchStack.getCurrentPatch()
Returns the Patch corresponding to the current slice.
|
Patch |
PatchStack.getPatch(int i)
From 0 to getNSlices() -1, otherwise null.
|
Patch |
PatchStack.getPatch(Layer layer,
Patch p)
If the 'p' is contained in this PatchStack, get the first Patch found to be contained here and in the given 'layer'
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
PatchStack.contains(Patch p) |
static double[] |
StitchingTEM.correlate(Patch base,
Patch moving,
float percent_overlap,
double scale,
int direction,
double default_dx,
double default_dy,
double min_R) |
Patch |
PatchStack.getPatch(Layer layer,
Patch p)
If the 'p' is contained in this PatchStack, get the first Patch found to be contained here and in the given 'layer'
|
static ij.process.ImageProcessor |
StitchingTEM.makeStripe(Patch p,
Roi roi,
double scale) |
static ij.process.ImageProcessor |
StitchingTEM.makeStripe(Patch p,
Roi roi,
double scale,
boolean ignore_patch_transform) |
void |
PatchStack.revert(Patch p) |
void |
PatchStack.setCurrentSlice(Patch p) |
boolean |
StitchingTEM.PhaseCorrelationParam.setup(Patch ref)
Returns false when canceled.
|
static Runnable |
StitchingTEM.stitch(Patch[] patch,
int grid_width,
double default_bottom_top_overlap,
double default_left_right_overlap,
boolean optimize,
StitchingTEM.PhaseCorrelationParam param)
Returns the same Patch instances with their coordinates modified; the top-left image is assumed to be the first one, and thus serves as reference; so, after the first image, coordinates are ignored for each specific Patch.
|
| Modifier and Type | Method and Description |
|---|---|
static Bureaucrat |
Blending.blend(List<Layer> layers,
boolean respect_current_mask,
Filter<Patch> filter) |
static Bureaucrat |
Blending.blend(Set<Patch> patches,
boolean respect_current_mask)
For each file, find the weight for the alpha mask according to
wether the pixel overlaps with other images (weighted alpha
dependent on the distante to the image border and of that on
the other images) or not (full alpha).
|
static void |
Blending.blendLayerWise(List<Layer> layers,
boolean respect_current_mask,
Filter<Patch> filter) |
static void |
Blending.blendPatches(Set<Patch> patches,
boolean respect_current_mask) |
static void |
StitchingTEM.montageWithPhaseCorrelation(Collection<Patch> col) |
static void |
StitchingTEM.montageWithPhaseCorrelation(Collection<Patch> col,
StitchingTEM.PhaseCorrelationParam param)
Perform montage based on phase correlation
|
static Bureaucrat |
StitchingTEM.montageWithPhaseCorrelationTask(Collection<Patch> col)
For each Patch, find who overlaps with it and perform a phase correlation or cross-correlation with it;
then consider all successful correlations as links and run the optimizer on it all.
|
| Constructor and Description |
|---|
ContrastEnhancerWrapper(Patch reference) |
PatchStack(Patch[] patch,
int currentSlice) |
| Modifier and Type | Method and Description |
|---|---|
static void |
FilterEditor.GUI(Collection<Patch> patches,
Patch reference) |
| Modifier and Type | Method and Description |
|---|---|
static void |
FilterEditor.GUI(Collection<Patch> patches,
Patch reference) |
| Modifier and Type | Method and Description |
|---|---|
Patch |
Loader.addNewImage(ij.ImagePlus imp) |
Patch |
Loader.addNewImage(ij.ImagePlus imp,
double x,
double y)
Mipmaps for this image are generated asynchronously.
|
Patch |
Loader.importImage(Project project,
double x,
double y) |
Patch |
Loader.importImage(Project project,
double x,
double y,
String path,
boolean synch_mipmap_generation)
Import a new image at the given coordinates; does not puts it into any layer, unless it's a stack -in which case importStack is called with the current front layer of the given project as target.
|
Patch |
Loader.importNextImage(Project project,
double x,
double y) |
protected abstract Patch |
Loader.importStackAsPatches(Project project,
Layer first_layer,
double x,
double y,
ij.ImagePlus stack,
boolean as_copy,
String filepath) |
protected Patch |
FSLoader.importStackAsPatches(Project project,
Layer first_layer,
double x,
double y,
ij.ImagePlus imp_stack,
boolean as_copy,
String filepath)
Returns the last Patch.
|
protected Patch |
DBLoader.importStackAsPatches(Project project,
Layer first_layer,
double x,
double y,
ij.ImagePlus imp_stack,
boolean as_copy,
String filepath)
Returns the last Patch.
|
protected Patch |
Loader.importStackAsPatches(Project project,
Layer first_layer,
ij.ImagePlus stack,
boolean as_copy,
String filepath) |
| Modifier and Type | Method and Description |
|---|---|
static void |
FilePathRepair.add(Patch patch) |
void |
Loader.addedPatchFrom(String path,
Patch patch)
Subclasses can override this method to register the URL of the imported image.
|
void |
FSLoader.addedPatchFrom(String path,
Patch patch)
All backslashes are converted to slashes to avoid havoc in MSWindows.
|
void |
Loader.adjustChannels(Patch p,
int old_channels) |
void |
Loader.cache(Patch p,
ij.ImagePlus imp) |
boolean |
Loader.checkMipMapFileExists(Patch p,
double magnification)
Does nothing and returns false unless overriden.
|
boolean |
FSLoader.checkMipMapFileExists(Patch p,
double magnification)
Checks if the mipmap file for the Patch and closest upper level to the desired magnification exists.
|
boolean |
Loader.clearIntensityMap(Patch p)
Clear the intensity map coefficients for a patch.
|
boolean |
FSLoader.clearIntensityMap(Patch p) |
static ImageBytes[] |
IntegralImageMipMaps.create(Patch patch,
ij.process.ImageProcessor ip,
ij.process.ByteProcessor alpha,
ij.process.ByteProcessor outside,
int type)
WARNING modifies the
outside array when both alpha and outside are not null,
and when ip is a ColorProcessor, will also modify ints int[] pixels
if alpha or outside are not null (the alpha channel is or'ed in). |
static ImageBytes[] |
DownsamplerMipMaps.create(Patch patch,
int type,
ij.process.ImageProcessor ip,
ij.process.ByteProcessor alpha,
ij.process.ByteProcessor outside) |
static ImageBytes[] |
DownsamplerMipMaps.create(Patch patch,
int type,
ij.process.ImageProcessor ip,
ij.process.ByteProcessor alpha,
ij.process.ByteProcessor outside,
int first_level) |
static ImageBytes[] |
DownsamplerMipMaps.create(Patch patch,
int type,
int n_levels,
ij.process.ImageProcessor ip,
ij.process.ByteProcessor alpha,
ij.process.ByteProcessor outside) |
static String |
FSLoader.createMipMapRelPath(Patch p,
String ext)
For Patch id=12345 creates 12/34/5.${filename}.jpg
|
Bureaucrat |
Loader.enhanceContrast(Collection<Displayable> patches,
Patch reference)
Homogenize contrast for all patches, optionally using the @param reference Patch (can be null).
|
long |
Loader.estimateImageFileSize(Patch p,
int level) |
long |
FSLoader.estimateImageFileSize(Patch p,
int level)
Compute the number of bytes that the ImagePlus of a Patch will take.
|
String |
Loader.exportImage(Patch patch,
ij.ImagePlus imp,
String path,
boolean overwrite)
Returns the path to the saved image, or null if not saved.
|
String |
Loader.exportImage(Patch patch,
String path,
boolean overwrite) |
MipMapImage |
Loader.fetchAWTImage(Patch p,
int level,
int max_level) |
MipMapImage |
Loader.fetchDataImage(Patch p,
double mag)
Calls fetchImage(p, mag) unless overriden.
|
MipMapImage |
FSLoader.fetchDataImage(Patch p,
double mag)
Waits until a proper image of the desired size or larger can be returned, which is never the Loader.REGENERATING image.
|
MipMapImage |
Loader.fetchImage(Patch p) |
MipMapImage |
Loader.fetchImage(Patch p,
double mag)
Fetch a suitable awt.Image for the given magnification.
|
Object |
FSLoader.fetchImage(Patch p,
int format)
So far accepts Layer.IMAGEPLUS and Layer.IMAGEPROCESSOR as format.
|
ij.process.ByteProcessor |
Loader.fetchImageMask(Patch p)
Deprecated.
|
ij.process.ByteProcessor |
FSLoader.fetchImageMask(Patch p)
Returns the alpha mask image from a file, or null if none stored.
|
abstract ij.ImagePlus |
Loader.fetchImagePlus(Patch p) |
ij.ImagePlus |
FSLoader.fetchImagePlus(Patch p) |
ij.ImagePlus |
DBLoader.fetchImagePlus(Patch p) |
ij.process.ImageProcessor |
Loader.fetchImageProcessor(Patch p)
Returns null unless overriden.
|
ij.process.ImageProcessor |
FSLoader.fetchImageProcessor(Patch p)
Fetch the ImageProcessor in a synchronized manner, so that there are no conflicts in retrieving the ImageProcessor for a specific stack slice, for example.
|
MipMapImage |
FSLoader.fetchMipMap(Patch patch,
int level,
long n_bytes)
Does the actual fetching of the file.
|
protected MipMapImage |
Loader.fetchMipMapAWT(Patch patch,
int level,
long n_bytes)
Does nothing and returns null unless overriden.
|
protected MipMapImage |
FSLoader.fetchMipMapAWT(Patch patch,
int level,
long n_bytes)
Loads the file containing the scaled image corresponding to the given level
(or the maximum possible level, if too large)
and returns it as an awt.Image, or null if not found.
|
abstract ij.ImagePlus |
Loader.fetchOriginal(Patch patch)
Used for the revert command.
|
ij.ImagePlus |
FSLoader.fetchOriginal(Patch patch)
Loads and returns the original image, which is not cached, or returns null if it's not different than the working image.
|
ij.ImagePlus |
DBLoader.fetchOriginal(Patch patch) |
protected boolean |
Loader.generateMipMaps(Patch patch)
Does nothing and returns false unless overriden.
|
protected boolean |
FSLoader.generateMipMaps(Patch patch)
Given an image and its source file name (without directory prepended), generate
a pyramid of images until reaching an image not smaller than 32x32 pixels.
|
String |
StaleFiles.Path.get(Patch patch) |
String |
StaleFiles.CoordinateTransformPath.get(Patch patch) |
String |
StaleFiles.AlphaMaskPath.get(Patch patch) |
String |
Loader.getAbsolutePath(Patch patch)
Returns null unless overriden.
|
String |
FSLoader.getAbsolutePath(Patch patch)
With slice info appended at the end; only if it exists, otherwise null.
|
MipMapImage |
Loader.getCachedClosestAboveImage(Patch p,
double mag)
Above or equal in size.
|
MipMapImage |
Loader.getCachedClosestBelowImage(Patch p,
double mag)
Below, not equal.
|
int |
Loader.getClosestMipMapLevel(Patch patch,
int level,
int max_level)
Does nothing and returns zero unless overriden.
|
int |
FSLoader.getClosestMipMapLevel(Patch patch,
int level,
int max_level)
Return the closest level to
level that exists as a file. |
Dimension |
Loader.getDimensions(Patch p) |
String |
Loader.getFileName(Patch p)
Equivalent to File.getName(), but subtracts the slice info from it if any.
|
static int |
Loader.getHighestMipMapLevel(Patch p)
Returns the highest mipmap level for which a mipmap image may have been generated given the dimensions of the Patch.
|
String |
Loader.getImageFilePath(Patch p)
Returns null unless overriden.
|
String |
FSLoader.getImageFilePath(Patch p) |
protected String |
Loader.getInternalFileName(Patch p)
Equivalent to File.getName(), does not subtract the slice info from it.
|
String |
Loader.getPath(Patch patch)
Returns null unless overriden.
|
String |
FSLoader.getPath(Patch patch)
Returns the stored path for the given Patch image, which may be relative and may contain slice information appended.
|
String |
Loader.getPreprocessorScriptPath(Patch p) |
boolean |
Loader.isCached(Patch p,
double mag)
Returns true if there is a cached awt image for the given mag and Patch id.
|
boolean |
Loader.isImagePlusCached(Patch p) |
protected boolean |
Loader.mapIntensities(Patch p,
ij.ImagePlus imp) |
protected boolean |
FSLoader.mapIntensities(Patch p,
ij.ImagePlus imp) |
static FutureTask<MipMapImage> |
Loader.preload(Patch p,
double mag,
boolean repaint)
Returns null when on low memory condition.
|
protected ij.ImagePlus |
Loader.preProcess(Patch p,
ij.ImagePlus imp,
long image_n_bytes) |
void |
Loader.queueForMipmapRemoval(Patch p,
boolean yes)
Does nothing unless overriden.
|
void |
FSLoader.queueForMipmapRemoval(Patch p,
boolean yes)
Queue/unqueue for mipmap removal on shutdown without saving;
the
yes, when true, makes the p be queued,
and when false, be removed from the queue. |
Future<Boolean> |
Loader.regenerateMipMaps(Patch patch)
Does nothing and returns null unless overriden.
|
Future<Boolean> |
FSLoader.regenerateMipMaps(Patch patch)
Queue the regeneration of mipmaps for the Patch; returns immediately, having submitted the job to an executor queue;
returns a Future if the task was submitted, null if not.
|
boolean |
Loader.removeAlphaMask(Patch p)
Deprecated.
|
Future<Boolean> |
Loader.removeMipMaps(Patch patch)
Does nothing unless overriden.
|
Future<Boolean> |
FSLoader.removeMipMaps(Patch p)
Gets data from the Patch and queues a new task to do the file removal in a separate task manager thread.
|
boolean |
FSLoader.removeSerializedFeatures(Patch patch)
Remove the file, if it exists, with serialized features for patch.
|
boolean |
FSLoader.removeSerializedPointMatches(Patch patch)
Remove the file, if it exists, with serialized point matches for patch.
|
String |
Loader.setImageFile(Patch p,
ij.ImagePlus imp)
Does nothing and returns null unless overridden.
|
String |
FSLoader.setImageFile(Patch p,
ij.ImagePlus imp)
Returns the absolute path to a file that contains the given ImagePlus image - which may be the path as described in the ImagePlus FileInfo object itself, or a totally new file.
|
void |
Loader.setPreprocessorScriptPath(Patch p,
String path)
Set a preprocessor script that will be executed on the ImagePlus of the Patch when loading it, before TrakEM2 sees it at all.
|
void |
Loader.setPreprocessorScriptPathSilently(Patch p,
String path)
Set a preprocessor script that will be executed on the ImagePlus of the Patch when loading it, before TrakEM2 sees it at all.
|
void |
Loader.storeAlphaMask(Patch p,
ij.process.ByteProcessor fp)
Deprecated.
|
void |
Loader.tagForMipmapRemoval(Patch p,
boolean yes)
Does nothing unless overriden.
|
void |
FSLoader.tagForMipmapRemoval(Patch p,
boolean yes)
Queue/unqueue for mipmap removal on shutdown without saving;
the
yes, when true, makes the p be queued,
and when false, be removed from the queue. |
| Modifier and Type | Method and Description |
|---|---|
static void |
Loader.preload(Collection<Patch> patches,
double mag,
boolean repaint)
Disabled when on low memory condition, or when num_preloader_threads is smaller than 1.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
PatchScript.run(Patch patch,
ij.ImagePlus imp,
String path)
Run the script at path on the ImagePlus of patch.
|
| Modifier and Type | Field and Description |
|---|---|
protected List<Patch> |
DistortionCorrectionTask.SetCoordinateTransformThread.patches |
protected List<Patch> |
DistortionCorrectionTask.AppendCoordinateTransformThread.patches |
| Modifier and Type | Method and Description |
|---|---|
protected static void |
DistortionCorrectionTask.appendCoordinateTransform(List<Patch> patches,
CoordinateTransform transform,
int numThreads) |
static void |
DistortionCorrectionTask.run(DistortionCorrectionTask.CorrectDistortionFromSelectionParam p,
List<Patch> patches,
Displayable active,
Layer layer) |
static void |
DistortionCorrectionTask.run(DistortionCorrectionTask.CorrectDistortionFromSelectionParam p,
List<Patch> patches,
Displayable active,
Layer layer,
Worker worker) |
protected static void |
DistortionCorrectionTask.setCoordinateTransform(List<Patch> patches,
CoordinateTransform transform,
int numThreads) |
| Constructor and Description |
|---|
AppendCoordinateTransformThread(List<Patch> patches,
CoordinateTransform transform,
AtomicInteger ai) |
SetCoordinateTransformThread(List<Patch> patches,
CoordinateTransform transform,
AtomicInteger ai) |
| Modifier and Type | Field and Description |
|---|---|
protected Patch |
AbstractAffineTile2D.patch |
| Modifier and Type | Method and Description |
|---|---|
Patch |
AbstractAffineTile2D.getPatch() |
| Modifier and Type | Method and Description |
|---|---|
static List<Patch> |
AlignmentUtils.filterPatches(Layer layer,
Filter<Patch> filter) |
| Modifier and Type | Method and Description |
|---|---|
static void |
AlignTask.alignMultiLayerMosaic(Layer l,
Patch nail)
Align a multi-layer mosaic.
|
static Bureaucrat |
AlignTask.alignMultiLayerMosaicTask(Layer l,
Patch nail) |
static void |
AlignTask.alignMultiLayerMosaicTask(List<Layer> layerRange,
Patch nail,
Align.Param cp,
Align.ParamOptimize p,
Align.ParamOptimize pcp,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn,
boolean deformIn) |
static void |
Util.applyLayerTransformToPatch(Patch patch,
CoordinateTransform ct) |
static Bureaucrat |
AlignTask.registerStackSlices(Patch slice) |
static Bureaucrat |
AlignTask.snap(Patch patch,
Align.ParamOptimize p_snapIn,
boolean setup)
Find the most overlapping image to @param patch in the same layer where @param patch sits, and snap @param patch and all its linked Displayable objects.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
Align.alignLayersLinearly(List<Layer> layers,
int numThreads,
Filter<Patch> filter)
Align a range of layers by accumulating pairwise alignments of contiguous layers.
|
static void |
AlignLayersTask.alignLayersLinearlyJob(LayerSet layerSet,
int first,
int last,
boolean propagateTransform,
Rectangle fov,
Filter<Patch> filter) |
static void |
AlignLayersTask.alignLayersNonLinearlyJob(LayerSet layerSet,
int first,
int last,
boolean propagateTransform,
Rectangle fov,
Filter<Patch> filter) |
static void |
AlignTask.alignPatches(Align.ParamOptimize p,
List<Patch> patches,
Collection<Patch> fixedPatches,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn) |
static void |
AlignTask.alignPatches(Align.ParamOptimize p,
List<Patch> patches,
Collection<Patch> fixedPatches,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn) |
static void |
AlignTask.alignPatches(Align.ParamOptimize p,
List<Patch> patches,
Collection<Patch> fixedPatches,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn,
boolean sloppyOverlapTest) |
static void |
AlignTask.alignPatches(Align.ParamOptimize p,
List<Patch> patches,
Collection<Patch> fixedPatches,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn,
boolean sloppyOverlapTest) |
static void |
AlignTask.alignPatches(List<Patch> patches,
Set<Patch> fixedPatches,
int m) |
static void |
AlignTask.alignPatches(List<Patch> patches,
Set<Patch> fixedPatches,
int m) |
static Bureaucrat |
AlignTask.alignPatchesTask(List<Patch> patches,
Set<Patch> fixedPatches) |
static Bureaucrat |
AlignTask.alignPatchesTask(List<Patch> patches,
Set<Patch> fixedPatches) |
protected static void |
RegularizedAffineLayerAlignment.applyTransformToLayer(Layer layer,
AffineTransform affine,
Filter<Patch> filter) |
protected static void |
ElasticLayerAlignment.applyTransformToLayer(Layer layer,
CoordinateTransform mlt,
Filter<Patch> filter) |
void |
ElasticLayerAlignment.exec(ElasticLayerAlignment.Param param,
Project project,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
void |
ElasticMontage.exec(ElasticMontage.Param param,
List<Patch> patches,
Set<Patch> fixedPatches) |
void |
ElasticMontage.exec(ElasticMontage.Param param,
List<Patch> patches,
Set<Patch> fixedPatches) |
void |
RegularizedAffineLayerAlignment.exec(LayerSet layerSet,
int firstIn,
int lastIn,
int ref,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
ElasticLayerAlignment.exec(LayerSet layerSet,
int firstIn,
int lastIn,
int ref,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
RegularizedAffineLayerAlignment.exec(LayerSet layerSet,
int firstIn,
int lastIn,
int ref,
boolean propagateTransform,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
ElasticLayerAlignment.exec(LayerSet layerSet,
int firstIn,
int lastIn,
int ref,
boolean propagateTransform,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
RegularizedAffineLayerAlignment.exec(LayerSet layerSet,
int firstIn,
int lastIn,
int ref1,
int ref2,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
ElasticLayerAlignment.exec(LayerSet layerSet,
int firstIn,
int lastIn,
int ref1,
int ref2,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
RegularizedAffineLayerAlignment.exec(List<Layer> layerRange,
Set<Layer> fixedLayers,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
ElasticMontage.exec(List<Patch> patches,
Set<Patch> fixedPatches) |
void |
ElasticMontage.exec(List<Patch> patches,
Set<Patch> fixedPatches) |
void |
ElasticLayerAlignment.exec(Project project,
List<Layer> layerRange,
Set<Layer> fixedLayers,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
RegularizedAffineLayerAlignment.exec(RegularizedAffineLayerAlignment.Param param,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
protected static void |
AlignmentUtils.extractAndSaveLayerFeatures(List<Layer> layerRange,
Rectangle box,
double scale,
Filter<Patch> filter,
FloatArray2DSIFT.Param siftParam,
boolean clearCache,
int numThreads)
Extract SIFT features and save them into the project folder.
|
static List<Patch> |
AlignmentUtils.filterPatches(Layer layer,
Filter<Patch> filter) |
static void |
Align.tilesFromPatches(Align.Param p,
List<? extends Patch> patches,
Collection<? extends Patch> fixedPatches,
List<AbstractAffineTile2D<?>> tiles,
Collection<AbstractAffineTile2D<?>> fixedTiles)
If a Patch is locked or in fixedPatches, its corresponding Tile is added to fixedTiles.
|
static void |
Align.tilesFromPatches(Align.Param p,
List<? extends Patch> patches,
Collection<? extends Patch> fixedPatches,
List<AbstractAffineTile2D<?>> tiles,
Collection<AbstractAffineTile2D<?>> fixedTiles)
If a Patch is locked or in fixedPatches, its corresponding Tile is added to fixedTiles.
|
static void |
AlignTask.transformPatchesAndVectorData(Collection<Patch> patches,
AffineTransform a) |
static void |
AlignTask.transformPatchesAndVectorData(Collection<Patch> patches,
Runnable alignment)
For registering within the same project instance.
|
| Constructor and Description |
|---|
AbstractAffineTile2D(A model,
Patch patch) |
AffineTile2D(AffineModel2D model,
Patch patch) |
AffineTile2D(Patch patch) |
GenericAffineTile2D(A model,
Patch patch) |
RigidTile2D(Patch patch) |
RigidTile2D(RigidModel2D model,
Patch patch) |
SimilarityTile2D(Patch patch) |
SimilarityTile2D(SimilarityModel2D model,
Patch patch) |
TranslationTile2D(Patch patch) |
TranslationTile2D(TranslationModel2D model,
Patch patch) |
| Constructor and Description |
|---|
BlockMatchPairCallable(Triple<Integer,Integer,AbstractModel<?>> pair,
List<Layer> layerRange,
boolean layer1Fixed,
boolean layer2Fixed,
Filter<Patch> filter,
ElasticLayerAlignment.Param param,
Collection<? extends Point> sourcePoints1,
Collection<? extends Point> sourcePoints2,
Rectangle box) |
| Modifier and Type | Field and Description |
|---|---|
Patch |
ExportUnsignedShort.PatchIntensityRange.patch |
| Modifier and Type | Field and Description |
|---|---|
List<Patch> |
ExportBestFlatImage.patches |
| Modifier and Type | Method and Description |
|---|---|
ExportUnsignedByte.ImageData |
ExportUnsignedByte.ImageSource.fetch(Patch p,
double scale) |
ExportUnsignedByte.ImageData |
ExportUnsignedByte.MipMapSource.fetch(Patch patch,
double scale) |
ExportUnsignedByte.ImageData |
ExportUnsignedByte.OriginalSource.fetch(Patch patch,
double scale) |
| Modifier and Type | Method and Description |
|---|---|
static ij.process.ShortProcessor |
ExportUnsignedShort.makeFlatImage(List<Patch> patches,
Rectangle roi)
Create a flat image into which Patch instances are transferred considering their min and max values.
|
static ij.process.ShortProcessor |
ExportUnsignedShort.makeFlatImage(List<Patch> patches,
Rectangle roi,
double backgroundValue) |
static ij.process.ShortProcessor |
ExportUnsignedShort.makeFlatImage(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale) |
static Pair<ij.process.ShortProcessor,ij.process.ByteProcessor> |
ExportUnsignedShort.makeFlatImage(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale,
boolean makeAlphaMask) |
static Pair<ij.process.ByteProcessor,ij.process.ByteProcessor> |
ExportUnsignedByte.makeFlatImage(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale,
ExportUnsignedByte.ImageSource fetcher) |
static Pair<ij.process.ColorProcessor,ij.process.ByteProcessor> |
ExportARGB.makeFlatImageARGB(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale,
boolean use_mipmaps) |
static Pair<ij.process.ColorProcessor,ij.process.ByteProcessor> |
ExportARGB.makeFlatImageARGBFromMipMaps(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale)
Returns nonsense or throws an Exception if mipmaps are not available.
|
static Pair<ij.process.ColorProcessor,ij.process.ByteProcessor> |
ExportARGB.makeFlatImageARGBFromOriginals(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale)
Limited to 2GB arrays for the requested image.
|
static Pair<ij.process.ByteProcessor,ij.process.ByteProcessor> |
ExportUnsignedByte.makeFlatImageFromMipMaps(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale)
Works only when mipmaps are available, returning nonsense otherwise.
|
static Pair<ij.process.ByteProcessor,ij.process.ByteProcessor> |
ExportUnsignedByte.makeFlatImageFromOriginals(List<Patch> patches,
Rectangle roi,
double backgroundValue,
double scale) |
| Constructor and Description |
|---|
ExportBestFlatImage(List<Patch> patches,
Rectangle finalBox,
int backgroundValue,
double scale)
Class to manage the creation of an ImageProcessor containing a flat 8-bit or RGB image for use in e.g.
|
| Modifier and Type | Method and Description |
|---|---|
protected static <T extends Model<T> & Affine1D<T>> |
MatchIntensities.generateCoefficientsTiles(Collection<Patch> patches,
T template,
int nCoefficients) |
| Modifier and Type | Method and Description |
|---|---|
static void |
Render.render(Patch patch,
int coefficientsWidth,
int coefficientsHeight,
ij.process.FloatProcessor targetImage,
ij.process.FloatProcessor targetWeight,
ij.process.ColorProcessor targetCoefficients,
double x,
double y,
double scale)
Renders a patch, mapping its intensities [min, max] → [0, 1]
|
| Modifier and Type | Method and Description |
|---|---|
protected static <T extends Model<T> & Affine1D<T>> |
MatchIntensities.generateCoefficientsTiles(Collection<Patch> patches,
T template,
int nCoefficients) |
Copyright © 2015–2021 Fiji. All rights reserved.