[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7F2HGG8PDPXRAJT5FNVYF7C":3,"skill-same:01M7F2HGG8PDPXRAJT5FNVYF7C":58},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":30,"commitSha":31,"skillDirectory":32,"forksCount":33,"repositoryHtmlUrl":34,"repositoryHomepageUrl":6,"ownerHtmlUrl":35,"ownerBlogUrl":6,"ownerDescription":36,"updatedAt":37,"install":38,"resources":51},"01M7F2HGG8PDPXRAJT5FNVYF7C","openpiv",null,"Particle Image Velocimetry (PIV) analysis with OpenPIV. Use when extracting velocity fields from PIV image pairs, analyzing fluid dynamics or flow visualization experiments, cross-correlating interrogation windows, validating and replacing spurious PIV vectors, or computing vorticity, strain rate, and turbulence statistics from measured velocity fields.","lza6\u002FArmor-piercing-system-prompts","lza6","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F128880206?v=4","01M7EB3K7WPX5T28EJ2NVHE6EG","Chinese-tingfeng","01M7EB3K97E1KQ16QWKJMFNGX8",11,"BSD-3-Clause","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fopenpiv\u002FSKILL.md",[],[],"2026-11-16 10:05:34",false,"---\nname: openpiv\ndescription: Particle Image Velocimetry (PIV) analysis with OpenPIV. Use when extracting velocity fields from PIV image pairs, analyzing fluid dynamics or flow visualization experiments, cross-correlating interrogation windows, validating and replacing spurious PIV vectors, or computing vorticity, strain rate, and turbulence statistics from measured velocity fields.\nlicense: BSD-3-Clause\ncompatibility: Requires Python 3.10+ with openpiv installed (uv pip install openpiv). numpy, scipy, scikit-image, and matplotlib arrive as dependencies. No network access needed after install.\nallowed-tools: Read Write Edit Bash\nmetadata:\n  version: \"1.1\"\n  skill-author: OpenPIV Team\n  tested-against: \"openpiv 0.25.4\"\n---\n\n# OpenPIV\n\n## Overview\n\nOpenPIV (Open Particle Image Velocimetry) analyzes fluid flow from PIV image pairs. It covers\npreprocessing, cross-correlation, vector validation, outlier replacement, smoothing, and scaling to\nphysical units.\n\nEverything below is verified against **openpiv 0.25.4**. The API moves between releases — check\n`inspect.signature()` before trusting a snippet against a different version.\n\n## When to use\n\nUse this skill when working with experimental PIV or flow-visualization image pairs: measuring 2D\nvelocity fields, tuning interrogation-window parameters, validating vectors, or deriving vorticity,\nstrain rate, and turbulence statistics. For *simulating* flow rather than measuring it, use a CFD\nskill instead.\n\n## Quick Start\n\nInstall OpenPIV:\n\n```bash\nuv pip install openpiv\n\n# Pin it when the analysis needs to be reproducible -- this is the version every\n# snippet below was checked against.\nuv pip install \"openpiv==0.25.4\"\n```\n\nRun PIV analysis on an image pair:\n\n```python\nimport numpy as np\nfrom openpiv import tools, pyprocess, validation, filters, scaling\n\nframe_a = tools.imread(\"image_a.bmp\")\nframe_b = tools.imread(\"image_b.bmp\")\n\n# Cross-correlate. Returns (u, v, s2n) whenever sig2noise_method is not None.\nu, v, s2n = pyprocess.extended_search_area_piv(\n    frame_a.astype(np.int32),\n    frame_b.astype(np.int32),\n    window_size=32,\n    overlap=12,\n    dt=0.02,\n    search_area_size=38,\n    correlation_method=\"linear\",   # required for search_area_size > window_size\n    sig2noise_method=\"peak2peak\",\n)\n\nx, y = pyprocess.get_coordinates(\n    image_size=frame_a.shape,\n    search_area_size=38,\n    overlap=12,\n)\n\n# flags is a boolean array: True marks a spurious vector.\nflags = validation.sig2noise_val(s2n, threshold=1.05)\nu, v = filters.replace_outliers(u, v, flags, method=\"localmean\", max_iter=3, kernel_size=2)\n\n# Scale to physical units, then flip to image coordinates for plotting.\nx, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=96.52)\nx, y, u, v = tools.transform_coordinates(x, y, u, v)\n\ntools.save(\"vectors.txt\", x, y, u, v, flags)\n```\n\nOr use the bundled CLI, which wraps exactly that pipeline:\n\n```bash\npython skills\u002Fopenpiv\u002Fscripts\u002Frunner.py \\\n    --image frame_a.bmp --image frame_b.bmp --output_dir results --verbose\n```\n\n## Core Concepts\n\n### PIV Fundamentals\n\nParticle Image Velocimetry is an optical method for measuring fluid velocity by tracking illuminated\ntracer particles between two images.\n\n**Process flow:**\n\n1. Capture an image pair (`frame_a`, `frame_b`) separated by a known time `dt`.\n2. Divide the images into interrogation windows.\n3. Cross-correlate matching windows to find peak displacement.\n4. Validate vectors (signal-to-noise, global range, local median).\n5. Replace spurious vectors with interpolated values.\n6. Scale pixel displacements to physical units.\n\n### Interrogation Window Parameters\n\n**`window_size`** — correlation window in pixels (typically 16–128). Larger windows give better\ncorrelation but coarser spatial resolution.\n\n**`overlap`** — pixels shared between adjacent windows (typically 50–75% of `window_size`). Higher\noverlap raises vector density and cost, but adjacent vectors become correlated rather than\nindependent.\n\n**`search_area_size`** — the window searched in the second frame. Must be ≥ `window_size`; a few\npixels larger accommodates larger displacements. Pair an extended search area with\n`correlation_method=\"linear\"` — the default `\"circular\"` relies on FFT wrap-around and aliases large\ndisplacements into small ones. See `references\u002Fadvanced_algorithms.md`.\n\nRules of thumb: keep the largest displacement under about a quarter of `window_size`, and aim for\n5–10 particles per window.\n\n### Signal-to-Noise Ratio\n\n`s2n` measures how distinct the correlation peak is. `sig2noise_method` controls how it is computed —\n`\"peak2mean\"` (the function default) or `\"peak2peak\"`. **The two are on different scales**, so a\nthreshold tuned for one is meaningless for the other. Typical `peak2peak` thresholds are 1.05–1.3.\n\n```python\nflags = validation.sig2noise_val(s2n, threshold=1.05)\n# flags is bool: True == spurious. `~flags` selects the good vectors.\n```\n\n## Common Operations\n\n### Dynamic Masking\n\nMasking lives in `openpiv.preprocess`, **not** in an `openpiv.masking` module. It returns an\n`(image, mask)` tuple and expects a float image.\n\n```python\nfrom openpiv import preprocess\n\n# method=\"edges\" for dark, sharp-edged objects; \"intensity\" for high-contrast objects.\nframe_a_masked, mask_a = preprocess.dynamic_masking(\n    frame_a.astype(np.float64), method=\"intensity\", filter_size=7, threshold=0.005\n)\nframe_b_masked, mask_b = preprocess.dynamic_masking(\n    frame_b.astype(np.float64), method=\"intensity\", filter_size=7, threshold=0.005\n)\n```\n\nFeed the **returned image** into the correlation step — it already has the masked region zeroed. Do\nnot multiply the original frame by `mask`: masking is already applied, and for `method=\"edges\"` the\nmask comes back as `uint8` 0\u002F255 rather than boolean, so multiplying rescales the image by 255.\n\n### Multi-Pass Processing\n\nMulti-pass (window deformation) lives in `openpiv.windef`, driven by a `PIVSettings` dataclass.\n`pyprocess` has no multi-pass entry point.\n\n```python\nimport numpy as np\nfrom openpiv import scaling, windef\n\nsettings = windef.PIVSettings()\nsettings.windowsizes = (64, 32, 16)   # one entry per pass, decreasing (this is also the default)\nsettings.overlap = (32, 16, 8)        # same length as windowsizes\nsettings.num_iterations = 3           # number of passes to actually run\nsettings.sig2noise_threshold = 1.05\n\nx, y, u, v, flags = windef.simple_multipass(\n    frame_a.astype(np.int32), frame_b.astype(np.int32), settings\n)\n\n# Output is in PIXELS PER FRAME -- convert yourself. scaling.uniform only divides\n# by scaling_factor, so apply dt separately.\ndt = 0.02\nx, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=96.52)\nu, v = u \u002F dt, v \u002F dt\n```\n\n`simple_multipass` already validates, replaces outliers, fills remaining NaNs with zeros, and calls\n`transform_coordinates` — do not repeat those steps.\n\n**Units trap:** `PIVSettings` has `dt` and `scaling_factor` fields, but `windef` never uses either —\n`first_pass` calls `extended_search_area_piv` without `dt`, so the whole multi-pass chain works in\npixels per frame. Setting `settings.dt = 0.02` changes nothing about the returned values. Convert\nafter the fact, as above.\n\nFor control over individual passes, `windef.first_pass` and `windef.multipass_img_deform` are the\nlower-level building blocks.\n\n## Validation and Post-Processing\n\n### Validation Methods\n\nEvery validator returns a boolean array where **True marks a spurious vector**.\n\n```python\n# Signal-to-noise\nflags = validation.sig2noise_val(s2n, threshold=1.05)\n\n# Global range -- takes (min, max) TUPLES, positionally or as u_thresholds\u002Fv_thresholds.\nflags = validation.global_val(u, v, (-300, 300), (-300, 300))\n\n# Local median -- u_threshold and v_threshold are REQUIRED; size is the neighbourhood half-width.\nflags = validation.local_median_val(u, v, u_threshold=30.0, v_threshold=30.0, size=1)\n\n# Combine with boolean OR (not np.maximum -- these are bool arrays).\nflags = (\n    validation.sig2noise_val(s2n, threshold=1.05)\n    | validation.global_val(u, v, (-300, 300), (-300, 300))\n    | validation.local_median_val(u, v, u_threshold=30.0, v_threshold=30.0)\n)\n```\n\n**Set these thresholds in the units of `u` and `v`, not in pixels per frame.**\n`extended_search_area_piv` divides by `dt`, so with `dt=0.02` a 3 px\u002Fframe displacement arrives as\n150 px\u002Fs. The thresholds above suit that case; the `(-30, 30)` figure that PIV literature and\n`PIVSettings.min_max_u_disp` use is a px\u002Fframe limit, and applying it to px\u002Fs output rejects the\nentire field. Either validate before scaling, or scale the thresholds by `1\u002Fdt` too.\n\n### Outlier Replacement\n\n```python\nu, v = filters.replace_outliers(\n    u, v, flags, method=\"localmean\", max_iter=3, tol=1e-3, kernel_size=2\n)\n```\n\n`method` accepts `\"localmean\"`, `\"disk\"`, or `\"distance\"` — and only those three. An unrecognized\nname is not rejected; it falls through to an all-zero kernel and silently returns a useless field.\nNote that replacement *fills* the flagged\npositions with interpolated values — if you then overwrite them with NaN, the replacement was\nwasted. Choose one or the other:\n\n```python\n# Keep flagged vectors out of the analysis entirely, instead of interpolating them.\nu = np.where(flags, np.nan, u)\nv = np.where(flags, np.nan, v)\n```\n\n### Smoothing\n\nSmoothing is `openpiv.smoothn.smoothn`; there is no `openpiv.smooth` module. It returns a tuple\nwhose first element is the smoothed field, and it does not accept NaN input.\n\n```python\nfrom openpiv.smoothn import smoothn\n\nu_smooth, *_ = smoothn(np.nan_to_num(u), s=0.5)  # s: larger == smoother\nv_smooth, *_ = smoothn(np.nan_to_num(v), s=0.5)\nu_smooth = np.asarray(u_smooth)\n```\n\n## Visualization\n\n### Vector Field Plotting\n\n`display_vector_field` reads a saved vectors file and calls `plt.show()` internally, so select a\nnon-interactive backend for batch runs.\n\n```python\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\nfrom openpiv import tools\n\nfig, ax = plt.subplots(figsize=(8, 8))\ntools.display_vector_field(\n    \"vectors.txt\",\n    ax=ax,\n    scaling_factor=96.52,   # same factor used in scaling.uniform, to map back onto the image\n    scale=50,\n    width=0.0035,\n    on_img=True,\n    image_name=\"frame_a.bmp\",\n)\nfig.savefig(\"vector_field.png\", dpi=150, bbox_inches=\"tight\")\nplt.close(fig)\n```\n\n### Custom Visualization\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfig, axes = plt.subplots(1, 3, figsize=(15, 5))\n\nmag = np.sqrt(u**2 + v**2)\nfor ax, field, title, cmap in [\n    (axes[0], mag, \"Velocity Magnitude\", \"viridis\"),\n    (axes[1], u, \"U Velocity\", \"RdBu_r\"),\n    (axes[2], v, \"V Velocity\", \"RdBu_r\"),\n]:\n    im = ax.imshow(field, cmap=cmap)\n    ax.set_title(title)\n    plt.colorbar(im, ax=ax)\n\nfig.tight_layout()\nfig.savefig(\"velocity_components.png\")\nplt.close(fig)\n```\n\n## Analysis Functions\n\n`scripts\u002Fanalyze.py` bundles these against a `params.npz` written by `runner.py`. It infers the\nphysical grid spacing from the saved coordinates, so the derivatives come out per unit length:\n\n```python\nimport sys\nsys.path.insert(0, \"skills\u002Fopenpiv\u002Fscripts\")\nfrom analyze import PIVAnalyzer\n\npiv = PIVAnalyzer(\"results\u002Fparams.npz\")\nvorticity = piv.compute_vorticity()          # dv\u002Fdx - du\u002Fdy\nexx, eyy, exy = piv.compute_strain()\nstats = piv.compute_statistics()             # u_mean, v_mean, rms_u, rms_v, tke\npiv.plot_vector_field(save_path=\"quiver.png\")\n```\n\nThe standalone forms, if you would rather compute them inline:\n\n### Vorticity\n\n```python\ndef compute_vorticity(u, v, dx=1.0, dy=None):\n    \"\"\"Out-of-plane vorticity dv\u002Fdx - du\u002Fdy. Pass the physical grid spacing, not 1.0.\"\"\"\n    dy = dx if dy is None else dy\n    return np.gradient(v, dx, axis=1) - np.gradient(u, dy, axis=0)\n```\n\nThe grid spacing is `(window_size - overlap) \u002F scaling_factor` in physical units, so leaving `dx=1.0`\nyields vorticity per grid cell, not per unit length.\n\n**Sign convention:** `runner.py` ends with `transform_coordinates`, which relabels the grid into a\nright-handed y-up frame but leaves the rows in image order, so the saved `y` *decreases* as the row\nindex grows. The standalone forms above assume the opposite, so on a `params.npz` field they return\n`-du\u002Fdy` and flip the sign of the vorticity and the shear strain — negate the `axis=0` derivatives, or\nuse `PIVAnalyzer`, which reads the orientation off the saved coordinates.\n\n### Strain Rate\n\n```python\ndef compute_strain(u, v, dx=1.0, dy=None):\n    \"\"\"Return (exx, eyy, exy) of the 2D strain-rate tensor.\"\"\"\n    dy = dx if dy is None else dy\n    du_dx = np.gradient(u, dx, axis=1)\n    du_dy = np.gradient(u, dy, axis=0)\n    dv_dx = np.gradient(v, dx, axis=1)\n    dv_dy = np.gradient(v, dy, axis=0)\n    return du_dx, dv_dy, 0.5 * (du_dy + dv_dx)\n```\n\n### Turbulence Statistics\n\n```python\ndef compute_statistics(u, v):\n    \"\"\"Single-frame spatial statistics. NOT Reynolds decomposition.\"\"\"\n    u_prime = u - np.nanmean(u)\n    v_prime = v - np.nanmean(v)\n    rms_u, rms_v = np.nanstd(u_prime), np.nanstd(v_prime)\n    return {\n        \"u_mean\": np.nanmean(u),\n        \"v_mean\": np.nanmean(v),\n        \"rms_u\": rms_u,\n        \"rms_v\": rms_v,\n        \"tke\": 0.5 * (rms_u**2 + rms_v**2),\n    }\n```\n\n**Caveat:** subtracting the *spatial* mean of one frame measures spatial variance, which equals\nturbulent intensity only for a homogeneous field. Genuine Reynolds decomposition needs an ensemble of\nimage pairs: average over the time axis, then subtract that mean field from each realization.\n\n## CLI Usage\n\n```bash\n# Basic run\npython skills\u002Fopenpiv\u002Fscripts\u002Frunner.py \\\n    --image img1.bmp --image img2.bmp --output_dir results --verbose\n\n# Tuned parameters with dynamic masking\npython skills\u002Fopenpiv\u002Fscripts\u002Frunner.py \\\n    --image frame_a.bmp \\\n    --image frame_b.bmp \\\n    --output_dir results \\\n    --window_size 32 \\\n    --overlap 12 \\\n    --search_area 38 \\\n    --dt 0.02 \\\n    --scaling 96.52 \\\n    --threshold 1.05 \\\n    --mask dynamic \\\n    --mask_method intensity \\\n    --verbose\n```\n\n### CLI Options\n\n| Option | Default | Description |\n|--------|---------|-------------|\n| `--image` | required | Image file; specify exactly twice for the pair |\n| `--output_dir` | `results` | Output directory (created if absent) |\n| `--window_size` | 32 | Interrogation window size (px) |\n| `--overlap` | 12 | Window overlap (px) |\n| `--search_area` | 38 | Search area size (px), must be ≥ `--window_size` |\n| `--dt` | 0.02 | Time between frames (s) |\n| `--scaling` | 96.52 | Scaling factor, pixels per physical unit (e.g. px\u002Fmm) |\n| `--threshold` | 1.05 | `peak2peak` signal-to-noise threshold |\n| `--mask` | `none` | `none` or `dynamic` (`openpiv.preprocess.dynamic_masking`) |\n| `--mask_method` | `intensity` | `edges` or `intensity`, used only with `--mask dynamic` |\n| `--drop_invalid` | off | NaN out flagged vectors instead of keeping interpolated values |\n| `--verbose` | off | Print progress messages |\n\nVerify an install end to end against OpenPIV's own bundled image pair:\n\n```bash\npython skills\u002Fopenpiv\u002Fscripts\u002Frun_example.py --output_dir \u002Ftmp\u002Fopenpiv-demo\n```\n\n## Output Files\n\n- **vectors.txt** — tab-delimited, `%.4e` formatted, with a `# x y u v flags mask` comment header\n- **params.npz** — NumPy archive with `x`, `y`, `u`, `v`, `flags` arrays\n- **vector_field.png** — vector field drawn over the first frame\n\n```text\n# x\ty\tu\tv\tflags\tmask\n2.1757e-01\t3.5226e+00\t-6.2220e-02\t-2.7081e+00\t0.0000e+00\t0.0000e+00\n4.8695e-01\t3.5226e+00\t-3.1587e-01\t-2.9800e+00\t0.0000e+00\t0.0000e+00\n```\n\n`flags` is written as a float, `0` for a valid vector and `1` for a flagged one.\n\n## Best Practices\n\n### Parameter Selection\n\n1. **Window size** — 32×32 suits most cases. 64\u002F128 for better correlation at coarser resolution;\n   16\u002F24 for finer resolution at the cost of noise.\n2. **Overlap** — 50–75% of window size.\n3. **Threshold** — raise it to reject more vectors; always re-tune after switching\n   `sig2noise_method`.\n4. **Scaling factor** — calibrate against a known reference such as a calibration grid, and keep the\n   units straight (`96.52` in OpenPIV's `test1` tutorial data is px\u002Fmm).\n\n### Image Quality\n\n- Particles visible and evenly distributed, 5–10 per interrogation window\n- No saturated or overexposed regions\n- Minimal background noise; consider background subtraction across a run\n\n### Processing Tips\n\n1. Start from the defaults, then tune against the vector field you get.\n2. Inspect the `s2n` distribution — a low median means poor correlation, not a bad threshold.\n3. Visualize early; obvious problems (uniform vectors, edge artifacts) show up immediately.\n4. Use multi-pass (`windef`) for flows with large velocity gradients or displacements.\n5. Mask reflections and solid boundaries rather than letting them generate vectors.\n\n## Resources\n\n### references\u002F\n\n- `advanced_algorithms.md` — correlation and subpixel methods, multi-pass window deformation,\n  `PIVSettings` fields, 3D and phase-separation modules\n\nLoad the reference when detailed algorithm or settings information is needed.\n","# OpenPIV\n\n## Overview\n\nOpenPIV (Open Particle Image Velocimetry) analyzes fluid flow from PIV image pairs. It covers\npreprocessing, cross-correlation, vector validation, outlier replacement, smoothing, and scaling to\nphysical units.\n\nEverything below is verified against **openpiv 0.25.4**. The API moves between releases — check\n`inspect.signature()` before trusting a snippet against a different version.\n\n## When to use\n\nUse this skill when working with experimental PIV or flow-visualization image pairs: measuring 2D\nvelocity fields, tuning interrogation-window parameters, validating vectors, or deriving vorticity,\nstrain rate, and turbulence statistics. For *simulating* flow rather than measuring it, use a CFD\nskill instead.\n\n## Quick Start\n\nInstall OpenPIV:\n\n```bash\nuv pip install openpiv\n\n# Pin it when the analysis needs to be reproducible -- this is the version every\n# snippet below was checked against.\nuv pip install \"openpiv==0.25.4\"\n```\n\nRun PIV analysis on an image pair:\n\n```python\nimport numpy as np\nfrom openpiv import tools, pyprocess, validation, filters, scaling\n\nframe_a = tools.imread(\"image_a.bmp\")\nframe_b = tools.imread(\"image_b.bmp\")\n\n# Cross-correlate. Returns (u, v, s2n) whenever sig2noise_method is not None.\nu, v, s2n = pyprocess.extended_search_area_piv(\n    frame_a.astype(np.int32),\n    frame_b.astype(np.int32),\n    window_size=32,\n    overlap=12,\n    dt=0.02,\n    search_area_size=38,\n    correlation_method=\"linear\",   # required for search_area_size > window_size\n    sig2noise_method=\"peak2peak\",\n)\n\nx, y = pyprocess.get_coordinates(\n    image_size=frame_a.shape,\n    search_area_size=38,\n    overlap=12,\n)\n\n# flags is a boolean array: True marks a spurious vector.\nflags = validation.sig2noise_val(s2n, threshold=1.05)\nu, v = filters.replace_outliers(u, v, flags, method=\"localmean\", max_iter=3, kernel_size=2)\n\n# Scale to physical units, then flip to image coordinates for plotting.\nx, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=96.52)\nx, y, u, v = tools.transform_coordinates(x, y, u, v)\n\ntools.save(\"vectors.txt\", x, y, u, v, flags)\n```\n\nOr use the bundled CLI, which wraps exactly that pipeline:\n\n```bash\npython skills\u002Fopenpiv\u002Fscripts\u002Frunner.py \\\n    --image frame_a.bmp --image frame_b.bmp --output_dir results --verbose\n```\n\n## Core Concepts\n\n### PIV Fundamentals\n\nParticle Image Velocimetry is an optical method for measuring fluid velocity by tracking illuminated\ntracer particles between two images.\n\n**Process flow:**\n\n1. Capture an image pair (`frame_a`, `frame_b`) separated by a known time `dt`.\n2. Divide the images into interrogation windows.\n3. Cross-correlate matching windows to find peak displacement.\n4. Validate vectors (signal-to-noise, global range, local median).\n5. Replace spurious vectors with interpolated values.\n6. Scale pixel displacements to physical units.\n\n### Interrogation Window Parameters\n\n**`window_size`** — correlation window in pixels (typically 16–128). Larger windows give better\ncorrelation but coarser spatial resolution.\n\n**`overlap`** — pixels shared between adjacent windows (typically 50–75% of `window_size`). Higher\noverlap raises vector density and cost, but adjacent vectors become correlated rather than\nindependent.\n\n**`search_area_size`** — the window searched in the second frame. Must be ≥ `window_size`; a few\npixels larger accommodates larger displacements. Pair an extended search area with\n`correlation_method=\"linear\"` — the default `\"circular\"` relies on FFT wrap-around and aliases large\ndisplacements into small ones. See `references\u002Fadvanced_algorithms.md`.\n\nRules of thumb: keep the largest displacement under about a quarter of `window_size`, and aim for\n5–10 particles per window.\n\n### Signal-to-Noise Ratio\n\n`s2n` measures how distinct the correlation peak is. `sig2noise_method` controls how it is computed —\n`\"peak2mean\"` (the function default) or `\"peak2peak\"`. **The two are on different scales**, so a\nthreshold tuned for one is meaningless for the other. Typical `peak2peak` thresholds are 1.05–1.3.\n\n```python\nflags = validation.sig2noise_val(s2n, threshold=1.05)\n# flags is bool: True == spurious. `~flags` selects the good vectors.\n```\n\n## Common Operations\n\n### Dynamic Masking\n\nMasking lives in `openpiv.preprocess`, **not** in an `openpiv.masking` module. It returns an\n`(image, mask)` tuple and expects a float image.\n\n```python\nfrom openpiv import preprocess\n\n# method=\"edges\" for dark, sharp-edged objects; \"intensity\" for high-contrast objects.\nframe_a_masked, mask_a = preprocess.dynamic_masking(\n    frame_a.astype(np.float64), method=\"intensity\", filter_size=7, threshold=0.005\n)\nframe_b_masked, mask_b = preprocess.dynamic_masking(\n    frame_b.astype(np.float64), method=\"intensity\", filter_size=7, threshold=0.005\n)\n```\n\nFeed the **returned image** into the correlation step — it already has the masked region zeroed. Do\nnot multiply the original frame by `mask`: masking is already applied, and for `method=\"edges\"` the\nmask comes back as `uint8` 0\u002F255 rather than boolean, so multiplying rescales the image by 255.\n\n### Multi-Pass Processing\n\nMulti-pass (window deformation) lives in `openpiv.windef`, driven by a `PIVSettings` dataclass.\n`pyprocess` has no multi-pass entry point.\n\n```python\nimport numpy as np\nfrom openpiv import scaling, windef\n\nsettings = windef.PIVSettings()\nsettings.windowsizes = (64, 32, 16)   # one entry per pass, decreasing (this is also the default)\nsettings.overlap = (32, 16, 8)        # same length as windowsizes\nsettings.num_iterations = 3           # number of passes to actually run\nsettings.sig2noise_threshold = 1.05\n\nx, y, u, v, flags = windef.simple_multipass(\n    frame_a.astype(np.int32), frame_b.astype(np.int32), settings\n)\n\n# Output is in PIXELS PER FRAME -- convert yourself. scaling.uniform only divides\n# by scaling_factor, so apply dt separately.\ndt = 0.02\nx, y, u, v = scaling.uniform(x, y, u, v, scaling_factor=96.52)\nu, v = u \u002F dt, v \u002F dt\n```\n\n`simple_multipass` already validates, replaces outliers, fills remaining NaNs with zeros, and calls\n`transform_coordinates` — do not repeat those steps.\n\n**Units trap:** `PIVSettings` has `dt` and `scaling_factor` fields, but `windef` never uses either —\n`first_pass` calls `extended_search_area_piv` without `dt`, so the whole multi-pass chain works in\npixels per frame. Setting `settings.dt = 0.02` changes nothing about the returned values. Convert\nafter the fact, as above.\n\nFor control over individual passes, `windef.first_pass` and `windef.multipass_img_deform` are the\nlower-level building blocks.\n\n## Validation and Post-Processing\n\n### Validation Methods\n\nEvery validator returns a boolean array where **True marks a spurious vector**.\n\n```python\n# Signal-to-noise\nflags = validation.sig2noise_val(s2n, threshold=1.05)\n\n# Global range -- takes (min, max) TUPLES, positionally or as u_thresholds\u002Fv_thresholds.\nflags = validation.global_val(u, v, (-300, 300), (-300, 300))\n\n# Local median -- u_threshold and v_threshold are REQUIRED; size is the neighbourhood half-width.\nflags = validation.local_median_val(u, v, u_threshold=30.0, v_threshold=30.0, size=1)\n\n# Combine with boolean OR (not np.maximum -- these are bool arrays).\nflags = (\n    validation.sig2noise_val(s2n, threshold=1.05)\n    | validation.global_val(u, v, (-300, 300), (-300, 300))\n    | validation.local_median_val(u, v, u_threshold=30.0, v_threshold=30.0)\n)\n```\n\n**Set these thresholds in the units of `u` and `v`, not in pixels per frame.**\n`extended_search_area_piv` divides by `dt`, so with `dt=0.02` a 3 px\u002Fframe displacement arrives as\n150 px\u002Fs. The thresholds above suit that case; the `(-30, 30)` figure that PIV literature and\n`PIVSettings.min_max_u_disp` use is a px\u002Fframe limit, and applying it to px\u002Fs output rejects the\nentire field. Either validate before scaling, or scale the thresholds by `1\u002Fdt` too.\n\n### Outlier Replacement\n\n```python\nu, v = filters.replace_outliers(\n    u, v, flags, method=\"localmean\", max_iter=3, tol=1e-3, kernel_size=2\n)\n```\n\n`method` accepts `\"localmean\"`, `\"disk\"`, or `\"distance\"` — and only those three. An unrecognized\nname is not rejected; it falls through to an all-zero kernel and silently returns a useless field.\nNote that replacement *fills* the flagged\npositions with interpolated values — if you then overwrite them with NaN, the replacement was\nwasted. Choose one or the other:\n\n```python\n# Keep flagged vectors out of the analysis entirely, instead of interpolating them.\nu = np.where(flags, np.nan, u)\nv = np.where(flags, np.nan, v)\n```\n\n### Smoothing\n\nSmoothing is `openpiv.smoothn.smoothn`; there is no `openpiv.smooth` module. It returns a tuple\nwhose first element is the smoothed field, and it does not accept NaN input.\n\n```python\nfrom openpiv.smoothn import smoothn\n\nu_smooth, *_ = smoothn(np.nan_to_num(u), s=0.5)  # s: larger == smoother\nv_smooth, *_ = smoothn(np.nan_to_num(v), s=0.5)\nu_smooth = np.asarray(u_smooth)\n```\n\n## Visualization\n\n### Vector Field Plotting\n\n`display_vector_field` reads a saved vectors file and calls `plt.show()` internally, so select a\nnon-interactive backend for batch runs.\n\n```python\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\nfrom openpiv import tools\n\nfig, ax = plt.subplots(figsize=(8, 8))\ntools.display_vector_field(\n    \"vectors.txt\",\n    ax=ax,\n    scaling_factor=96.52,   # same factor used in scaling.uniform, to map back onto the image\n    scale=50,\n    width=0.0035,\n    on_img=True,\n    image_name=\"frame_a.bmp\",\n)\nfig.savefig(\"vector_field.png\", dpi=150, bbox_inches=\"tight\")\nplt.close(fig)\n```\n\n### Custom Visualization\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfig, axes = plt.subplots(1, 3, figsize=(15, 5))\n\nmag = np.sqrt(u**2 + v**2)\nfor ax, field, title, cmap in [\n    (axes[0], mag, \"Velocity Magnitude\", \"viridis\"),\n    (axes[1], u, \"U Velocity\", \"RdBu_r\"),\n    (axes[2], v, \"V Velocity\", \"RdBu_r\"),\n]:\n    im = ax.imshow(field, cmap=cmap)\n    ax.set_title(title)\n    plt.colorbar(im, ax=ax)\n\nfig.tight_layout()\nfig.savefig(\"velocity_components.png\")\nplt.close(fig)\n```\n\n## Analysis Functions\n\n`scripts\u002Fanalyze.py` bundles these against a `params.npz` written by `runner.py`. It infers the\nphysical grid spacing from the saved coordinates, so the derivatives come out per unit length:\n\n```python\nimport sys\nsys.path.insert(0, \"skills\u002Fopenpiv\u002Fscripts\")\nfrom analyze import PIVAnalyzer\n\npiv = PIVAnalyzer(\"results\u002Fparams.npz\")\nvorticity = piv.compute_vorticity()          # dv\u002Fdx - du\u002Fdy\nexx, eyy, exy = piv.compute_strain()\nstats = piv.compute_statistics()             # u_mean, v_mean, rms_u, rms_v, tke\npiv.plot_vector_field(save_path=\"quiver.png\")\n```\n\nThe standalone forms, if you would rather compute them inline:\n\n### Vorticity\n\n```python\ndef compute_vorticity(u, v, dx=1.0, dy=None):\n    \"\"\"Out-of-plane vorticity dv\u002Fdx - du\u002Fdy. Pass the physical grid spacing, not 1.0.\"\"\"\n    dy = dx if dy is None else dy\n    return np.gradient(v, dx, axis=1) - np.gradient(u, dy, axis=0)\n```\n\nThe grid spacing is `(window_size - overlap) \u002F scaling_factor` in physical units, so leaving `dx=1.0`\nyields vorticity per grid cell, not per unit length.\n\n**Sign convention:** `runner.py` ends with `transform_coordinates`, which relabels the grid into a\nright-handed y-up frame but leaves the rows in image order, so the saved `y` *decreases* as the row\nindex grows. The standalone forms above assume the opposite, so on a `params.npz` field they return\n`-du\u002Fdy` and flip the sign of the vorticity and the shear strain — negate the `axis=0` derivatives, or\nuse `PIVAnalyzer`, which reads the orientation off the saved coordinates.\n\n### Strain Rate\n\n```python\ndef compute_strain(u, v, dx=1.0, dy=None):\n    \"\"\"Return (exx, eyy, exy) of the 2D strain-rate tensor.\"\"\"\n    dy = dx if dy is None else dy\n    du_dx = np.gradient(u, dx, axis=1)\n    du_dy = np.gradient(u, dy, axis=0)\n    dv_dx = np.gradient(v, dx, axis=1)\n    dv_dy = np.gradient(v, dy, axis=0)\n    return du_dx, dv_dy, 0.5 * (du_dy + dv_dx)\n```\n\n### Turbulence Statistics\n\n```python\ndef compute_statistics(u, v):\n    \"\"\"Single-frame spatial statistics. NOT Reynolds decomposition.\"\"\"\n    u_prime = u - np.nanmean(u)\n    v_prime = v - np.nanmean(v)\n    rms_u, rms_v = np.nanstd(u_prime), np.nanstd(v_prime)\n    return {\n        \"u_mean\": np.nanmean(u),\n        \"v_mean\": np.nanmean(v),\n        \"rms_u\": rms_u,\n        \"rms_v\": rms_v,\n        \"tke\": 0.5 * (rms_u**2 + rms_v**2),\n    }\n```\n\n**Caveat:** subtracting the *spatial* mean of one frame measures spatial variance, which equals\nturbulent intensity only for a homogeneous field. Genuine Reynolds decomposition needs an ensemble of\nimage pairs: average over the time axis, then subtract that mean field from each realization.\n\n## CLI Usage\n\n```bash\n# Basic run\npython skills\u002Fopenpiv\u002Fscripts\u002Frunner.py \\\n    --image img1.bmp --image img2.bmp --output_dir results --verbose\n\n# Tuned parameters with dynamic masking\npython skills\u002Fopenpiv\u002Fscripts\u002Frunner.py \\\n    --image frame_a.bmp \\\n    --image frame_b.bmp \\\n    --output_dir results \\\n    --window_size 32 \\\n    --overlap 12 \\\n    --search_area 38 \\\n    --dt 0.02 \\\n    --scaling 96.52 \\\n    --threshold 1.05 \\\n    --mask dynamic \\\n    --mask_method intensity \\\n    --verbose\n```\n\n### CLI Options\n\n| Option | Default | Description |\n|--------|---------|-------------|\n| `--image` | required | Image file; specify exactly twice for the pair |\n| `--output_dir` | `results` | Output directory (created if absent) |\n| `--window_size` | 32 | Interrogation window size (px) |\n| `--overlap` | 12 | Window overlap (px) |\n| `--search_area` | 38 | Search area size (px), must be ≥ `--window_size` |\n| `--dt` | 0.02 | Time between frames (s) |\n| `--scaling` | 96.52 | Scaling factor, pixels per physical unit (e.g. px\u002Fmm) |\n| `--threshold` | 1.05 | `peak2peak` signal-to-noise threshold |\n| `--mask` | `none` | `none` or `dynamic` (`openpiv.preprocess.dynamic_masking`) |\n| `--mask_method` | `intensity` | `edges` or `intensity`, used only with `--mask dynamic` |\n| `--drop_invalid` | off | NaN out flagged vectors instead of keeping interpolated values |\n| `--verbose` | off | Print progress messages |\n\nVerify an install end to end against OpenPIV's own bundled image pair:\n\n```bash\npython skills\u002Fopenpiv\u002Fscripts\u002Frun_example.py --output_dir \u002Ftmp\u002Fopenpiv-demo\n```\n\n## Output Files\n\n- **vectors.txt** — tab-delimited, `%.4e` formatted, with a `# x y u v flags mask` comment header\n- **params.npz** — NumPy archive with `x`, `y`, `u`, `v`, `flags` arrays\n- **vector_field.png** — vector field drawn over the first frame\n\n```text\n# x\ty\tu\tv\tflags\tmask\n2.1757e-01\t3.5226e+00\t-6.2220e-02\t-2.7081e+00\t0.0000e+00\t0.0000e+00\n4.8695e-01\t3.5226e+00\t-3.1587e-01\t-2.9800e+00\t0.0000e+00\t0.0000e+00\n```\n\n`flags` is written as a float, `0` for a valid vector and `1` for a flagged one.\n\n## Best Practices\n\n### Parameter Selection\n\n1. **Window size** — 32×32 suits most cases. 64\u002F128 for better correlation at coarser resolution;\n   16\u002F24 for finer resolution at the cost of noise.\n2. **Overlap** — 50–75% of window size.\n3. **Threshold** — raise it to reject more vectors; always re-tune after switching\n   `sig2noise_method`.\n4. **Scaling factor** — calibrate against a known reference such as a calibration grid, and keep the\n   units straight (`96.52` in OpenPIV's `test1` tutorial data is px\u002Fmm).\n\n### Image Quality\n\n- Particles visible and evenly distributed, 5–10 per interrogation window\n- No saturated or overexposed regions\n- Minimal background noise; consider background subtraction across a run\n\n### Processing Tips\n\n1. Start from the defaults, then tune against the vector field you get.\n2. Inspect the `s2n` distribution — a low median means poor correlation, not a bad threshold.\n3. Visualize early; obvious problems (uniform vectors, edge artifacts) show up immediately.\n4. Use multi-pass (`windef`) for flows with large velocity gradients or displacements.\n5. Mask reflections and solid boundaries rather than letting them generate vectors.\n\n## Resources\n\n### references\u002F\n\n- `advanced_algorithms.md` — correlation and subpixel methods, multi-pass window deformation,\n  `PIVSettings` fields, 3D and phase-separation modules\n\nLoad the reference when detailed algorithm or settings information is needed.\n",{"name":5,"license":15,"metadata":24,"description":7,"allowed-tools":28,"compatibility":29},{"version":25,"skill-author":26,"tested-against":27},"1.1","OpenPIV Team","openpiv 0.25.4","Read Write Edit Bash","Requires Python 3.10+ with openpiv installed (uv pip install openpiv). numpy, scipy, scikit-image, and matplotlib arrive as dependencies. No network access needed after install.","main","d69096e239f2a89aabc2cd078c47664a9d3b1e11","05-技能与代理开发\u002Fopenpiv",3,"https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts","https:\u002F\u002Fgithub.com\u002Flza6","个人vx：Tf00798\r\n个人✈：@TFGY999","2026-10-08 14:29:22",{"source":8,"skillName":5,"commands":39,"prompt":49,"zipAvailable":50},[40,43,46],{"tool":41,"command":42},"npx","npx skills add lza6\u002FArmor-piercing-system-prompts --skill openpiv",{"tool":44,"command":45},"bunx","bunx skills add lza6\u002FArmor-piercing-system-prompts --skill openpiv",{"tool":47,"command":48},"pnpm","pnpm dlx skills add lza6\u002FArmor-piercing-system-prompts --skill openpiv","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fopenpiv\u002FSKILL.md",true,[52],{"path":53,"resourceType":54,"resourceTypeDesc":55,"sizeBytes":56,"sourceHtmlUrl":57},"references\u002Fadvanced_algorithms.md","REFERENCE","参考文档",10669,"https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fopenpiv\u002Freferences\u002Fadvanced_algorithms.md",[59,67,72,79,86,93],{"skillNo":60,"name":61,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":63,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M7FFG485KY83TD6HSC4YPCMC","obsidian-clipper-template-creator","Guide for creating templates for the Obsidian Web Clipper. Use when you want to create a new clipping template, understand available variables, or format clipped content.","MIT","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobsidian-clipper-template-creator\u002FSKILL.md",[],[],{"skillNo":68,"name":61,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":63,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7FFG0T6AZ0STEJPSB3CX84K","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobsidian-clipper-template-creator-antigravity-awesome-skills-main\u002FSKILL.md",[],[],{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":63,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M7FFFY0QEM14SKWPDYGMXM2P","python-api","Programmatic Object-Detection-Metrics API guidance for BoundingBox, BoundingBoxes, Evaluator, enums, coordinate conversion, AP\u002FmAP semantics, and source-style import diagnostics.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002Fsub-skills\u002Fpython-api\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":63,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M7FFFVZQZ2GJ0C0TGP7JHD20","file-evaluation","Folder-based PASCAL VOC AP\u002FmAP evaluation from ground-truth and detection text files.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002Fsub-skills\u002Ffile-evaluation\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":63,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M7FFFSFNYSE77SJ6PE1CK2DA","object-detection-metrics","Guides legacy Object-Detection-Metrics PASCAL VOC AP\u002FmAP evaluation from detection text folders and direct Python API classes.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002FSKILL.md",[],[],{"skillNo":94,"name":95,"nameZh":6,"description":96,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":63,"licenseFileUrl":6,"sourceHtmlUrl":97,"categories":98,"keywords":99,"publishedAt":19},"01M7FFFP0GCK1RVXBCPQ8APBMT","nx-workspace-patterns","Configure and optimize Nx monorepo workspaces. Use when setting up Nx, configuring project boundaries, optimizing build caching, or implementing affected commands.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fnx-workspace-patterns\u002FSKILL.md",[],[]]