@jjlmoya/utils-astronomy 1.35.1 → 1.36.0

package/src/tool/astrophotographyExposureStackPlanner/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { astrophotographyExposureStackPlanner } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await astrophotographyExposureStackPlanner.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/astrophotographyExposureStackPlanner/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const ASTROPHOTOGRAPHY_EXPOSURE_BIBLIOGRAPHY: BibliographyEntry[] = [
+  {
+    name: 'Societe Astronomique du Havre, La Regle NPF',
+    url: 'https://sahavre.fr/wp/regle-npf-rule/',
+  },
+  {
+    name: 'NASA Science, Astrophotography With Your Smartphone',
+    url: 'https://science.nasa.gov/solar-system/skywatching/night-sky-network/astrophotography-with-your-smartphone/',
+  },
+];

package/src/tool/astrophotographyExposureStackPlanner/component.astro

@@ -0,0 +1,149 @@
+---
+import type { ExposurePlannerUI } from './ui';
+import { DEFAULT_INPUT } from './logic';
+
+interface Props {
+  ui: ExposurePlannerUI;
+}
+
+const { ui } = Astro.props;
+const config = JSON.stringify({ defaults: DEFAULT_INPUT, ui });
+---
+
+<div class="astrophotography-exposure-stack-planner" data-exposure-planner>
+  <form class="exposure-planner-form" onsubmit="return false">
+    <section class="control-rail" aria-label={ui.cameraLegend}>
+      <fieldset class="camera-fields">
+        <legend>{ui.cameraLegend}</legend>
+        <label class="field-control">
+          <span>{ui.focalLabel}</span>
+          <input data-field="focalLength" type="number" min="5" max="600" step="1" value={DEFAULT_INPUT.focalLength} inputmode="decimal" />
+          <small>{ui.focalHelp}</small>
+        </label>
+        <label class="field-control">
+          <span>{ui.apertureLabel}</span>
+          <input data-field="aperture" type="number" min="1" max="32" step="0.1" value={DEFAULT_INPUT.aperture} inputmode="decimal" />
+          <small>{ui.apertureHelp}</small>
+        </label>
+        <label class="field-control">
+          <span>{ui.pixelPitchLabel}</span>
+          <input data-field="pixelPitch" type="number" min="0.5" max="30" step="0.1" value={DEFAULT_INPUT.pixelPitch} inputmode="decimal" />
+          <small>{ui.pixelPitchHelp}</small>
+        </label>
+        <label class="field-control">
+          <span>{ui.declinationLabel}</span>
+          <input data-field="declination" type="number" min="0" max="89" step="1" value={DEFAULT_INPUT.declination} inputmode="decimal" />
+          <small>{ui.declinationHelp}</small>
+        </label>
+      </fieldset>
+
+      <fieldset class="choice-fieldset">
+        <legend>{ui.sensorLabel}</legend>
+        <div class="choice-grid sensor-grid">
+          {Object.entries(ui.sensorOptions).map(([value, label]) => (
+            <button type="button" data-sensor data-value={value} aria-pressed="false">{label}</button>
+          ))}
+        </div>
+      </fieldset>
+
+      <fieldset class="choice-fieldset">
+        <legend>{ui.ruleLabel}</legend>
+        <div class="choice-grid two-up">
+          <button type="button" data-rule data-value="npf" aria-pressed="false">{ui.ruleNpf}</button>
+          <button type="button" data-rule data-value="rule500" aria-pressed="false">{ui.rule500}</button>
+        </div>
+      </fieldset>
+
+      <fieldset class="choice-fieldset">
+        <legend>{ui.trackingLabel}</legend>
+        <div class="choice-grid two-up">
+          <button type="button" data-tracking data-value="untracked" aria-pressed="false">{ui.untracked}</button>
+          <button type="button" data-tracking data-value="tracked" aria-pressed="false">{ui.tracked}</button>
+        </div>
+      </fieldset>
+
+      <fieldset class="timing-fields">
+        <legend>{ui.trackingExposureLabel}</legend>
+        <label class="field-control">
+          <span>{ui.trackingExposureLabel}</span>
+          <input data-field="trackingExposureSeconds" type="number" min="5" max="900" step="5" value={DEFAULT_INPUT.trackingExposureSeconds} inputmode="decimal" />
+          <small>{ui.trackingExposureHelp}</small>
+        </label>
+        <label class="field-control">
+          <span>{ui.deadTimeLabel}</span>
+          <input data-field="deadTimeSeconds" type="number" min="0" max="120" step="1" value={DEFAULT_INPUT.deadTimeSeconds} inputmode="decimal" />
+          <small>{ui.deadTimeHelp}</small>
+        </label>
+      </fieldset>
+
+      <label class="field-control integration-field">
+        <span>{ui.totalIntegrationLabel}</span>
+        <input data-field="totalIntegrationMinutes" type="number" min="1" max="1440" step="5" value={DEFAULT_INPUT.totalIntegrationMinutes} inputmode="decimal" />
+        <small>{ui.totalIntegrationHelp}</small>
+      </label>
+    </section>
+  </form>
+
+  <section class="exposure-result" aria-live="polite">
+    <div class="result-topline">
+      <span class="result-kicker">{ui.resultKicker}</span>
+      <span class="status-pill" data-status data-tone="attention">{ui.startingStatus}</span>
+    </div>
+    <div class="result-heading">
+      <div>
+        <h2>{ui.resultTitle}</h2>
+        <p data-note></p>
+      </div>
+      <div class="hero-output">
+        <strong data-output="ceiling">0.0 s</strong>
+        <span>{ui.secondsUnit}</span>
+      </div>
+    </div>
+
+    <div class="timeline-panel">
+      <div class="timeline-header">
+        <h3>{ui.timelineTitle}</h3>
+        <span><span data-output="frames">0</span> {ui.framesLabel}</span>
+      </div>
+      <div class="timeline" data-timeline></div>
+      <div class="timeline-labels"><span data-output="timeline-start">{ui.timelineStart}</span><span data-output="timeline-end">{ui.timelineEnd}</span></div>
+    </div>
+
+    <div class="metric-strip">
+      <div><span>{ui.totalTimeLabel}</span><strong data-output="total">0.0 min</strong></div>
+      <div><span>{ui.sessionTimeLabel}</span><strong data-output="session">0.0 min</strong></div>
+      <div><span>{ui.gainLabel}</span><strong data-output="gain">0.0 stops</strong></div>
+    </div>
+    <p class="session-detail" data-output="session-detail"></p>
+    <aside class="workload-note" data-workload></aside>
+    <aside class="sensor-warning" data-sensor-warning hidden></aside>
+
+    <section class="comparison-panel">
+      <h3>{ui.comparisonTitle}</h3>
+      <div class="comparison-row"><span>{ui.npfLabel}</span><strong data-output="npf">0.0 s</strong></div>
+      <div class="comparison-row"><span>{ui.rule500Label}</span><strong data-output="rule500">0.0 s</strong></div>
+      <div class="comparison-row"><span>{ui.deltaLabel}</span><strong data-output="delta">0%</strong></div>
+    </section>
+
+    <details class="method-details">
+      <summary>{ui.methodTitle}</summary>
+      <p>{ui.methodText}</p>
+      <p><strong>{ui.formulaLabel}</strong></p>
+      <p>{ui.formulaNpf}</p>
+      <p>{ui.formula500}</p>
+    </details>
+    <aside class="limits-note">
+      <strong>{ui.limitsTitle}</strong>
+      <p>{ui.limitsText}</p>
+    </aside>
+  </section>
+
+  <script is:inline type="application/json" data-planner-config set:html={config}></script>
+</div>
+
+<script>
+  import { mountExposurePlanner } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-exposure-planner]');
+  if (root) mountExposurePlanner(root);
+</script>

package/src/tool/astrophotographyExposureStackPlanner/controller.ts

@@ -0,0 +1,125 @@
+import { calculateExposurePlan, DEFAULT_INPUT } from './logic';
+import { evaluateExposurePlan } from './evaluator';
+import { renderExposureTimeline, updateResultValues } from './dom-views';
+import { loadExposurePlannerInput, saveExposurePlannerInput } from './storage';
+import type { ExposurePlannerInput, ExposurePlannerUI, ExposureRule, SensorPreset, TrackingMode } from './ui';
+
+interface PlannerConfig {
+  defaults: ExposurePlannerInput;
+  ui: ExposurePlannerUI;
+}
+
+function readConfig(root: HTMLElement): PlannerConfig {
+  const script = root.querySelector<HTMLScriptElement>('[data-planner-config]');
+  return JSON.parse(script?.textContent ?? '{}') as PlannerConfig;
+}
+
+function readNumber(root: HTMLElement, field: string, fallback: number): number {
+  const input = root.querySelector<HTMLInputElement>(`[data-field="${field}"]`);
+  return Number(input?.value ?? fallback);
+}
+
+function readInput(root: HTMLElement, activeRule: ExposureRule, activeSensor: SensorPreset, activeTracking: TrackingMode): ExposurePlannerInput {
+  return {
+    exposureRule: activeRule,
+    sensor: activeSensor,
+    tracking: activeTracking,
+    focalLength: readNumber(root, 'focalLength', DEFAULT_INPUT.focalLength),
+    aperture: readNumber(root, 'aperture', DEFAULT_INPUT.aperture),
+    pixelPitch: readNumber(root, 'pixelPitch', DEFAULT_INPUT.pixelPitch),
+    declination: readNumber(root, 'declination', DEFAULT_INPUT.declination),
+    trackingExposureSeconds: readNumber(root, 'trackingExposureSeconds', DEFAULT_INPUT.trackingExposureSeconds),
+    deadTimeSeconds: readNumber(root, 'deadTimeSeconds', DEFAULT_INPUT.deadTimeSeconds),
+    totalIntegrationMinutes: readNumber(root, 'totalIntegrationMinutes', DEFAULT_INPUT.totalIntegrationMinutes),
+  };
+}
+
+function setActive(root: HTMLElement, selector: string, value: string): void {
+  root.querySelectorAll<HTMLElement>(selector).forEach((button) => {
+    button.classList.toggle('is-active', button.dataset.value === value);
+    button.setAttribute('aria-pressed', String(button.dataset.value === value));
+  });
+}
+
+function setStatus(root: HTMLElement, evaluation: ReturnType<typeof evaluateExposurePlan>): void {
+  const status = root.querySelector<HTMLElement>('[data-status]');
+  const note = root.querySelector<HTMLElement>('[data-note]');
+  if (status) {
+    status.textContent = evaluation.status;
+    status.dataset.tone = evaluation.tone;
+  }
+  if (note) note.textContent = evaluation.note;
+}
+
+function render(root: HTMLElement, state: ExposurePlannerInput, ui: ExposurePlannerUI): void {
+  const result = calculateExposurePlan(state);
+  setStatus(root, evaluateExposurePlan(state, result, ui));
+  updateResultValues(root, result, ui);
+  updateContextNotes(root, state, result, ui);
+  renderExposureTimeline(root, result);
+  saveExposurePlannerInput(state);
+}
+
+function updateContextNotes(root: HTMLElement, state: ExposurePlannerInput, result: ReturnType<typeof calculateExposurePlan>, ui: ExposurePlannerUI): void {
+  const workload = root.querySelector<HTMLElement>('[data-workload]');
+  if (workload) {
+    const template = result.frameCount >= 500 ? ui.highWorkloadText : ui.workloadText;
+    workload.textContent = template
+      .replace('{frames}', result.frameCount.toLocaleString('en-US'))
+      .replace('{session}', formatDuration(result.sessionDurationMinutes));
+  }
+  const sensorWarning = root.querySelector<HTMLElement>('[data-sensor-warning]');
+  const hasPixelMismatch = state.sensor === 'apsC' && state.pixelPitch >= 5.5;
+  if (sensorWarning) {
+    sensorWarning.hidden = !hasPixelMismatch;
+    sensorWarning.textContent = hasPixelMismatch
+      ? ui.sensorPixelWarning.replace('{pixel}', `${state.pixelPitch.toFixed(1)} µm`)
+      : '';
+  }
+}
+
+function formatDuration(minutes: number): string {
+  if (minutes < 60) return `${minutes.toFixed(1)} min`;
+  const roundedMinutes = Math.round(minutes);
+  const hours = Math.floor(roundedMinutes / 60);
+  const remainingMinutes = roundedMinutes % 60;
+  return `${hours} h ${remainingMinutes} min`;
+}
+
+function bind(root: HTMLElement, ui: ExposurePlannerUI, initial: ExposurePlannerInput): void {
+  let activeRule = initial.exposureRule;
+  let activeSensor = initial.sensor;
+  let activeTracking = initial.tracking;
+  const refresh = (): void => render(root, readInput(root, activeRule, activeSensor, activeTracking), ui);
+  root.querySelectorAll<HTMLButtonElement>('[data-rule]').forEach((button) => button.addEventListener('click', () => {
+    activeRule = button.dataset.value as ExposureRule;
+    setActive(root, '[data-rule]', activeRule);
+    refresh();
+  }));
+  root.querySelectorAll<HTMLButtonElement>('[data-sensor]').forEach((button) => button.addEventListener('click', () => {
+    activeSensor = button.dataset.value as SensorPreset;
+    setActive(root, '[data-sensor]', activeSensor);
+    refresh();
+  }));
+  root.querySelectorAll<HTMLButtonElement>('[data-tracking]').forEach((button) => button.addEventListener('click', () => {
+    activeTracking = button.dataset.value as TrackingMode;
+    setActive(root, '[data-tracking]', activeTracking);
+    refresh();
+  }));
+  root.querySelectorAll<HTMLInputElement>('[data-field]').forEach((input) => input.addEventListener('input', refresh));
+  setActive(root, '[data-rule]', activeRule);
+  setActive(root, '[data-sensor]', activeSensor);
+  setActive(root, '[data-tracking]', activeTracking);
+  refresh();
+}
+
+export function mountExposurePlanner(root: HTMLElement): void {
+  const config = readConfig(root);
+  const initial = loadExposurePlannerInput(config.defaults);
+  root.querySelectorAll<HTMLInputElement>('[data-field]').forEach((input) => {
+    const field = input.dataset.field as keyof ExposurePlannerInput;
+    const value = initial[field];
+    if (typeof value === 'number') input.value = String(value);
+  });
+  bind(root, config.ui, initial);
+}

package/src/tool/astrophotographyExposureStackPlanner/dom-views.ts

@@ -0,0 +1,41 @@
+import type { ExposurePlannerUI, ExposurePlannerResult } from './ui';
+
+function setText(root: HTMLElement, selector: string, value: string): void {
+  const target = root.querySelector<HTMLElement>(selector);
+  if (target) target.textContent = value;
+}
+
+function formatSeconds(seconds: number): string {
+  return seconds < 10 ? `${seconds.toFixed(1)} s` : `${Math.round(seconds)} s`;
+}
+
+function formatDuration(minutes: number): string {
+  if (minutes < 60) return `${minutes.toFixed(1)} min`;
+  const roundedMinutes = Math.round(minutes);
+  const hours = Math.floor(roundedMinutes / 60);
+  const remainingMinutes = roundedMinutes % 60;
+  return `${hours} h ${remainingMinutes} min`;
+}
+
+export function updateResultValues(root: HTMLElement, result: ExposurePlannerResult, ui: ExposurePlannerUI): void {
+  setText(root, '[data-output="ceiling"]', formatSeconds(result.selectedCeilingSeconds));
+  setText(root, '[data-output="frames"]', result.frameCount.toLocaleString('en-US'));
+  setText(root, '[data-output="total"]', `${result.plannedIntegrationMinutes.toFixed(1)} min`);
+  setText(root, '[data-output="session"]', formatDuration(result.sessionDurationMinutes));
+  setText(root, '[data-output="session-detail"]', ui.sessionDetail
+    .replace('{dead}', formatSeconds(result.deadTimePerFrameSeconds))
+    .replace('{deadTotal}', formatDuration(result.deadTimeMinutes)));
+  setText(root, '[data-output="gain"]', `${result.stackingGainStops.toFixed(1)} stops`);
+  setText(root, '[data-output="npf"]', formatSeconds(result.npfSeconds));
+  setText(root, '[data-output="rule500"]', formatSeconds(result.rule500Seconds));
+  setText(root, '[data-output="delta"]', `${result.npfDifferencePercent >= 0 ? '+' : ''}${result.npfDifferencePercent.toFixed(0)}%`);
+  setText(root, '[data-output="timeline-start"]', ui.timelineStart);
+  setText(root, '[data-output="timeline-end"]', ui.timelineEnd);
+}
+
+export function renderExposureTimeline(root: HTMLElement, result: ExposurePlannerResult): void {
+  const target = root.querySelector<HTMLElement>('[data-timeline]');
+  if (!target) return;
+  const slices = result.timeline.map((slice) => `<span class="exposure-slice${slice.isFinal ? ' is-final' : ''}" style="width:${slice.width}%" aria-label="Frame ${slice.index}"></span>`).join('');
+  target.innerHTML = `<div class="exposure-track" aria-label="${result.frameCount} planned frames">${slices}</div>`;
+}

package/src/tool/astrophotographyExposureStackPlanner/entry.ts

@@ -0,0 +1,29 @@
+import type { AstronomyToolEntry } from '../../types';
+import type { ExposurePlannerLocaleContent, ExposurePlannerUI } from './ui';
+
+export type { ExposurePlannerLocaleContent, ExposurePlannerUI };
+
+export const astrophotographyExposureStackPlanner: AstronomyToolEntry<ExposurePlannerUI> = {
+  id: 'astrophotography-exposure-stack-planner',
+  icons: {
+    bg: 'mdi:camera-iris',
+    fg: 'mdi:timer-outline',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/astrophotographyExposureStackPlanner/evaluator.ts

@@ -0,0 +1,44 @@
+import type { ExposurePlannerInput, ExposurePlannerUI } from './ui';
+import type { ExposurePlannerResult } from './ui';
+
+export type EvaluationTone = 'calm' | 'attention' | 'critical';
+
+export interface ExposureEvaluation {
+  tone: EvaluationTone;
+  status: string;
+  note: string;
+}
+
+function formatSeconds(seconds: number): string {
+  if (seconds < 10) return `${seconds.toFixed(1)} s`;
+  return `${Math.round(seconds)} s`;
+}
+
+function formatDuration(minutes: number): string {
+  if (minutes < 60) return `${minutes.toFixed(1)} min`;
+  const roundedMinutes = Math.round(minutes);
+  const hours = Math.floor(roundedMinutes / 60);
+  const remainingMinutes = roundedMinutes % 60;
+  return `${hours} h ${remainingMinutes} min`;
+}
+
+export function evaluateExposurePlan(
+  input: ExposurePlannerInput,
+  result: ExposurePlannerResult,
+  ui: ExposurePlannerUI,
+): ExposureEvaluation {
+  if (input.tracking === 'tracked') {
+    return {
+      tone: 'calm',
+      status: ui.tracked,
+      note: ui.trackingNote
+        .replace('{ceiling}', formatSeconds(result.selectedCeilingSeconds))
+        .replace('{frames}', result.frameCount.toLocaleString('en-US'))
+        .replace('{session}', formatDuration(result.sessionDurationMinutes)),
+    };
+  }
+  if (result.selectedCeilingSeconds < 2) {
+    return { tone: 'critical', status: ui.untracked, note: ui.untrackedNote.replace('{ceiling}', formatSeconds(result.selectedCeilingSeconds)) };
+  }
+  return { tone: 'attention', status: ui.untracked, note: ui.untrackedNote.replace('{ceiling}', formatSeconds(result.selectedCeilingSeconds)) };
+}

package/src/tool/astrophotographyExposureStackPlanner/i18n/de.ts

@@ -0,0 +1,40 @@
+import { createLocalizedContent } from '../localized';
+
+export const content = createLocalizedContent({
+  slug: 'astrophotografie-belichtungsstapel-planer',
+  title: 'Planer für Belichtungsstapel in der Astrofotografie',
+  description: 'Plane Astrofotografie-Sitzungen mit NPF und der 500er-Regel, Bildzahl, Gesamtintegration und realer Feldzeit.',
+  ui: {
+    cameraLegend: 'Kamerageometrie', focalLabel: 'Brennweite', focalHelp: 'Brennweite von Objektiv oder Teleskop in mm', apertureLabel: 'Blende', apertureHelp: 'Nutze die Blendenzahl, zum Beispiel 2,8', pixelPitchLabel: 'Pixelgröße', pixelPitchHelp: 'Physische Größe des Fotosites in Mikrometern', declinationLabel: 'Deklination des Ziels', declinationHelp: 'Absolute Deklination in Grad', sensorLabel: 'Sensorformat', sensorOptions: { fullFrame: 'Vollformat', apsC: 'APS C', microFourThirds: 'Micro Four Thirds', phone: 'Smartphone Sensor' },
+    ruleLabel: 'Belichtungsgrenze', ruleNpf: 'NPF Formel', rule500: '500er Regel', trackingLabel: 'Montagestatus', untracked: 'Ohne Nachführung', tracked: 'Nachführmontierung', trackingExposureLabel: 'Belichtung pro geführtem Bild', trackingExposureHelp: 'Nur mit Nachführmontierung verwendet. Beginne mit 30 bis 120 s und prüfe Testbilder.', deadTimeLabel: 'Pause zwischen Bildern', deadTimeHelp: 'Beginne mit etwa 2 s und passe Puffer, Speichern und Intervall der Kamera an.', totalIntegrationLabel: 'Gewünschte Gesamtintegration', totalIntegrationHelp: 'Die nutzbare Belichtungszeit, die du sammeln möchtest', resultTitle: 'Dein Aufnahmeplan', resultKicker: 'Ein Ausgangspunkt für die Nacht', secondsUnit: 'pro Bild', framesLabel: 'Bilder', totalTimeLabel: 'Geplante Integration', sessionTimeLabel: 'Geschätzte Feldzeit', gainLabel: 'Idealer Stacking Gewinn', sessionDetail: 'Enthält {dead} zwischen den Bildern: {deadTotal} Intervallzeit.', workloadText: '{frames} Verschlusszyklen. Die Feldschätzung enthält die Pausen zwischen den Bildern.', highWorkloadText: '{frames} Verschlusszyklen. Prüfe elektronischen Verschluss, Akkus und Speicher. Geschätzte Feldzeit: {session}.', sensorPixelWarning: 'Prüfe die Kameradaten: {pixel} ist für APS C eine große Pixelgröße und kann die NPF Grenze verkürzen.', comparisonTitle: 'Zwei Grenzen, eine Entscheidung', npfLabel: 'NPF Grenze', rule500Label: 'Grenze der 500er Regel', deltaLabel: 'NPF Unterschied', timelineTitle: 'Der Stapel als Lichtstreifen', timelineStart: 'erstes Bild', timelineEnd: 'letztes Bild', trackingNote: 'Die Nachführung ist aktiv. Der Plan nutzt {ceiling} pro Bild, also {frames} Bilder und etwa {session} Feldzeit. Prüfe diese Dauer mit Ausrichtung, Guiding und einem Testbild; NPF bleibt die Vergleichsbasis ohne Nachführung.', untrackedNote: 'Nutze {ceiling} als Ausgangsgrenze und prüfe ein Testbild in voller Auflösung auf Sternform und Himmelshelligkeit.', methodTitle: 'So entsteht die Schätzung', methodText: 'Der NPF Weg nutzt Blende, Brennweite, Pixelgröße und Zieldeklination, um sichtbare Sternbewegung auf Pixelebene zu schätzen. Die 500er Regel nutzt nur Brennweite und Sensor Crop. Beide sind geometrische Heuristiken für eine Kamera ohne Nachführung. Mit einer Nachführmontierung verwendet der Plan deine eingestellte Belichtungszeit und zertifiziert die Montierung nicht.', limitsTitle: 'Grenze im Feld', limitsText: 'Nachführung, heller Himmel, ein hochauflösender Ausschnitt, Wind oder Fokusdrift können die praktische Belichtung ändern. Mache ein Testbild und entscheide nach Ecken, Histogramm und Montierungsverhalten.', startingStatus: 'Eingaben werden geprüft', formulaLabel: 'Referenzformeln', formulaNpf: 'NPF: (16,9 x Blende + 0,10 x Brennweite + 13,7 x Pixelgröße) / (Brennweite x cos Deklination).', formula500: '500er Regel: 500 / (Brennweite x Sensor Crop Faktor).', presetsLabel: 'Schnelle Setups', presets: { milkyWay: '24 mm Vollformat', wideAngle: '14 mm Weitwinkel', telephoto: '85 mm Teleobjektiv' },
+  },
+  seo: [
+    { type: 'title', text: 'Warum ein Belichtungsstapel eine Grenze braucht', level: 2 },
+    { type: 'paragraph', html: 'Ein Belichtungsstapel besteht aus getrennten Bildern, die später ausgerichtet und kombiniert werden. So sammelst du mehr Signal, ohne jedes Bild unbrauchbar lang zu belichten. Bei einer festen Kamera werden Sterne durch die scheinbare Himmelsbewegung länglich. Zu kurze Bilder machen die Sitzung dagegen durch Auslösepausen und Leserauschen ineffizient.' },
+    { type: 'paragraph', html: 'Der Planer macht daraus einen konkreten Aufnahmeablauf. Er zeigt NPF und die 500er Regel, teilt die gewünschte Integration in vollständige Bilder und rechnet die Pause zwischen Dateien in die Feldzeit ein. Das letzte Bild kann die gewünschte Zeit leicht überschreiten, weil keine Teilaufnahme möglich ist.' },
+    { type: 'list', items: ['Nutze NPF mit bekannter Blende und Pixelgröße.', 'Vergleiche die 500er Regel als schnelle Sensorberechnung.', 'Behandle die Bildzahl als echte Last für Speicher und Nachbearbeitung.', 'Mache vor dem kompletten Stapel ein Testbild.'] },
+    { type: 'tip', title: 'Eine Grenze ist keine Garantie', html: 'Prüfe helle Sterne und Bildecken in voller Auflösung. Wind, Koma, Fokusdrift und Vibration können stärker zählen als eine Formel.' },
+    { type: 'title', text: 'NPF und 500er Regel beantworten verschiedene Fragen', level: 2 },
+    { type: 'paragraph', html: 'Die 500er Regel ist schnell und bezieht den Crop Faktor des Sensors ein. Sie kennt Pixelgröße, Blende und Deklination nicht. NPF ergänzt diese Werte und ist dadurch stärker an Kamera und Ziel angepasst, bleibt aber eine Heuristik für eine Kamera ohne Nachführung.' },
+    { type: 'title', text: 'So wird das Ergebnis zu einer Nachtsitzung', level: 2 },
+    { type: 'paragraph', html: 'Trage die echten Werte des verwendeten Objektivs und Sensors ein. Verwende keine äquivalente Brennweite, wenn Brennweite und Sensorformat bereits getrennt erfasst sind. Bei der Pixelgröße sollte eine zuverlässige Modellspezifikation die Grundlage sein.' },
+    { type: 'list', items: ['Prüfe ein Testbild an den Ecken mit voller Auflösung.', 'Kontrolliere Histogramm und ausgebrannte Lichter.', 'Halte Fokus und Aufnahmeparameter konstant.', 'Plane Zeit für Dunkelbilder und Kalibrierung ein.'] },
+    { type: 'title', text: 'Was sich bei einer Nachführmontierung ändert', level: 2 },
+    { type: 'paragraph', html: 'Bei aktivierter Nachführung nutzt das Tool die eingegebene Belichtungsdauer pro Bild. NPF und 500er Regel bleiben als Vergleichswerte ohne Nachführung sichtbar, bestimmen aber nicht mehr die Bildzahl. Polausrichtung, periodischer Fehler, Guiding, Wind, Himmelshelligkeit und Sättigung können die neue Grenze bilden.' },
+    { type: 'tip', title: 'Erst testen, dann den ganzen Stapel aufnehmen', html: 'Nimm eine kurze Testserie auf, vergrößere die Ecken und prüfe die Sterne. Passe die geführte Belichtung an, bevor du zwei Stunden dunklen Himmel bindest.' },
+    { type: 'paragraph', html: 'Ein Beispiel zeigt den Unterschied: Bei 35 mm, APS C, 5,9 Mikrometern und 5 Grad Deklination liegt die NPF Grenze bei rund 3,8 Sekunden. Ohne Nachführung entstehen für zwei Stunden ungefähr 1.907 Bilder. Mit einer Nachführmontierung und 120 Sekunden pro Bild reichen dagegen 60 Bilder; fünf Sekunden Pause pro Bild verlängern die Feldzeit nur um fünf Minuten.' },
+    { type: 'paragraph', html: 'Beurteile die Feldzeit getrennt von der reinen Integrationszeit. Speicherpausen, Fokusprüfung, Dithering, Akkuwechsel und verworfene Bilder gehören in die Nachtplanung, auch wenn sie nicht zum Signal beitragen. Bei vielen kurzen Bildern kann ein elektronischer Verschluss die mechanische Belastung verringern, ersetzt aber keine Kontrolle von Puffer und Speicherkapazität.' },
+    { type: 'tip', title: 'Pixelgröße und Sensorformat prüfen', html: 'APS C mit 5,9 Mikrometern ist eine ungewöhnliche Kombination für moderne hochauflösende Kameras. Wenn die echte Pixelgröße kleiner ist, fällt die NPF Grenze kürzer aus. Prüfe deshalb das Kameramodell und mache immer eine Testaufnahme, bevor du die komplette Serie startest.' },
+  ],
+  faq: [
+    { question: 'Soll ich NPF oder die 500er Regel nutzen?', answer: 'Nutze NPF als kameranäheren Ausgangspunkt, wenn Blende und Pixelgröße bekannt sind. Die 500er Regel ist ein schneller Vergleich. Prüfe beide Ergebnisse mit einem Testbild.' },
+    { question: 'Was enthält die Bildzahl?', answer: 'Sie zählt vollständige Lichtbilder, die nötig sind, um die gewünschte Integration zu erreichen oder leicht zu überschreiten. Dunkelbilder, Flats, Bias, Pausen und Ausschuss sind nicht enthalten.' },
+    { question: 'Berechnet der Nachführmodus die Guiding Genauigkeit?', answer: 'Nein. Er verwendet deine eingegebene Belichtungsdauer. Ausrichtung, Guiding und Himmelshelligkeit müssen mit echten Testbildern geprüft werden.' },
+  ],
+  howTo: [
+    { name: 'Kamerageometrie eingeben', text: 'Trage Brennweite, Blende, Pixelgröße und Deklination des Ziels ein.' },
+    { name: 'Methode wählen', text: 'Wähle ohne Nachführung NPF oder 500er Regel, oder aktiviere die Nachführung und setze die Bilddauer.' },
+    { name: 'Integration festlegen', text: 'Gib die nutzbare Gesamtzeit ein und prüfe Bildzahl und Feldzeit.' },
+    { name: 'Im Feld validieren', text: 'Nimm ein Testbild auf, prüfe Sterne und Histogramm und passe die Serie an.' },
+  ],
+});