wip

Author: previ

camera.py

@@ -72,7 +72,6 @@ def __init__(self):
     self.video_start_time = time.time() + 8640000
     self._image_time = 0
     self._cv_image_factor = int(config.Config.get().get("cv_image_factor", 4))
-    #self._image_lock = Lock()
     self._image_refresh_timeout = float(config.Config.get().get("camera_refresh_timeout", 0.1))
     self._color_object_size_min = int(config.Config.get().get("camera_color_object_size_min", 80)) / (self._cv_image_factor * self._cv_image_factor)
     self._color_object_size_max = int(config.Config.get().get("camera_color_object_size_max", 32000)) / (self._cv_image_factor * self._cv_image_factor)
@@ -235,29 +234,23 @@ def find_line(self):
     return coords[0]
 
   def find_signal(self):
-    #print "signal"
     angle = None
     ts = time.time()
-    #self._image_lock.acquire()
     img = self.get_image()
     signals = img.find_template(self._img_template)
 
     logging.info("signal: " + str(time.time() - ts))
     if len(signals):
       angle = signals[0].angle
 
-    #self._image_lock.release()
-
     return angle
 
   def find_face(self):
     face_x = face_y = face_size = None
-    #self._image_lock.acquire()
     img = self.get_image()
     ts = time.time()
     faces = img.grayscale().find_faces()
     logging.info("face.detect: " + str(time.time() - ts))
-    #self._image_lock.release()
     if len(faces):
       # Get the largest face, face is a rectangle 
       x, y, w, h = faces[0]
@@ -292,18 +285,15 @@ def path_ahead(self):
       coordY = 60 - ((y * 48) / (480 / self._cv_image_factor)) 
       logging.info("x: " + str(x) + " y: " + str(y) + " coordY: " + str(coordY))
 
-    #self._image_lock.release()
     return coordY
 
   def find_color(self, s_color):
     image_size = self._camera.out_rgb_resolution
     color = (int(s_color[1:3],16), int(s_color[3:5],16), int(s_color[5:7],16))
     code_data = None
     ts = time.time()
-    #self._image_lock.acquire()
     img = self.get_image()
     bw = img.filter_color(color)
-    #self._image_lock.release()
     objects = bw.find_blobs(minsize=self._color_object_size_min, maxsize=self._color_object_size_max)
     logging.debug("objects: " + str(objects))
     dist = -1
@@ -330,9 +320,7 @@ def find_color(self, s_color):
   def find_text(self, accept, back_color):
     text = None
     color = (int(back_color[1:3],16), int(back_color[3:5],16), int(back_color[5:7],16))
-    #self._image_lock.acquire()
     img = self.get_image()
-    #self._image_lock.release()
     image = img.find_rect(color=color)
     if image:
       logging.info("image: " + str(image))
@@ -359,9 +347,7 @@ def cnn_classify(self, model_name=None):
     else:
       classifier = self._cnn_classifier_default
 
-    #self._image_lock.acquire()
     img = self.get_image()
-    #self._image_lock.release()
     classes = classifier.classify_image(img.mat())
     s_classes = sorted(classes.items(), key=lambda x: x[1], reverse=True)
     return s_classes

cnn_manager.py

@@ -127,4 +127,6 @@ def prepare_images(self):
 
     def clear_filesystem(self):
       shutil.rmtree(MODEL_TMP_PATH + "/" + self.model_name)
+      #shutil.rmtree(MODEL_TMP_PATH + "/bottleneck")
+      #shutil.rmtree(MODEL_TMP_PATH + "/retrain_logs")
 

cnn_train.py

@@ -138,6 +138,7 @@ def __init__(self, manager, architecture):
     self.bottleneck_dir = "/tmp/bottleneck"
     self.model_dir = "/tmp/imagenet"
     self.final_tensor_name = "final_result"
+    self.write_logs = False 
 
     # Needed to make sure the logging output is visible.
     # See https://github.com/tensorflow/tensorflow/issues/3047
@@ -223,11 +224,12 @@ def retrain(self,
 
       # Merge all the summaries and write them out to the summaries_dir
       merged = tf.summary.merge_all()
-      train_writer = tf.summary.FileWriter(self.summaries_dir + '/train',
+      if self.write_logs:
+        train_writer = tf.summary.FileWriter(self.summaries_dir + '/train',
                                          sess.graph)
 
-      validation_writer = tf.summary.FileWriter(
-        self.summaries_dir + '/validation')
+      if self.write_logs:
+        validation_writer = tf.summary.FileWriter(self.summaries_dir + '/validation')
 
       # Set up all our weights to their initial default values.
       init = tf.global_variables_initializer()
@@ -256,7 +258,8 @@ def retrain(self,
             [merged, train_step],
             feed_dict={bottleneck_input: train_bottlenecks,
                        ground_truth_input: train_ground_truth})
-        train_writer.add_summary(train_summary, i)
+        if self.write_logs:
+          train_writer.add_summary(train_summary, i)
 
         # Every so often, print out how well the graph is training.
         is_last_step = (i + 1 == training_steps)
@@ -281,7 +284,8 @@ def retrain(self,
             [merged, evaluation_step],
             feed_dict={bottleneck_input: validation_bottlenecks,
                        ground_truth_input: validation_ground_truth})
-          validation_writer.add_summary(validation_summary, i)
+          if self.write_logs:
+            validation_writer.add_summary(validation_summary, i)
           tf.logging.info('%s: Step %d: Validation accuracy = %.1f%% (N=%d)' %
                         (datetime.now(), i, validation_accuracy * 100,
                          len(validation_bottlenecks)))
@@ -377,31 +381,23 @@ def create_image_lists(self, image_dir, testing_percentage, validation_percentag
       training_images = []
       testing_images = []
       validation_images = []
+      testing_images_len = int(len(file_list) * testing_percentage / 100.0)
+      validation_images_len = int(len(file_list) * validation_percentage / 100.0)
+      while len(testing_images) <= testing_images_len:
+        file_name = random.choice(file_list)
+        file_list.remove(file_name)
+        base_name = os.path.basename(file_name)
+        testing_images.append(base_name)
+        print ("testing: " + base_name)
+      while len(validation_images) <= validation_images_len:
+        file_name = random.choice(file_list)
+        file_list.remove(file_name)
+        base_name = os.path.basename(file_name)
+        validation_images.append(base_name)
+        print ("validation: " + base_name)
       for file_name in file_list:
         base_name = os.path.basename(file_name)
-        # We want to ignore anything after '_nohash_' in the file name when
-        # deciding which set to put an image in, the data set creator has a way of
-        # grouping photos that are close variations of each other. For example
-        # this is used in the plant disease data set to group multiple pictures of
-        # the same leaf.
-        hash_name = re.sub(r'_nohash_.*$', '', file_name)
-        # This looks a bit magical, but we need to decide whether this file should
-        # go into the training, testing, or validation sets, and we want to keep
-        # existing files in the same set even if more files are subsequently
-        # added.
-        # To do that, we need a stable way of deciding based on just the file name
-        # itself, so we do a hash of that and then use that to generate a
-        # probability value that we use to assign it.
-        hash_name_hashed = hashlib.sha1(compat.as_bytes(hash_name)).hexdigest()
-        percentage_hash = ((int(hash_name_hashed, 16) %
-                            (MAX_NUM_IMAGES_PER_CLASS + 1)) *
-                           (100.0 / MAX_NUM_IMAGES_PER_CLASS))
-        if percentage_hash < validation_percentage:
-          validation_images.append(base_name)
-        elif percentage_hash < (testing_percentage + validation_percentage):
-          testing_images.append(base_name)
-        else:
-          training_images.append(base_name)
+        training_images.append(base_name)
       result[label_name] = {
           'dir': dir_name,
           'training': training_images,

coderbot.cfg

@@ -1 +1 @@
-{"move_tr_speed": "85", "move_fw_elapse": "1", "camera_color_object_size_min": "4000", "camera_jpeg_bitrate": "2000000", "load_at_start": "", "move_tr_elapse": "0.5", "sound_stop": "$shutdown.mp3", "show_control_move_commands": "true", "prog_level": "adv", "prog_scrollbars": "true", "move_fw_speed": "100", "camera_color_object_size_max": "160000", "sound_shutter": "$shutter.mp3", "show_page_prefs": "true", "cv_image_factor": "2", "ctrl_hud_image": "", "button_func": "none", "ctrl_fw_elapse": "-1", "ctrl_tr_elapse": "-1", "move_power_angle_2": "60", "move_power_angle_3": "60", "camera_path_object_size_max": "160000", "move_motor_trim": "1", "camera_path_object_size_min": "4000", "cnn_default_model": "apple_kiwi_fast", "show_page_program": "true", "sound_start": "$startup.mp3", "camera_exposure_mode": "auto", "ctrl_tr_speed": "80", "prog_move_mpu": "yes", "ctrl_fw_speed": "100", "camera_jpeg_quality": "20", "prog_maxblocks": "-1", "camera_framerate": "30", "move_motor_mode": "dc", "move_power_angle_1": "45", "show_page_control": "true"}
+{"move_tr_speed": "85", "move_fw_elapse": "1", "camera_color_object_size_min": "4000", "camera_jpeg_bitrate": "2000000", "load_at_start": "", "move_tr_elapse": "0.5", "sound_stop": "$shutdown.mp3", "show_control_move_commands": "true", "prog_level": "adv", "prog_scrollbars": "true", "move_fw_speed": "100", "camera_color_object_size_max": "160000", "sound_shutter": "$shutter.mp3", "show_page_prefs": "true", "cv_image_factor": "2", "ctrl_hud_image": "", "button_func": "none", "ctrl_fw_elapse": "-1", "ctrl_tr_elapse": "-1", "move_power_angle_2": "60", "move_power_angle_3": "60", "camera_path_object_size_max": "160000", "move_motor_trim": "1", "camera_path_object_size_min": "4000", "cnn_default_model": "harry_3_50", "show_page_program": "true", "sound_start": "$startup.mp3", "camera_exposure_mode": "auto", "ctrl_tr_speed": "80", "prog_move_mpu": "yes", "ctrl_fw_speed": "100", "camera_jpeg_quality": "20", "prog_maxblocks": "-1", "camera_framerate": "30", "move_motor_mode": "dc", "move_power_angle_1": "45", "show_page_control": "true"}

cv/image.py

@@ -50,7 +50,7 @@ class Image():
     r_from = np.float32([[0, 0], [640, 0], [640, 480], [0, 480]])
     r_dest   = np.float32([[0, -120], [640, -120], [380, 480], [260, 480]])
 
-    _aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_50) 
+    _aruco_dict = aruco.Dictionary_get(aruco.DICT_ARUCO_ORIGINAL) 
     _aruco_parameters =  aruco.DetectorParameters_create()
 
     #_face_cascade = cv2.CascadeClassifier('/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml')
@@ -271,6 +271,7 @@ def find_ar_code(self):
       codes = []
       positions = []
       if ids is not None:
+        print ids
         for i in range(0, len(ids)):
           codes.append(ids[i][0])
           rect = corners[i][0]

photos/metadata.json

@@ -253,6 +253,10 @@ <h3>{% trans %}Train new CNN Model{% endtrans %}</h3>
        <option value="mobilenet_0.75_128">MobileNet 0.75 128</option>
        <option value="mobilenet_0.50_128">MobileNet 0.50 128</option>
        <option value="mobilenet_0.25_128">MobileNet 0.25 128</option>
+       <option value="mobilenet_1.0_224">MobileNet 1.0 224</option>
+       <option value="mobilenet_0.75_224">MobileNet 0.75 224</option>
+       <option value="mobilenet_0.50_224">MobileNet 0.50 224</option>
+       <option value="mobilenet_0.25_224">MobileNet 0.25 224</option>
      </select>
      <label for="i_cnn_model_train_steps">{% trans %}Training steps{% endtrans %}</label>
      <input type="range" id="i_cnn_train_steps" name="cnn_train_steps" min="10" max="100" step="10" value="50">