def recognize_srv_callback(self, req):
"""
Method callback for the Recognize.srv
:param req: The service request
"""
self._response.recognitions = []
self._recognizing = True
try:
cv_image = self.bridge.imgmsg_to_cv2(req.image, "bgr8")
except CvBridgeError as e:
rospy.logerr(e)
self._image_widget.set_image(cv_image)
self._done_recognizing_button.setDisabled(False)
timeout = 60.0 # Maximum of 60 seconds
future = rospy.Time.now() + rospy.Duration(timeout)
rospy.loginfo("Waiting for manual recognition, maximum of %d seconds", timeout)
while not rospy.is_shutdown() and self._recognizing:
if rospy.Time.now() > future:
raise rospy.ServiceException("Timeout of %d seconds exceeded .." % timeout)
rospy.sleep(rospy.Duration(0.1))
self._done_recognizing_button.setDisabled(True)
return self._response
python类CvBridgeError()的实例源码
def grabImage(self, sim=False, viz=False):
# Grab image from Kinect sensor
msg = rospy.wait_for_message('/semihaptics/image' if not sim else '/wide_stereo/left/image_color', Image)
try:
image = self.bridge.imgmsg_to_cv2(msg)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if viz:
PILImage.fromarray(np.uint8(image)).show()
return image
except CvBridgeError, e:
print e
return None
def callback_image(self, data):
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
rospy.logerr('[ros-video-recorder][VideoFrames] Converting Image Error. ' + str(e))
return
self.frames.append((time.time(), cv_image))
def start_record(self):
self.start_time = time.time()
curr_time = self.start_time
while self.end_time < 0 or curr_time <= self.end_time:
try:
canvas = np.zeros((self.output_height, self.output_width, 3), np.uint8)
for frame_w in self.frame_wrappers:
f = frame_w.get_latest(at_time=curr_time)
if f is None:
continue
resized = cv2.resize(f, (frame_w.target_w, frame_w.target_h))
canvas[frame_w.target_y:frame_w.target_y+frame_w.target_h, frame_w.target_x:frame_w.target_x+frame_w.target_w] = resized
# rospy.sleep(0.01)
self.video_writer.write(canvas)
if self.pub_img:
try:
self.pub_img.publish(self.bridge.cv2_to_imgmsg(canvas, 'bgr8'))
except CvBridgeError as e:
rospy.logerr('cvbridgeerror, e={}'.format(str(e)))
pass
rospy.sleep(0.01)
if rospy.is_shutdown() and self.end_time < 0:
self.terminate()
while curr_time + self.interval > time.time():
rospy.sleep(self.interval)
curr_time += self.interval
except KeyboardInterrupt:
self.terminate()
continue
self.video_writer.release()
def color_detection(self, data):
""" Callback to detect r, g, and b values in the image """
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print e
hsv = cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV)
for request in self.detection_requests:
request.detection(hsv)
#############################################
# Stereo image point cloud processing members
#############################################
def left_color_detection(self, data):
""" Callback to detect r, g, and b values in the image """
try:
self.left_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as excep:
print excep
for processor in self.processors:
if processor.side&self.LEFT == self.LEFT:
processor.process_image(self.left_image, data.header, 'left')
def right_color_detection(self, data):
""" Callback to detect r, g, and b values in the image """
try:
self.right_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as excep:
print excep
for processor in self.processors:
if processor.side&self.RIGHT == self.RIGHT:
processor.process_image(self.right_image, data.header, 'right')
def left_color_detection(self, data):
""" Callback to detect r, g, and b values in the image """
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print e
self.process_image(cv_image, data.header, 'left')
def right_color_detection(self, data):
""" Callback to detect r, g, and b values in the image """
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print e
self.process_image(cv_image, data.header, 'right')
def _learn_face_srv(self, req):
try:
bgr_image = self._bridge.imgmsg_to_cv2(req.image, "bgr8")
except CvBridgeError as e:
error_msg = "Could not convert to opencv image: %s" % e
rospy.logerr(error_msg)
return {"error_msg": error_msg}
now = datetime.now()
cv2.imwrite("%s/%s_learn_%s.jpeg" % (self._storage_folder, now.strftime("%Y-%m-%d-%H-%M-%S-%f"), req.name), bgr_image)
try:
rep = self._get_rep(bgr_image)
except Exception as e:
error_msg = "Could not get representation of face image: %s" % e
rospy.logerr(error_msg)
return {"error_msg": error_msg}
if req.name not in self._face_dict:
self._face_dict[req.name] = []
self._face_dict[req.name].append(rep)
rospy.loginfo("Succesfully learned face of '%s'" % req.name)
# from http://www.diveintopython3.net/serializing.html
if ( self._face_dict_filename != '' ):
with open( self._face_dict_filename, 'wb' ) as f:
pickle.dump( self._face_dict, f );
print "wrote _face_dict: %s" % self._face_dict_filename
return {"error_msg": ""}
def _detect_face_srv(self, req):
try:
bgr_image = self._bridge.imgmsg_to_cv2(req.image, "bgr8")
except CvBridgeError as e:
error_msg = "Could not convert to opencv image: %s" % e
rospy.logerr(error_msg)
return {"error_msg": error_msg}
# Display the resulting frame
detections = [{"roi": _get_roi(bgr_image, d), "x": d.left(), "y": d.top(),
"width": d.width(), "height": d.height()} for d
in self._face_detector(bgr_image, 1)] # 1 = upsample factor
# Try to recognize
detections = self._update_detections_with_recognitions(detections)
rospy.logerr("This is for debugging")
rospy.logerr(detections)
# Try to add attributes
if req.external_api_request:
detections = self._update_detections_with_attributes(detections)
# Save images
if req.save_images:
self._save_images(detections, bgr_image)
return {
"face_detections": [FaceDetection(names=(d["names"] if "name" in d else []),
l2_distances=(d["l2_distances"] if "name" in d else []),
x=d["x"], y=d["y"], width=d["width"], height=d["height"],
gender_is_male=(d["attrs"]["gender"]["value"] == "male" if "attrs" in d else 0),
gender_score=(float(d["attrs"]["gender"]["confidence"]) if "attrs" in d else 0),
age_score=(1.0 if "attrs" in d else 0),
age=(int(d["attrs"]["age_est"]["value"]) if "attrs" in d else 0))
for d in detections],
"error_msg": ""
}
def img_callback(self,data):
try:
self.cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print(e)
def hand_img_callback(self, ros_image):
try:
self.hand_img = self.bridge.imgmsg_to_cv2(ros_image, "bgr8")
except CvBridgeError, e:
print e
# cv2.imshow("Hand Image", self.hand_img)
# cv2.waitKey(3)
def face_img_callback(self, ros_image):
try:
self.face_img = self.bridge.imgmsg_to_cv2(ros_image, "bgr8")
except CvBridgeError, e:
print e
# cv2.imshow("Face Image", self.face_img)
# cv2.waitKey(3)
def convert_depth_image(self, ros_image):
# Use cv_bridge() to convert the ROS image to OpenCV format
try:
# Convert the depth image using the default passthrough encoding
depth_image = self.cv_bridge.imgmsg_to_cv2(ros_image, "passthrough")
except CvBridgeError, e:
print e
# Convert the depth image to a Numpy array
self.depth_array = np.array(depth_image, dtype=np.float32)
def set_object_image(self, req, compress=False):
"""Handles SetObjectImage service requests.
Args:
req: SetObjectImageRequest/SetObjectCompressedImageRequest message.
compress: Whether to return a compressed image or not.
Returns:
SetObjectImageResponse or SetObjectCompressedImageResponse.
"""
if compress:
response = interop.srv.SetObjectCompressedImageResponse()
else:
response = interop.srv.SetObjectImageResponse()
try:
png_image = serializers.ObjectImageSerializer.from_msg(req.image)
except CvBridgeError as e:
rospy.logerr(e)
response.success = False
except Exception as e:
rospy.logfatal(e)
response.success = False
else:
try:
self.objects_dir.set_object_image(req.id, png_image)
except (KeyError, IOError) as e:
rospy.logerr("Could not set object image: {}".format(e))
response.success = False
else:
response.success = True
return response
def get_object_image(self, req, compress=False):
"""Handles GetObjectImage service requests.
Args:
req: GetObjectImageRequest/GetObjectCompressedImageRequest message.
compress: Whether to return a compressed image or not.
Returns:
GetObjectImageResponse or GetObjectCompressedImageResponse.
"""
if compress:
response = interop.srv.GetObjectCompressedImageResponse()
else:
response = interop.srv.GetObjectImageResponse()
try:
png = self.objects_dir.get_object_image(req.id)
except (KeyError, IOError) as e:
rospy.logerr("Could not get object image: {}".format(e))
response.success = False
except Exception as e:
rospy.logfatal(e)
response.success = False
else:
try:
response.image = serializers.ObjectImageSerializer.from_raw(
png, compress)
except CvBridgeError as e:
rospy.logerr(e)
response.success = False
else:
response.success = True
return response
def laserCB(self, data):
try:
self.screen = np.squeeze(bridge.imgmsg_to_cv2(data, "mono8"))
# print shape( self.screen)
except CvBridgeError as e:
print(e)
def laserCB(data):
try:
screen = np.squeeze(bridge.imgmsg_to_cv2(data, "mono8"))
except CvBridgeError as e:
print(e)
cv2.imshow("Scree", screen)
# rospy.loginfo(" dim : %s", screen.shape)
cv2.waitKey(3)
def cvt_image(self,data):
try:
self.latestImage = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print(e)
if self.imgRcvd != True:
self.imgRcvd = True
