Add visualization utils

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+vis/Metal_I_cell1550.html filter=lfs diff=lfs merge=lfs -text
+vis/vis_SMO.ipynb filter=lfs diff=lfs merge=lfs -text

vis/Metal_I_cell1550.html

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:733b9f6e981a4adc8657fd40c9cd92e919019817f46d4f88075c828828999e07
+size 37023874

vis/utils_PW.py

@@ -0,0 +1,163 @@
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+from skimage import measure
+
+
+def get_color_gradient(start_hex, end_hex, n):
+    def hex_to_rgb(h):
+        h = h.lstrip('#')
+        return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+    if n <= 1:
+        return [f'rgb{hex_to_rgb(end_hex)}']
+
+    s, e = hex_to_rgb(start_hex), hex_to_rgb(end_hex)
+    return [
+        f'rgb({int(s[0] + (e[0]-s[0])*i/(n-1))}, {int(s[1] + (e[1]-s[1])*i/(n-1))}, {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, **kwargs):
+    dpi      = kwargs.get('dpi', 600)
+    fig_w    = kwargs.get('fig_width_cm', 5) / 2.54 * dpi
+    fig_h    = kwargs.get('fig_height_cm', 1.5) / 2.54 * dpi
+    text_px  = int(kwargs.get('text_font_size', 1.5) / 72 * dpi)
+    tick_px  = int(kwargs.get('ticklabel_font_size', 2) / 72 * dpi)
+
+    show_x_ticks      = kwargs.get('show_x_ticks', True)
+    show_x_ticklabels = kwargs.get('show_x_ticklabels', True)
+    show_y_ticks      = kwargs.get('show_y_ticks', True)
+    show_y_ticklabels = kwargs.get('show_y_ticklabels', True)
+
+    n = len(data_list)
+    fig = make_subplots(rows=1, cols=n, subplot_titles=[title for _, title in data_list])
+
+    target_color = px.colors.qualitative.Plotly[cmap_idx]
+    sorted_doses = sorted(dose_ary)
+    colors = get_color_gradient("#D0D0D0", target_color, len(sorted_doses))
+    dose_color = {dose: colors[i] for i, dose in enumerate(sorted_doses)}
+
+    for col_idx, (data, title) in enumerate(data_list, start=1):
+        for dose in dose_ary:
+            if dose not in data:
+                continue
+            focus_p, cd_p = data[dose]
+            fig.add_trace(go.Scatter(
+                x=focus_p, y=cd_p, mode='lines',
+                name=f'{dose} mJ/cm²',
+                line=dict(color=dose_color[dose], width=4),
+                legendgroup=f'{dose}', showlegend=(col_idx == 1),
+            ), row=1, col=col_idx)
+
+    axis_common = dict(
+        showline=True, linecolor='black', mirror=True, linewidth=1,
+        tickfont=dict(size=tick_px, color='black'),
+    )
+
+    for col_idx in range(1, n + 1):
+        s = '' if col_idx == 1 else str(col_idx)
+        fig.update_layout(**{
+            f'xaxis{s}': dict(
+                **axis_common,
+                title=dict(text=kwargs.get('x_label', 'Focus [nm]')),
+                range=[-160, 160], nticks=5,
+                ticks='inside' if show_x_ticks else '',
+                showticklabels=show_x_ticklabels,
+            ),
+            f'yaxis{s}': dict(
+                **axis_common,
+                title=dict(text=kwargs.get('y_label', 'CD [nm]') if col_idx == 1 else '', standoff=text_px * 0.8),
+                range=[0, 310],
+                ticks='inside' if show_y_ticks else '',
+                showticklabels=show_y_ticklabels if col_idx == 1 else False,
+            ),
+        })
+
+    fig.update_layout(
+        autosize=False, width=int(fig_w), height=int(fig_h),
+        paper_bgcolor='rgba(255,255,255,1)', plot_bgcolor='rgba(255,255,255,1)',
+        font=dict(family='Arial, sans-serif', size=text_px, color='black'),
+        showlegend=kwargs.get('showlegend', False),
+    )
+    fig.update_annotations(font=dict(family='Arial, sans-serif', size=text_px, color='black'))
+    return fig
+
+
+def plot_profiles(bot, top, sem, **kwargs):
+    dpi      = kwargs.get('dpi', 600)
+    text_px  = int(kwargs.get('text_font_size', 1.5) / 72 * dpi)
+    scale    = kwargs.get('scale', 1.5)
+
+    dose_ary  = kwargs.get('dose_ary',  [34, 26, 18])
+    focus_ary = kwargs.get('focus_ary', [-100 + 20*i for i in range(11)])
+    ny, nx    = kwargs.get('ny', 50), kwargs.get('nx', 35)
+    nc        = 512 // 2 - 1
+
+    n_rows, n_cols   = len(dose_ary), len(focus_ary)
+    cell_h, cell_w   = 2*ny + 1, 2*nx + 1
+    margin_l         = kwargs.get('margin_l', text_px * 10)
+    margin_t         = kwargs.get('margin_t', text_px * 4)
+
+    to_np = lambda t: t.float().numpy() if hasattr(t, 'numpy') else np.array(t, dtype=float)
+
+    fig = make_subplots(
+        rows=n_rows, cols=n_cols,
+        subplot_titles=[f'{focus_ary[c]} nm' if r == 0 else '' for r in range(n_rows) for c in range(n_cols)],
+        horizontal_spacing=0.01, vertical_spacing=0.01,
+    )
+
+    for row_idx, dose in enumerate(dose_ary):
+        for col_idx, focus in enumerate(focus_ary):
+            r, c = row_idx + 1, col_idx + 1
+            crop = lambda d: to_np(d[dose][focus][nc-ny:nc+ny+1, nc-nx:nc+nx+1])
+            bot_c, top_c, sem_c = crop(bot), crop(top), crop(sem)
+
+            fig.add_trace(go.Heatmap(
+                z=sem_c, colorscale=[[0, 'black'], [1, 'white']],
+                zmin=0, zmax=255, showscale=False,
+            ), row=r, col=c)
+
+            for contour in measure.find_contours(bot_c, 0.5):
+                fig.add_trace(go.Scatter(
+                    x=contour[:, 1], y=contour[:, 0], mode='lines',
+                    line=dict(color='rgba(255,0,0,0.5)', width=4), showlegend=False,
+                ), row=r, col=c)
+
+            for contour in measure.find_contours(top_c, 0.5):
+                fig.add_trace(go.Scatter(
+                    x=contour[:, 1], y=contour[:, 0], mode='lines',
+                    line=dict(color='rgba(0,0,255,0.5)', width=4), showlegend=False,
+                ), row=r, col=c)
+
+    for row_idx in range(n_rows):
+        for col_idx in range(n_cols):
+            idx = row_idx * n_cols + col_idx + 1
+            s = '' if idx == 1 else str(idx)
+            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 row_idx, dose in enumerate(dose_ary):
+        fig.add_annotation(
+            x=0, y=1 - (row_idx + 0.5) / n_rows,
+            xref='paper', yref='paper',
+            xanchor='right', yanchor='middle', xshift=-4,
+            text=f'{dose} mJ/cm²', showarrow=False,
+        )
+
+    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='Resist profiles [Red: Bottom, Blue: Top, Background: SEM]',
+        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

vis/utils_SMO.py

@@ -0,0 +1,177 @@
+import os
+import torch
+import numpy as np
+import plotly.graph_objects as go
+from stl import mesh
+from skimage import measure
+from torch.fft import fftfreq, fftshift
+
+
+def _make_ground_plane(xmin, xmax, ymin, ymax, z0=0.0, color="#1653D0", grid_color="black", 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=grid_color, start=xmin, end=xmax, size=(xmax - xmin) / grid_size, width=16),
+            y=dict(show=True, color=grid_color, start=ymin, end=ymax, size=(ymax - ymin) / grid_size, width=16),
+            z=dict(show=False),
+        ),
+    )
+
+
+def plot_stl(
+    stl_path, z_th=0.5, scale_mode="auto", isotropic_view=True,
+    camera_distance=0.9, below_color="rgba(0,0,0,0)", above_color="#86CDFF",
+    flat_shading=False, ambient=0.20, diffuse=0.70, specular=0.45,
+    roughness=0.35, fresnel=0.06, light_xyz=None, width=800, height=600, margin=0,
+):
+    tri = mesh.Mesh.from_file(str(stl_path)).vectors
+    vertices, reindex = np.unique(tri.reshape(-1, 3), axis=0, return_inverse=True)
+    i, j, k = reindex.reshape(-1, 3).T
+
+    if scale_mode == "auto":
+        diag_len = np.linalg.norm(np.ptp(vertices, axis=0))
+        vertices = vertices / diag_len
+    elif isinstance(scale_mode, (int, float)):
+        vertices = vertices * float(scale_mode)
+
+    vmin, vmax = vertices.min(0), vertices.max(0)
+    center, diag_vec = (vmin + vmax) / 2, vmax - vmin
+    diag_len = np.linalg.norm(diag_vec)
+
+    z_centroids = tri.mean(axis=1)[:, 2]
+    if scale_mode == "auto":
+        z_centroids = z_centroids / diag_len
+    face_colors = np.where(z_centroids < z_th, below_color, above_color)
+
+    light_pos = light_xyz or (center + 2 * diag_vec)
+    mesh3d = go.Mesh3d(
+        x=vertices[:, 0], y=vertices[:, 1], z=vertices[:, 2],
+        i=i, j=j, k=k, facecolor=face_colors, flatshading=flat_shading,
+        lighting=dict(ambient=ambient, diffuse=diffuse, specular=specular, roughness=roughness, fresnel=fresnel),
+        lightposition=dict(x=light_pos[0], y=light_pos[1], z=light_pos[2]),
+        showscale=False, name="",
+    )
+
+    p = 0.05 * vmax[0]
+    ground = _make_ground_plane(p, vmax[0] - p, p, vmax[1] - p, z0=0.003, color="rgba(200,200,255,1)", grid_color="black")
+
+    eye_pos = center + camera_distance * diag_len * (
+        np.array([1.5, -2, 1.7]) / 4 * 5 if isotropic_view else np.array([0, 0, 1])
+    )
+
+    fig = go.Figure(mesh3d)
+    fig.add_trace(ground)
+    fig.update_layout(
+        width=width, height=height,
+        margin=dict(l=margin, r=margin, t=margin, b=margin),
+        paper_bgcolor="rgba(0,0,0,0)",
+        scene=dict(
+            aspectmode="data",
+            camera=dict(eye=dict(x=eye_pos[0], y=eye_pos[1], z=eye_pos[2])),
+            xaxis=dict(visible=False), yaxis=dict(visible=False), zaxis=dict(visible=False),
+        ),
+    )
+    return fig
+
+
+def vis_time_resist(traveltime, level=30.):
+    traveltime = traveltime.permute(1, 2, 0).flip(dims=(2,))
+    bo = traveltime[:, :, 0]
+    bo[bo < level] = level + 0.1
+    traveltime[:, :, 0] = bo
+
+    vertices, faces, _, _ = measure.marching_cubes(traveltime.numpy(), level=level)
+    surf_mesh = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+    surf_mesh.vectors = vertices[faces]
+    surf_mesh.save('tmp.stl')
+
+    fig = plot_stl('tmp.stl')
+    os.remove('tmp.stl')
+    return fig
+
+
+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,
+    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_ticktext=None, y_ticktext=None,
+    x_ticks=[-125, 0, 125], y_ticks=[-125, 0, 125],
+    boundary_linewidth=1, tick_width=1,
+    x_label='sx', y_label='sy',
+    ticklen=16, outer_margin_cm=0.2,
+):
+    if isinstance(coords, torch.Tensor):
+        coords = coords.detach().cpu().numpy()
+    if isinstance(intensity, torch.Tensor):
+        intensity = intensity.detach().cpu().numpy()
+
+    def cm2px(v): return v / 2.54 * dpi
+
+    data_w = cm2px(scatter_width_cm)
+    data_h = cm2px(scatter_height_cm)
+    text_px = int(text_font_size / 72 * dpi * scale)
+    tick_px = int(ticklabel_font_size / 72 * dpi * scale)
+    pad = int(5 * scale)
+    outer = cm2px(outer_margin_cm)
+
+    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
+    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 + data_w
+    fig_h = mt + mb + data_h
+
+    border = dict(showline=True, linecolor='lightgray', linewidth=boundary_linewidth, mirror=True, fixedrange=True)
+    tick_cfg = dict(tickcolor='black', tickfont=dict(size=tick_px, color='black'), tickwidth=tick_width, ticklen=ticklen)
+
+    def make_axis(label, domain, anchor, show_ticks, show_labels, ticks, ticktext, unit):
+        ax = dict(
+            domain=domain, anchor=anchor, **border, **tick_cfg,
+            ticks='outside' if show_ticks else '',
+            showticklabels=show_labels,
+            title=dict(text=label or '', font=dict(size=text_px, color='black'), standoff=tick_px + ticklen),
+            range=[-1.1, 1.1],
+        )
+        if ticks is not None:
+            ax.update(
+                tickmode='array', tickvals=ticks,
+                ticktext=[str(int(v * unit)) for v in ticks] if ticktext is None else ticktext,
+            )
+        return ax
+
+    fig = go.Figure(data=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', show_x_ticks, show_x_ticklabels, x_ticks, x_ticktext, x_unit),
+        yaxis=make_axis(y_label, [mb / fig_h, (mb + data_h) / fig_h], 'x', show_y_ticks, show_y_ticklabels, y_ticks, y_ticktext, y_unit),
+    )
+    return fig
+
+
+def vis_source(y_src, Nx=512, dx=4, Ny=512, dy=4, sigma=[0.5, 0.9], NA=1.35, wavelength=193):
+    fx_v, fy_v = fftfreq(Nx, dx), fftfreq(Ny, dy)
+    FY, FX = torch.meshgrid(fy_v, fx_v, indexing='ij')
+    fx_grid, fy_grid = fftshift(FX), fftshift(FY)
+
+    rb = (fx_grid**2 + fy_grid**2)**0.5 / (NA / wavelength)
+    mask = (sigma[0] < rb) & (rb < sigma[1])
+    coords = torch.stack([fx_grid[mask].view(-1), fy_grid[mask].view(-1)], dim=1)
+    coords = coords / (sigma[1] * NA / wavelength)
+
+    return export_scatter_plotly(
+        coords, y_src,
+        x_ticks=[-1, 0, 1], y_ticks=[-1, 0, 1],
+        x_ticktext=['-1.0', '0.0', '1.0'], y_ticktext=['-1.0', '0.0', '1.0'],
+    )

vis/utils_data.py

@@ -0,0 +1,422 @@
+import torch
+import numpy as np
+import plotly.graph_objects as go
+from stl import mesh as stl_mesh
+from matplotlib import cm
+
+
+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 = cm.get_cmap(cmap_name) if isinstance(cmap_name, str) else 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 = cm.get_cmap(cmap_name) if isinstance(cmap_name, str) else 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,
+):
+    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)
+
+    def cm2px(v): return v / 2.54 * dpi
+
+    N = panels[0, 0].shape[0]
+    if N > 1000:
+        x_ticks = [0, 500, 1000]; y_ticks = [0, 500, 1000]
+        heatmap_width_cm *= 2; heatmap_height_cm *= 2
+        colorbar_thickness *= 2
+
+    data_w = cm2px(heatmap_width_cm)
+    data_h = cm2px(heatmap_height_cm)
+    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 = cm2px(outer_margin_cm)
+    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 min(panels[r, c].min() for r in range(rows) for c in range(cols)))
+    vmax = float(colorbar_max if colorbar_max is not None else max(panels[r, c].max() for r in range(rows) for c in range(cols)))
+
+    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=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=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], anchor=yname(idx), is_bottom=(r == rows - 1)),
+                f'yaxis{"" if idx == 0 else idx+1}': make_yaxis([y0, y1], anchor=xname(idx), is_left=(c == 0)),
+            })
+
+    if use_colorbar:
+        n_cb = 256
+        cb_idx = rows * cols
+        cb_data = np.linspace(vmin, vmax, n_cb).reshape(n_cb, 1)
+        cb_x0 = (ml + cols * data_w + (cols - 1) * gap + cb_gap) / fig_w
+        cb_x1 = cb_x0 + colorbar_thickness / fig_w
+        cb_tickvals = np.linspace(0, n_cb - 1, 5)
+        cb_ticktext = [f"{v:.2f}" for v in np.linspace(vmin, vmax, 5)]
+
+        fig.add_trace(go.Heatmap(
+            z=cb_data, colorscale=cmap, showscale=False,
+            zmin=vmin, zmax=vmax, xaxis=xname(cb_idx), yaxis=yname(cb_idx),
+        ))
+        fig.update_layout(**{
+            f'xaxis{"" if cb_idx == 0 else 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{"" if cb_idx == 0 else cb_idx+1}': dict(
+                domain=[grid_y0, grid_y1], anchor=xname(cb_idx), side='right', fixedrange=True,
+                tickmode='array', tickvals=cb_tickvals, ticktext=cb_ticktext,
+                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'):
+    return plot_2d(torch.flip(data, dims=(0,)), cmap=cmap, use_colorbar=False)
+
+def vis_sc(data, cmap='jet'):
+    return plot_2d(torch.flip(data, dims=(2,)), cmap=cmap, use_colorbar=True, colorbar_title='Amplitude [-]')
+
+
+def plot_tensor_slices(
+    data, slice_indices=None, opacity=None, colorscale="jet",
+    vmin=None, vmax=None, alpha_at_cmin=0.1, alpha_at_cmax=1,
+    use_colorbar=True, colorbar_thickness=20, colorbar_title=None,
+    colorbar_title_side="right", use_dummy_colorbar=True, colorbar_length=0.6,
+    colorbar_font="Arial, sans-serif", colorbar_fontsize=7, colorbar_tick_fontsize=5,
+    colorbar_nticks=None, show_axes=True, isotropic_view=True,
+    camera_distance=1.5, fig_width_cm=6.0, fig_height_cm=4.0, dpi=300, png_path=None,
+):
+    if data.ndim != 3:
+        raise ValueError("`data` must be a 3-D array (Nx, Ny, Nz).")
+
+    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
+    ix, iy, iz = map(int, slice_indices) if slice_indices else (Nx // 2, Ny // 2, Nz // 2)
+    vmin = float(np.nanmin(data)) if vmin is None else float(vmin)
+    vmax = float(np.nanmax(data)) if vmax is None else float(vmax)
+
+    custom_scale = _alpha_colorscale(colorscale, alpha_at_cmin, alpha_at_cmax)
+    dummy_scale = _rgb_colorscale(colorscale)
+
+    x, y, z = np.arange(Nx), np.arange(Ny), np.arange(Nz)
+
+    def cb_cfg():
+        cb = dict(
+            lenmode="fraction", len=colorbar_length, thickness=colorbar_thickness,
+            x=0.85, y=0.45,
+            tickfont=dict(family=colorbar_font, size=_pt2px(colorbar_tick_fontsize, dpi), color="black"),
+            tickwidth=1, tickcolor="black", outlinewidth=1, outlinecolor="black",
+            nticks=colorbar_nticks or 5,
+        )
+        if colorbar_title is not None:
+            cb["title"] = dict(
+                text=colorbar_title, side=colorbar_title_side,
+                font=dict(family=colorbar_font, size=_pt2px(colorbar_fontsize, dpi), color="black"),
+            )
+        return cb
+
+    surf_kw = dict(
+        colorscale=custom_scale, cmin=vmin, cmax=vmax,
+        lighting=dict(ambient=1.0), opacity=1.0 if opacity is None else opacity,
+    )
+
+    surfaces = []
+    for k_z in range(0, Nz, 4):
+        show_scale = use_colorbar and not use_dummy_colorbar and len(surfaces) == 0
+        surfaces.append(go.Surface(
+            x=np.tile(x[:, None], (1, Ny)), y=np.tile(y[None, :], (Nx, 1)),
+            z=np.full((Nx, Ny), k_z), surfacecolor=data[:, :, k_z],
+            showscale=show_scale, colorbar=cb_cfg() if show_scale else None,
+            name=f"XY @ z={k_z}", **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, :, :],
+        showscale=False, name=f"YZ @ x={Nx-1}", **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, :],
+        showscale=False, name=f"XZ @ y={Ny-1}", **surf_kw,
+    ))
+
+    fig = go.Figure(data=surfaces)
+
+    if use_colorbar and use_dummy_colorbar:
+        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=dummy_scale,
+                showscale=True, colorbar=cb_cfg(),
+            ),
+        ))
+
+    bbox_x = [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]
+    bbox_y = [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]
+    bbox_z = [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=bbox_x, y=bbox_y, z=bbox_z, 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(visible=show_axes, 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
+
+    if isotropic_view:
+        eye_dir = np.array([1.0, 1.0, 1.7 * (2.5 if sf == 2 else 1.0)])
+        eye_pos = centre + camera_distance * diag_len * eye_dir / np.linalg.norm(eye_dir) / 1.1
+    else:
+        eye_pos = centre + camera_distance * np.array([0.0, 0.0, diag_len])
+
+    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"{abs(Nz * unit):.2f}"]),
+            aspectmode="data",
+            camera=dict(eye=dict(x=float(eye_pos[0]*0.01), y=float(eye_pos[1]*0.01), z=float(eye_pos[2]*0.01))),
+        ),
+        width=_cm2px(fig_width_cm, dpi), height=_cm2px(fig_height_cm, dpi),
+        paper_bgcolor="rgba(0,0,0,0)",
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+    )
+
+    if png_path is not None:
+        fig.write_image(png_path, width=_cm2px(fig_width_cm, dpi), height=_cm2px(fig_height_cm, dpi), scale=1.0)
+
+    return fig
+
+
+def vis_field(data, cmap="jet", colorbar_title=None):
+    data = data.permute(2, 1, 0).flip(dims=(0, 2))
+    return plot_tensor_slices(data, colorscale=cmap, colorbar_title=colorbar_title)
+
+
+def _make_ground_plane(xmin, xmax, ymin, ymax, z0=0.0, color="#1653D0", grid_color="black", 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=grid_color, start=xmin, end=xmax, size=(xmax - xmin) / grid_size, width=16),
+            y=dict(show=True, color=grid_color, start=ymin, end=ymax, size=(ymax - ymin) / grid_size, width=16),
+            z=dict(show=False),
+        ),
+    )
+
+
+def plot_stl(
+    stl_path, z_th=0.5, scale_mode="auto", isotropic_view=True,
+    camera_distance=0.9, below_color="rgba(0,0,0,0)", above_color="#86CDFF",
+    flat_shading=False, ambient=0.20, diffuse=0.70, specular=0.45,
+    roughness=0.35, fresnel=0.06, light_xyz=None, width=800, height=600, margin=0,
+):
+    tri = stl_mesh.Mesh.from_file(str(stl_path)).vectors
+    vertices, reindex = np.unique(tri.reshape(-1, 3), axis=0, return_inverse=True)
+    i, j, k = reindex.reshape(-1, 3).T
+
+    if scale_mode == "auto":
+        diag_len = np.linalg.norm(np.ptp(vertices, axis=0))
+        vertices = vertices / diag_len
+    elif isinstance(scale_mode, (int, float)):
+        vertices = vertices * float(scale_mode)
+
+    vmin, vmax = vertices.min(0), vertices.max(0)
+    center, diag_vec = (vmin + vmax) / 2, vmax - vmin
+    diag_len = np.linalg.norm(diag_vec)
+
+    z_centroids = tri.mean(axis=1)[:, 2]
+    if scale_mode == "auto":
+        z_centroids = z_centroids / diag_len
+    face_colors = np.where(z_centroids < z_th, below_color, above_color)
+
+    light_pos = light_xyz or (center + 2 * diag_vec)
+    mesh3d = go.Mesh3d(
+        x=vertices[:, 0], y=vertices[:, 1], z=vertices[:, 2],
+        i=i, j=j, k=k, facecolor=face_colors, flatshading=flat_shading,
+        lighting=dict(ambient=ambient, diffuse=diffuse, specular=specular, roughness=roughness, fresnel=fresnel),
+        lightposition=dict(x=light_pos[0], y=light_pos[1], z=light_pos[2]),
+        showscale=False, name="",
+    )
+
+    p = 0.05 * vmax[0]
+    ground = _make_ground_plane(p, vmax[0] - p, p, vmax[1] - p, z0=0.003, color="rgba(200,200,255,1)", grid_color="black")
+
+    eye_pos = center + camera_distance * diag_len * (
+        np.array([1.5, -2, 1.7]) / 4 * 5 if isotropic_view else np.array([0, 0, 1])
+    )
+
+    fig = go.Figure(mesh3d)
+    fig.add_trace(ground)
+    fig.update_layout(
+        width=width, height=height,
+        margin=dict(l=margin, r=margin, t=margin, b=margin),
+        paper_bgcolor="rgba(0,0,0,0)",
+        scene=dict(
+            aspectmode="data",
+            camera=dict(eye=dict(x=eye_pos[0], y=eye_pos[1], z=eye_pos[2])),
+            xaxis=dict(visible=False), yaxis=dict(visible=False), zaxis=dict(visible=False),
+        ),
+    )
+    return fig
+
+
+_default_layout = [
+    {'row': 1, 'col': 1, 'title': 'Photomask (M)'},
+    {'row': 1, 'col': 2, 'title': 'Diffracted near field (E)'},
+    {'row': 2, 'col': 1, 'title': 'Photoacid (h)'},
+    {'row': 2, 'col': 2, 'title': 'Deprotection image (m)'},
+    {'row': 3, 'col': 1, 'title': 'Development rate (R)'},
+    {'row': 3, 'col': 2, 'title': 'Development time (T)'},
+]
+
+def save_html(figures, filepath, title="Dashboard", layout=_default_layout, cols=2):
+    import plotly.io as pio
+
+    html_parts = [pio.to_html(fig, full_html=False, include_plotlyjs=(i == 0)) for i, fig in enumerate(figures)]
+
+    items_html = ""
+    for i, part in enumerate(html_parts):
+        L = layout[i] if layout and i < len(layout) else {}
+        row, col = L.get("row", "auto"), L.get("col", "auto")
+        rowspan, colspan = L.get("rowspan", 1), L.get("colspan", 1)
+        fig_title = L.get("title", "")
+        style = f"grid-row: {row} / span {rowspan}; grid-column: {col} / span {colspan};"
+        title_html = f'<div class="fig-title">{fig_title}</div>' if fig_title else ""
+        items_html += f'<div class="fig-item" style="{style}">{title_html}<div class="fig-inner">{part}</div></div>\n'
+
+    full_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: 20px; }}
+    .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%; }}
+  </style>
+</head>
+<body>
+  <h1>{title}</h1>
+  <div class="grid-container">{items_html}</div>
+</body>
+</html>"""
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(full_html)
+    print(f"Saved → {filepath}")

vis/vis_SMO.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7b95b76099c2bef1a6f4a8965dea13afcdc1bd3650f1e1332e2dc88bcb9bdb3
+size 38513268

vis/vis_data.ipynb

@@ -0,0 +1,92 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "95b596a0",
+   "metadata": {},
+   "source": [
+    "# Data visualization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "659ff786",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import os\n",
+    "from utils_data import vis_mask, vis_sc, vis_field, save_html\n",
+    "\n",
+    "BASE = '../LithoBench_PDE'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a7b8b049",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load and visualize a data point (M, E), (h, m), (R, T)\n",
+    "layer_type = 'Metal_I'\n",
+    "cell_name = 'cell1550'\n",
+    "\n",
+    "data = torch.load(os.path.join(BASE, layer_type, f'{cell_name}.pt'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "cc776e33",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved → Metal_I_cell1550.html\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig_M = vis_mask(data['M'], cmap='gray')\n",
+    "fig_E = vis_sc(data['E'].abs(), cmap='jet')\n",
+    "\n",
+    "fig_h = vis_field(data['h'], cmap='coolwarm', colorbar_title='Rel. conc. [-]')\n",
+    "fig_m = vis_field(data['m'], cmap='jet',  colorbar_title='Rel. conc. [-]')\n",
+    "\n",
+    "fig_R = vis_field(data['R'], cmap='rainbow',  colorbar_title='Dev. rate [nm/s]')\n",
+    "fig_T = vis_field(data['T'], cmap='plasma', colorbar_title='Traveltime [s]')\n",
+    "\n",
+    "figures = [fig_M, fig_E, fig_h, fig_m, fig_R, fig_T]\n",
+    "\n",
+    "filepath = f'{layer_type}_{cell_name}.html'\n",
+    "\n",
+    "save_html(figures, filepath, title=f'{layer_type} {cell_name}')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "neurolitho",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}