如何为 TrackMate 编写自己的检测算法

    package plugin.trackmate.examples.detector;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import net.imglib2.Interval;
    import net.imglib2.type.NativeType;
    import net.imglib2.type.numeric.RealType;
    import fiji.plugin.trackmate.Spot;
    import fiji.plugin.trackmate.detection.SpotDetector;
    
    public class SpiralDummyDetector< T extends RealType< T > & NativeType< T >> implements SpotDetector< T >
    {
    
        private static final double RADIAL_SPEED = 3d; // pixels per frame
    
        // radians per frame
        private static final double ANGULAR_SPEED = Math.PI / 10;
    
        // in image units
        private static final double SPOT_RADIUS = 1d;
    
        /** The width if the ROI. */
        private final long width;
    
        /** The height if the ROI. */
        private final long height;
    
        /** The X coordinates of the ROI. */
        private final long xstart;
    
        /** The Y coordinates of the ROI. */
        private final long ystart;
    
        /** The pixel sizes in the 3 dimensions. */
        private final double[] calibration;
    
        /** The frame we operate in. */
        private final int frame;
    
        /** Holder for the results of detection. */
        private List< Spot > spots;
    
        /** Error message holder. */
        private String errorMessage;
    
        /** Holder for the processing time. */
        private long processingTime;
    
        /*
         * CONSTRUCTOR
         */
    
        public SpiralDummyDetector( final Interval interval, final double[] calibration, final int frame )
        {
            // Take the ROI box from the interval parameter.
            this.width = interval.dimension( 0 );
            this.height = interval.dimension( 1 );
            this.xstart = interval.min( 0 );
            this.ystart = interval.min( 1 );
            // We will need the calibration to convert to physical units.
            this.calibration = calibration;
            // We need to know what frame we are in.
            this.frame = frame;
        }
    
        /*
         * METHODS
         */
    
        @Override
        public List< Spot > getResult()
        {
            return spots;
        }
    
        @Override
        public boolean checkInput()
        {
            // Nothing to test, it's all good.
            return true;
        }
    
        @Override
        public boolean process()
        {
            final long start = System.currentTimeMillis();
            spots = new ArrayList< Spot >();
    
            /*
             * This dummy detector creates spots that spiral out from the center of
             * the specified ROI. It spits a new spiral every 10 frames.
             */
    
            final int x0 = ( int ) ( width / 2 + xstart );
            final int y0 = ( int ) ( height / 2 + ystart );
    
            int t = frame;
            int nspiral = 0;
            while ( t >= 0 )
            {
                final double r = t * RADIAL_SPEED;
                final double phi0 = nspiral * Math.PI / 4;
                final double phi = t * ANGULAR_SPEED + phi0;
    
                // Spot in pixel coordinates.
                final double x = x0 + r * Math.cos( phi );
                final double y = y0 + r * Math.sin( phi );
    
                // But we want to create spots in image coordinates:
                final double xpos = x * calibration[ 0 ];
                final double ypos = y * calibration[ 1 ];
                final double zpos = 0d;
    
                // Create the spot.
                final Spot spot = new Spot( xpos, ypos, zpos, SPOT_RADIUS, 1d / ( nspiral + 1d ) );
                spots.add( spot );
    
                // Loop to another spiral.
                t = t - 10;
                nspiral++;
            }
    
            final long end = System.currentTimeMillis();
            this.processingTime = end - start;
            return true;
        }
    
        @Override
        public String getErrorMessage()
        {
            /*
             * If something wrong happens while you #checkInput() or #process(),
             * state it in the errorMessage field.
             */
            return errorMessage;
        }
    
        @Override
        public long getProcessingTime()
        {
            return processingTime;
        }
    
    }

@Plugin( type = SpotDetectorFactory.class )
public class SpiralDummyDetectorFactory< T extends RealType< T > & NativeType< T >> implements SpotDetectorFactory< T >

@Override
public boolean setTarget( final ImgPlus< T > img, final Map< String, Object > settings )

@Override
public ConfigurationPanel getDetectorConfigurationPanel( final Settings settings, final Model model )

public Map< String, Object > getDefaultSettings();

public boolean checkSettings( final Map< String, Object > settings );

public String getErrorMessage();

public boolean marshall( final Map< String, Object > settings, final Element element );
    
public boolean unmarshall( final Element element, final Map< String, Object > settings );

public SpotDetector< T > getDetector( final Interval interval, final int frame )

        @Override
        public SpotDetector< T > getDetector( final Interval interval, final int frame )
        {
            final double radius = ( Double ) settings.get( KEY_RADIUS );
            final double threshold = ( Double ) settings.get( KEY_THRESHOLD );
            final boolean doMedian = ( Boolean ) settings.get( KEY_DO_MEDIAN_FILTERING );
            final boolean doSubpixel = ( Boolean ) settings.get( KEY_DO_SUBPIXEL_LOCALIZATION );
            final double[] calibration = TMUtils.getSpatialCalibration( img );
    
            RandomAccessible< T > imFrame;
            final int cDim = TMUtils.findCAxisIndex( img );
            if ( cDim < 0 )
            {
                imFrame = img;
            }
            else
            {
                // In ImgLib2, dimensions are 0-based.
                final int channel = ( Integer ) settings.get( KEY_TARGET_CHANNEL ) - 1;
                imFrame = Views.hyperSlice( img, cDim, channel );
            }
    
            int timeDim = TMUtils.findTAxisIndex( img );
            if ( timeDim >= 0 )
            {
                if ( cDim >= 0 && timeDim > cDim )
                {
                    timeDim--;
                }
                imFrame = Views.hyperSlice( imFrame, timeDim, frame );
            }
            final LogDetector< T > detector = new LogDetector< T >( imFrame, interval, calibration, radius, threshold, doSubpixel, doMedian );
            detector.setNumThreads( 1 ); // in TrackMate context, we use 1 thread
            // per detector but multiple detectors
            return detector;
        }

    package plugin.trackmate.examples.detector;
    
    import ij.ImageJ;
    import ij.ImagePlus;
    
    import java.util.Collections;
    import java.util.Map;
    
    import javax.swing.ImageIcon;
    
    import net.imglib2.Interval;
    import net.imglib2.meta.ImgPlus;
    import net.imglib2.type.NativeType;
    import net.imglib2.type.numeric.RealType;
    
    import org.jdom2.Element;
    import org.scijava.plugin.Plugin;
    
    import fiji.plugin.trackmate.Model;
    import fiji.plugin.trackmate.Settings;
    import fiji.plugin.trackmate.TrackMatePlugIn_;
    import fiji.plugin.trackmate.detection.SpotDetector;
    import fiji.plugin.trackmate.detection.SpotDetectorFactory;
    import fiji.plugin.trackmate.gui.ConfigurationPanel;
    import fiji.plugin.trackmate.util.TMUtils;
    
    @Plugin( type = SpotDetectorFactory.class )
    public class SpiralDummyDetectorFactory< T extends RealType< T > & NativeType< T >> implements SpotDetectorFactory< T >
    {
    
        static final String INFO_TEXT = "<html>This is a dummy detector that creates spirals made of spots emerging from the center of the ROI. The actual image content is not used.</html>";
    
        private static final String KEY = "DUMMY_DETECTOR_SPIRAL";
    
        static final String NAME = "Dummy detector in spirals";
    
        private double[] calibration;
    
        private String errorMessage;
    
        @Override
        public String getInfoText()
        {
            return INFO_TEXT;
        }
    
        @Override
        public ImageIcon getIcon()
        {
            return null;
        }
    
        @Override
        public String getKey()
        {
            return KEY;
        }
    
        @Override
        public String getName()
        {
            return NAME;
        }
    
        @Override
        public SpotDetector< T > getDetector( final Interval interval, final int frame )
        {
            return new SpiralDummyDetector< T >( interval, calibration, frame );
        }
    
        @Override
        public boolean setTarget( final ImgPlus< T > img, final Map< String, Object > settings )
        {
            /*
             * Well, we do not care for the image at all. We just need to get the
             * physical calibration and there is a helper method for that.
             */
            this.calibration = TMUtils.getSpatialCalibration( img );
            // True means that the settings map is OK.
            return true;
        }
    
        @Override
        public String getErrorMessage()
        {
            /*
             * If something is not right when calling #setTarget (i.e. the settings
             * maps is not right), this is how we get an error message.
             */
            return errorMessage;
        }
    
        @Override
        public boolean marshall( final Map< String, Object > settings, final Element element )
        {
            /*
             * This where you save the settings map to a JDom element. Since we do
             * not have parameters, we have nothing to do.
             */
            return true;
        }
    
        @Override
        public boolean unmarshall( final Element element, final Map< String, Object > settings )
        {
            /*
             * The same goes for loading: there is nothing to load.
             */
            return true;
        }
    
        @Override
        public ConfigurationPanel getDetectorConfigurationPanel( final Settings settings, final Model model )
        {
            // We return a simple configuration panel.
            return new DummyDetectorSpiralConfigurationPanel();
        }
    
        @Override
        public Map< String, Object > getDefaultSettings()
        {
            /*
             * We just have to return a new empty map.
             */
            return Collections.emptyMap();
        }
    
        @Override
        public boolean checkSettings( final Map< String, Object > settings )
        {
            /*
             * Since we have no settings, we just have to test that we received the
             * empty map. Otherwise we generate an error.
             */
            if ( settings.isEmpty() ) { return true; }
            errorMessage = "Expected the settings map to be empty, but it was not: " + settings + '\n';
            return false;
        }
    }