> void runN5Export(
final IntervalView< T > img = Views.interval( Views.raster( rai ),
Intervals.zeroMin( outputInterval ) );
- final String srcName = data.sources.get( data.movingSourceIndices[ i ]).getSpimSource().getName();
+ final String srcName = originalMovingSource.getSpimSource().getName();
String destDataset = dataset;
if( N > 1 )
@@ -1067,12 +1071,12 @@ public void run( final String arg )
gd.addChoice( "Transform type",
new String[] {
- TransformTypeSelectDialog.TPS,
- TransformTypeSelectDialog.AFFINE,
- TransformTypeSelectDialog.SIMILARITY,
- TransformTypeSelectDialog.ROTATION,
- TransformTypeSelectDialog.TRANSLATION },
- TransformTypeSelectDialog.TPS);
+ BigWarpTransform.TPS,
+ BigWarpTransform.AFFINE,
+ BigWarpTransform.SIMILARITY,
+ BigWarpTransform.ROTATION,
+ BigWarpTransform.TRANSLATION },
+ BigWarpTransform.TPS);
gd.addMessage( "Field of view and resolution:" );
gd.addChoice( "Resolution",
diff --git a/src/main/java/bdv/ij/BigWarpBdvCommand.java b/src/main/java/bdv/ij/BigWarpBdvCommand.java
index 34cd2c6e..ed6e406f 100755
--- a/src/main/java/bdv/ij/BigWarpBdvCommand.java
+++ b/src/main/java/bdv/ij/BigWarpBdvCommand.java
@@ -23,6 +23,7 @@
import bdv.ij.util.ProgressWriterIJ;
import bigwarp.BigWarp;
+import bigwarp.BigWarpData;
import bigwarp.BigWarpInit;
import mpicbg.spim.data.SpimData;
import mpicbg.spim.data.SpimDataException;
@@ -61,8 +62,8 @@ public void run()
final SpimData fixedSpimData = new XmlIoSpimData().load( fixedImageXml.getAbsolutePath() );
final SpimData movingSpimData = new XmlIoSpimData().load( movingImageXml.getAbsolutePath() );
new RepeatingReleasedEventsFixer().install();
- final BigWarp.BigWarpData< ? > bigWarpData = BigWarpInit.createBigWarpData( movingSpimData, fixedSpimData );
- bw = new BigWarp( bigWarpData, "Big Warp", new ProgressWriterIJ() );
+ final BigWarpData< ? > bigWarpData = BigWarpInit.createBigWarpData( movingSpimData, fixedSpimData );
+ bw = new BigWarp( bigWarpData, new ProgressWriterIJ() );
bw.getViewerFrameP().getViewerPanel().requestRepaint();
bw.getViewerFrameQ().getViewerPanel().requestRepaint();
bw.getLandmarkFrame().repaint();
diff --git a/src/main/java/bdv/ij/BigWarpCommand.java b/src/main/java/bdv/ij/BigWarpCommand.java
new file mode 100644
index 00000000..6fe1a074
--- /dev/null
+++ b/src/main/java/bdv/ij/BigWarpCommand.java
@@ -0,0 +1,100 @@
+package bdv.ij;
+
+import java.io.IOException;
+
+import org.scijava.command.Command;
+import org.scijava.plugin.Parameter;
+import org.scijava.plugin.Plugin;
+
+import bdv.gui.BigWarpInitDialog;
+import ij.Macro;
+import ij.plugin.PlugIn;
+import ij.plugin.frame.Recorder;
+import net.imagej.Dataset;
+import net.imagej.DatasetService;
+import net.imagej.ImageJ;
+
+@Plugin(type = Command.class, menuPath = "Plugins>BigDataViewer>Big Warp Command" )
+public class BigWarpCommand implements Command, PlugIn
+{
+ private boolean initialRecorderState;
+
+ @Parameter
+ private DatasetService datasetService;
+
+ public BigWarpCommand()
+ {
+ initialRecorderState = Recorder.record;
+ Recorder.record = false;
+ }
+
+ @Override
+ public void run( String args )
+ {
+ Recorder.record = initialRecorderState;
+ final String macroOptions = Macro.getOptions();
+ String options = args;
+ if ( options == null || options.isEmpty() )
+ options = macroOptions;
+
+ final boolean isMacro = (options != null && !options.isEmpty());
+ if ( isMacro )
+ BigWarpInitDialog.runMacro( macroOptions );
+ else
+ {
+// if( datasetService != null )
+// {
+// System.out.println( "dset service exists");
+// for( final Dataset d : datasetService.getDatasets() )
+// System.out.println( d.getName());
+// }
+
+ final BigWarpInitDialog dialog = BigWarpInitDialog.createAndShow( datasetService );
+ // dialog sets recorder to its initial state on cancel or execution
+ dialog.setInitialRecorderState( initialRecorderState );
+ }
+ }
+
+ @Override
+ public void run()
+ {
+ run(null);
+ }
+
+ public static void main( String[] a ) throws IOException
+ {
+// String options = "images=mri-stack.tif,mri-stack.tif moving=true,false transforms=,";
+//
+// String images = Macro.getValue(options, "images", "");
+// String moving = Macro.getValue(options, "moving", "");
+// String transforms = Macro.getValue(options, "transforms", "");
+//
+// System.out.println( images );
+// System.out.println( moving );
+// System.out.println( transforms );
+
+ final ImageJ ij2 = new ImageJ();
+ ij2.ui().showUI();
+
+// final Object im1 = ij2.io().open( "/home/john/tmp/mri-stack.tif" );
+// final Object im2 = ij2.io().open( "/home/john/tmp/t1-head.tif" );
+////
+//// Object im1 = ij2.io().open( "/groups/saalfeld/home/bogovicj/tmp/mri-stack.tif" );
+//// Object im2 = ij2.io().open( "/groups/saalfeld/home/bogovicj/tmp/t1-head.tif" );
+////
+// ij2.ui().show( im1 );
+// ij2.ui().show( im2 );
+
+
+ final Object im1 = ij2.io().open( "/home/john/tmp/boats.tif" );
+ ij2.ui().show( im1 );
+
+
+// String args = "images=[a, b, c], isMoving=[true, true, false], transforms=[,,]";
+//
+// String imagesList = null;
+// String isMovingList = null;
+// String transformsList = null;
+ }
+
+}
diff --git a/src/main/java/bdv/ij/BigWarpImagePlusPlugIn.java b/src/main/java/bdv/ij/BigWarpImagePlusPlugIn.java
index 2e804074..c8a0badd 100755
--- a/src/main/java/bdv/ij/BigWarpImagePlusPlugIn.java
+++ b/src/main/java/bdv/ij/BigWarpImagePlusPlugIn.java
@@ -27,7 +27,7 @@
import bdv.ij.util.ProgressWriterIJ;
import bigwarp.BigWarp;
-import bigwarp.BigWarp.BigWarpData;
+import bigwarp.BigWarpData;
import bigwarp.BigWarpInit;
import fiji.util.gui.GenericDialogPlus;
import ij.IJ;
@@ -170,7 +170,7 @@ public void run( final String arg )
try
{
new RepeatingReleasedEventsFixer().install();
- final BigWarp bw = new BigWarp<>( bigwarpdata, "Big Warp", new ProgressWriterIJ() );
+ final BigWarp bw = new BigWarp<>( bigwarpdata, new ProgressWriterIJ() );
if( landmarkPath != null && !landmarkPath.isEmpty())
{
diff --git a/src/main/java/bdv/ij/BigWarpToDeformationFieldPlugIn.java b/src/main/java/bdv/ij/BigWarpToDeformationFieldPlugIn.java
index a10a2256..1bceb401 100644
--- a/src/main/java/bdv/ij/BigWarpToDeformationFieldPlugIn.java
+++ b/src/main/java/bdv/ij/BigWarpToDeformationFieldPlugIn.java
@@ -26,16 +26,21 @@
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map.Entry;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import javax.swing.JFrame;
import org.janelia.saalfeldlab.n5.Compression;
import org.janelia.saalfeldlab.n5.GzipCompression;
import org.janelia.saalfeldlab.n5.Lz4Compression;
-import org.janelia.saalfeldlab.n5.N5Exception;
import org.janelia.saalfeldlab.n5.N5Writer;
import org.janelia.saalfeldlab.n5.RawCompression;
import org.janelia.saalfeldlab.n5.XzCompression;
@@ -43,36 +48,69 @@
import org.janelia.saalfeldlab.n5.ij.N5Exporter;
import org.janelia.saalfeldlab.n5.imglib2.N5DisplacementField;
import org.janelia.saalfeldlab.n5.universe.N5Factory;
-
-import bdv.gui.TransformTypeSelectDialog;
-import bdv.viewer.SourceAndConverter;
+import org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v05.transformations.AffineCoordinateTransform;
+import org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v05.transformations.CoordinateTransform;
+import org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v05.transformations.DisplacementFieldCoordinateTransform;
+import org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v05.transformations.ReferencedCoordinateTransform;
+import org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v05.transformations.SequenceCoordinateTransform;
+import org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v05.transformations.TranslationCoordinateTransform;
+
+import bdv.gui.ExportDisplacementFieldFrame;
+import bdv.img.WarpedSource;
+import bdv.viewer.Source;
+import bigwarp.BigWarp;
+import bigwarp.BigWarpData;
import bigwarp.BigWarpExporter;
import bigwarp.landmarks.LandmarkTableModel;
+import bigwarp.source.SourceInfo;
import bigwarp.transforms.BigWarpTransform;
+import bigwarp.transforms.NgffTransformations;
+import bigwarp.transforms.SlicerTransformations;
import fiji.util.gui.GenericDialogPlus;
import ij.IJ;
import ij.ImageJ;
import ij.ImagePlus;
+import ij.Macro;
import ij.WindowManager;
import ij.plugin.PlugIn;
+import ij.plugin.frame.Recorder;
import jitk.spline.ThinPlateR2LogRSplineKernelTransform;
-import mpicbg.spim.data.sequence.VoxelDimensions;
+import mpicbg.models.AffineModel2D;
+import mpicbg.models.AffineModel3D;
+import mpicbg.models.InvertibleCoordinateTransform;
+import mpicbg.models.RigidModel2D;
+import mpicbg.models.RigidModel3D;
+import mpicbg.models.SimilarityModel2D;
+import mpicbg.models.SimilarityModel3D;
+import mpicbg.models.TranslationModel2D;
+import mpicbg.models.TranslationModel3D;
import net.imglib2.Cursor;
import net.imglib2.FinalInterval;
import net.imglib2.Interval;
import net.imglib2.RandomAccessibleInterval;
import net.imglib2.RealPoint;
+import net.imglib2.converter.Converters;
+import net.imglib2.converter.RealFloatConverter;
+import net.imglib2.img.display.imagej.ImageJFunctions;
import net.imglib2.img.imageplus.FloatImagePlus;
import net.imglib2.img.imageplus.ImagePlusImgs;
import net.imglib2.iterator.IntervalIterator;
+import net.imglib2.loops.LoopBuilder;
+import net.imglib2.parallel.TaskExecutors;
import net.imglib2.realtransform.AffineGet;
import net.imglib2.realtransform.AffineTransform2D;
import net.imglib2.realtransform.AffineTransform3D;
+import net.imglib2.realtransform.DisplacementFieldTransform;
+import net.imglib2.realtransform.InvertibleRealTransform;
+import net.imglib2.realtransform.InvertibleRealTransformSequence;
+import net.imglib2.realtransform.InvertibleWrapped2DIntermediate3D;
import net.imglib2.realtransform.RealTransform;
-import net.imglib2.realtransform.Scale2D;
-import net.imglib2.realtransform.Scale3D;
+import net.imglib2.realtransform.RealTransformSequence;
+import net.imglib2.realtransform.ScaleAndTranslation;
import net.imglib2.realtransform.ThinplateSplineTransform;
+import net.imglib2.realtransform.inverse.WrappedIterativeInvertibleRealTransform;
import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.real.DoubleType;
import net.imglib2.type.numeric.real.FloatType;
import net.imglib2.view.IntervalView;
import net.imglib2.view.Views;
@@ -80,7 +118,13 @@
import net.imglib2.view.composite.GenericComposite;
/**
- * ImageJ plugin to convert the thin plate spline to a deformation field.
+ * ImageJ plugin to convert the thin plate spline to a displacement field.
+ *
+ * If the ignoreAffine option is true, the resulting displacement field will
+ * not contain the affine part of the transformation. In this case, the total
+ * transformation is the displacement field first, followed by the affine part
+ * of the transformation.
+ *
*
* @author John Bogovic <bogovicj@janelia.hhmi.org>
* @author Tobias Pietzsch <tobias.pietzsch@gmail.com>
@@ -88,6 +132,8 @@
*/
public class BigWarpToDeformationFieldPlugIn implements PlugIn
{
+ public static enum INVERSE_OPTIONS { FORWARD, INVERSE, BOTH };
+
public static final String[] compressionOptions = new String[] {
N5Exporter.RAW_COMPRESSION,
N5Exporter.GZIP_COMPRESSION,
@@ -95,224 +141,731 @@ public class BigWarpToDeformationFieldPlugIn implements PlugIn
N5Exporter.XZ_COMPRESSION,
N5Exporter.BLOSC_COMPRESSION };
+ public static final String flattenOption = "Flat";
+ public static final String sequenceOption = "Sequence";
+
public static void main( final String[] args )
{
new ImageJ();
-// IJ.run("Boats (356K)");
- final ImagePlus imp = IJ.openImage( "/groups/saalfeld/home/bogovicj/tmp/mri-stack.tif" );
-// ImagePlus imp = IJ.openImage( "/groups/saalfeld/home/bogovicj/tmp/mri-stack_p2p2p4.tif" );
-// WindowManager.getActiveWindow();
+ new Recorder();
+ Recorder.record = true;
+
+// IJ.run("Boats (356K)");
+// ImagePlus imp = IJ.openImage( "/groups/saalfeld/home/bogovicj/tmp/mri-stack.tif" );
+ final ImagePlus imp = IJ.openImage( "/home/john/tmp/mri-stack.tif" );
+// ImagePlus imp = IJ.openImage( "/home/john/tmp/mri-stack_mm.tif" );
imp.show();
new BigWarpToDeformationFieldPlugIn().run( null );
}
- public void runFromBigWarpInstance(
- final LandmarkTableModel landmarkModel,
- final List> sources,
- final int[] targetSourceIndexList )
+ public void runFromBigWarpInstance( final BigWarp bw )
{
- final ImageJ ij = IJ.getInstance();
- if ( ij == null )
- return;
-
-
- final DeformationFieldExportParameters params = DeformationFieldExportParameters.fromDialog( false, false );
- if( params == null )
- return;
+// ImageJ ij = IJ.getInstance();
+// if ( ij == null )
+// return;
+//
+ ExportDisplacementFieldFrame.createAndShow( bw );
+ }
- final RandomAccessibleInterval< ? > tgtInterval = sources.get( targetSourceIndexList[ 0 ] ).getSpimSource().getSource( 0, 0 );
+// /**
+// * @deprecated not necessary access thedesired source this way anymore, use {@link #runFromBigWarpInstance(LandmarkTableModel, SourceAndConverter)}
+// * on the result of {@link bigwarp.BigWarpData#getTargetSource(int)}
+// */
+// @Deprecated
+// public void runFromBigWarpInstanceOld(
+// final BigWarpData data,
+// final LandmarkTableModel landmarkModel,
+// final List> sources,
+// final List targetSourceIndexList )
+// {
+// runFromBigWarpInstanceOld( data, landmarkModel, data.getTargetSource( 0 ) );
+// }
+
+// public void runFromBigWarpInstanceOld(
+// final BigWarpData data, final LandmarkTableModel landmarkModel, final SourceAndConverter< T > sourceAndConverter )
+// {
+// ImageJ ij = IJ.getInstance();
+// if ( ij == null )
+// return;
+//
+// final DeformationFieldExportParameters params = DeformationFieldExportParameters.fromDialog( false, false );
+// if( params == null )
+// return;
+//
+// final RandomAccessibleInterval< ? > tgtInterval = sourceAndConverter.getSpimSource().getSource( 0, 0 );
+//
+// int ndims = landmarkModel.getNumdims();
+// long[] dims = tgtInterval.dimensionsAsLongArray();
+//
+// double[] spacing = new double[ 3 ];
+// double[] offset = new double[ 3 ];
+// String unit = "pix";
+// VoxelDimensions voxelDim = sourceAndConverter.getSpimSource().getVoxelDimensions();
+// voxelDim.dimensions( spacing );
+//
+// if( params.spacing != null )
+// spacing = params.spacing;
+//
+// if( params.offset != null )
+// offset = params.offset;
+//
+// if( params.size != null )
+// dims = params.size;
+//
+// if( params.n5Base.isEmpty() )
+// {
+//// toImagePlus( data, landmarkModel, null, params.ignoreAffine, params.flatten(), params.virtual, dims, spacing, params.nThreads );
+// if ( params.inverseOption.equals( INVERSE_OPTIONS.BOTH.toString() ) )
+// {
+// toImagePlus( data, landmarkModel, null, params.ignoreAffine, params.flatten(), false, params.virtual, params.size, params.spacing, params.nThreads );
+// toImagePlus( data, landmarkModel, null, params.ignoreAffine, params.flatten(), true, params.virtual, params.size, params.spacing, params.nThreads );
+// }
+// else
+// {
+// final boolean inverse = params.inverseOption.equals( INVERSE_OPTIONS.INVERSE.toString() );
+// toImagePlus( data, landmarkModel, null, params.ignoreAffine, params.flatten(), inverse, params.virtual, params.size, params.spacing, params.nThreads );
+// }
+// }
+// else
+// {
+// try
+// {
+// final boolean inverse = params.inverseOption.equals( INVERSE_OPTIONS.INVERSE.toString() );
+// writeN5( params.n5Base, params.n5Dataset, landmarkModel, null, data, dims, spacing, offset, unit, params.blockSize, params.compression, params.nThreads, params.ignoreAffine, params.flatten(), inverse );
+// }
+// catch ( IOException e )
+// {
+// e.printStackTrace();
+// }
+// }
+// }
+
+ public static void runFromParameters( final DeformationFieldExportParameters params, final BigWarpData data, final LandmarkTableModel landmarkModel, final BigWarpTransform bwTransform )
+ {
+ final String unit = "pixel";
+ LandmarkTableModel ltm;
- final int ndims = landmarkModel.getNumdims();
- long[] dims;
- if ( ndims <= 2 )
+ if( landmarkModel == null )
{
- dims = new long[ 3 ];
- dims[ 0 ] = tgtInterval.dimension( 0 );
- dims[ 1 ] = tgtInterval.dimension( 1 );
- dims[ 2 ] = 2;
+ if( params.landmarkPath == null || params.landmarkPath.isEmpty() )
+ {
+ IJ.showMessage( "Must provide landmark file." ); // TODO message differently
+ return;
+ }
+
+ // load landmarks
+ try
+ {
+ ltm = LandmarkTableModel.loadFromCsv( new File( params.landmarkPath ), false );
+ }
+ catch ( final IOException e )
+ {
+ e.printStackTrace();
+ return;
+ }
}
else
- {
- dims = new long[ 4 ];
- dims[ 0 ] = tgtInterval.dimension( 0 );
- dims[ 1 ] = tgtInterval.dimension( 1 );
- dims[ 2 ] = 3;
- dims[ 3 ] = tgtInterval.dimension( 2 );
- }
+ ltm = landmarkModel;
- double[] spacing = new double[ 3 ];
- final VoxelDimensions voxelDim = sources.get( targetSourceIndexList[ 0 ] ).getSpimSource().getVoxelDimensions();
- voxelDim.dimensions( spacing );
+ final int ndims = ltm.getNumdims();
+ double[] spacing = new double[ ndims ];
+ double[] offset = new double[ ndims ];
+ long[] dims = new long[ ndims ];
+ if ( params.spacing != null )
- if( params.spacing != null )
spacing = params.spacing;
- if( params.size != null )
+ if ( params.offset != null )
+ offset = params.offset;
+
+ if ( params.size != null )
dims = params.size;
- if( params.n5Base.isEmpty() )
+ ImagePlus imp = null;
+ if ( params.n5Base.isEmpty() )
{
- toImagePlus( landmarkModel, params.ignoreAffine, dims, spacing, params.nThreads );
+ if( !bwTransform.isNonlinear() ) // is linear
+ {
+ IJ.showMessage("unsupported at the moment");
+ }
+ else if ( params.inverseOption.equals( INVERSE_OPTIONS.BOTH.toString() ) )
+ {
+ imp = toImagePlus( data, ltm, bwTransform, params.ignoreAffine, params.flatten(), false, params.virtual, params.size, params.spacing, params.nThreads );
+ imp = toImagePlus( data, ltm, bwTransform, params.ignoreAffine, params.flatten(), true, params.virtual, params.size, params.spacing, params.nThreads );
+ }
+ else
+ {
+ final boolean inverse = params.inverseOption.equals( INVERSE_OPTIONS.INVERSE.toString() );
+ imp = toImagePlus( data, ltm, bwTransform, params.ignoreAffine, params.flatten(), inverse, params.virtual, params.size, params.spacing, params.nThreads );
+ }
+ if( imp != null )
+ imp.show();
}
else
{
- try
+ if( !bwTransform.isNonlinear() ) // is linear
{
- writeN5( params.n5Base, landmarkModel, dims, spacing, params.blockSize, params.compression, params.nThreads );
+ writeAffineN5(params.n5Base, params.n5Dataset, data, bwTransform );
}
- catch ( final N5Exception e )
+ else if ( params.inverseOption.equals( INVERSE_OPTIONS.BOTH.toString() ) )
{
- e.printStackTrace();
+ writeN5( params.n5Base, params.n5Dataset + "/dfield", ltm, bwTransform, data, dims, spacing, offset, unit, params.blockSize, params.compression, params.nThreads, params.format, params.ignoreAffine, params.flatten(),
+ false, params.inverseTolerance, params.inverseMaxIterations );
+ writeN5( params.n5Base, params.n5Dataset + "/invdfield", ltm, bwTransform, data, dims, spacing, offset, unit, params.blockSize, params.compression, params.nThreads, params.format, params.ignoreAffine, params.flatten(),
+ true, params.inverseTolerance, params.inverseMaxIterations );
+ }
+ else
+ {
+ final boolean inverse = params.inverseOption.equals( INVERSE_OPTIONS.INVERSE.toString() );
+ writeN5( params.n5Base, params.n5Dataset, ltm, bwTransform, data, dims, spacing, offset, unit, params.blockSize, params.compression, params.nThreads, params.format, params.ignoreAffine, params.flatten(),
+ inverse, params.inverseTolerance, params.inverseMaxIterations );
}
}
}
@Override
- public void run( final String arg )
+ public void run( final String args )
{
if ( IJ.versionLessThan( "1.40" ) )
return;
- final DeformationFieldExportParameters params = DeformationFieldExportParameters.fromDialog( true, true );
- final int nd = params.size.length;
+ final String macroOptions = Macro.getOptions();
+ String options = args;
+ if( options == null || options.isEmpty())
+ options = macroOptions;
- // load
- final LandmarkTableModel ltm = new LandmarkTableModel( nd );
- try
- {
- ltm.load( new File( params.landmarkPath ) );
- }
- catch ( final IOException e )
- {
- e.printStackTrace();
- return;
- }
+ final boolean isMacro = (options != null && !options.isEmpty());
- if( params.n5Base.isEmpty() )
- {
- toImagePlus( ltm, params.ignoreAffine, params.size, params.spacing, params.nThreads );
- }
+ if( isMacro )
+ ExportDisplacementFieldFrame.runMacro( macroOptions );
else
- {
- try
- {
- writeN5( params.n5Base, params.n5Dataset, ltm, params.size, params.spacing, params.blockSize, params.compression, params.nThreads );
- }
- catch ( final N5Exception e )
- {
- e.printStackTrace();
- }
- }
+ ExportDisplacementFieldFrame.createAndShow();
}
public static ImagePlus toImagePlus(
+ final BigWarpData data,
final LandmarkTableModel ltm,
- final boolean ignoreAffine,
+ final BigWarpTransform bwTransform,
+ final boolean splitAffine,
+ final boolean flatten,
+ final boolean inverse,
+ final boolean virtual,
final long[] dims,
final double[] spacing,
final int nThreads )
{
- final BigWarpTransform bwXfm = new BigWarpTransform( ltm, TransformTypeSelectDialog.TPS );
- final RealTransform tps = getTpsAffineToggle( bwXfm, ignoreAffine );
+ final double[] offset = new double[ spacing.length ];
+ return toImagePlus( data, ltm, bwTransform, splitAffine, flatten, inverse, virtual, dims, spacing, offset, nThreads );
+ }
- AffineGet pixelToPhysical = null;
- if( spacing.length == 2)
+ /**
+ *
+ * @param data the {@link BigWarpData}
+ * @param ltm the {@link LandmarkTableModel}
+ * @param bwTransform the {@link BigWarpTransform}
+ * @param splitAffine omit the affine part of the transformation
+ * @param flatten include any fixed transformation
+ * @param inverse output the inverse transformation
+ * @param virtual output of virtual image
+ * @param dims the dimensions of the output {@link ImagePlus}'s spatial dimensions
+ * @param spacing the pixel spacing of the output field
+ * @param offset the physical offset (origin) of the output field
+ * @param nThreads number of threads for copying
+ * @return the image plus representing the displacement field
+ */
+ public static ImagePlus toImagePlus(
+ final BigWarpData data,
+ final LandmarkTableModel ltm,
+ final BigWarpTransform bwTransform,
+ final boolean splitAffine,
+ final boolean flatten,
+ final boolean inverse,
+ final boolean virtual,
+ final long[] dims,
+ final double[] spacing,
+ final double[] offset,
+ final int nThreads )
+ {
+ BigWarpTransform bwXfm;
+ if( bwTransform == null )
+ bwXfm = new BigWarpTransform( ltm, BigWarpTransform.TPS );
+ else
+ bwXfm = bwTransform;
+
+ final InvertibleRealTransform fwdTransform = getTransformation( data, bwXfm, flatten, splitAffine );
+ final InvertibleRealTransform startingTransform = inverse ? fwdTransform.inverse() : fwdTransform;
+
+ final InvertibleRealTransform transform;
+ final int nd = ltm.getNumdims();
+ long[] ipDims = null;
+ if ( nd == 2 )
{
- pixelToPhysical = new Scale2D( spacing );
+ ipDims = new long[ 4 ];
+ ipDims[ 0 ] = dims[ 0 ];
+ ipDims[ 1 ] = dims[ 1 ];
+ ipDims[ 2 ] = 2;
+ ipDims[ 3 ] = 1;
+
+ if (bwXfm.isMasked())
+ transform = new InvertibleWrapped2DIntermediate3D(startingTransform);
+ else
+ transform = startingTransform;
}
- else if( spacing.length == 3)
+ else if ( nd == 3 )
{
- pixelToPhysical = new Scale3D( spacing );
+ ipDims = new long[ 4 ];
+ ipDims[ 0 ] = dims[ 0 ];
+ ipDims[ 1 ] = dims[ 1 ];
+ ipDims[ 2 ] = 3;
+ ipDims[ 3 ] = dims[ 2 ];
+
+ transform = startingTransform;
}
else
- {
return null;
+
+ final RandomAccessibleInterval< DoubleType > dfieldVirt = DisplacementFieldTransform.createDisplacementField( transform, new FinalInterval( dims ), spacing, offset );
+
+ ImagePlus dfieldIp;
+ if( virtual )
+ {
+ final RealFloatConverter conv = new RealFloatConverter<>();
+ final RandomAccessibleInterval< FloatType > dfieldF = Views.moveAxis(
+ Converters.convert2( dfieldVirt, conv, FloatType::new ),
+ 0, 2 );
+ dfieldIp = ImageJFunctions.wrap( dfieldF, "" ); // title gets set below
}
+ else
+ {
+ final FloatImagePlus< FloatType > dfield = ImagePlusImgs.floats( ipDims );
- final FloatImagePlus< FloatType > dfield = convertToDeformationField( dims, tps, pixelToPhysical, nThreads );
+ // make the "vector" axis the first dimension
+ // 2d displacement fields will have an extraneous singleton z-dimension
+ final RandomAccessibleInterval< FloatType > dfieldImpPerm = Views.dropSingletonDimensions( Views.moveAxis( dfield, 2, 0 ));
+ LoopBuilder.setImages( dfieldVirt, dfieldImpPerm ).multiThreaded( TaskExecutors.fixedThreadPool( nThreads ) ).forEachPixel( (x,y) -> { y.setReal(x.get()); });
+ dfieldIp = dfield.getImagePlus();
+ }
String title = "bigwarp dfield";
- if ( ignoreAffine )
+ if ( splitAffine )
title += " (no affine)";
- final ImagePlus dfieldIp = dfield.getImagePlus();
dfieldIp.setTitle( title );
dfieldIp.getCalibration().pixelWidth = spacing[ 0 ];
dfieldIp.getCalibration().pixelHeight = spacing[ 1 ];
+ dfieldIp.getCalibration().xOrigin = offset[ 0 ];
+ dfieldIp.getCalibration().yOrigin = offset[ 1 ];
+
if( spacing.length > 2 )
+ {
dfieldIp.getCalibration().pixelDepth = spacing[ 2 ];
+ dfieldIp.getCalibration().zOrigin = offset[ 2 ];
+ }
- dfieldIp.show();
return dfieldIp;
}
+ /**
+ * Returns the transformation to be converted to a displacement field.
+ *
+ * @param data the bigwarp data storing the fixed transformations
+ * @param transform the current transformation
+ * @param concatPreTransforms concatenate the current with fixed transformation
+ * @param ignoreAffine whether the output should include the affine part of the transformation
+ * @return the transformation
+ */
+ public static InvertibleRealTransform getTransformation( final BigWarpData data, final BigWarpTransform transform, final boolean concatPreTransforms,
+ final boolean ignoreAffine )
+ {
+ final InvertibleRealTransform tps = transform.getTransformation( false );
+
+ AffineGet affine = null;
+ if( ignoreAffine )
+ affine = transform.affinePartOfTps();
+
+ if ( !ignoreAffine && ( data == null || !concatPreTransforms ) )
+ {
+ return tps;
+ }
+
+ InvertibleRealTransform preTransform = null;
+ if( data != null && concatPreTransforms )
+ {
+ for ( final Entry< Integer, SourceInfo > entry : data.sourceInfos.entrySet() )
+ {
+ if ( entry.getValue().getTransform() != null )
+ {
+ final RealTransform tform = entry.getValue().getTransform();
+ if( tform instanceof InvertibleRealTransform )
+ {
+ preTransform = ( InvertibleRealTransform ) tform;
+ }
+ else
+ {
+ final WrappedIterativeInvertibleRealTransform< RealTransform > ixfm = new WrappedIterativeInvertibleRealTransform<>( tform );
+ // use same parameters as the passed transform, hopefully that works
+ // alternatively, I could wrap the sequence in the iterative invertible transform - there are tradeoffs here
+ // TODO consider the tradeoffs
+ ixfm.getOptimzer().setMaxIters( transform.getInverseMaxIterations() );
+ ixfm.getOptimzer().setTolerance( transform.getInverseTolerance() );
+ preTransform = ixfm;
+ }
+ break;
+ }
+ }
+ }
+
+ final InvertibleRealTransform startingTransform;
+ if ( preTransform != null || affine != null )
+ {
+ final InvertibleRealTransformSequence seq = new InvertibleRealTransformSequence();
+ seq.add( tps );
+
+ if( affine != null )
+ seq.add( affine.inverse() );
+
+ if( preTransform != null )
+ seq.add( preTransform );
+
+ startingTransform = seq;
+ }
+ else
+ startingTransform = tps;
+
+ return startingTransform;
+ }
+
+
+
+ public static void writeAffineN5(
+ final String n5BasePath,
+ final String n5Dataset,
+ final BigWarpData data,
+ final BigWarpTransform bwTransform )
+ {
+ final String mvgSpaceName = data != null && data.numMovingSources() > 0 ? data.getMovingSource( 0 ).getSpimSource().getName() : "moving";
+ final String tgtSpaceName = data != null && data.numTargetSources() > 0 ? data.getTargetSource( 0 ).getSpimSource().getName() : "target";
+ final String input= mvgSpaceName;
+ final String output= tgtSpaceName;
+ final String name = input + " to " + output;
+
+ CoordinateTransform ct = null;
+ final InvertibleCoordinateTransform tform = bwTransform.getCoordinateTransform();
+ switch( bwTransform.getTransformType()) {
+ case BigWarpTransform.TRANSLATION:
+ if (tform instanceof TranslationModel2D)
+ ct = new TranslationCoordinateTransform(name, input, output, ((TranslationModel2D)tform).getTranslation());
+ else if (tform instanceof TranslationModel3D)
+ ct = new TranslationCoordinateTransform(name, input, output, ((TranslationModel3D)tform).getTranslation());
+ break;
+ case BigWarpTransform.SIMILARITY:
+ double[] simparams;
+ if (tform instanceof SimilarityModel2D)
+ {
+ simparams = bwTransform.toImglib2((SimilarityModel2D)tform).getRowPackedCopy();
+ ct = new AffineCoordinateTransform(name, input, output, simparams);
+ }
+ else if (tform instanceof SimilarityModel3D)
+ {
+ simparams = bwTransform.toImglib2((SimilarityModel3D)tform).getRowPackedCopy();
+ ct = new AffineCoordinateTransform(name, input, output, simparams);
+ }
+ break;
+ case BigWarpTransform.ROTATION:
+ double[] rotparams;
+ if (tform instanceof RigidModel2D)
+ {
+ rotparams = bwTransform.toImglib2((RigidModel2D)tform).getRowPackedCopy();
+ ct = new AffineCoordinateTransform(name, input, output, rotparams);
+ }
+ else if (tform instanceof RigidModel3D)
+ {
+ rotparams = bwTransform.toImglib2((RigidModel3D)tform).getRowPackedCopy();
+ ct = new AffineCoordinateTransform(name, input, output, rotparams);
+ }
+ break;
+ case BigWarpTransform.AFFINE:
+ double[] affparams;
+ if (tform instanceof AffineModel2D)
+ {
+ affparams = bwTransform.toImglib2((AffineModel2D)tform).getRowPackedCopy();
+ ct = new AffineCoordinateTransform(name, input, output, affparams);
+ }
+ else if (tform instanceof AffineModel3D)
+ {
+ affparams = bwTransform.toImglib2((AffineModel3D)tform).getRowPackedCopy();
+ ct = new AffineCoordinateTransform(name, input, output, affparams);
+ }
+ break;
+ }
+
+ if( ct == null )
+ return;
+
+
+
+ final String dataset = (n5Dataset == null) ? "" : n5Dataset;
+ final N5Factory factory = new N5Factory().gsonBuilder( NgffTransformations.gsonBuilder() );
+ final N5Writer n5 = factory.openWriter( n5BasePath );
+ NgffTransformations.addCoordinateTransformations(n5, dataset, ct);
+
+ // also add to root
+ NgffTransformations.addCoordinateTransformations(n5, "", ct);
+ }
+
public static void writeN5(
final String n5BasePath,
final LandmarkTableModel ltm,
+ final BigWarpTransform bwTransform,
+ final BigWarpData data,
final long[] dims,
final double[] spacing,
+ final double[] offset,
+ final String unit,
final int[] spatialBlockSize,
final Compression compression,
- final int nThreads )
+ final int nThreads,
+ final String format,
+ final boolean flatten,
+ final boolean inverse,
+ final double invTolerance,
+ final int invMaxIters ) throws IOException
{
- writeN5( n5BasePath, "dfield", ltm, dims, spacing, spatialBlockSize, compression, nThreads );
+ writeN5( n5BasePath, N5DisplacementField.FORWARD_ATTR, ltm, bwTransform, data, dims, spacing, offset, unit, spatialBlockSize, compression, nThreads, format, flatten, inverse, invTolerance, invMaxIters );
}
- public static void writeN5( final String n5BasePath, final String n5Dataset,
+ public static void writeN5(
+ final String n5BasePath,
+ final String n5Dataset,
final LandmarkTableModel ltm,
+ final BigWarpTransform bwTransform,
+ final BigWarpData data,
final long[] dims,
final double[] spacing,
+ final double[] offset,
+ final String unit,
final int[] spatialBlockSize,
final Compression compression,
- final int nThreads )
+ final int nThreads,
+ final String format,
+ final boolean flatten,
+ final boolean inverse,
+ final double invTolerance,
+ final int invMaxIters ) throws IOException
{
- final BigWarpTransform bwXfm = new BigWarpTransform( ltm, TransformTypeSelectDialog.TPS );
- final RealTransform tpsTotal = getTpsAffineToggle( bwXfm, false );
+ writeN5( n5BasePath, n5Dataset, ltm, bwTransform, data, dims, spacing, offset, unit, spatialBlockSize, compression, nThreads, format, false, flatten, inverse, invTolerance, invMaxIters );
+ }
+
+ @SuppressWarnings("rawtypes")
+ public static void writeN5(
+ final String n5BasePath,
+ final String n5Dataset,
+ final LandmarkTableModel ltm,
+ final BigWarpTransform bwTransform,
+ final BigWarpData data,
+ final long[] dims,
+ final double[] spacing,
+ final double[] offset,
+ final String unit,
+ final int[] spatialBlockSizeArg,
+ final Compression compression,
+ final int nThreads,
+ final String format,
+ final boolean splitAffine,
+ final boolean flatten,
+ final boolean inverse,
+ final double invTolerance,
+ final int invMaxIters )
+ {
+ final String dataset = ( n5Dataset == null || n5Dataset.isEmpty() ) ? N5DisplacementField.FORWARD_ATTR : n5Dataset;
+
+ final String mvgSpaceName = getMovingName(data);
+ final String tgtSpaceName = getTargetName(data);
+ final String inputSpace;
+ final String outputSpace;
+ if( inverse )
+ {
+ inputSpace = mvgSpaceName;
+ outputSpace = tgtSpaceName;
+ }
+ else
+ {
+ inputSpace = tgtSpaceName;
+ outputSpace = mvgSpaceName;
+ }
+
+ final BigWarpTransform bwXfm;
+ if( bwTransform == null )
+ bwXfm = new BigWarpTransform( ltm, BigWarpTransform.TPS );
+ else
+ bwXfm = bwTransform;
- AffineGet pixelToPhysical = null;
- if( spacing.length == 2 )
- pixelToPhysical = new Scale2D( spacing );
- else if( spacing.length == 3 )
- pixelToPhysical = new Scale3D( spacing );
+ bwXfm.setInverseMaxIterations( invMaxIters );
+ bwXfm.setInverseTolerance( invTolerance );
- final FloatImagePlus< FloatType > dfieldRaw = convertToDeformationField(
- dims, tpsTotal, pixelToPhysical, nThreads );
+ final InvertibleRealTransform fwdTransform = getTransformation( data, bwXfm, flatten, splitAffine );
+ final InvertibleRealTransform totalTransform = inverse ? fwdTransform.inverse() : fwdTransform;
+ final InvertibleRealTransform transform;
- // this works for both 2d and 3d, it turn out
- final RandomAccessibleInterval< FloatType > dfield =
- Views.permute(
- Views.permute( dfieldRaw,
- 0, 2 ),
- 1, 2 );
+ if (totalTransform.numSourceDimensions() == 2 && bwXfm.isMasked())
+ transform = new InvertibleWrapped2DIntermediate3D(totalTransform);
+ else
+ transform = totalTransform;
+ final int[] spatialBlockSize = fillBlockSize( spatialBlockSizeArg, ltm.getNumdims() );
final int[] blockSize = new int[ spatialBlockSize.length + 1 ];
blockSize[ 0 ] = spatialBlockSize.length;
- for( int i = 0; i < spatialBlockSize.length; i++ )
+ System.arraycopy( spatialBlockSize, 0, blockSize, 1, spatialBlockSize.length );
+
+ final N5Factory factory = new N5Factory().gsonBuilder( NgffTransformations.gsonBuilder() );
+ final N5Writer n5 = factory.openWriter( n5BasePath );
+
+
+ // TODO generalize
+ // get first transformUri for a moving source
+ ReferencedCoordinateTransform refCt = null;
+ if( !flatten )
+ {
+ for ( final Entry e : data.sourceInfos.entrySet() )
+ {
+ final SourceInfo i = e.getValue();
+ if( i.isMoving() && i.getTransformUri() != null && !i.getTransformUri().isEmpty())
+ {
+ refCt = new ReferencedCoordinateTransform( i.getTransformUri() );
+ break;
+ }
+ }
+ }
+
+
+ final RandomAccessibleInterval< DoubleType > dfield;
+ if( splitAffine )
+ {
+ // the affine part
+ final AffineGet affine = bwXfm.affinePartOfTps();
+ final AffineCoordinateTransform ngffAffine = new AffineCoordinateTransform( affine.getRowPackedCopy() );
+
+ // the variable transform has the affine part removed here
+ dfield = DisplacementFieldTransform.createDisplacementField( transform, new FinalInterval( dims ), spacing, offset );
+
+ if( format.equals( ExportDisplacementFieldFrame.FMT_SLICER ))
+ {
+ final ThreadPoolExecutor exec = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue() );
+ SlicerTransformations.saveDisplacementField( n5, dataset, dfield, blockSize, compression, exec );
+ SlicerTransformations.saveAffine( n5, dataset, affine );
+ }
+ else
+ {
+ final DisplacementFieldCoordinateTransform dfieldTform = NgffTransformations.save( n5, dataset, dfield, inputSpace, outputSpace, spacing, offset, unit, blockSize, compression, nThreads );
+
+ // the transform sequence needs to have a reference to whatever transform was imported, if requested
+ final CoordinateTransform[] ctList = refCt == null ? new CoordinateTransform[]{ dfieldTform, ngffAffine } : new CoordinateTransform[]{ dfieldTform, ngffAffine, refCt };
+
+ // the total transform
+ final SequenceCoordinateTransform totalTform = new SequenceCoordinateTransform( inputSpace, outputSpace, ctList );
+
+ NgffTransformations.addCoordinateTransformations( n5, "/", totalTform );
+ }
+ }
+ else
{
- blockSize[ i + 1 ] = spatialBlockSize[ i ];
+ dfield = DisplacementFieldTransform.createDisplacementField( transform, new FinalInterval( dims ), spacing, offset );
+
+ if( format.equals( ExportDisplacementFieldFrame.FMT_SLICER ))
+ {
+ final ThreadPoolExecutor exec = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue() );
+ SlicerTransformations.saveDisplacementField( n5, dataset, dfield, blockSize, compression, exec );
+
+ // for slicer, this affine represents the pixel to physical transformation
+ SlicerTransformations.saveAffine( n5, dataset, new ScaleAndTranslation( spacing, offset ) );
+ }
+ else
+ {
+ final DisplacementFieldCoordinateTransform dfieldTform = NgffTransformations.save( n5, dataset, dfield, inputSpace, outputSpace, spacing, offset, unit, blockSize, compression, nThreads );
+
+ final CoordinateTransform ngffTform;
+ if( refCt == null )
+ ngffTform = dfieldTform;
+ else
+ ngffTform = new SequenceCoordinateTransform( refCt.getInput(), dfieldTform.getOutput(), new CoordinateTransform[]{ dfieldTform, refCt });
+
+
+ NgffTransformations.addCoordinateTransformations( n5, "/", ngffTform );
+ }
}
- final N5Writer n5 = new N5Factory().openWriter( n5BasePath );
- N5DisplacementField.save( n5, n5Dataset, null, dfield, spacing, blockSize, compression );
n5.close();
}
- private static RealTransform getTpsAffineToggle( final BigWarpTransform bwXfm, final boolean ignoreAffine )
+ private static String getMovingName( final BigWarpData data ) {
+ if( data != null && data.numMovingSources() > 0 )
+ {
+ final Source src = data.getMovingSource( 0 ).getSpimSource();
+ if( src instanceof WarpedSource )
+ return ((WarpedSource)src).getOriginalName();
+ else
+ return src.getName();
+ }
+ return "moving";
+ }
+
+ private static String getTargetName( final BigWarpData data ) {
+ if( data != null && data.numTargetSources() > 0 )
+ {
+ final Source src = data.getTargetSource( 0 ).getSpimSource();
+ if( src instanceof WarpedSource )
+ return ((WarpedSource)src).getOriginalName();
+ else
+ return src.getName();
+ }
+ return "target";
+ }
+
+ private static int[] fillBlockSize(final int[] blockSize, final int N)
{
- if( ignoreAffine )
+ if( blockSize.length >= N )
+ return blockSize;
+ else
+ {
+ final int[] out = new int[ N ];
+ final int j = blockSize.length - 1;
+ for ( int i = 0; i < N; i++ )
+ {
+ if ( i < blockSize.length )
+ out[ i ] = blockSize[ i ];
+ else
+ out[ i ] = blockSize[ j ];
+ }
+ return out;
+ }
+ }
+
+ private static RealTransform getTpsAffineToggle( final BigWarpTransform bwXfm, final boolean splitAffine )
+ {
+ if ( splitAffine )
{
final ThinPlateR2LogRSplineKernelTransform tps = bwXfm.getTpsBase();
return new ThinplateSplineTransform(
- new ThinPlateR2LogRSplineKernelTransform( tps.getSourceLandmarks(), null, null, tps.getKnotWeights() ));
+ new ThinPlateR2LogRSplineKernelTransform( tps.getSourceLandmarks(), null, null, tps.getKnotWeights() ) );
}
else
- return bwXfm.getTransformation();
+ return bwXfm.getTransformation( false );
}
+ /**
+ * Get the affine part of a thin-plate spline transform. The affine will be 2D (3D)
+ * if the transformation is 2D (3D).
+ *
+ * @param tps the {@link ThinPlateR2LogRSplineKernelTransform} instance
+ * @return the {@link AffineGet} instance.
+ *
+ * @deprecated Use {@link BigWarpTransform} method instead
+ */
+ @Deprecated()
public static AffineGet toAffine( final ThinPlateR2LogRSplineKernelTransform tps )
{
final double[] affineFlat = toFlatAffine( tps );
@@ -379,22 +932,21 @@ public static long[] dimensionsFromImagePlus( final ImagePlus ref_imp )
long[] dims;
if( ref_imp.getNSlices() < 2 )
{
- dims = new long[ 3 ];
+ dims = new long[ 2 ];
dims[ 0 ] = ref_imp.getWidth();
dims[ 1 ] = ref_imp.getHeight();
- dims[ 2 ] = 2;
}
else
{
- dims = new long[ 4 ];
+ dims = new long[ 3 ];
dims[ 0 ] = ref_imp.getWidth();
dims[ 1 ] = ref_imp.getHeight();
- dims[ 2 ] = 3;
- dims[ 3 ] = ref_imp.getNSlices();
+ dims[ 2 ] = ref_imp.getNSlices();
}
return dims;
}
+ @Deprecated
public static FloatImagePlus< FloatType > convertToDeformationField(
final long[] dims,
final RealTransform transform,
@@ -458,6 +1010,7 @@ public static boolean areTransformsTheSame( final RealTransform xfm1, final Real
* the {@link RandomAccessibleInterval} into which the
* displacement field will be written
*/
+ @Deprecated
public static < T extends RealType< T > > void fromRealTransform(
final RealTransform transform,
final AffineGet pixelToPhysical,
@@ -509,6 +1062,7 @@ public static < T extends RealType< T > > void fromRealTransform(
* @param nThreads
* the number of threads
*/
+ @Deprecated
public static < T extends RealType< T > > void fromRealTransform( final RealTransform transform,
final AffineGet pixelToPhysical,
final RandomAccessibleInterval< T > deformationField,
@@ -532,7 +1086,7 @@ public static < T extends RealType< T > > void fromRealTransform( final RealTran
dim2split = 2;
}
- final long del = ( long )( N / nThreads );
+ final long del = ( N / nThreads );
splitPoints[ 0 ] = 0;
splitPoints[ nThreads ] = deformationField.dimension( dim2split );
for( int i = 1; i < nThreads; i++ )
@@ -606,7 +1160,7 @@ public Boolean call()
}
}
- private static Compression getCompression( final String compressionArg )
+ public static Compression getCompression( final String compressionArg )
{
switch (compressionArg) {
case N5Exporter.GZIP_COMPRESSION:
@@ -629,26 +1183,44 @@ private static Compression getCompression( final String compressionArg )
* and can prompt the user for these parameters.
*
*/
- private static class DeformationFieldExportParameters
+ public static class DeformationFieldExportParameters
{
public final String landmarkPath;
public final boolean ignoreAffine;
+ public final String option;
+ public final String inverseOption;
+ public final boolean virtual;
public final int nThreads;
+ public final String format;
+
public final long[] size;
public final double[] spacing;
+ public final double[] offset;
+ public final String unit;
public final String n5Base;
public final String n5Dataset;
public final Compression compression;
public final int[] blockSize;
+ public final double inverseTolerance;
+ public final int inverseMaxIterations;
+
public DeformationFieldExportParameters(
final String landmarkPath,
final boolean ignoreAffine,
+ final String option,
+ final String inverseOption,
+ final double inverseTolerance,
+ final int inverseMaxIterations,
+ final boolean virtual,
final int nThreads,
+ final String format,
final long[] size,
final double[] spacing,
+ final double[] offset,
+ final String unit,
final String n5Base,
final String n5Dataset,
final int[] blockSize,
@@ -656,10 +1228,20 @@ public DeformationFieldExportParameters(
{
this.landmarkPath = landmarkPath;
this.ignoreAffine = ignoreAffine;
+ this.option = option;
+
+ this.inverseOption = inverseOption;
+ this.inverseTolerance = inverseTolerance;
+ this.inverseMaxIterations = inverseMaxIterations;
+
+ this.virtual = virtual;
this.nThreads = nThreads;
+ this.format = format;
this.size = size;
this.spacing = spacing;
+ this.offset = offset;
+ this.unit = unit;
this.n5Base = n5Base;
this.n5Dataset = n5Dataset;
@@ -667,6 +1249,11 @@ public DeformationFieldExportParameters(
this.compression = compression;
}
+ public boolean flatten()
+ {
+ return option.equals( flattenOption );
+ }
+
public static DeformationFieldExportParameters fromDialog(
final boolean promptLandmarks,
final boolean promptReference )
@@ -678,8 +1265,17 @@ public static DeformationFieldExportParameters fromDialog(
gd.addFileField( "landmarks_image_file", "" );
}
- gd.addCheckbox( "Ignore affine part", false );
+ gd.addCheckbox( "Split affine part", false );
+
+ final String[] choices = new String[] { flattenOption, sequenceOption };
+ gd.addChoice( "type", choices, flattenOption );
+
+ final String[] invChoices = new String[] { INVERSE_OPTIONS.FORWARD.toString(), INVERSE_OPTIONS.INVERSE.toString(), INVERSE_OPTIONS.BOTH.toString() };
+ gd.addChoice( "direction", invChoices, INVERSE_OPTIONS.FORWARD.toString() );
+
+ gd.addCheckbox( "virtual", false );
gd.addNumericField( "threads", 1, 0 );
+ gd.addStringField( "format", ExportDisplacementFieldFrame.FMT_NGFF );
gd.addMessage( "Size and spacing" );
final int[] ids = WindowManager.getIDList();
@@ -697,10 +1293,12 @@ public static DeformationFieldExportParameters fromDialog(
}
gd.addStringField( "output size", "");
gd.addStringField( "output spacing", "");
+ gd.addStringField( "output offset", "");
+ gd.addStringField( "output unit", "pixel");
gd.addMessage( "Leave n5 path empty to export as ImagePlus" );
gd.addDirectoryOrFileField( "n5 root path", "" );
- gd.addStringField( "n5 dataset", "");
+ gd.addStringField( "n5 dataset", N5DisplacementField.FORWARD_ATTR );
gd.addStringField( "n5 block size", "32,32,32");
gd.addChoice( "n5 compression", compressionOptions, N5Exporter.GZIP_COMPRESSION );
gd.showDialog();
@@ -713,7 +1311,11 @@ public static DeformationFieldExportParameters fromDialog(
landmarkPath = gd.getNextString();
final boolean ignoreAffine = gd.getNextBoolean();
+ final String option = gd.getNextChoice();
+ final String direction = gd.getNextChoice();
+ final boolean virtual = gd.getNextBoolean();
final int nThreads = ( int ) gd.getNextNumber();
+ final String format = gd.getNextString();
ImagePlus ref_imp = null;
if( promptReference )
@@ -725,6 +1327,8 @@ public static DeformationFieldExportParameters fromDialog(
final String sizeString = gd.getNextString();
final String spacingString = gd.getNextString();
+ final String offsetString = gd.getNextString();
+ final String unitString = gd.getNextString();
final String n5Base = gd.getNextString();
final String n5Dataset = gd.getNextString();
@@ -737,6 +1341,8 @@ public static DeformationFieldExportParameters fromDialog(
final long[] size;
final double[] spacing;
+ final double[] offset;
+ String unit = "pixel";
if( ref_imp == null )
{
if( !sizeString.isEmpty())
@@ -748,6 +1354,14 @@ public static DeformationFieldExportParameters fromDialog(
spacing = Arrays.stream( spacingString.split( "," ) ).mapToDouble( Double::parseDouble ).toArray();
else
spacing = null;
+
+ if( !offsetString.isEmpty() )
+ offset = Arrays.stream( offsetString.split( "," ) ).mapToDouble( Double::parseDouble ).toArray();
+ else
+ offset = null;
+
+ if( !unitString.isEmpty() )
+ unit = unitString;
}
else
{
@@ -757,11 +1371,18 @@ public static DeformationFieldExportParameters fromDialog(
// account for physical units of reference image
spacing = new double[ nd ];
+ offset = new double[ nd ];
spacing[ 0 ] = ref_imp.getCalibration().pixelWidth;
spacing[ 1 ] = ref_imp.getCalibration().pixelHeight;
+ offset[ 0 ] = ref_imp.getCalibration().xOrigin;
+ offset[ 1 ] = ref_imp.getCalibration().yOrigin;
+
if ( nd > 2 )
+ {
spacing[ 2 ] = ref_imp.getCalibration().pixelDepth;
+ offset[ 2 ] = ref_imp.getCalibration().zOrigin;
+ }
size = BigWarpToDeformationFieldPlugIn.dimensionsFromImagePlus( ref_imp );
}
@@ -769,14 +1390,27 @@ public static DeformationFieldExportParameters fromDialog(
return new DeformationFieldExportParameters(
landmarkPath,
ignoreAffine,
+ option,
+ direction, 0.5, 200,
+ virtual,
nThreads,
+ format,
size,
spacing,
+ offset,
+ unit,
n5Base,
n5Dataset,
blockSize,
compression );
}
+
+ public JFrame makeDialog()
+ {
+ final ExportDisplacementFieldFrame frame = new ExportDisplacementFieldFrame( null );
+ return frame;
+ }
+
}
}
diff --git a/src/main/java/bdv/ij/BigWarpTransformExportPlugin.java b/src/main/java/bdv/ij/BigWarpTransformExportPlugin.java
new file mode 100644
index 00000000..157808ec
--- /dev/null
+++ b/src/main/java/bdv/ij/BigWarpTransformExportPlugin.java
@@ -0,0 +1,101 @@
+package bdv.ij;
+
+import java.io.File;
+import java.io.IOException;
+
+import bigwarp.BigWarp;
+import bigwarp.landmarks.LandmarkTableModel;
+import bigwarp.transforms.BigWarpTransform;
+import bigwarp.transforms.NgffTransformations;
+import bigwarp.transforms.WrappedCoordinateTransform;
+import fiji.util.gui.GenericDialogPlus;
+import ij.ImageJ;
+import ij.plugin.PlugIn;
+import mpicbg.models.Model;
+import net.imglib2.realtransform.AffineGet;
+
+public class BigWarpTransformExportPlugin implements PlugIn
+{
+ private boolean promptLandmarks = true;
+
+ private BigWarpTransform bwTransform;
+
+ public static void main( final String[] args )
+ {
+ new ImageJ();
+ new BigWarpTransformExportPlugin().run( null );
+ }
+
+ public void runFromBigWarpInstance( final BigWarp< ? > bw )
+ {
+ promptLandmarks = false;
+ bwTransform = bw.getBwTransform();
+ run( null );
+ }
+
+ @Override
+ public void run( final String arg )
+ {
+ // TODO deal with macro recordability
+
+ final GenericDialogPlus gd = new GenericDialogPlus( "Export BigWarp Transformation" );
+ gd.addMessage( "Transformation export:" );
+ if ( promptLandmarks )
+ {
+ gd.addFileField( "landmarks_file", "" );
+ }
+
+ gd.addChoice( "Transform type",
+ new String[] {
+ BigWarpTransform.AFFINE,
+ BigWarpTransform.SIMILARITY,
+ BigWarpTransform.ROTATION,
+ BigWarpTransform.TRANSLATION },
+ BigWarpTransform.AFFINE );
+
+ gd.addFileField( "Output json file or n5", "" );
+ gd.addStringField( "N5 dataset", "" );
+ gd.addStringField( "N5 attribute name", "" );
+
+ gd.showDialog();
+ if ( gd.wasCanceled() )
+ return;
+
+ String landmarksPath = null;
+ if ( promptLandmarks )
+ {
+ landmarksPath = gd.getNextString();
+ }
+
+ final String transformTypeOption = gd.getNextChoice();
+ final String fileOrN5Root = gd.getNextString();
+ final String n5Dataset = gd.getNextString();
+ final String n5Attr = gd.getNextString();
+
+ if ( bwTransform == null )
+ {
+ try
+ {
+ final LandmarkTableModel ltm = LandmarkTableModel.loadFromCsv( new File( landmarksPath ), false );
+ bwTransform = new BigWarpTransform( ltm, transformTypeOption );
+ }
+ catch ( final IOException e )
+ {
+ e.printStackTrace();
+ return;
+ }
+ }
+
+ String url = fileOrN5Root;
+ if ( !n5Dataset.isEmpty() )
+ url = url + "?" + n5Dataset;
+
+ if ( !n5Attr.isEmpty() )
+ url = url + "#" + n5Attr;
+
+ final WrappedCoordinateTransform wct = ( WrappedCoordinateTransform ) bwTransform.getTransformation( false );
+ final AffineGet affine = bwTransform.toImglib2( ( Model< ? > ) wct.getTransform() );
+ NgffTransformations.save( url, NgffTransformations.createAffine( affine ) );
+ }
+
+}
diff --git a/src/main/java/bdv/img/RealTransformedSource.java b/src/main/java/bdv/img/RealTransformedSource.java
new file mode 100644
index 00000000..1701f84c
--- /dev/null
+++ b/src/main/java/bdv/img/RealTransformedSource.java
@@ -0,0 +1,266 @@
+/*-
+ * #%L
+ * BigWarp plugin for Fiji.
+ * %%
+ * Copyright (C) 2015 - 2022 Howard Hughes Medical Institute.
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program. If not, see
+ * .
+ * #L%
+ */
+package bdv.img;
+
+import java.util.function.Supplier;
+
+import bdv.viewer.Interpolation;
+import bdv.viewer.Source;
+import bdv.viewer.SourceAndConverter;
+import bdv.viewer.render.DefaultMipmapOrdering;
+import bdv.viewer.render.MipmapOrdering;
+import mpicbg.spim.data.sequence.VoxelDimensions;
+import net.imglib2.Interval;
+import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.RealRandomAccessible;
+import net.imglib2.realtransform.AffineTransform3D;
+import net.imglib2.realtransform.BoundingBoxEstimation;
+import net.imglib2.realtransform.InvertibleRealTransform;
+import net.imglib2.realtransform.RealTransform;
+import net.imglib2.realtransform.RealTransformRealRandomAccessible;
+import net.imglib2.realtransform.RealTransformSequence;
+import net.imglib2.realtransform.inverse.WrappedIterativeInvertibleRealTransform;
+import net.imglib2.view.Views;
+
+public class RealTransformedSource < T > implements Source< T >, MipmapOrdering
+{
+
+ public static < T > SourceAndConverter< T > wrap( final SourceAndConverter< T > wrap, final String name, int ndims )
+ {
+ return new SourceAndConverter< T >(
+ new RealTransformedSource< T >( wrap.getSpimSource(), name ),
+ wrap.getConverter(),
+ wrap.asVolatile() == null ? null : wrap( wrap.asVolatile(), name, ndims ) );
+ }
+
+ /**
+ * The wrapped {@link Source}.
+ */
+ private final Source< T > source;
+
+ private final String name;
+
+ /**
+ * This is either the {@link #source} itself, if it implements
+ * {@link MipmapOrdering}, or a {@link DefaultMipmapOrdering}.
+ */
+ private final MipmapOrdering sourceMipmapOrdering;
+
+ private InvertibleRealTransform xfm;
+
+ private Interval[] boundingIntervalsPerLevel;
+
+ private boolean isTransformed;
+
+ private final Supplier< Boolean > boundingBoxCullingSupplier;
+
+ private BoundingBoxEstimation bboxEst;
+
+ public RealTransformedSource( final Source< T > source, final String name )
+ {
+ this( source, name, null );
+ }
+
+ public RealTransformedSource( final Source< T > source, final String name,
+ final Supplier< Boolean > doBoundingBoxCulling )
+ {
+ this.source = source;
+ this.name = name;
+ this.isTransformed = false;
+ this.boundingBoxCullingSupplier = doBoundingBoxCulling;
+ this.xfm = null;
+
+ bboxEst = new BoundingBoxEstimation( BoundingBoxEstimation.Method.FACES, 5 );
+ boundingIntervalsPerLevel = new Interval[source.getNumMipmapLevels()];
+
+ sourceMipmapOrdering = MipmapOrdering.class.isInstance( source ) ?
+ ( MipmapOrdering ) source : new DefaultMipmapOrdering( source );
+ }
+
+ @Override
+ public boolean isPresent( final int t )
+ {
+ return source.isPresent( t );
+ }
+
+ @Override
+ public boolean doBoundingBoxCulling()
+ {
+ if( boundingBoxCullingSupplier != null )
+ return boundingBoxCullingSupplier.get();
+ else
+ return ( !isTransformed ) && ( source.doBoundingBoxCulling() );
+ }
+
+ public void updateTransform( RealTransform xfm )
+ {
+ if( xfm instanceof InvertibleRealTransform )
+ this.xfm = (InvertibleRealTransform)xfm;
+ else
+ this.xfm = new WrappedIterativeInvertibleRealTransform<>(xfm);
+
+ updateBoundingIntervals();
+ }
+
+ protected void updateBoundingIntervals()
+ {
+ for( int i = 0; i < getNumMipmapLevels(); i++ )
+ {
+ boundingIntervalsPerLevel[i] = estimateBoundingInterval(0, i);
+ }
+ }
+
+ public void setIsTransformed( boolean isTransformed )
+ {
+ this.isTransformed = isTransformed;
+ }
+
+ public void setBoundingBoxEstimator( final BoundingBoxEstimation bboxEst )
+ {
+ this.bboxEst = bboxEst;
+ }
+
+ public boolean isTransformed( )
+ {
+ return isTransformed;
+ }
+
+ public Source< T > getWrappedSource()
+ {
+ return source;
+ }
+
+ @Override
+ public RandomAccessibleInterval< T > getSource( final int t, final int level )
+ {
+// if( isTransformed )
+// {
+// return Views.interval(
+// Views.raster( getInterpolatedSource( t, level, Interpolation.NEARESTNEIGHBOR ) ),
+// boundingIntervalsPerLevel[level] );
+// }
+// return source.getSource( t, level );
+
+ if( isTransformed )
+ {
+ final RealTransformRealRandomAccessible interpSrc = (RealTransformRealRandomAccessible)getInterpolatedSource( t, level, Interpolation.NEARESTNEIGHBOR );
+
+ final AffineTransform3D transform = new AffineTransform3D();
+ source.getSourceTransform( t, level, transform );
+ final RealTransformSequence totalInverseTransform = new RealTransformSequence();
+ totalInverseTransform.add( transform.inverse() );
+ totalInverseTransform.add( transform.inverse() );
+ totalInverseTransform.add( transform );
+
+ return Views.interval( Views.raster(interpSrc), boundingIntervalsPerLevel[level] );
+ }
+ else
+ return source.getSource( t, level );
+ }
+
+ private Interval estimateBoundingInterval( final int t, final int level )
+ {
+ if( xfm == null )
+ {
+ return source.getSource( t, level );
+ }
+ else
+ {
+ // getSource can be called by multiple threads, so need ensure application of
+ // the transform is thread safe here by copying
+ return bboxEst.estimatePixelInterval( xfm.copy().inverse(), source.getSource( t, level ) );
+ }
+ }
+
+ @Override
+ public RealRandomAccessible< T > getInterpolatedSource( final int t, final int level, final Interpolation method )
+ {
+
+ final RealRandomAccessible realSrc = source.getInterpolatedSource( t, level, method );
+ if( isTransformed && xfm != null )
+ {
+ final AffineTransform3D transform = new AffineTransform3D();
+ source.getSourceTransform( t, level, transform );
+
+ final RealTransformSequence totalTransform = new RealTransformSequence();
+ totalTransform.add( transform.inverse() );
+ totalTransform.add( xfm );
+ totalTransform.add( transform );
+
+ return new RealTransformRealRandomAccessible< T, RealTransform >( realSrc, xfm );
+ }
+ else
+ {
+ return realSrc;
+ }
+ }
+
+ @Override
+ public synchronized void getSourceTransform( final int t, final int level, final AffineTransform3D transform )
+ {
+ if( isTransformed )
+ transform.identity();
+ else
+ source.getSourceTransform( t, level, transform );
+ }
+
+ public RealTransform getTransform()
+ {
+ return xfm;
+ }
+
+ @Override
+ public T getType()
+ {
+ return source.getType();
+ }
+
+ @Override
+ public String getName()
+ {
+ return source.getName() + "_" + name;
+ }
+
+ public String getOriginalName()
+ {
+ return getWrappedSource().getName();
+ }
+
+ @Override
+ public VoxelDimensions getVoxelDimensions()
+ {
+ return source.getVoxelDimensions();
+ }
+
+ @Override
+ public int getNumMipmapLevels()
+ {
+ return source.getNumMipmapLevels();
+ }
+
+ @Override
+ public synchronized MipmapHints getMipmapHints( final AffineTransform3D screenTransform, final int timepoint, final int previousTimepoint )
+ {
+ return sourceMipmapOrdering.getMipmapHints( screenTransform, timepoint, previousTimepoint );
+ }
+
+}
diff --git a/src/main/java/bdv/img/WarpedSource.java b/src/main/java/bdv/img/WarpedSource.java
index bd70dd1c..296d804d 100644
--- a/src/main/java/bdv/img/WarpedSource.java
+++ b/src/main/java/bdv/img/WarpedSource.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -28,16 +28,18 @@
import bdv.viewer.SourceAndConverter;
import bdv.viewer.render.DefaultMipmapOrdering;
import bdv.viewer.render.MipmapOrdering;
-import bigwarp.BigWarpExporter;
import mpicbg.spim.data.sequence.VoxelDimensions;
import net.imglib2.Interval;
import net.imglib2.RandomAccessibleInterval;
import net.imglib2.RealRandomAccessible;
import net.imglib2.realtransform.AffineTransform3D;
import net.imglib2.realtransform.BoundingBoxEstimation;
+import net.imglib2.realtransform.InvertibleRealTransform;
import net.imglib2.realtransform.RealTransform;
import net.imglib2.realtransform.RealTransformRealRandomAccessible;
+import net.imglib2.realtransform.RealTransformSequence;
import net.imglib2.realtransform.RealViews;
+import net.imglib2.realtransform.inverse.WrappedIterativeInvertibleRealTransform;
import net.imglib2.view.Views;
public class WarpedSource < T > implements Source< T >, MipmapOrdering
@@ -64,10 +66,12 @@ public static < T > SourceAndConverter< T > wrap( final SourceAndConverter< T >
*/
private final MipmapOrdering sourceMipmapOrdering;
- private RealTransform xfm;
+ private InvertibleRealTransform xfm;
+
+ private Interval[] boundingIntervalsPerLevel;
private boolean isTransformed;
-
+
private final Supplier< Boolean > boundingBoxCullingSupplier;
private BoundingBoxEstimation bboxEst;
@@ -84,9 +88,11 @@ public WarpedSource( final Source< T > source, final String name,
this.name = name;
this.isTransformed = false;
this.boundingBoxCullingSupplier = doBoundingBoxCulling;
-
this.xfm = null;
+ bboxEst = new BoundingBoxEstimation( BoundingBoxEstimation.Method.FACES, 5 );
+ boundingIntervalsPerLevel = new Interval[source.getNumMipmapLevels()];
+
sourceMipmapOrdering = MipmapOrdering.class.isInstance( source ) ?
( MipmapOrdering ) source : new DefaultMipmapOrdering( source );
}
@@ -96,7 +102,7 @@ public boolean isPresent( final int t )
{
return source.isPresent( t );
}
-
+
@Override
public boolean doBoundingBoxCulling()
{
@@ -108,14 +114,27 @@ public boolean doBoundingBoxCulling()
public void updateTransform( RealTransform xfm )
{
- this.xfm = xfm;
+ if( xfm instanceof InvertibleRealTransform )
+ this.xfm = (InvertibleRealTransform)xfm;
+ else
+ this.xfm = new WrappedIterativeInvertibleRealTransform<>(xfm);
+
+ updateBoundingIntervals();
+ }
+
+ protected void updateBoundingIntervals()
+ {
+ for( int i = 0; i < getNumMipmapLevels(); i++ )
+ {
+ boundingIntervalsPerLevel[i] = estimateBoundingInterval(0, i);
+ }
}
-
+
public void setIsTransformed( boolean isTransformed )
{
this.isTransformed = isTransformed;
}
-
+
public void setBoundingBoxEstimator( final BoundingBoxEstimation bboxEst )
{
this.bboxEst = bboxEst;
@@ -138,44 +157,32 @@ public RandomAccessibleInterval< T > getSource( final int t, final int level )
{
return Views.interval(
Views.raster( getInterpolatedSource( t, level, Interpolation.NEARESTNEIGHBOR ) ),
- estimateBoundingInterval( t, level ));
+ boundingIntervalsPerLevel[level] );
+
}
return source.getSource( t, level );
}
private Interval estimateBoundingInterval( final int t, final int level )
{
- return bboxEst.estimatePixelInterval( xfm, source.getSource( t, level ) );
+ if( xfm == null )
+ {
+ return source.getSource( t, level );
+ }
+ else
+ {
+ // getSource can be called by multiple threads, so need ensure application of
+ // the transform is thread safe here by copying
+ return bboxEst.estimatePixelInterval( xfm.copy().inverse(), source.getSource( t, level ) );
+ }
}
@Override
public RealRandomAccessible< T > getInterpolatedSource( final int t, final int level, final Interpolation method )
{
-// RealRandomAccessible realSrc = source.getInterpolatedSource( t, level, method );
-// if( isTransformed && xfm != null )
-// {
-// final AffineTransform3D transform = new AffineTransform3D();
-// source.getSourceTransform( t, level, transform );
-//
-// RealTransformSequence totalTransform = new RealTransformSequence();
-//// totalTransform.add( transform );
-//// totalTransform.add( xfm );
-//// totalTransform.add( transform.inverse() );
-//
-// totalTransform.add( transform.inverse() );
-// totalTransform.add( xfm );
-// totalTransform.add( transform );
-//
-// return new RealTransformRealRandomAccessible< T, RealTransform >( realSrc, xfm );
-// }
-// else
-// {
-// return realSrc;
-// }
-
- final RealRandomAccessible< T > sourceRealAccessible = source.getInterpolatedSource( t, level, method );
- if( isTransformed )
+ final RealRandomAccessible realSrc = source.getInterpolatedSource( t, level, method );
+ if( isTransformed && xfm != null )
{
final AffineTransform3D transform = new AffineTransform3D();
source.getSourceTransform( t, level, transform );
@@ -184,11 +191,11 @@ public RealRandomAccessible< T > getInterpolatedSource( final int t, final int l
if( xfm == null )
return srcRaTransformed;
else
- return new RealTransformRealRandomAccessible< T, RealTransform >( srcRaTransformed, xfm );
+ return new RealTransformRealRandomAccessible< T, RealTransform >( srcRaTransformed, xfm);
}
else
{
- return sourceRealAccessible;
+ return realSrc;
}
}
@@ -218,6 +225,11 @@ public String getName()
return source.getName() + "_" + name;
}
+ public String getOriginalName()
+ {
+ return getWrappedSource().getName();
+ }
+
@Override
public VoxelDimensions getVoxelDimensions()
{
diff --git a/src/main/java/bdv/ui/convertersetupeditor/MaskBoundsRangePanel.java b/src/main/java/bdv/ui/convertersetupeditor/MaskBoundsRangePanel.java
new file mode 100644
index 00000000..e617fa48
--- /dev/null
+++ b/src/main/java/bdv/ui/convertersetupeditor/MaskBoundsRangePanel.java
@@ -0,0 +1,29 @@
+package bdv.ui.convertersetupeditor;
+
+import bdv.util.BoundedRange;
+import bigwarp.BigWarp;
+
+public class MaskBoundsRangePanel extends BoundedRangePanel {
+
+ private static final long serialVersionUID = -4065636040399818543L;
+
+ public MaskBoundsRangePanel(BigWarp bw ) {
+ this(bw, new BoundedRange(0, 1, 0, 1));
+ }
+
+ public MaskBoundsRangePanel( final BigWarp bw, final BoundedRange range ) {
+ super( range );
+ setConsistent( true );
+ setup( bw );
+ }
+
+ protected void setup( BigWarp bw ) {
+ changeListeners().add(new ChangeListener() {
+ @Override
+ public void boundedRangeChanged() {
+ bw.getBwTransform().setMaskIntensityBounds( getRange().getMin(), getRange().getMax());
+ }
+ });
+ }
+
+}
diff --git a/src/main/java/bdv/viewer/BigWarpDragOverlay.java b/src/main/java/bdv/viewer/BigWarpDragOverlay.java
index 5af16790..b6979a07 100644
--- a/src/main/java/bdv/viewer/BigWarpDragOverlay.java
+++ b/src/main/java/bdv/viewer/BigWarpDragOverlay.java
@@ -81,13 +81,11 @@ public void paint( final Graphics2D g )
{
arad = viewer.getSettings().getSpotSize();
baseColor = viewer.getSettings().getSpotColor();
-
- // System.out.println("BigWarpDragOverlay - PAINT" );
+
if( inProgress )
{
viewer.state().getViewerTransform( transform );
- //System.out.println("BigWarpDragOverlay - PAINT IN PROGRESS" );
transform.apply( movingPoint, movingPointScreen );
transform.apply( targetPoint, targetPointScreen );
diff --git a/src/main/java/bdv/viewer/BigWarpLandmarkFrame.java b/src/main/java/bdv/viewer/BigWarpLandmarkFrame.java
index 52116094..b54e90b9 100644
--- a/src/main/java/bdv/viewer/BigWarpLandmarkFrame.java
+++ b/src/main/java/bdv/viewer/BigWarpLandmarkFrame.java
@@ -31,9 +31,11 @@
import javax.swing.WindowConstants;
import org.scijava.ui.behaviour.util.InputActionBindings;
+import org.scijava.ui.behaviour.util.TriggerBehaviourBindings;
import bdv.gui.BigWarpLandmarkPanel;
import bigwarp.BigWarp;
+import bigwarp.ui.keymap.KeymapManager;
public class BigWarpLandmarkFrame extends JFrame {
@@ -43,16 +45,21 @@ public class BigWarpLandmarkFrame extends JFrame {
private BigWarpLandmarkPanel lmPanel;
+ private final KeymapManager keymapManager;
+
private final InputActionBindings keybindings;
- public BigWarpLandmarkFrame( String name, BigWarpLandmarkPanel panel, BigWarp bw )
+ private final TriggerBehaviourBindings triggerbindings;
+
+ public BigWarpLandmarkFrame( String name, BigWarpLandmarkPanel panel, BigWarp< ? > bw, KeymapManager keymapManager )
{
super( name, AWTUtils.getSuitableGraphicsConfiguration( AWTUtils.RGB_COLOR_MODEL ) );
this.bw = bw;
+ this.keymapManager = keymapManager;
setLandmarkPanel( panel );
keybindings = new InputActionBindings();
-
+ triggerbindings = new TriggerBehaviourBindings();
// do nothing because the closeAll method in bigWarp is responsible for calling dispose and cleaning up
setDefaultCloseOperation( WindowConstants.DO_NOTHING_ON_CLOSE );
@@ -63,11 +70,11 @@ public void windowClosing( final WindowEvent e )
BigWarpLandmarkFrame.this.bw.closeAll();
}
} );
-
+
SwingUtilities.replaceUIActionMap( lmPanel.getJTable(), keybindings.getConcatenatedActionMap() );
- SwingUtilities.replaceUIInputMap( lmPanel.getJTable(), JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keybindings.getConcatenatedInputMap() );
+ SwingUtilities.replaceUIInputMap( lmPanel.getJTable(), JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keybindings.getConcatenatedInputMap() );
}
-
+
public void setLandmarkPanel( BigWarpLandmarkPanel panel )
{
this.lmPanel = panel;
@@ -81,5 +88,4 @@ public InputActionBindings getKeybindings()
return keybindings;
}
-
}
diff --git a/src/main/java/bdv/viewer/BigWarpOverlay.java b/src/main/java/bdv/viewer/BigWarpOverlay.java
index 23ce4368..2ab164aa 100644
--- a/src/main/java/bdv/viewer/BigWarpOverlay.java
+++ b/src/main/java/bdv/viewer/BigWarpOverlay.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -40,70 +40,51 @@
public class BigWarpOverlay {
private BigWarpViewerPanel viewer;
-
- protected JTable table;
- protected LandmarkTableModel landmarkModel;
+ private BigWarpLandmarkPanel landmarkPanel;
protected RealTransform estimatedXfm;
-
+
protected boolean isTransformed = false;
private int hoveredIndex;
protected final boolean isMoving;
- protected final boolean is3d;
-
+
protected final double[] spot;
- protected final double[] viewerCoords;
+ protected final double[] viewerCoords;
/** The transform for the viewer current viewpoint. */
private final AffineTransform3D transform = new AffineTransform3D();
-
- public BigWarpOverlay( final BigWarpViewerPanel viewer, BigWarpLandmarkPanel landmarkpanel )
- {
- this.viewer = viewer;
- this.table = landmarkpanel.getJTable();
- this.landmarkModel = landmarkpanel.getTableModel();
- if( landmarkModel.getNumdims() == 3 )
- is3d = true;
- else
- is3d = false;
+ public BigWarpOverlay( final BigWarpViewerPanel viewer, BigWarpLandmarkPanel landmarkPanel )
+ {
+ this.viewer = viewer;
+ setLandmarkPanel(landmarkPanel);
isMoving = viewer.getIsMoving();
spot = new double[ 3 ];
viewerCoords = new double[ 3 ];
}
-
public int getHoveredIndex()
{
return hoveredIndex;
}
-
public void setHoveredIndex( int hoveredIndex )
{
this.hoveredIndex = hoveredIndex;
}
+ public void setLandmarkPanel( final BigWarpLandmarkPanel landmarkPanel )
+ {
+ this.landmarkPanel = landmarkPanel;
+ }
public void paint( final Graphics2D g )
{
- // Save graphic device original settings
- final Composite originalComposite = g.getComposite();
- final Stroke originalStroke = g.getStroke();
- final Color originalColor = g.getColor();
-
- // get selected points
- int[] selectedRows = table.getSelectedRows();
- Arrays.sort( selectedRows );
- boolean[] isSelected = new boolean[ landmarkModel.getRowCount() ];
- for( int i : selectedRows )
- isSelected[ i ] = true;
-
/*
* Draw spots.
@@ -111,17 +92,34 @@ public void paint( final Graphics2D g )
if ( viewer.getSettings().areLandmarksVisible() )
{
+ final LandmarkTableModel landmarkModel = landmarkPanel.getTableModel();
+ final JTable table = landmarkPanel.getJTable();
+ final boolean is3d = landmarkPanel.numDimensions() == 3;
+
+ // Save graphic device original settings
+ final Composite originalComposite = g.getComposite();
+ final Stroke originalStroke = g.getStroke();
+ final Color originalColor = g.getColor();
+
+ // get selected points
+ final int[] selectedRows = table.getSelectedRows();
+ Arrays.sort( selectedRows );
+ final boolean[] isSelected = new boolean[ landmarkModel.getRowCount() ];
+ for( final int i : selectedRows )
+ isSelected[ i ] = true;
+
+
final BasicStroke hlStroke = new BasicStroke( (int)viewer.getSettings().strokeWeight );
- final BasicStroke selStroke = new BasicStroke( (int)viewer.getSettings().strokeWeight / 2 );
+ // final BasicStroke selStroke = new BasicStroke( (int)viewer.getSettings().strokeWeight / 2 );
- final double radiusRatio = ( Double ) viewer.getSettings().get(
+ final double radiusRatio = ( Double ) viewer.getSettings().get(
BigWarpViewerSettings.KEY_SPOT_RADIUS_RATIO );
-
+
final double radius = viewer.getSettings().getSpotSize();
Stroke stroke;
stroke = BigWarpViewerSettings.NORMAL_STROKE;
-
+
FontMetrics fm = null;
Font font = null;
int fonthgt = 0;
@@ -143,7 +141,7 @@ public void paint( final Graphics2D g )
textBoxColorHl = new Color( color.getRed(), color.getGreen(), color.getBlue(), 255 );
textBoxColor = new Color( color.getRed(), color.getGreen(), color.getBlue(), 128 );
- } final Color desaturatedColor = null;
+ }
final int nRows = landmarkModel.getRowCount();
for( int index = 0; index < nRows; index++ )
@@ -195,13 +193,13 @@ public void paint( final Graphics2D g )
else
arad = rad;
- double srad = arad + strokeW;
+ final double srad = arad + strokeW;
// vary size
- g.fillOval( ( int ) ( viewerCoords[ 0 ] - arad ),
- ( int ) ( viewerCoords[ 1 ] - arad ),
+ g.fillOval( ( int ) ( viewerCoords[ 0 ] - arad ),
+ ( int ) ( viewerCoords[ 1 ] - arad ),
( int ) ( 2 * arad + 1 ), ( int ) ( 2 * arad + 1) );
-
+
if( isSelected[ index ] )
{
g.setStroke( hlStroke );
@@ -228,31 +226,31 @@ public void paint( final Graphics2D g )
{
final int tx = ( int ) ( viewerCoords[ 0 ] + arad + 5 );
final int ty = ( int ) viewerCoords[ 1 ];
-
- String name = landmarkModel.getNames().get(index);
- int strwidth = fm.stringWidth( name );
-
+
+ final String name = landmarkModel.getNames().get(index);
+ final int strwidth = fm.stringWidth( name );
+
if( hoveredIndex == index )
g.setColor( textBoxColorHl );
else
g.setColor( textBoxColor );
-
+
g.fillRect( tx - 1, ty - fonthgt + 2, strwidth + 2, fonthgt);
-
+
g.setColor( Color.BLACK );
g.setFont( font );
g.drawString( name, tx, ty );
-
+
}
}
-
}
+
+ // Restore graphic device original settings
+ g.setComposite( originalComposite );
+ g.setStroke( originalStroke );
+ g.setColor( originalColor );
}
- // Restore graphic device original settings
- g.setComposite( originalComposite );
- g.setStroke( originalStroke );
- g.setColor( originalColor );
}
@@ -267,17 +265,17 @@ public void setViewerState( final ViewerState state )
*/
state.getViewerTransform( transform );
}
-
+
public void setEstimatedTransform( final RealTransform estimatedXfm )
{
this.estimatedXfm = estimatedXfm;
}
-
+
public boolean getIsTransformed()
{
return isTransformed;
}
-
+
public void setIsTransformed( boolean isTransformed )
{
this.isTransformed = isTransformed;
diff --git a/src/main/java/bdv/viewer/BigWarpViewerPanel.java b/src/main/java/bdv/viewer/BigWarpViewerPanel.java
index 1bb9b2cf..de353058 100644
--- a/src/main/java/bdv/viewer/BigWarpViewerPanel.java
+++ b/src/main/java/bdv/viewer/BigWarpViewerPanel.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -28,6 +28,10 @@
import bdv.util.Prefs;
import bdv.viewer.animate.RotationAnimator;
import bdv.viewer.animate.SimilarityTransformAnimator3D;
+import bdv.viewer.overlay.BigWarpMaskSphereOverlay;
+import bigwarp.BigWarp;
+import bigwarp.BigWarpData;
+import bigwarp.source.SourceInfo;
import bigwarp.util.Rotation2DHelpers;
import java.awt.Graphics;
import java.awt.Graphics2D;
@@ -45,12 +49,16 @@ public class BigWarpViewerPanel extends ViewerPanel
public static final int TARGET_GROUP_INDEX = 1;
+ protected final BigWarpData bwData;
+
protected BigWarpViewerSettings viewerSettings;
protected BigWarpOverlay overlay;
protected BigWarpDragOverlay dragOverlay;
+ protected BigWarpMaskSphereOverlay maskOverlay;
+
protected boolean isMoving;
protected boolean updateOnDrag;
@@ -59,10 +67,6 @@ public class BigWarpViewerPanel extends ViewerPanel
protected int ndims;
- final protected int[] movingSourceIndexList;
-
- final protected int[] targetSourceIndexList;
-
protected boolean boxOverlayVisible = true;
protected boolean textOverlayVisible = true;
@@ -74,35 +78,33 @@ public class BigWarpViewerPanel extends ViewerPanel
ViewerOptions options;
- public BigWarpViewerPanel( final List< SourceAndConverter< ? > > sources, final BigWarpViewerSettings viewerSettings, final CacheControl cache, boolean isMoving,
- int[] movingSourceIndexList, int[] targetSourceIndexList )
+ @SuppressWarnings("rawtypes")
+ public BigWarpViewerPanel( final BigWarpData bwData , final BigWarpViewerSettings viewerSettings, final CacheControl cache, boolean isMoving )
{
- this( sources, viewerSettings, cache, BigWarpViewerOptions.options(), isMoving, movingSourceIndexList, targetSourceIndexList );
+ this( bwData, viewerSettings, cache, BigWarpViewerOptions.options(), isMoving );
}
- public BigWarpViewerPanel( final List< SourceAndConverter< ? > > sources, final BigWarpViewerSettings viewerSettings, final CacheControl cache, final BigWarpViewerOptions optional, boolean isMoving,
- int[] movingSourceIndexList, int[] targetSourceIndexList )
+ @SuppressWarnings("unchecked")
+ public BigWarpViewerPanel( final BigWarpData bwData, final BigWarpViewerSettings viewerSettings, final CacheControl cache, final BigWarpViewerOptions optional, boolean isMoving )
{
- super( sources, 1, cache, optional.getViewerOptions( isMoving ) );
+ // TODO compiler complains if the first argument is 'final BigWarpData bwData'
+ super( bwData.sources, 1, cache, optional.getViewerOptions( isMoving ) );
+ this.bwData = bwData;
this.viewerSettings = viewerSettings;
this.isMoving = isMoving;
this.updateOnDrag = !isMoving; // update on drag only for the fixed
// image by default
- this.movingSourceIndexList = movingSourceIndexList;
- this.targetSourceIndexList = targetSourceIndexList;
-
getDisplay().overlays().add( g -> {
if ( null != overlay ) {
overlay.setViewerState( state() );
overlay.paint( ( Graphics2D ) g );
}
if ( dragOverlay != null ) {
- //dragOverlay.setViewerState( state );
dragOverlay.paint( ( Graphics2D ) g );
}
} );
- updateGrouping();
+ //updateGrouping();
}
@Override
@@ -114,29 +116,29 @@ public ViewerOptions.Values getOptionValues()
public void precomputeRotations2d( final AffineTransform3D initialViewTransform )
{
orthoTransforms = new ArrayList<>();
- AffineTransform3D rot = new AffineTransform3D();
+ final AffineTransform3D rot = new AffineTransform3D();
rot.rotate( 2, -Math.PI / 2 );
AffineTransform3D xfm = initialViewTransform;
orthoTransforms.add( xfm );
for( int i = 1; i < 4; i++ )
{
- AffineTransform3D newXfm = xfm.copy();
+ final AffineTransform3D newXfm = xfm.copy();
newXfm.rotate( 2, -Math.PI/2);
orthoTransforms.add( newXfm );
xfm = newXfm;
}
}
- public void toggleTextOverlayVisible()
- {
- textOverlayVisible = !textOverlayVisible;
- }
-
- public void toggleBoxOverlayVisible()
- {
- boxOverlayVisible = !boxOverlayVisible;
- }
+// public void toggleTextOverlayVisible()
+// {
+// textOverlayVisible = !textOverlayVisible;
+// }
+//
+// public void toggleBoxOverlayVisible()
+// {
+// boxOverlayVisible = !boxOverlayVisible;
+// }
public void setHoveredIndex( int index )
{
@@ -154,23 +156,30 @@ public void setHoveredIndex( int index )
/**
* Makes the first group contain all the moving images and the second group
* contain all the fixed images
+ *
+ * @deprecated use {@link BigWarp#createMovingTargetGroups}
*
* @return the number sources in the moving group
*/
+ @Deprecated
public int updateGrouping()
{
final SynchronizedViewerState state = state();
synchronized ( state )
{
- // TODO: work backwards to find out whether movingSourceIndexList
- // and targetSourceIndexList are required, or whether a
- // List> can be used directly
final List< SourceAndConverter< ? > > moving = new ArrayList<>();
- for ( int i : movingSourceIndexList )
- moving.add( state.getSources().get( i ) );
final List< SourceAndConverter< ? > > target = new ArrayList<>();
- for ( int i : targetSourceIndexList )
- target.add( state.getSources().get( i ) );
+
+ int idx = 0;
+ for ( final SourceInfo sourceInfo : bwData.sourceInfos.values() )
+ {
+ if (sourceInfo.isMoving()) {
+ moving.add( state.getSources().get( idx ) );
+ } else {
+ target.add( state.getSources().get( idx ) );
+ }
+ idx++;
+ }
state.clearGroups();
@@ -202,7 +211,12 @@ public int updateGrouping()
public boolean isInFixedImageSpace()
{
- return !isMoving || ( ( WarpedSource< ? > ) ( state().getSources().get( movingSourceIndexList[ 0 ] ).getSpimSource() ) ).isTransformed();
+ if( bwData.numMovingSources() < 1 )
+ return true;
+ else
+ {
+ return !isMoving || ( ( WarpedSource< ? > ) ( ( bwData.getMovingSource( 0 )).getSpimSource() ) ).isTransformed();
+ }
}
public boolean doUpdateOnDrag()
@@ -236,10 +250,26 @@ public void addDragOverlay( BigWarpDragOverlay dragOverlay ){
this.dragOverlay = dragOverlay;
}
+ public void addOverlay( OverlayRenderer overlay )
+ {
+ super.getDisplay().overlays().add( overlay );
+ }
+
public BigWarpDragOverlay getDragOverlay(){
return dragOverlay;
}
+ public BigWarpMaskSphereOverlay getMaskOverlay()
+ {
+ return maskOverlay;
+ }
+
+ public void setMaskOverlay( final BigWarpMaskSphereOverlay maskOverlay )
+ {
+ this.maskOverlay = maskOverlay;
+ addOverlay( maskOverlay );
+ }
+
public boolean getIsMoving()
{
return isMoving;
@@ -288,7 +318,7 @@ public synchronized void rotateView2d( boolean isClockwise )
newTransform = Rotation2DHelpers.targetViewerTransform2d( transform , isClockwise );
break;
}
- catch(Exception e)
+ catch(final Exception e)
{
if( isClockwise )
transform.rotate( 2, -0.1 );
@@ -297,7 +327,7 @@ public synchronized void rotateView2d( boolean isClockwise )
}
}
- double[] qNew = new double[ 4 ];
+ final double[] qNew = new double[ 4 ];
Affine3DHelpers.extractRotation( newTransform, qNew );
setTransformAnimator( new RotationAnimator(transform, centerX, centerY, qNew, 300 ) );
}
@@ -369,12 +399,12 @@ public void drawOverlays( final Graphics g )
final boolean prefsShowTextOverlay = Prefs.showTextOverlay();
final boolean prefsShowMultibox = Prefs.showMultibox();
- Prefs.showTextOverlay( textOverlayVisible );
- Prefs.showMultibox( boxOverlayVisible );
+// Prefs.showTextOverlay( textOverlayVisible );
+// Prefs.showMultibox( boxOverlayVisible );
super.drawOverlays( g );
- // restore Prefs settings
- Prefs.showTextOverlay( prefsShowTextOverlay );
- Prefs.showMultibox( prefsShowMultibox );
+// // restore Prefs settings
+// Prefs.showTextOverlay( prefsShowTextOverlay );
+// Prefs.showMultibox( prefsShowMultibox );
}
}
diff --git a/src/main/java/bdv/viewer/BigWarpViewerSettings.java b/src/main/java/bdv/viewer/BigWarpViewerSettings.java
index 3413a7c2..99f077b3 100644
--- a/src/main/java/bdv/viewer/BigWarpViewerSettings.java
+++ b/src/main/java/bdv/viewer/BigWarpViewerSettings.java
@@ -120,8 +120,6 @@ public Boolean areLandmarksVisible(){
public void togglePointsVisible(){
displaySettings.put( KEY_SPOTS_VISIBLE,
!((Boolean)displaySettings.get( KEY_SPOTS_VISIBLE )).booleanValue());
-
- //System.out.println(((Boolean)displaySettings.get( KEY_DISPLAY_SPOT_NAMES )));
}
public void setSpotColor( Color c )
diff --git a/src/main/java/bdv/viewer/LandmarkPointMenu.java b/src/main/java/bdv/viewer/LandmarkPointMenu.java
index 8ca7b5e3..49965081 100644
--- a/src/main/java/bdv/viewer/LandmarkPointMenu.java
+++ b/src/main/java/bdv/viewer/LandmarkPointMenu.java
@@ -23,10 +23,10 @@
import java.awt.Point;
import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
+import java.util.Arrays;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
@@ -35,6 +35,7 @@
import bdv.gui.BigWarpLandmarkPanel;
import bigwarp.BigWarp;
+import bigwarp.BigWarpActions;
import bigwarp.landmarks.LandmarkTableModel;
public class LandmarkPointMenu extends JPopupMenu
@@ -43,46 +44,45 @@ public class LandmarkPointMenu extends JPopupMenu
public static final boolean MOVING = true;
public static final boolean FIXED = false;
- public static final String CLEAR_MOVING = "table clear moving";
- public static final String CLEAR_FIXED = "table clear fixed";
- public static final String CLEAR_SELECTED_MOVING = "table clear selected moving";
- public static final String CLEAR_SELECTED_FIXED = "table clear selected fixed";
-
- public static final String DELETE = "table delete";
- public static final String DELETE_SELECTED = "table delete selected ";
-
- public static final String ACTIVATE = "table activate";
- public static final String ACTIVATE_SELECTED = "table activate selected ";
+// public static final String CLEAR_MOVING = "table clear moving";
+// public static final String CLEAR_FIXED = "table clear fixed";
+// public static final String CLEAR_SELECTED_MOVING = "table clear selected moving";
+// public static final String CLEAR_SELECTED_FIXED = "table clear selected fixed";
+//
+// public static final String DELETE = "table delete";
+// public static final String DELETE_SELECTED = "table delete selected ";
+//
+// public static final String ACTIVATE_SELECTED = "table activate selected";
+// public static final String DEACTIVATE_SELECTED = "table deactivate selected ";
private static final long serialVersionUID = -3676180390835767585L;
protected BigWarpLandmarkPanel landmarkPanel;
- protected BigWarp bw;
-
-// public ClearHandler clearMoving;
-// public ClearHandler clearFixed;
+ protected BigWarp< ? > bw;
+
public ClearSelectedHandler clearSelectedMoving;
public ClearSelectedHandler clearSelectedFixed;
-// public DeleteHandler deleteHandler;
public DeleteSelectedHandler deleteSelectedHandler;
- public ActivateSelectedHandler activateAllHandler;
- public DeactivateSelectedHandler deactivateAllHandler;
-
+ public ActivateSelectedHandler activateSelectedHandler;
+ public DeactivateSelectedHandler deactivateSelectedHandler;
+
+ public AddToSelection addAboveHandler;
+ public AddToSelection addAllAboveHandler;
+ public AddToSelection addBelowHandler;
+ public AddToSelection addAllBelowHandler;
+
protected MouseListener popupListener;
-// protected JMenuItem deleteSingleItem;
protected JMenuItem deleteAllItem;
protected JMenuItem activateAllItem;
protected JMenuItem deactivateAllItem;
-// protected JMenuItem clearMovingItem;
-// protected JMenuItem clearFixedItem;
protected JMenuItem clearSelectedMovingItem;
protected JMenuItem clearSelectedFixedItem;
private Point clickPt;
- public LandmarkPointMenu( BigWarp bw )
+ public LandmarkPointMenu( BigWarp< ? > bw )
{
this( bw.getLandmarkPanel() );
this.bw = bw;
@@ -92,30 +92,23 @@ public LandmarkPointMenu( BigWarpLandmarkPanel landmarkPanel )
{
this.landmarkPanel = landmarkPanel;
-// deleteHandler = new DeleteHandler( DELETE );
- deleteSelectedHandler = new DeleteSelectedHandler( DELETE_SELECTED );
- activateAllHandler = new ActivateSelectedHandler( ACTIVATE );
- deactivateAllHandler = new DeactivateSelectedHandler( ACTIVATE_SELECTED );
+ deleteSelectedHandler = new DeleteSelectedHandler( BigWarpActions.DELETE_SELECTED );
+ activateSelectedHandler = new ActivateSelectedHandler( BigWarpActions.ACTIVATE_SELECTED );
+ deactivateSelectedHandler = new DeactivateSelectedHandler( BigWarpActions.DEACTIVATE_SELECTED );
-// clearMoving = new ClearHandler( CLEAR_MOVING, MOVING );
-// clearFixed = new ClearHandler( CLEAR_FIXED, FIXED );
- clearSelectedMoving = new ClearSelectedHandler( CLEAR_SELECTED_MOVING, MOVING );
- clearSelectedFixed = new ClearSelectedHandler( CLEAR_SELECTED_FIXED, FIXED );
+ clearSelectedMoving = new ClearSelectedHandler( BigWarpActions.CLEAR_SELECTED_MOVING, MOVING );
+ clearSelectedFixed = new ClearSelectedHandler( BigWarpActions.CLEAR_SELECTED_FIXED, FIXED );
- popupListener = new PopupListener();
+ addAboveHandler = new AddToSelection( BigWarpActions.LANDMARK_SELECT_ABOVE, true, false );
+ addAllAboveHandler = new AddToSelection( BigWarpActions.LANDMARK_SELECT_ALL_ABOVE, true, true );
+ addBelowHandler = new AddToSelection( BigWarpActions.LANDMARK_SELECT_BELOW, false, false );
+ addAllBelowHandler = new AddToSelection( BigWarpActions.LANDMARK_SELECT_ALL_BELOW, false, true );
-// deleteSingleItem = new JMenuItem( "Delete" );
-// deleteSingleItem.addActionListener( deleteHandler );
+ popupListener = new PopupListener();
deleteAllItem = new JMenuItem( "Delete" );
deleteAllItem.addActionListener( deleteSelectedHandler );
-// clearMovingItem = new JMenuItem( "Clear moving point" );
-// clearMovingItem.addActionListener( clearMoving );
-//
-// clearFixedItem = new JMenuItem( "Clear fixed point" );
-// clearFixedItem.addActionListener( clearFixed );
-
clearSelectedMovingItem = new JMenuItem( "Clear moving" );
clearSelectedMovingItem.addActionListener( clearSelectedMoving );
@@ -123,17 +116,14 @@ public LandmarkPointMenu( BigWarpLandmarkPanel landmarkPanel )
clearSelectedFixedItem.addActionListener( clearSelectedFixed );
activateAllItem = new JMenuItem( "Activate" );
- activateAllItem.addActionListener( activateAllHandler );
+ activateAllItem.addActionListener( activateSelectedHandler );
deactivateAllItem = new JMenuItem( "Deactivate" );
- deactivateAllItem.addActionListener( deactivateAllHandler );
+ deactivateAllItem.addActionListener( deactivateSelectedHandler );
-// this.add( deleteSingleItem );
this.add( deleteAllItem );
this.addSeparator();
-// this.add( clearMovingItem );
-// this.add( clearFixedItem );
this.add( clearSelectedMovingItem );
this.add( clearSelectedFixedItem );
@@ -305,7 +295,8 @@ public ActivateSelectedHandler( String name )
@Override
public void actionPerformed(ActionEvent e)
{
- int[] selectedRows = landmarkPanel.getJTable().getSelectedRows();
+ final int[] selectedRows = landmarkPanel.getJTable().getSelectedRows();
+ Arrays.sort( selectedRows );
// do in reverse order so that the index
for( int i = selectedRows.length - 1; i >= 0; i-- )
@@ -333,7 +324,8 @@ public DeactivateSelectedHandler( String name )
@Override
public void actionPerformed(ActionEvent e)
{
- int[] selectedRows = landmarkPanel.getJTable().getSelectedRows();
+ final int[] selectedRows = landmarkPanel.getJTable().getSelectedRows();
+ Arrays.sort( selectedRows );
// do in reverse order so that the index
for( int i = selectedRows.length - 1; i >= 0; i-- )
@@ -348,4 +340,48 @@ public void actionPerformed(ActionEvent e)
landmarkPanel.repaint();
}
}
+
+ public class AddToSelection extends AbstractNamedAction
+ {
+ private static final long serialVersionUID = -904756750247052099L;
+
+ private final boolean before;
+ private final boolean all;
+
+ public AddToSelection( final String name, final boolean before, final boolean all )
+ {
+ super( name );
+ this.before = before;
+ this.all = all;
+ }
+
+ @Override
+ public void actionPerformed( ActionEvent e )
+ {
+ final int[] selectedRows = landmarkPanel.getJTable().getSelectedRows();
+ if( selectedRows.length == 0 )
+ return;
+
+ Arrays.sort( selectedRows );
+
+ int i;
+ int j;
+ if ( before )
+ {
+ j = selectedRows[ 0 ];
+ i = all ? 0 : j - 1;
+ } else
+ {
+ i = selectedRows[ selectedRows.length - 1 ];
+ j = all ? landmarkPanel.getJTable().getRowCount() - 1 : i + 1;
+ }
+ landmarkPanel.getJTable().getSelectionModel().addSelectionInterval( i, j );
+
+ if ( bw != null )
+ bw.restimateTransformation();
+
+ landmarkPanel.repaint();
+ }
+ }
+
}
diff --git a/src/main/java/bdv/viewer/overlay/BigWarpMaskSphereOverlay.java b/src/main/java/bdv/viewer/overlay/BigWarpMaskSphereOverlay.java
new file mode 100644
index 00000000..0776abd7
--- /dev/null
+++ b/src/main/java/bdv/viewer/overlay/BigWarpMaskSphereOverlay.java
@@ -0,0 +1,171 @@
+package bdv.viewer.overlay;
+
+import java.awt.AlphaComposite;
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+
+import bdv.util.Affine3DHelpers;
+import bdv.viewer.BigWarpViewerPanel;
+import bdv.viewer.OverlayRenderer;
+import net.imglib2.RealLocalizable;
+import net.imglib2.RealPoint;
+import net.imglib2.realtransform.AffineTransform3D;
+
+public class BigWarpMaskSphereOverlay implements OverlayRenderer
+{
+
+ final static protected BasicStroke stroke = new BasicStroke( 1 );
+ final protected BigWarpViewerPanel viewer;
+
+ protected double[] radii;
+ protected final double[] viewerCoords;
+ protected double minWidth = 0.1;
+
+ protected final Color[] colors;
+ final protected AffineTransform3D viewerTransform;
+
+ protected double[] center;
+ protected int width, height;
+ protected boolean is3d;
+ protected boolean visible = false;
+
+ public BigWarpMaskSphereOverlay( final BigWarpViewerPanel viewer, boolean is3d )
+ {
+ this( viewer, new double[]{0,0}, new Color[]{ Color.ORANGE, Color.YELLOW }, is3d );
+ }
+
+ public BigWarpMaskSphereOverlay( final BigWarpViewerPanel viewer, final Color[] colors, boolean is3d )
+ {
+ this( viewer, new double[]{0, 0}, colors, is3d );
+ }
+
+ public BigWarpMaskSphereOverlay( final BigWarpViewerPanel viewer, final double[] radii, final Color[] colors, boolean is3d )
+ {
+ this.viewer = viewer;
+ this.radii = radii;
+ this.colors = colors;
+ viewerCoords = new double[ 3 ];
+ center = new double[ 3 ];
+ this.is3d = is3d;
+ viewerTransform = new AffineTransform3D();
+ }
+
+ public double[] getCenter()
+ {
+ return center;
+ }
+
+ public double[] getRadii()
+ {
+ return radii;
+ }
+
+ public void setCenter( final double[] center )
+ {
+ this.center = center;
+ }
+
+ public void setCenter( final RealLocalizable c )
+ {
+ c.localize( center );
+ }
+
+ public void setCenter( final RealPoint center )
+ {
+ center.localize( this.center );
+ }
+
+ public void setRadii( double[] radii )
+ {
+ this.radii = radii;
+ }
+
+ public void setInnerRadius( double inner )
+ {
+ final double del = radii[1] - radii[0];
+ radii[0] = inner;
+ radii[1] = inner + del;
+ }
+
+ public void setOuterRadiusDelta( double outerDelta )
+ {
+ radii[1] = radii[0] + outerDelta;
+ }
+
+ public void setColor( final Color color, final int i )
+ {
+ colors[ i ] = color;
+ }
+
+ public void setColors( final Color[] colors )
+ {
+ System.arraycopy( colors, 0, this.colors, 0, Math.min( colors.length, this.colors.length ) );
+ }
+
+ public void setVisible( final boolean visible )
+ {
+ this.visible = visible;
+ viewer.requestRepaint();
+ }
+
+ public void toggleVisible()
+ {
+ setVisible( !visible );
+ }
+
+ @Override
+ public void drawOverlays( final Graphics g )
+ {
+ if ( visible )
+ {
+ final Graphics2D g2d = (Graphics2D) g;
+ g2d.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
+ g2d.setComposite( AlphaComposite.SrcOver );
+
+ viewer.state().getViewerTransform( viewerTransform ); // synchronized
+ final double scale = Affine3DHelpers.extractScale( viewerTransform, 0 );
+ viewerTransform.apply( center, viewerCoords );
+
+ final double zv;
+ if( is3d )
+ zv = viewerCoords[ 2 ];
+ else
+ zv = 0;
+
+ final double dz2 = zv * zv;
+ for ( int i = 0; i < radii.length; ++i )
+ {
+ final double rad = radii[i];
+ final double scaledRadius = scale * rad;
+
+ if ( viewerCoords[0] + scaledRadius > 0 && viewerCoords[0] - scaledRadius < width &&
+ viewerCoords[1] + scaledRadius > 0 && viewerCoords[1] - scaledRadius < height )
+ {
+ final double arad;
+ if( is3d )
+ arad = Math.sqrt( scaledRadius * scaledRadius - dz2 );
+ else
+ arad = scaledRadius;
+
+ final int rarad = (int)Math.round( arad );
+
+ g2d.setColor( colors[ i ] );
+ g2d.setStroke( stroke );
+ g2d.drawOval( (int)viewerCoords[0] - rarad, (int)viewerCoords[1] - rarad,
+ (2 * rarad + 1), 2 * rarad + 1 );
+ }
+ }
+ }
+ }
+
+ @Override
+ public void setCanvasSize( final int width, final int height )
+ {
+ this.width = width;
+ this.height = height;
+ }
+
+}
diff --git a/src/main/java/bdv/viewer/overlay/BigWarpSourceOverlayRenderer.java b/src/main/java/bdv/viewer/overlay/BigWarpSourceOverlayRenderer.java
index a94157e4..8971569f 100644
--- a/src/main/java/bdv/viewer/overlay/BigWarpSourceOverlayRenderer.java
+++ b/src/main/java/bdv/viewer/overlay/BigWarpSourceOverlayRenderer.java
@@ -24,23 +24,60 @@
import java.awt.Font;
import java.awt.Graphics2D;
+import bdv.img.WarpedSource;
+import bdv.viewer.Source;
+import bdv.viewer.SourceAndConverter;
+import bdv.viewer.ViewerState;
+
public class BigWarpSourceOverlayRenderer extends SourceInfoOverlayRenderer
{
+ private boolean indicateTransformed = true;
+
+ // are any visible source in this viewer transformed
+ private boolean anyTransformed = false;
@Override
public synchronized void paint( final Graphics2D g )
{
- g.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) );
+ super.paint( g );
+ if( indicateTransformed && anyTransformed )
+ {
+ g.setFont( new Font( "Monospaced", Font.BOLD, 16 ) );
+ int tformedWidth = g.getFontMetrics().stringWidth( "TRANSFORMED" );
+ g.drawString( "TRANSFORMED",
+ ( int ) ( g.getClipBounds().getWidth() - tformedWidth ) / 2,
+ ( int ) g.getClipBounds().getHeight() - 16 );
+ }
+ }
- int actual_width = g.getFontMetrics().stringWidth( sourceName );
- g.drawString( sourceName, ( int ) g.getClipBounds().getWidth() - actual_width - 10, 12 );
+ /**
+ * Update data to show in the overlay.
+ *
+ * Checks whether any sources in this viewer are transformed in order to indicate that fact.
+ */
+ @Override
+ public synchronized void setViewerState( final ViewerState state )
+ {
+ super.setViewerState( state );
- if( !groupName.isEmpty() )
+ anyTransformed = false;
+ for( SourceAndConverter vs : state.getVisibleSources())
{
- String groupStringBracket = "[ " + groupName + " ]";
- int actual_width_group = g.getFontMetrics().stringWidth( groupStringBracket );
- g.drawString( groupStringBracket,
- ( int ) g.getClipBounds().getWidth() - actual_width - actual_width_group - 20, 12 );
+ Source< ? > src = vs.getSpimSource();
+ if( src instanceof WarpedSource )
+ {
+ WarpedSource ws = (WarpedSource)src;
+ if( ws.isTransformed() )
+ {
+ anyTransformed = true;
+ break;
+ }
+ }
}
}
+
+ public void setIndicateTransformed( final boolean indicateTransformed )
+ {
+ this.indicateTransformed = indicateTransformed;
+ }
}
diff --git a/src/main/java/bigwarp/BigWarp.java b/src/main/java/bigwarp/BigWarp.java
index 52e80812..e80ed662 100755
--- a/src/main/java/bigwarp/BigWarp.java
+++ b/src/main/java/bigwarp/BigWarp.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -21,13 +21,11 @@
*/
package bigwarp;
-import bdv.viewer.ConverterSetups;
-import bdv.viewer.DisplayMode;
-import bdv.viewer.TransformListener;
-import bdv.viewer.ViewerState;
+import bdv.TransformState;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
+import java.awt.Dimension;
import java.awt.FileDialog;
import java.awt.KeyEventPostProcessor;
import java.awt.KeyboardFocusManager;
@@ -37,14 +35,16 @@
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.io.File;
+import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URISyntaxException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -66,15 +66,14 @@
import javax.swing.Timer;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
+import javax.swing.filechooser.FileFilter;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellEditor;
-import mpicbg.spim.data.SpimData;
-import mpicbg.spim.data.XmlIoSpimData;
-import mpicbg.spim.data.registration.ViewTransformAffine;
-
import org.janelia.saalfeldlab.n5.Compression;
import org.janelia.saalfeldlab.n5.ij.N5Exporter;
+import org.janelia.utility.geom.BoundingSphereRitter;
+import org.janelia.utility.geom.Sphere;
import org.janelia.utility.ui.RepeatingReleasedEventsFixer;
import org.jdom2.Document;
import org.jdom2.Element;
@@ -83,11 +82,14 @@
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import org.scijava.ui.behaviour.io.InputTriggerConfig;
+import org.scijava.ui.behaviour.util.Actions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.formdev.flatlaf.util.UIScale;
+import com.google.gson.stream.JsonReader;
+
import bdv.BigDataViewer;
-import bdv.cache.CacheControl;
import bdv.export.ProgressWriter;
import bdv.export.ProgressWriterConsole;
import bdv.gui.BigWarpLandmarkPanel;
@@ -95,7 +97,10 @@
import bdv.gui.BigWarpViewerFrame;
import bdv.gui.BigWarpViewerOptions;
import bdv.gui.BigwarpLandmarkSelectionPanel;
+import bdv.gui.ExportDisplacementFieldFrame;
import bdv.gui.LandmarkKeyboardProcessor;
+import bdv.gui.MaskOptionsPanel;
+import bdv.gui.MaskedSourceEditorMouseListener;
import bdv.gui.TransformTypeSelectDialog;
import bdv.ij.ApplyBigwarpPlugin;
import bdv.ij.ApplyBigwarpPlugin.WriteDestinationOptions;
@@ -103,44 +108,65 @@
import bdv.ij.util.ProgressWriterIJ;
import bdv.img.WarpedSource;
import bdv.tools.InitializeViewerState;
+import bdv.tools.PreferencesDialog;
import bdv.tools.VisibilityAndGroupingDialog;
import bdv.tools.bookmarks.Bookmarks;
import bdv.tools.bookmarks.BookmarksEditor;
-import bdv.tools.brightness.BrightnessDialog;
import bdv.tools.brightness.ConverterSetup;
import bdv.tools.brightness.SetupAssignments;
+import bdv.ui.appearance.AppearanceManager;
+import bdv.ui.appearance.AppearanceSettingsPage;
+import bdv.ui.keymap.Keymap;
+import bdv.ui.keymap.KeymapSettingsPage;
+import bdv.util.BoundedRange;
import bdv.util.Bounds;
+import bdv.viewer.AbstractViewerPanel.AlignPlane;
import bdv.viewer.BigWarpDragOverlay;
import bdv.viewer.BigWarpLandmarkFrame;
import bdv.viewer.BigWarpOverlay;
import bdv.viewer.BigWarpViewerPanel;
import bdv.viewer.BigWarpViewerSettings;
+import bdv.viewer.ConverterSetups;
+import bdv.viewer.DisplayMode;
import bdv.viewer.Interpolation;
import bdv.viewer.LandmarkPointMenu;
import bdv.viewer.MultiBoxOverlay2d;
import bdv.viewer.Source;
import bdv.viewer.SourceAndConverter;
+import bdv.viewer.SourceGroup;
import bdv.viewer.SynchronizedViewerState;
+import bdv.viewer.TransformListener;
import bdv.viewer.ViewerPanel;
-import bdv.viewer.VisibilityAndGrouping;
+import bdv.viewer.ViewerState;
import bdv.viewer.WarpNavigationActions;
import bdv.viewer.animate.SimilarityModel3D;
import bdv.viewer.animate.TranslationAnimator;
+import bdv.viewer.overlay.BigWarpMaskSphereOverlay;
import bdv.viewer.overlay.BigWarpSourceOverlayRenderer;
import bdv.viewer.overlay.MultiBoxOverlayRenderer;
import bigwarp.landmarks.LandmarkTableModel;
-import bigwarp.loader.ImagePlusLoader;
-import bigwarp.loader.ImagePlusLoader.ColorSettings;
import bigwarp.source.GridSource;
import bigwarp.source.JacobianDeterminantSource;
+import bigwarp.source.PlateauSphericalMaskRealRandomAccessible;
+import bigwarp.source.PlateauSphericalMaskRealRandomAccessible.FalloffShape;
+import bigwarp.source.PlateauSphericalMaskSource;
+import bigwarp.source.SourceInfo;
import bigwarp.source.WarpMagnitudeSource;
+import bigwarp.transforms.AbstractTransformSolver;
import bigwarp.transforms.BigWarpTransform;
+import bigwarp.transforms.MaskedSimRotTransformSolver;
import bigwarp.transforms.WrappedCoordinateTransform;
+import bigwarp.transforms.io.TransformWriterJson;
+import bigwarp.ui.keymap.KeymapManager;
+import bigwarp.ui.keymap.NavigationKeys;
import bigwarp.util.BigWarpUtils;
+import dev.dirs.ProjectDirectories;
import fiji.util.gui.GenericDialogPlus;
import ij.IJ;
import ij.ImageJ;
import ij.ImagePlus;
+
+import java.util.LinkedHashMap;
import jitk.spline.ThinPlateR2LogRSplineKernelTransform;
import jitk.spline.XfmUtils;
import mpicbg.models.AbstractModel;
@@ -155,7 +181,10 @@
import mpicbg.models.SimilarityModel2D;
import mpicbg.models.TranslationModel2D;
import mpicbg.models.TranslationModel3D;
+import mpicbg.spim.data.SpimData;
import mpicbg.spim.data.SpimDataException;
+import mpicbg.spim.data.XmlIoSpimData;
+import mpicbg.spim.data.registration.ViewTransformAffine;
import net.imglib2.Interval;
import net.imglib2.RandomAccessibleInterval;
import net.imglib2.RealPoint;
@@ -163,18 +192,23 @@
import net.imglib2.realtransform.AffineTransform3D;
import net.imglib2.realtransform.BoundingBoxEstimation;
import net.imglib2.realtransform.InvertibleRealTransform;
+import net.imglib2.realtransform.InvertibleWrapped2DTransformAs3D;
+import net.imglib2.realtransform.RealTransform;
import net.imglib2.realtransform.ThinplateSplineTransform;
-import net.imglib2.realtransform.Wrapped2DTransformAs3D;
+import net.imglib2.realtransform.inverse.RealTransformFiniteDerivatives;
import net.imglib2.realtransform.inverse.WrappedIterativeInvertibleRealTransform;
import net.imglib2.type.numeric.ARGBType;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.real.DoubleType;
import net.imglib2.type.numeric.real.FloatType;
public class BigWarp< T >
{
+ public static String configDir = ProjectDirectories.from( "sc", "fiji", "bigwarp" ).configDir;
- protected static final int DEFAULT_WIDTH = 600;
+ protected static final int DEFAULT_WIDTH = 400;
- protected static final int DEFAULT_HEIGHT = 400;
+ protected static final int DEFAULT_HEIGHT = 300;
public static final int GRID_SOURCE_ID = 1696993146;
@@ -182,34 +216,32 @@ public class BigWarp< T >
public static final int JACDET_SOURCE_ID = 1006827158;
+ public static final int TRANSFORM_MASK_SOURCE_ID = 33872301;
+
protected BigWarpViewerOptions options;
protected BigWarpData< T > data;
- // descriptive names for indexing sources
- protected int[] movingSourceIndexList;
-
- protected int[] targetSourceIndexList;
-
- protected List< SourceAndConverter< T > > sources;
-
protected final SetupAssignments setupAssignments;
-
- protected final BrightnessDialog brightnessDialog;
-
protected final WarpVisFrame warpVisDialog;
protected final HelpDialog helpDialog;
+ private final KeymapManager keymapManager;
+
+ private final AppearanceManager appearanceManager;
+
protected final SourceInfoDialog sourceInfoDialog;
protected final VisibilityAndGroupingDialog activeSourcesDialogP;
protected final VisibilityAndGroupingDialog activeSourcesDialogQ;
+ protected final PreferencesDialog preferencesDialog;
+
final AffineTransform3D fixedViewXfm;
- private final Bookmarks bookmarks;
+ private Bookmarks bookmarks;
protected final BookmarksEditor bookmarkEditorP;
@@ -223,9 +255,9 @@ public class BigWarp< T >
protected final BigWarpViewerPanel viewerQ;
- protected final AffineTransform3D initialViewP;
+ protected AffineTransform3D initialViewP;
- protected final AffineTransform3D initialViewQ;
+ protected AffineTransform3D initialViewQ;
private JMenuItem toggleAlwaysWarpMenuP;
@@ -235,7 +267,7 @@ public class BigWarp< T >
protected final LandmarkPointMenu landmarkPopupMenu;
- protected final BigWarpLandmarkFrame landmarkFrame;
+ protected BigWarpLandmarkFrame landmarkFrame;
protected final BigWarpViewerSettings viewerSettings;
@@ -263,17 +295,27 @@ public class BigWarp< T >
protected MouseLandmarkTableListener landmarkTableListener;
+ protected MaskedSourceEditorMouseListener maskSourceMouseListenerP;
+
+ protected MaskedSourceEditorMouseListener maskSourceMouseListenerQ;
+
protected BigWarpMessageAnimator message;
protected final Set< KeyEventPostProcessor > keyEventPostProcessorSet = new HashSet< KeyEventPostProcessor >();
private final RepeatingReleasedEventsFixer repeatedKeyEventsFixer;
- protected final SourceAndConverter< FloatType > gridSource;
+ protected GridSource gridSource;
- protected final SourceAndConverter< FloatType > warpMagSource;
+ protected WarpMagnitudeSource warpMagSource;
- protected final SourceAndConverter< FloatType > jacDetSource;
+ protected JacobianDeterminantSource jacDetSource;
+
+ protected SourceAndConverter< ? extends RealType> transformMaskSource;
+
+ protected Source< ? extends RealType> transformMask;
+
+ protected PlateauSphericalMaskSource plateauTransformMask;
protected final AbstractModel< ? >[] baseXfmList;
@@ -283,10 +325,12 @@ public class BigWarp< T >
private BigWarpTransform bwTransform;
+ protected SourceGroup mvgGrp, tgtGrp;
+
private BoundingBoxEstimation bboxOptions;
private long keyClickMaxLength = 250;
-
+
protected TransformTypeSelectDialog transformSelector;
protected AffineTransform3D tmpTransform = new AffineTransform3D();
@@ -300,9 +344,11 @@ public class BigWarp< T >
protected int baselineModelIndex;
// file selection
- final JFrame fileFrame;
+ protected JFrame fileFrame;
- final FileDialog fileDialog;
+ protected FileDialog fileDialog;
+
+ final JFileChooser fileChooser;
protected File autoSaveDirectory;
@@ -324,21 +370,42 @@ public class BigWarp< T >
protected static Logger logger = LoggerFactory.getLogger( BigWarp.class );
+ //TODO Caleb: John, can this be replaced by info from BigWarpData/SourceInfo url?
private SpimData movingSpimData;
private File movingImageXml;
private CopyOnWriteArrayList< TransformListener< InvertibleRealTransform > > transformListeners = new CopyOnWriteArrayList<>( );
- final int ndims;
+ int ndims;
- public BigWarp( final BigWarpData data, final String windowTitle, final ProgressWriter progressWriter ) throws SpimDataException
+ @Deprecated
+ public BigWarp( final BigWarpData< T > data, final String windowTitle, final ProgressWriter progressWriter ) throws SpimDataException
{
- this( data, windowTitle, BigWarpViewerOptions.options().is2D( detectNumDims( data.sources ) == 2 ), progressWriter );
+ this( data, BigWarpViewerOptions.options().is2D( detectNumDims( data.sources ) == 2 ), progressWriter );
}
- public BigWarp( final BigWarpData data, final String windowTitle, BigWarpViewerOptions options, final ProgressWriter progressWriter ) throws SpimDataException
+ @Deprecated
+ public BigWarp( final BigWarpData< T > data, final String windowTitle, BigWarpViewerOptions options, final ProgressWriter progressWriter ) throws SpimDataException {
+ this(data, options, progressWriter );
+ }
+
+ public BigWarp( final BigWarpData< T > data, final ProgressWriter progressWriter ) throws SpimDataException {
+ this( data, BigWarpViewerOptions.options().is2D( detectNumDims( data.sources ) == 2 ), progressWriter );
+ }
+
+ public BigWarp( final BigWarpData data, BigWarpViewerOptions options, final ProgressWriter progressWriter ) throws SpimDataException
{
+ final KeymapManager optionsKeymapManager = options.getValues().getKeymapManager();
+ final AppearanceManager optionsAppearanceManager = options.values.getAppearanceManager();
+ keymapManager = optionsKeymapManager != null ? optionsKeymapManager : new KeymapManager( configDir );
+ appearanceManager = optionsAppearanceManager != null ? optionsAppearanceManager : new AppearanceManager( configDir );
+
+ InputTriggerConfig inputTriggerConfig = options.values.getInputTriggerConfig();
+ final Keymap keymap = this.keymapManager.getForwardSelectedKeymap();
+ if ( inputTriggerConfig == null )
+ inputTriggerConfig = keymap.getConfig();
+
repeatedKeyEventsFixer = RepeatingReleasedEventsFixer.installAnyTime();
ij = IJ.getInstance();
@@ -361,58 +428,34 @@ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpVie
* Set up LandmarkTableModel, holds the data and interfaces with the
* LandmarkPanel
*/
- landmarkModel = new LandmarkTableModel( ndims );
- landmarkModellistener = new LandmarkTableListener();
- landmarkModel.addTableModelListener( landmarkModellistener );
- addTransformListener( landmarkModel );
/* Set up landmark panel */
- landmarkPanel = new BigWarpLandmarkPanel( landmarkModel );
- landmarkPanel.setOpaque( true );
- landmarkTable = landmarkPanel.getJTable();
- landmarkTable.setDefaultRenderer( Object.class, new WarningTableCellRenderer() );
- addDefaultTableMouseListener();
-
- landmarkFrame = new BigWarpLandmarkFrame( "Landmarks", landmarkPanel, this );
+ setupLandmarkFrame();
baseXfmList = new AbstractModel< ? >[ 3 ];
setupWarpMagBaselineOptions( baseXfmList, ndims );
fixedViewXfm = new AffineTransform3D();
- //sources.get( targetSourceIndexList[ 0 ] ).getSpimSource().getSourceTransform( 0, 0, fixedViewXfm );
- data.sources.get( data.targetSourceIndices[ 0 ] ).getSpimSource().getSourceTransform( 0, 0, fixedViewXfm );
-
- baselineModelIndex = 0;
- warpMagSource = addWarpMagnitudeSource( data, ndims == 2, "WarpMagnitudeSource" );
- jacDetSource = addJacobianDeterminantSource( data, "JacobianDeterminantSource" );
- gridSource = addGridSource( data, "GridSource" );
-
- this.sources = this.data.sources;
- final List< ConverterSetup > converterSetups = data.converterSetups;
- this.movingSourceIndexList = data.movingSourceIndices;
- this.targetSourceIndexList = data.targetSourceIndices;
- Arrays.sort( movingSourceIndexList );
- Arrays.sort( targetSourceIndexList );
-
- sources = wrapSourcesAsTransformed( data.sources, ndims, data );
-
- setGridType( GridSource.GRID_TYPE.LINE );
-
viewerSettings = new BigWarpViewerSettings();
// key properties
final InputTriggerConfig keyProperties = BigDataViewer.getInputTriggerConfig( options );
options = options.inputTriggerConfig( keyProperties );
+ final int width = UIScale.scale( DEFAULT_WIDTH );
+ final int height = UIScale.scale( DEFAULT_HEIGHT );
+
+ final List> srcs = (List)data.sources;
+
// Viewer frame for the moving image
- viewerFrameP = new BigWarpViewerFrame( this, DEFAULT_WIDTH, DEFAULT_HEIGHT, (List)sources, converterSetups, viewerSettings,
- data.cache, options, "Bigwarp moving image", true, movingSourceIndexList, targetSourceIndexList );
+ viewerFrameP = new BigWarpViewerFrame(this, width, height, srcs, data.converterSetups,
+ viewerSettings, data.cache, keymapManager, appearanceManager, options, "BigWarp moving image", true);
viewerP = getViewerFrameP().getViewerPanel();
// Viewer frame for the fixed image
- viewerFrameQ = new BigWarpViewerFrame( this, DEFAULT_WIDTH, DEFAULT_HEIGHT, (List)sources, converterSetups, viewerSettings,
- data.cache, options, "Bigwarp fixed image", false, movingSourceIndexList, targetSourceIndexList );
+ viewerFrameQ = new BigWarpViewerFrame(this, width, height, srcs, data.converterSetups,
+ viewerSettings, data.cache, keymapManager, appearanceManager, options, "BigWarp fixed image", false);
viewerQ = getViewerFrameQ().getViewerPanel();
@@ -434,7 +477,7 @@ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpVie
final MultiBoxOverlayRenderer overlayRenderP = new MultiBoxOverlayRenderer( DEFAULT_WIDTH, DEFAULT_HEIGHT );
final MultiBoxOverlayRenderer overlayRenderQ = new MultiBoxOverlayRenderer( DEFAULT_WIDTH, DEFAULT_HEIGHT );
-
+
// TODO hopefully I won't' need reflection any more
final Field boxField = overlayRenderP.getClass().getDeclaredField( "box" );
boxField.setAccessible( true );
@@ -476,22 +519,6 @@ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpVie
activeSourcesDialogQ = new VisibilityAndGroupingDialog( viewerFrameQ, viewerQ.getVisibilityAndGrouping() );
activeSourcesDialogQ.setTitle( "visibility and grouping ( fixed )" );
- final ARGBType white = new ARGBType( ARGBType.rgba( 255, 255, 255, 255 ));
- // set warp mag source to inactive at the start
- viewerP.state().setSourceActive( warpMagSource, false );
- viewerQ.state().setSourceActive( warpMagSource, false );
- data.sourceColorSettings.put( warpMagSource, new ImagePlusLoader.ColorSettings( -1, 0, 15, white ));
-
- // set warp grid source to inactive at the start
- viewerP.state().setSourceActive( gridSource, false );
- viewerQ.state().setSourceActive( gridSource, false );
- data.sourceColorSettings.put( gridSource, new ImagePlusLoader.ColorSettings( -1, 0, 255, white ));
-
- // set jacobian determinant source to inactive at the start
- viewerP.state().setSourceActive( jacDetSource, false );
- viewerQ.state().setSourceActive( jacDetSource, false );
- data.sourceColorSettings.put( jacDetSource, new ImagePlusLoader.ColorSettings( -1, 0.0, 1.0, white ));
-
overlayP = new BigWarpOverlay( viewerP, landmarkPanel );
overlayQ = new BigWarpOverlay( viewerQ, landmarkPanel );
viewerP.addOverlay( overlayP );
@@ -504,7 +531,6 @@ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpVie
solverThread.start();
bboxOptions = new BoundingBoxEstimation( BoundingBoxEstimation.Method.FACES, 5 );
- updateSourceBoundingBoxEstimators();
dragOverlayP = new BigWarpDragOverlay( this, viewerP, solverThread );
dragOverlayQ = new BigWarpDragOverlay( this, viewerQ, solverThread );
@@ -514,24 +540,76 @@ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpVie
landmarkPopupMenu = new LandmarkPointMenu( this );
landmarkPopupMenu.setupListeners();
- setupAssignments = new SetupAssignments( new ArrayList<>( converterSetups ), 0, 65535 );
+ setupAssignments = new SetupAssignments( new ArrayList<>( data.converterSetups ), 0, 65535 );
- brightnessDialog = new BrightnessDialog( landmarkFrame, setupAssignments );
helpDialog = new HelpDialog( landmarkFrame );
sourceInfoDialog = new SourceInfoDialog( landmarkFrame, data );
transformSelector = new TransformTypeSelectDialog( landmarkFrame, this );
// dialogs have to be constructed before action maps are made
- warpVisDialog = new WarpVisFrame( viewerFrameQ, this );
+ warpVisDialog = new WarpVisFrame( viewerFrameQ, this );
+// warpVisDialog.maskOptionsPanel.setMask( transformMask );
- WarpNavigationActions.installActionBindings( getViewerFrameP().getKeybindings(), viewerFrameP, keyProperties, ( ndims == 2 ) );
- BigWarpActions.installActionBindings( getViewerFrameP().getKeybindings(), this, keyProperties );
+ preferencesDialog = new PreferencesDialog( landmarkFrame, keymap, new String[] { "bigwarp", "navigation", "bw-table" } );
+ preferencesDialog.addPage( new AppearanceSettingsPage( "Appearance", appearanceManager ) );
+ preferencesDialog.addPage( new KeymapSettingsPage( "Keymap", this.keymapManager, new KeymapManager(), this.keymapManager.getCommandDescriptions() ) );
- WarpNavigationActions.installActionBindings( getViewerFrameQ().getKeybindings(), viewerFrameQ, keyProperties, ( ndims == 2 ) );
- BigWarpActions.installActionBindings( getViewerFrameQ().getKeybindings(), this, keyProperties );
+ fileChooser = new JFileChooser();
+ fileChooser.setFileFilter( new FileFilter()
+ {
+ @Override
+ public String getDescription()
+ {
+ return "xml files";
+ }
- BigWarpActions.installLandmarkPanelActionBindings( landmarkFrame.getKeybindings(), this, landmarkTable, keyProperties );
+ @Override
+ public boolean accept( final File f )
+ {
+ if ( f.isDirectory() )
+ return true;
+ if ( f.isFile() )
+ {
+ final String s = f.getName();
+ final int i = s.lastIndexOf( '.' );
+ if ( i > 0 && i < s.length() - 1 )
+ {
+ final String ext = s.substring( i + 1 ).toLowerCase();
+ return ext.equals( "xml" );
+ }
+ }
+ return false;
+ }
+ } );
+
+ appearanceManager.appearance().updateListeners().add( viewerFrameP::repaint );
+ appearanceManager.appearance().updateListeners().add( viewerFrameQ::repaint );
+ appearanceManager.appearance().updateListeners().add( landmarkFrame::repaint );
+ appearanceManager.addLafComponent( fileChooser );
+ SwingUtilities.invokeLater(() -> appearanceManager.updateLookAndFeel());
+
+ final Actions navigationActions = new Actions( inputTriggerConfig, "navigation" );
+ navigationActions.install( getViewerFrameP().getKeybindings(), "navigation" );
+ NavigationKeys.install( navigationActions, getViewerFrameP().getViewerPanel(), options.values.is2D() );
+ navigationActions.install( getViewerFrameQ().getKeybindings(), "navigation" );
+ NavigationKeys.install( navigationActions, getViewerFrameQ().getViewerPanel(), options.values.is2D() );
+
+ final BigWarpActions bwActions = new BigWarpActions( inputTriggerConfig, "bigwarp" );
+ BigWarpActions.installViewerActions( bwActions, getViewerFrameP(), this );
+ BigWarpActions.installViewerActions( bwActions, getViewerFrameQ(), this );
+ final BigWarpActions tableActions = new BigWarpActions( inputTriggerConfig, "bw-table" );
+ BigWarpActions.installTableActions( tableActions, getLandmarkFrame().getKeybindings(), this );
+// UnmappedNavigationActions.install( tableActions, options.values.is2D() );
+
+ keymap.updateListeners().add( () -> {
+
+ bwActions.updateKeyConfig( keymap.getConfig() );
+ tableActions.updateKeyConfig( keymap.getConfig() );
+
+ viewerFrameP.getTransformBehaviours().updateKeyConfig( keymap.getConfig() );
+ viewerFrameQ.getTransformBehaviours().updateKeyConfig( keymap.getConfig() );
+ } );
// this call has to come after the actions are set
warpVisDialog.setActions();
@@ -542,11 +620,11 @@ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpVie
setUpLandmarkMenus();
/* Set the locations of frames */
- final Point viewerFramePloc = getViewerFrameP().getLocation();
- viewerFramePloc.setLocation( viewerFramePloc.x + DEFAULT_WIDTH, viewerFramePloc.y );
- getViewerFrameQ().setLocation( viewerFramePloc );
- viewerFramePloc.setLocation( viewerFramePloc.x + DEFAULT_WIDTH, viewerFramePloc.y );
- landmarkFrame.setLocation( viewerFramePloc );
+ viewerFrameP.setLocation( 0, 0 );
+ viewerFrameP.setSize( width, height );
+ viewerFrameQ.setLocation( width, 0 );
+ viewerFrameQ.setSize( width, height );
+ landmarkFrame.setLocation( 2 * width, 0 );
landmarkClickListenerP = new MouseLandmarkListener( this.viewerP );
landmarkClickListenerQ = new MouseLandmarkListener( this.viewerQ );
@@ -562,40 +640,13 @@ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpVie
viewerP.state().getViewerTransform( initialViewP );
viewerQ.state().getViewerTransform( initialViewQ );
- viewerFrameP.setVisible( true );
- viewerFrameQ.setVisible( true );
-
- landmarkFrame.pack();
- landmarkFrame.setVisible( true );
-
- SwingUtilities.invokeLater( new Runnable()
- {
- public void run()
- {
- data.transferChannelSettings( viewerFrameP );
- data.transferChannelSettings( viewerFrameQ );
-
- }
- } );
-
- // set initial transforms so data are visible
- InitializeViewerState.initTransform( viewerP );
- InitializeViewerState.initTransform( viewerQ );
-
checkBoxInputMaps();
- // file selection
- fileFrame = new JFrame( "Select File" );
- fileDialog = new FileDialog( fileFrame );
-
if ( ij == null || (IJ.getDirectory( "current" ) == null) )
lastDirectory = new File( System.getProperty( "user.home" ));
else
lastDirectory = new File( IJ.getDirectory( "current" ));
- // default to linear interpolation
- fileFrame.setVisible( false );
-
// add focus listener
//new BigwarpFocusListener( this );
@@ -605,6 +656,324 @@ public void run()
// add landmark mode listener
//addKeyEventPostProcessor( new LandmarkModeListener() );
+
+ baselineModelIndex = 0;
+
+ if( data.sources.size() > 0 )
+ initialize();
+
+ createMovingTargetGroups();
+ viewerP.state().setCurrentGroup( mvgGrp );
+ viewerP.state().setCurrentGroup( tgtGrp );
+
+ SwingUtilities.invokeLater( () -> {
+ viewerFrameP.setVisible( true );
+ viewerFrameQ.setVisible( true );
+ landmarkFrame.setVisible( true );
+
+ fileFrame = new JFrame( "Select File" );
+ fileDialog = new FileDialog( fileFrame );
+ fileFrame.setVisible( false );
+ });
+ }
+
+ public void changeDimensionality(boolean is2D) {
+
+ if (options.values.is2D() == is2D)
+ return;
+
+ options.is2D( is2D );
+ if( options.values.is2D() )
+ ndims = 2;
+ else
+ ndims = 3;
+
+ /* update landmark model with new dimensionality */
+ landmarkModel = new LandmarkTableModel( ndims );
+ landmarkModel.addTableModelListener( landmarkModellistener );
+ addTransformListener( landmarkModel );
+ landmarkModel.setMessage( message );
+
+ landmarkPanel.setTableModel(landmarkModel);
+ setupLandmarkFrame();
+
+ setupWarpMagBaselineOptions( baseXfmList, ndims );
+
+ final Class< ViewerPanel > c_vp = ViewerPanel.class;
+ try
+ {
+ final Field transformEventHandlerField = c_vp.getDeclaredField( "transformEventHandler" );
+ transformEventHandlerField.setAccessible( true );
+ transformEventHandlerField.set( viewerP, options.values.getTransformEventHandlerFactory().create( TransformState.from( viewerP.state()::getViewerTransform, viewerP.state()::setViewerTransform ) ) );
+ transformEventHandlerField.set( viewerQ, options.values.getTransformEventHandlerFactory().create( TransformState.from( viewerQ.state()::getViewerTransform, viewerQ.state()::setViewerTransform ) ) );
+ transformEventHandlerField.setAccessible( false );
+ }
+ catch ( final Exception e )
+ {
+ e.printStackTrace();
+ }
+
+ viewerFrameP.updateTransformBehaviors( options );
+ viewerFrameQ.updateTransformBehaviors( options );
+
+ // If the images are 2d, use a transform handler that limits
+ // transformations to rotations and scalings of the 2d plane ( z = 0 )
+ if ( options.values.is2D() )
+ {
+
+ // final Class< ViewerPanel > c_vp = ViewerPanel.class;
+ try
+ {
+ final Field overlayRendererField = c_vp.getDeclaredField( "multiBoxOverlayRenderer" );
+ overlayRendererField.setAccessible( true );
+
+ final MultiBoxOverlayRenderer overlayRenderP = new MultiBoxOverlayRenderer( DEFAULT_WIDTH, DEFAULT_HEIGHT );
+ final MultiBoxOverlayRenderer overlayRenderQ = new MultiBoxOverlayRenderer( DEFAULT_WIDTH, DEFAULT_HEIGHT );
+
+ // TODO hopefully I won't' need reflection any more
+ final Field boxField = overlayRenderP.getClass().getDeclaredField( "box" );
+ boxField.setAccessible( true );
+ boxField.set( overlayRenderP, new MultiBoxOverlay2d() );
+ boxField.set( overlayRenderQ, new MultiBoxOverlay2d() );
+ boxField.setAccessible( false );
+
+ overlayRendererField.set( viewerP, overlayRenderP );
+ overlayRendererField.set( viewerQ, overlayRenderQ );
+ overlayRendererField.setAccessible( false );
+
+ }
+ catch ( final Exception e )
+ {
+ e.printStackTrace();
+ }
+ }
+
+ viewerP.setNumDim( ndims );
+ viewerQ.setNumDim( ndims );
+
+// overlayP.is2D( options.values.is2D() );
+// overlayQ.is2D( options.values.is2D() );
+
+ bwTransform = new BigWarpTransform( landmarkModel );
+ bwTransform.initializeInverseParameters(data);
+
+ transformSelector = new TransformTypeSelectDialog( landmarkFrame, this );
+
+ final InputTriggerConfig keyProperties = BigDataViewer.getInputTriggerConfig( options );
+ WarpNavigationActions.installActionBindings( getViewerFrameP().getKeybindings(), viewerFrameP, keyProperties, ( ndims == 2 ) );
+ BigWarpActions.installActionBindings( getViewerFrameP().getKeybindings(), this, keyProperties );
+
+ WarpNavigationActions.installActionBindings( getViewerFrameQ().getKeybindings(), viewerFrameQ, keyProperties, ( ndims == 2 ) );
+ BigWarpActions.installActionBindings( getViewerFrameQ().getKeybindings(), this, keyProperties );
+
+ BigWarpActions.installLandmarkPanelActionBindings( landmarkFrame.getKeybindings(), this, landmarkTable, keyProperties );
+
+ warpVisDialog.toleranceSpinner.setValue( bwTransform.getInverseTolerance() );
+
+ SwingUtilities.invokeLater( () -> {
+ landmarkFrame.setVisible( true );
+ });
+ }
+
+ public void initialize()
+ {
+ wrapMovingSources( ndims, data );
+
+ // starting view
+ if( data.numTargetSources() > 0 )
+ data.getTargetSource( 0 ).getSpimSource().getSourceTransform( 0, 0, fixedViewXfm );
+
+//TODO Expose adding these sources via UI
+
+// final ARGBType white = new ARGBType( ARGBType.rgba( 255, 255, 255, 255 ));
+//
+// warpMagSource = addWarpMagnitudeSource( data, ndims == 2, "Warp magnitude" );
+// jacDetSource = addJacobianDeterminantSource( data, "Jacobian determinant" );
+// gridSource = addGridSource( data, "GridSource" );
+// setGridType( GridSource.GRID_TYPE.LINE );
+//
+// transformMaskSource = addTransformMaskSource( data, ndims, "Transform mask" );
+// bwTransform.setLambda( transformMask.getRandomAccessible() );
+// addMaskMouseListener();
+//
+// // set warp mag source to inactive at the start
+// viewerP.state().setSourceActive( warpMagSource, false );
+// viewerQ.state().setSourceActive( warpMagSource, false );
+// data.sourceColorSettings.put( warpMagSource, new ImagePlusLoader.ColorSettings( -1, 0, 15, white ));
+//
+// // set warp grid source to inactive at the start
+// viewerP.state().setSourceActive( gridSource, false );
+// viewerQ.state().setSourceActive( gridSource, false );
+// data.sourceColorSettings.put( gridSource, new ImagePlusLoader.ColorSettings( -1, 0, 255, white ));
+
+ // set jacobian determinant source to inactive at the start
+// viewerP.state().setSourceActive( jacDetSource, false );
+// viewerQ.state().setSourceActive( jacDetSource, false );
+// data.sourceColorSettings.put( jacDetSource, new ImagePlusLoader.ColorSettings( -1, 0.0, 1.0, white ));
+
+ synchronizeSources();
+
+ data.transferChannelSettings( viewerFrameP );
+ data.transferChannelSettings( viewerFrameQ );
+
+ updateSourceBoundingBoxEstimators();
+
+ createMovingTargetGroups();
+ viewerP.state().setCurrentGroup( mvgGrp );
+ viewerP.state().setCurrentGroup( tgtGrp );
+
+ // set initial transforms so data are visible
+// SwingUtilities.invokeLater( () -> {
+
+ // show moving sources in the moving viewer
+ if( data.numMovingSources() == 1 )
+ viewerP.state().setCurrentSource( data.getMovingSource( 0 ) );
+ else
+ {
+ viewerP.state().setDisplayMode( DisplayMode.GROUP );
+ viewerP.state().setCurrentGroup( mvgGrp );
+ }
+
+ // show fixed sources in the fixed viewer
+ if( data.numTargetSources() == 1 )
+ viewerQ.state().setCurrentSource( data.getTargetSource( 0 ) );
+ else
+ {
+ viewerQ.state().setDisplayMode( DisplayMode.GROUP );
+ viewerQ.state().setCurrentGroup( tgtGrp );
+ }
+
+ InitializeViewerState.initTransform( viewerP );
+ InitializeViewerState.initTransform( viewerQ );
+
+ // save the initial viewer transforms
+ initialViewP = new AffineTransform3D();
+ initialViewQ = new AffineTransform3D();
+ viewerP.state().getViewerTransform( initialViewP );
+ viewerQ.state().getViewerTransform( initialViewQ );
+// } );
+ }
+
+ protected void setupLandmarkFrame()
+ {
+ Point loc = null;
+ Dimension sz = null;
+ if ( landmarkFrame != null )
+ {
+ loc = landmarkFrame.getLocation();
+ sz = landmarkFrame.getSize();
+
+ landmarkModel = null;
+ landmarkFrame.setVisible( false );
+ landmarkFrame.dispose();
+ landmarkFrame = null;
+ landmarkPanel = null;
+
+ }
+
+ landmarkModel = new LandmarkTableModel( ndims );
+ landmarkModellistener = new LandmarkTableListener();
+ landmarkModel.addTableModelListener( landmarkModellistener );
+ addTransformListener( landmarkModel );
+
+ /* Set up landmark panel */
+ landmarkPanel = new BigWarpLandmarkPanel( landmarkModel );
+ landmarkPanel.setOpaque( true );
+ landmarkTable = landmarkPanel.getJTable();
+ landmarkTable.setDefaultRenderer( Object.class, new WarningTableCellRenderer() );
+ addDefaultTableMouseListener();
+ landmarkFrame = new BigWarpLandmarkFrame( "Landmarks", landmarkPanel, this, keymapManager );
+
+ if( overlayP != null )
+ overlayP.setLandmarkPanel(landmarkPanel);
+
+ if( overlayQ != null )
+ overlayQ.setLandmarkPanel(landmarkPanel);
+
+ if ( loc != null )
+ landmarkFrame.setLocation( loc );
+
+ if ( sz != null )
+ landmarkFrame.setSize( sz );
+
+ SwingUtilities.invokeLater( () -> {
+ setUpLandmarkMenus();
+ landmarkFrame.pack();
+ });
+ }
+
+ public void synchronizeSources()
+ {
+ final SynchronizedViewerState pState = viewerP.state();
+ final SynchronizedViewerState qState = viewerQ.state();
+
+ final Set> activeSourcesP = new HashSet<>(pState.getActiveSources());
+ final Set> activeSourcesQ = new HashSet<>(qState.getActiveSources());
+
+ pState.clearSources();
+ qState.clearSources();
+
+ final ArrayList converterSetupsToRemove = new ArrayList<>(setupAssignments.getConverterSetups());
+ converterSetupsToRemove.forEach( setupAssignments::removeSetup );
+
+ for ( int i = 0; i < data.sources.size(); i++ )
+ {
+ final SourceAndConverter< T > sac = data.sources.get( i );
+ pState.addSource( sac );
+ if (activeSourcesP.contains(sac)) {
+ pState.setSourceActive(sac, true);
+ }
+ qState.addSource( sac );
+ if (activeSourcesQ.contains(sac)) {
+ qState.setSourceActive(sac, true);
+ }
+
+ // update the viewer converter setups too
+ final ConverterSetup setup = data.converterSetups.get( i );
+
+ viewerFrameP.getConverterSetups().put( sac, setup );
+ viewerFrameQ.getConverterSetups().put( sac, setup );
+ setupAssignments.addSetup( setup );
+ }
+ }
+
+ /**
+ * Create two source groups - one for moving images,
+ * and the other for target images, for both viewer frames.
+ *
+ * Ensure sources are synchronized with {@link #synchronizeSources()}
+ * before calling this method.
+ */
+ public void createMovingTargetGroups()
+ {
+ mvgGrp = new SourceGroup();
+ tgtGrp = new SourceGroup();
+
+ final SynchronizedViewerState pState = viewerP.state();
+ pState.addGroup( mvgGrp );
+ pState.addGroup( tgtGrp );
+ pState.setGroupName( mvgGrp, "moving images" );
+ pState.setGroupName( tgtGrp, "target images" );
+
+ final SynchronizedViewerState qState = viewerQ.state();
+ qState.addGroup( mvgGrp );
+ qState.addGroup( tgtGrp );
+ qState.setGroupName( mvgGrp, "moving images" );
+ qState.setGroupName( tgtGrp, "target images" );
+
+ for ( final SourceAndConverter< ? > sac : data.sources )
+ {
+ if ( data.isMoving( sac ) )
+ {
+ viewerP.state().addSourceToGroup( sac, mvgGrp );
+ viewerQ.state().addSourceToGroup( sac, mvgGrp );
+ }
+ else
+ {
+ viewerP.state().addSourceToGroup( sac, tgtGrp );
+ viewerQ.state().addSourceToGroup( sac, tgtGrp );
+ }
+ }
}
public int numDimensions()
@@ -615,7 +984,7 @@ public int numDimensions()
/**
* TODO Make a PR that updates this method in InitializeViewerState in bdv-core
* @deprecated Use {@link InitializeViewerState} method instead.
- *
+ *
* @param cumulativeMinCutoff the min image intensity
* @param cumulativeMaxCutoff the max image intensity
* @param state the viewer state
@@ -624,14 +993,48 @@ public int numDimensions()
@Deprecated
public static void initBrightness( final double cumulativeMinCutoff, final double cumulativeMaxCutoff, final ViewerState state, final ConverterSetups converterSetups )
{
- final SourceAndConverter< ? > current = state.getCurrentSource();
- if ( current == null )
- return;
- final Source< ? > source = current.getSpimSource();
- final int timepoint = state.getCurrentTimepoint();
- final Bounds bounds = InitializeViewerState.estimateSourceRange( source, timepoint, cumulativeMinCutoff, cumulativeMaxCutoff );
- final ConverterSetup setup = converterSetups.getConverterSetup( current );
- setup.setDisplayRange( bounds.getMinBound(), bounds.getMaxBound() );
+ final SourceAndConverter< ? > current = state.getCurrentSource();
+ if ( current == null )
+ return;
+ final Source< ? > source = current.getSpimSource();
+ final int timepoint = state.getCurrentTimepoint();
+ final Bounds bounds = InitializeViewerState.estimateSourceRange( source, timepoint, cumulativeMinCutoff, cumulativeMaxCutoff );
+ final ConverterSetup setup = converterSetups.getConverterSetup( current );
+ setup.setDisplayRange( bounds.getMinBound(), bounds.getMaxBound() );
+ }
+
+ /**
+ * @param sources to add; typically the output of a {#{@link BigWarpInit#createSources(BigWarpData, String, int, boolean)}} call
+ */
+ public void addSources( LinkedHashMap, SourceInfo> sources)
+ {
+
+ BigWarpInit.add( data, sources);
+ synchronizeSources();
+ }
+
+ public void addSource( Source< T > source, boolean moving )
+ {
+ data.addSource( source, moving );
+ synchronizeSources();
+ }
+
+ public void addSource( Source source )
+ {
+ addSource( source, false );
+ }
+
+ public int removeSource( SourceInfo info )
+ {
+ final int removedIdx = data.remove( info );
+ synchronizeSources();
+ return removedIdx;
+ }
+
+ public void removeSource( int i )
+ {
+ data.remove( i );
+ synchronizeSources();
}
public void addKeyEventPostProcessor( final KeyEventPostProcessor ke )
@@ -722,14 +1125,21 @@ public void setSpotColor( final Color c )
protected void setUpViewerMenu( final BigWarpViewerFrame vframe )
{
// TODO setupviewermenu
-
final ActionMap actionMap = vframe.getKeybindings().getConcatenatedActionMap();
-
final JMenuBar viewerMenuBar = new JMenuBar();
- JMenu fileMenu = new JMenu( "File" );
+ final JMenu fileMenu = new JMenu( "File" );
viewerMenuBar.add( fileMenu );
+ final JMenuItem loadProject = new JMenuItem( actionMap.get( BigWarpActions.LOAD_PROJECT ) );
+ loadProject.setText( "Load project" );
+ fileMenu.add( loadProject );
+
+ final JMenuItem saveProject = new JMenuItem( actionMap.get( BigWarpActions.SAVE_PROJECT ) );
+ saveProject.setText( "Save project" );
+ fileMenu.add( saveProject );
+
+ fileMenu.addSeparator();
final JMenuItem openItem = new JMenuItem( actionMap.get( BigWarpActions.LOAD_LANDMARKS ) );
openItem.setText( "Import landmarks" );
fileMenu.add( openItem );
@@ -739,23 +1149,32 @@ protected void setUpViewerMenu( final BigWarpViewerFrame vframe )
fileMenu.add( saveItem );
fileMenu.addSeparator();
- final JMenuItem miLoadSettings = new JMenuItem( actionMap.get( BigWarpActions.LOAD_SETTINGS ) );
+ final JMenuItem openMask = new JMenuItem( actionMap.get( BigWarpActions.MASK_IMPORT ));
+ openMask.setText( "Import mask" );
+ fileMenu.add( openMask );
+
+ final JMenuItem removeMask = new JMenuItem( actionMap.get( BigWarpActions.MASK_REMOVE ));
+ removeMask.setText( "Remove mask" );
+ fileMenu.add( removeMask );
+
+ fileMenu.addSeparator();
+ final JMenuItem miLoadSettings = new JMenuItem( actionMap.get( BigWarpActions.LOAD_SETTINGS ));
miLoadSettings.setText( "Load settings" );
fileMenu.add( miLoadSettings );
- final JMenuItem miSaveSettings = new JMenuItem( actionMap.get( BigWarpActions.SAVE_SETTINGS ) );
+ final JMenuItem miSaveSettings = new JMenuItem( actionMap.get( BigWarpActions.SAVE_SETTINGS ));
miSaveSettings.setText( "Save settings" );
fileMenu.add( miSaveSettings );
if( ij != null )
{
fileMenu.addSeparator();
- final JMenuItem exportToImagePlus = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_IP ) );
+ final JMenuItem exportToImagePlus = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_IP ));
exportToImagePlus.setText( "Export moving image" );
fileMenu.add( exportToImagePlus );
-
- final JMenuItem exportWarpField = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_WARP ) );
- exportWarpField.setText( "Export warp field" );
+
+ final JMenuItem exportWarpField = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_WARP ));
+ exportWarpField.setText( "Export transformation" );
fileMenu.add( exportWarpField );
}
@@ -777,9 +1196,10 @@ protected void setUpViewerMenu( final BigWarpViewerFrame vframe )
toggleAlwaysWarpMenu.setText( "Toggle warp on drag" );
settingsMenu.add( toggleAlwaysWarpMenu );
- final JMenuItem miBrightness = new JMenuItem( actionMap.get( BigWarpActions.BRIGHTNESS_SETTINGS ) );
- miBrightness.setText( "Brightness & Color" );
- settingsMenu.add( miBrightness );
+ /* */
+ final JMenuItem transformTypeMenu = new JMenuItem( actionMap.get( BigWarpActions.TRANSFORM_TYPE ) );
+ transformTypeMenu.setText( "Transformation Options" );
+ settingsMenu.add( transformTypeMenu );
/* Warp Visualization */
final JMenuItem warpVisMenu = new JMenuItem( actionMap.get( BigWarpActions.SHOW_WARPTYPE_DIALOG ) );
@@ -807,7 +1227,7 @@ protected void setupImageJExportOption()
final JMenuItem exportToImagePlus = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_IP ) );
exportToImagePlus.setText( "Export moving image" );
fileMenu.add( exportToImagePlus );
-
+
final JMenuItem exportWarpField = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_WARP ) );
exportWarpField.setText( "Export warp field" );
fileMenu.add( exportWarpField );
@@ -822,7 +1242,7 @@ public void exportAsImagePlus( boolean virtual )
public void saveMovingImageToFile()
{
final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
- File proposedFile = new File( sources.get( movingSourceIndexList[ 0 ] ).getSpimSource().getName() );
+ File proposedFile = new File( data.getMovingSource( 0 ).getSpimSource().getName() );
fileChooser.setSelectedFile( proposedFile );
final int returnVal = fileChooser.showSaveDialog( null );
@@ -857,7 +1277,7 @@ public File saveMovingImageXml( String proposedFilePath )
System.out.println( "bigWarp transform as affine 3d: " + bigWarpTransform.toString() );
- movingSpimData.getViewRegistrations().getViewRegistration( 0, 0 ).preconcatenateTransform(
+ movingSpimData.getViewRegistrations().getViewRegistration( 0, 0 ).preconcatenateTransform(
new ViewTransformAffine( "Big Warp: " + bwTransform.getTransformType(), bigWarpTransform ) );
File proposedFile;
@@ -881,7 +1301,7 @@ public File saveMovingImageXml( String proposedFilePath )
try
{
new XmlIoSpimData().save( movingSpimData, proposedFile.getAbsolutePath() );
- } catch ( SpimDataException e )
+ } catch ( final SpimDataException e )
{
e.printStackTrace();
}
@@ -891,8 +1311,8 @@ public File saveMovingImageXml( String proposedFilePath )
public AffineTransform3D getMovingToFixedTransformAsAffineTransform3D()
{
- double[][] affine3DMatrix = new double[ 3 ][ 4 ];
- double[][] affine2DMatrix = new double[ 2 ][ 3 ];
+ final double[][] affine3DMatrix = new double[ 3 ][ 4 ];
+ final double[][] affine2DMatrix = new double[ 2 ][ 3 ];
if ( currentTransform == null )
{
@@ -968,15 +1388,15 @@ public void exportAsImagePlus( boolean virtual, String path )
final GenericDialogPlus gd = new GenericDialogPlus( "Apply Big Warp transform" );
gd.addMessage( "Field of view and resolution:" );
- gd.addChoice( "Resolution",
+ gd.addChoice( "Resolution",
new String[]{ ApplyBigwarpPlugin.TARGET, ApplyBigwarpPlugin.MOVING, ApplyBigwarpPlugin.SPECIFIED },
ApplyBigwarpPlugin.TARGET );
- gd.addChoice( "Field of view",
- new String[]{ ApplyBigwarpPlugin.TARGET,
+ gd.addChoice( "Field of view",
+ new String[]{ ApplyBigwarpPlugin.TARGET,
ApplyBigwarpPlugin.MOVING_WARPED,
ApplyBigwarpPlugin.UNION_TARGET_MOVING,
- ApplyBigwarpPlugin.LANDMARK_POINTS,
+ ApplyBigwarpPlugin.LANDMARK_POINTS,
ApplyBigwarpPlugin.LANDMARK_POINT_CUBE_PIXEL,
ApplyBigwarpPlugin.LANDMARK_POINT_CUBE_PHYSICAL,
ApplyBigwarpPlugin.SPECIFIED_PIXEL,
@@ -985,29 +1405,29 @@ public void exportAsImagePlus( boolean virtual, String path )
ApplyBigwarpPlugin.TARGET );
gd.addStringField( "point filter", "" );
-
+
gd.addMessage( "Resolution");
gd.addNumericField( "x", 1.0, 4 );
gd.addNumericField( "y", 1.0, 4 );
gd.addNumericField( "z", 1.0, 4 );
-
+
gd.addMessage( "Offset");
gd.addNumericField( "x", 0.0, 4 );
gd.addNumericField( "y", 0.0, 4 );
gd.addNumericField( "z", 0.0, 4 );
-
+
gd.addMessage( "Field of view");
gd.addNumericField( "x", -1, 0 );
gd.addNumericField( "y", -1, 0 );
gd.addNumericField( "z", -1, 0 );
-
+
gd.addMessage( "Other Output options");
gd.addChoice( "Interpolation", new String[]{ "Nearest Neighbor", "Linear" }, "Linear" );
-
+
gd.addMessage( "Virtual: fast to display,\n"
+ "low memory requirements,\nbut slow to navigate" );
gd.addCheckbox( "virtual?", false );
- int defaultCores = (int)Math.ceil( Runtime.getRuntime().availableProcessors()/4);
+ final int defaultCores = (int)Math.ceil( Runtime.getRuntime().availableProcessors()/4);
gd.addNumericField( "threads", defaultCores, 0 );
gd.addMessage( "Writing options (leave empty to opena new image window)" );
@@ -1026,21 +1446,21 @@ public void exportAsImagePlus( boolean virtual, String path )
if ( gd.wasCanceled() )
return;
-
+
final String resolutionOption = gd.getNextChoice();
final String fieldOfViewOption = gd.getNextChoice();
final String fieldOfViewPointFilter = gd.getNextString();
-
+
final double[] resolutionSpec = new double[ 3 ];
resolutionSpec[ 0 ] = gd.getNextNumber();
resolutionSpec[ 1 ] = gd.getNextNumber();
resolutionSpec[ 2 ] = gd.getNextNumber();
-
+
final double[] offsetSpec = new double[ 3 ];
offsetSpec[ 0 ] = gd.getNextNumber();
offsetSpec[ 1 ] = gd.getNextNumber();
offsetSpec[ 2 ] = gd.getNextNumber();
-
+
final double[] fovSpec = new double[ 3 ];
fovSpec[ 0 ] = gd.getNextNumber();
fovSpec[ 1 ] = gd.getNextNumber();
@@ -1069,7 +1489,7 @@ public void exportAsImagePlus( boolean virtual, String path )
final double[] res = ApplyBigwarpPlugin.getResolution( this.data, resolutionOption, resolutionSpec );
- final List outputIntervalList = ApplyBigwarpPlugin.getPixelInterval( this.data,
+ final List outputIntervalList = ApplyBigwarpPlugin.getPixelInterval( this.data,
this.landmarkModel, this.currentTransform,
fieldOfViewOption, fieldOfViewPointFilter, bboxOptions, fovSpec, offsetSpec, res );
@@ -1082,8 +1502,8 @@ public void exportAsImagePlus( boolean virtual, String path )
// landmark centers (because multiple images can be exported this way )
if( matchedPtNames.size() > 0 )
{
- BigwarpLandmarkSelectionPanel selection = new BigwarpLandmarkSelectionPanel<>(
- data, sources, fieldOfViewOption,
+ final BigwarpLandmarkSelectionPanel selection = new BigwarpLandmarkSelectionPanel<>(
+ data, data.sources, fieldOfViewOption,
outputIntervalList, matchedPtNames, interp,
offsetSpec, res, isVirtual, nThreads,
progressWriter );
@@ -1096,26 +1516,27 @@ public void exportAsImagePlus( boolean virtual, String path )
// export async
new Thread()
{
+ @Override
public void run()
{
progressWriter.setProgress( 0.01 );
- ApplyBigwarpPlugin.runN5Export( data, sources, fieldOfViewOption,
+ ApplyBigwarpPlugin.runN5Export( data, data.sources, fieldOfViewOption,
outputIntervalList.get( 0 ), interp,
- offsetSpec, res, unit,
- progressWriter, writeOpts,
+ offsetSpec, res, unit,
+ progressWriter, writeOpts,
Executors.newFixedThreadPool( nThreads ) );
progressWriter.setProgress( 1.00 );
}
}.start();
}
- else
+ else
{
// export
final boolean show = ( writeOpts.pathOrN5Root == null || writeOpts.pathOrN5Root.isEmpty() );
- ApplyBigwarpPlugin.runExport( data, sources, fieldOfViewOption,
+ ApplyBigwarpPlugin.runExport( data, data.sources, fieldOfViewOption,
outputIntervalList, matchedPtNames, interp,
- offsetSpec, res, isVirtual, nThreads,
+ offsetSpec, res, isVirtual, nThreads,
progressWriter, show, false, writeOpts );
}
}
@@ -1123,8 +1544,7 @@ public void run()
public void exportWarpField()
{
- BigWarpToDeformationFieldPlugIn dfieldExporter = new BigWarpToDeformationFieldPlugIn();
- dfieldExporter.runFromBigWarpInstance( landmarkModel, sources, targetSourceIndexList );
+ ExportDisplacementFieldFrame.createAndShow( this );
}
protected void setUpLandmarkMenus()
@@ -1201,7 +1621,7 @@ public BigWarpData getData()
public List< SourceAndConverter< T > > getSources()
{
- return sources;
+ return data.sources;
}
public BigWarpLandmarkFrame getLandmarkFrame()
@@ -1308,15 +1728,12 @@ public void updateRowSelection( boolean isMoving, int lastRowEdited )
}
public static void updateRowSelection(
- LandmarkTableModel landmarkModel, JTable table,
+ LandmarkTableModel landmarkModel, JTable table,
boolean isMoving, int lastRowEdited )
{
- logger.trace( "updateRowSelection " );
-
- int i = landmarkModel.getNextRow( isMoving );
+ final int i = landmarkModel.getNextRow( isMoving );
if ( i < table.getRowCount() )
{
- logger.trace( " landmarkTable ( updateRowSelection ) selecting row " + i );
table.setRowSelectionInterval( i, i );
} else if( lastRowEdited >= 0 && lastRowEdited < table.getRowCount() )
table.setRowSelectionInterval( lastRowEdited, lastRowEdited );
@@ -1324,13 +1741,13 @@ public static void updateRowSelection(
/**
* Returns the index of the selected row, if it is unpaired, -1 otherwise
- *
+ *
* @param isMoving isMoving
* @return index of the selected row
*/
public int getSelectedUnpairedRow( boolean isMoving )
{
- int row = landmarkTable.getSelectedRow();
+ final int row = landmarkTable.getSelectedRow();
if( row >= 0 && ( isMoving ? !landmarkModel.isMovingPoint( row ) : !landmarkModel.isFixedPoint( row )))
return row;
@@ -1369,14 +1786,14 @@ public boolean addPoint( final double[] ptarray, final boolean isMoving )
{
final boolean isWarped = ( isMoving && landmarkModel.getTransform() != null && BigWarp.this.isMovingDisplayTransformed() );
- InvertibleRealTransform transform;
+ InvertibleRealTransform transform;
if( options.values.is2D() && currentTransform != null )
- transform = ((Wrapped2DTransformAs3D)currentTransform).getTransform();
+ transform = ((InvertibleWrapped2DTransformAs3D)currentTransform).getTransform();
else
transform = currentTransform;
// TODO check this (current transform part)
- final boolean didAdd = BigWarp.this.landmarkModel.pointEdit( -1, ptarray, false, isMoving, isWarped, true, transform );
+ final boolean didAdd = BigWarp.this.landmarkModel.pointEdit( -1, ptarray, false, isMoving, isWarped, true, transform );
if ( BigWarp.this.landmarkFrame.isVisible() )
{
@@ -1393,20 +1810,19 @@ protected int selectedLandmark( final double[] pt, final boolean isMoving )
/**
* Returns the index of the landmark closest to the input point,
* if it is within a certain distance threshold.
- *
+ *
* Updates the global variable ptBack
*
* @param pt the point location
* @param isMoving is the point location in moving image space
- * @param selectInTable also select the landmark in the table
+ * @param selectInTable also select the landmark in the table
* @return the index of the selected landmark
*/
protected int selectedLandmark( final double[] pt, final boolean isMoving, final boolean selectInTable )
{
- logger.trace( "clicked: " + XfmUtils.printArray( pt ) );
-
- // TODO selectedLandmark
- final int N = landmarkModel.getRowCount();
+ // this gets called on startup for some reason, so put this check in
+ if( landmarkModel == null )
+ return -1;
// a point will be selected if you click inside the spot ( with a 5 pixel buffer )
double radsq = ( viewerSettings.getSpotSize() * viewerSettings.getSpotSize() ) + 5 ;
@@ -1428,54 +1844,59 @@ protected int selectedLandmark( final double[] pt, final boolean isMoving, final
int bestIdx = -1;
double smallestDist = Double.MAX_VALUE;
- logger.trace( " selectedLandmarkHelper dist scale: " + scale );
- logger.trace( " selectedLandmarkHelper radsq: " + radsq );
-
- for ( int n = 0; n < N; n++ )
+ synchronized( landmarkModel )
{
- final Double[] lmpt;
- if( isMoving && landmarkModel.isWarped( n ) && isMovingDisplayTransformed() )
+ final int N = landmarkModel.getRowCount();
+ for ( int n = 0; n < N; n++ )
{
- lmpt = landmarkModel.getWarpedPoints().get( n );
- }
- else if( isMoving && isMovingDisplayTransformed() )
- {
- lmpt = landmarkModel.getPoints( false ).get( n );
- }
- else
- {
- lmpt = landmarkModel.getPoints( isMoving ).get( n );
- }
+ final Double[] lmpt;
+ if( isMoving && landmarkModel.isWarped( n ) && isMovingDisplayTransformed() )
+ {
+ lmpt = landmarkModel.getWarpedPoints().get( n );
+ }
+ else if( isMoving && isMovingDisplayTransformed() )
+ {
+ lmpt = landmarkModel.getPoints( false ).get( n );
+ }
+ else
+ {
+ lmpt = landmarkModel.getPoints( isMoving ).get( n );
+ }
- dist = 0.0;
- for ( int i = 0; i < landmarkModel.getNumdims(); i++ )
- {
- dist += ( pt[ i ] - lmpt[ i ] ) * ( pt[ i ] - lmpt[ i ] );
- }
+ dist = 0.0;
+ for ( int i = 0; i < landmarkModel.getNumdims(); i++ )
+ {
+ dist += ( pt[ i ] - lmpt[ i ] ) * ( pt[ i ] - lmpt[ i ] );
+ }
- dist *= ( scale * scale );
- logger.trace( " dist squared of lm index : " + n + " is " + dist );
- if ( dist < radsq && dist < smallestDist )
- {
- smallestDist = dist;
- bestIdx = n;
+ dist *= ( scale * scale );
+ if ( dist < radsq && dist < smallestDist )
+ {
+ smallestDist = dist;
+ bestIdx = n;
+ }
}
- }
- if ( selectInTable && landmarkFrame.isVisible() )
- {
- if( landmarkTable.isEditing())
+ if ( selectInTable && landmarkFrame.isVisible() )
{
- landmarkTable.getCellEditor().stopCellEditing();
+ if( landmarkTable.isEditing())
+ {
+ landmarkTable.getCellEditor().stopCellEditing();
+ }
+
+ landmarkTable.setEditingRow( bestIdx );
+ landmarkFrame.repaint();
}
- landmarkTable.setEditingRow( bestIdx );
- landmarkFrame.repaint();
}
- logger.trace( "selectedLandmark: " + bestIdx );
return bestIdx;
}
+ public void selectAllLandmarks()
+ {
+ getLandmarkPanel().getJTable().selectAll();
+ }
+
public static double computeScaleAssumeRigid( final AffineTransform3D xfm )
{
return xfm.get( 0, 0 ) + xfm.get( 0, 1 ) + xfm.get( 0, 2 );
@@ -1498,10 +1919,10 @@ protected void enableTransformHandlers()
private void printSourceTransforms()
{
final AffineTransform3D xfm = new AffineTransform3D();
- for( SourceAndConverter sac : data.sources )
+ for( final SourceAndConverter sac : data.sources )
{
sac.getSpimSource().getSourceTransform(0, 0, xfm );
- double det = BigWarpUtils.det( xfm );
+ final double det = BigWarpUtils.det( xfm );
System.out.println( "source xfm ( " + sac.getSpimSource().getName() + " ) : " + xfm );
System.out.println( " det = " + det );
}
@@ -1521,8 +1942,20 @@ private void printViewerTransforms()
System.out.println( " dotxy = " + BigWarpUtils.dotXy( xfm ));
}
+ protected void alignActive( final AlignPlane plane )
+ {
+ if ( viewerFrameP.isActive() )
+ {
+ viewerFrameP.getViewerPanel().align( plane );
+ }
+ else if ( viewerFrameQ.isActive() )
+ {
+ viewerFrameQ.getViewerPanel().align( plane );
+ }
+ }
+
/**
- * Changes the view transformation of 'panelToChange' to match that of 'panelToMatch'
+ * Changes the view transformation of 'panelToChange' to match that of 'panelToMatch'
* @param panelToChange the viewer panel whose transform will change
* @param panelToMatch the viewer panel the transform will come from
*/
@@ -1530,7 +1963,7 @@ protected void matchWindowTransforms( final BigWarpViewerPanel panelToChange, fi
{
panelToChange.showMessage( "Aligning" );
panelToMatch.showMessage( "Matching alignment" );
-
+
// get the transform from panelToMatch
final AffineTransform3D viewXfm = new AffineTransform3D();
panelToMatch.state().getViewerTransform( viewXfm );
@@ -1593,7 +2026,60 @@ else if ( viewerFrameQ.isActive() )
matchWindowTransforms( panelToChange, panelToMatch );
}
- public void warpToNearest( BigWarpViewerPanel viewer )
+ /**
+ * Centers the active viewer at a landmark whose index is an increment from the currently
+ * selected landmark.
+ *
+ * @param inc the increment
+ */
+ public void jumpToLandmarkRelative( int inc )
+ {
+ final int[] selectedRows = getLandmarkPanel().getJTable().getSelectedRows();
+
+ int row = 0;
+ if( selectedRows.length > 0 )
+ row = selectedRows[ selectedRows.length - 1 ];
+
+ row = row + inc; // increment to get the *next* row
+
+ // wrap to start if necessary
+ if( row >= getLandmarkPanel().getTableModel().getRowCount() )
+ row = 0;
+ else if( row < 0 )
+ row = getLandmarkPanel().getTableModel().getRowCount() - 1;
+
+ // select new row
+ getLandmarkPanel().getJTable().setRowSelectionInterval( row, row );
+
+ if( getViewerFrameP().isActive() )
+ {
+ jumpToLandmark( row, getViewerFrameP().getViewerPanel() );
+ }
+ else
+ {
+ jumpToLandmark( row, getViewerFrameQ().getViewerPanel() );
+ }
+ }
+
+ public void jumpToNextLandmark()
+ {
+ jumpToLandmarkRelative( 1 );
+ }
+
+ public void jumpToPrevLandmark()
+ {
+ jumpToLandmarkRelative( -1 );
+ }
+
+ public void jumpToNearestLandmark()
+ {
+ if( getViewerFrameP().isActive() )
+ jumpToNearestLandmark( getViewerFrameP().getViewerPanel() );
+ else
+ jumpToNearestLandmark( getViewerFrameQ().getViewerPanel() );
+ }
+
+ public void jumpToNearestLandmark( BigWarpViewerPanel viewer )
{
if ( inLandmarkMode )
{
@@ -1601,12 +2087,26 @@ public void warpToNearest( BigWarpViewerPanel viewer )
return;
}
- RealPoint mousePt = new RealPoint( 3 ); // need 3d point even for 2d images
+ final RealPoint mousePt = new RealPoint( 3 ); // need 3d point even for 2d images
viewer.getGlobalMouseCoordinates( mousePt );
- warpToLandmark( landmarkModel.getIndexNearestTo( mousePt, viewer.getIsMoving() ), viewer );
+ jumpToLandmark( landmarkModel.getIndexNearestTo( mousePt, viewer.getIsMoving() ), viewer );
+ }
+
+ public void jumpToSelectedLandmark()
+ {
+ final int[] selectedRows = getLandmarkPanel().getJTable().getSelectedRows();
+
+ int row = 0;
+ if( selectedRows.length > 0 )
+ row = selectedRows[ 0 ];
+
+ if( getViewerFrameP().isActive() )
+ jumpToLandmark( row, getViewerFrameP().getViewerPanel() );
+ else
+ jumpToLandmark( row, getViewerFrameQ().getViewerPanel() );
}
- public void warpToLandmark( int row, BigWarpViewerPanel viewer )
+ public void jumpToLandmark( int row, BigWarpViewerPanel viewer )
{
if( inLandmarkMode )
{
@@ -1614,8 +2114,14 @@ public void warpToLandmark( int row, BigWarpViewerPanel viewer )
return;
}
+ if ( BigWarp.this.landmarkModel.getRowCount() < 1 )
+ {
+ message.showMessage( "No landmarks found." );
+ return;
+ }
+
int offset = 0;
- int ndims = landmarkModel.getNumdims();
+ final int ndims = landmarkModel.getNumdims();
double[] pt = null;
if( viewer.getIsMoving() && viewer.getOverlay().getIsTransformed() )
{
@@ -1680,6 +2186,22 @@ else if ( viewerFrameQ.isActive() )
}
}
+ public void goToBookmarkRotation() {
+
+ if (getViewerFrameP().isActive())
+ bookmarkEditorP.initGoToBookmarkRotation();
+ else if (getViewerFrameP().isActive())
+ bookmarkEditorQ.initGoToBookmarkRotation();
+ }
+
+ public void setBookmark() {
+
+ if (getViewerFrameP().isActive())
+ bookmarkEditorP.initSetBookmark();
+ else if (getViewerFrameQ().isActive())
+ bookmarkEditorQ.initSetBookmark();
+ }
+
public void resetView()
{
final RandomAccessibleInterval< ? > interval = getSources().get( 1 ).getSpimSource().getSource( 0, 0 );
@@ -1716,16 +2238,15 @@ public void togglePointVisibility()
/**
* Toggles whether the moving image is displayed after warping (in the same
* space as the fixed image), or in its native space.
- *
+ *
* @return true of the display mode changed
*/
public boolean toggleMovingImageDisplay()
{
// If this is the first time calling the toggle, there may not be enough
- // points to estimate a reasonable transformation.
+ // points to estimate a reasonable transformation.
// return early if an re-estimation did not occur
- boolean success = restimateTransformation();
- logger.trace( "toggleMovingImageDisplay, success: " + success );
+ final boolean success = restimateTransformation();
if ( !success )
{
message.showMessage( "Require at least 4 points to estimate a transformation" );
@@ -1744,39 +2265,94 @@ public boolean toggleMovingImageDisplay()
return success;
}
+ public void toggleMaskOverlayVisibility()
+ {
+ final BigWarpMaskSphereOverlay overlay = getViewerFrameQ().getViewerPanel().getMaskOverlay();
+ if( overlay != null )
+ overlay.toggleVisible();
+ }
+
+ public void setMaskOverlayVisibility( final boolean visible )
+ {
+ final BigWarpMaskSphereOverlay overlay = getViewerFrameQ().getViewerPanel().getMaskOverlay();
+ if( overlay != null )
+ overlay.setVisible( visible );
+ }
+
protected void addDefaultTableMouseListener()
{
landmarkTableListener = new MouseLandmarkTableListener();
landmarkPanel.getJTable().addMouseListener( landmarkTableListener );
}
+ protected void addMaskMouseListener()
+ {
+ final Color[] maskColors = new Color[]{ Color.ORANGE, Color.YELLOW };
+ // only render mask overlay on target window
+ viewerQ.setMaskOverlay( new BigWarpMaskSphereOverlay( viewerQ, maskColors, numDimensions() == 3 ));
+
+ maskSourceMouseListenerQ = new MaskedSourceEditorMouseListener( getLandmarkPanel().getTableModel().getNumdims(), this, viewerQ );
+ maskSourceMouseListenerQ.setActive( false );
+ maskSourceMouseListenerQ.setMask( plateauTransformMask.getRandomAccessible() );
+
+ plateauTransformMask.getRandomAccessible().setOverlays( Arrays.asList( viewerQ.getMaskOverlay() ));
+ }
+
public void setGridType( final GridSource.GRID_TYPE method )
{
- ( ( GridSource< ? > ) gridSource.getSpimSource() ).setMethod( method );
+ gridSource.setMethod( method );
+ }
+
+ @SuppressWarnings( "unchecked" )
+ public static < T > void wrapMovingSources( final int ndims, final BigWarpData< T > data )
+ {
+ int i = 0;
+ for ( final SourceInfo sourceInfo : data.sourceInfos.values() )
+ {
+ if ( sourceInfo.isMoving() )
+ {
+ final SourceAndConverter< T > newSac = ( SourceAndConverter< T > ) wrapSourceAsTransformed( sourceInfo.getSourceAndConverter(), "xfm_" + i, ndims );
+ final int sourceIdx = data.sources.indexOf( sourceInfo.getSourceAndConverter() );
+ sourceInfo.setSourceAndConverter( newSac );
+ data.sources.set( sourceIdx, newSac );
+ }
+ i++;
+ }
+ }
+
+ public static < T > void wrapMovingSources( final int ndims, final BigWarpData< T > data, int id )
+ {
+ final SourceInfo sourceInfo = data.getSourceInfo( id );
+ if( sourceInfo == null )
+ return;
+
+ if ( sourceInfo.isMoving() )
+ {
+ final SourceAndConverter< T > newSac = ( SourceAndConverter< T > ) wrapSourceAsTransformed( sourceInfo.getSourceAndConverter(), "xfm", ndims );
+ final int sourceIdx = data.sources.indexOf( sourceInfo.getSourceAndConverter() );
+ sourceInfo.setSourceAndConverter( newSac );
+ data.sources.set( sourceIdx, newSac );
+ }
}
- public static List< SourceAndConverter > wrapSourcesAsTransformed( final List< SourceAndConverter > sources,
+ @SuppressWarnings( "unchecked" )
+ public static < T > List< SourceAndConverter< T > > wrapSourcesAsTransformed( final LinkedHashMap< Integer, SourceInfo > sources,
final int ndims,
- final BigWarpData data )
+ final BigWarpData< T > data )
{
final List< SourceAndConverter> wrappedSource = new ArrayList<>();
- int[] warpUsIndices = data.movingSourceIndices;
- HashMap, ColorSettings> colorSettings = data.sourceColorSettings;
-
int i = 0;
- for ( final SourceAndConvertersac : sources )
+ for ( final SourceInfo sourceInfo : sources.values() )
{
- int idx = Arrays.binarySearch( warpUsIndices, i );
- if ( idx >= 0 )
+ if ( sourceInfo.isMoving() )
{
- SourceAndConverter newSac = wrapSourceAsTransformed( sac, "xfm_" + i, ndims );
+ final SourceAndConverter< T > newSac = ( SourceAndConverter< T > ) wrapSourceAsTransformed( sourceInfo.getSourceAndConverter(), "xfm_" + i, ndims );
wrappedSource.add( newSac );
- colorSettings.put( newSac, colorSettings.get( sac ));
}
else
{
- wrappedSource.add( sac );
+ wrappedSource.add( ( SourceAndConverter< T > ) sourceInfo.getSourceAndConverter() );
}
i++;
@@ -1785,44 +2361,250 @@ public static List< SourceAndConverter > wrapSourcesAsTransformed( final
}
@SuppressWarnings( { "rawtypes", "unchecked" } )
- private static < T > SourceAndConverter< FloatType > addJacobianDeterminantSource( final BigWarpData< T > data, final String name )
+ private static < T > JacobianDeterminantSource addJacobianDeterminantSource( final int ndims, final BigWarpData< T > data, final String name )
{
- // TODO think about whether its worth it to pass a type parameter.
- final JacobianDeterminantSource< FloatType > jdSource = new JacobianDeterminantSource<>( name, data, new FloatType() );
- final RealARGBColorConverter< FloatType > converter = RealARGBColorConverter.create( new FloatType(), 0, 512 );
- converter.setColor( new ARGBType( 0xffffffff ) );
- final SourceAndConverter< FloatType > soc = new SourceAndConverter<>( jdSource, converter, null );
- data.converterSetups.add( BigDataViewer.createConverterSetup( soc, JACDET_SOURCE_ID ) );
- data.sources.add( ( SourceAndConverter ) soc );
- return soc;
+ final JacobianDeterminantSource jdSource = new JacobianDeterminantSource<>( name, data, new FloatType() );
+ final LinkedHashMap< Source, SourceInfo > infos = BigWarpInit.createSources( data, jdSource, JACDET_SOURCE_ID, false );
+ final LinkedHashMap< Integer, SourceInfo > id2Info = new LinkedHashMap<>( 1 );
+ id2Info.put( JACDET_SOURCE_ID, infos.get( jdSource ) );
+ BigWarpInit.add( data, infos );
+
+ return jdSource;
}
@SuppressWarnings( { "rawtypes", "unchecked" } )
- private static < T > SourceAndConverter< FloatType > addWarpMagnitudeSource( final BigWarpData< T > data, final boolean is2D, final String name )
+ private static < T > WarpMagnitudeSource addWarpMagnitudeSource( final BigWarpData< T > data, final boolean is2D, final String name )
{
- // TODO think about whether its worth it to pass a type parameter.
- final WarpMagnitudeSource< FloatType > magSource = new WarpMagnitudeSource<>( name, data, new FloatType() );
- final RealARGBColorConverter< FloatType > converter = RealARGBColorConverter.create( new FloatType(), 0, 512 );
- converter.setColor( new ARGBType( 0xffffffff ) );
- final SourceAndConverter< FloatType > soc = new SourceAndConverter<>( magSource, converter, null );
- data.converterSetups.add( BigDataViewer.createConverterSetup( soc, WARPMAG_SOURCE_ID ) );
- data.sources.add( ( SourceAndConverter ) soc );
- return soc;
+ final WarpMagnitudeSource magSource = new WarpMagnitudeSource<>( name, data, new FloatType() );
+ final LinkedHashMap< Source, SourceInfo > infos = BigWarpInit.createSources( data, magSource, WARPMAG_SOURCE_ID, false );
+ final LinkedHashMap< Integer, SourceInfo > id2Info = new LinkedHashMap<>( 1 );
+ id2Info.put( WARPMAG_SOURCE_ID, infos.get( magSource ) );
+ BigWarpInit.add( data, infos );
+
+ return magSource;
}
- @SuppressWarnings( { "unchecked", "rawtypes" } )
- private static < T > SourceAndConverter< FloatType > addGridSource( final BigWarpData< T > data, final String name )
+ private static < T > GridSource addGridSource( final int ndims, final BigWarpData< T > data, final String name )
{
// TODO think about whether its worth it to pass a type parameter.
- final GridSource< FloatType > gridSource = new GridSource<>( name, data, new FloatType(), null );
- final RealARGBColorConverter< FloatType > converter = RealARGBColorConverter.create( new FloatType(), 0, 512 );
+ final GridSource gridSource = new GridSource<>( name, data, new FloatType(), null );
+ gridSource.setMethod( GridSource.GRID_TYPE.LINE );
+ final LinkedHashMap< Source, SourceInfo > infos = BigWarpInit.createSources( data, gridSource, GRID_SOURCE_ID, true );
+ final LinkedHashMap< Integer, SourceInfo > id2Info = new LinkedHashMap<>( 1 );
+ id2Info.put( GRID_SOURCE_ID, infos.get( gridSource ) );
+ BigWarpInit.add( data, infos );
+ wrapMovingSources( ndims, data, GRID_SOURCE_ID );
+
+ return gridSource;
+ }
+
+ /**
+ * Call this method when the transform mask type or options have changed.
+ */
+ public void updateTransformMask()
+ {
+ final MaskOptionsPanel maskOpts = warpVisDialog.maskOptionsPanel;
+ final String type = maskOpts.getType();
+ final boolean masked = maskOpts.isMask();
+
+ // add the transform mask if necessary
+ if( masked && transformMaskSource == null )
+ addTransformMaskSource();
+
+ // update the bigwarp transform
+ final boolean isVirtualMask = isVirtualMask();
+ getBwTransform().setMaskInterpolationType( type );
+ setMaskOverlayVisibility( maskOpts.showMaskOverlay() && masked && isVirtualMask );
+
+ if (masked && isVirtualMask)
+ autoEstimateMask();
+
+ restimateTransformation();
+ getViewerFrameQ().getViewerPanel().requestRepaint();
+ getViewerFrameP().getViewerPanel().requestRepaint();
+ }
+
+ private boolean isVirtualMask() {
+
+ return plateauTransformMask == transformMask;
+ }
+
+ public void refreshTransformMask()
+ {
+ getBwTransform().setLambda(
+ transformMaskSource.getSpimSource().getInterpolatedSource(0, 0, Interpolation.NLINEAR));
+ }
+
+ public void setTransformMaskRange( double min, double max )
+ {
+ getBwTransform().setMaskIntensityBounds(min, max);
+ warpVisDialog.maskOptionsPanel.getMaskRangeSlider().setRange(
+ new BoundedRange( min, max, min, max ));
+ }
+
+ public void setTransformMaskType( final String maskInterpolationType )
+ {
+ getBwTransform().setMaskInterpolationType(maskInterpolationType);
+ warpVisDialog.maskOptionsPanel.getMaskTypeDropdown().setSelectedItem(maskInterpolationType);
+ }
+
+ public void setTransformMaskProperties( final FalloffShape falloffShape,
+ final double squaredRadius, double[] center )
+ {
+ warpVisDialog.maskOptionsPanel.getMaskFalloffTypeDropdown().setSelectedItem(falloffShape);
+
+ final PlateauSphericalMaskRealRandomAccessible mask = getTransformPlateauMaskSource().getRandomAccessible();
+ mask.setFalloffShape( falloffShape );
+ mask.setSquaredRadius( squaredRadius );
+ mask.setCenter( center );
+ }
+
+ public void importTransformMaskSourceDialog() {
+
+ final JFileChooser fileChooser = new JFileChooser();
+ fileChooser.setFileSelectionMode( JFileChooser.FILES_AND_DIRECTORIES );
+ fileChooser.setCurrentDirectory(lastDirectory);
+
+ final int ret = fileChooser.showOpenDialog(landmarkFrame);
+ if ( ret == JFileChooser.APPROVE_OPTION ) {
+
+ final File selection = fileChooser.getSelectedFile();
+ importTransformMaskSource( selection.getAbsolutePath() );
+ }
+
+ }
+
+ @SuppressWarnings( { "unchecked" } )
+ public void importTransformMaskSource( final String uri ) {
+
+ // first remove any existing mask source
+ final SourceInfo srcInfo = data.sourceInfos.get(TRANSFORM_MASK_SOURCE_ID);
+ if( srcInfo != null )
+ removeSource(srcInfo);
+
+ LinkedHashMap, SourceInfo> infos;
+ try {
+ infos = BigWarpInit.createSources(data, uri, TRANSFORM_MASK_SOURCE_ID, false);
+ BigWarpInit.add( data, infos, null, null );
+
+ infos.entrySet().stream().map( e -> { return e.getKey(); }).findFirst().ifPresent( x -> {
+ transformMask = (Source>)x;
+ });
+ synchronizeSources();
+
+ } catch (final URISyntaxException e) {
+ e.printStackTrace();
+ } catch (final IOException e) {
+ e.printStackTrace();
+ } catch (final SpimDataException e) {
+ e.printStackTrace();
+ }
+
+ bwTransform.setLambda( transformMask.getInterpolatedSource(0, 0, Interpolation.NLINEAR));
+ updateTransformMask();
+
+ final RealType type = transformMask.getType();
+ if( !(type instanceof DoubleType ) && !(type instanceof FloatType ))
+ {
+ final double min = type.getMinValue();
+ final double max = type.getMaxValue();
+ bwTransform.setMaskIntensityBounds( min, max );
+ warpVisDialog.maskOptionsPanel.getMaskRangeSlider().setRange(new BoundedRange( min, max, min, max ));
+ }
+ }
+
+ /**
+ * Run this after loading projet to set the transform mask from a loaded source
+ */
+ @SuppressWarnings("unchecked")
+ public void connectMaskSource()
+ {
+ transformMask = (Source>)data.sourceInfos.get(TRANSFORM_MASK_SOURCE_ID).getSourceAndConverter().getSpimSource();
+ bwTransform.setLambda( transformMask.getInterpolatedSource(0, 0, Interpolation.NLINEAR));
+ }
+
+ public void removeMaskSource() {
+
+ final SourceInfo srcInfo = data.sourceInfos.get(TRANSFORM_MASK_SOURCE_ID);
+ if( srcInfo != null )
+ removeSource(srcInfo);
+
+ transformMask = null;
+ transformMaskSource = null;
+ bwTransform.setLambda(null);
+ bwTransform.setMaskInterpolationType(BigWarpTransform.NO_MASK_INTERP);
+ warpVisDialog.maskOptionsPanel.getMaskTypeDropdown().setSelectedItem(BigWarpTransform.NO_MASK_INTERP);
+
+ final BigWarpMaskSphereOverlay overlay = getViewerFrameQ().getViewerPanel().getMaskOverlay();
+ if( overlay != null )
+ overlay.setVisible(false);
+
+ updateTransformMask();
+
+ restimateTransformation();
+ }
+
+ @SuppressWarnings( { "unchecked", "rawtypes", "hiding" } )
+ public > SourceAndConverter< T > addTransformMaskSource()
+ {
+ if( warpVisDialog == null )
+ return null;
+
+ if( transformMask != null)
+ {
+ return ( SourceAndConverter< T > ) data.getSourceInfo( TRANSFORM_MASK_SOURCE_ID ).getSourceAndConverter();
+ }
+
+ // think about whether its worth it to pass a type parameter. or should we just stick with Floats?
+ final BoundingBoxEstimation bbe = new BoundingBoxEstimation();
+ final AffineTransform3D affine = new AffineTransform3D();
+ data.getTargetSource( 0 ).getSpimSource().getSourceTransform( 0, 0, affine );
+ final Interval itvl = bbe.estimatePixelInterval( affine, data.getTargetSource( 0 ).getSpimSource().getSource( 0, 0 ) );
+
+ plateauTransformMask = PlateauSphericalMaskSource.build( new RealPoint( 3 ), itvl );
+ transformMask = plateauTransformMask;
+
+
+ final RealARGBColorConverter< T > converter = (RealARGBColorConverter)RealARGBColorConverter.create( plateauTransformMask.getType(), 0, 1 );
converter.setColor( new ARGBType( 0xffffffff ) );
- final SourceAndConverter< FloatType > soc = new SourceAndConverter<>( gridSource, converter, null );
- data.converterSetups.add( BigDataViewer.createConverterSetup( soc, GRID_SOURCE_ID ) );
+ final SourceAndConverter< T > soc = new SourceAndConverter( (Source)transformMask, converter, null );
+ data.converterSetups.add( BigDataViewer.createConverterSetup( soc, TRANSFORM_MASK_SOURCE_ID ) );
data.sources.add( ( SourceAndConverter ) soc );
+
+ final SourceInfo sourceInfo = new SourceInfo( TRANSFORM_MASK_SOURCE_ID, false, transformMask.getName(), null, null );
+ sourceInfo.setSourceAndConverter( soc );
+ data.sourceInfos.put( TRANSFORM_MASK_SOURCE_ID, sourceInfo);
+
+ // connect to UI
+ warpVisDialog.maskOptionsPanel.setMask( plateauTransformMask );
+ addMaskMouseListener();
+ bwTransform.setLambda( plateauTransformMask.getRandomAccessible() );
+ bwTransform.setMaskIntensityBounds(0, 1);
+
+ final ArrayList overlayList = new ArrayList<>();
+ final BigWarpMaskSphereOverlay overlay = new BigWarpMaskSphereOverlay( viewerQ, ndims==3 );
+ overlayList.add( overlay );
+
+ // first attach the overlay to the viewer
+ getViewerFrameQ().getViewerPanel().setMaskOverlay( overlay );
+ plateauTransformMask.getRandomAccessible().setOverlays( overlayList );
+
+
+ synchronizeSources();
+ transformMaskSource = soc;
return soc;
}
+ public Source> getTansformMaskSource()
+ {
+ return transformMask;
+ }
+
+ public PlateauSphericalMaskSource getTransformPlateauMaskSource()
+ {
+ return plateauTransformMask;
+ }
+
private static < T > SourceAndConverter< T > wrapSourceAsTransformed( final SourceAndConverter< T > src, final String name, final int ndims )
{
if ( src.asVolatile() == null )
@@ -1842,25 +2624,30 @@ public void setupKeyListener()
public void setWarpVisGridType( final GridSource.GRID_TYPE type )
{
- ( ( GridSource< ? > ) gridSource.getSpimSource() ).setMethod( type );
+ gridSource.setMethod( type );
viewerP.requestRepaint();
viewerQ.requestRepaint();
}
public void setWarpGridWidth( final double width )
{
- ( ( GridSource< ? > ) gridSource.getSpimSource() ).setGridWidth( width );
+ gridSource.setGridWidth( width );
viewerP.requestRepaint();
viewerQ.requestRepaint();
}
public void setWarpGridSpacing( final double spacing )
{
- ( ( GridSource< ? > ) gridSource.getSpimSource() ).setGridSpacing( spacing );
+ gridSource.setGridSpacing( spacing );
viewerP.requestRepaint();
viewerQ.requestRepaint();
}
+ public void setAutoSaver( final BigWarpAutoSaver autoSaver )
+ {
+ this.autoSaver = autoSaver;
+ }
+
protected void setupWarpMagBaselineOptions( final CoordinateTransform[] xfm, final int ndim )
{
if ( ndim == 2 )
@@ -1896,29 +2683,28 @@ protected void fitBaselineWarpMagModel()
landmarkModel.copyLandmarks( p, q );
Arrays.fill( w, 1.0 );
-
- try
- {
- final AbstractModel< ? > baseline = this.baseXfmList[ baselineModelIndex ];
-
- baseline.fit( p, q, w ); // FITBASELINE
- WrappedCoordinateTransform baselineTransform = new WrappedCoordinateTransform(
- (InvertibleCoordinateTransform)baseline, ndims );
-
- // the transform to compare is the inverse (because we use it for rendering)
- // so need to give the inverse transform for baseline as well
- ( ( WarpMagnitudeSource< ? > ) warpMagSource.getSpimSource() ).setBaseline( baselineTransform.inverse() );
- }
- catch ( final NotEnoughDataPointsException e )
- {
- e.printStackTrace();
- }
- catch ( final IllDefinedDataPointsException e )
+
+ if( warpMagSource != null )
{
- e.printStackTrace();
+ try
+ {
+ final AbstractModel< ? > baseline = this.baseXfmList[ baselineModelIndex ];
+ baseline.fit( p, q, w ); // FITBASELINE
+ final WrappedCoordinateTransform baselineTransform = new WrappedCoordinateTransform(
+ (InvertibleCoordinateTransform)baseline, ndims );
+
+ // the transform to compare is the inverse (because we use it for rendering)
+ // so need to give the inverse transform for baseline as well
+ warpMagSource.setBaseline( baselineTransform.inverse() );
+ }
+ catch ( final IllDefinedDataPointsException | NotEnoughDataPointsException e )
+ {
+ e.printStackTrace();
+ }
+
+ getViewerFrameP().getViewerPanel().requestRepaint();
+ getViewerFrameQ().getViewerPanel().requestRepaint();
}
- getViewerFrameP().getViewerPanel().requestRepaint();
- getViewerFrameQ().getViewerPanel().requestRepaint();
}
public void setMovingSpimData( SpimData movingSpimData, File movingImageXml )
@@ -1927,10 +2713,39 @@ public void setMovingSpimData( SpimData movingSpimData, File movingImageXml )
this.movingImageXml = movingImageXml;
}
+ public void setBookmarks( final Bookmarks bookmarks )
+ {
+ this.bookmarks = bookmarks;
+ }
+
+ public void setAutoEstimateMask( final boolean selected )
+ {
+ warpVisDialog.maskOptionsPanel.getAutoEstimateMaskButton().setSelected( selected );
+ }
+
+ public void autoEstimateMask()
+ {
+ if( landmarkModel.numActive() < 4 )
+ return;
+
+ if( warpVisDialog.autoEstimateMask() && bwTransform.isMasked() && transformMask instanceof PlateauSphericalMaskSource )
+ {
+ final Sphere sph = BoundingSphereRitter.boundingSphere(landmarkModel.getFixedPointsCopy());
+ plateauTransformMask.getRandomAccessible().setCenter(sph.getCenter());
+ plateauTransformMask.getRandomAccessible().setRadius(sph.getRadius());
+
+ final AbstractTransformSolver< ? > solver = getBwTransform().getSolver();
+ if( solver instanceof MaskedSimRotTransformSolver )
+ {
+ ((MaskedSimRotTransformSolver)solver).setCenter( sph.getCenter() );
+ }
+ }
+ }
+
public enum WarpVisType
{
NONE, WARPMAG, JACDET, GRID
- };
+ }
public void setWarpVisMode( final WarpVisType type, BigWarpViewerFrame viewerFrame, final boolean both )
{
@@ -1954,19 +2769,9 @@ else if ( both )
{
return;
}
-
}
-//
-// int offImgIndex = 0;
-// int onImgIndex = 1;
-//
-// if ( viewerFrame == viewerFrameP )
-// {
-// offImgIndex = 1;
-// onImgIndex = 0;
-// }
- if ( landmarkModel.getTransform() == null )
+ if ( currentTransform == null )
{
message.showMessage( "No warp - estimate warp first." );
return;
@@ -1977,19 +2782,27 @@ else if ( both )
{
case JACDET:
{
- // turn warp mag on
- state.setSourceActive( warpMagSource, false );
- state.setSourceActive( jacDetSource, true );
- state.setSourceActive( gridSource, false );
+ // turn jacobian determinant
+ if ( jacDetSource == null )
+ {
+ jacDetSource = addJacobianDeterminantSource( ndims, data, "Jacobian determinant" );
+ synchronizeSources();
+ }
+ showSourceFused( viewerFrame, JACDET_SOURCE_ID );
+ viewerFrame.getViewerPanel().showMessage( "Displaying Jacobian Determinant" );
+ break;
}
case WARPMAG:
{
// turn warp mag on
- state.setSourceActive( warpMagSource, true );
- state.setSourceActive( jacDetSource, false );
- state.setSourceActive( gridSource, false );
-// vg.setSourceActive( offImgIndex, false );
+ if ( warpMagSource == null )
+ {
+
+ warpMagSource = addWarpMagnitudeSource( data, ndims == 2, "Warp magnitude" );
+ synchronizeSources();
+ }
+ showSourceFused( viewerFrame, WARPMAG_SOURCE_ID );
// estimate the max warp
// final WarpMagnitudeSource< ? > wmSrc = ( ( WarpMagnitudeSource< ? > ) sources.get( warpMagSourceIndex ).getSpimSource() );
@@ -1998,30 +2811,32 @@ else if ( both )
// set the slider
// ( ( RealARGBColorConverter< FloatType > ) ( sources.get( warpMagSourceIndex ).getConverter() ) ).setMax( maxval );
- state.setDisplayMode( DisplayMode.FUSED );
- message.showMessage( "Displaying Warp Magnitude" );
+
+ viewerFrame.getViewerPanel().showMessage( "Displaying Warp Magnitude" );
break;
}
case GRID:
{
// turn grid vis on
+ if ( gridSource == null )
+ {
+ gridSource = addGridSource( ndims, data, "Transform grid" );
+ synchronizeSources();
+ data.getConverterSetup( GRID_SOURCE_ID ).setDisplayRange( 0, 512 );
+ }
+ showSourceFused( viewerFrame, GRID_SOURCE_ID );
- state.setSourceActive( warpMagSource, false );
- state.setSourceActive( jacDetSource, false );
- state.setSourceActive( gridSource, true );
-// vg.setSourceActive( offImgIndex, false );
-
- state.setDisplayMode( DisplayMode.FUSED );
- message.showMessage( "Displaying Warp Grid" );
+ viewerFrame.getViewerPanel().showMessage( "Displaying Warp Grid" );
break;
}
default:
{
- state.setSourceActive( warpMagSource, false );
- state.setSourceActive( gridSource, false );
-// vg.setSourceActive( offImgIndex, true );
+ if ( warpMagSource != null )
+ state.setSourceActive( data.getSourceInfo( WARPMAG_SOURCE_ID ).getSourceAndConverter(), false );
+
+ if ( gridSource != null )
+ state.setSourceActive( data.getSourceInfo( GRID_SOURCE_ID ).getSourceAndConverter(), false );
-// vg.setFusedEnabled( false );
message.showMessage( "Turning off warp vis" );
break;
}
@@ -2030,8 +2845,6 @@ else if ( both )
public void toggleWarpVisMode( BigWarpViewerFrame viewerFrame )
{
-// int offImgIndex = 0;
-// int onImgIndex = 1;
if ( viewerFrame == null )
{
if ( viewerFrameP.isActive() )
@@ -2046,13 +2859,7 @@ else if ( viewerFrameQ.isActive() )
return;
}
-// if ( viewerFrame == viewerFrameP )
-// {
-// offImgIndex = 1;
-// onImgIndex = 0;
-// }
-
- if ( landmarkModel.getTransform() == null )
+ if( getBwTransform().getTransformation() == null )
{
message.showMessage( "No warp - estimate warp first." );
return;
@@ -2060,23 +2867,20 @@ else if ( viewerFrameQ.isActive() )
final ViewerState state = viewerFrame.getViewerPanel().state();
- // TODO consider remembering whether fused was on before displaying
- // warpmag
+ // TODO consider remembering whether fused was on before displaying warpmag
// so that its still on or off after we turn it off
- if ( state.isSourceActive( warpMagSource ) ) // warp mag is visible,
- // turn it off
- {
- state.setSourceActive( warpMagSource, false );
-// vg.setSourceActive( offImgIndex, true );
+ final SourceAndConverter< ? > wmSac = data.getSourceInfo( WARPMAG_SOURCE_ID ).getSourceAndConverter();
+ if ( state.isSourceActive( wmSac ) ) // warp mag is visible, turn it off
+ {
+ state.setSourceActive( wmSac, false );
state.setDisplayMode( state.getDisplayMode().withFused( false ) );
message.showMessage( "Removing Warp Magnitude" );
}
else // warp mag is invisible, turn it on
{
- state.setSourceActive( warpMagSource, true );
-// vg.setSourceActive( offImgIndex, false );
+ state.setSourceActive( wmSac, true );
// estimate the max warp
// final WarpMagnitudeSource< ? > wmSrc = ( ( WarpMagnitudeSource< ? > ) sources.get( warpMagSourceIndex ).getSpimSource() );
@@ -2092,40 +2896,88 @@ else if ( viewerFrameQ.isActive() )
viewerFrame.getViewerPanel().requestRepaint();
}
- private void setTransformationMovingSourceOnly( final InvertibleRealTransform transform )
- {
- this.currentTransform = transform;
+ private void showSourceFused(BigWarpViewerFrame viewerFrame, int sourceId) {
- for ( int i = 0; i < movingSourceIndexList.length; i++ )
- {
- int idx = movingSourceIndexList [ i ];
+ if (viewerFrame == null) {
+ if (viewerFrameP.isActive()) {
+ viewerFrame = viewerFrameP;
+ } else if (viewerFrameQ.isActive()) {
+ viewerFrame = viewerFrameQ;
+ } else
+ return;
+ }
+
+ if (getBwTransform().getTransformation() == null) {
+ message.showMessage("No warp - estimate warp first.");
+ return;
+ }
+
+ final SourceAndConverter< ? > newSrc = data.getSourceInfo( sourceId ).getSourceAndConverter();
- // the xfm must always be 3d for bdv to be happy.
- // when bigwarp has 2d images though, the z- component will be left unchanged
- //InverseRealTransform xfm = new InverseRealTransform( new TpsTransformWrapper( 3, transform ));
+ final ViewerState state = viewerFrame.getViewerPanel().state();
+ if (!state.getDisplayMode().equals(DisplayMode.FUSED)) {
+ final SourceAndConverter currentSource = state.getCurrentSource();
+ for( final SourceAndConverter src : state.getSources())
+ state.setSourceActive(src, src == currentSource || src == newSrc );
+ }
+ else {
+
+ final SourceInfo warpMagSrcInfo = data.getSourceInfo( WARPMAG_SOURCE_ID );
+ final SourceInfo gridSrcInfo = data.getSourceInfo( GRID_SOURCE_ID );
+ final SourceInfo jacDetSrcInfo = data.getSourceInfo( JACDET_SOURCE_ID );
+
+ // un-dispolay all the warp vis sources
+ if (warpMagSrcInfo != null)
+ state.setSourceActive(warpMagSrcInfo.getSourceAndConverter(), false);
- // the updateTransform method creates a copy of the transform
- ( ( WarpedSource< ? > ) ( sources.get( idx ).getSpimSource() ) ).updateTransform( transform );
- if ( sources.get( 0 ).asVolatile() != null )
- ( ( WarpedSource< ? > ) ( sources.get( idx ).asVolatile().getSpimSource() ) ).updateTransform( transform );
+ if (gridSrcInfo != null)
+ state.setSourceActive(gridSrcInfo.getSourceAndConverter(), false);
+
+ if (jacDetSrcInfo != null)
+ state.setSourceActive(jacDetSrcInfo.getSourceAndConverter(), false);
+
+ // activate the requested one
+ state.setSourceActive(newSrc, true);
}
+
+ state.setDisplayMode(DisplayMode.FUSED);
}
- public void updateSourceBoundingBoxEstimators()
+ private void setTransformationMovingSourceOnly( final InvertibleRealTransform transform )
{
- for ( int i = 0; i < movingSourceIndexList.length; i++ )
- {
- int idx = movingSourceIndexList [ i ];
-
- // the xfm must always be 3d for bdv to be happy.
- // when bigwarp has 2d images though, the z- component will be left unchanged
- //InverseRealTransform xfm = new InverseRealTransform( new TpsTransformWrapper( 3, transform ));
+ this.currentTransform = transform;
+ data.sourceInfos.values().forEach( sourceInfo -> {
+ if ( sourceInfo.isMoving() )
+ {
+ // the xfm must always be 3d for bdv to be happy.
+ // when bigwarp has 2d images though, the z- component will be left unchanged
+ // InverseRealTransform xfm = new InverseRealTransform( new TpsTransformWrapper( 3, transform ));
+
+ // the updateTransform method creates a copy of the transform
+ final SourceAndConverter< ? > sac = sourceInfo.getSourceAndConverter();
+ final WarpedSource< ? > wsrc = ( WarpedSource< ? > ) sac.getSpimSource();
+ wsrc.updateTransform( transform );
+ if ( sac.asVolatile() != null )
+ ( ( WarpedSource< ? > ) sourceInfo.getSourceAndConverter().asVolatile().getSpimSource() ).updateTransform( transform );
+ }
+ } );
+ }
- // the updateTransform method creates a copy of the transform
- ( ( WarpedSource< ? > ) ( sources.get( idx ).getSpimSource() ) ).setBoundingBoxEstimator(bboxOptions.copy());
- if ( sources.get( 0 ).asVolatile() != null )
- ( ( WarpedSource< ? > ) ( sources.get( idx ).asVolatile().getSpimSource() ) ).setBoundingBoxEstimator(bboxOptions.copy());
- }
+ public void updateSourceBoundingBoxEstimators()
+ {
+ data.sourceInfos.values().forEach( sourceInfo -> {
+ if ( sourceInfo.isMoving() )
+ {
+ // the xfm must always be 3d for bdv to be happy.
+ // when bigwarp has 2d images though, the z- component will be left unchanged
+ //InverseRealTransform xfm = new InverseRealTransform( new TpsTransformWrapper( 3, transform ));
+
+ // the updateTransform method creates a copy of the transform
+ ( ( WarpedSource< ? > ) sourceInfo.getSourceAndConverter().getSpimSource() ).setBoundingBoxEstimator( bboxOptions.copy() );
+ if ( data.sources.get( 0 ).asVolatile() != null )
+ ( ( WarpedSource< ? > ) sourceInfo.getSourceAndConverter().asVolatile().getSpimSource() ).setBoundingBoxEstimator( bboxOptions.copy() );
+ }
+ } );
}
private synchronized void notifyTransformListeners( )
@@ -2138,25 +2990,29 @@ private void setTransformationAll( final InvertibleRealTransform transform )
{
setTransformationMovingSourceOnly( transform );
- final WarpMagnitudeSource< ? > wmSrc = ( ( WarpMagnitudeSource< ? > ) warpMagSource.getSpimSource() );
- final JacobianDeterminantSource< ? > jdSrc = ( ( JacobianDeterminantSource< ? > ) jacDetSource.getSpimSource() );
- final GridSource< ? > gSrc = ( ( GridSource< ? > ) gridSource.getSpimSource() );
-
- wmSrc.setWarp( transform );
- fitBaselineWarpMagModel();
-
- if( transform instanceof ThinplateSplineTransform )
+ if( warpMagSource != null )
{
- jdSrc.setTransform( (ThinplateSplineTransform)transform );
+ warpMagSource.setWarp( transform );
+ fitBaselineWarpMagModel();
}
- else if ( transform instanceof WrappedIterativeInvertibleRealTransform )
+
+ if( jacDetSource != null )
{
- jdSrc.setTransform( (ThinplateSplineTransform)((WrappedIterativeInvertibleRealTransform)transform).getTransform() );
+ if( transform instanceof ThinplateSplineTransform )
+ {
+ jacDetSource.setTransform( (ThinplateSplineTransform)transform );
+ }
+ else if ( transform instanceof WrappedIterativeInvertibleRealTransform )
+ {
+ final RealTransform xfm = ((WrappedIterativeInvertibleRealTransform)transform).getTransform();
+ if( xfm instanceof ThinplateSplineTransform )
+ jacDetSource.setTransform( (ThinplateSplineTransform) xfm );
+ else
+ jacDetSource.setTransform( new RealTransformFiniteDerivatives( xfm ));
+ }
+ else
+ jacDetSource.setTransform( null );
}
- else
- jdSrc.setTransform( null );
-
- gSrc.setWarp( transform );
}
public boolean restimateTransformation()
@@ -2194,15 +3050,17 @@ public boolean restimateTransformation()
public synchronized void setIsMovingDisplayTransformed( final boolean isTransformed )
{
- for( int i = 0 ; i < movingSourceIndexList.length; i ++ )
- {
- int movingSourceIndex = movingSourceIndexList[ i ];
- ( ( WarpedSource< ? > ) ( sources.get( movingSourceIndex ).getSpimSource() ) ).setIsTransformed( isTransformed );
+ data.sourceInfos.values().forEach( sourceInfo -> {
+ if ( sourceInfo.isMoving() )
+ {
+ final SourceAndConverter< ? > sourceAndConverter = sourceInfo.getSourceAndConverter();
+ ( ( WarpedSource< ? > ) sourceAndConverter.getSpimSource() ).setIsTransformed( isTransformed );
- if ( sources.get( movingSourceIndex ).asVolatile() != null )
- ( ( WarpedSource< ? > ) ( sources.get( movingSourceIndex ).asVolatile().getSpimSource() ) ).setIsTransformed( isTransformed );
- }
+ if ( sourceAndConverter.asVolatile() != null )
+ ( ( WarpedSource< ? > ) sourceAndConverter.asVolatile().getSpimSource() ).setIsTransformed( isTransformed );
+ }
+ } );
overlayP.setIsTransformed( isTransformed );
@@ -2220,14 +3078,21 @@ public synchronized void setIsMovingDisplayTransformed( final boolean isTransfor
*/
public boolean isRowIncomplete()
{
- LandmarkTableModel ltm = landmarkPanel.getTableModel();
+ final LandmarkTableModel ltm = landmarkPanel.getTableModel();
return ltm.isPointUpdatePending() || ltm.isPointUpdatePendingMoving();
}
public boolean isMovingDisplayTransformed()
{
// this implementation is okay, so long as all the moving images have the same state of 'isTransformed'
- return ( ( WarpedSource< ? > ) ( sources.get( movingSourceIndexList[ 0 ] ).getSpimSource() ) ).isTransformed();
+// return ( ( WarpedSource< ? > ) ( data.sources.get( data.movingSourceIndexList.get( 0 ) ).getSpimSource() ) ).isTransformed();
+
+ // TODO better to explicitly keep track of this
+
+ if( data.sources.size() < 1 )
+ return true;
+ else
+ return ( ( WarpedSource< ? > ) ( data.getMovingSource( 0 ).getSpimSource() ) ).isTransformed();
}
/**
@@ -2236,7 +3101,7 @@ public boolean isMovingDisplayTransformed()
*/
protected int detectNumDims()
{
- return detectNumDims( sources );
+ return detectNumDims( data.sources );
}
/**
@@ -2247,10 +3112,14 @@ protected int detectNumDims()
*/
public static int detectNumDims( List< SourceAndConverter< T > > sources )
{
+ // default to 3D if bigwarp is opened without any sources
+ if( sources.size() == 0 )
+ return 3;
+
boolean isAnySource3d = false;
- for ( SourceAndConverter< T > sac : sources )
+ for ( final SourceAndConverter< T > sac : sources )
{
- long[] dims = new long[ sac.getSpimSource().getSource( 0, 0 ).numDimensions() ];
+ final long[] dims = new long[ sac.getSpimSource().getSource( 0, 0 ).numDimensions() ];
sac.getSpimSource().getSource( 0, 0 ).dimensions( dims );
if ( sac.getSpimSource().getSource( 0, 0 ).dimension( 2 ) > 1 )
@@ -2270,7 +3139,7 @@ public static int detectNumDims( List< SourceAndConverter< T > > sources )
public static void main( final String[] args )
{
new ImageJ();
-
+
// TODO main
String fnP = "";
String fnQ = "";
@@ -2282,11 +3151,6 @@ public static void main( final String[] args )
fnP = args[ i++ ];
fnQ = args[ i++ ];
}
- else
- {
- System.err.println( "Must provide at least 2 inputs for moving and target image files" );
- System.exit( 1 );
- }
if ( args.length > i )
fnLandmarks = args[ i++ ];
@@ -2311,35 +3175,41 @@ public static void main( final String[] args )
System.setProperty( "apple.laf.useScreenMenuBar", "false" );
- ProgressWriterIJ progress = new ProgressWriterIJ();
- BigWarp bw;
- BigWarpData bwdata;
+ final ProgressWriterIJ progress = new ProgressWriterIJ();
+ BigWarp bw;
+ BigWarpData bwdata;
if ( fnP.endsWith( "xml" ) && fnQ.endsWith( "xml" ) )
{
bwdata = BigWarpInit.createBigWarpDataFromXML( fnP, fnQ );
- bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ bw = new BigWarp<>( bwdata, progress );
}
else if ( fnP.endsWith( "xml" ) && !fnQ.endsWith( "xml" ) )
{
final ImagePlus impQ = IJ.openImage( fnQ );
bwdata = BigWarpInit.createBigWarpDataFromXMLImagePlus( fnP, impQ );
- bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ bw = new BigWarp<>( bwdata, progress );
}
else if ( !fnP.endsWith( "xml" ) && fnQ.endsWith( "xml" ) )
{
final ImagePlus impP = IJ.openImage( fnP );
bwdata = BigWarpInit.createBigWarpDataFromImagePlusXML( impP, fnQ );
- bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ bw = new BigWarp<>( bwdata, progress );
}
- else
+ else if (!fnP.isEmpty() && !fnQ.isEmpty())
{
final ImagePlus impP = IJ.openImage( fnP );
final ImagePlus impQ = IJ.openImage( fnQ );
+ // For testing display and color settings
+// impP.setDisplayRange( 10, 200 );
+// impQ.setDisplayRange( 20, 180 );
+// impP.show();
+// impQ.show();
+
if ( !( impP == null || impQ == null ) )
{
bwdata = BigWarpInit.createBigWarpDataFromImages( impP, impQ );
- bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ bw = new BigWarp<>( bwdata, progress );
}
else
{
@@ -2347,10 +3217,13 @@ else if ( !fnP.endsWith( "xml" ) && fnQ.endsWith( "xml" ) )
return;
}
}
+ else
+ {
+ bw = new BigWarp<>( new BigWarpData<>(), progress );
+ }
-
if ( !fnLandmarks.isEmpty() )
- bw.getLandmarkPanel().getTableModel().load( new File( fnLandmarks ) );
+ bw.loadLandmarks( fnLandmarks );
if ( doInverse )
bw.invertPointCorrespondences();
@@ -2362,19 +3235,19 @@ else if ( !fnP.endsWith( "xml" ) && fnQ.endsWith( "xml" ) )
e.printStackTrace();
}
}
-
+
private void viewerXfmTest()
{
- AffineTransform3D srcTransform0 = new AffineTransform3D();
- sources.get( 0 ).getSpimSource().getSourceTransform(0, 0, srcTransform0 );
+ final AffineTransform3D srcTransform0 = new AffineTransform3D();
+ data.sources.get( 0 ).getSpimSource().getSourceTransform(0, 0, srcTransform0 );
- AffineTransform3D srcTransform1 = new AffineTransform3D();
- sources.get( 1 ).getSpimSource().getSourceTransform(0, 0, srcTransform1 );
+ final AffineTransform3D srcTransform1 = new AffineTransform3D();
+ data.sources.get( 1 ).getSpimSource().getSourceTransform(0, 0, srcTransform1 );
- AffineTransform3D viewerTransformM = new AffineTransform3D();
+ final AffineTransform3D viewerTransformM = new AffineTransform3D();
viewerP.state().getViewerTransform( viewerTransformM );
- AffineTransform3D viewerTransformT = new AffineTransform3D();
+ final AffineTransform3D viewerTransformT = new AffineTransform3D();
viewerQ.state().getViewerTransform( viewerTransformT );
System.out.println( " " );
@@ -2395,6 +3268,7 @@ public void checkBoxInputMaps()
// Make it enter instead
// This is super ugly ... why does it have to be this way.
+
final TableCellEditor celled = landmarkTable.getCellEditor( 0, 1 );
final Component c = celled.getTableCellEditorComponent( landmarkTable, Boolean.TRUE, true, 0, 1 );
@@ -2414,92 +3288,6 @@ public void checkBoxInputMaps()
// SwingUtilities.replaceUIInputMap( getRootPane(), JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keybindings.getConcatenatedInputMap() );
}
- public static class BigWarpData< T >
- {
- public final List< SourceAndConverter< T > > sources;
-
- public final List< ConverterSetup > converterSetups;
-
- public final CacheControl cache;
-
- public int[] movingSourceIndices;
-
- public int[] targetSourceIndices;
-
- public final ArrayList< Integer > movingSourceIndexList;
-
- public final ArrayList< Integer > targetSourceIndexList;
-
- public final HashMap< Integer, ColorSettings > setupSettings;
-
- public final HashMap< SourceAndConverter, ColorSettings > sourceColorSettings;
-
- public BigWarpData( final List< SourceAndConverter< T > > sources, final List< ConverterSetup > converterSetups, final CacheControl cache, int[] movingSourceIndices, int[] targetSourceIndices )
- {
- this.sources = sources;
- this.converterSetups = converterSetups;
- this.movingSourceIndices = movingSourceIndices;
- this.targetSourceIndices = targetSourceIndices;
-
- this.movingSourceIndexList = new ArrayList<>();
- this.targetSourceIndexList = new ArrayList<>();
-
-
- if ( cache == null )
- this.cache = new CacheControl.Dummy();
- else
- this.cache = cache;
-
- setupSettings = new HashMap<>();
- sourceColorSettings = new HashMap<>();
- }
-
- public void wrapUp()
- {
- movingSourceIndices = movingSourceIndexList.stream().mapToInt( x -> x ).toArray();
- targetSourceIndices = targetSourceIndexList.stream().mapToInt( x -> x ).toArray();
-
- Arrays.sort( movingSourceIndices );
- Arrays.sort( targetSourceIndices );
- }
-
- /**
- * @deprecated
- */
- public void transferChannelSettings( final SetupAssignments setupAssignments, final VisibilityAndGrouping visibility )
- {
- for( Integer key : setupSettings.keySet() )
- setupSettings.get( key ).updateSetup( setupAssignments );
- }
-
- public void transferChannelSettings( final BigWarpViewerFrame viewer )
- {
- SynchronizedViewerState state = viewer.getViewerPanel().state();
- ConverterSetups setups = viewer.getConverterSetups();
- synchronized ( state )
- {
- for ( SourceAndConverter< ? > sac : state.getSources() )
- {
- if ( sourceColorSettings.containsKey( sac ) )
- {
- if ( sourceColorSettings.get( sac ) == null )
- continue;
-
- sourceColorSettings.get( sac ).updateSetup( setups.getConverterSetup( sac ) );
- }
- else
- {
- final int timepoint = state.getCurrentTimepoint();
- final Bounds bounds = InitializeViewerState.estimateSourceRange( sac.getSpimSource(), timepoint, 0.001, 0.999 );
- ConverterSetup cs = setups.getConverterSetup(sac);
- if( cs != null )
- cs.setDisplayRange( bounds.getMinBound(), bounds.getMaxBound() );
- }
- }
- }
- }
- }
-
protected class LandmarkModeListener implements KeyEventPostProcessor
{
@Override
@@ -2602,7 +3390,7 @@ public void mousePressed( final MouseEvent e )
@Override
public void mouseReleased( final MouseEvent e )
{
- long clickLength = System.currentTimeMillis() - pressTime;
+ final long clickLength = System.currentTimeMillis() - pressTime;
if( clickLength < keyClickMaxLength && selectedPointIndex != -1 )
return;
@@ -2610,7 +3398,7 @@ public void mouseReleased( final MouseEvent e )
// shift when
boolean isMovingLocal = isMoving;
if ( e.isShiftDown() && e.isControlDown() )
- {
+ {
isMovingLocal = !isMoving;
}
else if( e.isShiftDown())
@@ -2677,7 +3465,6 @@ public void mouseDragged( final MouseEvent e )
thisViewer.doUpdateOnDrag() &&
BigWarp.this.landmarkModel.isActive( selectedPointIndex ) )
{
- logger.trace("Drag resolve");
solverThread.requestResolve( isMoving, selectedPointIndex, ptarrayLoc );
}
else
@@ -2686,7 +3473,6 @@ public void mouseDragged( final MouseEvent e )
// the undoable action is added on mouseRelease
if( isMoving && isMovingDisplayTransformed() )
{
- logger.trace("Drag moving transformed");
// The moving image:
// Update the warped point during the drag even if there is a corresponding fixed image point
// Do this so the point sticks on the mouse
@@ -2698,7 +3484,6 @@ public void mouseDragged( final MouseEvent e )
}
else
{
- logger.trace("Drag default");
// The fixed image
BigWarp.this.landmarkModel.pointEdit( selectedPointIndex, ptarrayLoc, false, isMoving, false, false, currentTransform );
thisViewer.requestRepaint();
@@ -2711,7 +3496,7 @@ public void mouseDragged( final MouseEvent e )
public void mouseMoved( final MouseEvent e )
{
thisViewer.getGlobalMouseCoordinates( hoveredPoint );
- int hoveredIndex = BigWarp.this.selectedLandmark( hoveredArray, isMoving, false );
+ final int hoveredIndex = BigWarp.this.selectedLandmark( hoveredArray, isMoving, false );
thisViewer.setHoveredIndex( hoveredIndex );
}
@@ -2747,8 +3532,8 @@ public class WarningTableCellRenderer extends DefaultTableCellRenderer
@Override
public Component getTableCellRendererComponent( JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column )
{
- LandmarkTableModel model = ( LandmarkTableModel ) table.getModel();
- Component c = super.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column );
+ final LandmarkTableModel model = ( LandmarkTableModel ) table.getModel();
+ final Component c = super.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column );
if ( model.rowNeedsWarning( row ) )
c.setBackground( LandmarkTableModel.WARNINGBGCOLOR );
else
@@ -2764,11 +3549,12 @@ public void tableChanged( final TableModelEvent e )
{
// re-estimate if a a point was set to or from active
// note - this covers "resetting" points as well
- if( e.getColumn() == LandmarkTableModel.ACTIVECOLUMN )
+ if ( e.getColumn() == LandmarkTableModel.ACTIVECOLUMN )
{
BigWarp.this.restimateTransformation();
BigWarp.this.landmarkPanel.repaint();
}
+ autoEstimateMask();
}
}
@@ -2895,11 +3681,43 @@ public void mouseReleased( final MouseEvent e )
public void setTransformType( final String type )
{
- transformSelector.setTransformType( type );
- bwTransform.setTransformType( type );
+ updateTransformTypePanel(type);
+ updateTransformTypeDialog(type);
+ bwTransform.setTransformType(type);
this.restimateTransformation();
}
+ public void setTransformTypeUpdateUI( final String type )
+ {
+ setTransformType( type );
+ updateTransformTypeDialog( type );
+ updateTransformTypePanel( type );
+ }
+
+ /**
+ * Update the transformation selection dialog to reflect the given transform type selection.
+ *
+ * @param type the transformation type
+ */
+ public void updateTransformTypeDialog( final String type )
+ {
+ transformSelector.deactivate();
+ transformSelector.setTransformType( type );
+ transformSelector.activate();
+ }
+
+ /**
+ * Update the transformation selection panel in the options dialog to reflect the given transform type selection.
+ *
+ * @param type the transformation type
+ */
+ public void updateTransformTypePanel( final String type )
+ {
+ warpVisDialog.transformTypePanel.deactivate();
+ warpVisDialog.transformTypePanel.setType( type );
+ warpVisDialog.transformTypePanel.activate();
+ }
+
public String getTransformType()
{
return bwTransform.getTransformType();
@@ -2916,8 +3734,9 @@ public BoundingBoxEstimation getBoxEstimation()
}
/**
- * Use getTps, getTpsBase, or getTransformation instead
- * @return
+ * @deprecated Use getTps, getTpsBase, or getTransformation instead
+ *
+ * @return the {@link ThinPlateR2LogRSplineKernelTransform} iinnstance
*/
@Deprecated
public ThinPlateR2LogRSplineKernelTransform getTransform()
@@ -3012,7 +3831,7 @@ public void run()
{
try
{
- InvertibleRealTransform invXfm = bw.bwTransform.getTransformation( index );
+ final InvertibleRealTransform invXfm = bw.bwTransform.getTransformation( index );
if ( invXfm == null )
return;
@@ -3032,7 +3851,9 @@ public void run()
else
{
// update the transform and warped point
- bw.setTransformationMovingSourceOnly( invXfm );
+// bw.setTransformationMovingSourceOnly( invXfm );
+// bw.data.updateEditableTransformation( invXfm );
+ bw.setTransformationAll( invXfm );
}
// update fixed point - but don't allow undo/redo
@@ -3044,7 +3865,7 @@ public void run()
}
/*
- * repaint both panels so that:
+ * repaint both panels so that:
* 1) new transform is displayed
* 2) points are rendered
*/
@@ -3089,26 +3910,7 @@ public void requestResolve( final boolean isMoving, final int index, final doubl
notify();
}
}
-
- }
-
- /**
- * Set the folder where the results of auto-saving will be stored.
- *
- * @param autoSaveFolder the destination folder
- */
- public void setAutosaveFolder( final File autoSaveFolder )
- {
- boolean exists = autoSaveFolder.exists();
- if( !exists )
- exists = autoSaveFolder.mkdir();
- if( exists && autoSaveFolder.isDirectory() )
- {
- this.autoSaveDirectory = autoSaveFolder;
- warpVisDialog.autoSaveFolderText.setText( autoSaveFolder.getAbsolutePath() );
- warpVisDialog.repaint();
- }
}
/**
@@ -3117,12 +3919,12 @@ public void setAutosaveFolder( final File autoSaveFolder )
public void autoSaveLandmarks()
{
final File baseFolder;
- if( autoSaveDirectory != null )
- baseFolder = autoSaveDirectory;
+ if ( autoSaver.autoSaveDirectory != null )
+ baseFolder = autoSaver.autoSaveDirectory;
else
baseFolder = getBigwarpSettingsFolder();
- File proposedLandmarksFile = new File( baseFolder.getAbsolutePath() +
+ final File proposedLandmarksFile = new File( baseFolder.getAbsolutePath() +
File.separator + "bigwarp_landmarks_" +
new SimpleDateFormat( "yyyyMMdd-HHmmss" ).format( Calendar.getInstance().getTime() ) +
".csv" );
@@ -3131,13 +3933,13 @@ public void autoSaveLandmarks()
{
saveLandmarks( proposedLandmarksFile.getCanonicalPath() );
}
- catch ( IOException e ) { e.printStackTrace(); }
+ catch ( final IOException e ) { e.printStackTrace(); }
}
/**
* Saves landmarks to either the last File the user
* saved landmarks to, or a unique location in the user's bigwarp folder.
- *
+ *
*/
public void quickSaveLandmarks()
{
@@ -3147,7 +3949,7 @@ public void quickSaveLandmarks()
{
saveLandmarks( lastLandmarks.getCanonicalPath() );
}
- catch ( IOException e ) { e.printStackTrace(); }
+ catch ( final IOException e ) { e.printStackTrace(); }
}
else
{
@@ -3158,7 +3960,7 @@ public void quickSaveLandmarks()
/**
* Returns the default location for bigwarp settings / auto saved files: ~/.bigwarp
- * @return the folder
+ * @return the folder
*/
public File getBigwarpSettingsFolder()
{
@@ -3178,8 +3980,8 @@ public File getBigwarpSettingsFolder()
/**
* Returns the {@link BigWarpAutoSaver}.
- *
- * @return
+ *
+ * @return the {@link BigWarpAutoSaver} instance.
*/
public BigWarpAutoSaver getAutoSaver()
{
@@ -3190,7 +3992,7 @@ public void stopAutosave()
{
if( autoSaver != null )
{
- autoSaver.stop();;
+ autoSaver.stop();
autoSaver = null;
}
}
@@ -3222,7 +4024,10 @@ protected void saveLandmarks()
protected void saveLandmarks( final String filename ) throws IOException
{
- landmarkModel.save(new File( filename ));
+ if( filename.endsWith("csv"))
+ landmarkModel.save(new File( filename ));
+ else if( filename.endsWith("json"))
+ TransformWriterJson.write(landmarkModel, bwTransform, new File( filename ));
}
protected void loadLandmarks()
@@ -3247,18 +4052,26 @@ protected void loadLandmarks()
public void loadLandmarks( final String filename )
{
- File file = new File( filename );
+ final File file = new File( filename );
setLastDirectory( file.getParentFile() );
- try
+
+ if( filename.endsWith( "csv" ))
{
- landmarkModel.load( file );
+ try
+ {
+ landmarkModel.load( file );
+ }
+ catch ( final IOException e1 )
+ {
+ e1.printStackTrace();
+ }
}
- catch ( final IOException e1 )
+ else if( filename.endsWith( "json" ))
{
- e1.printStackTrace();
+ TransformWriterJson.read( file, this );
}
- boolean didCompute = restimateTransformation();
+ final boolean didCompute = restimateTransformation();
// didCompute = false means that there were not enough points
// in the loaded points, so we should display the 'raw' moving
@@ -3266,25 +4079,48 @@ public void loadLandmarks( final String filename )
if ( !didCompute )
setIsMovingDisplayTransformed( false );
+ autoEstimateMask();
+
viewerP.requestRepaint();
viewerQ.requestRepaint();
landmarkFrame.repaint();
}
protected void saveSettings()
+ {
+ final File proposedSettingsFile = new File( "bigwarp.settings.xml" );
+ saveSettingsOrProject( proposedSettingsFile );
+ }
+
+ protected void saveProject()
+ {
+ final File proposedSettingsFile = new File( "bigwarp-project.json" );
+ saveSettingsOrProject( proposedSettingsFile );
+ }
+
+ protected void saveSettingsOrProject( final File proposedFile )
{
final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
- File proposedSettingsFile = new File( "bigwarp.settings.xml" );
- fileChooser.setSelectedFile( proposedSettingsFile );
+ File settingsFile;
+ fileChooser.setSelectedFile( proposedFile );
final int returnVal = fileChooser.showSaveDialog( null );
if ( returnVal == JFileChooser.APPROVE_OPTION )
{
- proposedSettingsFile = fileChooser.getSelectedFile();
+ settingsFile = fileChooser.getSelectedFile();
try
{
- saveSettings( proposedSettingsFile.getCanonicalPath() );
- } catch ( final IOException e )
+ final String canonicalPath = settingsFile.getCanonicalPath();
+ if ( canonicalPath.endsWith( ".xml" ) )
+ {
+ saveSettings( canonicalPath );
+ }
+ else
+ {
+ saveSettingsJson( canonicalPath );
+ }
+ }
+ catch ( final IOException e )
{
e.printStackTrace();
}
@@ -3295,8 +4131,8 @@ protected void saveSettings( final String xmlFilename ) throws IOException
{
final Element root = new Element( "Settings" );
- Element viewerPNode = new Element( "viewerP" );
- Element viewerQNode = new Element( "viewerQ" );
+ final Element viewerPNode = new Element( "viewerP" );
+ final Element viewerQNode = new Element( "viewerQ" );
root.addContent( viewerPNode );
root.addContent( viewerQNode );
@@ -3309,8 +4145,8 @@ protected void saveSettings( final String xmlFilename ) throws IOException
final Element autoSaveNode = new Element( "autosave" );
final Element autoSaveLocation = new Element( "location" );
- if( autoSaveDirectory != null )
- autoSaveLocation.setText( autoSaveDirectory.getAbsolutePath() );
+ if ( autoSaver != null && autoSaver.autoSaveDirectory != null )
+ autoSaveLocation.setText( autoSaver.autoSaveDirectory.getAbsolutePath() );
else
autoSaveLocation.setText( getBigwarpSettingsFolder().getAbsolutePath() );
@@ -3320,53 +4156,183 @@ protected void saveSettings( final String xmlFilename ) throws IOException
autoSaveNode.addContent( autoSaveLocation );
autoSaveNode.addContent( autoSavePeriod );
- root.addContent( autoSaveNode );
+ root.addContent( autoSaveNode );
+ if ( transformMask != null )
+ {
+ // TODO check if is imported mask
+ root.addContent( plateauTransformMask.getRandomAccessible().toXml() );
+ }
final Document doc = new Document( root );
final XMLOutputter xout = new XMLOutputter( Format.getPrettyFormat() );
xout.output( doc, new FileWriter( xmlFilename ) );
}
+ protected void saveSettingsJson( final String jsonFilename ) throws IOException
+ {
+ final BigwarpSettings settings = getSettings();
+ settings.serialize( jsonFilename );
+ }
+
+ public BigwarpSettings getSettings()
+ {
+ return new BigwarpSettings(
+ this,
+ viewerP,
+ viewerQ,
+ setupAssignments,
+ bookmarks,
+ autoSaver,
+ landmarkModel,
+ bwTransform,
+ data.sourceInfos
+ );
+ }
+
protected void loadSettings()
+ {
+ loadSettingsOrProject( new File( "bigwarp.settings.xml" ) );
+ }
+
+ protected void loadProject()
+ {
+ loadSettingsOrProject( new File( "bigwarp-project.json" ) );
+ }
+
+ protected void loadSettingsOrProject( final File f )
{
final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
- File proposedSettingsFile = new File( "bigwarp.settings.xml" );
- fileChooser.setSelectedFile( proposedSettingsFile );
+ File settingsFile;
+ fileChooser.setSelectedFile( f );
final int returnVal = fileChooser.showOpenDialog( null );
if ( returnVal == JFileChooser.APPROVE_OPTION )
{
- proposedSettingsFile = fileChooser.getSelectedFile();
- try
- {
- loadSettings( proposedSettingsFile.getCanonicalPath() );
- } catch ( final Exception e )
- {
+ settingsFile = fileChooser.getSelectedFile();
+
+ try {
+ loadSettings(settingsFile.getCanonicalPath(), true);
+ } catch (IOException | JDOMException e) {
e.printStackTrace();
}
+
+// try {
+// SwingUtilities.invokeAndWait( () -> {
+// try {
+// loadSettings(settingsFile.getCanonicalPath(), true);
+// } catch (final IOException e) {
+// e.printStackTrace();
+// } catch (final JDOMException e) {
+// e.printStackTrace();
+// }
+// });
+// } catch (final Exception e) {
+// e.printStackTrace();
+// }
+
+ // TODO I may need this
+// Executors.newSingleThreadExecutor().execute(new Runnable() {
+// @Override
+// public void run() {
+// try {
+// loadSettings(settingsFile.getCanonicalPath(), true);
+// } catch (final Exception e) {
+// e.printStackTrace();
+// }
+// }
+// });
+ }
+ }
+
+ private void addInternalSource(int id) {
+ final boolean sourceWithIdPresent = data.sources.stream().map( it -> it.getConverter()).filter( it -> it instanceof ConverterSetup ).filter( it -> ( ( ConverterSetup ) it ).getSetupId() == id ).findAny().isPresent();
+ if (sourceWithIdPresent) {
+ return;
+ }
+ switch ( id )
+ {
+ case GRID_SOURCE_ID:
+ gridSource = addGridSource( ndims, data, "GridSource" );
+ setGridType( GridSource.GRID_TYPE.LINE );
+ break;
+ case WARPMAG_SOURCE_ID:
+ warpMagSource = addWarpMagnitudeSource( data, ndims == 2, "Warp magnitude" );
+ break;
+ case JACDET_SOURCE_ID:
+ jacDetSource = addJacobianDeterminantSource( ndims, data, "Jacobian determinant" );
+ break;
+ case TRANSFORM_MASK_SOURCE_ID:
+ updateTransformMask();
+ break;
+ default:
+ break;
}
}
- protected void loadSettings( final String xmlFilename ) throws IOException,
+ public void loadSettings( final String jsonOrXmlFilename ) throws IOException,
+ JDOMException
+ {
+ loadSettings( jsonOrXmlFilename, false );
+ }
+
+ public void loadSettings( final String jsonOrXmlFilename, boolean overwriteSources ) throws IOException,
JDOMException
{
- final SAXBuilder sax = new SAXBuilder();
- final Document doc = sax.build( xmlFilename );
- final Element root = doc.getRootElement();
- viewerP.stateFromXml( root.getChild( "viewerP" ) );
- viewerQ.stateFromXml( root.getChild( "viewerQ" ) );
- setupAssignments.restoreFromXml( root );
- bookmarks.restoreFromXml( root );
- activeSourcesDialogP.update();
- activeSourcesDialogQ.update();
-
- // auto-save settings
- Element autoSaveElem = root.getChild( "autosave" );
- final String autoSavePath = autoSaveElem.getChild( "location" ).getText();
- final long autoSavePeriod = Integer.parseInt( autoSaveElem.getChild( "period" ).getText());
- setAutosaveFolder( new File( autoSavePath ));
- BigWarpAutoSaver.setAutosaveOptions( this, autoSavePeriod, autoSavePath );
+ if ( jsonOrXmlFilename.endsWith( ".xml" ) )
+ {
+ final SAXBuilder sax = new SAXBuilder();
+ final Document doc = sax.build( jsonOrXmlFilename );
+ final Element root = doc.getRootElement();
+
+ /* add default sources if present */
+ final List< Element > converterSetups = root.getChild( "SetupAssignments" ).getChild( "ConverterSetups" ).getChildren( "ConverterSetup" );
+ for ( final Element converterSetup : converterSetups )
+ {
+ final int id = Integer.parseInt( converterSetup.getChild( "id" ).getText() );
+ addInternalSource( id );
+ }
+ synchronizeSources();
+
+ viewerP.stateFromXml( root.getChild( "viewerP" ) );
+ viewerQ.stateFromXml( root.getChild( "viewerQ" ) );
+ setupAssignments.restoreFromXml( root );
+ bookmarks.restoreFromXml( root );
+ activeSourcesDialogP.update();
+ activeSourcesDialogQ.update();
+
+ // auto-save settings
+ final Element autoSaveElem = root.getChild( "autosave" );
+ final String autoSavePath = autoSaveElem.getChild( "location" ).getText();
+ final long autoSavePeriod = Integer.parseInt( autoSaveElem.getChild( "period" ).getText() );
+ BigWarpAutoSaver.setAutosaveOptions( this, autoSavePeriod, autoSavePath );
+
+ // TODO check if is imported mask
+ final Element maskSettings = root.getChild( "transform-mask" );
+ if ( maskSettings != null )
+ plateauTransformMask.getRandomAccessible().fromXml( maskSettings );
+ }
+ else
+ {
+ final BigwarpSettings settings = getSettings();
+ settings.setOverwriteSources( overwriteSources );
+ settings.read( new JsonReader( new FileReader( jsonOrXmlFilename ) ) );
+
+ // TODO I may need this
+// Executors.newSingleThreadExecutor().execute(new Runnable() {
+// @Override
+// public void run() {
+// try {
+// settings.read( new JsonReader( new FileReader( jsonOrXmlFilename ) ) );
+// } catch (final Exception e) {
+// e.printStackTrace();
+// }
+// }
+// });
+
+ activeSourcesDialogP.update();
+ activeSourcesDialogQ.update();
+ }
viewerFrameP.repaint();
viewerFrameQ.repaint();
diff --git a/src/main/java/bigwarp/BigWarp.java.orig b/src/main/java/bigwarp/BigWarp.java.orig
new file mode 100755
index 00000000..d73e3fe6
--- /dev/null
+++ b/src/main/java/bigwarp/BigWarp.java.orig
@@ -0,0 +1,3632 @@
+/*-
+ * #%L
+ * BigWarp plugin for Fiji.
+ * %%
+ * Copyright (C) 2015 - 2021 Howard Hughes Medical Institute.
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program. If not, see
+ * .
+ * #L%
+ */
+package bigwarp;
+
+<<<<<<< HEAD
+import bdv.viewer.ConverterSetups;
+import bdv.viewer.DisplayMode;
+import bdv.viewer.TransformListener;
+import bdv.viewer.ViewerState;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.FileDialog;
+import java.awt.KeyEventPostProcessor;
+import java.awt.KeyboardFocusManager;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionListener;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+
+import javax.swing.ActionMap;
+import javax.swing.InputMap;
+import javax.swing.JCheckBox;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JTable;
+import javax.swing.KeyStroke;
+import javax.swing.SwingUtilities;
+import javax.swing.Timer;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellEditor;
+
+import mpicbg.spim.data.SpimData;
+import mpicbg.spim.data.XmlIoSpimData;
+import mpicbg.spim.data.registration.ViewTransformAffine;
+
+import org.janelia.saalfeldlab.n5.Compression;
+import org.janelia.saalfeldlab.n5.ij.N5Exporter;
+import org.janelia.utility.geom.BoundingSphereRitter;
+import org.janelia.utility.geom.Sphere;
+import org.janelia.utility.ui.RepeatingReleasedEventsFixer;
+import org.jdom2.Document;
+import org.jdom2.Element;
+import org.jdom2.JDOMException;
+import org.jdom2.input.SAXBuilder;
+import org.jdom2.output.Format;
+import org.jdom2.output.XMLOutputter;
+import org.scijava.ui.behaviour.io.InputTriggerConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+=======
+>>>>>>> cmhulbert/jsonSettings
+import bdv.BigDataViewer;
+import bdv.cache.CacheControl;
+import bdv.export.ProgressWriter;
+import bdv.export.ProgressWriterConsole;
+import bdv.gui.BigWarpLandmarkPanel;
+import bdv.gui.BigWarpMessageAnimator;
+import bdv.gui.BigWarpViewerFrame;
+import bdv.gui.BigWarpViewerOptions;
+import bdv.gui.BigwarpLandmarkSelectionPanel;
+import bdv.gui.LandmarkKeyboardProcessor;
+import bdv.gui.MaskedSourceEditorMouseListener;
+import bdv.gui.TransformTypeSelectDialog;
+import bdv.ij.ApplyBigwarpPlugin;
+import bdv.ij.ApplyBigwarpPlugin.WriteDestinationOptions;
+import bdv.ij.BigWarpToDeformationFieldPlugIn;
+import bdv.ij.util.ProgressWriterIJ;
+import bdv.img.WarpedSource;
+import bdv.tools.InitializeViewerState;
+import bdv.tools.VisibilityAndGroupingDialog;
+import bdv.tools.bookmarks.Bookmarks;
+import bdv.tools.bookmarks.BookmarksEditor;
+import bdv.tools.brightness.BrightnessDialog;
+import bdv.tools.brightness.ConverterSetup;
+import bdv.tools.brightness.SetupAssignments;
+import bdv.util.Bounds;
+import bdv.viewer.BigWarpDragOverlay;
+import bdv.viewer.BigWarpLandmarkFrame;
+import bdv.viewer.BigWarpOverlay;
+import bdv.viewer.BigWarpViewerPanel;
+import bdv.viewer.BigWarpViewerSettings;
+import bdv.viewer.ConverterSetups;
+import bdv.viewer.DisplayMode;
+import bdv.viewer.Interpolation;
+import bdv.viewer.LandmarkPointMenu;
+import bdv.viewer.MultiBoxOverlay2d;
+import bdv.viewer.Source;
+import bdv.viewer.SourceAndConverter;
+import bdv.viewer.SynchronizedViewerState;
+import bdv.viewer.TransformListener;
+import bdv.viewer.ViewerPanel;
+import bdv.viewer.ViewerState;
+import bdv.viewer.VisibilityAndGrouping;
+import bdv.viewer.WarpNavigationActions;
+import bdv.viewer.animate.SimilarityModel3D;
+import bdv.viewer.animate.TranslationAnimator;
+import bdv.viewer.overlay.BigWarpMaskSphereOverlay;
+import bdv.viewer.overlay.BigWarpSourceOverlayRenderer;
+import bdv.viewer.overlay.MultiBoxOverlayRenderer;
+import bigwarp.landmarks.LandmarkTableModel;
+import bigwarp.loader.ImagePlusLoader.ColorSettings;
+import bigwarp.source.GridSource;
+import bigwarp.source.JacobianDeterminantSource;
+import bigwarp.source.PlateauSphericalMaskSource;
+import bigwarp.source.WarpMagnitudeSource;
+import bigwarp.transforms.BigWarpTransform;
+import bigwarp.transforms.WrappedCoordinateTransform;
+import bigwarp.transforms.io.TransformWriterJson;
+import bigwarp.util.BigWarpUtils;
+import com.google.common.collect.Lists;
+import com.google.gson.stream.JsonReader;
+import fiji.util.gui.GenericDialogPlus;
+import ij.IJ;
+import ij.ImageJ;
+import ij.ImagePlus;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.FileDialog;
+import java.awt.KeyEventPostProcessor;
+import java.awt.KeyboardFocusManager;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionListener;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import javax.swing.ActionMap;
+import javax.swing.InputMap;
+import javax.swing.JCheckBox;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JTable;
+import javax.swing.KeyStroke;
+import javax.swing.SwingUtilities;
+import javax.swing.Timer;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellEditor;
+import jitk.spline.ThinPlateR2LogRSplineKernelTransform;
+import jitk.spline.XfmUtils;
+import mpicbg.models.AbstractModel;
+import mpicbg.models.AffineModel2D;
+import mpicbg.models.AffineModel3D;
+import mpicbg.models.CoordinateTransform;
+import mpicbg.models.IllDefinedDataPointsException;
+import mpicbg.models.InvertibleCoordinateTransform;
+import mpicbg.models.NotEnoughDataPointsException;
+import mpicbg.models.RigidModel2D;
+import mpicbg.models.RigidModel3D;
+import mpicbg.models.SimilarityModel2D;
+import mpicbg.models.TranslationModel2D;
+import mpicbg.models.TranslationModel3D;
+import mpicbg.spim.data.SpimData;
+import mpicbg.spim.data.SpimDataException;
+import mpicbg.spim.data.XmlIoSpimData;
+import mpicbg.spim.data.registration.ViewTransformAffine;
+import net.imglib2.FinalInterval;
+import net.imglib2.Interval;
+import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.RealPoint;
+import net.imglib2.display.RealARGBColorConverter;
+import net.imglib2.realtransform.AffineTransform3D;
+import net.imglib2.realtransform.BoundingBoxEstimation;
+import net.imglib2.realtransform.InvertibleRealTransform;
+import net.imglib2.realtransform.RealTransform;
+import net.imglib2.realtransform.ThinplateSplineTransform;
+import net.imglib2.realtransform.Wrapped2DTransformAs3D;
+import net.imglib2.realtransform.inverse.RealTransformFiniteDerivatives;
+import net.imglib2.realtransform.inverse.WrappedIterativeInvertibleRealTransform;
+import net.imglib2.type.numeric.ARGBType;
+import net.imglib2.type.numeric.real.AbstractRealType;
+import net.imglib2.type.numeric.real.DoubleType;
+import net.imglib2.type.numeric.real.FloatType;
+import org.janelia.saalfeldlab.n5.Compression;
+import org.janelia.saalfeldlab.n5.ij.N5Exporter;
+import org.janelia.utility.geom.BoundingSphereRitter;
+import org.janelia.utility.geom.Sphere;
+import org.janelia.utility.ui.RepeatingReleasedEventsFixer;
+import org.jdom2.Document;
+import org.jdom2.Element;
+import org.jdom2.JDOMException;
+import org.jdom2.input.SAXBuilder;
+import org.jdom2.output.Format;
+import org.jdom2.output.XMLOutputter;
+import org.scijava.ui.behaviour.io.InputTriggerConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class BigWarp< T >
+{
+
+ protected static final int DEFAULT_WIDTH = 600;
+
+ protected static final int DEFAULT_HEIGHT = 400;
+
+ public static final int GRID_SOURCE_ID = 1696993146;
+
+ public static final int WARPMAG_SOURCE_ID = 956736363;
+
+ public static final int JACDET_SOURCE_ID = 1006827158;
+
+ public static final int TRANSFORM_MASK_SOURCE_ID = 33872301;
+
+ protected BigWarpViewerOptions options;
+
+ protected BigWarpData< T > data;
+
+ // descriptive names for indexing sources
+ protected int[] movingSourceIndexList;
+
+ protected int[] targetSourceIndexList;
+
+ protected List< SourceAndConverter< T > > sources;
+
+ protected final SetupAssignments setupAssignments;
+
+ protected final BrightnessDialog brightnessDialog;
+
+ protected final WarpVisFrame warpVisDialog;
+
+ protected final HelpDialog helpDialog;
+
+ protected final SourceInfoDialog sourceInfoDialog;
+
+ protected final VisibilityAndGroupingDialog activeSourcesDialogP;
+
+ protected final VisibilityAndGroupingDialog activeSourcesDialogQ;
+
+ final AffineTransform3D fixedViewXfm;
+
+ private Bookmarks bookmarks;
+
+ protected final BookmarksEditor bookmarkEditorP;
+
+ protected final BookmarksEditor bookmarkEditorQ;
+
+ private final BigWarpViewerFrame viewerFrameP;
+
+ private final BigWarpViewerFrame viewerFrameQ;
+
+ protected final BigWarpViewerPanel viewerP;
+
+ protected final BigWarpViewerPanel viewerQ;
+
+ protected final AffineTransform3D initialViewP;
+
+ protected final AffineTransform3D initialViewQ;
+
+ private JMenuItem toggleAlwaysWarpMenuP;
+
+ private JMenuItem toggleAlwaysWarpMenuQ;
+
+ protected BigWarpLandmarkPanel landmarkPanel;
+
+ protected final LandmarkPointMenu landmarkPopupMenu;
+
+ protected final BigWarpLandmarkFrame landmarkFrame;
+
+ protected final BigWarpViewerSettings viewerSettings;
+
+ protected final BigWarpOverlay overlayP;
+
+ protected final BigWarpOverlay overlayQ;
+
+ protected final BigWarpDragOverlay dragOverlayP;
+
+ protected final BigWarpDragOverlay dragOverlayQ;
+
+ protected RealPoint currentLandmark;
+
+ protected LandmarkTableModel landmarkModel;
+
+ protected InvertibleRealTransform currentTransform;
+
+ protected JTable landmarkTable;
+
+ protected LandmarkTableListener landmarkModellistener;
+
+ protected MouseLandmarkListener landmarkClickListenerP;
+
+ protected MouseLandmarkListener landmarkClickListenerQ;
+
+ protected MouseLandmarkTableListener landmarkTableListener;
+
+ protected MaskedSourceEditorMouseListener maskSourceMouseListenerP;
+
+ protected MaskedSourceEditorMouseListener maskSourceMouseListenerQ;
+
+ protected BigWarpMessageAnimator message;
+
+ protected final Set< KeyEventPostProcessor > keyEventPostProcessorSet = new HashSet< KeyEventPostProcessor >();
+
+ private final RepeatingReleasedEventsFixer repeatedKeyEventsFixer;
+
+ protected final SourceAndConverter< FloatType > gridSource;
+
+ protected final SourceAndConverter< FloatType > warpMagSource;
+
+ protected final SourceAndConverter< FloatType > jacDetSource;
+
+ protected final SourceAndConverter< DoubleType > transformMaskSource;
+
+ protected PlateauSphericalMaskSource transformMask;
+
+ protected final AbstractModel< ? >[] baseXfmList;
+
+ private final double[] ptBack;
+
+ private SolveThread solverThread;
+
+ private BigWarpTransform bwTransform;
+
+ private BoundingBoxEstimation bboxOptions;
+
+ private long keyClickMaxLength = 250;
+
+ protected TransformTypeSelectDialog transformSelector;
+
+ protected AffineTransform3D tmpTransform = new AffineTransform3D();
+
+ /*
+ * landmarks are placed on clicks only if we are inLandmarkMode during the
+ * click
+ */
+ protected boolean inLandmarkMode;
+
+ protected int baselineModelIndex;
+
+ // file selection
+ final JFrame fileFrame;
+
+ final FileDialog fileDialog;
+
+ protected File lastDirectory;
+
+ protected File lastLandmarks;
+
+ protected BigWarpAutoSaver autoSaver;
+
+ protected boolean updateWarpOnPtChange = false;
+
+ protected boolean firstWarpEstimation = true;
+
+ JMenu fileMenu;
+
+ final ProgressWriter progressWriter;
+
+ private static ImageJ ij;
+
+ protected static Logger logger = LoggerFactory.getLogger( BigWarp.class );
+
+ private SpimData movingSpimData;
+
+ private File movingImageXml;
+
+ private CopyOnWriteArrayList< TransformListener< InvertibleRealTransform > > transformListeners = new CopyOnWriteArrayList<>( );
+
+ final int ndims;
+
+ public BigWarp( final BigWarpData data, final String windowTitle, final ProgressWriter progressWriter ) throws SpimDataException
+ {
+ this( data, windowTitle, BigWarpViewerOptions.options( ( detectNumDims( data.sources ) == 2 ) ), progressWriter );
+ }
+
+ public BigWarp( final BigWarpData data, final String windowTitle, BigWarpViewerOptions options, final ProgressWriter progressWriter ) throws SpimDataException
+ {
+ repeatedKeyEventsFixer = RepeatingReleasedEventsFixer.installAnyTime();
+
+ ij = IJ.getInstance();
+
+ if( progressWriter == null )
+ this.progressWriter = new ProgressWriterConsole();
+ else
+ this.progressWriter = progressWriter;
+
+ this.data = data;
+ this.options = options;
+
+ ptBack = new double[ 3 ];
+ if( options.is2d )
+ ndims = 2;
+ else
+ ndims = 3;
+
+ /*
+ * Set up LandmarkTableModel, holds the data and interfaces with the
+ * LandmarkPanel
+ */
+ landmarkModel = new LandmarkTableModel( ndims );
+ landmarkModellistener = new LandmarkTableListener();
+ landmarkModel.addTableModelListener( landmarkModellistener );
+ addTransformListener( landmarkModel );
+
+ /* Set up landmark panel */
+ landmarkPanel = new BigWarpLandmarkPanel( landmarkModel );
+ landmarkPanel.setOpaque( true );
+ landmarkTable = landmarkPanel.getJTable();
+ landmarkTable.setDefaultRenderer( Object.class, new WarningTableCellRenderer() );
+ addDefaultTableMouseListener();
+
+ landmarkFrame = new BigWarpLandmarkFrame( "Landmarks", landmarkPanel, this );
+
+ baseXfmList = new AbstractModel< ? >[ 3 ];
+ setupWarpMagBaselineOptions( baseXfmList, ndims );
+
+ fixedViewXfm = new AffineTransform3D();
+ //sources.get( targetSourceIndexList[ 0 ] ).getSpimSource().getSourceTransform( 0, 0, fixedViewXfm );
+ data.sources.get( data.targetSourceIndices[ 0 ] ).getSpimSource().getSourceTransform( 0, 0, fixedViewXfm );
+
+ baselineModelIndex = 0;
+ warpMagSource = addWarpMagnitudeSource( data, "WarpMagnitudeSource" );
+ jacDetSource = addJacobianDeterminantSource( data, "JacobianDeterminantSource" );
+ gridSource = addGridSource( data, "GridSource" );
+ transformMaskSource = addTransformMaskSource( data, ndims, "Transform Mask Source" );
+
+ this.sources = this.data.sources;
+ final List< ConverterSetup > converterSetups = data.converterSetups;
+ this.movingSourceIndexList = data.movingSourceIndices;
+ this.targetSourceIndexList = data.targetSourceIndices;
+ Arrays.sort( movingSourceIndexList );
+ Arrays.sort( targetSourceIndexList );
+
+ sources = wrapSourcesAsTransformed( data.sources, ndims, data );
+
+ setGridType( GridSource.GRID_TYPE.LINE );
+
+ viewerSettings = new BigWarpViewerSettings();
+
+ // key properties
+ final InputTriggerConfig keyProperties = BigDataViewer.getInputTriggerConfig( options );
+ options = options.inputTriggerConfig( keyProperties );
+
+ // Viewer frame for the moving image
+ viewerFrameP = new BigWarpViewerFrame( this, DEFAULT_WIDTH, DEFAULT_HEIGHT, (List)sources, converterSetups, viewerSettings,
+ data.cache, options, "Bigwarp moving image", true, movingSourceIndexList, targetSourceIndexList );
+
+ viewerP = getViewerFrameP().getViewerPanel();
+
+ // Viewer frame for the fixed image
+ viewerFrameQ = new BigWarpViewerFrame( this, DEFAULT_WIDTH, DEFAULT_HEIGHT, (List)sources, converterSetups, viewerSettings,
+ data.cache, options, "Bigwarp fixed image", false, movingSourceIndexList, targetSourceIndexList );
+
+ viewerQ = getViewerFrameQ().getViewerPanel();
+
+ // setup messaging
+ message = options.getMessageAnimator();
+ message.setViewers( viewerP, viewerQ );
+ landmarkModel.setMessage( message );
+
+ // If the images are 2d, use a transform handler that limits
+ // transformations to rotations and scalings of the 2d plane ( z = 0 )
+ if ( options.is2d )
+ {
+
+ final Class< ViewerPanel > c_vp = ViewerPanel.class;
+ try
+ {
+ final Field overlayRendererField = c_vp.getDeclaredField( "multiBoxOverlayRenderer" );
+ overlayRendererField.setAccessible( true );
+
+ final MultiBoxOverlayRenderer overlayRenderP = new MultiBoxOverlayRenderer( DEFAULT_WIDTH, DEFAULT_HEIGHT );
+ final MultiBoxOverlayRenderer overlayRenderQ = new MultiBoxOverlayRenderer( DEFAULT_WIDTH, DEFAULT_HEIGHT );
+
+ // TODO hopefully I won't' need reflection any more
+ final Field boxField = overlayRenderP.getClass().getDeclaredField( "box" );
+ boxField.setAccessible( true );
+ boxField.set( overlayRenderP, new MultiBoxOverlay2d() );
+ boxField.set( overlayRenderQ, new MultiBoxOverlay2d() );
+ boxField.setAccessible( false );
+
+ overlayRendererField.set( viewerP, overlayRenderP );
+ overlayRendererField.set( viewerQ, overlayRenderQ );
+ overlayRendererField.setAccessible( false );
+
+ }
+ catch ( final Exception e )
+ {
+ e.printStackTrace();
+ }
+ }
+
+ try
+ {
+ // TODO hopefully I won't' need reflection any more
+ final Class< ViewerPanel > c_vp = ViewerPanel.class;
+ final Field sourceInfoOverlayRendererField = c_vp.getDeclaredField( "sourceInfoOverlayRenderer" );
+ sourceInfoOverlayRendererField.setAccessible( true );
+ sourceInfoOverlayRendererField.set( viewerP, new BigWarpSourceOverlayRenderer() );
+ sourceInfoOverlayRendererField.set( viewerQ, new BigWarpSourceOverlayRenderer() );
+ sourceInfoOverlayRendererField.setAccessible( false );
+ }
+ catch ( final Exception e )
+ {
+ e.printStackTrace();
+ }
+
+ viewerP.setNumDim( ndims );
+ viewerQ.setNumDim( ndims );
+
+ activeSourcesDialogP = new VisibilityAndGroupingDialog( viewerFrameP, viewerP.getVisibilityAndGrouping() );
+ activeSourcesDialogP.setTitle( "visibility and grouping ( moving )" );
+ activeSourcesDialogQ = new VisibilityAndGroupingDialog( viewerFrameQ, viewerQ.getVisibilityAndGrouping() );
+ activeSourcesDialogQ.setTitle( "visibility and grouping ( fixed )" );
+
+ // set sources to inactive at the start
+ for ( final SourceAndConverter< ? > source : Arrays.asList( warpMagSource, gridSource, jacDetSource, transformMaskSource ) )
+ {
+ viewerP.state().setSourceActive( source, false );
+ viewerQ.state().setSourceActive( source, false );
+ }
+
+
+ overlayP = new BigWarpOverlay( viewerP, landmarkPanel );
+ overlayQ = new BigWarpOverlay( viewerQ, landmarkPanel );
+ viewerP.addOverlay( overlayP );
+ viewerQ.addOverlay( overlayQ );
+
+ bwTransform = new BigWarpTransform( landmarkModel );
+ bwTransform.initializeInverseParameters(data);
+ bwTransform.setLambda( transformMask.getRandomAccessible() );
+
+ solverThread = new SolveThread( this );
+ solverThread.start();
+
+ bboxOptions = new BoundingBoxEstimation( BoundingBoxEstimation.Method.FACES, 5 );
+ updateSourceBoundingBoxEstimators();
+
+ dragOverlayP = new BigWarpDragOverlay( this, viewerP, solverThread );
+ dragOverlayQ = new BigWarpDragOverlay( this, viewerQ, solverThread );
+ viewerP.addDragOverlay( dragOverlayP );
+ viewerQ.addDragOverlay( dragOverlayQ );
+
+ landmarkPopupMenu = new LandmarkPointMenu( this );
+ landmarkPopupMenu.setupListeners();
+
+ setupAssignments = new SetupAssignments( new ArrayList<>( converterSetups ), 0, 65535 );
+
+ brightnessDialog = new BrightnessDialog( landmarkFrame, setupAssignments );
+ helpDialog = new HelpDialog( landmarkFrame );
+ sourceInfoDialog = new SourceInfoDialog( landmarkFrame, data );
+
+ transformSelector = new TransformTypeSelectDialog( landmarkFrame, this );
+
+ // dialogs have to be constructed before action maps are made
+ warpVisDialog = new WarpVisFrame( viewerFrameQ, this );
+ warpVisDialog.maskOptionsPanel.setMask( transformMask );
+
+ WarpNavigationActions.installActionBindings( getViewerFrameP().getKeybindings(), viewerFrameP, keyProperties, ( ndims == 2 ) );
+ BigWarpActions.installActionBindings( getViewerFrameP().getKeybindings(), this, keyProperties );
+
+ WarpNavigationActions.installActionBindings( getViewerFrameQ().getKeybindings(), viewerFrameQ, keyProperties, ( ndims == 2 ) );
+ BigWarpActions.installActionBindings( getViewerFrameQ().getKeybindings(), this, keyProperties );
+
+ BigWarpActions.installLandmarkPanelActionBindings( landmarkFrame.getKeybindings(), this, landmarkTable, keyProperties );
+
+ // this call has to come after the actions are set
+ warpVisDialog.setActions();
+ warpVisDialog.toleranceSpinner.setValue( bwTransform.getInverseTolerance() );
+
+ setUpViewerMenu( viewerFrameP );
+ setUpViewerMenu( viewerFrameQ );
+ setUpLandmarkMenus();
+
+ /* Set the locations of frames */
+ viewerFrameP.setLocation( 0, 0 );
+ viewerFrameP.setSize( DEFAULT_WIDTH, DEFAULT_HEIGHT );
+ viewerFrameQ.setLocation( DEFAULT_WIDTH, 0 );
+ viewerFrameQ.setSize( DEFAULT_WIDTH, DEFAULT_HEIGHT );
+ landmarkFrame.setLocation( 2 * DEFAULT_WIDTH, 0 );
+
+ landmarkClickListenerP = new MouseLandmarkListener( this.viewerP );
+ landmarkClickListenerQ = new MouseLandmarkListener( this.viewerQ );
+ addMaskMouseListener();
+
+ // have to be safe here and use 3dim point for both 3d and 2d
+ currentLandmark = new RealPoint( 3 );
+ inLandmarkMode = false;
+ setupKeyListener();
+
+ initialViewP = new AffineTransform3D();
+ initialViewQ = new AffineTransform3D();
+ viewerP.state().getViewerTransform( initialViewP );
+ viewerQ.state().getViewerTransform( initialViewQ );
+
+ // set colors and min/max ranges
+ viewerFrameP.setVisible( true );
+ viewerFrameQ.setVisible( true );
+
+ landmarkFrame.pack();
+ landmarkFrame.setVisible( true );
+
+ SwingUtilities.invokeLater( new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ data.transferChannelSettings( viewerFrameP );
+ data.transferChannelSettings( viewerFrameQ );
+ }
+ } );
+
+ // set initial transforms so data are visible
+ InitializeViewerState.initTransform( viewerP );
+ InitializeViewerState.initTransform( viewerQ );
+
+ checkBoxInputMaps();
+
+ // file selection
+ fileFrame = new JFrame( "Select File" );
+ fileDialog = new FileDialog( fileFrame );
+
+ if ( ij == null || (IJ.getDirectory( "current" ) == null) )
+ lastDirectory = new File( System.getProperty( "user.home" ));
+ else
+ lastDirectory = new File( IJ.getDirectory( "current" ));
+
+ // default to linear interpolation
+ fileFrame.setVisible( false );
+
+ // add focus listener
+ //new BigwarpFocusListener( this );
+
+ bookmarks = new Bookmarks();
+ bookmarkEditorP = new BookmarksEditor( viewerP, viewerFrameP.getKeybindings(), bookmarks );
+ bookmarkEditorQ = new BookmarksEditor( viewerQ, viewerFrameQ.getKeybindings(), bookmarks );
+
+ // add landmark mode listener
+ //addKeyEventPostProcessor( new LandmarkModeListener() );
+ }
+
+ public int numDimensions()
+ {
+ return ndims;
+ }
+
+ /**
+ * TODO Make a PR that updates this method in InitializeViewerState in bdv-core
+ * @deprecated Use {@link InitializeViewerState} method instead.
+ *
+ * @param cumulativeMinCutoff the min image intensity
+ * @param cumulativeMaxCutoff the max image intensity
+ * @param state the viewer state
+ * @param converterSetups the converter setups
+ */
+ @Deprecated
+ public static void initBrightness( final double cumulativeMinCutoff, final double cumulativeMaxCutoff, final ViewerState state, final ConverterSetups converterSetups )
+ {
+ final SourceAndConverter< ? > current = state.getCurrentSource();
+ if ( current == null )
+ return;
+ final Source< ? > source = current.getSpimSource();
+ final int timepoint = state.getCurrentTimepoint();
+ final Bounds bounds = InitializeViewerState.estimateSourceRange( source, timepoint, cumulativeMinCutoff, cumulativeMaxCutoff );
+ final ConverterSetup setup = converterSetups.getConverterSetup( current );
+ setup.setDisplayRange( bounds.getMinBound(), bounds.getMaxBound() );
+ }
+
+ public void addKeyEventPostProcessor( final KeyEventPostProcessor ke )
+ {
+ keyEventPostProcessorSet.add( ke );
+ KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventPostProcessor( ke );
+ }
+
+ public void removeKeyEventPostProcessor( final KeyEventPostProcessor ke )
+ {
+ keyEventPostProcessorSet.remove( ke );
+ KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventPostProcessor( ke );
+ }
+
+ public void closeAll()
+ {
+ final ArrayList< KeyEventPostProcessor > ks = new ArrayList< KeyEventPostProcessor >( keyEventPostProcessorSet );
+ for ( final KeyEventPostProcessor ke : ks )
+ removeKeyEventPostProcessor( ke );
+
+ repeatedKeyEventsFixer.remove();
+
+ viewerFrameP.setVisible( false );
+ viewerFrameQ.setVisible( false );
+ landmarkFrame.setVisible( false );
+
+ viewerFrameP.getViewerPanel().stop();
+ viewerFrameQ.getViewerPanel().stop();
+
+ viewerFrameP.dispose();
+ viewerFrameQ.dispose();
+ landmarkFrame.dispose();
+ }
+
+ public void setUpdateWarpOnChange( final boolean updateWarpOnPtChange )
+ {
+ this.updateWarpOnPtChange = updateWarpOnPtChange;
+ }
+
+ public void toggleUpdateWarpOnChange()
+ {
+ this.updateWarpOnPtChange = !this.updateWarpOnPtChange;
+
+ if ( updateWarpOnPtChange )
+ {
+ message.showMessage( "Always estimate transform on change" );
+
+ // toggleAlwaysWarpMenuP.setText( "Toggle always warp off" );
+ // toggleAlwaysWarpMenuQ.setText( "Toggle always warp off" );
+ }
+ else
+ {
+ message.showMessage( "Estimate transform on request only" );
+
+ // toggleAlwaysWarpMenuP.setText( "Warp on every point change" );
+ // toggleAlwaysWarpMenuQ.setText( "Toggle always warp on" );
+ }
+ }
+
+ public boolean isUpdateWarpOnChange()
+ {
+ return updateWarpOnPtChange;
+ }
+
+ public void invertPointCorrespondences()
+ {
+ landmarkModel = landmarkModel.invert();
+ landmarkPanel.setTableModel( landmarkModel );
+ }
+
+ public File getLastDirectory()
+ {
+ return lastDirectory;
+ }
+
+ public void setLastDirectory( final File dir )
+ {
+ this.lastDirectory = dir;
+ }
+
+ public void setSpotColor( final Color c )
+ {
+ viewerSettings.setSpotColor( c );
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+ }
+
+ protected void setUpViewerMenu( final BigWarpViewerFrame vframe )
+ {
+ // TODO setupviewermenu
+
+ final ActionMap actionMap = vframe.getKeybindings().getConcatenatedActionMap();
+
+ final JMenuBar viewerMenuBar = new JMenuBar();
+
+ JMenu fileMenu = new JMenu( "File" );
+ viewerMenuBar.add( fileMenu );
+
+ final JMenuItem openItem = new JMenuItem( actionMap.get( BigWarpActions.LOAD_LANDMARKS ) );
+ openItem.setText( "Import landmarks" );
+ fileMenu.add( openItem );
+
+ final JMenuItem saveItem = new JMenuItem( actionMap.get( BigWarpActions.SAVE_LANDMARKS ));
+ saveItem.setText( "Export landmarks" );
+ fileMenu.add( saveItem );
+
+ fileMenu.addSeparator();
+ final JMenuItem miLoadSettings = new JMenuItem( actionMap.get( BigWarpActions.LOAD_SETTINGS ) );
+ miLoadSettings.setText( "Load settings" );
+ fileMenu.add( miLoadSettings );
+
+ final JMenuItem miSaveSettings = new JMenuItem( actionMap.get( BigWarpActions.SAVE_SETTINGS ) );
+ miSaveSettings.setText( "Save settings" );
+ fileMenu.add( miSaveSettings );
+
+ if( ij != null )
+ {
+ fileMenu.addSeparator();
+ final JMenuItem exportToImagePlus = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_IP ) );
+ exportToImagePlus.setText( "Export moving image" );
+ fileMenu.add( exportToImagePlus );
+
+ final JMenuItem exportWarpField = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_WARP ) );
+ exportWarpField.setText( "Export warp field" );
+ fileMenu.add( exportWarpField );
+ }
+
+ final JMenu settingsMenu = new JMenu( "Settings" );
+ viewerMenuBar.add( settingsMenu );
+
+ final JMenuItem toggleAlwaysWarpMenu;
+ if ( vframe.isMoving() )
+ {
+ toggleAlwaysWarpMenuP = new JMenuItem( new BigWarpActions.ToggleAlwaysEstimateTransformAction( "", vframe ) );
+ toggleAlwaysWarpMenu = toggleAlwaysWarpMenuP;
+ }
+ else
+ {
+ toggleAlwaysWarpMenuQ = new JMenuItem( new BigWarpActions.ToggleAlwaysEstimateTransformAction( "", vframe ) );
+ toggleAlwaysWarpMenu = toggleAlwaysWarpMenuQ;
+ }
+
+ toggleAlwaysWarpMenu.setText( "Toggle warp on drag" );
+ settingsMenu.add( toggleAlwaysWarpMenu );
+
+ final JMenuItem miBrightness = new JMenuItem( actionMap.get( BigWarpActions.BRIGHTNESS_SETTINGS ) );
+ miBrightness.setText( "Brightness & Color" );
+ settingsMenu.add( miBrightness );
+
+ /* */
+ final JMenuItem transformTypeMenu = new JMenuItem( actionMap.get( BigWarpActions.TRANSFORM_TYPE ) );
+ transformTypeMenu.setText( "Transformation Options" );
+ settingsMenu.add( transformTypeMenu );
+
+ /* Warp Visualization */
+ final JMenuItem warpVisMenu = new JMenuItem( actionMap.get( BigWarpActions.SHOW_WARPTYPE_DIALOG ) );
+ warpVisMenu.setText( "BigWarp Options" );
+ settingsMenu.add( warpVisMenu );
+
+ vframe.setJMenuBar( viewerMenuBar );
+
+ final JMenu helpMenu = new JMenu( "Help" );
+ viewerMenuBar.add( helpMenu );
+
+ final JMenuItem miHelp = new JMenuItem( actionMap.get( BigWarpActions.SHOW_HELP ) );
+ miHelp.setText( "Show Help Menu" );
+ helpMenu.add( miHelp );
+
+ final JMenuItem miSrcInfo = new JMenuItem( actionMap.get( BigWarpActions.SHOW_SOURCE_INFO ) );
+ miSrcInfo.setText( "Show source information" );
+ helpMenu.add( miSrcInfo );
+ }
+
+ protected void setupImageJExportOption()
+ {
+ final ActionMap actionMap = landmarkFrame.getKeybindings().getConcatenatedActionMap();
+
+ final JMenuItem exportToImagePlus = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_IP ) );
+ exportToImagePlus.setText( "Export moving image" );
+ fileMenu.add( exportToImagePlus );
+
+ final JMenuItem exportWarpField = new JMenuItem( actionMap.get( BigWarpActions.EXPORT_WARP ) );
+ exportWarpField.setText( "Export warp field" );
+ fileMenu.add( exportWarpField );
+ }
+
+ public void exportAsImagePlus( boolean virtual )
+ {
+ exportAsImagePlus( virtual, "" );
+ }
+
+ @Deprecated
+ public void saveMovingImageToFile()
+ {
+ final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
+ File proposedFile = new File( sources.get( movingSourceIndexList[ 0 ] ).getSpimSource().getName() );
+
+ fileChooser.setSelectedFile( proposedFile );
+ final int returnVal = fileChooser.showSaveDialog( null );
+ if ( returnVal == JFileChooser.APPROVE_OPTION )
+ {
+ proposedFile = fileChooser.getSelectedFile();
+ try
+ {
+ exportAsImagePlus( false, proposedFile.getCanonicalPath() );
+ } catch ( final IOException e )
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public File saveMovingImageXml( )
+ {
+ return saveMovingImageXml( null );
+ }
+
+ public File saveMovingImageXml( String proposedFilePath )
+ {
+
+ if ( movingSpimData == null )
+ {
+ IJ.log("Cannot save warped moving image XML, because the input image was not a BDV/XML.");
+ return null;
+ }
+
+ final AffineTransform3D bigWarpTransform = getMovingToFixedTransformAsAffineTransform3D();
+
+ System.out.println( "bigWarp transform as affine 3d: " + bigWarpTransform.toString() );
+
+ movingSpimData.getViewRegistrations().getViewRegistration( 0, 0 ).preconcatenateTransform(
+ new ViewTransformAffine( "Big Warp: " + bwTransform.getTransformType(), bigWarpTransform ) );
+
+ File proposedFile;
+ if ( proposedFilePath == null )
+ {
+ final JFileChooser fileChooser = new JFileChooser( movingImageXml.getParent() );
+ proposedFile = new File( movingImageXml.getName().replace( ".xml", "-bigWarp.xml" ) );
+
+ fileChooser.setSelectedFile( proposedFile );
+ final int returnVal = fileChooser.showSaveDialog( null );
+ if ( returnVal == JFileChooser.APPROVE_OPTION )
+ proposedFile = fileChooser.getSelectedFile();
+ else
+ return null;
+ }
+ else
+ {
+ proposedFile = new File( proposedFilePath );
+ }
+
+ try
+ {
+ new XmlIoSpimData().save( movingSpimData, proposedFile.getAbsolutePath() );
+ } catch ( SpimDataException e )
+ {
+ e.printStackTrace();
+ }
+
+ return proposedFile;
+ }
+
+ public AffineTransform3D getMovingToFixedTransformAsAffineTransform3D()
+ {
+ double[][] affine3DMatrix = new double[ 3 ][ 4 ];
+ double[][] affine2DMatrix = new double[ 2 ][ 3 ];
+
+ if ( currentTransform == null )
+ {
+ return null;
+ }
+
+ final InvertibleCoordinateTransform transform =
+ ( ( WrappedCoordinateTransform ) currentTransform ).getTransform().createInverse();
+
+ if ( transform instanceof AffineModel3D )
+ {
+ ((AffineModel3D)transform).toMatrix( affine3DMatrix );
+ }
+ else if ( transform instanceof SimilarityModel3D )
+ {
+ ((SimilarityModel3D)transform).toMatrix( affine3DMatrix );
+ }
+ else if ( transform instanceof RigidModel3D )
+ {
+ ((RigidModel3D)transform).toMatrix( affine3DMatrix );
+ }
+ else if ( transform instanceof TranslationModel3D )
+ {
+ ((TranslationModel3D)transform).toMatrix( affine3DMatrix );
+ }
+ else if ( transform instanceof AffineModel2D )
+ {
+ ((AffineModel2D)transform).toMatrix( affine2DMatrix );
+ affineMatrix2DtoAffineMatrix3D( affine2DMatrix, affine3DMatrix );
+ }
+ else if ( transform instanceof SimilarityModel2D )
+ {
+ ((SimilarityModel2D)transform).toMatrix( affine2DMatrix );
+ affineMatrix2DtoAffineMatrix3D( affine2DMatrix, affine3DMatrix );
+ }
+ else if ( transform instanceof RigidModel2D )
+ {
+ ((RigidModel2D)transform).toMatrix( affine2DMatrix );
+ affineMatrix2DtoAffineMatrix3D( affine2DMatrix, affine3DMatrix );
+ }
+ else if ( transform instanceof TranslationModel2D )
+ {
+ ((TranslationModel2D)transform).toMatrix( affine2DMatrix );
+ affineMatrix2DtoAffineMatrix3D( affine2DMatrix, affine3DMatrix );
+ }
+ else
+ {
+ IJ.error("Cannot convert transform of type " + transform.getClass().toString()
+ + "\nto an 3D affine tranform.");
+ return null;
+ }
+
+ final AffineTransform3D bigWarpTransform = new AffineTransform3D();
+ bigWarpTransform.set( affine3DMatrix );
+ return bigWarpTransform;
+ }
+
+ private void affineMatrix2DtoAffineMatrix3D( double[][] affine2DMatrix, double[][] affine3DMatrix )
+ {
+ for ( int d = 0; d < 2; ++d )
+ {
+ affine3DMatrix[ d ][ 0 ] = affine2DMatrix[ d ][ 0 ];
+ affine3DMatrix[ d ][ 1 ] = affine2DMatrix[ d ][ 1 ];
+ affine3DMatrix[ d ][ 3 ] = affine2DMatrix[ d ][ 2 ];
+ }
+ }
+
+ public void exportAsImagePlus( boolean virtual, String path )
+ {
+ if( ij == null )
+ return;
+
+ final GenericDialogPlus gd = new GenericDialogPlus( "Apply Big Warp transform" );
+
+ gd.addMessage( "Field of view and resolution:" );
+ gd.addChoice( "Resolution",
+ new String[]{ ApplyBigwarpPlugin.TARGET, ApplyBigwarpPlugin.MOVING, ApplyBigwarpPlugin.SPECIFIED },
+ ApplyBigwarpPlugin.TARGET );
+
+ gd.addChoice( "Field of view",
+ new String[]{ ApplyBigwarpPlugin.TARGET,
+ ApplyBigwarpPlugin.MOVING_WARPED,
+ ApplyBigwarpPlugin.UNION_TARGET_MOVING,
+ ApplyBigwarpPlugin.LANDMARK_POINTS,
+ ApplyBigwarpPlugin.LANDMARK_POINT_CUBE_PIXEL,
+ ApplyBigwarpPlugin.LANDMARK_POINT_CUBE_PHYSICAL,
+ ApplyBigwarpPlugin.SPECIFIED_PIXEL,
+ ApplyBigwarpPlugin.SPECIFIED_PHYSICAL
+ },
+ ApplyBigwarpPlugin.TARGET );
+
+ gd.addStringField( "point filter", "" );
+
+ gd.addMessage( "Resolution");
+ gd.addNumericField( "x", 1.0, 4 );
+ gd.addNumericField( "y", 1.0, 4 );
+ gd.addNumericField( "z", 1.0, 4 );
+
+ gd.addMessage( "Offset");
+ gd.addNumericField( "x", 0.0, 4 );
+ gd.addNumericField( "y", 0.0, 4 );
+ gd.addNumericField( "z", 0.0, 4 );
+
+ gd.addMessage( "Field of view");
+ gd.addNumericField( "x", -1, 0 );
+ gd.addNumericField( "y", -1, 0 );
+ gd.addNumericField( "z", -1, 0 );
+
+ gd.addMessage( "Other Output options");
+ gd.addChoice( "Interpolation", new String[]{ "Nearest Neighbor", "Linear" }, "Linear" );
+
+ gd.addMessage( "Virtual: fast to display,\n"
+ + "low memory requirements,\nbut slow to navigate" );
+ gd.addCheckbox( "virtual?", false );
+ int defaultCores = (int)Math.ceil( Runtime.getRuntime().availableProcessors()/4);
+ gd.addNumericField( "threads", defaultCores, 0 );
+
+ gd.addMessage( "Writing options (leave empty to opena new image window)" );
+ gd.addDirectoryOrFileField( "File or n5 root", "" );
+ gd.addStringField( "n5 dataset", "" );
+ gd.addStringField( "n5 block size", "32" );
+ gd.addChoice( "n5 compression", new String[] {
+ N5Exporter.GZIP_COMPRESSION,
+ N5Exporter.RAW_COMPRESSION,
+ N5Exporter.LZ4_COMPRESSION,
+ N5Exporter.XZ_COMPRESSION,
+ N5Exporter.BLOSC_COMPRESSION },
+ N5Exporter.GZIP_COMPRESSION );
+
+ gd.showDialog();
+
+ if ( gd.wasCanceled() )
+ return;
+
+ final String resolutionOption = gd.getNextChoice();
+ final String fieldOfViewOption = gd.getNextChoice();
+ final String fieldOfViewPointFilter = gd.getNextString();
+
+ final double[] resolutionSpec = new double[ 3 ];
+ resolutionSpec[ 0 ] = gd.getNextNumber();
+ resolutionSpec[ 1 ] = gd.getNextNumber();
+ resolutionSpec[ 2 ] = gd.getNextNumber();
+
+ final double[] offsetSpec = new double[ 3 ];
+ offsetSpec[ 0 ] = gd.getNextNumber();
+ offsetSpec[ 1 ] = gd.getNextNumber();
+ offsetSpec[ 2 ] = gd.getNextNumber();
+
+ final double[] fovSpec = new double[ 3 ];
+ fovSpec[ 0 ] = gd.getNextNumber();
+ fovSpec[ 1 ] = gd.getNextNumber();
+ fovSpec[ 2 ] = gd.getNextNumber();
+
+
+ final String interpType = gd.getNextChoice();
+ final boolean isVirtual = gd.getNextBoolean();
+ final int nThreads = (int)gd.getNextNumber();
+
+ final String fileOrN5Root = gd.getNextString();
+ final String n5Dataset = gd.getNextString();
+ final String blockSizeString = gd.getNextString();
+ final String compressionString = gd.getNextChoice();
+
+ final int[] blockSize = ApplyBigwarpPlugin.parseBlockSize( blockSizeString, this.ndims );
+ final Compression compression = ApplyBigwarpPlugin.getCompression( compressionString );
+ final WriteDestinationOptions writeOpts = new ApplyBigwarpPlugin.WriteDestinationOptions( fileOrN5Root, n5Dataset,
+ blockSize, compression );
+
+ final Interpolation interp;
+ if( interpType.equals( "Nearest Neighbor" ))
+ interp = Interpolation.NEARESTNEIGHBOR;
+ else
+ interp = Interpolation.NLINEAR;
+
+ final double[] res = ApplyBigwarpPlugin.getResolution( this.data, resolutionOption, resolutionSpec );
+
+ final List outputIntervalList = ApplyBigwarpPlugin.getPixelInterval( this.data,
+ this.landmarkModel, this.currentTransform,
+ fieldOfViewOption, fieldOfViewPointFilter, bboxOptions, fovSpec, offsetSpec, res );
+
+ final List matchedPtNames = new ArrayList<>();
+ if( outputIntervalList.size() > 1 )
+ ApplyBigwarpPlugin.fillMatchedPointNames( matchedPtNames, getLandmarkPanel().getTableModel(), fieldOfViewPointFilter );
+
+
+ // export has to be treated differently if we're doing fov's around
+ // landmark centers (because multiple images can be exported this way )
+ if( matchedPtNames.size() > 0 )
+ {
+ BigwarpLandmarkSelectionPanel selection = new BigwarpLandmarkSelectionPanel<>(
+ data, sources, fieldOfViewOption,
+ outputIntervalList, matchedPtNames, interp,
+ offsetSpec, res, isVirtual, nThreads,
+ progressWriter );
+ }
+ else
+ {
+ if( writeOpts.n5Dataset != null && !writeOpts.n5Dataset.isEmpty())
+ {
+ final String unit = ApplyBigwarpPlugin.getUnit( data, resolutionOption );
+ // export async
+ new Thread()
+ {
+ @Override
+ public void run()
+ {
+ progressWriter.setProgress( 0.01 );
+ ApplyBigwarpPlugin.runN5Export( data, sources, fieldOfViewOption,
+ outputIntervalList.get( 0 ), interp,
+ offsetSpec, res, unit,
+ progressWriter, writeOpts,
+ Executors.newFixedThreadPool( nThreads ) );
+
+ progressWriter.setProgress( 1.00 );
+ }
+ }.start();
+ }
+ else
+ {
+ // export
+ final boolean show = ( writeOpts.pathOrN5Root == null || writeOpts.pathOrN5Root.isEmpty() );
+ ApplyBigwarpPlugin.runExport( data, sources, fieldOfViewOption,
+ outputIntervalList, matchedPtNames, interp,
+ offsetSpec, res, isVirtual, nThreads,
+ progressWriter, show, false, writeOpts );
+ }
+ }
+ }
+
+ public void exportWarpField()
+ {
+ BigWarpToDeformationFieldPlugIn dfieldExporter = new BigWarpToDeformationFieldPlugIn();
+ dfieldExporter.runFromBigWarpInstance( landmarkModel, sources, targetSourceIndexList );
+ }
+
+ protected void setUpLandmarkMenus()
+ {
+ final ActionMap actionMap = landmarkFrame.getKeybindings().getConcatenatedActionMap();
+
+ final JMenuBar landmarkMenuBar = new JMenuBar();
+ fileMenu = new JMenu( "File" );
+ final JMenuItem openItem = new JMenuItem( actionMap.get( BigWarpActions.LOAD_LANDMARKS ) );
+ openItem.setText( "Import landmarks" );
+ fileMenu.add( openItem );
+
+ final JMenuItem saveItem = new JMenuItem( actionMap.get( BigWarpActions.SAVE_LANDMARKS ));
+ saveItem.setText( "Export landmarks" );
+ fileMenu.add( saveItem );
+
+ fileMenu.addSeparator();
+ final JMenuItem exportImageItem = new JMenuItem( "Export Moving Image" );
+
+ landmarkMenuBar.add( fileMenu );
+ landmarkFrame.setJMenuBar( landmarkMenuBar );
+ // exportMovingImage( file, state, progressWriter );
+
+ final JMenuItem saveExport = new JMenuItem( actionMap.get( BigWarpActions.SAVE_WARPED ) );
+ saveExport.setText( "Save warped image" );
+ fileMenu.add( saveExport );
+
+ final JMenu landmarkMenu = new JMenu( "Landmarks" );
+ final JMenuItem landmarkGridItem = new JMenuItem( actionMap.get( BigWarpActions.LANDMARK_GRID_DIALOG ) );
+ landmarkGridItem.setText( "Build landmark grid" );
+ landmarkMenu.add( landmarkGridItem );
+
+ landmarkMenuBar.add( landmarkMenu );
+
+
+ if( ij != null )
+ setupImageJExportOption();
+ }
+
+ public Bookmarks getBookmarks()
+ {
+ return bookmarks;
+ }
+
+ public BigWarpViewerFrame getViewerFrameP()
+ {
+ return viewerFrameP;
+ }
+
+ public BigWarpViewerFrame getViewerFrameQ()
+ {
+ return viewerFrameQ;
+ }
+
+ public BigWarpOverlay getOverlayP()
+ {
+ return overlayP;
+ }
+
+ public BigWarpOverlay getOverlayQ()
+ {
+ return overlayQ;
+ }
+
+ public SetupAssignments getSetupAssignments()
+ {
+ return setupAssignments;
+ }
+
+ public BigWarpData getData()
+ {
+ return data;
+ }
+
+ public List< SourceAndConverter< T > > getSources()
+ {
+ return sources;
+ }
+
+ public BigWarpLandmarkFrame getLandmarkFrame()
+ {
+ return landmarkFrame;
+ }
+
+ public BigWarpLandmarkPanel getLandmarkPanel()
+ {
+ return landmarkPanel;
+ }
+
+ public boolean isInLandmarkMode()
+ {
+ return inLandmarkMode;
+ }
+
+ public void toggleInLandmarkMode()
+ {
+ setInLandmarkMode( !inLandmarkMode );
+ }
+
+ public void setInLandmarkMode( final boolean inLmMode )
+ {
+ if( inLandmarkMode == inLmMode )
+ return;
+
+ if ( inLmMode )
+ {
+ disableTransformHandlers();
+ message.showMessage( "Landmark mode on" );
+ viewerFrameP.setCursor( Cursor.getPredefinedCursor( Cursor.CROSSHAIR_CURSOR ) );
+ viewerFrameQ.setCursor( Cursor.getPredefinedCursor( Cursor.CROSSHAIR_CURSOR ) );
+ }
+ else
+ {
+ enableTransformHandlers();
+ message.showMessage( "Landmark mode off" );
+ viewerFrameP.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR ) );
+ viewerFrameQ.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR ) );
+ }
+ inLandmarkMode = inLmMode;
+ }
+
+ /**
+ *
+ * @param ptarray location of the clicked point
+ * @param isMoving is the viewer in moving space
+ * @param selectedPointIndex the index of the selected point
+ * @param viewer the BigWarpViewerPanel clicked on
+ */
+ public void updatePointLocation( final double[] ptarray, final boolean isMoving, final int selectedPointIndex, final BigWarpViewerPanel viewer )
+ {
+ final boolean isMovingViewerXfm = viewer.getOverlay().getIsTransformed();
+
+ // TODO avoid duplicate effort and comment this section
+ if ( landmarkModel.getTransform() == null || !isMovingViewerXfm )
+ {
+ landmarkModel.setPoint( selectedPointIndex, isMoving, ptarray, false, currentTransform );
+
+ if ( !isMoving && !landmarkModel.isWarped( selectedPointIndex ) )
+ landmarkModel.updateWarpedPoint( selectedPointIndex, ptarray );
+ }
+ else
+ {
+ landmarkModel.getTransform().apply( ptarray, ptBack );
+ landmarkModel.updateWarpedPoint( selectedPointIndex, ptarray );
+ }
+
+ if ( landmarkFrame.isVisible() )
+ {
+ landmarkFrame.repaint();
+ viewer.requestRepaint();
+ }
+ }
+
+ public void updatePointLocation( final double[] ptarray, final boolean isMoving, final int selectedPointIndex )
+ {
+ if ( isMoving )
+ updatePointLocation( ptarray, isMoving, selectedPointIndex, viewerP );
+ else
+ updatePointLocation( ptarray, isMoving, selectedPointIndex, viewerQ );
+ }
+
+ public int updateWarpedPoint( final double[] ptarray, final boolean isMoving )
+ {
+ final int selectedPointIndex = selectedLandmark( ptarray, isMoving );
+
+ // if a fixed point is changing its location,
+ // we need to update the warped position for the corresponding moving point
+ // so that it can be rendered correctly
+ if ( selectedPointIndex >= 0 && !isMoving && landmarkModel.getTransform() != null )
+ {
+ landmarkModel.updateWarpedPoint( selectedPointIndex, ptarray );
+ }
+
+ return selectedPointIndex;
+ }
+
+ public void updateRowSelection( boolean isMoving, int lastRowEdited )
+ {
+ updateRowSelection( landmarkModel, landmarkTable, isMoving, lastRowEdited );
+ landmarkPanel.repaint();
+ }
+
+ public static void updateRowSelection(
+ LandmarkTableModel landmarkModel, JTable table,
+ boolean isMoving, int lastRowEdited )
+ {
+ logger.trace( "updateRowSelection " );
+
+ int i = landmarkModel.getNextRow( isMoving );
+ if ( i < table.getRowCount() )
+ {
+ logger.trace( " landmarkTable ( updateRowSelection ) selecting row " + i );
+ table.setRowSelectionInterval( i, i );
+ } else if( lastRowEdited >= 0 && lastRowEdited < table.getRowCount() )
+ table.setRowSelectionInterval( lastRowEdited, lastRowEdited );
+ }
+
+ /**
+ * Returns the index of the selected row, if it is unpaired, -1 otherwise
+ *
+ * @param isMoving isMoving
+ * @return index of the selected row
+ */
+ public int getSelectedUnpairedRow( boolean isMoving )
+ {
+ int row = landmarkTable.getSelectedRow();
+ if( row >= 0 && ( isMoving ? !landmarkModel.isMovingPoint( row ) : !landmarkModel.isFixedPoint( row )))
+ return row;
+
+ return -1;
+ }
+
+ /**
+ * Updates the global variable ptBack
+ *
+ * @param ptarray the point location
+ * @param isMoving is the point location in moving image space
+ * @param viewer the viewer panel
+ * @return an error string if an error occurred, empty string otherwise
+ */
+ public String addPoint( final double[] ptarray, final boolean isMoving, final BigWarpViewerPanel viewer )
+ {
+ final boolean isViewerTransformed = viewer.getOverlay().getIsTransformed();
+
+ if ( !isMoving && viewer.getIsMoving() && !isViewerTransformed )
+ return "Adding a fixed point in moving image space not supported";
+ else
+ {
+ addPoint( ptarray, isMoving );
+ return "";
+ }
+ }
+
+ /**
+ * Updates the global variable ptBack
+ *
+ * @param ptarray the point location
+ * @param isMoving is the point location in moving image space
+ * @return true if a new row was created
+ */
+ public boolean addPoint( final double[] ptarray, final boolean isMoving )
+ {
+ final boolean isWarped = ( isMoving && landmarkModel.getTransform() != null && BigWarp.this.isMovingDisplayTransformed() );
+
+ InvertibleRealTransform transform;
+ if( options.is2d && currentTransform != null )
+ transform = ((Wrapped2DTransformAs3D)currentTransform).getTransform();
+ else
+ transform = currentTransform;
+
+ // TODO check this (current transform part)
+ final boolean didAdd = BigWarp.this.landmarkModel.pointEdit( -1, ptarray, false, isMoving, isWarped, true, transform );
+
+ if ( BigWarp.this.landmarkFrame.isVisible() )
+ {
+ BigWarp.this.landmarkFrame.repaint();
+ }
+ return didAdd;
+ }
+
+ protected int selectedLandmark( final double[] pt, final boolean isMoving )
+ {
+ return selectedLandmark( pt, isMoving, true );
+ }
+
+ /**
+ * Returns the index of the landmark closest to the input point,
+ * if it is within a certain distance threshold.
+ *
+ * Updates the global variable ptBack
+ *
+ * @param pt the point location
+ * @param isMoving is the point location in moving image space
+ * @param selectInTable also select the landmark in the table
+ * @return the index of the selected landmark
+ */
+ protected int selectedLandmark( final double[] pt, final boolean isMoving, final boolean selectInTable )
+ {
+ logger.trace( "clicked: " + XfmUtils.printArray( pt ) );
+
+ // TODO selectedLandmark
+ final int N = landmarkModel.getRowCount();
+
+ // a point will be selected if you click inside the spot ( with a 5 pixel buffer )
+ double radsq = ( viewerSettings.getSpotSize() * viewerSettings.getSpotSize() ) + 5 ;
+ final AffineTransform3D viewerXfm = new AffineTransform3D();
+ if ( isMoving ) //&& !isMovingDisplayTransformed() )
+ {
+ viewerP.state().getViewerTransform( viewerXfm );
+ radsq = viewerP.getSettings().getSpotSize();
+ }
+ else
+ {
+ viewerQ.state().getViewerTransform( viewerXfm );
+ radsq = viewerQ.getSettings().getSpotSize();
+ }
+ radsq = ( radsq * radsq );
+ final double scale = computeScaleAssumeRigid( viewerXfm );
+
+ double dist = 0.0;
+ int bestIdx = -1;
+ double smallestDist = Double.MAX_VALUE;
+
+ logger.trace( " selectedLandmarkHelper dist scale: " + scale );
+ logger.trace( " selectedLandmarkHelper radsq: " + radsq );
+
+ for ( int n = 0; n < N; n++ )
+ {
+ final Double[] lmpt;
+ if( isMoving && landmarkModel.isWarped( n ) && isMovingDisplayTransformed() )
+ {
+ lmpt = landmarkModel.getWarpedPoints().get( n );
+ }
+ else if( isMoving && isMovingDisplayTransformed() )
+ {
+ lmpt = landmarkModel.getPoints( false ).get( n );
+ }
+ else
+ {
+ lmpt = landmarkModel.getPoints( isMoving ).get( n );
+ }
+
+ dist = 0.0;
+ for ( int i = 0; i < landmarkModel.getNumdims(); i++ )
+ {
+ dist += ( pt[ i ] - lmpt[ i ] ) * ( pt[ i ] - lmpt[ i ] );
+ }
+
+ dist *= ( scale * scale );
+ logger.trace( " dist squared of lm index : " + n + " is " + dist );
+ if ( dist < radsq && dist < smallestDist )
+ {
+ smallestDist = dist;
+ bestIdx = n;
+ }
+ }
+
+ if ( selectInTable && landmarkFrame.isVisible() )
+ {
+ if( landmarkTable.isEditing())
+ {
+ landmarkTable.getCellEditor().stopCellEditing();
+ }
+
+ landmarkTable.setEditingRow( bestIdx );
+ landmarkFrame.repaint();
+ }
+ logger.trace( "selectedLandmark: " + bestIdx );
+ return bestIdx;
+ }
+
+ public static double computeScaleAssumeRigid( final AffineTransform3D xfm )
+ {
+ return xfm.get( 0, 0 ) + xfm.get( 0, 1 ) + xfm.get( 0, 2 );
+ }
+
+ protected void disableTransformHandlers()
+ {
+ // disable navigation listeners
+ viewerFrameP.setTransformEnabled( false );
+ viewerFrameQ.setTransformEnabled( false );
+ }
+
+ protected void enableTransformHandlers()
+ {
+ // enable navigation listeners
+ viewerFrameP.setTransformEnabled( true );
+ viewerFrameQ.setTransformEnabled( true );
+ }
+
+ private void printSourceTransforms()
+ {
+ final AffineTransform3D xfm = new AffineTransform3D();
+ for( SourceAndConverter sac : data.sources )
+ {
+ sac.getSpimSource().getSourceTransform(0, 0, xfm );
+ double det = BigWarpUtils.det( xfm );
+ System.out.println( "source xfm ( " + sac.getSpimSource().getName() + " ) : " + xfm );
+ System.out.println( " det = " + det );
+ }
+ }
+
+ private void printViewerTransforms()
+ {
+ final AffineTransform3D xfm = new AffineTransform3D();
+ viewerP.state().getViewerTransform( xfm );
+ System.out.println( "mvg viewer xfm: " + xfm );
+ System.out.println( " det = " + BigWarpUtils.det( xfm ));
+ System.out.println( " dotxy = " + BigWarpUtils.dotXy( xfm ));
+
+ viewerQ.state().getViewerTransform( xfm );
+ System.out.println( "tgt viewer xfm: " + xfm );
+ System.out.println( " det = " + BigWarpUtils.det( xfm ));
+ System.out.println( " dotxy = " + BigWarpUtils.dotXy( xfm ));
+ }
+
+ /**
+ * Changes the view transformation of 'panelToChange' to match that of 'panelToMatch'
+ * @param panelToChange the viewer panel whose transform will change
+ * @param panelToMatch the viewer panel the transform will come from
+ */
+ protected void matchWindowTransforms( final BigWarpViewerPanel panelToChange, final BigWarpViewerPanel panelToMatch )
+ {
+ panelToChange.showMessage( "Aligning" );
+ panelToMatch.showMessage( "Matching alignment" );
+
+ // get the transform from panelToMatch
+ final AffineTransform3D viewXfm = new AffineTransform3D();
+ panelToMatch.state().getViewerTransform( viewXfm );
+
+ // change transform of panelToChange
+ panelToChange.animateTransformation( viewXfm );
+ }
+
+ public void matchOtherViewerPanelToActive()
+ {
+ if ( inLandmarkMode )
+ {
+ message.showMessage( "Can't move viewer in landmark mode." );
+ return;
+ }
+
+ BigWarpViewerPanel panelToChange;
+ BigWarpViewerPanel panelToMatch;
+
+ if ( viewerFrameP.isActive() )
+ {
+ panelToChange = viewerQ;
+ panelToMatch = viewerP;
+ }
+ else if ( viewerFrameQ.isActive() )
+ {
+ panelToChange = viewerP;
+ panelToMatch = viewerQ;
+ }
+ else
+ return;
+
+ matchWindowTransforms( panelToChange, panelToMatch );
+ }
+
+ public void matchActiveViewerPanelToOther()
+ {
+ if ( inLandmarkMode )
+ {
+ message.showMessage( "Can't move viewer in landmark mode." );
+ return;
+ }
+
+ BigWarpViewerPanel panelToChange;
+ BigWarpViewerPanel panelToMatch;
+
+ if ( viewerFrameP.isActive() )
+ {
+ panelToChange = viewerP;
+ panelToMatch = viewerQ;
+ }
+ else if ( viewerFrameQ.isActive() )
+ {
+ panelToChange = viewerQ;
+ panelToMatch = viewerP;
+ }
+ else
+ return;
+
+ matchWindowTransforms( panelToChange, panelToMatch );
+ }
+
+ public void warpToNearest( BigWarpViewerPanel viewer )
+ {
+ if ( inLandmarkMode )
+ {
+ message.showMessage( "Can't move viewer in landmark mode." );
+ return;
+ }
+
+ RealPoint mousePt = new RealPoint( 3 ); // need 3d point even for 2d images
+ viewer.getGlobalMouseCoordinates( mousePt );
+ warpToLandmark( landmarkModel.getIndexNearestTo( mousePt, viewer.getIsMoving() ), viewer );
+ }
+
+ public void warpToLandmark( int row, BigWarpViewerPanel viewer )
+ {
+ if( inLandmarkMode )
+ {
+ message.showMessage( "Can't move viewer in landmark mode." );
+ return;
+ }
+
+ int offset = 0;
+ int ndims = landmarkModel.getNumdims();
+ double[] pt = null;
+ if( viewer.getIsMoving() && viewer.getOverlay().getIsTransformed() )
+ {
+ if ( BigWarp.this.landmarkModel.isWarped( row ) )
+ {
+ pt = LandmarkTableModel.toPrimitive( BigWarp.this.landmarkModel.getWarpedPoints().get( row ) );
+ }
+ else
+ {
+ offset = ndims;
+ }
+ }else if( !viewer.getIsMoving() )
+ {
+ offset = ndims;
+ }
+
+ if ( pt == null )
+ {
+ if ( ndims == 3 )
+
+ pt = new double[] {
+ (Double) landmarkModel.getValueAt( row, offset + 2 ),
+ (Double) landmarkModel.getValueAt( row, offset + 3 ),
+ (Double) landmarkModel.getValueAt( row, offset + 4 ) };
+ else
+ pt = new double[] {
+ (Double) landmarkModel.getValueAt( row, offset + 2 ),
+ (Double) landmarkModel.getValueAt( row, offset + 3 ), 0.0 };
+ }
+
+ // we have an unmatched point
+ if ( Double.isInfinite( pt[ 0 ] ) )
+ return;
+
+ final AffineTransform3D transform = viewer.state().getViewerTransform();
+ final AffineTransform3D xfmCopy = transform.copy();
+ xfmCopy.set( 0.0, 0, 3 );
+ xfmCopy.set( 0.0, 1, 3 );
+ xfmCopy.set( 0.0, 2, 3 );
+
+ final double[] center = new double[] { viewer.getWidth() / 2, viewer.getHeight() / 2, 0 };
+ final double[] ptxfm = new double[ 3 ];
+ xfmCopy.apply( pt, ptxfm );
+
+ // select appropriate row in the table
+ landmarkTable.setRowSelectionInterval( row, row );
+
+ // this should work fine in the 2d case
+ final TranslationAnimator animator = new TranslationAnimator( transform, new double[] { center[ 0 ] - ptxfm[ 0 ], center[ 1 ] - ptxfm[ 1 ], -ptxfm[ 2 ] }, 300 );
+ viewer.setTransformAnimator( animator );
+ }
+
+ public void goToBookmark()
+ {
+ if ( viewerFrameP.isActive() )
+ {
+ bookmarkEditorP.initGoToBookmark();
+ }
+ else if ( viewerFrameQ.isActive() )
+ {
+ bookmarkEditorQ.initGoToBookmark();
+ }
+ }
+
+ public void resetView()
+ {
+ final RandomAccessibleInterval< ? > interval = getSources().get( 1 ).getSpimSource().getSource( 0, 0 );
+
+ final AffineTransform3D viewXfm = new AffineTransform3D();
+ viewXfm.identity();
+ viewXfm.set( -interval.min( 2 ), 2, 3 );
+
+ if ( viewerFrameP.isActive() )
+ {
+ if ( viewerP.getOverlay().getIsTransformed() )
+ viewerP.animateTransformation( initialViewQ );
+ else
+ viewerP.animateTransformation( initialViewP );
+ }
+ else if ( viewerFrameQ.isActive() )
+ viewerQ.animateTransformation( initialViewQ );
+ }
+
+ public void toggleNameVisibility()
+ {
+ viewerSettings.toggleNamesVisible();
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+ }
+
+ public void togglePointVisibility()
+ {
+ viewerSettings.togglePointsVisible();
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+ }
+
+ /**
+ * Toggles whether the moving image is displayed after warping (in the same
+ * space as the fixed image), or in its native space.
+ *
+ * @return true of the display mode changed
+ */
+ public boolean toggleMovingImageDisplay()
+ {
+ // If this is the first time calling the toggle, there may not be enough
+ // points to estimate a reasonable transformation.
+ // return early if an re-estimation did not occur
+ boolean success = restimateTransformation();
+ logger.trace( "toggleMovingImageDisplay, success: " + success );
+ if ( !success )
+ {
+ message.showMessage( "Require at least 4 points to estimate a transformation" );
+ return false;
+ }
+
+ final boolean newState = !getOverlayP().getIsTransformed();
+
+ if ( newState )
+ message.showMessage( "Displaying warped" );
+ else
+ message.showMessage( "Displaying raw" );
+
+ // Toggle whether moving image is displayed as transformed or not
+ setIsMovingDisplayTransformed( newState );
+ return success;
+ }
+
+ public void toggleMaskOverlayVisibility()
+ {
+ getViewerFrameQ().getViewerPanel().getMaskOverlay().toggleVisible();
+ }
+
+ public void setMaskOverlayVisibility( final boolean visible )
+ {
+ getViewerFrameQ().getViewerPanel().getMaskOverlay().setVisible( visible );
+ }
+
+ protected void addDefaultTableMouseListener()
+ {
+ landmarkTableListener = new MouseLandmarkTableListener();
+ landmarkPanel.getJTable().addMouseListener( landmarkTableListener );
+ }
+
+ protected void addMaskMouseListener()
+ {
+ final Color[] maskColors = new Color[]{ Color.ORANGE, Color.YELLOW };
+ // only render mask overlay on target window
+ viewerQ.setMaskOverlay( new BigWarpMaskSphereOverlay( viewerQ, maskColors, numDimensions() == 3 ));
+
+ maskSourceMouseListenerP = new MaskedSourceEditorMouseListener( getLandmarkPanel().getTableModel().getNumdims(), this, viewerP );
+ maskSourceMouseListenerP.setActive( false );
+ maskSourceMouseListenerP.setMask( transformMask.getRandomAccessible() );
+
+ maskSourceMouseListenerQ = new MaskedSourceEditorMouseListener( getLandmarkPanel().getTableModel().getNumdims(), this, viewerQ );
+ maskSourceMouseListenerQ.setActive( false );
+ maskSourceMouseListenerQ.setMask( transformMask.getRandomAccessible() );
+
+<<<<<<< HEAD
+ tpsMask.getRandomAccessible().setOverlays( Arrays.asList( viewerQ.getMaskOverlay() ));
+=======
+ transformMask.getRandomAccessible().setOverlays( Arrays.asList( viewerP.getMaskOverlay(), viewerQ.getMaskOverlay() ));
+>>>>>>> cmhulbert/jsonSettings
+ }
+
+ public void setGridType( final GridSource.GRID_TYPE method )
+ {
+ ( ( GridSource< ? > ) gridSource.getSpimSource() ).setMethod( method );
+ }
+
+ public static List< SourceAndConverter > wrapSourcesAsTransformed( final List< SourceAndConverter > sources,
+ final int ndims,
+ final BigWarpData data )
+ {
+ final List< SourceAndConverter> wrappedSource = new ArrayList<>();
+
+ int[] warpUsIndices = data.movingSourceIndices;
+ HashMap, ColorSettings> colorSettings = data.sourceColorSettings;
+
+ int i = 0;
+ for ( final SourceAndConvertersac : sources )
+ {
+ int idx = Arrays.binarySearch( warpUsIndices, i );
+ if ( idx >= 0 )
+ {
+ SourceAndConverter newSac = wrapSourceAsTransformed( sac, "xfm_" + i, ndims );
+ wrappedSource.add( newSac );
+ colorSettings.put( newSac, colorSettings.get( sac ));
+ }
+ else
+ {
+ wrappedSource.add( sac );
+ }
+
+ i++;
+ }
+ return wrappedSource;
+ }
+
+ @SuppressWarnings( { "rawtypes", "unchecked" } )
+ private static < T > SourceAndConverter< FloatType > addJacobianDeterminantSource( final BigWarpData< T > data, final String name )
+ {
+ // TODO think about whether its worth it to pass a type parameter.
+ // or should we just stick with Doubles?
+
+ final JacobianDeterminantSource< FloatType > jdSource = new JacobianDeterminantSource<>( name, data, new FloatType() );
+ final RealARGBColorConverter< FloatType > converter = RealARGBColorConverter.create( new FloatType(), 0, 512 );
+ converter.setColor( new ARGBType( 0xffffffff ) );
+ final SourceAndConverter< FloatType > soc = new SourceAndConverter<>( jdSource, converter, null );
+ data.converterSetups.add( BigDataViewer.createConverterSetup( soc, JACDET_SOURCE_ID ) );
+ data.sources.add( ( SourceAndConverter ) soc );
+ return soc;
+ }
+
+ @SuppressWarnings( { "rawtypes", "unchecked" } )
+ private static < T > SourceAndConverter< FloatType > addWarpMagnitudeSource( final BigWarpData< T > data, final String name )
+ {
+ // TODO think about whether its worth it to pass a type parameter.
+ // or should we just stick with Doubles?
+
+ final WarpMagnitudeSource< FloatType > magSource = new WarpMagnitudeSource<>( name, data, new FloatType() );
+ final RealARGBColorConverter< FloatType > converter = RealARGBColorConverter.create( new FloatType(), 0, 512 );
+ converter.setColor( new ARGBType( 0xffffffff ) );
+ final SourceAndConverter< FloatType > soc = new SourceAndConverter<>( magSource, converter, null );
+ data.converterSetups.add( BigDataViewer.createConverterSetup( soc, WARPMAG_SOURCE_ID ) );
+ data.sources.add( ( SourceAndConverter ) soc );
+ return soc;
+ }
+
+ @SuppressWarnings( { "unchecked", "rawtypes" } )
+ private static < T > SourceAndConverter< FloatType > addGridSource( final BigWarpData< T > data, final String name )
+ {
+ // TODO think about whether its worth it to pass a type parameter.
+ // or should we just stick with Floats?
+
+ final GridSource< FloatType > gridSource = new GridSource<>( name, data, new FloatType(), null );
+ final RealARGBColorConverter< FloatType > converter = RealARGBColorConverter.create( new FloatType(), 0, 512 );
+ converter.setColor( new ARGBType( 0xffffffff ) );
+ final SourceAndConverter< FloatType > soc = new SourceAndConverter<>( gridSource, converter, null );
+ data.converterSetups.add( BigDataViewer.createConverterSetup( soc, GRID_SOURCE_ID ) );
+ data.sources.add( ( SourceAndConverter ) soc );
+ return soc;
+ }
+
+ @SuppressWarnings( { "unchecked", "rawtypes" } )
+ private SourceAndConverter< DoubleType > addTransformMaskSource( final BigWarpData< T > data, final int ndims, final String name )
+ {
+ // TODO think about whether its worth it to pass a type parameter.
+ // or should we just stick with Floats?
+ FinalInterval itvl = new FinalInterval( data.sources.get( data.targetSourceIndices[0] ).getSpimSource().getSource( 0, 0 ));
+ transformMask = PlateauSphericalMaskSource.build( new RealPoint( ndims ), itvl );
+
+ final RealARGBColorConverter< DoubleType > converter = RealARGBColorConverter.create( new DoubleType(), 0, 1 );
+ converter.setColor( new ARGBType( 0xffffffff ) );
+ final SourceAndConverter< DoubleType > soc = new SourceAndConverter( transformMask, converter, null );
+ data.converterSetups.add( BigDataViewer.createConverterSetup( soc, TRANSFORM_MASK_SOURCE_ID ) );
+ data.sources.add( ( SourceAndConverter ) soc );
+ return soc;
+ }
+
+ public PlateauSphericalMaskSource getTransformMaskSource()
+ {
+ return transformMask;
+ }
+
+ private static < T > SourceAndConverter< T > wrapSourceAsTransformed( final SourceAndConverter< T > src, final String name, final int ndims )
+ {
+ if ( src.asVolatile() == null )
+ {
+ return new SourceAndConverter< T >( new WarpedSource< T >( src.getSpimSource(), name ), src.getConverter(), null );
+ }
+ else
+ {
+ return new SourceAndConverter< T >( new WarpedSource< T >( src.getSpimSource(), name ), src.getConverter(), wrapSourceAsTransformed( src.asVolatile(), name + "_vol", ndims ) );
+ }
+ }
+
+ public void setupKeyListener()
+ {
+ KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventPostProcessor( new LandmarkKeyboardProcessor( this ) );
+ }
+
+ public void setWarpVisGridType( final GridSource.GRID_TYPE type )
+ {
+ ( ( GridSource< ? > ) gridSource.getSpimSource() ).setMethod( type );
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+ }
+
+ public void setWarpGridWidth( final double width )
+ {
+ ( ( GridSource< ? > ) gridSource.getSpimSource() ).setGridWidth( width );
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+ }
+
+ public void setWarpGridSpacing( final double spacing )
+ {
+ ( ( GridSource< ? > ) gridSource.getSpimSource() ).setGridSpacing( spacing );
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+ }
+
+ public void setAutoSaver( final BigWarpAutoSaver autoSaver )
+ {
+ this.autoSaver = autoSaver;
+ }
+
+ protected void setupWarpMagBaselineOptions( final CoordinateTransform[] xfm, final int ndim )
+ {
+ if ( ndim == 2 )
+ {
+ xfm[ 0 ] = new AffineModel2D();
+ xfm[ 1 ] = new SimilarityModel2D();
+ xfm[ 2 ] = new RigidModel2D();
+ }
+ else
+ {
+ xfm[ 0 ] = new AffineModel3D();
+ xfm[ 1 ] = new SimilarityModel3D();
+ xfm[ 2 ] = new RigidModel3D();
+ }
+ }
+
+ public void setWarpMagBaselineIndex( int index )
+ {
+ baselineModelIndex = index;
+ fitBaselineWarpMagModel();
+ }
+
+ protected void fitBaselineWarpMagModel()
+ {
+ final int numActive = landmarkModel.numActive();
+ if( numActive < 4 )
+ return;
+
+ final int ndims = landmarkModel.getNumdims();
+ final double[][] p = new double[ ndims ][ numActive ];
+ final double[][] q = new double[ ndims ][ numActive ];
+ final double[] w = new double[ numActive ];
+
+ int k = 0;
+ for ( int i = 0; i < landmarkModel.getTransform().getNumLandmarks(); i++ )
+ {
+ if ( landmarkModel.isActive( i ) )
+ {
+ w[ k ] = 1.0;
+
+ for ( int d = 0; d < ndims; d++ )
+ {
+ p[ d ][ k ] = landmarkModel.getMovingPoint( i )[ d ];
+ q[ d ][ k ] = landmarkModel.getFixedPoint( i )[ d ];
+ }
+ k++;
+ }
+ }
+
+ try
+ {
+ final AbstractModel< ? > baseline = this.baseXfmList[ baselineModelIndex ];
+
+ baseline.fit( p, q, w ); // FITBASELINE
+ WrappedCoordinateTransform baselineTransform = new WrappedCoordinateTransform(
+ (InvertibleCoordinateTransform)baseline, ndims );
+
+ // the transform to compare is the inverse (because we use it for rendering)
+ // so need to give the inverse transform for baseline as well
+ ( ( WarpMagnitudeSource< ? > ) warpMagSource.getSpimSource() ).setBaseline( baselineTransform.inverse() );
+ }
+ catch ( final NotEnoughDataPointsException e )
+ {
+ e.printStackTrace();
+ }
+ catch ( final IllDefinedDataPointsException e )
+ {
+ e.printStackTrace();
+ }
+ getViewerFrameP().getViewerPanel().requestRepaint();
+ getViewerFrameQ().getViewerPanel().requestRepaint();
+ }
+
+ public void setMovingSpimData( SpimData movingSpimData, File movingImageXml )
+ {
+ this.movingSpimData = movingSpimData;
+ this.movingImageXml = movingImageXml;
+ }
+
+ public void setBookmarks( final Bookmarks bookmarks )
+ {
+ this.bookmarks = bookmarks;
+ }
+
+ public void setAutoEstimateMask( final boolean selected )
+ {
+ warpVisDialog.maskOptionsPanel.getAutoEstimateMaskButton().setSelected( selected );
+ }
+
+ public void autoEstimateMask()
+ {
+ if( landmarkModel.numActive() < 4 )
+ return;
+
+ if( warpVisDialog.autoEstimateMask() && bwTransform.isMasked() )
+ {
+ final Sphere sph = BoundingSphereRitter.boundingSphere(landmarkModel.getFixedPointsCopy());
+ transformMask.getRandomAccessible().setCenter(sph.getCenter());
+ transformMask.getRandomAccessible().setRadius(sph.getRadius());
+ }
+ }
+
+ public enum WarpVisType
+ {
+ NONE, WARPMAG, JACDET, GRID
+ }
+
+ public void setWarpVisMode( final WarpVisType type, BigWarpViewerFrame viewerFrame, final boolean both )
+ {
+ if ( viewerFrame == null )
+ {
+ if ( viewerFrameP.isActive() )
+ {
+ viewerFrame = viewerFrameP;
+ }
+ else if ( viewerFrameQ.isActive() )
+ {
+ viewerFrame = viewerFrameQ;
+ }
+ else if ( both )
+ {
+ setWarpVisMode( type, viewerFrameP, false );
+ setWarpVisMode( type, viewerFrameQ, false );
+ return;
+ }
+ else
+ {
+ return;
+ }
+
+ }
+//
+// int offImgIndex = 0;
+// int onImgIndex = 1;
+//
+// if ( viewerFrame == viewerFrameP )
+// {
+// offImgIndex = 1;
+// onImgIndex = 0;
+// }
+
+ if ( landmarkModel.getTransform() == null )
+ {
+ message.showMessage( "No warp - estimate warp first." );
+ return;
+ }
+ final ViewerState state = viewerFrame.getViewerPanel().state();
+
+ switch ( type )
+ {
+ case JACDET:
+ {
+ // turn warp mag on
+ state.setSourceActive( warpMagSource, false );
+ state.setSourceActive( jacDetSource, true );
+ state.setSourceActive( gridSource, false );
+
+ }
+ case WARPMAG:
+ {
+ // turn warp mag on
+ state.setSourceActive( warpMagSource, true );
+ state.setSourceActive( jacDetSource, false );
+ state.setSourceActive( gridSource, false );
+// vg.setSourceActive( offImgIndex, false );
+
+ // estimate the max warp
+// final WarpMagnitudeSource< ? > wmSrc = ( ( WarpMagnitudeSource< ? > ) sources.get( warpMagSourceIndex ).getSpimSource() );
+// final double maxval = wmSrc.getMax( landmarkModel );
+
+ // set the slider
+// ( ( RealARGBColorConverter< FloatType > ) ( sources.get( warpMagSourceIndex ).getConverter() ) ).setMax( maxval );
+
+ state.setDisplayMode( DisplayMode.FUSED );
+ message.showMessage( "Displaying Warp Magnitude" );
+ break;
+ }
+ case GRID:
+ {
+ // turn grid vis on
+
+ state.setSourceActive( warpMagSource, false );
+ state.setSourceActive( jacDetSource, false );
+ state.setSourceActive( gridSource, true );
+// vg.setSourceActive( offImgIndex, false );
+
+ state.setDisplayMode( DisplayMode.FUSED );
+ message.showMessage( "Displaying Warp Grid" );
+ break;
+ }
+ default:
+ {
+ state.setSourceActive( warpMagSource, false );
+ state.setSourceActive( gridSource, false );
+// vg.setSourceActive( offImgIndex, true );
+
+// vg.setFusedEnabled( false );
+ message.showMessage( "Turning off warp vis" );
+ break;
+ }
+ }
+ }
+
+ public void toggleWarpVisMode( BigWarpViewerFrame viewerFrame )
+ {
+// int offImgIndex = 0;
+// int onImgIndex = 1;
+ if ( viewerFrame == null )
+ {
+ if ( viewerFrameP.isActive() )
+ {
+ viewerFrame = viewerFrameP;
+ }
+ else if ( viewerFrameQ.isActive() )
+ {
+ viewerFrame = viewerFrameQ;
+ }
+ else
+ return;
+ }
+
+// if ( viewerFrame == viewerFrameP )
+// {
+// offImgIndex = 1;
+// onImgIndex = 0;
+// }
+
+ if ( landmarkModel.getTransform() == null )
+ {
+ message.showMessage( "No warp - estimate warp first." );
+ return;
+ }
+
+ final ViewerState state = viewerFrame.getViewerPanel().state();
+
+ // TODO consider remembering whether fused was on before displaying
+ // warpmag
+ // so that its still on or off after we turn it off
+ if ( state.isSourceActive( warpMagSource ) ) // warp mag is visible,
+ // turn it off
+ {
+ state.setSourceActive( warpMagSource, false );
+
+// vg.setSourceActive( offImgIndex, true );
+
+ state.setDisplayMode( state.getDisplayMode().withFused( false ) );
+ message.showMessage( "Removing Warp Magnitude" );
+ }
+ else // warp mag is invisible, turn it on
+ {
+ state.setSourceActive( warpMagSource, true );
+
+// vg.setSourceActive( offImgIndex, false );
+
+ // estimate the max warp
+// final WarpMagnitudeSource< ? > wmSrc = ( ( WarpMagnitudeSource< ? > ) sources.get( warpMagSourceIndex ).getSpimSource() );
+// final double maxval = wmSrc.getMax( landmarkModel );
+
+ // set the slider
+// ( ( RealARGBColorConverter< FloatType > ) ( sources.get( warpMagSourceIndex ).getConverter() ) ).setMax( maxval );
+
+ state.setDisplayMode( state.getDisplayMode().withFused( false ) );
+ message.showMessage( "Displaying Warp Magnitude" );
+ }
+
+ viewerFrame.getViewerPanel().requestRepaint();
+ }
+
+ private void setTransformationMovingSourceOnly( final InvertibleRealTransform transform )
+ {
+ this.currentTransform = transform;
+
+ for ( int i = 0; i < movingSourceIndexList.length; i++ )
+ {
+ int idx = movingSourceIndexList [ i ];
+
+ // the xfm must always be 3d for bdv to be happy.
+ // when bigwarp has 2d images though, the z- component will be left unchanged
+ //InverseRealTransform xfm = new InverseRealTransform( new TpsTransformWrapper( 3, transform ));
+
+ // the updateTransform method creates a copy of the transform
+ ( ( WarpedSource< ? > ) ( sources.get( idx ).getSpimSource() ) ).updateTransform( transform );
+ if ( sources.get( 0 ).asVolatile() != null )
+ ( ( WarpedSource< ? > ) ( sources.get( idx ).asVolatile().getSpimSource() ) ).updateTransform( transform );
+ }
+ }
+
+ public void updateSourceBoundingBoxEstimators()
+ {
+ for ( int i = 0; i < movingSourceIndexList.length; i++ )
+ {
+ int idx = movingSourceIndexList [ i ];
+
+ // the xfm must always be 3d for bdv to be happy.
+ // when bigwarp has 2d images though, the z- component will be left unchanged
+ //InverseRealTransform xfm = new InverseRealTransform( new TpsTransformWrapper( 3, transform ));
+
+ // the updateTransform method creates a copy of the transform
+ ( ( WarpedSource< ? > ) ( sources.get( idx ).getSpimSource() ) ).setBoundingBoxEstimator(bboxOptions.copy());
+ if ( sources.get( 0 ).asVolatile() != null )
+ ( ( WarpedSource< ? > ) ( sources.get( idx ).asVolatile().getSpimSource() ) ).setBoundingBoxEstimator(bboxOptions.copy());
+ }
+ }
+
+ private synchronized void notifyTransformListeners( )
+ {
+ for ( final TransformListener< InvertibleRealTransform > l : transformListeners )
+ l.transformChanged( currentTransform );
+ }
+
+ private void setTransformationAll( final InvertibleRealTransform transform )
+ {
+ setTransformationMovingSourceOnly( transform );
+
+ final WarpMagnitudeSource< ? > wmSrc = ( ( WarpMagnitudeSource< ? > ) warpMagSource.getSpimSource() );
+ final JacobianDeterminantSource< ? > jdSrc = ( ( JacobianDeterminantSource< ? > ) jacDetSource.getSpimSource() );
+ final GridSource< ? > gSrc = ( ( GridSource< ? > ) gridSource.getSpimSource() );
+
+ wmSrc.setWarp( transform );
+ fitBaselineWarpMagModel();
+
+ if( transform instanceof ThinplateSplineTransform )
+ {
+ jdSrc.setTransform( (ThinplateSplineTransform)transform );
+ }
+ else if ( transform instanceof WrappedIterativeInvertibleRealTransform )
+ {
+ RealTransform xfm = ((WrappedIterativeInvertibleRealTransform)transform).getTransform();
+ if( xfm instanceof ThinplateSplineTransform )
+ jdSrc.setTransform( (ThinplateSplineTransform) xfm );
+ else
+ jdSrc.setTransform( new RealTransformFiniteDerivatives( xfm ));
+ }
+ else
+ jdSrc.setTransform( null );
+
+ gSrc.setWarp( transform );
+ }
+
+ public boolean restimateTransformation()
+ {
+ if ( landmarkModel.getActiveRowCount() < 4 )
+ {
+ return false;
+ }
+ // TODO restimateTransformation
+ // This distinction is unnecessary right now, because
+ // transferUpdatesToModel just calls initTransformation.. but this may
+ // change
+// if ( landmarkModel.getTransform() == null )
+// landmarkModel.initTransformation();
+// else
+// landmarkModel.transferUpdatesToModel();
+
+ solverThread.requestResolve( true, -1, null );
+
+ // display the warped version automatically if this is the first
+ // time the transform was computed
+ if ( firstWarpEstimation )
+ {
+ setUpdateWarpOnChange( true );
+ firstWarpEstimation = false;
+ }
+
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+
+ notifyTransformListeners();
+
+ return true;
+ }
+
+ public synchronized void setIsMovingDisplayTransformed( final boolean isTransformed )
+ {
+ for( int i = 0 ; i < movingSourceIndexList.length; i ++ )
+ {
+ int movingSourceIndex = movingSourceIndexList[ i ];
+
+ ( ( WarpedSource< ? > ) ( sources.get( movingSourceIndex ).getSpimSource() ) ).setIsTransformed( isTransformed );
+
+ if ( sources.get( movingSourceIndex ).asVolatile() != null )
+ ( ( WarpedSource< ? > ) ( sources.get( movingSourceIndex ).asVolatile().getSpimSource() ) ).setIsTransformed( isTransformed );
+ }
+
+ overlayP.setIsTransformed( isTransformed );
+
+ viewerP.requestRepaint();
+
+ if ( viewerQ.state().getDisplayMode().hasFused() )
+ {
+ viewerQ.requestRepaint();
+ }
+ }
+
+ /**
+ * Returns true if the currently selected row in the landmark table is missing on the the landmarks
+ * @return true if there is a missing value
+ */
+ public boolean isRowIncomplete()
+ {
+ LandmarkTableModel ltm = landmarkPanel.getTableModel();
+ return ltm.isPointUpdatePending() || ltm.isPointUpdatePendingMoving();
+ }
+
+ public boolean isMovingDisplayTransformed()
+ {
+ // this implementation is okay, so long as all the moving images have the same state of 'isTransformed'
+ return ( ( WarpedSource< ? > ) ( sources.get( movingSourceIndexList[ 0 ] ).getSpimSource() ) ).isTransformed();
+ }
+
+ /**
+ * The display will be in 3d if any of the input sources are 3d.
+ * @return dimension of the input sources
+ */
+ protected int detectNumDims()
+ {
+ return detectNumDims( sources );
+ }
+
+ /**
+ * The display will be in 3d if any of the input sources are 3d.
+ * @param sources the sources
+ * @param the type
+ * @return dimension of the input sources
+ */
+ public static int detectNumDims( List< SourceAndConverter< T > > sources )
+ {
+ boolean isAnySource3d = false;
+ for ( SourceAndConverter< T > sac : sources )
+ {
+ long[] dims = new long[ sac.getSpimSource().getSource( 0, 0 ).numDimensions() ];
+ sac.getSpimSource().getSource( 0, 0 ).dimensions( dims );
+
+ if ( sac.getSpimSource().getSource( 0, 0 ).dimension( 2 ) > 1 )
+ {
+ isAnySource3d = true;
+ break;
+ }
+ }
+
+ int ndims = 2;
+ if ( isAnySource3d )
+ ndims = 3;
+
+ return ndims;
+ }
+
+ public static void main( final String[] args )
+ {
+ new ImageJ();
+
+ // TODO main
+ String fnP = "";
+ String fnQ = "";
+ String fnLandmarks = "";
+
+ int i = 0;
+ if ( args.length >= 2 )
+ {
+ fnP = args[ i++ ];
+ fnQ = args[ i++ ];
+ }
+ else
+ {
+ System.err.println( "Must provide at least 2 inputs for moving and target image files" );
+ System.exit( 1 );
+ }
+
+ if ( args.length > i )
+ fnLandmarks = args[ i++ ];
+
+ boolean doInverse = false;
+ if ( args.length > i )
+ {
+ try
+ {
+ doInverse = Boolean.parseBoolean( args[ i++ ] );
+ System.out.println( "parsed inverse param: " + doInverse );
+ }
+ catch ( final Exception e )
+ {
+ // no inverse param
+ System.err.println( "Warning: Failed to parse inverse parameter." );
+ }
+ }
+
+ try
+ {
+ System.setProperty( "apple.laf.useScreenMenuBar", "false" );
+
+
+ ProgressWriterIJ progress = new ProgressWriterIJ();
+ BigWarp bw;
+ BigWarpData bwdata;
+ if ( fnP.endsWith( "xml" ) && fnQ.endsWith( "xml" ) )
+ {
+ bwdata = BigWarpInit.createBigWarpDataFromXML( fnP, fnQ );
+ bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ }
+ else if ( fnP.endsWith( "xml" ) && !fnQ.endsWith( "xml" ) )
+ {
+ final ImagePlus impQ = IJ.openImage( fnQ );
+ bwdata = BigWarpInit.createBigWarpDataFromXMLImagePlus( fnP, impQ );
+ bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ }
+ else if ( !fnP.endsWith( "xml" ) && fnQ.endsWith( "xml" ) )
+ {
+ final ImagePlus impP = IJ.openImage( fnP );
+ bwdata = BigWarpInit.createBigWarpDataFromImagePlusXML( impP, fnQ );
+ bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ }
+ else
+ {
+ final ImagePlus impP = IJ.openImage( fnP );
+ final ImagePlus impQ = IJ.openImage( fnQ );
+
+ if ( !( impP == null || impQ == null ) )
+ {
+ bwdata = BigWarpInit.createBigWarpDataFromImages( impP, impQ );
+ bw = new BigWarp<>( bwdata, new File( fnP ).getName(), progress );
+ }
+ else
+ {
+ System.err.println( "Error reading images" );
+ return;
+ }
+ }
+
+
+ if ( !fnLandmarks.isEmpty() )
+ bw.loadLandmarks( fnLandmarks );
+
+ if ( doInverse )
+ bw.invertPointCorrespondences();
+
+ }
+ catch ( final Exception e )
+ {
+
+ e.printStackTrace();
+ }
+ }
+
+ private void viewerXfmTest()
+ {
+ AffineTransform3D srcTransform0 = new AffineTransform3D();
+ sources.get( 0 ).getSpimSource().getSourceTransform(0, 0, srcTransform0 );
+
+ AffineTransform3D srcTransform1 = new AffineTransform3D();
+ sources.get( 1 ).getSpimSource().getSourceTransform(0, 0, srcTransform1 );
+
+ AffineTransform3D viewerTransformM = new AffineTransform3D();
+ viewerP.state().getViewerTransform( viewerTransformM );
+
+ AffineTransform3D viewerTransformT = new AffineTransform3D();
+ viewerQ.state().getViewerTransform( viewerTransformT );
+
+ System.out.println( " " );
+ System.out.println( " " );
+ System.out.println( "srcXfm 0 " + srcTransform0 );
+ System.out.println( "srcXfm 1 " + srcTransform1 );
+
+ System.out.println( "viewerXfm M " + viewerTransformM );
+ System.out.println( "viewerXfm T " + viewerTransformT );
+ System.out.println( " " );
+ System.out.println( " " );
+
+ }
+
+ public void checkBoxInputMaps()
+ {
+ // Disable spacebar for toggling checkboxes
+ // Make it enter instead
+ // This is super ugly ... why does it have to be this way.
+
+ final TableCellEditor celled = landmarkTable.getCellEditor( 0, 1 );
+ final Component c = celled.getTableCellEditorComponent( landmarkTable, Boolean.TRUE, true, 0, 1 );
+
+ final InputMap parentInputMap = ( ( JCheckBox ) c ).getInputMap().getParent();
+ parentInputMap.clear();
+ final KeyStroke enterDownKS = KeyStroke.getKeyStroke( "pressed ENTER" );
+ final KeyStroke enterUpKS = KeyStroke.getKeyStroke( "released ENTER" );
+
+ parentInputMap.put( enterDownKS, "pressed" );
+ parentInputMap.put( enterUpKS, "released" );
+
+ /*
+ * Consider with replacing with something like the below Found in
+ * BigWarpViewerFrame
+ */
+// SwingUtilities.replaceUIActionMap( getRootPane(), keybindings.getConcatenatedActionMap() );
+// SwingUtilities.replaceUIInputMap( getRootPane(), JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keybindings.getConcatenatedInputMap() );
+ }
+
+ public static class BigWarpData< T >
+ {
+ public final List< SourceAndConverter< T > > sources;
+
+ public final List< ConverterSetup > converterSetups;
+
+ public final CacheControl cache;
+
+ public int[] movingSourceIndices;
+
+ public int[] targetSourceIndices;
+
+ public final ArrayList< Integer > movingSourceIndexList;
+
+ public final ArrayList< Integer > targetSourceIndexList;
+
+ public final HashMap< Integer, ColorSettings > setupSettings;
+
+ public final HashMap< SourceAndConverter, ColorSettings > sourceColorSettings;
+ public BigWarpData( final List< SourceAndConverter< T > > sources, final List< ConverterSetup > converterSetups, final CacheControl cache, int[] movingSourceIndices, int[] targetSourceIndices )
+ {
+ this.sources = sources;
+ this.converterSetups = converterSetups;
+ this.movingSourceIndices = movingSourceIndices;
+ this.targetSourceIndices = targetSourceIndices;
+
+ this.movingSourceIndexList = new ArrayList<>();
+ this.targetSourceIndexList = new ArrayList<>();
+
+
+ if ( cache == null )
+ this.cache = new CacheControl.Dummy();
+ else
+ this.cache = cache;
+
+ setupSettings = new HashMap<>();
+ sourceColorSettings = new HashMap<>();
+ }
+
+ public void wrapUp()
+ {
+ movingSourceIndices = movingSourceIndexList.stream().mapToInt( x -> x ).toArray();
+ targetSourceIndices = targetSourceIndexList.stream().mapToInt( x -> x ).toArray();
+
+ Arrays.sort( movingSourceIndices );
+ Arrays.sort( targetSourceIndices );
+ }
+
+ /**
+ * @deprecated
+ */
+ public void transferChannelSettings( final SetupAssignments setupAssignments, final VisibilityAndGrouping visibility )
+ {
+ for( Integer key : setupSettings.keySet() )
+ setupSettings.get( key ).updateSetup( setupAssignments );
+ }
+
+ public void transferChannelSettings( final BigWarpViewerFrame viewer )
+ {
+ SynchronizedViewerState state = viewer.getViewerPanel().state();
+ ConverterSetups setups = viewer.getConverterSetups();
+ synchronized ( state )
+ {
+ for ( SourceAndConverter< ? > sac : state.getSources() )
+ {
+ if ( sourceColorSettings.containsKey( sac ) )
+ {
+ if ( sourceColorSettings.get( sac ) == null )
+ continue;
+
+ sourceColorSettings.get( sac ).updateSetup( setups.getConverterSetup( sac ) );
+ }
+ else
+ {
+ final int timepoint = state.getCurrentTimepoint();
+ final Bounds bounds = InitializeViewerState.estimateSourceRange( sac.getSpimSource(), timepoint, 0.001, 0.999 );
+ ConverterSetup cs = setups.getConverterSetup(sac);
+ if( cs != null )
+ cs.setDisplayRange( bounds.getMinBound(), bounds.getMaxBound() );
+ }
+ }
+ }
+ }
+ }
+
+ protected class LandmarkModeListener implements KeyEventPostProcessor
+ {
+ @Override
+ public boolean postProcessKeyEvent( final KeyEvent ke )
+ {
+ if ( ke.isConsumed() )
+ return false;
+
+ if ( ke.getKeyCode() == KeyEvent.VK_SPACE )
+ {
+ if ( ke.getID() == KeyEvent.KEY_PRESSED )
+ {
+ BigWarp.this.setInLandmarkMode( true );
+ return false;
+ }
+ else if ( ke.getID() == KeyEvent.KEY_RELEASED )
+ {
+ BigWarp.this.setInLandmarkMode( false );
+ return false;
+ }
+ }
+ return false;
+ }
+ }
+
+ // TODO,
+ // consider this
+ // https://github.com/kwhat/jnativehook
+ // for arbitrary modifiers
+ protected class MouseLandmarkListener implements MouseListener, MouseMotionListener
+ {
+
+ // -1 indicates that no point is selected
+ int selectedPointIndex = -1;
+
+ double[] ptarrayLoc = new double[ 3 ];
+
+ double[] ptBackLoc = new double[ 3 ];
+
+ private BigWarpViewerPanel thisViewer;
+
+ private boolean isMoving;
+
+ private long pressTime;
+
+ private RealPoint hoveredPoint;
+
+ private double[] hoveredArray;
+
+ protected MouseLandmarkListener( final BigWarpViewerPanel thisViewer )
+ {
+ setViewer( thisViewer );
+ thisViewer.getDisplay().addHandler( this );
+ isMoving = ( thisViewer == BigWarp.this.viewerP );
+ hoveredArray = new double[ 3 ];
+ hoveredPoint = RealPoint.wrap( hoveredArray );
+ }
+
+ protected void setViewer( final BigWarpViewerPanel thisViewer )
+ {
+ this.thisViewer = thisViewer;
+ }
+
+ @Override
+ public void mouseClicked( final MouseEvent arg0 )
+ {}
+
+ @Override
+ public void mouseEntered( final MouseEvent arg0 )
+ {}
+
+ @Override
+ public void mouseExited( final MouseEvent arg0 )
+ {}
+
+ @Override
+ public void mousePressed( final MouseEvent e )
+ {
+ pressTime = System.currentTimeMillis();
+
+ // shift down is reserved for drag overlay
+ if ( e.isShiftDown() ) { return; }
+
+ if ( BigWarp.this.isInLandmarkMode() )
+ {
+ thisViewer.getGlobalMouseCoordinates( BigWarp.this.currentLandmark );
+
+ BigWarp.this.currentLandmark.localize( ptarrayLoc );
+ selectedPointIndex = BigWarp.this.selectedLandmark( ptarrayLoc, isMoving );
+
+ if ( selectedPointIndex >= 0 )
+ {
+ landmarkTable.setRowSelectionInterval( selectedPointIndex, selectedPointIndex );
+ landmarkFrame.repaint();
+ BigWarp.this.landmarkModel.setLastPoint( selectedPointIndex, isMoving );
+ }
+ }
+ }
+
+ @Override
+ public void mouseReleased( final MouseEvent e )
+ {
+ long clickLength = System.currentTimeMillis() - pressTime;
+
+ if( clickLength < keyClickMaxLength && selectedPointIndex != -1 )
+ return;
+
+ // shift when
+ boolean isMovingLocal = isMoving;
+ if ( e.isShiftDown() && e.isControlDown() )
+ {
+ isMovingLocal = !isMoving;
+ }
+ else if( e.isShiftDown())
+ {
+ // shift is reserved for click-drag
+ return;
+ }
+ else if ( e.isControlDown() )
+ {
+ if ( BigWarp.this.isInLandmarkMode() && selectedPointIndex < 0 )
+ {
+ thisViewer.getGlobalMouseCoordinates( BigWarp.this.currentLandmark );
+ addFixedPoint( BigWarp.this.currentLandmark, isMovingLocal );
+ }
+ return;
+ }
+
+ boolean wasNewRowAdded = false;
+
+ // deselect any point that may be selected
+ if ( BigWarp.this.isInLandmarkMode() )
+ {
+ thisViewer.getGlobalMouseCoordinates( BigWarp.this.currentLandmark );
+ currentLandmark.localize( ptarrayLoc );
+
+ if ( selectedPointIndex == -1 )
+ wasNewRowAdded = addPoint( ptarrayLoc, isMovingLocal );
+ else
+ {
+ final boolean isWarped = isMovingLocal && ( landmarkModel.getTransform() != null ) && ( BigWarp.this.isMovingDisplayTransformed() );
+ wasNewRowAdded = BigWarp.this.landmarkModel.pointEdit( selectedPointIndex, ptarrayLoc, false, isMovingLocal, isWarped, true, currentTransform );
+ }
+
+ if ( updateWarpOnPtChange && !wasNewRowAdded )
+ {
+ // here, if a new row is added, then only one of the point
+ // pair was added.
+ // if we changed and existing row, then we have both points
+ // in the pair and should recompute
+ BigWarp.this.restimateTransformation();
+ }
+
+ if( wasNewRowAdded )
+ updateRowSelection( isMovingLocal, landmarkModel.getRowCount() - 1 );
+ else
+ updateRowSelection( isMovingLocal, selectedPointIndex );
+ }
+ BigWarp.this.landmarkModel.resetLastPoint();
+ selectedPointIndex = -1;
+ }
+
+ @Override
+ public void mouseDragged( final MouseEvent e )
+ {
+ // shift down is reserved for drag overlay
+ if ( e.isShiftDown() ) { return; }
+
+ if ( BigWarp.this.isInLandmarkMode() && selectedPointIndex >= 0 )
+ {
+ thisViewer.getGlobalMouseCoordinates( BigWarp.this.currentLandmark );
+ currentLandmark.localize( ptarrayLoc );
+
+ if ( BigWarp.this.isMovingDisplayTransformed() &&
+ thisViewer.doUpdateOnDrag() &&
+ BigWarp.this.landmarkModel.isActive( selectedPointIndex ) )
+ {
+ logger.trace("Drag resolve");
+ solverThread.requestResolve( isMoving, selectedPointIndex, ptarrayLoc );
+ }
+ else
+ {
+ // Make a non-undoable edit so that the point can be displayed correctly
+ // the undoable action is added on mouseRelease
+ if( isMoving && isMovingDisplayTransformed() )
+ {
+ logger.trace("Drag moving transformed");
+ // The moving image:
+ // Update the warped point during the drag even if there is a corresponding fixed image point
+ // Do this so the point sticks on the mouse
+ BigWarp.this.landmarkModel.pointEdit(
+ selectedPointIndex,
+ BigWarp.this.landmarkModel.getTransform().apply( ptarrayLoc ),
+ false, isMoving, ptarrayLoc, false );
+ thisViewer.requestRepaint();
+ }
+ else
+ {
+ logger.trace("Drag default");
+ // The fixed image
+ BigWarp.this.landmarkModel.pointEdit( selectedPointIndex, ptarrayLoc, false, isMoving, false, false, currentTransform );
+ thisViewer.requestRepaint();
+ }
+ }
+ }
+ }
+
+ @Override
+ public void mouseMoved( final MouseEvent e )
+ {
+ thisViewer.getGlobalMouseCoordinates( hoveredPoint );
+ int hoveredIndex = BigWarp.this.selectedLandmark( hoveredArray, isMoving, false );
+ thisViewer.setHoveredIndex( hoveredIndex );
+ }
+
+ /**
+ * Adds a point in the moving and fixed images at the same point.
+ * @param pt the point
+ * @param isMovingImage is the point in moving image space
+ */
+ public void addFixedPoint( final RealPoint pt, final boolean isMovingImage )
+ {
+ if ( isMovingImage && viewerP.getTransformEnabled() )
+ {
+ // Here we clicked in the space of the moving image
+ currentLandmark.localize( ptarrayLoc );
+ addPoint( ptarrayLoc, true, viewerP );
+ addPoint( ptarrayLoc, false, viewerQ );
+ }
+ else
+ {
+ currentLandmark.localize( ptarrayLoc );
+ addPoint( ptarrayLoc, true, viewerP );
+ addPoint( ptarrayLoc, false, viewerQ );
+ }
+ if ( updateWarpOnPtChange )
+ BigWarp.this.restimateTransformation();
+ }
+ }
+
+ public class WarningTableCellRenderer extends DefaultTableCellRenderer
+ {
+ private static final long serialVersionUID = 7836269349663370123L;
+
+ @Override
+ public Component getTableCellRendererComponent( JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column )
+ {
+ LandmarkTableModel model = ( LandmarkTableModel ) table.getModel();
+ Component c = super.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column );
+ if ( model.rowNeedsWarning( row ) )
+ c.setBackground( LandmarkTableModel.WARNINGBGCOLOR );
+ else
+ c.setBackground( LandmarkTableModel.DEFAULTBGCOLOR );
+ return c;
+ }
+ }
+
+ public class LandmarkTableListener implements TableModelListener
+ {
+ @Override
+ public void tableChanged( final TableModelEvent e )
+ {
+ // re-estimate if a a point was set to or from active
+ // note - this covers "resetting" points as well
+ if ( e.getColumn() == LandmarkTableModel.ACTIVECOLUMN )
+ {
+ BigWarp.this.restimateTransformation();
+ BigWarp.this.landmarkPanel.repaint();
+ }
+ autoEstimateMask();
+ }
+ }
+
+ public class MouseLandmarkTableListener implements MouseListener
+ {
+ boolean wasDoubleClick = false;
+
+ Timer timer;
+
+ public MouseLandmarkTableListener()
+ {}
+
+ @Override
+ public void mouseClicked( final MouseEvent e )
+ {
+ final int ndims = landmarkModel.getNumdims();
+// if ( BigWarp.this.isInLandmarkMode() )
+// {
+// final JTable target = ( JTable ) e.getSource();
+//
+// final int row = target.getSelectedRow();
+// final int column = target.getSelectedColumn();
+//
+// final boolean isMoving = ( column > 1 && column < ( 2 + ndims ) );
+//
+// BigWarp.this.landmarkModel.clearPt( row, isMoving );
+//
+// }
+// else if ( e.getClickCount() == 2 )
+ if ( e.getClickCount() == 2 )
+ {
+ final JTable target = ( JTable ) e.getSource();
+ final int row = target.getSelectedRow();
+ final int column = target.getSelectedColumn();
+
+ if( row < 0 )
+ return;
+
+ double[] pt = null;
+ int offset = 0;
+
+ final BigWarpViewerPanel viewer;
+ if ( column >= ( 2 + ndims ) )
+ {
+ // clicked on a fixed point
+ viewer = BigWarp.this.viewerQ;
+ offset = ndims;
+ }
+ else if ( column >= 2 && column < ( 2 + ndims ) )
+ {
+ // clicked on a moving point
+ viewer = BigWarp.this.viewerP;
+
+ if ( BigWarp.this.viewerP.getOverlay().getIsTransformed() )
+ if ( BigWarp.this.landmarkModel.isWarped( row ) )
+ pt = LandmarkTableModel.toPrimitive( BigWarp.this.landmarkModel.getWarpedPoints().get( row ) );
+ else
+ offset = ndims;
+ }
+ else
+ {
+ // we're in a column that doesn't correspond to a point and
+ // should do nothing
+ return;
+ }
+
+ // the pt variable might be set above by grabbing the warped point.
+ // if so, stick with it, else grab the appropriate value from the table
+ if ( pt == null )
+ {
+ if ( ndims == 3 )
+ pt = new double[] { ( Double ) target.getValueAt( row, offset + 2 ), ( Double ) target.getValueAt( row, offset + 3 ), ( Double ) target.getValueAt( row, offset + 4 ) };
+ else
+ pt = new double[] { ( Double ) target.getValueAt( row, offset + 2 ), ( Double ) target.getValueAt( row, offset + 3 ), 0.0 };
+ }
+
+ // we have an unmatched point
+ if ( Double.isInfinite( pt[ 0 ] ) )
+ return;
+
+ final AffineTransform3D transform = viewer.state().getViewerTransform();
+ final AffineTransform3D xfmCopy = transform.copy();
+ xfmCopy.set( 0.0, 0, 3 );
+ xfmCopy.set( 0.0, 1, 3 );
+ xfmCopy.set( 0.0, 2, 3 );
+
+ final double[] center = new double[] { viewer.getWidth() / 2, viewer.getHeight() / 2, 0
+ };
+ final double[] ptxfm = new double[ 3 ];
+ xfmCopy.apply( pt, ptxfm );
+
+ // this should work fine in the 2d case
+ final TranslationAnimator animator = new TranslationAnimator( transform, new double[] { center[ 0 ] - ptxfm[ 0 ], center[ 1 ] - ptxfm[ 1 ], -ptxfm[ 2 ] }, 300 );
+ viewer.setTransformAnimator( animator );
+ }
+ else
+ {
+ final JTable target = ( JTable ) e.getSource();
+ final int row = target.rowAtPoint( e.getPoint() );
+
+ // if we click in the table but not on a row, deselect everything
+ if( row < 0 && target.getRowCount() > 0 )
+ target.removeRowSelectionInterval( 0, target.getRowCount() - 1 );
+ }
+ }
+
+ @Override
+ public void mouseEntered( final MouseEvent e )
+ {}
+
+ @Override
+ public void mouseExited( final MouseEvent e )
+ {}
+
+ @Override
+ public void mousePressed( final MouseEvent e )
+ {}
+
+ @Override
+ public void mouseReleased( final MouseEvent e )
+ {}
+
+ }
+
+ public void setTransformType( final String type )
+ {
+ bwTransform.setTransformType( type );
+ this.restimateTransformation();
+ }
+
+ public void setTransformTypeUpdateUI( final String type )
+ {
+ setTransformType( type );
+ updateTransformTypeDialog( type );
+ updateTransformTypePanel( type );
+ }
+
+ /**
+ * Update the transformation selection dialog to reflect the given transform type selection.
+ *
+ * @param type the transformation type
+ */
+ public void updateTransformTypeDialog( final String type )
+ {
+ transformSelector.deactivate();
+ transformSelector.setTransformType( type );
+ transformSelector.activate();
+ }
+
+ /**
+ * Update the transformation selection panel in the options dialog to reflect the given transform type selection.
+ *
+ * @param type the transformation type
+ */
+ public void updateTransformTypePanel( final String type )
+ {
+ warpVisDialog.transformTypePanel.deactivate();
+ warpVisDialog.transformTypePanel.setType( type );
+ warpVisDialog.transformTypePanel.activate();
+ }
+
+ public String getTransformType()
+ {
+ return bwTransform.getTransformType();
+ }
+
+ public BigWarpTransform getBwTransform()
+ {
+ return bwTransform;
+ }
+
+ public BoundingBoxEstimation getBoxEstimation()
+ {
+ return bboxOptions;
+ }
+
+ /**
+ * Use getTps, getTpsBase, or getTransformation instead
+ * @return
+ */
+ @Deprecated
+ public ThinPlateR2LogRSplineKernelTransform getTransform()
+ {
+ return landmarkPanel.getTableModel().getTransform();
+ }
+
+ public synchronized void addTransformListener( TransformListener< InvertibleRealTransform > listener )
+ {
+ transformListeners.add( listener );
+ }
+
+
+// public InvertibleRealTransform getTransformation( final int index )
+// {
+// int ndims = 3;
+// InvertibleRealTransform invXfm = null;
+// if( transformType.equals( TransformTypeSelectDialog.TPS ))
+// {
+// final ThinPlateR2LogRSplineKernelTransform xfm;
+// if ( index >= 0 ) // a point position is modified
+// {
+// LandmarkTableModel tableModel = getLandmarkPanel().getTableModel();
+// if ( !tableModel.getIsActive( index ) )
+// return null;
+//
+// int numActive = tableModel.numActive();
+// ndims = tableModel.getNumdims();
+//
+// double[][] mvgPts = new double[ ndims ][ numActive ];
+// double[][] tgtPts = new double[ ndims ][ numActive ];
+//
+// tableModel.copyLandmarks( mvgPts, tgtPts );
+//
+// // need to find the "inverse TPS" - the transform from target space to moving space.
+// xfm = new ThinPlateR2LogRSplineKernelTransform( ndims, tgtPts, mvgPts );
+// }
+// else // a point is added
+// {
+// landmarkModel.initTransformation();
+// ndims = landmarkModel.getNumdims();
+// xfm = getLandmarkPanel().getTableModel().getTransform();
+// }
+// invXfm = new WrappedIterativeInvertibleRealTransform<>( new ThinplateSplineTransform( xfm ));
+// }
+// else
+// {
+// Model model = getModelType();
+// fitModel(model);
+// int nd = landmarkModel.getNumdims();
+// invXfm = new WrappedCoordinateTransform( (InvertibleCoordinateTransform) model, nd ).inverse();
+// }
+//
+// if( options.is2d )
+// {
+// invXfm = new Wrapped2DTransformAs3D( invXfm );
+// }
+//
+// return invXfm;
+// }
+
+ public static class SolveThread extends Thread
+ {
+ private boolean pleaseResolve;
+
+ private BigWarp bw;
+
+ private boolean isMoving;
+
+ private int index;
+
+ private double[] pt;
+
+ public SolveThread( final BigWarp bw )
+ {
+ this.bw = bw;
+ pleaseResolve = false;
+ }
+
+ @Override
+ public void run()
+ {
+ while ( !isInterrupted() )
+ {
+ final boolean b;
+ synchronized ( this )
+ {
+ b = pleaseResolve;
+ pleaseResolve = false;
+ }
+ if ( b )
+ {
+ try
+ {
+ InvertibleRealTransform invXfm = bw.bwTransform.getTransformation( index );
+
+ if ( invXfm == null )
+ return;
+
+ if ( index < 0 )
+ {
+ // reset active warped points
+ bw.landmarkModel.resetWarpedPoints();
+
+ // re-compute all warped points for non-active points
+ bw.landmarkModel.updateAllWarpedPoints( bw.currentTransform );
+
+ // update sources with the new transformation
+ bw.setTransformationAll( invXfm );
+ bw.fitBaselineWarpMagModel();
+ }
+ else
+ {
+ // update the transform and warped point
+ bw.setTransformationMovingSourceOnly( invXfm );
+ }
+
+ // update fixed point - but don't allow undo/redo
+ // and update warped point
+ // both for rendering purposes
+ if ( !isMoving )
+ {
+ bw.getLandmarkPanel().getTableModel().setPoint( index, isMoving, pt, false, bw.currentTransform );
+ }
+
+ /*
+ * repaint both panels so that:
+ * 1) new transform is displayed
+ * 2) points are rendered
+ */
+ bw.getViewerFrameP().getViewerPanel().requestRepaint();
+ bw.getViewerFrameQ().getViewerPanel().requestRepaint();
+
+// bw.notifyTransformListeners();
+ }
+
+ catch ( final RejectedExecutionException e )
+ {
+ // this happens when the rendering threadpool
+ // is killed before the painter thread.
+ }
+ }
+
+ synchronized ( this )
+ {
+ try
+ {
+ if ( !pleaseResolve )
+ wait();
+ }
+ catch ( final InterruptedException e )
+ {
+ break;
+ }
+ }
+ }
+ }
+
+ public void requestResolve( final boolean isMoving, final int index, final double[] newpt )
+ {
+ synchronized ( this )
+ {
+ pleaseResolve = true;
+ this.isMoving = isMoving;
+ this.index = index;
+ if ( newpt != null )
+ this.pt = Arrays.copyOf( newpt, newpt.length );
+
+ notify();
+ }
+ }
+
+ }
+
+ /**
+ * Saves landmarks to a new File in the user's bigwarp folder.
+ */
+ public void autoSaveLandmarks()
+ {
+ final File baseFolder;
+ if ( autoSaver.autoSaveDirectory != null )
+ baseFolder = autoSaver.autoSaveDirectory;
+ else
+ baseFolder = getBigwarpSettingsFolder();
+
+ File proposedLandmarksFile = new File( baseFolder.getAbsolutePath() +
+ File.separator + "bigwarp_landmarks_" +
+ new SimpleDateFormat( "yyyyMMdd-HHmmss" ).format( Calendar.getInstance().getTime() ) +
+ ".csv" );
+
+ try
+ {
+ saveLandmarks( proposedLandmarksFile.getCanonicalPath() );
+ }
+ catch ( IOException e ) { e.printStackTrace(); }
+ }
+
+ /**
+ * Saves landmarks to either the last File the user
+ * saved landmarks to, or a unique location in the user's bigwarp folder.
+ *
+ */
+ public void quickSaveLandmarks()
+ {
+ if(lastLandmarks != null)
+ {
+ try
+ {
+ saveLandmarks( lastLandmarks.getCanonicalPath() );
+ }
+ catch ( IOException e ) { e.printStackTrace(); }
+ }
+ else
+ {
+ autoSaveLandmarks();
+ return;
+ }
+ }
+
+ /**
+ * Returns the default location for bigwarp settings / auto saved files: ~/.bigwarp
+ * @return the folder
+ */
+ public File getBigwarpSettingsFolder()
+ {
+
+ final File hiddenFolder = new File( System.getProperty( "user.home" ) + File.separator + ".bigwarp");
+ boolean exists = hiddenFolder.isDirectory();
+ if( !exists )
+ {
+ exists = hiddenFolder.mkdir();
+ }
+
+ if( exists )
+ return hiddenFolder;
+ else
+ return null;
+ }
+
+ /**
+ * Returns the {@link BigWarpAutoSaver}.
+ *
+ * @return
+ */
+ public BigWarpAutoSaver getAutoSaver()
+ {
+ return autoSaver;
+ }
+
+ public void stopAutosave()
+ {
+ if( autoSaver != null )
+ {
+ autoSaver.stop();
+ autoSaver = null;
+ }
+ }
+
+ protected void saveLandmarks()
+ {
+ final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
+ File proposedLandmarksFile;
+ if(lastLandmarks != null)
+ proposedLandmarksFile = lastLandmarks;
+ else
+ proposedLandmarksFile = new File( "landmarks.csv" );
+
+ fileChooser.setSelectedFile( proposedLandmarksFile );
+ final int returnVal = fileChooser.showSaveDialog( null );
+ if ( returnVal == JFileChooser.APPROVE_OPTION )
+ {
+ proposedLandmarksFile = fileChooser.getSelectedFile();
+ try
+ {
+ saveLandmarks( proposedLandmarksFile.getCanonicalPath() );
+ lastLandmarks = proposedLandmarksFile;
+ } catch ( final IOException e )
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ protected void saveLandmarks( final String filename ) throws IOException
+ {
+ if( filename.endsWith("csv"))
+ landmarkModel.save(new File( filename ));
+ else if( filename.endsWith("json"))
+ TransformWriterJson.write(landmarkModel, bwTransform, new File( filename ));
+ }
+
+ protected void loadLandmarks()
+ {
+ final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
+ File proposedLandmarksFile = new File( "landmarks.csv" );
+
+ fileChooser.setSelectedFile( proposedLandmarksFile );
+ final int returnVal = fileChooser.showOpenDialog( null );
+ if ( returnVal == JFileChooser.APPROVE_OPTION )
+ {
+ proposedLandmarksFile = fileChooser.getSelectedFile();
+ try
+ {
+ loadLandmarks( proposedLandmarksFile.getCanonicalPath() );
+ } catch ( final IOException e )
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public void loadLandmarks( final String filename )
+ {
+ File file = new File( filename );
+ setLastDirectory( file.getParentFile() );
+
+ if( filename.endsWith( "csv" ))
+ {
+ try
+ {
+ landmarkModel.load( file );
+ }
+ catch ( final IOException e1 )
+ {
+ e1.printStackTrace();
+ }
+ }
+ else if( filename.endsWith( "json" ))
+ {
+ TransformWriterJson.read( file, this );
+ }
+
+ boolean didCompute = restimateTransformation();
+
+ // didCompute = false means that there were not enough points
+ // in the loaded points, so we should display the 'raw' moving
+ // image
+ if ( !didCompute )
+ setIsMovingDisplayTransformed( false );
+
+ autoEstimateMask();
+
+ viewerP.requestRepaint();
+ viewerQ.requestRepaint();
+ landmarkFrame.repaint();
+ }
+
+ protected void saveSettings()
+ {
+ final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
+ File proposedSettingsFile = new File( "bigwarp.settings.xml" );
+
+ fileChooser.setSelectedFile( proposedSettingsFile );
+ final int returnVal = fileChooser.showSaveDialog( null );
+ if ( returnVal == JFileChooser.APPROVE_OPTION )
+ {
+ proposedSettingsFile = fileChooser.getSelectedFile();
+ try
+ {
+ final String canonicalPath = proposedSettingsFile.getCanonicalPath();
+ if ( canonicalPath.endsWith( ".xml" ) )
+ {
+ saveSettings( canonicalPath );
+ }
+ else
+ {
+ saveSettingsJson( canonicalPath );
+ }
+ }
+ catch ( final IOException e )
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ protected void saveSettings( final String xmlFilename ) throws IOException
+ {
+ final Element root = new Element( "Settings" );
+
+ Element viewerPNode = new Element( "viewerP" );
+ Element viewerQNode = new Element( "viewerQ" );
+
+ root.addContent( viewerPNode );
+ root.addContent( viewerQNode );
+
+ viewerPNode.addContent( viewerP.stateToXml() );
+ viewerQNode.addContent( viewerQ.stateToXml() );
+
+ root.addContent( setupAssignments.toXml() );
+ root.addContent( bookmarks.toXml() );
+
+ final Element autoSaveNode = new Element( "autosave" );
+ final Element autoSaveLocation = new Element( "location" );
+ if ( autoSaver != null && autoSaver.autoSaveDirectory != null )
+ autoSaveLocation.setText( autoSaver.autoSaveDirectory.getAbsolutePath() );
+ else
+ autoSaveLocation.setText( getBigwarpSettingsFolder().getAbsolutePath() );
+
+ final Element autoSavePeriod = new Element( "period" );
+ final String periodString = autoSaver == null ? "-1" : Long.toString(autoSaver.getPeriod());
+ autoSavePeriod.setText( periodString );
+
+ autoSaveNode.addContent( autoSaveLocation );
+ autoSaveNode.addContent( autoSavePeriod );
+
+ root.addContent( autoSaveNode );
+ root.addContent( transformMask.getRandomAccessible().toXml() );
+
+ final Document doc = new Document( root );
+ final XMLOutputter xout = new XMLOutputter( Format.getPrettyFormat() );
+ xout.output( doc, new FileWriter( xmlFilename ) );
+ }
+
+ protected void saveSettingsJson( final String jsonFilename ) throws IOException
+ {
+ BigwarpSettings settings = getSettings();
+ settings.serialize( jsonFilename );
+ }
+
+ public BigwarpSettings getSettings()
+ {
+ return new BigwarpSettings(
+ this,
+ viewerP,
+ viewerQ,
+ setupAssignments,
+ bookmarks,
+ autoSaver,
+ transformMask.getRandomAccessible(),
+ landmarkModel,
+ bwTransform
+ );
+ }
+
+ protected void loadSettings()
+ {
+ final JFileChooser fileChooser = new JFileChooser( getLastDirectory() );
+ File proposedSettingsFile = new File( "bigwarp.settings.xml" );
+
+ fileChooser.setSelectedFile( proposedSettingsFile );
+ final int returnVal = fileChooser.showOpenDialog( null );
+ if ( returnVal == JFileChooser.APPROVE_OPTION )
+ {
+ proposedSettingsFile = fileChooser.getSelectedFile();
+ try
+ {
+ loadSettings( proposedSettingsFile.getCanonicalPath() );
+ } catch ( final Exception e )
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ protected void loadSettings( final String jsonOrXmlFilename ) throws IOException,
+ JDOMException
+ {
+ if ( jsonOrXmlFilename.endsWith( ".xml" ) )
+ {
+ final SAXBuilder sax = new SAXBuilder();
+ final Document doc = sax.build( jsonOrXmlFilename );
+ final Element root = doc.getRootElement();
+ viewerP.stateFromXml( root.getChild( "viewerP" ) );
+ viewerQ.stateFromXml( root.getChild( "viewerQ" ) );
+ setupAssignments.restoreFromXml( root );
+ bookmarks.restoreFromXml( root );
+ activeSourcesDialogP.update();
+ activeSourcesDialogQ.update();
+
+ // auto-save settings
+ Element autoSaveElem = root.getChild( "autosave" );
+ final String autoSavePath = autoSaveElem.getChild( "location" ).getText();
+ final long autoSavePeriod = Integer.parseInt( autoSaveElem.getChild( "period" ).getText() );
+ BigWarpAutoSaver.setAutosaveOptions( this, autoSavePeriod, autoSavePath );
+
+ final Element maskSettings = root.getChild( "transform-mask" );
+ if ( maskSettings != null )
+ transformMask.getRandomAccessible().fromXml( maskSettings );
+ }
+ else
+ {
+ getSettings().read( new JsonReader( new FileReader( jsonOrXmlFilename ) ) );
+ activeSourcesDialogP.update();
+ activeSourcesDialogQ.update();
+ }
+
+ viewerFrameP.repaint();
+ viewerFrameQ.repaint();
+ }
+}
diff --git a/src/main/java/bigwarp/BigWarpARGBExporter.java b/src/main/java/bigwarp/BigWarpARGBExporter.java
index 168f0bcf..2de86dc0 100644
--- a/src/main/java/bigwarp/BigWarpARGBExporter.java
+++ b/src/main/java/bigwarp/BigWarpARGBExporter.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -29,14 +29,11 @@
import java.util.ArrayList;
import java.util.List;
-import org.janelia.saalfeldlab.n5.ij.N5IJUtils;
-
import net.imglib2.FinalInterval;
import net.imglib2.Interval;
import net.imglib2.RandomAccess;
import net.imglib2.RandomAccessible;
import net.imglib2.RandomAccessibleInterval;
-import net.imglib2.RealRandomAccess;
import net.imglib2.RealRandomAccessible;
import net.imglib2.exception.ImgLibException;
import net.imglib2.img.display.imagej.ImageJFunctions;
@@ -44,16 +41,12 @@
import net.imglib2.img.imageplus.ImagePlusImgFactory;
import net.imglib2.realtransform.AffineGet;
import net.imglib2.realtransform.AffineRandomAccessible;
-import net.imglib2.realtransform.AffineTransform3D;
import net.imglib2.realtransform.RealViews;
-import net.imglib2.type.NativeType;
import net.imglib2.type.numeric.ARGBType;
-import net.imglib2.type.numeric.NumericType;
import net.imglib2.view.MixedTransformView;
import net.imglib2.view.Views;
import bdv.export.ProgressWriter;
import bdv.tools.brightness.ConverterSetup;
-import bdv.viewer.ConverterSetups;
import bdv.viewer.Interpolation;
import bdv.viewer.SourceAndConverter;
@@ -63,19 +56,17 @@ public class BigWarpARGBExporter extends BigWarpExporter
private Interpolation interp;
public BigWarpARGBExporter(
- final List< SourceAndConverter< ARGBType >> sources,
+ BigWarpData bwData,
final List< ConverterSetup > convSetups,
- final int[] movingSourceIndexList,
- final int[] targetSourceIndexList,
final Interpolation interp,
final ProgressWriter progress )
{
- super( sources, convSetups, movingSourceIndexList, targetSourceIndexList, interp, progress );
+ super( bwData, convSetups, interp, progress );
}
/**
* Returns true if moving image sources are all of the same type.
- *
+ *
* @param sources the sources
* @param movingSourceIndexList list of indexes for moving sources
* @return true if all moving sources are of the same type
@@ -84,15 +75,15 @@ public static boolean isTypeListFullyConsistent( ArrayList< SourceAndConverter<
{
for ( int i = 0; i < movingSourceIndexList.length; i++ )
{
- int idx = movingSourceIndexList[ i ];
- Object type = sources.get( idx ).getSpimSource().getType();
+ final int idx = movingSourceIndexList[ i ];
+ final Object type = sources.get( idx ).getSpimSource().getType();
if ( !type.getClass().equals( ARGBType.class ) )
return false;
}
return true;
}
-
+
@Override
public boolean isRGB()
{
@@ -102,38 +93,38 @@ public boolean isRGB()
@Override
public RandomAccessibleInterval< ARGBType > exportRai()
{
- ArrayList< RandomAccessibleInterval< ARGBType > > raiList = new ArrayList< RandomAccessibleInterval< ARGBType > >();
+ final ArrayList< RandomAccessibleInterval< ARGBType > > raiList = new ArrayList< RandomAccessibleInterval< ARGBType > >();
buildTotalRenderTransform();
- int numChannels = movingSourceIndexList.length;
- VoxelDimensions voxdim = new FinalVoxelDimensions( unit,
+ final int numChannels = bwData.numMovingSources();
+ final VoxelDimensions voxdim = new FinalVoxelDimensions( unit,
resolutionTransform.get( 0, 0 ),
resolutionTransform.get( 1, 1 ),
resolutionTransform.get( 2, 2 ));
for ( int i = 0; i < numChannels; i++ )
{
- int movingSourceIndex = movingSourceIndexList[ i ];
- final RealRandomAccessible< ARGBType > raiRaw = ( RealRandomAccessible< ARGBType > )sources.get( movingSourceIndex ).getSpimSource().getInterpolatedSource( 0, 0, interp );
+ final RealRandomAccessible< ARGBType > raiRaw = ( RealRandomAccessible< ARGBType > )bwData.getMovingSource( i ).getSpimSource().getInterpolatedSource( 0, 0, interp );
// apply the transformations
- final AffineRandomAccessible< ARGBType, AffineGet > rai = RealViews.affine(
+ final AffineRandomAccessible< ARGBType, AffineGet > rai = RealViews.affine(
raiRaw, pixelRenderToPhysical.inverse() );
raiList.add( Views.interval( Views.raster( rai ), outputInterval ) );
}
- RandomAccessibleInterval< ARGBType > raiStack = Views.stack( raiList );
+ final RandomAccessibleInterval< ARGBType > raiStack = Views.stack( raiList );
return raiStack;
}
+ @Override
public ImagePlus export()
{
buildTotalRenderTransform();
- int numChannels = movingSourceIndexList.length;
- VoxelDimensions voxdim = new FinalVoxelDimensions( unit,
+ final int numChannels = bwData.numMovingSources();
+ final VoxelDimensions voxdim = new FinalVoxelDimensions( unit,
resolutionTransform.get( 0, 0 ),
resolutionTransform.get( 1, 1 ),
resolutionTransform.get( 2, 2 ));
@@ -160,9 +151,9 @@ else if( nThreads == 1 )
dimensions[ 0 ] = outputInterval.dimension( 0 ); // x
dimensions[ 1 ] = outputInterval.dimension( 1 ); // y
dimensions[ 2 ] = numChannels; // c
- dimensions[ 3 ] = outputInterval.dimension( 2 ); // z
- FinalInterval destIntervalPerm = new FinalInterval( dimensions );
- RandomAccessibleInterval< ARGBType > img = copyToImageStack(
+ dimensions[ 3 ] = outputInterval.dimension( 2 ); // z
+ final FinalInterval destIntervalPerm = new FinalInterval( dimensions );
+ final RandomAccessibleInterval< ARGBType > img = copyToImageStack(
raiStack,
destIntervalPerm, factory, nThreads );
ip = ((ImagePlusImg)img).getImagePlus();
@@ -173,9 +164,9 @@ else if ( outputInterval.numDimensions() == 2 )
dimensions[ 0 ] = outputInterval.dimension( 0 ); // x
dimensions[ 1 ] = outputInterval.dimension( 1 ); // y
dimensions[ 2 ] = numChannels; // c
- dimensions[ 3 ] = 1; // z
- FinalInterval destIntervalPerm = new FinalInterval( dimensions );
- RandomAccessibleInterval< ARGBType > img = copyToImageStack(
+ dimensions[ 3 ] = 1; // z
+ final FinalInterval destIntervalPerm = new FinalInterval( dimensions );
+ final RandomAccessibleInterval< ARGBType > img = copyToImageStack(
Views.addDimension( Views.extendMirrorDouble( raiStack )),
destIntervalPerm, factory, nThreads );
ip = ((ImagePlusImg)img).getImagePlus();
@@ -186,15 +177,15 @@ else if ( outputInterval.numDimensions() == 2 )
ip.getCalibration().pixelHeight = voxdim.dimension( 1 );
ip.getCalibration().pixelDepth = voxdim.dimension( 2 );
ip.getCalibration().setUnit( voxdim.unit() );
-
+
if( offsetTransform != null )
{
ip.getCalibration().xOrigin = offsetTransform.get( 0, 3 );
ip.getCalibration().yOrigin = offsetTransform.get( 1, 3 );
ip.getCalibration().zOrigin = offsetTransform.get( 2, 3 );
}
-
- ip.setTitle( sources.get( movingSourceIndexList[ 0 ]).getSpimSource().getName() + nameSuffix );
+
+ ip.setTitle( bwData.getMovingSource( 0 ).getSpimSource().getName() + nameSuffix );
return ip;
}
@@ -203,7 +194,7 @@ public static ImagePlus copyToImageStack( final RandomAccessible< ARGBType > rai
{
// A bit of hacking to make slices the 4th dimension and channels the 3rd
// since that's how ImagePlusImgFactory does it
- MixedTransformView< ARGBType > raip = Views.permute( rai, 2, 3 );
+ final MixedTransformView< ARGBType > raip = Views.permute( rai, 2, 3 );
final long[] dimensions = new long[ itvl.numDimensions() ];
for( int d = 0; d < itvl.numDimensions(); d++ )
@@ -220,7 +211,7 @@ else if( d == 3 )
final ImagePlusImgFactory< ARGBType > factory = new ImagePlusImgFactory< ARGBType >( new ARGBType() );
final ImagePlusImg< ARGBType, ? > target = factory.create( dimensions );
- long[] dims = new long[ target.numDimensions() ];
+ final long[] dims = new long[ target.numDimensions() ];
target.dimensions( dims );
double k = 0;
diff --git a/src/main/java/bigwarp/BigWarpActions.java b/src/main/java/bigwarp/BigWarpActions.java
index 372a25e6..54c559b2 100755
--- a/src/main/java/bigwarp/BigWarpActions.java
+++ b/src/main/java/bigwarp/BigWarpActions.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -31,85 +31,540 @@
import javax.swing.KeyStroke;
import javax.swing.table.TableCellEditor;
+import org.scijava.plugin.Plugin;
import org.scijava.ui.behaviour.KeyStrokeAdder;
+import org.scijava.ui.behaviour.io.gui.CommandDescriptionProvider;
+import org.scijava.ui.behaviour.io.gui.CommandDescriptions;
import org.scijava.ui.behaviour.util.AbstractNamedAction;
+import org.scijava.ui.behaviour.util.Actions;
import org.scijava.ui.behaviour.util.InputActionBindings;
import bdv.gui.BigWarpViewerFrame;
import bdv.tools.ToggleDialogAction;
+import bdv.util.Prefs;
+import bdv.viewer.LandmarkPointMenu;
import bdv.viewer.SourceAndConverter;
-import bigwarp.BigWarp.BigWarpData;
+import bdv.viewer.AbstractViewerPanel.AlignPlane;
import bigwarp.landmarks.LandmarkGridGenerator;
import bigwarp.source.GridSource;
import bigwarp.util.BigWarpUtils;
import mpicbg.models.AbstractModel;
import net.imglib2.realtransform.AffineTransform3D;
-public class BigWarpActions
+public class BigWarpActions extends Actions
{
+ public static final CommandDescriptionProvider.Scope BIGWARP = new CommandDescriptionProvider.Scope( "bigwarp" );
+ public static final String BIGWARP_CTXT = "bigwarp";
+ public static final String NOT_MAPPED = "not mapped";
+
public static final String LANDMARK_MODE_ON = "landmark mode on";
public static final String LANDMARK_MODE_OFF = "landmark mode off";
- public static final String TOGGLE_LANDMARK_MODE = "landmark mode toggle";
+ public static final String TRANSFORM_TYPE = "transform type";
+
+ // General options
+ public static final String CLOSE_DIALOG = "close dialog window";
+ public static final String[] CLOSE_DIALOG_KEYS = new String[] { NOT_MAPPED };
+
+ public static final String LOAD_PROJECT = "load project";
+ public static final String[] LOAD_PROJECT_KEYS = new String[]{ "ctrl shift O" };
+
+ public static final String SAVE_PROJECT = "save project";
+ public static final String[] SAVE_PROJECT_KEYS = new String[]{ "ctrl shift S" };
+
+ public static final String EXPAND_CARDS = "expand and focus cards panel";
+ public static final String[] EXPAND_CARDS_KEYS = new String[] { "P" };
+
+ public static final String COLLAPSE_CARDS = "collapse cards panel";
+ public static final String[] COLLAPSE_CARDS_KEYS = new String[] { "shift P", "shift ESCAPE" };
+
+ public static final String PREFERENCES_DIALOG = "Preferences";
+ public static final String[] PREFERENCES_DIALOG_KEYS= new String[] { "meta COMMA", "ctrl COMMA" };
+
+ // Display options
+ public static final String TOGGLE_LANDMARK_MODE = "landmark mode toggle";
+ public static final String[] TOGGLE_LANDMARK_MODE_KEYS = new String[]{ "SPACE" };
+
+ public static final String TOGGLE_POINTS_VISIBLE = "toggle points visible";
+ public static final String[] TOGGLE_POINTS_VISIBLE_KEYS = new String[]{ "V" };
- public static final String TOGGLE_POINTS_VISIBLE = "toggle points visible";
public static final String TOGGLE_POINT_NAMES_VISIBLE = "toggle point names visible";
+ public static final String[] TOGGLE_POINT_NAMES_VISIBLE_KEYS = new String[]{ "N" };
+
public static final String TOGGLE_MOVING_IMAGE_DISPLAY = "toggle moving image display";
+ public static final String[] TOGGLE_MOVING_IMAGE_DISPLAY_KEYS = new String[]{ "T" };
+
public static final String TOGGLE_BOX_AND_TEXT_OVERLAY_VISIBLE = "toggle box and text overlay visible";
+ public static final String[] TOGGLE_BOX_AND_TEXT_OVERLAY_VISIBLE_KEYS = new String[]{ "F8" };
+
public static final String ESTIMATE_WARP = "estimate warp";
+ public static final String[] ESTIMATE_WARP_KEYS = new String[] { "C" };
+
public static final String PRINT_TRANSFORM = "print transform";
+ public static final String[] PRINT_TRANSFORM_KEYS = new String[]{ "control shift T" };
+
public static final String TOGGLE_ESTIMATE_WARP_ONDRAG = "toggle estimate warp on drag";
+ public static final String[] TOGGLE_ESTIMATE_WARP_ONDRAG_KEYS = new String[]{ NOT_MAPPED };
+
+ public static final String SAVE_SETTINGS = "save settings";
+ public static final String[] SAVE_SETTINGS_KEYS = new String[]{ NOT_MAPPED };
+
+ public static final String LOAD_SETTINGS = "load settings";
+ public static final String[] LOAD_SETTINGS_KEYS = new String[]{ NOT_MAPPED };
+
+ public static final String BRIGHTNESS_SETTINGS = "brightness settings";
+ public static final String[] BRIGHTNESS_SETTINGS_KEYS = new String[]{ "S" };
+
+ public static final String VISIBILITY_AND_GROUPING = "visibility and grouping %s";
+ public static final String VISIBILITY_AND_GROUPING_MVG = String.format( VISIBILITY_AND_GROUPING, "moving" );
+ public static final String[] VISIBILITY_AND_GROUPING_MVG_KEYS = new String[]{ "F3" };
+
+ public static final String VISIBILITY_AND_GROUPING_TGT = String.format( VISIBILITY_AND_GROUPING, "target" );
+ public static final String[] VISIBILITY_AND_GROUPING_TGT_KEYS = new String[]{ "F4" };
+
+ public static final String SHOW_HELP = "help";
+ public static final String[] SHOW_HELP_KEYS = new String[] { "F1" };
+
+ public static final String SHOW_SOURCE_INFO = "show source info";
+ // Warp visualization options
public static final String SHOW_WARPTYPE_DIALOG = "show warp vis dialog" ;
+ public static final String[] SHOW_WARPTYPE_DIALOG_KEYS = new String[]{ "U" };
+
public static final String SET_WARPTYPE_VIS = "set warp vis type %s" ;
+
public static final String SET_WARPTYPE_VIS_P = "p " + SET_WARPTYPE_VIS;
+
public static final String SET_WARPTYPE_VIS_Q = "q " + SET_WARPTYPE_VIS;
public static final String WARPMAG_BASE = "set warpmag base %s";
public static final String WARPVISGRID = "set warp vis grid %s";
public static final String WARPVISDIALOG = "warp vis dialog";
- public static final String RESET_VIEWER = "reset active viewer";
+ // Navigation options
+ public static final String RESET_VIEWER = "reset active viewer";
+ public static final String[] RESET_VIEWER_KEYS = new String[]{"R"};
+
+
public static final String ALIGN_VIEW_TRANSFORMS = "align view transforms %s";
- public static final String BRIGHTNESS_SETTINGS = "brightness settings";
- public static final String VISIBILITY_AND_GROUPING = "visibility and grouping %s";
- public static final String SHOW_HELP = "help";
- public static final String SHOW_SOURCE_INFO = "show source info";
+ public static final String ALIGN_OTHER_TO_ACTIVE = String.format( ALIGN_VIEW_TRANSFORMS, AlignViewerPanelAction.TYPE.OTHER_TO_ACTIVE );
+ public static final String[] ALIGN_OTHER_TO_ACTIVE_KEYS = new String[] { "Q" };
- public static final String CROP = "crop";
- public static final String SAVE_SETTINGS = "save settings";
- public static final String LOAD_SETTINGS = "load settings";
+ public static final String ALIGN_ACTIVE_TO_OTHER = String.format( ALIGN_VIEW_TRANSFORMS, AlignViewerPanelAction.TYPE.ACTIVE_TO_OTHER );
+ public static final String[] ALIGN_ACTIVE_TO_OTHER_KEYS = new String[] { "W" };
+
+ public static final String JUMP_TO_SELECTED_POINT = "center on selected landmark";
+ public static final String[] JUMP_TO_SELECTED_POINT_KEYS = new String[]{ "D" };
+
+ public static final String JUMP_TO_NEXT_POINT = "center on next landmark";
+ public static final String[] JUMP_TO_NEXT_POINT_KEYS = new String[]{ "ctrl D"};
+
+ public static final String JUMP_TO_PREV_POINT = "center on prev landmark";
+ public static final String[] JUMP_TO_PREV_POINT_KEYS = new String[]{ "ctrl shift D"};
+
+ public static final String JUMP_TO_NEAREST_POINT = "center on nearest landmark";
+ public static final String[] JUMP_TO_NEAREST_POINT_KEYS = new String[]{ "E" };
+
+ // landmark options
public static final String LOAD_LANDMARKS = "load landmarks";
+ public static final String[] LOAD_LANDMARKS_KEYS = new String[]{ "control O" };
+
public static final String SAVE_LANDMARKS = "save landmarks";
+ public static final String[] SAVE_LANDMARKS_KEYS = new String[]{ "control S" };
+
public static final String QUICK_SAVE_LANDMARKS = "quick save landmarks";
+ public static final String[] QUICK_SAVE_LANDMARKS_KEYS = new String[]{ "control Q" };
+
+ public static final String SET_BOOKMARK = "set bookmark";
+ public static final String[] SET_BOOKMARK_KEYS = new String[]{ "shift B" };
+
+ public static final String GO_TO_BOOKMARK = "go to bookmark";
+ public static final String[] GO_TO_BOOKMARK_KEYS = new String[]{ "B" };
+
+ public static final String GO_TO_BOOKMARK_ROTATION = "go to bookmark rotation";
+ public static final String[] GO_TO_BOOKMARK_ROTATION_KEYS = new String[]{ "control shift B" };
+
+ public static final String UNDO = "undo";
+ public static final String[] UNDO_KEYS = new String[]{ "control Z" };
+
+ public static final String REDO = "redo";
+ public static final String[] REDO_KEYS = new String[]{ "control shift Z", "control Y" };
+
+ public static final String SELECT_TABLE_ROWS = "select table row %d";
+
+ public static final String LANDMARK_SELECT_ALL = "select all landmarks";
+ public static final String[] LANDMARK_SELECT_ALL_KEYS = new String[]{ "ctrl A"};
+
+ public static final String LANDMARK_DESELECT_ALL = "deselect all landmarks";
+ public static final String[] LANDMARK_DESELECT_ALL_KEYS = new String[]{ "ESCAPE", "ctrl shift A" };
+
+ public static final String LANDMARK_SELECT_ABOVE = "select landmark above";
+ public static final String[] LANDMARK_SELECT_ABOVE_KEYS = new String[]{ "ctrl UP"};
+
+ public static final String LANDMARK_SELECT_ALL_ABOVE = "select all landmarks above";
+ public static final String[] LANDMARK_SELECT_ALL_ABOVE_KEYS = new String[]{ "ctrl shift UP"};
+
+ public static final String LANDMARK_SELECT_BELOW = "select landmark below";
+ public static final String[] LANDMARK_SELECT_BELOW_KEYS = new String[]{ "ctrl DOWN"};
+
+ public static final String LANDMARK_SELECT_ALL_BELOW = "select all landmarks below";
+ public static final String[] LANDMARK_SELECT_ALL_BELOW_KEYS = new String[]{ "ctrl shift DOWN"};
+
+ public static final String LANDMARK_DELETE_SELECTED = "delete selected landmarks";
+ public static final String[] LANDMARK_DELETE_SELECTED_KEYS = new String[]{ "DELETE" };
+
+ public static final String LANDMARK_DEACTIVATE_SELECTED = "deactivate selected landmarks";
+ public static final String[] LANDMARK_DEACTIVATE_SELECTED_KEYS = new String[]{ "BACK_SPACE" };
+
+ public static final String[] LANDMARK_ACTIVATE_SELECTED_KEYS = new String[]{ "ctrl BACK_SPACE" };
+ public static final String LANDMARK_ACTIVATE_SELECTED = "activate selected landmarks";
public static final String LANDMARK_GRID_DIALOG = "landmark grid dialog";
+ public static final String MASK_IMPORT = "import mask";
+ public static final String MASK_REMOVE = "remove mask";
+ public static final String MASK_SIZE_EDIT = "mask edit";
+ public static final String MASK_VIS_TOGGLE = "mask vis toggle";
+
+ // export options
public static final String SAVE_WARPED = "save warped";
public static final String SAVE_WARPED_XML = "save warped xml";
+ public static final String[] SAVE_WARPED_XML_KEYS = new String[] { "ctrl E" };
public static final String EXPORT_IP = "export imageplus";
- public static final String EXPORT_WARP = "export warp field";
- public static final String EXPORT_AFFINE = "export affine";
+ public static final String[] EXPORT_IP_KEYS = new String[] { "ctrl shift W" };
- public static final String WARP_TO_SELECTED_POINT = "warp to selected landmark";
- public static final String WARP_TO_NEXT_POINT = "warp to next landmark %s";
- public static final String WARP_TO_NEAREST_POINT = "warp to nearest landmark";
+ public static final String EXPORT_WARP = "export warp field";
+ public static final String[] EXPORT_WARP_KEYS = new String[] { "ctrl W" };
- public static final String SET_BOOKMARK = "set bookmark";
- public static final String GO_TO_BOOKMARK = "go to bookmark";
- public static final String GO_TO_BOOKMARK_ROTATION = "go to bookmark rotation";
+ public static final String EXPORT_AFFINE = "export affine";
+ public static final String[] EXPORT_AFFINE_KEYS = new String[] { "ctrl A" };
- public static final String UNDO = "undo";
- public static final String REDO = "redo";
+ public static final String CLEAR_MOVING = "table clear moving";
+ public static final String[] CLEAR_MOVING_KEYS = new String[] { "BACK_SPACE" };
- public static final String SELECT_TABLE_ROWS = "select table row %d";
+ public static final String CLEAR_FIXED = "table clear fixed";
+ public static final String[] CLEAR_FIXED_KEYS = new String[] { "ctrl BACK_SPACE" };
+
+ public static final String CLEAR_SELECTED_MOVING = "table clear selected moving";
+ public static final String[] CLEAR_SELECTED_MOVING_KEYS = new String[] { "ctrl BACK_SPACE" };
+
+ public static final String CLEAR_SELECTED_FIXED = "table clear selected fixed";
+ public static final String[] CLEAR_SELECTED_FIXED_KEYS = new String[] { "ctrl BACK_SPACE" };
+
+ public static final String DELETE = "table delete";
+ public static final String[] DELETE_KEYS = new String[] { NOT_MAPPED };
+
+ public static final String DELETE_SELECTED = "table delete selected ";
+ public static final String[] DELETE_SELECTED_KEYS = new String[] { "DELETE" };
+
+ public static final String ACTIVATE_SELECTED = "table activate selected";
+ public static final String[] ACTIVATE_SELECTED_KEYS = new String[] { NOT_MAPPED };
+
+ public static final String DEACTIVATE_SELECTED = "table deactivate selected ";
+ public static final String[] DEACTIVATE_SELECTED_KEYS = new String[]{ NOT_MAPPED };
public static final String DEBUG = "debug";
public static final String GARBAGE_COLLECTION = "garbage collection";
+ public static final String XYPLANE = "xyPlane";
+ public static final String[] XYPLANE_KEYS = new String[] { "shift Z" };
+
+ public static final String YZPLANE = "yzPlane";
+ public static final String[] YZPLANE_KEYS = new String[] { "shift X" };
+
+ public static final String XZPLANE = "xzPlane";
+ public static final String[] XZPLANE_KEYS = new String[] { "shift Y", "shift A" };
+
+ public BigWarpActions( final KeyStrokeAdder.Factory keyConfig, String name )
+ {
+ this( keyConfig, "bigwarp", name );
+ }
+
+ public BigWarpActions( final KeyStrokeAdder.Factory keyConfig, String context, String name )
+ {
+ super( keyConfig, context, name );
+ }
+
+ /*
+ * Command descriptions for all provided commands
+ */
+ @Plugin( type = CommandDescriptionProvider.class )
+ public static class Descriptions extends CommandDescriptionProvider
+ {
+ public Descriptions()
+ {
+ super( BIGWARP, "bigwarp", "bw-table", "navigation" );
+ }
+
+ @Override
+ public void getCommandDescriptions( final CommandDescriptions descriptions )
+ {
+ descriptions.add( CLOSE_DIALOG, CLOSE_DIALOG_KEYS, "Close bigwarp." );
+
+ descriptions.add( SAVE_PROJECT, SAVE_PROJECT_KEYS, "Save a bigwarp project." );
+ descriptions.add( LOAD_PROJECT, LOAD_PROJECT_KEYS, "Load a bigwarp project." );
+
+ descriptions.add( TOGGLE_LANDMARK_MODE, TOGGLE_LANDMARK_MODE_KEYS, "Toggle landmark mode." );
+ descriptions.add( TOGGLE_MOVING_IMAGE_DISPLAY, TOGGLE_MOVING_IMAGE_DISPLAY_KEYS, "Toggle landmark mode." );
+
+ descriptions.add( SHOW_HELP, SHOW_HELP_KEYS, "Show the Help dialog." );
+ descriptions.add( SHOW_WARPTYPE_DIALOG, SHOW_WARPTYPE_DIALOG_KEYS, "Show the BigWarp options dialog." );
+ descriptions.add( PREFERENCES_DIALOG, PREFERENCES_DIALOG_KEYS, "Show the appearance and keymap dialog." );
+
+ descriptions.add( BRIGHTNESS_SETTINGS, BRIGHTNESS_SETTINGS_KEYS, "Show the Brightness & Colors dialog." );
+ descriptions.add( VISIBILITY_AND_GROUPING_MVG, VISIBILITY_AND_GROUPING_MVG_KEYS, "Show the Visibility&Grouping dialog for the moving frame." );
+ descriptions.add( VISIBILITY_AND_GROUPING_TGT, VISIBILITY_AND_GROUPING_TGT_KEYS, "Show the Visibility&Grouping dialog for the fixed frame." );
+ descriptions.add( SAVE_SETTINGS, SAVE_SETTINGS_KEYS, "Save the BigDataViewer settings to a settings.xml file." );
+ descriptions.add( LOAD_SETTINGS, LOAD_SETTINGS_KEYS, "Load the BigDataViewer settings from a settings.xml file." );
+
+ descriptions.add( SET_BOOKMARK, SET_BOOKMARK_KEYS, "Set a labeled bookmark at the current location." );
+ descriptions.add( GO_TO_BOOKMARK, GO_TO_BOOKMARK_KEYS, "Retrieve a labeled bookmark location." );
+ descriptions.add( GO_TO_BOOKMARK_ROTATION, GO_TO_BOOKMARK_ROTATION_KEYS, "Retrieve a labeled bookmark, set only the orientation." );
+
+ descriptions.add( RESET_VIEWER, RESET_VIEWER_KEYS, "Resets the view to the view on startup." );
+ descriptions.add( ALIGN_OTHER_TO_ACTIVE, ALIGN_OTHER_TO_ACTIVE_KEYS, "Sets the view of the non-active viewer to match the active viewer." );
+ descriptions.add( ALIGN_ACTIVE_TO_OTHER, ALIGN_ACTIVE_TO_OTHER_KEYS, "Sets the view of the active viewer to match the non-active viewer." );
+ descriptions.add( JUMP_TO_SELECTED_POINT, JUMP_TO_SELECTED_POINT_KEYS, "Center the viewer on the selected landmark." );
+ descriptions.add( JUMP_TO_NEAREST_POINT, JUMP_TO_NEAREST_POINT_KEYS, "Center the viewer on the nearest landmark." );
+ descriptions.add( JUMP_TO_NEXT_POINT, JUMP_TO_NEXT_POINT_KEYS, "Center the viewer on the next landmark." );
+ descriptions.add( JUMP_TO_PREV_POINT, JUMP_TO_PREV_POINT_KEYS, "Center the viewer on the previous landmark." );
+
+ // cards
+ descriptions.add( EXPAND_CARDS, EXPAND_CARDS_KEYS, "Expand and focus the BigDataViewer card panel" );
+ descriptions.add( COLLAPSE_CARDS, COLLAPSE_CARDS_KEYS, "Collapse the BigDataViewer card panel" );
+
+ // export
+ descriptions.add( EXPORT_IP, EXPORT_IP_KEYS, "Export moving image to ImageJ." );
+ descriptions.add( SAVE_WARPED_XML, SAVE_WARPED_XML_KEYS, "Export moving image to BigDataViewer xml/h5." );
+ descriptions.add( EXPORT_WARP, EXPORT_WARP_KEYS, "Show the dialog to export the displacement field." );
+ descriptions.add( EXPORT_AFFINE, EXPORT_AFFINE_KEYS, "Print the affine transformation." );
+ descriptions.add( PRINT_TRANSFORM,PRINT_TRANSFORM_KEYS, "Prints the current transformation." );
+
+ // landmarks
+ descriptions.add( LOAD_LANDMARKS, LOAD_LANDMARKS_KEYS, "Load landmark from a file." );
+ descriptions.add( SAVE_LANDMARKS, SAVE_LANDMARKS_KEYS, "Save landmark from a file." );
+ descriptions.add( QUICK_SAVE_LANDMARKS, QUICK_SAVE_LANDMARKS_KEYS, "Quick save landmarks.");
+ descriptions.add( UNDO, UNDO_KEYS, "Undo the last landmark change." );
+ descriptions.add( REDO, REDO_KEYS, "Redo the last landmark change." );
+
+ descriptions.add( TOGGLE_POINTS_VISIBLE, TOGGLE_POINTS_VISIBLE_KEYS, "Toggle visibility of landmarks." );
+ descriptions.add( TOGGLE_POINT_NAMES_VISIBLE, TOGGLE_POINT_NAMES_VISIBLE_KEYS , "Toggle visibility of landmark names." );
+
+ descriptions.add( TOGGLE_BOX_AND_TEXT_OVERLAY_VISIBLE, TOGGLE_BOX_AND_TEXT_OVERLAY_VISIBLE_KEYS, "Toggle visibility of bounding box and source information." );
+ descriptions.add( TOGGLE_POINTS_VISIBLE, TOGGLE_POINTS_VISIBLE_KEYS, "Toggle visibility of landmark points." );
+ descriptions.add( TOGGLE_POINT_NAMES_VISIBLE, TOGGLE_POINT_NAMES_VISIBLE_KEYS, "Toggle visibility of landmark point names." );
+
+ descriptions.add( LANDMARK_ACTIVATE_SELECTED, LANDMARK_ACTIVATE_SELECTED_KEYS, "Activate selected landmarks." );
+ descriptions.add( LANDMARK_DEACTIVATE_SELECTED, LANDMARK_DEACTIVATE_SELECTED_KEYS, "Deactivate selected landmarks." );
+
+ // alignment
+ descriptions.add( XYPLANE, XYPLANE_KEYS, "xy plane" );
+ descriptions.add( XZPLANE, XZPLANE_KEYS, "xz plane" );
+ descriptions.add( YZPLANE, YZPLANE_KEYS, "yz plane" );
+ }
+ }
+
+ @Plugin( type = CommandDescriptionProvider.class )
+ public static class TableDescriptions extends CommandDescriptionProvider
+ {
+ public TableDescriptions()
+ {
+ super( BIGWARP, "bw-table", "bigwarp", "navigation" );
+ }
+
+ @Override
+ public void getCommandDescriptions( final CommandDescriptions descriptions )
+ {
+ descriptions.add( SAVE_PROJECT, SAVE_PROJECT_KEYS, "Save a bigwarp project." );
+ descriptions.add( LOAD_PROJECT, LOAD_PROJECT_KEYS, "Load a bigwarp project." );
+
+ descriptions.add( CLEAR_MOVING, CLEAR_MOVING_KEYS, "Clears moving landmark under the mouse cursor." );
+ descriptions.add( CLEAR_FIXED, CLEAR_FIXED_KEYS, "Clears fixed landmark under the mouse cursor." );
+ descriptions.add( CLEAR_SELECTED_MOVING, CLEAR_SELECTED_MOVING_KEYS, "Clears moving landmark for currently selected row." );
+ descriptions.add( CLEAR_SELECTED_FIXED, CLEAR_SELECTED_FIXED_KEYS, "Clears fixed landmark for currently selected row." );
+
+ descriptions.add( DELETE, DELETE_KEYS, "Delete table row under the mouse cursor" );
+ descriptions.add( DELETE_SELECTED, DELETE_SELECTED_KEYS, "Delete all selected rows in the table" );
+
+ descriptions.add( ACTIVATE_SELECTED, ACTIVATE_SELECTED_KEYS, "Activate all selected rows in the table" );
+ descriptions.add( DEACTIVATE_SELECTED, DEACTIVATE_SELECTED_KEYS, "Deactivate all selected rows in the table" );
+
+ descriptions.add( LOAD_LANDMARKS, LOAD_LANDMARKS_KEYS, "Load landmark from a file." );
+ descriptions.add( SAVE_LANDMARKS, SAVE_LANDMARKS_KEYS, "Save landmark from a file." );
+ descriptions.add( QUICK_SAVE_LANDMARKS, QUICK_SAVE_LANDMARKS_KEYS, "Quick save landmarks.");
+
+ descriptions.add( LANDMARK_SELECT_ALL, LANDMARK_SELECT_ALL_KEYS, "Select all landmarks." );
+ descriptions.add( LANDMARK_DESELECT_ALL, LANDMARK_DESELECT_ALL_KEYS, "Deselect all landmarks." );
+
+ descriptions.add( LANDMARK_DELETE_SELECTED, LANDMARK_DELETE_SELECTED_KEYS, "Delete selected landmarks." );
+ descriptions.add( LANDMARK_ACTIVATE_SELECTED, LANDMARK_ACTIVATE_SELECTED_KEYS, "Activate selected landmarks." );
+ descriptions.add( LANDMARK_DEACTIVATE_SELECTED, LANDMARK_DEACTIVATE_SELECTED_KEYS, "Deactivate selected landmarks." );
+
+ descriptions.add( LANDMARK_SELECT_ABOVE, LANDMARK_SELECT_ABOVE_KEYS, "Add the row above the curent selection to the selection" );
+ descriptions.add( LANDMARK_SELECT_ALL_ABOVE, LANDMARK_SELECT_ALL_ABOVE_KEYS, "Add the all rows above the curent selection to the selection" );
+ descriptions.add( LANDMARK_SELECT_BELOW, LANDMARK_SELECT_BELOW_KEYS, "Add the row below the curent selection to the selection" );
+ descriptions.add( LANDMARK_SELECT_ALL_BELOW, LANDMARK_SELECT_ALL_BELOW_KEYS, "Add the all rows below the curent selection to the selection" );
+
+ descriptions.add( UNDO, UNDO_KEYS, "Undo the last landmark change." );
+ descriptions.add( REDO, REDO_KEYS, "Redo the last landmark change." );
+
+ descriptions.add( TOGGLE_POINTS_VISIBLE, TOGGLE_POINTS_VISIBLE_KEYS, "Toggle visibility of landmark points." );
+ descriptions.add( TOGGLE_POINT_NAMES_VISIBLE, TOGGLE_POINT_NAMES_VISIBLE_KEYS, "Toggle visibility of landmark point names." );
+ }
+ }
+
+ public static void installViewerActions(
+ Actions actions,
+ final BigWarpViewerFrame bwFrame,
+ final BigWarp< ? > bw )
+ {
+
+ final InputActionBindings inputActionBindings = bwFrame.getKeybindings();
+ actions.install( inputActionBindings, "bw" );
+
+ actions.runnableAction( bw::saveProject, SAVE_PROJECT, SAVE_PROJECT_KEYS );
+ actions.runnableAction( bw::loadProject, LOAD_PROJECT, LOAD_PROJECT_KEYS );
+
+ actions.runnableAction( () -> { bw.getBwTransform().transformToString(); }, PRINT_TRANSFORM, PRINT_TRANSFORM_KEYS);
+ actions.runnableAction( bw::toggleInLandmarkMode, TOGGLE_LANDMARK_MODE, TOGGLE_LANDMARK_MODE_KEYS);
+ actions.runnableAction( bw::toggleMovingImageDisplay, TOGGLE_MOVING_IMAGE_DISPLAY, TOGGLE_MOVING_IMAGE_DISPLAY_KEYS );
+
+ actions.namedAction( new TogglePointsVisibleAction( TOGGLE_POINTS_VISIBLE, bw ), TOGGLE_POINTS_VISIBLE_KEYS);
+ actions.namedAction( new TogglePointNameVisibleAction( TOGGLE_POINT_NAMES_VISIBLE, bw ), TOGGLE_POINT_NAMES_VISIBLE_KEYS);
+
+ // navigation
+ actions.runnableAction( bw::resetView, RESET_VIEWER, RESET_VIEWER_KEYS);
+ actions.runnableAction( bw::matchOtherViewerPanelToActive, ALIGN_OTHER_TO_ACTIVE, ALIGN_OTHER_TO_ACTIVE_KEYS );
+ actions.runnableAction( bw::matchActiveViewerPanelToOther, ALIGN_ACTIVE_TO_OTHER, ALIGN_ACTIVE_TO_OTHER_KEYS );
+ actions.runnableAction( bw::jumpToSelectedLandmark, JUMP_TO_SELECTED_POINT, JUMP_TO_SELECTED_POINT_KEYS );
+ actions.runnableAction( bw::jumpToNearestLandmark, JUMP_TO_NEAREST_POINT, JUMP_TO_NEAREST_POINT_KEYS );
+ actions.runnableAction( bw::jumpToNextLandmark, JUMP_TO_NEXT_POINT, JUMP_TO_NEXT_POINT_KEYS );
+ actions.runnableAction( bw::jumpToPrevLandmark, JUMP_TO_PREV_POINT, JUMP_TO_PREV_POINT_KEYS );
+
+ // bookmarks
+ actions.runnableAction( bw::goToBookmark, GO_TO_BOOKMARK, GO_TO_BOOKMARK_KEYS );
+ actions.runnableAction( bw::goToBookmarkRotation, GO_TO_BOOKMARK_ROTATION, GO_TO_BOOKMARK_ROTATION_KEYS );
+ actions.runnableAction( bw::setBookmark, SET_BOOKMARK, SET_BOOKMARK_KEYS );
+
+ // cards
+ actions.runnableAction( bwFrame::expandAndFocusCardPanel, EXPAND_CARDS, EXPAND_CARDS_KEYS );
+ actions.runnableAction( bwFrame::collapseCardPanel, COLLAPSE_CARDS, COLLAPSE_CARDS_KEYS );
+
+ // export
+ actions.runnableAction( bw::exportWarpField, EXPORT_WARP, EXPORT_WARP_KEYS );
+ actions.runnableAction( () -> { bw.getBwTransform().printAffine(); }, EXPORT_AFFINE, EXPORT_AFFINE_KEYS );
+
+ // dialogs
+ actions.namedAction( new ToggleDialogAction( SHOW_HELP, bw.helpDialog ), SHOW_HELP_KEYS );
+ actions.namedAction( new ToggleDialogAction( VISIBILITY_AND_GROUPING_MVG, bw.activeSourcesDialogP ), VISIBILITY_AND_GROUPING_MVG_KEYS );
+ actions.namedAction( new ToggleDialogAction( VISIBILITY_AND_GROUPING_TGT, bw.activeSourcesDialogQ ), VISIBILITY_AND_GROUPING_TGT_KEYS );
+ actions.namedAction( new ToggleDialogAction( SHOW_WARPTYPE_DIALOG, bw.warpVisDialog ), SHOW_WARPTYPE_DIALOG_KEYS );
+ actions.namedAction( new ToggleDialogAction( PREFERENCES_DIALOG, bw.preferencesDialog ), PREFERENCES_DIALOG_KEYS );
+
+ // landmarks unbound
+ actions.runnableAction( () -> { bw.getLandmarkPanel().getJTable().selectAll(); }, LANDMARK_SELECT_ALL, NOT_MAPPED );
+ actions.runnableAction( () -> { bw.getLandmarkPanel().getJTable().clearSelection(); }, LANDMARK_DESELECT_ALL, NOT_MAPPED );
+
+ actions.namedAction( bw.landmarkPopupMenu.deleteSelectedHandler, LANDMARK_DELETE_SELECTED_KEYS );
+
+ actions.namedAction( bw.landmarkPopupMenu.activateSelectedHandler, LANDMARK_ACTIVATE_SELECTED_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.deactivateSelectedHandler, LANDMARK_DEACTIVATE_SELECTED_KEYS );
+
+ actions.namedAction( bw.landmarkPopupMenu.addAboveHandler, LANDMARK_SELECT_ABOVE_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.addAllAboveHandler, LANDMARK_SELECT_ALL_ABOVE_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.addBelowHandler, LANDMARK_SELECT_BELOW_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.addAllBelowHandler, LANDMARK_SELECT_ALL_BELOW_KEYS );
+
+ // landmarks bound
+ actions.runnableAction( bw::loadLandmarks, LOAD_LANDMARKS, LOAD_LANDMARKS_KEYS );
+ actions.runnableAction( bw::saveLandmarks, SAVE_LANDMARKS, SAVE_LANDMARKS_KEYS );
+ actions.runnableAction( bw::quickSaveLandmarks, QUICK_SAVE_LANDMARKS, QUICK_SAVE_LANDMARKS_KEYS );
+
+ actions.namedAction( new UndoRedoAction( UNDO, bw ), UNDO_KEYS );
+ actions.namedAction( new UndoRedoAction( REDO, bw ), REDO_KEYS );
+
+ actions.namedAction( new ToggleBoxAndTexOverlayVisibility( TOGGLE_BOX_AND_TEXT_OVERLAY_VISIBLE, bw ), TOGGLE_BOX_AND_TEXT_OVERLAY_VISIBLE_KEYS);
+ actions.namedAction( new TogglePointsVisibleAction( TOGGLE_POINTS_VISIBLE, bw ), TOGGLE_POINTS_VISIBLE_KEYS );
+ actions.namedAction( new TogglePointNameVisibleAction( TOGGLE_POINT_NAMES_VISIBLE, bw ), TOGGLE_POINT_NAMES_VISIBLE_KEYS);
+
+ actions.runnableAction( () -> bw.alignActive( AlignPlane.XY ), XYPLANE, XYPLANE_KEYS );
+ actions.runnableAction( () -> bw.alignActive( AlignPlane.XZ ), XZPLANE, XZPLANE_KEYS );
+ actions.runnableAction( () -> bw.alignActive( AlignPlane.ZY ), YZPLANE, YZPLANE_KEYS );
+ }
+
+ public static void installTableActions(
+ Actions actions,
+ final InputActionBindings inputActionBindings,
+ final BigWarp< ? > bw )
+ {
+ actions.install( inputActionBindings, "bw-table" );
+
+ actions.runnableAction( bw::saveProject, SAVE_PROJECT, SAVE_PROJECT_KEYS );
+ actions.runnableAction( bw::loadProject, LOAD_PROJECT, LOAD_PROJECT_KEYS );
+
+ // unmapped
+ actions.runnableAction( () -> { bw.getBwTransform().transformToString(); }, PRINT_TRANSFORM, PRINT_TRANSFORM_KEYS);
+ actions.runnableAction( bw::toggleInLandmarkMode, TOGGLE_LANDMARK_MODE, TOGGLE_LANDMARK_MODE_KEYS);
+ actions.runnableAction( bw::toggleMovingImageDisplay, TOGGLE_MOVING_IMAGE_DISPLAY, TOGGLE_MOVING_IMAGE_DISPLAY_KEYS );
+
+ // navigation
+ actions.runnableAction( bw::resetView, RESET_VIEWER, NOT_MAPPED );
+ actions.runnableAction( bw::matchOtherViewerPanelToActive, ALIGN_OTHER_TO_ACTIVE, NOT_MAPPED );
+ actions.runnableAction( bw::matchActiveViewerPanelToOther, ALIGN_ACTIVE_TO_OTHER, NOT_MAPPED );
+ actions.runnableAction( bw::jumpToSelectedLandmark, JUMP_TO_SELECTED_POINT, NOT_MAPPED );
+ actions.runnableAction( bw::jumpToNearestLandmark, JUMP_TO_NEAREST_POINT, NOT_MAPPED );
+ actions.runnableAction( bw::jumpToNextLandmark, JUMP_TO_NEXT_POINT, NOT_MAPPED );
+ actions.runnableAction( bw::jumpToPrevLandmark, JUMP_TO_PREV_POINT, NOT_MAPPED );
+
+ // bookmarks
+ actions.runnableAction( bw::goToBookmark, GO_TO_BOOKMARK, NOT_MAPPED );
+ actions.runnableAction( bw::goToBookmarkRotation, GO_TO_BOOKMARK_ROTATION, NOT_MAPPED );
+ actions.runnableAction( bw::setBookmark, SET_BOOKMARK, NOT_MAPPED );
+
+ // cards
+ actions.runnableAction( ()->{}, EXPAND_CARDS, NOT_MAPPED );
+ actions.runnableAction( ()->{}, COLLAPSE_CARDS, NOT_MAPPED );
+
+ // export
+ actions.runnableAction( bw::exportWarpField, EXPORT_WARP, EXPORT_WARP_KEYS );
+ actions.runnableAction( () -> { bw.getBwTransform().printAffine(); }, EXPORT_AFFINE, EXPORT_AFFINE_KEYS );
+
+ // dialogs
+ actions.namedAction( new ToggleDialogAction( SHOW_HELP, bw.helpDialog ), SHOW_HELP_KEYS );
+ actions.namedAction( new ToggleDialogAction( VISIBILITY_AND_GROUPING_MVG, bw.activeSourcesDialogP ), VISIBILITY_AND_GROUPING_MVG_KEYS );
+ actions.namedAction( new ToggleDialogAction( VISIBILITY_AND_GROUPING_TGT, bw.activeSourcesDialogQ ), VISIBILITY_AND_GROUPING_TGT_KEYS );
+ actions.namedAction( new ToggleDialogAction( SHOW_WARPTYPE_DIALOG, bw.warpVisDialog ), SHOW_WARPTYPE_DIALOG_KEYS );
+ actions.namedAction( new ToggleDialogAction( PREFERENCES_DIALOG, bw.preferencesDialog ), PREFERENCES_DIALOG_KEYS );
+
+ // landmarks
+ actions.runnableAction( () -> { bw.getLandmarkPanel().getJTable().selectAll(); }, LANDMARK_SELECT_ALL, LANDMARK_SELECT_ALL_KEYS );
+ actions.runnableAction( () -> { bw.getLandmarkPanel().getJTable().clearSelection(); }, LANDMARK_DESELECT_ALL, LANDMARK_DESELECT_ALL_KEYS );
+
+ actions.namedAction( bw.landmarkPopupMenu.deleteSelectedHandler, LANDMARK_DELETE_SELECTED_KEYS );
+
+ actions.namedAction( bw.landmarkPopupMenu.activateSelectedHandler, LANDMARK_ACTIVATE_SELECTED_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.deactivateSelectedHandler, LANDMARK_DEACTIVATE_SELECTED_KEYS );
+
+ actions.namedAction( bw.landmarkPopupMenu.addAboveHandler, LANDMARK_SELECT_ABOVE_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.addAllAboveHandler, LANDMARK_SELECT_ALL_ABOVE_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.addBelowHandler, LANDMARK_SELECT_BELOW_KEYS );
+ actions.namedAction( bw.landmarkPopupMenu.addAllBelowHandler, LANDMARK_SELECT_ALL_BELOW_KEYS );
+
+ actions.runnableAction( bw::loadLandmarks, LOAD_LANDMARKS, LOAD_LANDMARKS_KEYS );
+ actions.runnableAction( bw::saveLandmarks, SAVE_LANDMARKS, SAVE_LANDMARKS_KEYS );
+ actions.runnableAction( bw::quickSaveLandmarks, QUICK_SAVE_LANDMARKS, QUICK_SAVE_LANDMARKS_KEYS );
+
+ actions.namedAction( new UndoRedoAction( UNDO, bw ), UNDO_KEYS );
+ actions.namedAction( new UndoRedoAction( REDO, bw ), REDO_KEYS );
+
+ actions.namedAction( new ToggleBoxAndTexOverlayVisibility( TOGGLE_BOX_AND_TEXT_OVERLAY_VISIBLE, bw ), NOT_MAPPED );
+ actions.namedAction( new TogglePointsVisibleAction( TOGGLE_POINTS_VISIBLE, bw ), TOGGLE_POINTS_VISIBLE_KEYS );
+ actions.namedAction( new TogglePointNameVisibleAction( TOGGLE_POINT_NAMES_VISIBLE, bw ), TOGGLE_POINT_NAMES_VISIBLE_KEYS);
+ }
+
/**
* Create BigWarp actions and install them in the specified
- * {@link InputActionBindings}.
+ * {@link InputActionBindings}.
*
* @param inputActionBindings
* {@link InputMap} and {@link ActionMap} are installed here.
@@ -126,10 +581,10 @@ public static void installActionBindings(
inputActionBindings.addActionMap( "bw", createActionMap( bw ) );
inputActionBindings.addInputMap( "bw", createInputMap( keyProperties ) );
- inputActionBindings.addActionMap( "bwv", createActionMapViewer( bw ) );
+ inputActionBindings.addActionMap( "bwV", createActionMapViewer( bw ) );
inputActionBindings.addInputMap( "bwv", createInputMapViewer( keyProperties ) );
}
-
+
public static void installLandmarkPanelActionBindings(
final InputActionBindings inputActionBindings,
final BigWarp< ? > bw,
@@ -138,14 +593,14 @@ public static void installLandmarkPanelActionBindings(
{
inputActionBindings.addActionMap( "bw", createActionMap( bw ) );
inputActionBindings.addInputMap( "bw", createInputMap( keyProperties ) );
-
- TableCellEditor celled = landmarkTable.getCellEditor( 0, 1 );
- Component c = celled.getTableCellEditorComponent(landmarkTable, Boolean.TRUE, true, 0, 1 );
- InputMap parentInputMap = ((JCheckBox)c).getInputMap().getParent();
+ final TableCellEditor celled = landmarkTable.getCellEditor( 0, 1 );
+ final Component c = celled.getTableCellEditorComponent(landmarkTable, Boolean.TRUE, true, 0, 1 );
+
+ final InputMap parentInputMap = ((JCheckBox)c).getInputMap().getParent();
parentInputMap.clear();
- KeyStroke enterDownKS = KeyStroke.getKeyStroke("pressed ENTER" );
- KeyStroke enterUpKS = KeyStroke.getKeyStroke("released ENTER" );
+ final KeyStroke enterDownKS = KeyStroke.getKeyStroke("pressed ENTER" );
+ final KeyStroke enterUpKS = KeyStroke.getKeyStroke("released ENTER" );
parentInputMap.put( enterDownKS, "pressed" );
parentInputMap.put( enterUpKS, "released" );
@@ -157,20 +612,20 @@ public static InputMap createInputMapViewer( final KeyStrokeAdder.Factory keyPro
final KeyStrokeAdder map = keyProperties.keyStrokeAdder( inputMap );
map.put(RESET_VIEWER, "R");
-
+
map.put( String.format( VISIBILITY_AND_GROUPING, "moving" ), "F3" );
map.put( String.format( VISIBILITY_AND_GROUPING, "target" ), "F4" );
- map.put( "transform type", "F2" );
-
+ map.put( TRANSFORM_TYPE, "F2" );
+
map.put( String.format( ALIGN_VIEW_TRANSFORMS, AlignViewerPanelAction.TYPE.OTHER_TO_ACTIVE ), "Q" );
map.put( String.format( ALIGN_VIEW_TRANSFORMS, AlignViewerPanelAction.TYPE.ACTIVE_TO_OTHER ), "W" );
map.put( TOGGLE_MOVING_IMAGE_DISPLAY, "T" );
- map.put( WARP_TO_SELECTED_POINT, "D" );
- map.put( String.format( WARP_TO_NEXT_POINT, true), "ctrl D" );
- map.put( String.format( WARP_TO_NEXT_POINT, false), "ctrl shift D" );
- map.put( WARP_TO_NEAREST_POINT, "E" );
+ map.put( JUMP_TO_SELECTED_POINT, "D" );
+ map.put( String.format( JUMP_TO_NEXT_POINT, true), "ctrl D" );
+ map.put( String.format( JUMP_TO_NEXT_POINT, false), "ctrl shift D" );
+ map.put( JUMP_TO_NEAREST_POINT, "E" );
map.put( EXPORT_WARP, "ctrl W" );
map.put( EXPORT_AFFINE, "ctrl A" );
@@ -188,7 +643,7 @@ public static ActionMap createActionMapViewer( final BigWarp< ? > bw )
new ToggleDialogAction( String.format( VISIBILITY_AND_GROUPING, "moving" ), bw.activeSourcesDialogP ).put( actionMap );
new ToggleDialogAction( String.format( VISIBILITY_AND_GROUPING, "target" ), bw.activeSourcesDialogQ ).put( actionMap );
- new ToggleDialogAction( "transform type", bw.transformSelector ).put( actionMap );
+ new ToggleDialogAction( TRANSFORM_TYPE, bw.transformSelector ).put( actionMap );
for( final BigWarp.WarpVisType t: BigWarp.WarpVisType.values())
{
@@ -200,10 +655,10 @@ public static ActionMap createActionMapViewer( final BigWarp< ? > bw )
new ResetActiveViewerAction( bw ).put( actionMap );
new AlignViewerPanelAction( bw, AlignViewerPanelAction.TYPE.ACTIVE_TO_OTHER ).put( actionMap );
new AlignViewerPanelAction( bw, AlignViewerPanelAction.TYPE.OTHER_TO_ACTIVE ).put( actionMap );
- new WarpToSelectedAction( bw ).put( actionMap );
- new WarpToNextAction( bw, true ).put( actionMap );
- new WarpToNextAction( bw, false ).put( actionMap );
- new WarpToNearest( bw ).put( actionMap );
+ new JumpToSelectedAction( bw ).put( actionMap );
+ new JumpToNextAction( bw, true ).put( actionMap );
+ new JumpToNextAction( bw, false ).put( actionMap );
+ new JumpToNearest( bw ).put( actionMap );
for( final GridSource.GRID_TYPE t : GridSource.GRID_TYPE.values())
new SetWarpVisGridTypeAction( String.format( WARPVISGRID, t.name()), bw, t ).put( actionMap );
@@ -215,6 +670,9 @@ public static ActionMap createActionMapViewer( final BigWarp< ? > bw )
new SaveSettingsAction( bw ).put( actionMap );
new LoadSettingsAction( bw ).put( actionMap );
+ new SaveProjectAction( bw ).put( actionMap );
+ new LoadProjectAction( bw ).put( actionMap );
+
return actionMap;
}
@@ -226,6 +684,7 @@ public static InputMap createInputMap( final KeyStrokeAdder.Factory keyPropertie
map.put( SHOW_WARPTYPE_DIALOG, "U" );
map.put( TOGGLE_LANDMARK_MODE, "SPACE" );
+ map.put( BRIGHTNESS_SETTINGS, "S" );
// map.put( LANDMARK_MODE_ON, "pressed SPACE" );
// // the few lines below are super ugly, but are necessary for robustness
// map.put( LANDMARK_MODE_ON, "shift pressed SPACE" );
@@ -246,13 +705,15 @@ public static InputMap createInputMap( final KeyStrokeAdder.Factory keyPropertie
// map.put( LANDMARK_MODE_OFF, "ctrl shift released SPACE", "released" );
// map.put( LANDMARK_MODE_OFF, "alt ctrl shift released SPACE", "released" );
- map.put( BRIGHTNESS_SETTINGS, "S" );
map.put( SHOW_HELP, "F1", "H" );
map.put( TOGGLE_POINTS_VISIBLE, "V" );
map.put( TOGGLE_POINT_NAMES_VISIBLE, "N" );
map.put( ESTIMATE_WARP, "C" );
+ map.put( MASK_SIZE_EDIT, "M" );
+ map.put( MASK_VIS_TOGGLE, "control M" );
+
map.put( UNDO, "control Z" );
map.put( REDO, "control Y" );
map.put( REDO, "control shift Z" );
@@ -265,9 +726,9 @@ public static InputMap createInputMap( final KeyStrokeAdder.Factory keyPropertie
// map.put( SAVE_WARPED, "control alt shift E" );
map.put( SAVE_WARPED_XML, "control shift E" );
-// map.put( LandmarkPointMenu.CLEAR_SELECTED_MOVING, "BACK_SPACE" );
-// map.put( LandmarkPointMenu.CLEAR_SELECTED_FIXED, "control BACK_SPACE" );
-// map.put( LandmarkPointMenu.DELETE_SELECTED, "DELETE" );
+ map.put( CLEAR_SELECTED_MOVING, "BACK_SPACE" );
+ map.put( CLEAR_SELECTED_FIXED, "control BACK_SPACE" );
+ map.put( DELETE_SELECTED, "DELETE" );
map.put( String.format( SELECT_TABLE_ROWS, -1 ), "shift ESCAPE" );
@@ -304,7 +765,6 @@ public static ActionMap createActionMap( final BigWarp< ? > bw )
new ToggleDialogAction( SHOW_WARPTYPE_DIALOG, bw.warpVisDialog ).put( actionMap );
- new ToggleDialogAction( BRIGHTNESS_SETTINGS, bw.brightnessDialog ).put( actionMap );
new ToggleDialogAction( SHOW_HELP, bw.helpDialog ).put( actionMap );
new ToggleDialogAction( SHOW_SOURCE_INFO, bw.sourceInfoDialog ).put( actionMap );
@@ -326,6 +786,12 @@ public static ActionMap createActionMap( final BigWarp< ? > bw )
new ToggleMovingImageDisplayAction( TOGGLE_MOVING_IMAGE_DISPLAY, bw ).put( actionMap );
new EstimateWarpAction( ESTIMATE_WARP, bw ).put( actionMap );
+ // MASK
+ new MaskSizeEdit( bw ).put(actionMap);
+ new MaskVisToggle( bw ).put(actionMap);
+ new MaskImport( bw ).put(actionMap);
+ new MaskRemove( bw ).put(actionMap);
+
for( int i = 0; i < bw.baseXfmList.length; i++ ){
final AbstractModel xfm = bw.baseXfmList[ i ];
new SetWarpMagBaseAction( String.format( WARPMAG_BASE, xfm.getClass().getName()), bw, i ).put( actionMap );
@@ -343,8 +809,6 @@ public static ActionMap createActionMap( final BigWarp< ? > bw )
return actionMap;
}
- private BigWarpActions(){}
-
public static class UndoRedoAction extends AbstractNamedAction
{
private static final long serialVersionUID = -5413579107763110117L;
@@ -356,7 +820,7 @@ public UndoRedoAction( final String name, BigWarp< ? > bw )
{
super( name );
this.bw = bw;
-
+
isRedo = false;
if ( name.equals( REDO ) )
@@ -367,16 +831,10 @@ public UndoRedoAction( final String name, BigWarp< ? > bw )
@Override
public void actionPerformed( ActionEvent e )
{
- if( bw.isInLandmarkMode() )
- {
- bw.message.showMessage( "Undo/Redo not allowed in landmark mode" );
- return;
- }
-
// I would love for this check to work instead of using a try-catch
// bug it doesn't seem to be consistent
// if( isRedo && manager.canRedo() ){
- try {
+ try {
if( isRedo )
{
@@ -401,7 +859,7 @@ public void actionPerformed( ActionEvent e )
// repaint
this.bw.getLandmarkPanel().repaint();
}
- catch( Exception ex )
+ catch( final Exception ex )
{
if( isRedo )
{
@@ -411,8 +869,6 @@ public void actionPerformed( ActionEvent e )
{
bw.message.showMessage("Can't undo");
}
- //System.err.println( " Undo / redo error, or nothing to do " );
- //ex.printStackTrace();
}
}
}
@@ -435,7 +891,6 @@ public LandmarkModeAction( final String name, final BigWarp< ? > bw, final boole
@Override
public void actionPerformed( ActionEvent e )
{
-// System.out.println( "LM MODE : " + isOn );
bw.setInLandmarkMode( isOn );
}
}
@@ -455,12 +910,11 @@ public ToggleLandmarkModeAction( final String name, final BigWarp< ? > bw )
@Override
public void actionPerformed( ActionEvent e )
{
-// System.out.println( "TOGGLE LM MODE" );
bw.setInLandmarkMode( !bw.inLandmarkMode );
}
}
- public static class ToggleAlwaysEstimateTransformAction extends AbstractNamedAction
+ public static class ToggleAlwaysEstimateTransformAction extends AbstractNamedAction
{
private static final long serialVersionUID = 2909830484701853577L;
@@ -479,7 +933,7 @@ public void actionPerformed( ActionEvent e )
}
}
- public static class GarbageCollectionAction extends AbstractNamedAction
+ public static class GarbageCollectionAction extends AbstractNamedAction
{
private static final long serialVersionUID = -4487441057212703143L;
@@ -495,13 +949,13 @@ public void actionPerformed( ActionEvent e )
System.gc();
}
}
-
+
public static class PrintTransformAction extends AbstractNamedAction
{
private static final long serialVersionUID = 6065343788485350279L;
private BigWarp< ? > bw;
-
+
public PrintTransformAction( final String name, final BigWarp< ? > bw )
{
super( name );
@@ -539,32 +993,31 @@ public void actionPerformed( ActionEvent e )
// System.out.println( ltm.getChangedSinceWarp() );
// System.out.println( ltm.getWarpedPoints() );
// ltm.printWarpedPoints();
-
- AffineTransform3D xfm = new AffineTransform3D();
+
+ final AffineTransform3D xfm = new AffineTransform3D();
bw.viewerP.state().getViewerTransform( xfm );
System.out.println( "mvg xfm " + xfm + " DET = " + BigWarpUtils.det( xfm ));
bw.viewerQ.state().getViewerTransform( xfm );
System.out.println( "tgt xfm " + xfm + " DET = " + BigWarpUtils.det( xfm ));
- BigWarpData< ? > data = bw.getData();
- for( int mi : data.movingSourceIndices )
- {
- ((SourceAndConverter)data.sources.get( mi )).getSpimSource().getSourceTransform( 0, 0, xfm );
- System.out.println( "mvg src xfm " + xfm );
- }
-
- for( int ti : data.targetSourceIndices )
- {
- ((SourceAndConverter)data.sources.get( ti )).getSpimSource().getSourceTransform( 0, 0, xfm );
- System.out.println( "tgt src xfm " + xfm );
- }
-
-
- System.out.println( " " );
+// BigWarpData< ? > data = bw.getData();
+// for( int mi : data.movingSourceIndices )
+// {
+// ((SourceAndConverter)data.sources.get( mi )).getSpimSource().getSourceTransform( 0, 0, xfm );
+// System.out.println( "mvg src xfm " + xfm );
+// }
+//
+// for( int ti : data.targetSourceIndices )
+// {
+// ((SourceAndConverter)data.sources.get( ti )).getSpimSource().getSourceTransform( 0, 0, xfm );
+// System.out.println( "tgt src xfm " + xfm );
+// }
+//
+// System.out.println( " " );
}
}
-
+
public static class EstimateWarpAction extends AbstractNamedAction
{
private static final long serialVersionUID = -210012348709096037L;
@@ -583,13 +1036,13 @@ public void actionPerformed( ActionEvent e )
bw.restimateTransformation();
}
}
-
+
public static class ToggleMovingImageDisplayAction extends AbstractNamedAction
{
private static final long serialVersionUID = 6495981071796613953L;
-
+
private BigWarp< ? > bw;
-
+
public ToggleMovingImageDisplayAction( final String name, final BigWarp< ? > bw )
{
super( name );
@@ -602,7 +1055,7 @@ public void actionPerformed( ActionEvent e )
bw.toggleMovingImageDisplay();
}
}
-
+
public static class TogglePointNameVisibleAction extends AbstractNamedAction
{
private static final long serialVersionUID = 2639535533224809586L;
@@ -618,7 +1071,7 @@ public TogglePointNameVisibleAction( final String name, final BigWarp< ? > bw )
@Override
public void actionPerformed( ActionEvent e )
{
- bw.toggleNameVisibility();
+ bw.toggleNameVisibility();
}
}
@@ -637,10 +1090,13 @@ public ToggleBoxAndTexOverlayVisibility( final String name, final BigWarp< ? > b
@Override
public void actionPerformed( ActionEvent e )
{
- bw.getViewerFrameP().getViewerPanel().toggleBoxOverlayVisible();
- bw.getViewerFrameQ().getViewerPanel().toggleBoxOverlayVisible();
- bw.getViewerFrameP().getViewerPanel().toggleTextOverlayVisible();
- bw.getViewerFrameQ().getViewerPanel().toggleTextOverlayVisible();
+// bw.getViewerFrameP().getViewerPanel().toggleBoxOverlayVisible();
+// bw.getViewerFrameQ().getViewerPanel().toggleBoxOverlayVisible();
+// bw.getViewerFrameP().getViewerPanel().toggleTextOverlayVisible();
+// bw.getViewerFrameQ().getViewerPanel().toggleTextOverlayVisible();
+ Prefs.showTextOverlay(!Prefs.showTextOverlay());
+ Prefs.showMultibox(!Prefs.showMultibox());
+
bw.getViewerFrameP().repaint();
bw.getViewerFrameQ().repaint();
}
@@ -650,7 +1106,7 @@ public static class TogglePointsVisibleAction extends AbstractNamedAction
{
private static final long serialVersionUID = 8747830204501341125L;
private BigWarp< ? > bw;
-
+
public TogglePointsVisibleAction( final String name, final BigWarp< ? > bw )
{
super( name );
@@ -660,44 +1116,46 @@ public TogglePointsVisibleAction( final String name, final BigWarp< ? > bw )
@Override
public void actionPerformed( ActionEvent e )
{
- bw.togglePointVisibility();
+ bw.togglePointVisibility();
}
}
-
+
public static class ResetActiveViewerAction extends AbstractNamedAction
{
private static final long serialVersionUID = -130575800163574517L;
-
+
private BigWarp< ? > bw;
-
+
public ResetActiveViewerAction( final BigWarp< ? > bw )
{
super( String.format( RESET_VIEWER ) );
this.bw = bw;
}
-
+
+ @Override
public void actionPerformed( ActionEvent e )
{
bw.resetView();
}
}
-
+
public static class AlignViewerPanelAction extends AbstractNamedAction
{
private static final long serialVersionUID = -7023242695323421450L;
-
- public enum TYPE { ACTIVE_TO_OTHER, OTHER_TO_ACTIVE };
-
+
+ public enum TYPE { ACTIVE_TO_OTHER, OTHER_TO_ACTIVE }
+
private BigWarp< ? >bw;
private TYPE type;
-
+
public AlignViewerPanelAction( final BigWarp< ? > bw, TYPE type )
{
super( String.format( ALIGN_VIEW_TRANSFORMS, type ) );
this.bw = bw;
this.type = type;
}
-
+
+ @Override
public void actionPerformed( ActionEvent e )
{
if( type == TYPE.ACTIVE_TO_OTHER )
@@ -710,10 +1168,10 @@ public void actionPerformed( ActionEvent e )
public static class SetWarpMagBaseAction extends AbstractNamedAction
{
private static final long serialVersionUID = 7370813069619338918L;
-
+
private BigWarp< ? > bw;
private int i;
-
+
public SetWarpMagBaseAction( final String name, final BigWarp< ? > bw, int i )
{
super( name );
@@ -727,14 +1185,14 @@ public void actionPerformed( ActionEvent e )
bw.setWarpMagBaselineIndex( i );
}
}
-
+
public static class SetWarpVisGridTypeAction extends AbstractNamedAction
{
private static final long serialVersionUID = 7370813069619338918L;
-
+
private final BigWarp< ? > bw;
private final GridSource.GRID_TYPE type;
-
+
public SetWarpVisGridTypeAction( final String name, final BigWarp< ? > bw, final GridSource.GRID_TYPE type )
{
super( name );
@@ -748,20 +1206,20 @@ public void actionPerformed( ActionEvent e )
bw.setWarpVisGridType( type );
}
}
-
+
public static class SetWarpVisTypeAction extends AbstractNamedAction
{
private static final long serialVersionUID = 7370813069619338918L;
-
+
private BigWarp< ? > bw;
private BigWarpViewerFrame p;
private BigWarp.WarpVisType type;
-
+
public SetWarpVisTypeAction( final BigWarp.WarpVisType type, final BigWarp< ? > bw )
{
this( type, bw, null );
}
-
+
public SetWarpVisTypeAction( final BigWarp.WarpVisType type, final BigWarp< ? > bw, BigWarpViewerFrame p )
{
super( getName( type, p ));
@@ -778,7 +1236,7 @@ public void actionPerformed( ActionEvent e )
else
bw.setWarpVisMode( type, p, false );
}
-
+
public static String getName( final BigWarp.WarpVisType type, BigWarpViewerFrame p )
{
if( p == null )
@@ -789,7 +1247,7 @@ else if( p.isMoving() )
return String.format( SET_WARPTYPE_VIS_Q, type.name() );
}
}
-
+
public static class TableSelectionAction extends AbstractNamedAction
{
private static final long serialVersionUID = -4647679094757721276L;
@@ -893,6 +1351,23 @@ public void actionPerformed( final ActionEvent e )
private static final long serialVersionUID = 1L;
}
+ public static class SaveProjectAction extends AbstractNamedAction
+ {
+ private static final long serialVersionUID = -965388576691467002L;
+ BigWarp< ? > bw;
+ public SaveProjectAction( final BigWarp< ? > bw )
+ {
+ super( SAVE_PROJECT );
+ this.bw = bw;
+ }
+
+ @Override
+ public void actionPerformed( final ActionEvent e )
+ {
+ bw.saveProject();
+ }
+ }
+
public static class LoadSettingsAction extends AbstractNamedAction
{
BigWarp< ? > bw;
@@ -911,62 +1386,67 @@ public void actionPerformed( final ActionEvent e )
private static final long serialVersionUID = 1L;
}
- public static class WarpToSelectedAction extends AbstractNamedAction
+ public static class LoadProjectAction extends AbstractNamedAction
+ {
+ private static final long serialVersionUID = 1793182816804229398L;
+ BigWarp< ? > bw;
+ public LoadProjectAction( final BigWarp< ? > bw )
+ {
+ super( LOAD_PROJECT );
+ this.bw = bw;
+ }
+
+ @Override
+ public void actionPerformed( final ActionEvent e )
+ {
+ bw.loadProject();
+ }
+ }
+
+ public static class JumpToSelectedAction extends AbstractNamedAction
{
final BigWarp< ? > bw;
- public WarpToSelectedAction( final BigWarp< ? > bw )
+ public JumpToSelectedAction( final BigWarp< ? > bw )
{
- super( WARP_TO_SELECTED_POINT );
+ super( JUMP_TO_SELECTED_POINT );
this.bw = bw;
}
@Override
public void actionPerformed( ActionEvent e )
{
- int[] selectedRows = bw.getLandmarkPanel().getJTable().getSelectedRows();
-
- int row = 0;
- if( selectedRows.length > 0 )
- row = selectedRows[ 0 ];
-
- if( bw.getViewerFrameP().isActive() )
- bw.warpToLandmark( row, bw.getViewerFrameP().getViewerPanel() );
- else
- bw.warpToLandmark( row, bw.getViewerFrameQ().getViewerPanel() );
+ bw.jumpToSelectedLandmark();
}
private static final long serialVersionUID = 5233843444920094805L;
}
- public static class WarpToNearest extends AbstractNamedAction
+ public static class JumpToNearest extends AbstractNamedAction
{
final BigWarp< ? > bw;
- public WarpToNearest( final BigWarp< ? > bw )
+ public JumpToNearest( final BigWarp< ? > bw )
{
- super( WARP_TO_NEAREST_POINT );
+ super( JUMP_TO_NEAREST_POINT );
this.bw = bw;
}
@Override
public void actionPerformed( ActionEvent e )
{
- if( bw.getViewerFrameP().isActive() )
- bw.warpToNearest( bw.getViewerFrameP().getViewerPanel() );
- else
- bw.warpToNearest( bw.getViewerFrameQ().getViewerPanel() );
+ bw.jumpToNearestLandmark();
}
private static final long serialVersionUID = 3244181492305479433L;
}
- public static class WarpToNextAction extends AbstractNamedAction
+ public static class JumpToNextAction extends AbstractNamedAction
{
final BigWarp< ? > bw;
final int inc;
- public WarpToNextAction( final BigWarp< ? > bw, boolean fwd )
+ public JumpToNextAction( final BigWarp< ? > bw, boolean fwd )
{
- super( String.format( WARP_TO_NEXT_POINT, fwd) );
+ super( fwd ? JUMP_TO_NEXT_POINT : JUMP_TO_PREV_POINT );
this.bw = bw;
if( fwd )
inc = 1;
@@ -977,31 +1457,7 @@ public WarpToNextAction( final BigWarp< ? > bw, boolean fwd )
@Override
public void actionPerformed( ActionEvent e )
{
- int[] selectedRows = bw.getLandmarkPanel().getJTable().getSelectedRows();
-
- int row = 0;
- if( selectedRows.length > 0 )
- row = selectedRows[ selectedRows.length - 1 ];
-
- row = row + inc; // increment to get the *next* row
-
- // wrap to start if necessary
- if( row >= bw.getLandmarkPanel().getTableModel().getRowCount() )
- row = 0;
- else if( row < 0 )
- row = bw.getLandmarkPanel().getTableModel().getRowCount() - 1;
-
- // select new row
- bw.getLandmarkPanel().getJTable().setRowSelectionInterval( row, row );
-
- if( bw.getViewerFrameP().isActive() )
- {
- bw.warpToLandmark( row, bw.getViewerFrameP().getViewerPanel() );
- }
- else
- {
- bw.warpToLandmark( row, bw.getViewerFrameQ().getViewerPanel() );
- }
+ bw.jumpToLandmarkRelative(inc);
}
private static final long serialVersionUID = 8515568118251877405L;
}
@@ -1070,7 +1526,7 @@ public void actionPerformed(ActionEvent e)
bw.exportAsImagePlus( false );
}
}
-
+
public static class ExportWarpAction extends AbstractNamedAction
{
private static final long serialVersionUID = 4626378501415886468L;
@@ -1156,4 +1612,78 @@ public void actionPerformed(ActionEvent e)
LandmarkGridGenerator.fillFromDialog( bw );
}
}
+
+ public static class MaskSizeEdit extends AbstractNamedAction
+ {
+ private static final long serialVersionUID = -7918625162439713732L;
+ private final BigWarp< ? > bw;
+
+ public MaskSizeEdit( final BigWarp< ? > bw )
+ {
+ super( MASK_SIZE_EDIT );
+ this.bw = bw;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ if( bw.maskSourceMouseListenerQ != null )
+ bw.maskSourceMouseListenerQ.toggleActive();
+ }
+ }
+
+ public static class MaskVisToggle extends AbstractNamedAction
+ {
+ private static final long serialVersionUID = 493457851797644046L;
+ private final BigWarp< ? > bw;
+
+ public MaskVisToggle( final BigWarp< ? > bw )
+ {
+ super( MASK_VIS_TOGGLE );
+ this.bw = bw;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ bw.getViewerFrameQ().getViewerPanel().getMaskOverlay().toggleVisible();
+ }
+ }
+
+ public static class MaskImport extends AbstractNamedAction
+ {
+ private static final long serialVersionUID = 493457851797644046L;
+ private final BigWarp< ? > bw;
+
+ public MaskImport( final BigWarp< ? > bw )
+ {
+ super( MASK_IMPORT );
+ this.bw = bw;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ bw.importTransformMaskSourceDialog();
+ }
+ }
+
+ public static class MaskRemove extends AbstractNamedAction
+ {
+ private static final long serialVersionUID = 4103338122650843631L;
+ private final BigWarp< ? > bw;
+
+ public MaskRemove( final BigWarp< ? > bw )
+ {
+ super( MASK_REMOVE );
+ this.bw = bw;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ bw.removeMaskSource();
+ }
+ }
+
}
diff --git a/src/main/java/bigwarp/BigWarpAutoSaver.java b/src/main/java/bigwarp/BigWarpAutoSaver.java
index 2cbfa9f2..91cd701f 100644
--- a/src/main/java/bigwarp/BigWarpAutoSaver.java
+++ b/src/main/java/bigwarp/BigWarpAutoSaver.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -25,30 +25,37 @@
import java.util.Timer;
import java.util.TimerTask;
+import com.google.gson.annotations.JsonAdapter;
+import com.google.gson.annotations.SerializedName;
+
import bigwarp.landmarks.LandmarkTableModel;
/**
- * Saves bigwarp landmarks to a file periodically,
+ * Saves bigwarp landmarks to a file periodically,
* but only if modification has occured since the last save.
- *
+ *
* @author John Bogovic
*
*/
-public class BigWarpAutoSaver
+public class BigWarpAutoSaver
{
- private final BigWarp bw;
+ transient private final BigWarp bw;
- final Timer timer;
+ transient final Timer timer;
- final AutoSave saveTask;
+ transient final AutoSave saveTask;
final long period;
+ @SerializedName("location")
+ @JsonAdapter( BigwarpSettings.FileAdapter.class )
+ protected File autoSaveDirectory;
+
+
public BigWarpAutoSaver( final BigWarp bw, final long period )
{
this.bw = bw;
this.period = period;
- bw.autoSaver = this;
timer = new Timer();
saveTask = new AutoSave();
timer.schedule( saveTask, period, period );
@@ -65,37 +72,57 @@ public void stop()
timer.cancel();
}
- private class AutoSave extends TimerTask
+ private class AutoSave extends TimerTask
{
@Override
public void run()
{
- LandmarkTableModel ltm = bw.getLandmarkPanel().getTableModel();
+ final LandmarkTableModel ltm = bw.getLandmarkPanel().getTableModel();
if( ltm.isModifiedSinceSave() )
{
bw.autoSaveLandmarks();
}
}
}
-
+
public static void setAutosaveOptions( final BigWarp bw, final long period, final String autoSavePath )
{
- bw.setAutosaveFolder( new File( autoSavePath ) );
if( period > 0 )
{
- bw.warpVisDialog.doAutoSaveBox.setSelected( true );
- int periodMinutes = ( int ) ( period / 60000 );
- bw.warpVisDialog.autoSavePeriodSpinner.setValue( periodMinutes );
+ bw.warpVisDialog.getAutoSaveOptionsPanel().getDoAutoSaveBox().setSelected( true );
+ final int periodMinutes = ( int ) ( period / 60000 );
+ bw.warpVisDialog.getAutoSaveOptionsPanel().getAutoSavePeriodSpinner().setValue( periodMinutes );
if( bw.autoSaver != null )
bw.autoSaver.stop();
- new BigWarpAutoSaver( bw, period );
- bw.warpVisDialog.repaint();
+ final BigWarpAutoSaver autoSaver = new BigWarpAutoSaver( bw, period );
+ bw.setAutoSaver( autoSaver );
+ autoSaver.setAutosaveFolder( new File( autoSavePath ) );
}
else
{
- bw.warpVisDialog.doAutoSaveBox.setSelected( false );
+ bw.warpVisDialog.getAutoSaveOptionsPanel().getDoAutoSaveBox().setSelected( false );
+ bw.warpVisDialog.repaint();
+ }
+ }
+
+ /**
+ * Set the folder where the results of auto-saving will be stored.
+ *
+ * @param autoSaveFolder
+ * the destination folder
+ */
+ public void setAutosaveFolder( final File autoSaveFolder )
+ {
+ boolean exists = autoSaveFolder.exists();
+ if ( !exists )
+ exists = autoSaveFolder.mkdir();
+
+ if ( exists && autoSaveFolder.isDirectory() )
+ {
+ autoSaveDirectory = autoSaveFolder;
+ bw.warpVisDialog.getAutoSaveOptionsPanel().getAutoSaveFolderText().setText( autoSaveFolder.getAbsolutePath() );
bw.warpVisDialog.repaint();
}
}
diff --git a/src/main/java/bigwarp/BigWarpBatchTransformFOV.java b/src/main/java/bigwarp/BigWarpBatchTransformFOV.java
index b25db515..fe0a55b3 100644
--- a/src/main/java/bigwarp/BigWarpBatchTransformFOV.java
+++ b/src/main/java/bigwarp/BigWarpBatchTransformFOV.java
@@ -42,7 +42,6 @@
import bdv.spimdata.WrapBasicImgLoader;
import bdv.viewer.Interpolation;
import bdv.viewer.SourceAndConverter;
-import bigwarp.BigWarp.BigWarpData;
import bigwarp.BigWarpExporter.ExportThread;
import bigwarp.landmarks.LandmarkTableModel;
import bigwarp.loader.ImagePlusLoader;
@@ -69,12 +68,6 @@
import net.imglib2.realtransform.AffineTransform3D;
import net.imglib2.realtransform.ThinplateSplineTransform;
import net.imglib2.realtransform.inverse.WrappedIterativeInvertibleRealTransform;
-import net.imglib2.type.numeric.ARGBType;
-import net.imglib2.type.numeric.integer.ByteType;
-import net.imglib2.type.numeric.integer.IntType;
-import net.imglib2.type.numeric.integer.UnsignedByteType;
-import net.imglib2.type.numeric.integer.UnsignedShortType;
-import net.imglib2.type.numeric.real.DoubleType;
import net.imglib2.type.numeric.real.FloatType;
import net.imglib2.util.ConstantUtils;
@@ -339,11 +332,9 @@ public static < T > BigWarpExporter< T > applyBigWarpHelper( AbstractSpimData< ?
movingSourceIndexList[ i ] = i;
}
- int[] targetSourceIndexList = data.targetSourceIndices;
-
@SuppressWarnings("unchecked")
List< SourceAndConverter< T >> sourcesxfm = BigWarp.wrapSourcesAsTransformed(
- data.sources,
+ data.sourceInfos,
ltm.getNumdims(),
data );
diff --git a/src/main/java/bigwarp/BigWarpData.java b/src/main/java/bigwarp/BigWarpData.java
new file mode 100644
index 00000000..1d5a3465
--- /dev/null
+++ b/src/main/java/bigwarp/BigWarpData.java
@@ -0,0 +1,466 @@
+package bigwarp;
+
+import bigwarp.source.SourceInfo;
+import bigwarp.util.BigWarpUtils;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import bdv.cache.CacheControl;
+import bdv.gui.BigWarpViewerFrame;
+import bdv.img.WarpedSource;
+import bdv.tools.InitializeViewerState;
+import bdv.tools.brightness.ConverterSetup;
+import bdv.tools.brightness.SetupAssignments;
+import bdv.tools.transformation.TransformedSource;
+import bdv.util.Bounds;
+import bdv.viewer.ConverterSetups;
+import bdv.viewer.Source;
+import bdv.viewer.SourceAndConverter;
+import bdv.viewer.SynchronizedViewerState;
+import bdv.viewer.VisibilityAndGrouping;
+import net.imglib2.realtransform.AffineGet;
+import net.imglib2.realtransform.AffineTransform3D;
+import net.imglib2.realtransform.InvertibleRealTransform;
+import net.imglib2.realtransform.InvertibleWrapped2DTransformAs3D;
+import net.imglib2.realtransform.RealTransform;
+import net.imglib2.realtransform.Wrapped2DTransformAs3D;
+
+public class BigWarpData< T >
+{
+ public List< SourceAndConverter< T > > sources;
+
+ public final LinkedHashMap< Integer, SourceInfo > sourceInfos = new LinkedHashMap<>();
+ public final List< ConverterSetup > converterSetups;
+
+ public final CacheControl cache;
+
+ public BigWarpData()
+ {
+ this( new ArrayList<>(), new ArrayList<>(), null );
+ }
+
+ public BigWarpData( final List< SourceAndConverter< T > > sources, final List< ConverterSetup > converterSetups,
+ final CacheControl cache,
+ final int[] movingIndexes,
+ final int[] targetIndexes )
+ {
+ this( sources, converterSetups, cache,
+ listOf( movingIndexes ),
+ listOf( targetIndexes ));
+ }
+
+ public BigWarpData( final List< SourceAndConverter< T > > sources,
+ final List< ConverterSetup > converterSetups,
+ final CacheControl cache )
+ {
+ this( sources, null, converterSetups, cache );
+ }
+
+ public BigWarpData( final List< SourceAndConverter< T > > sources,
+ final List< RealTransform > transforms,
+ final List< ConverterSetup > converterSetups,
+ final CacheControl cache )
+ {
+ this.sources = sources;
+ this.converterSetups = converterSetups;
+
+ if ( cache == null )
+ this.cache = new CacheControl.Dummy();
+ else
+ this.cache = cache;
+ }
+
+ public BigWarpData( final List< SourceAndConverter< T > > sources, final List< ConverterSetup > converterSetups,
+ final CacheControl cache,
+ final List movingIndexes,
+ final List targetIndexes )
+ {
+ this.sources = sources;
+ this.converterSetups = converterSetups;
+
+ for ( int i = 0; i < sources.size(); i++ )
+ {
+ final SourceAndConverter< T > sourceAndConverter = sources.get( i );
+ final SourceInfo sourceInfo = new SourceInfo( i, movingIndexes.contains( i ), sourceAndConverter.getSpimSource().getName() );
+ sourceInfo.setSourceAndConverter( sourceAndConverter );
+ sourceInfos.put( i, sourceInfo );
+ }
+
+ if ( cache == null )
+ this.cache = new CacheControl.Dummy();
+ else
+ this.cache = cache;
+ }
+
+ private static ArrayList listOf( int[] x )
+ {
+ final ArrayList< Integer > out = new ArrayList();
+ for( final int i : x )
+ out.add( i );
+
+ return out;
+ }
+
+ public int numMovingSources()
+ {
+ final AtomicInteger movingCount = new AtomicInteger();
+ sourceInfos.forEach( (id, info) -> {
+ if (info.isMoving()) movingCount.incrementAndGet();
+ } );
+ return movingCount.get();
+ }
+
+ @SuppressWarnings( "unchecked" )
+ public SourceAndConverter< T > getMovingSource( int i )
+ {
+ int curIdx = 0;
+ for ( final Map.Entry< Integer, SourceInfo > idToInfo : sourceInfos.entrySet() )
+ {
+ final SourceInfo info = idToInfo.getValue();
+ if (info.isMoving()) {
+ if (curIdx == i) return ( SourceAndConverter< T > ) info.getSourceAndConverter();
+ curIdx++;
+ }
+ }
+ return null;
+ }
+
+ public int numTargetSources()
+ {
+ return sourceInfos.size() - numMovingSources();
+ }
+
+ public List< Integer > getMovingSourceIndices() {
+ final ArrayList indices = new ArrayList<>();
+ int idx = 0;
+ for ( final SourceInfo sourceInfo : sourceInfos.values() )
+ {
+ if ( sourceInfo.isMoving()){
+ indices.add( idx );
+ }
+ idx++;
+ }
+ return indices;
+ }
+
+ public SourceAndConverter< T > getTargetSource( int i )
+ {
+ int curIdx = 0;
+ for ( final Map.Entry< Integer, SourceInfo > idToInfo : sourceInfos.entrySet() )
+ {
+ final SourceInfo info = idToInfo.getValue();
+ if (!info.isMoving()) {
+ if (curIdx == i) return ( SourceAndConverter< T > ) info.getSourceAndConverter();
+ curIdx++;
+ }
+ }
+ return null;
+ }
+
+ public List getMovingConverterSetups()
+ {
+ final ArrayList out = new ArrayList<>();
+
+ final SourceInfo[] infos = sourceInfos.values().toArray(new SourceInfo[]{} );
+ for ( int i = 0; i < infos.length; i++ )
+ {
+ final SourceInfo info = infos[ i ];
+ if (info.isMoving()) {
+ out.add( converterSetups.get( i ) );
+ }
+ }
+ return out;
+ }
+
+ public List getTargetConverterSetups()
+ {
+ final ArrayList out = new ArrayList<>();
+
+ final SourceInfo[] infos = sourceInfos.values().toArray(new SourceInfo[]{} );
+ for ( int i = 0; i < infos.length; i++ )
+ {
+ final SourceInfo info = infos[ i ];
+ if (!info.isMoving()) {
+ out.add( converterSetups.get( i ) );
+ }
+ }
+ return out;
+ }
+
+ public ConverterSetup getConverterSetup( final int id )
+ {
+ final SourceInfo[] infos = sourceInfos.values().toArray(new SourceInfo[]{} );
+ for ( int i = 0; i < infos.length; i++ )
+ {
+ final SourceInfo info = infos[ i ];
+ if (info.getId() == id )
+ return converterSetups.get( i );
+ }
+ return null;
+ }
+
+ public SourceInfo getSourceInfo( int id )
+ {
+ return sourceInfos.get( id );
+ }
+
+ public SourceInfo getSourceInfo( SourceAndConverter< ? > sac )
+ {
+ for ( final SourceInfo info : sourceInfos.values() )
+ {
+ if (info.getSourceAndConverter() == sac) {
+ return info;
+ }
+ }
+ return null;
+ }
+
+ public boolean isMoving( SourceAndConverter sac ) {
+ return getSourceInfo( sac ).isMoving();
+ }
+
+ /**
+ * @deprecated only handled maintaing the moving lists, now a no-op
+ */
+ @Deprecated
+ public void wrapUp()
+ {
+ }
+
+ void addSource( Source src, boolean isMoving )
+ {
+ addSource( src, isMoving, null );
+ }
+
+ void addSource( Source src, boolean isMoving, RealTransform transform )
+ {
+ // find an unused id
+ int id = 0;
+ for( final ConverterSetup cs : converterSetups )
+ {
+ if( id == cs.getSetupId() )
+ id++;
+ }
+ addSource( id, src, isMoving, transform );
+ }
+
+ /**
+ * Adds a {@link Source} with the given id. Does not check that the id is unused.
+ *
+ * @param id the id
+ * @param src the source
+ * @param isMoving if the source is moving
+ * @param transform an optional transformation
+ */
+ void addSource( final int id, Source src, boolean isMoving, RealTransform transform )
+ {
+ BigWarpInit.add( this, src, id, 0, isMoving, transform );
+ final SourceInfo sourceInfo = new SourceInfo( id, isMoving, src.getName(), null, transform );
+ sourceInfo.setSourceAndConverter( sources.get( sources.size() -1 ) );
+ sourceInfos.put( id, sourceInfo);
+ }
+
+ int remove( SourceInfo sourceInfo)
+ {
+ final int idx = sources.indexOf( sourceInfo.getSourceAndConverter() );
+ remove( idx );
+ return idx;
+ }
+
+ void remove( int i )
+ {
+ final SourceAndConverter< T > sac = sources.get( i );
+ sourceInfos.entrySet().stream().filter( it -> it.getValue().getSourceAndConverter() == sac ).map( Map.Entry::getKey ).findFirst().ifPresent(
+ sacId -> { sourceInfos.remove( sacId ); } );
+
+ sources.remove( i );
+ converterSetups.remove( i );
+ }
+
+ public void applyTransformations()
+ {
+ int i = 0;
+ for ( final SourceAndConverter sac : sources )
+ {
+ final SourceInfo info = getSourceInfo( sac );
+ final RealTransform transform = info.getTransform();
+ if ( transform != null )
+ {
+ final SourceAndConverter newSac = inheritConverter(
+ applyFixedTransform( sac.getSpimSource(), transform),
+ sac );
+
+ info.setSourceAndConverter( newSac );
+ sources.set( i, newSac );
+ }
+ i++;
+ }
+ }
+
+ public static < T > SourceAndConverter< T > inheritConverter( final Source src, final SourceAndConverter< T > sac )
+ {
+ if ( sac.asVolatile() == null ) {
+ return new SourceAndConverter< T >( src, sac.getConverter(), null );
+ }
+ else
+ {
+ System.err.println( "Inherit Converter can't handle volatile");
+// inheritConverter( src, sac );
+ return null;
+// return new SourceAndConverter< T >( src, sac.getConverter(), wrapSourceAsTransformed( src, name + "_vol", ndims ) );
+ }
+ }
+
+ /**
+ * Returns a source that applies the given {@link RealTransform} to the given {@link Source}.
+ *
+ * The returned source will be a new instance than unless the transform
+ * is a instance of {@link AffineGet} and source is an instance of {@link TransformedSource}.
+ *
+ * @param the type
+ * @param src the original source
+ * @param transform the transformation
+ * @return the transformed source
+ */
+ public Source applyFixedTransform( final Source src, final RealTransform transform )
+ {
+ RealTransform tform = transform;
+ if( transform.numSourceDimensions() < 3 )
+ {
+ if( transform instanceof InvertibleRealTransform )
+ tform = new InvertibleWrapped2DTransformAs3D( ( InvertibleRealTransform ) transform );
+ else
+ tform = new Wrapped2DTransformAs3D( transform );
+ }
+
+ // TODO using a TransformedSource like the below wasn't working correctly
+ // investigate later
+
+// if( transform instanceof AffineGet )
+// {
+// // if transform is a 2D affine, turn it into a 3D transform
+//
+// // can use TransformedSource
+// final AffineTransform3D affine3d;
+// if( transform instanceof AffineTransform3D )
+// affine3d = ( AffineTransform3D ) transform;
+// else
+// {
+// affine3d = new AffineTransform3D();
+// final AffineGet transformTo3D = BigWarpUtils.toAffine3D((AffineGet)transform);
+// System.out.println( transformTo3D );
+// affine3d.preConcatenate( transformTo3D );
+// System.out.println( affine3d );
+// }
+//
+// // could perhaps try to be clever if its a warped source (?), maybe later
+// TransformedSource tsrc;
+// if ( src instanceof TransformedSource )
+// {
+// tsrc = ( TransformedSource ) ( src );
+// }
+// else
+// {
+// tsrc = new TransformedSource( src );
+// }
+// tsrc.setFixedTransform( affine3d );
+// return ( Source< T > ) tsrc;
+// }
+// else
+// {
+// // need to use WarpedSource
+// final WarpedSource wsrc = new WarpedSource( src, src.getName() );
+// wsrc.updateTransform( tform );
+// wsrc.setIsTransformed( true );
+// return ( Source< T > ) wsrc;
+// }
+
+
+ if( transform instanceof AffineGet )
+ {
+ // if transform is a 2D affine, turn it into a 3D transform
+
+ // can use TransformedSource
+ final AffineTransform3D affine3d;
+ if( transform instanceof AffineTransform3D )
+ affine3d = ( AffineTransform3D ) transform;
+ else
+ {
+ affine3d = new AffineTransform3D();
+ final AffineGet transformTo3D = BigWarpUtils.toAffine3D((AffineGet)transform);
+ affine3d.preConcatenate( transformTo3D );
+ }
+ }
+
+ // need to use WarpedSource
+ final WarpedSource wsrc = new WarpedSource( src, src.getName() );
+ wsrc.updateTransform( tform );
+ wsrc.setIsTransformed( true );
+ return ( Source< T > ) wsrc;
+ }
+
+ /**
+ * Updates the moving sources' transformation with the transform currently
+ * being edited by BigWarp.
+ *
+ * @param transform the transformation
+ */
+ public void updateEditableTransformation( RealTransform transform )
+ {
+ for ( final SourceInfo sourceInfo : sourceInfos.values() )
+ {
+ // could be extra careful and ensure the source is a WarpedSource, but hopefully not necessary
+ if ( sourceInfo.isMoving() )
+ {
+ final SourceAndConverter< ? > sac = sourceInfo.getSourceAndConverter();
+ final WarpedSource< ? > wsrc = ( WarpedSource< ? > ) sac.getSpimSource();
+ wsrc.updateTransform( transform );
+ if ( sac.asVolatile() != null )
+ ( ( WarpedSource< ? > ) sourceInfo.getSourceAndConverter().asVolatile().getSpimSource() ).updateTransform( transform );
+
+ wsrc.updateTransform( transform );
+
+ /*
+ * There was a time when I had a single WarpedSource manage a RealTransformSequence
+ * instead of a WarpedSource wrapping a different WarpedSource as I'm doing now.
+ *
+ * But I decided against having a single source because warped sources can toggle their transforms.
+ * That toggling makes sense for the editable transform, but the fixex should be "on"
+ * always, and therefore be handled by either a TransformedSource or a different
+ * WarpedSource instance.
+ */
+ }
+ }
+ }
+
+ public void transferChannelSettings( final BigWarpViewerFrame viewer )
+ {
+ final SynchronizedViewerState state = viewer.getViewerPanel().state();
+ final ConverterSetups setups = viewer.getConverterSetups();
+
+ for( final Entry< Integer, SourceInfo > infoEntry : sourceInfos.entrySet() )
+ {
+ final int id = infoEntry.getKey();
+ final SourceInfo info = infoEntry.getValue();
+ final SourceAndConverter< ? > sac = info.getSourceAndConverter();
+ final ConverterSetup cs = setups.getConverterSetup( sac );
+
+ if ( info.getColorSettings() == null )
+ {
+ final int timepoint = state.getCurrentTimepoint();
+ final Bounds bounds = InitializeViewerState.estimateSourceRange( sac.getSpimSource(), timepoint, 0.001, 0.999 );
+ if( cs != null )
+ cs.setDisplayRange( bounds.getMinBound(), bounds.getMaxBound() );
+ }
+ else
+ {
+ info.getColorSettings().updateSetup( cs );
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/bigwarp/BigWarpExporter.java b/src/main/java/bigwarp/BigWarpExporter.java
index 2bd86303..226f8e26 100644
--- a/src/main/java/bigwarp/BigWarpExporter.java
+++ b/src/main/java/bigwarp/BigWarpExporter.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -40,7 +40,6 @@
import bdv.viewer.Interpolation;
import bdv.viewer.Source;
import bdv.viewer.SourceAndConverter;
-import bigwarp.BigWarp.BigWarpData;
import ij.IJ;
import ij.ImagePlus;
import mpicbg.models.AffineModel2D;
@@ -75,24 +74,20 @@ public abstract class BigWarpExporter
{
final protected List< SourceAndConverter< T >> sources;
- private List< ConverterSetup > convSetups;
-
private List< ImagePlus > outputList;
- final protected int[] movingSourceIndexList;
+ protected final BigWarpData bwData;
- final protected int[] targetSourceIndexList;
-
protected AffineTransform3D pixelRenderToPhysical;
-
+
protected AffineTransform3D resolutionTransform;
-
+
protected AffineTransform3D offsetTransform;
-
+
protected Interval outputInterval;
protected Interpolation interp;
-
+
protected boolean isVirtual = false;
protected int nThreads = 1;
@@ -107,7 +102,7 @@ public abstract class BigWarpExporter
public enum ParallelizationPolicy {
SLICE, ITER
- };
+ }
public ParallelizationPolicy policy = ParallelizationPolicy.ITER;
@@ -119,25 +114,75 @@ public enum ParallelizationPolicy {
private String exportPath;
+// public BigWarpExporter(
+// final List< SourceAndConverter< T >> sourcesIn,
+// final List< ConverterSetup > convSetups,
+// final int[] movingSourceIndexList,
+// final int[] targetSourceIndexList,
+// final Interpolation interp,
+// final ProgressWriter progress )
+// {
+// this.sources = new ArrayList>();
+// this.convSetups = convSetups;
+// for( SourceAndConverter sac : sourcesIn )
+// {
+// Source srcCopy = null;
+// Source src = sac.getSpimSource();
+// if( src instanceof WarpedSource )
+// {
+// WarpedSource ws = (WarpedSource)( sac.getSpimSource() );
+// WarpedSource wsCopy = new WarpedSource<>( ws.getWrappedSource(), ws.getName() ) ;
+//
+// if( ws.getTransform() != null )
+// {
+// wsCopy.updateTransform( ws.getTransform().copy() );
+// wsCopy.setIsTransformed( true );
+// }
+// srcCopy = wsCopy;
+// }
+// else
+// srcCopy = src;
+//
+// SourceAndConverter copy = new SourceAndConverter<>( srcCopy, sac.getConverter() );
+// sources.add( copy );
+// }
+//
+// this.movingSourceIndexList = movingSourceIndexList;
+// this.targetSourceIndexList = targetSourceIndexList;
+//
+// if( progress == null )
+// this.progress = new ProgressWriterConsole();
+// else
+// this.progress = progress;
+//
+// this.setInterp( interp );
+//
+// pixelRenderToPhysical = new AffineTransform3D();
+// resolutionTransform = new AffineTransform3D();
+// offsetTransform = new AffineTransform3D();
+//
+// try {
+// unit = sources.get( targetSourceIndexList[ 0 ] ).getSpimSource().getVoxelDimensions().unit();
+// } catch( Exception e ) {}
+// }
+
public BigWarpExporter(
- final List< SourceAndConverter< T >> sourcesIn,
+ BigWarpData bwData,
final List< ConverterSetup > convSetups,
- final int[] movingSourceIndexList,
- final int[] targetSourceIndexList,
final Interpolation interp,
final ProgressWriter progress )
{
+ this.bwData = bwData;
this.sources = new ArrayList>();
- this.convSetups = convSetups;
- for( SourceAndConverter sac : sourcesIn )
+ for( final SourceAndConverter sac : bwData.sources )
{
Source srcCopy = null;
- Source src = sac.getSpimSource();
+ final Source src = sac.getSpimSource();
if( src instanceof WarpedSource )
{
- WarpedSource ws = (WarpedSource)( sac.getSpimSource() );
- WarpedSource wsCopy = new WarpedSource<>( ws.getWrappedSource(), ws.getName() ) ;
-
+ final WarpedSource ws = (WarpedSource)( sac.getSpimSource() );
+ final WarpedSource wsCopy = new WarpedSource<>( ws.getWrappedSource(), ws.getName() ) ;
+
if( ws.getTransform() != null )
{
wsCopy.updateTransform( ws.getTransform().copy() );
@@ -147,28 +192,25 @@ public BigWarpExporter(
}
else
srcCopy = src;
-
- SourceAndConverter copy = new SourceAndConverter<>( srcCopy, sac.getConverter() );
+
+ final SourceAndConverter copy = new SourceAndConverter<>( srcCopy, sac.getConverter() );
sources.add( copy );
}
- this.movingSourceIndexList = movingSourceIndexList;
- this.targetSourceIndexList = targetSourceIndexList;
-
if( progress == null )
this.progress = new ProgressWriterConsole();
else
this.progress = progress;
this.setInterp( interp );
-
+
pixelRenderToPhysical = new AffineTransform3D();
resolutionTransform = new AffineTransform3D();
offsetTransform = new AffineTransform3D();
try {
- unit = sources.get( targetSourceIndexList[ 0 ] ).getSpimSource().getVoxelDimensions().unit();
- } catch( Exception e ) {}
+ unit = bwData.getTargetSource( 0 ).getSpimSource().getVoxelDimensions().unit();
+ } catch( final Exception e ) {}
}
public abstract RandomAccessibleInterval exportRai();
@@ -201,7 +243,7 @@ public void setInterp( Interpolation interp )
{
this.interp = interp;
}
-
+
public void setVirtual( final boolean isVirtual )
{
this.isVirtual = isVirtual;
@@ -227,10 +269,10 @@ public void setRenderResolution( double... res )
for( int i = 0; i < res.length; i++ )
resolutionTransform.set( res[ i ], i, i );
}
-
+
/**
* Set the offset of the output field of view in pixels.
- *
+ *
* @param offset the offset in pixel units.
*/
public void setOffset( double... offset )
@@ -241,8 +283,8 @@ public void setOffset( double... offset )
/**
* Generate the transform from output pixel space to physical space.
- *
- * Call this after setRenderResolution and setOffset.
+ *
+ * Call this after setRenderResolution and setOffset.
*/
public void buildTotalRenderTransform()
{
@@ -261,13 +303,13 @@ public RandomAccessibleInterval exportSource( SourceAndConverter src )
final RealRandomAccessible< T > raiRaw = src.getSpimSource().getInterpolatedSource( 0, 0, interp );
// apply the transformations
- final AffineRandomAccessible< T, AffineGet > rai = RealViews.affine(
+ final AffineRandomAccessible< T, AffineGet > rai = RealViews.affine(
raiRaw, pixelRenderToPhysical.inverse() );
- return Views.interval( Views.raster( rai ), outputInterval );
+ return Views.interval( Views.raster( rai ), outputInterval );
}
- public static void updateBrightnessContrast(
+ public static void updateBrightnessContrast(
final ImagePlus imp,
final List convSetups,
final int[] indexList )
@@ -276,9 +318,25 @@ public static void updateBrightnessContrast(
for( int i = 0; i < indexList.length; i++ )
{
- ConverterSetup setup = convSetups.get( indexList[ i ] );
- double rngmin = setup.getDisplayRangeMin();
- double rngmax = setup.getDisplayRangeMax();
+ final ConverterSetup setup = convSetups.get( indexList[ i ] );
+ final double rngmin = setup.getDisplayRangeMin();
+ final double rngmax = setup.getDisplayRangeMax();
+
+ imp.setC( i + 1 ); // ImagePlus.setC is one-indexed
+ imp.setDisplayRange( rngmin, rngmax );
+ imp.updateAndDraw();
+ }
+ }
+
+ public static void updateBrightnessContrast(
+ final ImagePlus imp,
+ final List convSetups)
+ {
+ for( int i = 0; i < convSetups.size(); i++ )
+ {
+ final ConverterSetup setup = convSetups.get( i );
+ final double rngmin = setup.getDisplayRangeMin();
+ final double rngmax = setup.getDisplayRangeMax();
imp.setC( i + 1 ); // ImagePlus.setC is one-indexed
imp.setDisplayRange( rngmin, rngmax );
@@ -286,7 +344,7 @@ public static void updateBrightnessContrast(
}
}
- public static void updateBrightnessContrast(
+ public static void updateBrightnessContrast(
final ImagePlus imp,
final BigWarpData bwdata,
final int[] indexList )
@@ -295,9 +353,9 @@ public static void updateBrightnessContrast(
for( int i = 0; i < indexList.length; i++ )
{
- ConverterSetup setup = bwdata.converterSetups.get( indexList[ i ] );
- double rngmin = setup.getDisplayRangeMin();
- double rngmax = setup.getDisplayRangeMax();
+ final ConverterSetup setup = bwdata.converterSetups.get( indexList[ i ] );
+ final double rngmin = setup.getDisplayRangeMin();
+ final double rngmax = setup.getDisplayRangeMax();
imp.setC( i + 1 ); // ImagePlus.setC is one-indexed
imp.setDisplayRange( rngmin, rngmax );
@@ -307,32 +365,32 @@ public static void updateBrightnessContrast(
public FinalInterval destinationIntervalFromLandmarks( ArrayList pts, boolean isMoving )
{
- int nd = pts.get( 0 ).length;
- long[] min = new long[ nd ];
- long[] max = new long[ nd ];
+ final int nd = pts.get( 0 ).length;
+ final long[] min = new long[ nd ];
+ final long[] max = new long[ nd ];
Arrays.fill( min, Long.MAX_VALUE );
Arrays.fill( max, Long.MIN_VALUE );
- for( Double[] pt : pts )
+ for( final Double[] pt : pts )
{
for( int d = 0; d < nd; d++ )
{
if( pt[ d ] > max [ d ] )
max[ d ] = (long)Math.ceil( pt[ d ]);
-
+
if( pt[ d ] < min [ d ] )
min[ d ] = (long)Math.floor( pt[ d ]);
}
}
return new FinalInterval( min, max );
}
-
+
public static FinalInterval getSubInterval( Interval interval, int d, long start, long end )
{
- int nd = interval.numDimensions();
- long[] min = new long[ nd ];
- long[] max = new long[ nd ];
+ final int nd = interval.numDimensions();
+ final long[] min = new long[ nd ];
+ final long[] max = new long[ nd ];
for( int i = 0; i < nd; i++ )
{
if( i == d )
@@ -349,20 +407,20 @@ public static FinalInterval getSubInterval( Interval interval, int d, long start
return new FinalInterval( min, max );
}
- public < T extends NumericType > RandomAccessibleInterval copyToImageStack(
+ public < T extends NumericType > RandomAccessibleInterval copyToImageStack(
final RandomAccessible< T > raible,
final Interval itvl,
final ImgFactory factory,
final int nThreads )
{
- Img< T > target = factory.create( itvl );
+ final Img< T > target = factory.create( itvl );
if( policy == ParallelizationPolicy.ITER )
return copyToImageStackIterOrder( raible, itvl, target, nThreads, progress );
else
return copyToImageStackBySlice( raible, itvl, target, nThreads, progress );
}
- public static < T extends NumericType > RandomAccessibleInterval copyToImageStackBySlice(
+ public static < T extends NumericType > RandomAccessibleInterval copyToImageStackBySlice(
final RandomAccessible< T > raible,
final Interval itvl,
final ImgFactory factory,
@@ -370,11 +428,11 @@ public static < T extends NumericType > RandomAccessibleInterval copyToIma
final ProgressWriter progress )
{
// create the image plus image
- Img< T > target = factory.create( itvl );
+ final Img< T > target = factory.create( itvl );
return copyToImageStackBySlice( raible, itvl, target, nThreads, progress );
}
- public static < T extends NumericType > RandomAccessibleInterval copyToImageStackBySlice(
+ public static < T extends NumericType > RandomAccessibleInterval copyToImageStackBySlice(
final RandomAccessible< T > ra,
final Interval itvl,
final RandomAccessibleInterval target,
@@ -382,10 +440,10 @@ public static < T extends NumericType > RandomAccessibleInterval copyToIma
final ProgressWriter progress )
{
// TODO I wish I didn't have to do this inside this method
- MixedTransformView< T > raible = Views.permute( ra, 2, 3 );
+ final MixedTransformView< T > raible = Views.permute( ra, 2, 3 );
// what dimension should we split across?
- int nd = raible.numDimensions();
+ final int nd = raible.numDimensions();
int tmp = nd - 1;
while( tmp >= 0 )
{
@@ -397,8 +455,8 @@ public static < T extends NumericType > RandomAccessibleInterval copyToIma
final int dim2split = tmp;
final long[] splitPoints = new long[ nThreads + 1 ];
- long N = target.dimension( dim2split );
- long del = ( long )( N / nThreads );
+ final long N = target.dimension( dim2split );
+ final long del = ( long )( N / nThreads );
splitPoints[ 0 ] = 0;
splitPoints[ nThreads ] = target.dimension( dim2split );
for( int i = 1; i < nThreads; i++ )
@@ -406,9 +464,9 @@ public static < T extends NumericType > RandomAccessibleInterval copyToIma
splitPoints[ i ] = splitPoints[ i - 1 ] + del;
}
- ExecutorService threadPool = Executors.newFixedThreadPool( nThreads );
+ final ExecutorService threadPool = Executors.newFixedThreadPool( nThreads );
- LinkedList> jobs = new LinkedList>();
+ final LinkedList> jobs = new LinkedList>();
for( int i = 0; i < nThreads; i++ )
{
final long start = splitPoints[ i ];
@@ -416,13 +474,14 @@ public static < T extends NumericType > RandomAccessibleInterval copyToIma
jobs.add( new Callable()
{
+ @Override
public Boolean call()
{
try
{
final FinalInterval subItvl = getSubInterval( target, dim2split, start, end );
final IntervalView< T > subTgt = Views.interval( target, subItvl );
- long N = Intervals.numElements(subTgt);
+ final long N = Intervals.numElements(subTgt);
final Cursor< T > c = subTgt.cursor();
final RandomAccess< T > ra = raible.randomAccess();
long j = 0;
@@ -434,14 +493,14 @@ public Boolean call()
if( start == 0 && j % 100000 == 0 )
{
- double ratio = 1.0 * j / N;
- progress.setProgress( ratio );
+ final double ratio = 1.0 * j / N;
+ progress.setProgress( ratio );
}
j++;
}
return true;
}
- catch( Exception e )
+ catch( final Exception e )
{
e.printStackTrace();
}
@@ -455,7 +514,7 @@ public Boolean call()
threadPool.shutdown(); // wait for all jobs to finish
}
- catch ( InterruptedException e1 )
+ catch ( final InterruptedException e1 )
{
e1.printStackTrace();
}
@@ -464,7 +523,7 @@ public Boolean call()
return target;
}
- public static < T extends NumericType > RandomAccessibleInterval copyToImageStackIterOrder(
+ public static < T extends NumericType > RandomAccessibleInterval copyToImageStackIterOrder(
final RandomAccessible< T > raible,
final Interval itvl,
final ImgFactory factory,
@@ -472,11 +531,11 @@ public static < T extends NumericType > RandomAccessibleInterval copyToIma
final ProgressWriter progress )
{
// create the image plus image
- Img< T > target = factory.create( itvl );
+ final Img< T > target = factory.create( itvl );
return copyToImageStackIterOrder( raible, itvl, target, nThreads, progress );
}
- public static < T extends NumericType > RandomAccessibleInterval copyToImageStackIterOrder(
+ public static < T extends NumericType > RandomAccessibleInterval copyToImageStackIterOrder(
final RandomAccessible< T > ra,
final Interval itvl,
final RandomAccessibleInterval target,
@@ -486,25 +545,26 @@ public static < T extends NumericType > RandomAccessibleInterval copyToIma
progress.setProgress(0.0);
// TODO I wish I didn't have to do this inside this method..
// Maybe I don't have to, and should do it where I call this instead?
- MixedTransformView< T > raible = Views.permute( ra, 2, 3 );
+ final MixedTransformView< T > raible = Views.permute( ra, 2, 3 );
- ExecutorService threadPool = Executors.newFixedThreadPool( nThreads );
+ final ExecutorService threadPool = Executors.newFixedThreadPool( nThreads );
- LinkedList> jobs = new LinkedList>();
+ final LinkedList> jobs = new LinkedList>();
for( int i = 0; i < nThreads; i++ )
{
final int offset = i;
jobs.add( new Callable()
{
+ @Override
public Boolean call()
{
try
{
- IterableInterval it = Views.flatIterable( target );
+ final IterableInterval it = Views.flatIterable( target );
final RandomAccess< T > access = raible.randomAccess();
- long N = it.size();
+ final long N = it.size();
final Cursor< T > c = it.cursor();
c.jumpFwd( 1 + offset );
for( long j = offset; j < N; j += nThreads )
@@ -512,17 +572,17 @@ public Boolean call()
access.setPosition( c );
c.get().set( access.get() );
c.jumpFwd( nThreads );
-
+
if( offset == 0 && j % (nThreads * 100000) == 0 )
{
- double ratio = 1.0 * j / N;
- progress.setProgress( ratio );
+ final double ratio = 1.0 * j / N;
+ progress.setProgress( ratio );
}
}
return true;
}
- catch( Exception e )
+ catch( final Exception e )
{
e.printStackTrace();
}
@@ -536,7 +596,7 @@ public Boolean call()
threadPool.shutdown(); // wait for all jobs to finish
}
- catch ( InterruptedException e1 )
+ catch ( final InterruptedException e1 )
{
e1.printStackTrace();
}
@@ -544,80 +604,80 @@ public Boolean call()
progress.setProgress(1.0);
return target;
}
-
+
public static FinalInterval transformRealInterval( RealTransform xfm, RealInterval interval )
{
- int nd = interval.numDimensions();
- double[] pt = new double[ nd ];
- double[] ptxfm = new double[ nd ];
+ final int nd = interval.numDimensions();
+ final double[] pt = new double[ nd ];
+ final double[] ptxfm = new double[ nd ];
- long[] min = new long[ nd ];
- long[] max = new long[ nd ];
+ final long[] min = new long[ nd ];
+ final long[] max = new long[ nd ];
- // transform min
+ // transform min
for( int d = 0; d < nd; d++ )
pt[ d ] = interval.realMin( d );
-
+
xfm.apply( pt, ptxfm );
copyToLongFloor( ptxfm, min );
// transform max
-
+
for( int d = 0; d < nd; d++ )
{
pt[ d ] = interval.realMax( d );
}
-
+
xfm.apply( pt, ptxfm );
copyToLongCeil( ptxfm, max );
-
+
return new FinalInterval( min, max );
}
-
+
public static FinalInterval transformIntervalMinMax( RealTransform xfm, Interval interval )
{
- int nd = interval.numDimensions();
- double[] pt = new double[ nd ];
- double[] ptxfm = new double[ nd ];
+ final int nd = interval.numDimensions();
+ final double[] pt = new double[ nd ];
+ final double[] ptxfm = new double[ nd ];
- long[] min = new long[ nd ];
- long[] max = new long[ nd ];
+ final long[] min = new long[ nd ];
+ final long[] max = new long[ nd ];
- // transform min
+ // transform min
for( int d = 0; d < nd; d++ )
pt[ d ] = interval.min( d );
-
+
xfm.apply( pt, ptxfm );
copyToLongFloor( ptxfm, min );
// transform max
-
+
for( int d = 0; d < nd; d++ )
{
pt[ d ] = interval.max( d );
}
-
+
xfm.apply( pt, ptxfm );
copyToLongCeil( ptxfm, max );
-
+
return new FinalInterval( min, max );
}
/**
* Only works for 2D or 3D.
- *
+ *
* @param affine variable in which to store the result
- * @param xfm the transform
+ * @param xfm the transform
* @param interval the interval
*/
public static void estimateAffineFromCorners( AffineTransform3D affine, RealTransform xfm, Interval interval )
{
- if( xfm == null )
+ if( xfm == null )
return;
- int nd = interval.numDimensions();
+ final int nd = interval.numDimensions();
int N;
Model model;
if ( nd == 2 )
@@ -630,21 +690,21 @@ public static void estimateAffineFromCorners( AffineTransform3D affine, RealTran
N = 8;
model = new AffineModel3D();
}
-
- double[][] mvgPts = new double[ nd ][ N ];
- double[][] tgtPts = new double[ nd ][ N ];
- double[] w = new double[ N ];
+ final double[][] mvgPts = new double[ nd ][ N ];
+ final double[][] tgtPts = new double[ nd ][ N ];
+
+ final double[] w = new double[ N ];
Arrays.fill( w, 1.0 );
- double[] pt = new double[ nd ];
- double[] ptxfm = new double[ nd ];
+ final double[] pt = new double[ nd ];
+ final double[] ptxfm = new double[ nd ];
- long[] unitInterval = new long[ nd ];
+ final long[] unitInterval = new long[ nd ];
Arrays.fill( unitInterval, 2 );
-
+
int i = 0;
- IntervalIterator it = new IntervalIterator( unitInterval );
+ final IntervalIterator it = new IntervalIterator( unitInterval );
while( it.hasNext() )
{
it.fwd();
@@ -663,7 +723,7 @@ public static void estimateAffineFromCorners( AffineTransform3D affine, RealTran
mvgPts[ d ][ i ] = pt[ d ];
tgtPts[ d ][ i ] = ptxfm[ d ];
}
-
+
i++;
}
@@ -671,46 +731,46 @@ public static void estimateAffineFromCorners( AffineTransform3D affine, RealTran
{
model.fit( mvgPts, tgtPts, w );
}
- catch ( Exception e )
+ catch ( final Exception e )
{
affine.identity();
return;
}
-
+
if ( nd == 2 )
{
- double[] mat = new double[ 6 ];
+ final double[] mat = new double[ 6 ];
((AffineModel2D)model).toArray( mat );
affine.set( mat );
}
else
{
- double[] mat = new double[ 12 ];
+ final double[] mat = new double[ 12 ];
((AffineModel3D)model).getMatrix( mat );
affine.set( mat );
}
}
-
+
public static FinalInterval estimateBounds( RealTransform xfm, Interval interval )
{
if( xfm == null )
- return new FinalInterval(
+ return new FinalInterval(
Intervals.minAsLongArray(interval),
Intervals.maxAsLongArray(interval) );
- int nd = interval.numDimensions();
- double[] pt = new double[ nd ];
- double[] ptxfm = new double[ nd ];
+ final int nd = interval.numDimensions();
+ final double[] pt = new double[ nd ];
+ final double[] ptxfm = new double[ nd ];
- long[] min = new long[ nd ];
- long[] max = new long[ nd ];
+ final long[] min = new long[ nd ];
+ final long[] max = new long[ nd ];
Arrays.fill( min, Long.MAX_VALUE );
Arrays.fill( max, Long.MIN_VALUE );
- long[] unitInterval = new long[ nd ];
+ final long[] unitInterval = new long[ nd ];
Arrays.fill( unitInterval, 2 );
-
- IntervalIterator it = new IntervalIterator( unitInterval );
+
+ final IntervalIterator it = new IntervalIterator( unitInterval );
while( it.hasNext() )
{
it.fwd();
@@ -726,12 +786,12 @@ public static FinalInterval estimateBounds( RealTransform xfm, Interval interval
for( int d = 0; d < nd; d++ )
{
- long lo = (long)Math.floor( ptxfm[d] );
- long hi = (long)Math.ceil( ptxfm[d] );
-
+ final long lo = (long)Math.floor( ptxfm[d] );
+ final long hi = (long)Math.ceil( ptxfm[d] );
+
if( lo < min[ d ])
min[ d ] = lo;
-
+
if( hi > max[ d ])
max[ d ] = hi;
}
@@ -765,7 +825,7 @@ public ImagePlus exportAsynch( final boolean wait, final boolean show )
{
exportThread.join();
}
- catch ( InterruptedException e )
+ catch ( final InterruptedException e )
{
e.printStackTrace();
}
@@ -808,7 +868,7 @@ public void run()
if (exporter.result != null && exporter.showResult && show )
{
if( !exporter.isRGB() )
- BigWarpExporter.updateBrightnessContrast( exporter.result, exporter.convSetups, exporter.movingSourceIndexList );
+ BigWarpExporter.updateBrightnessContrast( exporter.result, exporter.bwData.getMovingConverterSetups() );
}
@@ -817,7 +877,7 @@ public void run()
try{
IJ.save( exporter.result, exporter.exportPath );
}
- catch( Exception e )
+ catch( final Exception e )
{
IJ.showMessage( "Failed to write : " + exporter.exportPath );
}
@@ -839,17 +899,17 @@ public static BigWarpExporter getExporter(
final Interpolation interp,
final ProgressWriter progressWriter )
{
- int[] movingSourceIndexList = bwData.movingSourceIndices;
- int[] targetSourceIndexList = bwData.targetSourceIndices;
+ final List movingSourceIndexList = bwData.getMovingSourceIndices();
+ //TODO Caleb: Consider a method that just takes a list of all moving sources
if ( BigWarpRealExporter.isTypeListFullyConsistent( transformedSources, movingSourceIndexList ) )
{
- Object baseType = transformedSources.get( movingSourceIndexList[ 0 ] ).getSpimSource().getType();
+ final Object baseType = transformedSources.get( movingSourceIndexList.get( 0 ) ).getSpimSource().getType();
if( baseType instanceof RealType )
- return new BigWarpRealExporter( transformedSources, bwData.converterSetups, movingSourceIndexList, targetSourceIndexList, interp, (RealType)baseType, progressWriter);
+ return new BigWarpRealExporter( bwData, bwData.converterSetups, interp, (RealType)baseType, progressWriter);
else if ( ARGBType.class.isInstance( baseType ) )
{
- return new BigWarpARGBExporter( (List)transformedSources, bwData.converterSetups, movingSourceIndexList, targetSourceIndexList, interp, progressWriter );
+ return new BigWarpARGBExporter( (BigWarpData)bwData, bwData.converterSetups, interp, progressWriter );
}
else
{
diff --git a/src/main/java/bigwarp/BigWarpInit.java b/src/main/java/bigwarp/BigWarpInit.java
index 47b0be1f..13144358 100644
--- a/src/main/java/bigwarp/BigWarpInit.java
+++ b/src/main/java/bigwarp/BigWarpInit.java
@@ -21,12 +21,24 @@
*/
package bigwarp;
+import java.io.File;
import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
import java.util.ArrayList;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
import org.janelia.saalfeldlab.n5.N5Reader;
+import org.janelia.saalfeldlab.n5.N5URI;
+import org.janelia.saalfeldlab.n5.hdf5.N5HDF5Reader;
import org.janelia.saalfeldlab.n5.imglib2.N5Utils;
+import org.janelia.saalfeldlab.n5.metadata.N5ViewerMultichannelMetadata;
import org.janelia.saalfeldlab.n5.metadata.imagej.ImagePlusLegacyMetadataParser;
import org.janelia.saalfeldlab.n5.metadata.imagej.N5ImagePlusMetadata;
import org.janelia.saalfeldlab.n5.universe.N5DatasetDiscoverer;
@@ -42,8 +54,10 @@
import org.janelia.saalfeldlab.n5.universe.metadata.N5ViewerMultiscaleMetadataParser;
import org.janelia.saalfeldlab.n5.universe.metadata.SpatialMetadata;
import org.janelia.saalfeldlab.n5.universe.metadata.canonical.CanonicalMetadataParser;
+import org.janelia.saalfeldlab.n5.zarr.N5ZarrReader;
import bdv.BigDataViewer;
+import bdv.cache.SharedQueue;
import bdv.img.BwRandomAccessibleIntervalSource;
import bdv.img.RenamableSource;
import bdv.spimdata.SpimDataMinimal;
@@ -52,13 +66,18 @@
import bdv.tools.brightness.SetupAssignments;
import bdv.tools.transformation.TransformedSource;
import bdv.util.RandomAccessibleIntervalMipmapSource;
+import bdv.util.RandomAccessibleIntervalSource;
+import bdv.util.volatiles.VolatileViews;
import bdv.viewer.Source;
import bdv.viewer.SourceAndConverter;
-import bigwarp.BigWarp.BigWarpData;
import bigwarp.loader.ImagePlusLoader;
import bigwarp.loader.Loader;
import bigwarp.loader.XMLLoader;
+import bigwarp.source.SourceInfo;
+import ij.IJ;
import ij.ImagePlus;
+import ij.io.FileInfo;
+import ij.plugin.FolderOpener;
import mpicbg.spim.data.SpimData;
import mpicbg.spim.data.SpimDataException;
import mpicbg.spim.data.XmlIoSpimData;
@@ -68,23 +87,50 @@
import mpicbg.spim.data.sequence.Angle;
import mpicbg.spim.data.sequence.Channel;
import mpicbg.spim.data.sequence.FinalVoxelDimensions;
+import net.imagej.Dataset;
+import net.imagej.axis.Axes;
+import net.imagej.axis.CalibratedAxis;
import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.cache.img.CachedCellImg;
+import net.imglib2.cache.volatiles.CacheHints;
+import net.imglib2.cache.volatiles.LoadingStrategy;
import net.imglib2.converter.Converter;
import net.imglib2.converter.Converters;
import net.imglib2.display.RealARGBColorConverter;
import net.imglib2.display.ScaledARGBConverter;
import net.imglib2.realtransform.AffineTransform3D;
+import net.imglib2.realtransform.RealTransform;
+import net.imglib2.type.NativeType;
import net.imglib2.type.numeric.ARGBType;
import net.imglib2.type.numeric.NumericType;
import net.imglib2.type.numeric.RealType;
import net.imglib2.type.numeric.integer.UnsignedIntType;
import net.imglib2.type.volatiles.VolatileARGBType;
import net.imglib2.util.Util;
+import net.imglib2.view.IntervalView;
import net.imglib2.view.Views;
public class BigWarpInit
{
+
+ public static final N5MetadataParser[] PARSERS = new N5MetadataParser[]{
+ new N5CosemMetadataParser(),
+ new N5SingleScaleMetadataParser(),
+ new CanonicalMetadataParser(),
+ new ImagePlusLegacyMetadataParser(),
+ new N5GenericSingleScaleMetadataParser()
+ };
+
+ public static final N5MetadataParser[] GROUP_PARSERS = new N5MetadataParser[]{
+// new org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v04.OmeNgffMetadataParser(),
+// new org.janelia.saalfeldlab.n5.universe.metadata.ome.ngff.v03.OmeNgffMetadataParser(), // TODO test later
+ new N5CosemMultiScaleMetadata.CosemMultiScaleParser(),
+ new N5ViewerMultiscaleMetadataParser(),
+ new CanonicalMetadataParser(),
+ new N5ViewerMultichannelMetadata.N5ViewerMultichannelMetadataParser()
+ };
+
private static String createSetupName( final BasicViewSetup setup )
{
if ( setup.hasName() )
@@ -103,139 +149,6 @@ private static String createSetupName( final BasicViewSetup setup )
return name;
}
-// public static void initSetupsARGBTypeRandom( final AbstractSpimData< ? > spimData, final ARGBType type, final List< ConverterSetup > converterSetups, final List< SourceAndConverter< ? > > sources )
-// {
-// if ( spimData.getSequenceDescription().getImgLoader() instanceof WrapBasicImgLoader )
-// {
-// initSetupsARGBTypeNonVolatile( spimData, type, converterSetups, sources );
-// return;
-// }
-//
-// final AbstractSequenceDescription< ?, ?, ? > seq = spimData.getSequenceDescription();
-// for ( final BasicViewSetup setup : seq.getViewSetupsOrdered() )
-// {
-//
-// final int setupId = setup.getId();
-//
-// final String setupName = createSetupName( setup );
-// final VolatileSpimSource< ARGBType, VolatileARGBType > vs = new VolatileSpimSource< ARGBType, VolatileARGBType >( spimData, setupId, setupName );
-// final SpimSource< ARGBType > s = vs.nonVolatile();
-//
-// // Decorate each source with an extra transformation, that can be
-// // edited manually in this viewer.
-// final TransformedSource< VolatileARGBType > tvs = new TransformedSource< VolatileARGBType >( vs );
-// final TransformedSource< ARGBType > ts = new TransformedSource< ARGBType >( s, tvs );
-//
-// final SourceAndConverter< ARGBType > soc;
-// final SourceAndConverter< VolatileARGBType > vsoc;
-// final ConverterSetup converterSetup;
-//
-// final ARGBtoRandomARGBColorConverter.ToGray converter = new ARGBtoRandomARGBColorConverter.ToGray( 0, 255 );
-// final ARGBtoRandomARGBColorConverter.VolatileToGray vconverter = new ARGBtoRandomARGBColorConverter.VolatileToGray( 0, 255 );
-//
-// converterSetup = new RealARGBColorConverterSetup( setupId, converter, vconverter );
-// vsoc = new SourceAndConverter< VolatileARGBType >( tvs, vconverter );
-// soc = new SourceAndConverter< ARGBType >( ts, converter, vsoc );
-//
-// converterSetups.add( converterSetup );
-//
-// sources.add( soc );
-// }
-// }
-
-// public static void initSetupsARGBType( final AbstractSpimData< ? > spimData, final ARGBType type, final List< ConverterSetup > converterSetups, final List< SourceAndConverter< ? > > sources )
-// {
-// initSetupsARGBType( spimData, type, converterSetups, sources, true );
-// }
-
-// public static void initSetupsARGBType( final AbstractSpimData< ? > spimData, final ARGBType type, final List< ConverterSetup > converterSetups, final List< SourceAndConverter< ? > > sources, final boolean grayConversion )
-// {
-// if ( spimData.getSequenceDescription().getImgLoader() instanceof WrapBasicImgLoader )
-// {
-// initSetupsARGBTypeNonVolatile( spimData, type, converterSetups, sources );
-// return;
-// }
-//
-// final AbstractSequenceDescription< ?, ?, ? > seq = spimData.getSequenceDescription();
-// for ( final BasicViewSetup setup : seq.getViewSetupsOrdered() )
-// {
-//
-// final int setupId = setup.getId();
-//
-// final String setupName = createSetupName( setup );
-// final VolatileSpimSource< ARGBType, VolatileARGBType > vs = new VolatileSpimSource< ARGBType, VolatileARGBType >( spimData, setupId, setupName );
-// final SpimSource< ARGBType > s = vs.nonVolatile();
-//
-// // Decorate each source with an extra transformation, that can be
-// // edited manually in this viewer.
-// final TransformedSource< VolatileARGBType > tvs = new TransformedSource< VolatileARGBType >( vs );
-// final TransformedSource< ARGBType > ts = new TransformedSource< ARGBType >( s, tvs );
-//
-// final SourceAndConverter< ARGBType > soc;
-// final SourceAndConverter< VolatileARGBType > vsoc;
-// final ConverterSetup converterSetup;
-// if ( grayConversion )
-// {
-// final ARGBARGBColorConverter.ToGray converter = new ARGBARGBColorConverter.ToGray( 0, 255 );
-// final ARGBARGBColorConverter.VolatileToGray vconverter = new ARGBARGBColorConverter.VolatileToGray( 0, 255 );
-//// converter = new ScaledARGBConverter.ARGB( 0, 255 );
-//// vconverter = new ScaledARGBConverter.VolatileARGB( 0, 255 );
-//
-// converterSetup = new RealARGBColorConverterSetup( setupId, converter, vconverter );
-// vsoc = new SourceAndConverter< VolatileARGBType >( tvs, vconverter );
-// soc = new SourceAndConverter< ARGBType >( ts, converter, vsoc );
-//
-// converterSetups.add( converterSetup );
-// }
-// else
-// {
-// final Converter< VolatileARGBType, ARGBType > vconverter = new Converter< VolatileARGBType, ARGBType >()
-// {
-// @Override
-// public void convert( final VolatileARGBType input, final ARGBType output )
-// {
-// output.set( input.get() );
-// }
-// };
-// final Converter< ARGBType, ARGBType > converter = new Converter< ARGBType, ARGBType >()
-// {
-// @Override
-// public void convert( final ARGBType input, final ARGBType output )
-// {
-// output.set( input.get() );
-// }
-// };
-//
-// vsoc = new SourceAndConverter< VolatileARGBType >( tvs, vconverter );
-// soc = new SourceAndConverter< ARGBType >( ts, converter, vsoc );
-//
-// }
-//
-// sources.add( soc );
-// }
-// }
-
-// private static void initSetupsARGBTypeNonVolatile( final AbstractSpimData< ? > spimData, final ARGBType type, final List< ConverterSetup > converterSetups, final List< SourceAndConverter< ? > > sources )
-// {
-// final AbstractSequenceDescription< ?, ?, ? > seq = spimData.getSequenceDescription();
-// for ( final BasicViewSetup setup : seq.getViewSetupsOrdered() )
-// {
-// final ScaledARGBConverter.ARGB converter = new ScaledARGBConverter.ARGB( 0, 255 );
-//
-// final int setupId = setup.getId();
-// final String setupName = createSetupName( setup );
-// final SpimSource< ARGBType > s = new SpimSource< ARGBType >( spimData, setupId, setupName );
-//
-// // Decorate each source with an extra transformation, that can be
-// // edited manually in this viewer.
-// final TransformedSource< ARGBType > ts = new TransformedSource< ARGBType >( s );
-// final SourceAndConverter< ARGBType > soc = new SourceAndConverter< ARGBType >( ts, converter );
-//
-// sources.add( soc );
-// converterSetups.add( new RealARGBColorConverterSetup( setupId, converter ) );
-// }
-// }
-
public static void initSetups( final AbstractSpimData< ? > spimData, final List< ConverterSetup > converterSetups, final List< SourceAndConverter< ? > > sources )
{
BigDataViewer.initSetups( spimData, converterSetups, sources );
@@ -302,104 +215,453 @@ public static < T extends RealType< T > > void initSourceReal( final Source< T >
public static BigWarpData< ? > createBigWarpData( final Source< ? >[] movingSourceList, final Source< ? >[] fixedSourceList, final String[] names )
{
final BigWarpData data = initData();
-
+ int nameIdx = 0;
int setupId = 0;
// moving
for ( final Source< ? > mvgSource : movingSourceList )
{
- add( data, mvgSource, setupId++, 1, true );
+ add( data, mvgSource, setupId, 1, true );
+ final SourceAndConverter< ? > addedSource = ( ( BigWarpData< ? > ) data ).sources.get( data.sources.size() - 1 );
+ final SourceInfo info = new SourceInfo( setupId, true, names[ nameIdx++ ] );
+ info.setSourceAndConverter( addedSource );
+ data.sourceInfos.put( setupId++, info );
}
// target
for ( final Source< ? > fxdSource : fixedSourceList )
{
add( data, fxdSource, setupId, 1, false );
+ final SourceAndConverter< ? > addedSource = ( ( BigWarpData< ? > ) data ).sources.get( data.sources.size() - 1 );
+ final SourceInfo info = new SourceInfo( setupId, false, names[ nameIdx++ ] );
+ info.setSourceAndConverter( addedSource );
+ data.sourceInfos.put( setupId++, info );
}
data.wrapUp();
- if ( names != null ) { return new BigWarpData( wrapSourcesAsRenamable( data.sources, names ), data.converterSetups, data.cache, data.movingSourceIndices, data.targetSourceIndices ); }
+ if ( names != null )
+ {
+ final ArrayList wrappedSources = wrapSourcesAsRenamable( data.sources, names );
+ final AtomicInteger sourceInfoIdx = new AtomicInteger();
+
+ final BigWarpData< ? > typedData = data;
+ typedData.sourceInfos.forEach( ( id, info ) -> {
+ info.setSourceAndConverter( typedData.sources.get( sourceInfoIdx.getAndIncrement() ) );
+ } );
+
+ return new BigWarpData( wrappedSources, data.converterSetups, data.cache );
+
+ }
return data;
}
- @SuppressWarnings( { "rawtypes" } )
- public static < T > int add( final BigWarpData bwdata, final ImagePlus ip, int setupId, final int numTimepoints, final boolean isMoving )
+ /**
+ * Initialize BigWarp.
+ *
+ * @return the number of sources
+ *
+ * @deprecated Use {@code createSources(BigWarpData,ImagePlus,int,int,boolean)} instead, and pass output to
+ * {@code add(BigWarpData,LinkedHashMap)}
+ */
+ @Deprecated
+ public static < T > int add( BigWarpData< T > bwdata, ImagePlus ip, int setupId, int numTimepoints, boolean isMoving )
+ {
+ final LinkedHashMap< Source< T >, SourceInfo > sources = createSources( bwdata, ip, setupId, numTimepoints, isMoving );
+ add( bwdata, sources );
+ return sources.size();
+ }
+
+ public static < T > LinkedHashMap< Source< T >, SourceInfo > createSources( BigWarpData< T > bwdata, ImagePlus ip, int setupId, int numTimepoints, boolean isMoving )
{
final ImagePlusLoader loader = new ImagePlusLoader( ip );
final SpimDataMinimal[] dataList = loader.loadAll( setupId );
+
+ final LinkedHashMap< Source< T >, SourceInfo > sourceInfoMap = new LinkedHashMap<>();
for ( final SpimDataMinimal data : dataList )
{
- add( bwdata, data, setupId, numTimepoints, isMoving );
- setupId++;
+ final LinkedHashMap< Source< T >, SourceInfo > map = createSources( bwdata, data, setupId, isMoving );
+ sourceInfoMap.putAll( map );
+ setupId += map.values().stream().map( SourceInfo::getId ).max( Integer::compare ).orElseGet( () -> 0 );
+ }
+
+ sourceInfoMap.forEach( ( sac, state ) -> {
+ loader.update( state );
+ state.setUriSupplier( () -> {
+ final FileInfo originalFileInfo = ip.getOriginalFileInfo();
+ if ( originalFileInfo != null )
+ {
+ final String url = originalFileInfo.url;
+ if ( url != null && !url.isEmpty() )
+ {
+ return url;
+ }
+ else
+ {
+ return originalFileInfo.getFilePath();
+ }
+ }
+ return null;
+ } );
+ } );
+
+ for ( final Map.Entry< Source< T >, SourceInfo > sourceSourceInfoEntry : sourceInfoMap.entrySet() )
+ {
+ sourceSourceInfoEntry.getValue().setSerializable( true );
+ /* Always break after the first */
+ break;
}
- loader.update(bwdata);
- return loader.numSources();
+ return sourceInfoMap;
}
+ /**
+ * Initialize BigWarp.
+ *
+ * @return a {@link BigWarpData} instance
+ *
+ * @deprecated Use the output from one of the
+ * {{@link #createSources(BigWarpData, String, int, boolean)}}
+ * to call {{@link #add(BigWarpData, LinkedHashMap)}} instead
+ */
+ @Deprecated
+ public static < T > BigWarpData< T > add( BigWarpData< T > bwdata, Source< T > src, int setupId, int numTimepoints, boolean isMoving )
+ {
+ return add( bwdata, src, setupId, numTimepoints, isMoving, null );
+ }
+
+ public static < T > BigWarpData< T > add( BigWarpData< T > bwdata, Source< T > source, SourceInfo sourceInfo )
+ {
+ return add( bwdata, source, sourceInfo );
+ }
+
+ public static < T > BigWarpData< T > add( BigWarpData< T > bwdata, Source< T > source, SourceInfo sourceInfo, RealTransform transform, Supplier transformUriSupplier )
+ {
+ final LinkedHashMap< Source< T >, SourceInfo > sourceToInfo = new LinkedHashMap<>();
+ sourceToInfo.put( source, sourceInfo );
+ return add( bwdata, sourceToInfo, transform, transformUriSupplier );
+ }
+
+ public static < T > BigWarpData< T > add( BigWarpData< T > bwdata, LinkedHashMap< Source< T >, SourceInfo > sources )
+ {
+ add( bwdata, sources, null, null );
+ return bwdata;
+ }
+
+ /**
+ * Initialize BigWarp.
+ *
+ * @return a {@link BigWarpData} instance
+ *
+ * @deprecated Use the output from one of the
+ * {{@code createSources(BigWarpData, String, int, boolean)}}
+ * to call {{@code add(BigWarpData, LinkedHashMap, RealTransform)}}
+ * instead
+ */
@SuppressWarnings( { "unchecked", "rawtypes" } )
- public static < T > BigWarpData< ? > add( final BigWarpData bwdata, final Source< T > src, final int setupId, final int numTimepoints, final boolean isMoving )
+ @Deprecated
+ public static < T > BigWarpData< T > add( BigWarpData bwdata, Source< T > src, int setupId, int numTimepoints, boolean isMoving, RealTransform transform )
{
addSourceToListsGenericType( src, setupId, bwdata.converterSetups, bwdata.sources );
+// bwdata.transforms.add( transform );
+ return bwdata;
+ }
- final int N = bwdata.sources.size();
- if ( isMoving )
- bwdata.movingSourceIndexList.add( N - 1 );
- else
- bwdata.targetSourceIndexList.add( N - 1 );
+ public static < T > BigWarpData< T > add( BigWarpData< T > bwdata, LinkedHashMap< Source< T >, SourceInfo > sources, RealTransform transform, Supplier transformUriSupplier )
+ {
+ sources.forEach( ( source, info ) -> {
+ addSourceToListsGenericType( source, info.getId(), bwdata.converterSetups, bwdata.sources );
+ final SourceAndConverter< T > addedSource = bwdata.sources.get( bwdata.sources.size() - 1 );
+ info.setSourceAndConverter( addedSource );
+ if ( transform != null )
+ {
+ info.setTransform( transform, transformUriSupplier );
+ }
+ bwdata.sourceInfos.put( info.getId(), info );
+ } );
return bwdata;
}
- @SuppressWarnings( { "unchecked", "rawtypes" } )
- public static < T > BigWarpData< ? > add( final BigWarpData bwdata, final AbstractSpimData< ? > data, final int baseId, final int numTimepoints, final boolean isMoving )
+ @SuppressWarnings( { "rawtypes" } )
+ public static < T > LinkedHashMap< Source< T >, SourceInfo > createSources( BigWarpData bwdata, Dataset data, int baseId, final boolean isMoving )
{
- final List> tmpSources = new ArrayList<>();
- final List tmpConverterSetups = new ArrayList<>();
+ boolean first = true;
+ final LinkedHashMap< Source< T >, SourceInfo > sourceInfoMap = new LinkedHashMap<>();
+
+ final AffineTransform3D res = datasetResolution( data );
+ final long nc = data.getChannels();
+ boolean hasZ = false;
+
+ final CalibratedAxis[] axes = new CalibratedAxis[ data.numDimensions() ];
+ data.axes( axes );
+ for (int i = 0; i < data.numDimensions(); i++) {
+ if (axes[i].type().equals(Axes.Z))
+ {
+ hasZ = true;
+ break;
+ }
+ }
+
+ if ( nc > 1 )
+ {
+ int channelIdx = -1;
+ for ( int i = 0; i < data.numDimensions(); i++ )
+ {
+ if ( axes[ i ].type().equals( Axes.CHANNEL ) )
+ {
+ channelIdx = i;
+ break;
+ }
+ }
+
+ for ( int c = 0; c < nc; c++ )
+ {
+ final IntervalView> channelRaw = Views.hyperSlice( data, channelIdx, c );
+ final IntervalView> channel = hasZ ? channelRaw : Views.addDimension( channelRaw, 0, 0 );
+
+ @SuppressWarnings( "unchecked" )
+ final RandomAccessibleIntervalSource source = new RandomAccessibleIntervalSource( channel, Util.getTypeFromInterval( data ), res, data.getName() );
+
+ final SourceInfo info = new SourceInfo( baseId + c, isMoving, data.getName(), () -> data.getSource() );
+ info.setSerializable( first );
+ if ( first )
+ first = false;
+
+ sourceInfoMap.put( source, info );
+ }
+ }
+ else
+ {
+ final RandomAccessibleInterval> img = hasZ ? data : Views.addDimension( data, 0, 0 );
+
+ @SuppressWarnings( "unchecked" )
+ final RandomAccessibleIntervalSource source = new RandomAccessibleIntervalSource( img, Util.getTypeFromInterval( data ), res, data.getName() );
+
+ final SourceInfo info = new SourceInfo( baseId, isMoving, data.getName(), () -> data.getSource() );
+ info.setSerializable( true );
+ sourceInfoMap.put( source, info );
+ }
+
+ return sourceInfoMap;
+ }
+
+ public static AffineTransform3D datasetResolution( Dataset data )
+ {
+ final AffineTransform3D affine = new AffineTransform3D();
+ final CalibratedAxis[] axes = new CalibratedAxis[ data.numDimensions() ];
+ data.axes( axes );
+
+ for ( int d = 0; d < data.numDimensions(); d++ )
+ {
+ if ( axes[ d ].type().equals( Axes.X ) )
+ affine.set( axes[ d ].calibratedValue( 1 ), 0, 0 );
+ else if ( axes[ d ].type().equals( Axes.Y ) )
+ affine.set( axes[ d ].calibratedValue( 1 ), 1, 1 );
+ else if ( axes[ d ].type().equals( Axes.Z ) )
+ affine.set( axes[ d ].calibratedValue( 1 ), 2, 2 );
+ }
+ return affine;
+ }
+
+ @SuppressWarnings( { "rawtypes" } )
+ public static < T > LinkedHashMap< Source< T >, SourceInfo > createSources( BigWarpData bwdata, AbstractSpimData< ? > data, int baseId, final boolean isMoving )
+ {
+ final List< SourceAndConverter< ? > > tmpSources = new ArrayList<>();
+ final List< ConverterSetup > tmpConverterSetups = new ArrayList<>();
initSetups( data, tmpConverterSetups, tmpSources );
+ final LinkedHashMap< Source< T >, SourceInfo > sourceInfoMap = new LinkedHashMap<>();
int setupId = baseId;
- for( final SourceAndConverter sac : tmpSources )
- add( bwdata, sac.getSpimSource(), setupId++, numTimepoints, isMoving );
-
-// int N = bwdata.sources.size();
-// final ArrayList idxList;
-// if ( isMoving )
-// idxList = bwdata.movingSourceIndexList;
-// else
-// idxList = bwdata.targetSourceIndexList;
-//
-// for( int i = startSize; i < N; i++ )
-// idxList.add( i );
-//
- return bwdata;
+ for ( final SourceAndConverter sac : tmpSources )
+ {
+ final Source< T > source = sac.getSpimSource();
+ sourceInfoMap.put( source, new SourceInfo( setupId++, isMoving, source.getName() ) );
+ }
+
+ return sourceInfoMap;
+ }
+
+ public static < T > LinkedHashMap< Source< T >, SourceInfo > createSources( BigWarpData bwdata, Source< T > src, int baseId, final boolean isMoving )
+ {
+ final LinkedHashMap< Source< T >, SourceInfo > sourceInfoMap = new LinkedHashMap<>();
+ sourceInfoMap.put( src, new SourceInfo( baseId, isMoving, src.getName() ) );
+ return sourceInfoMap;
+ }
+
+ private static String schemeSpecificPartWithoutQuery( URI uri )
+ {
+ return uri.getSchemeSpecificPart().replaceAll( "\\?" + uri.getQuery(), "" ).replaceAll( "//", "" );
}
- public static SpimData addToData( final BigWarpData bwdata,
- final boolean isMoving, final int setupId, final String rootPath, final String dataset )
+ public static < T > LinkedHashMap< Source< T >, SourceInfo > createSources( final BigWarpData< T > bwData, String uri, int setupId, boolean isMoving ) throws URISyntaxException, IOException, SpimDataException
{
- if( rootPath.endsWith( "xml" ))
+ final SharedQueue sharedQueue = new SharedQueue(Math.max(1, Runtime.getRuntime().availableProcessors() / 2));
+ final URI encodedUri = N5URI.encodeAsUri( uri );
+ final LinkedHashMap< Source< T >, SourceInfo > sourceStateMap = new LinkedHashMap<>();
+ if ( encodedUri.isOpaque() )
+ {
+ final N5URI n5URL = new N5URI( encodedUri.getSchemeSpecificPart() );
+ final String firstScheme = encodedUri.getScheme().toLowerCase();
+ final N5Reader n5reader;
+ switch ( firstScheme.toLowerCase() )
+ {
+ case "n5":
+ n5reader = new N5Factory().openReader( n5URL.getContainerPath() );
+ break;
+ case "zarr":
+ n5reader = new N5ZarrReader( n5URL.getContainerPath() );
+ break;
+ case "h5":
+ case "hdf5":
+ case "hdf":
+ n5reader = new N5HDF5Reader( n5URL.getContainerPath() );
+ break;
+ default:
+ throw new URISyntaxException( firstScheme, "Unsupported Top Level Protocol" );
+ }
+
+ final Source< T > source = (Source)loadN5Source( n5reader, n5URL.getGroupPath(), sharedQueue );
+ sourceStateMap.put( source, new SourceInfo( setupId, isMoving, n5URL.getGroupPath() ) );
+ }
+ else
+ {
+ final N5URI n5URL = new N5URI( encodedUri );
+ try
+ {
+ final String containerWithoutN5Scheme = n5URL.getContainerPath().replaceFirst( "^n5://", "" );
+ final N5Reader n5reader = new N5Factory().openReader( containerWithoutN5Scheme );
+ final String group = n5URL.getGroupPath();
+ final Source< T > source = (Source)loadN5Source( n5reader, group, sharedQueue );
+
+ if( source != null )
+ sourceStateMap.put( source, new SourceInfo( setupId, isMoving, group ) );
+ }
+ catch ( final Exception ignored )
+ {}
+ if ( sourceStateMap.isEmpty() )
+ {
+ final String containerPath = n5URL.getContainerPath();
+ if ( containerPath.trim().toLowerCase().endsWith( ".xml" ) )
+ {
+ sourceStateMap.putAll( createSources( bwData, isMoving, setupId, containerPath, n5URL.getGroupPath() ) );
+ }
+ else
+ {
+ final ImagePlus ijp;
+ if ( Objects.equals( encodedUri.getScheme(), "imagej" ) )
+ {
+ final String title = n5URL.getContainerPath().replaceAll( "^imagej:(///|//)", "" );
+ IJ.selectWindow( title );
+ ijp = IJ.getImage();
+ }
+ else if ( new File( uri ).isDirectory() )
+ {
+ ijp = FolderOpener.open( uri );
+ }
+ else
+ {
+ ijp = IJ.openImage( uri );
+ }
+ sourceStateMap.putAll( createSources( bwData, ijp, setupId, 0, isMoving ) );
+ }
+ }
+
+ }
+
+ /*
+ * override any already set urls with the uri we used to load this
+ * source.
+ */
+ sourceStateMap.forEach( ( source, state ) -> {
+ state.setUriSupplier( () -> uri );
+ } );
+ for ( final Map.Entry< Source< T >, SourceInfo > sourceSourceInfoEntry : sourceStateMap.entrySet() )
+ {
+ sourceSourceInfoEntry.getValue().setSerializable( true );
+ /* Always break after the first */
+ break;
+ }
+ return sourceStateMap;
+ }
+
+ /**
+ * Initialize BigWarp.
+ *
+ * @return a {@link SpimData} instance
+ *
+ * @deprecated Use output from
+ * {@code createSources(BigWarpData, boolean, int, String, String)} and add with
+ * {@code add(BigWarpData, LinkedHashMap, RealTransform)} instead.
+ */
+ @Deprecated
+ public static < T > SpimData addToData( final BigWarpData< T > bwdata, final boolean isMoving, final int setupId, final String rootPath, final String dataset )
+ {
+ final AtomicReference< SpimData > returnMovingSpimData = new AtomicReference<>();
+ final LinkedHashMap< Source< T >, SourceInfo > sources = createSources( bwdata, isMoving, setupId, rootPath, dataset, returnMovingSpimData );
+ add( bwdata, sources );
+ return returnMovingSpimData.get();
+ }
+
+ public static < T > Map< Source< T >, SourceInfo > createSources( final BigWarpData< T > bwdata, final boolean isMoving, final int setupId, final String rootPath, final String dataset )
+ {
+ return createSources( bwdata, isMoving, setupId, rootPath, dataset, null );
+ }
+
+ private static < T > LinkedHashMap< Source< T >, SourceInfo > createSources( final BigWarpData< T > bwdata, final boolean isMoving, final int setupId, final String rootPath, final String dataset, final AtomicReference< SpimData > returnMovingSpimData )
+ {
+ final SharedQueue sharedQueue = new SharedQueue(Math.max(1, Runtime.getRuntime().availableProcessors() / 2));
+ if ( rootPath.endsWith( "xml" ) )
{
SpimData spimData;
try
{
spimData = new XmlIoSpimData().load( rootPath );
- add( bwdata, spimData, setupId, 0, isMoving );
-
- if( isMoving )
- return spimData;
+ if ( returnMovingSpimData != null && isMoving )
+ {
+ returnMovingSpimData.set( spimData );
+ }
+ final LinkedHashMap< Source< T >, SourceInfo > sources = createSources( bwdata, spimData, setupId, isMoving );
+
+ sources.forEach( ( source, state ) -> {
+ state.setUriSupplier( () -> {
+ try
+ {
+ return spimData.getBasePath().getCanonicalPath();
+ }
+ catch ( final IOException e )
+ {
+ return null;
+ }
+ } );
+ } );
+
+ for ( final Map.Entry< Source< T >, SourceInfo > sourceSourceInfoEntry : sources.entrySet() )
+ {
+ sourceSourceInfoEntry.getValue().setSerializable( true );
+ /* Always break after the first */
+ break;
+ }
+ return sources;
+ }
+ catch ( final SpimDataException e )
+ {
+ e.printStackTrace();
}
- catch ( final SpimDataException e ) { e.printStackTrace(); }
return null;
}
else
{
- BigWarpInit.add( bwdata, loadN5Source( rootPath, dataset ), setupId, 0, isMoving );
- return null;
+ final LinkedHashMap< Source< T >, SourceInfo > map = new LinkedHashMap<>();
+ final Source< T > source = (Source)loadN5Source( rootPath, dataset, sharedQueue );
+ final SourceInfo info = new SourceInfo( setupId, isMoving, dataset, () -> rootPath + "$" + dataset );
+ info.setSerializable( true );
+ map.put( source, info );
+ return map;
}
}
- public static Source loadN5Source( final String n5Root, final String n5Dataset )
+
+ public static < T extends NativeType > Source< T > loadN5Source( final String n5Root, final String n5Dataset, final SharedQueue queue )
{
final N5Reader n5;
try
@@ -410,27 +672,16 @@ public static Source loadN5Source( final String n5Root, final String n5Datase
e.printStackTrace();
return null;
}
+ return loadN5Source( n5, n5Dataset, queue );
+ }
- final N5MetadataParser[] PARSERS = new N5MetadataParser[]{
- new ImagePlusLegacyMetadataParser(),
- new N5CosemMetadataParser(),
- new N5SingleScaleMetadataParser(),
- new CanonicalMetadataParser(),
- new N5GenericSingleScaleMetadataParser()
- };
-
- final N5MetadataParser[] GROUP_PARSERS = new N5MetadataParser[]{
- new N5CosemMultiScaleMetadata.CosemMultiScaleParser(),
- new N5ViewerMultiscaleMetadataParser(),
- new CanonicalMetadataParser(),
- };
+ public static < T extends NativeType> Source< T > loadN5Source( final N5Reader n5, final String n5Dataset, final SharedQueue queue )
+ {
N5Metadata meta = null;
try
{
- final N5DatasetDiscoverer discoverer = new N5DatasetDiscoverer( n5,
- N5DatasetDiscoverer.fromParsers(PARSERS),
- N5DatasetDiscoverer.fromParsers(GROUP_PARSERS) );
+ final N5DatasetDiscoverer discoverer = new N5DatasetDiscoverer( n5, N5DatasetDiscoverer.fromParsers( PARSERS ), N5DatasetDiscoverer.fromParsers( GROUP_PARSERS ) );
final N5TreeNode node = discoverer.discoverAndParseRecursive( n5Dataset );
meta = node.getMetadata();
@@ -438,50 +689,51 @@ public static Source loadN5Source( final String n5Root, final String n5Datase
catch ( final IOException e )
{}
- if( meta instanceof MultiscaleMetadata )
+ if ( meta instanceof MultiscaleMetadata )
{
- return openAsSourceMulti( n5, (MultiscaleMetadata)meta, true );
+ return openAsSourceMulti( n5, ( MultiscaleMetadata< ? > ) meta, queue, true );
}
else
{
- return openAsSource( n5, meta, true );
+ return openAsSource( n5, meta, queue, true );
}
}
@SuppressWarnings( { "unchecked", "rawtypes" } )
- public static Source openAsSource( final N5Reader n5, final T meta, final boolean isVolatile )
+ public static < T extends NativeType, M extends N5Metadata > Source< T > openAsSource( final N5Reader n5, final M meta, final SharedQueue sharedQueue, final boolean isVolatile )
{
final RandomAccessibleInterval imageRaw;
final RandomAccessibleInterval image;
+ if( meta == null )
+ return null;
+
try
{
- if( isVolatile )
- imageRaw = to3d( N5Utils.openVolatile( n5, meta.getPath() ));
+ if ( isVolatile )
+ {
+ final CachedCellImg rai = N5Utils.openVolatile( n5, meta.getPath() );
+ imageRaw = to3d( VolatileViews.wrapAsVolatile( rai, sharedQueue, new CacheHints(LoadingStrategy.VOLATILE, 0, true)) );
+ }
else
- imageRaw = to3d( N5Utils.open( n5, meta.getPath() ));
+ imageRaw = to3d( N5Utils.open( n5, meta.getPath() ) );
- if( meta instanceof N5ImagePlusMetadata
- && ((N5ImagePlusMetadata)meta).getType() == ImagePlus.COLOR_RGB
- && Util.getTypeFromInterval( imageRaw ) instanceof UnsignedIntType )
+ if ( meta instanceof N5ImagePlusMetadata && ( ( N5ImagePlusMetadata ) meta ).getType() == ImagePlus.COLOR_RGB && Util.getTypeFromInterval( imageRaw ) instanceof UnsignedIntType )
{
image = toColor( imageRaw );
}
else
image = imageRaw;
- if( meta instanceof SpatialMetadata )
+ if ( meta instanceof SpatialMetadata )
{
- final String unit = ((SpatialMetadata)meta).unit();
- final AffineTransform3D srcXfm = ((SpatialMetadata)meta).spatialTransform3d();
- final FinalVoxelDimensions voxelDims = new FinalVoxelDimensions( unit,
- new double[]{ srcXfm.get( 0, 0 ), srcXfm.get( 1, 1 ), srcXfm.get( 2, 2 ) });
+ final String unit = ( ( SpatialMetadata ) meta ).unit();
+ final AffineTransform3D srcXfm = ( ( SpatialMetadata ) meta ).spatialTransform3d();
+ final FinalVoxelDimensions voxelDims = new FinalVoxelDimensions( unit, new double[] { srcXfm.get( 0, 0 ), srcXfm.get( 1, 1 ), srcXfm.get( 2, 2 ) } );
- return new BwRandomAccessibleIntervalSource( image, (NumericType ) Util.getTypeFromInterval( image ),
- srcXfm, meta.getPath(), voxelDims );
+ return new BwRandomAccessibleIntervalSource( image, ( NumericType ) Util.getTypeFromInterval( image ), srcXfm, meta.getPath(), voxelDims );
}
else
- return new BwRandomAccessibleIntervalSource( image, ( NumericType ) Util.getTypeFromInterval( image ),
- new AffineTransform3D(), meta.getPath() );
+ return new BwRandomAccessibleIntervalSource( image, ( NumericType ) Util.getTypeFromInterval( image ), new AffineTransform3D(), meta.getPath() );
}
catch ( final RuntimeException e )
{
@@ -491,23 +743,27 @@ public static Source openAsSource( final N5Reader n5,
return null;
}
- public static Source openAsSourceMulti( final N5Reader n5, final MultiscaleMetadata multiMeta, final boolean isVolatile )
+ public static < T extends NativeType > Source< T > openAsSourceMulti( final N5Reader n5, final MultiscaleMetadata< ? > multiMeta, final SharedQueue sharedQueue, final boolean isVolatile )
{
final String[] paths = multiMeta.getPaths();
final AffineTransform3D[] transforms = multiMeta.spatialTransforms3d();
- final String unit = multiMeta.units()[0];
+ final String unit = multiMeta.units()[ 0 ];
@SuppressWarnings( "rawtypes" )
- final RandomAccessibleInterval[] images = new RandomAccessibleInterval[paths.length];
+ final RandomAccessibleInterval[] images = new RandomAccessibleInterval[ paths.length ];
final double[][] mipmapScales = new double[ images.length ][ 3 ];
+ final CacheHints cacheHints = new CacheHints(LoadingStrategy.VOLATILE, 0, true);
for ( int s = 0; s < images.length; ++s )
{
try
{
- if( isVolatile )
- images[ s ] = to3d( N5Utils.openVolatile( n5, paths[s] ));
+ if ( isVolatile )
+ {
+ final CachedCellImg rai = N5Utils.openVolatile( n5, paths[ s ] );
+ images[ s ] = to3d( VolatileViews.wrapAsVolatile( rai, sharedQueue, cacheHints) );
+ }
else
- images[ s ] = to3d( N5Utils.open( n5, paths[s] ));
+ images[ s ] = to3d( N5Utils.open( n5, paths[ s ] ) );
}
catch ( final RuntimeException e )
{
@@ -520,46 +776,38 @@ public static Source openAsSourceMulti( final N5Reader n5, final MultiscaleMe
}
@SuppressWarnings( { "unchecked", "rawtypes" } )
- final RandomAccessibleIntervalMipmapSource source = new RandomAccessibleIntervalMipmapSource(
- images,
- (NumericType ) Util.getTypeFromInterval(images[0]),
- mipmapScales,
- new mpicbg.spim.data.sequence.FinalVoxelDimensions( unit, mipmapScales[0]),
- new AffineTransform3D(),
- multiMeta.getPaths()[0] + "_group" );
+ final RandomAccessibleIntervalMipmapSource source = new RandomAccessibleIntervalMipmapSource( images, ( NumericType ) Util.getTypeFromInterval( images[ 0 ] ), mipmapScales, new mpicbg.spim.data.sequence.FinalVoxelDimensions( unit, mipmapScales[ 0 ] ), new AffineTransform3D(), multiMeta.getPaths()[ 0 ] + "_group" );
return source;
}
- private static RandomAccessibleInterval to3d( final RandomAccessibleInterval img )
+ private static RandomAccessibleInterval< ? > to3d( RandomAccessibleInterval< ? > img )
{
- if( img.numDimensions() == 2 )
+ if ( img.numDimensions() == 2 )
return Views.addDimension( img, 0, 0 );
else
return img;
}
- private static RandomAccessibleInterval toColor( final RandomAccessibleInterval img )
+ private static RandomAccessibleInterval< ARGBType > toColor( RandomAccessibleInterval< UnsignedIntType > img )
{
- return Converters.convertRAI( img,
- new Converter()
- {
- @Override
- public void convert( final UnsignedIntType input, final ARGBType output )
- {
- output.set( input.getInt() );
- }
- },
- new ARGBType() );
+ return Converters.convertRAI( img, new Converter< UnsignedIntType, ARGBType >()
+ {
+ @Override
+ public void convert( UnsignedIntType input, ARGBType output )
+ {
+ output.set( input.getInt() );
+ }
+ }, new ARGBType() );
}
@SuppressWarnings( { "rawtypes", "unchecked" } )
public static < T > BigWarpData< T > initData()
{
- final ArrayList< ConverterSetup > converterSetups = new ArrayList< ConverterSetup >();
- final ArrayList< SourceAndConverter< T > > sources = new ArrayList< SourceAndConverter< T > >();
-
- return new BigWarpData( sources, converterSetups, null, null, null );
+// final ArrayList< ConverterSetup > converterSetups = new ArrayList< ConverterSetup >();
+// final ArrayList< SourceAndConverter< T > > sources = new ArrayList< SourceAndConverter< T > >();
+// return new BigWarpData( sources, converterSetups, null );
+ return new BigWarpData();
}
/**
@@ -580,11 +828,7 @@ public static < T > BigWarpData< T > initData()
* be added.
*/
@SuppressWarnings( { "rawtypes", "unchecked" } )
- private static < T > void addSourceToListsGenericType(
- final Source< T > source,
- final int setupId,
- final List< ConverterSetup > converterSetups,
- final List< SourceAndConverter< T > > sources )
+ private static < T > void addSourceToListsGenericType( final Source< T > source, final int setupId, final List< ConverterSetup > converterSetups, final List< SourceAndConverter< T > > sources )
{
final T type = source.getType();
if ( type instanceof RealType || type instanceof ARGBType || type instanceof VolatileARGBType )
@@ -610,15 +854,10 @@ private static < T > void addSourceToListsGenericType(
* list of {@link SourceAndConverter}s to which the source should
* be added.
*/
- private static < T extends NumericType< T > > void addSourceToListsNumericType(
- final Source< T > source,
- final int setupId,
- final List< ConverterSetup > converterSetups,
- final List< SourceAndConverter< T > > sources )
+ private static < T extends NumericType< T > > void addSourceToListsNumericType( final Source< T > source, final int setupId, final List< ConverterSetup > converterSetups, final List< SourceAndConverter< T > > sources )
{
final T type = source.getType();
- final SourceAndConverter< T > soc = BigDataViewer.wrapWithTransformedSource(
- new SourceAndConverter<>( source, BigDataViewer.createConverterToARGB( type ) ) );
+ final SourceAndConverter< T > soc = BigDataViewer.wrapWithTransformedSource( new SourceAndConverter<>( source, BigDataViewer.createConverterToARGB( type ) ) );
converterSetups.add( BigDataViewer.createConverterSetup( soc, setupId ) );
sources.add( soc );
}
@@ -734,8 +973,7 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
return createBigWarpData( loaderP, loaderQ, null );
}
- public static BigWarpData< ? > createBigWarpData( final ImagePlusLoader loaderP, final ImagePlusLoader loaderQ,
- final String[] names )
+ public static BigWarpData< ? > createBigWarpData( final ImagePlusLoader loaderP, final ImagePlusLoader loaderQ, final String[] names )
{
/* Load the first source */
final AbstractSpimData< ? >[] spimDataP = loaderP.loadAll( 0 );
@@ -784,29 +1022,29 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
{
/* Load the moving sources */
final AbstractSpimData< ? >[] spimDataP;
- if( loaderP instanceof ImagePlusLoader )
+ if ( loaderP instanceof ImagePlusLoader )
spimDataP = loaderP.load();
else
spimDataP = loaderP.load();
/* Load the fixed sources */
final AbstractSpimData< ? >[] spimDataQ;
- if( loaderQ instanceof ImagePlusLoader )
- spimDataQ = ((ImagePlusLoader)loaderQ).loadAll( spimDataP.length );
+ if ( loaderQ instanceof ImagePlusLoader )
+ spimDataQ = ( ( ImagePlusLoader ) loaderQ ).loadAll( spimDataP.length );
else
spimDataQ = loaderQ.load();
final int N = loaderP.numSources() + loaderQ.numSources();
String[] names;
- if( namesIn == null || namesIn.length != N )
+ if ( namesIn == null || namesIn.length != N )
{
names = new String[ N ];
int j = 0;
- for( int i = 0; i < loaderP.numSources(); i++ )
+ for ( int i = 0; i < loaderP.numSources(); i++ )
names[ j++ ] = loaderP.name( i );
- for( int i = 0; i < loaderQ.numSources(); i++ )
+ for ( int i = 0; i < loaderQ.numSources(); i++ )
names[ j++ ] = loaderQ.name( i );
}
else
@@ -814,11 +1052,11 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
final BigWarpData< ? > data = createBigWarpData( spimDataP, spimDataQ, names );
- if( loaderP instanceof ImagePlusLoader )
- ((ImagePlusLoader)loaderP).update( data );
+ if ( loaderP instanceof ImagePlusLoader )
+ ( ( ImagePlusLoader ) loaderP ).update( data );
- if( loaderQ instanceof ImagePlusLoader )
- ((ImagePlusLoader)loaderQ).update( data );
+ if ( loaderQ instanceof ImagePlusLoader )
+ ( ( ImagePlusLoader ) loaderQ ).update( data );
return data;
}
@@ -832,9 +1070,33 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
* fixed source XML
* @return BigWarpData
*/
- public static BigWarpData< ? > createBigWarpDataFromXML( final String xmlFilenameP, final String xmlFilenameQ )
+ public static < T extends NativeType > BigWarpData< T > createBigWarpDataFromXML( final String xmlFilenameP, final String xmlFilenameQ )
{
- return createBigWarpData( new XMLLoader( xmlFilenameP ), new XMLLoader( xmlFilenameQ ), null );
+// return createBigWarpData( new XMLLoader( xmlFilenameP ), new XMLLoader( xmlFilenameQ ), null );
+ final BigWarpData< T > bwdata = BigWarpInit.initData();
+ try
+ {
+ int id = 0;
+ LinkedHashMap< Source< T >, SourceInfo > mvgSrcs;
+ mvgSrcs = BigWarpInit.createSources( bwdata, xmlFilenameP, id, true );
+ id += mvgSrcs.size();
+ BigWarpInit.add( bwdata, mvgSrcs );
+ BigWarpInit.add( bwdata, BigWarpInit.createSources( bwdata, xmlFilenameQ, id, false ) );
+ }
+ catch ( final URISyntaxException e )
+ {
+ e.printStackTrace();
+ }
+ catch ( final IOException e )
+ {
+ e.printStackTrace();
+ }
+ catch ( final SpimDataException e )
+ {
+ e.printStackTrace();
+ }
+
+ return bwdata;
}
/**
@@ -846,9 +1108,16 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
* fixed source ImagePlus
* @return BigWarpData
*/
- public static BigWarpData< ? > createBigWarpDataFromImages( final ImagePlus impP, final ImagePlus impQ )
+ public static < T > BigWarpData< T > createBigWarpDataFromImages( final ImagePlus impP, final ImagePlus impQ )
{
- return createBigWarpData( new ImagePlusLoader( impP ), new ImagePlusLoader( impQ ), null );
+ int id = 0;
+ final BigWarpData< T > bwdata = BigWarpInit.initData();
+ final LinkedHashMap< Source< T >, SourceInfo > mvgSrcs = BigWarpInit.createSources( bwdata, impP, id, 0, true );
+ id += mvgSrcs.size();
+ BigWarpInit.add( bwdata, mvgSrcs );
+ BigWarpInit.add( bwdata, BigWarpInit.createSources( bwdata, impQ, id, 0, false ) );
+
+ return bwdata;
}
/**
@@ -904,9 +1173,32 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
* fixed source ImagePlus
* @return BigWarpData
*/
- public static BigWarpData< ? > createBigWarpDataFromXMLImagePlus( final String xmlFilenameP, final ImagePlus impQ )
+ public static < T extends NativeType > BigWarpData< T > createBigWarpDataFromXMLImagePlus( final String xmlFilenameP, final ImagePlus impQ )
{
- return createBigWarpData( new XMLLoader( xmlFilenameP ), new ImagePlusLoader( impQ ) );
+ final BigWarpData< T > bwdata = BigWarpInit.initData();
+ try
+ {
+ int id = 0;
+ LinkedHashMap< Source< T >, SourceInfo > mvgSrcs;
+ mvgSrcs = BigWarpInit.createSources( bwdata, xmlFilenameP, id, true );
+ id += mvgSrcs.size();
+ BigWarpInit.add( bwdata, mvgSrcs );
+ BigWarpInit.add( bwdata, BigWarpInit.createSources( bwdata, impQ, id, 0, false ) );
+ }
+ catch ( final URISyntaxException e )
+ {
+ e.printStackTrace();
+ }
+ catch ( final IOException e )
+ {
+ e.printStackTrace();
+ }
+ catch ( final SpimDataException e )
+ {
+ e.printStackTrace();
+ }
+
+ return bwdata;
}
/**
@@ -933,9 +1225,33 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
* fixed source XML
* @return BigWarpData
*/
- public static BigWarpData< ? > createBigWarpDataFromImagePlusXML( final ImagePlus impP, final String xmlFilenameQ )
+ public static < T extends NativeType > BigWarpData< T > createBigWarpDataFromImagePlusXML( final ImagePlus impP, final String xmlFilenameQ )
{
- return createBigWarpData( new ImagePlusLoader( impP ), new XMLLoader( xmlFilenameQ ) );
+// return createBigWarpData( new ImagePlusLoader( impP ), new XMLLoader( xmlFilenameQ ) );
+ final BigWarpData< T > bwdata = BigWarpInit.initData();
+ try
+ {
+ int id = 0;
+ LinkedHashMap< Source< T >, SourceInfo > mvgSrcs;
+ mvgSrcs = BigWarpInit.createSources( bwdata, impP, id, 0, true );
+ id += mvgSrcs.size();
+ BigWarpInit.add( bwdata, mvgSrcs );
+ BigWarpInit.add( bwdata, BigWarpInit.createSources( bwdata, xmlFilenameQ, id, false ) );
+ }
+ catch ( final URISyntaxException e )
+ {
+ e.printStackTrace();
+ }
+ catch ( final IOException e )
+ {
+ e.printStackTrace();
+ }
+ catch ( final SpimDataException e )
+ {
+ e.printStackTrace();
+ }
+
+ return bwdata;
}
/**
@@ -956,7 +1272,7 @@ private static < T > SourceAndConverter< T > wrapSourceAsRenamable( final Source
/**
* Create a {@link String} array of names from two {@link ImagePlus}es,
* essentially concatenating the results from calling
- * {@link namesFromImagePlus} with each.
+ * {@link #namesFromImagePlus(ImagePlus)} with each.
*
* @param impP
* first image to generate names from
diff --git a/src/main/java/bigwarp/BigWarpRealExporter.java b/src/main/java/bigwarp/BigWarpRealExporter.java
index 84f83c4f..a264c3e1 100644
--- a/src/main/java/bigwarp/BigWarpRealExporter.java
+++ b/src/main/java/bigwarp/BigWarpRealExporter.java
@@ -8,12 +8,12 @@
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* .
@@ -59,34 +59,30 @@ public class BigWarpRealExporter< T extends RealType< T > & NativeType< T > > e
final private T baseType;
public BigWarpRealExporter(
- final List< SourceAndConverter< T >> sources,
+ final BigWarpData