Ejemplo n.º 1
0
  /**
   * Computes a Gaussian convolution with double precision on an entire {@link Img}
   *
   * @param sigma - the sigma for the convolution
   * @param img - the img {@link Img}
   * @param outofbounds - the {@link OutOfBoundsFactory}
   * @return the convolved img having the input type
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  public static <T extends RealType<T>> Img<T> inDouble(
      final double[] sigma,
      final Img<T> img,
      final OutOfBoundsFactory<DoubleType, RandomAccessibleInterval<DoubleType>> outofbounds) {
    try {
      if (DoubleType.class.isInstance(img.firstElement())) {
        return (Img) toDouble(sigma, img, outofbounds);
      }
      final Img<T> output = img.factory().create(img, img.firstElement());

      final RandomAccessible<DoubleType> rIn =
          Views.extend(
              new WriteConvertedRandomAccessibleInterval<T, DoubleType>(
                  img, new RealDoubleSamplerConverter<T>()),
              outofbounds);
      final RandomAccessible<DoubleType> rOut =
          new WriteConvertedRandomAccessible<T, DoubleType>(
              output, new RealDoubleSamplerConverter<T>());

      inDouble(
          sigma,
          rIn,
          img,
          rOut,
          new Point(sigma.length),
          img.factory().imgFactory(new DoubleType()));

      return output;
    } catch (final IncompatibleTypeException e) {
      return null;
    }
  }
Ejemplo n.º 2
0
  /**
   * Computes a Gaussian convolution with double precision on an entire {@link Img}
   *
   * @param sigma - the sigma for the convolution
   * @param img - the img {@link Img}
   * @param outofbounds - the {@link OutOfBoundsFactory}
   * @return the convolved img in {@link DoubleType}
   */
  public static <T extends RealType<T>> Img<DoubleType> toDouble(
      final double[] sigma,
      final Img<T> img,
      final OutOfBoundsFactory<DoubleType, RandomAccessibleInterval<DoubleType>> outofbounds) {
    GaussDouble gauss = null;
    try {
      if (DoubleType.class.isInstance(img.firstElement())) {
        @SuppressWarnings({"rawtypes", "unchecked"})
        final Img<DoubleType> img2 = (Img) img;
        gauss = new GaussDouble(sigma, img2);
      } else {
        final RandomAccessibleInterval<DoubleType> rIn =
            new WriteConvertedIterableRandomAccessibleInterval<T, DoubleType, Img<T>>(
                img, new RealDoubleSamplerConverter<T>());
        gauss =
            new GaussDouble(
                sigma,
                Views.extend(rIn, outofbounds),
                img,
                img.factory().imgFactory(new DoubleType()));
      }
    } catch (final IncompatibleTypeException e) {
      return null;
    }

    gauss.call();

    return (Img<DoubleType>) gauss.getResult();
  }
Ejemplo n.º 3
0
 @Override
 public boolean checkInput() {
   if (!(source.numDimensions() == 2 || source.numDimensions() == 3)) {
     errorMessage = BASE_ERROR_MSG + "Only operates on 2D or 3D images.";
     return false;
   }
   return true;
 }
Ejemplo n.º 4
0
  /** {@inheritDoc} */
  @Override
  public Labeling<L> compute(final RandomAccessibleInterval<T> op, final Labeling<L> r) {

    initRegionGrowing(op);

    final LinkedList<ValuePair<int[], L>> q = new LinkedList<ValuePair<int[], L>>();

    // image and random access to keep track of the already visited
    // pixel
    // positions
    if (m_allowOverlap) {
      NativeImgLabeling<L, IntType> tmp =
          new NativeImgLabeling<L, IntType>(
              new ArrayImgFactory<IntType>().create(resultDims(op), new IntType()));
      m_visitedLabRA = tmp.randomAccess();
    } else {
      BitType bt = new BitType();
      Img<BitType> tmp = null;
      try {
        tmp = new ArrayImgFactory<BitType>().imgFactory(bt).create(op, bt);
      } catch (IncompatibleTypeException e) {
        //
      }
      m_visitedRA = tmp.randomAccess();
    }

    // access to the resulting labeling
    RandomAccess<LabelingType<L>> resRA = r.randomAccess();

    L label;
    int[] pos = new int[op.numDimensions()];
    do {
      while ((label = nextSeedPosition(pos)) != null) {

        // already visited?
        setVisitedPosition(pos);
        if (isMarkedAsVisited(label)) {
          continue;
        }
        markAsVisited(label);

        q.addLast(new ValuePair<int[], L>(pos.clone(), label));

        // set new labeling
        resRA.setPosition(pos);
        setLabel(resRA, label);

        if (m_mode == GrowingMode.ASYNCHRONOUS) {
          growProcess(q, resRA, op);
        }
      }
      if (m_mode == GrowingMode.SYNCHRONOUS) {
        growProcess(q, resRA, op);
      }
    } while (hasMoreSeedingPoints());

    return r;
  }
Ejemplo n.º 5
0
 /**
  * Computes a Gaussian convolution with the precision of the type provided on an entire {@link
  * Img}
  *
  * @param sigma - the sigma for the convolution
  * @param img - the img {@link Img}
  * @param outofbounds - the {@link OutOfBoundsFactory}
  * @return the convolved img
  */
 public static <T extends NumericType<T>> Img<T> inNumericType(
     final double[] sigma,
     final Img<T> img,
     final OutOfBoundsFactory<T, RandomAccessibleInterval<T>> outofbounds) {
   final Img<T> output = img.factory().create(img, img.firstElement());
   inNumericType(
       sigma, Views.extend(img, outofbounds), img, output, new Point(sigma.length), img.factory());
   return output;
 }
Ejemplo n.º 6
0
 /** Test the Fourier transformation with a known frequency */
 @Test
 public void oneDimensional() throws IncompatibleTypeException {
   double[] values = {0, 1, 0, -1, 0};
   final Img<DoubleType> img = ArrayImgs.doubles(values, 5);
   final FourierTransform<DoubleType, ComplexDoubleType> fft =
       new FourierTransform<DoubleType, ComplexDoubleType>(img, new ComplexDoubleType());
   fft.process();
   Img<ComplexDoubleType> convolved = fft.getResult();
   assertEquals(convolved.numDimensions(), 1);
 }
Ejemplo n.º 7
0
 @Test
 public void testSingleDilateFull() {
   final Shape shape = new DiamondShape(1);
   @SuppressWarnings("unchecked")
   final Img<ByteType> out1 =
       (Img<ByteType>) ops.run(DefaultDilate.class, Img.class, in, shape, true);
   final Img<ByteType> out2 = Dilation.dilateFull(in, shape, 1);
   final Cursor<ByteType> c1 = out1.cursor();
   final Cursor<ByteType> c2 = out2.cursor();
   while (c1.hasNext()) assertEquals(c1.next().get(), c2.next().get());
 }
Ejemplo n.º 8
0
 void copyWithSourceIteration(final Img<IntType> srcImg, final Img<IntType> dstImg) {
   final long[] pos = new long[dimensions.length];
   final Cursor<IntType> src = srcImg.localizingCursor();
   final RandomAccess<IntType> dst = dstImg.randomAccess();
   while (src.hasNext()) {
     src.fwd();
     src.localize(pos);
     dst.setPosition(pos);
     dst.get().set(src.get());
   }
 }
Ejemplo n.º 9
0
 void copyWithDestIteration(final Img<IntType> srcImg, final Img<IntType> dstImg) {
   final long[] pos = new long[dstImg.numDimensions()];
   final Cursor<IntType> dst = dstImg.localizingCursor();
   final RandomAccess<IntType> src = srcImg.randomAccess();
   while (dst.hasNext()) {
     dst.fwd();
     dst.localize(pos);
     src.setPosition(pos);
     dst.get().set(src.get());
   }
 }
Ejemplo n.º 10
0
  public Example6a1() throws ImgIOException {
    // open with ImgOpener as a FloatType
    Img<FloatType> image = new ImgOpener().openImg("DrosophilaWing.tif", new FloatType());

    // perform gaussian convolution with float precision
    double[] sigma = new double[image.numDimensions()];

    for (int d = 0; d < image.numDimensions(); ++d) sigma[d] = 8;

    // convolve & display
    ImageJFunctions.show(Gauss.toFloat(sigma, image));
  }
Ejemplo n.º 11
0
 @Override
 public void run() {
   double[] sigmas = sigmas();
   @SuppressWarnings("unchecked")
   Img<T> target = (Img<T>) dataset.getImgPlus();
   Img<T> input = target.copy();
   ExtendedRandomAccessibleInterval<T, ?> paddedInput = Views.extendMirrorSingle(input);
   try {
     Gauss3.gauss(sigmas, paddedInput, target);
   } catch (Exception e) {
     cancel(e.getMessage());
   }
 }
Ejemplo n.º 12
0
  private Img<?> getUsableImage(final Img<ComplexType<?>> img) {
    if (m_imgBuffer.size() > 0) {
      return m_imgBuffer.poll();
    } else {
      Img tmpImg = m_imgFactory.create(img, m_resultType);

      // wrap the result image with an ImgView in case the other image has an offset (i.e. minimum)
      // -> if not set, an iteration order exception will occur
      long[] min = new long[img.numDimensions()];
      img.min(min);
      return ImgView.wrap(Views.translate(tmpImg, min), tmpImg.factory());
    }
  }
Ejemplo n.º 13
0
 private Img<DoubleType> makeInputImage() {
   Img<DoubleType> inputImg = allocateImage();
   RandomAccess<DoubleType> accessor = inputImg.randomAccess();
   long[] pos = new long[2];
   for (int x = 0; x < XSIZE; x++) {
     for (int y = 0; y < YSIZE; y++) {
       pos[0] = x;
       pos[1] = y;
       accessor.setPosition(pos);
       accessor.get().setReal(x + y);
     }
   }
   return inputImg;
 }
Ejemplo n.º 14
0
 int[] getImgAsInts(final Img<IntType> img) {
   final RandomAccess<IntType> a = img.randomAccess();
   final int N = (int) img.size();
   final int[] data = new int[N];
   final long[] dim = new long[img.numDimensions()];
   final long[] pos = new long[img.numDimensions()];
   img.dimensions(dim);
   for (int i = 0; i < N; ++i) {
     IntervalIndexer.indexToPosition(i, dim, pos);
     a.setPosition(pos);
     data[i] = a.get().get();
   }
   return data;
 }
Ejemplo n.º 15
0
  /** Makes sure input is okay and creates output image */
  @Override
  public boolean checkInput() {
    final Img inputImage = dataset.getImgPlus(); // TODO - raw type required
    // here

    inputDimensions = new long[inputImage.numDimensions()];

    inputImage.dimensions(inputDimensions);

    final long[] outputDimensions = flipper.calcOutputDimensions(inputDimensions);

    outputImage = inputImage.factory().create(outputDimensions, inputImage.firstElement());

    return true;
  }
Ejemplo n.º 16
0
  private static final <R extends RealType<R>> Img<R> processReal(
      final Img<R> img, final float[] m, final Mode mode, final OutOfBoundsFactory<R, Img<R>> oobf)
      throws Exception {
    final InterpolatorFactory<R, RandomAccessible<R>> inter;
    switch (mode) {
      case LINEAR:
        inter = new NLinearInterpolatorFactory<R>();
        break;
      case NEAREST_NEIGHBOR:
        inter = new NearestNeighborInterpolatorFactory<R>();
        break;
      default:
        throw new IllegalArgumentException("Scale: don't know how to scale with mode " + mode);
    }

    final ImageTransform<R> transform;
    final ExtendedRandomAccessibleInterval<R, Img<R>> imgExt = Views.extend(img, oobf);

    if (2 == img.numDimensions()) {
      // Transform the single-plane image in 2D
      AffineModel2D aff = new AffineModel2D();
      aff.set(m[0], m[4], m[1], m[5], m[3], m[7]);
      transform = new ImageTransform<R>(imgExt, aff, (InterpolatorFactory) inter);
    } else if (3 == img.numDimensions()) {
      // Transform the image in 3D, or each plane in 2D
      if (m.length < 12) {
        throw new IllegalArgumentException(
            "Affine transform in 3D requires a matrix array of 12 elements.");
      }
      AffineModel3D aff = new AffineModel3D();
      aff.set(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11]);
      transform = new ImageTransform<R>(imgExt, aff, (InterpolatorFactory) inter);
      // Ensure Z dimension is not altered if scaleZ is 1:
      if (Math.abs(m[10] - 1.0f) < 0.000001 && 0 == m[8] && 0 == m[9]) {
        long[] d = transform.getNewImageSize();
        d[2] = img.dimension(2); // 0-based: '2' is the third dimension
        transform.setNewImageSize(d);
      }
    } else {
      throw new Exception("Affine transform: only 2D and 3D images are supported.");
    }

    if (!transform.checkInput() || !transform.process()) {
      throw new Exception("Could not affine transform the image: " + transform.getErrorMessage());
    }

    return transform.getResult();
  }
Ejemplo n.º 17
0
 /**
  * Computes a Gaussian convolution in-place (temporary imgs are necessary) with the precision of
  * the type provided on an entire {@link Img}
  *
  * @param sigma - the sigma for the convolution
  * @param img - the img {@link Img} that will be convolved in place
  */
 public static <T extends NumericType<T>> void inNumericTypeInPlace(
     final double[] sigma,
     final Img<T> img,
     final OutOfBoundsFactory<T, RandomAccessibleInterval<T>> outofbounds) {
   inNumericType(
       sigma, Views.extend(img, outofbounds), img, img, new Point(sigma.length), img.factory());
 }
Ejemplo n.º 18
0
 @Test
 public void testListDilateFull() {
   final List<Shape> shapes = new ArrayList<Shape>();
   shapes.add(new DiamondShape(1));
   shapes.add(new DiamondShape(1));
   shapes.add(new RectangleShape(1, false));
   shapes.add(new HorizontalLineShape(2, 1, false));
   @SuppressWarnings("unchecked")
   final IterableInterval<ByteType> out1 =
       (IterableInterval<ByteType>)
           ops.run(ListDilate.class, IterableInterval.class, in, shapes, true);
   final Img<ByteType> out2 = Dilation.dilateFull(in, shapes, 1);
   final Cursor<ByteType> c1 = out1.cursor();
   final Cursor<ByteType> c2 = out2.cursor();
   while (c1.hasNext()) assertEquals(c1.next().get(), c2.next().get());
 }
Ejemplo n.º 19
0
  public Example1c() {
    // create the ImgFactory based on cells (cellsize = 5x5x5...x5) that will
    // instantiate the Img
    final ImgFactory<FloatType> imgFactory = new CellImgFactory<FloatType>(5);

    // create an 3d-Img with dimensions 20x30x40 (here cellsize is 5x5x5)Ø
    final Img<FloatType> img1 = imgFactory.create(new long[] {20, 30, 40}, new FloatType());

    // create another image with the same size
    // note that the input provides the size for the new image as it implements
    // the Interval interface
    final Img<FloatType> img2 = imgFactory.create(img1, img1.firstElement());

    // display both (but they are empty)
    ImageJFunctions.show(img1);
    ImageJFunctions.show(img2);
  }
Ejemplo n.º 20
0
 protected void updateTitle() {
   String trailer = "";
   if (display instanceof ImageDisplay) {
     ImageDisplayService srv = getContext().getService(ImageDisplayService.class);
     if (srv != null) {
       Dataset ds = srv.getActiveDataset((ImageDisplay) display);
       if (ds != null) {
         Img<?> img = ds.getImgPlus().getImg();
         if (AbstractCellImg.class.isAssignableFrom(img.getClass())) {
           trailer = " (V)";
         }
       }
     }
   }
   String name = getDisplay().getName();
   if (name == null) name = "";
   getWindow().setTitle(name + trailer);
 }
Ejemplo n.º 21
0
 @Override
 public void run() {
   if (!threshSrv.hasThreshold(input)) {
     cancel("This command requires a thresholded image.");
     return;
   }
   ThresholdOverlay thresh = threshSrv.getThreshold(input);
   PointSetIterator iter = thresh.getPointsWithin().iterator();
   if (!iter.hasNext()) {
     cancel("No pixels are within the threshold");
     return;
   }
   Dataset ds = dispSrv.getActiveDataset(input);
   final int numDims = ds.numDimensions();
   final long[] dimensions = new long[numDims];
   final long[] min = new long[numDims];
   /*
    * First pass - find minima and maxima so we can use a shrunken image in some cases.
    */
   for (int i = 0; i < numDims; i++) {
     min[i] = (long) Math.floor(thresh.realMin(i));
     dimensions[i] = (long) Math.floor(thresh.realMax(i) - thresh.realMin(i) + 1);
   }
   final ArrayImg<BitType, BitArray> arrayMask =
       new ArrayImgFactory<BitType>().createBitInstance(dimensions, 1);
   final BitType t = new BitType(arrayMask);
   arrayMask.setLinkedType(t);
   final Img<BitType> mask =
       new ImgTranslationAdapter<BitType, ArrayImg<BitType, BitArray>>(arrayMask, min);
   final RandomAccess<BitType> raMask = mask.randomAccess();
   iter.reset();
   while (iter.hasNext()) {
     long[] pos = iter.next();
     raMask.setPosition(pos);
     raMask.get().set(true);
   }
   output =
       new BinaryMaskOverlay(context, new BinaryMaskRegionOfInterest<BitType, Img<BitType>>(mask));
   output.setAlpha(alpha);
   output.setFillColor(color);
   for (int i = 0; i < numDims; i++) {
     output.setAxis(ds.getImgPlus().axis(i), i);
   }
 }
Ejemplo n.º 22
0
  /** @see LocalContrastThreshold */
  @Test
  public void testLocalContrastThreshold() {
    ops.run(
        LocalContrastThreshold.class,
        out,
        in,
        new RectangleShape(3, false),
        new OutOfBoundsMirrorFactory<ByteType, Img<ByteType>>(Boundary.SINGLE));

    assertEquals(out.firstElement().get(), false);
  }
Ejemplo n.º 23
0
  @Test
  public void testInplace() {
    ops.run(DefaultLoopInplace.class, in, inplaceOp, numIterations);

    // test
    final Cursor<ByteType> c = in.cursor();

    while (c.hasNext()) {
      org.junit.Assert.assertEquals(numIterations, c.next().get());
    }
  }
Ejemplo n.º 24
0
  public SubpixelLocalization(
      final Img<T> laPlacian, final List<DifferenceOfGaussianPeak<T>> peaks) {
    setNumThreads();
    this.laPlacian = laPlacian;
    this.peaks = peaks;
    this.allowedToMoveInDim = new boolean[laPlacian.numDimensions()];

    // principally one can move in any dimension
    for (int d = 0; d < allowedToMoveInDim.length; ++d) allowedToMoveInDim[d] = true;

    this.doubleArrayFactory = new ArrayImgFactory<DoubleType>();
  }
Ejemplo n.º 25
0
  /**
   * Converts an {@link Img} into a matrix
   *
   * @param maxtrixImg - the input {@link Img}
   * @return a {@link Matrix} or null if the {@link Img} is not one or two-dimensional
   */
  public static <S extends RealType<S>> Matrix getMatrix(final Img<S> maxtrixImg) {
    final int numDimensions = maxtrixImg.numDimensions();

    if (numDimensions > 2) return null;

    final Matrix matrix;

    if (numDimensions == 1) {
      matrix = new Matrix((int) maxtrixImg.dimension(0), 1);

      final Cursor<S> cursor = maxtrixImg.localizingCursor();

      while (cursor.hasNext()) {
        cursor.fwd();
        matrix.set(cursor.getIntPosition(0), 0, cursor.get().getRealDouble());
      }
    } else {
      matrix = new Matrix((int) maxtrixImg.dimension(0), (int) maxtrixImg.dimension(1));

      final Cursor<S> cursor = maxtrixImg.localizingCursor();

      while (cursor.hasNext()) {
        cursor.fwd();
        matrix.set(
            cursor.getIntPosition(0), cursor.getIntPosition(1), cursor.get().getRealDouble());
      }
    }

    return matrix;
  }
Ejemplo n.º 26
0
  /** @see LocalBernsenThreshold */
  @Test
  public void testLocalBernsenThreshold() {
    ops.run(
        LocalBernsenThreshold.class,
        out,
        in,
        new RectangleShape(3, false),
        new OutOfBoundsMirrorFactory<ByteType, Img<ByteType>>(Boundary.SINGLE),
        1.0,
        Double.MAX_VALUE * 0.5);

    assertEquals(out.firstElement().get(), true);
  }
Ejemplo n.º 27
0
 /** With a default {@link OutOfBoundsStrategyValueFactory} with @param outside. */
 @SuppressWarnings("unchecked")
 public AbstractAffine3D(
     final Img<T> img, final float[] matrix, final Mode mode, final Number outside)
     throws Exception {
   this(
       img,
       matrix,
       mode,
       new OutOfBoundsConstantValueFactory<T, Img<T>>(
           (T)
               withValue(
                   img, img.firstElement().createVariable(), outside))); // default value is zero
 }
Ejemplo n.º 28
0
 private static final <T extends RealType<T>> Img<T> process(
     final Img<ComplexDoubleType> fftImage, final FourierTransform<T, ComplexDoubleType> fft)
     throws Exception {
   final InverseFourierTransform<T, ComplexDoubleType> ifft =
       new InverseFourierTransform<T, ComplexDoubleType>(fftImage, fft);
   if (!ifft.checkInput() || !ifft.process()) {
     throw new Exception(
         "FFT: failed to process for image "
             + fftImage.getClass()
             + " -- "
             + ifft.getErrorMessage());
   }
   return ifft.getResult();
 }
Ejemplo n.º 29
0
  public Img<DoubleType> getImage() {
    // create the ImgFactory based on cells (cellsize = 5x5x5...x5) that will
    // instantiate the Img
    final ImgFactory<DoubleType> imgFactory = new CellImgFactory<DoubleType>(5);

    // create an 2d-Img with dimensions the of the value_array
    final Img<DoubleType> img1 =
        imgFactory.create(new long[] {getValues().length, getValues()[0].length}, new DoubleType());
    // System.out.println( "Create image with dimension: " + img1.dimension( 0 ) + " " +
    // img1.dimension( 1 ) );
    RandomAccess<DoubleType> ra = img1.randomAccess();

    for (int row = 0; row < getValues().length; row++) {
      for (int col = 0; col < getValues()[0].length; col++) {
        ra.setPosition(new int[] {row, col});
        // System.out.println( "Current cursor: " + ra.getIntPosition( 0 ) + " " +
        // ra.getIntPosition( 1 ) );
        ra.get().set(getValues()[row][col]);
      }
    }

    return img1;
  }
Ejemplo n.º 30
0
  /**
   * Computes a Gaussian convolution in-place (temporary imgs are necessary) with float precision on
   * an entire {@link Img}
   *
   * @param sigma - the sigma for the convolution
   * @param img - the img {@link Img} that will be convolved in place
   */
  public static <T extends RealType<T>> void inFloatInPlace(
      final double[] sigma,
      final Img<T> img,
      final OutOfBoundsFactory<FloatType, RandomAccessibleInterval<FloatType>> outofbounds) {
    GaussFloat gauss = null;
    try {
      if (FloatType.class.isInstance(img.firstElement())) {
        @SuppressWarnings({"rawtypes", "unchecked"})
        final Img<FloatType> img2 = (Img) img;
        gauss =
            new GaussFloat(
                sigma,
                Views.extend(img2, outofbounds),
                img2,
                img2,
                new Point(sigma.length),
                img2.factory().imgFactory(new FloatType()));
      } else {
        final RandomAccessibleInterval<FloatType> rIn =
            new WriteConvertedIterableRandomAccessibleInterval<T, FloatType, Img<T>>(
                img, new RealFloatSamplerConverter<T>());
        gauss =
            new GaussFloat(
                sigma,
                Views.extend(rIn, outofbounds),
                img,
                rIn,
                new Point(sigma.length),
                img.factory().imgFactory(new FloatType()));
      }
    } catch (final IncompatibleTypeException e) {
      System.out.println(e);
      return;
    }

    gauss.call();
  }