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]
