示例#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;
    }
  }
示例#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();
  }
示例#3
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;
 }
  /** @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);
  }
示例#5
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
 }
  /** @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);
  }
示例#7
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;
  }
示例#8
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);
  }
示例#9
0
 /** With a default {@link OutOfBoundsStrategyValueFactory} with @param outside. */
 @SuppressWarnings("unchecked")
 public AbstractAffine3D(
     final Img<T> img,
     final float scaleX,
     final float shearX,
     final float shearY,
     final float scaleY,
     final float translateX,
     final float translateY,
     final Mode mode,
     final Number outside)
     throws Exception {
   this(
       img,
       new float[] {scaleX, shearX, 0, translateX, shearY, scaleY, 0, translateY, 0, 0, 1, 0},
       mode,
       new OutOfBoundsConstantValueFactory<T, Img<T>>(
           (T) withValue(img, img.firstElement().createVariable(), outside)));
 }
示例#10
0
 @SuppressWarnings({"unchecked", "rawtypes"})
 private static final <N extends NumericType<N>> Img<N> process(
     final Img<N> img,
     final float[] matrix,
     final Mode mode,
     final OutOfBoundsFactory<N, Img<N>> oobf)
     throws Exception {
   if (matrix.length < 12) {
     throw new IllegalArgumentException(
         "Affine transform in 2D requires a matrix array of 12 elements.");
   }
   final Type<?> type = img.firstElement().createVariable();
   if (ARGBType.class.isAssignableFrom(
       type.getClass())) { // type instanceof RGBALegacyType fails to compile
     return (Img) processRGBA((Img) img, matrix, mode, (OutOfBoundsFactory) oobf);
   } else if (type instanceof RealType<?>) {
     return processReal((Img) img, matrix, mode, (OutOfBoundsFactory) oobf);
   } else {
     throw new Exception("Affine transform: cannot handle type " + type.getClass());
   }
 }
示例#11
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();
  }
示例#12
0
  @Override
  public boolean process() {
    final int numDimensions = img.numDimensions();
    final long integralSize[] = new long[numDimensions];

    // the size of the first dimension is changed
    for (int d = 0; d < numDimensions; ++d) integralSize[d] = img.dimension(d) + 1;

    final Img<T> integral = imgFactory.create(integralSize, type);

    // not enough RAM or disc space
    if (integral == null) return false;

    this.integral = integral;

    if (numDimensions > 1) {
      final long[] fakeSize = new long[numDimensions - 1];

      // the size of dimension 0
      final long size = integralSize[0];

      for (int d = 1; d < numDimensions; ++d) fakeSize[d - 1] = integralSize[d];

      final long imageSize = getNumPixels(fakeSize);

      final AtomicInteger ai = new AtomicInteger(0);
      final Thread[] threads = SimpleMultiThreading.newThreads();

      final Vector<Chunk> threadChunks =
          SimpleMultiThreading.divideIntoChunks(imageSize, threads.length);

      for (int ithread = 0; ithread < threads.length; ++ithread)
        threads[ithread] =
            new Thread(
                new Runnable() {
                  @Override
                  public void run() {
                    // Thread ID
                    final int myNumber = ai.getAndIncrement();

                    // get chunk of pixels to process
                    final Chunk myChunk = threadChunks.get(myNumber);
                    final long loopSize = myChunk.getLoopSize();

                    final LocalizingZeroMinIntervalIterator cursorDim =
                        new LocalizingZeroMinIntervalIterator(fakeSize);

                    // location for the input location
                    final long[] tmpIn = new long[numDimensions];

                    // location for the integral location
                    final long[] tmpOut = new long[numDimensions];

                    final long[] tmp = new long[numDimensions - 1];

                    final RandomAccess<R> cursorIn = img.randomAccess();
                    final RandomAccess<T> cursorOut = integral.randomAccess();

                    final T tmpVar = integral.firstElement().createVariable();
                    final T sum = integral.firstElement().createVariable();

                    cursorDim.jumpFwd(myChunk.getStartPosition());

                    // iterate over all dimensions except the one we are computing the integral in,
                    // which is dim=0 here
                    main:
                    for (long j = 0; j < loopSize; ++j) {
                      cursorDim.fwd();

                      // get all dimensions except the one we are currently doing the integral on
                      cursorDim.localize(tmp);

                      tmpIn[0] = 0;
                      tmpOut[0] = 1;

                      for (int d = 1; d < numDimensions; ++d) {
                        tmpIn[d] = tmp[d - 1] - 1;
                        tmpOut[d] = tmp[d - 1];

                        // all entries of position 0 are 0
                        if (tmpOut[d] == 0) continue main;
                      }

                      // set the cursor to the beginning of the correct line
                      cursorIn.setPosition(tmpIn);

                      // set the cursor in the integral image to the right position
                      cursorOut.setPosition(tmpOut);

                      // integrate over the line
                      integrateLineDim0(converter, cursorIn, cursorOut, sum, tmpVar, size);
                    }
                  }
                });

      SimpleMultiThreading.startAndJoin(threads);
    } else {
      final T tmpVar = integral.firstElement().createVariable();
      final T sum = integral.firstElement().createVariable();

      // the size of dimension 0
      final long size = integralSize[0];

      final RandomAccess<R> cursorIn = img.randomAccess();
      final RandomAccess<T> cursorOut = integral.randomAccess();

      cursorIn.setPosition(0, 0);
      cursorOut.setPosition(1, 0);

      // compute the first pixel
      converter.convert(cursorIn.get(), sum);
      cursorOut.get().set(sum);

      for (long i = 2; i < size; ++i) {
        cursorIn.fwd(0);
        cursorOut.fwd(0);

        converter.convert(cursorIn.get(), tmpVar);
        sum.add(tmpVar);
        cursorOut.get().set(sum);
      }

      return true;
    }

    for (int d = 1; d < numDimensions; ++d) {
      final int dim = d;

      final long[] fakeSize = new long[numDimensions - 1];

      // the size of dimension d
      final long size = integralSize[d];

      // get all dimensions except the one we are currently doing the integral on
      int countDim = 0;
      for (int e = 0; e < numDimensions; ++e) if (e != d) fakeSize[countDim++] = integralSize[e];

      final long imageSize = getNumPixels(fakeSize);

      final AtomicInteger ai = new AtomicInteger(0);
      final Thread[] threads = SimpleMultiThreading.newThreads();

      final Vector<Chunk> threadChunks =
          SimpleMultiThreading.divideIntoChunks(imageSize, threads.length);

      for (int ithread = 0; ithread < threads.length; ++ithread)
        threads[ithread] =
            new Thread(
                new Runnable() {
                  @Override
                  public void run() {
                    // Thread ID
                    final int myNumber = ai.getAndIncrement();

                    // get chunk of pixels to process
                    final Chunk myChunk = threadChunks.get(myNumber);
                    final long loopSize = myChunk.getLoopSize();

                    final LocalizingZeroMinIntervalIterator cursorDim =
                        new LocalizingZeroMinIntervalIterator(fakeSize);

                    // local instances
                    final long[] tmp2 = new long[numDimensions - 1];
                    final long[] tmp = new long[numDimensions];

                    final RandomAccess<T> cursor = integral.randomAccess();
                    final T sum = integral.firstElement().createVariable();

                    cursorDim.jumpFwd(myChunk.getStartPosition());

                    for (long j = 0; j < loopSize; ++j) {
                      cursorDim.fwd();

                      // get all dimensions except the one we are currently doing the integral on
                      cursorDim.localize(tmp2);

                      tmp[dim] = 1;
                      int countDim = 0;
                      for (int e = 0; e < numDimensions; ++e)
                        if (e != dim) tmp[e] = tmp2[countDim++];

                      // update the cursor in the input image to the current dimension position
                      cursor.setPosition(tmp);

                      // sum up line
                      integrateLine(dim, cursor, sum, size);
                    }
                  }
                });

      SimpleMultiThreading.startAndJoin(threads);
    }

    return true;
  }