Minor fixes linked to deprecated types and dependencies (#122)

* Replace deprecated np types

* Comment python dependencies from package.xml, as they no longer work

Author: cedricgoubard

rt_bene_model_training/pytorch/rtbene_dataset.py

@@ -65,7 +65,7 @@ def __getitem__(self, index):
         with h5py.File(self._h5_file, mode="r") as h5_file:
             left_img = h5_file[sample[0] + "/left"][sample[1]][()][0]
             right_img = h5_file[sample[0] + "/right"][sample[1]][()][0]
-            label = h5_file[sample[0] + "/label"][()].astype(np.float32)
+            label = h5_file[sample[0] + "/label"][()].astype(float)
 
             # Load data and get label
             transformed_left_img = self._transform(Image.fromarray(left_img, 'RGB'))

rt_gene/package.xml

@@ -42,15 +42,17 @@
   <depend>uvc_camera</depend>
   <depend>dynamic_reconfigure</depend>
 
-  <depend>python-opencv</depend>
+  <!-- Python dependencies, no longer installable this way -->
+  
+  <!-- <depend>python-opencv</depend>
   <depend>python-dlib</depend>
   <depend>python-scipy</depend>
   <depend>python-numpy</depend>
   <depend>python-tensorflow-gpu-pip</depend>
   <depend>python-tqdm</depend>
   <depend>python-imaging</depend>
   <depend>python-pytorch-pip</depend>
-  <depend>python-matplotlib</depend>
+  <depend>python-matplotlib</depend> -->
 
   <exec_depend>rviz</exec_depend>
   <exec_depend>message_runtime</exec_depend>

rt_gene/src/rt_gene/ThreeDDFA/io.py

@@ -88,19 +88,19 @@ def load_bfm(model_path):
         model = model[0, 0]
 
         model_new = {}
-        w_shp = model['w'].astype(np.float32)
+        w_shp = model['w'].astype(float)
         model_new['w_shp_sim'] = w_shp[:, :40]
-        w_exp = model['w_exp'].astype(np.float32)
+        w_exp = model['w_exp'].astype(float)
         model_new['w_exp_sim'] = w_exp[:, :10]
 
         u_shp = model['mu_shape']
         u_exp = model['mu_exp']
-        u = (u_shp + u_exp).astype(np.float32)
+        u = (u_shp + u_exp).astype(float)
         model_new['mu'] = u
-        model_new['tri'] = model['tri'].astype(np.int32) - 1
+        model_new['tri'] = model['tri'].astype(int) - 1
 
         # flatten it, pay attention to index value
-        keypoints = model['keypoints'].astype(np.int32) - 1
+        keypoints = model['keypoints'].astype(int) - 1
         keypoints = np.concatenate((3 * keypoints, 3 * keypoints + 1, 3 * keypoints + 2), axis=0)
 
         model_new['keypoints'] = keypoints.T.flatten()

rt_gene/src/rt_gene/estimate_gaze_tensorflow.py

@@ -70,7 +70,7 @@ def input_from_image(self, cv_image):
         """This method converts an eye_img_msg provided by the landmark estimator, and converts it to a format
         suitable for the gaze network."""
         currimg = cv_image.reshape(36, 60, 3, order='F')
-        currimg = currimg.astype(np.float32)
+        currimg = currimg.astype(float)
         testimg = np.zeros((36, 60, 3))
         testimg[:, :, 0] = currimg[:, :, 0] - 103.939
         testimg[:, :, 1] = currimg[:, :, 1] - 116.779

rt_gene/src/rt_gene/extract_landmarks_method_base.py

@@ -65,7 +65,7 @@ def get_full_model_points(self, model_points_file=None):
         with open(model_points_file) as f:
             for line in f:
                 raw_value.append(line)
-        model_points = np.array(raw_value, dtype=np.float32)
+        model_points = np.array(raw_value, dtype=float)
         model_points = np.reshape(model_points, (3, -1)).T
 
         # index the expansion of the model based.
@@ -115,7 +115,7 @@ def ddfa_forward_pass(self, color_img, roi_box_list):
         _input = torch.cat([facial_landmark_transform(img).unsqueeze(0) for img in img_step], 0)
         with torch.no_grad():
             _input = _input.to(self.device)
-            param = self.facial_landmark_nn(_input).cpu().numpy().astype(np.float32)
+            param = self.facial_landmark_nn(_input).cpu().numpy().astype(float)
 
         return [predict_68pts(p.flatten(), roi_box) for p, roi_box in zip(param, roi_box_list)]
 

rt_gene/src/rt_gene/kalman_stabilizer.py

@@ -51,44 +51,44 @@ def __init__(self,
         self.filter = cv2.KalmanFilter(state_num, measure_num, 0)
 
         # Store the state.
-        self.state = np.zeros((state_num, 1), dtype=np.float32)
+        self.state = np.zeros((state_num, 1), dtype=float)
 
         # Store the measurement result.
-        self.measurement = np.array((measure_num, 1), np.float32)
+        self.measurement = np.array((measure_num, 1), float)
 
         # Store the prediction.
-        self.prediction = np.zeros((state_num, 1), np.float32)
+        self.prediction = np.zeros((state_num, 1), float)
 
         # Kalman parameters setup for scalar.
         if self.measure_num == 1:
             self.filter.transitionMatrix = np.array([[1, 1],
-                                                     [0, 1]], np.float32)
+                                                     [0, 1]], float)
 
-            self.filter.measurementMatrix = np.array([[1, 1]], np.float32)
+            self.filter.measurementMatrix = np.array([[1, 1]], float)
 
             self.filter.processNoiseCov = np.array([[1, 0],
-                                                    [0, 1]], np.float32) * cov_process
+                                                    [0, 1]], float) * cov_process
 
             self.filter.measurementNoiseCov = np.array(
-                [[1]], np.float32) * cov_measure
+                [[1]], float) * cov_measure
 
         # Kalman parameters setup for point.
         if self.measure_num == 2:
             self.filter.transitionMatrix = np.array([[1, 0, 1, 0],
                                                      [0, 1, 0, 1],
                                                      [0, 0, 1, 0],
-                                                     [0, 0, 0, 1]], np.float32)
+                                                     [0, 0, 0, 1]], float)
 
             self.filter.measurementMatrix = np.array([[1, 0, 0, 0],
-                                                      [0, 1, 0, 0]], np.float32)
+                                                      [0, 1, 0, 0]], float)
 
             self.filter.processNoiseCov = np.array([[1, 0, 0, 0],
                                                     [0, 1, 0, 0],
                                                     [0, 0, 1, 0],
-                                                    [0, 0, 0, 1]], np.float32) * cov_process
+                                                    [0, 0, 0, 1]], float) * cov_process
 
             self.filter.measurementNoiseCov = np.array([[1, 0],
-                                                        [0, 1]], np.float32) * cov_measure
+                                                        [0, 1]], float) * cov_measure
 
     def update(self, measurement):
         """Update the filter"""
@@ -97,10 +97,10 @@ def update(self, measurement):
 
         # Get new measurement
         if self.measure_num == 1:
-            self.measurement = np.array([[np.float32(measurement[0])]])
+            self.measurement = np.array([[float(measurement[0])]])
         else:
-            self.measurement = np.array([[np.float32(measurement[0])],
-                                         [np.float32(measurement[1])]])
+            self.measurement = np.array([[float(measurement[0])],
+                                         [float(measurement[1])]])
 
         # Correct according to mesurement
         self.filter.correct(self.measurement)
@@ -112,13 +112,13 @@ def set_q_r(self, cov_process=0.1, cov_measure=0.001):
         """Set new value for processNoiseCov and measurementNoiseCov."""
         if self.measure_num == 1:
             self.filter.processNoiseCov = np.array([[1, 0],
-                                                    [0, 1]], np.float32) * cov_process
+                                                    [0, 1]], float) * cov_process
             self.filter.measurementNoiseCov = np.array(
-                [[1]], np.float32) * cov_measure
+                [[1]], float) * cov_measure
         else:
             self.filter.processNoiseCov = np.array([[1, 0, 0, 0],
                                                     [0, 1, 0, 0],
                                                     [0, 0, 1, 0],
-                                                    [0, 0, 0, 1]], np.float32) * cov_process
+                                                    [0, 0, 0, 1]], float) * cov_process
             self.filter.measurementNoiseCov = np.array([[1, 0],
-                                                        [0, 1]], np.float32) * cov_measure
+                                                        [0, 1]], float) * cov_measure

rt_gene/src/rt_gene/tracker_face_encoding.py

@@ -55,7 +55,7 @@ def __add_new_element(self, element):
 
         for untracked_encoding_id in list_to_check:
             previous_encoding = self.__encoding_list[untracked_encoding_id]
-            previous_encoding = np.fromstring(previous_encoding[1:-1], dtype=np.float, sep=",")
+            previous_encoding = np.fromstring(previous_encoding[1:-1], dtype=float, sep=",")
             distance = np.linalg.norm(previous_encoding - encoding, axis=0)
 
             # the new element and the previous encoding are the same person

rt_gene/src/rt_gene/tracker_generic.py

@@ -58,13 +58,13 @@ def get_eye_image_from_landmarks(subject, eye_image_size):
             # Now compute the bounding boxes
             # The left / right x-coordinates are computed as the landmark position plus/minus the margin
             # The bottom / top y-coordinates are computed according to the desired ratio, as the width of the image is known
-            left_bb = np.zeros(4, dtype=np.int)
+            left_bb = np.zeros(4, dtype=int)
             left_bb[0] = transformed_eye_landmarks[2][0] - lefteye_margin / 2.0
             left_bb[1] = lefteye_center_y - (lefteye_width + lefteye_margin) * desired_ratio
             left_bb[2] = transformed_eye_landmarks[3][0] + lefteye_margin / 2.0
             left_bb[3] = lefteye_center_y + (lefteye_width + lefteye_margin) * desired_ratio
 
-            right_bb = np.zeros(4, dtype=np.int)
+            right_bb = np.zeros(4, dtype=int)
             right_bb[0] = transformed_eye_landmarks[0][0] - righteye_margin / 2.0
             right_bb[1] = righteye_center_y - (righteye_width + righteye_margin) * desired_ratio
             right_bb[2] = transformed_eye_landmarks[1][0] + righteye_margin / 2.0

rt_gene_inpainting/GlassesCompletion.py

@@ -116,10 +116,10 @@ def image_completion_random_search(self, nIter=1000, GPU_ID="0"):
                 continue
 
             data_face = imread_PRL(filename_face, is_grayscale=False)
-            image_face = np.array(data_face).astype(np.float32)   
+            image_face = np.array(data_face).astype(float)   
 
             data_mask = imread_PRL(filename_mask, is_grayscale=True)
-            image_mask = np.array(data_mask).astype(np.float32)                            
+            image_mask = np.array(data_mask).astype(float)                            
 
             # Sample index
             sample_num = 1

rt_gene_inpainting/utils.py

@@ -11,16 +11,16 @@
 
 def imread_PRL(path, is_grayscale=False):
     if is_grayscale:
-        return scipy.misc.imread(path, flatten=True).astype(np.float) / 127.5 - 1.
+        return scipy.misc.imread(path, flatten=True).astype(float) / 127.5 - 1.
     else:
-        return scipy.misc.imread(path).astype(np.float) / 127.5 - 1.
+        return scipy.misc.imread(path).astype(float) / 127.5 - 1.
 
 
 def PRL_data_image_load(data, sample_idx=0):
     data_files = map(lambda i: data[i], sample_idx)
 
     data = [imread_PRL(data_file, is_grayscale=False) for data_file in data_files]
-    data_images = np.array(data).astype(np.float32)
+    data_images = np.array(data).astype(float)
 
     return data_images