challenge-bot.com Git - 3501/OpenCVShowImage/blob - IsolateImage.java

   1 import java.util.ArrayList;
   2 import java.util.Iterator;
   3
   4 import org.opencv.core.Core;
   5 import org.opencv.core.Mat;
   6 import org.opencv.core.MatOfPoint;
   7 import org.opencv.core.Point;
   8 import org.opencv.core.Rect;
   9 import org.opencv.core.Scalar;
  10 import org.opencv.core.Size;
  11 import org.opencv.imgcodecs.Imgcodecs;
  12 import org.opencv.imgproc.Imgproc;
  13
  14 public class IsolateImage {
  15
  16         public static Mat matOriginal;
  17         public static Mat filtered;
  18         public static Mat kernel;
  19         public static Mat matHierarchy;
  20
  21         public static final Scalar LOWER_BOUNDS = new Scalar(80, 80, 80);
  22         public static final Scalar UPPER_BOUNDS = new Scalar(140, 180, 140);
  23         public static final Scalar BLACK = new Scalar(0, 0, 0);
  24         public static final Scalar GRAY = new Scalar(100, 100, 100);
  25
  26         static {
  27                 System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
  28         }
  29
  30         public static void main(String args[]) throws Exception {
  31
  32                 matOriginal = new Mat();
  33                 filtered = new Mat();
  34                 matHierarchy = new Mat();
  35
  36                 kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(3, 3));
  37
  38                 findContours();
  39         }
  40
  41         public static void findContours() {
  42
  43                 ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>();
  44                 int frameCount = 0;
  45                 int THE_BEST_MAGIC_NUMBER = 300;
  46
  47                 contours.clear();
  48                 matOriginal = Imgcodecs.imread("imgs/goal2.png"); // convert image
  49                 // into matrix
  50
  51                 filtered = matOriginal;
  52
  53                 Imgproc.cvtColor(matOriginal, filtered, Imgproc.COLOR_BGR2GRAY);
  54                 // takes out unnecessary colors
  55
  56                 Imgproc.GaussianBlur(matOriginal, filtered, new Size(5, 5), Core.BORDER_DEFAULT);
  57
  58                 // bing bing bong bong
  59                 // bing bing bong bong
  60
  61                 // converts image to grayscale, blurs it, and detects edges
  62
  63                 Imgproc.Canny(matOriginal, filtered, 35, 125);
  64
  65                 Imgproc.findContours(filtered, contours, matHierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
  66
  67                 for (Iterator<MatOfPoint> iterator = contours.iterator(); iterator.hasNext();) {
  68                         MatOfPoint matOfPoint = iterator.next();
  69                         Rect rec = Imgproc.boundingRect(matOfPoint);
  70                         if (rec.height < THE_BEST_MAGIC_NUMBER || rec.width < THE_BEST_MAGIC_NUMBER) {
  71
  72                                 iterator.remove();
  73                         }
  74
  75                 }
  76                 Rect largestRec = null;
  77                 double largestRecArea = 0;
  78
  79                 for (MatOfPoint mop : contours) {
  80                         double recArea = Imgproc.contourArea(mop);
  81                         if (largestRecArea < recArea) {
  82                                 largestRec = Imgproc.boundingRect(mop);
  83                                 largestRecArea = recArea;
  84                         }
  85                 }
  86                 Imgproc.rectangle(matOriginal, largestRec.br(), largestRec.tl(), GRAY, 1);
  87
  88                 Imgcodecs.imwrite("output.png", filtered);
  89
  90         }
  91
  92         public static double distanceToCamera(double knownWidth, int focalLength, double perWidth) {
  93                 return (knownWidth * ((double) (focalLength))) / perWidth;
  94         }
  95
  96         public static void processImage() {
  97
  98                 ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>();
  99                 int frameCount = 0;
 100                 int THE_BEST_MAGIC_NUMBER = 300;
 101                 while (frameCount < 1) {
 102                         contours.clear();
 103                         matOriginal = Imgcodecs.imread("imgs/goal2.png"); // convert image
 104                         // into matrix
 105
 106                         filtered = matOriginal;
 107
 108                         Imgproc.GaussianBlur(matOriginal, filtered, new Size(25, 25), Core.BORDER_DEFAULT);
 109
 110                         Core.inRange(matOriginal, LOWER_BOUNDS, UPPER_BOUNDS, filtered);
 111                         Imgproc.erode(matOriginal, filtered, kernel, new Point(-1, -1), 5);
 112                         Imgproc.dilate(matOriginal, filtered, kernel, new Point(-1, -1), 0);
 113                         Imgproc.findContours(filtered, contours, matHierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 114
 115                         for (Iterator<MatOfPoint> iterator = contours.iterator(); iterator.hasNext();) {
 116                                 MatOfPoint matOfPoint = iterator.next();
 117                                 Rect rec = Imgproc.boundingRect(matOfPoint);
 118                                 if (rec.height < THE_BEST_MAGIC_NUMBER || rec.width < THE_BEST_MAGIC_NUMBER) {
 119
 120                                         iterator.remove();
 121                                 }
 122
 123                         }
 124
 125                         for (MatOfPoint mop : contours) {
 126                                 Rect rec = Imgproc.boundingRect(mop);
 127                                 Imgproc.rectangle(matOriginal, rec.br(), rec.tl(), GRAY, 1);
 128                                 System.out.println(rec.toString());
 129                         }
 130
 131                         frameCount++;
 132                 }
 133
 134                 Imgcodecs.imwrite("output.png", filtered);
 135
 136         }
 137
 138         /**
 139          * @param angle
 140          *            a nonnormalized angle
 141          */
 142
 143         public static double normalize360(double angle) {
 144                 while (angle >= 360.0) {
 145                         angle -= 360.0;
 146                 }
 147                 while (angle < 0.0) {
 148                         angle += 360.0;
 149                 }
 150                 return angle;
 151         }
 152 }