@jjlmoya/utils-astronomy 1.35.1 → 1.37.0

package/src/tool/astrophotographyExposureStackPlanner/logic.ts

@@ -0,0 +1,95 @@
+import type {
+  ExposurePlannerInput,
+  ExposurePlannerResult,
+  SensorPreset,
+  TimelineSlice,
+} from './ui';
+
+export const SENSOR_CROP_FACTORS: Record<SensorPreset, number> = {
+  fullFrame: 1,
+  apsC: 1.5,
+  microFourThirds: 2,
+  phone: 2.7,
+};
+
+export const DEFAULT_INPUT: ExposurePlannerInput = {
+  exposureRule: 'npf',
+  sensor: 'fullFrame',
+  focalLength: 24,
+  aperture: 2.8,
+  pixelPitch: 5.9,
+  declination: 0,
+  tracking: 'untracked',
+  trackingExposureSeconds: 120,
+  deadTimeSeconds: 2,
+  totalIntegrationMinutes: 120,
+};
+
+function finiteOr(value: number, fallback: number): number {
+  return Number.isFinite(value) ? value : fallback;
+}
+
+export function normalizeInput(input: ExposurePlannerInput): ExposurePlannerInput {
+  return {
+    ...input,
+    focalLength: Math.min(600, Math.max(5, finiteOr(input.focalLength, DEFAULT_INPUT.focalLength))),
+    aperture: Math.min(32, Math.max(1, finiteOr(input.aperture, DEFAULT_INPUT.aperture))),
+    pixelPitch: Math.min(30, Math.max(0.5, finiteOr(input.pixelPitch, DEFAULT_INPUT.pixelPitch))),
+    declination: Math.min(89, Math.max(0, finiteOr(input.declination, DEFAULT_INPUT.declination))),
+    trackingExposureSeconds: Math.min(900, Math.max(5, finiteOr(input.trackingExposureSeconds, DEFAULT_INPUT.trackingExposureSeconds))),
+    deadTimeSeconds: Math.min(120, Math.max(0, finiteOr(input.deadTimeSeconds, DEFAULT_INPUT.deadTimeSeconds))),
+    totalIntegrationMinutes: Math.min(1440, Math.max(1, finiteOr(input.totalIntegrationMinutes, DEFAULT_INPUT.totalIntegrationMinutes))),
+  };
+}
+
+export function calculateRule500(focalLength: number, sensor: SensorPreset): number {
+  const cropFactor = SENSOR_CROP_FACTORS[sensor];
+  return 500 / (focalLength * cropFactor);
+}
+
+export function calculateNpfSeconds(
+  focalLength: number,
+  aperture: number,
+  pixelPitch: number,
+  declination: number,
+): number {
+  const declinationRadians = declination * (Math.PI / 180);
+  const cosine = Math.max(0.1, Math.cos(declinationRadians));
+  return (16.9 * aperture + 0.1 * focalLength + 13.7 * pixelPitch) / (focalLength * cosine);
+}
+
+export function calculateTimeline(frameCount: number): TimelineSlice[] {
+  const visibleSlices = Math.min(12, Math.max(1, frameCount));
+  return Array.from({ length: visibleSlices }, (_, index) => ({
+    index: index + 1,
+    width: 100 / visibleSlices,
+    isFinal: index === visibleSlices - 1,
+  }));
+}
+
+export function calculateExposurePlan(rawInput: ExposurePlannerInput): ExposurePlannerResult {
+  const input = normalizeInput(rawInput);
+  const npfSeconds = calculateNpfSeconds(input.focalLength, input.aperture, input.pixelPitch, input.declination);
+  const rule500Seconds = calculateRule500(input.focalLength, input.sensor);
+  const untrackedCeilingSeconds = input.exposureRule === 'npf' ? npfSeconds : rule500Seconds;
+  const selectedCeilingSeconds = input.tracking === 'tracked' ? input.trackingExposureSeconds : untrackedCeilingSeconds;
+  const totalSeconds = input.totalIntegrationMinutes * 60;
+  const frameCount = Math.ceil(totalSeconds / selectedCeilingSeconds);
+  const plannedIntegrationMinutes = (frameCount * selectedCeilingSeconds) / 60;
+  const deadTimeMinutes = (frameCount * input.deadTimeSeconds) / 60;
+  const stackingGainStops = Math.log2(frameCount) / 2;
+  const npfDifferencePercent = ((npfSeconds - rule500Seconds) / rule500Seconds) * 100;
+  return {
+    npfSeconds,
+    rule500Seconds,
+    selectedCeilingSeconds,
+    frameCount,
+    plannedIntegrationMinutes,
+    deadTimePerFrameSeconds: input.deadTimeSeconds,
+    deadTimeMinutes,
+    sessionDurationMinutes: plannedIntegrationMinutes + deadTimeMinutes,
+    stackingGainStops,
+    npfDifferencePercent,
+    timeline: calculateTimeline(frameCount),
+  };
+}

package/src/tool/astrophotographyExposureStackPlanner/seo.astro

@@ -0,0 +1,14 @@
+---
+import { SEORenderer } 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 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/astrophotographyExposureStackPlanner/storage.ts

@@ -0,0 +1,22 @@
+import type { ExposurePlannerInput } from './ui';
+
+const STORAGE_KEY = 'jjlmoya-astronomy-exposure-stack-planner';
+
+export function loadExposurePlannerInput(fallback: ExposurePlannerInput): ExposurePlannerInput {
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return fallback;
+    const parsed = JSON.parse(raw) as Partial<ExposurePlannerInput>;
+    return { ...fallback, ...parsed };
+  } catch {
+    return fallback;
+  }
+}
+
+export function saveExposurePlannerInput(input: ExposurePlannerInput): void {
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(input));
+  } catch {
+    return;
+  }
+}

package/src/tool/astrophotographyExposureStackPlanner/ui.ts

@@ -0,0 +1,102 @@
+import type { BibliographyEntry, ToolLocaleContent } from '../../types';
+
+export type ExposureRule = 'npf' | 'rule500';
+export type SensorPreset = 'fullFrame' | 'apsC' | 'microFourThirds' | 'phone';
+export type TrackingMode = 'untracked' | 'tracked';
+
+export interface ExposurePlannerInput {
+  exposureRule: ExposureRule;
+  sensor: SensorPreset;
+  focalLength: number;
+  aperture: number;
+  pixelPitch: number;
+  declination: number;
+  tracking: TrackingMode;
+  trackingExposureSeconds: number;
+  deadTimeSeconds: number;
+  totalIntegrationMinutes: number;
+}
+
+export interface TimelineSlice {
+  index: number;
+  width: number;
+  isFinal: boolean;
+}
+
+export interface ExposurePlannerResult {
+  npfSeconds: number;
+  rule500Seconds: number;
+  selectedCeilingSeconds: number;
+  frameCount: number;
+  plannedIntegrationMinutes: number;
+  deadTimePerFrameSeconds: number;
+  deadTimeMinutes: number;
+  sessionDurationMinutes: number;
+  stackingGainStops: number;
+  npfDifferencePercent: number;
+  timeline: TimelineSlice[];
+}
+
+export interface ExposurePlannerUI {
+  cameraLegend: string;
+  focalLabel: string;
+  focalHelp: string;
+  apertureLabel: string;
+  apertureHelp: string;
+  pixelPitchLabel: string;
+  pixelPitchHelp: string;
+  declinationLabel: string;
+  declinationHelp: string;
+  sensorLabel: string;
+  sensorOptions: Record<SensorPreset, string>;
+  ruleLabel: string;
+  ruleNpf: string;
+  rule500: string;
+  trackingLabel: string;
+  untracked: string;
+  tracked: string;
+  trackingExposureLabel: string;
+  trackingExposureHelp: string;
+  deadTimeLabel: string;
+  deadTimeHelp: string;
+  totalIntegrationLabel: string;
+  totalIntegrationHelp: string;
+  resultTitle: string;
+  resultKicker: string;
+  secondsUnit: string;
+  framesLabel: string;
+  totalTimeLabel: string;
+  sessionTimeLabel: string;
+  gainLabel: string;
+  sessionDetail: string;
+  workloadText: string;
+  highWorkloadText: string;
+  sensorPixelWarning: string;
+  comparisonTitle: string;
+  npfLabel: string;
+  rule500Label: string;
+  deltaLabel: string;
+  timelineTitle: string;
+  timelineStart: string;
+  timelineEnd: string;
+  trackingNote: string;
+  untrackedNote: string;
+  methodTitle: string;
+  methodText: string;
+  limitsTitle: string;
+  limitsText: string;
+  startingStatus: string;
+  formulaLabel: string;
+  formulaNpf: string;
+  formula500: string;
+  presetsLabel: string;
+  presets: Record<string, string>;
+}
+
+export type ExposurePlannerLocaleContent = ToolLocaleContent<ExposurePlannerUI>;
+
+export interface ExposurePlannerBibliographyEntry extends BibliographyEntry {
+  country: string;
+  language: string;
+  supports: string;
+}

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

@@ -129,39 +129,61 @@ function calculateDomeCoords(input: ObservingPlannerInput, evaluation: Evaluatio
   return { peakHour, elev, isAbove, radiantX, radiantY, moonX, moonY };
 }
 
-function getConstellationName(constKey: string, ui?: MeteorShowerObservingPlannerUI): string {
-  if (!ui || !ui.constellations) return constKey;
-  return ui.constellations[constKey] || constKey;
-}
-
 function getStatusText(isAbove: boolean, elev: number, ui?: MeteorShowerObservingPlannerUI): string {
   const alt = ui && ui.altLabel ? ui.altLabel : 'Alt';
   const below = ui && ui.belowHorizonLabel ? ui.belowHorizonLabel : 'Below Horizon';
   return isAbove ? `+${elev}° ${alt}` : below;
 }
 
-export function renderSkyDomeSvg(input: ObservingPlannerInput, evaluation: EvaluationResult, ui?: MeteorShowerObservingPlannerUI): string {
+function getConstellationName(constKey: string, ui?: MeteorShowerObservingPlannerUI): string {
+  if (!ui?.constellations) return constKey;
+  return ui.constellations[constKey] || constKey;
+}
+
+interface DomePresentation {
+  coords: DomeCoords;
+  peakZhr: number;
+  constName: string;
+  statusTxt: string;
+  moonLabelTxt: string;
+  belowHorizonTxt: string;
+  telemetryTitle: string;
+}
+
+function createDomePresentation(
+  input: ObservingPlannerInput,
+  evaluation: EvaluationResult,
+  ui?: MeteorShowerObservingPlannerUI,
+): DomePresentation {
   const shower = getShowerById(input.showerId);
   const coords = calculateDomeCoords(input, evaluation);
   const peakItem = evaluation.hourlyBreakdown.find((h) => h.isPeakHour) || evaluation.hourlyBreakdown[0];
+  const labels = ui ?? {};
+  return {
+    coords,
+    peakZhr: peakItem?.effectiveZhr ?? 0,
+    constName: getConstellationName(shower.radiantConstellation, ui),
+    statusTxt: getStatusText(coords.isAbove, coords.elev, ui),
+    moonLabelTxt: labels.moonLabel ?? 'Moon',
+    belowHorizonTxt: labels.belowHorizonLabel ?? 'Below Horizon',
+    telemetryTitle: labels.radiantTelemetryLabel ?? 'RADIANT TELEMETRY',
+  };
+}
 
+export function renderSkyDomeSvg(input: ObservingPlannerInput, evaluation: EvaluationResult, ui?: MeteorShowerObservingPlannerUI): string {
+  const presentation = createDomePresentation(input, evaluation, ui);
   const moonOpacity = (input.moonPhase * 0.5).toFixed(2);
-  const constName = getConstellationName(shower.radiantConstellation, ui);
-  const statusTxt = getStatusText(coords.isAbove, coords.elev, ui);
-  const moonLabelTxt = ui && ui.moonLabel ? ui.moonLabel : 'Moon';
-  const belowHorizonTxt = ui && ui.belowHorizonLabel ? ui.belowHorizonLabel : 'Below Horizon';
-  const telemetryTitle = ui && ui.radiantTelemetryLabel ? ui.radiantTelemetryLabel : 'RADIANT TELEMETRY';
-
-  const moonParams: MoonGraphicParams = { moonPhase: input.moonPhase, x: coords.moonX, y: coords.moonY, moonTxt: moonLabelTxt };
+  const { coords } = presentation;
+  const moonParams: MoonGraphicParams = { moonPhase: input.moonPhase, x: coords.moonX, y: coords.moonY, moonTxt: presentation.moonLabelTxt };
 
   return `
     <svg class="sky-dome-svg" viewBox="0 0 400 230" role="img" aria-label="Celestial Sky Dome">
       ${renderSkyDomeBackground(moonOpacity)}
       ${renderSkyDomeGrid()}
-      ${renderTelemetryCard(telemetryTitle, constName, statusTxt, coords.isAbove ? '#10b981' : '#f43f5e')}
+      ${renderTelemetryCard(presentation.telemetryTitle, presentation.constName, presentation.statusTxt, coords.isAbove ? '#10b981' : '#f43f5e')}
       ${renderMoonGraphic(moonParams)}
-      ${renderMeteorStreaks(coords.isAbove, peakItem ? peakItem.effectiveZhr : 0, coords.radiantX, coords.radiantY)}
-      ${renderRadiantMarker(coords.isAbove, coords.radiantX, coords.radiantY, belowHorizonTxt)}
+      ${renderMeteorStreaks(coords.isAbove, presentation.peakZhr, coords.radiantX, coords.radiantY)}
+      ${renderRadiantMarker(coords.isAbove, coords.radiantX, coords.radiantY, presentation.belowHorizonTxt)}
     </svg>
   `;
 }