Beispiel #1
0
 protected Image<FloatType> getFloatImage() {
   if (floatImage == null) {
     ImageConverter<T, FloatType> convertToFloat =
         new ImageConverter<T, FloatType>(
             input, getFloatFactory(), new RealTypeConverter<T, FloatType>());
     if (!convertToFloat.process()) return null;
     floatImage = convertToFloat.getResult();
   }
   return floatImage;
 }
Beispiel #2
0
  /**
   * Return a difference of gaussian image that measures the gradient at a scale defined by the two
   * sigmas of the gaussians.
   *
   * @param image
   * @param sigma1
   * @param sigma2
   * @return
   */
  public Image<FloatType> getGradientImage() {
    /*
     * Create the DoG kernel.
     */
    double[][] kernels1d1 = new double[input.getNumDimensions()][];
    double[][] kernels1d2 = new double[input.getNumDimensions()][];
    int[] kernelDimensions = input.createPositionArray();
    int[] offset = input.createPositionArray();
    for (int i = 0; i < kernels1d1.length; i++) {
      kernels1d1[i] = Util.createGaussianKernel1DDouble(sigma1[i], true);
      kernels1d2[i] = Util.createGaussianKernel1DDouble(sigma2[i], true);
      kernelDimensions[i] = kernels1d1[i].length;
      offset[i] = (kernels1d1[i].length - kernels1d2[i].length) / 2;
    }
    Image<FloatType> kernel = getFloatFactory().createImage(kernelDimensions);
    LocalizableCursor<FloatType> kc = kernel.createLocalizableCursor();
    int[] position = input.createPositionArray();
    for (FloatType t : kc) {
      kc.getPosition(position);
      double value1 = 1;
      double value2 = 1;
      for (int i = 0; i < kernels1d1.length; i++) {
        value1 *= kernels1d1[i][position[i]];
        int position2 = position[i] - offset[i];
        if ((position2 >= 0) && (position2 < kernels1d2[i].length)) {
          value2 *= kernels1d2[i][position2];
        } else {
          value2 = 0;
        }
      }
      t.setReal(value1 - value2);
    }
    kc.close();
    /*
     * Apply the kernel to the image.
     */
    FourierConvolution<FloatType, FloatType> convolution =
        new FourierConvolution<FloatType, FloatType>(getFloatImage(), kernel);
    if (!convolution.process()) return null;
    Image<FloatType> result = convolution.getResult();
    /*
     * Quantize the image.
     */
    ComputeMinMax<FloatType> computeMinMax = new ComputeMinMax<FloatType>(result);
    computeMinMax.process();
    final float min = computeMinMax.getMin().get();
    final float max = computeMinMax.getMax().get();
    if (max == min) return result;

    ImageConverter<FloatType, FloatType> quantizer =
        new ImageConverter<FloatType, FloatType>(
            result,
            result.getImageFactory(),
            new Converter<FloatType, FloatType>() {

              @Override
              public void convert(FloatType input, FloatType output) {
                float value = (input.get() - min) / (max - min);
                value = Math.round(value * 100);
                output.set(value);
              }
            });
    quantizer.process();
    return quantizer.getResult();
  }
Beispiel #3
0
  @Override
  public boolean process() {
    floatImage = null;
    if (output == null) {
      output = new Labeling<L>(labelingFactory, input.getDimensions(), null);
    } else {
      /*
       * Initialize the output to all background
       */
      LocalizableCursor<LabelingType<L>> c = output.createLocalizableCursor();
      List<L> background = c.getType().intern(new ArrayList<L>());
      for (LabelingType<L> t : c) {
        t.setLabeling(background);
      }
      c.close();
    }
    /*
     * Get the smoothed image.
     */
    Image<FloatType> kernel =
        FourierConvolution.createGaussianKernel(input.getContainerFactory(), scale);
    FourierConvolution<FloatType, FloatType> convolution =
        new FourierConvolution<FloatType, FloatType>(getFloatImage(), kernel);
    if (!convolution.process()) return false;
    Image<FloatType> smoothed = convolution.getResult();

    /*
     * Find the local maxima and label them individually.
     */
    PickImagePeaks<FloatType> peakPicker = new PickImagePeaks<FloatType>(smoothed);
    peakPicker.setSuppression(scale);
    peakPicker.process();
    Labeling<L> seeds = output.createNewLabeling();
    LocalizableByDimCursor<LabelingType<L>> lc = seeds.createLocalizableByDimCursor();
    LocalizableByDimCursor<FloatType> imageCursor = smoothed.createLocalizableByDimCursor();
    int[] dimensions = input.getDimensions();
    for (int[] peak : peakPicker.getPeakList()) {
      if (!filterPeak(imageCursor, peak, dimensions, false)) continue;
      lc.setPosition(peak);
      lc.getType().setLabel(names.next());
    }
    imageCursor.close();
    /*
     * Find the local minima and label them all the same.
     */
    List<L> background = lc.getType().intern(names.next());
    Converter<FloatType, FloatType> invert =
        new Converter<FloatType, FloatType>() {

          @Override
          public void convert(FloatType input, FloatType output) {
            output.setReal(-input.getRealFloat());
          }
        };
    ImageConverter<FloatType, FloatType> invSmoothed =
        new ImageConverter<FloatType, FloatType>(smoothed, smoothed, invert);
    invSmoothed.process();
    peakPicker = new PickImagePeaks<FloatType>(smoothed);
    peakPicker.setSuppression(scale);
    peakPicker.process();
    imageCursor = smoothed.createLocalizableByDimCursor();
    for (int[] peak : peakPicker.getPeakList()) {
      if (!filterPeak(imageCursor, peak, dimensions, true)) continue;
      lc.setPosition(peak);
      lc.getType().setLabeling(background);
    }
    lc.close();
    imageCursor.close();
    smoothed = null;
    invSmoothed = null;
    Image<FloatType> gradientImage = getGradientImage();
    if (gradientImage == null) return false;
    /*
     * Run the seeded watershed on the image.
     */
    Watershed.seededWatershed(gradientImage, seeds, structuringElement, output);
    return true;
  }