def __init__(self, object_names = [], namespace = "", detector_srv = '/object_detection/detect_object', mode='all'):
		smach.State.__init__(
			self,
			outcomes=['detected','not_detected','failed'],
			input_keys=['object_names'],
			output_keys=['objects'])
		
		if mode not in ['all','one']:
			rospy.logwarn("Invalid mode: must be 'all', or 'one', selecting default value = 'all'")
			self.mode = 'all'	
		else:
			self.mode = mode

		self.object_detector = ObjectDetector(object_names, namespace, detector_srv, self.mode)
Exemplo n.º 2
0
def evaluateDeckSlots():
    '''
	Checks items on deck and returns dict of {slot:item type}
	Assumes that pipette is not occluding top camera
	'''

    camera = cv2.VideoCapture(0)
    time.sleep(.25)
    ret, frame = camera.read()
    frame = imutils.resize(frame, width=500)
    frame = cropFrame(frame)

    name_to_boxes_map = ObjectDetector.detectMat(frame,
                                                 num_classes=num_classes,
                                                 graph_path=ckpt_path,
                                                 label_path=label_path)
    # print(name_to_boxes_map)
    scaleBoxes(name_to_boxes_map, frame)
    # print(name_to_boxes_map)
    slot_item_dict = {}
    for name, boxes in name_to_boxes_map.items():
        if name not in skip:
            for box in boxes:
                pos = determineSlot(box)
                slot_item_dict[pos] = name

    return slot_item_dict
Exemplo n.º 3
0
 def getGamestateVector(self,double=False):
   if(not self.vectorState is None):
     return self.vectorState
   
   if(self.Breakout):
     bar,barVelocity,ball,ballVelocity = imageParser.detectObjectBreakout(self.frames[-1],double=double)
   else:
     bar,barVelocity,ball,ballVelocity = imageParser.detectObjectPong(self.frames[-1],double=double)
   
   # vector content:
   # bar_X,bar_Y,Bar_XSpeed,Bar_YSpeed,ball_X,ball_Y,ball_XSpeed,ball_YSpeed
   vector = []
   vector.extend(bar)
   vector.extend(barVelocity)
   vector.extend(ball)
   vector.extend(ballVelocity)
   vector = np.array(vector)
   self.vectorState = vector
   return vector
    def __init__(self, object_names=[], namespace="", detector_srv="/object_detection/detect_object", mode="all"):
        smach.State.__init__(
            self, outcomes=["detected", "not_detected", "failed"], input_keys=["object_names"], output_keys=["objects"]
        )

        if mode not in ["all", "one"]:
            rospy.logwarn("Invalid mode: must be 'all', or 'one', selecting default value = 'all'")
            self.mode = "all"
        else:
            self.mode = mode

        self.object_detector = ObjectDetector(object_names, namespace, detector_srv, self.mode)
Exemplo n.º 5
0
	def evaluateDeck(self, frame):
		print("Evaluate deck")
		img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
		img_pil = Image.fromarray(img)
		obj_boxes = ObjectDetector.detectPIL(img_pil)
		width,height = img_pil.size
		self.scaleBoxes(obj_boxes, img_pil)
		print(obj_boxes)
		item_slot_dict = {}
		for item, boxes in obj_boxes.items():
			box = boxes[0]
			slot = self.determineSlot(box)
			item_slot_dict[item] = slot
			print('{} at {}'.format(item, slot))
		return item_slot_dict
Exemplo n.º 6
0
 def evaluate(self):
     if len(self.img_points) != 2:
         return {'error': 'Must calibrate before evaluation'}
     # Each box is (ymin, xmin, ymax, xmax)
     pos_dict = ObjectDetector.detect(img_path=self.img_path)
     if len(pos_dict) != 1:
         return {'error':'{} objects detected'.format(len(pos_dict))}
     else:
         labware, position = list(pos_dict.items())[0]
         height, width = self.img.shape[:2]
         # xmin * width, ymax * height
         x = self.transform(width * position[1], 0)
         y = self.transform(height * position[2], 1)
         name, percentage = [c.strip() for c in labware.split(':')]
         return {'item':name, 'x':x, 'y':y, 'percent':percentage}
class DetectObjectsBackside(smach.State):
	def __init__(self, object_names = [], namespace = "", detector_srv = '/object_detection/detect_object', mode='all'):
		smach.State.__init__(
			self,
			outcomes=['detected','not_detected','failed'],
			input_keys=['object_names'],
			output_keys=['objects'])
		
		if mode not in ['all','one']:
			rospy.logwarn("Invalid mode: must be 'all', or 'one', selecting default value = 'all'")
			self.mode = 'all'	
		else:
			self.mode = mode

		self.object_detector = ObjectDetector(object_names, namespace, detector_srv, self.mode)
	

	def execute(self, userdata):

		sss.set_light('blue')

		#Preparations for object detection
		handle_torso = sss.move("torso","home",False)
		sss.set_light('yellow')
		handle_arm = sss.move("arm","folded-to-look_at_table",False)
		handle_head = sss.move("head","back",False)
		handle_arm.wait()
		handle_torso.wait()
		handle_head.wait()
		sss.set_light('blue')

		result, userdata.objects = self.object_detector.execute(userdata)

		# ... cleanup robot components
		if result != "detected":
			sss.set_light('yellow')
			sss.move("torso","front")
			handle_arm = sss.move("arm","look_at_table-to-folded")
		sss.move("torso","home")

		if result == "failed":
			sss.set_light('red')
		else:
			sss.set_light('green')
		
		return result
Exemplo n.º 8
0
    def do_POST(self):
        """Serve a POST request."""

        r, info = self.deal_post_data()
        print((r, info, "by: ", self.client_address))
        f = BytesIO()
        f.write(b'<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">')
        f.write(b"<html>\n<title>Upload Result Page</title>\n")
        f.write(b"<body>\n<h2>Upload Result Page</h2>\n")
        f.write(b"<hr>\n")
        json_string = ""

        if r:
            f.write(b"<strong>Success:</strong>")
            # print("hellooooo"+socket.gethostbyname(socket.gethostname()))
            imgLink = ObjectDetector.detect(self.imagePath, self.imageName)
            responseJson = {
                'link': imgLink,
                'status': 'success',
                'statusCode': 200
            }
            json_string = json.dumps(responseJson)

        else:
            f.write(b"<strong>Failed:</strong>")

        f.write(info.encode())
        f.write(
            ("<br><a href=\"%s\">back</a>" % self.headers['referer']).encode())
        f.write(b"</ul>\n<hr>\n</body>\n</html>\n")

        length = f.tell()
        f.seek(0)
        self.send_response(200)
        self.send_header('Content-Type', 'application/json')
        self.end_headers()
        self.wfile.write(json_string.encode(encoding='utf_8'))
        # self.send_header("Content-type", "text/html")
        # self.send_header("Content-Length", str(length))

        if f:
            self.copyfile(f, self.wfile)
            f.close()
class DetectObjectsFrontside(smach.State):
    def __init__(self, object_names=[], namespace="", detector_srv="/object_detection/detect_object", mode="all"):
        smach.State.__init__(
            self, outcomes=["detected", "not_detected", "failed"], input_keys=["object_names"], output_keys=["objects"]
        )

        if mode not in ["all", "one"]:
            rospy.logwarn("Invalid mode: must be 'all', or 'one', selecting default value = 'all'")
            self.mode = "all"
        else:
            self.mode = mode

        self.object_detector = ObjectDetector(object_names, namespace, detector_srv, self.mode)

    def execute(self, userdata):

        sss.set_light("blue")

        # Preparations for object detection
        handle_torso = sss.move("torso", "home", False)
        handle_head = sss.move("head", "front", False)
        handle_head.wait()
        handle_torso.wait()
        sss.set_light("blue")

        result, userdata.objects = self.object_detector.execute(userdata)

        # ... cleanup robot components
        sss.move("torso", "home")

        if result == "failed":
            sss.set_light("red")
        else:
            sss.set_light("green")

        return result
class DetectObjectFrontside(smach.State):
	def __init__(self,namespace, object_names = [], detector_srv = '/object_detection/detect_object',mode = 'all'):
		smach.State.__init__(
			self,
			outcomes=['detected','not_detected','failed'],
			input_keys=['object_names'],
			output_keys=['objects'])
		
		if mode not in ['all','one']:
			rospy.logwarn("Invalid mode: must be 'all', or 'one', selecting default value = 'all'")
			self.mode = 'all'	
		else:
			self.mode = mode

		self.object_detector = ObjectDetector(namespace, object_names, detector_srv,self.mode)
	

	def execute(self, userdata):
			

		sss.set_light('blue')

		handle_torso = sss.move("torso","shake",False)
		handle_head = sss.move("head","front",False)
		handle_head.wait()
		handle_torso.wait()
		sss.set_light('blue')

		result, userdata.objects = self.object_detector.execute(userdata)

		# ... cleanup robot components
		sss.move("torso","home")
		sss.set_light('green')

		
		return result
Exemplo n.º 11
0
def main():
    detector = ObjectDetector()
    detector.init()

    cap = cv2.VideoCapture(0)

    timer_thread = TimerThread()
    timer_thread.start()

    overlay_color = green
    detection_color = red
    opacity = 0.2

    box_color = white
    box_thickness = 1

    #buffer to make avoid false reads, make sure we see a person
    #in 10 consecutive frames
    buffer = 0

    timer_running = False

    ret, initial_frame = cap.read()
    region = select_region(initial_frame)

    current_datetime = datetime.now()
    csv_filename = current_datetime.strftime("%d-%m-%Y")
    #check for security log folder and
    #folder for today's date otherwise create it
    try:
        os.makedirs('security_logs')
    except OSError:
        pass

    try:
        os.makedirs('security_logs/%s' % csv_filename)
    except OSError:
        pass

    #check for csv for today
    csv_path = "security_logs/%s/%s.csv" % (csv_filename, csv_filename)
    files = glob.glob(csv_path)
    print("csv_path: %s" % (csv_path))

    #if csv exists, open it into a pandas dataframe.
    #if no csv, create new dataframe to keep track of events
    #create variable to keep track of event number for the day
    if len(files) == 1:
        print("csv found, loading dataframe")
        df = pd.read_csv(csv_path)
        event = len(df)
    elif len(files) == 0:
        print("no csv found, creating new dataframe")
        df = pd.DataFrame(columns=['event', 'time'])
        event = 0
    else:
        raise Exception("multiple csv's found matching date")

    #it is expensive to constantly append to Pandas dataframe,
    #so while program is running keep events in a list
    event_list = [[]]

    while (True):
        ret, input_frame = cap.read()
        x1 = region[0]
        y1 = region[1]
        x2 = x1 + region[2]
        y2 = y1 + region[3]

        overlay = input_frame.copy()
        output = input_frame.copy()

        region_frame = input_frame[y1:y2, x1:x2]

        found = detect_people(region_frame, detector)

        if found:
            color = detection_color
            buffer += 1
        else:
            color = overlay_color
            buffer = 0

        box = cv2.rectangle(overlay, (x1, y1), (x2, y2), color, -1)
        output = cv2.addWeighted(overlay, opacity, output, 1 - opacity, 0)

        #if buffer is over 10, save an alert, then sleep for 30 seconds
        #in order to prevent saving tons of images from one security alert
        if buffer >= 10 and timer_thread.timer_active == False:
            # we will save an image and add an entry to the csv
            timer_thread.timer_active = True
            event += 1
            image_path = "security_logs/%s" % (csv_filename)
            image_filename = "%d.jpg" % event
            cv2.imwrite(os.path.join(image_path, image_filename), input_frame)
            event_list.append([event, time.strftime("%H-%M")])

        cv2.imshow("Output", output)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            #first event is empty because we initialized the list, so get rid of first entry in list
            del event_list[0]
            df = df.append(pd.DataFrame(event_list, columns=['event', 'time']),
                           ignore_index=True)
            df.to_csv(csv_path, index=False)
            timer_thread.stop()
            timer_thread.join()
            break
Exemplo n.º 12
0
import recog
import ObjectDetector

process_frame = 0
cont = 0
root = tk.Tk()
w = tk.Frame(root, height="400", width="1280", bg="black")
w.pack()
w.pack_propagate(0)
foto = ImageTk.PhotoImage(Image.open("dados.jpg"))
pop = ImageTk.PhotoImage(Image.open("popup.jpg"))
lmain = tk.Label(w)
lmain.pack()
cap = recog.ligar_camera()
lista = recog.guardar_participantes('okita.jpg', 'caio.jpg')
od = ObjectDetector.Object_Detector()


def popup():
    toplevel = tk.Toplevel()
    label1 = tk.Label(toplevel, height=0, bg="white", width=100)
    label1.pack()
    label2 = tk.Label(toplevel, height=0, bg="white", width=100)
    label2.pack()
    label3 = tk.Label(toplevel, image=pop, bg="white", height="130px")
    label3.pack(side=tk.TOP)


def show_frame(frame):
    img = Image.fromarray(frame)
    imgtk = ImageTk.PhotoImage(image=img)