graphica-plot 2.0.0__py3-none-any.whl

graphica/core/fit_models.py

@@ -0,0 +1,379 @@
+"""曲線フィットのモデルの表。種類の判定・パラメータ名・関数・初期値の推定をここ 1 か所に持つ。
+
+種類は表示名(例「ガウシアン (y = …)」)で渡され、保存ファイルと方法の文章にもそのまま入る。判定の順は、
+プラグインの関数(名前の完全一致)→ カスタム数式 → 組み込み(語の部分一致、表の順:「2成分指数」を「指数関数」より、
+「擬似フォークト」を「フォークト」より、「ボルツマン」を「シグモイド」より先に)。プラグインを先に見ないと、
+「二重ガウシアン」のような名前が黙って組み込みのガウシアンになる。
+初期値の式は結果の popt が 1 ビットも変わらないよう、演算の順まで変えないこと。
+"""
+import re
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping
+
+import numpy as np
+from scipy.special import wofz
+
+from graphica.core.safe_eval import DEFAULT_FUNCTIONS, safe_eval_formula
+
+CUSTOM_FORMULA_KEYWORD = "カスタム数式"
+CUSTOM_FORMULA_LABEL = "カスタム数式..."
+CUSTOM_FORMULA_MODEL_ID = "custom_formula"
+PLUGIN_MODEL_ID_PREFIX = "plugin:"
+
+
+def is_custom_formula_type(fit_type: str) -> bool:
+    return CUSTOM_FORMULA_KEYWORD in fit_type
+
+
+def _linear(x: Any, a: float, b: float) -> Any:
+    return a * x + b
+
+
+def _poly2(x: Any, a: float, b: float, c: float) -> Any:
+    return a * x**2 + b * x + c
+
+
+def _poly3(x: Any, a: float, b: float, c: float, d: float) -> Any:
+    return a * x**3 + b * x**2 + c * x + d
+
+
+def _exponential(x: Any, a: float, b: float) -> Any:
+    return a * np.exp(b * x)
+
+
+def _logarithmic(x: Any, a: float, b: float) -> Any:
+    return a * np.log(x) + b
+
+
+def _power(x: Any, a: float, b: float) -> Any:
+    return a * np.power(x, b)
+
+
+def _gaussian(x: Any, a: float, b: float, c: float, d: float) -> Any:
+    return a * np.exp(-((x - b) ** 2) / (2 * c ** 2)) + d
+
+
+def _sigmoid(x: Any, a: float, b: float, c: float) -> Any:
+    return a / (1 + np.exp(-b * (x - c)))
+
+
+def _two_exponentials(x: Any, a1: float, b1: float, a2: float, b2: float, c: float) -> Any:
+    return a1 * np.exp(b1 * x) + a2 * np.exp(b2 * x) + c
+
+
+def _lorentzian(x: Any, a: float, b: float, c: float, d: float) -> Any:
+    return a / (1 + ((x - b) / c) ** 2) + d
+
+
+def _pseudo_voigt(x: Any, a: float, b: float, c: float, eta: float, d: float) -> Any:
+    # 共通の中心 b と FWHM c を持つローレンツ型とガウス型を eta で混ぜる
+    lorentzian_shape = 1 / (1 + ((x - b) / c) ** 2)
+    gaussian_shape = np.exp(-4 * np.log(2) * ((x - b) / c) ** 2)
+    return a * (eta * lorentzian_shape + (1 - eta) * gaussian_shape) + d
+
+
+def _voigt(x: Any, a: float, b: float, sigma: float, gamma: float, d: float) -> Any:
+    # Faddeeva 関数による Voigt。この正規化で gamma→0 のとき a がピーク高さになる
+    z = ((x - b) + 1j * gamma) / (sigma * np.sqrt(2))
+    return a * np.real(wofz(z)) / (sigma * np.sqrt(2 * np.pi)) + d
+
+
+def _boltzmann_sigmoid(x: Any, a1: float, a2: float, x0: float, dx: float) -> Any:
+    return a2 + (a1 - a2) / (1 + np.exp((x - x0) / dx))
+
+
+def _hill(x: Any, vmax: float, k: float, n: float) -> Any:
+    return (vmax * np.power(x, n)) / (np.power(k, n) + np.power(x, n))
+
+
+def _estimate_fwhm(x_arr: Any, y_arr: Any, amplitude: float) -> float:
+    """半値を横切る X の幅を FWHM の粗い推定にする(裾の広い形で誤った局所解に落ちないため)。"""
+    half_level = np.nanmin(y_arr) + amplitude / 2
+    above_half = x_arr[y_arr >= half_level]
+    if len(above_half) == 0:
+        return (np.nanmax(x_arr) - np.nanmin(x_arr)) / 4 or 1.0
+    return (above_half.max() - above_half.min()) or 1.0
+
+
+def _p0_linear(x: Any, y: Any) -> list[Any]:
+    return [1.0, 0.0]
+
+
+def _p0_poly2(x: Any, y: Any) -> list[Any]:
+    return [1.0, 1.0, 0.0]
+
+
+def _p0_poly3(x: Any, y: Any) -> list[Any]:
+    return [1.0, 1.0, 1.0, 0.0]
+
+
+def _p0_two_exponentials(x: Any, y: Any) -> list[Any]:
+    amplitude = (np.nanmax(y) - np.nanmin(y)) / 2 or 1.0
+    x_span = (np.nanmax(x) - np.nanmin(x)) or 1.0
+    # 2成分が同じ初期値だと縮退して収束しないので、符号の違う率から始める
+    rate0 = 2.0 / x_span
+    return [amplitude, rate0, amplitude, -rate0, np.nanmin(y)]
+
+
+def _p0_exponential(x: Any, y: Any) -> list[Any]:
+    amplitude = np.nanmean(np.abs(y)) or 1.0
+    return [amplitude, 0.01]
+
+
+def _p0_logarithmic(x: Any, y: Any) -> list[Any]:
+    return [1.0, 0.0]
+
+
+def _p0_power(x: Any, y: Any) -> list[Any]:
+    return [1.0, 1.0]
+
+
+def _peak_amplitude_and_center(x: Any, y: Any) -> tuple[Any, Any]:
+    amplitude = (np.nanmax(y) - np.nanmin(y)) or 1.0
+    center = x[np.nanargmax(y)] if len(x) else 0.0
+    return amplitude, center
+
+
+def _p0_gaussian(x: Any, y: Any) -> list[Any]:
+    amplitude, center = _peak_amplitude_and_center(x, y)
+    width = (np.nanmax(x) - np.nanmin(x)) / 4 or 1.0
+    return [amplitude, center, width, np.nanmin(y)]
+
+
+def _p0_lorentzian(x: Any, y: Any) -> list[Any]:
+    amplitude, center = _peak_amplitude_and_center(x, y)
+    # c は HWHM なので FWHM の半分
+    fwhm0 = _estimate_fwhm(x, y, amplitude)
+    return [amplitude, center, fwhm0 / 2, np.nanmin(y)]
+
+
+def _p0_pseudo_voigt(x: Any, y: Any) -> list[Any]:
+    amplitude, center = _peak_amplitude_and_center(x, y)
+    # この定義の c は FWHM そのもの
+    fwhm0 = _estimate_fwhm(x, y, amplitude)
+    return [amplitude, center, fwhm0, 0.5, np.nanmin(y)]
+
+
+def _p0_voigt(x: Any, y: Any) -> list[Any]:
+    amplitude, center = _peak_amplitude_and_center(x, y)
+    fwhm0 = _estimate_fwhm(x, y, amplitude)
+    # FWHM をガウス成分とローレンツ成分に大まかに割り振る経験的な初期値
+    sigma0 = (fwhm0 / 2.355) or 1.0
+    gamma0 = (fwhm0 / 4) or 1.0
+    # _voigt の正規化に合わせ、ピーク高さが振幅に近くなるよう a をスケールする
+    return [amplitude * sigma0 * np.sqrt(2 * np.pi), center, sigma0, gamma0, np.nanmin(y)]
+
+
+def _p0_boltzmann_sigmoid(x: Any, y: Any) -> list[Any]:
+    order = np.argsort(x)
+    x_sorted, y_sorted = x[order], y[order]
+    y_start = y_sorted[0]
+    y_end = y_sorted[-1]
+    mid_level = (y_start + y_end) / 2
+    # 遷移の中心は Y の中点を最初に横切る X から推定する(X の平均だと局所解に落ちやすい)
+    crossing_mask = y_sorted < mid_level if y_start >= y_end else y_sorted > mid_level
+    crossing_indices = np.flatnonzero(crossing_mask)
+    x0 = x_sorted[crossing_indices[0]] if len(crossing_indices) else np.nanmean(x)
+    dx0 = (np.nanmax(x) - np.nanmin(x)) / 10 or 1.0
+    return [y_start, y_end, x0, dx0]
+
+
+def _p0_sigmoid(x: Any, y: Any) -> list[Any]:
+    amplitude = np.nanmax(y) or 1.0
+    return [amplitude, 1.0, np.nanmean(x)]
+
+
+def _p0_hill(x: Any, y: Any) -> list[Any]:
+    vmax0 = np.nanmax(y) or 1.0
+    positive_x = x[x > 0]
+    k0 = np.nanmedian(positive_x) if len(positive_x) else 1.0
+    return [vmax0, k0, 1.0]
+
+
+def _require_positive_x(message: str) -> Callable[[Any], None]:
+    def check(x: Any) -> None:
+        if np.any(x <= 0):
+            raise ValueError(message)
+    return check
+
+
+def _require_non_negative_x(x: Any) -> None:
+    if np.any(x < 0):
+        raise ValueError("ヒル式は X >= 0 のデータにのみ使用できます。")
+
+
+@dataclass(frozen=True)
+class FitModel:
+    model_id: str              # 保存用の ID(fit_result['fit_model_id'])。一度決めたら変えない
+    keyword: str               # 種類の名前にこの語が含まれればこのモデル
+    menu_label: str            # ダイアログの選択肢(= 保存される fit_type)
+    param_names: tuple[str, ...]
+    func: Callable[..., Any]
+    initial_guess: Callable[[Any, Any], list[Any]]
+    check_data: Callable[[Any], None] | None = None   # 使えないデータなら ValueError
+
+
+# 判定の順。ダイアログの並びは MENU_ORDER。
+BUILTIN_FIT_MODELS: tuple[FitModel, ...] = (
+    FitModel("linear", "線形", "線形 (y = ax + b)", ("a", "b"), _linear, _p0_linear),
+    FitModel("poly2", "2次多項式", "2次多項式 (y = ax^2 + bx + c)", ("a", "b", "c"), _poly2, _p0_poly2),
+    FitModel("poly3", "3次多項式", "3次多項式 (y = ax^3 + bx^2 + cx + d)", ("a", "b", "c", "d"), _poly3, _p0_poly3),
+    FitModel("two_exponentials", "2成分指数", "2成分指数関数 (y = a1*exp(b1*x) + a2*exp(b2*x) + c)", ("a1", "b1", "a2", "b2", "c"),
+             _two_exponentials, _p0_two_exponentials),
+    FitModel("exponential", "指数関数", "指数関数 (y = a * exp(bx))", ("a", "b"), _exponential, _p0_exponential),
+    FitModel("logarithmic", "対数", "対数 (y = a * ln(x) + b)", ("a", "b"), _logarithmic, _p0_logarithmic,
+             _require_positive_x("対数フィットは X > 0 のデータにのみ使用できます。")),
+    FitModel("power", "べき乗", "べき乗 (y = a * x^b)", ("a", "b"), _power, _p0_power,
+             _require_positive_x("べき乗フィットは X > 0 のデータにのみ使用できます。")),
+    FitModel("gaussian", "ガウシアン", "ガウシアン (y = a * exp(-(x-b)^2 / (2c^2)) + d)", ("a", "b", "c", "d"),
+             _gaussian, _p0_gaussian),
+    FitModel("lorentzian", "ローレンツ", "ローレンツ関数 (y = a / (1 + ((x-b)/c)^2) + d)", ("a", "b", "c", "d"),
+             _lorentzian, _p0_lorentzian),
+    FitModel("pseudo_voigt", "擬似フォークト", "擬似フォークト関数 (y = a*(η/(1+((x-b)/c)^2) + (1-η)*exp(-4ln2*((x-b)/c)^2)) + d)",
+             ("a", "b", "c", "eta", "d"), _pseudo_voigt, _p0_pseudo_voigt),
+    FitModel("voigt", "フォークト", "フォークト関数 (y = a*Re[wofz((x-b+iγ)/(σ√2))] / (σ√(2π)) + d)",
+             ("a", "b", "sigma", "gamma", "d"), _voigt, _p0_voigt),
+    FitModel("boltzmann_sigmoid", "ボルツマン", "ボルツマンシグモイド (y = a2 + (a1-a2) / (1 + exp((x-x0)/dx)))",
+             ("a1", "a2", "x0", "dx"), _boltzmann_sigmoid, _p0_boltzmann_sigmoid),
+    FitModel("sigmoid", "シグモイド", "シグモイド (y = a / (1 + exp(-b(x-c))))", ("a", "b", "c"), _sigmoid, _p0_sigmoid),
+    FitModel("hill", "ヒル", "ヒルの式 (y = vmax*x^n / (k^n + x^n))", ("vmax", "k", "n"), _hill, _p0_hill,
+             _require_non_negative_x),
+)
+
+MENU_ORDER: tuple[str, ...] = (
+    "線形", "2次多項式", "3次多項式", "指数関数", "対数", "べき乗", "ガウシアン", "ローレンツ",
+    "擬似フォークト", "フォークト", "2成分指数", "ボルツマン", "シグモイド", "ヒル",
+)
+
+# プラグインの関数名がこれらと同じだと、保存済みの組み込みの種類を取り違えるので、登録を断る
+RESERVED_FIT_TYPE_NAMES: tuple[str, ...] = (CUSTOM_FORMULA_KEYWORD,) + tuple(m.keyword for m in BUILTIN_FIT_MODELS)
+
+
+def builtin_menu_labels() -> list[str]:
+    by_keyword = {m.keyword: m for m in BUILTIN_FIT_MODELS}
+    return [by_keyword[keyword].menu_label for keyword in MENU_ORDER]
+
+
+_RESERVED_FORMULA_NAMES = set(DEFAULT_FUNCTIONS.keys()) | {'x'}
+
+
+def extract_formula_params(formula: str) -> list[str]:
+    """x でも既知の関数名でもない識別子を、出現順にパラメータとして取り出す。"""
+    params = []
+    for name in re.findall(r'[a-zA-Z_][a-zA-Z_0-9]*', formula):
+        if name in _RESERVED_FORMULA_NAMES or name in params:
+            continue
+        params.append(name)
+    if not params:
+        raise ValueError("数式にフィットパラメータ(x以外の文字)が見つかりません。")
+    return params
+
+
+def build_custom_fit_func(formula: str, param_names: list[str]) -> Callable[..., Any]:
+    def custom_func(x: Any, *params: float) -> Any:
+        variables = {'x': x}
+        variables.update(zip(param_names, params))
+        try:
+            return safe_eval_formula(formula, variables)
+        except Exception as e:
+            raise ValueError(f"数式の評価に失敗しました: {e}") from e
+    return custom_func
+
+
+@dataclass
+class ResolvedFitModel:
+    """種類の名前から決まったモデル。param_names はプラグインのときは登録されたリストそのもの。"""
+    param_names: list[str]
+    func: Callable[..., Any]
+    initial_guess: Callable[[Any, Any], list[Any]]
+    check_data: Callable[[Any], None] | None = None
+
+
+def _custom_formula_or_raise(custom_formula: str | None) -> str:
+    if not custom_formula or not custom_formula.strip():
+        raise ValueError("カスタム数式が入力されていません。")
+    return custom_formula
+
+
+_BUILTIN_BY_ID = {m.model_id: m for m in BUILTIN_FIT_MODELS}
+
+
+def _identify(fit_type: str, model_id: str | None,
+              plugin_functions: Mapping[str, dict[str, Any]]) -> tuple[str, Any] | None:
+    """("custom", None) / ("builtin", FitModel) / ("plugin", 名前)。ID が分かればそれを先に使う(表示名が変わっても同じモデル)。"""
+    if model_id:
+        if model_id == CUSTOM_FORMULA_MODEL_ID:
+            return ("custom", None)
+        if model_id in _BUILTIN_BY_ID:
+            return ("builtin", _BUILTIN_BY_ID[model_id])
+        plugin_name = model_id[len(PLUGIN_MODEL_ID_PREFIX):]
+        if model_id.startswith(PLUGIN_MODEL_ID_PREFIX) and plugin_name in plugin_functions:
+            return ("plugin", plugin_name)
+    if fit_type in plugin_functions:
+        return ("plugin", fit_type)
+    if is_custom_formula_type(fit_type):
+        return ("custom", None)
+    for model in BUILTIN_FIT_MODELS:
+        if model.keyword in fit_type:
+            return ("builtin", model)
+    return None
+
+
+def fit_model_id(fit_type: str, plugin_functions: Mapping[str, dict[str, Any]]) -> str | None:
+    found = _identify(fit_type, None, plugin_functions)
+    if found is None:
+        return None
+    kind, target = found
+    if kind == "custom":
+        return CUSTOM_FORMULA_MODEL_ID
+    if kind == "builtin":
+        return str(target.model_id)
+    return PLUGIN_MODEL_ID_PREFIX + target
+
+
+def fit_type_label(fit_result: Mapping[str, Any], default: Any = None) -> Any:
+    """保存したフィット結果の種類の表示名。組み込みは ID から今の表示名を引く(表示名を変えても古いファイルとそろう)。"""
+    model = _BUILTIN_BY_ID.get(fit_result.get('fit_model_id') or "")
+    return model.menu_label if model is not None else fit_result.get('fit_type', default)
+
+
+def resolve_fit_param_names(fit_type: str, custom_formula: str | None,
+                            plugin_functions: Mapping[str, dict[str, Any]], model_id: str | None = None) -> list[str]:
+    """パラメータ名だけを決める(カスタム数式の関数は作らない)。"""
+    found = _identify(fit_type, model_id, plugin_functions)
+    if found is None:
+        raise ValueError(f"不明なフィットタイプ: {fit_type}")
+    kind, target = found
+    if kind == "custom":
+        return extract_formula_params(_custom_formula_or_raise(custom_formula))
+    if kind == "builtin":
+        return list(target.param_names)
+    return list(plugin_functions[target]["params"])
+
+
+def resolve_fit_model(fit_type: str, custom_formula: str | None,
+                      plugin_functions: Mapping[str, dict[str, Any]], model_id: str | None = None) -> ResolvedFitModel:
+    found = _identify(fit_type, model_id, plugin_functions)
+    if found is None:
+        raise ValueError(f"不明なフィットタイプ: {fit_type}")
+    kind, target = found
+    if kind == "custom":
+        params = extract_formula_params(_custom_formula_or_raise(custom_formula))
+        # *params 形式ではパラメータ数を推定できないので p0 で数を伝える
+        return ResolvedFitModel(params, build_custom_fit_func(custom_formula or "", params),
+                                lambda x, y: [1.0] * len(params))
+    if kind == "builtin":
+        return ResolvedFitModel(list(target.param_names), target.func, target.initial_guess, target.check_data)
+    entry = plugin_functions[target]
+    return ResolvedFitModel(entry["params"], entry["func"], _plugin_initial_guess(entry))
+
+
+def _plugin_initial_guess(entry: dict[str, Any]) -> Callable[[Any, Any], list[Any]]:
+    def initial_guess(x: Any, y: Any) -> list[Any]:
+        plugin_p0 = entry["p0"]
+        if callable(plugin_p0):
+            return list(plugin_p0(x, y))
+        if plugin_p0 is not None:
+            return list(plugin_p0)
+        return [1.0] * len(entry["params"])
+    return initial_guess

graphica/core/grid_data.py

@@ -0,0 +1,128 @@
+"""(x, y, z) の点から 2D マップの格子を作る。GUI には依存しない。
+
+(x, y) が完全な格子なら pivot でそのまま並べ(is_regular=True、値を変えない)、そうでなければ griddata で補間する。
+"""
+import numpy as np
+import pandas as pd
+from scipy.interpolate import griddata, RegularGridInterpolator
+from typing import Any
+
+# ドラッグでぴったり水平・垂直には引けないので、各軸の範囲に対するこの割合までは水平・垂直とみなす
+SLICE_AXIS_ALIGNMENT_TOLERANCE = 0.01
+
+GRID_INTERP_METHODS = ('linear', 'cubic', 'nearest')
+
+
+class GridDataError(ValueError):
+    """2D の格子を作れない。"""
+
+
+def is_regular_grid(x: Any, y: Any) -> bool:
+    """x と y の全部の組み合わせが、ちょうど1回ずつあるか。"""
+    unique_x = np.unique(x)
+    unique_y = np.unique(y)
+    if len(unique_x) * len(unique_y) != len(x):
+        return False
+    pairs = set(zip(x.tolist(), y.tolist()))
+    return len(pairs) == len(x)
+
+
+def compute_z_grid(x: Any, y: Any, z: Any, interp_method: str = 'linear',
+                   resolution: tuple[int, int] | list[int] | None = None) -> dict[str, Any]:
+    """{'x_grid', 'y_grid'(ソート済みの1次元), 'z_grid'(shape=(len(y), len(x))、データの無い所は nan), 'is_regular'}。
+
+    resolution=(nx, ny) は補間するときだけ使う(None なら点の数から決める)。interp_method も補間のときだけ。
+    """
+    if interp_method not in GRID_INTERP_METHODS:
+        raise GridDataError(f"不明な補間方法です: {interp_method}")
+
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    z = np.asarray(z, dtype=float)
+
+    valid = ~(np.isnan(x) | np.isnan(y) | np.isnan(z))
+    x, y, z = x[valid], y[valid], z[valid]
+
+    if len(x) == 0:
+        raise GridDataError("有効なデータ点がありません(すべて欠損値です)。")
+
+    if is_regular_grid(x, y):
+        x_grid = np.unique(x)
+        y_grid = np.unique(y)
+        pivot = pd.DataFrame({'x': x, 'y': y, 'z': z}).pivot(index='y', columns='x', values='z')
+        pivot = pivot.reindex(index=y_grid, columns=x_grid)
+        return {
+            'x_grid': x_grid,
+            'y_grid': y_grid,
+            'z_grid': pivot.values,
+            'is_regular': True,
+        }
+
+    if resolution is None:
+        n = max(int(np.sqrt(len(x)) * 2), 10)
+        nx, ny = n, n
+    else:
+        nx, ny = resolution
+        if nx < 2 or ny < 2:
+            raise GridDataError("補間グリッドの解像度は2以上である必要があります。")
+
+    if len(x) < 3:
+        raise GridDataError(
+            "散在データの補間には最低3点が必要です(規則格子ではない点が"
+            f"{len(x)}点しかありません)。"
+        )
+
+    x_grid = np.linspace(x.min(), x.max(), nx)
+    y_grid = np.linspace(y.min(), y.max(), ny)
+    xx, yy = np.meshgrid(x_grid, y_grid)
+    z_grid = griddata((x, y), z, (xx, yy), method=interp_method)
+
+    return {
+        'x_grid': x_grid,
+        'y_grid': y_grid,
+        'z_grid': z_grid,
+        'is_regular': False,
+    }
+
+
+def extract_slice(x_grid: Any, y_grid: Any, z_grid: Any, start: tuple[float, float], end: tuple[float, float],
+                  n_points: int = 200) -> dict[str, Any]:
+    """格子上の線分に沿った断面を返す({'axis_values', 'axis_kind', 'z_values'})。
+
+    axis_kind はほぼ水平なら 'x'、ほぼ垂直なら 'y'、斜めなら 'distance'(始点からの距離)。格子の外は nan。
+    """
+    x0, y0 = float(start[0]), float(start[1])
+    x1, y1 = float(end[0]), float(end[1])
+    if x0 == x1 and y0 == y1:
+        raise GridDataError("始点と終点が同じ位置です(長さ0の線分は抽出できません)。")
+
+    x_grid = np.asarray(x_grid, dtype=float)
+    y_grid = np.asarray(y_grid, dtype=float)
+    z_grid = np.asarray(z_grid, dtype=float)
+
+    x_range = x_grid.max() - x_grid.min() if len(x_grid) > 1 else 1.0
+    y_range = y_grid.max() - y_grid.min() if len(y_grid) > 1 else 1.0
+
+    is_horizontal = abs(y1 - y0) <= SLICE_AXIS_ALIGNMENT_TOLERANCE * (y_range or 1.0)
+    is_vertical = abs(x1 - x0) <= SLICE_AXIS_ALIGNMENT_TOLERANCE * (x_range or 1.0)
+
+    if is_horizontal and not is_vertical:
+        axis_kind = 'x'
+        axis_values = np.linspace(x0, x1, n_points)
+        sample_x, sample_y = axis_values, np.full(n_points, y0)
+    elif is_vertical and not is_horizontal:
+        axis_kind = 'y'
+        axis_values = np.linspace(y0, y1, n_points)
+        sample_x, sample_y = np.full(n_points, x0), axis_values
+    else:
+        axis_kind = 'distance'
+        sample_x = np.linspace(x0, x1, n_points)
+        sample_y = np.linspace(y0, y1, n_points)
+        axis_values = np.sqrt((sample_x - x0) ** 2 + (sample_y - y0) ** 2)
+
+    interpolator = RegularGridInterpolator(
+        (y_grid, x_grid), z_grid, method='linear', bounds_error=False, fill_value=np.nan,
+    )
+    z_values = interpolator(np.column_stack([sample_y, sample_x]))
+
+    return {'axis_values': axis_values, 'axis_kind': axis_kind, 'z_values': z_values}

graphica/core/i18n.py

@@ -0,0 +1,44 @@
+"""簡単な翻訳の仕組み: 日本語の原文をキーに、言語ごとの辞書を引く。
+
+Qt の .ts / .qm は外部のツールが要るので使わない。訳の無い文字列は原文のまま返る。
+対象はメニューや主なボタンなど目に触れる所だけ。言語の切り替えは次の起動から(作った画面は訳し直さない)。
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+SUPPORTED_LANGUAGES = {"ja": "日本語", "en": "English"}
+DEFAULT_LANGUAGE = "ja"
+
+_current_language = DEFAULT_LANGUAGE
+_translations: dict[str, dict[str, str]] = {}  # {言語コード: {原文: 訳文}}
+
+
+def register_translations(lang_code: str, mapping: dict[str, str]) -> None:
+    _translations.setdefault(lang_code, {}).update(mapping)
+
+
+def set_language(lang_code: str) -> None:
+    """対応していない言語なら日本語にする。"""
+    global _current_language
+    if lang_code not in SUPPORTED_LANGUAGES:
+        lang_code = DEFAULT_LANGUAGE
+    _current_language = lang_code
+
+
+def get_language() -> str:
+    return _current_language
+
+
+def tr(text: str) -> str:
+    """日本語のとき、または訳が無いときは原文のまま。"""
+    if _current_language == DEFAULT_LANGUAGE:
+        return text
+    return _translations.get(_current_language, {}).get(text, text)
+
+
+try:
+    from graphica.core.translations_en import TRANSLATIONS as _EN_TRANSLATIONS
+    register_translations("en", _EN_TRANSLATIONS)
+except ImportError:
+    logger.warning("英語翻訳辞書 (core/translations_en.py) の読み込みに失敗しました。")

graphica/core/json_utils.py

@@ -0,0 +1,27 @@
+# core/json_utils.py
+"""
+JSON形式でのプロジェクト保存(.graphica)のための共通ユーティリティ。
+
+numpy のスカラ型(numpy.int64, numpy.float64 等)や ndarray は標準の
+json.JSONEncoder ではそのままシリアライズできない場合があるため、
+これらを素のPython型へ変換する安全網として GraphicaJSONEncoder を提供する。
+プロジェクトデータ中のどこかに numpy スカラが紛れ込んでいても、この
+エンコーダを使う限り個別に洗い出さなくても json.dump が失敗しないようにする。
+"""
+import json
+
+import numpy as np
+from typing import Any
+
+
+class GraphicaJSONEncoder(json.JSONEncoder):
+    """numpy型を素のPython型に変換してからシリアライズするJSONEncoder。"""
+
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super().default(obj)

graphica/core/label_utils.py

@@ -0,0 +1,21 @@
+"""列名から軸ラベルを推測する。"""
+import re
+
+# 「ラベル (単位)」か「ラベル [単位]」。出力は丸括弧にそろえる
+_LABEL_WITH_UNIT_PATTERN = re.compile(r'^(?P<label>.+?)\s*[\(\[](?P<unit>[^()\[\]]+)[\)\]]\s*$')
+
+
+def infer_axis_label_from_column_name(column_name: object) -> str | None:
+    """列名が「ラベル (単位)」の形ならそのラベルを返す('Wavelength[nm]' -> 'Wavelength (nm)')。
+
+    形が合わなければ None(単位の無い列名にラベルをでっちあげない)。
+    """
+    if not isinstance(column_name, str):
+        return None
+    match = _LABEL_WITH_UNIT_PATTERN.match(column_name.strip())
+    if not match:
+        return None
+    label, unit = match.group('label').strip(), match.group('unit').strip()
+    if not label or not unit:
+        return None
+    return f"{label} ({unit})"