def main():
dataFolder = '/Users/deepak/Dropbox/GravityMachine/GravityMachineManuscript/EnsembleTrackStatistics'
subFolder = 'Starfish_Blinks'
saveFolder = dataFolder
Files = os.listdir(os.path.join(dataFolder, subFolder))
# Files = {0:'Dendraster1_Blink_Statistics.pkl',1:'Dendraster2_Blink_Statistics.pkl',2:'Dendraster3_Blink_Statistics.pkl'}
# Files = {0:'Dendraster1_Blink_Statistics.pkl',1:'Dendraster2_Blink_Statistics.pkl',2:'Dendraster3_Blink_Statistics.pkl'}
# Time = []
# peak_indicator = []
# peak_indicator_neg = []
# TimeBetweenBlinks_array = []
# BlinkDurations_array = []
TimeBetweenBlinks_array = np.array([])
BlinkDurations_array = np.array([])
color1 = cm.inferno(64)
color2 = cm.inferno(128)
for fileNames in Files:
print('Analyzing ... {}'.format(fileNames))
with open(os.path.join(dataFolder,subFolder,fileNames),'rb') as f:
Time, peak_indicator, peak_indicator_neg, TimeBetweenBlinks, BlinkDurations = pickle.load(f)
def plotModified(reference, histo, color=1):
# plot original histogram (reference) with ones resampled from it (histo),
# histo is either an array of histograms or a single histogram.
# reference is a dataframe element.
if color == 1:
colors = [cm.viridis(i) for i in np.linspace(0, 1, len(histo))]
elif color == 2:
colors = [cm.plasma(i) for i in np.linspace(0, 1, len(histo))]
else:
colors = [cm.inferno(i) for i in np.linspace(0, 1, len(histo))]
name = reference['hname']
vmin = reference['Xmin']
vmax = reference['Xmax']
# create an array with x values, from x_min to x_max and length as input histogram
x = vmin + (np.arange(len(histo[0]))) * float(
(vmax - vmin) / float(len(histo[0])))
x = x[1:-1]
for i in range(len(histo)):
plt.xlim(vmin, vmax)
histo_todraw = histo[i][1:-1]
#srun=df_plot.index.get_level_values('fromrun')[num]
#slumi=df_plot.index.get_level_values('fromlumi')[num]
plt.step(x,
histo_todraw,
where='mid',
label=(name + " LS " + str(reference['fromlumi']) + " Run " +
str(reference['fromrun'])),
color=colors[i])
def plot_cube(ax, cube, angle=50):
cube = plot_normalize(cube)
facecolors = cm.inferno(cube)
facecolors[:, :, :, -1] = cube # alpha channel = voxel value
facecolors = explode(facecolors)
filled = abs(facecolors[:, :, :, -1]) >= 0.5
#filled = facecolors[:,:,:,-1] != 0
z, y, x = expand_coordinates(np.indices(np.array(filled.shape) + 1))
ax.view_init(50, angle)
ax.set_xlim(right=IMG_DIM * 2)
ax.set_ylim(top=IMG_DIM * 2)
ax.set_zlim(top=IMG_DIM * 2)
ax.set_xlabel('$X$') #, fontsize=20)
ax.set_ylabel('$Y$')
#ax.yaxis._axinfo['label']['space_factor'] = 3.0
# set z ticks and labels
#ax.set_zticks([-2, 0, 2])
# change fontsize
#for t in ax.zaxis.get_major_ticks(): t.label.set_fontsize(10)
# disable auto rotation
ax.zaxis.set_rotate_label(False)
ax.set_zlabel('$\lambda$', rotation=0) #, fontsize=30)
im = ax.voxels(x, y, z, filled, facecolors=facecolors)
def main_synth():
n = 1536
n = 2000
pts = np.stack(
np.meshgrid(np.linspace(-1, 1, n), np.linspace(-1, 1, n), [-1]),
-1).reshape(-1, 3)
pts = pts.astype(np.float32)
pts[..., 2] = np.random.randn(n * n) * .0001 - .9
pts[(pts[:, 1] + pts[:, 0] > -.5) & (pts[:, 1] + pts[:, 0] < .5) &
(pts[:, 1] - 2 * pts[:, 0] > -.5) & (2 * pts[:, 1] - pts[:, 0] < .5),
2] = -.6
pts[(pts[:, 1] + pts[:, 0] > -.3) & (pts[:, 1] + pts[:, 0] < .3) &
(pts[:, 1] - pts[:, 0] > -.3) & (pts[:, 1] - pts[:, 0] < .3), 2] = -.4
print('PTS\n', pts)
lo = pts[:, 2].min()
hi = pts[:, 2].max()
print(lo, hi)
colors = inferno(1e-1 + (pts[:, 2] - lo) / (1e-6 + hi - lo))[..., :3]
app = PointRenderer(1024, 1024)
app.init(True)
app.setPts(pts, colors, None)
while not app.q_pressed:
app.startFrame()
app.render()
app.endFrame()
#if app.endFrame(): break
app.q_pressed = False
def get_depth(model, img):
model.switch_to_eval()
input_height = 384
input_height = 512
input_width = 512
img = cv2.resize(img, (input_width, input_height))
input_img = torch.from_numpy(np.transpose(
img, (2, 0, 1))).contiguous().float() / 255.
input_img = input_img.unsqueeze(0)
input_images = Variable(input_img.cuda())
pred_log_depth = model.netG.forward(input_images)
pred_log_depth = torch.squeeze(pred_log_depth)
pred_depth = torch.exp(pred_log_depth)
# visualize prediction using inverse depth, so that we don't need sky segmentation (if you want to use RGB map for visualization, \
# you have to run semantic segmentation to mask the sky first since the depth of sky is random from CNN)
pred_inv_depth = 1 / pred_depth
pred_inv_depth = pred_inv_depth.data.cpu().numpy()
# you might also use percentile for better visualization
pred_inv_depth = pred_inv_depth / np.amax(pred_inv_depth)
from matplotlib.cm import inferno
colored = (inferno(pred_inv_depth) * 255)[..., 0:3].astype(np.uint8)
#io.imsave('demo.png', colored)
# print(pred_inv_depth.shape)
cv2.imshow('depth', cv2.cvtColor(colored, cv2.COLOR_BGR2RGB))
cv2.waitKey(0)
cv2.destroyAllWindows()
return img, pred_depth.detach().cpu().numpy()
def plot_ei_regime(ax,data,JEI,JII,filename,fig,zoom_in,zoom_lims,scales):
JII_b = np.array(data["points_fr_gpe"])*0.725*40*10
JEI_b = np.array(data["points_fr_stn"])*1.2*23*5
ax1 = ax.twinx().twiny()
start_markers=[]
end_markers=[]
lines=[]
line_colors=[]
for k,(x_row,y_row) in enumerate(zip(JEI_b,JII_b)):
arr_col = cm.inferno(float(k)/len(JEI_b))
line_colors.append(arr_col)
for l,(x_col,y_col) in enumerate(zip(x_row,y_row)):
if l < len(x_row)-1:
lines.append(ax1.arrow(x_col,y_col,x_row[l+1]-x_col,y_row[l+1]-y_col,head_width=50,length_includes_head=True,fc = arr_col, ec = arr_col,linestyle='-',linewidth=1.0,alpha=0.8))
if k%2 == 0:
end_markers.append(ax1.plot(x_col,y_col,marker='o',markersize=12,color=arr_col,label='gpe ratio:'+str(gpe_rat[k]),alpha=0.8))
else:
end_markers.append(ax1.plot(x_col,y_col,marker='o',markersize=12,color=arr_col,alpha=0.8))
start_markers.append(ax1.plot(x_row[0],y_row[0],marker='*',markersize=12,color=arr_col,alpha = 0.8))
handles, labels = ax1.get_legend_handles_labels()
fig.legend(handles,labels,loc='upper center', bbox_to_anchor=(0.8, 1.005), ncol=2, fancybox=True,prop={'size':18,'weight':'bold'})
ax1.set_xlim(ax.get_xlim())
ax1.set_ylim(ax.get_ylim())
ax1.set_xticklabels([])
ax1.set_yticklabels([])
def normalize_and_show(arr):
dimg = (inferno((arr - arr.min()) / (arr.max() - arr.min())) *
255)[..., 0:3].astype(np.uint8)
dimg = cv2.cvtColor(dimg, cv2.COLOR_RGB2BGR)
cv2.imshow('dimg', dimg)
cv2.waitKey(0)
cv2.destroyAllWindows()
def visualise_voxels(vox_cubes: np.ndarray,
inv=True,
figsize=(5, 5),
det_coords=None):
"""
Plot a 3D visualization of the voxels. Intensities are from Inferno colormap. Transparency is equal to value in the voxel.
Inverted image is (1-original). If detector coordinates are provided, they are added as a scatter plot.
:param vox_cubes: 3d array of voxels
:param inv: bool whether to invert filled-empty
:param figsize: matplotlib figure size
:param det_coords: 2d array (n_det, 3) of detector coordinates
:return: (interactive) 3d graph
"""
facecolors = cm.inferno(inv + ((-1)**inv) * vox_cubes)
facecolors[..., -1] = inv + ((-1)**inv) * vox_cubes
filled = np.ones(vox_cubes.shape)
filled_2 = explode(filled)
fcolors_2 = explode(facecolors)
fig = plt.figure(figsize=figsize)
ax = fig.gca(projection='3d')
ax.voxels(*shrink(filled_2), filled_2, facecolors=fcolors_2)
if det_coords is not None:
ax.scatter(det_coords[:, 0],
det_coords[:, 1],
zs=np.min(det_coords[:, 2]),
zdir='z',
linewidth=3)
plt.show(block=False)
def save_images(self):
"""
Save the extracted images
:return:
"""
rgb_np = self.get_rgb_np()
thermal_np = self.extract_thermal_image()
img_visual = Image.fromarray(rgb_np)
thermal_normalized = (thermal_np - np.amin(thermal_np)) / (
np.amax(thermal_np) - np.amin(thermal_np))
img_thermal = Image.fromarray(
np.uint8(cm.inferno(thermal_normalized) * 255))
fn_prefix, _ = os.path.splitext(self.flir_img_filename)
thermal_filename = fn_prefix + self.thermal_suffix
image_filename = fn_prefix + self.image_suffix
if self.use_thumbnail:
image_filename = fn_prefix + self.thumbnail_suffix
if self.is_debug:
print("DEBUG Saving RGB image to:{}".format(image_filename))
print("DEBUG Saving Thermal image to:{}".format(thermal_filename))
img_visual.save(image_filename)
img_thermal.save(thermal_filename)
def save_images(self, options):
"""
Save the extracted images
:return:
"""
options = options.split('|')
rgb_np = self.rgb_image_np
thermal_np = self.thermal_image_np
img_visual = Image.fromarray(rgb_np)
thermal_normalized = (thermal_np - np.amin(thermal_np)) / (np.amax(thermal_np) - np.amin(thermal_np))
img_thermal = Image.fromarray(np.uint8(cm.inferno(thermal_normalized) * 255))
img_gray = Image.fromarray(np.uint8(cm.binary(thermal_normalized) * 255))
fn_prefix, _ = os.path.splitext(self.flir_img_filename)
thermal_filename = fn_prefix + self.thermal_suffix
image_filename = fn_prefix + self.image_suffix
grayscale_filename = fn_prefix + self.grayscale_suffix
if self.use_thumbnail:
image_filename = fn_prefix + self.thumbnail_suffix
if self.is_debug:
print("DEBUG Saving RGB image to:{}".format(image_filename))
print("DEBUG Saving Thermal image to:{}".format(thermal_filename))
print("DEBUG Saving Gray image to:{}".format(grayscale_filename))
if 'rgb' in options:
img_visual.save(image_filename)
if 'thermal' in options:
img_thermal.save(thermal_filename)
if 'gray' in options:
img_gray.save(grayscale_filename)
def lineplot_files(fnames, xlabels, yaxis):
color = cm.inferno(np.linspace(0.1, 0.4, len(fnames)))
nfiles = len(fnames)
data_means = []
data_stds = []
data_pos = np.arange(nfiles)
for i in range(0,nfiles):
temp_data = np.loadtxt("data/context-switches/" + fnames[i])
temp_mean = st.hmean(temp_data)
temp_std = np.std(temp_data)
data_means.append(temp_mean)
data_stds.append(temp_std)
ax, fig = plt.subplots(1, figsize=(3.5,6))
ax = plt.bar(data_pos, data_means, yerr=data_stds, align='center',capsize=10, width=0.2, color=color)
plt.xticks(data_pos, xlabels, rotation=30)
plt.ylabel(yaxis)
# Save figure
plt.tight_layout()
plt.savefig("context_switches.pdf")
def audio_to_spectrum(audio_batch):
def convert_(audio):
spectrogram = librosa.feature.melspectrogram(
audio[:16384], sr=16000, n_mels=64, n_fft=512, hop_length=256)
log_amp = librosa.core.amplitude_to_db(spectrogram)[::-1, :]
return log_amp
audio_batch = audio_batch[:100]
specturm_batch = [convert_(audio) for audio in audio_batch]
specturm_batch = np.array(specturm_batch)
specturm_batch = np.clip(specturm_batch, -100.0, 0.0) / 100.0 + 1.0
for index_b in range(specturm_batch.shape[0]):
min_v_ = specturm_batch[index_b].min()
max_v_ = specturm_batch[index_b].max()
specturm_batch[
index_b] = (specturm_batch[index_b] - min_v_) / (max_v_ - min_v_)
# [0., 1.0], means -100 to 0 e.g. 100db to 0db
# http://thomas-cokelaer.info/blog/2014/09/about-matplotlib-colormap-and-how-to-get-rgb-values-of-the-map/
img = np.zeros(list(specturm_batch.shape) + [3])
for index_b in range(specturm_batch.shape[0]):
for index_x in range(specturm_batch.shape[1]):
for index_y in range(specturm_batch.shape[2]):
v = int(specturm_batch[index_b][index_x][index_y] * 255)
r, g, b, _ = cm.inferno(v)
img[index_b][index_x][index_y] = [r, g, b]
# specturm_batch = np.clip(specturm_batch, -100.0, 0.0) / 100.0 + 1.0
# [0., 1.0], means -100 to 0 e.g. 100db to 0db
# img = np.stack((specturm_batch,) * 3, -1) # grey -> rgb
return img
def make_color_lookup(self):
self.color_lookup = np.zeros(shape=(256, 4))
for aa in range(256):
r, g, b, _ = cm.inferno(aa)
alpha = (aa / 256)
self.color_lookup[aa, :] = [r, g, b, alpha]
def topOverall(topk=30):
df = pd.read_csv(FIFA_DIR, encoding="utf-8")[['Name', 'Overall']]
df.sort_values(by='Overall')
df = df.head(topk)
colors = [cm.inferno(x) for x in np.linspace(0, 1, topk)]
plt.bar(df['Name'], df['Overall'] - 80, bottom=80, color=colors)
plt.xticks(rotation=90)
plt.title('Top {} Overall'.format(topk))
plt.show()
def plot_set(data_wide,
idx_calibration,
idx_change_1,
idx_change_0,
datapath,
y_var="$\Delta T$",
title=""):
fig, (ax) = plt.subplots(1, 1, gridspec_kw={'height_ratios': [3]})
plt.subplots_adjust(left=.15,
bottom=.333,
right=.85,
top=.95,
wspace=0,
hspace=0)
capture_start = .75
capture_range = .2
idx_look = np.argwhere(idx_calibration == 1).ravel()
colors = cm.inferno(np.linspace(0, 1, idx_look.size + 2))
data_a = data_wide[0:0] # empty array to hold the data
for ii, i in enumerate(idx_look):
data_s = data_wide.iloc[idx_change_0[i]:idx_change_1[i]]
idx_range = idx_change_1[i] - idx_change_0[i]
idx_a, idx_b = int(capture_start *
idx_range), int(capture_start * idx_range +
capture_range * idx_range)
# local_dataframe= data_s.iloc[idx_a:idx_b].agg(['mean'])
local_dataframe = data_s.iloc[idx_a:idx_b].mean(numeric_only=None)
data_a = data_a.append(local_dataframe, ignore_index=True)
label = "%1.0i: Temp: %3.1f, Mass Flow: %3.2f" % (
i, local_dataframe["T Preheat Setpoint"],
local_dataframe["Mass Flow Rate (kg/hr)"])
ax.plot(data_s["Time (hr)"] - data_s["Time (hr)"].iloc[0],
data_s[y_var],
label=label,
c=colors[ii])
ax.axhline(y=local_dataframe[y_var],
linestyle="-.",
lw=1,
c=colors[ii],
label='_nolegend_')
ax.set_ylabel(y_var) # we already handled the x-label with ax1
ax.set_xlabel('Time (hr)') # we already handled the x-label with ax1
ax.set_title(title) # we already handled the x-label with ax1
# ax.xaxis.tick_top()
# ax.xaxis.set_label_position("top")
# ax.set_xlim([0,np.max(data_s["Time (hr)"])])
fig.legend(loc='lower center',
borderaxespad=0.2,
fontsize=8,
frameon=False)
fig.savefig(pjoin(datapath, '0_' + title.replace(' ', '') + '.png'))
return fig, data_a
def make_intensity_lookup(self):
rospy.loginfo("make_intensity_lookup")
self.intensity_lookup = [0 for _ in range(256)]
for aa in range(256):
r, g, b, _ = cm.inferno(aa)
rr = int(255 * r)
gg = int(255 * g)
bb = int(255 * b)
rgba = struct.unpack('I', struct.pack('BBBB', bb, gg, rr, aa))[0]
self.intensity_lookup[aa] = rgba
def cat_spatiale_trajets(prob_dist, prob_duree, data, li_spat):
df = data.copy()
df['V2_DUREE'] = pd.to_timedelta(
df['V2_DUREE'], unit='Min').dt.round('1Min').dt.total_seconds() // 60
df = df[(df['V2_DUREE'] < 200) & (np.floor(df['V2_MMOTIFDES']) == 9) &
(df['V2_MORICOM_MDESCOM_indicUU'] == 1)].copy()
colors = cm.winter(np.linspace(0, 1, len(li_spat)))
colors_outli = cm.inferno(np.linspace(0, 1, len(li_spat)))
li_co = {}
for i in range(len(li_spat)):
# sprint(li_spat[i])
if df[df['SPATIAL'] == i]['V2_DUREE'].count() != 0:
df_filt = df[df['SPATIAL'] == i].copy()
te = sm.OLS(df_filt['V2_MDISTTOT'].values,
df_filt['V2_DUREE'].values.reshape(-1, 1))
res = te.fit()
influ = res.get_influence()
(cook, p) = influ.cooks_distance
df_filt['COOK'] = cook
cook_outlier = [(df_filt['V2_DUREE'].values[o],
df_filt['V2_MDISTTOT'].values[o])
for o, t in enumerate(cook) if t > 4 / len(cook)]
print(cook_outlier)
plt.scatter(
df_filt[df_filt['COOK'] <= 8 / len(cook)]['V2_DUREE'],
df_filt[df_filt['COOK'] <= 8 / len(cook)]['V2_MDISTTOT'],
color=colors[i])
plt.plot(df_filt['V2_DUREE'],
res.predict(df_filt['V2_DUREE'].values))
plt.scatter(
df_filt[df_filt['COOK'] > 8 / len(cook)]['V2_DUREE'],
df_filt[df_filt['COOK'] > 8 / len(cook)]['V2_MDISTTOT'],
color=colors_outli[i])
modele_sans_outlier = sm.OLS(
df_filt[df_filt['COOK'] <= 4 /
len(cook)]['V2_MDISTTOT'].values,
df_filt[df_filt['COOK'] <= 4 /
len(cook)]['V2_DUREE'].values.reshape(-1, 1))
res_ss_outli = modele_sans_outlier.fit()
plt.plot(df_filt['V2_DUREE'],
res_ss_outli.predict(df_filt['V2_DUREE'].values))
plt.show()
li_co[li_spat[i]] = [
np.round(res.params[0] * 60, decimals=1),
np.round(res.rsquared * 100, decimals=2),
df[df['SPATIAL'] == i]['V2_MDISTTOT'].count()
]
print(np.round(res.rsquared * 100, decimals=2),
np.round(res_ss_outli.rsquared * 100, decimals=2))
else:
li_co[li_spat[i]] = [0]
print(li_co)
# plt.scatter(df[df['V2_MORICOM_MDESCOM_indicUU']==1]['V2_MDISTTOT'],df[df['V2_MORICOM_MDESCOM_indicUU']==1]['V2_DUREE'],color = 'm')
return li_co
def NewAlphaZeroColormap(orig_cm, name, extent=25):
"""
Only works for ListedColormaps
"""
newcolors = orig_cm(crange)
init = cm.inferno(0, alpha=0)
final = newcolors[extent]
t = crange[:extent][:, None] / crange[extent]
newcolors[:extent] = t * t * t * np.subtract(final, init) + init
new_cm = ListedColormap(newcolors, name=name)
cm.register_cmap(name=name, cmap=new_cm)
def plot_hist(ax, data, label):
from matplotlib import cm
colors = [cm.inferno(x) for x in np.linspace(0, 1, len(data))]
for c,component in enumerate(data):
if np.nanmax(component)>1e5:
bins = np.logspace(np.log10(np.nanmin(component)),np.log10(np.nanmax(component)), 20)
ax.set_xscale('log')
else:
bins = 20
ax.hist(component, bins=bins, histtype='step', color=colors[c], label=str(c+1))
ax.hist(component, bins=bins, histtype='stepfilled', color=colors[c], alpha=0.5, label=None)
ax.set_xlabel(label, fontsize=12)
def plot_ei_regime(ax, data, JEI, JII, filename, fig, zoom_in, zoom_lims,
scales):
JII_b = np.array(data["points_fr_gpe"]) * 0.725 * 40 * 10
JEI_b = np.array(data["points_fr_stn"]) * 1.2 * 23 * 5
ax1 = ax.twinx().twiny()
#if zoom_in == True:
# ax1.margins(x=zoom_lims[0],y=zoom_lims[1])
for k, (x_row, y_row) in enumerate(zip(JEI_b, JII_b)):
arr_col = cm.inferno(float(k) / len(JEI_b))
for l, (x_col, y_col) in enumerate(zip(x_row, y_row)):
if l < len(x_row) - 1:
ax1.arrow(x_col,
y_col,
x_row[l + 1] - x_col,
y_row[l + 1] - y_col,
head_width=50,
length_includes_head=True,
fc=arr_col,
ec=arr_col,
linestyle='-',
linewidth=1.0)
if k % 2 == 0:
ax1.plot(x_col,
y_col,
marker='o',
markersize=12,
color=arr_col,
label='gpe ratio:' + str(gpe_rat[k]),
alpha=0.8)
else:
ax1.plot(x_col,
y_col,
marker='o',
markersize=12,
color=arr_col,
alpha=0.8)
ax1.plot(x_row[0],
y_row[0],
marker='*',
markersize=12,
color=arr_col,
alpha=0.8)
handles, labels = ax1.get_legend_handles_labels()
ax1.set_xlim(ax.get_xlim())
ax1.set_ylim(ax.get_ylim())
ax1.set_xticklabels([])
ax1.set_yticklabels([])
def save_images(self):
"""
Save the extracted images
:return:
"""
rgb_np = self.get_rgb_np()
thermal_np = self.extract_thermal_image()
# Generate Images out of numpy arrays
img_visual = Image.fromarray(rgb_np)
thermal_normalized = (thermal_np - np.amin(thermal_np)) / (
np.amax(thermal_np) - np.amin(thermal_np))
img_thermal = Image.fromarray(
np.uint8(cm.inferno(thermal_normalized) * 255))
cropped_img_visual = Image.fromarray(self.cropped_visual_np)
downscaled_img_visual = Image.fromarray(self.downscaled_rgb_image_np)
fn_prefix, _ = os.path.splitext(self.flir_img_filename)
# Generate the paths for the images
thermal_filename = os.path.join(fn_prefix + '/' +
fn_prefix.split('/')[1] +
self.thermal_suffix)
image_filename = os.path.join(fn_prefix + '/' +
fn_prefix.split('/')[1] +
self.image_suffix)
cropped_image_filename = os.path.join(fn_prefix + '/' +
fn_prefix.split('/')[1] +
self.cropped_image_suffix)
downscaled_image_filename = os.path.join(fn_prefix + '/' +
fn_prefix.split('/')[1] +
self.downscaled_image_suffix)
if self.use_thumbnail:
image_filename = os.path.join(fn_prefix + '/' +
fn_prefix.split('\\')[6] +
self.thumbnail_suffix)
if self.is_debug:
print("DEBUG Saving RGB image to:{}".format(image_filename))
print("DEBUG Saving Thermal image to:{}".format(thermal_filename))
print("DEBUG Saving RGB cropped image image to:{}".format(
cropped_image_filename))
print("DEBUG Saving RGB downscaled image to:{}".format(
downscaled_image_filename))
img_visual.save(image_filename)
img_thermal.save(thermal_filename)
downscaled_img_visual.save(downscaled_image_filename)
cropped_img_visual.save(cropped_image_filename)
def plot(ind, square_sizes):
maxX = max([x[0] + square_sizes[i] for i, x in enumerate(ind)])
maxY = max([x[1] + square_sizes[i] for i, x in enumerate(ind)])
grid = np.zeros((maxX, maxY))
for square_index in range(len(square_sizes)):
for x in range(ind[square_index][0],
ind[square_index][0] + square_sizes[square_index]):
for y in range(ind[square_index][1],
ind[square_index][1] + square_sizes[square_index]):
grid[x, y] = square_index
my_cmap = cm.inferno(np.arange(cm.inferno.N))
my_cmap[:, -1] = np.linspace(0, 1, cm.inferno.N)
my_cmap = ListedColormap(my_cmap)
plt.imshow(grid, cmap=my_cmap, alpha=0.3)
plt.xticks([]), plt.yticks([])
plt.show()
def setup_ui(self):
# {
# Configure the main window defaults. It enables mouse tracking to
# be used by the zoom, and sets a black background.
policy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
policy.setHorizontalStretch(0)
policy.setVerticalStretch(0)
policy.setHeightForWidth(False)
self.setSizePolicy(policy)
self.setMouseTracking(True)
pal = self.palette()
pal.setColor(QtGui.QPalette.Background, QtCore.Qt.black)
self.setAutoFillBackground(True)
self.setPalette(pal)
# }
# {
# Pre-compute RGBA values for the two different modes from the `inferno`
# colormap.
#
# self.rgbas_alpha is used when the heatmap is overlayed atop the image.
# self.rgbas_noalpha is used when no image is displayed.
indices = np.linspace(0, 1, 256)
rgbas = cm.inferno(indices)
self.rgbas_noalpha = [
QtGui.QColor(
int(r * 255),
int(g * 255),
int(b * 255),
int(a * 255)).rgba() for r, g, b, a in rgbas]
rgbas[:,3] *= indices
self.rgbas_alpha = [
QtGui.QColor(
int(r * 255),
int(g * 255),
int(b * 255),
int(a * 255)).rgba() for r, g, b, a in rgbas]
def plotMedianDacNoise(nos, detFreq=150, getGoodDetsFromStats=True, show=True):
''' gets a list of noise observations, splits the data in detector types
and makes a plot of the median psd
'''
no = nos[0]
colors = cm.inferno(np.linspace(0, 1, len(nos)))
if not getGoodDetsFromStats:
detFreqs = no.detFreqs
row, col = np.where(detFreqs == detFreq)
print "warning, blindly plotting dets of the same freq"
alpha = 0.4
for j in range(len(nos)):
color = colors[j]
no = nos[j]
if getGoodRowsColsFromNoiseStats:
if no.pctRn != 0:
row, col = getGoodRowsColsFromNoiseStats(
no.array, no.pctRn, detFreq)
md = np.mean(no.pxx[row, col, :], axis=-2)
if no.pctRn == 0:
color = 'blue'
alpha = 0.6
plt.loglog(no.f,
md,
label='pctRn: %i, N_det: %i' % (no.pctRn, len(row)),
alpha=alpha,
color=color)
plt.ylim([3e-4, 40.0])
plt.legend()
title = 'Array: %s. %i GHz mean psd.' % (no.array, detFreq)
title = title.replace('AR', 'PA')
plt.title(title)
plt.xlabel('f [Hz]')
plt.ylabel('psd [$\\frac{dac^2}{Hz}$]')
plt.tight_layout()
if show:
plt.show()
else:
plt.savefig('results/average_HighFreqSpectrum_%s_detFreq_%i.pdf' %
(no.array, detFreq))
plt.close()
def main():
flags = parse_args()
images = sorted(os.listdir(os.path.join(flags.data, 'depth')))
frames = []
for i, image in enumerate(images):
print(f"Reading image {image}", end='\r')
path = os.path.join(flags.data, 'depth', image)
depth = np.load(path)
max_depth = 7.5
depth_m = depth / 1000.0
depth_map = np.clip(1.0 - depth_m / max_depth, 0.0, 1.0)
depth_map = cm.inferno(depth_map)
frames.append((depth_map * 255).astype(np.uint8))
writer = io.FFmpegWriter(os.path.join(flags.data, 'depth_video.mp4'))
try:
for i, frame in enumerate(frames):
print(f"Writing frame {i:06}" + " " * 10, end='\r')
writer.writeFrame(frame)
finally:
writer.close()
def __init__(self, fname_path, skip_thermal=False):
assert os.path.exists(fname_path), f'file {fname_path} does not exists'
self.fname_path = fname_path
self.datetime = self.extract_datetime()
self.fie = flir_image_extractor.FlirImageExtractor(
image_suffix="v.jpg", thermal_suffix="t.png")
cached_thermal = ImageFiles.get_cached_thermal(
fname_path) if Cfg.cache_thermal_allowed else None
self.fie.process_image(fname_path, cached_thermal, skip_thermal)
self.flir_img = self.get_flir_image(fname_path)
self.visual_img = self.fie.get_rgb_np()
self.thermal_np = self.fie.get_thermal_np()
thermal_normalized = (self.thermal_np - np.amin(self.thermal_np)) \
/ (np.amax(self.thermal_np) - np.amin(self.thermal_np))
self.thermal_img = np.array(
np.uint8(cm.inferno(thermal_normalized) * 255)) # inferno,gray
self.thermal_img = cv.cvtColor(self.thermal_img, cv.COLOR_RGBA2BGR)
self.vis_therm_ratio = (self.visual_img.shape[0] /
self.thermal_np.shape[0],
self.visual_img.shape[1] /
self.thermal_np.shape[1])
if self.flir_img.shape[0] > self.flir_img.shape[1]: # vertical
# transpose
# self.flir_img = cv.transpose(self.flir_img)
# self.visual_img = cv.transpose(self.visual_img)
# self.thermal_np = cv.transpose(self.thermal_np)
# self.thermal_img = cv.transpose(self.thermal_img)
# rotate
self.flir_img = np.rot90(self.flir_img)
self.visual_img = np.rot90(self.visual_img)
self.thermal_np = np.rot90(self.thermal_np)
self.thermal_img = np.rot90(self.thermal_img)
self.image_id = ImageFiles.save(self.datetime, self.flir_img,
self.visual_img, self.thermal_np)
self.skip_thermal = skip_thermal
def plot_deu_by_level(self, maxlevel, d0list, dumb=True):
"""
Plots the defender's expected utility.
"""
res = self.lkresults
fig, ax = plt.subplots()
ix = 0
for d0 in d0list:
if len(d0list) ==1:
b = 1
else:
b = (255 - 255*ix/float(len(d0list)))/float(255)
toplot = self.deu_over_levels(maxlevel, d0, dumb).values.T
ax.plot(np.arange(0, maxlevel,2), toplot, color = cm.inferno(int(255*(1-b))), linewidth=1)
ix +=1
if len(d0list) > 1:
ax2 = fig.add_axes([0.95, 0.12, 0.05, 0.78])
cb = mpl.colorbar.ColorbarBase(ax2, cmap=plt.cm.inferno,
boundaries=d0list,
label="Initial Threshold")
fig.suptitle("Defender of level-$k$ expected utility against an attacker of level $k+1$.", fontsize=12)
ax.set_xlabel("$k$")
ax.set_ylabel("Defender's Expected Utility")
return fig, ax
def draw_brush(self, x, y):
width = self.line_width
color = self.color
if self.shrink != 0:
interpolation_factor = ((self.shrink - 1) / 9.0)
value = 50.0 * interpolation_factor + 500.0 * (
1.0 - interpolation_factor)
width *= (value - self.distance) / value
width = max(0, int(width))
color_index = 255 * (value - self.distance) / value
color_index = 255 - max(0, int(color_index))
color = cm.inferno(color_index)
color = (int(color[0] * 255), int(color[1] * 255),
int(color[2] * 255))
if width == 0:
return
color_image = Image.new("RGBA",
size=(2 * width, 2 * width),
color=color)
image = self.brush_image.resize((2 * width, 2 * width),
Image.ANTIALIAS)
image = ImageChops.multiply(image, color_image)
overall_image = Image.new("RGBA", size=self.size, color="black")
points = self.get_mandala_points(x, y)
for (x, y) in points:
x = int(x)
y = int(y)
self.pilImage.paste(image, (x - width, y - width), image)
self.refresh()
def draw_stixels(stixels,
max_disparity,
disparity_image=None,
semantic_image=None,
semantic_labelImg=None,
cost_image=None,
max_cost=1e4,
instancegt_mask=None,
disparity_result_image=None,
instance_image=None):
"""
This method visualizes the stixels as images. Output images are for example
a semantic segmentation image which visualizes each class by a color.
A stixel will then be drawn as a rectangle. Optionally, a border can be
drawn around the stixel. The final result can then be overlayed with the
original RGB image.
Note: Over the course of implementing and especially extending the
proof of conecpt, it has become quite a mess, but it works.
"""
instance_gt_image = None
shape = None
for img in (semantic_image, disparity_image, semantic_labelImg):
if img is not None:
shape = img.shape[:2]
if shape is None:
raise ValueError("At least one output image has to be provided!")
stixel_width = shape[1] // len(stixels)
print("Stixel width = {}".format(stixel_width))
print("image shape = {}".format(shape))
stixel_count = 0
for col, column_stixels in enumerate(stixels):
for stixel in column_stixels:
stixel_count += 1
# Decide color based upon stixel type.
color = (255, 255, 255) # type 0 (ground)
instance_color = np.array((0, 0, 0, 255), dtype=np.float)
#cost = stixel[5] / max
min_cost = -1e4
max_cost = 1e4
factor = max((stixel[5] - min_cost), 0) / (max_cost - min_cost)
cost = (1. - factor) * 255
# Compute image coordinates
# *.stixels file OpenCV
# row in [0,h-1] y in [0,h-1]
# ^ 0/0---x---->
# | |
# | |
# row y
# | |
# | |
# 0/0--column--> v
# y = (h-1) - row
topleft_x = col * stixel_width
topleft_y = shape[0] - stixel[2] - 1 # vT, mirror y-axis
bottomright_x = topleft_x + stixel_width - 1 # e.g. width 5: 0-4,5-9,
bottomright_y = shape[0] - stixel[1] - 1 # vB, mirror y-axis
# type distinction
# type 2 (sky)
if stixel[0] == 2 or (stixel[0] == 1 and stixel[3] < 1.0):
color = (255, 191, 0)
elif stixel[0] == 1: # type 1 (object)
# Cropping of at disparities of max_disparity * 2e-2 = 2.56 and
# below.
distance = min(float(stixel[3] + 20) / max_disparity, 1.)
color = np.array([[cm.inferno(distance)[:3]]]) * 255
color = color.astype(np.uint8)
color = cv2.cvtColor(color, cv2.COLOR_RGB2BGR)
color = color[0, 0].tolist()
# compute instance affiliation from ground truth
if instancegt_mask is not None:
# Only consider classes with instances.
if stixel[4] < 11: # 10 is sky
instance_color = np.array((0., 0., 0., 255.))
else:
max_instanceid = 0
# Must be at least 10% of stixel.
max_instanceid_pixels = 0
# Only use instance mask of predicted class.
# Before:for mask in instancegt_mask:
mask = instancegt_mask[stixel[4] - 11]
# extract pixels that belong to stixel from mask
stixel_pixels = mask[topleft_y:bottomright_y+1,
topleft_x:bottomright_x+1]\
.astype(np.int)
pixels_per_id = np.bincount(np.ravel(stixel_pixels))
# ignore zero-rows-stixels
if len(pixels_per_id) > 0:
max_instanceid_pixels = pixels_per_id.max()
max_instanceid = pixels_per_id.argmax()
instance_color =\
COLOR_LUT_RANDOM[max_instanceid\
% len(COLOR_LUT_RANDOM),
:]
# Alpha based on number of instance pixels.
#alpha = np.clip(max_instanceid_pixels, 150.0, 255.0)
alpha = 255.0
instance_color = np.concatenate(
[instance_color, [alpha]])
instance_color = instance_color.astype(np.float)
if max_instanceid == 0:
instance_color[:3] = 255.0
instance_color[3] = 255.0
elif (max_instanceid_pixels < 0.1 * stixel_width *
(bottomright_y - topleft_y)):
instance_color[:3] = 255.0
if instancegt_mask is not None:
if instance_gt_image is None:
instance_gt_image = np.zeros(
(*disparity_image.shape[:2], 4))
cv2.rectangle(instance_gt_image, (topleft_x, topleft_y),
(bottomright_x, bottomright_y),
instance_color,
thickness=-1) # fill rectangle
# let's skip borders for now
if False:
if np.abs(topleft_y - bottomright_y) > 1:
cv2.rectangle(instance_gt_image,
(topleft_x, topleft_y),
(bottomright_x + 1, bottomright_y + 1),
0,
thickness=1) # border only on left side
if instance_image is not None:
if len(stixel) > 8:
instance_id = int(stixel[8])
if instance_id == -1:
instance_color = np.array((255., 255., 255.))
else:
instance_color = COLOR_LUT_RANDOM[
instance_id % len(COLOR_LUT_RANDOM), :]
instance_color = instance_color.astype(np.float)
cv2.rectangle(instance_image, (topleft_x, topleft_y),
(bottomright_x, bottomright_y),
instance_color,
thickness=-1) # fill rectangle
if True:
if np.abs(topleft_y - bottomright_y) > 1:
cv2.rectangle(instance_image, (topleft_x, topleft_y),
(bottomright_x, topleft_y - 2),
(255, 255, 255),
thickness=-1) # border only on left side
if disparity_image is not None and len(stixel) > 4:
cv2.rectangle(disparity_image, (topleft_x, topleft_y),
(bottomright_x, bottomright_y),
color,
thickness=-1) # fill rectangle
# Border always overlaps with right and bottom neighboring
# stixel.
#if np.abs(topleft_y - bottomright_y) > 2:
# cv2.rectangle(disparity_image,
# (topleft_x, topleft_y),
# (bottomright_x+1, bottomright_y+1),
# (0,0,0),
# thickness=1) # border only on left side
if semantic_image is not None and len(stixel) > 4:
cv2.rectangle(semantic_image, (topleft_x, topleft_y),
(bottomright_x, bottomright_y),
stixel[4] + 1,
thickness=-1) # fill rectangle
if False: # one pixel width border (around)
if np.abs(topleft_y - bottomright_y) > 1:
cv2.rectangle(semantic_image, (topleft_x, topleft_y),
(bottomright_x + 1, bottomright_y + 1),
0,
thickness=1) # border only on left side
if True: # upper end border of "width" pixels
width = 1
if np.abs(topleft_y - bottomright_y) > 1:
cv2.rectangle(semantic_image, (topleft_x, topleft_y),
(bottomright_x, topleft_y - width),
0,
thickness=-1) # border only on left side
if cost_image is not None and len(stixel) > 4:
cv2.rectangle(cost_image, (topleft_x, topleft_y),
(bottomright_x, bottomright_y),
int(cost),
thickness=-1) # fill rectangle
# --- result images
if semantic_labelImg is not None and len(stixel) > 4:
cv2.rectangle(semantic_labelImg, (topleft_x, topleft_y),
(bottomright_x, bottomright_y),
cityscapes_labels.trainId2label[stixel[4]].id,
thickness=-1) # fill rectangle
if disparity_result_image is not None:
# TODO: Handle ground stixels appropriately.
cv2.rectangle(disparity_result_image, (topleft_x, topleft_y),
(bottomright_x, bottomright_y),
stixel[3],
thickness=-1) # fill rectangle
print("Processed {} stixels.".format(stixel_count))
return (disparity_image, semantic_image, semantic_labelImg, cost_image,
stixel_count, instance_gt_image, disparity_result_image,
instance_image)
def plot_obse_samplers(
lcset_name,
lcset_info,
obse_sampler_bdict,
original_space: bool = 1,
pdf_scale: float = 0.01,
figsize=FIGSIZE_2X1,
dpi=DPI,
add_samples=0,
save_filedir=None,
):
survey = lcset_info['survey']
band_names = lcset_info['band_names']
fig, axs = plt.subplots(1, 2, figsize=figsize, dpi=dpi)
for kb, b in enumerate(band_names):
ax = axs[kb]
obse_sampler = obse_sampler_bdict[b]
if original_space:
label = '$p(x_{ij},\sigma_{xij})$' + f' {lcset_name} samples'
ax.plot(obse_sampler.raw_obse,
obse_sampler.raw_obs,
'k.',
markersize=2,
alpha=0.2)
ax.plot(np.nan, np.nan, 'k.', label=label)
### add samples
if add_samples:
n = int(2e3)
to_sample = obse_sampler.raw_obs
std = 1e-4
new_obs = [
np.random.normal(
to_sample[np.random.randint(0, len(to_sample))], std)
for _ in range(n)
] # kde
#x = 0.05; new_obs = np.linspace(x, x+0.001, 1000) # sanity check
new_obse, new_obs = obse_sampler.conditional_sample(new_obs)
ax.plot(new_obse, new_obs, 'r.', markersize=2, alpha=1)
ax.plot(np.nan,
np.nan,
'r.',
label='$\hat{p}(x_{ij},\sigma_{xij})$ samples (KDE)')
### rot axis
x = np.linspace(obse_sampler.raw_obse.min(),
obse_sampler.raw_obse.max(), 100)
ax.plot(x,
x * obse_sampler.m + obse_sampler.n,
'b',
alpha=0.75,
label='rotation axis',
lw=1)
#ax.plot(obse_sampler.lr_x, obse_sampler.lr_y, 'b.', alpha=1, markersize=4); ax.plot(np.nan, np.nan, 'b.', label='rotation axis support samples')
ax.set_xlabel('observation-error')
ax.set_ylabel('observation-flux' if kb == 0 else None)
ax.set_xlim([0.0, 0.05])
ax.set_ylim([0.0, 0.3])
else:
label = '$p(x_{ij}' + "'" + ',\sigma_{xij}' + "'" + ')$' + f' empirical samples'
ax.plot(obse_sampler.obse,
obse_sampler.obs,
'k.',
markersize=2,
alpha=0.2)
ax.plot(np.nan, np.nan, 'k.', label=label)
min_obse = obse_sampler.obse.min()
max_obse = obse_sampler.obse.max()
pdfx = np.linspace(min_obse, max_obse, 200)
colors = cm.inferno(np.linspace(0, .5, len(obse_sampler.distrs)))
min_pdfy = np.infty
for p_idx in range(len(obse_sampler.distrs)):
d = obse_sampler.distrs[p_idx]
if p_idx % 10 == 0:
rank_ranges = obse_sampler.rank_ranges[p_idx]
pdf_offset = rank_ranges[1] # upper of rank range
pdfy = d['distr'].pdf(pdfx, *d['params'])
pdfy = pdfy / pdfy.max() * pdf_scale + pdf_offset
c = colors[p_idx]
label = '$q(\sigma_{xij}' + "'" + '|x_{ij}' + "'" + ')$ Normal distribution fit'
ax.plot(pdfx,
pdfy,
c=c,
alpha=1,
lw=1,
label=label if p_idx == 0 else None)
min_pdfy = pdfy.min(
) if pdfy.min() < min_pdfy else min_pdfy
ax.set_xlabel('rotated-flipped observation-error')
ax.set_ylabel('rotated observation-flux' if kb == 0 else None)
#ax.set_xlim([0.0, 0.02])
ax.set_ylim([min_pdfy, 1])
title = ''
title += f'{latex_bf_alphabet_count(kb)} Joint distribution from {lcset_name}; band={b}' + '\n'
ax.set_title(title[:-1])
ax.legend(loc='upper left')
### multiband colors
[
ax.spines[border].set_color(COLOR_DICT[b])
for border in ['bottom', 'top', 'right', 'left']
]
[
ax.spines[border].set_linewidth(2)
for border in ['bottom', 'top', 'right', 'left']
]
fig.tight_layout()
save_fig(save_filedir, fig)
def make_coolingfile(colfiles):
'''
prepost.make_coolingfile
PURPOSE:
Reads in a bunch of outfiles and writes a single parameter file with nh, T and the volume emissivity
INPUTS:
colfiles:[list/array] All the .col files for the completed runs
OUTPUTS:
File with nh, T and volume emissivity, Lambda
NOTES:
Likely only works if the grid is a rectangle. May want to change this in the future?
Also will want to remove interpolation section once grid is complete.
'''
outdata = []
for i, f in enumerate(colfiles):
try:
data = np.genfromtxt(f, skip_header = 1, usecols=[1,3])
except StopIteration:
print('File empty: ' +f)
continue
except ValueError:
pdb.set_trace()
density = float(f.split('__n')[1].split('.col')[0])
Temperature = float(f.split('__T')[1].split('__')[0])
outdata.append([data[1], density, Temperature])
outdata = np.array(outdata)
maxcool = np.max(np.log10(outdata[:,0]))
mincool = np.min(np.log10(outdata[:,0]))
for i, point in enumerate(outdata):
plt.scatter(point[2], point[1], color = cm.inferno((np.log10(point[0])-mincool)/(maxcool - mincool), 1), s = 50, marker = 's')
sm = plt.cm.ScalarMappable(cmap=cm.inferno, norm=plt.Normalize(vmin=mincool, vmax=maxcool))
sm.set_array(outdata[:,2])
plt.colorbar(sm)
plt.show()
#Sort the data into a grid
unT = np.unique(outdata[:,2])
unN = np.unique(outdata[:,1])
grid = np.zeros([len(unT), len(unN)])
for i, x in enumerate(unT):
for j, y in enumerate(unN):
ind = (outdata[:,2] == x) * (outdata[:,1] == y)
if np.sum(ind) == 0:
grid[i,j] = np.nan
else:
grid[i,j] = outdata[np.where(ind)[0][0],0]
#Write out the grid + temp/density
gridfile = open('coolinggrid.txt', 'w')
gridfile.write('Grid containing volume emissivities from Cloudy coronal models. First row is log10(nh), first column is T\n')
gridfile.write('#-------------------------------------------------------------------------------------------------------#\n')
gridfile.write('0, ')
line = ''
for val in unN:
line = line + str(val) +', '
line = line[:-2] +'\n'
gridfile.write(line)
for i, line in enumerate(grid):
line = str(unT[i]) +', '
for val in grid[i]:
line = line +str(val) +', '
line = line[:-2] + '\n'
gridfile.write(line)
gridfile.close()
def transform_and_clean_hex_image(pmt_signal, cam_geom, photo_electrons):
start_time = time.time()
colors = cm.inferno(pmt_signal/max(pmt_signal))
new_geom, new_signal = convert_geometry_1d_to_2d(
cam_geom, pmt_signal, cam_geom.cam_id)
print("rot_signal", np.count_nonzero(np.isnan(new_signal)))
square_mask = new_geom.mask
cleaned_img = wavelet_transform(new_signal,
raw_option_string=args.raw)
unrot_img = cleaned_img[square_mask]
unrot_colors = cm.inferno(unrot_img/max(unrot_img))
cleaned_img_ik = kill_isolpix(cleaned_img, threshold=.5)
unrot_img_ik = cleaned_img_ik[square_mask]
unrot_colors_ik = cm.inferno(unrot_img_ik/max(unrot_img_ik))
square_image_add_noise = np.copy(new_signal)
square_image_add_noise[~square_mask] = \
np.random.normal(0.13, 5.77, np.count_nonzero(~square_mask))
square_image_add_noise_cleaned = wavelet_transform(square_image_add_noise,
raw_option_string=args.raw)
square_image_add_noise_cleaned_ik = kill_isolpix(square_image_add_noise_cleaned,
threshold=1.5)
unrot_geom, unrot_noised_signal = convert_geometry_back(
new_geom, square_image_add_noise_cleaned_ik, cam_geom.cam_id)
end_time = time.time()
print(end_time - start_time)
global fig
global cb1, ax1
global cb2, ax2
global cb3, ax3
global cb4, ax4
global cb5, ax5
global cb6, ax6
global cb7, ax7
global cb8, ax8
global cb9, ax9
if fig is None:
fig = plt.figure(figsize=(10, 10))
else:
fig.delaxes(ax1)
fig.delaxes(ax2)
fig.delaxes(ax3)
fig.delaxes(ax4)
fig.delaxes(ax5)
fig.delaxes(ax6)
fig.delaxes(ax7)
fig.delaxes(ax8)
fig.delaxes(ax9)
cb1.remove()
cb2.remove()
cb3.remove()
cb4.remove()
cb5.remove()
cb6.remove()
cb7.remove()
cb8.remove()
cb9.remove()
ax1 = fig.add_subplot(333)
disp1 = CameraDisplay(cam_geom, image=photo_electrons, ax=ax1)
plt.gca().set_aspect('equal', adjustable='box')
plt.title("photo-electron image")
disp1.cmap = plt.cm.inferno
disp1.add_colorbar()
cb1 = disp1.colorbar
ax2 = fig.add_subplot(336)
disp2 = CameraDisplay(cam_geom, image=pmt_signal, ax=ax2)
plt.gca().set_aspect('equal', adjustable='box')
disp2.cmap = plt.cm.inferno
disp2.add_colorbar()
cb2 = disp2.colorbar
plt.title("noisy image")
ax3 = fig.add_subplot(331)
plt.imshow(new_signal, interpolation='none', cmap=cm.inferno,
origin='lower')
plt.gca().set_aspect('equal', adjustable='box')
plt.title("noisy, slanted image")
cb3 = plt.colorbar()
ax4 = fig.add_subplot(334)
plt.imshow(cleaned_img, interpolation='none', cmap=cm.inferno,
origin='lower')
plt.gca().set_aspect('equal', adjustable='box')
plt.title("cleaned, slanted image, islands not killed")
cb4 = plt.colorbar()
ax4.set_axis_off()
ax5 = fig.add_subplot(337)
plt.imshow(np.sqrt(cleaned_img_ik), interpolation='none', cmap=cm.inferno,
origin='lower')
plt.gca().set_aspect('equal', adjustable='box')
plt.title("cleaned, slanted image, islands killed")
cb5 = plt.colorbar()
ax5.set_axis_off()
#
ax6 = fig.add_subplot(332)
plt.imshow(square_image_add_noise, interpolation='none', cmap=cm.inferno,
origin='lower')
plt.gca().set_aspect('equal', adjustable='box')
plt.title("slanted image, noise added")
cb6 = plt.colorbar()
ax6.set_axis_off()
#
ax7 = fig.add_subplot(335)
plt.imshow(np.sqrt(square_image_add_noise_cleaned), interpolation='none',
cmap=cm.inferno,
origin='lower')
plt.gca().set_aspect('equal', adjustable='box')
plt.title("slanted image, noise added, cleaned")
cb7 = plt.colorbar()
ax7.set_axis_off()
ax8 = fig.add_subplot(338)
plt.imshow(square_image_add_noise_cleaned_ik, interpolation='none',
cmap=cm.inferno,
origin='lower')
plt.gca().set_aspect('equal', adjustable='box')
plt.title("slanted image, noise added, cleaned, islands killed")
cb8 = plt.colorbar()
ax8.set_axis_off()
try:
ax9 = fig.add_subplot(339)
disp9 = CameraDisplay(unrot_geom, image=unrot_noised_signal,
ax=ax9)
plt.gca().set_aspect('equal', adjustable='box')
plt.title("cleaned, original geometry, islands killed")
disp9.cmap = plt.cm.inferno
disp9.add_colorbar()
cb9 = disp9.colorbar
except:
pass
plt.suptitle(cam_geom.cam_id)
plt.subplots_adjust(top=0.94, bottom=.08, left=0, right=.96, hspace=.41, wspace=.08)
plt.pause(.1)
response = input("press return to continue")
if response != "":
exit()
if i>0:
param_range = np.linspace(param_values[i][0], param_values[i][1], 3)
else:
param_range = np.array(param_values[i])
current_params = model.get_baseline_params()
for n, param_value in enumerate(param_range):
current_params[i] = param_value
x_grid, y_grid, dl = dlg.get_model_dl(current_params)
scale_z = True if n==1 else False
dlp.plot_surface(x_grid, y_grid, dl, color=colors[n], alpha=0.7, scale_z=scale_z)
title_format = r'$\%s$' if param_name=='tau' else r'$%s$'
dlp.ax.set_title(title_format % (param_name), loc='left', fontsize=42)
dlp.ax.legend(labels, param_range, fontsize=32)
plt.savefig('figures/param_variations_%s.pdf' % param_name)
model = dl_model_3.DLModel3()
dlg = dl_generator.DLGenerator(model)
dr = data_reader.DataReader()
data = dr.get_processed_data(path='csv/processed_data_high_low.csv')
param_names = ['tau', 'c_{11}', 'c_{21}', 'c_{12}']
k = 0.2
param_values = [[0.04, 0.05, 0.07], [-k*1.0, k*1.0], [-k*1.0, k*1.0], [-k*1.0, k*1.0]]
colors = [cm.inferno(0.2), cm.Greys(0.7), cm.inferno(0.8)]
labels = [plt.Rectangle((0, 0), 1, 1, fc=color) for color in colors]
plot_dl_variations(dlg, param_names, param_values, colors)
def update(self):
"""
"""
# Gets an element from the buffer and free the buffer
buffer_element = self.buffer.get()
self.buffer.task_done()
# When the Producer Thread finishes publishing the data it sends a None
# through the buffer to sinalize it has finished.
if buffer_element is not None:
score_map = buffer_element.score_map
gt_img = buffer_element.img
ref_img = buffer_element.ref_img
visible = buffer_element.visible
name = buffer_element.name
bbox = buffer_element.bbox
if self.peak_pos is not None and self.disp_prior is not None:
h, w = score_map.shape
disp_prior = make_gaussian_map((h,w), self.peak_pos, self.disp_prior)
np.expand_dims(disp_prior, axis=2)
score_map = score_map*disp_prior
self.prior_radius.setData(pos=[(self.peak_pos[1], self.peak_pos[0])], size=self.disp_prior)
# Find peak of the score map. You must incorporate all priors before
# taking the max.
peak = np.unravel_index(score_map.argmax(), score_map.shape)
self.peak_pos = peak
# Apply the inferno color map to the score map.
# The output of cm.inferno has 4 channels, 3 color channels and a
# transparency channel
score_img = cm.inferno(score_map)[:, :, 0:3]
# Overlay the score_img with a grayscale version of the original
# frame
img_gray = rgb2gray(gt_img)
score_img = score_img[0:img_gray.shape[0], 0:img_gray.shape[1], :]
score_img = score_img*self.alpha + (1-self.alpha)*img_gray/255
vis_color = 'g' if visible else 'r'
self.score_img.setImage(score_img, autoDownsample=False)
# Set the marker in the peak. The pyqtgraph GraphItem takes the
# position in terms of the x and y coordinates.
self.peak.setData(pos=[(peak[1], peak[0])])
self.gt_img.setImage(gt_img, autoDownsample=False)
if bbox is not None:
self.bounding_box.setRect(*bbox)
center_error = np.linalg.norm([bbox[0]+bbox[2]/2-peak[1], bbox[1]+bbox[3]/2-peak[0]])
self.center_errors.append(center_error)
self.curve.setData(self.center_errors)
else:
self.bounding_box.setRect(0, 0, 0, 0)
self.ref_img.setImage(ref_img, autoDownsample=False)
# Calculate the fps rate.
now = ptime.time()
dt = now - self.lastTime
self.lastTime = now
if self.fps is None:
self.fps = 1.0/dt
else:
s = np.clip(dt*3., 0, 1)
self.fps = self.fps * (1-s) + (1.0/dt) * s
self.fpsLabel.setText('{:.2f} fps'.format(self.fps), color='w')
self.visibleLabel.setText('Visible: {}'.format(visible), color=vis_color)
self.bufferLabel.setText('{} in Buffer'.format(self.buffer.qsize()))
self.nameLabel.setText(name, size='10pt', color='w')
self.index += 1
else:
# Set alive attribute to False to indicate the end of the program
self.alive = False
if self.exit_on_end:
self.exit()
"Fp2" : (239,61), "O1" : (157,301),
"O2" : (238,301), "Pz" : (197,245),
"P3" : (146,245), "P4" : (250,245), "T5" : (95,255),
"T6" : (300,255)}
el_centers = np.array([el_centers_dict[item] for item in sens])
fig, ax = plt.subplots(nrows=2, ncols=2)
for band in range(4):
plt.subplot(2,2,band+1)
plt.title(bands[band])
for i in range(eeg_no_ch):
for j in range(i):
coh = coherence_master[0,7,1,i,j,band]
if coh > 0.5:
coh = (coh - 0.5)*2
col = cm.inferno(coh)
plt.plot([el_centers[i,0], el_centers[j,0]],
[el_centers[i,1], el_centers[j,1]],
color=col, alpha=coh*.99, linewidth=coh*8)
plt.imshow(eeg_1020)
ax = plt.gca()
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_xticks([])
ax.set_yticks([])
fig.subplots_adjust(right=0.8)
cbar_ax = fig.add_axes([0.85, 0.15, 0.03, 0.7])
cmap = mpl.cm.plasma
norm = mpl.colors.Normalize(vmin=0.5, vmax=1)
mpl.colorbar.ColorbarBase(cbar_ax, cmap=cmap,
norm=norm, orientation='vertical',
V[2: , 1:-1])
uvv = u*v*v
u += (Du*Lu - uvv + F*(1-u))
v += (Dv*Lv + uvv - (F+k)*v)
t = 0.3
for i in tqdm(range(n)):
res[:,n-i-1][v>t] = 256*u[v>t]
update()
mask = res == 0
res += np.arange(n,dtype='B')[:, np.newaxis]//8
res[mask] = 0
pal = [ Color(0,0,0,0) ] + [ Color( *[ int(255*x) for x in inferno(i/128)] ) for i in range(255) ]
# res[res<0.1] = 0
# res = (res*256).astype('B')
res = res[:,:-3,...]
nz = len(res.nonzero()[0])
print(nz, 'non-zero')
if nz:
vox = Vox.from_dense(res)
vox.palette = pal
fn = 'test-%s.vox'%datetime.now().isoformat().replace(':', '_')
print('wrote', fn)
VoxWriter(fn, vox).write()
