BigWarpExporter (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- bigwarp.BigWarpExporter<T>

Direct Known Subclasses:

BigWarpARGBExporter, BigWarpRealExporter
```
public abstract class BigWarpExporter<T>
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class BigWarpExporter.ExportThread

static class BigWarpExporter.ParallelizationPolicy

Nested Classes
Modifier and Type	Class and Description
`static class`	`BigWarpExporter.ExportThread`
`static class`	`BigWarpExporter.ParallelizationPolicy`

Field Summary

Fields
Modifier and Type	Field and Description
`protected BigWarpExporter.ExportThread`	`exportThread`
`protected Interpolation`	`interp`
`protected boolean`	`isVirtual`
`protected static org.apache.log4j.Logger`	`logger`
`protected int[]`	`movingSourceIndexList`
`protected String`	`nameSuffix`
`protected int`	`nThreads`
`protected AffineTransform3D`	`offsetTransform`
`protected Interval`	`outputInterval`
`protected AffineTransform3D`	`pixelRenderToPhysical`
`BigWarpExporter.ParallelizationPolicy`	`policy`
`protected ProgressWriter`	`progress`
`protected AffineTransform3D`	`resolutionTransform`
`protected List<SourceAndConverter<T>>`	`sources`
`protected int[]`	`targetSourceIndexList`
`protected String`	`unit`

Constructor Summary

Constructors
Constructor and Description
`BigWarpExporter(List<SourceAndConverter<T>> sourcesIn, List<ConverterSetup> convSetups, int[] movingSourceIndexList, int[] targetSourceIndexList, Interpolation interp, ProgressWriter progress)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`buildTotalRenderTransform()` Generate the transform from output pixel space to physical space.
`<T extends NumericType<T>> RandomAccessibleInterval<T>`	`copyToImageStack(RandomAccessible<T> raible, Interval itvl, ImgFactory<T> factory, int nThreads)`
`static <T extends NumericType<T>> RandomAccessibleInterval<T>`	`copyToImageStackBySlice(RandomAccessible<T> raible, Interval itvl, ImgFactory<T> factory, int nThreads, ProgressWriter progress)`
`static <T extends NumericType<T>> RandomAccessibleInterval<T>`	`copyToImageStackBySlice(RandomAccessible<T> ra, Interval itvl, RandomAccessibleInterval<T> target, int nThreads, ProgressWriter progress)`
`static <T extends NumericType<T>> RandomAccessibleInterval<T>`	`copyToImageStackIterOrder(RandomAccessible<T> raible, Interval itvl, ImgFactory<T> factory, int nThreads, ProgressWriter progress)`
`static <T extends NumericType<T>> RandomAccessibleInterval<T>`	`copyToImageStackIterOrder(RandomAccessible<T> ra, Interval itvl, RandomAccessibleInterval<T> target, int nThreads, ProgressWriter progress)`
`static void`	`copyToLongCeil(double[] src, long[] dst)`
`static void`	`copyToLongFloor(double[] src, long[] dst)`
`FinalInterval`	`destinationIntervalFromLandmarks(ArrayList<Double[]> pts, boolean isMoving)`
`static void`	`estimateAffineFromCorners(AffineTransform3D affine, RealTransform xfm, Interval interval)` Only works for 2D or 3D.
`static FinalInterval`	`estimateBounds(RealTransform xfm, Interval interval)`
`abstract ij.ImagePlus`	`export()`
`ij.ImagePlus`	`exportAsynch(boolean wait)`
`ij.ImagePlus`	`exportAsynch(boolean wait, boolean show)`
`abstract RandomAccessibleInterval<?>`	`exportRai()`
`<T> RandomAccessibleInterval<T>`	`exportSource(SourceAndConverter<T> src)`
`static <T> BigWarpExporter<?>`	`getExporter(BigWarp.BigWarpData<T> bwData, List<SourceAndConverter<T>> transformedSources, Interpolation interp, ProgressWriter progressWriter)`
`ij.ImagePlus`	`getResult()`
`static FinalInterval`	`getSubInterval(Interval interval, int d, long start, long end)`
`abstract boolean`	`isRGB()`
`void`	`setExportPath(String exportPath)`
`void`	`setInterp(Interpolation interp)`
`void`	`setInterval(Interval outputInterval)`
`void`	`setNameSuffix(String suffix)`
`void`	`setNumThreads(int nThreads)`
`void`	`setOffset(double... offset)` Set the offset of the output field of view in pixels.
`void`	`setOutputList(List<ij.ImagePlus> outputList)`
`void`	`setParallelizationPolicy(BigWarpExporter.ParallelizationPolicy policy)`
`void`	`setRenderResolution(double... res)`
`void`	`setUnit(String unit)`
`void`	`setVirtual(boolean isVirtual)`
`void`	`showResult(boolean showResult)`
`static FinalInterval`	`transformIntervalMinMax(RealTransform xfm, Interval interval)`
`static FinalInterval`	`transformRealInterval(RealTransform xfm, RealInterval interval)`
`static void`	`updateBrightnessContrast(ij.ImagePlus imp, BigWarp.BigWarpData<?> bwdata, int[] indexList)`
`static void`	`updateBrightnessContrast(ij.ImagePlus imp, List<ConverterSetup> convSetups, int[] indexList)`

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

Field Detail

sources

protected final List<SourceAndConverter<T>> sources

movingSourceIndexList

protected final int[] movingSourceIndexList

targetSourceIndexList

protected final int[] targetSourceIndexList

pixelRenderToPhysical

protected AffineTransform3D pixelRenderToPhysical

resolutionTransform

protected AffineTransform3D resolutionTransform

offsetTransform

protected AffineTransform3D offsetTransform

outputInterval
```
protected Interval outputInterval
```

interp
```
protected Interpolation interp
```

isVirtual
```
protected boolean isVirtual
```

nThreads
```
protected int nThreads
```

exportThread

protected BigWarpExporter.ExportThread exportThread

nameSuffix
```
protected String nameSuffix
```

unit
```
protected String unit
```

progress
```
protected ProgressWriter progress
```

policy

public BigWarpExporter.ParallelizationPolicy policy

logger

protected static org.apache.log4j.Logger logger

Constructor Detail

BigWarpExporter

public BigWarpExporter(List<SourceAndConverter<T>> sourcesIn,
                       List<ConverterSetup> convSetups,
                       int[] movingSourceIndexList,
                       int[] targetSourceIndexList,
                       Interpolation interp,
                       ProgressWriter progress)

Method Detail

exportRai

public abstract RandomAccessibleInterval<?> exportRai()

export
```
public abstract ij.ImagePlus export()
```

isRGB
```
public abstract boolean isRGB()
```

showResult

public void showResult(boolean showResult)

setExportPath

public void setExportPath(String exportPath)

setOutputList

public void setOutputList(List<ij.ImagePlus> outputList)

setUnit
```
public void setUnit(String unit)
```

setInterp

public void setInterp(Interpolation interp)

setVirtual

public void setVirtual(boolean isVirtual)

setParallelizationPolicy

public void setParallelizationPolicy(BigWarpExporter.ParallelizationPolicy policy)

setNumThreads

public void setNumThreads(int nThreads)

setNameSuffix

public void setNameSuffix(String suffix)

setRenderResolution

public void setRenderResolution(double... res)

setOffset
```
public void setOffset(double... offset)
```
Set the offset of the output field of view in pixels.

Parameters:

offset - the offset in pixel units.

buildTotalRenderTransform
```
public void buildTotalRenderTransform()
```
Generate the transform from output pixel space to physical space. Call this after setRenderResolution and setOffset.

setInterval

public void setInterval(Interval outputInterval)

exportSource

public <T> RandomAccessibleInterval<T> exportSource(SourceAndConverter<T> src)

updateBrightnessContrast

public static void updateBrightnessContrast(ij.ImagePlus imp,
                                            List<ConverterSetup> convSetups,
                                            int[] indexList)

updateBrightnessContrast

public static void updateBrightnessContrast(ij.ImagePlus imp,
                                            BigWarp.BigWarpData<?> bwdata,
                                            int[] indexList)

destinationIntervalFromLandmarks

public FinalInterval destinationIntervalFromLandmarks(ArrayList<Double[]> pts,
                                                      boolean isMoving)

getSubInterval

public static FinalInterval getSubInterval(Interval interval,
                                           int d,
                                           long start,
                                           long end)

copyToImageStack

public <T extends NumericType<T>> RandomAccessibleInterval<T> copyToImageStack(RandomAccessible<T> raible,
                                                                               Interval itvl,
                                                                               ImgFactory<T> factory,
                                                                               int nThreads)

copyToImageStackBySlice

public static <T extends NumericType<T>> RandomAccessibleInterval<T> copyToImageStackBySlice(RandomAccessible<T> raible,
                                                                                             Interval itvl,
                                                                                             ImgFactory<T> factory,
                                                                                             int nThreads,
                                                                                             ProgressWriter progress)

copyToImageStackBySlice

public static <T extends NumericType<T>> RandomAccessibleInterval<T> copyToImageStackBySlice(RandomAccessible<T> ra,
                                                                                             Interval itvl,
                                                                                             RandomAccessibleInterval<T> target,
                                                                                             int nThreads,
                                                                                             ProgressWriter progress)

copyToImageStackIterOrder

public static <T extends NumericType<T>> RandomAccessibleInterval<T> copyToImageStackIterOrder(RandomAccessible<T> raible,
                                                                                               Interval itvl,
                                                                                               ImgFactory<T> factory,
                                                                                               int nThreads,
                                                                                               ProgressWriter progress)

copyToImageStackIterOrder

public static <T extends NumericType<T>> RandomAccessibleInterval<T> copyToImageStackIterOrder(RandomAccessible<T> ra,
                                                                                               Interval itvl,
                                                                                               RandomAccessibleInterval<T> target,
                                                                                               int nThreads,
                                                                                               ProgressWriter progress)

transformRealInterval

public static FinalInterval transformRealInterval(RealTransform xfm,
                                                  RealInterval interval)

transformIntervalMinMax

public static FinalInterval transformIntervalMinMax(RealTransform xfm,
                                                    Interval interval)

estimateAffineFromCorners

public static void estimateAffineFromCorners(AffineTransform3D affine,
                                             RealTransform xfm,
                                             Interval interval)

Only works for 2D or 3D.

Parameters:: affine - variable in which to store the result; xfm - the transform; interval - the interval

estimateBounds

public static FinalInterval estimateBounds(RealTransform xfm,
                                           Interval interval)

copyToLongFloor

public static void copyToLongFloor(double[] src,
                                   long[] dst)

copyToLongCeil

public static void copyToLongCeil(double[] src,
                                  long[] dst)

exportAsynch

public ij.ImagePlus exportAsynch(boolean wait)

exportAsynch

public ij.ImagePlus exportAsynch(boolean wait,
                                 boolean show)

getResult
```
public ij.ImagePlus getResult()
```

getExporter

public static <T> BigWarpExporter<?> getExporter(BigWarp.BigWarpData<T> bwData,
                                                 List<SourceAndConverter<T>> transformedSources,
                                                 Interpolation interp,
                                                 ProgressWriter progressWriter)

Class BigWarpExporter<T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sources

movingSourceIndexList

targetSourceIndexList

pixelRenderToPhysical

resolutionTransform

offsetTransform

outputInterval

interp

isVirtual

nThreads

exportThread

nameSuffix

unit

progress

policy

logger

Constructor Detail

BigWarpExporter

Method Detail

exportRai

export

isRGB

showResult

setExportPath

setOutputList

setUnit

setInterp

setVirtual

setParallelizationPolicy

setNumThreads

setNameSuffix

setRenderResolution

setOffset

buildTotalRenderTransform

setInterval

exportSource

updateBrightnessContrast

updateBrightnessContrast

destinationIntervalFromLandmarks

getSubInterval

copyToImageStack

copyToImageStackBySlice

copyToImageStackBySlice

copyToImageStackIterOrder

copyToImageStackIterOrder

transformRealInterval

transformIntervalMinMax

estimateAffineFromCorners

estimateBounds

copyToLongFloor

copyToLongCeil

exportAsynch

exportAsynch

getResult

getExporter