def test_full_integral_image_correctness(): ''' Test generated full integral image correctness, note that this relies on the corectness of interpreter and reference.py ''' block_size = (20, 20) size = tuple(x*3 for x in block_size) # generate random test image test_image = [[float(random.randint(0, 255)) for i in xrange(size[0])] for j in xrange(size[1])] # reference implementation integral_ref = reference.gen_integral_image(test_image) sq_integral_ref = reference.gen_integral_squared_image(test_image) # pointer config buffer_size = block_size[0]*block_size[1] src_ptr = 0 integral_ptr = buffer_size sq_integral_ptr = 2*buffer_size # set up interpreter for integral image calculation pe_dim = [s//b for s, b in zip(size, block_size)] def code_gen(code, block_size, args): return gen_code.gen_full_integral_image(code, src_ptr, integral_ptr, sq_integral_ptr, pe_dim, block_size) code = Code() code.set_generator(optimiser_wrapper(code_gen), block_size) sim = Interpreter(code, test_image, block_size) sim.run() # get result of simulator with scaling, truncation turned off and float output integral_test = sim.gen_output_image(1, False, False, True) sq_integral_test = sim.gen_output_image(2, False, False, True) # comparison of reference with blip sim integral_err = compare_images(integral_ref, integral_test) sq_integral_err = compare_images(sq_integral_ref, sq_integral_test) err_eps = 0.001 if not ((integral_err < err_eps) and (sq_integral_err < err_eps)): print 'integral comp:', integral_err print 'squared integral comp:', sq_integral_err print 'rendering instruction stream to file, can take a while' try: f = open('unoptimised_full_integral_image_trace.txt', 'w') def tag_str(instr): return ', '.join(instr.tag) if hasattr(instr, 'tag') else '' f.write('\n'.join(str(x).ljust(40) + ' tags: ' + tag_str(x) for x in code_gen(Code()))) f.close() optim_gen = optimiser_wrapper(code_gen, block_size, {}) f = open('bad_full_integral_image_trace.txt', 'w') def tag_str(instr): return ', '.join(instr.tag) if hasattr(instr, 'tag') else '' f.write('\n'.join(str(x).ljust(40) + ' tags: ' + tag_str(x) for x in optim_gen(Code()))) f.close() except Exception, e: print 'could render instruction stream to file' print 'err: ' + str(e) assert False
def run_test(images, th, alpha, block_size): image0 = images[0] im_size = len(image0) bwidth, bheight = block_size assert(im_size == bwidth * bheight) # only one pe code = Code() code.set_generator(gen_bbs, block_size, {'th':th, 'alpha':alpha}) output = [] sim = None for im in images: # interpreter expects 2D array im_tr = [[im[i*width + j] for j in xrange(bwidth)] for i in xrange(bheight)] if not sim: sim = Interpreter(code, im_tr, block_size) else: # restart code gen sim.reset() # set new image sim.set_src_image(im_tr) sim.run() im_out = sim.gen_output_image(1) # convert to 1D vector im_out_1D = [] for row in im_out: for v in row: im_out_1D.append(v) output.append(im_out_1D) return output
def run_test(image, position, shape, block_size): def code_gen(code, block_size, args): return gen_code.gen_fullintegral_sum(code, code.r(4), position, shape, ptr, block_size) code = Code() code.set_generator(optimiser_wrapper(code_gen), block_size) sim = Interpreter(code, image, block_size) sim.run() # extract value return sim.procs[0][0].get_reg_by_name('r4')
def run_test(image, position, shape, block_size): code = Code() out_reg = code.alloc_reg() def code_gen(code, block_size, args): return gen_code.gen_integral_sum(code, out_reg, position, shape, ptr, block_size) code.set_generator(optimiser_wrapper(code_gen), block_size) sim = Interpreter(code, image, block_size) sim.run() # extract value return sim.procs[0][0].get_reg_by_name(str(out_reg))
def run_test(image, coeff): code = Code() block_size = (16, 16) in_ptr = 0 out_ptr = block_size[0]*block_size[1] args = {} def codegen(code, block_size, args): return map_neighborhood_to_pixel(code, in_ptr, out_ptr, coeff, pixel_op, args, block_size) code.set_generator(codegen, block_size, args) sim = Interpreter(code, image, block_size) sim.run() return sim.gen_output_image(1)
def run_test(image, offset): code = Code() block_size = (16, 16) in_ptr = 0 out_ptr = block_size[0]*block_size[1] args = {'offset' : offset} def codegen(code, block_size, args): return map_image_to_pixel(code, in_ptr, out_ptr, pixel_op, args, block_size) code.set_generator(codegen, block_size, args) sim = Interpreter(code, image, block_size) sim.run() return sim.gen_output_image(1)
def run_test(image, args, block_size): im_size = len(image[0]), len(image) bwidth, bheight = block_size assert(im_size == block_size) # only one pe code = Code() code.set_generator(codegen, block_size, args) sim = Interpreter(code, image, block_size) sim.run() output = sim.gen_output_image(1, False) return output
def run_test(image, position, shape, ptr, block_size): px, py = position x, y, w, h = shape xx = px + x yy = py + y points = ((xx, yy), (xx+w-1, yy), (xx, yy+h-1), (xx+w-1, yy+h-1)) def code_gen(code, block_size, args): return gen_code.gen_fullintegral_sum2_2(code, code.r(4), ptr, points, block_size) code = Code() code.set_generator(code_gen, block_size) sim = Interpreter(code, image, block_size) sim.run() # extract value return sim.procs[0][0].get_reg_by_name('r4')
def run_codegen_function(test_image, code_gen, block_size, args, buffer_sel = 1, **kwargs): image2buffer = kwargs['image2buffer'] if 'image2buffer' in kwargs else {} im_size = len(test_image[0]), len(test_image) pe_dim = [s//b for s,b in zip(im_size, block_size)] # fill this in for all functions args['pe_dim'] = pe_dim code = Code() code.set_generator(code_gen, block_size, args) sim = Interpreter(code, test_image, block_size) for buffer_nr, image in image2buffer.iteritems(): sim.set_src_image(image, buffer_nr) sim.run() return sim.gen_output_image(buffer_sel, False, False, True), sim
def gen_integral_image_correctness(): ''' test if generated integral image is correct, note that this relies on the corectness of interpreter and reference.py ''' # size = (120, 80) # block_size = (40, 40) size = (80, 80) block_size = size # generate random test image test_image = [[float(random.randint(0, 255)) for i in xrange(size[0])] for j in xrange(size[1])] # reference implementation integral_ref = reference.gen_integral_image(test_image) sq_integral_ref = reference.gen_integral_squared_image(test_image) # pointer config buffer_size = block_size[0]*block_size[1] src_ptr = 0 integral_ptr = buffer_size sq_integral_ptr = 2*buffer_size # set up interpreter for integral image calculation def code_gen(code, block_size, args): return gen_code.gen_integral_image(code, src_ptr, integral_ptr, sq_integral_ptr, block_size) code = Code() code.set_generator(optimiser_wrapper(code_gen), block_size) sim = Interpreter(code, test_image, block_size) sim.run() # get result of simulator with scaling, truncation turned off and float output integral_test = sim.gen_output_image(1, False, False, True) sq_integral_test = sim.gen_output_image(2, False, False, True) # comparison of reference with blip sim integral_err = compare_images(integral_ref, integral_test) sq_integral_err = compare_images(sq_integral_ref, sq_integral_test) err_eps = 0.001 if not ((integral_err < err_eps) and (sq_integral_err < err_eps)): print 'integral comp:', integral_err print 'squared integral comp:', sq_integral_err assert False
def run_test(image, cascade): block_size = (64, 64) print 'XXX histogram equalisation is not implemented yet, use violajones impl' print ' before executing simulator' image = reference.equalizeHist(image) args = {'haar_classifier':cascade} # now execute the codegen code = Code() code.set_generator(gen_code.gen_detect_faces_opt, block_size, args) #print '# instructions: %i'%(code.instr_size()) sim = Interpreter(code, image, block_size, 4) sim.run() detections_pixmap = sim.gen_output_image(1) # result is saved in first buffer # convert the number of rejections in the stages to detections detections = gen_code.convert_pixelmap_to_detections(detections_pixmap, cascade.size) return detections
def test_full_integral_image_correctness(): ''' Test generated full integral image correctness, note that this relies on the correctness of interpreter and reference.py ''' block_size = (20, 20) size = tuple(x*3 for x in block_size) # generate random test image test_image = [[float(random.randint(0, 255)) for i in xrange(size[0])] for j in xrange(size[1])] # reference implementation integral_ref = reference.gen_integral_image(test_image) sq_integral_ref = reference.gen_integral_squared_image(test_image) # pointer config buffer_size = block_size[0]*block_size[1] src_ptr = 0 integral_ptr = buffer_size sq_integral_ptr = 2*buffer_size # set up interpreter for integral image calculation pe_dim = [s//b for s, b in zip(size, block_size)] code = Code() def code_gen(code, block_size, args): return gen_code.gen_full_integral_image(code, src_ptr, integral_ptr, sq_integral_ptr, pe_dim, block_size) code.set_generator(code_gen, block_size) sim = Interpreter(code, test_image, block_size) sim.run() # get result of simulator with scaling, truncation turned off and float output integral_test = sim.gen_output_image(1, False, False, True) sq_integral_test = sim.gen_output_image(2, False, False, True) # comparison of reference with blip sim integral_err = compare_images(integral_ref, integral_test) sq_integral_err = compare_images(sq_integral_ref, sq_integral_test) err_eps = 0.001 assert (integral_err < err_eps) and (sq_integral_err < err_eps)
def run_test(codegen_function, image, cascade, block_size): print 'running %s'%codegen_function.__name__ print 'XXX histogram equalisation is not implemented yet, use violajones impl' print ' before executing simulator' image = reference.equalizeHist(image) width, height = block_size pe_dim = (len(image[0])//width, len(image)//height) args = {'haar_classifier': cascade, 'pe_dim':pe_dim} # now execute the codegen code = Code() code.set_generator(optimiser_wrapper(codegen_function), block_size, args) sim = Interpreter(code, image, block_size, 4) sim.run() detections_pixmap = sim.gen_output_image(1) # result is saved in first buffer # convert the number of rejections in the stages to detections detections = gen_code.convert_pixelmap_to_detections(detections_pixmap, cascade.size) return detections
def run_test(position, integral_test, sq_integral_test, haar_size, block_size): integral_ptr = 0 sq_integral_ptr = block_size[0]*block_size[1] code = Code() out_reg = code.alloc_reg() def code_gen(code, block_size, args): return gen_code.gen_calc_variance(code, out_reg, position, integral_ptr, sq_integral_ptr, haar_size, block_size) code.set_generator(optimiser_wrapper(code_gen), block_size) sim = Interpreter(code, integral_test, block_size) # hack: in order to avoid calculating integral images, inject random values into the sq_integral buffer # this is easy since their is only a single PE for i, row in enumerate(sq_integral_test): for j, v in enumerate(row): sim.procs[0][0].memory.set(sq_integral_ptr + len(row)*i+j, v) sim.run() pe = sim.procs[0][0] # extract value return (1./(pe.get_reg_by_name(str(out_reg)))), pe