wip #70

Author: previ

.camera.py.swp

@@ -94,12 +94,19 @@ def __init__(self):
             self._cnn_classifier_default = self._cnn_classifiers[cnn_model]
 
         self._camera.grab_start()
+        self._image_cv = self.get_image()
 
         super(Camera, self).__init__()
 
     def get_image(self):
         return image.Image(self._camera.get_image_bgr())
 
+    def get_image_cv_jpeg(self):
+        return self._image_cv.to_jpeg()
+
+    def set_image_cv(self, image):
+        self._image_cv = image
+
     def get_image_jpeg(self):
         return self._camera.get_image_jpeg()
 
@@ -218,20 +225,26 @@ def get_average(self):
         return avg
 
     def find_line(self):
-        img = self.get_image().binarize()
-        #img = img.erode().dilate()
+        avg = self.get_image().get_average()
+        img = self.get_image().binarize(int((avg[0]+avg[2])/2))
+        img = img.erode().dilate()
         slices = [0,0,0]
         blobs = [0,0,0]
         slices[0] = img.crop(0, int(self._camera.out_rgb_resolution[1]/1.2), self._camera.out_rgb_resolution[0], self._camera.out_rgb_resolution[1])
         slices[1] = img.crop(0, int(self._camera.out_rgb_resolution[1]/1.5), self._camera.out_rgb_resolution[0], int(self._camera.out_rgb_resolution[1]/1.2))
         slices[2] = img.crop(0, int(self._camera.out_rgb_resolution[1]/2.0), self._camera.out_rgb_resolution[0], int(self._camera.out_rgb_resolution[1]/1.5))
+        y_offset = [int(self._camera.out_rgb_resolution[1]/1.2),
+                    int(self._camera.out_rgb_resolution[1]/1.5),
+                    int(self._camera.out_rgb_resolution[1]/2.0)]
         coords = [-1, -1, -1]
         for idx, slice in enumerate(slices):
-            blobs[idx] = slice.find_blobs(minsize=300/(self._cv_image_factor * self._cv_image_factor), maxsize=8000/(self._cv_image_factor * self._cv_image_factor))
+            blobs[idx] = slice.find_blobs(minsize=2000/(self._cv_image_factor * self._cv_image_factor), maxsize=8000/(self._cv_image_factor * self._cv_image_factor))
             if len(blobs[idx]):
                 coords[idx] = (blobs[idx][0].center[0] * 100) / self._camera.out_rgb_resolution[0]
-                logging.info("line coord: " + str(idx) + " " +  str(coords[idx])+ " area: " + str(blobs[idx][0].area()))
-
+                #logging.info("line coord: " + str(idx) + " " +  str(coords[idx])+ " area: " + str(blobs[idx][0].area()))
+                blob = blobs[idx][0]
+                img.draw_rect(blob.left, y_offset[idx] + blob.top, blob.right, y_offset[idx] + blob.bottom, (0,255,0), 5) 
+        self.set_image_cv(img)
         return coords
 
     def find_signal(self):

camera.py

@@ -50,6 +50,9 @@ def area(self):
     def minAreaRect(self):
         return cv2.minAreaRect(self._contour)
 
+    def contour(self):
+        return self._contour
+
     @classmethod
     def sort_distance(cls, point, blobs):
         return sorted(blobs, key=lambda blob: (point[0] - blob.bottom))

cv/blob.py

@@ -137,13 +137,16 @@ def grayscale(self):
         data = cv2.cvtColor(self._data, cv2.COLOR_BGR2GRAY)
         return Image(data)
 
+    def blackwhite(self):
+        data = cv2.threshold(self._data, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
+        return Image(data)
+
     def invert(self):
         data = cv2.bitwise_not(self._data)
         return Image(data)
 
     def binarize(self, threshold = -1):
         data = cv2.cvtColor(self._data, cv2.COLOR_BGR2GRAY)
-        #data = cv2.adaptiveThreshold(data, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 11, 0)
         if threshold < 0:
             data = cv2.adaptiveThreshold(data, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, max((self._kernel.shape[0]/2*2)+1, 3), 3)
         else:
@@ -161,10 +164,7 @@ def get_average(self):
     def find_blobs(self, minsize=0, maxsize=10000000):
         blobs = []
         image = contours = hyerarchy = None
-        if "2.4" in cv2.__version__:
-            contours, hyerarchy = cv2.findContours(self._data, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
-        else:
-            image, contours, hyerarchy = cv2.findContours(self._data, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+        image, contours, hyerarchy = cv2.findContours(self._data, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
 
         for c in contours:
             area = cv2.contourArea(c)
@@ -280,6 +280,12 @@ def find_ar_code(self):
                                       (rect[0][1]+rect[1][1]+rect[2][1]+rect[3][1])/4])
 	return {"codes": codes, "positions": positions}
 
+    def draw_blob(self, blob):
+        cv2.drawContours(self._data, blob.contour(), -1, (0,255,0))
+ 
+    def draw_rect(self, x1, y1, x2, y2, color, thickness):
+        cv2.rectangle(self._data, (x1,y1), (x2,y2), color, thickness)
+
     def to_jpeg(self):
         ret, jpeg_array = cv2.imencode('.jpeg', self._data)
         return np.array(jpeg_array).tostring()

cv/image.py

@@ -204,6 +204,26 @@ def handle_video_stream():
         return Response(video_stream(cam), headers=h, mimetype="multipart/x-mixed-replace; boundary=--BOUNDARYSTRING")
     except: pass
 
+def video_stream_cv(cam):
+    while not app.shutdown_requested:
+        frame = cam.get_image_cv_jpeg()
+        yield ("--BOUNDARYSTRING\r\n" +
+               "Content-type: image/jpeg\r\n" +
+               "Content-Length: " + str(len(frame)) + "\r\n\r\n" +
+               frame + "\r\n")
+
+@app.route("/video/stream/cv")
+def handle_video_stream_cv():
+    try:
+        h = Headers()
+        h.add('Age', 0)
+        h.add('Cache-Control', 'no-cache, private')
+        h.add('Pragma', 'no-cache')
+        return Response(video_stream_cv(cam), headers=h, mimetype="multipart/x-mixed-replace; boundary=--BOUNDARYSTRING")
+    except: pass
+
+
+
 @app.route("/photos", methods=["GET"])
 def handle_photos():
     logging.info("photos")

main.py

@@ -168,8 +168,10 @@ def run(self):
             get_event().wait_event_generators()
         except RuntimeError as re:
             logging.info("quit: " + str(re))
+            raise
         except Exception as e:
             logging.info("quit: " + str(e))
+            raise
 
         finally:
             try: