make_mesh_png.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import argparse
import html
import json
from glob import glob
from pathlib import Path
 
from matplotlib import colors as mcolors
import matplotlib.pyplot as plt
import numpy as np
import pyvista as pv
 
 
GLYPH_VECTOR_NAME = "__glyph_vectors"
 
 
def expand_input_files(inputs):
    files = []
    for entry in inputs:
        matches = sorted(glob(entry))
        if matches:
            files.extend(matches)
        else:
            files.append(entry)
    return files
 
 
def filter_vtk_files(files):
    return [file for file in files if file.lower().endswith(".vtk")]
 
 
def select_field_component(mesh, field_name, component):
    if field_name in mesh.point_data:
        data = mesh.point_data[field_name]
        target = mesh.point_data
    elif field_name in mesh.cell_data:
        data = mesh.cell_data[field_name]
        target = mesh.cell_data
    else:
        raise KeyError(f"Field '{field_name}' was not found in point or cell data.")
 
    values = np.asarray(data)
    if values.ndim == 1:
        values = values.reshape(-1, 1)
    else:
        values = values.reshape(values.shape[0], -1)
 
    component_index = component
 
    if component_index < 0 or component_index >= values.shape[1]:
        raise ValueError(
            f"Field '{field_name}' has {values.shape[1]} component(s), "
            f"so component {component} is out of range. "
            f"Use 0..{values.shape[1] - 1}."
        )
 
    component_name = f"{field_name}[{component_index}]"
    target[component_name] = values[:, component_index]
    return component_name
 
 
def get_cmap():
    return plt.get_cmap("turbo", 124)
 
 
def get_scalar_name(mesh, args):
    if not args.field:
        return None
    if args.field_component is not None:
        return select_field_component(mesh, args.field, args.field_component)
    return args.field
 
 
def make_plotter(mesh, args, off_screen=True):
    cmap = get_cmap()
    plotter = pv.Plotter(notebook=False, off_screen=off_screen)
 
    scalar_name = get_scalar_name(mesh, args)
    if scalar_name:
        plotter.add_mesh(
            mesh,
            scalars=scalar_name,
            show_edges=args.show_edges,
            smooth_shading=False,
            cmap=cmap,
        )
    else:
        plotter.add_mesh(
            mesh,
            show_edges=args.show_edges,
            edge_color="white",
            color="white",
        )
 
    glyph_source = make_glyph_source(mesh, args)
    if glyph_source is not None:
        glyphs = make_glyph_mesh(glyph_source, args)
        plotter.add_mesh(
            glyphs,
            color=args.glyph_color,
            smooth_shading=True,
        )
 
    if args.d2:
        plotter.camera_position = args.d2
    plotter.camera.zoom(args.zoom)
    plotter.camera.roll += args.roll
    plotter.camera.azimuth += args.azimuth
    return plotter
 
 
def extract_surface(mesh):
    try:
        surface = mesh.extract_surface(algorithm="dataset_surface")
    except TypeError:
        surface = mesh.extract_surface()
    return surface.triangulate()
 
 
def scalar_values(data):
    values = np.asarray(data)
    if values.ndim == 1:
        return values.astype(float)
 
    values = values.reshape(values.shape[0], -1).astype(float)
    if values.shape[1] == 1:
        return values[:, 0]
    return np.linalg.norm(values, axis=1)
 
 
def vector_values(data, field_name):
    values = np.asarray(data)
    if values.ndim == 1:
        values = values.reshape(-1, 1)
    else:
        values = values.reshape(values.shape[0], -1)
 
    if values.shape[1] < 2:
        raise ValueError(
            f"Glyph field '{field_name}' has {values.shape[1]} component(s). "
            "Use a vector field with at least 2 components."
        )
 
    vectors = np.zeros((values.shape[0], 3), dtype=float)
    vectors[:, : min(values.shape[1], 3)] = values[:, :3]
    return vectors
 
 
def make_glyph_source(mesh, args):
    if not args.glyph_field:
        return None
 
    if args.glyph_field in mesh.point_data:
        points = np.asarray(mesh.points, dtype=float)
        vectors = vector_values(mesh.point_data[args.glyph_field], args.glyph_field)
    elif args.glyph_field in mesh.cell_data:
        centers = mesh.cell_centers()
        points = np.asarray(centers.points, dtype=float)
        vectors = vector_values(mesh.cell_data[args.glyph_field], args.glyph_field)
    else:
        raise KeyError(
            f"Glyph field '{args.glyph_field}' was not found in point or cell data."
        )
 
    vector_norms = np.linalg.norm(vectors, axis=1)
    valid = (
        np.isfinite(points).all(axis=1)
        & np.isfinite(vectors).all(axis=1)
        & (vector_norms > 0)
    )
    points = points[valid]
    vectors = vectors[valid]
 
    if points.size == 0:
        return None
 
    stride = max(1, int(args.glyph_stride))
    points = points[::stride]
    vectors = vectors[::stride]
 
    source = pv.PolyData(points)
    source.point_data[GLYPH_VECTOR_NAME] = vectors
    return source
 
 
def make_glyph_mesh(glyph_source, args):
    return glyph_source.glyph(
        orient=GLYPH_VECTOR_NAME,
        scale=GLYPH_VECTOR_NAME,
        factor=args.glyph_magnitude,
        geom=pv.Arrow(tip_resolution=12, shaft_resolution=12),
    )
 
 
def values_to_rgb(values):
    values = np.asarray(values, dtype=float)
    finite_values = values[np.isfinite(values)]
    if finite_values.size:
        value_min = float(np.min(finite_values))
        value_max = float(np.max(finite_values))
    else:
        value_min = 0.0
        value_max = 1.0
 
    if value_max > value_min:
        normalized = (values - value_min) / (value_max - value_min)
    else:
        normalized = np.full(values.shape, 0.5)
 
    normalized = np.nan_to_num(normalized, nan=0.5, posinf=1.0, neginf=0.0)
    colors = get_cmap()(np.clip(normalized, 0.0, 1.0))[:, :3]
    return colors, value_min, value_max
 
 
def make_edge_positions(triangle_points):
    edges = triangle_points[:, ((0, 1), (1, 2), (2, 0)), :]
    return edges.reshape(-1, 3)
 
 
def make_glyph_surface_payload(mesh, args, center, radius):
    source = make_glyph_source(mesh, args)
    if source is None:
        return {
            "positions": [],
            "normals": [],
            "colors": [],
        }
 
    glyph_surface = extract_surface(make_glyph_mesh(source, args))
    if glyph_surface.n_points == 0 or glyph_surface.n_cells == 0:
        return {
            "positions": [],
            "normals": [],
            "colors": [],
        }
 
    faces = np.asarray(glyph_surface.faces, dtype=np.int64).reshape(-1, 4)[:, 1:4]
    points = np.asarray(glyph_surface.points, dtype=float)
    triangle_points = points[faces]
    face_normals = np.cross(
        triangle_points[:, 1] - triangle_points[:, 0],
        triangle_points[:, 2] - triangle_points[:, 0],
    )
    normal_lengths = np.linalg.norm(face_normals, axis=1)
    valid_normals = normal_lengths > 0
    face_normals[valid_normals] /= normal_lengths[valid_normals, None]
    face_normals[~valid_normals] = (0.0, 0.0, 1.0)
 
    positions = ((triangle_points.reshape(-1, 3) - center) / radius).astype(float)
    normals = np.repeat(face_normals, 3, axis=0)
    glyph_color = np.array(mcolors.to_rgb(args.glyph_color), dtype=float)
    colors = np.tile(glyph_color, (positions.shape[0], 1))
 
    return {
        "positions": positions.ravel().round(8).tolist(),
        "normals": normals.ravel().round(8).tolist(),
        "colors": colors.ravel().round(8).tolist(),
    }
 
 
def make_widget_payload(file, mesh, args):
    scalar_name = get_scalar_name(mesh, args)
    surface = extract_surface(mesh)
    faces = np.asarray(surface.faces, dtype=np.int64).reshape(-1, 4)[:, 1:4]
    points = np.asarray(surface.points, dtype=float)
 
    if points.size == 0 or faces.size == 0:
        raise RuntimeError(f"File '{file}' does not contain surface triangles.")
 
    triangle_points = points[faces]
    face_normals = np.cross(
        triangle_points[:, 1] - triangle_points[:, 0],
        triangle_points[:, 2] - triangle_points[:, 0],
    )
    normal_lengths = np.linalg.norm(face_normals, axis=1)
    valid_normals = normal_lengths > 0
    face_normals[valid_normals] /= normal_lengths[valid_normals, None]
    face_normals[~valid_normals] = (0.0, 0.0, 1.0)
 
    if scalar_name:
        if scalar_name in surface.point_data:
            scalar_data = scalar_values(surface.point_data[scalar_name])
            colors, scalar_min, scalar_max = values_to_rgb(scalar_data[faces].ravel())
        elif scalar_name in surface.cell_data:
            scalar_data = scalar_values(surface.cell_data[scalar_name])
            colors, scalar_min, scalar_max = values_to_rgb(np.repeat(scalar_data, 3))
        else:
            raise KeyError(
                f"Field '{scalar_name}' was not found on the extracted surface."
            )
    else:
        colors = np.tile(np.array([[0.92, 0.92, 0.88]]), (faces.size, 1))
        scalar_min = None
        scalar_max = None
 
    center = np.mean(points, axis=0)
    radius = np.max(np.linalg.norm(points - center, axis=1))
    if not np.isfinite(radius) or radius <= 0:
        radius = 1.0
 
    positions = ((triangle_points.reshape(-1, 3) - center) / radius).astype(float)
    normals = np.repeat(face_normals, 3, axis=0)
    edge_positions = ((make_edge_positions(triangle_points) - center) / radius).astype(
        float
    )
    glyph_payload = make_glyph_surface_payload(mesh, args, center, radius)
 
    return {
        "file": Path(file).name,
        "scalar": scalar_name,
        "glyph": args.glyph_field or None,
        "scalarMin": scalar_min,
        "scalarMax": scalar_max,
        "showEdges": bool(args.show_edges),
        "zoom": float(args.zoom),
        "d2": args.d2,
        "roll": float(args.roll),
        "azimuth": float(args.azimuth),
        "positions": positions.ravel().round(8).tolist(),
        "normals": normals.ravel().round(8).tolist(),
        "colors": colors.ravel().round(8).tolist(),
        "edges": edge_positions.ravel().round(8).tolist(),
        "glyphPositions": glyph_payload["positions"],
        "glyphNormals": glyph_payload["normals"],
        "glyphColors": glyph_payload["colors"],
    }
 
 
def make_widget_html(payload):
    payload_json = json.dumps(payload, separators=(",", ":")).replace("</", "<\\/")
    title = html.escape(payload["file"])
    return f"""<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{title}</title>
<style>
html, body {{
  margin: 0;
  width: 100%;
  height: 100%;
  overflow: hidden;
  background: #f5f5f2;
  font-family: Arial, sans-serif;
}}
#viewer {{
  width: 100vw;
  height: 100vh;
  display: block;
  cursor: grab;
}}
#viewer:active {{
  cursor: grabbing;
}}
#toolbar {{
  position: fixed;
  top: 12px;
  right: 12px;
  display: flex;
  gap: 6px;
  align-items: center;
}}
button {{
  min-width: 40px;
  height: 32px;
  border: 1px solid rgba(16, 24, 32, 0.2);
  border-radius: 4px;
  background: rgba(255, 255, 255, 0.86);
  color: #111820;
  font-size: 12px;
  font-weight: 600;
}}
button:hover {{
  background: #ffffff;
}}
#status {{
  position: fixed;
  left: 12px;
  top: 12px;
  max-width: min(520px, calc(100vw - 24px));
  padding: 8px 10px;
  border: 1px solid rgba(16, 24, 32, 0.18);
  border-radius: 4px;
  background: rgba(255, 255, 255, 0.88);
  color: #111820;
  font-size: 12px;
  line-height: 1.4;
  white-space: pre-wrap;
}}
#status.hidden {{
  display: none;
}}
#colorbar {{
  position: fixed;
  left: 12px;
  bottom: 12px;
  display: none;
  align-items: flex-end;
  gap: 8px;
  color: #111820;
  font-size: 11px;
  background: rgba(255, 255, 255, 0.78);
  border: 1px solid rgba(16, 24, 32, 0.16);
  border-radius: 4px;
  padding: 8px;
}}
#gradient {{
  width: 160px;
  height: 12px;
  background: linear-gradient(90deg, #30123b, #4662d7, #36a9e1, #1ae4b6, #72fe5c, #d7e219, #f89441, #d93806, #7a0403);
  border: 1px solid rgba(16, 24, 32, 0.24);
}}
#legend-values {{
  display: flex;
  justify-content: space-between;
  width: 160px;
  margin-top: 4px;
}}
</style>
</head>
<body>
<canvas id="viewer"></canvas>
<div id="status">Loading mesh...</div>
<div id="toolbar">
  <button type="button" data-view="iso">Iso</button>
  <button type="button" data-view="xy">XY</button>
  <button type="button" data-view="xz">XZ</button>
  <button type="button" data-view="yz">YZ</button>
</div>
<div id="colorbar">
  <div>
    <div id="gradient"></div>
    <div id="legend-values"><span id="legend-min"></span><span id="legend-max"></span></div>
  </div>
</div>
<script>
const payload = {payload_json};
const canvas = document.getElementById("viewer");
const status = document.getElementById("status");
window.addEventListener("error", (event) => showError(event.message));
window.addEventListener("unhandledrejection", (event) => showError(String(event.reason)));
const gl = canvas.getContext("webgl", {{ antialias: true }});
if (!gl) {{
  showError("WebGL is not available in this browser. Try opening this file in Firefox/Chrome instead of VS Code Simple Browser.");
  throw new Error("WebGL is not available in this browser.");
}}
 
const positions = new Float32Array(payload.positions);
const normals = new Float32Array(payload.normals);
const colors = new Float32Array(payload.colors);
const edges = new Float32Array(payload.edges);
const glyphPositions = new Float32Array(payload.glyphPositions);
const glyphNormals = new Float32Array(payload.glyphNormals);
const glyphColors = new Float32Array(payload.glyphColors);
let rotation = identity();
let zoom = Number.isFinite(payload.zoom) ? payload.zoom : 1.2;
let dragging = false;
let lastX = 0;
let lastY = 0;
 
const meshProgram = makeProgram(`
attribute vec3 aPosition;
attribute vec3 aNormal;
attribute vec3 aColor;
uniform mat4 uModelView;
uniform mat4 uProjection;
varying vec3 vNormal;
varying vec3 vColor;
void main() {{
  vec4 pos = uModelView * vec4(aPosition, 1.0);
  vNormal = (uModelView * vec4(aNormal, 0.0)).xyz;
  vColor = aColor;
  gl_Position = uProjection * pos;
}}`, `
precision mediump float;
varying vec3 vNormal;
varying vec3 vColor;
void main() {{
  vec3 normal = normalize(vNormal);
  vec3 light = normalize(vec3(0.35, 0.55, 0.9));
  float diffuse = max(dot(normal, light), 0.0);
  float shade = 0.34 + 0.66 * diffuse;
  gl_FragColor = vec4(vColor * shade, 1.0);
}}`);
 
const lineProgram = makeProgram(`
attribute vec3 aPosition;
uniform mat4 uModelView;
uniform mat4 uProjection;
void main() {{
  gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);
}}`, `
precision mediump float;
uniform vec4 uColor;
void main() {{
  gl_FragColor = uColor;
}}`);
 
const positionBuffer = bufferData(positions);
const normalBuffer = bufferData(normals);
const colorBuffer = bufferData(colors);
const edgeBuffer = bufferData(edges);
const glyphPositionBuffer = bufferData(glyphPositions);
const glyphNormalBuffer = bufferData(glyphNormals);
const glyphColorBuffer = bufferData(glyphColors);
 
setInitialView();
setupLegend();
resize();
requestAnimationFrame(draw);
setTimeout(() => status.classList.add("hidden"), 1200);
 
window.addEventListener("resize", resize);
canvas.addEventListener("pointerdown", (event) => {{
  dragging = true;
  lastX = event.clientX;
  lastY = event.clientY;
  canvas.setPointerCapture(event.pointerId);
}});
canvas.addEventListener("pointermove", (event) => {{
  if (!dragging) return;
  const dx = event.clientX - lastX;
  const dy = event.clientY - lastY;
  lastX = event.clientX;
  lastY = event.clientY;
  rotation = multiply(rotateX(dy * 0.01), multiply(rotateY(dx * 0.01), rotation));
  requestAnimationFrame(draw);
}});
canvas.addEventListener("pointerup", () => {{
  dragging = false;
}});
canvas.addEventListener("wheel", (event) => {{
  event.preventDefault();
  zoom *= Math.exp(-event.deltaY * 0.001);
  zoom = Math.min(Math.max(zoom, 0.15), 20.0);
  requestAnimationFrame(draw);
}}, {{ passive: false }});
document.querySelectorAll("button[data-view]").forEach((button) => {{
  button.addEventListener("click", () => {{
    setView(button.dataset.view);
    requestAnimationFrame(draw);
  }});
}});
 
function setupLegend() {{
  if (payload.scalar === null || payload.scalarMin === null || payload.scalarMax === null) return;
  document.getElementById("colorbar").style.display = "flex";
  document.getElementById("legend-min").textContent = formatValue(payload.scalarMin);
  document.getElementById("legend-max").textContent = formatValue(payload.scalarMax);
}}
 
function showError(message) {{
  status.classList.remove("hidden");
  status.textContent = "Viewer error: " + message;
}}
 
function formatValue(value) {{
  const absValue = Math.abs(value);
  if ((absValue > 0 && absValue < 0.001) || absValue >= 10000) {{
    return value.toExponential(2);
  }}
  return value.toPrecision(4);
}}
 
function resize() {{
  const dpr = window.devicePixelRatio || 1;
  const width = Math.max(1, Math.floor(canvas.clientWidth * dpr));
  const height = Math.max(1, Math.floor(canvas.clientHeight * dpr));
  if (canvas.width !== width || canvas.height !== height) {{
    canvas.width = width;
    canvas.height = height;
  }}
  gl.viewport(0, 0, canvas.width, canvas.height);
  requestAnimationFrame(draw);
}}
 
function draw() {{
  if (!gl) return;
  gl.clearColor(0.96, 0.96, 0.94, 1.0);
  gl.clearDepth(1.0);
  gl.enable(gl.DEPTH_TEST);
  gl.depthFunc(gl.LEQUAL);
  gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
  const aspect = canvas.width / Math.max(1, canvas.height);
  const projection = perspective(35 * Math.PI / 180, aspect, 0.01, 100.0);
  const distance = 3.15 / Math.max(zoom, 0.001);
  const modelView = multiply(translate(0, 0, -distance), rotation);
 
  gl.useProgram(meshProgram.program);
  setMat4(meshProgram, "uProjection", projection);
  setMat4(meshProgram, "uModelView", modelView);
  bindAttrib(meshProgram, "aPosition", positionBuffer, 3);
  bindAttrib(meshProgram, "aNormal", normalBuffer, 3);
  bindAttrib(meshProgram, "aColor", colorBuffer, 3);
  gl.enable(gl.POLYGON_OFFSET_FILL);
  gl.polygonOffset(1, 1);
  gl.drawArrays(gl.TRIANGLES, 0, positions.length / 3);
  gl.disable(gl.POLYGON_OFFSET_FILL);
 
  if (payload.showEdges && edges.length > 0) {{
    gl.useProgram(lineProgram.program);
    setMat4(lineProgram, "uProjection", projection);
    setMat4(lineProgram, "uModelView", modelView);
    setVec4(lineProgram, "uColor", [0.08, 0.09, 0.1, 0.42]);
    bindAttrib(lineProgram, "aPosition", edgeBuffer, 3);
    gl.drawArrays(gl.LINES, 0, edges.length / 3);
  }}
 
  if (glyphPositions.length > 0) {{
    gl.useProgram(meshProgram.program);
    setMat4(meshProgram, "uProjection", projection);
    setMat4(meshProgram, "uModelView", modelView);
    bindAttrib(meshProgram, "aPosition", glyphPositionBuffer, 3);
    bindAttrib(meshProgram, "aNormal", glyphNormalBuffer, 3);
    bindAttrib(meshProgram, "aColor", glyphColorBuffer, 3);
    gl.drawArrays(gl.TRIANGLES, 0, glyphPositions.length / 3);
  }}
}}
 
function setView(view) {{
  if (view === "xy") rotation = identity();
  if (view === "xz") rotation = rotateX(-Math.PI / 2);
  if (view === "yz") rotation = rotateY(Math.PI / 2);
  if (view === "iso") rotation = multiply(rotateX(-0.75), rotateY(0.72));
}}
 
function setInitialView() {{
  const view = String(payload.d2 || "iso").toLowerCase();
  setView(["xy", "xz", "yz", "iso"].includes(view) ? view : "iso");
  const azimuth = Number(payload.azimuth) || 0;
  const roll = Number(payload.roll) || 0;
  rotation = multiply(rotateY(azimuth * Math.PI / 180), rotation);
  rotation = multiply(rotateZ(roll * Math.PI / 180), rotation);
}}
 
function makeProgram(vertexSource, fragmentSource) {{
  const vertexShader = compileShader(gl.VERTEX_SHADER, vertexSource);
  const fragmentShader = compileShader(gl.FRAGMENT_SHADER, fragmentSource);
  const program = gl.createProgram();
  gl.attachShader(program, vertexShader);
  gl.attachShader(program, fragmentShader);
  gl.linkProgram(program);
  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {{
    throw new Error(gl.getProgramInfoLog(program));
  }}
  return {{ program, locations: new Map() }};
}}
 
function compileShader(type, source) {{
  const shader = gl.createShader(type);
  gl.shaderSource(shader, source);
  gl.compileShader(shader);
  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {{
    throw new Error(gl.getShaderInfoLog(shader));
  }}
  return shader;
}}
 
function bufferData(data) {{
  const buffer = gl.createBuffer();
  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
  return buffer;
}}
 
function bindAttrib(programInfo, name, buffer, size) {{
  const location = attribLocation(programInfo, name);
  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
  gl.enableVertexAttribArray(location);
  gl.vertexAttribPointer(location, size, gl.FLOAT, false, 0, 0);
}}
 
function attribLocation(programInfo, name) {{
  if (!programInfo.locations.has(name)) {{
    programInfo.locations.set(name, gl.getAttribLocation(programInfo.program, name));
  }}
  return programInfo.locations.get(name);
}}
 
function uniformLocation(programInfo, name) {{
  if (!programInfo.locations.has(name)) {{
    programInfo.locations.set(name, gl.getUniformLocation(programInfo.program, name));
  }}
  return programInfo.locations.get(name);
}}
 
function setMat4(programInfo, name, matrix) {{
  gl.uniformMatrix4fv(uniformLocation(programInfo, name), false, new Float32Array(matrix));
}}
 
function setVec4(programInfo, name, value) {{
  gl.uniform4fv(uniformLocation(programInfo, name), new Float32Array(value));
}}
 
function identity() {{
  return [
    1, 0, 0, 0,
    0, 1, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1,
  ];
}}
 
function translate(x, y, z) {{
  return [
    1, 0, 0, 0,
    0, 1, 0, 0,
    0, 0, 1, 0,
    x, y, z, 1,
  ];
}}
 
function rotateX(angle) {{
  const c = Math.cos(angle);
  const s = Math.sin(angle);
  return [
    1, 0, 0, 0,
    0, c, s, 0,
    0, -s, c, 0,
    0, 0, 0, 1,
  ];
}}
 
function rotateY(angle) {{
  const c = Math.cos(angle);
  const s = Math.sin(angle);
  return [
    c, 0, -s, 0,
    0, 1, 0, 0,
    s, 0, c, 0,
    0, 0, 0, 1,
  ];
}}
 
function rotateZ(angle) {{
  const c = Math.cos(angle);
  const s = Math.sin(angle);
  return [
    c, s, 0, 0,
    -s, c, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1,
  ];
}}
 
function perspective(fovy, aspect, near, far) {{
  const f = 1.0 / Math.tan(fovy / 2.0);
  const nf = 1.0 / (near - far);
  return [
    f / aspect, 0, 0, 0,
    0, f, 0, 0,
    0, 0, (far + near) * nf, -1,
    0, 0, 2 * far * near * nf, 0,
  ];
}}
 
function multiply(a, b) {{
  const out = new Array(16);
  for (let col = 0; col < 4; col++) {{
    for (let row = 0; row < 4; row++) {{
      out[col * 4 + row] =
        a[0 * 4 + row] * b[col * 4 + 0] +
        a[1 * 4 + row] * b[col * 4 + 1] +
        a[2 * 4 + row] * b[col * 4 + 2] +
        a[3 * 4 + row] * b[col * 4 + 3];
    }}
  }}
  return out;
}}
</script>
</body>
</html>
"""
 
 
def read_mesh(file, args):
    mesh = pv.read(file)
 
    if args.wrap_vector:
        mesh = mesh.warp_by_vector(args.wrap_vector, factor=args.wrap_factor)
    return mesh
 
 
def make_png(file, mesh, args):
    output_file = str(Path(file).with_suffix(".png"))
    plotter = make_plotter(mesh, args)
    try:
        plotter.screenshot(output_file)
    finally:
        plotter.close()
 
 
def make_widget(file, mesh, args):
    output_file = str(Path(file).with_suffix(".html"))
    payload = make_widget_payload(file, mesh, args)
    Path(output_file).write_text(make_widget_html(payload), encoding="utf-8")
 
 
def make_outputs(file, args):
    mesh = read_mesh(file, args)
    if not args.widget_only:
        make_png(file, mesh, args)
    if args.write_widget or args.widget_only:
        make_widget(file, mesh, args)
 
 
def maybe_start_virtual_display():
    try:
        from pyvirtualdisplay import Display
    except ImportError:
        return None
 
    try:
        display = Display(backend="xvfb", visible=False, size=(800, 800))
        display.start()
    except Exception:
        return None
    return display
 
 
if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=(
            "Convert multiple vtk files to png files or interactive HTML "
            "widgets using PyVista."
        )
    )
    parser.add_argument(
        "files",
        help="list of vtk files or glob masks",
        nargs="+",
    )
    parser.add_argument("-d2", "--d2", dest="d2", default="")
    parser.add_argument("-f", "--field", dest="field", default="", type=str)
    parser.add_argument(
        "--field-component",
        dest="field_component",
        default=None,
        type=int,
        help="0-based component index for vector/tensor fields",
    )
    parser.add_argument(
        "-g",
        "--glyph",
        "--glyph-field",
        dest="glyph_field",
        default="",
        type=str,
        help="Vector field used to draw glyph arrows.",
    )
    parser.add_argument(
        "--glyph-magnitude",
        "--glyph-factor",
        dest="glyph_magnitude",
        default=1.0,
        type=float,
        help="Scale factor applied to glyph arrow lengths.",
    )
    parser.add_argument(
        "--glyph-stride",
        dest="glyph_stride",
        default=1,
        type=int,
        help="Draw every Nth glyph vector.",
    )
    parser.add_argument(
        "--glyph-color",
        dest="glyph_color",
        default="red",
        type=str,
        help="Glyph color for PNG output.",
    )
    parser.add_argument(
        "-wv", "--wrap_vector", dest="wrap_vector", default="", type=str
    )
    parser.add_argument("--wrap-factor", dest="wrap_factor", default=1.0, type=float)
    parser.add_argument("--zoom", dest="zoom", default=1.2, type=float)
    parser.add_argument("--roll", dest="roll", default=0, type=float)
    parser.add_argument("--azimuth", dest="azimuth", default=0, type=float)
    parser.add_argument(
        "--show-edges",
        dest="show_edges",
        action="store_true",
        default=True,
        help="Show mesh edges (default)",
    )
    parser.add_argument(
        "--no-show-edges",
        dest="show_edges",
        action="store_false",
        help="Hide mesh edges",
    )
    parser.add_argument(
        "--widget",
        "--html",
        dest="write_widget",
        action="store_true",
        help="Also write an interactive HTML widget next to each PNG file.",
    )
    parser.add_argument(
        "--widget-only",
        dest="widget_only",
        action="store_true",
        help="Write only the interactive HTML widget, without a PNG screenshot.",
    )
    parser.add_argument("--debug", dest="debug", action="store_true")
    args = parser.parse_args()
 
    if args.debug:
        print(args)
 
    file_list = filter_vtk_files(expand_input_files(args.files))
    if not file_list:
        parser.error("No vtk files were found with the given names or glob masks.")
 
    display = maybe_start_virtual_display()
    try:
        for file_name in file_list:
            make_outputs(file_name, args)
    finally:
        if display is not None:
            display.stop()