Fix bugs in the dataset source package

Author: nathanielsherry

LibPeakaboo/src/main/java/org/peakaboo/dataset/source/model/components/datasize/SimpleDataSize.java

@@ -32,7 +32,7 @@ public Coord<Integer> getDataDimensions() {
 	@Override
 	public Coord<Integer> getDataCoordinatesAtIndex(int index) throws IndexOutOfBoundsException {
 		int cx = index % dataWidth;
-		int cy = (index - cx) / dataHeight;
+		int cy = (index - cx) / dataWidth;
 		return new Coord<>(cx, cy);
 	}
 

LibPeakaboo/src/main/java/org/peakaboo/dataset/source/model/components/scandata/analysis/DataSourceAnalysis.java

@@ -76,6 +76,11 @@ public int scanCount() {
 
 	public static DataSourceAnalysis merge(List<Analysis> analyses) {
 		DataSourceAnalysis result = new DataSourceAnalysis();
+		
+		// Remove any empty analyses and exit fast if none are left after
+		analyses = analyses.stream().filter(a -> a.scanCount() > 0).toList();
+		if (analyses.size() == 0) { return result; }
+		
 		result.init(analyses.get(0).channelsPerScan());
 		for (var analysis : analyses) {
 			SpectrumCalculations.addLists_inplace(result.summedSpectrum, analysis.summedPlot());

LibPeakaboo/src/test/java/org/peakaboo/dataset/source/model/components/datasize/SimpleDataSizeTest.java

@@ -0,0 +1,96 @@
+package org.peakaboo.dataset.source.model.components.datasize;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.peakaboo.framework.accent.Coord;
+
+public class SimpleDataSizeTest {
+
+    private SimpleDataSize makeSize(int width, int height) {
+        SimpleDataSize size = new SimpleDataSize();
+        size.setDataWidth(width);
+        size.setDataHeight(height);
+        return size;
+    }
+
+    @Test
+    public void testNonSquareWide() {
+        // 5 columns x 3 rows
+        SimpleDataSize size = makeSize(5, 3);
+
+        // index 0 => (0,0)
+        Coord<Integer> c0 = size.getDataCoordinatesAtIndex(0);
+        Assert.assertEquals(0, (int) c0.x);
+        Assert.assertEquals(0, (int) c0.y);
+
+        // index 4 => (4,0) — end of first row
+        Coord<Integer> c4 = size.getDataCoordinatesAtIndex(4);
+        Assert.assertEquals(4, (int) c4.x);
+        Assert.assertEquals(0, (int) c4.y);
+
+        // index 5 => (0,1) — start of second row
+        Coord<Integer> c5 = size.getDataCoordinatesAtIndex(5);
+        Assert.assertEquals(0, (int) c5.x);
+        Assert.assertEquals(1, (int) c5.y);
+
+        // index 11 => (1,2)
+        Coord<Integer> c11 = size.getDataCoordinatesAtIndex(11);
+        Assert.assertEquals(1, (int) c11.x);
+        Assert.assertEquals(2, (int) c11.y);
+
+        // index 14 => (4,2) — last element
+        Coord<Integer> c14 = size.getDataCoordinatesAtIndex(14);
+        Assert.assertEquals(4, (int) c14.x);
+        Assert.assertEquals(2, (int) c14.y);
+    }
+
+    @Test
+    public void testNonSquareTall() {
+        // 3 columns x 5 rows
+        SimpleDataSize size = makeSize(3, 5);
+
+        // index 4 => (1,1)
+        Coord<Integer> c4 = size.getDataCoordinatesAtIndex(4);
+        Assert.assertEquals(1, (int) c4.x);
+        Assert.assertEquals(1, (int) c4.y);
+
+        // index 14 => (2,4) — last element
+        Coord<Integer> c14 = size.getDataCoordinatesAtIndex(14);
+        Assert.assertEquals(2, (int) c14.x);
+        Assert.assertEquals(4, (int) c14.y);
+    }
+
+    @Test
+    public void testSquare() {
+        SimpleDataSize size = makeSize(4, 4);
+
+        Coord<Integer> c5 = size.getDataCoordinatesAtIndex(5);
+        Assert.assertEquals(1, (int) c5.x);
+        Assert.assertEquals(1, (int) c5.y);
+
+        Coord<Integer> c15 = size.getDataCoordinatesAtIndex(15);
+        Assert.assertEquals(3, (int) c15.x);
+        Assert.assertEquals(3, (int) c15.y);
+    }
+
+    @Test
+    public void testRoundTrip() {
+        // For every index in a non-square grid, verify index -> coords -> index
+        SimpleDataSize size = makeSize(5, 3);
+        int total = 5 * 3;
+        for (int i = 0; i < total; i++) {
+            Coord<Integer> c = size.getDataCoordinatesAtIndex(i);
+            int reconstructed = c.y * 5 + c.x;
+            Assert.assertEquals("Round-trip failed for index " + i, i, reconstructed);
+        }
+    }
+
+    @Test
+    public void testDimensions() {
+        SimpleDataSize size = makeSize(7, 3);
+        Coord<Integer> dims = size.getDataDimensions();
+        Assert.assertEquals(7, (int) dims.x);
+        Assert.assertEquals(3, (int) dims.y);
+    }
+
+}

LibPeakaboo/src/test/java/org/peakaboo/dataset/source/model/components/scandata/analysis/DataSourceAnalysisTest.java

@@ -0,0 +1,83 @@
+package org.peakaboo.dataset.source.model.components.scandata.analysis;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.peakaboo.framework.cyclops.spectrum.ArraySpectrum;
+import org.peakaboo.framework.cyclops.spectrum.Spectrum;
+
+public class DataSourceAnalysisTest {
+
+    @Test
+    public void testMergeEmptyList() {
+        DataSourceAnalysis result = DataSourceAnalysis.merge(new ArrayList<>());
+        Assert.assertEquals(-1, result.channelsPerScan());
+        Assert.assertEquals(0, result.scanCount());
+    }
+
+    @Test
+    public void testMergeAllZeroScanCount() {
+        // Analyses that never processed any data
+        DataSourceAnalysis a = new DataSourceAnalysis();
+        DataSourceAnalysis b = new DataSourceAnalysis();
+        DataSourceAnalysis result = DataSourceAnalysis.merge(List.of(a, b));
+        Assert.assertEquals(-1, result.channelsPerScan());
+        Assert.assertEquals(0, result.scanCount());
+    }
+
+    @Test
+    public void testMergeTwoAnalyses() {
+        DataSourceAnalysis a = new DataSourceAnalysis();
+        a.process(new ArraySpectrum(new float[]{1.0f, 2.0f, 3.0f}, false));
+        a.process(new ArraySpectrum(new float[]{4.0f, 5.0f, 6.0f}, false));
+
+        DataSourceAnalysis b = new DataSourceAnalysis();
+        b.process(new ArraySpectrum(new float[]{10.0f, 20.0f, 30.0f}, false));
+
+        DataSourceAnalysis result = DataSourceAnalysis.merge(List.of(a, b));
+
+        Assert.assertEquals(3, result.channelsPerScan());
+        Assert.assertEquals(3, result.scanCount());
+
+        // Summed: (1+4+10, 2+5+20, 3+6+30) = (15, 27, 39)
+        Spectrum summed = new ArraySpectrum(result.summedPlot());
+        Assert.assertEquals(15.0f, summed.get(0), 1e-5f);
+        Assert.assertEquals(27.0f, summed.get(1), 1e-5f);
+        Assert.assertEquals(39.0f, summed.get(2), 1e-5f);
+
+        // Maximum: max(4,10), max(5,20), max(6,30) = (10, 20, 30)
+        Spectrum max = new ArraySpectrum(result.maximumPlot());
+        Assert.assertEquals(10.0f, max.get(0), 1e-5f);
+        Assert.assertEquals(20.0f, max.get(1), 1e-5f);
+        Assert.assertEquals(30.0f, max.get(2), 1e-5f);
+
+        // Max intensity: max(6, 30) = 30
+        Assert.assertEquals(30.0f, result.maximumIntensity(), 1e-5f);
+    }
+
+    @Test
+    public void testSingleAnalysisProcess() {
+        DataSourceAnalysis a = new DataSourceAnalysis();
+        a.process(new ArraySpectrum(new float[]{2.0f, 4.0f}, false));
+        a.process(new ArraySpectrum(new float[]{6.0f, 8.0f}, false));
+
+        Assert.assertEquals(2, a.channelsPerScan());
+        Assert.assertEquals(2, a.scanCount());
+
+        // Average: (8/2, 12/2) = (4, 6)
+        Spectrum avg = new ArraySpectrum(a.averagePlot());
+        Assert.assertEquals(4.0f, avg.get(0), 1e-5f);
+        Assert.assertEquals(6.0f, avg.get(1), 1e-5f);
+    }
+
+    @Test
+    public void testNullSpectrumIgnored() {
+        DataSourceAnalysis a = new DataSourceAnalysis();
+        a.process(null);
+        Assert.assertEquals(-1, a.channelsPerScan());
+        Assert.assertEquals(0, a.scanCount());
+    }
+
+}