def wavefunction_interactive(self) -> widgets.interactive:
"""Returns an interactive for the wavefunction plot
Returns
-------
widgets.interactive
"""
if isinstance(self.active_qubit, scq.FullZeroPi):
qubit_plot_interactive = None
else:
self.qubit_plot_options_widgets[
"mode_dropdown"
].value = self.active_defaults["mode_wavefunc"]
self.qubit_params_widgets[
self.qubit_plot_options_widgets["scan_dropdown"].value
].disabled = False
if (
isinstance(self.active_qubit, scq.FluxQubit)
or isinstance(self.active_qubit, scq.ZeroPi)
or isinstance(self.active_qubit, scq.Cos2PhiQubit)
):
which_widget = self.qubit_plot_options_widgets[
"wavefunction_single_state_selector"
]
else:
which_widget = self.qubit_plot_options_widgets[
"wavefunction_multi_state_selector"
]
if isinstance(self.active_qubit, scq.ZeroPi):
interactive_choice = self.grid_wavefunction_plot
elif isinstance(self.active_qubit, (scq.FluxQubit, scq.Cos2PhiQubit)):
interactive_choice = self.wavefunction_plot
else:
interactive_choice = self.scaled_wavefunction_plot
if interactive_choice == self.scaled_wavefunction_plot:
qubit_plot_interactive = widgets.interactive(
interactive_choice,
eigenvalue_states=which_widget,
mode_value=self.qubit_plot_options_widgets["mode_dropdown"],
manual_scale_tf=self.qubit_plot_options_widgets[
"manual_scale_checkbox"
],
scale_value=self.qubit_plot_options_widgets[
"wavefunction_scale_slider"
],
**self.qubit_params_widgets
)
else:
qubit_plot_interactive = widgets.interactive(
interactive_choice,
eigenvalue_states=which_widget,
mode_value=self.qubit_plot_options_widgets["mode_dropdown"],
**self.qubit_params_widgets
)
return qubit_plot_interactive
def matelem_scan_interactive(self) -> widgets.interactive:
"""Returns an interactive for the matelem_vs_paramvals plot
Returns
-------
widgets.interactive
"""
self.qubit_plot_options_widgets[
"mode_dropdown"].value = self.active_defaults["mode_matrixelem"]
self.qubit_params_widgets[self.qubit_plot_options_widgets[
"scan_dropdown"].value].disabled = True
if isinstance(self.active_qubit, (scq.ZeroPi, scq.FullZeroPi)):
interactive_choice = self.grid_matelem_vs_paramvals_plot
else:
interactive_choice = self.matelem_vs_paramvals_plot
qubit_plot_interactive = widgets.interactive(
interactive_choice,
operator_value=self.
qubit_plot_options_widgets["operator_dropdown"],
scan_value=self.qubit_plot_options_widgets["scan_dropdown"],
scan_range=self.qubit_plot_options_widgets["scan_range_slider"],
matrix_element_state_value=self.
qubit_plot_options_widgets["matrix_element_state_slider"],
mode_value=self.qubit_plot_options_widgets["mode_dropdown"],
**self.qubit_params_widgets)
return qubit_plot_interactive
def matelem_interactive(self) -> widgets.interactive:
"""Returns an interactive for the matrix elements plot.
Returns
-------
widgets.interactive
"""
self.qubit_plot_options_widgets[
"mode_dropdown"].value = self.active_defaults["mode_matrixelem"]
self.qubit_params_widgets[self.qubit_plot_options_widgets[
"scan_dropdown"].value].disabled = False
if isinstance(self.active_qubit, (scq.ZeroPi, scq.FullZeroPi)):
interactive_choice = self.grid_matrixelements_plot
else:
interactive_choice = self.matrixelements_plot
qubit_plot_interactive = widgets.interactive(
interactive_choice,
operator_value=self.
qubit_plot_options_widgets["operator_dropdown"],
eigenvalue_state_value=self.
qubit_plot_options_widgets["eigenvalue_state_slider"],
mode_value=self.qubit_plot_options_widgets["mode_dropdown"],
show_numbers_tf=self.
qubit_plot_options_widgets["show_numbers_checkbox"],
show3d_tf=self.qubit_plot_options_widgets["show3d_checkbox"],
**self.qubit_params_widgets)
return qubit_plot_interactive
def create_platform_product_gui(platforms: List[str],
products: List[str],
datacube: datacube.Datacube,
default_platform:str = None,
default_product:str = None,):
"""
Description:
-----
"""
plat_selected = [None]
prod_selected = [None]
def parse_widget(x):
var = datacube.list_products()
return var["name"][(var["platform"] == x) & (var["name"].isin(products))]
def get_keys(platform):
products = [x for x in parse_widget(platform)]
product = default_product if default_product in products else products[0]
product_widget = widgets.Select(options=products, value=product)
product_field = widgets.interactive(get_product, prod=product_widget, continuous_update=True)
display(product_field)
plat_selected[0] = (platform)
return platform
def get_product(prod):
prod_selected[0] = (prod)
return prod
platform = default_platform if default_platform in platforms else platforms[0]
platform_widget = widgets.Select(options=platforms, value=platform)
platform_field = widgets.interactive(get_keys, platform=platform_widget, continuous_update=True)
display(platform_field)
return [plat_selected, prod_selected]
def TrajectorySliderView(traj, frame=0, **kwargs):
"""IPython notebook widget for viewing trajectories in the browser with
an interactiver slider.
Parameters
----------
traj : Trajectory
Trajectory for which you want the viewer.
frame : int, default=0
Frame to set the slider to by default
Other Parameters
----------------
kwargs : string
See TrajectoryView for all available options.
See Also
--------
TrajectoryView: IPython notebook widget for displaying trajectories in the
browser with WebGL.
"""
widget = TrajectoryView(traj, frame=frame, **kwargs)
def slide(frame):
widget.frame = frame
s = IntSlider(min=0, max=traj.n_frames - 1, value=frame)
slider = interactive(slide, frame=s)
container = Box()
container.children = [widget, slider]
return container
def overlayViewer(im4d, overlay3d, zz=0, tt=0, th=0, oa=1, im_range=None, o_range=None):
tt_enable = True
if im4d.ndim == 3:
im4d = im4d[:,:,:,np.newaxis]
tt_enable = False
out = widgets.Output()
zz_slider = widgets.IntSlider(min=0, max=im4d.shape[2]-1, step=1, value=zz)
tt_slider = widgets.IntSlider(min=0, max=im4d.shape[3]-1, step=1, value=tt)
oa_slider = widgets.FloatSlider(min=0, max=1, step=0.1, value=oa)
if issubclass(overlay3d.dtype.type, np.integer) or overlay3d.dtype == np.bool:
th = 1
th_slider = widgets.IntSlider(min=np.amin(overlay3d), max=np.amax(overlay3d), step=1, value=th)
th_slider.visible = False
oa_slider.visible = True
else:
th_slider = widgets.FloatSlider(min=np.amin(overlay3d), max=np.amax(overlay3d), step=0.01, value=th)
oa_slider.visible = False
overlay_button = widgets.ToggleButton(description='Overlay', value=True)
if not tt_enable:
tt_slider.visible = False
with warnings.catch_warnings():
warnings.simplefilter('ignore')
w = widgets.interactive(overlayShow, recon=widgets.fixed(im4d), overlay3d=widgets.fixed(overlay3d),
zz=zz_slider, tt=tt_slider, th=th_slider, oa=oa_slider, oe=overlay_button,
im_range=widgets.fixed(im_range), o_range=widgets.fixed(o_range), out=widgets.fixed(out))
wo = widgets.HBox(children=(w,out))
display(wo)
def energy_scan_interactive(self) -> widgets.interactive:
"""Returns an interactive for the evals_vs_paramvals
Returns
-------
widgets.interactive
"""
self.qubit_params_widgets[self.qubit_plot_options_widgets[
"scan_dropdown"].value].disabled = True
if isinstance(self.active_qubit, (scq.ZeroPi, scq.FullZeroPi)):
interactive_choice = self.grid_evals_vs_paramvals_plot
else:
interactive_choice = self.evals_vs_paramvals_plot
qubit_plot_interactive = widgets.interactive(
interactive_choice,
scan_value=self.qubit_plot_options_widgets["scan_dropdown"],
scan_range=self.qubit_plot_options_widgets["scan_range_slider"],
subtract_ground_tf=self.
qubit_plot_options_widgets["subtract_ground_checkbox"],
eigenvalue_state_value=self.
qubit_plot_options_widgets["eigenvalue_state_slider"],
**self.qubit_params_widgets)
return qubit_plot_interactive
def TrajectorySliderView(traj, frame=0, **kwargs):
"""IPython notebook widget for viewing trajectories in the browser with
an interactiver slider.
Parameters
----------
traj : Trajectory
Trajectory for which you want the viewer.
frame : int, default=0
Frame to set the slider to by default
Other Parameters
----------------
kwargs : string
See TrajectoryView for all available options.
See Also
--------
TrajectoryView: IPython notebook widget for displaying trajectories in the
browser with WebGL.
"""
widget = TrajectoryView(traj, frame=frame, **kwargs)
def slide(frame):
widget.frame = frame
s = IntSlider(min=0, max=traj.n_frames - 1, value=frame)
slider = interactive(slide, frame=s)
container = Box()
container.children = [widget, slider]
return container
def get_keys(platform):
products = [x for x in parse_widget(platform)]
product = default_product if default_product in products else products[0]
product_widget = widgets.Select(options=products, value=product)
product_field = widgets.interactive(get_product, prod=product_widget, continuous_update=True)
display(product_field)
plat_selected[0] = (platform)
return platform
def InteractivePlaneProfile():
nRx = 100
def foo(Field, Sigma, Scale, Time):
plt.figure(figsize=(8, 4))
ax1 = plt.subplot(111)
r = np.linspace(-1000.0, 0.0, nRx)
val_ex, val_hy = PlaneEHfield(r, t=Time, sig=Sigma)
if Field == "Ex":
val = val_ex.flatten()
label = "Ex-field (V/m)"
elif Field == "Hy":
val = val_hy.flatten()
label = "Hy-field (A/m)"
if Scale == "log":
val_p, val_n = DisPosNegvalues(val)
ax1.plot(r, val_p, "k-", lw=2)
ax1.plot(r, val_n, "k--", lw=2)
ax1.set_yscale(Scale)
elif Scale == "linear":
ax1.plot(r, val, "k-", lw=2)
ax1.set_yscale(Scale)
y = ax1.yaxis.get_majorticklocs()
yticksa = np.linspace(y.min(), y.max(), 3)
ax1.yaxis.set_ticks(yticksa)
ax1.yaxis.set_major_formatter(ticker.FormatStrFormatter("%.1e"))
ax1.set_xlim(0, -1000)
ax1.set_ylabel(label, color="k")
ax1.set_xlabel("Z (m)")
ax1.grid(True)
plt.show()
Q2 = widgets.interactive(
foo,
Field=widgets.ToggleButtons(options=["Ex", "Hy"], value="Ex"),
Sigma=widgets.FloatText(value=1,
continuous_update=False,
description="$\sigma$ (S/m)"),
Scale=widgets.ToggleButtons(options=["log", "linear"], value="linear"),
Time=widgets.FloatSlider(min=0.01,
max=1.0,
step=0.01,
value=0.0,
description="$t$ (s)"),
)
return Q2
def update_plot(request):
amp = widgets.FloatSlider(min=1,
max=1000,
value=1,
description='AMPLITUDE')
phase = widgets.FloatSlider(min=0, max=5, value=0, description='PHASE')
fre = widgets.FloatSlider(min=1, max=10, value=1, description='FREQUENCY')
widgets.interactive(amp=amp, phase=phase, fre=fre)
x = np.linspace(0, 2, 1000)
fig, ax = plt.subplots(1, figsize=(10, 4))
plt.suptitle('SINE WAVE')
ax.clear()
units = 'amp={} $(psi)$\nphase={} $(s)$\nfre={} $(Hz)$'
y = amp * np.sin(2 * np.pi * (fre * x + phase))
ax.plot(x, y, label=units.format(amp, phase, fre))
ax.legend(loc=1)
ax.set_xlabel('S')
ax.set_ylabel('psi')
w = plt.show()
return render(request, 'DEMOAPP/projecT.html', {'result': w})
def display_controls(self):
# Creating the interactive widget with VBox layout
w = widgets.interactive(self.plot_interactive, **self.controls)
# Changing the format
UI = VBox([
HBox(children=list(w.children[0:3])),
HBox(children=list(w.children[3:6])),
HBox(children=list(w.children[6:9])), w.children[-2],
w.children[-1]
])
display(UI)
def reconViewer(im4d, zz=0, tt=0, rgb=False):
tt_enable = True
if im4d.ndim == 3:
im4d = im4d[:,:,:,np.newaxis]
tt_enable = False
if rgb:
tt_enable = False
out = widgets.Output()
zz_slider = widgets.IntSlider(min=0, max=im4d.shape[2]-1, step=1, value=zz)
tt_slider = widgets.IntSlider(min=0, max=im4d.shape[3]-1, step=1, value=tt)
if not tt_enable:
tt_slider.visible = False
with warnings.catch_warnings():
warnings.simplefilter('ignore')
w = widgets.interactive(reconShow, recon=widgets.fixed(im4d), zz=zz_slider, tt=tt_slider,
rgb=widgets.fixed(rgb), out=widgets.fixed(out))
wo = widgets.HBox(children=(w,out))
display(wo)
def display(self):
hlayout = Layout(display='flex',
flex_flow='row',
align_items='stretch',
border='none',
width='100%')
vbox = VBox(children=[
self.text, self.label_answer, self.label_query,
self.label_expression
])
vbox.layout.width = '70%'
interact = widgets.interactive(self._next_image,
idx=(0, len(self.images) - 1))
interact.layout.height = '550px'
self.image_output = interact.out
if self.camera:
vbox_images = VBox(
children=[self.image_output, self.camera, self.image_recorder])
else:
vbox_images = VBox(children=[interact])
display.display(HBox(children=[vbox_images, vbox], layout=hlayout))
# Then, make the image grayscale.
gray_image = convert_image_to_grayscale(small_image)
# Let's use the pixel values to map to the ASCII character set of choice.
pixels_in_image = list(get_image_values(gray_image))
pixels_to_chars = [get_ascii_for_pixel_value(pixel_value, ascii_chars) for pixel_value in pixels_in_image]
# Shape the ASCII list to make the final ASCII image.
ascii_width = new_width * len(ascii_chars[0])
ascii_art = reshape_list(pixels_to_chars, ascii_width)
steps = show(image, small_image, gray_image)
global save_to_files
save_to_files = partial(file_saver, steps, ascii_art)
print(ascii_art)
return steps
convert_image_to_ascii = interactive(make_to_ascii, image_url_path='http://png.clipart.me/previews/a03/puppy-vector-8-39942.jpg', ascii_chars = {'a': ASCII_A, 'b': ASCII_B, 'c': ASCII_C, 'd': ASCII_D, 'e': ASCII_E}, new_width=50)
def file_saver(plot, text, save_to_filename):
plot.savefig(save_to_filename + '.png')
ascii_text = open(save_to_filename + '.txt', 'w+')
ascii_text.write(text)
ascii_text.close()
font_path = Path('./assets/font.ttf')
encoded_image_path = text2png(text, save_to_filename + '-ascii.png', fontfullpath = str(font_path.resolve()), width = len(text.split('\n')[0]) * 8)
def interactive_ascii():
display(convert_image_to_ascii)
def pairwiseplot_widget(df):
def pairwiseplot():
return df.scatter_matrix()
pplot_widget = interactive(pairwiseplot)
return pplot_widget
def InteractivePlaneProfile():
# srcLoc = 0.0
# orientation = "X"
nRx = 100
def foo(Field, Sigma, Scale, Fixed, Frequency, Time):
plt.figure(figsize=(8, 4))
ax1 = plt.subplot(111)
ax2 = ax1.twinx()
r = np.linspace(-1000.0, 0.0, nRx)
val_ex, val_hy = PlaneEHfield(r, t=Time, f=Frequency, sig=Sigma)
if Field == "Ex":
valr = val_ex.real.flatten()
vali = val_ex.imag.flatten()
labelr = "Re (Ex)-field (V/m)"
labeli = "Im (Ex)-field (V/m)"
elif Field == "Hy":
valr = val_hy.real.flatten()
vali = val_hy.imag.flatten()
labelr = "Re (Hy)-field (A/m)"
labeli = "Im (Hy)-field (A/m)"
elif Field == "Impedance":
imp = -val_ex / val_hy
valr = imp.real.flatten()
vali = imp.imag.flatten()
labelr = "Re (Z) (Ohm)"
labeli = "Im (Z) (Ohm)"
elif Field == "rhophi":
imp = -val_ex / val_hy
valr = abs(imp)**2 / (2 * np.pi * Frequency * mu_0)
vali = np.angle(imp, deg=True)
labelr = "Apparent resistivity (Ohm-m)"
labeli = "Phase of Impedance (degree)"
if Scale == "log":
valr_p, valr_n = DisPosNegvalues(valr)
vali_p, vali_n = DisPosNegvalues(vali)
if Field == "rhophi":
ax1.plot(r, valr, "k.")
else:
ax1.plot(r, valr_p, "k-", lw=2)
ax1.plot(r, valr_n, "k--", lw=2)
ax2.plot(r, vali_p, "r-", lw=2)
ax2.plot(r, vali_n, "r--", lw=2)
ax1.set_yscale(Scale)
ax2.set_yscale(Scale)
if Fixed:
vmin1, vmax1 = ax1.get_ylim()
vmin2, vmax2 = ax2.get_ylim()
vmin = min(vmin1, vmin2)
vmax = max(vmax1, vmax2)
ax1.set_ylim(vmin, vmax)
ax2.set_ylim(vmin, vmax)
elif Scale == "linear":
if Field == "rhophi":
ax1.plot(r, valr, "k.")
else:
ax1.plot(r, valr, "k-", lw=2)
ax2.plot(r, vali, "r-", lw=2)
ax1.set_yscale(Scale)
ax2.set_yscale(Scale)
y = ax1.yaxis.get_majorticklocs()
yticksa = np.linspace(y.min(), y.max(), 3)
ax1.yaxis.set_ticks(yticksa)
if Fixed and Field != "Impedance":
vmax = np.r_[abs(valr), abs(vali)].max()
vmin = -vmax
ax1.set_ylim(vmin, vmax)
ax2.set_ylim(vmin, vmax)
# y = ax2.yaxis.get_majorticklocs()
yticks = np.linspace(vmin, vmax, 3)
ax1.yaxis.set_ticks(yticks)
ax2.yaxis.set_ticks(yticks)
ax1.yaxis.set_major_formatter(ticker.FormatStrFormatter("%.1e"))
ax2.yaxis.set_major_formatter(ticker.FormatStrFormatter("%.1e"))
ax1.set_xlim(0, -1000)
ax2.set_ylabel(labeli, color="r")
ax1.set_ylabel(labelr, color="k")
ax1.set_xlabel("Z (m)")
for tl in ax2.get_yticklabels():
tl.set_color("r")
ax1.grid(True)
plt.show()
Q2 = widgets.interactive(
foo,
Field=widgets.ToggleButtons(
options=["Ex", "Hy", "Impedance", "rhophi"], value="Ex"),
Sigma=widgets.FloatText(value=1,
continuous_update=False,
description="$\sigma$ (S/m)"),
Scale=widgets.ToggleButtons(options=["log", "linear"], value="linear"),
Fixed=widgets.widget_bool.Checkbox(value=False),
Frequency=widgets.FloatText(value=10.0,
continuous_update=False,
description="$f$ (Hz)"),
Time=widgets.FloatSlider(min=0,
max=0.2,
step=0.005,
continuous_update=False,
description="t (s)"),
)
return Q2
def InteractivePlaneWave(
self,
nRx=100,
npts2D=50,
scale="log",
offset_plane=50.0,
X1=-500,
X2=500,
Y1=-500,
Y2=500,
Z1=-1000,
Z2=0,
):
# x1, x2, y1, y2 = offset_rx, offset_rx, Z1, Z2
self.xmin, self.xmax = X1, X2
self.ymin, self.ymax = Y1, Y2
self.zmin, self.zmax = Z1, Z2
def foo(Field, ComplexNumber, Frequency, Sigma, Scale, Time):
f = np.r_[Frequency]
sig = np.r_[Sigma]
if Field == "Ex":
normal = "Y"
self.offset_rx = 0.0
Field = "E_from_SheetCurrent"
Component = "x"
elif Field == "Hy":
normal = "X"
self.offset_rx = 0.0
Field = "H_from_SheetCurrent"
Component = "y"
x1, x2, y1, y2 = self.offset_rx, self.offset_rx, Z1, Z2
if ComplexNumber == "Re":
ComplexNumber = "real"
elif ComplexNumber == "Im":
ComplexNumber = "imag"
elif ComplexNumber == "Amp":
ComplexNumber = "amplitude"
elif ComplexNumber == "Phase":
ComplexNumber = "phase"
return self.Planewave2Dviz(
x1,
y1,
x2,
y2,
npts2D,
nRx,
sig,
f,
srcLoc=0.0,
orientation="X",
component=ComplexNumber,
view=Component,
normal=normal,
functype=Field,
scale=Scale,
t=Time,
)
out = widgets.interactive(
foo,
Field=widgets.ToggleButtons(options=["Ex", "Hy"]),
ComplexNumber=widgets.ToggleButtons(
options=["Re", "Im", "Amp", "Phase"]),
Frequency=widgets.FloatText(value=10.0, continuous_update=False),
Sigma=widgets.FloatText(value=1, continuous_update=False),
Scale=widgets.ToggleButtons(options=["log", "linear"],
value="linear"),
Time=widgets.FloatSlider(min=0, max=0.2, step=0.01, value=0.0),
)
return out
# パラメータ「threshold1」「threshold2」を設定するスライダー
thresh_slider = widgets.SelectionRangeSlider(options=np.arange(1000),
index=(100, 200),
description=f"threshold")
thresh_slider.layout.width = "400px"
# パラメータ「apertureSize」を設定するスライダー
aperture_size_slider = slider = widgets.IntSlider(min=3,
max=7,
step=2,
value=3,
description="apertureSize: ")
aperture_size_slider.layout.width = "400px"
# パラメータ「L2gradient」を設定するチェックボックス
l2_gradient_checkbox = widgets.Checkbox(value=False,
description="L2gradient: ")
l2_gradient_checkbox.layout.width = "400px"
# 画像を読み込む。
img = cv2.imread("sample.jpg")
# ウィジェットを表示する。
widgets.interactive(
canny,
img=widgets.fixed(img),
thresh=thresh_slider,
apertureSize=aperture_size_slider,
L2gradient=l2_gradient_checkbox,
)
s= FFT(Ck[i])
U.append([])
for j in range(M):
U[i].append(s[j])
U = np.asarray(U, dtype=float)
#Построение графика
x, y = np.meshgrid(x, y)
f = f.reshape((M, N))
furie = furie.reshape((M, N))
Ck = Ck.reshape((M, N))
U = U.reshape((M, N))
ax.view_init(Thetha, Phi) #поворот графика
surf = ax.plot_surface(x, y, U.real, cmap=cm.coolwarm, #если .real поменять на .imag, то построит мнимую часть, карты: cm.coolwarm,'viridis'
linewidth=0)
plt.show()
fig.savefig(Grafic, dpi=170)
p_height = widgets.FloatSlider(min=0.5, max=2, step=0.1, description= 'p')
q_height = widgets.FloatSlider(min=0.5, max=2, step=0.1, description= 'q')
r_height = widgets.FloatSlider(min=0.5, max=2, step=0.1, description= 'r')
s_height = widgets.FloatSlider(min=0.5, max=2, step=0.1, description= 's')
Thetha_height = widgets.IntSlider(min=0, max=360, value =30, step=5, description= 'Thetha')
Phi_height = widgets.IntSlider(min=0, max=360, value = 60, step=5, description= 'Phi')
widgets.interactive(update_plot, p=p_height, q=q_height, r=r_height, s=s_height, Thetha=Thetha_height, Phi=Phi_height)
ax2.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%d/%HZ'))
ax2.set_ylabel('Ens. Variance [K$^{2}$]', fontsize=12)
ax2.legend(loc=0)
ax2.grid()
# This uses iPython widgets to build sliders for determining what to assimilate
obs_slider = widgets.IntRangeSlider(min=1,
max=len(obs),
step=1,
value=(1, len(obs)),
description='Num. Obs. Assimilated')
error_slider = widgets.FloatSlider(value=1.0,
min=0.25,
max=2.0,
step=0.25,
description='Obs. Error [K$^{2}$]')
inflation_slider = widgets.FloatSlider(value=1.0,
min=1.0,
max=3.0,
step=0.5,
description='Inflation Factor')
show_inflated_prior = widgets.Checkbox(description="Show inflated prior",
value=False)
w = widgets.interactive(assimilation_viewer,
obs_range=obs_slider,
ob_error=error_slider,
inflation=inflation_slider,
show_inflated=show_inflated_prior)
display(w)
Vticks = widgets.IntSlider(min = 2, max = 50, value=10, description='Vticks')
function = widgets.Text( value = 'z**2' , description='w : ')
frame = widgets.FloatSlider(min=0, max=100, value=100, step = 5, description='anim')
play = widgets.Play(min= 0, max = 100, step = 5)
widgets.jslink((play, 'value'), (frame, 'value'))
interactive_plot = widgets.interactive(rect.updateFunc,
w = function,
left = left,
right = right,
top= top,
bottom = bottom,
fine = fine,
Hticks = Hticks,
Vticks = Vticks,
frame = frame
)
w1 = VBox([ left, right])
w2 = VBox([top,bottom])
w3 = VBox([Hticks,Vticks])
w4 = HBox([w1,w2,w3])
w5 = HBox([function, fine])
anim_slider = HBox([play, frame])
def InteractivePlaneWave(
self,
nRx=100,
npts2D=50,
scale="log",
offset_plane=50.0,
X1=-500,
X2=500,
Y1=-500,
Y2=500,
Z1=-1000,
Z2=0,
):
# x1, x2, y1, y2 = offset_rx, offset_rx, Z1, Z2
self.xmin, self.xmax = X1, X2
self.ymin, self.ymax = Y1, Y2
self.zmin, self.zmax = Z1, Z2
def foo(Field, Time, Sigma, Scale):
t = np.r_[Time]
sig = np.r_[Sigma]
if Field == "Ex":
normal = "Y"
self.offset_rx = 0.0
Field = "E_from_SheetCurrent"
Component = "x"
elif Field == "Hy":
normal = "X"
self.offset_rx = 0.0
Field = "H_from_SheetCurrent"
Component = "y"
x1, x2, y1, y2 = self.offset_rx, self.offset_rx, Z1, Z2
return self.Planewave2Dviz(
x1,
y1,
x2,
y2,
npts2D,
nRx,
sig,
t,
srcLoc=0.0,
orientation="X",
view=Component,
normal=normal,
functype=Field,
scale=Scale,
)
out = widgets.interactive(
foo,
Field=widgets.ToggleButtons(options=["Ex", "Hy"]),
Time=widgets.FloatSlider(min=0.01,
max=1.0,
step=0.01,
value=0.0,
description="$t$ (s)"),
Sigma=widgets.FloatText(value=1, continuous_update=False),
Scale=widgets.ToggleButtons(options=["log", "linear"],
value="linear"),
)
return out
fig_width = len(images) * fig_image_width
for index, image in enumerate(images):
ax[0][index].imshow(image, cmap=plt.cm.gray)
fig.set_size_inches(fig_width, fig_height)
steps = plt.gcf()
plt.close()
return steps
# This function grabs the image from a url so we can change it.
def get_image_from_url(image_url_path):
image = io.imread(image_url_path)
return image
# This will let us easily update where the url for image should come from.
set_image = interactive(get_image_from_url, image_url_path='http://png.clipart.me/previews/a03/puppy-vector-8-39942.jpg')
def resize_image(input_image, new_width, new_height):
resized_image = resize(input_image, (new_height, new_width), mode = 'constant', anti_aliasing = False)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
return(img_as_ubyte(resized_image))
def convert_image_to_grayscale(input_image):
# return rgb2gray(input_image)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
return(img_as_ubyte(rgb2gray(input_image)))
def get_image_pixel_data(input_image):
