def keep(in_nii, keep_labels, keep_csv_filename, out_filename, merge=None): in_label_nii = labels.read_nifti_file(in_nii, 'Label file does not exist') in_label_array = in_label_nii.get_data() if len(keep_csv_filename): csv_keep_labels = labels.read_labels_from_csv(keep_csv_filename) else: csv_keep_labels = [] all_labels = set(labels.get_labels(None, in_label_array)) keep_labels = set( labels.get_labels(keep_labels + csv_keep_labels, in_label_array)) remove_labels = sorted(list(all_labels.symmetric_difference(keep_labels))) out_label_array = in_label_array for ii in remove_labels: mask = in_label_array == ii out_label_array[mask] = 0 if merge is not None and merge != 0: # isinstance(map, (int, long, float)) and float(map) !=0: out_label_array = merge * (out_label_array > 0) nb.save(nb.Nifti1Image(out_label_array, None, in_label_nii.get_header()), out_filename)
def load_data(): dir = 'training2017CSV/' records = [f for f in listdir(dir) if isfile(join(dir, f)) if(f.find('.csv') != -1)] records.sort() # print(records) y, f = lb.get_labels() # print(y) # print(f) # print(type(y)) # records = ['A00001.csv','A00002.csv'] # records = records[0:100] # print(records) x_train = np.array([]) for r in records: test = pd.read_csv(dir + r, index_col=0,nrows=2714) # print(test) test = test.values.tolist() # print(test) # test = test[0:2714] # test = test[:,1] x = np.array([]) for t in test: # print(t[1]) x = np.append(x,t) # print(x) # x = x[0:2714] x_train = np.append(x_train,x) print(dir + r) x_train = x_train.reshape(-1, 2714) x_train = tf.keras.utils.normalize(x_train, axis = 1) # print(x_train) return y,x_train
def remove(in_nii, remove_labels, remove_csv_filename, out_filename, merge=None): in_label_nii = labels.read_nifti_file(in_nii, 'Label file does not exist') in_label_array = in_label_nii.get_data() if len(remove_csv_filename): csv_remove_labels = labels.read_labels_from_csv(remove_csv_filename) else: csv_remove_labels = [] remove_labels = set( labels.get_labels(remove_labels + csv_remove_labels, in_label_array)) out_label_array = in_label_array for ii in remove_labels: mask = in_label_array == ii out_label_array[mask] = 0 if merge is not None and merge != 0: # isinstance(map, (int, long, float)) and float(map) !=0: out_label_array = merge * (out_label_array > 0) nibabel.save( nibabel.Nifti1Image(out_label_array, None, in_label_nii.get_header()), out_filename)
def build_model_for_corpus(corpus): """ Build an appropriate Keras NN model depending on the corpus """ keras_model = None no_of_labels = -1 if corpus == 'keywords': keras_model = berger_cnn(embedding_size=100, output_length=1000) no_of_labels = 1000 elif corpus == 'categories': keras_model = berger_cnn(embedding_size=50, output_length=14) no_of_labels = 14 model_path = os.path.join(DATA_DIR, corpus, 'model.pickle') keras_model.load_weights(model_path) w2v_path = os.path.join(DATA_DIR, corpus, 'word2vec.pickle') w2v_model = Word2Vec.load(w2v_path) scaler_path = os.path.join(DATA_DIR, corpus, 'scaler.pickle') scaler = load_from_disk(scaler_path) labels = get_labels(no_of_labels) model = MagpieModel( keras_model=keras_model, word2vec_model=w2v_model, scaler=scaler, labels=labels, ) return model
def train(train_dir, test_dir=None, nn='berger_cnn', nb_epochs=NB_EPOCHS, batch_size=BATCH_SIZE, verbose=1): # Figure out whether we're predicting categories or keywords if NO_OF_LABELS == 14: scaler_path = CATEGORY_SCALER w2v_path = CATEGORY_WORD2VEC else: scaler_path = KEYWORD_SCALER w2v_path = KEYWORD_WORD2VEC model = MagpieModel( word2vec_model=Word2Vec.load(w2v_path), scaler=load_from_disk(scaler_path), ) logger = CustomLogger(nn) model_checkpoint = ModelCheckpoint( os.path.join(logger.log_dir, 'keras_model'), save_best_only=True, ) history = model.train( train_dir, get_labels(NO_OF_LABELS), test_dir=test_dir, nn_model=nn, callbacks=[logger, model_checkpoint], batch_size=batch_size, nb_epochs=nb_epochs, verbose=verbose, ) finish_logging(logger, history) return history, model
def keep(in_nii, keep_labels, keep_csv_filename, out_filename): in_label_nii = labels.read_nifti_file(in_nii, 'Label file does not exist') in_label_array = in_label_nii.get_data() if len(keep_csv_filename): csv_keep_labels = labels.read_labels_from_csv(keep_csv_filename) else: csv_keep_labels = [] all_labels = set(labels.get_labels(None, in_label_array)) keep_labels = set( labels.get_labels(keep_labels + csv_keep_labels, in_label_array)) remove_labels = sorted(list(all_labels.symmetric_difference(keep_labels))) out_label_array = in_label_array for ii in remove_labels: mask = in_label_array == ii out_label_array[mask] = 0 nb.save(nb.Nifti1Image(out_label_array, None, in_label_nii.get_header()), out_filename)
def load_data(): # dir = 'training2017CSV/' dir = 'test/' counter = 0 # ==> Find all csv files and save them in records list: records = [ f for f in listdir(dir) if isfile(join(dir, f)) if (f.find('.csv') != -1) ] records.sort() # print(records) print(len(records)) # =========================== Create Labels ====================================================================== y, f = lb.get_labels() print(y) print(f) # ================================================================================================================ # x = np.array([])h # =========================== Create train test ===================================================================================== x_train = np.array([]) y_train = np.array([]) file = np.array([]) for r in records: # print(r) test = pd.read_csv(dir + r) test = test.values.tolist() # --> convert test dataframe to list # print(r) if len(test) == 9000: for char in '.csv': r = r.replace(char, '') # print(r) x = np.array([]) for t in test: # print(t[1]) x = np.append(x, t[1]) # print(x) x_train = np.append(x_train, x) # print(x_train,counter) # TODO : add switch mode eg: N --> 0 etc y_train = np.append(y_train, y[f.index(r)]) file = np.append(file, r) counter = counter + 1 x_train = x_train.reshape(counter, 9000) for i in range(0, counter): print(file[i], y_train[i]) return x_train, y_train
def create_strings(imgurl): labels = get_labels(imgurl) face = faceDetect(imgurl) celebstr = celeb(imgurl) labelstr = "Objects detected in the image are:\n" facestr = "" for i in labels: labelstr += i['Name'] + " with confidence " + str( i['Confidence']) + ",\n" if face: facestr += "The attributes for faces found in the image are as follows: \n\n" + face[ 0] + ",\n\n" facestr += "Number of faces detected in the image are" + str( face[1]) + "\n\n" else: facestr += " \n\n" return [labelstr, facestr, celebstr]
def extract(in_filename, in_csv, in_extract_labels, out_filename, verbose=False, merge=None): # Read in label array in_nii = labels.read_nifti_file(in_filename, 'Label file does not exist') in_array = in_nii.get_data() if len(in_csv): csv_extract_labels = labels.read_labels_from_csv(in_csv) else: csv_extract_labels = [] # print ( inArgs.extract.shape) # print ( csv_extract_labels.shape) requested_labels = in_extract_labels + csv_extract_labels extract_labels = labels.get_labels(requested_labels, in_array) if verbose: print('Requested labels for extraction not found', list(set(requested_labels) - set(extract_labels))) out_array = np.zeros(in_array.shape, dtype=np.int8) for ii in extract_labels: mask = in_array == ii out_array[mask] = in_array[mask] if merge is not None and merge != 0: # isinstance(map, (int, long, float)) and float(map) !=0: out_array = merge * (out_array > 0) nb.save(nb.Nifti1Image(out_array, None, in_nii.get_header()), out_filename) return
def batch_train(train_dir, test_dir=None, nn='berger_cnn', nb_epochs=NB_EPOCHS, batch_size=BATCH_SIZE, verbose=1): # Figure out whether we're predicting categories or keywords if NO_OF_LABELS == 14: scaler_path = CATEGORY_SCALER w2v_path = CATEGORY_WORD2VEC else: scaler_path = KEYWORD_SCALER w2v_path = KEYWORD_WORD2VEC model = MagpieModel( word2vec_model=Word2Vec.load(w2v_path), scaler=load_from_disk(scaler_path), ) logger = CustomLogger(nn) model_checkpoint = ModelCheckpoint( os.path.join(logger.log_dir, 'keras_model'), save_best_only=True, ) history = model.batch_train( train_dir, get_labels(NO_OF_LABELS), test_dir=test_dir, nn_model=nn, callbacks=[logger, model_checkpoint], batch_size=batch_size, nb_epochs=nb_epochs, verbose=verbose, ) finish_logging(logger, history) return history, model
def remove(in_nii, remove_labels, remove_csv_filename, out_filename): in_label_nii = labels.read_nifti_file(in_nii, 'Label file does not exist') in_label_array = in_label_nii.get_data() if len(remove_csv_filename): csv_remove_labels = labels.read_labels_from_csv(remove_csv_filename) else: csv_remove_labels = [] remove_labels = set( labels.get_labels(remove_labels + csv_remove_labels, in_label_array)) out_label_array = in_label_array for ii in remove_labels: mask = in_label_array == ii out_label_array[mask] = 0 nibabel.save( nibabel.Nifti1Image(out_label_array, None, in_label_nii.get_header()), out_filename)
def getCleanMarksDF(week_number): marks_WS = gspread.authorize(getCredentials()).open( f"Voti_Fantacalcio_Stagione_2018-19_Giornata_{week_number}").worksheet("Fantagazzetta") # GET ALL VALUES labels = lb.get_labels() x = marks_WS.get_all_values()[4:] marks_DF = pd.DataFrame(x, columns=labels) # STORE TEAMS THA HAS ALREADY PLAYED codeCol = marks_DF[lb.code] alreadyPlayedTeams = codeCol.loc[marks_DF[lb.code].isin( util.italian_teams)] alreadyPlayedTeams = alreadyPlayedTeams.values.tolist() # REMOVE USELESS COLUMNS marks_DF.pop(lb.code) marks_DF.pop(lb.gdv) marks_DF.pop(lb.gdp) # REMOVE USELESS ROWS roles = rl.get_roles() marks_DF = marks_DF.loc[marks_DF[lb.role].isin(roles)] marks_DF = marks_DF.loc[marks_DF[lb.mark] != '6*'] # ARRANGE COLUMNS TYPES floatLabels = lb.get_float_labels() intLabels = lb.get_int_labels() marks_DF[floatLabels] = marks_DF[floatLabels].astype(float) marks_DF[intLabels] = marks_DF[intLabels].astype(int) # SUM THE TWO KINDS OF ASSISTS marks_DF[lb.ass] += marks_DF[lb.asf] # TODO check marks_DF.pop(lb.asf) # CALCULATE GOAL BONUS marks_DF[lb.golBns] = 0.0 marks_DF.loc[marks_DF[lb.gf] > 0, [lb.golBns]] = \ marks_DF[lb.gf] * marks_DF[lb.role].apply(bn.get_gol_value) + \ marks_DF[lb.gf].apply(bn.get_gol_bonus) # CALCULATE ASSIST BONUS marks_DF[lb.assBns] = 0.0 marks_DF.loc[marks_DF[lb.ass] > 0, [lb.assBns]] = \ marks_DF[lb.ass] * marks_DF[lb.role].apply(bn.get_ass_value) + \ marks_DF[lb.ass].apply(bn.get_ass_bonus) # CALCULATE TOTAL BONUS marks_DF[lb.bonus] = getTotalBonus(marks_DF) return marks_DF
"https://www.googleapis.com/auth/drive" ]) gc = gspread.authorize(credentials) # WORKSHEET VOTI try: marksWS = gc.open("Voti_Fantacalcio_Stagione_2018-19_Giornata_").worksheet( "Fantagazzetta") except SpreadsheetNotFound: input("SpreadsheetNotFound:") # GET ALL VALUES labels = lb.get_labels() x = marksWS.get_all_values()[4:] marksDF = pd.DataFrame(x, columns=labels) # STORE TEAMS THA HAS ALREADY PLAYED codeCol = marksDF[lb.code] alreadyPlayedTeams = codeCol.loc[marksDF[lb.code].isin(util.italian_teams)] alreadyPlayedTeams = alreadyPlayedTeams.values.tolist() # REMOVE USELESS COLUMNS marksDF.pop(lb.code) marksDF.pop(lb.gdv) marksDF.pop(lb.gdp)
traces01 = readIn(lines01, '\t') traces02 = readIn(lines02, '\t') #make them into dataframe df01 = sqlContext.createDataFrame(traces01) df02 = sqlContext.createDataFrame(traces02) #convert them to vectors df_conv01 = convDf(df01) #prepare for ml df_prepped01 = prep(df_conv01) df_prepped02 = df02.select("name").distinct() #function to apply labels df_labeled = get_labels(df_prepped01, df_prepped02) df_labeled = df_labeled.na.drop().drop("version_idx") cols_for_ml = df_prepped01.drop("name").drop("version_idx").schema.names #pipline stages #index the label labelIndexer = mlf.StringIndexer(inputCol="Label", outputCol="Label_idx") #vectorise the input toVec = mlf.VectorAssembler(inputCols=cols_for_ml, outputCol="Features") #classify classifier = DecisionTreeClassifier(labelCol="Label_idx", featuresCol="Features", maxDepth=10, maxBins=200) #create pipline of the stages and use it to train and test
parser.add_argument("--debug", help="Debug flag", action="store_true", default=False ) inArgs = parser.parse_args() if inArgs.debug: print("inArgs.in_nii = " + inArgs.in_nii + '\n') print("inArgs.debug = " + str(inArgs.debug)) print("inArgs.verbose = " + str(inArgs.verbose)) label_nii = labels.read_nifti_file( inArgs.in_nii, 'Label file does not exist' ) label_array = label_nii.get_data() labels = labels.get_labels( inArgs.labels, label_array) df_stats = pd.DataFrame(columns=('label', 'com_x', 'com_y', 'com_z', 'label_volume', 'ellipsoid_volume', 'center_x', 'center_y', 'center_z', 'r1', 'r2', 'r3', 'fa' )) if inArgs.stats is not None: stats_list = inArgs.stats else: stats_list = list(df_stats.columns.values) if inArgs.verbose: jj=0 pd.set_option('expand_frame_repr', False) for ii in labels:
def measure(label_nii_filename, image_nii_filename, requested_labels=[], verbose_flag=False, verbose_nlines=10, verbose_all_flag=False): # Load arrays label_nii = labels.read_nifti_file(label_nii_filename, 'Label file does not exist') image_nii = labels.read_nifti_file(image_nii_filename, 'Image file does not exist') # System Checks to verify that the Array Size and Dimensions are compatible image_array = image_nii.get_data() label_array = label_nii.get_data() if len(image_array.shape) < 2 or len(image_array.shape) > 4: sys.exit('Only supports 3D and 4D image arrays') # if not len(label_array.shape) == 3: # sys.exit('Only supports 3D label arrays') label_ndim = len(label_array.shape) image_ndim = len(image_array.shape) ndim = min([label_ndim, image_ndim]) if not image_array.shape[0:ndim] == label_array.shape[0:ndim]: sys.exit( 'Image array and label array do not have the same voxel dimensions' ) # Find a set of acceptable labels label_list = labels.get_labels(requested_labels, label_array) # Permute array or expand so desired stats is along first dimension if image_ndim == 4: nVolumes = int(image_array.shape[3]) image_array = numpy.transpose(image_array, [3, 0, 1, 2]) elif image_ndim == 3: image_array = numpy.transpose(image_array, [2, 0, 1]) else: nVolumes = 1 image_array = numpy.expand_dims(image_array, axis=0) label_array = numpy.expand_dims(label_array, axis=0) # Gather stats if verbose_flag: ii_verbose = 0 pandas.set_option('expand_frame_repr', False) df_stats = pandas.DataFrame(columns=('label', 'x_com', 'y_com', 'z_com', 'time', 'mean', 'std', 'min', 'max')) nlabels = len(label_list) for ii, ii_label in enumerate(label_list): for jj in range(0, nVolumes): if label_ndim == 3: mask = label_array[0, :, :, :] == ii_label else: mask = label_array[0, :, :] == ii_label label_mean = numpy.mean(image_array[jj][mask]) label_std = numpy.std(image_array[jj][mask]) label_min = numpy.min(image_array[jj][mask]) label_max = numpy.max(image_array[jj][mask]) if label_ndim == 3: x_com, y_com, z_com = ndimage.measurements.center_of_mass(mask) else: z_com = 0 x_com, y_com = ndimage.measurements.center_of_mass(mask) stats = [ ii_label, x_com, y_com, z_com, jj, label_mean, label_std, label_min, label_max ] if verbose_flag and nlabels > 3 * verbose_nlines: if ii_verbose == (verbose_nlines - 1): df_verbose = df_stats.tail(verbose_nlines) print('\n') print( df_verbose.to_string( formatters={ 'label': '{:,.0f}'.format, 'volume': '{:,.0f}'.format, 'time': '{:,.0f}'.format, 'mean': '{:,.3f}'.format, 'std': '{:,.3f}'.format, 'min': '{:,.3f}'.format, 'max': '{:,.3f}'.format, 'x_com': '{:,.0f}'.format, 'y_com': '{:,.0f}'.format, 'z_com': '{:,.0f}'.format })) ii_verbose = 0 else: ii_verbose += 1 df_stats.loc[len(df_stats)] = stats if verbose_flag: if verbose_all_flag: pandas.set_option('display.max_rows', len(df_stats)) print('\n') # ['label' 'x_com' 'y_com' 'z_com' 'time' 'mean' 'std' 'min' 'max'] print( df_stats.to_string( formatters={ 'label': '{:,.0f}'.format, 'time': '{:,.0f}'.format, 'mean': '{:,.3f}'.format, 'std': '{:,.3f}'.format, 'min': '{:,.3f}'.format, 'max': '{:,.3f}'.format, 'x_com': '{:,.0f}'.format, 'y_com': '{:,.0f}'.format, 'z_com': '{:,.0f}'.format })) print('\n') return df_stats
def properties(in_label_nii_filename, label_list, background, stats, out_filename, limits_volume_voxels=[0, numpy.inf], limits_bb_volume_voxels=[0, numpy.inf], limits_fill_factor=[0,1], sort='volume', verbose=False, verbose_nlines=20): label_nii = labels.read_nifti_file( in_label_nii_filename, 'labels.properties.py: Label file does not exist. ') single_voxel_volume_mm3 = query_voxel_volume_mm3( label_nii ) label_array = label_nii.get_data() label_list = labels.get_labels(label_list, label_array, background) df_stats = pd.DataFrame(columns=( 'label', 'volume_voxels', 'volume_mm3', 'com_x', 'com_y', 'com_z', 'com_t', 'com_in', 'bb_dx', 'bb_dy', 'bb_dz', 'bb_dt', 'bb_dmin', 'bb_volume_voxels', 'fill_factor')) stats_list = ['label', ] + list(stats) if verbose: jj = 0 pd.set_option('expand_frame_repr', False) for ii in label_list: # Create logical mask mask = (label_array == ii) ndim = len(mask.shape) # Calculate Volume label_volume_voxels = int(numpy.sum(mask)) label_volume_mm3 = single_voxel_volume_mm3 * label_volume_voxels if check_limits(label_volume_voxels, limits_volume_voxels): bb_dx, bb_dy, bb_dz, bb_dt, bb_dmin, bb_volume_voxels = calculate_bounding_box(mask) if check_limits(bb_volume_voxels, limits_bb_volume_voxels): label_x_com, label_y_com, label_z_com, label_t_com = calculate_center_of_mass(mask) if ndim == 4: label_com_in = mask[label_x_com, label_y_com, label_z_com, label_t_com] elif ndim==3: label_t_com = 0 label_com_in = mask[label_x_com, label_y_com, label_z_com] else: label_z_com = label_t_com = 0 label_com_in = mask[label_x_com, label_y_com] fill_factor = label_volume_voxels / bb_volume_voxels if check_limits(fill_factor, limits_fill_factor): label_stats = [ii, label_volume_voxels, label_volume_mm3, label_x_com, label_y_com, label_z_com, label_t_com, label_com_in, bb_dx, bb_dy, bb_dz, bb_dt, bb_dmin, bb_volume_voxels, fill_factor] df_stats.loc[len(df_stats)] = label_stats if verbose: if jj == (verbose_nlines - 1): print('\n') df_verbose = df_stats.tail(verbose_nlines) df_verbose = df_verbose[stats_list] print(df_verbose.to_string( formatters={'volume_voxels': '{:,.0f}'.format, 'volume_mm3': '{:,.3f}'.format, 'com_x': '{:,.0f}'.format, 'com_y': '{:,.0f}'.format, 'com_z': '{:,.0f}'.format, 'com_t': '{:,.0f}'.format, 'com_in': '{:,.0f}'.format, 'bb_dx': '{:,.0f}'.format, 'bb_dy': '{:,.0f}'.format, 'bb_dz': '{:,.0f}'.format, 'bb_dt': '{:,.0f}'.format, 'bb_volume_voxels': '{:,.0f}'.format, 'fill_factor': '{:,.3f}'.format } )) jj = 0 else: jj += 1 df_sorted = df_stats.sort_values([sort], ascending=[1]).reset_index(drop=True) if verbose: print('\n') print(df_sorted[stats_list]) print('\n') if not out_filename == None: df_sorted[stats_list].to_csv(out_filename, index=False)
def list_labels(in_filename): in_label_nii = labels.read_nifti_file(in_filename, 'Label file does not exist') label_list = labels.get_labels(None, in_label_nii.get_data()) return label_list
def overlap( label_nii_filename, label2_nii_filename, requested_labels=[], verbose_flag=False, verbose_nlines=10, verbose_all_flag=False ): # Load arrays label_nii = labels.read_nifti_file( label_nii_filename, 'Label file does not exist' ) label2_nii = labels.read_nifti_file( label2_nii_filename, 'Image file does not exist' ) label_single_voxel_volume_mm3 = query_voxel_volume_mm3(label_nii) label2_single_voxel_volume_mm3 = query_voxel_volume_mm3(label2_nii) # System Checks to verify that the Array Size and Dimensions are compatible label_array = label_nii.get_data() label2_array = label2_nii.get_data() if len(label2_array.shape) < 2 or len(label2_array.shape) > 4: sys.exit('Only supports 3D and 4D image arrays') # if not len(label_array.shape) == 3: # sys.exit('Only supports 3D label arrays') label_ndim = len(label_array.shape) label2_ndim = len(label2_array.shape) ndim = min([label_ndim, label2_ndim]) if not label2_array.shape[0:ndim] == label_array.shape[0:ndim]: sys.exit('Image array and label array do not have the same voxel dimensions') # Find a set of acceptable labels label_list = labels.get_labels( requested_labels, label_array) label2_list = labels.get_labels([], label2_array) # Gather stats if verbose_flag: ii_verbose=0 pandas.set_option('expand_frame_repr', False) df_stats = pandas.DataFrame(columns=('label1', 'label2', 'volume1_mm3', 'volume2_mm3', 'volume12_mm3', 'fraction12', 'x12_com', 'y12_com', 'z12_com')) for ii, ii_label in enumerate(label_list): mask1 = label_array[0, ...] == ii_label _, label1_volume_mm3 = measure_volume(mask1, label_single_voxel_volume_mm3) overlap_label2_list = list(numpy.unique(mask1 * label2_array)) print(overlap_label2_list) for jj, jj_label in enumerate(overlap_label2_list): mask2 = label2_array[0,...] == jj_label mask12 = mask1 * mask2 _, label2_volume_mm3 = measure_volume( mask2, label_single_voxel_volume_mm3) _, label12_volume_mm3 = measure_volume(mask12, label_single_voxel_volume_mm3) fraction12 = label12_volume_mm3 / label1_volume_mm3 x12_com, y12_com, z12_com = ndimage.measurements.center_of_mass(mask12) stats = [ii_label, jj_label, label1_volume_mm3, label2_volume_mm3, label2_volume_mm3, fraction12, x12_com, y12_com, z12_com ] if verbose_flag: if ii_verbose==(verbose_nlines-1): df_verbose = df_stats.tail(verbose_nlines) print('\n') print (df_verbose.to_string(formatters={'label1':'{:,.0f}'.format, 'label2':'{:,.0f}'.format 'volume1':'{:,.0f}'.format, 'volume2':'{:,.0f}'.format, 'volume12':'{:,.0f}'.format, 'fraction12':'{:,.3f}'.format, 'x12_com':'{:,.0f}'.format, 'y12_com':'{:,.0f}'.format, 'z12_com':'{:,.0f}'.format} )) ii_verbose = 0 else: ii_verbose += 1 df_stats.loc[len(df_stats)] = stats
import os import sys from crop_func import crop_func from get_directories import get_directories import labels as lbl labels_path = str(sys.argv[1]) # path to label.txt files data_path = str(sys.argv[2]) # path to images save_path = str(sys.argv[3]) # path to save the cropped directory labels_dir, data_dir = get_directories(labels_path, data_path) all_labels = lbl.get_labels(labels_path, labels_dir) print("all labels...") idx = 0 for i in all_labels: print(F"File #{idx}") for row in i: print(row) idx += 1 print() print("Attempting to create cropped directory") if os.path.exists(save_path): print(F"{save_path} already exists.") else: try: os.mkdir(save_path) except OSError: print(F"Creation of the directory '{save_path}' failed.")
def get(self, video_id): return get_labels(video_id)
# -*- coding: UTF-8 -*- """ Constructs an index.html for debugging the translation and region information. """ from regions import regions as get_regions from names import names as get_names from labels import labels as get_labels regions = get_regions() names = get_names() labels = get_labels() def language_abbr(language): return """<em><abbr title="%s">%s</abbr>.</em>""" % ( { "E": "English", "S": "Sindarin", "Q": "Quenya", "N": "Ñoldorin", }.get(language, language), language ) def label_html(language): key = language["Canonical"], language["Language"], "Tengwar", "General Use" if key not in labels: return "" label = labels[key] return """ <img class="label" src="http://3rin.gs/labels/%s-%st-thumbnail.png" title="%s in the Tengwar">