import time
x_co = 0
y_co = 0
def on_mouse(event, x, y, flag, param):
global x_co
global y_co
if (event == cv.CV_EVENT_MOUSEMOVE):
x_co = x
y_co = y
cv.NamedWindow("camera", 1)
capture = cv.CaptureFromCAM(0)
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5, 1, 0, 2, 8)
while True:
src = cv.QueryFrame(capture)
cv.Smooth(src, src, cv.CV_BLUR, 3)
hsv = cv.CreateImage(cv.GetSize(src), 8, 3)
thr = cv.CreateImage(cv.GetSize(src), 8, 1)
cv.CvtColor(src, hsv, cv.CV_BGR2HSV)
cv.SetMouseCallback("camera", on_mouse, 0)
s = cv.Get2D(hsv, y_co, x_co)
print "H:", s[0], " S:", s[1], " V:", s[2]
cv.PutText(src,
str(s[0]) + "," + str(s[1]) + "," + str(s[2]), (x_co, y_co),
font, (55, 25, 255))
cv.ShowImage("camera", src)
if cv.WaitKey(10) == 27:
break
def main():
os.chdir(sys.argv[1])
try:
os.mkdir(OUTPUT_DIR_NAME)
except:
pass
tree = et.parse("project.xml")
movie = tree.getroot()
file_path = movie.attrib["path"]
cap = cv.CreateFileCapture(file_path)
cv.QueryFrame(cap)
# skip frames in the beginning, if neccessary
start_frame = int(movie.attrib["start_frame"])
for i in range(start_frame):
cv.QueryFrame(cap)
if DEBUG:
cv.NamedWindow("win", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("win", 200, 200)
t = time.time()
f = open("shots.txt", "r")
scene_durations = [
int(values[2]) for values in [line.split("\t") for line in f if line]
]
f.close()
for scene_nr, duration in enumerate(scene_durations):
print "shot #%d" % scene_nr, "/", len(scene_durations) - 1
h = int(math.ceil(float(duration) / EVERY_NTH_FRAME))
output_img = cv.CreateImage((PIXELS_PER_COLOR * NUM_CLUSTERS, h),
cv.IPL_DEPTH_8U, 3)
frame_counter = 0
for i in range(duration):
img_orig = cv.QueryFrame(cap)
if not img_orig: # eof
break
if i % EVERY_NTH_FRAME != 0:
continue
new_width = int(img_orig.width / 4.0)
new_height = int(img_orig.height / 4.0)
img_small = cv.CreateImage((new_width, new_height),
cv.IPL_DEPTH_8U, 3)
cv.Resize(img_orig, img_small, cv.CV_INTER_AREA)
if DEBUG:
cv.ShowImage("win", img_small)
img = cv.CreateImage((new_width, new_height), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(img_small, img, cv.CV_BGR2HLS)
# convert to numpy array
a = numpy.asarray(cv.GetMat(img))
a = a.reshape(a.shape[0] * a.shape[1],
a.shape[2]) # make it 1-dimensional
# set initial centroids
init_cluster = []
for y in [int(new_height / 4.0), int(new_height * 3 / 4.0)]:
for x in [int(new_width * f) for f in [0.25, 0.75]]:
init_cluster.append(a[y * new_width + x])
init_cluster.insert(
2, a[int(new_height / 2.0) * new_width + int(new_width / 2.0)])
centroids, labels = scipy.cluster.vq.kmeans2(
a, numpy.array(init_cluster))
vecs, dist = scipy.cluster.vq.vq(a, centroids) # assign codes
counts, bins = scipy.histogram(vecs,
len(centroids)) # count occurrences
centroid_count = []
for i, count in enumerate(counts):
#print centroids[i], count
if count > 0:
centroid_count.append((centroids[i].tolist(), count))
#centroids = centroids.tolist()
#centroids.sort(hls_sort)
centroid_count.sort(hls_sort2)
px_count = new_width * new_height
x = 0
for item in centroid_count:
count = item[1] * (PIXELS_PER_COLOR * NUM_CLUSTERS)
count = int(math.ceil(count / float(px_count)))
centroid = item[0]
for l in range(count):
if x + l >= PIXELS_PER_COLOR * NUM_CLUSTERS:
break
cv.Set2D(output_img, frame_counter, x + l,
(centroid[0], centroid[1], centroid[2]))
x += count
if DEBUG:
if cv.WaitKey(1) == 27:
cv.DestroyWindow("win")
return
frame_counter += 1
output_img_rgb = cv.CreateImage(cv.GetSize(output_img),
cv.IPL_DEPTH_8U, 3)
cv.CvtColor(output_img, output_img_rgb, cv.CV_HLS2BGR)
cv.SaveImage(OUTPUT_DIR_NAME + "\\shot_colors_%04d.png" % (scene_nr),
output_img_rgb)
if DEBUG:
cv.DestroyWindow("win")
print "%.2f min" % ((time.time() - t) / 60)
#raw_input("- done -")
return
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
new_size = ( frame_size[0] / 2, frame_size[1] / 2)
color_image = cv.CreateImage(new_size, 8, 3)
grey_image = cv.CreateImage(new_size, cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(new_size, cv.IPL_DEPTH_32F, 3)
font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX_SMALL, 1, 1, 0, 1, 1)
first = True
k = 0
while True:
k+=1
captured_image = cv.QueryFrame(self.capture)
color_image = cv.CreateImage(new_size, captured_image.depth, captured_image.nChannels)
cv.Resize(captured_image, color_image)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)
if first:
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
first = False
else:
cv.RunningAvg(color_image, moving_average, 0.020, None)
# Convert the scale of the moving average.
cv.ConvertScale(moving_average, temp, 1.0, 0.0)
# Minus the current frame from the moving average.
cv.AbsDiff(color_image, temp, difference)
# Convert the image to grayscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
# Convert the image to black and white.
cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY)
# Dilate and erode to get people blobs
cv.Dilate(grey_image, grey_image, None, 18)
cv.Erode(grey_image, grey_image, None, 10)
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_TC89_KCOS)
points = []
#cv.DrawContours(color_image, contour, cv.CV_RGB(255,0,0), cv.CV_RGB(255,0,255), 2, 1, 8, (0, 0))
i = 0
while contour:
self.observed_occupancy = True
bound_rect = cv.BoundingRect(list(contour))
center_x = bound_rect[0] + (bound_rect[2]/2)
center_y = bound_rect[1] + (bound_rect[3]/2)
#if center_y < 200:
# continue
i+=1
closest_distance = 10000
closest_object = None
for to in self.tracked_objects:
current_distance = math.hypot(to.latest_position[0] - center_x, to.latest_position[1] - center_y)
closest_distance = min(closest_distance, current_distance)
#print "DISTANCES: ", str(closest_distance), str(current_distance)
if current_distance == closest_distance:
closest_object = to
if closest_object is None:
#print "OBJECT IS NEW"
self.tracked_objects.append(TrackedObject((center_x, center_y), [(center_x, center_y)], "new"))
else:
#print "CLOSEST OBJECT: ", closest_object.latest_position
closest_object.movement_vector.append((center_x, center_y))
closest_object.latest_position = (center_x, center_y)
#print "AMOUNT OF OBJECTS: ", str(len(self.tracked_objects))
if closest_object is not None:
cv.Line(color_image, closest_object.latest_position, (center_x, center_y), cv.CV_RGB(0,255,0))
#closest_x = min(closest_x, to.latest_position[0])
#closest_y = min(closest_y, to.latest_position[0])
contour = contour.h_next()
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
points.append(pt1)
points.append(pt2)
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(0,0,255), 1)
cv.PutText(color_image, str(i), pt1, font, cv.CV_RGB(255,0,255))
cv.Circle(color_image, (center_x, center_y), 2, cv.CV_RGB(255,0,255), 2, 8, 0)
#print "LEN ", len(self.tracked_objects)
#if len(self.tracked_objects) > 0 and self.tracked_objects[0] is not None:
# #print "ENTRE"
# obj_vector = self.tracked_objects[0].movement_vector
# print "MVV LEN ", len(obj_vector)
# for index in range(0, len(obj_vector)-2):
# try:
# print "Index ", index, "len(obj_vector) ", len(obj_vector)
# cv.Line(color_image, obj_vector[index], obj_vector[index+1], cv.CV_RGB(0,255,0))
#
# except: print "oops"
#print "Iteration ", k, " Vector: ", vectors["1"]
cv.ShowImage("Target", color_image)
time_passed = time.time() - self.last_request
request_threshold = 60
if time_passed > request_threshold:
self.send_occupancy()
self.send_image(color_image)
#Listen for ESC key
c = cv.WaitKey(10)
#c = cv.WaitKey(7) % 0x100
if c == 27:
break
hedef_konumu.width = logo_bau.width
hedef_konumu.height = logo_bau.height
hedefler.append(hedef_konumu)
return hedefler
sayi = 5
hedefler = hedefleri_olustur(sayi)
gecikme_zamani = 100
skor = 0
yazi_tipi = python_opencv_modulu.InitFont(
python_opencv_modulu.CV_FONT_HERSHEY_SIMPLEX, 1, 1)
while True:
goruntu_yakala = python_opencv_modulu.QueryFrame(kamera)
python_opencv_modulu.Flip(goruntu_yakala, goruntu_yakala, flipMode=1)
python_opencv_modulu.Smooth(goruntu_yakala, current,
python_opencv_modulu.CV_BLUR, 15, 15)
python_opencv_modulu.AbsDiff(current, previous, difference)
cerceve = python_opencv_modulu.CreateImage(cerceve_boyutu, 8, 1)
python_opencv_modulu.CvtColor(difference, cerceve,
python_opencv_modulu.CV_BGR2GRAY)
python_opencv_modulu.Threshold(cerceve, cerceve, 10, 0xff,
python_opencv_modulu.CV_THRESH_BINARY)
python_opencv_modulu.Dilate(cerceve,
cerceve,
element=elips_sekil_kalibi,
iterations=3)
if gecikme_zamani <= 0:
rightmost = i
if temp == 0:
leftmost = i
temp = 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.CaptureFromCAM(1)
frame = cv.QueryFrame(capture)
test = cv.CreateImage(cv.GetSize(frame), 8, 3)
# Now the selection of the desired color from video.( new)
cv.NamedWindow("pick")
cv.SetMouseCallback("pick", my_mouse_callback)
while (1):
frame = cv.QueryFrame(capture)
cv.ShowImage("pick", frame)
cv.WaitKey(33)
if evente == 7: # When double-clicked(i.e. event=7), this window closes and opens next window
break
cv.DestroyWindow("pick")
# Drawing Part (from earlier program)
cv.NamedWindow("threshold")
def closest_point(self, pt):
pos0, dpos = zip(*self.objects)
est_pts = np.asarray(pos0)+np.asarray(dpos)
min_dist = np.sum( est_pts
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
color_image = cv.CreateImage(cv.GetSize(frame), 8, 3)
grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_32F, 3)
first = True
while True:
closest_to_left = cv.GetSize(frame)[0]
closest_to_right = cv.GetSize(frame)[1]
color_image = cv.QueryFrame(self.capture)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)
if first:
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
first = False
else:
cv.RunningAvg(color_image, moving_average, 0.020, None)
# Convert the scale of the moving average.
cv.ConvertScale(moving_average, temp, 1.0, 0.0)
# Minus the current frame from the moving average.
cv.AbsDiff(color_image, temp, difference)
# Convert the image to grayscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
# Convert the image to black and white.
cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY)
# Dilate and erode to get people blobs
cv.Dilate(grey_image, grey_image, None, 18)
cv.Erode(grey_image, grey_image, None, 10)
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
objects = []
while contour:
bound_rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1)
center_point = ((pt1[0] + pt2[0]) / 2, (pt1[1] + pt2[1]) / 2), points)
if len(objects):
closest
def main():
captura = cv.CreateCameraCapture(
1) ##guardamos la imagen de la camara web usb
global arra ##cargamos el arreglo de los objetos
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 3,
3) #creamos el fondo para las letras
proses = 0
sumaa = 0
while True:
img = cv.QueryFrame(captura)
#cv.Resize(img,img,cv.CV_INTER_CUBIC)
#tiempoi = time.time()
#draw = ImageDraw.Draw(img)
anch, alt = cv.GetSize(img) ##obtenemos las dimensiones
k = cv.WaitKey(10)
##esperemos para cualquier incombeniente
#cv.SaveImage("test.jpg",img)
cv.Smooth(img, img, cv.CV_GAUSSIAN, 9,
9) ##aplicamos filtro para reducir el ruido
#cv.SaveImage("sruido.jpg",img)
grey = cv.CreateImage(cv.GetSize(img), 8,
1) ##creamos una imagen en blanco
bn = cv.CreateImage(cv.GetSize(img), 8, 1)
##creamos imagen en blanco
cv.CvtColor(
img, grey, cv.CV_BGR2GRAY
) ###pasamos la imagen a escala de grises y la guardamos en la imagen ne blanco
#cv.SaveImage("gris.jpg",grey)
cv.ConvertImage(img, bn, 0)
##convertimos la imagen a blancos
threshold = 40 ##umbral 1 para binarizacion
colour = 255 ## umbral 2 para binarizacion
cv.Threshold(grey, grey, threshold, colour,
cv.CV_THRESH_BINARY) ##aplicamos binarizacion
cv.Canny(
grey, bn, 1, 1, 3
) ##preparamos para obtener contornos, esto nos muestra la imagen con los contornos
#cv.SaveImage("cont.jpg",bn)
cv.SaveImage("grey.jpg", grey) ##guardamos la imagen
cambio("grey.jpg") ##invertimos la imagen y discretisamos
imgg = cv.LoadImage(
'ngrey.jpg',
cv.CV_LOAD_IMAGE_GRAYSCALE) ##cargamos nuevamente la imagen
storage = cv.CreateMemStorage(
0) ##para guardar los puntos y no saturar la memoria
contours = cv.FindContours(
imgg, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE,
(0, 0)) ##obtener los puntos de los contornos
puntos = [
] ##para guardar los diferente centros de los objetos y verificarlas posteriormente
while contours: ##leemos los contornos
nx, ny = contours[
0] ##para verificar donde se encuentra los centros de la figura u bojeto
mx, my = contours[0] ##
ancho, altura = cv.GetSize(img) ##obtenemos el tama de la imagen
for i in range(len(contours)): ##verificamos las esquinas
xx, yy = contours[i]
if xx > mx:
mx = xx
if xx < nx:
nx = xx
if yy > my:
my = yy
if yy < ny:
ny = yy
a, b, c, d = random.randint(0, 255), random.randint(
0,
255), random.randint(0,
255), random.randint(0,
255) ##para el color
if len(contours
) >= 50: ##si son mas de 50 puntos es tomada como figura
cv.Rectangle(img, (nx, ny), (mx, my), cv.RGB(0, 255, 0), 1, 8,
0) ##pintamos el rectangulo con las esquinas
#are = abs(mx-nx)*abs(my-ny)
puntos.append((abs(mx + nx) / 2,
abs(my + ny) / 2)) ##agregamos los centros
#are = abs(mx-nx)*abs(my-ny)
contours = contours.h_next(
) #pasamos con los siguientes puntos unidos
nuevo = de(
puntos, anch, alt
) ##verificamos los objetos y obtenemos los centros de los mismos
for i in range(len(nuevo)): ## pintamos la direccin de los mismos
x, y, z = nuevo[i]
cv.PutText(img, "" + z + "", (x, y), font, 255)
tiempof = time.time() ##verificar rendimiento
cv.ShowImage('img', img)
#cv.SaveImage("final.jpg",img)
#tiempoa = tiempof - tiempoi
#proses += 1
#sumaa = sumaa + tiempoa
#print float(sumaa)/float(proses)
#f.write(""+str(proses)+" "+str(tiempoa)+"\n")
##verificar rendimientp
if k == 'f': ##si se preciona f se sale
break
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_32F, 3)
difference = None
while True:
# Capture frame from webcam
color_image = cv.QueryFrame(self.capture)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)
if not difference:
# Initialize
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
else:
cv.RunningAvg(color_image, moving_average, 0.020, None)
# Convert the scale of the moving average.
cv.ConvertScale(moving_average, temp, 1.0, 0.0)
# Minus the current frame from the moving average.
cv.AbsDiff(color_image, temp, difference)
# Convert the image to grayscale.
cv.hsv
cv.cvtColor(color_image, cv.hsv, CV_BGR2HSV)
inRange(hsv, Scalar(0, 58, 89), Scalar(25, 173, 229), cv.bw)
# Dilate and erode to get object blobs
# cv.Dilate(grey_image, grey_image, None, 18)
# cv.Erode(grey_image, grey_image, None, 10)
# Calculate movements
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
points = []
while contour:
# Draw rectangles
bound_rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2],
bound_rect[1] + bound_rect[3])
points.append(pt1)
points.append(pt2)
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255, 0, 0), 1)
num_points = len(points)
if num_points:
# Draw bullseye in midpoint of all movements
x = y = 0
for point in points:
x += point[0]
y += point[1]
x /= num_points
y /= num_points
center_point = (x, y)
cv.Circle(color_image, center_point, 40,
cv.CV_RGB(255, 255, 255), 1)
cv.Circle(color_image, center_point, 30,
cv.CV_RGB(255, 100, 0), 1)
cv.Circle(color_image, center_point, 20,
cv.CV_RGB(255, 255, 255), 1)
cv.Circle(color_image, center_point, 10,
cv.CV_RGB(255, 100, 0), 5)
# Display frame to user
cv.ShowImage("Target", color_image)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
#Get component colors
imgyellow = cv.CreateImage(cv.GetSize(imhsv), 8, 1)
imgblue = cv.CreateImage(cv.GetSize(imhsv), 8, 1)
imgthreshold = cv.CreateImage(cv.GetSize(imhsv), 8, 1)
cv.InRangeS(imghsv, cv.Scalar(20, 100, 100), cv.Scalar(30, 255, 255),
imgyellow) # Select a range of yellow color
cv.InRangeS(imghsv, cv.Scalar(100, 100, 100), cv.Scalar(120, 255, 255),
imgblue) # Select a range of blue color
cv.Add(imgyellow, imgblue, imgthreshold)
return imgthreshold
capture = cv.CaptureFromCAM(0)
frame = cv.QueryFrame(capture)
frame_size = cv.GetSize(frame)
test = cv.CreateImage(cv.GetSize(frame), 8, 3)
img2 = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.NamedWindow("Real", 0)
cv.NamedWindow("Threshold", 0)
cv.NamedWindow("final", 0)
# Create two lists to store co-ordinates of blobs
blue = []
yellow = []
red = []
green = []
orange = []
while (1):
def run(self):
"""
Handles the actual video playback
"""
# Log the onset time of the item
self.set_item_onset()
t = pygame.time.get_ticks()
start_t = t
# Loop until a key is pressed
go = True
while go:
# Get the frame
self.src = cv.QueryFrame(self.video)
# Check for the end of the video
if self.src == None:
break
# Resize if requested and convert the resulting image to
# RGB format, which is compatible with PyGame
if self._fullscreen:
cv.Resize(self.src, self.src_tmp)
cv.CvtColor(self.src_tmp, self.src_rgb, cv.CV_BGR2RGB)
else:
cv.CvtColor(self.src, self.src_rgb, cv.CV_BGR2RGB)
# Convert the image to PyGame format
pg_img = pygame.image.frombuffer(self.src_rgb.tostring(),
cv.GetSize(self.src_rgb), "RGB")
# Show the video frame!
self.experiment.surface.blit(pg_img, (self._x, self._y))
pygame.display.flip()
# Pause before jumping to the next frame
pygame.time.wait(self.frame_dur - pygame.time.get_ticks() + t)
t = pygame.time.get_ticks()
if type(self.duration) == int:
# Wait for a specified duration
if t - start_t >= self.duration:
go = False
# Catch escape presses
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == pygame.K_ESCAPE:
raise exceptions.runtime_error(
"The escape key was pressed.")
if self.duration == "keypress":
go = False
if event.type == MOUSEBUTTONDOWN and self.duration == "mouseclick":
go = False
# Release the camera
# Note: This function appears to be missing. Perhaps it's ok
# and Python will release it automatically?
# cv.ReleaseCapture(self.video)
# Report success
return True
def get_cv_image(self):
return cv.QueryFrame(self.__capture)
def handle_frame(self):
frame = cv.QueryFrame(self.capture)
frame_array = numpy.asarray(frame[:, :])
frame_array = self.rotate(frame_array)
self.buffer_frame(frame_array)
mas = cv.LoadImage("NEED_ME3.jpg")
rora = cv.LoadImage("Q2.png")
q = 0
points = [int] * 11
capo = cv.CaptureFromFile("bobo.mpeg")
red = cv.CreateImage((1200, 900), 8, 1)
jingo = 0
x = 0
y = 0
R = [None] * 11
G = [None] * 11
B = [None] * 11
alpha = [None] * 11
sump = 0
while (1):
telly = cv.QueryFrame(capo)
#bingo=cv.CloneImage(telly)
#red=cv.CreateImage(cv.GetSize(bingo),8,1)
#bingo=cv.CloneImage(telly)
cv.Zero(red)
if (q == 9):
break
cv.Split(telly, None, None, red, None)
(_, _, _, jingo) = cv.MinMaxLoc(red, None)
(x, y) = jingo
points[q] = cv.Get2D(mas, y, x)
(B[q], G[q], R[q], alpha[q]) = points[q]
print "Points scored in shot"
print q + 1
print "is:"
print R[q]
cv.NamedWindow("Snapshot")
cv.NamedWindow("Raw Video")
image_points = cv.CreateMat(num_boards * board_total, 2, cv.CV_32FC1)
object_points = cv.CreateMat(num_boards * board_total, 3, cv.CV_32FC1)
point_counts = cv.CreateMat(num_boards, 1, cv.CV_32SC1)
intrinsic = cv.CreateMat(3, 3, cv.CV_32FC1)
distortion = cv.CreateMat(4, 1, cv.CV_32FC1)
corners = None
corner_count = 0
successes = 0
step = 0
frame = 0
image = cv.QueryFrame(cam)
gray_image = cv.CreateImage(cv.GetSize(image), 8, 1)
while (successes < num_boards):
frame += 1
if (frame % num_framestep == 0):
corners = cv.FindChessboardCorners(
image, board_size,
cv.CV_CALIB_CB_ADAPTIVE_THRESH | cv.CV_CALIB_CB_FILTER_QUADS)
corners = corners[1]
cv.CvtColor(image, gray_image, cv.CV_BGR2GRAY)
cv.FindCornerSubPix(
gray_image, corners, (11, 11), (0, 0),
(cv.CV_TERMCRIT_EPS + cv.CV_TERMCRIT_ITER, 30, 0.1))
if (len(corners) > 1):
cv.DrawChessboardCorners(image, board_size, corners, 1)
capture = cv.CaptureFromCAM(MY_CAMERA)
if not capture:
print "I am blinded, check Camera Config"
exit(1)
cv.NamedWindow('camera', cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow('threshed', cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow('cropped', cv.CV_WINDOW_AUTOSIZE)
# initialize position array
positions_x, positions_y = [0]*SMOOTHNESS, [0]*SMOOTHNESS
while 1:
image = cv.QueryFrame(capture)
# image = cv.LoadImage("2012_automata.jpg")
if not image:
break
# Blurring image
image_smoothed = cv.CloneImage(image)
cv.Smooth(image, image_smoothed, cv.CV_GAUSSIAN, 1)
image_threshed = thresholded_image(image_smoothed)
cv.Dilate(image_threshed, image_threshed, None, 3)
cv.Erode(image_threshed, image_threshed, None, 3)
blobContour = None
def main():
os.chdir(sys.argv[1])
try:
os.mkdir(OUTPUT_DIR_NAME)
except OSError:
pass
tree = et.parse("project.xml")
movie = tree.getroot()
file_path = movie.attrib["path"]
if DEBUG:
cv.NamedWindow("win", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("win", 200, 200)
cap = cv.CreateFileCapture(file_path)
skip_frames(cap, movie)
pixel_count = None
prev_img = None
global_frame_counter = 0
file_counter = 0
w = None
h = None
output_img = cv.CreateImage((WIDTH, MAX_FRAMES), cv.IPL_DEPTH_8U, 3)
f = open("shots.txt", "r")
lines = [line for line in f if line] # (start_frame, end_frame, duration)
f.close()
f_frm = open("motion.txt", "w")
f_avg = open("motion_shot-avg.txt", "w")
motion = []
t = time.time()
for nr, line in enumerate(lines):
print(nr + 1), "/", len(lines)
duration = int(line.split("\t")[2])
for frame_counter in range(duration):
img = cv.QueryFrame(cap)
if not img:
print "error?"
print nr, frame_counter
#break
return
if DEBUG:
cv.ShowImage("win", img)
global_frame_counter += 1
if nr == 0 and frame_counter == 0: # first shot, first frame
w = img.width
h = img.height
pixel_count = float(img.width * img.height)
prev_img = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3)
cv.Zero(prev_img)
diff = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3)
cv.AbsDiff(img, prev_img, diff)
cv.Threshold(diff, diff, 10, 255, cv.CV_THRESH_BINARY)
d_color = 0
for i in range(1, 4):
cv.SetImageCOI(diff, i)
d_color += cv.CountNonZero(diff) / pixel_count
d_color = d_color / 3 # 0..1
#print "%.1f" % (d_color*100), "%"
motion.append(d_color)
cv.Copy(img, prev_img)
# WRITE TEXT FILE
f_frm.write("%f\n" % (d_color))
if frame_counter == duration - 1: # last frame of current shot
motion_value = sum(motion) / len(motion)
print "average motion:", motion_value
f_avg.write("%f\t%d\n" % (motion_value, duration))
motion = []
# WRITE IMAGE
if frame_counter == 0: # ignore each first frame -- the diff after a hard cut is meaningless
global_frame_counter -= 1
continue
else:
for i in range(WIDTH):
value = d_color * 255
cv.Set2D(output_img,
(global_frame_counter - 1) % MAX_FRAMES, i,
cv.RGB(value, value, value))
if global_frame_counter % MAX_FRAMES == 0:
cv.SaveImage(
os.path.join(OUTPUT_DIR_NAME,
"motion_%03d.png" % (file_counter)),
output_img)
file_counter += 1
if DEBUG:
if cv.WaitKey(1) == 27:
break
if global_frame_counter % MAX_FRAMES != 0:
#cv.SetImageROI(output_img, (0, 0, WIDTH-1, (global_frame_counter % MAX_FRAMES)-1))
cv.SetImageROI(output_img, (0, 0, WIDTH - 1,
(global_frame_counter - 1) % MAX_FRAMES))
cv.SaveImage(
os.path.join(OUTPUT_DIR_NAME, "motion_%03d.png" % (file_counter)),
output_img)
f_frm.close()
f_avg.close()
if DEBUG:
cv.DestroyWindow("win")
print "%.2f min" % ((time.time() - t) / 60)
#raw_input("- done -")
return
def main():
BLACK_AND_WHITE = False
THRESHOLD = 0.48
BW_THRESHOLD = 0.4
os.chdir(sys.argv[1])
try:
os.mkdir(OUTPUT_DIR_NAME)
except:
pass
if len(sys.argv) > 2:
if sys.argv[2] == "bw":
BLACK_AND_WHITE = True
THRESHOLD = BW_THRESHOLD
print "##########"
print " B/W MODE"
print "##########"
tree = et.parse("project.xml")
movie = tree.getroot()
file_path = movie.attrib["path"]
cap = cv.CreateFileCapture(file_path)
if DEBUG:
cv.NamedWindow("win", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("win", 200, 200)
hist = None
prev_hist = None
prev_img = None
pixel_count = None
frame_counter = 0
last_frame_black = False
black_frame_start = -1
t = time.time()
while 1:
img_orig = cv.QueryFrame(cap)
if not img_orig: # eof
cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (frame_counter - 1),
prev_img)
"""movie.set("frames", str(frame_counter))
tree.write("project.xml")"""
break
img = cv.CreateImage(
(int(img_orig.width / 4), int(img_orig.height / 4)),
cv.IPL_DEPTH_8U, 3)
cv.Resize(img_orig, img, cv.CV_INTER_AREA)
if frame_counter == 0: # erster frame
cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (0), img)
pixel_count = img.width * img.height
prev_img = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3)
cv.Zero(prev_img)
if DEBUG and frame_counter % 2 == 1:
cv.ShowImage("win", img)
img_hsv = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(img, img_hsv, cv.CV_BGR2HSV)
# #####################
# METHOD #1: find the number of pixels that have (significantly) changed since the last frame
diff = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3)
cv.AbsDiff(img_hsv, prev_img, diff)
cv.Threshold(diff, diff, 10, 255, cv.CV_THRESH_BINARY)
d_color = 0
for i in range(1, 4):
cv.SetImageCOI(diff, i)
d_color += float(cv.CountNonZero(diff)) / float(pixel_count)
if not BLACK_AND_WHITE:
d_color = float(d_color / 3.0) # 0..1
# #####################
# METHOD #2: calculate the amount of change in the histograms
h_plane = cv.CreateMat(img.height, img.width, cv.CV_8UC1)
s_plane = cv.CreateMat(img.height, img.width, cv.CV_8UC1)
v_plane = cv.CreateMat(img.height, img.width, cv.CV_8UC1)
cv.Split(img_hsv, h_plane, s_plane, v_plane, None)
planes = [h_plane, s_plane, v_plane]
hist_size = [50, 50, 50]
hist_range = [[0, 360], [0, 255], [0, 255]]
if not hist:
hist = cv.CreateHist(hist_size, cv.CV_HIST_ARRAY, hist_range, 1)
cv.CalcHist([cv.GetImage(i) for i in planes], hist)
cv.NormalizeHist(hist, 1.0)
if not prev_hist:
prev_hist = cv.CreateHist(hist_size, cv.CV_HIST_ARRAY, hist_range,
1)
# wieso gibt es kein cv.CopyHist()?!
cv.CalcHist([cv.GetImage(i) for i in planes], prev_hist)
cv.NormalizeHist(prev_hist, 1.0)
continue
d_hist = cv.CompareHist(prev_hist, hist, cv.CV_COMP_INTERSECT)
# combine both methods to make a decision
if ((0.4 * d_color + 0.6 * (1 - d_hist))) >= THRESHOLD:
if DEBUG:
if frame_counter % 2 == 0:
cv.ShowImage("win", img)
winsound.PlaySound(soundfile,
winsound.SND_FILENAME | winsound.SND_ASYNC)
print "%.3f" % ((0.4 * d_color + 0.6 * (1 - d_hist))), "%.3f" % (
d_color), "%.3f" % (1 - d_hist), frame_counter
if DEBUG and DEBUG_INTERACTIVE:
if win32api.MessageBox(0, "cut?", "",
win32con.MB_YESNO) == 6: #yes
cv.SaveImage(
OUTPUT_DIR_NAME + "\\%06d.png" % (frame_counter), img)
else:
cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (frame_counter),
img)
cv.CalcHist([cv.GetImage(i) for i in planes], prev_hist)
cv.NormalizeHist(prev_hist, 1.0)
# #####################
# METHOD #3: detect series of (almost) black frames as an indicator for "fade to black"
average = cv.Avg(v_plane)[0]
if average <= 0.6:
if not last_frame_black: # possible the start
print "start", frame_counter
black_frame_start = frame_counter
last_frame_black = True
else:
if last_frame_black: # end of a series of black frames
cut_at = black_frame_start + int(
(frame_counter - black_frame_start) / 2)
print "end", frame_counter, "cut at", cut_at
img_black = cv.CreateImage(
(img_orig.width / 4, img_orig.height / 4), cv.IPL_DEPTH_8U,
3)
cv.Set(img_black, cv.RGB(0, 255, 0))
cv.SaveImage(OUTPUT_DIR_NAME + "\\%06d.png" % (cut_at),
img_black)
last_frame_black = False
cv.Copy(img_hsv, prev_img)
frame_counter += 1
if DEBUG:
if cv.WaitKey(1) == 27:
break
if DEBUG:
cv.DestroyWindow("win")
print "%.2f min" % ((time.time() - t) / 60)
#raw_input("- done -")
return
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
color_image = cv.CreateImage(cv.GetSize(frame), 8, 3)
grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_32F, 3)
first = True
while True:
closest_to_left = cv.GetSize(frame)[0]
closest_to_right = cv.GetSize(frame)[1]
color_image = cv.QueryFrame(self.capture)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)
if first:
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
first = False
else:
cv.RunningAvg(color_image, moving_average, 0.020, None)
# Convert the scale of the moving average.
cv.ConvertScale(moving_average, temp, 1.0, 0.0)
# Minus the current frame from the moving average.
cv.AbsDiff(color_image, temp, difference)
# Convert the image to grayscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
# Convert the image to black and white.
cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY)
# Dilate and erode to get people blobs
cv.Dilate(grey_image, grey_image, None, 18)
cv.Erode(grey_image, grey_image, None, 10)
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
points = []
while contour:
bound_rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2],
bound_rect[1] + bound_rect[3])
points.append(pt1)
points.append(pt2)
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255, 0, 0), 1)
if len(points):
center_point = reduce(
lambda a, b: ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2),
points)
cv.Circle(color_image, center_point, 40,
cv.CV_RGB(255, 255, 255), 1)
# cv.Circle(color_image, center_point, 30, cv.CV_RGB(255, 100, 0), 1)
# cv.Circle(color_image, center_point, 20, cv.CV_RGB(255, 255, 255), 1)
# cv.Circle(color_image, center_point, 10, cv.CV_RGB(255, 100, 0), 1)
print center_point
cv.ShowImage("Target", color_image)
# Listen for ESC key
c = cv.WaitKey(7) % 0x100
if c == 27:
break
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
def main():
import argparse
import logging
import os
import yaml
parser = argparse.ArgumentParser()
parser.add_argument('classifier')
parser.add_argument(
'--postprocess',
action="store_true",
help='Run postprocessing, close blobs and remove noise')
parser.add_argument('videolist',
help='A file listed all the videos to be indexed')
parser.add_argument('cores',
type=int,
help='Number of processes of paralellism')
args = parser.parse_args()
logging.basicConfig(level=logging.WARNING,
format="%(asctime)s - %(message)s")
classifier = zipfile.ZipFile(args.classifier)
global forest0, svmmodels, training_bosts, hist0
forest0, hist0, forest1, hist1, training_bosts, svmmodels, prior = \
load_from_classifier(classifier)
classifier.close()
KEY_FRAME_PERIOD = 2 # in seconds
#processes = args.cores
#pool = Pool(processes = processes)
for processes in [4]:
video_list = open(args.videolist, 'r')
log_file = open('statistics%d.txt' % processes, 'w')
fps = 0
sps = 0
fps_count = 0
for video_file in video_list:
video_file = video_file.strip()
name = os.path.splitext(video_file)[0]
file_path = os.path.join(VIDEO_RESOURCE, video_file)
log_file.write(file_path + "\n")
print file_path
capture = cv.CaptureFromFile(file_path)
frame_rate = cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FPS)
total_frames = cv.GetCaptureProperty(capture,
cv.CV_CAP_PROP_FRAME_COUNT)
log_file.write("frame rate: %.3f, total frames: %d\n" %
(frame_rate, total_frames))
print "frame rate: %.3f, total frames: %d\n" % (frame_rate,
total_frames)
start_time0 = time.time()
key_frame_counter = 0
frame = cv.QueryFrame(capture)
os.makedirs("tmp")
while frame:
cv.SaveImage("tmp/" + name + "%d.png" % key_frame_counter,
frame)
for i in xrange(int(KEY_FRAME_PERIOD * frame_rate)):
frame = cv.QueryFrame(capture)
#calculate_class(image)
#p = Process(target = calculate_class, args=(image, ))
#p.start()
key_frame_counter += 1
del (capture)
start_time = time.time()
ps = []
for group in xrange(processes):
p = Process(target=calculate_class,
args=(
group,
name,
processes,
))
p.start()
ps.append(p)
for p in ps:
p.join()
#pool.map(calculate_class, range(processes))
elapse_time = time.time() - start_time
os.system("rm -rf tmp")
log_file.write("decoding time: %.2f, total time: %.2f, key frames: %d, frame per sec: %.3f\n" \
% (start_time - start_time0, elapse_time, key_frame_counter, key_frame_counter / elapse_time))
fps += key_frame_counter / elapse_time
sps += key_frame_counter / elapse_time * KEY_FRAME_PERIOD
fps_count += 1
time.sleep(10)
video_list.close()
log_file.write("average fps: %.3f\n" % (fps / fps_count))
log_file.write("average sps: %.3f\n" % (sps / fps_count))
#print "total tags: %d" % (sum(tag_number))
log_file.close()
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=4096)
snare = pygame.mixer.Sound("E_SNARE_02.wav")
tom1 = pygame.mixer.Sound("tomtomdrum7.wav")
tom2 = pygame.mixer.Sound("tomtomdrum6.wav")
hihat = pygame.mixer.Sound("hihat22.wav")
synchNoise = pygame.mixer.Sound("cowbell9.wav")
based = pygame.mixer.Sound("01-Based-Is-How-You-Feel-Inside.wav")
over = pygame.mixer.Sound("vegetaover9000.wav")
bonzo = pygame.mixer.Sound("Led-Zeppelin-Coda-Bonzo's-Montreux.wav")
yyz = pygame.mixer.Sound("Rush-yyz.wav")
# opencv stuff
CAMERA_INDEX = 0
capture = cv.CaptureFromCAM(CAMERA_INDEX)
sampleFrame = cv.QueryFrame(capture)
imageSize = cv.GetSize(sampleFrame)
imageSize = 1280, 720
#pygame stuff
screen = pygame.display.set_mode(imageSize, 0)
#camlist = pygame.camera.list_cameras()
#print camlist
#cam = pygame.camera.Camera(camlist[0], imageSize)
#cam.start()
#cam.set_controls(hflip = True, vflip = False)
#snapshot = pygame.surface.Surface(imageSize, 0, screen)
class Stick(object):
def __init__(self, color):
def getImageCapture(videoFlow):
""" Capture the current image of camera/IP camera video flow and save it in current.jpg file """
capture = cv.CaptureFromFile(videoFlow)
frame = cv.QueryFrame(capture)
image = cv.SaveImage("img/current.jpg", frame)
import cv
vidFile = cv.CaptureFromFile('crash-480.mp4')
nFrames = int(cv.GetCaptureProperty(vidFile, cv.CV_CAP_PROP_FRAME_COUNT))
fps = cv.GetCaptureProperty(vidFile, cv.CV_CAP_PROP_FPS)
waitPerFrameInMillisec = int(1 / fps * 1000 / 1)
print 'Num. Frames = ', nFrames
print 'Frame Rate = ', fps, ' frames per sec'
for f in xrange(nFrames):
frameImg = cv.QueryFrame(vidFile)
cv.ShowImage("My Video Window", frameImg)
cv.WaitKey(waitPerFrameInMillisec)
# When playing is done, delete the window
# NOTE: this step is not strictly necessary,
# when the script terminates it will close all windows it owns anyways
cv.DestroyWindow("My Video Window")
# import numpy as np
# import cv2
# cap = cv2.VideoCapture('crash-480.mp4')
# while(cap.isOpened()):
# ret, frame = cap.read()
# gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
def getFrame(self):
return cv.QueryFrame(self.capture)
cv.NamedWindow("hsv_frame", 1)
cv.MoveWindow('webcam', 450, 0)
cam = cv.CaptureFromCAM(1)
pos_x = 0
pos_y = 0
last_x = 0
last_y = 0
# my creation to find good ball position
count_of_measurements = 0
not_found_two_circles = 0
dead_end = 0
direction = 1
while True:
frame = cv.QueryFrame(cam)
#blur the source image to reduce color noise
#cv.Smooth(frame, frame, cv.CV_BLUR, 3);
#convert the image to hsv(Hue, Saturation, Value) so its
#easier to determine the color to track(hue)
timesample = time.clock()
time.sleep(1)
print timesample
hsv_frame = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.CvtColor(frame, hsv_frame, cv.CV_BGR2HSV)
#limit all pixels that don't match our criteria, in this case we are
#looking for purple but if you want you can adjust the first value in
#both turples which is the hue range(120,140). OpenCV uses 0-180 as
def main():
# Initialize capturing live feed from the camera
capture = 0
capture = cv.CaptureFromCAM(0)
# Couldn't get a device? Throw an error and quit
if (not capture):
print "Could not initialize capturing...\n"
return -1
# The two windows we'll be using
cv.NamedWindow("video")
cv.NamedWindow("thresh")
# This image holds the "scribble" data...
# the tracked positions of the ball
imgScribble = 0
# a flag which indicates a valid mouse click
clicked = 0
# to hold the previous co-ordinate values.
prevXred = 0
prevYred = 0
prevXyellow = 0
prevYyellow = 0
#initialising fake motioning
import ctypes
c = ctypes.CDLL("libhelper.so.1")
libc = ctypes.CDLL("libc.so.6")
c.helper_init()
Xred = -1
Yred = -1
Xyellow = -1
Yyellow = -1
# An infinite loop
while (True):
#----------------------------------------------------------------------------------------
# Will hold a frame captured from the camera
frame = 0
frame = cv.QueryFrame(capture)
# If we couldn't grab a frame... quit
if (not frame):
break
# If this is the first frame, we need to initialize it
if (imgScribble == 0):
imgScribble = cv.CreateImage(cv.GetSize(frame), 8, 3)
# representative co-ordinates of RED & YELLOW finger-tips, initialized.
dx = 0
dy = 0
#----------------------------------------------------------------------------------------
# Holds the RED thresholded image (red = white, rest = black)
imgRedThresh = GetRedThresholded(frame)
moments = 0
# Calculate the moments to estimate the position of RED finger-tip
moments = cv.Moments(imgRedThresh)
# The actual moment values
moment01 = cv.GetSpatialMoment(moments, 0, 1)
moment10 = cv.GetSpatialMoment(moments, 1, 0)
area = cv.GetSpatialMoment(moments, 0, 0)
if (area == 0):
continue
prevXred = Xred
prevYred = Yred
if area:
Xred = moment10 / area
Yred = moment01 / area
# Print it out for debugging purposes
#print "position "+ str(Xred)+' '+ str(Yred)+'\n'
#----------------------------------------------------------------------------------------
# Holds the YELLOW thresholded image (yellow = white, rest = black)
imgYellowThresh = GetYellowThresholded(frame)
moments = 0
# Calculate the moments to estimate the position of YELLOW finger-tip
moments = cv.Moments(imgYellowThresh)
# The actual moment values
moment01 = cv.GetSpatialMoment(moments, 0, 1)
moment10 = cv.GetSpatialMoment(moments, 1, 0)
area = cv.GetSpatialMoment(moments, 0, 0)
if (area == 0): continue
prevXyellow = Xyellow
prevYyellow = Yyellow
Xyellow = moment10 / area
Yyellow = moment01 / area
#dx = (Xyellow - prevXyellow)
#dy = (Yyellow - prevYyellow)
#x=1390-Xyellow*2.125
#y=Yyellow*1.575
Xt = 1390 - (abs(Xred + Xyellow) * 1.125)
Yt = (abs(Yred + Yyellow) * 0.7875)
libc.usleep(150)
c.helper_mov_absxy(int(Xt), int(Yt))
#c.helper_mov_relxy(int(dx),int(dy))
# Print it out for debugging purposes
#print "position "+ str(Xyellow)+' '+ str(Yyellow)
#----------------------------------------------------------------------------------------
# find distance between RED & YELLOW finger-tips
# for faster calculation, individually Xdiff, Ydiff
# considered, instead of sqrt((x2-x1)^2 + (y2-y2)^2)
Xdiff = abs(Xred - Xyellow)
Ydiff = abs(Yred - Yyellow)
# determine the 'clicked' state, using approximation to circle method.
d = 50
#if((21*Xdiff + 50*Ydiff <= 50*d) and (50*Xdiff + 21*Ydiff <= 50*d)):
if (Xdiff * Xdiff + Ydiff * Ydiff < d * d):
#if(Xdiff < 25 and Ydiff < 25):
if (not clicked):
clicked = 1
print "clicked"
else:
if (clicked):
clicked = 0
if clicked:
c.helper_press()
c.helper_release()
# convey prevXred,prevYred,Xred,Yred,clicked for generation of appropriate mouse event.
#libc.sleep(2)
#c.helper_mov_relxy()
#c.helper_mov_relxy()
#libc.sleep(2)
#if clicked
#c.helper_press()
#c.helper_release()
#----------------------------------------------------------------------------------------
# # We want to draw a line only if its a valid position
# if(lastX>0 and lastY>0 and posX>0 and posY>0):
#
# # Draw a yellow line from the previous point to the current point
# cv.Line(imgScribble, cv.Point(posX, posY), cv.Point(lastX, lastY), cv.Scalar(0,255,255), 5)
#
#
# # Add the scribbling image and the frame... and we get a combination of the two
# cv.Add(frame, imgScribble, frame)
#cv.ShowImage("thresh", imgYellowThresh)
#cv.ShowImage("video", frame)
#----------------------------------------------------------------------------------------
# Wait for a keypress
cin = cv.WaitKey(10)
if not (cin == -1):
# If pressed, break out of the loop
break
# Release the thresholded image... we need no memory leaks.. please
#----------------------------------------------------------------------------------------
# We're done using the camera. Other applications can now use it
return 0
f.write("v " + str(v) + chr(10))
f.write("e " + str(e) + chr(10))
f.write("s " + str(s) + chr(10))
f.close()
v = 90
h = 90
e = 90
s = 90
STEP = 6
ENSTEP = 30
SSTEP = 1
cv.NamedWindow("CamView")
while True:
im = cv.QueryFrame(camera)
cv.ShowImage("CamView", im)
# im = cv.CreateMat(im)
c = cv.WaitKey(33)
if c == 27:
break
if c == ord('a'):
h += STEP
move()
if c == ord('d'):
h -= STEP
move()
if c == ord('w'):
v -= STEP
move()
if c == ord('s'):
options.min_obj_size)
# Now open the video for input
inStream = cv.CaptureFromFile(inputFile)
fps = cv.GetCaptureProperty(inStream, cv.CV_CAP_PROP_FPS)
# Next open the file for output
outStream = cv.CreateVideoWriter(
outputFile, cv.CV_FOURCC('P', 'I', 'M', '1'), fps,
(cv.GetCaptureProperty(inStream, cv.CV_CAP_PROP_FRAME_WIDTH),
cv.GetCaptureProperty(inStream, cv.CV_CAP_PROP_FRAME_HEIGHT)),
1) # is_color
curTime = 0
cvFrame = cv.QueryFrame(inStream)
while (cvFrame is not None):
frame = np.asarray(cv.GetMat(cvFrame)).astype(np.float64) / 255.0
motionExtractor.AddImage(frame, curTime)
if (motionExtractor.RetreiveObjects() is not None
and (curTime - motionExtractor.time() < 5.0 / fps)):
# Create a new frame showing the objects in red
outFrame = frame
outFrame[:,:,2] = outFrame[:,:,2]*0.6 + 0.4 * \
motionExtractor.RetreiveObjects().ToBinaryImageMask().astype(np.float64)
outFrame *= 255.0
cv.WriteFrame(outStream,
cv.GetImage(cv.fromarray(frame.astype(np.uint8()))))
import cv
import sys
if (len(sys.argv) > 1):
capture = cv.CaptureFromCAM(1)
img = cv.QueryFrame(capture)
cv.SaveImage(sys.argv[1], img)
def charger_modules(self):
"""Pour recharger la liste des modules si on a modifié le fichier
modules.js qui contient leur description sous format json"""
self.liste_modules.clear()
self.modules = json.loads(open("modules.js").read())
for module in self.modules:
self.liste_modules.addItem(module["nom"])
if __name__ == "__main__":
# Ce code ne s'exécute que si on exécute directement le module (pas en cas d'import)
webcam = cv.CaptureFromCAM(0)
print "Appuyez sur S pour prendre la photo"
while True:
image = cv.GetSubRect(cv.QueryFrame(webcam), (281, 191, 80, 100))
cv.ShowImage("webcam", image)
key = cv.WaitKey(1)
# La touche pour prendre la photo est la touche s
# Sous le linux utilisé pour tester, la valeur correspondante
# était 1048691.
# Sous Windows, la valeur était ord("s"), soit 115.
# Sous certaines machine, cette valeur peut être "s".
if key in [1048691, ord("s"), "s"]:
cv.SaveImage("visage.bmp", image)
break
# thira = THIbault RAlph
# sys.argv = les arguments de la commande exécutée,
# par exemple ["interface.py", "-o3", "visage.bmp"]
# Inutile pour nous mais demandé dans le constructeur de QApplication
thira = QApplication(sys.argv)
