def plot_both(): data = mapper.Mapper() tele1 = data.tele2 day1 = data.route1 day1 = day1[ROUTE_COLS] day1 = day1.sort_values(by='Print Seq') color_max = day1['Print Seq'].max() keywords = {'maximum': color_max} day1['color'] = day1.apply(func=normalize_sequence_color, axis=1, **keywords) color_map = day1[['color']].values # plt.plot(day1[['Longitude']].values, day1[['Latitude']].values, 'g', # zorder=1, alpha=.5) plt.scatter(day1[['Longitude']].values, day1[['Latitude']].values, c=color_map, cmap=cm.bwr, zorder=3) #plt.show() data = mapper.Mapper() tele1 = tele1[TELE_COLS] tele1 = tele1.sort_values(by='Time') start = np.datetime64(convert_timestamp(tele1['Time'].head(1).values[0])) end = np.datetime64(convert_timestamp(tele1['Time'].tail(1).values[0])) max_delta = end - start keywords = {'start': start} tele1['delta'] = tele1.apply(func=time_delta, axis=1, **keywords) keywords = {'maximum_delta': max_delta} tele1['delta_color'] = tele1.apply(func=normalize_tele_color, axis=1, **keywords) tele1['lat_conv'] = tele1[['Latitude']].apply(func=float, axis=1) tele1['lon_conv'] = tele1[['Longitude']].apply(func=float, axis=1) color_map = tele1[['delta_color']].values plt.scatter(tele1[['lon_conv']], tele1[['lat_conv']], c=color_map, cmap=cm.plasma, zorder=2, alpha=.03, s=5) # print(tele1.head()) # print(tele1.tail()) plt.show()
def plot_actual_route(): data = mapper.Mapper() day1 = data.tele2 day1 = day1[TELE_COLS] day1 = day1.sort_values(by='Time') start = np.datetime64(convert_timestamp(day1['Time'].head(1).values[0])) end = np.datetime64(convert_timestamp(day1['Time'].tail(1).values[0])) max_delta = end - start keywords = {'start': start} day1['delta'] = day1.apply(func=time_delta, axis=1, **keywords) keywords = {'maximum_delta': max_delta} day1['delta_color'] = day1.apply(func=normalize_tele_color, axis=1, **keywords) day1['lat_conv'] = day1[['Latitude']].apply(func=float, axis=1) day1['lon_conv'] = day1[['Longitude']].apply(func=float, axis=1) color_map = day1[['delta_color']].values plt.scatter(day1[['lon_conv']], day1[['lat_conv']], c=color_map, cmap=cm.plasma, zorder=2, alpha=.3) # print(day1.head()) # print(day1.tail()) plt.show()
def plot_expected_route(): data = mapper.Mapper() day1 = data.route1 day1 = day1[ROUTE_COLS] day1 = day1.sort_values(by='Print Seq') color_max = day1['Print Seq'].max() keywords = {'maximum': color_max} day1['color'] = day1.apply(func=normalize_sequence_color, axis=1, **keywords) color_map = day1[['color']].values plt.plot(day1[['Longitude']].values, day1[['Latitude']].values, 'b', zorder=1) plt.scatter(day1[['Longitude']].values, day1[['Latitude']].values, c=color_map, cmap=cm.plasma, zorder=3) plt.show()
def __init__(self, cases_func_ref_dict, cases_checkfunc_ref_dict, proxy_obj, activity, logfile, testrunid, testid, log_xml_parser, lockfile, loglevel): self.cases_func_ref_dict = cases_func_ref_dict self.cases_checkfunc_ref_dict = cases_checkfunc_ref_dict self.proxy_obj = proxy_obj self.logfile = logfile self.testrunid = testrunid self.testid = testid self.lockfile = lockfile self.loglevel = loglevel self.fmt = format.Format(logfile) self.log_xml_parser = log_xml_parser # Save case information to a file in a format self.__case_info_save(activity, testrunid) self.env = env_parser.Envparser("global.cfg") mapper_obj = mapper.Mapper(activity) case_list = mapper_obj.module_casename_func_map() for test_procedure in case_list: log_xml_parser.add_testprocedure_xml(testrunid, testid, test_procedure) self.case_name_list = [] for case in case_list: mod_case_func = case.keys()[0] self.case_name_list.append(mod_case_func) self.case_params_list = [] for case in case_list: case_params = case.values()[0] self.case_params_list.append(case_params)
def enterparams(): rcover = request.form.get("rcover") overlap = request.form.get("overlap") lens = request.form.get("Lens") eps = request.form.get("eps") min_samples = request.form.get("min_samples") #strength = int(request.form.get("strength")) #if not rcover or not overlap or not lens: # return render_template("failure.html") import mapper as mp dataset = request.form.get("Dataset") if dataset == "IRIS": from sklearn.datasets import fetch_mldata data = fetch_mldata('iris').data.tolist() elif dataset == "MNIST": from sklearn.datasets import fetch_mldata mnist = fetch_mldata('MNIST original') dataf = mnist.data[::70,:] data = dataf.astype(np.float32).tolist() #from sklearn.manifold import TSNE #data_embedded = TSNE(n_components = 10).fit_transform(data) #data = data_embedded elif dataset == "BREAST_CANCER": from sklearn.datasets import load_breast_cancer dataf = load_breast_cancer() data = dataf.data.tolist() elif dataset == "BLOBS": from sklearn.datasets.samples_generator import make_blobs centers = [[1, 1], [-1, -1] , [1,-1]] X, labels_true = make_blobs(n_samples=3000, centers=centers, cluster_std=0.3, random_state=0) data = X.tolist() elif dataset == "OTHER": f = open("datasets/winequality-white.csv", "r") dataf = list(csv.reader(f, delimiter = ";")) f.close() data = [[float(x) for x in a[0:-1]] for a in dataf[1:]] else: pass out = mp.Mapper(lens = lens, clusterer = "DBSCAN", n_rcover = [int(rcover), float(overlap)], clusterer_params = (float(eps),int(min_samples))) out.write_to_json(data) url = url_for("static", filename = "data/mapperViz.json") return render_template("mapperViz.html", url = url)
def __init__(self, mode = App_Mode.DEBUG_MODE): self.app_mode = mode # initializes the window self.root = tk.Tk() self.root.title('Object Detection and Tracking') # some related booleans self.first_run = True self.first_detect = True self.first_track = True # name of the video to be played self.name = None # initializes the image frame - a Label frame inside which the frames will be displayed self.imageframe = ttk.LabelFrame(self.root, width=600, height=500) self.imageframe.grid(row=0, column=0) # initialize and declare a frame that holds all the buttons self.buttonframe = ttk.LabelFrame(self.root, width=600, height=100) self.buttonframe.grid(row=1, column=0) # initialize a few important buttons within the buttonframe self.select_video_btn = ttk.Button(self.buttonframe, text='Select Video', command=self.select_video) self.select_video_btn.grid(row=0, column=0) self.play_btn = ttk.Button(self.buttonframe, text='Play', command=lambda: self.play(self.first_run)) self.play_btn.grid(row=0, column=1) self.pause_btn = ttk.Button(self.buttonframe, text='Pause', command=self.pause) self.pause_btn.grid(row=0, column=2) self.detect_btn = ttk.Button(self.buttonframe, text='Detect', command=self.detect) self.detect_btn.grid(row=0, column=3) self.track_btn = ttk.Button(self.buttonframe, text='Track', command=self.track) self.track_btn.grid(row=0, column=4) # initialize a label to display the frame self.imagelabel = ttk.Label(self.imageframe) self.imagelabel.grid(row=0, column=0) # mouse events self.imagelabel.bind("<Button-1>", self.leftclick) # initialize image processing related variables self.imageProcessor = ip.ImageProcessor(self.name) self.boxes = None # a list of detection boxes of the latest frame # subscribe to different frame events self.imageProcessor.frameEvent += self.frame_event_handler self.imageProcessor.TrackEvent += self.track_frame_event_handler self.imageProcessor.DetectionEvent += self.detect_frame_event_handler # detection to tracking self.latest_frame = None self.boxes = None self.tracking_roi = None # communication related variables - NOTE: only for tracking self.laser_dot = ev.Event_(point=None) self.laser_dot += self.laser_dot_handler self.laserMedia = None # stores the latest laser position self.laser_position = [0, 0] # mapper to map pixel coordinates to laser coordinates self.map = mapper.Mapper() self.RES_X = 1024 self.RES_Y = 768 self.scale = (self.RES_X, self.RES_Y) self.laser_max = (4, 3) self.map.set_scale(self.scale, self.laser_max)
def search(self, lat, long, r=2): # when searching, the bot does things that aren't really "human" self.Searching = True self.noTask = False self.center = [lat, long] self.radius = r self.player.set_position(lat, long, 0) # this will do a "big jump" # we should also set the speed to the maximum for us not to get banned mapObj = mapper.Mapper(lat, long, self.plt, r=r) self.Destinations = mapObj.scan()
def __init__(self, ktype, carrier_freq, changap, samplerate, spb, demodtype, preamble): self.ktype = ktype self.fc = carrier_freq self.changap = changap self.samplerate = samplerate self.mapper = mapper.Mapper(ktype, 1.0, spb, preamble) # 1.0 is arbitrary self.demodtype = demodtype self.preamble = preamble
def __init__(self, config, carrier_freq, preamble): self.ktype = config.ktype self.fc = carrier_freq self.changap = config.changap self.samplerate = config.samplerate self.mapper = mapper.Mapper(config.ktype, 1.0, config.spb, preamble) # 1.0 is arbitrary self.demodtype = config.demod self.filtertype = config.filter self.preamble = preamble self.config = config
def test_51_map_csv_to_fact(self): """ use the mapper to define how to map a CSV file to facts and parse it to CoreData obects """ import mapper raw_file = os.path.join(pth, 'data', 'core', 'LOCATION_WORLD.csv') mapPC_Usage = mapper.Mapper(os.path.join(os.path.join(pth, 'data', 'raw'), 'country.map')) tot, vals, grps, events = mapPC_Usage.process_raw_file(raw_file, ["id","code","name"]) self.assertEqual(tot, 261) self.assertEqual(len(vals), 785) self.assertEqual(len(grps), 786) self.assertEqual(len(events), 0)
def __init__(self, cases_clearfunc_ref_dict, activity, logfile, loglevel): self.cases_clearfunc_ref_dict = cases_clearfunc_ref_dict self.logfile = logfile self.loglevel = loglevel mapper_obj = mapper.Mapper(activity) mod_casename_func = mapper_obj.module_casename_func_noflag() self.case_name_list = [] for case in mod_casename_func: mod_case_func = case.keys()[0] self.case_name_list.append(mod_case_func) self.case_params_list = [] for case in mod_casename_func: case_params = case.values()[0] self.case_params_list.append(case_params)
def __init__(self, track, world_size: Tuple[float, float] = (50, 50), output_size: Tuple[int, int] = (64, 64), max_offset: float = 50): self.world_offset = np.asarray(world_size) / 2 map_info = mapper.MapInfo(*output_size, *(-self.world_offset), *self.world_offset) self.drawer = mapper.Mapper(map_info, ctx=moderngl.create_context()) self.track_renderer = TrackRenderer("track", total_track_len=track.length, max_offset=max_offset) self.track_renderer.set_data( position=track.path_nodes[:, :, ::2].reshape(-1, 2), track_width=np.tile(track.path_width, [1, 2]).flatten(), track_len=track.path_distance.flatten()) self.drawer.add(self.track_renderer)
def choices(): choice = input("Enter your choice: ") #print(choice) if choice == "1": bp.basicPrint() elif choice == "2": mp.Mapper() elif choice == "3": ts.templateSearcher() elif choice == "4": search.jsonSearcher() elif choice == "5": regs.regexSearcher() else: print( "You didn't select a valid option, please select a valid option.") choices()
def run(self): # open dir and get oldest file with the given extension dir = directory.Directory(os, self.import_dir, ['jpg', 'jpeg']) self.imagefile = dir.get_oldest_file() # open image scan = scanner.Scanner(self.imagefile.name) self.remove_image() informations = scan.scan() # load board_id and cards mapping = mapper.Mapper(informations) board_id = mapping.board_id cards = mapping.get_cards() # create board current_board = board.Board(board_id, cards) # write baord to json current_board.export_json(self.export_dir)
def test_40_read_raw_file(self): mapPC_Usage = mod_map.Mapper( os.path.join(fldr_raw_data, 'PC_Usage.map')) flds = ['Date', 'Time', 'Length', 'Caption'] tot, vals, grps, events = mapPC_Usage.process_raw_file( os.path.join(fldr_raw_data, 'sample_PC_usage.txt'), flds) print(' tot = ', tot) print('vals = ', vals[0:2]) print('grps = ', grps[0:2]) print('events = ', events[0:2]) self.assertEqual( tot, 17) # note that tot starts from zero, meaning 18 lines in file self.assertEqual(len(vals), 8) self.assertEqual(len(grps), 18) self.assertEqual(len(events), 1) self.assertTrue('C:\\Windows\\system32\\cmd.exe' in vals) self.assertTrue('2014-12-23' in events) self.assertTrue('Google Calendar - Google Chrome' in grps)
def train(self, filekey): # Importing the dataset mapr = map.Mapper() dataset = mapr.get_entry(filekey) #dataset = pd.read_csv('..\\data\\tele.csv') #dataset = pd.read_parquet('..\\data\\data.parquet.gz') #convert Time to time since the start dataset['Time'] = pd.to_datetime(dataset['Time']) dataset['Time'] = (dataset['Time'] - dataset['Time'].min()) / np.timedelta64(1, 's') # Taking care of missing data filter = (dataset['Latitude'].notna()) & ( dataset['Longitude'].notna()) & (dataset['Time'].notna()) dataset = dataset[filter] #set x to location and y to time x = dataset.iloc[:, 1:3].values y = dataset.iloc[:, 0].values # Splitting the dataset into the Training set and Test set x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2) # Fitting Multiple Linear Regression to the Training set regressor = LinearRegression() regressor.fit(x_train, y_train) # ============================================================================= #plot fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter3D(x[:, 0], x[:, 1], y) plt.show() # ============================================================================= return regressor
#!/usr/bin/env python import os import re import sys import math import backtrack import mapper b = backtrack.Backtrack("doid", "filter.tsv") m = mapper.Mapper(b, "doid", "uniprot", 200, True, { 'firstmatch': 1, 'title': 1, 'text': 1 }) #ignore specific labels like beginning with ^ (moved to) and * (pure genes) #re_info = re.compile("ID (\w+).*?(CC -!- DISEASE:(.*?)CC -!-)?.*?(DR (MIM[^.]))*", re.DOTALL) re_document = re.compile("ID.*?//\n", re.DOTALL) re_entry = re.compile("ID (\w+)", re.DOTALL) re_cc = re.compile("CC -!- DISEASE:(.*?)(?=CC -[!-]-)", re.DOTALL) re_linkout = re.compile("DR MIM; (\d+); phenotype\.") re_omim = re.compile("\[MIM:(\d+)\]") protein_omims = {} protein_page_texts = {} pages = set() page_text = {} proteins = set() OUT2 = open("uniprot_text_omim.tsv", "w")
def setUp(self): """ gets called for EACH test """ unittest.TestCase.setUp(self) self.mymap = mod_map.Mapper()
import pandas as pd import mapper data = mapper.Mapper() customers = data.unique_customers route_names = [ 'route1', 'route2', 'route3', 'route4', 'route5', 'route6', 'route7', 'route8', 'route9', 'route10', 'route11', 'route12', 'route13', 'route14' ] columns = [ 'Company Number', 'Route Number', 'Date Serviced', 'Route Type', 'Truck Number', 'Print Seq', 'Perm Seq', 'Lift Time', 'Account #', 'Site', 'Container Group', 'Cont Qty', 'Cont Type', 'Container Size', 'Site Name', 'Site Address #/Name', 'Site Address Line 2', 'Site Suite #', 'City', 'State', 'Zip', 'Longitude', 'Latitude' ] routes = [] for name in route_names: routes.append((data.get_entry(name), name)) for route, name in routes: # google lat and long aren't here yet route = route[columns] print(route.columns) a = route.merge( customers[['Site Address #/Name', 'google_lat', 'google_lng']], on='Site Address #/Name', how='left', suffixes=('', ''))
def __init__(self): self.rc_mapper = mapper.Mapper()
def test_90_get_maps_stats(self): mc = mod_map.Mapper(mod_map.map_file) stats = mc.get_maps_stats() self.assertTrue(stats, {'file': 10, 'text': 4})
#!/usr/bin/env python import os import re import sys import math import backtrack import mapper b = backtrack.Backtrack("doid", "filter.tsv") m = mapper.Mapper(b, "doid", "uniprot", 201) #ignore specific labels like beginning with ^ (moved to) and * (pure genes) #re_info = re.compile("ID (\w+).*?(CC -!- DISEASE:(.*?)CC -!-)?.*?(DR (MIM[^.]))*", re.DOTALL) re_document = re.compile("ID.*?//\n", re.DOTALL) re_entry = re.compile("ID (\w+)", re.DOTALL) re_cc = re.compile("CC -!- DISEASE:(.*?)(?=CC -[!-]-)", re.DOTALL) re_linkout = re.compile("DR MIM; (\d+); phenotype\.") re_omim = re.compile("\[MIM:(\d+)\]") protein_omims = {} protein_page_texts = {} pages = set() page_text = {} proteins = set() OUT2 = open("uniprot_text_omim.tsv", "w") for document in re_document.findall(open("uniprot_sprot.dat").read()): info = re_entry.search(document) protein = info.group(1).strip() linkouts = re_linkout.findall(document)
def __init__(self, configuration_file=None): super(self.__class__, self).__init__( ) # Runs the initialization of the base classes (.QMainWindow and design.UI_MainWindow) self.setupUi( self ) # This is defined in design.py file automatically; created in QT Designer self.gd = { } # gui data; dict of dict where gd[class][unique_name][file_path, nilearn image object] self.computed_analysis = False cfile = configuration_file if isinstance(configuration_file, str) else CONFIGURATION_FILE anat_sp = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred) anat_sp.setVerticalStretch(ANATOMICAL_TO_TIMESERIES_PLOT_RATIO) ts_sp = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred) ts_sp.setVerticalStretch(1) # figure instance to view spatial data self.figure_x = plt.figure() self.canvas_x = FigureCanvas(self.figure_x) self.verticalLayout_plot.addWidget(self.canvas_x) self.canvas_x.setSizePolicy(anat_sp) # fig self.figure_t = plt.figure() self.canvas_t = FigureCanvas(self.figure_t) self.verticalLayout_plot.addWidget(self.canvas_t) self.canvas_t.setSizePolicy(ts_sp) self.reset_gui() self.load_configuration_file(cfile) # Connections self.action_LoadScript.triggered.connect(self._load_configuration) self.pushButton_outputDir.clicked.connect(self.browse_output_directory) self.pushButton_loadFMRI.clicked.connect( partial(self.browse_file, 'fmri')) self.pushButton_loadStrucMRI.clicked.connect( partial(self.browse_file, 'smri')) self.pushButton_icaload.clicked.connect( partial( self.browse_folder, self.listWidget_ICAComponents, search_pattern=self.config['ica']['search_pattern'], title="Select ICA Component Directory", list_name="ica", )) # When the button is pressed self.pushButton_rsnload.clicked.connect( partial( self.browse_folder, self.listWidget_RSN, search_pattern=self.config['rsn']['search_pattern'], title="Select RSN Directory", list_name="rsn", )) # When the button is pressed self.pushButton_loadGM.clicked.connect( partial(self.browse_file, 'gm_mask')) self.pushButton_loadWM.clicked.connect( partial(self.browse_file, 'wm_mask')) self.pushButton_loadCSF.clicked.connect( partial(self.browse_file, 'csf_mask')) self.pushButton_loadBrain.clicked.connect( partial(self.browse_file, 'brain_mask')) self.pushButton_loadSegmentation.clicked.connect( partial(self.browse_file, 'segmentation')) self.pushButton_Plot.clicked.connect(self.update_plots) self.listWidget_ICAComponents.itemClicked.connect(self.update_gui) self.listWidget_RSN.itemClicked.connect(self.update_gui) self.listWidget_mappedICANetworks.itemClicked.connect( self.update_mapping) self.listWidget_mappedICANetworks.currentItemChanged.connect( self.update_mapping) self.pushButton_addNetwork.clicked.connect(self.add_mapped_network) self.pushButton_rmNetwork.clicked.connect(self.delete_mapped_network) self.pushButton_reset.clicked.connect(self.reset_gui) self.pushButton_runAnalysis.clicked.connect(self.run_analysis) self.pushButton_createReport.clicked.connect(self.generate_report) self.horizontalSlider_Xslice.sliderReleased.connect(self.update_plots) self.horizontalSlider_Yslice.sliderReleased.connect(self.update_plots) self.horizontalSlider_Zslice.sliderReleased.connect(self.update_plots) self.spinBox_numSlices.valueChanged.connect(self.update_plots) self.listWidget_ICAComponents.setCurrentRow(0) self.listWidget_RSN.setCurrentRow(0) self.mapper = map.Mapper(map_files=self.get_imgobjects('rsn'), in_files=self.get_imgobjects('ica'))
#import mapper as mp #from sklearn import datasets #data, labels = datasets.make_circles(n_samples=2000, noise=0.03, factor=0.5) #X, Y = data[:,0], data[:,1] #data = [[x,y] for x,y in zip(X,Y)] #out = mp.Mapper(lens = "PCA", clusterer = "DBSCAN", n_rcover = [50, 2], clusterer_params = (0.1,5)) #out.write_to_json(data) import mapper as mp #from sklearn.datasets import fetch_mldata from sklearn.datasets import fetch_openml data = fetch_openml('diabetes').data.tolist() out = mp.Mapper(lens = "PCA", clusterer = "DBSCAN", n_rcover = [100, 3], clusterer_params = (0.1,5)) out.write_to_json(data)
#!/usr/bin/env python import mapper import backtrack b = backtrack.Backtrack("doid", "filter.tsv") m = mapper.Mapper(b, "doid", "omim", 120.3) pages = set() type_page_text = {} type_page_text["title"] = {} type_page_text["text"] = {} for line in open("omim_corpus.tsv"): page, block, text = line[:-1].split("\t") pages.add(page) if block == "TITLE": type_page_text["title"][page] = text elif block == "TEXT": type_page_text["text"][page] = text OUT2 = open("omim_matches.tsv", "w") type_entry_page = {} type_page_entry_count = {} for t in type_page_text: type_entry_page[t] = {} type_page_entry_count[t] = {} for page in type_page_text[t]: text = type_page_text[t][page]