def main():
args = sys.argv[1:]
imgpaths = ['contest_oc.png']
T = cv.LoadImage('target_oc.png', cv.CV_LOAD_IMAGE_GRAYSCALE)
T_smooth = cv.CreateImage((T.width, T.height), T.depth, T.channels)
cv.Smooth(T, T_smooth, cv.CV_GAUSSIAN, param1=17, param2=17)
allmatches = find_matches(imgpaths, T_smooth, C=0.8)
for imgpath, matches in allmatches.iteritems():
print "For image: {0}, {1} matches found.".format(
imgpath, len(matches))
I = cv.LoadImage(imgpath, cv.CV_LOAD_IMAGE_COLOR)
for (x, y, score) in matches:
cv.Circle(I, (x, y), 15, cv.RGB(0, 60, 255), thickness=4)
cv.SaveImage("allmatches_result.png", I)
print "Done."
def setUp(self):
"""
This method is called before each test
"""
self.img_1c = cv.LoadImage(
"data/tippy.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE) # 1 channel image
self.img_3c = cv.LoadImage("data/tippy.jpg",
cv.CV_LOAD_IMAGE_COLOR) # 3 channel image
self.img_fake_2c = cv.CreateImage((15, 15), cv.IPL_DEPTH_8U,
2) # 2 channels
self.fake_img = 10 # non Image
self.false_mode = "A" # non True/False (or 0/1) argument
self.fake_mode = 100 # non True/False (or 0/1) argument
self.fake_name = 100 # non True/False (or 0/1) argument
def main(args):
if args.output_directory:
directory = args.output_directory
else:
directory = os.path.dirname(args.compared_image)
print "No output directory specified. Defaulting to %s"%directory
if not os.path.exists(directory):
os.makedirs(directory)
if args.output_prefix:
prefix = args.output_prefix
else:
prefix_c = os.path.splitext(os.path.basename(args.compared_image))[0]
prefix_r = os.path.splitext(os.path.basename(args.reference_image))[0]
prefix = "%s_TO_%s"%(prefix_c, prefix_r)
print "No output prefix selected. Defaulting to %s"%prefix
output_file = "%s/%s.matches"%(directory, prefix)
if not args.input_match_file:
args.input_match_file = output_file
if not args.force_overwrite and os.path.exists( args.input_match_file ):
match_set_old = MatchSet( args.compared_image, args.reference_image )
match_set_old.read_from_file( args.input_match_file )
for match in match_set_old.get_matches():
compare_pts.append(match.compare_pt)
reference_pts.append(match.reference_pt)
strengths.append(match.strength)
compared_image = cv.LoadImage( args.compared_image)
reference_image = cv.LoadImage( args.reference_image )
compare_window = ClickWindow( compared_image, args.compare_zoom_out, COMPARE)
reference_window = ClickWindow( reference_image, args.reference_zoom_out, REFERENCE)
global mode
global strength
while(True):
cont = update_all_windows()
if not cont:
break
if compare_window.click_pt and reference_window.click_pt:
compare_pts.append(compare_window.click_pt)
reference_pts.append(reference_window.click_pt)
strengths.append(strength)
compare_window.clear_click_pt()
reference_window.clear_click_pt()
if save_flag:
match_set = MatchSet(args.compared_image, args.reference_image)
for i in range( len(compare_pts) ):
match_set.add_match( compare_pts[i], reference_pts[i], strengths[i] )
match_set.save_to_file( output_file )
print "Saved to %s"%output_file
def video_descriptor(obj, i, v_dictionary, v_noise):
depth = cv.LoadImage(
globals.path + 'img/' + obj + '-' + str(i) + '-depth.png',
cv.CV_LOAD_IMAGE_GRAYSCALE)
mask = cv.LoadImage(globals.path + 'mask.png', cv.CV_LOAD_IMAGE_GRAYSCALE)
if v_noise > 0:
rgb = cv2.imread(
globals.path + 'img/' + obj + '-' + str(i) + '-rgb.png',
cv.CV_LOAD_IMAGE_GRAYSCALE)
noise = np.random.randn(*rgb.shape) * v_noise
# Add this noise to image
noisy = rgb + noise
cv2.imwrite(globals.path + 'noisy.png', noisy)
rgb = cv.LoadImage(globals.path + 'noisy.png',
cv.CV_LOAD_IMAGE_GRAYSCALE)
#rgb = noisy
else:
rgb = cv.LoadImage(
globals.path + 'img/' + obj + '-' + str(i) + '-rgb.png',
cv.CV_LOAD_IMAGE_GRAYSCALE)
#cv.fromarray(rgb)
bridge = CvBridge()
rgb_image = bridge.cv_to_imgmsg(rgb)
depth_image = bridge.cv_to_imgmsg(depth)
mask_image = bridge.cv_to_imgmsg(mask)
#BASE Keypoint descriptors
keypoint_descriptors = []
rospy.wait_for_service('masked_base_descriptor_service')
try:
descriptor_request = rospy.ServiceProxy(
'masked_base_descriptor_service', masked_service)
response = descriptor_request(rgb=rgb_image,
depth=depth_image,
mask=mask_image)
base_descriptor = bridge.imgmsg_to_cv(response.descriptor)
keypoint_descriptors = np.array(base_descriptor)
keypoint_descriptors = keypoint_descriptors.tolist()
except rospy.ServiceException, e:
print "Service call failed: %s" % e
def __init__(self, path):
"""You provide the path of the dataset and then the input to channel 0 is the background subtraction mask."""
self.path = path
# Open the region of interest and convert it into a mask we can use...
roi = cv.LoadImage(os.path.join(path, 'ROI.bmp'))
self.roi = (cv2array(roi)!=0).astype(numpy.uint8)
if len(self.roi.shape)==3: self.roi = self.roi[:,:,0]
# Get the temporal range of the frames we are to analyse...
data = open(os.path.join(path, 'temporalROI.txt'), 'r').read()
tokens = data.split()
assert(len(tokens)==2)
self.start = int(tokens[0])
self.end = int(tokens[1]) # Note that these are inclusive.
# Confusion matrix - first index is truth, second guess, bg=0, fg=1...
self.con = numpy.zeros((2,2), dtype=numpy.int32)
# Shadow matrix - for all pixels that are in shadow records how many are background (0) and how many are foreground (1)...
self.shadow = numpy.zeros(2, dtype=numpy.int32)
# Basic stuff...
self.frame = 0
self.video = None
self.channel = 0
def haarface (filename):
source_image = cv.LoadImage(filename, cv.CV_LOAD_IMAGE_COLOR)
hf = Haarface (source_image)
def thin_processing(enhanced_image):
array = [0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,1,
0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,1,
1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,1,0,0,1,1,0,0,1,1,0,1,1,1,0,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,1,
0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,
1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,
1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,
1,1,0,0,1,1,0,0,1,1,0,1,1,1,0,0,
1,1,0,0,1,1,1,0,1,1,0,0,1,0,0,0]
cv2.imwrite("enhanced.bmp", enhanced_image)
image = cv.LoadImage("enhanced.bmp",0)
iTwo = Two(image)
iThin = thin(iTwo, array)
invertThin = Two(iThin)
#cv.WaitKey(0)
return invertThin
def main(argv):
if len(argv) < 10:
print('Usage: %s input-file fx fy cx cy k1 k2 p1 p2 output-file' %
argv[0])
sys.exit(-1)
src = argv[1]
fx, fy, cx, cy, k1, k2, p1, p2, output = argv[2:]
intrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
cv.Zero(intrinsics)
intrinsics[0, 0] = float(fx)
intrinsics[1, 1] = float(fy)
intrinsics[2, 2] = 1.0
intrinsics[0, 2] = float(cx)
intrinsics[1, 2] = float(cy)
dist_coeffs = cv.CreateMat(1, 4, cv.CV_64FC1)
cv.Zero(dist_coeffs)
dist_coeffs[0, 0] = float(k1)
dist_coeffs[0, 1] = float(k2)
dist_coeffs[0, 2] = float(p1)
dist_coeffs[0, 3] = float(p2)
src = cv.LoadImage(src)
dst = cv.CreateImage(cv.GetSize(src), src.depth, src.nChannels)
mapx = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_32F, 1)
mapy = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_32F, 1)
cv.InitUndistortMap(intrinsics, dist_coeffs, mapx, mapy)
cv.Remap(src, dst, mapx, mapy,
cv.CV_INTER_LINEAR + cv.CV_WARP_FILL_OUTLIERS, cv.ScalarAll(0))
# cv.Undistort2(src, dst, intrinsics, dist_coeffs)
cv.SaveImage(output, dst)
def LoadImage(filename, rotate180=False, RGB=False):
'''wrapper around cv.LoadImage that also handles PGM.
It always returns a colour image of the same size'''
if filename.endswith('.pgm'):
from ..image import scanner
try:
pgm = PGM(filename)
except Exception as e:
print('Failed to load %s: %s' % (filename, e))
return None
im_full = numpy.zeros((960, 1280, 3), dtype='uint8')
if RGB:
scanner.debayer_RGB(pgm.array, im_full)
else:
scanner.debayer(pgm.array, im_full)
if rotate180:
scanner.rotate180(im_full)
return cv.GetImage(cv.fromarray(im_full))
img = cv.LoadImage(filename)
if rotate180:
from ..image import scanner
img = numpy.ascontiguousarray(cv.GetMat(img))
scanner.rotate180(img)
img = cv.GetImage(cv.fromarray(img))
return img
def decode_v2_wrapper(imgpath,
markpath,
Icol,
H_GAP=7,
W_MARK=WIDTH_MARK,
H_MARK=HEIGHT_MARK,
idx2tol=None):
I = cv.LoadImage(imgpath, cv.CV_LOAD_IMAGE_GRAYSCALE)
result = decode_v2(I,
markpath,
Icol,
False,
_imgpath=imgpath,
H_GAP=H_GAP,
W_MARK=W_MARK,
H_MARK=H_MARK,
idx2tol=idx2tol)
if result == None and not DEBUG_SKIP_FLIP:
print_dbg("...Trying FLIP...")
cv.ResetImageROI(I)
result = decode_v2(I,
markpath,
Icol,
True,
_imgpath=imgpath,
H_GAP=H_GAP,
W_MARK=W_MARK,
H_MARK=H_MARK,
idx2tol=idx2tol)
if result == None:
return None, None, None
else:
decoding, isflip, bbs_out = result
return (decoding, isflip, bbs_out)
def application(request):
tempfile = NamedTemporaryFile()
try:
if request.method != 'GET':
raise MethodNotAllowed(['GET'])
if request.args.get('url') is None:
raise BadRequest('Missing parameter url')
try:
response = urllib2.urlopen(request.args.get('url'))
data = response.read()
except urllib2.HTTPError:
raise NotFound('url does not exist')
try:
tempfile.file.write(data)
image = cv.LoadImage(tempfile.name, 1)
except Exception:
raise BadRequest('No picture found on url')
faces = detect(image)
response = Response(json.dumps(faces))
except HTTPException, e:
return e
def detect(self, image):
"""
Determines the location of one or more faces in the given image.
"""
if isinstance(image, basestring):
image = cv.LoadImage(image)
image_size = cv.GetSize(image)
# Convert to grayscale.
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
#cv.EqualizeHist(grayscale, grayscale)
_image = image
image = grayscale
# Assume an image equal to the target size contains a single face.
target_size = (self.target_width, self.target_height)
if image_size == target_size:
rect = 0, 0, self.target_width, self.target_height
neighbors = None
return [(rect, neighbors)], image
# Locate one or more faces in the image.
t0 = time.time()
faces = cv.HaarDetectObjects(image, self.face_cascade,
cv.CreateMemStorage(0), 1.2, 2, 0,
(20, 20))
t1 = time.time() - t0
LOG.info('Haar detect took %.2f seconds.' % (t1, ))
return faces, image
def _do_decode_ballots(ballots, mark_path, queue=None):
"""
Decode ES&S barcode for all ballots
Input:
ballots : {int ballotID: [imgpath_side0, ...]}.
mark_path : path to example timing mark representing '1' in bitstring
queue : used for multiprocessing
Output:
results: {ballotid: [(bitstring, is_flipped, bit_locations), ...]}
"""
try:
mark = cv.LoadImage(mark_path, cv.CV_LOAD_IMAGE_GRAYSCALE)
results = {}
for ballotid, imgpaths in ballots.iteritems():
balresults = []
for imgpath in imgpaths:
bitstring, is_flipped, bit_locations = es_s.decode(
imgpath, mark, bits)
balresults.append((bitstring, is_flipped, bit_locations))
results[ballotid] = balresults
if queue:
queue.put(True)
return results
except:
traceback.print_exc()
def negative_cropped_oriented_boxes(xml_filename, image_filename):
image = cv.LoadImage(image_filename)
size = cv.GetSize(image)
# Transform the generator to a list, to avoid reparsing the xml file
oriented_boxes = list(read_oriented_boxes(xml_filename))
taboo_list = list(oriented_boxes)
for i in range(3):
for box in oriented_boxes:
x, y, width, height, angle, flip = box
for trial in range(10):
# Propose a negative box (it can extend outside the image a little)
n_angle = random.uniform(-pi, pi)
n_x = random.uniform(width / 2, size[0] - 1 - width / 2)
n_y = random.uniform(height / 2, size[1] - 1 - height / 2)
n_flip = random.choice([0, 1])
candidate = [n_x, n_y, width, height, n_angle, n_flip]
for b in taboo_list:
if oriented_boxes_overlap(b, candidate):
# Candidate is invalid. Try another random location
break
else:
# No overlap with any other box, this is a valid negative example
taboo_list.append(
candidate) # We dont want to resample the same
yield crop_single_oriented_box(candidate, image)
# Exit the rejection sampling loop and move on to the next box
break
def find_faces(self, file_name=None):
try:
import cv
except ImportError:
return
if file_name is None:
return
logger.debug("%s: %s" % (self.__class__.__name__, file_name))
imcolor = cv.LoadImage(file_name) #@UndefinedVariable
detectors = [
"haarcascade_frontalface_default.xml",
"haarcascade_profileface.xml"
]
for detector in detectors:
haarFace = cv.Load(os.path.join(settings.STATIC_ROOT,
detector)) # @UndefinedVariable
storage = cv.CreateMemStorage() #@UndefinedVariable
detectedFaces = cv.HaarDetectObjects(
imcolor, haarFace, storage,
min_size=(200, 200)) #@UndefinedVariable
if detectedFaces:
for face in detectedFaces:
fata = DetectedFace(imagine=self,
x=face[0][0],
y=face[0][1],
width=face[0][2],
height=face[0][3])
fata.save()
self.is_face_processed = True
self.save()
def Cam_Video(self):
# Recebe uma imagem e manda mostrar na tela
Actions.Receive_File()
if (self.ui.Record_Button.isFlat()):
frame = cv.LoadImage("img/img.jpg")
cv.WriteFrame(self._writer, frame)
self.Image_Show("img/img.jpg")
def calctaille(out_img):
total=0
nb=0
for j in range(0 , cv.GetSize(out_img)[0]):
cpt=0
for i in range(0 , cv.GetSize(out_img)[1]):
if out_img[i,j] == 255:
cpt += 1
total=total+cpt
if cpt != 0:
nb += 1
moy = total / nb
print "La taille est de : " + str(moy)
#Fonction appelee lorsque l'on clique avec la souris
def printcoords(event):
#On affiche dans la console les coordonnees X & Y
print (event.x,event.y)
seed = (event.x,event.y)
threshold = 20
img = cv.LoadImage(File, cv.CV_LOAD_IMAGE_GRAYSCALE)
out_img = simple_region_growing(img, seed, threshold)
calctaille(out_img)
cv.SaveImage('sortie.png', out_img)
print "Ouvrez le fichier sortie.png pour visualiser"
#Evenement du clic de la souris
canvas.bind("<Button 1>",printcoords)
cv.WaitKey(0)
root.mainloop()
def loadSegments():
global segments
segments = os.listdir(segment_dir)
segments = map(
lambda name: (os.path.splitext(name)[0][0],
cv.LoadImage(os.path.join(segment_dir, name), cv.
CV_LOAD_IMAGE_GRAYSCALE)), segments)
def __get_key_points(self, image_path):
DESCRIPTORS_MIN = 300
DESCRIPTORS_MAX = 420
keypoints = 0
descriptors = 0
range = 600
range_gap = 40
do_surf = True
image = cv.LoadImage(image_path, cv.CV_LOAD_IMAGE_GRAYSCALE)
while (do_surf):
(keypoints, descriptors) = cv.ExtractSURF(image, None,
cv.CreateMemStorage(),
(1, range, 3, 1))
do_surf = False
print "Descriptors: %d (range=%d)" % (len(descriptors), range)
if (len(descriptors) < DESCRIPTORS_MIN):
range = range - range_gap
if (len(descriptors) > DESCRIPTORS_MAX):
range = range + range_gap
if (len(descriptors) >= DESCRIPTORS_MIN
and len(descriptors) <= DESCRIPTORS_MAX):
do_surf = False
return (keypoints, descriptors)
def train_test():
train_subdir = "data/train/"
test_subdir = "data/test/"
img_kinds = ["happy", "anger", "neutral", "surprise"]
models = {}
params = "-t 0 -c 3"
svm_params = { "happy": params,
"anger": params,
"neutral": params,
"surprise": params}
#train the models
print 'BUILDING TRAIN MODELS'
for img_kind in img_kinds:
print "\t" + img_kind
problem = build_problem(img_kind, train_subdir)
param = svm.svm_parameter(svm_params[img_kind])
models[img_kind] = svmutil.svm_train(problem, param)
print '================================'
#for each image in test set let's see what is the answe
total_count = 0
correct_count = 0
wrong_count = 0
print 'TESTING MODELS'
for img_kind in img_kinds:
images = glob.glob(test_subdir + "f_" + img_kind + "*.jpg")
for image in images:
print "\t" + image
image_data = cv.LoadImage(image)
# Let's see what are the results from the models
results = {}
for kind in img_kinds:
test_data = get_image_features(image_data, True, kind)
predict_input_data = []
predict_input_data.append(test_data)
# do svm query
(val, val_2, label) = svmutil.svm_predict([1] ,predict_input_data, models[kind])
results[kind] = label[0][0]
sorted_results = sorted(results.iteritems(), key=operator.itemgetter(1))
result = sorted_results[len(sorted_results)-1][0]
total_count += 1
if result == img_kind:
print 'YES :' + result
correct_count += 1
else:
print 'NO :' + result
print sorted_results
wrong_count += 1
print '-----------------------'
print '================================'
print "Total Pictures: " + str(total_count)
print "Correct: " + str(correct_count)
print "Wrong: " + str(wrong_count)
print "Accuracy: " + str(correct_count/float(total_count) * 100)
def main():
# Uses xawtv. Gstreamer can be used instead, but I found it much slower
os.system("v4lctl snap jpeg 640x480 face.jpg")
image = cv.LoadImage("face.jpg")
detectObject(image)
displayObject(image)
cv.SaveImage("face.jpg", image)
def getNextImage(self):
"""returns a image which can be used for calibration"""
#return kinect frame
if self.source == "kinect":
if self.imageDepth == 8:
return convert_16to8(self.depth_retreiver.get_image())
#The new openni image_raw gives 8bit image
return self.depth_retreiver.get_image()
elif self.imageDepth == 11 or self.imageDepth == 16:
return self.depth_retreiver.get_image()
else:
print "Illegal image depth: '" + str(
self.imageDepth) + "'. Using 8 bit"
return convert_16to8(self.depth_retreiver.get_image())
# return testimage
elif self.source == "file":
# return None if there are no more images in the filelist
if len(self.filelist) <= self.currentFrame:
print "No more images in filelist..."
return None
else:
return cv.LoadImage(self.filelist[self.currentFrame],
cv.CV_LOAD_IMAGE_GRAYSCALE)
def process(infile):
image = cv.LoadImage(infile)
if image:
faces = detect_object(image)
im = Image.open(infile)
path = os.path.abspath(infile)
#save_path = os.path.splitext(path)[0]+"_face"
save_path = "face"
if os.path.isdir(save_path):
shutil.rmtree(save_path)
try:
os.mkdir(save_path)
except:
pass
if faces:
draw = ImageDraw.Draw(im)
count = 0
for f in faces:
count += 1
draw.rectangle(f, outline=(255, 0, 0))
a = im.crop(f)
file_name = os.path.join(save_path, str(count) + ".jpg")
# print file_name
a.save(file_name)
drow_save_path = os.path.join(save_path, "out.jpg")
im.save(drow_save_path, "JPEG", quality=80)
else:
print "Error: cannot detect faces on %s" % infile
def rotacion_y_posicion_robot(self,robo_x=200,robo_y=100,robo_th=80): """ \brief graficar el robot en el lienzo de mapa \param self no se necesita incluirlo al utilizar la funcion ya que se lo pone solo por ser la definicion de una clase \param robo_x coordenada x de la odometria del robot \param robo_y coordenada y de la odometria del robot \param robo_th Valor Th del robot \return Nada """ image_mapa=cv.LoadImage(self.nombre_archivo1, cv.CV_LOAD_IMAGE_COLOR) dimensiones_robot=self.dimensiones_robot image1=cv.CreateImage(dimensiones_robot,8,3) image_mascara=cv.CreateImage(dimensiones_robot,8,1) ##rotacion #Rotar el robot src_center=dimensiones_robot[0]/2,dimensiones_robot[1]/2 rot_mat=cv.CreateMat( 2, 3, cv.CV_32FC1 ) cv.GetRotationMatrix2D(src_center, robo_th, 1.0,rot_mat); cv.WarpAffine(self.robot,image1,rot_mat) #crear filtro para negro cv.InRangeS(image1,cv.RGB(0,0,0),cv.RGB(14,14,14),image_mascara) cv.Not(image_mascara,image_mascara) #cv.ReleaseImage(image1) #reducir y posicion cv.SetImageROI(image_mapa,(robo_x,robo_y, dimensiones_robot[0], dimensiones_robot[1])); cv.Copy(image1,image_mapa,mask=image_mascara) cv.ResetImageROI(image_mapa); cv.SaveImage(self.nombre_archivo, image_mapa) #Saves the image#
def main(args):
image = cv.LoadImage( args.input_image)
featuremap = FeatureMap()
featuremap.read_from_file( args.input_features )
classifier = load_classifier_from_file( args.classifier )
if not classifier.is_trained():
print "Warning: using an untrained classifier. This will probably break."
label_set = LabelSet()
label_set.read_from_file( args.label_set )
window = ClickWindow( image, args.zoom_out)
while(True):
cont = update_all_windows()
if not cont:
break
if window.update_label:
click_pt = window.click_pt
closest_pt = min( featuremap.get_feature_points(),
key = lambda pt: l2_dist(pt,click_pt) )
feature = featuremap.get_feature( closest_pt )
shape = featuremap.get_shape( closest_pt )
size = featuremap.get_size( closest_pt )
label = classifier.predict_label( feature )
label_name = "None" if label==0 else label_set.get_label_name(label)
label_color = cv.RGB(0,0,0) if label==0 else label_set.get_label_color(label)
print "Predicted label: %d (%s)"%(label, label_name);
window.set_patch( closest_pt, shape, size, label_color )
window.update_label = False
def imagen_homografia(n):
global points, width, height,teclado
urllib.urlretrieve("http://192.168.0.100:8080/photo.jpg", "foto.jpg")
foto=cv.LoadImage('foto.jpg')
im_in= cv.CloneImage(foto)
#CALIBRACION
width, height = cv.GetSize(im_in)
im = cv.CloneImage(foto)
if n == 0 and (teclado ==1 or teclado ==3):
cv.ShowImage('Escoger 4 puntos',im)
cv.SetMouseCallback('Escoger 4 puntos', mouse, im)
cv.WaitKey(0)
guardarpoints(points)
h**o = homografia(im_in.width, im_in.height, im.width, im.height)
cv.Save('homography.cvmat', h**o)
else:
points = cargarpoints()
h**o = homografia(im_in.width, im_in.height, im.width, im.height)
out_big = cv.CloneImage(im_in)
cv.WarpPerspective(im_in, out_big, h**o)
out_small = cv.CloneImage(im)
cv.Resize(out_big, out_small)
return out_small, out_big
def detect(self, obj, event):
# First, reset image, in case of previous detections:
active_handle = self.get_active('Media')
media = self.dbstate.db.get_media_from_handle(active_handle)
self.load_image(media)
min_face_size = (50, 50) # FIXME: get from setting
self.cv_image = cv.LoadImage(self.full_path,
cv.CV_LOAD_IMAGE_GRAYSCALE)
o_width, o_height = self.cv_image.width, self.cv_image.height
cv.EqualizeHist(self.cv_image, self.cv_image)
cascade = cv.Load(HAARCASCADE_PATH)
faces = cv.HaarDetectObjects(self.cv_image, cascade,
cv.CreateMemStorage(0), 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING,
min_face_size)
references = self.find_references()
rects = []
o_width, o_height = [
float(t) for t in (self.cv_image.width, self.cv_image.height)
]
for ((x, y, width, height), neighbors) in faces:
# percentages:
rects.append((x / o_width, y / o_height, width / o_width,
height / o_height))
self.draw_rectangles(rects, references)
def main():
global val1, val2
img = cv.LoadImage(sys.argv[1])
if img:
cv.NamedWindow("bar")
img2 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
img21 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
img3 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_16S, 1)
img4 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(img, img2, cv.CV_BGR2GRAY)
cv.EqualizeHist(img2, img21)
stor = cv.CreateMemStorage()
cv.AdaptiveThreshold(img21, img4, 255,
cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C,
cv.CV_THRESH_BINARY_INV, 7, 7)
cont = cv.FindContours(img4, stor, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_NONE)
img5 = cv.CloneImage(img)
while cont:
if validate_contour(cont):
cv.DrawContours(img5, cont, (255, 255, 255), (255, 255, 255),
0, 2, 8, (0, 0))
cont = cont.h_next()
cv.ShowImage("bar", img5)
cv.WaitKey(0)
def test(self):
arr = cv.LoadImage("../samples/c/lena.jpg", 0)
original = cv.CloneImage(arr)
size = cv.GetSize(arr)
eig_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
temp_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
threshes = [ x / 100. for x in range(1,10) ]
results = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, use_harris = 1)) for t in threshes])
# Check that GoodFeaturesToTrack has not modified input image
self.assert_(arr.tostring() == original.tostring())
# Check for repeatability
for i in range(10):
results2 = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, use_harris = 1)) for t in threshes])
self.assert_(results == results2)
for t0,t1 in zip(threshes, threshes[1:]):
r0 = results[t0]
r1 = results[t1]
# Increasing thresh should make result list shorter
self.assert_(len(r0) > len(r1))
# Increasing thresh should monly truncate result list
self.assert_(r0[:len(r1)] == r1)
def images_from_random_people(all_people, max_pics, recognizer):
num_to_train = 8
id_counter = 2
random.shuffle(all_people)
all_people = all_people
num_training_added = 0
for person in all_people:
label_dict[recognizer][id_counter] = person
if "DS_STORE" in face_dir + person:
continue
try:
all_pictures = os.listdir(face_dir + person + "/")
except:
continue
if len(all_pictures) < 20:
continue
random.shuffle(all_pictures)
all_pictures = all_pictures[:max_pics]
for picture_name in all_pictures:
picture_dir = face_dir + person + "/"
full_path = picture_dir + picture_name
try:
face = cv.LoadImage(full_path, cv2.IMREAD_GRAYSCALE)
except IOError:
continue
yield face[:, :], id_counter
num_training_added += 1
if num_training_added > num_to_train:
break
id_counter += 1
