def showThresholdedImage(src,
dst,
Threshold,
show=True,
method=cv.CV_THRESH_BINARY):
n = src.nChannels
m = Threshold
if (n > 1):
src2 = cv.CreateImage((src.width, src.height), src.depth, 1)
cv.ConvertImage(src, src2, cv.CV_BGR2GRAY)
else:
src2 = src
cv.Threshold(src2, dst, m, 255, method)
i = 0
if (show):
cv.NamedWindow("Original", 1)
cv.NamedWindow("Thresholded", 1)
while (i < 6000):
cv.ShowImage("Original", src2)
cv.ShowImage("Thresholded", dst)
cv.WaitKey(300)
i = i + 1
return
def fetch_image(self, cam):
cam.simulate()
if not cam.pixels:
return None, None
cv_img = cv.CreateImageHeader((cam.width, cam.height), cv.IPL_DEPTH_8U,
3)
cv.SetData(cv_img, cam.pixels, cam.width * 3)
cv.ConvertImage(cv_img, cv_img, cv.CV_CVTIMG_FLIP)
im = self.bridge.cv_to_imgmsg(cv_img, "rgb8")
caminfo = CameraInfo()
caminfo.header = im.header
caminfo.height = cam.height
caminfo.width = cam.width
caminfo.D = 5 * [0.]
caminfo.K = sum([list(r) for r in cam.K], [])
caminfo.P = sum([list(r) for r in cam.P], [])
caminfo.R = sum([list(r) for r in cam.R], [])
return im, caminfo
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
cv.SetCaptureProperty(c, cv.CV_CAP_PROP_POS_FRAMES, current_frame)
frame = cv.QueryFrame(
c) #primer frame obtenido para el calculo del flujo optico
if frame == None:
break #si no se obtuvo ningun frame, se termino el archivo de video
cv.Resize(
frame,
thumbnail) #si se obtuvo un frame, se cambia el tamano al deseado
first_frame = cv.CloneImage(thumbnail)
output = cv.CloneImage(
thumbnail) #se crea una copia del frame para dibujar sobre el
#se pasa un filtro gaussiano para reducir ruido
cv.Smooth(thumbnail, thumbnail, cv.CV_GAUSSIAN, GAUSSIAN_BLUR_FACTOR,
GAUSSIAN_BLUR_FACTOR)
#se voltean las imagenes para corregir un error de opencv
cv.ConvertImage(thumbnail, frame1_1C, cv.CV_CVTIMG_FLIP)
#cv.ConvertImage(thumbnail, output, cv.CV_CVTIMG_FLIP)
frame = cv.QueryFrame(
c) #segundo frame obtenido para el calculo del flujo optico
if frame == None: break
cv.Resize(frame, thumbnail)
second_frame = cv.CloneImage(thumbnail)
motion = get_motion_mask(first_frame, second_frame)
cv.Smooth(thumbnail, thumbnail, cv.CV_GAUSSIAN, GAUSSIAN_BLUR_FACTOR,
GAUSSIAN_BLUR_FACTOR)
cv.ConvertImage(thumbnail, frame2_1C, cv.CV_CVTIMG_FLIP)
t = Thread(target=motion_bbox, args=(
output,
motion,
))
t.run()
arr2[i,j,0]=arr1[0]
arr2[i,j,1]=arr1[1]
arr2[i,j,2]=arr1[2]
#print pix
src=cv.CreateImage(cv.GetSize(img),8,3)
grayImg=cv.CreateImage(cv.GetSize(img),8,1)
grayImg1=cv.CreateImage(cv.GetSize(img),8,1)
j=0
i=0
for j in range(32):
for i in range(32):
pix1=arr2[i,j]
cv.Set2D(src,j,i,pix1)
cv.ConvertImage(img,grayImg,cv.CV_BGR2GRAY)
i=0
j=0
for j in range(32):
for i in range(32):
pix2=cv.Get2D(grayImg,j,i)
temp=pix2[0]
grayArr[i+j*32]=temp
#print temp
i=0
j=0
for j in range(32):
for i in range(32):
temp=grayArr[i+j*32]
cv.Set2D(grayImg1,j,i,cv.Scalar(temp,0,0))