Java GrayU8.getWidth方法代码示例

import boofcv.struct.image.GrayU8; //导入方法依赖的package包/类
public static GrayU8 binaryToDrawable(GrayU8 image) {
    GrayU8 drawable = new GrayU8(image.width,image.height);
    for (int y=0;y<image.getHeight();y++) {
        for (int x = 0; x < image.getWidth(); x++) {
            if (image.get(x, y) > 0) {
                drawable.set(x, y, BLACK);
            } else {
                drawable.set(x, y, WHITE);
            }
        }
    }
    return drawable;
}
 

import boofcv.struct.image.GrayU8; //导入方法依赖的package包/类
protected static float[] process(MultiImage img, float[] hist) {
  GrayU8 gray = ConvertBufferedImage.convertFrom(img.getBufferedImage(), (GrayU8) null);
  int width = img.getWidth(), height = img.getHeight();
  for (int x = 0; x < 4; ++x) {
    for (int y = 0; y < 4; ++y) {
      GrayU8 subImage = gray
          .subimage(width * x / 4, height * y / 4, width * (x + 1) / 4, height * (y + 1) / 4,
              null);
      int count = 0;
      int[] tmp = new int[5];
      for (int xx = 0; xx < subImage.getWidth() - 1; xx += 2) {
        for (int yy = 0; yy < subImage.getHeight() - 1; yy += 2) {
          count++;
          int index = edgeType(
              subImage.unsafe_get(xx, yy),
              subImage.unsafe_get(xx + 1, yy),
              subImage.unsafe_get(xx, yy + 1),
              subImage.unsafe_get(xx + 1, yy + 1)
          );
          if (index > -1) {
            tmp[index]++;
          }
        }
      }
      int offset = (4 * x + y) * 5;
      for (int i = 0; i < 5; ++i) {
        hist[offset + i] += ((float) tmp[i]) / (float) count;
      }
    }
  }
  return hist;
}
 

import boofcv.struct.image.GrayU8; //导入方法依赖的package包/类
/**
 * Consider only the points with strong derivates and remove the rest.
 */
private GrayU8 derivateCleanser( GrayU8 input ) {
    int blurRadius = 5;

    imageShower.show(input,"Derivates Input");

    GrayU8 blurred = new GrayU8(input.width,input.height);
    GrayS16 derivX = new GrayS16(input.width,input.height);
    GrayS16 derivY = new GrayS16(input.width,input.height);

    // Gaussian blur: Convolve a Gaussian kernel
    BlurImageOps.gaussian(input,blurred,-1,blurRadius,null);

    logTime("derivateCleanser a");

    // Calculate image's derivative
    GradientSobel.process(blurred, derivX, derivY, FactoryImageBorderAlgs.extend(input));

    logTime("derivateCleanser b");

    // First I save on a matrix if the point has a strong derivative
    int derivThreshold = 100;
    Map<Point, Boolean> pointsWithStrongDerivates = new HashMap<>();
    for (int y=0; y<input.getHeight(); y++) {
        for (int x=0; x<input.getWidth(); x++) {
            int dx = derivX.get(x, y);
            int dy = derivY.get(x, y);
            int totalDeriv = Math.abs(dx) + Math.abs(dy);
            if (totalDeriv > derivThreshold) {
                pointsWithStrongDerivates.put(new Point(x, y), true);
            }
        }
    }

    logTime("derivateCleanser c");

    // Second: I remove points with strong derivatives if they have not enough other points with strong derivates
    //         near them
    GrayU8 pointsToKeep = removeIsolatedPoints(pointsWithStrongDerivates, input.getWidth(), input.getHeight());

    logTime("derivateCleanser d");
    imageShower.show(pointsToKeep,"Derivates pointsToKeep");

    // display the results
    if (imageShower.verbose()) {
        BufferedImage outputImage = VisualizeImageData.colorizeGradient(derivX, derivY, -1);
        imageShower.show(outputImage, "Derivates");
    }
    imageShower.show(input,"Derivates Cleansed");
    imageShower.show(input,"Derivates Output");

    logTime("derivateCleanser e");

    return pointsToKeep;
}