def test():
#start = time.time()
#
src1 = cv.LoadImage("target_all_nl1.png", 0)
src2 = cv.LoadImage("target_all.png", 0)
# crop area
pt1 = (100, 100)
pt2 = (200, 200)
#get img size and compare
# convert cvMat to IplImage
crop1 = cv.GetImage(src1[pt1[1]:pt2[1], pt1[0]:pt2[0]])
crop2 = cv.GetImage(src2[pt1[1]:pt2[1], pt1[0]:pt2[0]])
# save image
cv.SaveImage("c1.jpg", crop1)
cv.SaveImage("c2.jpg", crop2)
print type(crop2)
print type(src2)
#cv2.GetMat
# compute
hist1 = compute_histogram(crop1)
hist2 = compute_histogram(crop2)
# compare
sc = cv.CompareHist(hist1, hist2, cv.CV_COMP_CHISQR)
print sc
def save_img(img_type, img_o, img_f):
subdir = "data/"
global count
cv.SaveImage(subdir + "o_" + img_type + "_" + str(count) + ".jpg", img_o)
cv.SaveImage(subdir + "f_" + img_type + "_" + str(count) + ".jpg", img_f)
print "saved " + img_type + ": " + str(count)
count = count + 1
def detect_and_draw(img, cascade, c):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
img.width / image_scale), cv.Round(img.height / image_scale)), 8, 1)
# convert color input image to grayscale
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
face_flag = False
if (cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
print "detection time = %gms" % (t / (cv.GetTickFrequency() * 1000.))
if faces:
face_flag = True
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
# ある程度顔が検出されたら
if c > 4:
# 画像の保存
global counter
counter = -1
d = datetime.today()
datestr = d.strftime('%Y-%m-%d_%H-%M-%S')
outputname = '/home/pi/fd/fd_' + datestr + '.jpg'
cv.SaveImage(outputname, img)
print 'Face Detect'
# 読み込みと切り取り
fimg = cv.LoadImage(outputname)
fimg_trim = fimg[pt1[1]:pt2[1], pt1[0]:pt2[0]]
outputname2 = '/home/pi/fd/face_' + datestr + '.jpg'
cv.SaveImage(outputname2, fimg_trim)
print 'Face Image Save'
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
cv.ShowImage("result", img)
return face_flag
def imgResizer(crop_img_string, width, height,crop_color_img):
image1 = cv.LoadImage(crop_img_string,cv.CV_LOAD_IMAGE_GRAYSCALE)
dst1 = cv.CreateImage((width,height), 8, 1)
cv.Resize(image1,dst1,interpolation=cv.CV_INTER_LINEAR)
cv.SaveImage('Z_Resized_image.png', dst1)
# dst0 = cv.CreateImage((width,height), 8, 3)
# dst0 = cv2.resize(crop_color_img,(width,height))
image2 = cv.LoadImage('Z_Cropped_color_image.png')
dst2 = cv.CreateImage((width,height), 8, 3)
cv.Resize(image2,dst2,interpolation=cv.CV_INTER_LINEAR)
cv.SaveImage('Z_Resized_color_image.png', dst2)
return dst1,dst2
def InterPolation_methods():
dst = cv.CreateImage((2 * src_image.width, 2 * src_image.height), 8, 3)
cv.Resize(src_image, dst, cv.CV_INTER_NN)
display(dst, "Nearest Neighbor Interpolation")
cv.SaveImage("NN.jpg", dst)
cv.Resize(src_image, dst, cv.CV_INTER_LINEAR)
display(dst, "Linear Interpolation")
cv.SaveImage("LI.jpg", dst)
cv.Resize(src_image, dst, cv.CV_INTER_AREA)
display(dst, "Area Interpolation")
cv.SaveImage("AI.jpg", dst)
cv.Resize(src_image, dst, cv.CV_INTER_CUBIC)
display(dst, "Cubic Interpolation")
cv.SaveImage("CI.jpg", dst)
cv.WaitKey(0)
def create_imagefile(filename,
latlon,
ground_width,
path_obj,
mission_obj,
width=600,
height=600):
'''create path and mission as an image file'''
mt = mp_tile.MPTile(service=opts.service)
map_img = mt.area_to_image(latlon[0], latlon[1], width, height,
ground_width)
while mt.tiles_pending() > 0:
print("Waiting on %u tiles" % mt.tiles_pending())
time.sleep(1)
map_img = mt.area_to_image(latlon[0], latlon[1], width, height,
ground_width)
# a function to convert from (lat,lon) to (px,py) on the map
pixmapper = functools.partial(pixel_coords,
ground_width=ground_width,
mt=mt,
topleft=latlon,
width=width)
path_obj.draw(map_img, pixmapper, None)
if mission_obj is not None:
mission_obj.draw(map_img, pixmapper, None)
cv.CvtColor(map_img, map_img, cv.CV_BGR2RGB)
cv.SaveImage(filename, map_img)
def recog(md, img):
global face_rect
src_path = './regist_pic/' + str(md)
while True:
rects = face_rect
if rects:
#img保存用来验证的人脸
if rects[0][2] < rects[0][3]:
cv.SetImageROI(img, (rects[0][0] + 10, rects[0][1] + 10,
rects[0][2] - 100, rects[0][2] - 100))
else:
cv.SetImageROI(img, (rects[0][0] + 10, rects[0][1] + 10,
rects[0][3] - 100, rects[0][3] - 100))
#将img暂时保存起来
dst = cv.CreateImage((224, 224), 8, 3)
cv.Resize(img, dst, cv.CV_INTER_LINEAR)
cv.SaveImage('./temp.bmp', dst)
#取出5张注册的人脸,分别与带验证的人脸进行匹配,可以得到五个相似度,保存到scores中
scores = []
for i in range(5):
res = compar_pic('./temp.bmp',
src_path + '/' + str(i) + '.bmp')
scores.append(res)
print res
#求scores的均值
result = avg(scores)
print 'avg is :', avg(scores)
return result
def crack(self,
dilateiter=4,
erodeiter=4,
threshold=200,
size=(155, 55),
whitelist_chars=string.ascii_lowercase): #Take all parameters
''':param whitelist_char: the characters to recognize'''
resized = resizeImage(self.image,
(self.image.width * 6, self.image.height * 6))
dilateImage(resized, dilateiter)
erodeImage(resized, erodeiter)
thresholdImage(resized, threshold, cv.CV_THRESH_BINARY)
resized = resizeImage(resized, size)
#Call the tesseract engine
from tempfile import NamedTemporaryFile
temp_img_file = NamedTemporaryFile(suffix='.jpg')
temp_solution_file = NamedTemporaryFile()
cv.SaveImage(temp_img_file.name, resized)
tesseract(temp_img_file.name, temp_solution_file.name, '-c',
'tessedit_char_whitelist=' + whitelist_chars)
ret = str(cat(temp_solution_file.name + '.txt'))
import os
os.unlink(temp_solution_file.name + '.txt')
return ret
def Unhideimage(self,output):
bina = []
for i in range(16):
bina.append(self.getb())
self.increment()
width = int("".join(bina),2)
bina = []
for i in range(16):
bina.append(self.getb())
self.increment()
height = int("".join(bina),2)
unhideimg = cv.CreateImage((width,height), 8, 3) #Create an image in which we will put all the pixels read
print "Wait this may take time !"
for h in range(height):
for w in range(width):
for chan in range(unhideimg.channels):
val = list(unhideimg[h,w])
b=[]
for i in range(8):
b.append(self.getb())
self.increment()
val[chan] = int("".join(b),2)
unhideimg[h,w] = tuple(val)
cv.SaveImage(output,unhideimg)
def extract_camera_data(dest_dir, msg, ratio):
"""
Extract camera file from message according to ratio
"""
time_nseconds = []
pre_time_second = 0
seq = 0
# Check timestamp.
while True:
cur_time_second = msg.header.stamp.to_sec()
if cur_time_second - pre_time_second < ratio:
continue
pre_time_second = cur_time_second
time_nseconds.append(msg.header.stamp.to_nsec())
Image.ParseFromString(msg)
# Save image according to cyber format.
# height = 4, image height, that is, number of rows.
# width = 5, image width, that is, number of columns.
# encoding = 6, as string, type is 'rgb8', 'bgr8' or 'gray'.
# step = 7, full row length in bytes.
# data = 8, actual matrix data in bytes, size is (step * rows).
# type = CV_8UC1 if image step is equal to width as gray, CV_8UC3
# if step * 3 is equal to width.
_type = cv.CV_8UC1 if Image.step == Image.width else cv.CV_8UC3
mat = cv.CreateMat(Image.height, Image.width, _type)
image_file = os.path.join(dest_dir, '{}.png'.format(seq))
cv.SaveImage(image_file, dest_dir + str(seq))
seq += 1
def saveVideo(self, directory, videoBuffer):
self.log("Write captured images to %s" % dir)
for img in videoBuffer:
cv.SaveImage(os.path.join(directory, "%s.png" % (img['time']) ), img['img'])
self.log("%d Images written to %s" % (len(videoBuffer), directory))
def convertToGreyImage(imagePath,newImagePath):
image = cv.LoadImage(imagePath)
new = cv.CreateImage(cv.GetSize(image), image.depth, 1)
for i in range(image.height):
for j in range(image.width):
new[i,j] = 0.3 * image[i,j][0] + 0.59 * image[i,j][1] + 0.11 * image[i,j][2]
cv.SaveImage(newImagePath,new)
def get_image(camera, filename=None):
im = cv.QueryFrame(camera)
# take greyscale and compute RMS value
im2 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 3)
cv.Convert(im, im2)
gray = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 1)
cv.CvtColor(im2, gray, cv.CV_RGB2GRAY)
gray_mat = cv.GetMat(gray)
img = numpy.asarray(gray_mat)
power = numpy.sqrt(numpy.mean(img**2))
#save file
if filename:
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.8, 0.8, 0, 2,
cv.CV_AA)
cv.PutText(im, filename, (DATE_X, DATE_Y), font, cv.RGB(255, 255, 0))
filename = os.path.join(DIR_PREFIX, filename + '.jpg')
print filename
cv.SaveImage(filename, im)
del font
else:
filename = ''
#del(camera)
del im, im2, gray, img, gray_mat
return (power, filename)
def store(self, rgbList):
"""Stores pictures in the directory"""
temp = time.time()
retName = None
for rgb in rgbList:
extraIndex = 1
if time.time() - temp > 3:
self._AbstractVisionModule__send_heartbeat()
temp = time.time()
path = self.address + "/" + self.currentCluster + '/'
try:
os.makedirs(path)
except:
pass
now = "%10.2f" % time.time()
filename = now + '.png'
if os.path.isfile(filename):
strtemp = ""
while os.path.isfile(filename):
strtemp = filename + '-' + str(extraIndex)
extraIndex += 1
filename = strtemp
if not retName:
retName = filename
cv.SaveImage(path + filename, rgb)
self.lastFileName = filename
self.lastDir = path
return retName
def store(self, rgb):
today = datetime.date.today()
path = self.address + "/" + str(today) + '/'
try:
os.makedirs(path)
except:
pass
now = int(time.time())
filename = str(now) + '.png'
extraIndex = 1
if os.path.isfile(filename):
temp = ""
while os.path.isfile(filename):
temp = filename + '-' + str(extraIndex)
extraIndex += 1
filename = temp
cv.SaveImage(path + filename, rgb)
self.add_property('name', 'observer')
self.add_property('picturename', filename)
self.add_property('picturedir', path)
self.add_property('observe', "True")
self.command = False
def run(self):
"""start loop which gets a new image, then processes it"""
im = None
while im == None:
im = self.vid_mem_reader.get_latest_image()
if im == None:
print "not receiving images yet..."
time.sleep(0.2)
#Wait for video source to be ready:
#TODO: Shoud use vidmemreader, but this one never seem to return a resolution (at time of writing):
#res = self.vid_mem_reader.get_resolution()
#TODO: This should work, but it doesn't because OpenCV keeps on complaining about that im is not a IPL image
#(while if you print it, it seems to be a IPL image).
#print im
size = cv.GetSize(im[0])
#print size
self.res = ({'width': size[0], 'height': size[1]})
res = self.res
self.transformer = util.speed_angle.SpeedAngle(None, res['width'],
res['height'])
while True:
self.__ticker.tick()
start_time = time.time()
img = self.get_new_image()
''' Parallel Process Inside this module
im = np.asarray(img[:,:])
time_spent = time.time() - start_time
#Parallel process
self.parallel_rotate_image(im)
self.logger.debug("Set one finished")
print "Image Length: ", self.rotatedImages
for img in self.rotatedImages:
self.get_faces(img[0])
self.update()
self.rotatedImages = []
'''
im = np.asarray(img[:, :])
image = self.rotate_image(im, [self.rotation])
self.get_faces(image)
self.update()
#TODO: To be removed and or configurable:
directory = "/tmp/emergency/"
if not os.path.exists(directory):
os.makedirs(directory)
try:
cv.SaveImage(directory + "image.png", image)
except:
print "ERROR: Could not write image to /tmp/emergency/"
def capture():
"""
Using the intel training set to capture the face in the video.
Most of them are frameworks in OpenCV.
"""
j = 0
g = os.walk("origin")
for path, d, filelist in g:
for filename in filelist:
img = cv.LoadImage(os.path.join(path, filename))
image_size = cv.GetSize(img)
greyscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(img, greyscale, cv.CV_BGR2GRAY)
storage = cv.CreateMemStorage(0)
cv.EqualizeHist(greyscale, greyscale)
cascade = cv.Load('haarcascade_frontalface_alt2.xml')
faces = cv.HaarDetectObjects(greyscale, cascade, storage, 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING, (50, 50))
for (x, y, w, h), n in faces:
j += 1
cv.SetImageROI(img, (x, y, w, h))
cv.SaveImage("captured/face" + str(j) + ".png", img)
def main_program(usn):
#capture from inbuilt camera i.e web cam
cap = cv.CaptureFromCAM(0)
while (True):
#frame for video
img = cv.QueryFrame(cap)
#display the image from frame
cv.ShowImage("image", img)
#wait for response
k = cv.WaitKey(10)
#if esc is pressed the break
if k == 27:
break
#if 'c' is pressed then save the image
elif k == ord('c'):
time = datetime.now()
cv.SaveImage("face/database/image.png", img)
cv.DestroyAllWindows()
os.system("python face.py")
path = "c:/python27/face/database/image.png"
if os.path.exists(path):
#renaming the file with the usn along with the current date stmp for making it unique
newPath = "c:/python27/face/database/" + usn + str(
time.month) + str(time.day) + str(time.hour) + str(
time.minute) + str(time.second) + str(
time.microsecond) + ".png"
#path1="c:python27/face/database/"+usn+".png"
cmd = os.rename(path, newPath)
print "image captured, resized and renamed successfully"
#cv.ShowImage("image","face/database"+usn+exp+".png")
else:
print "no face detected......image deleted"
def detect_and_draw(img, cascade, jpg_cnt):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
img.width / image_scale), cv.Round(img.height / image_scale)), 8, 1)
# convert color input image to grayscale
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
if (cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
print "detection time = %gms" % (t / (cv.GetTickFrequency() * 10000))
if faces:
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
if jpg_cnt % 50 == 1:
print('capture completed')
cv.SaveImage('test_' + str(jpg_cnt) + '.jpg', img)
print("aaa1")
url = 'http://210.94.185.52:8080/upload.php'
#files={ 'upfiles' : open('/home/lee/test_'+str(jpg_cnt)+'.jpg','rb')}
files = {
'upfiles':
open('/home/lee/test_' + str(jpg_cnt) + '.jpg', 'rb')
}
print("aaa2")
r = requests.post(url, files=files)
print("aaa3")
print(r.text)
for i in r.text.split():
try:
op = float(i)
break
except:
continue
print(op)
#LED
if op >= 0.9:
lock_on()
else:
print('no')
cv.ShowImage("result", img)
def capture():
capture = cv.CaptureFromCAM(0)
filename = str(uuid.uuid4())
while True:
img = cv.QueryFrame(capture)
cv.SaveImage(filename+".jpg", img)
break
cv.DestroyAllWindows()
def repeat():
global capture
global camera_index
frame = cv.QueryFrame(capture)
cv.ShowImage("w1", frame)
cv.SaveImage("test.jpg", frame)
c = cv.WaitKey(10)
def look_for_faces(self):
image = cv.QueryFrame(self.capture)
if self.detect_face(image):
cv.SaveImage(
self.output_folder + "/cloudface_%d.jpg" %
(self.num_cloud_faces), image)
self.num_cloud_faces += 1
def startSequence(frame):
print 'start sequence...'
i = 1
while (i <= 5):
print 'Save image'
cv2.SaveImage('test1.jpg', frame)
time.sleep(3)
i = i + 1
def iplimage_to_string(im, lang=None, psm=None):
if not OPENCV_AVAILABLE:
print "OpenCV not Available"
return -1
else:
cv.SaveImage(TEMP_IMAGE, im)
txt = image_to_string(TEMP_IMAGE, lang, psm)
os.remove(TEMP_IMAGE)
return txt
def lines2():
im = cv.LoadImage('roi_edges.jpg', cv.CV_LOAD_IMAGE_GRAYSCALE)
pi = math.pi
x = 0
dst = cv.CreateImage(cv.GetSize(im), 8, 1)
cv.Canny(im, dst, 200, 200)
cv.Threshold(dst, dst, 100, 255, cv.CV_THRESH_BINARY)
color_dst_standard = cv.CreateImage(cv.GetSize(im), 8, 3)
cv.CvtColor(im, color_dst_standard,
cv.CV_GRAY2BGR) #Create output image in RGB to put red lines
lines = cv.HoughLines2(dst, cv.CreateMemStorage(0), cv.CV_HOUGH_STANDARD,
1, pi / 100, 71, 0, 0)
klsum = 0
klaver = 0
krsum = 0
kraver = 0
#global k
#k=0
for (rho, theta) in lines[:100]:
kl = []
kr = []
a = math.cos(theta)
b = math.sin(theta)
x0 = a * rho
y0 = b * rho
pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a)))
pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a)))
k = ((y0 - 1000 * (a)) - (y0 + 1000 * (a))) / ((x0 - 1000 * (-b)) -
(x0 + 1000 * (-b)))
if abs(k) < 0.4:
pass
elif k > 0:
kr.append(k)
len_kr = len(kr)
for i in kr:
krsum = krsum + i
kraver = krsum / len_kr
cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2,
4)
elif k < 0:
kr.append(k)
kl.append(k)
len_kl = len(kl)
for i in kl:
klsum = klsum + i
klaver = klsum / len_kl
cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2,
4)
#print k
# cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2, 4)
cv.SaveImage('lane.jpg', color_dst_standard)
print '左车道平均斜率:', klaver, ' 右车道平均斜率:', kraver
cv.ShowImage("Hough Standard", color_dst_standard)
cv.WaitKey(0)
def test():
#start = time.time()
#
src1 = cv.LoadImage("all.png", 0)
src2 = cv.LoadImage("dark3.png", 0)
# crop area
w = 100
pt1 = (535, 60)
pt2 = (pt1[0] + w, pt1[1] + w)
print pt1
print pt2
#get img size and compare
# convert cvMat to IplImage
crop1 = src1[pt1[1]:pt2[1], pt1[0]:pt2[0]]
crop2 = src2[pt1[1]:pt2[1], pt1[0]:pt2[0]]
crop3 = cv.GetImage(cv.GetSubRect(src1, (10, 10, 100, 100)))
crop4 = cv.GetImage(cv.GetSubRect(src2, (10, 10, 100, 100)))
# save image
cv.SaveImage("c01.jpg", crop1)
cv.SaveImage("c02.jpg", crop2)
cv.SaveImage("c03.jpg", crop3)
cv.SaveImage("c04.jpg", crop4)
print type(src1)
print type(crop3)
#cv2.GetMat
# compute
#return 1
hist1 = compute_histogram(crop3)
hist2 = compute_histogram(crop4)
# compare
sc = cv.CompareHist(hist1, hist2, cv.CV_COMP_CHISQR)
print sc
def main():
#~ APP_KEY = 'vz2q46h298i5bqy'
#~ APP_SECRET = 'f8xid4xf294wrv1'
#~ ACCESS_TYPE = 'app_folder'
data_serial = "text"
width = 1000
height = 700
window_name = "test"
number = 100
delay = 5
line_type = cv.CV_AA # change it to 8 to see non-antialiased graphics
cpture = cv.CaptureFromCAM(1)
cv.SetCaptureProperty(cpture, cv.CV_CAP_PROP_FRAME_WIDTH, 640 / 2)
cv.SetCaptureProperty(cpture, cv.CV_CAP_PROP_FRAME_HEIGHT, 480 / 2)
ulang = 1
sess = session.DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)
request_token = sess.obtain_request_token()
url = sess.build_authorize_url(request_token)
print "url:", url
raw_input()
access_token = sess.obtain_access_token(request_token)
client = client.DropboxClient(sess)
print "linked account:", client.account_info()
nomorfile = 0
namafile = "initiasinama"
aktiv = 0
ser.timeout = 5
print "standby"
while (ulang == 1):
image = cv.QueryFrame(cpture)
cv.NamedWindow(window_name, 1)
cv.ShowImage(window_name, image)
data = ser.read(1)
if (data == "1"):
print("alarm aktiv")
aktiv = 1
if (data == "0"):
print("password terautentifikasi")
aktiv = 0
print("standby")
if (aktiv == 1):
cv.SaveImage("photo.jpg", image)
f = open('photo.jpg')
namafile = "photo" + elinsGetDate() + ".jpg"
nomorfile = nomorfile + 1
response = client.put_file(namafile, f)
f.close()
print "uploaded: ", namafile
def repeat():
global capture #declare as globals since we are assigning to them now
global camera_index
frame = cv.QueryFrame(capture)
# frame = cv2.flip(frame,1)
# frameCopy = frame.clone()
# cv2.flip(frame,1)
cv.ShowImage("w1", frame)
cv.SaveImage("test.jpg",frame)
c = cv.WaitKey(10)
def eachFile(filepath):
pathDir = os.listdir(filepath)
for allDir in pathDir:
child = os.path.join('%s%s' % (filepath, allDir))
write_child = os.path.join('%s%s' % (write_path, allDir))
image = cv.LoadImage(child, 0)
des_image = cv.CreateImage((width_scale, height_scale), image.depth, 1)
cv.Resize(image, des_image, cv2.INTER_AREA)
# cv.ShowImage('afe',des_image)
cv.SaveImage(write_child, des_image)
def save_image(cap, cant=1):
images = []
# TODO: debe asegurarse de tomar %cant imágenes distintas
for number in xrange(cant):
image = cv.QueryFrame(cap)
filename = "cap-%f.ppm" % time.time()
images.append((filename, image))
cv.SaveImage(filename, image)
time.sleep(0.0)
yield filename
