Field Detail

• pointSpreadFunctions

  protected final HashMap<ViewId,ArrayImg<T extends RealType<T> & NativeType<T>,?>> pointSpreadFunctions

• originalPSFs

  protected final HashMap<ViewId,ArrayImg<T extends RealType<T> & NativeType<T>,?>> originalPSFs

• viewIds

  protected final ArrayList<ViewId> viewIds

Constructor Detail

• ExtractPSF

  public ExtractPSF()

Method Detail

• getViewIdMapping

  public HashMap<ViewId,ViewId> getViewIdMapping()

  Returns:

  - the current mapping, should be appended by any process that wants to use exisiting PSF's

• getPSFMap

  public HashMap<ViewId,ArrayImg<T,?>> getPSFMap()

• getTransformedPSF

  public ArrayImg<T,?> getTransformedPSF(ViewId viewId)

  Returns the transformed PSF. It will first try to look it up directly, if not available it will check the mapping mapViewIds< from, to > which one should be used for this viewid.

  Parameters:

  viewId -

  Returns:

  - the extracted PSFs after applying the transformations of each view

• getInputCalibrationPSFs

  public HashMap<ViewId,ArrayImg<T,?>> getInputCalibrationPSFs()

  Returns:

  - the extracted PSFs in original calibration for each view

• getViewIdsForPSFs

  public ArrayList<ViewId> getViewIdsForPSFs()

  Returns:

  - the viewdescriptions corresponding to the PSFs

• computeMaxProjection

  public static <S extends RealType<S>> Img<S> computeMaxProjection(Img<S> avgPSF,
                                                                    int minDim)

  Get projection along the smallest dimension (which is usually the rotation axis)

  Parameters:

  avgPSF - - the average psf

  minDim - - along which dimension to project, if set to <0, the smallest dimension will be chosen

  Returns:

  - the averaged, projected PSF

• computeMaxProjection

  public static <S extends RealType<S>> Img<S> computeMaxProjection(RandomAccessibleInterval<S> avgPSF,
                                                                    ImgFactory<S> factory,
                                                                    int minDim)

• computeAverageTransformedPSF

  public Img<T> computeAverageTransformedPSF()

  compute the average psf in original calibration and after applying the transformations

• computeAveragePSF

  public Img<T> computeAveragePSF()

  Compute average PSF in local image coordinates, all images are supposed to have the same dimensions

  Returns:

• extractNextImg

  public void extractNextImg(RandomAccessibleInterval<T> img,
                             ViewId viewId,
                             AffineTransform3D model,
                             ArrayList<double[]> locations,
                             long[] psfSize)

  Parameters:

  img -

  viewId -

  model -

  locations -

  psfSize - - dimensions of psf to extract

• transformPSF

  protected static <T extends RealType<T> & NativeType<T>> ArrayImg<T,?> transformPSF(RandomAccessibleInterval<T> psf,
                                                                                      AffineTransform3D model)

  Transforms the extracted PSF using the affine transformation of the corresponding view

  Parameters:

  psf - - the extracted psf (NOT z-scaling corrected)

  model - - the transformation model

  Returns:

  the transformed psf which has odd sizes and where the center of the psf is also the center of the transformed psf

• extractPSFLocal

  protected static <T extends RealType<T> & NativeType<T>> ArrayImg<T,?> extractPSFLocal(RandomAccessibleInterval<T> img,
                                                                                         ArrayList<double[]> locations,
                                                                                         long[] size)

  Extracts the PSF by averaging the local neighborhood RANSAC correspondences

  Parameters:

  size - - the size in which the psf is extracted (in pixel units, z-scaling is ignored)

  Returns:

  - the psf, NOT z-scaling corrected

• transform

  public static <T extends RealType<T> & NativeType<T>> ArrayImg<T,?> transform(RandomAccessibleInterval<T> image,
                                                                                AffineTransform3D transformIn,
                                                                                long[] newDim,
                                                                                double[] offset)

• makeSameSize

  public static <T extends RealType<T>> Img<T> makeSameSize(Img<T> img,
                                                            long[] sizeIn)

  Make image the same size as defined, center it

  Parameters:

  img -

  Returns:

• commonSize

  public static <T extends Type<T>> long[] commonSize(List<Img<T>> images)

  Returns the bounding box so that all images can fit in there or null if input is null or input.size is 0

  Parameters:

  images -

  Returns:

• computeMaxDimTransformedPSF

  public long[] computeMaxDimTransformedPSF()

  Returns:

  - maximal dimensions of the transformed PSFs

• loadAndTransformPSFs

  public static <T extends RealType<T> & NativeType<T>> ExtractPSF<T> loadAndTransformPSFs(ArrayList<Pair<Pair<Angle,Illumination>,String>> filenames,
                                                                                           ArrayList<ViewDescription> viewDesc,
                                                                                           T type,
                                                                                           HashMap<ViewId,AffineTransform3D> models)

  Parameters:

  filenames -

  Returns:

• getFileNameForViewId

  protected static File getFileNameForViewId(ViewDescription vd,
                                             ArrayList<Pair<Pair<Angle,Illumination>,String>> filenames)