@@ -16,219 +26,408 @@
-
imzML & mzML Data Pre-Treatment
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
- {{ file }}
-
-
-
-
-
-
-
- -
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+ {{ step.label }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
imzML & mzML Data Pre-Treatment
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Mean spectrum plot
+
+
+ Sum Spectrum plot
+
+
+ Spectrum plot (X,Y)
+
+
+
+
+
+
+ Preview Spectrum:
+
+
+
+
+
+
+
+
+ Internal Standards
+ Reference peaks for calibration and alignment
+
+
+
+
+
+
+ Preprocessing Pipeline
+
+
- -
-
Method
- -
-
-
-
-
- Method
- -
-
Parameters
-
-
- Method
- -
-
-
-
Parameters
-
-
- Method
- -
-
-
-
- Method
- -
-
-
-
Parameters
-
-
- Detect if profile or centroid to determine which elements to show.
-Method
- -
-
Parameters
-
-
- Parameters
-
-
-
+
+
+
+
+
+ Method
+ The algorithm to use for baseline correction.
+ +
+
+
Parameters
+
+
+
+
+
+
+ Method
+ The normalization method to apply.
+ +
+
+
+
Method
+ The alignment algorithm.
+ +
+
+
Parameters
+
+
+
+
+
+
+
+
+
+
+
+
+ Parameters
+
+
+
+
+
+
+ Method
+ The peak detection algorithm.
+ +
+
+
Parameters
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Peak Quality Filters
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Method
+ The binning strategy.
+ +
+
Parameters
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
imzML & mzML Data Processor
Please make sure the ibd and imzML file are located in the same directory and have the same name. @@ -330,6 +529,10 @@
+
Before Preprocessing
-
@@ -790,4 +993,4 @@
-
\ No newline at end of file
+
diff --git a/app_snippet.html b/app_snippet.html
new file mode 100644
index 0000000..398a10d
--- /dev/null
+++ b/app_snippet.html
@@ -0,0 +1,665 @@
+
+ 
+
+
+
+
+")
binary_offset = position(stream)
+ #println("DEBUG: Binary data offset: $binary_offset")
# Move stream to the end of the binary data array for the next iteration
readuntil(stream, "")
+ #println("DEBUG: Exiting get_spectrum_asset_metadata.")
# Create SpectrumAsset directly from the variables
return SpectrumAsset(data_format, compression_flag, binary_offset, encoded_length, axis)
@@ -223,13 +250,16 @@ function parse_spectrum_metadata(stream::IO, offset::Int64)
id_match = match(r"= 19.08) .& (all_peaks_fwhm .<= 95.39) .& (all_peaks_snr .>= 3.0)
-
- scatter!(ax, all_peaks_mz[.!selected], all_peaks_fwhm[.!selected],
- color=:red, markersize=15, label="Rejected")
- scatter!(ax, all_peaks_mz[selected], all_peaks_fwhm[selected],
- color=:green, markersize=15, label="Selected")
-
- # Add selection criteria lines
- hlines!(ax, [19.08, 95.39], color=:black, linestyle=:dash, linewidth=2)
- text!(ax, 850, 50; text="FWHM bounds", color=:black, fontsize=10)
-
- elseif step_name == "Smoothing"
- # Simulate smoothing effect
- true_signal = 0.7 .* exp.(-0.001 .* (mz_range .- 450).^2) .+
- 0.5 .* exp.(-0.0008 .* (mz_range .- 650).^2)
- noisy_signal = true_signal .+ 0.1 .* randn(length(mz_range))
-
- # Simple smoothing simulation
- smoothed = similar(noisy_signal)
- window = 5
- for i in 1:length(noisy_signal)
- start_idx = max(1, i - window ÷ 2)
- end_idx = min(length(noisy_signal), i + window ÷ 2)
- smoothed[i] = mean(noisy_signal[start_idx:end_idx])
- end
-
- lines!(ax, mz_range, noisy_signal, color=:red, linewidth=1, label="Noisy")
- lines!(ax, mz_range, smoothed, color=:blue, linewidth=2, label="Smoothed")
- lines!(ax, mz_range, true_signal, color=:green, linewidth=1, linestyle=:dash, label="True")
end
-
- # Add parameter text using a more reliable approach
- param_text = join(params, "\n")
-
- text!(ax, param_text, position=Point2f(0.05, 0.95),
- space=:relative, align=(:left, :top), color=:black,
- fontsize=10, font=:regular)
-
- # Add legend for selected plots
- if idx <= 4
- axislegend(ax, position=:rt, framevisible=true, backgroundcolor=RGBA(1,1,1,0.8))
- end
-
- # Customize axes
- ax.xlabel = "m/z"
- ax.ylabel = idx in [1,3,5,7] ? "Intensity" : ""
- ax.xgridvisible = false
- ax.ygridvisible = false
+ return b
end
- # Add overall title
- Label(fig[0, :], "MSI Preprocessing Pipeline Parameters and Simulations",
- fontsize=18, font=:bold, padding=(0, 0, 10, 0))
-
- # Add explanation
- explanation = """
- Simulation of MSI preprocessing parameters showing:
- • Blue lines: Profile/continuous spectra
- • Red bars/points: Centroid data
- • Dashed lines: Reference/true signals
- • Green: Processed/corrected data
- • Each subplot demonstrates key parameters for the preprocessing step
- """
-
- Label(fig[2, :], explanation, fontsize=12, tellwidth=false, padding=(10, 10, 10, 10))
-
- # Adjust layout
- colgap!(g, 20)
- rowgap!(g, 20)
-
- fig
+ baseline_iter_20 = simple_snip(raw_signal, 20)
+ baseline_iter_200 = simple_snip(raw_signal, 200)
+ corrected_signal = raw_signal .- baseline_iter_200
+
+ lines!(ax, mz_range, raw_signal, color=(:grey, 0.6), label="Raw Signal")
+ lines!(ax, mz_range, corrected_signal, color=:green, linewidth=2.5, label="Corrected Signal")
+ l1 = lines!(ax, mz_range, baseline_iter_20, color=(:red, 0.7), linestyle=:dash, linewidth=2, label="Baseline (iterations: 20)")
+ l2 = lines!(ax, mz_range, baseline_iter_200, color=:red, linewidth=2.5, label="Baseline (iterations: 200)")
+
+ text!(ax, "Parameter: `iterations`\nMore iterations result in a more aggressive baseline that follows the signal floor more closely.",
+ position=Point2f(0.05, 0.95), space=:relative, align=(:left, :top), fontsize=12)
+ axislegend(ax, position=:rt)
+ save("descriptive_plot_baseline_correction.png", fig)
+ println("Saved: descriptive_plot_baseline_correction.png")
end
-# Create and display the plot
-fig = create_msi_parameter_plot()
+"""
+Plots the effect of smoothing, comparing different window sizes.
+"""
+function plot_smoothing_details()
+ fig = Figure(size=(1200, 700), fontsize=14)
+ ax = Axis(fig[1, 1], title="Detailed View: Smoothing (Savitzky-Golay)", xlabel="m/z", ylabel="Intensity")
-# Save the plot
-save("msi_preprocessing_parameters.png", fig)
-println("Plot saved as 'msi_preprocessing_parameters.png'")
+ mz_range = range(400, 700, length=1000)
+ true_signal = 0.8 .* exp.(-0.002 .* (mz_range .- 500).^2) .+ 0.6 .* exp.(-0.001 .* (mz_range .- 600).^2)
+ noisy_signal = true_signal .+ 0.1 .* randn(length(mz_range))
+
+ function simple_moving_average(y, window)
+ smoothed = similar(y)
+ for i in 1:length(y)
+ start_idx = max(1, i - window ÷ 2)
+ end_idx = min(length(y), i + window ÷ 2)
+ smoothed[i] = mean(y[start_idx:end_idx])
+ end
+ return smoothed
+ end
+
+ smoothed_small_window = simple_moving_average(noisy_signal, 5)
+ smoothed_large_window = simple_moving_average(noisy_signal, 21)
+
+ lines!(ax, mz_range, noisy_signal, color=(:red, 0.4), label="Noisy Signal")
+ lines!(ax, mz_range, true_signal, color=:black, linestyle=:dash, linewidth=2, label="True Signal")
+ lines!(ax, mz_range, smoothed_small_window, color=:blue, linewidth=2, label="Smoothed (window: 5)")
+ lines!(ax, mz_range, smoothed_large_window, color=:purple, linewidth=2, label="Smoothed (window: 21)")
+
+ text!(ax, "Parameter: `window`\nA larger window increases smoothing but may broaden peaks.",
+ position=Point2f(0.05, 0.95), space=:relative, align=(:left, :top), fontsize=12)
+ axislegend(ax, position=:rt)
+ save("descriptive_plot_smoothing.png", fig)
+ println("Saved: descriptive_plot_smoothing.png")
+end
+
+"""
+Visualizes the peak picking process for profile-mode data, illustrating the
+effects of SNR threshold and peak prominence.
+"""
+function plot_peak_picking_profile_details()
+ fig = Figure(size=(1200, 700), fontsize=14)
+ ax = Axis(fig[1, 1], title="Detailed View: Peak Picking (Profile Mode)", xlabel="m/z", ylabel="Intensity")
+
+ mz = 1:200
+ base_signal = 10 .* exp.(-((mz .- 50).^2) ./ (2*3^2)) .+ 7 .* exp.(-((mz .- 120).^2) ./ (2*5^2)) .+ 2
+ small_peak_signal = zeros(200)
+ for i in 80:90
+ small_peak_signal[i] = 3 * exp(-((i - 85)^2) / 2.0)
+ end
+ noise = 0.5 .* randn(200)
+ intensity = base_signal .+ small_peak_signal .+ noise
+
+ noise_level = median(abs.(intensity .- median(intensity))) * 1.4826 # MAD
+ snr_threshold_val = 3.0
+ intensity_threshold = noise_level * snr_threshold_val
+
+ picked_peaks_mz = [50, 85, 120]
+ picked_peaks_intensity = intensity[picked_peaks_mz]
+
+ hlines!(ax, [noise_level], color=:gray, linestyle=:dot, label="Est. Noise Level")
+ hlines!(ax, [intensity_threshold], color=:orange, linestyle=:dash, label="SNR Threshold (snr_threshold = 3.0)")
+ lines!(ax, mz, intensity, color=:blue, label="Profile Spectrum")
+ scatter!(ax, picked_peaks_mz, picked_peaks_intensity, color=:green, markersize=15, strokewidth=2, label="Peaks passing SNR")
+ scatter!(ax, [25], [intensity[25]], color=:red, marker=:x, markersize=15, label="Local max below SNR")
+
+ # Illustrate prominence
+ arrows!(ax, [120, 120], [intensity[135], intensity[120]], [0, 0], [intensity[120]-intensity[135], 0], color=:purple)
+ text!(ax, 125, (intensity[120]+intensity[135])/2, text="Prominence", color=:purple)
+
+ axislegend(ax, position=:rt)
+ save("descriptive_plot_peakpicking_profile.png", fig)
+ println("Saved: descriptive_plot_peakpicking_profile.png")
+end
+
+"""
+Visualizes peak picking (filtering) for centroid-mode data based on an SNR
+(intensity) threshold.
+"""
+function plot_peak_picking_centroid_details()
+ fig = Figure(size=(1200, 700), fontsize=14)
+ ax = Axis(fig[1, 1], title="Detailed View: Peak Picking (Centroid Mode)", xlabel="m/z", ylabel="Intensity")
+
+ mz = [100, 150, 200, 250, 300, 350, 400]
+ intensity = [10, 5, 25, 8, 3, 18, 12]
+ snr_threshold_val = 10.0
+
+ stem!(ax, mz, intensity, color=:gray, label="Input Centroids")
+
+ selected_mask = intensity .>= snr_threshold_val
+ stem!(ax, mz[selected_mask], intensity[selected_mask], color=:green, trunkwidth=3, label="Selected Peaks (intensity >= 10)")
+ stem!(ax, mz[.!selected_mask], intensity[.!selected_mask], color=:red, trunkwidth=3, label="Rejected Peaks (intensity < 10)")
+
+ hlines!(ax, [snr_threshold_val], color=:orange, linestyle=:dash, label="Intensity Threshold (snr_threshold)")
+
+ text!(ax, "Parameter: `snr_threshold`\nIn centroid mode, this acts as a direct intensity filter.",
+ position=Point2f(0.05, 0.95), space=:relative, align=(:left, :top), fontsize=12)
+ axislegend(ax, position=:rt)
+ save("descriptive_plot_peakpicking_centroid.png", fig)
+ println("Saved: descriptive_plot_peakpicking_centroid.png")
+end
+
+"""
+Plots the effect of different normalization methods on a set of spectra.
+"""
+function plot_normalization_details()
+ fig = Figure(size=(1200, 700), fontsize=14)
+
+ mz = range(300, 400, length=500)
+ spec1 = 1.5 .* exp.(-((mz .- 350).^2) ./ 50)
+ spec2 = 0.8 .* exp.(-((mz .- 350).^2) ./ 50)
+
+ ax1 = Axis(fig[1, 1], title="Before Normalization", ylabel="Absolute Intensity")
+ lines!(ax1, mz, spec1, label="Spectrum A (High TIC)")
+ lines!(ax1, mz, spec2, label="Spectrum B (Low TIC)")
+ axislegend(ax1)
+
+ ax2 = Axis(fig[1, 2], title="After Normalization (TIC)", ylabel="Relative Intensity")
+ lines!(ax2, mz, spec1 ./ sum(spec1), label="Spectrum A (Normalized)")
+ lines!(ax2, mz, spec2 ./ sum(spec2), label="Spectrum B (Normalized)")
+
+ text!(ax2, "Effect: Spectra are scaled to have the same total area, making their intensities comparable.",
+ position=Point2f(0.05, 0.95), space=:relative, align=(:left, :top), fontsize=12, justification=:left)
+
+ save("descriptive_plot_normalization.png", fig)
+ println("Saved: descriptive_plot_normalization.png")
+end
+
+"""
+Illustrates mass calibration, showing how a calibration curve corrects measured
+m/z values based on reference peaks.
+"""
+function plot_calibration_details()
+ fig = Figure(size=(1200, 700), fontsize=14)
+ ax = Axis(fig[1, 1], title="Detailed View: Calibration", xlabel="Measured m/z", ylabel="m/z Error (Measured - Reference)")
+
+ ref_mz = [200, 400, 600, 800, 1000]
+ measured_mz = ref_mz .+ [0.1, 0.15, 0.2, 0.25, 0.3] .+ 0.02 .* randn(5)
+ errors = measured_mz .- ref_mz
+
+ # Fit a linear model to the error
+ A = [ones(5) measured_mz]
+ coeffs = A \ errors
+ correction_func(m) = m - (coeffs[1] .+ coeffs[2] .* m)
+
+ fit_line = coeffs[1] .+ coeffs[2] .* measured_mz
+
+ scatter!(ax, measured_mz, errors, color=:red, markersize=15, label="Measured Error")
+ lines!(ax, measured_mz, fit_line, color=:blue, label="Calibration Curve (fit_order=1)")
+
+ text!(ax, "Parameter: `fit_order`\nA curve is fit to the error of known reference peaks.\nThis curve is then used to correct all m/z values.",
+ position=Point2f(0.05, 0.95), space=:relative, align=(:left, :top), fontsize=12)
+ axislegend(ax, position=:rb)
+ save("descriptive_plot_calibration.png", fig)
+ println("Saved: descriptive_plot_calibration.png")
+end
+
+"""
+Visualizes peak alignment by showing multiple spectra with misaligned peaks
+before and after the alignment process.
+"""
+function plot_alignment_details()
+ fig = Figure(size=(1600, 600), fontsize=14)
+ ax1 = Axis(fig[1, 1], title="Before Alignment", xlabel="m/z", yticklabelsvisible=false, ygridvisible=false)
+ ax2 = Axis(fig[1, 2], title="After Alignment", xlabel="m/z", yticklabelsvisible=false, ygridvisible=false)
+
+ mz = range(490, 510, length=1000)
+ shifts = [-0.5, 0.0, 0.8]
+ colors = [:blue, :green, :purple]
+
+ for (i, shift) in enumerate(shifts)
+ peak_center = 500 + shift
+ spectrum = exp.(-((mz .- peak_center).^2) ./ 0.1)
+ lines!(ax1, mz, spectrum .+ i, color=colors[i])
+ vlines!(ax1, [peak_center], color=(colors[i], 0.5), linestyle=:dash)
+
+ # After alignment, all peaks are at 500
+ aligned_spectrum = exp.(-((mz .- 500).^2) ./ 0.1)
+ lines!(ax2, mz, aligned_spectrum .+ i, color=colors[i])
+ end
+ vlines!(ax2, [500], color=:red, linestyle=:dash, label="Reference m/z")
+ axislegend(ax2)
+
+ save("descriptive_plot_alignment.png", fig)
+ println("Saved: descriptive_plot_alignment.png")
+end
+
+"""
+Illustrates peak selection by filtering a population of peaks based on
+FWHM and SNR criteria.
+"""
+function plot_peak_selection_details()
+ fig = Figure(size=(1200, 700), fontsize=14)
+ ax = Axis(fig[1, 1], title="Detailed View: Peak Selection", xlabel="FWHM (ppm)", ylabel="Signal-to-Noise Ratio (SNR)")
+
+ n_peaks = 100
+ fwhm = rand(n_peaks) .* 150
+ snr = rand(n_peaks) .* 20
+
+ min_fwhm_ppm = 20.0
+ max_fwhm_ppm = 100.0
+ min_snr = 5.0
+
+ selected_mask = (fwhm .>= min_fwhm_ppm) .& (fwhm .<= max_fwhm_ppm) .& (snr .>= min_snr)
+
+ scatter!(ax, fwhm[.!selected_mask], snr[.!selected_mask], color=(:red, 0.5), label="Rejected Peaks")
+ scatter!(ax, fwhm[selected_mask], snr[selected_mask], color=:green, label="Selected Peaks")
+
+ vlines!(ax, [min_fwhm_ppm, max_fwhm_ppm], color=:blue, linestyle=:dash, label="FWHM bounds")
+ hlines!(ax, [min_snr], color=:orange, linestyle=:dash, label="SNR bound")
+
+ poly!(ax, BBox(min_fwhm_ppm, max_fwhm_ppm, min_snr, 22), color=(:green, 0.1))
+ text!(ax, "Selection Region", position=(60, 12), color=:green, fontsize=14)
+
+ axislegend(ax)
+ save("descriptive_plot_peak_selection.png", fig)
+ println("Saved: descriptive_plot_peak_selection.png")
+end
+
+"""
+Visualizes the adaptive peak binning process, showing how peaks from different
+spectra are grouped into a common bin based on a PPM tolerance.
+"""
+function plot_peak_binning_details()
+ fig = Figure(size=(1200, 700), fontsize=14)
+ ax = Axis(fig[1, 1], title="Detailed View: Adaptive Peak Binning", xlabel="m/z", yticklabelsvisible=false)
+
+ ref_mz = 500.0
+ tolerance_ppm = 50.0
+ tol_mz = ref_mz * tolerance_ppm / 1e6
+
+ bin_start = ref_mz - tol_mz/2
+ bin_end = ref_mz + tol_mz/2
+
+ peaks_mz = [ref_mz - 0.01, ref_mz + 0.005, ref_mz + 0.02, ref_mz - 0.015]
+ peak_intensities = [0.8, 1.0, 0.9, 0.7]
+ peak_colors = [:blue, :green, :purple, :orange]
+
+ vspan!(ax, bin_start, bin_end, color=(:gray, 0.2), label="Bin (tolerance: 50 ppm)")
+ stem!(ax, peaks_mz, peak_intensities, color=peak_colors, markersize=15)
+
+ # Show bin center
+ bin_center = mean(peaks_mz)
+ vlines!(ax, [bin_center], color=:red, linestyle=:dash, label="Calculated Bin Center")
+
+ text!(ax, "Parameter: `tolerance`\nPeaks from different spectra within the tolerance window are grouped into a single feature.",
+ position=Point2f(0.05, 0.95), space=:relative, align=(:left, :top), fontsize=12)
+ axislegend(ax, position=:rt)
+ xlims!(ax, ref_mz - tol_mz*2, ref_mz + tol_mz*2)
+ save("descriptive_plot_peak_binning.png", fig)
+ println("Saved: descriptive_plot_peak_binning.png")
+end
+
+
+"""
+Main function to generate and save all descriptive plots.
+"""
+function create_and_save_all_plots()
+ println("Generating detailed descriptive plots for preprocessing steps...")
+
+ plot_baseline_correction_details()
+ plot_smoothing_details()
+ plot_peak_picking_profile_details()
+ plot_peak_picking_centroid_details()
+ plot_normalization_details()
+ plot_calibration_details()
+ plot_alignment_details()
+ plot_peak_selection_details()
+ plot_peak_binning_details()
+
+ println("\nAll descriptive plots have been saved in the current directory.")
+end
+
+# Execute the plot generation
+if abspath(PROGRAM_FILE) == @__FILE__
+ create_and_save_all_plots()
+end
-# Display the plot (if in an interactive environment)
-fig
diff --git a/test/run_preprocessing.jl b/test/run_preprocessing.jl
index 2e0e329..e244f8a 100644
--- a/test/run_preprocessing.jl
+++ b/test/run_preprocessing.jl
@@ -5,6 +5,8 @@ import Pkg
using CairoMakie
using DataFrames # For creating dataframes
using CSV
+using Statistics
+using Interpolations
# --- Load the MSI_src Module ---
Pkg.activate(joinpath(@__DIR__, ".."))
@@ -15,12 +17,13 @@ using MSI_src
# CONFIG: PLEASE FILL IN YOUR FILE PATHS HERE
# ===================================================================
-const TEST_FILE = "/home/pixel/Documents/Cinvestav_2025/Analisis/Thricoderma_etc/Imaging_interaccion_trichoderma_vs_streptomyces.imzML"
+# const TEST_FILE = "/home/pixel/Documents/Cinvestav_2025/Analisis/Thricoderma_etc/Imaging_interaccion_trichoderma_vs_streptomyces.imzML"
# const TEST_FILE = "/home/pixel/Documents/Cinvestav_2025/Analisis/set de datos MS/Atropina_tuneo_fraq_20ev.mzML"
-# const TEST_FILE = "/home/pixel/Documents/Cinvestav_2025/Analisis/salida/Stomach_DHB_uncompressed.imzML"
+const TEST_FILE = "/home/pixel/Documents/Cinvestav_2025/Analisis/salida/Stomach_DHB_uncompressed.imzML"
+# const TEST_FILE = "/home/pixel/Documents/Cinvestav_2025/Analisis/imzML_AP_SMALDI/HR2MSImouseurinarybladderS096.imzML"
-# const MASK_ROUTE = "/home/pixel/Documents/Cinvestav_2025/JuliaMSI/public/css/masks/Stomach_DHB_uncompressed.png"
-const MASK_ROUTE = ""
+const MASK_ROUTE = "/home/pixel/Documents/Cinvestav_2025/JuliaMSI/public/css/masks/Stomach_DHB_uncompressed.png"
+# const MASK_ROUTE = ""
const OUTPUT_DIR = "./test/results/preprocessing_results"
@@ -41,6 +44,55 @@ const reference_peaks = Dict(
124.0393 => "Tropine [M+H]+",
)
+const PIPELINE_STP = [
+ "stabilization",
+ #"baseline_correction",
+ "smoothing",
+ "peak_picking",
+ "peak_selection",
+ #"calibration",
+ "peak_alignment",
+ "normalization",
+ "peak_binning"
+]
+
+# ===================================================================
+# USER OVERRIDES: Manually specify parameters here
+# ===================================================================
+# This dictionary allows you to override any auto-detected parameters.
+# The structure should match the output of `main_precalculation`.
+# Example: Force a less aggressive peak prominence threshold.
+
+const USER_OVERRIDES = Dict(
+ :Stabilization => Dict(
+ :method => :sqrt # Default stabilization method
+ ),
+ :PeakPicking => Dict(
+ #:snr_threshold => 1.5,
+ #:half_window => 5,
+ :snr_threshold => 8.0,
+ #:merge_peaks_tolerance => 2.5,
+ #:half_window => 2
+ #:half_window => 3
+ ),
+ # :Smoothing => Dict(
+ # :window => 11
+ # )
+ #:PeakAlignment => Dict(
+ # :tolerance => 0.01
+ #)
+ #:PeakSelection => Dict(
+ #:frequency_threshold => 0,
+ #:min_shape_r2 => 0.5,
+ #:max_fwhm_ppm => 30.0,
+ #:min_fwhm_ppm => 2.0
+ #),
+ #:PeakBinning => Dict(
+ #:tolerance => 30.0,
+ #:frequency_threshold => 0
+ #)
+)
+
# ===================================================================
# HELPER FUNCTIONS
# ===================================================================
@@ -79,7 +131,7 @@ end
# PREPROCESSING PIPELINE FUNCTIONS (IN-PLACE)
# ===================================================================
-function apply_baseline_correction(spectra::Vector{MutableSpectrum}, params::Dict, msi_data::MSIData)
+function apply_baseline_correction_core(spectra::Vector{MutableSpectrum}, params::Dict, msi_data::MSIData)
print_step_header("Baseline Correction")
method = get(params, :method, :snip)
@@ -91,7 +143,7 @@ function apply_baseline_correction(spectra::Vector{MutableSpectrum}, params::Dic
if !isempty(spectra)
s = spectra[1]
if validate_spectrum(s.mz, s.intensity)
- baseline = MSI_src.apply_baseline_correction(s.intensity; method=method, iterations=iterations, window=window)
+ baseline = MSI_src.apply_baseline_correction_core(s.intensity; method=method, iterations=iterations, window=window)
corrected_intensity = max.(0.0, s.intensity .- baseline)
plot_spectrum_step(s.mz, corrected_intensity, "baseline_correction")
end
@@ -99,7 +151,7 @@ function apply_baseline_correction(spectra::Vector{MutableSpectrum}, params::Dic
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
- baseline = MSI_src.apply_baseline_correction(s.intensity; method=method, iterations=iterations, window=window)
+ baseline = MSI_src.apply_baseline_correction_core(s.intensity; method=method, iterations=iterations, window=window)
s.intensity = max.(0.0, s.intensity .- baseline)
end
end
@@ -117,14 +169,14 @@ function apply_smoothing(spectra::Vector{MutableSpectrum}, params::Dict)
if !isempty(spectra)
s = spectra[1]
if validate_spectrum(s.mz, s.intensity)
- smoothed_intensity = max.(0.0, smooth_spectrum(s.intensity; method=method, window=window, order=order))
+ smoothed_intensity = max.(0.0, smooth_spectrum_core(s.intensity; method=method, window=window, order=order))
plot_spectrum_step(s.mz, smoothed_intensity, "smoothing", spectrum_index=s.id)
end
end
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
- smoothed_intensity = max.(0.0, smooth_spectrum(s.intensity; method=method, window=window, order=order))
+ smoothed_intensity = max.(0.0, smooth_spectrum_core(s.intensity; method=method, window=window, order=order))
s.intensity = smoothed_intensity
end
end
@@ -153,13 +205,13 @@ function apply_peak_picking(spectra::Vector{MutableSpectrum}, params::Dict)
if is_valid
if method == :profile
- s.peaks = detect_peaks_profile(s.mz, s.intensity; snr_threshold=snr_threshold, half_window=half_window, min_peak_prominence=min_peak_prominence, merge_peaks_tolerance=merge_peaks_tolerance)
+ s.peaks = detect_peaks_profile_core(s.mz, s.intensity; snr_threshold=snr_threshold, half_window=half_window, min_peak_prominence=min_peak_prominence, merge_peaks_tolerance=merge_peaks_tolerance)
elseif method == :wavelet
s.peaks = detect_peaks_wavelet(s.mz, s.intensity; snr_threshold=snr_threshold, half_window=half_window)
elseif method == :centroid
- s.peaks = detect_peaks_centroid(s.mz, s.intensity; snr_threshold=snr_threshold)
+ s.peaks = detect_peaks_centroid_core(s.mz, s.intensity; snr_threshold=snr_threshold)
else
- s.peaks = detect_peaks_profile(s.mz, s.intensity; snr_threshold=snr_threshold, half_window=half_window)
+ s.peaks = detect_peaks_profile_core(s.mz, s.intensity; snr_threshold=snr_threshold, half_window=half_window)
end
else
s.peaks = []
@@ -176,6 +228,51 @@ function apply_peak_picking(spectra::Vector{MutableSpectrum}, params::Dict)
end
end
+function apply_peak_selection(spectra::Vector{MutableSpectrum}, params::Dict)
+ print_step_header("Peak Selection")
+
+ min_snr = get(params, :min_snr, 0.0)
+ min_fwhm = get(params, :min_fwhm_ppm, 0.0)
+ max_fwhm = get(params, :max_fwhm_ppm, Inf)
+ min_r2 = get(params, :min_shape_r2, 0.0)
+
+ # Handle `nothing` values from params, default to non-filtering values
+ min_snr = isnothing(min_snr) ? 0.0 : min_snr
+ min_fwhm = isnothing(min_fwhm) ? 0.0 : min_fwhm
+ max_fwhm = isnothing(max_fwhm) ? Inf : max_fwhm
+ min_r2 = isnothing(min_r2) ? 0.0 : min_r2
+
+ println(" - Min SNR: $min_snr")
+ println(" - FWHM Range (ppm): [$min_fwhm, $max_fwhm]")
+ println(" - Min Shape R²: $min_r2")
+
+ total_peaks_before = sum(s -> length(s.peaks), spectra)
+
+ Threads.@threads for s in spectra
+ if !isempty(s.peaks)
+ s.peaks = filter(p ->
+ p.snr >= min_snr &&
+ (min_fwhm <= p.fwhm <= max_fwhm) &&
+ p.shape_r2 >= min_r2,
+ s.peaks
+ )
+ end
+ end
+
+ total_peaks_after = sum(s -> length(s.peaks), spectra)
+ println(" - Peaks before: $total_peaks_before, Peaks after: $total_peaks_after")
+
+ # Safely plot the first spectrum to show effect of filtering
+ if !isempty(spectra)
+ s1_idx = findfirst(s -> s.id == 1, spectra)
+ if s1_idx !== nothing
+ s1 = spectra[s1_idx]
+ plot_spectrum_step(s1.mz, s1.intensity, "peak_selection", peaks=s1.peaks, spectrum_index=s1.id)
+ println(" - Spectrum 1 now has $(length(s1.peaks)) peaks after selection.")
+ end
+ end
+end
+
function apply_calibration(spectra::Vector{MutableSpectrum}, params::Dict, reference_peaks::Dict)
print_step_header("Calibration")
@@ -195,7 +292,7 @@ function apply_calibration(spectra::Vector{MutableSpectrum}, params::Dict, refer
s = spectra[i]
info_message = ""
if validate_spectrum(s.mz, s.intensity)
- matched_peaks = find_calibration_peaks(s.mz, s.intensity, reference_masses; ppm_tolerance=ppm_tolerance)
+ matched_peaks = find_calibration_peaks_core(s.mz, s.intensity, reference_masses; ppm_tolerance=ppm_tolerance)
if length(matched_peaks) >= 2
measured = sort(collect(values(matched_peaks)))
theoretical = sort(collect(keys(matched_peaks)))
@@ -248,7 +345,7 @@ function apply_peak_alignment(spectra::Vector{MutableSpectrum}, params::Dict)
end
current_peaks_mz = [p.mz for p in s.peaks]
- alignment_func = align_peaks_lowess(ref_peaks_mz, current_peaks_mz; method=method, tolerance=tolerance, tolerance_unit=tolerance_unit)
+ alignment_func = align_peaks_lowess_core(ref_peaks_mz, current_peaks_mz; method=method, tolerance=tolerance, tolerance_unit=tolerance_unit)
s.mz = alignment_func.(s.mz) # Update m/z axis
@@ -261,7 +358,7 @@ function apply_peak_alignment(spectra::Vector{MutableSpectrum}, params::Dict)
end
end
-function apply_normalization(spectra::Vector{MutableSpectrum}, params::Dict)
+function apply_normalization_core(spectra::Vector{MutableSpectrum}, params::Dict)
print_step_header("Normalization")
method = get(params, :method, :tic)
@@ -273,7 +370,7 @@ function apply_normalization(spectra::Vector{MutableSpectrum}, params::Dict)
if s1 !== nothing
s = spectra[s1]
if validate_spectrum(s.mz, s.intensity)
- normalized_intensity = MSI_src.apply_normalization(s.intensity; method=method)
+ normalized_intensity = MSI_src.apply_normalization_core(s.intensity; method=method)
plot_spectrum_step(s.mz, normalized_intensity, "normalization")
end
end
@@ -281,7 +378,7 @@ function apply_normalization(spectra::Vector{MutableSpectrum}, params::Dict)
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
- s.intensity = MSI_src.apply_normalization(s.intensity; method=method)
+ s.intensity = MSI_src.apply_normalization_core(s.intensity; method=method)
end
end
end
@@ -293,8 +390,6 @@ function apply_peak_binning(spectra::Vector{MutableSpectrum}, params::Dict)
tolerance = get(params, :tolerance, 20.0)
tolerance_unit = get(params, :tolerance_unit, :ppm)
min_peak_per_bin = get(params, :min_peak_per_bin, 3)
- max_bin_width_ppm = get(params, :max_bin_width_ppm, 150.0)
- intensity_weighted_centers = get(params, :intensity_weighted_centers, true)
println(" Method: $method, Tolerance: $tolerance $tolerance_unit")
if isempty(spectra) || all(s -> isempty(s.peaks), spectra)
@@ -304,92 +399,129 @@ function apply_peak_binning(spectra::Vector{MutableSpectrum}, params::Dict)
println(" - Binning peaks from $(length(spectra)) spectra")
- binning_params = PeakBinningParams(
- method=method,
- tolerance=tolerance,
- tolerance_unit=tolerance_unit,
- min_peak_per_bin=min_peak_per_bin,
- max_bin_width_ppm=max_bin_width_ppm,
- intensity_weighted_centers=intensity_weighted_centers
- )
-
- feature_matrix, bin_definitions = bin_peaks(spectra, binning_params)
-
- if feature_matrix !== nothing && bin_definitions !== nothing
- println(" - Generated feature matrix: $(size(feature_matrix.matrix))")
- println(" - Number of bins: $(length(bin_definitions))")
- end
-
- return feature_matrix, bin_definitions
-end
-
-function save_feature_matrix(feature_matrix, bin_definitions)
- print_step_header("Saving Results")
-
- # Save feature matrix as CSV
- csv_path = joinpath(OUTPUT_DIR, "feature_matrix.csv")
-
- # Create column headers
- bin_headers = ["bin_$(i)_$(round(def[1], digits=4))-$(round(def[2], digits=4))"
- for (i, def) in enumerate(bin_definitions)]
-
- # Open file for writing
- open(csv_path, "w") do io
- # Write header row
- write(io, "spectrum_index," * join(bin_headers, ",") * "\n")
-
- # Write data rows
- for r_idx in 1:size(feature_matrix.matrix, 1)
- write(io, "$(feature_matrix.sample_ids[r_idx]),")
- for c_idx in 1:size(feature_matrix.matrix, 2)
- write(io, "$(feature_matrix.matrix[r_idx, c_idx])")
- if c_idx < size(feature_matrix.matrix, 2)
- write(io, ",")
- end
- end
- write(io, "\n")
+ # Collect all peaks with their intensities
+ all_peaks = Vector{Tuple{Float64, Float64}}() # (mz, intensity)
+ for s in spectra
+ for p in s.peaks
+ push!(all_peaks, (p.mz, p.intensity))
end
end
- println(" - Saved feature matrix: $csv_path")
- # Save bin definitions (still using DataFrame as it's small)
- bins_path = joinpath(OUTPUT_DIR, "bin_definitions.csv")
- bins_df = DataFrame(
- bin_index = 1:length(bin_definitions),
- mz_start = [def[1] for def in bin_definitions],
- mz_end = [def[2] for def in bin_definitions],
- mz_center = [(def[1] + def[2])/2 for def in bin_definitions]
- )
- CSV.write(bins_path, bins_df)
- println(" - Saved bin definitions: $bins_path")
+ if isempty(all_peaks)
+ @warn "No peaks collected for binning."
+ return nothing, nothing
+ end
- return csv_path, bins_path
+ sort!(all_peaks, by=x->x[1])
+
+ # Create bins - just store mz_center and intensity
+ bin_centers = Float64[]
+ bin_intensities = Float64[]
+
+ i = 1
+ while i <= length(all_peaks)
+ current_bin_start = i
+ current_peak = all_peaks[i]
+
+ # Find all peaks in this bin
+ j = i + 1
+ while j <= length(all_peaks)
+ next_peak = all_peaks[j]
+ # Calculate tolerance
+ tol = (tolerance_unit == :ppm) ? (current_peak[1] * tolerance / 1e6) : tolerance
+
+ if (next_peak[1] - current_peak[1]) <= tol
+ j += 1
+ else
+ break
+ end
+ end
+
+ current_bin_end = j - 1
+ bin_size = current_bin_end - current_bin_start + 1
+
+ # Check if we have enough peaks in this bin
+ if bin_size >= min_peak_per_bin
+ bin_peaks_core = all_peaks[current_bin_start:current_bin_end]
+
+ # Calculate m/z center and average intensity
+ mz_sum = 0.0
+ intensity_sum = 0.0
+ for peak in bin_peaks_core
+ mz_sum += peak[1]
+ intensity_sum += peak[2]
+ end
+
+ mz_center = mz_sum / bin_size
+ avg_intensity = intensity_sum / bin_size
+
+ push!(bin_centers, mz_center)
+ push!(bin_intensities, avg_intensity)
+ end
+
+ i = j # Move to next potential bin
+ end
+
+ # Create the 2-row matrix
+ if !isempty(bin_centers)
+ n_bins = length(bin_centers)
+ feature_matrix = Matrix{Float64}(undef, 2, n_bins)
+
+ for i in 1:n_bins
+ feature_matrix[1, i] = bin_centers[i]
+ feature_matrix[2, i] = bin_intensities[i]
+ end
+
+ println(" - Created feature matrix: 2 × $n_bins")
+ println(" - Number of bins created: $n_bins")
+ println(" - m/z range: $(round(bin_centers[1], digits=4)) - $(round(bin_centers[end], digits=4))")
+
+ # Return bin info as a vector of tuples for compatibility
+ bin_info = [(bin_centers[i], bin_intensities[i]) for i in 1:n_bins]
+ return feature_matrix, bin_info
+ else
+ @warn "No bins created after filtering"
+ return nothing, nothing
+ end
end
-# ===================================================================
-# USER OVERRIDES: Manually specify parameters here
-# ===================================================================
-# This dictionary allows you to override any auto-detected parameters.
-# The structure should match the output of `main_precalculation`.
-# Example: Force a less aggressive peak prominence threshold.
-const USER_OVERRIDES = Dict(
- :PeakPicking => Dict(
- #:snr_threshold => 1.5,
- :half_window => 5,
- :snr_threshold => 15.0,
- #:merge_peaks_tolerance => 2.5,
- #:half_window => 2
- ),
- # :Smoothing => Dict(
- # :window => 11
- # )
- #:PeakAlignment => Dict(
- # :tolerance => 0.01
- #)
- :PeakBinningParams => Dict(
- :tolerance => 30.0
- )
-)
+function save_feature_matrix(feature_matrix::Matrix{Float64}, bin_info)
+ print_step_header("Saving Results")
+
+ # Save as simple CSV with m/z and intensity rows
+ csv_path = joinpath(OUTPUT_DIR, "feature_matrix_simple.csv")
+
+ open(csv_path, "w") do io
+ # Write header
+ write(io, "mz,intensity\n")
+
+ # Write data: m/z values in first column, intensities in second
+ for i in 1:size(feature_matrix, 2)
+ mz = feature_matrix[1, i]
+ intensity = feature_matrix[2, i]
+ write(io, "$mz,$intensity\n")
+ end
+ end
+ println(" - Saved simple feature matrix: $csv_path")
+
+ # Also save in a more standard format for MSI
+ csv_path_standard = joinpath(OUTPUT_DIR, "feature_matrix_standard.csv")
+
+ open(csv_path_standard, "w") do io
+ # Write header with m/z values as column names
+ write(io, "sample_type,")
+ mz_headers = [@sprintf("mz_%.4f", feature_matrix[1, i]) for i in 1:size(feature_matrix, 2)]
+ write(io, join(mz_headers, ",") * "\n")
+
+ # Write the aggregated intensity values
+ write(io, "aggregated_spectrum,")
+ intensity_values = [feature_matrix[2, i] for i in 1:size(feature_matrix, 2)]
+ write(io, join(string.(intensity_values), ",") * "\n")
+ end
+ println(" - Saved standard format matrix: $csv_path_standard")
+
+ return csv_path, csv_path_standard
+end
# ===================================================================
# MAIN PREPROCESSING PIPELINE
@@ -446,28 +578,45 @@ function run_preprocessing_pipeline()
end
# Define pipeline steps
- pipeline_steps = [
- "baseline_correction",
- "smoothing",
- "peak_picking",
- "calibration",
- "peak_alignment",
- "normalization",
- "peak_binning"
- ]
+ pipeline_steps = PIPELINE_STP
println("\nPipeline steps: $(join(pipeline_steps, " -> "))")
# Initialize `current_spectra` as a Vector of mutable structs for in-place modification
println("\nInitializing spectra data structure...")
- num_spectra = length(msi_data.spectra_metadata)
- current_spectra = Vector{MutableSpectrum}(undef, num_spectra)
- _iterate_spectra_fast(msi_data) do idx, mz, intensity
- current_spectra[idx] = MutableSpectrum(idx, mz, intensity, [])
+ local spectrum_indices_to_process::AbstractVector{Int}
+ if !isempty(MASK_ROUTE)
+ println("Applying mask from: $(MASK_ROUTE)")
+ try
+ mask_matrix = MSI_src.load_and_prepare_mask(MASK_ROUTE, msi_data.image_dims)
+ masked_indices_set = MSI_src.get_masked_spectrum_indices(msi_data, mask_matrix)
+ spectrum_indices_to_process = collect(masked_indices_set)
+ println("Mask applied. $(length(spectrum_indices_to_process)) spectra are within the masked region.")
+ catch e
+ @error "Failed to load or apply mask: $e. Proceeding without mask."
+ spectrum_indices_to_process = 1:length(msi_data.spectra_metadata)
+ end
+ else
+ spectrum_indices_to_process = 1:length(msi_data.spectra_metadata)
+ end
+
+ if isempty(spectrum_indices_to_process)
+ @warn "No spectra available for processing after applying mask/filter. Exiting pipeline."
+ close(msi_data)
+ return
+ end
+
+ num_spectra_to_process = length(spectrum_indices_to_process)
+ current_spectra = Vector{MutableSpectrum}(undef, num_spectra_to_process)
+
+ Threads.@threads for i in 1:num_spectra_to_process
+ original_idx = spectrum_indices_to_process[i]
+ mz, intensity = MSI_src.GetSpectrum(msi_data, original_idx)
+ current_spectra[i] = MSI_src.MutableSpectrum(original_idx, mz, intensity, [])
- # Plot raw spectrum without masks
- if idx == 1
- plot_spectrum_step(mz, intensity, "raw_unmasked_spectrum")
+ # Plot raw spectrum without masks (only the first processed one)
+ if i == 1
+ plot_spectrum_step(mz, intensity, "raw_unmasked_spectrum", spectrum_index=original_idx)
end
end
@@ -481,14 +630,42 @@ function run_preprocessing_pipeline()
println("PROCESSING STEP: $step")
println("-"^60)
- if step == "baseline_correction"
- @time apply_baseline_correction(current_spectra, auto_params[:BaselineCorrection], msi_data)
+ if step == "stabilization"
+ print_step_header("Intensity Transformation (Stabilization)")
+ method = get(auto_params[:Stabilization], :method, :sqrt)
+ println(" Method: $method")
+
+ # Safely plot the first spectrum before transformation
+ if !isempty(current_spectra)
+ s = current_spectra[1]
+ if validate_spectrum(s.mz, s.intensity)
+ # Use a temporary spectrum to plot before and after
+ initial_intensity = deepcopy(s.intensity)
+ plot_spectrum_step(s.mz, initial_intensity, "stabilization_before", spectrum_index=s.id)
+ end
+ end
+
+ @time apply_intensity_transformation(current_spectra, auto_params[:Stabilization])
+
+ # Safely plot the first spectrum after transformation
+ if !isempty(current_spectra)
+ s = current_spectra[1]
+ if validate_spectrum(s.mz, s.intensity)
+ plot_spectrum_step(s.mz, s.intensity, "stabilization_after", spectrum_index=s.id)
+ end
+ end
+
+ elseif step == "baseline_correction"
+ @time apply_baseline_correction_core(current_spectra, auto_params[:BaselineCorrection], msi_data)
elseif step == "smoothing"
apply_smoothing(current_spectra, auto_params[:Smoothing])
elseif step == "peak_picking"
@time apply_peak_picking(current_spectra, auto_params[:PeakPicking])
+
+ elseif step == "peak_selection"
+ @time apply_peak_selection(current_spectra, auto_params[:PeakSelection])
elseif step == "calibration"
@time apply_calibration(current_spectra, auto_params[:Calibration], reference_peaks)
@@ -497,14 +674,14 @@ function run_preprocessing_pipeline()
@time apply_peak_alignment(current_spectra, auto_params[:PeakAlignment])
elseif step == "normalization"
- @time apply_normalization(current_spectra, auto_params[:Normalization])
+ @time apply_normalization_core(current_spectra, auto_params[:Normalization])
elseif step == "peak_binning"
# This step is different as it generates the final matrix, not modifying spectra in-place
- feature_matrix, bin_definitions = @time apply_peak_binning(current_spectra, auto_params[:PeakBinningParams])
+ feature_matrix, bin_info = @time apply_peak_binning(current_spectra, auto_params[:PeakBinning])
if feature_matrix !== nothing
- @time save_feature_matrix(feature_matrix, bin_definitions)
+ @time save_feature_matrix(feature_matrix, bin_info)
end
else
+
+
+
+JuliaMSI
+
+
diff --git a/app_snippet.jl b/app_snippet.jl
new file mode 100644
index 0000000..118af40
--- /dev/null
+++ b/app_snippet.jl
@@ -0,0 +1,1524 @@
+# app.jl
+
+module App
+# ==Packages ==
+using GenieFramework
+using Pkg
+using Libz
+using PlotlyBase
+using CairoMakie
+using Colors
+using MSI_src # Import the new MSIData library
+using Statistics
+using NaturalSort
+using Images
+using LinearAlgebra
+using NativeFileDialog # Opens the file explorer depending on the OS
+using StipplePlotly
+using Base.Filesystem: mv # To rename files in the system
+using Printf # Required for @sprintf macro in colorbar generation
+using JSON
+using Dates
+using Base.Threads
+
+# Bring MSIData into App module's scope
+using .MSI_src: MSIData, OpenMSIData, process_spectrum, IterateSpectra, ImzMLSource, _iterate_spectra_fast, MzMLSource, find_mass, ViridisPalette, get_mz_slice, get_multiple_mz_slices, quantize_intensity, save_bitmap, median_filter, save_bitmap, downsample_spectrum, TrIQ, precompute_analytics, ImportMzmlFile, generate_colorbar_image, load_and_prepare_mask, set_global_mz_range!, main_precalculation, MutableSpectrum
+
+if !@isdefined(increment_image)
+ include("./julia_imzML_visual.jl")
+end
+
+# --- Memory Validation Logging ---
+if get(ENV, "GENIE_ENV", "dev") != "prod"
+ function get_rss_mb()
+ if !Sys.islinux()
+ return 0.0
+ end
+ try
+ pid = getpid()
+ cmd = `ps -p $pid -o rss=`
+ rss_kb_str = read(cmd, String)
+ rss_kb = parse(Int, strip(rss_kb_str))
+ return round(rss_kb / 1024, digits=2)
+ catch e
+ @warn "Could not get RSS via `ps` command. Error: $e"
+ return 0.0
+ end
+ end
+
+ function log_memory_usage(context::String, msi_data_val)
+ rss_mb = get_rss_mb()
+
+ msi_data_size_mb = 0
+ if msi_data_val !== nothing
+ msi_data_size_mb = round(Base.summarysize(msi_data_val) / (1024^2), digits=2)
+ end
+
+ gc_time_s = round(GC.time(), digits=3)
+
+ println("--- MEMORY LOG [$(context)] ---")
+ println(" Timestamp: $(now())")
+ println(" Process RSS: $(rss_mb) MB")
+ println(" msi_data size: $(msi_data_size_mb) MB")
+ println(" Cumulative GC time: $(gc_time_s) s")
+ println("--------------------------")
+ end
+else
+ log_memory_usage(context::String, msi_data_val) = nothing # No-op for production
+end
+
+@genietools
+
+# == Reactive code ==
+# Reactive code to make the UI interactive
+@app begin
+ # == Loading Screen Variables ==
+ @in is_initializing = true
+ @in initialization_message = "Initializing..."
+
+ # == Reactive variables ==
+ # reactive variables exist in both the Julia backend and the browser with two-way synchronization
+ # @out variables can only be modified by the backend
+ # @in variables can be modified by both the backend and the browser
+ # variables must be initialized with constant values, or variables defined outside of the @app block
+
+ ## Interface non Variables
+ @out btnStartDisable=true
+ @out btnPlotDisable=false
+ @out btnSpectraDisable=false
+ # Loading animations
+ @in progress=false
+ @in progressPlot=false
+ @in progressSpectraPlot=false
+ # Text field validations
+ @in triqEnabled=false
+ @in SpectraEnabled=false
+ @in MFilterEnabled=false
+ @in maskEnabled=false
+ # Dialogs
+ @in warning_msg=false
+ @in CompareDialog=false
+
+ ## Interface Variables
+ @in file_route=""
+ @in file_name=""
+ @in Nmass="0.0"
+ @in Tol=0.1
+ @in triqProb=0.98
+ @in colorLevel=20
+
+ ## Interface Buttons
+ @in btnSearch=false # To search for files in your device
+ @in btnAddBatch = false
+ @in clear_batch_btn = false
+ @out batch_file_count = 0
+ @in mainProcess=false # To generate images
+ @in compareBtn=false # To open dialog
+ @in createMeanPlot=false # To generate mean spectrum plot
+ @in createXYPlot=false # To generate an spectrum plot according to the xy values inputed
+ @in createSumPlot=false # To generate a sum of all the spectrum plots
+ @in image3dPlot=false # To generate 3d plot based on current image
+ @in triq3dPlot=false # To generate 3d plot based on current triq image
+ @in imageCPlot=false # To generate contour plots of current image
+ @in triqCPlot=false # To generate contour plots of current triq image
+ # Image change buttons
+ @in imgPlus=false
+ @in imgMinus=false
+ @in imgPlusT=false
+ @in imgMinusT=false
+ # Image change comparative buttons
+ @in imgPlusCompLeft=false
+ @in imgMinusCompLeft=false
+ @in imgPlusTCompLeft=false
+ @in imgMinusTCompLeft=false
+ @in imgPlusCompRight=false
+ @in imgMinusCompRight=false
+ @in imgPlusTCompRight=false
+ @in imgMinusTCompRight=false
+
+ ## Tabulation variables
+ @out tabIDs=["tab0","tab1","tab2","tab3","tab4"]
+ @out tabLabels=["Image", "TrIQ", "Spectrum Plot", "Topography Plot","Surface Plot"]
+ @in selectedTab="tab0"
+ @out CompTabIDsLeft=["tab0","tab1","tab2","tab3","tab4"]
+ @out CompTabLabelsLeft=["Image", "TrIQ", "Spectrum Plot", "Topography Plot","Surface Plot"]
+ @in CompSelectedTabLeft="tab0"
+ @out CompTabIDsRight=["tab0","tab1","tab2","tab3","tab4"]
+ @out CompTabLabelsRight=["Image", "TrIQ", "Spectrum Plot", "Topography Plot","Surface Plot"]
+ @in CompSelectedTabRight="tab0"
+
+ # Interface Images
+ @out imgInt="/.bmp" # image Interface
+ @out imgIntT="/.bmp" # image Interface TrIQ
+ @out colorbar="/.png"
+ @out colorbarT="/.png"
+ # Interface controlling for the comparative view
+ @out imgIntCompLeft="/.bmp"
+ @out imgIntTCompLeft="/.bmp"
+ @out colorbarCompLeft="/.png"
+ @out colorbarTCompLeft="/.png"
+ @out imgIntCompRight="/.bmp"
+ @out imgIntTCompRight="/.bmp"
+ @out colorbarCompRight="/.png"
+ @out colorbarTCompRight="/.png"
+ @out imgWidth=0
+ @out imgHeight=0
+
+ # Optical Image Overlay & Transparency
+ @in imgTrans=1.0
+ @in progressOptical=false
+ @out btnOpticalDisable=true
+ @in btnOptical=false
+ @in btnOpticalT=false
+ @in opticalOverTriq=false
+ @out imgRoute=""
+
+ # Messages to interface variables
+ @out msg=""
+ @out msgimg=""
+ @out msgtriq=""
+ # Reiteration of the messages under the image to know which spectra is being visualized
+ @out msgimgCompLeft=""
+ @out msgtriqCompLeft=""
+ @out msgimgCompRight=""
+ @out msgtriqCompRight=""
+
+ # Centralized MSIData object
+ @out msi_data::Union{MSIData, Nothing} = nothing
+
+ # Metadata table variables
+ @in showMetadataDialog = false
+ @in showMetadataBtn = false
+ @out metadata_columns = []
+ @out metadata_rows = []
+ @out btnMetadataDisable = false
+ @in selected_folder_metadata = ""
+
+ # Saves the route where imzML and mzML files are located
+ @out full_route=""
+
+ # == Converter Tab Variables ==
+ @in left_tab = "generator"
+ @out mzml_full_route = ""
+ @out sync_full_route = ""
+ @in btnSearchMzml = false
+ @in btnSearchSync = false
+ @in convert_process = false
+ @out progress_conversion = false
+ @out msg_conversion = ""
+ @out btnConvertDisable = true
+
+ # == Pre Processing Variables ==
+ @in pre_tab = "stabilization"
+
+ ## Preprocessing Parameters
+ @in progressPrep=false
+ @in stabilization_method="sqrt"
+ @in smoothing_method="sg"
+ @in smoothing_window = ""
+ @in smoothing_order = ""
+ @in baseline_method="snip"
+ @in baseline_iterations = ""
+ @in baseline_window = ""
+ @in normalization_method="tic"
+ @in alignment_method="lowess"
+ @in alignment_span = ""
+ @in alignment_tolerance = ""
+ @in alignment_tolerance_unit="mz"
+ @in alignment_max_shift_ppm = ""
+ @in alignment_min_matched_peaks = ""
+ @in peak_picking_method="profile"
+ @in peak_picking_snr_threshold = ""
+ @in peak_picking_half_window = ""
+ @in peak_picking_min_peak_prominence = ""
+ @in peak_picking_merge_peaks_tolerance = ""
+ @in peak_picking_min_peak_width_ppm = ""
+ @in peak_picking_max_peak_width_ppm = ""
+ @in peak_picking_min_peak_shape_r2 = ""
+ @in binning_method="adaptive"
+ @in binning_tolerance = ""
+ @in binning_tolerance_unit="ppm"
+ @in binning_frequency_threshold = ""
+ @in binning_min_peak_per_bin = ""
+ @in binning_max_bin_width_ppm = ""
+ @in binning_intensity_weighted_centers=true
+ @in binning_num_uniform_bins = ""
+ @in calibration_fit_order = ""
+ @in calibration_ppm_tolerance = ""
+ @in peak_selection_min_snr = ""
+ @in peak_selection_min_fwhm_ppm = ""
+ @in peak_selection_max_fwhm_ppm = ""
+ @in peak_selection_min_shape_r2 = ""
+ @in peak_selection_frequency_threshold = ""
+ @in peak_selection_correlation_threshold = ""
+
+ @in reference_peaks_list = [
+ Dict("mz" => 137.0244, "label" => "DHB_fragment"),
+ Dict("mz" => 155.0349, "label" => "DHB_M+H"),
+ ]
+
+ # --- Methods for Reference Peaks List ---
+ function addReferencePeak()
+ push!(reference_peaks_list, Dict("mz" => 0.0, "label" => ""))
+ reference_peaks_list = deepcopy(reference_peaks_list) # Force reactivity
+ end
+
+ function removeReferencePeak(index::Int)
+ deleteat!(reference_peaks_list, index)
+ reference_peaks_list = deepcopy(reference_peaks_list) # Force reactivity
+ end
+
+ # Individual step enable/disable flags
+ @in enable_stabilization = true
+ @in enable_smoothing = true
+ @in enable_baseline = true
+ @in enable_normalization = true
+ @in enable_standards = true
+ @in enable_alignment = true
+ @in enable_peak_picking = true
+ @in enable_binning = true
+ @in enable_calibration = true
+ @in enable_peak_selection = true
+
+ # Trigger for running the full pipeline
+ @in run_full_pipeline = false
+ @out current_pipeline_step = "" # To indicate which step is currently running in the full pipeline
+
+ @in export_params_btn = false
+ @in import_params_btn = false
+ @in imported_params_file = nothing
+
+ @in suggested_smoothing_window = ""
+ @in suggested_smoothing_order = ""
+ @in suggested_baseline_iterations = ""
+ @in suggested_baseline_window = ""
+ @in suggested_alignment_span = ""
+ @in suggested_alignment_tolerance = ""
+ @in suggested_alignment_max_shift_ppm = ""
+ @in suggested_alignment_min_matched_peaks = ""
+ @in suggested_peak_picking_snr_threshold = ""
+ @in suggested_peak_picking_half_window = ""
+ @in suggested_peak_picking_min_peak_prominence = ""
+ @in suggested_peak_picking_merge_peaks_tolerance = ""
+ @in suggested_peak_picking_min_peak_width_ppm = ""
+ @in suggested_peak_picking_max_peak_width_ppm = ""
+ @in suggested_peak_picking_min_peak_shape_r2 = ""
+ @in suggested_binning_tolerance = ""
+ @in suggested_binning_frequency_threshold = ""
+ @in suggested_binning_min_peak_per_bin = ""
+ @in suggested_binning_max_bin_width_ppm = ""
+ @in suggested_binning_num_uniform_bins = ""
+ @in suggested_calibration_fit_order = ""
+ @in suggested_calibration_ppm_tolerance = ""
+ @in suggested_peak_selection_min_snr = ""
+ @in suggested_peak_selection_min_fwhm_ppm = ""
+ @in suggested_peak_selection_max_fwhm_ppm = ""
+ @in suggested_peak_selection_min_shape_r2 = ""
+ @in suggested_peak_selection_frequency_threshold = ""
+ @in suggested_peak_selection_correlation_threshold = ""
+
+ # == Batch Summary Dialog ==
+ @in showBatchSummary = false
+ @out batch_summary = ""
+
+ # == Batch Processing & Registry Variables ==
+ @private registry_init_done = false
+ @in refetch_folders = false
+ @in selected_files = String[]
+ @in available_folders = String[]
+ @in image_available_folders = String[]
+ @out registry_path = abspath(joinpath(@__DIR__, "public", "registry.json"))
+ # Progress reporting
+ @out overall_progress = 0.0
+ @out progress_message = ""
+
+ # == Folder-based UI State ==
+ @in selected_folder_main = ""
+ @in selected_folder_compare_left = ""
+ @in selected_folder_compare_right = ""
+
+
+ # For the creation of images with a more specific mass charge
+ @out text_nmass=""
+
+ # For image search image lists we apply a filter that searches specific type of images into our public folder, then we sort it in a "numerical" order
+ @in msi_bmp=sort(filter(filename -> startswith(filename, "MSI_") && endswith(filename, ".bmp"), readdir("public")),lt=natural)
+ @in col_msi_png=sort(filter(filename -> startswith(filename, "colorbar_MSI_") && endswith(filename, ".png"), readdir("public")),lt=natural)
+ @in triq_bmp=sort(filter(filename -> startswith(filename, "TrIQ_") && endswith(filename, ".bmp"), readdir("public")),lt=natural)
+ @in col_triq_png=sort(filter(filename -> startswith(filename, "colorbar_TrIQ_") && endswith(filename, ".png"), readdir("public")),lt=natural)
+
+ # Set current image for the list to display
+ @out current_msi=""
+ @out current_col_msi=""
+ @out current_triq=""
+ @out current_col_triq=""
+ # We reiterate the process to display in the comparative view
+ @out current_msiCompLeft=""
+ @out current_col_msiCompLeft=""
+ @out current_triqCompLeft=""
+ @out current_col_triqCompLeft=""
+ @out current_msiCompRight=""
+ @out current_col_msiCompRight=""
+ @out current_triqCompRight=""
+ @out current_col_triqCompRight=""
+
+ ## Time measurement variables
+ @out sTime=time()
+ @out fTime=time()
+ @out eTime=time()
+
+ ## Plots
+ # Local image to plot
+ layoutImg=PlotlyBase.Layout(
+ title=PlotlyBase.attr(
+ text="",
+ font=PlotlyBase.attr(
+ family="Roboto, Lato, sans-serif",
+ size=14,
+ color="black"
+ )
+ ),
+ xaxis=PlotlyBase.attr(
+ visible=false,
+ scaleanchor="y",
+ range=[0, 0]
+ ),
+ yaxis=PlotlyBase.attr(
+ visible=false,
+ range=[0, 0]
+ ),
+ margin=attr(l=0,r=0,t=0,b=0,pad=0)
+ )
+ traceImg=PlotlyBase.heatmap(x=Vector{Float64}(), y=Vector{Float64}())
+ @out plotdataImg=[traceImg]
+ @out plotlayoutImg=layoutImg
+ # For the image in the comparative view
+ @out plotdataImgCompLeft=[traceImg]
+ @out plotlayoutImgCompLeft=layoutImg
+ @out plotdataImgCompRight=[traceImg]
+ @out plotlayoutImgCompRight=layoutImg
+
+ # For triq image
+ @out plotdataImgT=[traceImg]
+ @out plotlayoutImgT=layoutImg
+ # For the triq image in the comparative view
+ @out plotdataImgTCompLeft=[traceImg]
+ @out plotlayoutImgTCompLeft=layoutImg
+ @out plotdataImgTCompRight=[traceImg]
+ @out plotlayoutImgTCompRight=layoutImg
+ # Interface Plot Spectrum
+ layoutSpectra=PlotlyBase.Layout(
+ title=PlotlyBase.attr(
+ text="Spectrum plot",
+ font=PlotlyBase.attr(
+ family="Roboto, Lato, sans-serif",
+ size=18,
+ color="black"
+ )
+ ),
+ hovermode="closest",
+ xaxis=PlotlyBase.attr(
+ title="m/z",
+ showgrid=true
+ ),
+ yaxis=PlotlyBase.attr(
+ title="Intensity",
+ showgrid=true,
+ tickformat = ".3g"
+ ),
+ margin=attr(l=0,r=0,t=120,b=0,pad=0)
+ )
+ # Dummy 2D scatter plot
+ traceSpectra=PlotlyBase.scatter(x=Vector{Float64}(), y=Vector{Float64}(), mode="lines", marker=attr(size=1, color="blue", opacity=0.1))
+ # Create conection to frontend
+ @out plotdata=[traceSpectra]
+ @out plotlayout=layoutSpectra
+ @in xCoord=0
+ @in yCoord=0
+ @out xSpectraMz = Vector{Float64}()
+ @out ySpectraMz = Vector{Float64}()
+
+ # UI plot data for Preprocessing
+ @out plotdata_before = [traceSpectra]
+ @out plotlayout_before = layoutSpectra
+ @out plotdata_after = [traceSpectra]
+ @out plotlayout_after = layoutSpectra
+
+ # Interactive plot reactions
+ @in data_click=Dict{String,Any}()
+ #@in data_selected=Dict{String,Any}() # Selected is for areas, this can work for the masks
+ #
+
+
+
+
+
+
+
+
+
+
+ {{ file }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ file }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ imzML & mzML Data Pre-Treatment
+
+
+
+
+
+ +
+
+
+ Method
+ Applies a variance-stabilizing transformation to the intensity vector.
+ +
+
+
+
+
Method
+ The smoothing algorithm.
+ +
+
Parameters
+ Method
+ The algorithm to use for baseline correction.
+ +
+
+
Parameters
+ Method
+ The normalization method to apply.
+ +
+
+
+
Method
+ The alignment algorithm.
+ +
+
+
Parameters
+ Define Internal Standards / Reference Peaks
+ Provide m/z values and optional labels for internal standards or reference peaks. These are used for mass calibration and alignment.
+
+
+
+
+
+
+ This step uses the peaks defined in the 'Internal Standards' tab to correct the m/z axis.
+Parameters
+ Select the appropriate peak picking method and set its parameters.
+Method
+ The peak detection algorithm.
+ +
+
+
Parameters
+ Peak Quality Filters
+ Method
+ The binning strategy.
+ +
+
Parameters
+ imzML & mzML Data Processor
+ Please make sure the ibd and imzML file are located in the same directory and have the same name.
+
It may take a while to generate the slice / spectrum, please be patient.
+
To generate the contour or surface plots, you have to select the desired slice first using the
+ interface.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Mean spectrum plot
+
+
+
+
+ Sum Spectrum plot
+
+
+
+
+ Spectrum plot (X,Y)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ progress_message }}
+ {{msg}}
+
+
+
+
+
+
+ Image topography Plot
+
+
+
+
+
+ TrIQ topography Plot
+
+
+
+
+
+ Image surface Plot
+
+
+
+
+
+ TrIQ Surface Plot
+
+
+
+
+
+
+
+ Over normal image
+
+
+
+
+ Over TrIQ image
+
+
+
+
+
+ Transparency: {{ imgTrans }}
+
+ mzML to imzML Converter
+ Select the .mzML file and the corresponding .txt synchronization file to convert them into an .imzML/.ibd + pair.
+{{msg_conversion}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Spectrum View
+ Before Preprocessing
+ After Preprocessing
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Image visualizer
+
+
+
+
+
+
+
+
+
+
+ TrIQ visualizer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Mean spectrum plot
+
+
+
+
+ Sum Spectrum plot
+
+
+
+
+ Spectrum plot (X,Y)
+
+
+
+
+
+