def setUp(self): self.num_timestamps = 10 self.fov = math.pi / 2 self.image_width = 1000 self.object_universe = ObjectUniverse( num_timestamps=self.num_timestamps) self.camera = Camera() self.camera.set_actual_position((1,1)).\ set_fov_rad(self.fov).\ set_num_timestamps(self.num_timestamps).\ set_range(50000) for timestamp in range(self.camera.get_num_timestamps()): self.camera.set_state_of_pan_motor_angle_at_timestamp_rad( math.pi / 4, timestamp) self.cv = ComputerVision() self.image_generator = ImageGenerator(image_width=self.image_width) self.camera.set_computer_vision(self.cv).\ set_image_generator(self.image_generator) self.viewable_objects = [ StationaryObject((2, 1 + math.tan(math.pi / 8))), StationaryObject((1 + math.tan(math.pi / 8), 2)), StationaryObject((10000, 1.1)), StationaryObject((1.1, 10000)), ] self.object_universe.add_viewable_objects(self.viewable_objects) self.object_universe.add_camera(self.camera) self.d = self.image_width / (2 * math.tan(self.fov / 2)) self.theta = math.pi / 8
def main(): # Parameters images_directory = './data/images' categories_file = '../categories.json' if not os.path.isdir(images_directory): loader = ImageLoader(output_directory=images_directory, categories_file=categories_file) loader.load() experience_file = './data/experience-new-ratings.csv' number_of_experiences, ids_for_categories = load_experience_data( experience_file, n_ratings=2) number_of_true_images_for_provider = 8 number_of_noise_images_for_provider = 2 number_of_images_in_collage = 6 output_directory = './data/generated-data' features_original_images_file = './data/images/features-images-1' image_generator = ImageGenerator(images_directory, categories_file, features_original_images_file) image_generator.generate( number_of_true_images_for_provider=number_of_true_images_for_provider, number_of_noise_images_for_provider=number_of_noise_images_for_provider, number_of_images=number_of_experiences, ids=ids_for_categories, number_of_images_in_collage=number_of_images_in_collage, output_directory=output_directory) evaluator = Evaluator(output_directory, features_file='./data/features-generated-data') evaluator.visualize(show='ratings') evaluator.classify()
def generate_output_file(result, output_path, args): """ Generate output file """ if args.type == 'rp': ImageGenerator.save_recurrence_plot(result.recurrence_matrix_reverse, output_path) elif args.type == 'rqa': with open(output_path, 'w') as f: for line in result.to_string(): f.write(line)
def __init__(self): #============================================================================= # Please select one of the valid ids, currently between 0 and 3 # 0: 'artificial_no_noise': Produce the artificial image and its analytical and numerical slope and curvatures without noise # 1: 'artificial_noise': Same as 0 with noise # 2: 'landscape': Compute numerical slope and curvature for Souris landscape # 3: 'speed': Runtime over large basic image # 4: 'difference': Shows difference between numerical and analytical results for IART # Assumes that all plosts exist already, so please choice 1! # 5: r_squared self.analyses = ['artificial_no_noise','artificial_noise','landscape','speed','difference'] analysis_id = 1 # Display Tiff images using matplotlib.pyplot as they are created (True/False) # Note that Choice 3 (speed) has auto_plot turned off unless it is changed further down # and Choice 4 (difference) only provides pyplot figures as output, and does so regardless of auto_plot setting self.auto_plot = True # Number of aggregations that are requested, maximum window size will be 2^num_aggre self.num_aggre = 6 #============================================================================= self.analysis = self.analyses[analysis_id] self.dtype = config.work_dtype if self.analysis == self.analyses[0]: self.img_dir = 'img_artificial/' self.image_size = 512 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.multi_gauss = self.img_gen.multi_gauss(self.image_size,0,0) elif self.analysis == self.analyses[1]: self.img_dir = 'img_artificial/' self.image_size = 512 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.multi_gauss = self.img_gen.multi_gauss(self.image_size,0,0.01) elif self.analysis == self.analyses[2]: self.img_dir = 'img_souris/' self.image_size = 500 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.landscape = self.img_gen.landscape(self.img_dir+'SourisSmall.tif') elif self.analysis == self.analyses[3]: self.auto_plot = False self.img_dir = 'img_dome/' self.image_size = 5000 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.dome = self.img_gen.dome(self.image_size) elif self.analysis == self.analyses[4]: self.img_dir = 'img_artificial/' self.image_size = 512 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.landscape = self.img_gen.landscape(self.img_dir+'multi_random_id0_n10.tif')
def run_test(): keywords = ['apple', 'blue', '안녕', 'money'] #keywords = ['monday'] for crawl_type in ['sync', 'async']: datas = [] for keyword in keywords: data = run_wrk(keyword, crawl_type) datas.append(data) extracted_datas, website = extract_data(datas, keywords) image_generator = ImageGenerator(crawl_type) image_name = 'static/' + crawl_type + '_image.png' image_generator.generate_and_save_image(extracted_datas, website, image_name, latency_until=100)
def setUp(self) -> None: self.fd, self.name = tempfile.mkstemp(suffix=".db") self.sql_executor = SQLExecutor(self.name, debug=True) self.storage = StatStorage.make_with_executor(self.sql_executor) self.image_generator = ImageGenerator() routes = RoutesFactory.make_routes(self.storage, self.image_generator, RequestHandler) self.app = AppFactory.make_app(routes)
def show_image_sample(generator, transition): image_generator = ImageGenerator(generator, transition) image_current, image_next = image_generator(generator.device.device.id) image_current.to_cpu() image_next.to_cpu() viewer.show_image(image_current.data[0][0], is_gray=True) viewer.show_image(image_next.data[0][0], is_gray=True)
def img_filename_motivation(): """ Returns the number of the images from the motivation. It can be change if we want to modify them """ # The image numbers of our motivation images img_nums = img_num_motivation # Initialise an image generator img_dir = 'images/val/images/' img_class_map_file = 'images/val/val.txt' class_file = 'images/val/synset_words.txt' image_generator = ImageGenerator(img_dir, img_class_map_file, class_file) # Get a path and label for each of our images img_filenames = list() for img in img_nums: filename=image_generator.get_image_filename(img) img_filenames.append(filename) return img_filenames
def images_motivation(dnn_daemon): """ Plots the images from the motivation section """ # The image numbers of our motivation images img_nums = img_num_motivation # Initialise an image generator img_dir = 'images/val/images/' img_class_map_file = 'images/val/val.txt' class_file = 'images/val/synset_words.txt' image_generator = ImageGenerator(img_dir, img_class_map_file, class_file) # Get a path and label for each of our images img_paths = list() img_labels = list() for img in img_nums: path, label = image_generator.get_image_data(img) img_paths.append(path) img_labels.append(label) return img_paths
def run(self): np.random.seed(self.config['seed']) image_dict = {} for i,exppriment_parameters in enumerate(self.experiment_parameters_list): print(exppriment_parameters) (train_data, probe_data, train_update_sets, test_update_sets, test_set)=DataExtractor().get_data() shadow_model=TrainShadow(exppriment_parameters).get_trained_model(train_data, test_set) train_deltas=TrainUpdateModels('train',exppriment_parameters).get_update_dataset(probe_data, train_update_sets, shadow_model) test_deltas=TrainUpdateModels('test',exppriment_parameters).get_update_dataset(probe_data, test_update_sets, shadow_model) (generator, encoder)=TrainGan(train_deltas,train_update_sets, exppriment_parameters).get_GAN() generated_images=ImageGenerator(exppriment_parameters).get_images(test_update_sets,test_deltas, encoder, generator) Utils().add_images_to_dict(3,image_dict,generated_images, exppriment_parameters) print (f'finished running experiment {i+1} out of {len(self.experiment_parameters_list)}') plot_dict(image_dict, len(self.experiment_parameters_list)) Utils().plot_update(test_update_sets[1]) Utils().plot_generated(generated_images[1]) return generated_images
def up_down_selection(): while True: dir = os.path.join(args.root, cases[k]) result, img = process_dir(dir, ImageGenerator(dir)) if result == __PREVIOUS_CASE__: k=k-1 if k<0: k = len(cases)-1 elif result==__NEXT_CASE__: k = k + 1 # if k == len(cases): # print('finished') # break else: with open('annotation.txt', 'a') as f: f.write(",".join([name(parent(img)), img]) + '\n') print(img,' is validated') k = k + 1 if k == len(cases): k = 0
def save_sample_image(trainer): updater = trainer.updater g_optimizer = updater.get_optimizer('g_optimizer') t_optimizer = updater.get_optimizer('t_optimizer') generator = g_optimizer.target transition = t_optimizer.target image_generator = ImageGenerator(generator, transition) image_current, image_next = image_generator(generator.device.device.id) image_current.to_cpu() image_next.to_cpu() iterator = trainer.updater.get_iterator('main') filename_current = 'intermediate/epoch-{}-current.jpg'.format( iterator.epoch) filename_next = 'intermediate/epoch-{}-next.jpg'.format(iterator.epoch) print('image array: ', image_current.data[0][0][0]) pyplot.imsave(filename_current, image_current.data[0][0], cmap='gray') pyplot.imsave(filename_next, image_next.data[0][0], cmap='gray')
from images2gif import writeGif from image_generator import ImageGenerator from PIL import Image import os class Something(object): pass if __name__ == '__main__': args = Something() args.fontfile = '/Users/timoeemelikoola/Downloads/Cardo/Cardo-Regular.ttf' imgs = [] for i in xrange(20): ig = ImageGenerator({"text": str(i), "line": str(i)}, args) ig.generate() ig.save() imgs.append(Image.open(ig.file_name)) size = (150, 150) for im in images: im.thumbnail(size, Image.ANTIALIAS) filename = "images/my_gif.GIF" writeGif(filename, images, duration=0.2)
tmp_targets = np.array(targets) inputs = [] targets = [] yield preprocess_input(tmp_inp), tmp_targets # In[6]: path_prefix = 'VOC2007/JPEGImages/' #path_prefix = '../../frames/' # BATCH 11 is the maximum #gen = Generator(gt, bbox_util, 11, path_prefix, # train_keys, val_keys, # (input_shape[0], input_shape[1]), do_crop=False) # gen = ImageGenerator(gt, bbox_util, 9, (input_shape[0], input_shape[1]), train_keys, val_keys, path_prefix) # In[7]: model = SSD300(input_shape, num_classes=NUM_CLASSES) model.load_weights('weights_SSD300.hdf5', by_name=True) # In[8]: freeze = [ 'input_1', 'conv1_1', 'conv1_2', 'pool1', 'conv2_1', 'conv2_2', 'pool2', 'conv3_1', 'conv3_2', 'conv3_3', 'pool3' ] #, # 'conv4_1', 'conv4_2', 'conv4_3', 'pool4'] for L in model.layers: if L.name in freeze:
'min_size': 222.0, 'max_size': 276.0, 'aspect_ratios': [1.0, 1.0, 2.0, 1 / 2.0, 3.0, 1 / 3.0] }, { 'layer_width': 1, 'layer_height': 1, 'num_prior': 6, 'min_size': 276.0, 'max_size': 330.0, 'aspect_ratios': [1.0, 1.0, 2.0, 1 / 2.0, 3.0, 1 / 3.0] }, ] priors = create_prior_box(image_shape[0:2], box_configs, variances) bounding_box_utils = BoundingBoxUtility(num_classes, priors) ground_truth_data = XML_preprocessor(data_path + 'Annotations/').data keys = sorted(ground_truth_data.keys()) num_train = int(round(training_data_ratio * len(keys))) train_keys = keys[:num_train] validation_keys = keys[num_train:] num_val = len(validation_keys) image_generator = ImageGenerator(ground_truth_data, bounding_box_utils, batch_size, data_path + 'JPEGImages/', train_keys, validation_keys, image_shape[:2]) gen = image_generator.flow(True) next(gen)
class SlidingWindowComparison(): def __init__(self): #============================================================================= # Please select one of the valid ids, currently between 0 and 3 # 0: 'artificial_no_noise': Produce the artificial image and its analytical and numerical slope and curvatures without noise # 1: 'artificial_noise': Same as 0 with noise # 2: 'landscape': Compute numerical slope and curvature for Souris landscape # 3: 'speed': Runtime over large basic image # 4: 'difference': Shows difference between numerical and analytical results for IART # Assumes that all plosts exist already, so please choice 1! # 5: r_squared self.analyses = ['artificial_no_noise','artificial_noise','landscape','speed','difference'] analysis_id = 1 # Display Tiff images using matplotlib.pyplot as they are created (True/False) # Note that Choice 3 (speed) has auto_plot turned off unless it is changed further down # and Choice 4 (difference) only provides pyplot figures as output, and does so regardless of auto_plot setting self.auto_plot = True # Number of aggregations that are requested, maximum window size will be 2^num_aggre self.num_aggre = 6 #============================================================================= self.analysis = self.analyses[analysis_id] self.dtype = config.work_dtype if self.analysis == self.analyses[0]: self.img_dir = 'img_artificial/' self.image_size = 512 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.multi_gauss = self.img_gen.multi_gauss(self.image_size,0,0) elif self.analysis == self.analyses[1]: self.img_dir = 'img_artificial/' self.image_size = 512 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.multi_gauss = self.img_gen.multi_gauss(self.image_size,0,0.01) elif self.analysis == self.analyses[2]: self.img_dir = 'img_souris/' self.image_size = 500 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.landscape = self.img_gen.landscape(self.img_dir+'SourisSmall.tif') elif self.analysis == self.analyses[3]: self.auto_plot = False self.img_dir = 'img_dome/' self.image_size = 5000 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.dome = self.img_gen.dome(self.image_size) elif self.analysis == self.analyses[4]: self.img_dir = 'img_artificial/' self.image_size = 512 self.img_gen = ImageGenerator(self.img_dir) self.img_gen.auto_plot = self.auto_plot self.landscape = self.img_gen.landscape(self.img_dir+'multi_random_id0_n10.tif') def compute_multi(self,img_gen,num_aggre): with SlidingWindow(img_gen) as slide_window: print('img_gen: ',self.img_gen) slide_window.auto_plot = self.auto_plot slide_window.initialize_dem() slide_window.aggregate_dem(1) slide_window.dem_slope() for num_loc in range(2,num_aggre+1): slide_window.aggregate_dem(1) slide_window.dem_slope() slide_window.dem_profile() slide_window.dem_tangential() slide_window.dem_contour() slide_window.dem_proper_profile() slide_window.dem_proper_tangential() def speed_numbers(self,img_gen_fn,num_aggre): time_array = np.zeros([num_aggre-1,4]) with SlidingWindow(img_gen_fn) as slide_window: slide_window.auto_plot = self.auto_plot slide_window.initialize_dem() time_start = time.time_ns() i = 0 time_start = time.time_ns() slide_window.aggregate_dem() time0 = time.time_ns() - time_start print('time0: ',time0) time_start = time.time_ns() for num_aggre_loc in range(2,num_aggre+1): slide_window.aggregate_dem() time_array[i,0] = time.time_ns() - time_start time_start = time.time_ns() slide_window.dem_slope() time_array[i,1] = time.time_ns() - time_start time_start = time.time_ns() slide_window.dem_profile() time_array[i,2] = time.time_ns() - time_start time_start = time.time_ns() slide_window.dem_tangential() time_array[i,3] = time.time_ns() - time_start time_start = time.time_ns() i += 1 print('============================================================') print('Aggregation [from w=2 to w=4, w=4 to w=8, w=8 to w=16, w=16 to w=32, and w=32 to w=64]') print(time_array[:,0]) print() print('slope [w=4, w=8, w=16, w=32, w=64]') print(time_array[:,1]) print() print('profile [w=4, w=8, w=16, w=32, w=64]') print(time_array[:,2]) print() print('tangential [w=4, w=8, w=16, w=32, w=64]') print(time_array[:,3]) print('============================================================') return time_array def remove_frame_iart(self,arr,w): shift = int(w/2) out_array = np.empty((arr.shape[0]-w+1,arr.shape[1]-w+1)) height = out_array.shape[0] width = out_array.shape[1] for j in range(height): for i in range(width): out_array[j,i] = arr[j+shift,i+shift] return out_array def plot_differences(self,fn_trunc,fn_trunc_analytical): base_name = os.path.basename(fn_trunc).split('.')[0] quant_min = 0.1 quant_max = 0.9 for analysis in ('_slope','_profile','_tangential'): for num_agg_loc in range (2,self.num_aggre+1): w = int(2**num_agg_loc) file_name = self.img_dir+base_name+analysis+'_w='+str(w)+'.tif' with rasterio.open(file_name) as img: array_0 = img.read(1) file_name_analytical = self.img_dir+base_name+analysis+'.tif' with rasterio.open(file_name_analytical) as img: array_1 = self.remove_frame_iart(img.read(1),w) plt.figure() array_diff = array_0-array_1 low = np.quantile(array_diff,quant_min) array_diff[array_diff < low] = low high = np.quantile(array_diff,quant_max) array_diff[array_diff > high] = high shift = int(round(array_diff.shape[0]/50)) plt.text(0,-4*shift,'Difference from analytical for '+file_name) plt.text(0,-shift,'min: '+str(round(np.amin(array_diff),3))+' max: '+str(round(np.amax(array_diff),3))) plt.imshow(array_diff,'gray_r')
from ssd import SSD300 from utils.prior_box_creator import PriorBoxCreator from image_generator import ImageGenerator num_classes = 21 model = SSD300() image_shape = model.input_shape[1:] box_creator = PriorBoxCreator(model) prior_boxes = box_creator.create_boxes() root_prefix = '../datasets/VOCdevkit/VOC2007/' ground_data_prefix = root_prefix + 'Annotations/' image_prefix = root_prefix + 'JPEGImages/' ground_truth_manager = XMLParser(ground_data_prefix, background_id=None) ground_truth_data = ground_truth_manager.get_data() prior_boxes = flatten_prior_boxes(prior_boxes) prior_boxes = add_variances(prior_boxes) print('WTF') bbox_util = BBoxUtility(num_classes, prior_boxes) result = bbox_util.assign_boxes(ground_truth_data['000007.jpg']) train_keys, val_keys = split_data(ground_truth_data, training_ratio=.8) image_generator = ImageGenerator(ground_truth_data, bbox_util, 10, (300, 300), train_keys, val_keys, image_prefix) data = next(image_generator.flow(mode='train')) # test the differences here between you bbox_util # why can't you train with this ?
def train(sgru_model, loss_func, optim_func, image_rgb_real, args): # Join the log directory with the experiment name output_dir = os.path.join(args.output_dir, args.name) vgg_ckpt = os.path.join(args.data_dir, 'vgg_19.ckpt') # Load VGG variables vgg_init_fn = slim.assign_from_checkpoint_fn( vgg_ckpt, slim.get_model_variables('vgg_19')) # Add an op to initialize the variables. init_op = tf.global_variables_initializer() # Tell tensorflow not to hog all gpu memory and to multithread tf_config = tf.ConfigProto(inter_op_parallelism_threads=args.num_cpus, intra_op_parallelism_threads=args.num_cpus) tf_config.gpu_options.allow_growth = True with tf.Session(config=tf_config) as sess: # Summary operations for tensorboard summary_op = tf.summary.merge_all() writer = tf.summary.FileWriter(output_dir, graph=sess.graph) # Initialize all variables sess.run(init_op) # Initialize VGG variables (these were reset during global initialization) vgg_init_fn(sess) losses = [] image_dir = os.path.join(args.data_dir, 'images') image_generator = ImageGenerator(image_dir, args.num_cpus) image_bw_op, image_rgb_op = image_generator.load_images() for epoch in range(args.epochs): for image_num in range(image_generator.num_images): image_bw, image_rgb = sess.run([image_bw_op, image_rgb_op]) feed_dict = { sgru_model.image_bw: image_bw, image_rgb_real: image_rgb } out_list = [ sgru_model.images_rgb_fake, loss_func, optim_func, summary_op ] images_rgb_fake_out, loss, _, summary = sess.run( out_list, feed_dict=feed_dict) # Report to tensorboard all the summaries at the current timestep writer.add_summary( summary, epoch * image_generator.num_images + image_num) print('Epoch {}, image number: {}, loss: {}'.format( epoch, image_num, loss)) losses.append(loss) if image_num % args.save_every == 0: image_dir = os.path.join(output_dir, 'images') if not os.path.isdir(image_dir): os.mkdir(image_dir) image_fname = os.path.join( image_dir, '{}_{}.jpg'.format(epoch, image_num)) save_images(image_fname, images_rgb_fake_out, image_rgb, image_bw) sgru_model.save(os.path.join(output_dir, 'model.ckpt'))
def __init__(self): self.img_generator = ImageGenerator()
'min_size': 168.0, 'max_size': 222.0, 'aspect_ratios': [1.0, 1.0, 2.0, 1 / 2.0, 3.0, 1 / 3.0] }, { 'layer_width': 3, 'layer_height': 3, 'num_prior': 6, 'min_size': 222.0, 'max_size': 276.0, 'aspect_ratios': [1.0, 1.0, 2.0, 1 / 2.0, 3.0, 1 / 3.0] }, { 'layer_width': 1, 'layer_height': 1, 'num_prior': 6, 'min_size': 276.0, 'max_size': 330.0, 'aspect_ratios': [1.0, 1.0, 2.0, 1 / 2.0, 3.0, 1 / 3.0] }, ] variances = [0.1, 0.1, 0.2, 0.2] priors = create_prior_box(image_shape[0:2], box_configs, variances) num_classes = 21 bounding_box_utils = BoundingBoxUtility(num_classes, priors) data_path = '../datasets/VOCdevkit/VOC2007/' batch_size = 16 ground_truth_data = XML_preprocessor(data_path + 'Annotations/').data image_generator = ImageGenerator(ground_truth_data, bounding_box_utils, batch_size, data_path + 'JPEGImages')
def _set_object_stats_processor_in_image_renderer(self): if type(ImageGenerator()) in self._element_renderers: self._element_renderers[type( ImageGenerator())].set_object_stats_processor( self.object_stats_processor)
# update the image TODO could have been done better self.update_image() def update_image(self) -> None: self.imageGenerator.generate() # update the message to send daily def update_message(self) -> None: self.messageGenerator.update() self.message = messageGenerator.get_message() # start the bot def run(self) -> int: self.logger.info("Polling BOT.") self.updater.start_polling() # Run the BOT until you press Ctrl-C or the process receives SIGINT, # SIGTERM or SIGABRT. This should be used most of the time, since # start_polling() is non-blocking and will stop the BOT gracefully. self.updater.idle() return 0 if __name__ == "__main__": TOKEN = get_token() messageGenerator = MessageGenerator() imageGenerator = ImageGenerator() BOT = Bot(TOKEN, messageGenerator, imageGenerator) BOT.run()
def inference(dnn_daemon, img_nums, model_names, n_img_to_infer=5): """ Allows to do inference using a list of images and models. """ # Check all models are available for model in model_names: if not model_available(dnn_daemon, model): print("ERROR: Model", model, "not availale. Exiting.") sys.exit() # Initialise an image generator img_dir = 'images/val/images/' img_class_map_file = 'images/val/val.txt' class_file = 'images/val/synset_words.txt' image_generator = ImageGenerator(img_dir, img_class_map_file, class_file) # Get a path and label for each of our images img_paths = list() img_labels = list() for img in img_nums: path, label = image_generator.get_image_data(img) img_paths.append(path) img_labels.append(label) # Infer each image with each model, get the results # results: dict, mapping (img_num, model) to (inference_times, prediciton) print("Running inference on Jetson...") img_model_to_results = dict() img_model_to_img = [] img_model_to_models = [] img_model_to_inference = [] img_model_to_prediction = [] img_model_to_results = [] if(len(model_names) is 0): print("Any model was selected!!!") return img_model_to_img, img_model_to_models, img_model_to_results percentage_of_each_execution=100/(len(img_paths)*len(model_names)) counter=0 first_time=0 for img_num, path in enumerate(img_paths): img_model_to_inference = [] img_model_to_img.append("Image " + `img_num`) for model in model_names: results = dnn_daemon.inference(model, [path], 1) inference_time, prediction_vals, prediction_classes = results inference_time = inference_time[0] ordered_prediction = convert_prediction(prediction_vals[0], prediction_classes[0], image_generator.class_names) #img_model_to_results[(img_num, model)] = (inference_time, ordered_prediction) if first_time is 0: img_model_to_models.append(model) img_model_to_inference.append(inference_time) #img_model_to_prediction.append(ordered_prediction) counter=counter+1 print(percentage_of_each_execution*counter, "%\n") img_model_to_results.append(img_model_to_inference) first_time=first_time+1 #print("All the images has been inferenced! ") return img_model_to_img, img_model_to_models, img_model_to_results
k = k + 1 # if k == len(cases): # print('finished') # break else: with open('annotation.txt', 'a') as f: f.write(",".join([name(parent(img)), img]) + '\n') print(img,' is validated') k = k + 1 if k == len(cases): k = 0 if __name__ == '__main__': parser = argparse.ArgumentParser(description='Annotate 3d files from 2d projected volumes') parser.add_argument('--root', default='samples') args = parser.parse_args() cases = set(os.listdir(args.root)) cases_processed = set([line.split(",")[0] for line in open("annotation.txt", "r").readlines()]) cases = cases.difference(cases_processed) cases = list(cases) k=0 for k in tqdm(range(len(cases)), total=len(cases)): dir = os.path.join(args.root, cases[k]) image_generator = ImageGenerator(dir) result, img = process_dir(dir, image_generator) assert result==__VALIDATE_IMG__ with open('annotation.txt', 'a') as f: image_generator.export(img, "samples/{name}.ply".format(name=name(parent(img)))) f.write(",".join([name(parent(img)), img]) + '\n')
ground_truth_manager = XMLParser(ground_data_prefix, background_id=None, class_names=classes) ground_truth_data = ground_truth_manager.get_data() print('Number of ground truth samples:', len(ground_truth_data.keys())) train_keys, validation_keys = split_data(ground_truth_data, training_ratio=.8) prior_box_manager = PriorBoxManager(prior_boxes, box_scale_factors=[.1, .1, .2, .2], num_classes=num_classes) image_generator = ImageGenerator(ground_truth_data, prior_box_manager, batch_size, image_shape[0:2], train_keys, validation_keys, image_prefix, vertical_flip_probability=0, horizontal_flip_probability=0.5) model_names = ('../trained_models/model_checkpoints/' + 'weights.{epoch:02d}-{val_loss:.2f}.hdf5') model_checkpoint = ModelCheckpoint(model_names, monitor='val_loss', verbose=1, save_best_only=False, save_weights_only=True) learning_rate_schedule = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10,
class TestImageGenerator(unittest.TestCase): def setUp(self): self.num_timestamps = 10 self.fov = math.pi / 2 self.image_width = 1000 self.object_universe = ObjectUniverse( num_timestamps=self.num_timestamps) self.camera = Camera() self.camera.set_actual_position((1,1)).\ set_fov_rad(self.fov).\ set_num_timestamps(self.num_timestamps).\ set_range(50000) for timestamp in range(self.camera.get_num_timestamps()): self.camera.set_state_of_pan_motor_angle_at_timestamp_rad( math.pi / 4, timestamp) self.cv = ComputerVision() self.image_generator = ImageGenerator(image_width=self.image_width) self.camera.set_computer_vision(self.cv).\ set_image_generator(self.image_generator) self.viewable_objects = [ StationaryObject((2, 1 + math.tan(math.pi / 8))), StationaryObject((1 + math.tan(math.pi / 8), 2)), StationaryObject((10000, 1.1)), StationaryObject((1.1, 10000)), ] self.object_universe.add_viewable_objects(self.viewable_objects) self.object_universe.add_camera(self.camera) self.d = self.image_width / (2 * math.tan(self.fov / 2)) self.theta = math.pi / 8 def test_d_calculation_for_image_generator(self): self.camera.get_image_generator( ).get_x_for_all_inview_objects_for_all_camera_time() self.assertEqual(self.d, self.image_generator.d) def test_theta_calculation_for_image_generator(self): self.camera.get_image_generator( ).get_x_for_all_inview_objects_for_all_camera_time() self.assertAlmostEqual( -self.theta, self.image_generator._get_theta_rad(self.viewable_objects[0], 0)) self.assertAlmostEqual( self.theta, self.image_generator._get_theta_rad(self.viewable_objects[1], 0)) def test_get_x_for_all_inview_objects_for_all_camera_time(self): r = self.image_generator.get_x_for_all_inview_objects_for_all_camera_time( ) for timestamp in range(self.camera.get_num_timestamps()): self.assertAlmostEqual(r[timestamp][self.viewable_objects[0]], -self.d * math.tan(math.pi / 8)) self.assertAlmostEqual(r[timestamp][self.viewable_objects[1]], self.d * math.tan(math.pi / 8)) def test_get_x_for_distant_objects_at_edge_of_view_remain_in_image_width( self): r = self.image_generator.get_x_for_all_inview_objects_for_all_camera_time( ) for obj in self.viewable_objects: x = r[0][obj] self.assertLess(abs(x), self.image_width / 2)
if args.destination is not None: np.savetxt(args.destination, depth, delimiter=",", fmt="%s") else: print("Playing camera feed. Press \'q\' to quit") while True: bgr, depth = depth_live_generator.generate() cv2.imshow("Video", bgr) cv2.imshow("Depth", depth) key = cv2.waitKey(1) if key == ord('c') and args.destination is not None: np.savetxt(args.destination, depth, delimiter=",", fmt="%s") if key == ord('q'): break elif args.generator == "ImageGenerator": image_generator = ImageGenerator(args.image) rgb, depth = image_generator.generate() print(rgb.shape) elif args.generator == "VideoLiveGenerator": video_live_generator = VideoLiveGenerator(1) rgb, depth = video_live_generator.generate() print(rgb.shape) if args.play: print("Playing camera feed. Press \'q\' to quit") while True: rgb, _ = video_live_generator.generate() cv2.imshow("Live video", cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)) key = cv2.waitKey(1) if key == ord('q'):
layer_scale, box_arg = 0, 780 box_coordinates = prior_boxes[layer_scale][box_arg, :, :] image_path = '../images/' image_key = '007040.jpg' box_creator.draw_boxes(image_path + image_key, box_coordinates) data_path = '../datasets/VOCdevkit/VOC2007/' ground_truths = XMLParser(data_path + 'Annotations/').get_data() prior_box_manager = PriorBoxAssigner(prior_boxes, ground_truths) assigned_boxes = prior_box_manager.assign_boxes() prior_box_manager.draw_assigned_boxes(image_path, image_shape[0:2], image_key) batch_size = 7 train_keys, validation_keys = split_data(assigned_boxes, training_ratio=.8) assigned_image_generator = ImageGenerator(assigned_boxes, batch_size, image_shape[0:2], train_keys, validation_keys, data_path + 'JPEGImages/') transformed_image = next(assigned_image_generator.flow(mode='demo'))[0] transformed_image = np.squeeze(transformed_image[0]).astype('uint8') original_image = read_image(data_path + 'JPEGImages/' + validation_keys[0]) original_image = resize_image(original_image, image_shape[0:2]) plt.figure(1) plt.subplot(121) plt.title('Original image') plt.imshow(original_image) plt.subplot(122) plt.title('Transformed image') plt.imshow(transformed_image) plt.show()
def add_image_generator_if_none(self): if self.image_generator is None: self.set_image_generator(ImageGenerator()) return self
training_split = .8 do_random_crop = False num_classes = 2 dataset_name = 'imdb' input_shape = (48, 48, 3) images_path = '../datasets/imdb_crop/' log_file_path = 'log_files/gender_training.log' trained_models_path = '../trained_models/gender_models/simple_CNN' # data loader data_loader = DataLoader(dataset_name) ground_truth_data = data_loader.get_data() train_keys, val_keys = split_data(ground_truth_data, training_split) image_generator = ImageGenerator(ground_truth_data, batch_size, input_shape[:2], train_keys, val_keys, None, path_prefix=images_path, vertical_flip_probability=0, do_random_crop=do_random_crop) # model parameters/compilation model = simple_CNN(input_shape, num_classes) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model.summary() # model callbacks csv_logger = CSVLogger(log_file_path, append=False) model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5' model_checkpoint = ModelCheckpoint(model_names, monitor='val_loss',