Download vis/plot.py from LoveHotpot113/LithoBench-PDE: direct link, hf CLI and curl.
- Browser
- Download file 31.3 kB
-
https://huggingface.co/datasets/LoveHotpot113/LithoBench-PDE/resolve/main/vis/plot.py
- Command line
-
hf download hf://datasets/LoveHotpot113/LithoBench-PDE/vis/plot.py
-
curl -L -o plot.py https://huggingface.co/datasets/LoveHotpot113/LithoBench-PDE/resolve/main/vis/plot.py
31.3 kB
| """Plotly figures in the format of the LithoBench-PDE `vis/` notebooks.""" | |
| import base64 | |
| import io | |
| import numpy as np | |
| import plotly.express as px | |
| import plotly.graph_objects as go | |
| import plotly.io as pio | |
| import torch | |
| from matplotlib import colormaps | |
| from matplotlib.colors import hsv_to_rgb | |
| from PIL import Image | |
| from plotly.subplots import make_subplots | |
| from skimage import measure | |
| HUE = hsv_to_rgb(np.stack([np.linspace(0, 1, 256), np.ones(256), np.ones(256)], axis=-1)) | |
| GAMMA = 0.7 | |
| def to_numpy(x): | |
| return x.detach().cpu().numpy() if torch.is_tensor(x) else np.asarray(x) | |
| def cm2px(cm, dpi): | |
| return int(cm / 2.54 * dpi) | |
| def pt2px(pt, dpi): | |
| return int(pt / 72 * dpi) | |
| def rgb_colorscale(cmap_name): | |
| cmap = colormaps[cmap_name] | |
| return [[i / 255, 'rgb({},{},{})'.format(*[int(c * 255) for c in cmap(i / 255)[:3]])] for i in range(256)] | |
| def alpha_colorscale(cmap_name, a_min, a_max): | |
| cmap = colormaps[cmap_name] | |
| scale = [] | |
| for i in range(256): | |
| t = i / 255 | |
| r, g, b, _ = cmap(t) | |
| a = a_min + (a_max - a_min) * t ** 5 | |
| scale.append([t, f'rgba({int(r * 255)},{int(g * 255)},{int(b * 255)},{a:.3f})']) | |
| return scale | |
| def plot_2d(data, heatmap_width_cm=2., heatmap_height_cm=2., dpi=300, scale=1.0, | |
| use_colorbar=True, colorbar_thickness=24, text_font_size=7, ticklabel_font_size=5, | |
| show_x_ticks=True, show_x_ticklabels=True, show_y_ticks=True, show_y_ticklabels=True, | |
| x_unit=0.004, y_unit=0.004, x_ticks=(0, 250, 500), y_ticks=(0, 250, 500), | |
| boundary_linewidth=1, tick_width=1, x_label='x [μm]', y_label='y [μm]', cmap='Jet', | |
| ticklen=16, colorbar_min=None, colorbar_max=None, outer_margin_cm=0.2, colorbar_title=None): | |
| """One heatmap, or a 2 x 2 grid of heatmaps for data of shape (2, 2, H, W).""" | |
| data = to_numpy(data) | |
| is_grid = data.ndim == 4 and data.shape[:2] == (2, 2) | |
| panels = data if is_grid else data[np.newaxis, np.newaxis] | |
| rows, cols = (2, 2) if is_grid else (1, 1) | |
| N = panels[0, 0].shape[0] | |
| if N > 1000: | |
| x_ticks, y_ticks = (0, 500, 1000), (0, 500, 1000) | |
| heatmap_width_cm *= 2 | |
| heatmap_height_cm *= 2 | |
| colorbar_thickness *= 2 | |
| data_w = heatmap_width_cm / 2.54 * dpi | |
| data_h = heatmap_height_cm / 2.54 * dpi | |
| text_px = int(text_font_size / 72 * dpi * scale) | |
| tick_px = int(ticklabel_font_size / 72 * dpi * scale) | |
| pad = int(5 * scale) | |
| gap = pad * 5 | |
| outer = outer_margin_cm / 2.54 * dpi | |
| cb_gap = pad * 4 | |
| cb_tick_w = tick_px * 8 | |
| ml = outer + boundary_linewidth + show_y_ticks * ticklen + show_y_ticklabels * tick_px + (1 if y_label else 0) * text_px + pad | |
| mr = outer + boundary_linewidth + pad + use_colorbar * (cb_gap + colorbar_thickness + cb_tick_w) | |
| mb = outer + boundary_linewidth + show_x_ticks * ticklen + show_x_ticklabels * tick_px + (1 if x_label else 0) * text_px * 3 + pad | |
| mt = outer + boundary_linewidth + pad | |
| fig_w = ml + mr + cols * data_w + (cols - 1) * gap | |
| fig_h = mt + mb + rows * data_h + (rows - 1) * gap | |
| grid_y0 = mb / fig_h | |
| grid_y1 = (mb + rows * data_h + (rows - 1) * gap) / fig_h | |
| vmin = float(colorbar_min if colorbar_min is not None else panels.min()) | |
| vmax = float(colorbar_max if colorbar_max is not None else panels.max()) | |
| border = dict(showline=True, linecolor='lightgray', linewidth=boundary_linewidth, mirror=True, fixedrange=True) | |
| def xname(i): | |
| return 'x' if i == 0 else f'x{i + 1}' | |
| def yname(i): | |
| return 'y' if i == 0 else f'y{i + 1}' | |
| def make_xaxis(domain, anchor, is_bottom): | |
| ax = dict(domain=domain, anchor=anchor, **border) | |
| if is_bottom: | |
| ax.update(ticks='outside' if show_x_ticks else '', ticklen=ticklen, tickwidth=tick_width, | |
| tickcolor='black', tickfont=dict(size=tick_px, color='black'), | |
| showticklabels=show_x_ticklabels, | |
| title=dict(text=x_label or '', font=dict(size=text_px, color='black'), standoff=tick_px + ticklen), | |
| tickmode='array', tickvals=list(x_ticks), ticktext=[f'{v * x_unit:.1f}' for v in x_ticks]) | |
| else: | |
| ax.update(ticks='', ticklen=0, showticklabels=False, title=dict(text=''), showgrid=False) | |
| return ax | |
| def make_yaxis(domain, anchor, is_left): | |
| ax = dict(domain=domain, anchor=anchor, **border) | |
| if is_left: | |
| ax.update(ticks='outside' if show_y_ticks else '', ticklen=ticklen, tickwidth=tick_width, | |
| tickcolor='black', tickfont=dict(size=tick_px, color='black'), | |
| showticklabels=show_y_ticklabels, | |
| title=dict(text=y_label or '', font=dict(size=text_px, color='black'), standoff=tick_px + ticklen), | |
| tickmode='array', tickvals=list(y_ticks), ticktext=[f'{v * y_unit:.1f}' for v in y_ticks]) | |
| else: | |
| ax.update(ticks='', ticklen=0, showticklabels=False, title=dict(text=''), showgrid=False) | |
| return ax | |
| fig = go.Figure() | |
| for r in range(rows): | |
| for c in range(cols): | |
| idx = r * cols + c | |
| x0 = (ml + c * (data_w + gap)) / fig_w | |
| x1 = (ml + c * (data_w + gap) + data_w) / fig_w | |
| y0 = (mb + (rows - 1 - r) * (data_h + gap)) / fig_h | |
| y1 = (mb + (rows - 1 - r) * (data_h + gap) + data_h) / fig_h | |
| fig.add_trace(go.Heatmap(z=panels[r, c], colorscale=cmap, showscale=False, zmin=vmin, zmax=vmax, | |
| xaxis=xname(idx), yaxis=yname(idx))) | |
| fig.update_layout(**{ | |
| f'xaxis{"" if idx == 0 else idx + 1}': make_xaxis([x0, x1], yname(idx), r == rows - 1), | |
| f'yaxis{"" if idx == 0 else idx + 1}': make_yaxis([y0, y1], xname(idx), c == 0)}) | |
| if use_colorbar: | |
| n_cb = 256 | |
| cb_idx = rows * cols | |
| cb_x0 = (ml + cols * data_w + (cols - 1) * gap + cb_gap) / fig_w | |
| cb_x1 = cb_x0 + colorbar_thickness / fig_w | |
| fig.add_trace(go.Heatmap(z=np.linspace(vmin, vmax, n_cb).reshape(n_cb, 1), colorscale=cmap, showscale=False, | |
| zmin=vmin, zmax=vmax, xaxis=xname(cb_idx), yaxis=yname(cb_idx))) | |
| fig.update_layout(**{ | |
| f'xaxis{cb_idx + 1}': dict(domain=[cb_x0, cb_x1], anchor=yname(cb_idx), visible=False, fixedrange=True, | |
| showline=True, linecolor='black', linewidth=boundary_linewidth, mirror=True), | |
| f'yaxis{cb_idx + 1}': dict(domain=[grid_y0, grid_y1], anchor=xname(cb_idx), side='right', fixedrange=True, | |
| tickmode='array', tickvals=np.linspace(0, n_cb - 1, 5), | |
| ticktext=[f'{v:.2f}' for v in np.linspace(vmin, vmax, 5)], | |
| tickfont=dict(size=tick_px, color='black'), tickcolor='black', | |
| tickwidth=tick_width, ticklen=ticklen // 2, | |
| showline=True, linecolor='black', linewidth=boundary_linewidth, | |
| showgrid=False, mirror=False, | |
| title=dict(text=colorbar_title or '', font=dict(size=text_px, color='black'), | |
| standoff=tick_px + ticklen // 2))}) | |
| fig.update_layout(autosize=False, width=int(fig_w), height=int(fig_h), margin=dict(l=0, r=0, t=0, b=0), | |
| paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', | |
| font=dict(family='Arial, sans-serif', size=text_px, color='black')) | |
| return fig | |
| def vis_mask(data, cmap='gray', x_unit=0.016): | |
| """Photomask (H, W); the mask grid is 16 nm / px.""" | |
| return plot_2d(np.flipud(to_numpy(data)), cmap=cmap, use_colorbar=False, x_unit=x_unit, y_unit=x_unit) | |
| def median_phase(field): | |
| """Phase of (median Re, median Im): the phase origin of one near-field component.""" | |
| field = torch.as_tensor(field) | |
| return torch.complex(field.real.median(), field.imag.median()).angle().item() | |
| def phase_amplitude_rgb(field, ref_phase=0.0, amp_max=1.0): | |
| """Hue = phase relative to ref_phase (hsv wheel); white -> pure hue with (|field| / amp_max)^0.7.""" | |
| field = to_numpy(field) | |
| t = (np.angle(field * np.exp(-1j * ref_phase)) + np.pi) / (2 * np.pi) | |
| hue = HUE[np.clip((t * 255).astype(int), 0, 255)] | |
| v = np.clip(np.abs(field) / max(amp_max, 1e-30), 0, 1)[..., None] ** GAMMA | |
| return np.clip(1 - v + hue * v, 0, 1) | |
| def png_source(rgb): | |
| buffer = io.BytesIO() | |
| Image.fromarray((rgb * 255).astype(np.uint8)).save(buffer, format='PNG') | |
| return 'data:image/png;base64,' + base64.b64encode(buffer.getvalue()).decode() | |
| def vis_sc(E, reference=None, x_unit=0.016, panel_cm=2.0, dpi=300): | |
| """Near field E (2, 2, H, W) as a 2 x 2 grid of phase and amplitude (E[i, j]: output i, incident polarization j). | |
| The phase origin of each component and the amplitude scale come from `reference` (default: E itself), | |
| so a prediction drawn with its reference shares the color code of the reference.""" | |
| E = torch.as_tensor(E) | |
| reference = E if reference is None else torch.as_tensor(reference) | |
| amp_max = reference.abs().max().item() | |
| n = E.shape[-1] | |
| ticks = (0, 250, 500) if n <= 1000 else (0, 500, 1000) | |
| legend_w = 40 if n <= 1000 else 80 | |
| if n > 1000: | |
| panel_cm *= 2 | |
| data_w = panel_cm / 2.54 * dpi | |
| text_px, tick_px = int(7 / 72 * dpi), int(5 / 72 * dpi) | |
| ticklen, pad, gap, legend_gap = 16, 5, 45, 20 | |
| outer = 0.2 / 2.54 * dpi | |
| ml = outer + ticklen + tick_px + text_px + pad | |
| mb = outer + ticklen + tick_px + 3 * text_px + pad | |
| mr = outer + legend_gap + legend_w + ticklen + 3 * tick_px + 2 * text_px + pad | |
| mt = outer + pad | |
| grid = 2 * data_w + gap | |
| fig_w, fig_h = ml + grid + mr, mb + grid + mt | |
| axis = dict(showline=True, linecolor='gray', linewidth=2, mirror=True, showgrid=False, zeroline=False, | |
| fixedrange=True, tickmode='array', tickcolor='gray', tickwidth=1, ticklen=ticklen, | |
| tickfont=dict(size=tick_px, color='black')) | |
| labels = [f'{v * x_unit:.1f}' for v in ticks] | |
| fig = go.Figure() | |
| for i in range(2): | |
| for j in range(2): | |
| k = '' if i == j == 0 else str(2 * i + j + 1) | |
| rgb = phase_amplitude_rgb(E[i, j], median_phase(reference[i, j]), amp_max) | |
| fig.add_trace(go.Image(source=png_source(rgb), xaxis='x' + k, yaxis='y' + k)) | |
| x0, y0 = ml + j * (data_w + gap), mb + (1 - i) * (data_w + gap) | |
| bottom, left = i == 1, j == 0 | |
| fig.update_layout(**{ | |
| 'xaxis' + k: dict(axis, domain=[x0 / fig_w, (x0 + data_w) / fig_w], anchor='y' + k, range=[-0.5, n - 0.5], | |
| ticks='outside' if bottom else '', showticklabels=bottom, | |
| tickvals=list(ticks), ticktext=labels, | |
| title=dict(text='x [μm]' if bottom else '', font=dict(size=text_px))), | |
| 'yaxis' + k: dict(axis, domain=[y0 / fig_h, (y0 + data_w) / fig_h], anchor='x' + k, range=[n - 0.5, -0.5], | |
| ticks='outside' if left else '', showticklabels=left, | |
| tickvals=[n - 0.5 - v for v in ticks], ticktext=labels, | |
| title=dict(text='y [μm]' if left else '', font=dict(size=text_px)))}) | |
| rows = int(round(grid)) | |
| phase = np.linspace(np.pi, -np.pi, rows) | |
| amplitude = np.linspace(0, 1, legend_w) | |
| legend = phase_amplitude_rgb(amplitude[None, :] * np.exp(1j * phase[:, None])) | |
| lx0 = ml + grid + legend_gap | |
| fig.add_trace(go.Image(source=png_source(legend), xaxis='x5', yaxis='y5')) | |
| fig.update_layout( | |
| xaxis5=dict(axis, domain=[lx0 / fig_w, (lx0 + legend_w) / fig_w], anchor='y5', range=[-0.5, legend_w - 0.5], | |
| linecolor='black', linewidth=1, tickcolor='black', ticks='outside', ticklen=ticklen // 2, | |
| tickvals=[0, legend_w - 1], ticktext=['0', '1'], | |
| title=dict(text='Amp. [-]', font=dict(size=text_px))), | |
| yaxis5=dict(axis, domain=[mb / fig_h, (mb + grid) / fig_h], anchor='x5', side='right', range=[rows - 0.5, -0.5], | |
| linecolor='black', linewidth=1, tickcolor='black', ticks='outside', ticklen=ticklen // 2, | |
| tickvals=[(rows - 1) * f for f in (0, 0.25, 0.5, 0.75, 1)], | |
| ticktext=['π', 'π/2', '0', '-π/2', '-π'], | |
| title=dict(text='Phase [rad]', font=dict(size=text_px)))) | |
| fig.update_layout(autosize=False, width=int(fig_w), height=int(fig_h), margin=dict(l=0, r=0, t=0, b=0), | |
| paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', | |
| font=dict(family='Arial, sans-serif', size=text_px, color='black')) | |
| return fig | |
| def vis_pattern(T_pred, T_ref, level=60.0, x_unit=0.004): | |
| """Printed pattern at the substrate: reference (gray, blue contour) and prediction (red contour).""" | |
| ref = np.flipud(to_numpy(T_ref)) | |
| pred = np.flipud(to_numpy(T_pred)) | |
| fig = plot_2d((ref > level).astype(float), cmap=[[0, 'white'], [1, '#C8C8C8']], use_colorbar=False, | |
| colorbar_min=0, colorbar_max=1, x_unit=x_unit, y_unit=x_unit) | |
| for field, color in [(ref, 'rgba(0,0,255,0.7)'), (pred, 'rgba(255,0,0,0.7)')]: | |
| for c in measure.find_contours(field, level): | |
| fig.add_trace(go.Scatter(x=c[:, 1], y=c[:, 0], mode='lines', line=dict(color=color, width=1.5), | |
| showlegend=False, hoverinfo='skip', xaxis='x', yaxis='y')) | |
| return fig | |
| def plot_tensor_slices(data, colorscale='jet', vmin=None, vmax=None, alpha_at_cmin=0.1, alpha_at_cmax=1, | |
| colorbar_thickness=20, colorbar_title=None, colorbar_length=0.6, | |
| colorbar_fontsize=7, colorbar_tick_fontsize=5, camera_distance=1.5, | |
| fig_width_cm=6.0, fig_height_cm=4.0, dpi=300): | |
| """Semi-transparent xy slices of a 3-D field (Nx, Ny, Nz) plus the two far side faces.""" | |
| data = to_numpy(data) | |
| N = data.shape[0] | |
| sf = 2 if N >= 513 else 1 | |
| s, e = N // 2 - 128 * sf, N // 2 + 128 * sf | |
| data = data[s:e, s:e, :] | |
| fig_width_cm *= sf | |
| fig_height_cm *= sf | |
| camera_distance /= sf | |
| colorbar_thickness = int(colorbar_thickness * sf) | |
| Nx, Ny, Nz = data.shape | |
| vmin = float(np.nanmin(data)) if vmin is None else float(vmin) | |
| vmax = float(np.nanmax(data)) if vmax is None else float(vmax) | |
| x, y, z = np.arange(Nx), np.arange(Ny), np.arange(Nz) | |
| surf_kw = dict(colorscale=alpha_colorscale(colorscale, alpha_at_cmin, alpha_at_cmax), cmin=vmin, cmax=vmax, | |
| lighting=dict(ambient=1.0), opacity=1.0, showscale=False) | |
| surfaces = [] | |
| for k in range(0, Nz, 4): | |
| surfaces.append(go.Surface(x=np.tile(x[:, None], (1, Ny)), y=np.tile(y[None, :], (Nx, 1)), | |
| z=np.full((Nx, Ny), k), surfacecolor=data[:, :, k], name=f'XY @ z={k}', **surf_kw)) | |
| surfaces.append(go.Surface(x=np.full((Ny, Nz), Nx - 1), y=np.tile(y[:, None], (1, Nz)), | |
| z=np.tile(z[None, :], (Ny, 1)), surfacecolor=data[Nx - 1, :, :], name='YZ', **surf_kw)) | |
| surfaces.append(go.Surface(x=np.tile(x[:, None], (1, Nz)), y=np.full((Nx, Nz), Ny - 1), | |
| z=np.tile(z[None, :], (Nx, 1)), surfacecolor=data[:, Ny - 1, :], name='XZ', **surf_kw)) | |
| fig = go.Figure(data=surfaces) | |
| colorbar = dict(lenmode='fraction', len=colorbar_length, thickness=colorbar_thickness, x=0.85, y=0.45, | |
| tickfont=dict(family='Arial, sans-serif', size=pt2px(colorbar_tick_fontsize, dpi), color='black'), | |
| tickwidth=1, tickcolor='black', outlinewidth=1, outlinecolor='black', nticks=5) | |
| if colorbar_title is not None: | |
| colorbar['title'] = dict(text=colorbar_title, side='right', | |
| font=dict(family='Arial, sans-serif', size=pt2px(colorbar_fontsize, dpi), color='black')) | |
| fig.add_trace(go.Scatter3d(x=[0.0, 0.0], y=[0.0, 0.0], z=[0.0, 0.0], mode='markers', showlegend=False, | |
| hoverinfo='skip', | |
| marker=dict(size=0.001, opacity=0.0, color=[vmin, vmax], cmin=vmin, cmax=vmax, | |
| colorscale=rgb_colorscale(colorscale), showscale=True, colorbar=colorbar))) | |
| bx = [0, Nx - 1, Nx - 1, 0, 0, None, 0, Nx - 1, Nx - 1, 0, 0, None, 0, 0, None, Nx - 1, Nx - 1, None, Nx - 1, Nx - 1, None, 0, 0] | |
| by = [0, 0, Ny - 1, Ny - 1, 0, None, 0, 0, Ny - 1, Ny - 1, 0, None, 0, 0, None, 0, 0, None, Ny - 1, Ny - 1, None, Ny - 1, Ny - 1] | |
| bz = [0, 0, 0, 0, 0, None, Nz - 1, Nz - 1, Nz - 1, Nz - 1, Nz - 1, None, 0, Nz - 1, None, 0, Nz - 1, None, 0, Nz - 1, None, 0, Nz - 1] | |
| fig.add_trace(go.Scatter3d(x=bx, y=by, z=bz, mode='lines', line=dict(color='black', width=1.5), showlegend=False)) | |
| tick_px = int(2.5 / 72 * dpi) | |
| unit = 0.004 | |
| sz = 1 if Nx < 257 else 2 | |
| axis_style = dict(showbackground=False, mirror=True, linecolor='black', linewidth=0, tickwidth=0, tickcolor='black') | |
| title_font = dict(family='Arial, sans-serif', size=tick_px * 1.5, color='black') | |
| tick_font = dict(family='Arial, sans-serif', size=tick_px, color='black') | |
| centre = np.array([Nx / 2, Ny / 2, Nz / 2]) | |
| diag_len = np.linalg.norm([Nx, Ny, Nz]) / 2 | |
| eye_dir = np.array([1.0, 1.0, 1.7 * (2.5 if sf == 2 else 1.0)]) | |
| eye = centre + camera_distance * diag_len * eye_dir / np.linalg.norm(eye_dir) / 1.1 | |
| fig.update_layout( | |
| scene=dict( | |
| xaxis=dict(**axis_style, title=dict(text='x', font=title_font), tickfont=tick_font, tickmode='array', | |
| tickvals=[0, Nx // 2, Nx - 1], ticktext=[f'{abs(sz - v * unit):.1f}' for v in [0, Nx // 2, Nx - 1]]), | |
| yaxis=dict(**axis_style, title=dict(text='y', font=title_font), tickfont=tick_font, tickmode='array', | |
| tickvals=[0, Ny // 2, Ny - 1], ticktext=[f'{abs(sz - v * unit):.1f}' for v in [0, Ny // 2, Ny - 1]]), | |
| zaxis=dict(**axis_style, title=dict(text='z', font=title_font), tickfont=tick_font, tickmode='array', | |
| tickvals=[Nz - 1], ticktext=[f'{Nz * unit:.2f}']), | |
| aspectmode='data', | |
| camera=dict(eye=dict(x=float(eye[0] * 0.01), y=float(eye[1] * 0.01), z=float(eye[2] * 0.01)))), | |
| width=cm2px(fig_width_cm, dpi), height=cm2px(fig_height_cm, dpi), paper_bgcolor='rgba(0,0,0,0)') | |
| return fig | |
| def vis_field(data, cmap='jet', colorbar_title=None): | |
| """3-D resist field (Z, H, W) on the wafer grid (4 nm / px).""" | |
| data = to_numpy(data).transpose(2, 1, 0)[::-1, :, ::-1] | |
| return plot_tensor_slices(data, colorscale=cmap, colorbar_title=colorbar_title) | |
| def ground_plane(xmin, xmax, ymin, ymax, z0=0.0, color='rgba(200,200,255,1)', grid_size=10): | |
| return go.Surface(x=[[xmin, xmax]] * 2, y=[[ymin, ymin], [ymax, ymax]], z=[[z0, z0]] * 2, | |
| showscale=False, colorscale=[[0, color], [1, color]], | |
| contours=dict(x=dict(show=True, color='black', start=xmin, end=xmax, size=(xmax - xmin) / grid_size, width=16), | |
| y=dict(show=True, color='black', start=ymin, end=ymax, size=(ymax - ymin) / grid_size, width=16), | |
| z=dict(show=False))) | |
| def plot_mesh(vertices, faces, camera_distance=0.9, above_color='#86CDFF', width=800, height=600): | |
| """Triangle mesh of the developed resist on a ground plane; the bottom cap (z < 0.5 px) is hidden.""" | |
| z_centroids = vertices[faces].mean(axis=1)[:, 2] | |
| face_colors = np.where(z_centroids < 0.5, 'rgba(0,0,0,0)', above_color) | |
| vertices = vertices / np.linalg.norm(np.ptp(vertices, axis=0)) | |
| vmin, vmax = vertices.min(0), vertices.max(0) | |
| center, diag_vec = (vmin + vmax) / 2, vmax - vmin | |
| light = center + 2 * diag_vec | |
| mesh = go.Mesh3d(x=vertices[:, 0], y=vertices[:, 1], z=vertices[:, 2], | |
| i=faces[:, 0], j=faces[:, 1], k=faces[:, 2], facecolor=face_colors, flatshading=False, | |
| lighting=dict(ambient=0.20, diffuse=0.70, specular=0.45, roughness=0.35, fresnel=0.06), | |
| lightposition=dict(x=light[0], y=light[1], z=light[2]), showscale=False, name='') | |
| p = 0.05 * vmax[0] | |
| eye = center + camera_distance * np.linalg.norm(diag_vec) * np.array([1.5, -2, 1.7]) / 4 * 5 | |
| fig = go.Figure([mesh, ground_plane(p, vmax[0] - p, p, vmax[1] - p, z0=0.003)]) | |
| fig.update_layout(width=width, height=height, margin=dict(l=0, r=0, t=0, b=0), paper_bgcolor='rgba(0,0,0,0)', | |
| scene=dict(aspectmode='data', camera=dict(eye=dict(x=eye[0], y=eye[1], z=eye[2])), | |
| xaxis=dict(visible=False), yaxis=dict(visible=False), zaxis=dict(visible=False))) | |
| return fig | |
| def vis_resist(T, level=60.0): | |
| """Developed resist {T > level} of a development-time field (Z, H, W) as a 3-D surface.""" | |
| vol = to_numpy(T).transpose(1, 2, 0)[:, :, ::-1].copy() | |
| vol[:, :, 0] = np.maximum(vol[:, :, 0], level + 0.1) | |
| vertices, faces, _, _ = measure.marching_cubes(vol, level=level) | |
| return plot_mesh(vertices, faces) | |
| def export_scatter_plotly(coords, intensity, scatter_width_cm=2.0, scatter_height_cm=2.0, dpi=300, scale=1.0, | |
| marker_size=4.0, background_color='rgba(249, 240, 255, 1.0)', text_font_size=7, | |
| ticklabel_font_size=5, ticks=(-1, 0, 1), boundary_linewidth=1, tick_width=1, | |
| x_label='sx', y_label='sy', ticklen=16, outer_margin_cm=0.2): | |
| coords, intensity = to_numpy(coords), to_numpy(intensity) | |
| data_w = scatter_width_cm / 2.54 * dpi | |
| data_h = scatter_height_cm / 2.54 * dpi | |
| text_px = int(text_font_size / 72 * dpi * scale) | |
| tick_px = int(ticklabel_font_size / 72 * dpi * scale) | |
| pad = int(5 * scale) | |
| outer = outer_margin_cm / 2.54 * dpi | |
| ml = outer + boundary_linewidth + ticklen + tick_px + text_px + pad | |
| mr = outer + boundary_linewidth + pad | |
| mb = outer + boundary_linewidth + ticklen + tick_px + text_px * 3 + pad | |
| mt = outer + boundary_linewidth + pad | |
| fig_w = ml + mr + data_w | |
| fig_h = mt + mb + data_h | |
| def make_axis(label, domain, anchor): | |
| return dict(domain=domain, anchor=anchor, showline=True, linecolor='lightgray', linewidth=boundary_linewidth, | |
| mirror=True, fixedrange=True, tickcolor='black', tickfont=dict(size=tick_px, color='black'), | |
| tickwidth=tick_width, ticklen=ticklen, ticks='outside', range=[-1.1, 1.1], | |
| title=dict(text=label, font=dict(size=text_px, color='black'), standoff=tick_px + ticklen), | |
| tickmode='array', tickvals=list(ticks), ticktext=[f'{v:.1f}' for v in ticks]) | |
| fig = go.Figure(go.Scatter(x=coords[:, 0], y=coords[:, 1], mode='markers', | |
| marker=dict(size=marker_size, color='rgba(128,0,128,1.0)', opacity=intensity, line=dict(width=0)))) | |
| fig.update_layout(autosize=False, width=int(fig_w), height=int(fig_h), margin=dict(l=0, r=0, t=0, b=0), | |
| paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor=background_color, | |
| font=dict(family='Arial, sans-serif', size=text_px, color='black'), | |
| xaxis=make_axis(x_label, [ml / fig_w, (ml + data_w) / fig_w], 'y'), | |
| yaxis=make_axis(y_label, [mb / fig_h, (mb + data_h) / fig_h], 'x')) | |
| return fig | |
| def vis_source(points, weights): | |
| """Source points in pupil coordinates (sigma_x, sigma_y; unit circle = numerical aperture) with weights in [0, 1].""" | |
| return export_scatter_plotly(points, weights) | |
| def color_gradient(start_hex, end_hex, n): | |
| def rgb(h): | |
| return tuple(int(h[i:i + 2], 16) for i in (1, 3, 5)) | |
| s, e = rgb(start_hex), rgb(end_hex) | |
| if n <= 1: | |
| return [f'rgb{e}'] | |
| return [f'rgb({int(s[0] + (e[0] - s[0]) * i / (n - 1))}, {int(s[1] + (e[1] - s[1]) * i / (n - 1))}, ' | |
| f'{int(s[2] + (e[2] - s[2]) * i / (n - 1))})' for i in range(n)] | |
| def plot_focus_exposure(data_list, dose_ary, cmap_idx=0, fig_width_cm=5, fig_height_cm=1.5, dpi=600, | |
| text_font_size=1.5, ticklabel_font_size=2, x_label='Focus [nm]', y_label='CD [nm]', | |
| showlegend=False): | |
| """CD versus focus per dose. data_list = [({dose: (focus_list, cd_list)}, panel title), ...].""" | |
| fig_w = fig_width_cm / 2.54 * dpi | |
| fig_h = fig_height_cm / 2.54 * dpi | |
| text_px = int(text_font_size / 72 * dpi) | |
| tick_px = int(ticklabel_font_size / 72 * dpi) | |
| n = len(data_list) | |
| fig = make_subplots(rows=1, cols=n, subplot_titles=[title for _, title in data_list]) | |
| sorted_doses = sorted(dose_ary) | |
| colors = color_gradient('#D0D0D0', px.colors.qualitative.Plotly[cmap_idx], len(sorted_doses)) | |
| dose_color = {dose: colors[i] for i, dose in enumerate(sorted_doses)} | |
| for col, (data, _) in enumerate(data_list, start=1): | |
| for dose in dose_ary: | |
| if dose not in data: | |
| continue | |
| focus, cd = data[dose] | |
| fig.add_trace(go.Scatter(x=focus, y=cd, mode='lines', name=f'{dose:g} mJ/cm²', | |
| line=dict(color=dose_color[dose], width=4), | |
| legendgroup=f'{dose}', showlegend=col == 1), row=1, col=col) | |
| axis = dict(showline=True, linecolor='black', mirror=True, linewidth=1, tickfont=dict(size=tick_px, color='black'), ticks='inside') | |
| for col in range(1, n + 1): | |
| s = '' if col == 1 else str(col) | |
| fig.update_layout(**{f'xaxis{s}': dict(**axis, title=dict(text=x_label), range=[-160, 160], nticks=5), | |
| f'yaxis{s}': dict(**axis, title=dict(text=y_label if col == 1 else '', standoff=text_px * 0.8), | |
| range=[0, 310], showticklabels=col == 1)}) | |
| fig.update_layout(autosize=False, width=int(fig_w), height=int(fig_h), paper_bgcolor='white', plot_bgcolor='white', | |
| font=dict(family='Arial, sans-serif', size=text_px, color='black'), showlegend=showlegend) | |
| fig.update_annotations(font=dict(family='Arial, sans-serif', size=text_px, color='black')) | |
| return fig | |
| def plot_profiles(bot, top, sem=None, dose_ary=(51, 39, 27), focus_ary=tuple(-100 + 20 * i for i in range(11)), | |
| ny=50, nx=35, dpi=600, text_font_size=1.5, scale=1.5): | |
| """Resist profiles around the center line: bottom (red) and top (blue) contours, SEM image behind if given. | |
| bot / top / sem = {dose: {focus: (H, W)}}.""" | |
| text_px = int(text_font_size / 72 * dpi) | |
| n_rows, n_cols = len(dose_ary), len(focus_ary) | |
| cell_h, cell_w = 2 * ny + 1, 2 * nx + 1 | |
| margin_l, margin_t = text_px * 10, text_px * 4 | |
| fig = make_subplots(rows=n_rows, cols=n_cols, horizontal_spacing=0.01, vertical_spacing=0.01, | |
| subplot_titles=[f'{focus:g} nm' if r == 0 else '' for r in range(n_rows) for focus in focus_ary]) | |
| def crop(table, dose, focus): | |
| N = to_numpy(table[dose][focus]).shape[0] | |
| c = N // 2 - 1 | |
| return to_numpy(table[dose][focus])[c - ny:c + ny + 1, c - nx:c + nx + 1].astype(float) | |
| for r, dose in enumerate(dose_ary, start=1): | |
| for c, focus in enumerate(focus_ary, start=1): | |
| if sem is not None: | |
| fig.add_trace(go.Heatmap(z=crop(sem, dose, focus), colorscale=[[0, 'black'], [1, 'white']], | |
| zmin=0, zmax=255, showscale=False), row=r, col=c) | |
| else: | |
| fig.add_trace(go.Heatmap(z=crop(bot, dose, focus), colorscale=[[0, 'white'], [1, '#DDDDDD']], | |
| zmin=0, zmax=1, showscale=False), row=r, col=c) | |
| for table, color in [(bot, 'rgba(255,0,0,0.5)'), (top, 'rgba(0,0,255,0.5)')]: | |
| for contour in measure.find_contours(crop(table, dose, focus), 0.5): | |
| fig.add_trace(go.Scatter(x=contour[:, 1], y=contour[:, 0], mode='lines', | |
| line=dict(color=color, width=4), showlegend=False), row=r, col=c) | |
| for i in range(1, n_rows * n_cols + 1): | |
| s = '' if i == 1 else str(i) | |
| fig.update_layout(**{f'xaxis{s}': dict(showline=False, showticklabels=False, ticks='', showgrid=False, zeroline=False, range=[-0.5, cell_w - 0.5]), | |
| f'yaxis{s}': dict(showline=False, showticklabels=False, ticks='', showgrid=False, zeroline=False, range=[cell_h - 0.5, -0.5])}) | |
| for r, dose in enumerate(dose_ary): | |
| fig.add_annotation(x=0, y=1 - (r + 0.5) / n_rows, xref='paper', yref='paper', xanchor='right', yanchor='middle', | |
| xshift=-4, text=f'{dose:g} mJ/cm²', showarrow=False) | |
| background = ', Background: SEM' if sem is not None else '' | |
| fig.update_layout(width=int(n_cols * cell_w * scale + margin_l), height=int(n_rows * cell_h * scale + margin_t), | |
| autosize=False, paper_bgcolor='white', plot_bgcolor='white', | |
| font=dict(family='Arial, sans-serif', size=text_px, color='black'), | |
| title_text=f'Resist profiles [Red: Bottom, Blue: Top{background}]', title_x=0.5, showlegend=False, | |
| margin=dict(l=margin_l, t=margin_t, r=10, b=10)) | |
| fig.update_annotations(font=dict(family='Arial, sans-serif', size=text_px, color='black')) | |
| return fig | |
| def save_html(figures, filepath, title='Dashboard', layout=(), cols=2, subtitle=''): | |
| """Grid of figures in one standalone HTML page. layout = [{'row', 'col', 'title', 'colspan'}, ...].""" | |
| parts = [pio.to_html(fig, full_html=False, include_plotlyjs=(i == 0)) for i, fig in enumerate(figures)] | |
| items = '' | |
| for i, part in enumerate(parts): | |
| L = layout[i] if i < len(layout) else {} | |
| style = (f'grid-row: {L.get("row", "auto")} / span {L.get("rowspan", 1)}; ' | |
| f'grid-column: {L.get("col", "auto")} / span {L.get("colspan", 1)};') | |
| heading = f'<div class="fig-title">{L["title"]}</div>' if L.get('title') else '' | |
| items += f'<div class="fig-item" style="{style}">{heading}<div class="fig-inner">{part}</div></div>\n' | |
| html = f"""<!DOCTYPE html> | |
| <html> | |
| <head> | |
| <meta charset="utf-8"> | |
| <title>{title}</title> | |
| <style> | |
| body {{ font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }} | |
| h1 {{ margin-bottom: 8px; }} | |
| p.subtitle {{ margin: 0 0 20px 0; color: #444; }} | |
| .grid-container {{ display: grid; grid-template-columns: repeat({cols}, 1fr); gap: 16px; }} | |
| .fig-item {{ background: white; border-radius: 8px; padding: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }} | |
| .fig-title {{ font-size: 1em; font-weight: bold; color: #333; margin-bottom: 8px; padding-bottom: 6px; border-bottom: 2px solid #e0e0e0; }} | |
| .fig-inner {{ width: 100%; overflow-x: auto; }} | |
| </style> | |
| </head> | |
| <body> | |
| <h1>{title}</h1> | |
| <p class="subtitle">{subtitle}</p> | |
| <div class="grid-container">{items}</div> | |
| </body> | |
| </html>""" | |
| with open(filepath, 'w', encoding='utf-8') as f: | |
| f.write(html) | |
| print('saved', filepath) | |