def __init__(self, node_name):
ROS2OpenCV2.__init__(self, node_name)
self.node_name = node_name
# The minimum saturation of the tracked color in HSV space,
# as well as the min and max value (the V in HSV) and a
# threshold on the backprojection probability image.
self.smin = rospy.get_param("~smin", 85)
self.vmin = rospy.get_param("~vmin", 50)
self.vmax = rospy.get_param("~vmax", 254)
self.threshold = rospy.get_param("~threshold", 50)
# Create a number of windows for displaying the histogram,
# parameters controls, and backprojection image
cv.NamedWindow("Histogram", cv.CV_WINDOW_NORMAL)
cv.MoveWindow("Histogram", 700, 50)
cv.NamedWindow("Parameters", 0)
cv.MoveWindow("Parameters", 700, 325)
cv.NamedWindow("Backproject", 0)
cv.MoveWindow("Backproject", 700, 600)
# Create the slider controls for saturation, value and threshold
cv.CreateTrackbar("Saturation", "Parameters", self.smin, 255, self.set_smin)
cv.CreateTrackbar("Min Value", "Parameters", self.vmin, 255, self.set_vmin)
cv.CreateTrackbar("Max Value", "Parameters", self.vmax, 255, self.set_vmax)
cv.CreateTrackbar("Threshold", "Parameters", self.threshold, 255, self.set_threshold)
# Initialize a number of variables
self.hist = None
self.track_window = None
self.show_backproj = False
def __init__(self):
self.node_name = "cv_bridge_demo"
rospy.init_node(self.node_name)
# What we do during shutdown
rospy.on_shutdown(self.cleanup)
# Create the OpenCV display window for the RGB image
self.cv_window_name = self.node_name
cv2.NamedWindow(self.cv_window_name, cv2.CV_WINDOW_NORMAL)
cv2.MoveWindow(self.cv_window_name, 25, 75)
# And one for the depth image
cv2.NamedWindow("Depth Image", cv2.CV_WINDOW_NORMAL)
cv2.MoveWindow("Depth Image", 25, 350)
# Create the cv_bridge object
self.bridge = CvBridge()
# Subscribe to the camera image and depth topics and set
# the appropriate callbacks
self.image_sub = rospy.Subscriber("/bebop/image_raw", Image,
self.image_callback)
self.depth_sub = rospy.Subscriber("/camera/depth/image_raw", Image,
self.depth_callback)
rospy.loginfo("Waiting for image topics...")
def initialize(self, filename, verbose=0):
self._InitConfig(filename)
self._verbose = verbose
if self._verbose:
cv2.NamedWindow('src_image', cv2.CV_WINDOW_AUTOSIZE)
cv2.MoveWindow('src_image', 50, 50)
cv2.NamedWindow('dst_image', cv2.CV_WINDOW_AUTOSIZE)
cv2.MoveWindow('des_image', 50, 350)
def __init__(self, img0):
self.thresh1 = 255
self.thresh2 = 30
self.level =4
self.storage = cv.CreateMemStorage()
cv.NamedWindow("Source", 0)
cv.ShowImage("Source", img0)
cv.NamedWindow("Segmentation", 0)
cv.CreateTrackbar("Thresh1", "Segmentation", self.thresh1, 255, self.set_thresh1)
cv.CreateTrackbar("Thresh2", "Segmentation", self.thresh2, 255, self.set_thresh2)
self.image0 = cv.CloneImage(img0)
self.image1 = cv.CloneImage(img0)
cv.ShowImage("Segmentation", self.image1)
def __init__(self, ceil=8, doRecord=True, showWindows=True):
self.writer = None
self.font = None
self.doRecord = doRecord #Either or not record the moving object
self.show = showWindows #Either or not show the 2 windows
self.frame = None
self.capture = cv.VideoCapture(0)
self.frame = self.capture.read() #Take a frame to init recorder
if doRecord:
self.initRecorder()
self.frame1gray = cv.CreateMat(self.frame.height, self.frame.width,
cv.CV_8U) #Gray frame at t-1
cv.CvtColor(self.frame, self.frame1gray, cv.CV_RGB2GRAY)
#Will hold the thresholded result
self.res = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
self.frame2gray = cv.CreateMat(self.frame.height, self.frame.width,
cv.CV_8U) #Gray frame at t
self.width = self.frame.width
self.height = self.frame.height
self.nb_pixels = self.width * self.height
self.ceil = ceil
self.isRecording = False
self.trigger_time = 0 #Hold timestamp of the last detection
if showWindows:
cv.NamedWindow("Image")
cv.CreateTrackbar("Mytrack", "Image", self.ceil, 100,
self.onChange)
def __init__(self, threshold=1, doRecord=True, showWindows=True):
self.writer = None
self.font = None
self.doRecord = doRecord # Either or not record the moving object
self.show = showWindows # Either or not show the 2 windows
self.frame = None
self.capture = cv.CaptureFromCAM(0)
self.frame = cv.QueryFrame(
self.capture) # Take a frame to init recorder
if doRecord:
self.initRecorder()
self.gray_frame = cv.CreateImage(cv.GetSize(self.frame),
cv.IPL_DEPTH_8U, 1)
self.average_frame = cv.CreateImage(cv.GetSize(self.frame),
cv.IPL_DEPTH_32F, 3)
self.absdiff_frame = None
self.previous_frame = None
self.surface = self.frame.width * self.frame.height
self.currentsurface = 0
self.currentcontours = None
self.threshold = threshold
self.isRecording = False
self.trigger_time = 0 # Hold timestamp of the last detection
if showWindows:
cv.NamedWindow("Image")
cv.CreateTrackbar("Detection treshold: ", "Image", self.threshold,
100, self.onThresholdChange)
def show_shapes(shapes):
""" Function to show all of the shapes which are passed to it
"""
cv.NamedWindow("Shape Model", cv.CV_WINDOW_AUTOSIZE)
# Get size for the window
max_x = int(max([pt.x for shape in shapes for pt in shape.pts]))
max_y = int(max([pt.y for shape in shapes for pt in shape.pts]))
min_x = int(min([pt.x for shape in shapes for pt in shape.pts]))
min_y = int(min([pt.y for shape in shapes for pt in shape.pts]))
i = cv.CreateImage((max_x-min_x+20, max_y-min_y+20), cv.IPL_DEPTH_8U, 3)
cv.Set(i, (0, 0, 0))
for shape in shapes:
r = randint(0, 255)
g = randint(0, 255)
b = randint(0, 255)
#r = 0
#g = 0
#b = 0
for pt_num, pt in enumerate(shape.pts):
# Draw normals
#norm = shape.get_normal_to_point(pt_num)
#cv.Line(i,(pt.x-min_x,pt.y-min_y), \
# (norm[0]*10 + pt.x-min_x, norm[1]*10 + pt.y-min_y), (r, g, b))
cv.Circle(i, (int(pt.x-min_x), int(pt.y-min_y)), 2, (r, g, b), -1)
cv.ShowImage("Shape Model",i)
def grab_images(video_file, frame_inc=100, delay=100):
"""
Walks through the entire video and save image for each increment
"""
my_video = init_video(video_file)
if my_video != None:
# Display the video and save evry increment frames
cpt = 0
img = cv2.QueryFrame(my_video)
if img != None:
cv2.NamedWindow("Vid", cv2.CV_WINDOW_AUTOSIZE)
else:
return None
nFrames = int(
cv2.GetCaptureProperty(my_video, cv2.CV_CAP_PROP_FRAME_COUNT))
while cpt < nFrames:
for ii in range(frame_inc):
img = cv2.QueryFrame(my_video)
cpt += 1
cv2.ShowImage("Vid", img)
out_name = "" + str(cpt) + ".jpg"
cv2.SaveImage(out_name, img)
print out_name, str(nFrames)
cv2.WaitKey(delay)
else:
return None
def display_video(my_video, frame_inc=100, delay=100):
"""
Displays frames of the video in a dumb way.
Used to see if everything is working fine
my_video = cv2Capture object
frame_inc = Nmber of increments between each frame displayed
delay = time delay between each image
"""
cpt = 0
img = cv2.QueryFrame(my_video)
if img != None:
cv2.NamedWindow("Vid", cv2.CV_WINDOW_AUTOSIZE)
else:
return None
nFrames = int(cv2.GetCaptureProperty(my_video,
cv2.CV_CAP_PROP_FRAME_COUNT))
while cpt < nFrames:
for ii in range(frame_inc):
img = cv2.QueryFrame(my_video)
cpt + 1
cv2.ShowImage("Vid", img)
cv2.WaitKey(delay)
def display_img(img, delay=1000):
"""
One liner that displays the given image on screen
"""
cv2.NamedWindow("Vid", cv2.CV_WINDOW_AUTOSIZE)
cv2.ShowImage("Vid", img)
cv2.WaitKey(delay)
def show(area):
cv2.Rectangle(img, (area[0][0], area[0][1]),
(area[0][0] + area[0][2], area[0][1] + area[0][3]),
(255, 0, 0), 2)
cv2.NamedWindow('Face Detection', cv2.CV_WINDOW_NORMAL)
cv2.imread('Face Detection', img)
cv2.WaitKey()
def use_camera(self):
# global cascade, capture, frame_copy
if not self.is_device_connected():
return
try:
# if camera already openned
if self.capture is not None:
return
if self.cascade is None:
self.cascade = cv.Load(
os.path.join(APPLICATION_PATH, "face.xml"))
self.capture = cv.CreateCameraCapture(0)
if self.showVideo:
cv.NamedWindow("video", 1)
self.set_resolution(640, 480)
self.frame_copy = None
except:
self.close_camera()
print "Error in use_camera"
pass
def __init__(self,mode=1,name="w1",capture=1):
print name
if mode == 1:
cv2.StartWindowThread()
cv2.NamedWindow(name, cv2.CV_WINDOW_AUTOSIZE)
self.camera_index = 0
self.name=name
if capture == 1:
self.capture = cv2.CaptureFromCAM(self.camera_index)
def draw_model_fitter(f):
cv.NamedWindow("Model Fitter", cv.CV_WINDOW_AUTOSIZE)
# Copy image
i = cv.CreateImage(cv.GetSize(f.image), f.image.depth, 3)
cv.Copy(f.image, i)
for pt_num, pt in enumerate(f.shape.pts):
# Draw normals
cv.Circle(i, (int(pt.x), int(pt.y)), 2, (0,0,0), -1)
cv.ShowImage("Shape Model",i)
cv.WaitKey()
def __init__(self,
webcam=0,
sample_duration=10,
window_title="Heart Monitor"):
"""
Program to monitor heartrates using a webcam.
"""
self.cam = Camera(webcam)
self.face_detector = FaceDetector(*self.cam.get_size())
self.face_tracker = None
self.heart_monitor = HeartMonitor(sample_duration,
fps=self.cam.get_fps())
self.annotator = Annotator()
self.window = window_title
cv.NamedWindow(self.window)
self.show_bpm = True
self.show_face = True
self.show_forehead = True
self.show_fft = True
def __init__(self):
self.node_name = "cv_bridge_demo"
rospy.init_node(self.node_name)
# What we do during shutdown
rospy.on_shutdown(self.cleanup)
# Create the OpenCV display window for the RGB image
self.cv_window_name = self.node_name
cv2.NamedWindow(self.cv_window_name, cv2.CV_WINDOW_NORMAL)
cv2.MoveWindow(self.cv_window_name, 25, 75)
# Create the cv_bridge object
self.bridge = CvBridge()
# Subscribe to the camera image and depth topics and set
# the appropriate callbacks
self.image_sub = rospy.Subscriber("/usb_cam/image_raw",
Image,
self.image_callback,
queue_size=1)
rospy.loginfo("Waiting for image topics...")
rospy.wait_for_message("/usb_cam/image_raw", Image)
rospy.loginfo("Ready.")
#### end of Detect faces ######################
def getColor(mf):
if (mf.isNodding()): return GREEN
elif (mf.isShaking()): return RED
elif (mf.isStill()): return BLUE
else: return YELLOW
######### main program ############
if __name__ == '__main__':
#create window and move to screen position
cv2.NamedWindow('Camera', cv2.CV_WINDOW_AUTOSIZE)
cv2.namedWindow('Camera', cv2.WINDOW_AUTOSIZE)
if len(sys.argv) == 1:
# no argument on the command line, try to use the camera
capture = cv2.CreateCameraCapture(0)
#
### check that capture device is OK
if not capture:
print("Error opening capture device")
sys.exit(1)
#
### capture the 1st frame to get some propertie on it
frame = cv2.QueryFrame(capture)
#
### get size of the frame
frame_size = cv2.GetSize(frame)
def main():
global current_image
global current_img_file_name
global has_roi
global roi_x0
global roi_y0
global roi_x1
global roi_y1
iKey = 0
files = glob.glob(image_file_glob)
if len(files) == 0:
print("No files match glob pattern")
return
files = [os.path.abspath(f) for f in files]
files.sort()
# init GUI
cv.NamedWindow(window_name, 1)
cv.SetMouseCallback(window_name, on_mouse, None)
sys.stderr.write("Opening directory...")
# init output of rectangles to the info file
#os.chdir(input_directory)
sys.stderr.write("done.\n")
current_file_index = 0
while True:
current_img_file_name = files[current_file_index]
num_of_rec = 0
sys.stderr.write(
"Loading current_image (%d/%d) %s...\n" %
(current_file_index + 1, len(files), current_img_file_name))
try:
current_image = cv.LoadImage(current_img_file_name, 1)
except IOError:
sys.stderr.write("Failed to load current_image %s.\n" %
current_img_file_name)
return -1
# Work on current current_image
#cv.ShowImage(window_name, current_image)
redraw()
# Need to figure out waitkey returns.
# <Space> = 32 add rectangle to current image
# <left> = 81 save & next
# <right> = 83 save & prev
# <a> = 97 add rect to table
# <b> = 98 toggle file is background or not
# <d> = 100 remove old rect
# <q> = 113 exit program
# <s> = 115 save rect table
# <x> = 136 skip image
iKey = cv.WaitKey(0) % 255
# This is ugly, but is actually a simplification of the C++.
#sys.stderr.write(str(iKey) + '\n')
if draging:
continue
if iKey == 81:
current_file_index -= 1
if current_file_index == -1:
current_file_index = len(files) - 1
clear_roi()
elif iKey == 83:
current_file_index += 1
if current_file_index == len(files):
current_file_index = 0
clear_roi()
elif iKey == 113:
cv.DestroyWindow(window_name)
return 0
elif iKey == 97:
rect_table.setdefault(current_img_file_name, set()).add(
(roi_x0, roi_y0, roi_x1 - roi_x0, roi_y1 - roi_y0))
clear_roi()
write_rect_table()
redraw()
elif iKey == 98:
if current_img_file_name in background_files:
background_files.remove(current_img_file_name)
else:
background_files.add(current_img_file_name)
elif iKey == 100:
remove_rect(cur_mouse_x, cur_mouse_y)
elif iKey == 115:
write_rect_table()
elif iKey == 136:
sys.stderr.write("Skipped %s.\n" % current_file_index)
def __init__(self, ceil=15):
self.ceil = ceil
self.capture = cv.CaptureFromCAM(0)
cv.NamedWindow("Target", 1)
for i in range(im.height):
row = cv.GetRow(im, i)
if cv.Sum(row)[0] != 0.0:
bottommost = i
if temp == 1:
topmost = i
temp = 2
return (leftmost, rightmost, topmost, bottommost)
capture = cv.VideoCapture(0)
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, 1280)
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT, 720)
frame = cv.QueryFrame(capture)
test = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.NamedWindow("output")
previous_x = 0
previous_y = 0
while (1):
frame = cv.QueryFrame(capture)
cv.Flip(frame, frame, 1)
# we make all drawings on imdraw.
imdraw = cv.CreateImage(cv.GetSize(frame), 8, 3)
# we get coordinates from imgyellowthresh
imgyellowthresh = getthresholdedimg(frame)
# eroding removes small noises
cv.Erode(imgyellowthresh, imgyellowthresh, None, 1)
(leftmost, rightmost, topmost, bottommost) = getpositions(imgyellowthresh)
if (leftmost - rightmost != 0) or (topmost - bottommost != 0):
lastx = posx
lasty = posy
def Dilation(pos):
element = cv.CreateStructuringElementEx(pos * 2 + 1, pos * 2 + 1, pos, pos,
element_shape)
cv.Dilate(src, dest, element, 1)
cv.ShowImage("Erosion & Dilation", dest)
if __name__ == "__main__":
if len(sys.argv) > 1:
src = cv.LoadImage(sys.argv[1], cv.CV_LOAD_IMAGE_COLOR)
else:
url = 'https://code.ros.org/svn/opencv/trunk/opencv/samples/c/fruits.jpg'
filedata = urllib2.urlopen(url).read()
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1)
cv.SetData(imagefiledata, filedata, len(filedata))
src = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR)
image = cv.CloneImage(src)
dest = cv.CloneImage(src)
cv.NamedWindow("Opening & Closing", 1)
cv.NamedWindow("Erosion & Dilation", 1)
cv.ShowImage("Opening & Closing", src)
cv.ShowImage("Erosion & Dilation", src)
cv.CreateTrackbar("Open", "Opening & Closing", 0, 10, Opening)
cv.CreateTrackbar("Close", "Opening & Closing", 0, 10, Closing)
cv.CreateTrackbar("Dilate", "Erosion & Dilation", 0, 10, Dilation)
cv.CreateTrackbar("Erode", "Erosion & Dilation", 0, 10, Erosion)
cv.WaitKey(0)
cv.DestroyWindow("Opening & Closing")
cv.DestroyWindow("Erosion & Dilation")
for x in range(18):
set_pixel_rgbw(x, r if x in [3, 4] else 0, g if x in [3, 4] else 0, b,
w if x in [0, 1, 6, 7] else 0)
show()
lights(0, 0, 0, 50)
min_size = (15, 15)
image_scale = 5
haar_scale = 1.2
min_neighbors = 2
haar_flags = cv.CASCADE_DO_CANNY_PRUNING
cap = cv.VideoCapture(0)
cv.NamedWindow("Tracker", 1)
if cap:
frame_copy = None
while (True):
# Capture frame-by-frame
result, frame = capture.read()
#frame = cv.QueryFrame(cap)
if not frame:
cv.waitKey(0)
break
if not frame_copy:
frame_copy = cv.CreateImage((frame.width, frame.height),
cv.IPL_DEPTH_8U, frame.nChannels)
if frame.origin == cv.IPL_ORIGIN_TL:
import os
import cv2
cv2.NamedWindow('image')
while true:
os.system('fswebcam -r 1024')
cv.Set2D(disparity,i,j,cv.Get2D(image,i,j)) #Change the particular array element.
# loading the stereo pair
left = cv.imread('000000.png',cv.IMREAD_GRAYSCALE)
right = cv.imread('000001.png',cv.IMREAD_GRAYSCALE)
#create a matrix from each image
'''
disparity_left = cv.CreateMat(left.height, left.width, cv.CV_16S)
disparity_right = cv.CreateMat(left.height, left.width, cv.CV_16S)
'''
disparity_left = np.array((left.shape[0], left.shape[1]),np.uint8) #maybe changed to more approprate type
disparity_right = np.array((right.shape[0], right.shape[1]),np.uint8)
# Creates the state of graph cut-based stereo correspondence algorithm.
state = cv.CreateStereoGCState(16,2)
# Computes the disparity map using graph cut-based algorithm.
cv.FindStereoCorrespondenceGC(left,right,
disparity_left,disparity_right,state)
disp_left_visual = cv.CreateMat(left.height, left.width, cv.CV_8U)
cv.ConvertScale( disparity_left, disp_left_visual, -20 );
cv.Save( "disparity.pgm", disp_left_visual ); # save the map
# cutting the object farthest of a threshold (120)
cut(disp_left_visual,left,120)
cv.NamedWindow('Disparity map', cv.CV_WINDOW_AUTOSIZE)
cv.ShowImage('Disparity map', disp_left_visual)
cv.WaitKey()
#!/usr/bin/env python
# -*- coding:utf8 -*-
import cv2
# 读图片
image = cv2.LoadImage('G:/python/opencv_dir/wx.jpg',
cv2.CV_LOAD_IMAGE_COLOR) # Load the image
# Or just: image=cv.LoadImage('img/image.png')
cv2.NamedWindow('a_window', cv2.CV_WINDOW_AUTOSIZE) # Facultative
cv2.ShowImage('a_window', image) # Show the image
def __init__(self):
cv.NamedWindow(color_tracker_window, 1)
self.capture = cv.CaptureFromCAM(0)
return (pupilImg)
# Returns the image as a "tape" converting polar coord. to Cartesian coord.
#
# @param image Image with iris and pupil
# @returns image "Normalized" image
def getPolar2CartImg(image, rad):
imgSize = cv.GetSize(image)
c = (float(imgSize[0]/2.0), float(imgSize[1]/2.0))
imgRes = cv.CreateImage((rad*3, int(360)), 8, 3)
#cv.LogPolar(image,imgRes,c,50.0, cv.CV_INTER_LINEAR+cv.CV_WARP_FILL_OUTLIERS)
cv.LogPolar(image,imgRes,c,60.0, cv.CV_INTER_LINEAR+cv.CV_WARP_FILL_OUTLIERS)
return (imgRes)
# Window creation for showing input, output
cv.NamedWindow("input", cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow("output", cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow("normalized", cv.CV_WINDOW_AUTOSIZE)
eyesList = os.listdir('images/eyes')
key = 0
while True:
eye = getNewEye(eyesList)
frame = cv.LoadImage("images/eyes/"+eye)
iris = cv.CloneImage(frame)
output = getPupil(frame)
iris = getIris(output)
cv.ShowImage("input", frame)
cv.ShowImage("output", iris)
normImg = cv.CloneImage(iris)
normImg = getPolar2CartImg(iris,radius)
class Target:
def __init__(self):
self.capture = cv.CaptureFromCAM(0)
cv.NamedWindow('Target', 1)
cv.NamedWindow('Threshold1', 1)
cv.NamedWindow('Threshold2', 1)
cv.NamedWindow('hsv', 1)
def run(self):
#initiate font
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 3, 8)
# instantiate images
hsv_img = cv.CreateImage(cv.GetSize(cv.QueryFrame(self.capture)), 8, 3)
threshold_img1 = cv.CreateImage(cv.GetSize(hsv_img), 8, 1)
threshold_img1a = cv.CreateImage(cv.GetSize(hsv_img), 8, 1)
threshold_img2 = cv.CreateImage(cv.GetSize(hsv_img), 8, 1)
i = 0
writer = cv.CreateVideoWriter('angle_tracking.avi', cv.CV_FOURCC('M', 'J', 'P', 'G'), 30, cv.GetSize(hsv_img), 1)
while True:
# capture the image from the cam
img = cv.QueryFrame(self.capture)
# convert the image to HSV
cv.CvtColor(img, hsv_img, cv.CV_BGR2HSV)
# threshold the image to isolate two colors
cv.InRangeS(hsv_img, (165, 145, 100), (250, 210, 160), threshold_img1) # red
cv.InRangeS(hsv_img, (0, 145, 100), (10, 210, 160), threshold_img1a) # red again
cv.Add(threshold_img1, threshold_img1a, threshold_img1) # this is combining the two limits for red
cv.InRangeS(hsv_img, (105, 180, 40), (120, 260, 100), threshold_img2) # blue
# determine the moments of the two objects
threshold_img1 = cv.GetMat(threshold_img1)
threshold_img2 = cv.GetMat(threshold_img2)
moments1 = cv.Moments(threshold_img1, 0)
moments2 = cv.Moments(threshold_img2, 0)
area1 = cv.GetCentralMoment(moments1, 0, 0)
area2 = cv.GetCentralMoment(moments2, 0, 0)
# initialize x and y
x1, y1, x2, y2 = (1, 2, 3, 4)
coord_list = [x1, y1, x2, y2]
for x in coord_list:
x = 0
# there can be noise in the video so ignore objects with small areas
if (area1 > 200000):
# x and y coordinates of the center of the object is found by dividing the 1,0 and 0,1 moments by the area
x1 = int(cv.GetSpatialMoment(moments1, 1, 0) / area1)
y1 = int(cv.GetSpatialMoment(moments1, 0, 1) / area1)
# draw circle
cv.Circle(img, (x1, y1), 2, (0, 255, 0), 20)
# write x and y position
cv.PutText(img, str(x1) +', '+str(y1), (x1, y1 + 20), font, 255) # Draw the text
if (area2 > 100000):
# x and y coordinates of the center of the object is found by dividing the 1,0 and 0,1 moments by the area
x2 = int(cv.GetSpatialMoment(moments2, 1, 0) / area2)
y2 = int(cv.GetSpatialMoment(moments2, 0, 1) / area2)
# draw circle
cv.Circle(img, (x2, y2), 2, (0, 255, 0), 20)
cv.PutText(img, str(x2) +', '+str(y2), (x2, y2 + 20), font, 255) # Draw the text
cv.Line(img, (x1, y1), (x2, y2), (0, 255, 0), 4, cv.CV_AA)
# draw line and angle
cv.Line(img, (x1, y1), (cv.GetSize(img)[0], y1), (100, 100, 100, 100), 4, cv.CV_AA)
x1 = float(x1)
y1 = float(y1)
x2 = float(x2)
y2 = float(y2)
angle = int(math.atan((y1 - y2) / (x2 - x1)) * 180 / math.pi)
cv.PutText(img, str(angle), (int(x1) + 50, (int(y2) + int(y1)) / 2), font, 255)
# cv.WriteFrame(writer,img)
# display frames to users
cv.ShowImage('Target', img)
cv.ShowImage('Threshold1', threshold_img1)
cv.ShowImage('Threshold2', threshold_img2)
cv.ShowImage('hsv', hsv_img)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
cv.DestroyAllWindows()
import cv2 #import the openCV lib to python
import serial #import the pyserial module
#Module -1: Image Processing
hc = cv2.imread(
'/home/george/PycharmProjects/Embeded image processing system/haarcascade_frontalface_alt2.xml'
)
img = cv2.imshow('/home/jayneil/beautiful-faces.jpg', 0)
faces = cv2.HaarDetectObjects(img, hc, cv2.CreateMemStorage())
a = 1
print(faces)
for (x, y, w, h), n in faces:
cv2.Rectangle(img, (x, y), (x + w, y + h), 255)
cv2.SaveImage("faces_detected.jpg", img)
dst = cv2.imread('faces_detected.jpg')
cv2.NamedWindow('Face Detected', cv2.CV_WINDOW_AUTOSIZE)
cv2.imshow('Face Detected', dst)
cv2.WaitKey(5000)
cv2.DestroyWindow('Face Detected')
#Module -2: Trigger Pyserial
if faces == []:
ser = serial.Serial('/dev/ttyUSB0', 9600)
print(ser)
ser.write('N')
else:
ser = serial.Serial('/dev/ttyUSB0', 9600)
print(ser)
ser.write('Y')
import sys
import cv2
import numpy as np
if (sys.argv[1] == "-i" and len(sys.argv) == 3):
fileLocation = sys.argv[2]
img = cv2.imread(fileLocation)
cv2.imshow("Image", img)
cv2.waitkey(0)
cv2.destroyAllWindows()
elif (sys.argv[1] == "-l" and len(sys.argv) == 3):
cv2.NamedWindow("Camera Feed", cv2.CV_WINDOW_AUTOSIZE)
port = (int)(sys.argv[2])
capture = cv2.CaptureFromCAM(port)
while True:
frame = cv2.QueryFrame(capture)
cv2.ShowImage("Camera Feed", frame)
key = cv2.waitKey(10)
if key == 27:
break
cv2.destroyWindow("Camer Feed")
