コード例 #1
0
  /**
   * This method will perform erosion operation on the binary image img. A binary image has two
   * types of pixels - Black and White. WHITE pixel has the ARGB value (255,255,255,255) BLACK pixel
   * has the ARGB value (255,0,0,0)
   *
   * <p>For erosion we generally consider foreground pixel. So, erodeForegroundPixel = true
   *
   * @param img The image on which erosion operation is performed
   * @param erodeForegroundPixel If set to TRUE will perform erosion on WHITE pixels else on BLACK
   *     pixels.
   */
  public static void binaryImage(MyImage img, boolean erodeForegroundPixel) {
    /** Dimension of the image img. */
    int width = img.getImageWidth();
    int height = img.getImageHeight();

    /** This will hold the erosion result which will be copied to image img. */
    int output[] = new int[width * height];

    /**
     * If erosion is to be performed on BLACK pixels then targetValue = 0 else targetValue = 255;
     * //for WHITE pixels
     */
    int targetValue = (erodeForegroundPixel == true) ? 0 : 255;

    /**
     * If the target pixel value is WHITE (255) then the reverse pixel value will be BLACK (0) and
     * vice-versa.
     */
    int reverseValue = (targetValue == 255) ? 0 : 255;

    // perform erosion
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        // For BLACK pixel RGB all are set to 0 and for WHITE pixel all are set to 255.
        if (img.getRed(x, y) == targetValue) {
          /** We are using a 3x3 kernel [1, 1, 1 1, 1, 1 1, 1, 1] */
          boolean flag = false; // this will be set if a pixel of reverse value is found in the mask
          for (int ty = y - 1; ty <= y + 1 && flag == false; ty++) {
            for (int tx = x - 1; tx <= x + 1 && flag == false; tx++) {
              if (ty >= 0 && ty < height && tx >= 0 && tx < width) {
                // origin of the mask is on the image pixels
                if (img.getRed(tx, ty) != targetValue) {
                  flag = true;
                  output[x + y * width] = reverseValue;
                }
              }
            }
          }
          if (flag == false) {
            // all pixels inside the mask [i.e., kernel] were of targetValue
            output[x + y * width] = targetValue;
          }
        } else {
          output[x + y * width] = reverseValue;
        }
      }
    }

    /** Save the erosion value in image img. */
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        int v = output[x + y * width];
        img.setPixel(x, y, 255, v, v, v);
      }
    }
  }
コード例 #2
0
  /**
   * This method will perform erosion operation on the grayscale image img. It will find the minimum
   * value among the pixels that are under the mask [element value 1] and will set the origin to the
   * minimum value.
   *
   * @param img The image on which erosion operation is performed
   * @param mask the square mask.
   * @param maskSize the size of the square mask. [i.e., number of rows]
   */
  public static void grayscaleImage(MyImage img, int mask[], int maskSize) {
    /** Dimension of the image img. */
    int width = img.getImageWidth();
    int height = img.getImageHeight();

    // buff
    int buff[];

    // output of erosion
    int output[] = new int[width * height];

    // perform erosion
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        buff = new int[maskSize * maskSize];
        int i = 0;
        for (int ty = y - maskSize / 2, mr = 0; ty <= y + maskSize / 2; ty++, mr++) {
          for (int tx = x - maskSize / 2, mc = 0; tx <= x + maskSize / 2; tx++, mc++) {
            /**
             * Sample 3x3 mask [kernel or structuring element] [0, 1, 0 1, 1, 1 0, 1, 0]
             *
             * <p>Only those pixels of the image img that are under the mask element 1 are
             * considered.
             */
            if (ty >= 0 && ty < height && tx >= 0 && tx < width) {
              // pixel under the mask

              if (mask[mc + mr * maskSize] != 1) {
                continue;
              }

              buff[i] = img.getRed(tx, ty);
              i++;
            }
          }
        }

        // sort buff
        java.util.Arrays.sort(buff);

        // save lowest value
        output[x + y * width] = buff[(maskSize * maskSize) - i];
      }
    }

    /** Save the erosion value in image img. */
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        int v = output[x + y * width];
        img.setPixel(x, y, 255, v, v, v);
      }
    }
  }
コード例 #3
0
  /**
   * This method will perform erosion operation on the grayscale image img.
   *
   * @param img The image on which erosion operation is performed
   */
  public static void grayscaleImage(MyImage img) {
    /** Dimension of the image img. */
    int width = img.getImageWidth();
    int height = img.getImageHeight();

    // buff
    int buff[];

    // output of erosion
    int output[] = new int[width * height];

    // perform erosion
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        buff = new int[9];
        int i = 0;
        for (int ty = y - 1; ty <= y + 1; ty++) {
          for (int tx = x - 1; tx <= x + 1; tx++) {
            /** 3x3 mask [kernel or structuring element] [1, 1, 1 1, 1, 1 1, 1, 1] */
            if (ty >= 0 && ty < height && tx >= 0 && tx < width) {
              // pixel under the mask
              buff[i] = img.getRed(tx, ty);
              i++;
            }
          }
        }

        // sort buff
        java.util.Arrays.sort(buff);

        // save lowest value
        output[x + y * width] = buff[9 - i];
      }
    }

    /** Save the erosion value in image img. */
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        int v = output[x + y * width];
        img.setPixel(x, y, 255, v, v, v);
      }
    }
  }