def load_frames(video_path="project_video.mp4", start_frame=None, end_frame=None): from moviepy.editor import VideoFileClip import cv2 from util import printProgressBar # The file referenced in clip1 is the original video before anything has been done to it input = VideoFileClip(video_path) #vid_clip = input.fl_image(process_image) len_frames = int(input.fps * input.duration) len_frames = len_frames if end_frame == None or end_frame > len_frames else end_frame i = 0 # Initial call to print 0% progress printProgressBar(0, len_frames, 'Loading frames') frames = [] for frame in input.iter_frames(): if start_frame == None or i > start_frame: frames.append(frame) # Update Progress Bar printProgressBar(i + 1, len_frames, 'Loading frames') if i - 1 >= len_frames: break i = i + 1 return frames, input.fps
def generateMetaData(pathToFeatureSet, fileName, saveDirectory, readDirectory='Data/Normalized Data'): #Generate label for meta data featureSet = loadFeatureSet(pathToFeatureSet) labels = getLables(featureSet) labels.append('AuthorName') #print(len(labels)) fw = open(saveDirectory + '/' + fileName + '.tsv', 'w', encoding='UTF-8') writeToFile(labels, fw, ' ') #For each of the Normalized Text get required feature value i, l = 0, 0 authorList = os.listdir(readDirectory) for author in authorList: fileList = os.listdir(readDirectory + '/' + author) l += len(fileList) printProgressBar(0, l, prefix='Progress:', suffix='Complete', length=50) for author in authorList: fileList = os.listdir(readDirectory + '/' + author) for fileName in fileList: fr = open(readDirectory + '/' + author + '/' + fileName, 'r', encoding='UTF-8') text = fr.read() #print('Author Name:', author, 'File Name:', fileName) featureValues = getFeatureValues(featureSet, text) featureValues.append(author) writeToFile(featureValues, fw, ' ') printProgressBar(i + 1, l, prefix='Progress:', suffix='Complete', length=50) i += 1
def feature_extract(image, i, size, param): """ Dada uma image, extrai hist, co-matrix e LBP features de acordo com param """ util.printProgressBar(i, size) features = [] for ch in range(3): ch_img = image[:, :, ch] ch_img = (ch_img / 8) ch_img = ch_img.astype(util.np.int8) if param[0]: hist = util.cv2.calcHist([image], [ch], None, [256], [0, 256]) features.extend(hist.flatten()) if param[1]: co_matrix = greycomatrix(ch_img, [5], [0], 32, symmetric=True, normed=True) features.extend(co_matrix.flatten()) if param[2]: features.extend(get_lbp_features(image[:, :, ch], 12, 4)) return util.np.array(features).ravel().flatten()
def birds_eye_frames(bin_frames, M, width, height, src): import cv2 import numpy as np from util import printProgressBar birds_eye_bin_frames = [] #birds_eye_frames = [] len_frames = len(frames) # Initial call to print 0% progress printProgressBar(0, len_frames, 'Birds eye frames') for i in range(len_frames): bin_frame = bin_frames[i] ### outcommented but used for debugging #frame = frames[i] # Draw red rectangle on frame to show src for transformation #pts = np.array(src, np.int32) #pts = pts.reshape((-1,1,2)) #cv2.polylines(frame,[pts],True,(255,0,0)) #birds_eye_frames.append(frame) # Use cv2.warpPerspective() to warp the image to a top-down view birds_eye_bin_frame = cv2.warpPerspective(bin_frame, M, (width, height)) birds_eye_bin_frames.append(birds_eye_bin_frame) #birds_eye_frame = cv2.warpPerspective(frame, M, (width, height)) #birds_eye_frames.append(birds_eye_frame) # Update Progress Bar printProgressBar(i + 1, len_frames, 'Birds eye frames') return birds_eye_bin_frames #, birds_eye_frames
def color_gradient_frames(frames, s_thresh=(125, 255), sx_thresh=(30, 100), sobel_kernel=3): import cv2 import numpy as np from util import printProgressBar combined_binaries = [] color_binaries = [] len_frames = len(frames) # Initial call to print 0% progress printProgressBar(0, len_frames, 'Pipeline frames') for i in range(len_frames): img = np.copy(frames[i]) # Convert to HLS colorspace hls = cv2.cvtColor(img, cv2.COLOR_BGR2HLS).astype(np.float) l_channel = hls[:, :, 1] s_channel = hls[:, :, 2] # Find the dark colors in the image to remove them from s and sx lower = np.array([0, 0, 0]) upper = np.array([50, 50, 100]) mask = cv2.inRange(img, lower, upper) black_binary = np.zeros_like(s_channel) black_binary[(mask > 0)] = 1 # Sobelx - takes the derivate in x, absolute value, then rescale sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0, ksize=sobel_kernel) abs_sobelx = np.absolute(sobelx) scaled_sobelx = np.uint8(255 * abs_sobelx / np.max(abs_sobelx)) # Threshold x gradient sxbinary = np.zeros_like(scaled_sobelx) sxbinary[(black_binary == 0) & (scaled_sobelx >= sx_thresh[0]) & (scaled_sobelx <= sx_thresh[1])] = 1 # Threshold color channel s_binary = np.zeros_like(s_channel) s_binary[(black_binary == 0) & (s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1 # If two of the three are activated, activate in the binary image combined_binary = np.zeros_like(sxbinary) combined_binary[(sxbinary == 1) | (s_binary == 1)] = 1 combined_binaries.append(combined_binary) color_binary = np.dstack( (np.zeros_like(sxbinary), sxbinary, s_binary)) * 255 color_binaries.append(color_binary) # Update Progress Bar printProgressBar(i + 1, len_frames, 'Pipeline frames') return combined_binaries, color_binaries
def etlMain(): # Find the oldest document inside MongoDB date = mongo.findOldest() # Determine how many documents we need to transfer numDocs = mysql.findOlder(date) transferedDocs = 0 doc = mysql.getFirstDoc(date) while doc != None: mongo.insertDoc(doc) doc = mysql.getNextDoc() transferedDocs += 1 util.printProgressBar(transferedDocs, numDocs)
def undistort_frames(frames): import cv2 from util import printProgressBar undistorted_frames = [] len_frames = len(frames) # Initial call to print 0% progress printProgressBar(0, len_frames, 'Undistort frames') for i in range(len_frames): frame = frames[i] undistorted_frames.append(cv2.undistort(frame, mtx, dist, None, mtx)) # Update Progress Bar printProgressBar(i + 1, len_frames, 'Undistort frames') return undistorted_frames
def get_features_list(name, img_paths, orient=9, pix_per_cell=8, cell_per_block=2, vis=False, cspace='RGB', spatial_size=(32, 32), hist_bins=32, hist_range=(0, 256), hog_channel='ALL'): features = [] img_hogs = [] len_img_paths = len(img_paths) util.printProgressBar(0, len_img_paths, name) for i in range(len_img_paths): img_path = img_paths[i] img = mpimg.imread(img_path) if vis == True: img_features, img_hog = get_features(img, orient=orient, pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, vis=vis, cspace=cspace, spatial_size=spatial_size, hist_bins=hist_bins, hist_range=hist_range, hog_channel=hog_channel) img_hogs.append(img_hog) else: img_features = get_features(img, orient=orient, pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, vis=vis, cspace=cspace, spatial_size=spatial_size, hist_bins=hist_bins, hist_range=hist_range, hog_channel=hog_channel) features.append(img_features) util.printProgressBar(i + 1, len_img_paths, name) if vis == True: return features, img_hogs return features
def hard_negative_mine(self, folder, epochs): # this function is used to train svm by hard negative mining #initializing svm with default weights of positive sample means self.initialize_svm(folder) util.printProgressBar(0, epochs, prefix='Starting', suffix='complete') for epoch in range(epochs): # STEP 1: Mine for negative samples for i, img in enumerate(self.imgs): boxes, scores = self.edgebox.getproposals(img) if not isinstance( boxes, tuple): #because if boxes is tuple, its empty boxes = util.cv2_to_numpy(boxes) boxes, scores = self.filter_negsamples(boxes, scores, i) if (boxes.shape[0] > self.n): #only do it if more than n samples boxes, scores, _ = util.topn(boxes, scores, self.n) if (boxes.shape[0] > 0): #only do it some boxes survive the journey boxes, scores, _ = util.nms(boxes, scores, self.overlap_thresh) self.neg_rects.append(boxes.tolist()) # else: # print("no boxes detected!") # STEP 2: Add those samples into dataset self.populate_data(True) self.populate_data(False) # STEP 3: Prepare data X, y = self.prepare_data() # STEP 4: train the svm self.train_svm(X, y) util.printProgressBar(epoch + 1, epochs, prefix='Epoch %d' % (epoch + 1), suffix='complete') print('Training successfully finished after %d epochs' % epochs)
for fil in onlyfiles: # cargamos el archivo npy = np.load(os.path.join(dataset_path, str(fil)), allow_pickle=True) # separamos datos y etiquetas img, label = npy if label[0] < min_value: min_value = label[0] if label[0] > max_value: max_value = label[0] i = i + 1 printProgressBar(i, len(onlyfiles), prefix='Buscando maximo y minimo:', suffix='Completado (' + C + str(psutil.virtual_memory()[2]) + B + '% RAM)', length=100, color=45) print("\nMaximo: " + C + str(max_value) + B) print("Minimo: " + C + str(min_value) + B + "\n") #lista para guardar labels label_list = [] #para cada .npy i = 0 for fil in onlyfiles: # cargamos el archivo npy = np.load(os.path.join(dataset_path, str(fil)), allow_pickle=True)
targetv = (torch.from_numpy(np.argmax(big_target, axis = 1)).long()).cuda() trainingv, valv = torch.split(trainingv, int(trainingv.size()[0] * (1 - val_split))) trainingv_sv, valv_sv = torch.split(trainingv_sv, int(trainingv_sv.size()[0] * (1 - val_split))) targetv, val_targetv = torch.split(targetv, int(targetv.size()[0] * (1 - val_split))) samples_random = np.random.choice(range(len(trainingv)), valv.size()[0]/100) for j in range(0, trainingv.size()[0], batch_size): optimizer.zero_grad() out = gnn(trainingv[j:j + batch_size].cuda(), trainingv_sv[j:j + batch_size].cuda()) l = loss(out, targetv[j:j + batch_size].cuda()) l.backward() optimizer.step() loss_string = "Loss: %s" % "{0:.5f}".format(l.item()) util.printProgressBar(j + batch_size, trainingv.size()[0], prefix = "%s [%s/%s] " % (loss_string, j + batch_size, trainingv.size()[0]), length = 20) del trainingv, training_sv, targetv, valv, valv_sv, val_targetv for sub_X,sub_Y in data.generate_data(): training = sub_X[2] training_sv = sub_X[3] target = sub_Y[0] # Training Set n_targets = target.shape[1] samples = [get_sample_train(training, training_sv, target, i) for i in range(n_targets)] trainings = [i[0] for i in samples] trainings_sv = [i[1] for i in samples]
def getDailyAvgPlot(): num_images = 0 # contamos las imagenes totales for json_number, json_name in enumerate( glob.glob(os.path.join(saving_path, '*.json'))): f = open(json_name) j = json.load(f) i = 0 for key in j: num_images = num_images + 1 i += 1 print("Numero del Json: " + V + str(json_number) + B) print("Imagenes en el Json: " + V + str(i) + B, end='\n\n') print(attr(4) + "Imagenes Totales:" + attr(0) + " " + V + str(num_images) + B, end='\n\n') i2 = 0 label_list = [] num_lamb = 0 num_no_lamb = 0 num_fail = 0 daily_weight = {} one_for_day_done = False asker = ClasiLamb_2_1_ModelAsker() asker.loadModel(os.path.join(parent_folder, lamb_model_path)) # para todos los .json de labels for json_number, json_name in enumerate( glob.glob(os.path.join(saving_path, '*.json'))): f = open(json_name) j = json.load(f) json_key_name = json_name[json_name.rfind("/") + 1:json_name.rfind(".") - 1] daily_weight[json_key_name] = [] # estructuramos las imagenes del json for key in j: # Control para recoger solo un peso por dia (debug de plot) if just_one_for_day: if one_for_day_done == False: one_for_day_done = True else: one_for_day_done = False break # Comprobacion de maximo de imagenes. -1 para que no haya limite if max_out_img_num >= 0: if num_lamb == max_out_img_num: break # cargamos cada imagen img_path = raw_dataset_path + str( j[key]["path_depth_default_image"]) img = cv2.imread(img_path, flags=cv2.IMREAD_ANYDEPTH) # comprobamos si la imagen existe y ha sido cargada correctamente (si no, saltamos a la siguiente) try: if len(img) == 0: print("[!] Error al cargar la imagen: " + V + str(img_path) + B) exit() except: num_fail += 1 i2 += 1 continue # preparamos la imagen para ser normalizada posteriormente (todo pixel que supere OVERRIDE_MAXVALUE se queda en OVERRIDE_MAXVALUE) if OVERRIDE_MAXVALUE != -1: img = np.clip(img, None, OVERRIDE_MAXVALUE) """ # le hacemos crop x = 38 y = 102 h = 230 w = 510 img = img[y:y + h, x:x + w] """ # invertimos la imagen # if OVERRIDE_MAXVALUE != -1: # img = OVERRIDE_MAXVALUE-img # Normalizamos #img = img/OVERRIDE_MAXVALUE # Preguntamos a la red si la imagen es correcta # Si es correcta, la red sacara un 0, si no, sacara un 1 res, val = asker.ask(img) if res == 1.0: is_correct_lamb = False one_for_day_done = False elif res == 0.0: is_correct_lamb = True # Si la imagen es correcta guardamos la imagen y la etiqueta, si no, descartamos if is_correct_lamb: # Acumulamos el peso en su dia, en funcion del nombre del json daily_weight[json_key_name].append(float(j[key]["weight"])) num_lamb += 1 else: num_no_lamb += 1 i2 += 1 printProgressBar(i2, num_images, prefix='Estructurando JSON ' + str(json_number) + ':', suffix='Completado', length=50, color=33) # Procesamos el json en dos listas para pasarselo a la plot x_values = [str(key) for key in daily_weight.keys()] x_values.sort(key=lambda v: datetime.strptime(v, '%Y-%m-%d'), reverse=False) y_values = [] for k in x_values: try: y_values.append(mean(daily_weight[k])) except: y_values.append(0) # Montamos la plot color_list = [ "deepskyblue", "aquamarine", "limegreen", "yellow", "gold", "darkorange", "lightcoral", "orchid", "mediumpurple" ] num_lambs = 1 fig, axs = plt.subplots(num_lambs) i = 0 bars = axs.bar(x_values, y_values, color=color_list[2]) autolabel(bars, axs) plt.sca(axs) plt.xticks(rotation=-40, ha="left", size=8) plt.xticks(x_values) plt.ylabel("Peso [Kg]") plt.title("Peso Medio Diario", size=20) plt.show() y_values = [] for k in x_values: y_values.append(len(daily_weight[k])) # Montamos la plot de cantidades color_list = [ "deepskyblue", "aquamarine", "limegreen", "yellow", "gold", "darkorange", "lightcoral", "orchid", "mediumpurple" ] num_lambs = 1 fig, axs = plt.subplots(num_lambs) i = 0 bars = axs.bar(x_values, y_values, color=color_list[1]) autolabel(bars, axs) plt.sca(axs) plt.xticks(rotation=-40, ha="left", size=8) plt.xticks(x_values) plt.ylabel("Numero de Imagenes") plt.title("Numero de Imagenes Diarias", size=20) plt.show()
def getDailyAvgMultiPlot(): num_images = 0 # contamos las imagenes totales for json_number, json_name in enumerate( glob.glob(os.path.join(saving_path, '*.json'))): f = open(json_name) j = json.load(f) i = 0 for key in j: num_images = num_images + 1 i += 1 print("Numero del Json: " + V + str(json_number) + B) print("Imagenes en el Json: " + V + str(i) + B, end='\n\n') print(attr(4) + "Imagenes Totales:" + attr(0) + " " + V + str(num_images) + B, end='\n\n') i2 = 0 label_list = [] num_lamb = 0 num_no_lamb = 0 num_fail = 0 daily_weight = {} one_for_day_done = False asker = ClasiLamb_2_1_ModelAsker() asker.loadModel(os.path.join(parent_folder, lamb_model_path)) # para todos los .json de labels for json_number, json_name in enumerate( glob.glob(os.path.join(saving_path, '*.json'))): f = open(json_name) j = json.load(f) json_key_name = json_name[json_name.rfind("/") + 1:json_name.rfind(".") - 1] daily_weight[json_key_name] = [] # estructuramos las imagenes del json for key in j: # Control para recoger solo un peso por dia (debug de plot) if just_one_for_day: if one_for_day_done == False: one_for_day_done = True else: one_for_day_done = False break # Comprobacion de maximo de imagenes. -1 para que no haya limite if max_out_img_num >= 0: if num_lamb == max_out_img_num: break # cargamos cada imagen img_path = raw_dataset_path + str( j[key]["path_depth_default_image"]) img = cv2.imread(img_path, flags=cv2.IMREAD_ANYDEPTH) # comprobamos si la imagen existe y ha sido cargada correctamente (si no, saltamos a la siguiente) try: if len(img) == 0: print("[!] Error al cargar la imagen: " + V + str(img_path) + B) exit() except: num_fail += 1 i2 += 1 continue # preparamos la imagen para ser normalizada posteriormente (todo pixel que supere OVERRIDE_MAXVALUE se queda en OVERRIDE_MAXVALUE) if OVERRIDE_MAXVALUE != -1: img = np.clip(img, None, OVERRIDE_MAXVALUE) """ # le hacemos crop x = 38 y = 102 h = 230 w = 510 img = img[y:y + h, x:x + w] """ # invertimos la imagen # if OVERRIDE_MAXVALUE != -1: # img = OVERRIDE_MAXVALUE-img # Normalizamos #img = img/OVERRIDE_MAXVALUE # Preguntamos a la red si la imagen es correcta # Si es correcta, la red sacara un 0, si no, sacara un 1 res, val = asker.ask(img) if res == 1.0: is_correct_lamb = False one_for_day_done = False elif res == 0.0: is_correct_lamb = True # Si la imagen es correcta guardamos la imagen y la etiqueta, si no, descartamos if is_correct_lamb: # Acumulamos el peso en su dia, en funcion del nombre del json daily_weight[json_key_name].append(float(j[key]["weight"])) num_lamb += 1 else: num_no_lamb += 1 i2 += 1 printProgressBar(i2, num_images, prefix='Estructurando JSON ' + str(json_number) + ':', suffix='Completado', length=50, color=33) # Procesamos el json en dos listas para pasarselo a la plot # Pasamos de YYYY-MM-DD a DD-MM-YYYY x_values = [str(key) for key in daily_weight.keys()] x_values.sort(key=lambda v: datetime.strptime(v, '%Y-%m-%d'), reverse=False) y_values = [] for k in x_values: try: y_values.append(mean(daily_weight[k])) except: y_values.append(0) # Cortamos las listas en trocitos que correspondan a los periodos de tiempo seguidos long_x_list = [ datetime.strptime(x, '%Y-%m-%d').strftime('%d-%m-%Y') for x in x_values ] long_y_list = y_values past_date = None all_json = {"0": {"x": [], "y": []}} current_set_int_key = 0 for i in range(len(long_x_list)): tandas_diferentes = False current_date = long_x_list[i] # Obtenemos los datos de fecha y comparamos if past_date == None: # Primera fecha, no comprobamos nada tandas_diferentes = False else: # Comparamos fechas, as ver si se difieren en diff_days dias time_diff = datetime.strptime(current_date, '%d-%m-%Y') - datetime.strptime( past_date, '%d-%m-%Y') if time_diff.days >= 10: tandas_diferentes = True else: tandas_diferentes = False if tandas_diferentes: # Si este peso es de tanda diferente, terminamos esta # tanda y preparamos la siguiente current_set_int_key += 1 all_json[str(current_set_int_key)] = {"x": [], "y": []} # Acumulamos un dia mas y preparamos el siguiente dia all_json[str(current_set_int_key)]["x"].append(current_date) all_json[str(current_set_int_key)]["y"].append(long_y_list[i]) past_date = current_date # Montamos la plot de cantidades color_list = [ "deepskyblue", "aquamarine", "limegreen", "yellow", "gold", "darkorange", "lightcoral", "orchid", "mediumpurple" ] num_lambs = len(all_json) fig, axs = plt.subplots(num_lambs) for i, key in enumerate(all_json): x_values = all_json[key]["x"] y_values = all_json[key]["y"] key_number = int(str(key)) bars = axs[i].bar(x_values, y_values, color=color_list[i]) autolabel(bars, axs[i]) plt.sca(axs[i]) plt.xticks(rotation=-40, ha="left", size=8) plt.ylabel("Peso [Kg]") plt.title("Tanda de pesos " + str(key), size=20) plt.show() fig.set_size_inches((20, 10 * num_lambs)) fig.savefig("plot.png", dpi=300)
def find_draw_lanes(bin_frames, frames, M): from util import printProgressBar import numpy as np import cv2 from line import Line found_lanes_frames = [] drawed_lanes_frames = [] # Left and right line left_line = Line() right_line = Line() # Inverted M to transform image backwards Minv = np.linalg.inv(M) len_bin_frames = len(bin_frames) # Initial call to print 0% progress printProgressBar(0, len_bin_frames, 'Finding & drawing lane frames') for i in range(len_bin_frames): bin_frame = bin_frames[i] frame = frames[i] # Assuming you have created a warped binary image called "bin_frame" # Take a histogram of the bottom half of the image histogram = np.sum(bin_frame[int(bin_frame.shape[0] / 2):, :], axis=0) # Create an output image to draw on and visualize the result out_img = np.dstack((bin_frame, bin_frame, bin_frame)) * 255 # Find the peak of the left and right halves of the histogram # These will be the starting point for the left and right lines midpoint = np.int(histogram.shape[0] * 3 / 4) left_line.all_x_base = np.argmax(histogram[:midpoint]) rightx_base = np.argmax(histogram[midpoint:]) + midpoint # Choose the number of sliding windows nwindows = 9 # Set height of windows window_height = np.int(bin_frame.shape[0] / nwindows) # Identify the x and y positions of all nonzero pixels in the image nonzero = bin_frame.nonzero() nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) # Current positions to be updated for each window left_line.all_x_current = left_line.all_x_base rightx_current = rightx_base # Set the width of the windows +/- margin margin = 100 # Set minimum number of pixels found to recenter window minpix = 50 # Create empty lists to receive left and right lane pixel indices left_lane_inds = [] right_lane_inds = [] # Step through the windows one by one for window in range(nwindows): # Identify window boundaries in x and y (and right and left) win_y_low = bin_frame.shape[0] - (window + 1) * window_height win_y_high = bin_frame.shape[0] - window * window_height win_xleft_low = left_line.all_x_current - margin win_xleft_high = left_line.all_x_current + margin win_xright_low = rightx_current - margin win_xright_high = rightx_current + margin # Draw the windows on the visualization image cv2.rectangle(out_img, (win_xleft_low, win_y_low), (win_xleft_high, win_y_high), (0, 255, 0), 2) cv2.rectangle(out_img, (win_xright_low, win_y_low), (win_xright_high, win_y_high), (0, 255, 0), 2) # Identify the nonzero pixels in x and y within the window good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0] good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0] # Append these indices to the lists left_lane_inds.append(good_left_inds) right_lane_inds.append(good_right_inds) # If you found > minpix pixels, recenter next window on their mean position if len(good_left_inds) > minpix: left_line.all_x_current = np.int( np.mean(nonzerox[good_left_inds])) if len(good_right_inds) > minpix: rightx_current = np.int(np.mean(nonzerox[good_right_inds])) # Concatenate the arrays of indices left_lane_inds = np.concatenate(left_lane_inds) right_lane_inds = np.concatenate(right_lane_inds) # Extract left and right line pixel positions left_line.all_x = nonzerox[left_lane_inds] left_line.all_y = nonzeroy[left_lane_inds] rightx = nonzerox[right_lane_inds] righty = nonzeroy[right_lane_inds] # Fit a second order polynomial to each left_fit = np.polyfit(left_line.all_y, left_line.all_x, 2) right_fit = np.polyfit(righty, rightx, 2) ploty = np.linspace(0, bin_frame.shape[0] - 1, bin_frame.shape[0]) left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2] left_line.addXfitted(left_fitx) right_fitx = right_fit[0] * ploty**2 + right_fit[ 1] * ploty + right_fit[2] right_line.addXfitted(right_fitx) out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0] out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255] # Draw left line for x, y in zip(left_line.best_fit, ploty): y = int(y) x = int(x) if (x >= 0 and x < 1280 and y >= 0 and y < 720): out_img[y, x] = [255, 255, 0] # Draw left line for x, y in zip(right_line.best_fit, ploty): y = int(y) x = int(x) if (x >= 0 and x < 1280 and y >= 0 and y < 720): out_img[y, x] = [255, 255, 0] # Define y-value where we want radius of curvature y_eval = np.max(ploty) # Define conversions in x and y from pixels space to meters ym_per_pix = 30 / 720 # meters per pixel in y dimension xm_per_pix = 3.7 / 700 # meters per pixel in x dimension # Fit new polynomials to x,y in world space left_fit_cr = np.polyfit(left_line.all_y * ym_per_pix, left_line.all_x * xm_per_pix, 2) right_fit_cr = np.polyfit(righty * ym_per_pix, rightx * xm_per_pix, 2) # Calculate the new radii of curvature left_line.radius_of_curvature = ( (1 + (2 * left_fit_cr[0] * y_eval * ym_per_pix + left_fit_cr[1])**2)** 1.5) / np.absolute(2 * left_fit_cr[0]) right_line.radius_of_curvature = ( (1 + (2 * right_fit_cr[0] * y_eval * ym_per_pix + right_fit_cr[1])**2) **1.5) / np.absolute(2 * right_fit_cr[0]) found_lanes_frames.append(out_img) # Create an image to draw the lines on warp_zero = np.zeros_like(frame).astype(np.uint8) color_warp = np.dstack((warp_zero, warp_zero, warp_zero)) # Recast the x and y points into usable format for cv2.fillPoly() pts_left = np.array( [np.transpose(np.vstack([left_line.best_fit, ploty]))]) pts_right = np.array( [np.flipud(np.transpose(np.vstack([right_line.best_fit, ploty])))]) pts = np.hstack((pts_left, pts_right)) # Draw the lane onto the warped blank image cv2.fillPoly(warp_zero, np.int_([pts]), (0, 255, 0)) # Warp the blank back to original image space using inverse perspective matrix (Minv) newwarp = cv2.warpPerspective(warp_zero, Minv, (frame.shape[1], frame.shape[0])) # Combine the result with the original image result = cv2.addWeighted(frame, 1, newwarp, 0.3, 0) # Draw our radius of curvature is in meters on the result cv2.putText( result, 'Left curverad: {:5d}m'.format( np.int(left_line.radius_of_curvature)), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 165, 0), 2, cv2.LINE_AA) cv2.putText( result, 'Right curverad: {:5d}m'.format( np.int(right_line.radius_of_curvature)), (10, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 165, 0), 2, cv2.LINE_AA) cv2.putText( result, 'Diff. curverad: {:5d}m'.format( np.abs( np.int(left_line.radius_of_curvature) - np.int(right_line.radius_of_curvature))), (10, 110), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 165, 0), 2, cv2.LINE_AA) height = frame.shape[0] width = frame.shape[1] car_position = width / 2 l_fit_x_int = left_fit[0] * height**2 + left_fit[ 1] * height + left_fit[2] r_fit_x_int = right_fit[0] * height**2 + right_fit[ 1] * height + right_fit[2] lane_center_position = (r_fit_x_int + l_fit_x_int) / 2 center_dist = (car_position - lane_center_position) * xm_per_pix if center_dist < 0: cv2.putText( result, 'Vehicle is {0:.2f}m left of center'.format( np.abs(center_dist)), (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 165, 0), 2, cv2.LINE_AA) if center_dist > 0: cv2.putText( result, 'Vehicle is {0:.2f}m right of center'.format( np.abs(center_dist)), (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 165, 0), 2, cv2.LINE_AA) drawed_lanes_frames.append(result) # Update Progress Bar printProgressBar(i + 1, len_bin_frames, 'Finding & drawing lane frames') return found_lanes_frames, drawed_lanes_frames
env = gym.make('Taxi-v3') QLearner = QLearningAgent.QLearningAgent(env.observation_space, env.action_space, epsilon=0.3, alpha=0.2, discount=0.9) num_episodes = 1000 for episode in range(0, num_episodes): observation = env.reset() while True: action = QLearner.getAction(observation) next_observation, reward, done, info = env.step(action) QLearner.update(observation, action, next_observation, reward) observation = next_observation if done: break if episode % (num_episodes / 100) == 0: util.printProgressBar(episode, num_episodes) print("DONE TRAINING") for episode in range(0, 4): observation = env.reset() env.render() for i in range(0, 1000): action = QLearner.getAction(observation, False) next_observation, reward, done, info = env.step(action) env.render() observation = next_observation if done: print("Success!") print("") print("-------------------------------------------")
def calc_distortion(camera_cal_img_path='camera_cal', camera_cal_img_file_type='jpg', nx=9, ny=6, debug=False, write_undistorted_output=False): import numpy as np import glob import cv2 from util import printProgressBar # Storing image path and image in a map together imagesMap = {} # Storing object points and image points obj_points = [] img_points = [] # Prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(8,5,0) objp = np.zeros((nx * ny, 3), np.float32) objp[:, :2] = np.mgrid[0:nx, 0:ny].T.reshape(-1, 2) img_paths = glob.glob(camera_cal_img_path + '/*.' + camera_cal_img_file_type) len_img_paths = len(img_paths) printProgressBar(0, len_img_paths, 'Calculate camera distortion') # Looping over each image path in provided path for camera calculation images for i in range(len_img_paths): img_path = img_paths[i] if (debug): print("Reading chessboard image: {}".format(img_path)) img = cv2.imread(img_path) imagesMap[img_path] = img gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None) if ret == True: if (debug): print("Found chessboard corners for {}".format(img_path)) obj_points.append(objp) img_points.append(corners) cv2.drawChessboardCorners(img, (nx, ny), corners, ret) printProgressBar(i + 1, len_img_paths, 'Calculate camera distortion') # Camera calibration ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, gray.shape[::-1], None, None) # Output undistorted images to output_images folder if (write_undistorted_output): for img_path, img in imagesMap.items(): new_img_path = img_path.replace(camera_cal_img_path, 'output_images') if (debug): print("Writing undistorted chessboard image: {}".format( new_img_path)) undst_img = cv2.undistort(img, mtx, dist, None, mtx) cv2.imwrite(new_img_path, undst_img) return mtx, dist
def detect_vehicles(svc, frames, windows_list, orient, pix_per_cell, cell_per_block, cspace, spatial_size, hist_bins, hist_range): enhanced_frames = [] len_frames = len(frames) util.printProgressBar(0, len_frames, 'Detecting vehicles') for i in range(len_frames): frame = frames[i] vehicle_windows = [] for j in range(len(windows_list)): for k in range(len(windows_list[j])): window = windows_list[j][k] #(startx, starty), (endx, endy) startx = window[0][0] starty = window[0][1] endx = window[1][0] endy = window[1][1] diffx = endx - startx diffy = endy - starty diffxy = min(diffx, diffy) window_frame = frame[starty:starty + diffxy, startx:startx + diffxy] window_frame_resize = cv2.resize(window_frame, (64, 64)) window_frame_resize_features = features.get_features( window_frame_resize, orient=orient, pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, cspace=cspace, spatial_size=spatial_size, hist_bins=hist_bins, hist_range=hist_range) predictions = svc.predict([window_frame_resize_features]) for prediction in predictions: if prediction == 1: vehicle_windows.append(window) threshold = 1 heatmap, heat_windows = generate_heatmap(frame, vehicle_windows, threshold) for car in cars: car.not_found_count += 1 veh_windows = [] for heat_window in heat_windows: left = heat_window[0][0] top = heat_window[0][1] right = heat_window[1][0] bottom = heat_window[1][1] center_h = left + int((right - left) / 2) center_v = top + int((bottom - top) / 2) center = (center_h, center_v) car_exists = False for car in cars: if car.is_fit(center): car.add_center(center) if car.found_count >= COUNT_FRAMES_DRAW_CAR: veh_windows.append(car.avg_window) car_exists = True break if not car_exists: car = Car() cars.append(car) car.add_center(center) for car in cars: if car.not_found_count >= COUNT_FRAMES_DELETE_CARS: cars.remove(car) frame = lessons.draw_boxes(frame, veh_windows, color=(0, 0, 255), thick=3) enhanced_frames.append(frame) util.printProgressBar(i + 1, len_frames, 'Detecting vehicles') return enhanced_frames
def getErrorPlot(): # dataset (normalizamos las etiquetas entre 0 y 35 para los pesos dataset_loader = CLDL_r1(dataset_path, img_transform=None, manual_label_normalize=None) # Cargamos el modelo CNN asker = ClasiLamb_2_2_ModelAsker() asker.loadModel(weight_model_path) # Preparamos los Datos para hacer la plot. Para ello, leemos uno a uno todos los # elementos del data loader, guardamos el label y pasamos la imagen por la red. # Nos quedamos con el peso estimado tambien y lo guardamos todo en dos listas # separadas, pero cada indice relaciona el peso y la prediccion labels = [] preds = [] j = 0 for x, y in dataset_loader: prediction = asker.ask(x) * 35 # print("label: ", y, " pred: ", prediction, " diff: ", abs(y-prediction)) labels.append(y) preds.append(prediction) printProgressBar(j, len(dataset_loader), prefix='Obteniendo predicciones de la red: ', suffix='Completado', length=50, color=33) j += 1 if j == 15211: break print(len(labels), " entradas en labels_and_preds.") print("y type: ", type(y)) print("prediction type ", type(prediction)) # Procesamos la estructura anterior creando las dos listas finales para la plot. # Estas son, una lista de labels (los kilogramos discretos, Ej: 14, 15, 16) y # una lista de valores, que seran la media de errores de los pesos que entren # dentro de esa categoria. Cada peso entra dentro de la categoria que tenga # mas cerca (Ej: en la categoria 16Kg entran desde 15.50 hasta 16.49) # Lista de valores discretos x_values = [ i for i in range(int(round(min(labels), 0)), int(round(max(labels), 0)) + 1) ] print(min(labels)) print(max(labels)) print(round(min(labels))) print(round(max(labels))) print(x_values) # Acumulador de errores en cada categoria de peso acum = [[] for i in range(len(x_values))] # Para cada peso en label, obtenemos su redondeo sin decimales, obtenemos el # idx de la categoria en la que iria y añadimos EL ERROR (diferencia) a la # lista de esa categoria for i, p in enumerate(labels): int_p = round(p, 0) cat_idx = x_values.index(int_p) acum[cat_idx].append(abs(p - preds[i])) print("Categoria : Nº de pesos en la categoria") for i in range(len(x_values)): print(x_values[i], " : ", len(acum[i])) # Metemos en el idx de cada categoria la media de pesos y_values = [[] for i in range(len(x_values))] for i in range(len(x_values)): try: y_values[i] = mean(acum[i]) except: y_values[i] = 0 print(y_values) # Montamos la plot color_list = [ "deepskyblue", "aquamarine", "limegreen", "yellow", "gold", "darkorange", "lightcoral", "orchid", "mediumpurple" ] num_lambs = 1 fig, axs = plt.subplots(num_lambs) i = 0 bars = axs.bar(x_values, y_values, color=color_list[5]) autolabel(bars, axs) plt.sca(axs) plt.xticks(rotation=-40, ha="left", size=8) plt.xticks(x_values) plt.ylabel("Error [Kg]") plt.title("Error segun el peso", size=20) plt.show()
# img = OVERRIDE_MAXVALUE-img if not os.path.exists(dest_path): os.makedirs(dest_path) cv2.imwrite(os.path.join(dest_path, str(num_lamb) + ".png"), np.uint16(img)) # guardamos la etiqueta label = j[key]["weight"] label_list.append(label) num_lamb += 1 i2 += 1 printProgressBar(i2, num_images, prefix='Estructurando JSON ' + str(json_number) + ':', suffix='Completado', length=100, color=45) # guardamos las etiquetas if not os.path.exists(dest_path): os.makedirs(dest_path) d = open(os.path.join(dest_path, "labels.npy"), "wb+") np.save(d, np.array(label_list), allow_pickle=True) d.close() print("\n\nEl dataset resultado se compone de " + V + str(num_lamb) + B + " imagenes.\n\n")
# Set this parameter to True when you're done with algorithm development: done_tweaking = False # Since we seed the randomness, we can avoid executing on the training set # again for some extra speed train_model = True ''' Make predictions on the training set. ''' if train_model: print("Running predictions on training set") preds_train = {} n = len(file_names_train) printProgressBar(0, n, prefix='Progress:', suffix='Complete', length=50) for i in range(len(file_names_train)): # read image using PIL: I = Image.open(os.path.join(data_path,file_names_train[i])) # convert to numpy array: I = np.asarray(I) preds_train[file_names_train[i]] = detect_red_light_mf(I) # Intermediate saves just incase if (i+1) % 50 == 0: # print("Writing to preds_train_{}.json".format(i+1)) with open(os.path.join(preds_path,'preds_train_{}.json'.format(i+1)),'w') as f: json.dump(preds_train,f)
# gradient backprop & optimize ONLY G's parameters G_loss.backward() G_optimizer.step() return G_loss.data.item() def generate_image(epoch): with torch.no_grad(): test_z = Variable(torch.randn(batch_size, z_dim)) generated = G(test_z) save_image(generated.view(generated.size(0), 1, 28, 28), f'./samples/sample_{epoch}.png') n_epoch = 200 for epoch in range(1, n_epoch + 1): D_losses, G_losses = [], [] for batch_idx, (x, _) in enumerate(train_loader): printProgressBar(batch_idx, len(train_loader), f'Treinando - Epoch {epoch}') D_losses.append(D_train(x)) G_losses.append(G_train(x)) print('\n[%d/%d]: loss_d: %.3f, loss_g: %.3f' % ((epoch), n_epoch, torch.mean(torch.FloatTensor(D_losses)), torch.mean(torch.FloatTensor(G_losses)))) generate_image(epoch)