class rovioControl(object):
def __init__(self, url, username, password, port=80):
self.rovio = Rovio(url,
username=username,
password=password,
port=port)
self.last = None
self.key = 0
def night_vision(self, frame):
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = cv2.equalizeHist(frame)
return frame
def show_battery(self, frame):
sh = frame.shape
m, n = sh[0], sh[1]
battery, charging = self.rovio.battery()
battery = 100 * battery / 130.
bs = "Battery: %0.1f" % battery
cs = "Status: Roaming"
if charging == 80:
cs = "Status: Charging"
cv2.putText(frame, bs, (20, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
cv2.putText(frame, cs, (300, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
return frame
def resize(self, frame, size=(640, 480)):
frame = cv2.resize(frame, size)
return frame
def main(self):
frame = self.rovio.camera.get_frame()
if not isinstance(frame, np.ndarray):
return
frame = self.night_vision(frame)
#frame = filter.sobel(frame)
#frame = img_as_ubyte(frame)
frame = self.resize(frame)
frame = cv2.merge([frame, frame, frame])
frame = self.show_battery(frame)
cv2.imshow("rovio", frame)
self.key = cv2.waitKey(20)
if self.key > 0:
#print self.key
pass
if self.key == 114: #r
self.rovio.turn_around()
elif self.key == 63233 or self.key == 115: #down or s
self.rovio.backward(speed=1)
elif self.key == 63232 or self.key == 119: #up or w
self.rovio.forward(speed=1)
elif self.key == 63234 or self.key == 113: #left or a
self.rovio.rotate_left(angle=12, speed=5)
elif self.key == 63235 or self.key == 101: #right or d
self.rovio.rotate_right(angle=12, speed=5)
elif self.key == 97: #left or a
self.rovio.left(speed=1)
elif self.key == 100: #right or d
self.rovio.right(speed=1)
elif self.key == 44: #comma
self.rovio.head_down()
elif self.key == 46: #period
self.rovio.head_middle()
elif self.key == 47: #slash
self.rovio.head_up()
class rovioControl(object):
def __init__(self, url, username, password, port=80):
self.rovio = Rovio(url,
username=username,
password=password,
port=port)
self.last = None
self.key = 0
def night_vision(self, frame):
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = cv2.equalizeHist(frame)
return frame
def mse(self, imageA, imageB):
# the 'Mean Squared Error' between the two images is the
# sum of the squared difference between the two images;
# NOTE: the two images must have the same dimension
err = np.sum((imageA.astype("float") - imageB.astype("float"))**2)
err /= float(imageA.shape[0] * imageA.shape[1])
# return the MSE, the lower the error, the more "similar"
# the two images are
return err
def show_battery(self, frame):
sh = frame.shape
m, n = sh[0], sh[1]
battery, charging = self.rovio.battery()
battery = 100 * battery / 130.
bs = "Battery: %0.1f" % battery
cs = "Status: Roaming"
if charging == 80:
cs = "Status: Charging"
cv2.putText(frame, bs, (20, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
cv2.putText(frame, cs, (300, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
return frame
def dance(self):
x = random.randint(1, 5)
if x == 1:
self.rovio.head_down()
time.sleep(1)
elif x == 2:
self.rovio.rotate_left(angle=30, speed=7)
time.sleep(3)
elif x == 3:
self.rovio.head_up()
time.sleep(0.5)
elif x == 4:
self.rovio.rotate_right(angle=30, speed=7)
time.sleep(3)
elif x == 5:
self.rovio.head_middle()
time.sleep(0.5)
def object_detection(self):
# Stop Rovio so that it can stop down to recognize
self.rovio.stop()
#self.rovio.patrol()
self.rovio.head_middle()
while True:
# Input template image and video from rovio
image = self.rovio.camera.get_frame()
template = cv2.imread('template3.jpg')
# resize images
image = cv2.resize(image, (0, 0), fx=0.5, fy=0.5)
template = cv2.resize(template, (0, 0), fx=0.5, fy=0.5)
# Convert to grayscale
imageGray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
templateGray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
# Find template and match
result = cv2.matchTemplate(imageGray, templateGray, cv2.TM_SQDIFF)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
top_left = min_loc
h, w = templateGray.shape
bottom_right = (top_left[0] + w, top_left[1] + h)
cropped = image[top_left[1]:top_left[1] + h,
top_left[0]:top_left[0] + w]
cropgray = cv2.cvtColor(cropped, cv2.COLOR_BGR2GRAY)
# edge detection
edge1 = cv2.Canny(templateGray, 100, 200)
edge2 = cv2.Canny(cropgray, 100, 200)
# calculate Mean Squared Error
mse_v = self.mse(edge1, edge2)
#boundingbox
cv2.rectangle(image, top_left, bottom_right, (0, 0, 255), 4)
# Show result
cv2.imshow("Template", template) #show template image
image = self.resize(image)
mseval = "mse: %0.1f" % mse_v
cv2.putText(image, mseval, (20, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
cv2.imshow("Result",
image) #show input image with blue bounding box
cv2.imshow("cropped",
edge2) #show cropped image within blue bounding box
cv2.moveWindow("Template", 10, 50)
cv2.moveWindow("Result", 150, 50)
cv2.moveWindow("cropped", 10, 200)
if mse_v < 2000:
while True:
self.dance()
key = cv2.waitKey(1) & 0xFF
if key == ord("p"):
x = 0
self.rovio.head_middle()
break
# if the `q` key is pressed, break from the lop
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
def resize(self, frame, size=(640, 480)):
frame = cv2.resize(frame, size)
return frame
def main(self):
frame = self.rovio.camera.get_frame()
if not isinstance(frame, np.ndarray):
return
frame = self.night_vision(frame)
#frame = filter.sobel(frame)
#frame = img_as_ubyte(frame)
frame = self.resize(frame)
frame = cv2.merge([frame, frame, frame])
frame = self.show_battery(frame)
cv2.imshow("rovio", frame)
self.key = cv2.waitKey(20)
if self.key > 0:
#print self.key
pass
if self.key == 114: #r
self.rovio.turn_around()
elif self.key == 63233 or self.key == 115: #down or s
self.rovio.backward(speed=1)
elif self.key == 63232 or self.key == 119: #up or w
self.rovio.forward(speed=1)
elif self.key == 63234 or self.key == 113: #left or a
self.rovio.rotate_left(angle=30, speed=5)
elif self.key == 63235 or self.key == 101: #right or d
self.rovio.rotate_right(angle=30, speed=5)
elif self.key == 97: #left or a
self.rovio.left(speed=1)
elif self.key == 100: #right or d
self.rovio.right(speed=1)
elif self.key == 44: #comma
self.rovio.head_down()
elif self.key == 46: #period
self.rovio.head_middle()
elif self.key == 47: #slash
self.rovio.head_up()
elif self.key == 32: # Space Bar
flag = False
#self.rovio.stop()
#while not flag:flag =
self.object_detection()
print flag
class rovioControl(object):
def __init__(self, url, username, password, port=80):
self.rovio = Rovio(url,
username=username,
password=password,
port=port)
def main(self):
#self.rovio.head_up()
#frame = self.rovio.camera.get_frame()
#print(frame)
self.rovio.head_down()
lower_flag = False
human_flag = False
current_time = lambda: int(round(time.time() * 1000))
old_image = []
start_time = 0
while (True):
check = main2()
if (check == 1):
continue
self.rovio.head_down()
battery, charging = self.rovio.battery()
start = time.time()
#img = io.imread('http://192.168.10.18/Jpeg/CamImg0000.jpg')
response = urllib.urlopen('http://192.168.10.18/Jpeg/CamImg.jpg')
img_array = np.asarray(bytearray(response.read()), dtype=np.uint8)
img = cv2.imdecode(img_array, 1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gaussian = cv2.GaussianBlur(img, (5, 5), 0)
if (self.get_image_difference(np.asarray(gaussian, dtype="uint8"),
np.asarray(old_image, dtype="uint8"))
< 0.1):
print('I think i am stuck')
if (start_time == 0):
start_time = current_time()
else:
start_time = 0
diff = current_time() - start_time
if (start_time != 0 and diff > 200):
self.rovio.backward()
self.rovio.backward()
self.rovio.backward()
self.rovio.backward()
self.rovio.backward()
self.rovio.backward()
self.rovio.backward()
self.rovio.backward()
print('Rotating since stuck')
#self.dancer()
self.rovio.rotate_right(angle=30)
start_time = 0
print('Delays :', time.time() - start)
battery = 100 * battery / 130.
bs = "Battery: %0.1f" % battery
cv2.putText(gaussian, bs, (20, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
if cv2.waitKey(1) & 0xFF == ord('q'):
exit()
cv2.imshow("Ahmad's Group", gaussian)
gray = cv2.cvtColor(gaussian, cv2.COLOR_RGB2GRAY)
th = cv2.adaptiveThreshold(gray, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 115, 1)
if (self.rovio.obstacle()):
#self.rovio.backward()
#self.rovio.backward()
#self.rovio.backward()
#self.rovio.backward()
#self.rovio.backward()
print('obstacle detected')
#self.dancer()
self.rovio.rotate_right(angle=45)
continue
#app.rovio.patrol()
print('moving forward')
self.rovio.forward()
self.rovio.forward()
self.rovio.forward()
self.rovio.forward()
self.rovio.forward()
print('End of move')
edge = cv2.Canny(gaussian, 100, 200)
cv2.imshow('Edge', edge)
old_image = gaussian
sleep(25 / 1000)
def get_image_difference(self, image_1, image_2):
first_image_hist = cv2.calcHist([image_1], [0], None, [256], [0, 256])
second_image_hist = cv2.calcHist([image_2], [0], None, [256], [0, 256])
img_hist_diff = cv2.compareHist(first_image_hist, second_image_hist,
cv2.HISTCMP_BHATTACHARYYA)
img_template_probability_match = cv2.matchTemplate(
first_image_hist, second_image_hist, cv2.TM_CCOEFF_NORMED)[0][0]
img_template_diff = 1 - img_template_probability_match
# taking only 10% of histogram diff, since it's less accurate than template method
commutative_image_diff = (img_hist_diff / 10) + img_template_diff
return commutative_image_diff
def dancer(self):
dance_sequence = [1, 2, 3, 4, 5]
winsound.PlaySound(
'Fallout 4 - Intro Cinematic Theme Music (NO VOICE).mp3',
winsound.SND_FILENAME)
for x in dance_sequence:
# x = random.randint(1,5)
if x == 1:
self.rovio.head_up()
time.sleep(1)
elif x == 2:
self.rovio.rotate_left(angle=360, speed=2)
time.sleep(3)
elif x == 3:
self.rovio.head_middle()
self.rovio.right()
self.rovio.right()
self.rovio.right()
time.sleep(0.5)
self.rovio.left()
self.rovio.left()
self.rovio.left()
time.sleep(1)
elif x == 4:
self.rovio.rotate_right(angle=360, speed=2)
time.sleep(3)
elif x == 5:
self.rovio.head_down()
def ocr(image, num):
rovio = Rovio('192.168.10.18', 'myname', '12345')
# open image
image = cv2.imread(image)
# turn image to binary
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray, 0, 255,
cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
# deskew text function
coords = np.column_stack(np.where(thresh > 0))
angle = cv2.minAreaRect(coords)[-1]
# the `cv2.minAreaRect` function returns values in the
# range [-90, 0); as the rectangle rotates clockwise the
# returned angle trends to 0 -- in this special case we
# need to add 90 degrees to the angle
if angle < -45:
angle = -(90 + angle)
# otherwise, just take the inverse of the angle to make it positive
else:
angle = -angle
# rotate the image to deskew it
(h, w) = image.shape[:2]
center = (w // 2, h // 2)
M = cv2.getRotationMatrix2D(center, angle, 1.0)
rotated = cv2.warpAffine(image,
M, (w, h),
flags=cv2.INTER_CUBIC,
borderMode=cv2.BORDER_REPLICATE)
# draw the correction angle on the image so we can validate it
cv2.putText(rotated, "Angle: {:.2f} degrees".format(angle), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# show the output image
print("[INFO] angle: {:.3f}".format(angle))
# end of text deskew function
# save rotated image
imag = 'D:/works/Third year/Intelligent Robotics/Rovio/thresh' + str(
num) + '.jpg'
cv2.imwrite(
'D:/works/Third year/Intelligent Robotics/Rovio/skewed' + str(num) +
'.jpg', rotated)
# turn image to binary and save image
gray = cv2.cvtColor(rotated, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray, 0, 255,
cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
cv2.imwrite(
'D:/works/Third year/Intelligent Robotics/Rovio/thresh' + str(num) +
'.jpg', thresh)
# Simple image to string ocr, lang=eng
text = pytesseract.image_to_string(Image.open(imag),
lang='eng',
config=tessdata_dir_config)
# print output to console
print(num, ':\n', text)
text = text.lower()
val = 0
if "dance" in text:
val = 1
if "rotate" in text:
val = 2
if "stop" in text:
val = 99
if "nod" in text:
val = 3
url = '192.168.10.18'
user = '******'
password = "******"
app = rovioControl(url, user, password)
# if val value to run command
if val == 1:
#file.write(1)
print "Order Received. I'm dancing till dropping..."
app.dancer()
return 1
if val == 2:
rovio.rotate_left(angle=360)
return 1
if val == 3:
rovio.head_middle()
rovio.head_middle()
rovio.head_up()
rovio.head_up()
rovio.head_middle()
rovio.head_middle()
rovio.head_down()
rovio.head_down()
rovio.head_middle()
rovio.head_middle()
rovio.head_up()
rovio.head_up()
rovio.head_up()
rovio.head_middle()
rovio.head_middle()
rovio.head_down()
rovio.head_down()
rovio.head_middle()
rovio.head_middle()
rovio.head_up()
rovio.head_up()
rovio.head_up()
rovio.head_middle()
rovio.head_middle()
rovio.head_down()
rovio.head_down()
rovio.head_middle()
rovio.head_middle()
rovio.head_up()
rovio.head_up()
rovio.head_up()
rovio.head_middle()
rovio.head_middle()
rovio.head_down()
rovio.head_down()
return 1
if val == 99:
rovio.head_down()
exit()
else:
return 0
class rovioControl(object):
def __init__(self, url, username, password, port=80):
self.rovio = Rovio(url, username=username, password=password,
port=port)
self.last = None
self.key = 0
def night_vision(self, frame):
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = cv2.equalizeHist(frame)
return frame
def show_battery(self, frame):
sh = frame.shape
m, n = sh[0], sh[1]
battery, charging = self.rovio.battery()
battery = 100 * battery / 130.
bs = "Battery: %0.1f" % battery
cs = "Status: Roaming"
if charging == 80:
cs = "Status: Charging"
cv2.putText(frame, bs, (20, 20),
cv2.FONT_HERSHEY_PLAIN, 2, (255, 0, 0))
cv2.putText(frame, cs, (300, 20),
cv2.FONT_HERSHEY_PLAIN, 2, (255, 0, 0))
return frame
def resize(self, frame, size=(640, 480)):
frame = cv2.resize(frame, size)
return frame
def face_detection(self):
# Stop Rovio so that it can stop down to recognize
self.rovio.stop()
self.rovio.head_up()
flag = False
frame = self.rovio.camera.get_frame()
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
cv2.imshow(frame)
if faces == ():
pass
else:
flag = True
winsound.PlaySound('%s.wav' % 'humandetected', winsound.SND_FILENAME)
return flag
def floor_finder(self):
frame = self.rovio.camera.get_frame()
im_gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
gaussian = cv2.GaussianBlur(im_gray,(5,5),0)
edges = cv2.Canny(gaussian,100,200)
##############################
# Make the line more obvious #
##############################
# Kernel
kernel = np.ones((2, 2), np.uint8)
dilate = cv2.dilate(edges, kernel, iterations=1)
# Perform matrix function
im = np.asarray(dilate)
h= np.size(im, 0)
w= np.size(im, 1)
y = 0
line = []
for j in range(h-1,0,-1):
for i in range(w):
if not im[j][i] == 0:
y = j
break
cv2.rectangle(frame,(0,y),(w,h),(245,252,0),2)
cv2.imshow("FloorFinder", frame)
return h-y
def main(self):
# self.rovio.head_middle()
frame = self.rovio.camera.get_frame()
if not isinstance(frame, np.ndarray):
return
frame = self.night_vision(frame)
# frame = filter.sobel(frame)
# frame = img_as_ubyte(frame)
frame = self.resize(frame)
frame = cv2.merge([frame, frame, frame])
frame = self.show_battery(frame)
if self.floor_finder() > 50:
if (not self.rovio.ir()):
self.rovio.api.set_ir(1)
if (not self.rovio.obstacle()):
self.rovio.forward(speed=7)
else:
self.rovio.rotate_right(angle=20, speed=2)
else:
self.rovio.rotate_right(angle=20, speed=2)
self.key = cv2.waitKey(20)
if self.key > 0:
# print self.key
pass
if self.key == 114: # r
self.rovio.turn_around()
elif self.key == 63233 or self.key == 115: # down or s
self.rovio.backward(speed=1)
elif self.key == 63232 or self.key == 119: # up or w
self.rovio.forward(speed=1)
elif self.key == 63234 or self.key == 113: # left or a
self.rovio.rotate_left(angle=12, speed=5)
elif self.key == 63235 or self.key == 101: # right or d
self.rovio.rotate_right(angle=12, speed=5)
elif self.key == 97: # left or a
self.rovio.left(speed=1)
elif self.key == 100: # right or d
self.rovio.right(speed=1)
elif self.key == 44: # comma
self.rovio.head_down()
elif self.key == 46: # period
self.rovio.head_middle()
elif self.key == 47: # slash
self.rovio.head_up()
elif self.key == 32: # Space Bar
flag = False
self.rovio.stop()
while not flag:
flag = self.face_detection()
print flag
class rovioControl(object):
def __init__(self, url, username, password, port=80):
self.rovio = Rovio(url,
username=username,
password=password,
port=port)
self.last = None
self.key = 0
def night_vision(self, frame):
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = cv2.equalizeHist(frame)
return frame
def show_battery(self, frame):
sh = frame.shape
m, n = sh[0], sh[1]
battery, charging = self.rovio.battery()
battery = 100 * battery / 130.
bs = "Battery: %0.1f" % battery
cs = "Status: Roaming"
if charging == 80:
cs = "Status: Charging"
cv2.putText(frame, bs, (20, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
cv2.putText(frame, cs, (300, 20), cv2.FONT_HERSHEY_PLAIN, 2,
(255, 0, 0))
return frame
def resize(self, frame, size=(640, 480)):
frame = cv2.resize(frame, size)
return frame
def face_detection(self):
# Stop Rovio so that it can stop down to recognize
self.rovio.stop()
self.rovio.head_up()
flag = False
frame = self.rovio.camera.get_frame()
face_cascade = cv2.CascadeClassifier(
'haarcascade_frontalface_default.xml')
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
cv2.imshow(frame)
if faces == ():
pass
else:
flag = True
winsound.PlaySound('%s.wav' % 'humandetected',
winsound.SND_FILENAME)
return flag
def floor_finder(self):
frame = self.rovio.camera.get_frame()
im_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gaussian = cv2.GaussianBlur(im_gray, (5, 5), 0)
edges = cv2.Canny(gaussian, 100, 200)
##############################
# Make the line more obvious #
##############################
# Kernel
kernel = np.ones((2, 2), np.uint8)
dilate = cv2.dilate(edges, kernel, iterations=1)
# Perform matrix function
im = np.asarray(dilate)
h = np.size(im, 0)
w = np.size(im, 1)
y = 0
line = []
for j in range(h - 1, 0, -1):
for i in range(w):
if not im[j][i] == 0:
y = j
break
cv2.rectangle(frame, (0, y), (w, h), (245, 252, 0), 2)
cv2.imshow("FloorFinder", frame)
return h - y
def main(self):
# self.rovio.head_middle()
frame = self.rovio.camera.get_frame()
if not isinstance(frame, np.ndarray):
return
frame = self.night_vision(frame)
# frame = filter.sobel(frame)
# frame = img_as_ubyte(frame)
frame = self.resize(frame)
frame = cv2.merge([frame, frame, frame])
frame = self.show_battery(frame)
if self.floor_finder() > 50:
if (not self.rovio.ir()):
self.rovio.api.set_ir(1)
if (not self.rovio.obstacle()):
self.rovio.forward(speed=7)
else:
self.rovio.rotate_right(angle=20, speed=2)
else:
self.rovio.rotate_right(angle=20, speed=2)
self.key = cv2.waitKey(20)
if self.key > 0:
# print self.key
pass
if self.key == 114: # r
self.rovio.turn_around()
elif self.key == 63233 or self.key == 115: # down or s
self.rovio.backward(speed=1)
elif self.key == 63232 or self.key == 119: # up or w
self.rovio.forward(speed=1)
elif self.key == 63234 or self.key == 113: # left or a
self.rovio.rotate_left(angle=12, speed=5)
elif self.key == 63235 or self.key == 101: # right or d
self.rovio.rotate_right(angle=12, speed=5)
elif self.key == 97: # left or a
self.rovio.left(speed=1)
elif self.key == 100: # right or d
self.rovio.right(speed=1)
elif self.key == 44: # comma
self.rovio.head_down()
elif self.key == 46: # period
self.rovio.head_middle()
elif self.key == 47: # slash
self.rovio.head_up()
elif self.key == 32: # Space Bar
flag = False
self.rovio.stop()
while not flag:
flag = self.face_detection()
print flag