def __init__(self): self.node_name = "Object Detection" self.active = True # Detector Configuration rospack = rospkg.RosPack() self.configuration = rospy.get_param( '~object_detector') # TODO: On-the-fly reconfiguration # TODO: Fix after a place for inference models is established self.object_detector = ObjectDetector( path.join(rospack.get_path('object_detection'), self.configuration['inference_graph_path']), float(self.configuration['score_threshold']), bool(self.configuration['denormalize_boundingbox'])) # Subscribers self.sub_image = rospy.Subscriber("~image_compressed", CompressedImage, self.on_image_received, queue_size=1) # Publishers self.pub_detection = rospy.Publisher("~detections", ObjectDetectionList, queue_size=1)
def __init__(self, config): self.config_ = config # Load Models if (config.model_name == 'fchardnet'): self.seg_model_ = FCHarDNetSemanticSegmentation(config.model_path) else: self.seg_model_ = PSPNetSematicSegmentation( config.model_config_file) self.object_detector_ = ObjectDetector(config.model_path_yolo) # Load perspective transforms mtxs = np.load(config.perspective_transform_path) self.M_ = mtxs['M'] self.M_inv_ = mtxs['M_inv'] # Test Detection Models print('Segmentation and Detection Models loaded, Testing the models') img = cv2.imread("/usr/src/app/dev_ws/src/vision/vision/dolly.png") self.h_orig_, self.w_orig_, = self.config_.original_height, self.config_.original_width _, _ = self.seg_model_.process_img_driveable( img, [self.config_.original_height, self.config_.original_width], self.config_.drivable_idx) _ = self.object_detector_.process_frame(img) self.im_hw_ = self.object_detector_.im_hw print('Imgs tested')
def main(): parser = argparse.ArgumentParser() parser.add_argument('image_file_paths', nargs='*', default=sys.stdin, help='filepaths to the images for object detection.') parser.add_argument('-l', '--logfile', help='filepath for logging output, default is stdout.') parser.add_argument( '-o', '--outputsuffix', help= 'output image filename is made up of the input filepath with this suffix inserted before the file extention.', default='_output') parser.add_argument( '-c', '--confidencethreshold', help= 'number between 0 and 1 that represents the confidence level for declaring an object as detected. e.g. .5 requires greater than 50%% confidence.', default=0.5, type=float) args = parser.parse_args() if args.logfile is None: logging.basicConfig(format='%(message)s', level=logging.DEBUG) else: logging.basicConfig(filename=args.logfile, format='%(message)s', level=logging.DEBUG) net = cv2.dnn.readNetFromCaffe(prototxt, model) detector = ObjectDetector(net, classes, args.confidencethreshold) for f in args.image_file_paths: filepath = f.strip() detect_image(detector, filepath, output_filepath(filepath, args.outputsuffix))
for x in f.readlines()] id_map = [(x[0], x[1]) for x in id_map if x[0] in existingImages] minId, maxId = min([x[1] for x in id_map]), max([x[1] for x in id_map]) idNum = None if len(args) > 4: idNum = int(args[4]) rev_map = {} for x in id_map: if not x[1] in rev_map: rev_map[x[1]] = [] rev_map[x[1]].append(x[0]) print('Loading Object Detector') det = ObjectDetector(objdetmodel) det.SCORE_THRESHOLD = 0.7 det.loadModel() # Warming up det.getBoundingBoxes(readImageFromFile(os.path.join(folder, rev_map[0][0]))) det.getBoundingBoxes(readImageFromFile(os.path.join(folder, rev_map[0][0]))) print('Loading Object Identifier') idn = SvmIdentifier(modelPath, det) idn.loadModel() if not idNum is None and not idn.isPresent(idNum): print( 'Provided Id {} is not present in trained model, will choose random Id'
from train_validate_svm import * from extract_features_and_store_to_mongo import * import numpy as np from db_interface import DbInterface, DbRecord from joblib import dump, load from sklearn.decomposition import IncrementalPCA import sys import os from object_detection import ObjectDetector import time import argparse from test_svm_model import * print('Loading object detector...') det = ObjectDetector('ssd/saved_model') det.loadModel() #correct,count,times,cl_times = find_acc('jaguar-alexnet-fc7-linear-pca.model', 'jaguars/reid', 100, None, 3, None, det) #print('Jagaurs Test Accuracy: {:.4f}, out of {} images. Average Id Time: {:.3f}s, Average Classification Times: {:.3f}s'.format(correct/count, count, times/count, cl_times/count)) correct, count, times, cl_times = find_acc( 'amur-alexnet-relu6-linear-pca.model', 'amur/plain_reid_train/train', 100, None, 3, None, det) print( 'Tigers Test Accuracy: {:.4f}, out of {} images. Average Id Time: {:.3f}s, Average Classification Times: {:.3f}s' .format(correct / count, count, times / count, cl_times / count)) #correct,count,times,cl_times = find_acc('elp-alexnet-fc7-linear-pca.model', 'ELPephants/images', 100, None, 3, None, det) #print('Elephants Test Accuracy: {:.4f}, out of {} images'.format(correct/count, count, times/count, cl_times/count))
required=True, help="path to the image to be classified") args = vars(ap.parse_args()) # load the configuration file conf = Conf(args["conf"]) # load the classifier, then initialize the Histogram of Oriented Gradients descriptor # and the object detector model = pickle.loads(open(conf["classifier_path"], "rb").read()) hog = HOG(orientations=conf["orientations"], pixelsPerCell=tuple(conf["pixels_per_cell"]), cellsPerBlock=tuple(conf["cells_per_block"]), normalize=conf["normalize"], block_norm="L1") od = ObjectDetector(model, hog) # load the image and convert it to grayscale image = cv2.imread(args["image"]) image = imutils.resize(image, width=min(260, image.shape[1])) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # detect objects in the image (boxes, probs) = od.detect(gray, conf["window_dim"], winStep=conf["window_step"], pyramidScale=conf["pyramid_scale"], minProb=conf["min_probability"]) # loop over the bounding boxes and draw them for (startX, startY, endX, endY) in boxes:
n = int(args[3]) folder = 'amur/detection_train/trainval' images = ['{}/{}'.format(folder, x) for x in os.listdir(folder)] imagelist = np.random.choice(images, n, replace=False) print('Measuring performance over {} images...'.format(len(images))) config = args[1] weights = args[2] #model = YoloObjectDetector(config, weights, '../darknet/darknet/custom_data/detector.data') #model.loadModel() model = ObjectDetector(config) model.loadModel() print('Warming up...') #model.getBoundingBoxes(images[0]) #model.getBoundingBoxes(images[1]) model.getBoundingBoxes(cv2.imread(images[0])) model.getBoundingBoxes(cv2.imread(images[1])) [cv2.imread(x) for x in imagelist] print('Starting...') times = [] for im in imagelist: #model.getBoundingBoxes(im) img = cv2.imread(im) st = time.time()
if len(args) == 4: n = min(int(args[3]), len(imageFiles)) else: n = len(imageFiles) imageFiles = imageFiles[:n] print('Running Detection on {} images'.format(n)) box_map = {} with open(args[2]) as f: box_map = json.load(f) f.close() print('Loading Object Detector...') det = ObjectDetector('ssd_quantized_1L_steps/saved_model') det.loadModel() #det.SCORE_THRESHOLD = 0.25 #det.IOU_THRESHOLD = 0.01 print('Warming up model...') det.getBoundingBoxes(cv2.imread(imageFiles[0])) det.getBoundingBoxes(cv2.imread(imageFiles[0])) batchSize = 10 if 'jaguar' in folder.lower(): expected_classid = 1 # Only tigers elif 'elp' in folder.lower() or 'elephant' in folder.lower(): expected_classid = 2 elif 'amur' in folder.lower(): expected_classid = 3
th = threading.Thread(target=client.publishImageWithDetections, args=[image, detections]) th.setDaemon(True) th.start() if __name__ == '__main__': args = sys.argv if len(args) < 3: print('Usage: cmd <Model path> <MQTT server IP> [display]') exit() modelpath = args[1] server = args[2] detector = ObjectDetector(modelpath, numthreads=4) detector.loadModel() display = False if len(args) > 3 and args[3] == 'display': display = True publisher = TrackPublisher(DEVICE_NAME, server) publisher.register() imagePublisher = ImagePublisher(DEVICE_NAME, server) print('Registered with MQTT server, publishing messages on channel: {}'. format(DEVICE_NAME)) with picamera.PiCamera(resolution=(640, 480), framerate=30) as camera: #camera.start_recording('my_video.h264')
def __init__(self): self.object_detector = ObjectDetector() # connect to collision map processing service rospy.loginfo('waiting for tabletop_collision_map_processing service') rospy.wait_for_service( '/tabletop_collision_map_processing/tabletop_collision_map_processing' ) self.collision_map_processing_srv = rospy.ServiceProxy( '/tabletop_collision_map_processing/tabletop_collision_map_processing', TabletopCollisionMapProcessing) rospy.loginfo('connected to tabletop_collision_map_processing service') # connect to gripper action server rospy.loginfo('waiting for wubble_gripper_grasp_action') self.posture_controller = SimpleActionClient( '/wubble_gripper_grasp_action', GraspHandPostureExecutionAction) self.posture_controller.wait_for_server() rospy.loginfo('connected to wubble_gripper_grasp_action') rospy.loginfo('waiting for wubble_grasp_status service') rospy.wait_for_service('/wubble_grasp_status') self.get_grasp_status_srv = rospy.ServiceProxy('/wubble_grasp_status', GraspStatus) rospy.loginfo('connected to wubble_grasp_status service') rospy.loginfo('waiting for classify service') rospy.wait_for_service('/classify') self.classification_srv = rospy.ServiceProxy('/classify', classify) rospy.loginfo('connected to classify service') # connect to gripper action server rospy.loginfo('waiting for wubble_gripper_action') self.gripper_controller = SimpleActionClient('/wubble_gripper_action', WubbleGripperAction) self.gripper_controller.wait_for_server() rospy.loginfo('connected to wubble_gripper_action') # connect to wubble actions rospy.loginfo('waiting for drop_object') self.drop_object_client = SimpleActionClient('/drop_object', DropObjectAction) self.drop_object_client.wait_for_server() rospy.loginfo('connected to drop_object') rospy.loginfo('waiting for grasp_object') self.grasp_object_client = SimpleActionClient('/grasp_object', GraspObjectAction) self.grasp_object_client.wait_for_server() rospy.loginfo('connected to grasp_object') rospy.loginfo('waiting for lift_object') self.lift_object_client = SimpleActionClient('/lift_object', LiftObjectAction) self.lift_object_client.wait_for_server() rospy.loginfo('connected to lift_object') rospy.loginfo('waiting for place_object') self.place_object_client = SimpleActionClient('/place_object', PlaceObjectAction) self.place_object_client.wait_for_server() rospy.loginfo('connected to plcae_object') rospy.loginfo('waiting for push_object') self.push_object_client = SimpleActionClient('/push_object', PushObjectAction) self.push_object_client.wait_for_server() rospy.loginfo('connected to push_object') rospy.loginfo('waiting for shake_roll_object') self.shake_roll_object_client = SimpleActionClient( '/shake_roll_object', ShakeRollObjectAction) self.shake_roll_object_client.wait_for_server() rospy.loginfo('connected to drop_object') rospy.loginfo('waiting for shake_pitch_object') self.shake_pitch_object_client = SimpleActionClient( '/shake_pitch_object', ShakePitchObjectAction) self.shake_pitch_object_client.wait_for_server() rospy.loginfo('connected to pitch_object') rospy.loginfo('waiting for ready_arm') self.ready_arm_client = SimpleActionClient('/ready_arm', ReadyArmAction) self.ready_arm_client.wait_for_server() rospy.loginfo('connected to ready_arm') # advertise InfoMax service rospy.Service('get_category_distribution', InfoMax, self.process_infomax_request) rospy.loginfo( 'all services contacted, object_categorization is ready to go') self.ACTION_INFO = { InfomaxAction.GRASP: { 'client': self.grasp_object_client, 'goal': GraspObjectGoal(), 'prereqs': [InfomaxAction.GRASP] }, InfomaxAction.LIFT: { 'client': self.lift_object_client, 'goal': LiftObjectGoal(), 'prereqs': [InfomaxAction.GRASP, InfomaxAction.LIFT] }, InfomaxAction.SHAKE_ROLL: { 'client': self.shake_roll_object_client, 'goal': ShakeRollObjectGoal(), 'prereqs': [ InfomaxAction.GRASP, InfomaxAction.LIFT, InfomaxAction.SHAKE_ROLL ] }, InfomaxAction.DROP: { 'client': self.drop_object_client, 'goal': DropObjectGoal(), 'prereqs': [InfomaxAction.GRASP, InfomaxAction.LIFT, InfomaxAction.DROP] }, InfomaxAction.PLACE: { 'client': self.place_object_client, 'goal': PlaceObjectGoal(), 'prereqs': [InfomaxAction.GRASP, InfomaxAction.LIFT, InfomaxAction.PLACE] }, InfomaxAction.PUSH: { 'client': self.push_object_client, 'goal': PushObjectGoal(), 'prereqs': [ InfomaxAction.GRASP, InfomaxAction.LIFT, InfomaxAction.PLACE, InfomaxAction.PUSH ] }, InfomaxAction.SHAKE_PITCH: { 'client': self.shake_pitch_object_client, 'goal': ShakePitchObjectGoal(), 'prereqs': [ InfomaxAction.GRASP, InfomaxAction.LIFT, InfomaxAction.SHAKE_PITCH ] }, }
def __init__(self): self.detector = ObjectDetector() # 'http://host.docker.internal:5000/api/' # self.base_url = os.environ["MEDIA_API_URL"] print("API Url: {}".format(self.base_url))