matterviz 0.4.1 → 0.4.3

package/dist/structure/atom-label-placement.js

@@ -1,5 +1,5 @@
 import * as math from '../math';
-import { Vector3 } from 'three';
+import { Matrix4 } from 'three';
 export const LABEL_OFFSET_EPS = 1e-9;
 const LABEL_OFFSET_DIRECTIONS = [
     [0, -1, 0],
@@ -44,39 +44,72 @@ export const choose_site_label_offset = (bond_directions, base_offset) => {
     }
     return math.scale(best_direction, offset_length);
 };
-const project_to_screen = (position, label_camera, size) => {
-    const projected = new Vector3(...position).project(label_camera);
-    return [
-        (projected.x * size.width) / 2 + size.width / 2,
-        (-projected.y * size.height) / 2 + size.height / 2,
-    ];
-};
-export const label_screen_position = (atom_position, label_offset, visual_radius, label_screen_margin, label_camera, size) => {
-    const atom_screen = project_to_screen(atom_position, label_camera, size);
-    const offset_screen = project_to_screen(math.add(atom_position, label_offset), label_camera, size);
-    const offset_x = offset_screen[0] - atom_screen[0];
-    const offset_y = offset_screen[1] - atom_screen[1];
-    const offset_length = Math.hypot(offset_x, offset_y);
-    const direction_x = offset_length > LABEL_OFFSET_EPS ? offset_x / offset_length : 0;
-    const direction_y = offset_length > LABEL_OFFSET_EPS ? offset_y / offset_length : label_offset[1] >= 0 ? -1 : 1;
-    // Measure the atom's projected radius along the camera's right axis (always
-    // view-perpendicular). Measuring along label_offset would collapse the clearance
-    // to ~zero for offsets near the view axis, letting the label overlap the atom.
-    const radius_dir = new Vector3()
-        .setFromMatrixColumn(label_camera.matrixWorld, 0)
-        .normalize()
-        .multiplyScalar(visual_radius);
-    const radius_edge = math.add(atom_position, [
-        radius_dir.x,
-        radius_dir.y,
-        radius_dir.z,
-    ]);
-    const radius_screen = project_to_screen(radius_edge, label_camera, size);
-    const atom_screen_radius = Math.hypot(radius_screen[0] - atom_screen[0], radius_screen[1] - atom_screen[1]);
-    const screen_gap = atom_screen_radius + label_screen_margin;
-    return [atom_screen[0] + direction_x * screen_gap, atom_screen[1] + direction_y * screen_gap];
-};
-export const make_label_position_calculator = (_atom_position, label_offset, visual_radius, label_screen_margin) => (object, label_camera, size) => {
-    const world_position = object.getWorldPosition(new Vector3());
-    return label_screen_position([world_position.x, world_position.y, world_position.z], typeof label_offset === `function` ? label_offset() : label_offset, visual_radius, label_screen_margin, label_camera, size);
-};
+// Per-frame screen projector for label overlays. `update()` precomputes the
+// combined model-view-projection once per frame; `place()` then resolves each
+// label with a single clip-space transform and zero allocations (labels run
+// per site per frame, so the old 3-projections-per-label path with fresh
+// Vector3s dominated frame time on large supercells).
+//
+// Placement semantics match the previous label_screen_position helper: the
+// label sits `atom_screen_radius + margin` px from the atom center along the
+// screen direction of its offset. The projected radius is measured along the
+// camera's right axis, which for both projections equals
+// visual_radius * projection[5] * (height/2) / clip_w.
+export class LabelProjector {
+    #mvp = new Matrix4(); // projection * view * anchor (local -> clip space)
+    #view = new Matrix4(); // view * anchor (local -> view space, for behind-camera test)
+    #half_width = 0;
+    #half_height = 0;
+    #radius_scale = 0; // clip-space multiplier for projected atom radius
+    #margin = 0;
+    update(camera, anchor_world_matrix, size, margin) {
+        this.#view.multiplyMatrices(camera.matrixWorldInverse, anchor_world_matrix);
+        this.#mvp.multiplyMatrices(camera.projectionMatrix, this.#view);
+        this.#half_width = size.width / 2;
+        this.#half_height = size.height / 2;
+        // projectionMatrix[5] = cot(fov/2) for perspective, 2/(top-bottom) for ortho
+        this.#radius_scale = camera.projectionMatrix.elements[5] * this.#half_height;
+        this.#margin = margin;
+    }
+    // position + offset: label anchor and preferred direction in anchor-local
+    // space; visual_radius: atom radius in the same units
+    place(position, offset, visual_radius, out) {
+        const [pos_x, pos_y, pos_z] = position;
+        const mvp = this.#mvp.elements;
+        const view = this.#view.elements;
+        // Behind-camera test in view space (camera looks down -z)
+        const view_z = view[2] * pos_x + view[6] * pos_y + view[10] * pos_z + view[14];
+        if (view_z > 0) {
+            out.visible = false;
+            return;
+        }
+        const clip_x = mvp[0] * pos_x + mvp[4] * pos_y + mvp[8] * pos_z + mvp[12];
+        const clip_y = mvp[1] * pos_x + mvp[5] * pos_y + mvp[9] * pos_z + mvp[13];
+        const clip_w = mvp[3] * pos_x + mvp[7] * pos_y + mvp[11] * pos_z + mvp[15];
+        const screen_x = (clip_x / clip_w) * this.#half_width + this.#half_width;
+        const screen_y = (-clip_y / clip_w) * this.#half_height + this.#half_height;
+        // Screen direction of the offset: project position + offset and take the
+        // screen-space delta. Projecting the second point (instead of just rotating
+        // the offset into view space) keeps perspective foreshortening exact for
+        // offsets with a depth component, matching the pre-projector behavior.
+        const [off_x, off_y, off_z] = offset;
+        const end_x = pos_x + off_x;
+        const end_y = pos_y + off_y;
+        const end_z = pos_z + off_z;
+        const end_clip_x = mvp[0] * end_x + mvp[4] * end_y + mvp[8] * end_z + mvp[12];
+        const end_clip_y = mvp[1] * end_x + mvp[5] * end_y + mvp[9] * end_z + mvp[13];
+        const end_clip_w = mvp[3] * end_x + mvp[7] * end_y + mvp[11] * end_z + mvp[15];
+        const delta_x = (end_clip_x / end_clip_w) * this.#half_width + this.#half_width - screen_x;
+        const delta_y = (-end_clip_y / end_clip_w) * this.#half_height + this.#half_height - screen_y;
+        const dir_len = Math.hypot(delta_x, delta_y);
+        // Offsets along the view axis have no screen direction; nudge upward like
+        // the previous implementation (screen y grows downward)
+        const dir_x = dir_len > LABEL_OFFSET_EPS ? delta_x / dir_len : 0;
+        const dir_y = dir_len > LABEL_OFFSET_EPS ? delta_y / dir_len : off_y >= 0 ? -1 : 1;
+        const atom_screen_radius = (visual_radius * this.#radius_scale) / clip_w;
+        const screen_gap = Math.abs(atom_screen_radius) + this.#margin;
+        out.x = screen_x + dir_x * screen_gap;
+        out.y = screen_y + dir_y * screen_gap;
+        out.visible = true;
+    }
+}

package/dist/structure/atom-properties.d.ts

@@ -1,4 +1,5 @@
 import type { ColorScaleType, D3InterpolateName } from '../colors';
+import type { CoordinationData } from '../coordination/calc-coordination';
 import type { AtomColorMode } from '../settings';
 import type { AnyStructure, Site } from './';
 import type { BondingStrategy } from './bonding';
@@ -29,6 +30,7 @@ export declare const apply_categorical_color_scale: (vals: string[], scale?: str
     unique_values: string[];
 };
 export declare const get_orig_site_idx: (site: Site | undefined, site_idx: number) => number;
+export declare function calc_structure_coordination(structure: AnyStructure, strategy?: BondingStrategy): CoordinationData;
 export declare function get_coordination_colors(structure: AnyStructure, strategy?: BondingStrategy, scale?: string, type?: ColorScaleType): AtomPropertyColors;
 export declare function get_wyckoff_colors(structure: AnyStructure, sym_data: SymmetryDataWithOrigMap | null, scale?: string): AtomPropertyColors;
 export declare function get_custom_colors(structure: AnyStructure, fn: (site: Site, idx: number) => number | string, scale?: string, type?: ColorScaleType): AtomPropertyColors;

package/dist/structure/atom-properties.js

@@ -1,12 +1,22 @@
 // Utility functions for computing atom properties and applying color scales
 import { get_d3_interpolator } from '../colors';
-import { calc_coordination_nums } from '../coordination';
+import { calc_coordination_nums } from '../coordination/calc-coordination';
+import { element_by_symbol } from '../element/data';
 import * as math from '../math';
-import { wrap_to_unit_cell } from './pbc';
+import { get_majority_element } from './bonding';
+import { wrap_frac_coord } from './pbc';
 import { rgb } from 'd3-color';
 import * as d3_sc from 'd3-scale-chromatic';
 const GRAY = `#808080`;
 const DEFAULT_COLOR_SCALE = `interpolateViridis`;
+// Cap on periodic image shells per axis when expanding for coordination. Guards
+// against image explosion in very thin / highly oblique cells (coordination is ~O(n²)).
+const MAX_IMAGE_SHELLS = 3;
+// Max bond distance each strategy can form, mirroring the defaults in bonding.ts
+// (electroneg_ratio.max_distance_ratio, solid_angle.max_distance). Used to size PBC
+// image expansion just tightly enough that coordination never misses a bonded neighbor.
+const ELECTRONEG_MAX_RATIO = 2;
+const SOLID_ANGLE_MAX_DIST = 5; // Å
 export const get_d3_color_scales = () => Object.keys(d3_sc).filter((key) => key.startsWith(`interpolate`));
 const to_hex = (interp_fn, frac) => rgb(interp_fn(frac)).formatHex();
 const build_image_site = (site, frac_to_cart, offset, orig_idx) => {
@@ -22,12 +32,6 @@ const build_image_site = (site, frac_to_cart, offset, orig_idx) => {
         properties: { ...site.properties, orig_site_idx: orig_idx },
     };
 };
-const get_all_offsets = (pbc) => [-1, 0, 1]
-    .flatMap((dx) => [-1, 0, 1].flatMap((dy) => [-1, 0, 1].map((dz) => [dx, dy, dz])))
-    .filter(([dx, dy, dz]) => !(dx === 0 && dy === 0 && dz === 0) &&
-    (pbc[0] || dx === 0) &&
-    (pbc[1] || dy === 0) &&
-    (pbc[2] || dz === 0));
 const make_categorical = (vals, scale, sort_fn) => {
     const interp_fn = get_d3_interpolator(scale);
     const uniq = sort_fn
@@ -75,46 +79,109 @@ export const get_orig_site_idx = (site, site_idx) => typeof site?.properties?.or
     : typeof site?.properties?.orig_site_idx === `number`
         ? site.properties.orig_site_idx
         : site_idx;
-// Expand structure with PBC images - use minimal expansion based on atom positions
-function expand_structure_for_pbc(structure) {
+// Expand a periodic structure with the neighbor images needed for correct
+// coordination. Each atom's `reach` (the largest bond `strategy` can form for it —
+// electroneg_ratio's (r + r_max)·ratio or solid_angle's flat cap) sizes how many whole
+// cells to image per periodic axis, measured over the perpendicular cell height (not
+// the lattice vector length, so oblique cells work), keeping only images within `reach`
+// of the [0,1] cell and capping at MAX_IMAGE_SHELLS/axis (warns + may undercount beyond
+// that — near-degenerate cells only). Smaller atoms image less; atoms with no covalent
+// radius form no bonds and get no images.
+function expand_structure_for_pbc(structure, strategy) {
     if (!(`lattice` in structure) || !structure.lattice || structure.sites.length === 0) {
         return structure;
     }
     const { sites, lattice } = structure;
-    const frac_to_cart = math.create_frac_to_cart(lattice.matrix);
     const pbc = lattice.pbc ?? [true, true, true];
-    const all_offsets = get_all_offsets(pbc);
-    // Small structures: expand all atoms
-    if (sites.length < 20 || !pbc.some(Boolean)) {
-        const image_sites = sites.flatMap((site, orig_idx) => all_offsets.map((offset) => build_image_site(site, frac_to_cart, offset, orig_idx)));
-        return { ...structure, sites: [...sites, ...image_sites] };
-    }
-    // Large structures: only expand atoms near boundaries (within 5Å bond distance)
-    const cutoff = [5.0 / lattice.a, 5.0 / lattice.b, 5.0 / lattice.c];
-    const image_sites = sites.flatMap((site, orig_idx) => {
-        const norm = wrap_to_unit_cell(site.abc);
-        return all_offsets
-            .filter(([dx, dy, dz]) => (dx === 0 || (dx === -1 ? norm[0] <= cutoff[0] : norm[0] >= 1 - cutoff[0])) &&
-            (dy === 0 || (dy === -1 ? norm[1] <= cutoff[1] : norm[1] >= 1 - cutoff[1])) &&
-            (dz === 0 || (dz === -1 ? norm[2] <= cutoff[2] : norm[2] >= 1 - cutoff[2])))
-            .map((offset) => build_image_site(site, frac_to_cart, offset, orig_idx));
+    if (!pbc.some(Boolean))
+        return structure;
+    const frac_to_cart = math.create_frac_to_cart(lattice.matrix);
+    // Wrap into [0,1) along PERIODIC axes only so the near-cell filter and image
+    // building share one position (else boundary atoms image on the wrong side and lose
+    // neighbors). Vacuum axes keep their real coord — wrapping would fold apart atoms
+    // together and invent bonds.
+    const cell_sites = sites.map((site) => {
+        const abc = site.abc.map((coord, axis) => pbc[axis] ? wrap_frac_coord(coord) : coord);
+        return { ...site, abc, xyz: frac_to_cart(abc) };
     });
-    return { ...structure, sites: [...sites, ...image_sites] };
+    // Covalent radius per atom (0 = unknown → forms no bonds → needs no images)
+    const radii = cell_sites.map((site) => {
+        const elem = get_majority_element(site);
+        return (elem ? element_by_symbol.get(elem)?.covalent_radius : undefined) ?? 0;
+    });
+    let max_radius = 0;
+    for (const radius of radii)
+        if (radius > max_radius)
+            max_radius = radius;
+    const reach_of = (radius) => strategy === `solid_angle`
+        ? SOLID_ANGLE_MAX_DIST
+        : (radius + max_radius) * ELECTRONEG_MAX_RATIO;
+    const heights = math.cell_heights(lattice.matrix);
+    // Axes we image along: periodic and non-degenerate (finite height). Non-live axes
+    // (vacuum or degenerate) contribute no images — 0 shells + ∞ cutoff so their only
+    // copy (shift 0) always passes the near-cell filter. Loop-invariant, so hoisted out.
+    const live_axis = heights.map((height, axis) => pbc[axis] && Number.isFinite(height));
+    const image_near_cell = (frac, shift, axis_cutoff) => {
+        const shifted = frac + shift;
+        return shifted >= -axis_cutoff && shifted <= 1 + axis_cutoff;
+    };
+    let capped = false;
+    const image_sites = [];
+    for (const [orig_idx, site] of cell_sites.entries()) {
+        const radius = radii[orig_idx];
+        if (radius === 0)
+            continue; // no covalent radius → no bonds → no images
+        const reach = reach_of(radius);
+        // `cutoff` = fractional reach for the near-cell filter (keep an image shifted by `s`
+        // iff abc+s lands within `cutoff` of [0,1]); `n_shells` bounds the loop so no
+        // in-reach copy is missed.
+        const cutoff = heights.map((height, axis) => (live_axis[axis] ? reach / height : Infinity));
+        const n_shells = heights.map((height, axis) => {
+            if (!live_axis[axis])
+                return 0;
+            const shells = Math.floor(1 + reach / height);
+            if (shells > MAX_IMAGE_SHELLS)
+                capped = true;
+            return Math.min(MAX_IMAGE_SHELLS, shells);
+        });
+        const [frac_a, frac_b, frac_c] = site.abc; // periodic axes wrapped into [0, 1)
+        for (let dx = -n_shells[0]; dx <= n_shells[0]; dx++) {
+            if (!image_near_cell(frac_a, dx, cutoff[0]))
+                continue;
+            for (let dy = -n_shells[1]; dy <= n_shells[1]; dy++) {
+                if (!image_near_cell(frac_b, dy, cutoff[1]))
+                    continue;
+                for (let dz = -n_shells[2]; dz <= n_shells[2]; dz++) {
+                    if (dx === 0 && dy === 0 && dz === 0)
+                        continue;
+                    if (!image_near_cell(frac_c, dz, cutoff[2]))
+                        continue;
+                    image_sites.push(build_image_site(site, frac_to_cart, [dx, dy, dz], orig_idx));
+                }
+            }
+        }
+    }
+    if (capped) {
+        console.warn(`[coordination] cell is very thin or oblique relative to bond reach; capping ` +
+            `PBC images at ${MAX_IMAGE_SHELLS} shells/axis, coordination near cell ` +
+            `boundaries may be undercounted`);
+    }
+    return { ...structure, sites: [...cell_sites, ...image_sites] };
 }
-export function get_coordination_colors(structure, strategy = `electroneg_ratio`, scale = DEFAULT_COLOR_SCALE, type = `continuous`) {
-    const orig_site_count = structure.sites.length;
-    // Check if structure has periodic boundary conditions
+// PBC-aware coordination: expand periodic cells with image atoms (so boundary atoms get
+// full coordination), counting only original atoms as centers. Shared by the 3D viewer and
+// CoordinationBarPlot so both report identical numbers.
+export function calc_structure_coordination(structure, strategy = `electroneg_ratio`) {
     const has_lattice = `lattice` in structure && structure.lattice !== undefined;
     const pbc = has_lattice ? structure.lattice.pbc : undefined;
     const has_pbc = has_lattice && (pbc === undefined || pbc.some(Boolean));
-    // For PBC structures, expand with images from neighboring cells for accurate coordination
-    const coord_structure = has_pbc ? expand_structure_for_pbc(structure) : structure;
-    // Calculate coordination numbers on the (potentially expanded) structure
-    const all_coord_data = calc_coordination_nums(coord_structure, strategy);
-    // Extract coordination numbers only for the original sites (not image atoms)
-    const coord_nums = all_coord_data.sites
-        .slice(0, orig_site_count)
-        .map((site) => site.coordination_num);
+    // Image atoms still count as neighbors but aren't iterated as centers (big speedup)
+    const coord_structure = has_pbc ? expand_structure_for_pbc(structure, strategy) : structure;
+    return calc_coordination_nums(coord_structure, strategy, structure.sites.length);
+}
+export function get_coordination_colors(structure, strategy = `electroneg_ratio`, scale = DEFAULT_COLOR_SCALE, type = `continuous`) {
+    // sites is already limited to the original atoms (calc_coordination_nums center_count)
+    const coord_nums = calc_structure_coordination(structure, strategy).sites.map((site) => site.coordination_num);
     const { colors, unique_values } = apply_color_scale(coord_nums, scale, type);
     return build_prop_colors(coord_nums, colors, unique_values);
 }

package/dist/structure/bond-order-perception.js

@@ -52,12 +52,10 @@ function formal_charge(symbol, bond_valence) {
 const is_main_group = (symbol) => symbol in ATOMIC_VALENCE;
 // Cap per-fragment valence enumeration (3^k for catenated S/Se/Te/P chains).
 const MAX_VALENCE_COMBOS = 4096;
+// Edges are bounds-checked by perceive_bond_orders before reaching here.
 function split_fragments(n_atoms, edges) {
     const adjacency = Array.from({ length: n_atoms }, () => []);
     for (const [atom_idx_1, atom_idx_2] of edges) {
-        if (adjacency[atom_idx_1] === undefined || adjacency[atom_idx_2] === undefined) {
-            throw new Error(`Invalid edge ${atom_idx_1}-${atom_idx_2} for ${n_atoms} atoms`);
-        }
         adjacency[atom_idx_1].push(atom_idx_2);
         adjacency[atom_idx_2].push(atom_idx_1);
     }
@@ -140,9 +138,6 @@ function assign_bond_orders(edges, target_valence) {
 function find_rings(n_atoms, edges) {
     const adjacency = Array.from({ length: n_atoms }, () => new Set());
     for (const [atom_idx_1, atom_idx_2] of edges) {
-        if (adjacency[atom_idx_1] === undefined || adjacency[atom_idx_2] === undefined) {
-            throw new Error(`Invalid edge ${atom_idx_1}-${atom_idx_2} for ${n_atoms} atoms`);
-        }
         adjacency[atom_idx_1].add(atom_idx_2);
         adjacency[atom_idx_2].add(atom_idx_1);
     }
@@ -200,7 +195,6 @@ function find_rings(n_atoms, edges) {
     }
     return [...uniq.values()];
 }
-const order_to_bond_order = (order) => order >= 3 ? 3 : order === 2 ? 2 : 1;
 // Conservative planarity check: degenerate first-3-atom planes are non-planar.
 function ring_is_planar(ring, sites) {
     if (ring.length < 3)
@@ -294,7 +288,8 @@ export function perceive_bond_orders(sites, bonds, opts = {}) {
         if (!solved)
             continue;
         local_edges.forEach((edge, edge_idx) => {
-            const order = order_to_bond_order(solved[edge_idx]);
+            const solved_order = solved[edge_idx];
+            const order = solved_order >= 3 ? 3 : solved_order === 2 ? 2 : 1;
             result.set(edge.bond, { ...edge.bond, bond_order: order, perceived: true });
         });
         // Hückel aromatic post-pass, retaining Kekulé orders for display toggles.

package/dist/structure/bonding.d.ts

@@ -1,8 +1,9 @@
 import type { ElementSymbol } from '../element';
 import type { Vec3 } from '../math';
 import type { AnyStructure, BondOrder, BondPair, Site, StructureBond } from './';
-export declare const element_lookup: Map<"S" | "K" | "B" | "H" | "He" | "Li" | "Be" | "C" | "N" | "O" | "F" | "Ne" | "Na" | "Mg" | "Al" | "Si" | "P" | "Cl" | "Ar" | "Ca" | "Sc" | "Ti" | "V" | "Cr" | "Mn" | "Fe" | "Co" | "Ni" | "Cu" | "Zn" | "Ga" | "Ge" | "As" | "Se" | "Br" | "Kr" | "Rb" | "Sr" | "Y" | "Zr" | "Nb" | "Mo" | "Tc" | "Ru" | "Rh" | "Pd" | "Ag" | "Cd" | "In" | "Sn" | "Sb" | "Te" | "I" | "Xe" | "Cs" | "Ba" | "La" | "Ce" | "Pr" | "Nd" | "Pm" | "Sm" | "Eu" | "Gd" | "Tb" | "Dy" | "Ho" | "Er" | "Tm" | "Yb" | "Lu" | "Hf" | "Ta" | "W" | "Re" | "Os" | "Ir" | "Pt" | "Au" | "Hg" | "Tl" | "Pb" | "Bi" | "Po" | "At" | "Rn" | "Fr" | "Ra" | "Ac" | "Th" | "Pa" | "U" | "Np" | "Pu" | "Am" | "Cm" | "Bk" | "Cf" | "Es" | "Fm" | "Md" | "No" | "Lr" | "Rf" | "Db" | "Sg" | "Bh" | "Hs" | "Mt" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", import("../element").ChemicalElement>;
 export declare const get_majority_element: (site: Site | undefined) => ElementSymbol | null;
+export declare const is_spectator_center: (element: string) => boolean;
+export declare function has_framework_potential(elements: Iterable<string>): boolean;
 export declare const normalize_structure_bond: (site_idx_1: number, site_idx_2: number, order: BondOrder, cell_shift?: Vec3) => StructureBond;
 export declare const get_bond_key: (idx_1: number, idx_2: number, cell_shift?: Vec3) => string;
 export declare function remap_bonds_after_deletion(bonds: readonly StructureBond[], deleted_indices: ReadonlySet<number>): StructureBond[];
@@ -39,12 +40,14 @@ export declare function apply_explicit_bond_metadata(structure: AnyStructure, bo
 export declare function scale_and_offset_bond_matrix(transform_matrix: Float32Array, offset: number, radius_scale: number): Float32Array;
 export declare function get_bond_render_matrices(bond: BondPair, bond_thickness: number): Float32Array[];
 export declare function compute_bond_transform(pos_1: Vec3, pos_2: Vec3): Float32Array;
+export declare const pack_cell_key: (x: number, y: number, z: number) => number;
 export declare const BONDING_STRATEGIES: {
     readonly electroneg_ratio: typeof electroneg_ratio;
     readonly solid_angle: typeof solid_angle;
 };
 export type BondingStrategy = keyof typeof BONDING_STRATEGIES;
 export type BondingAlgo = (typeof BONDING_STRATEGIES)[BondingStrategy];
+export declare function compute_bonds(structure: AnyStructure, strategy: BondingStrategy, options?: Record<string, unknown>): BondPair[];
 export declare function electroneg_ratio(structure: AnyStructure, { electronegativity_threshold, // Max electronegativity difference for bonding
 max_distance_ratio, // Max distance as multiple of sum of covalent radii
 min_bond_dist, // Minimum bond distance in Angstroms
@@ -52,7 +55,8 @@ metal_metal_penalty, // Strength penalty for metal-metal bonds
 metal_nonmetal_bonus, // Strength bonus for metal-nonmetal bonds
 similar_electronegativity_bonus, // Bonus for similar electronegativity
 same_species_penalty, // Penalty for bonds between same element
-strength_threshold, }?: {
+strength_threshold, // Minimum bond strength to include in results
+center_count, }?: {
     electronegativity_threshold?: number | undefined;
     max_distance_ratio?: number | undefined;
     min_bond_dist?: number | undefined;
@@ -61,12 +65,14 @@ strength_threshold, }?: {
     similar_electronegativity_bonus?: number | undefined;
     same_species_penalty?: number | undefined;
     strength_threshold?: number | undefined;
+    center_count?: number | undefined;
 }): BondPair[];
-export declare function solid_angle(structure: AnyStructure, { min_solid_angle, min_face_area, max_distance, min_bond_dist, strength_threshold, }?: {
+export declare function solid_angle(structure: AnyStructure, { min_solid_angle, min_face_area, max_distance, min_bond_dist, strength_threshold, center_count, }?: {
     min_solid_angle?: number | undefined;
     min_face_area?: number | undefined;
     max_distance?: number | undefined;
     min_bond_dist?: number | undefined;
     strength_threshold?: number | undefined;
+    center_count?: number | undefined;
 }): BondPair[];
 export {};