Align (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- mpicbg.trakem2.align.Align

```
public class Align
extends Object
```
A collection of methods regarding SIFT-based alignment TODO Bring the methods and tasks into a class for each method and clean up this mess.

Author:

Stephan Saalfeld saalfeld@mpi-cbg.de

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`Align.ExtractFeaturesThread` Extracts `SIFT-features` from a `List` of `Tiles` and saves them to disk.
`protected static class`	`Align.MatchFeaturesAndFindModelThread`
`static class`	`Align.Param`
`static class`	`Align.ParamOptimize`

Field Summary

Fields
Modifier and Type Field and Description

static Align.Param param

static Align.ParamOptimize paramOptimize

Fields
Modifier and Type	Field and Description
`static Align.Param`	`param`
`static Align.ParamOptimize`	`paramOptimize`

Constructor Summary

Constructors
Constructor and Description

Align()

Constructors
Constructor and Description
`Align()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`alignLayer(Layer layer, int numThreads)` Align all `patches` in a Layer.
`static void`	`alignLayersLinearly(List<Layer> layers, int numThreads)` Align a range of layers by accumulating pairwise alignments of contiguous layers.
`static void`	`alignLayersLinearly(List<Layer> layers, int numThreads, Filter<Patch> filter)` Align a range of layers by accumulating pairwise alignments of contiguous layers.
`static void`	`alignSelectedPatches(Selection selection, int numThreads)` Align a selection of `patches` in a Layer.
`static void`	`alignTileCollections(Align.Param p, Collection<AbstractAffineTile2D<?>> a, Collection<AbstractAffineTile2D<?>> b)` Align two collections of tiles
`static void`	`alignTiles(Align.ParamOptimize p, List<AbstractAffineTile2D<?>> tiles, List<AbstractAffineTile2D<?>> fixedTiles, boolean tilesAreInPlace, int numThreads)` Align a set of `tiles` using the following procedure: Extract `SIFT-features` from all `tiles`. Establish `point-correspondences` from consistent sets of `feature` matches among tile pairs, optionally inspect only those that are already overlapping. Globally align the tile configuration. Both `feature extraction` and `matching` are executed in multiple `Threads`, with the number of `Threads` being a parameter of the method.
`static void`	`alignTiles(Align.ParamOptimize p, List<AbstractAffineTile2D<?>> tiles, List<AbstractAffineTile2D<?>> fixedTiles, int numThreads)` Align a set of overlapping `tiles` using the following procedure: Extract `SIFT-features` from all `tiles`. Establish `point-correspondences` from consistent sets of `feature` matches among overlapping tiles. Globally align the tile configuration. Both `feature extraction` and `matching` are executed in multiple `Threads`, with the number of `Threads` being a parameter of the method.
`static void`	`connectTilePairs(Align.Param p, List<AbstractAffineTile2D<?>> tiles, List<AbstractAffineTile2D<?>[]> tilePairs, int numThreads)` Connect a `List` of `Tiles` by geometrically consistent `SIFT-feature` correspondences.
`static void`	`connectTilePairs(Align.Param p, List<AbstractAffineTile2D<?>> tiles, List<AbstractAffineTile2D<?>[]> tilePairs, int numThreads, boolean multipleHypotheses)` Connect a `List` of `Tiles` by geometrically consistent `SIFT-feature` correspondences.
`static MovingLeastSquaresTransform2`	`createMLST(Collection<PointMatch> matches, double alpha)` Temporary helper method that creates
`protected static Collection<Feature>`	`deserializeFeatures(Align.Param p, AbstractAffineTile2D<?> t)` Retrieve the features only if saved with the exact same relevant SIFT parameters.
`protected static Collection<PointMatch>`	`deserializePointMatches(Align.Param p, AbstractAffineTile2D<?> t1, AbstractAffineTile2D<?> t2)`
`protected static Collection<Feature>`	`fetchFeatures(Align.Param p, AbstractAffineTile2D<?> t)`
`protected static Collection<PointMatch>`	`fetchPointMatches(Align.Param p, AbstractAffineTile2D<?> t1, AbstractAffineTile2D<?> t2)` Fetch a `Collection` of corresponding `SIFT-features`.
`static boolean`	`findModel(Model<?> model, List<PointMatch> candidates, Collection<PointMatch> inliers, float maxEpsilon, float minInlierRatio, int minNumInliers, boolean rejectIdentity, float identityTolerance)`
`static boolean`	`findModel(Model<?> model, List<PointMatch> candidates, Collection<PointMatch> inliers, float maxEpsilon, float minInlierRatio, int minNumInliers, boolean rejectIdentity, float identityTolerance, boolean multipleHypotheses)`
`static void`	`optimizeTileConfiguration(Align.ParamOptimize p, List<AbstractAffineTile2D<?>> tiles, List<AbstractAffineTile2D<?>> fixedTiles)` Align a set of `tiles` that are interconnected by `point-correspondences`.
`protected static void`	`pairwiseAlign(AbstractAffineTile2D<?> tile, Set<AbstractAffineTile2D<?>> visited)`
`static void`	`pairwiseAlignTileConfiguration(List<AbstractAffineTile2D<?>> tiles)`
`protected static boolean`	`serializeFeatures(Align.Param p, AbstractAffineTile2D<?> t, Collection<Feature> f)`
`protected static boolean`	`serializePointMatches(Align.Param p, AbstractAffineTile2D<?> t1, AbstractAffineTile2D<?> t2, Collection<PointMatch> m)` Save a `Collection` of `PointMatches` two-sided.
`static void`	`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.

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

Field Detail

param
```
public static final Align.Param param
```

paramOptimize

public static final Align.ParamOptimize paramOptimize

Constructor Detail
- Align
```
public Align()
```

Method Detail

findModel

public static final boolean findModel(Model<?> model,
                                      List<PointMatch> candidates,
                                      Collection<PointMatch> inliers,
                                      float maxEpsilon,
                                      float minInlierRatio,
                                      int minNumInliers,
                                      boolean rejectIdentity,
                                      float identityTolerance,
                                      boolean multipleHypotheses)

findModel

public static final boolean findModel(Model<?> model,
                                      List<PointMatch> candidates,
                                      Collection<PointMatch> inliers,
                                      float maxEpsilon,
                                      float minInlierRatio,
                                      int minNumInliers,
                                      boolean rejectIdentity,
                                      float identityTolerance)

serializeFeatures

protected static final boolean serializeFeatures(Align.Param p,
                                                 AbstractAffineTile2D<?> t,
                                                 Collection<Feature> f)

deserializeFeatures

protected static final Collection<Feature> deserializeFeatures(Align.Param p,
                                                               AbstractAffineTile2D<?> t)

Retrieve the features only if saved with the exact same relevant SIFT parameters.

fetchFeatures

protected static final Collection<Feature> fetchFeatures(Align.Param p,
                                                         AbstractAffineTile2D<?> t)

serializePointMatches

protected static final boolean serializePointMatches(Align.Param p,
                                                     AbstractAffineTile2D<?> t1,
                                                     AbstractAffineTile2D<?> t2,
                                                     Collection<PointMatch> m)

Save a Collection of PointMatches two-sided. Creates two serialization files which is desperately required to clean up properly invalid serializations on change of a Patch.

Parameters:: p -; t1 -; t2 -; m -
Returns:

deserializePointMatches

protected static final Collection<PointMatch> deserializePointMatches(Align.Param p,
                                                                      AbstractAffineTile2D<?> t1,
                                                                      AbstractAffineTile2D<?> t2)

fetchPointMatches

protected static final Collection<PointMatch> fetchPointMatches(Align.Param p,
                                                                AbstractAffineTile2D<?> t1,
                                                                AbstractAffineTile2D<?> t2)

Fetch a Collection of corresponding SIFT-features. Both SIFT-features and corresponding points are cached to disk.

Parameters:

p -

t1 -

t2 -

Returns:

null: if matching failed for some reasons
empty Collection: if there was no consistent set of matches
Collection of PointMatches: if there was a consistent set of PointMatches

alignTiles
```
public static final void alignTiles(Align.ParamOptimize p,
                                    List<AbstractAffineTile2D<?>> tiles,
                                    List<AbstractAffineTile2D<?>> fixedTiles,
                                    boolean tilesAreInPlace,
                                    int numThreads)
```
Align a set of tiles using the following procedure:
1. Extract SIFT-features from all tiles.
2. Establish point-correspondences from consistent sets of feature matches among tile pairs, optionally inspect only those that are already overlapping.
3. Globally align the tile configuration.
Both feature extraction and matching are executed in multiple Threads, with the number of Threads being a parameter of the method.
Parameters:

p -

tiles -

fixedTiles -

tilesAreInPlace -

numThreads -

alignTiles
```
public static final void alignTiles(Align.ParamOptimize p,
                                    List<AbstractAffineTile2D<?>> tiles,
                                    List<AbstractAffineTile2D<?>> fixedTiles,
                                    int numThreads)
```
Align a set of overlapping tiles using the following procedure:
1. Extract SIFT-features from all tiles.
2. Establish point-correspondences from consistent sets of feature matches among overlapping tiles.
3. Globally align the tile configuration.
Both feature extraction and matching are executed in multiple Threads, with the number of Threads being a parameter of the method.
Parameters:

p -

tiles -

numThreads -

optimizeTileConfiguration

public static final void optimizeTileConfiguration(Align.ParamOptimize p,
                                                   List<AbstractAffineTile2D<?>> tiles,
                                                   List<AbstractAffineTile2D<?>> fixedTiles)

Align a set of tiles that are interconnected by point-correspondences.

pairwiseAlign

protected static final void pairwiseAlign(AbstractAffineTile2D<?> tile,
                                          Set<AbstractAffineTile2D<?>> visited)

pairwiseAlignTileConfiguration

public static final void pairwiseAlignTileConfiguration(List<AbstractAffineTile2D<?>> tiles)

connectTilePairs

public static final void connectTilePairs(Align.Param p,
                                          List<AbstractAffineTile2D<?>> tiles,
                                          List<AbstractAffineTile2D<?>[]> tilePairs,
                                          int numThreads,
                                          boolean multipleHypotheses)

Connect a List of Tiles by geometrically consistent SIFT-feature correspondences.

Parameters:: p -; tiles -; tilePairs -; numThreads -; multipleHypotheses -

connectTilePairs

public static final void connectTilePairs(Align.Param p,
                                          List<AbstractAffineTile2D<?>> tiles,
                                          List<AbstractAffineTile2D<?>[]> tilePairs,
                                          int numThreads)

Connect a List of Tiles by geometrically consistent SIFT-feature correspondences.

Parameters:: p -; tiles -; tilePairs -; numThreads -

tilesFromPatches

public static final void 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.

Parameters:: p -; patches -; fixedPatches -; tiles - will contain the generated Tiles; fixedTiles - will contain the Tiles corresponding to the Patches in fixedPatches

alignSelectedPatches

public static final void alignSelectedPatches(Selection selection,
                                              int numThreads)

Align a selection of patches in a Layer.

Parameters:: selection -; numThreads -

alignLayer

public static final void alignLayer(Layer layer,
                                    int numThreads)

Align all patches in a Layer.

Parameters:: layer -

alignLayersLinearly
```
public static final void alignLayersLinearly(List<Layer> layers,
                                             int numThreads)
```
Align a range of layers by accumulating pairwise alignments of contiguous layers.

Parameters:

layers - The range of layers to align pairwise.

numThreads - The number of threads to use.

alignLayersLinearly
```
public static final void alignLayersLinearly(List<Layer> layers,
                                             int numThreads,
                                             Filter<Patch> filter)
```
Align a range of layers by accumulating pairwise alignments of contiguous layers.

Parameters:

layers - The range of layers to align pairwise.

numThreads - The number of threads to use.

filter - The Filter to decide which Patch instances to use in each Layer. Can be null.

createMLST

public static final MovingLeastSquaresTransform2 createMLST(Collection<PointMatch> matches,
                                                            double alpha)
                                                     throws Exception

Temporary helper method that creates

Parameters:: matches -; alpha -
Returns:
Throws:: Exception

alignTileCollections

public static final void alignTileCollections(Align.Param p,
                                              Collection<AbstractAffineTile2D<?>> a,
                                              Collection<AbstractAffineTile2D<?>> b)

Align two collections of tiles

Parameters:: p -; a -; b -

Class Align

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

param

paramOptimize

Constructor Detail

Align

Method Detail

findModel

findModel

serializeFeatures

deserializeFeatures

fetchFeatures

serializePointMatches

deserializePointMatches

fetchPointMatches

alignTiles

alignTiles

optimizeTileConfiguration

pairwiseAlign

pairwiseAlignTileConfiguration

connectTilePairs

connectTilePairs

tilesFromPatches

alignSelectedPatches

alignLayer

alignLayersLinearly

alignLayersLinearly

createMLST

alignTileCollections