From 1caa8d2a6607961fe3ece894927279a5b41b435d Mon Sep 17 00:00:00 2001 From: Jheison Martinez Bolivar Date: Mon, 16 Nov 2026 18:26:34 -0500 Subject: [PATCH 1/2] test(metrics): check every metric against reference values from the literature --- tests/metrics/test_reference_values.py | 268 +++++++++++++++++++++++++ 1 file changed, 268 insertions(+) create mode 100644 tests/metrics/test_reference_values.py diff --git a/tests/metrics/test_reference_values.py b/tests/metrics/test_reference_values.py new file mode 100644 index 0000000..0429c73 --- /dev/null +++ b/tests/metrics/test_reference_values.py @@ -0,0 +1,268 @@ +"""Reference-value tests for every metric the benchmark reports. + +Each expected value comes from the published definition of the metric or +from a closed-form result computed here, never from the output of the code +under test. A silent change in what a metric means therefore fails a test. + +Sources are named beside the value they justify: + +* source matching, completeness, purity: one-to-one nearest-neighbour + matching, expectations read off hand-built catalogues (construction); +* photometric accuracy: relative flux error and the magnitude offset + ``-2.5 log10(f)``, both closed form; +* PSNR: ``10 log10(range^2 / MSE)``, closed form (Gonzalez & Woods, 3rd + ed., 2008, ch. 3); +* SSIM: Wang et al. (2004), "Image quality assessment: from error + visibility to structural similarity", IEEE TIP 13(4), 600-612; +* sky noise: sigma of a seeded Gaussian, recovered with Astropy's + sigma-clipped statistics. +""" + +import numpy as np +import pytest +from scipy.ndimage import gaussian_filter, uniform_filter +from skimage.metrics import structural_similarity as skimage_ssim + +from astro_denoise.metrics import ( + completeness, + completeness_vs_mag, + photometric_accuracy, + psnr, + purity, + sky_sigma, + ssim, +) +from astro_denoise.metrics.metrics import match_catalogs + + +def cat(x, y, flux=None, mag=None): + """Catalog as a dict of arrays; photometric columns are optional.""" + catalog = {"x": np.asarray(x, dtype=float), "y": np.asarray(y, dtype=float)} + if flux is not None: + catalog["flux"] = np.asarray(flux, dtype=float) + if mag is not None: + catalog["mag"] = np.asarray(mag, dtype=float) + return catalog + + +# A[i, j] = (8 i + j) % 7 spans 0..6, so data_range = 6. Two pixels move. +PAIR_A = np.fromfunction(lambda i, j: (8 * i + j) % 7, (8, 8), dtype=float) +PAIR_B = PAIR_A.copy() +PAIR_B[3, 3] += 2.0 +PAIR_B[6, 1] -= 1.5 +PAIR_RANGE = 6.0 + + +def _ssim_uniform(x, y, win=7, data_range=PAIR_RANGE): + """SSIM with a uniform window, independent of the library under test. + + Mirrors the scikit-image default for this image size: 7x7 uniform + window, sample covariance ``N / (N - 1)``, constants + ``C1 = (K1 L)^2``, ``C2 = (K2 L)^2`` with K1 = 0.01, K2 = 0.03 + (Wang et al. 2004), and the border cropped by ``pad = (win - 1) // 2``. + """ + npix = win * win + cov_norm = npix / (npix - 1) + c1 = (0.01 * data_range) ** 2 + c2 = (0.03 * data_range) ** 2 + ux = uniform_filter(x, size=win) + uy = uniform_filter(y, size=win) + uxx = cov_norm * (uniform_filter(x * x, size=win) - ux * ux) + uyy = cov_norm * (uniform_filter(y * y, size=win) - uy * uy) + uxy = cov_norm * (uniform_filter(x * y, size=win) - ux * uy) + numerator = (2 * ux * uy + c1) * (2 * uxy + c2) + denominator = (ux * ux + uy * uy + c1) * (uxx + uyy + c2) + pad = (win - 1) // 2 + return float((numerator / denominator)[pad:-pad, pad:-pad].mean()) + + +def _ssim_wang(x, y, sigma=1.5, truncate=10 / 3, data_range=PAIR_RANGE): + """SSIM with the window and constants of Wang et al. (2004). + + Sigma = 1.5 (``truncate = 10 / 3`` gives an 11x11 window), Gaussian + weights normalised to unit sum so the weighted covariance is the + population one, K1 = 0.01, K2 = 0.03. The paper leaves border handling + open; this implementation pads by reflection and averages the full map. + """ + c1 = (0.01 * data_range) ** 2 + c2 = (0.03 * data_range) ** 2 + + def smooth(image): + return gaussian_filter(image, sigma=sigma, truncate=truncate, mode="reflect") + + ux = smooth(x) + uy = smooth(y) + uxx = smooth(x * x) - ux * ux + uyy = smooth(y * y) - uy * uy + uxy = smooth(x * y) - ux * uy + numerator = (2 * ux * uy + c1) * (2 * uxy + c2) + denominator = (ux * ux + uy * uy + c1) * (uxx + uyy + c2) + return float((numerator / denominator).mean()) + + +class TestMatchConstruction: + def test_detection_within_radius_of_two_truth(self): + # Nearest-neighbour by construction: det at (10, 10) is 1 px from + # truth 0 and 1.5 px from truth 1, so only the closer one may match. + det = cat([10.0], [10.0]) + truth = cat([9.0, 11.5], [10.0, 10.0]) + det_idx, truth_idx = match_catalogs(det, truth, radius=2.0) + np.testing.assert_array_equal(det_idx, [0]) + np.testing.assert_array_equal(truth_idx, [0]) + + def test_exactly_at_radius(self): + # The locked scipy 1.18.0 treats distance_upper_bound as strict: a + # neighbour at exactly that distance comes back as inf. Its + # cKDTree.query docstring only promises "within this distance", so + # this pins the behaviour of the pinned scipy rather than a wider + # contract: a source exactly at the radius is not matched, one just + # inside it is. + det = cat([10.0], [10.0]) + at_radius = cat([12.0], [10.0]) + det_idx, truth_idx = match_catalogs(det, at_radius, radius=2.0) + assert det_idx.size == 0 + assert truth_idx.size == 0 + + just_inside = cat([11.999], [10.0]) + det_idx, truth_idx = match_catalogs(det, just_inside, radius=2.0) + assert det_idx.size == 1 + assert truth_idx.size == 1 + + def test_empty_detection_catalog(self): + det_idx, truth_idx = match_catalogs(cat([], []), cat([1.0], [1.0]), radius=2.0) + assert det_idx.size == 0 + assert truth_idx.size == 0 + + def test_empty_truth_catalog(self): + det_idx, truth_idx = match_catalogs(cat([1.0], [1.0]), cat([], []), radius=2.0) + assert det_idx.size == 0 + assert truth_idx.size == 0 + + +class TestCompletenessPurityRatios: + def test_plain_ratios(self): + # 5 truth sources, 3 recovered, 4 detections -> 3/5 and 3/4. + truth = cat([10, 20, 30, 40, 50], [10, 20, 30, 40, 50]) + det = cat([10.0, 20.0, 30.0, 99.0], [10.0, 20.0, 30.0, 99.0]) + assert completeness(det, truth, radius=1.0) == pytest.approx(3 / 5) + assert purity(det, truth, radius=1.0) == pytest.approx(3 / 4) + + def test_vs_mag_counts_per_bin(self): + # Mags -10, -8, -7, -6 fall in [-11, -5); mag -2 in [-5, 0). + # Detections recover the first, second and fourth truth source. + mags = np.array([-10.0, -8.0, -7.0, -6.0, -2.0]) + fluxes = 10 ** (-0.4 * mags) + xy = np.arange(10.0, 60.0, 10.0) + truth = cat(xy, xy, flux=fluxes, mag=mags) + det = cat([10.0, 20.0, 40.0], [10.0, 20.0, 40.0]) + + bins = [-11.0, -5.0, 0.0] + curve = completeness_vs_mag(det, truth, mag_bins=bins, radius=1.0) + + # By construction: [-11, -5) holds four truth sources of which three + # are recovered, and [-5, 0) holds one of which none is. + np.testing.assert_array_equal(curve["n_truth"], [4, 1]) + np.testing.assert_array_equal(curve["n_recovered"], [3, 0]) + np.testing.assert_array_equal(curve["completeness"], [3 / 4, 0.0]) + + # Cross-check the same counts from the matching primitive and the + # binned histogram, independently of the curve's own bookkeeping. + _, truth_idx = match_catalogs(det, truth, radius=1.0) + recovered = np.zeros(mags.size, dtype=bool) + recovered[truth_idx] = True + n_truth, _ = np.histogram(mags, bins=bins) + n_recovered, _ = np.histogram(mags[recovered], bins=bins) + + np.testing.assert_array_equal(curve["n_truth"], n_truth) + np.testing.assert_array_equal(curve["n_recovered"], n_recovered) + np.testing.assert_array_equal(curve["completeness"], n_recovered / n_truth) + + +class TestPhotometricReference: + def test_constant_factor_bias(self): + # Closed form: relative flux error is factor - 1 and the magnitude + # offset is -2.5 log10(factor), with zero scatter. + truth_flux = np.array([100.0, 200.0, 300.0, 400.0, 500.0, 600.0]) + pos = np.arange(6.0) * 10.0 + truth = cat(pos, pos, flux=truth_flux) + det = cat(pos, pos, flux=truth_flux * 1.25) + result = photometric_accuracy(det, truth, radius=1.0) + assert result["n_matched"] == 6 + assert result["flux_bias"] == pytest.approx(0.25) + assert result["mag_bias"] == pytest.approx(-2.5 * np.log10(1.25)) + assert result["flux_scatter"] == pytest.approx(0.0, abs=1e-12) + + def test_gaussian_scatter(self): + # Relative flux errors drawn N(0, 0.05): the robust scatter + # 1.4826 * MAD estimates the Gaussian sigma (Hampel 1974; the + # Gaussian-consistency constant is 1.4826 = 1/Phi^-1(0.75)). + rng = np.random.default_rng(42) + sigma = 0.05 + n_src = 1000 + truth_flux = np.full(n_src, 1000.0) + rel_err = rng.normal(0.0, sigma, n_src) + pos = np.arange(n_src, dtype=float) + truth = cat(pos, pos, flux=truth_flux) + det = cat(pos, pos, flux=truth_flux * (1.0 + rel_err)) + result = photometric_accuracy(det, truth, radius=1.0) + assert result["n_matched"] == n_src + assert abs(result["flux_bias"]) < 0.008 + assert result["flux_scatter"] == pytest.approx(sigma, rel=0.15) + + +class TestPsnrClosedForm: + def test_equals_10log10_range_squared_over_mse(self): + # Closed form (Gonzalez & Woods 2008, ch. 3): range = 4, constant + # error 0.1 gives MSE = 0.01, so PSNR = 10 log10(16 / 0.01) dB. + original = np.linspace(0.0, 4.0, 64).reshape(8, 8) + denoised = original + 0.1 + data_range = original.max() - original.min() + mse = np.mean((original - denoised) ** 2) + expected = 10.0 * np.log10(data_range**2 / mse) + assert expected == pytest.approx(32.04119982655924) + assert psnr(original, denoised) == pytest.approx(expected, abs=1e-12) + + +class TestSsimReference: + def test_identity_is_one(self): + # Wang et al. (2004): identical images give SSIM = 1 everywhere. + assert ssim(PAIR_A, PAIR_A) == pytest.approx(1.0) + + def test_default_window_is_pinned(self): + # scikit-image defaults for an 8x8 image: 7x7 uniform window, + # sample covariance, K1 = 0.01, K2 = 0.03. Value from the + # independent uniform-window implementation, equal to the library. + library = skimage_ssim(PAIR_A, PAIR_B, data_range=PAIR_RANGE) + assert library == pytest.approx(0.9851537881821366, abs=1e-9) + assert ssim(PAIR_A, PAIR_B) == pytest.approx(library, abs=1e-12) + assert ssim(PAIR_A, PAIR_B) == pytest.approx(_ssim_uniform(PAIR_A, PAIR_B), abs=1e-9) + + def test_wang2004_differs_bounded(self): + # Wang et al. (2004) uses an 11x11 Gaussian window with sigma 1.5; + # on this pair it must differ from the library default, and the + # difference must stay small (the two are related definitions). + expected_wang = 0.98872677215362 + wang = _ssim_wang(PAIR_A, PAIR_B) + assert wang == pytest.approx(expected_wang, abs=1e-9) + library = ssim(PAIR_A, PAIR_B) + assert 1e-4 < abs(library - wang) < 0.02 + + +class TestSkyNoiseReference: + def test_recovers_sigma(self): + # Pure Gaussian sky N(0, 3): sigma-clipped std recovers sigma. + rng = np.random.default_rng(7) + image = rng.normal(0.0, 3.0, size=(256, 256)) + assert sky_sigma(image) == pytest.approx(3.0, rel=0.05) + + def test_sources_masked_do_not_move_sigma(self): + # Masking the source footprints leaves the same sky pixels, so the + # measured sigma is unchanged by the presence of sources. + rng = np.random.default_rng(7) + sky = rng.normal(0.0, 3.0, size=(256, 256)) + image = sky.copy() + mask = np.zeros(sky.shape, dtype=bool) + for cx, cy in [(40, 40), (90, 90)]: + image[cy - 4 : cy + 5, cx - 4 : cx + 5] += 200.0 + mask[cy - 4 : cy + 5, cx - 4 : cx + 5] = True + assert sky_sigma(image, mask=mask) == pytest.approx(sky_sigma(sky), rel=0.03) From 471737e7c6c03cab6fec959c9d78caae8f8defe6 Mon Sep 17 00:00:00 2001 From: Jheison Martinez Bolivar Date: Mon, 16 Nov 2026 19:21:50 -0500 Subject: [PATCH 2/2] docs(metrics): document each metric with its published sources and departures --- docs/metrics.md | 284 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 281 insertions(+), 3 deletions(-) diff --git a/docs/metrics.md b/docs/metrics.md index a84980f..37228fa 100644 --- a/docs/metrics.md +++ b/docs/metrics.md @@ -7,6 +7,286 @@ mide cómo un método de denoising afecta la **recuperación de fuentes** (completitud/pureza contra catálogo truth) además de métricas clásicas de calidad de imagen (PSNR, SSIM, σ_sky). +## Convenciones + +- Los catálogos son indexables por columna y usan `x`, `y` en coordenadas de + píxel, `flux` en unidades de la imagen y `mag` opcional. Las distancias de + emparejamiento son euclídeas en píxeles. +- Si un catálogo no tiene `mag`, la magnitud se deriva como + `m = -2.5·log10(flux)` solo cuando `flux > 0`; en otro caso la magnitud es + indefinida. +- `N_det`, `N_truth` y `N_match` son los números de detecciones, fuentes truth + y pares aceptados por el emparejamiento. `NaN` significa métrica indefinida + (por ejemplo, denominador cero), no un valor válido de cero. +- `r` es el radio de emparejamiento en píxeles. `match_catalogs`, `completeness` + y `purity` lo exigen como argumento; `photometric_accuracy`, + `completeness_vs_mag` y `detection_rate` usan 2.0 px por defecto, y el CLI usa + `--radius` con 2.0 px por defecto. + +## 1. Emparejamiento de catálogos + +### Definición + +`match_catalogs` empareja cada detección con la fuente truth más cercana. +Para cada detección `i` se busca la fuente truth `j` que minimiza la +distancia euclídea; el par es candidato solo si `d_ij < r`. Los candidatos se +ordenan por distancia creciente y se aceptan de forma codiciosa mientras ambos +índices sigan libres, de modo que cada detección y cada fuente truth participan +en a lo sumo un par. + +```text +d_ij = sqrt((x_det_i - x_truth_j)^2 + (y_det_i - y_truth_j)^2) +par (i, j) aceptado si d_ij < r, i no usado y j no usado; +asignación greedy por d_ij creciente +``` + +### Fuentes + +- [2] ComEst estima la completitud a partir de la tasa de detección de fuentes + sintéticas y la pureza comparando el catálogo detectado con el catálogo de + entrada de las fuentes simuladas. +- [4] Roscani et al. evalúan métodos de denoising mediante la completitud y la + pureza de los catálogos extraídos después del denoising. + +### Desviaciones + +- `r` es un parámetro libre: 2.0 px por defecto donde la API lo permite y + `--radius` en el CLI. +- El límite es estricto: una distancia exactamente igual a `r` px no forma par + porque la búsqueda usa `distance_upper_bound` de SciPy. +- El algoritmo es greedy por distancia tras buscar el vecino truth más cercano + de cada detección; no resuelve empates ni ambigüedades más allá del orden por + distancia. +- Si el vecino truth más cercano de una detección ya fue usado, la detección no + se reempareja con el siguiente vecino dentro de `r`. + +## 2. Completitud + +### Definición + +`completeness` es la fracción de fuentes truth recuperadas por el catálogo de +detecciones usando el emparejamiento uno-a-uno de la sección anterior. +`completeness_vs_mag` aplica la misma fracción dentro de bins de magnitud del +truth; un bin sin fuentes truth devuelve `NaN`. + +```text +C = N_match / N_truth (NaN si N_truth = 0) +``` + +### Fuentes + +- [2] ComEst deriva la completitud como tasa de detección de fuentes + sintéticas en función de flujo/magnitud y posición sobre imágenes CCD. +- [4] Roscani et al. miden la completitud de catálogos extraídos después de + aplicar algoritmos de denoising. +- [3] El LSST DESC DC2 Simulated Sky Survey aporta el marco de cielo simulado y + productos de imagen/catálogo sobre el que puede definirse una verdad de + referencia. + +### Desviaciones + +- No hay inyección de fuentes en esta métrica: el truth se toma como dado y la + completitud escalar no modela la tasa frente a flujo, posición o ruido; solo + `completeness_vs_mag` binnea por magnitud. +- No se aplica corrección por matches casuales ni por fuentes fuera del campo. +- Para derivar magnitudes desde `flux` se usa `m = -2.5·log10(flux)`; si + `flux <= 0` la magnitud es `NaN`. + +## 3. Pureza + +### Definición + +`purity` es la fracción de detecciones que corresponden a una fuente truth +dentro del radio de emparejamiento. + +```text +P = N_match / N_det (NaN si N_det = 0) +``` + +### Fuentes + +- [2] ComEst estima la pureza comparando el catálogo de fuentes detectadas con + el catálogo de entrada de las fuentes simuladas. +- [4] Roscani et al. reportan la pureza de los catálogos obtenidos tras + denoising imágenes simuladas y reales. + +### Desviaciones + +- No hay estimación de falsos positivos basada en ruido: la pureza es solo + catálogo contra truth. NoiseChisel [5] sí estima falsos positivos usando el + ruido ambiental como referencia. +- Una detección espuria que caiga dentro de `r` de una fuente truth puede contar + como emparejada y por tanto como pura; el radio controla esa contaminación. +- Solo es comparable entre métodos cuando la profundidad de detección está + fijada, por ejemplo con `--thresh-image`; sin ella cada método usa su propio + RMS de fondo y `N_det` no es comparable. + +## 4. Exactitud fotométrica + +### Definición + +`photometric_accuracy` usa los pares aceptados por el emparejamiento y compara +los flujos detectado y truth. Solo entran pares con `flux_truth` finito y +positivo y `flux_det` finito. + +```text +rel_i = (F_det_i - F_truth_i) / F_truth_i +bias_flux = median(rel) +MAD(rel) = median(|rel - median(rel)|) +scatter_flux = 1.4826 * MAD(rel) + +dmag_i = -2.5 * log10(F_det_i / F_truth_i) (solo si F_det_i > 0) +bias_mag = median(dmag) +scatter_mag = 1.4826 * MAD(dmag) +``` + +### Fuentes + +- [4] Roscani et al. evalúan la capacidad de los métodos de denoising para + preservar los flujos y las formas de los objetos. +- [6] Huang et al. caracterizan la precisión fotométrica del pipeline HSC, + incluyendo dispersión estadística en magnitud para estrellas y galaxias + sintéticas. + +### Desviaciones + +- La dispersión es `1.4826 * MAD`, no la desviación estándar ni una sigma + ajustada por un modelo. +- El sesgo es la mediana del error relativo, no la media ni una pendiente de + calibración. +- Las estadísticas de magnitud solo usan detecciones con `F_det > 0`; los pares + con flujo detectado no positivo siguen entrando en las estadísticas de flujo. +- Si el catálogo detectado está en ADU instrumentales y el truth DC2 está en + nJy, los biases absolutos no son interpretables; solo las dispersiones + relativas tienen significado. + +## 5. PSNR + +### Definición + +`psnr` compara la imagen denoiseada con la referencia sin ruido +`--original`/`original`. Usa el error cuadrático medio y el rango dinámico de +la referencia. + +```text +MSE = mean((I_ref - I_dn)^2) +R = nanmax(I_ref) - nanmin(I_ref) (si R <= 0, se usa R = 1) +PSNR = 10 * log10(R^2 / MSE) +``` + +Si `MSE = 0`, PSNR es infinito. + +### Fuentes + +- [8] Huynh-Thu & Ghanbari discuten el ámbito de validez de PSNR en la + evaluación de calidad de imagen/vídeo. +- [9] Hore & Ziou comparan PSNR y SSIM como métricas de calidad de imagen. + +### Desviaciones + +- El rango dinámico `R` es `max - min` de la imagen de referencia, no un valor + fijo como 255 u 1.0; por eso los PSNR de imágenes con rangos distintos no + son directamente comparables. +- Se usan los píxeles en bruto, sin máscara de fuentes ni whitening del ruido. +- Se mantiene a pesar de las cautelas de [8] porque es un diagnóstico pixel-wise + estándar y complementario a las métricas científicas. + +## 6. SSIM + +### Definición + +`ssim` usa `skimage.metrics.structural_similarity` con el mismo rango dinámico +`R` que PSNR. Para cada posición válida se combinan medias, varianzas y +covarianza locales de la referencia y la imagen denoiseada; el resultado es la +media del mapa SSIM tras recortar el borde. + +```text +SSIM = mean_valid [ (2 mu_x mu_y + C1)(2 sigma_xy + C2) + / ((mu_x^2 + mu_y^2 + C1)(sigma_x^2 + sigma_y^2 + C2)) ] +C1 = (0.01 R)^2, C2 = (0.03 R)^2 +``` + +### Fuentes + +- [10] Wang et al. definen SSIM a partir de luminancia, contraste y estructura + con una ventana local y constantes `K1 = 0.01`, `K2 = 0.03`. +- [9] Hore & Ziou comparan PSNR y SSIM para evaluar calidad de imagen. + +### Desviaciones + +- La ventana es la de scikit-image por defecto: 7×7 uniforme, no la ventana + gaussiana 11×11 con `sigma = 1.5` de Wang et al. [10]. +- Se usa covarianza muestral y se recorta el borde según los valores por + defecto de scikit-image. +- Las constantes `K1`/`K2` siguen la formulación de [10], pero el rango `R` es + el `max - min` de la referencia, igual que en PSNR. + +## 7. Ruido de fondo + +### Definición + +`sky_sigma` estima el ruido residual del fondo como la desviación estándar de +los píxeles que sobreviven al recorte iterativo sigma-clipped de +`astropy.stats.sigma_clipped_stats` con `sigma = 3.0` y `maxiters = 5`. El +argumento `mask` excluye píxeles donde `mask = True`. En el CLI la máscara se +construye con `source_mask`, es decir, las fuentes detectadas dilatadas. + +```text +sigma_sky = std_sigma_clipped(image; mask, sigma = 3.0, maxiters = 5) +``` + +### Fuentes + +- [1] SExtractor es la referencia clásica de extracción y medida de fuentes en + imágenes astronómicas, donde el fondo y el ruido condicionan la detección. +- [5] NoiseChisel usa el ruido ambiental como referencia para estimar y restar + falsos positivos en la detección de objetos nebulosos. + +### Desviaciones + +- Es un único sigma global, no una malla espacial de fondo ni una estimación + local por región. +- En el CLI la máscara son las detecciones dilatadas (`source_mask`, + `dilate = 3`), no una máscara manual ni una estimación de fondo por bloques. +- `background_rms` es una estadística distinta usada para anclar `--thresh` con + `--thresh-image` (SEP `globalrms`, con fallback sigma-clipped); no es lo + mismo que `sky_sigma`. + +## Referencias + +1. E. Bertin & S. Arnouts, “SExtractor: Software for source extraction,” + Astronomy & Astrophysics Supplement Series 117, 393–404 (1996). + [DOI](https://doi.org/10.1051/aas:1996164). +2. I.-N. Chiu, S. Desai & J. Liu, “ComEst: A Completeness Estimator of Source + Extraction on Astronomical Imaging,” Astronomy and Computing (2016), + arXiv:1605.02650. [DOI](https://doi.org/10.1016/j.ascom.2016.04.005). +3. LSST Dark Energy Science Collaboration, “The LSST DESC DC2 Simulated Sky + Survey,” The Astrophysical Journal Supplement Series 253, 31 (2021), + arXiv:2010.05926. [DOI](https://doi.org/10.3847/1538-4365/abd62c). +4. V. Roscani et al., “A comparative analysis of denoising algorithms for + extragalactic imaging surveys,” Astronomy & Astrophysics 643, A43 (2020), + arXiv:2009.01846. [DOI](https://doi.org/10.1051/0004-6361/201936278). +5. M. Akhlaghi & T. Ichikawa, “Noise Based Detection and Segmentation of + Nebulous Objects,” The Astrophysical Journal Supplement Series 220, 1 + (2015), arXiv:1505.01664. + [DOI](https://doi.org/10.1088/0067-0049/220/1/1). +6. S. Huang et al., “Characterization and photometric performance of the Hyper + Suprime-Cam Software Pipeline,” Publications of the Astronomical Society of + Japan 70, S6 (2018). [DOI](https://doi.org/10.1093/pasj/psx126). +7. J. Bosch et al., “The Hyper Suprime-Cam Software Pipeline,” Publications of + the Astronomical Society of Japan 70, S5 (2018), arXiv:1705.06766. + [DOI](https://doi.org/10.1093/pasj/psx080). +8. Q. Huynh-Thu & M. Ghanbari, “Scope of validity of PSNR in image/video + quality assessment,” Electronics Letters 44(13), 800 (2008). + [DOI](https://doi.org/10.1049/el:20080522). +9. A. Hore & D. Ziou, “Image quality metrics: PSNR vs. SSIM,” Proceedings of + the International Conference on Pattern Recognition (ICPR), 2010. + [DOI](https://doi.org/10.1109/ICPR.2010.579). +10. Z. Wang, A. C. Bovik, H. R. Sheikh & E. P. Simoncelli, “Image quality + assessment: from error visibility to structural similarity,” IEEE + Transactions on Image Processing 13(4), 600–612 (2004). + [DOI](https://doi.org/10.1109/TIP.2003.819861). + ## Instalación ```bash @@ -67,9 +347,7 @@ python -m astro_denoise.metrics \ métodos**: un método que aplasta el fondo baja su propio σ y "detecta más profundo" gratis (infla n_detected y hunde la pureza). Con `--thresh-image` todos los métodos se umbralizan a la misma profundidad absoluta de flujo; - el σ usado queda registrado en el JSON (`parameters.thresh_rms`). Esta es la - decisión metodológica adoptada para la deuda D3 del proyecto: umbral = - `--thresh × RMS(input)`, en unidades absolutas de la imagen. + el σ usado queda registrado en el JSON (`parameters.thresh_rms`). - `--thresh-sweep`: barrido de umbrales de detección; agrega al JSON la curva `detection_rate` (n_detected + completitud/pureza por umbral), el insumo del trade-off completitud/pureza. Respeta `--thresh-image`, de modo que el