public static void set(ImageSingleBand img, int x, int y, double value) {
   if (ImageInteger.class.isAssignableFrom(img.getClass())) {
     ((ImageInteger) img).set(x, y, (int) value);
   } else if (img instanceof ImageFloat32) {
     ((ImageFloat32) img).set(x, y, (float) value);
   } else if (img instanceof ImageFloat64) {
     ((ImageFloat64) img).set(x, y, value);
   } else {
     throw new IllegalArgumentException(
         "Unknown or incompatible image type: " + img.getClass().getSimpleName());
   }
 }
Esempio n. 2
0
  public static BufferedImage standard(ImageSingleBand<?> src, BufferedImage dst) {
    if (src.getDataType().isInteger()) {
      ImageInteger srcInt = (ImageInteger) src;

      if (src.getDataType().isSigned()) {
        double max = GImageStatistics.maxAbs(srcInt);
        return colorizeSign(srcInt, dst, (int) max);
      } else {
        if (src.getDataType().getNumBits() == 8) {
          dst = ConvertBufferedImage.convertTo((ImageUInt8) src, dst);
        } else {
          double max = GImageStatistics.maxAbs(srcInt);
          dst = grayUnsigned(srcInt, dst, (int) max);
        }
      }
    } else if (ImageFloat32.class.isAssignableFrom(src.getClass())) {
      ImageFloat32 img = (ImageFloat32) src;
      float max = ImageStatistics.maxAbs(img);

      boolean hasNegative = false;
      for (int i = 0; i < img.getHeight(); i++) {
        for (int j = 0; j < img.getWidth(); j++) {
          if (img.get(j, i) < 0) {
            hasNegative = true;
            break;
          }
        }
      }

      if (hasNegative) return colorizeSign(img, dst, (int) max);
      else return grayMagnitude((ImageFloat32) src, dst, max);
    }

    return dst;
  }
  /**
   * Converts an image from one type to another type.
   *
   * @param src Input image. Not modified.
   * @param dst Converted output image. Modified.
   * @return Converted image.
   */
  @SuppressWarnings({"unchecked"})
  public static void convert(ImageSingleBand<?> src, ImageSingleBand<?> dst) {
    if (src.getClass() == dst.getClass()) {
      ((ImageSingleBand) dst).setTo(src);
      return;
    }

    Method m =
        BoofTesting.findMethod(ImplConvertImage.class, "convert", src.getClass(), dst.getClass());
    try {
      m.invoke(null, src, dst);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      throw new RuntimeException(e);
    }
  }
 public static double get(ImageSingleBand img, int x, int y) {
   if (img instanceof ImageInt8) {
     return ((ImageInt8) img).get(x, y);
   } else if (img instanceof ImageInt16) {
     return ((ImageInt16) img).get(x, y);
   } else if (img instanceof ImageSInt32) {
     return ((ImageSInt32) img).get(x, y);
   } else if (img instanceof ImageFloat32) {
     return ((ImageFloat32) img).get(x, y);
   } else if (img instanceof ImageFloat64) {
     return ((ImageFloat64) img).get(x, y);
   } else if (img instanceof ImageSInt64) {
     return ((ImageSInt64) img).get(x, y);
   } else {
     throw new IllegalArgumentException(
         "Unknown or incompatible image type: " + img.getClass().getSimpleName());
   }
 }
Esempio n. 5
0
  /**
   * Renders a colored image where the color indicates the sign and intensity its magnitude. The
   * input is divided by normalize to render it in the appropriate scale.
   *
   * @param src Input single band image.
   * @param dst Where the image is rendered into. If null a new BufferedImage will be created and
   *     return.
   * @param normalize Used to normalize the input image. If <= 0 then the max value will be used
   * @return Rendered image.
   */
  public static BufferedImage colorizeSign(
      ImageSingleBand src, BufferedImage dst, double normalize) {
    dst = checkInputs(src, dst);

    if (normalize <= 0) {
      normalize = GImageStatistics.maxAbs(src);
    }

    if (normalize == 0) {
      // sets the output to black
      ConvertBufferedImage.convertTo(src, dst, true);
      return dst;
    }

    if (src.getClass().isAssignableFrom(ImageFloat32.class)) {
      return colorizeSign((ImageFloat32) src, dst, (float) normalize);
    } else {
      return colorizeSign((ImageInteger) src, dst, (int) normalize);
    }
  }