Add experiments

.gitignore

@@ -39,4 +39,5 @@ bin/
 .vscode/
 
 ### Mac OS ###
-.DS_Store
\ No newline at end of file
+.DS_Store
+cache

.idea/groovyc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GroovyCompilerProjectConfiguration">
+    <option name="invokeDynamic" value="true" />
+  </component>
+</project>
\ No newline at end of file

build.gradle

@@ -11,12 +11,31 @@ repositories {
     maven { url "https://jitpack.io" }
 }
 
+sourceSets {
+    experiments {
+        groovy.srcDir "$projectDir/src/experiments/groovy"
+        resources.srcDir "$projectDir/src/experiments/resources"
+        compileClasspath += main.output + test.output
+        runtimeClasspath += main.output + test.output
+    }
+}
+configurations {
+    experimentsImplementation.extendsFrom testImplementation
+    experimentsRuntime.extendsFrom testRuntime
+}
+tasks.register('experimentsTest', Test) {
+    group = "verification"
+    testClassesDirs = sourceSets.experiments.output.classesDirs
+    classpath = sourceSets.experiments.runtimeClasspath
+}
+
 dependencies {
     // AMAK (Only one of the next two lines should be uncommented. Also, settings.gradle file should also be modified)
      implementation 'com.github.alexandreprl:amak:3.1.0' // Uncomment this line to get AMAK from git repository (The last part matches a tag, a commit hash or the last commit of a branch : branchName-SNAPSHOT
 //    implementation project(':amak') // Uncomment this line to get AMAK from local
 
-    
+     implementation 'com.github.alexandreprl:lxplot:main-SNAPSHOT'
+
     testImplementation platform('org.junit:junit-bom:5.9.1')
     testImplementation 'org.junit.jupiter:junit-jupiter'
 

src/experiments/groovy/TemperatureClustering.groovy

+import fr.irit.smac.amas4dc.AMAS4DC
+import fr.irit.smac.amas4dc.amas.AMASOption
+import fr.irit.smac.amas4dc.amas.MASSettings
+import fr.irit.smac.amas4dc.cluster.Cluster
+import fr.irit.smac.amas4dc.cluster.DataPoint
+import fr.irit.smac.amas4dc.cluster.DataPointFuser
+import fr.irit.smac.amas4dc.cluster.SimilarityScoreMethod
+import fr.irit.smac.lxplot.LxPlot
+import groovy.transform.ToString
+
+import javax.swing.*
+import java.awt.*
+import java.util.List
+
+class TemperatureClustering {
+	static void main(String[] args) {
+
+		def amas4dc = new AMAS4DC<TemperatureDataPoint>(new MASSettings<TemperatureDataPoint>(new TemperatureSimilarityMethod(),
+		                                                                                      0.5f,
+		                                                                                      EnumSet.noneOf(AMASOption),
+		                                                                                      new TemperatureDataPointFuser()))
+
+//		11 juin 2023
+//		https://www.infoclimat.fr/observations-meteo/archives/11/juin/2023/paris-montsouris/07156.html
+		def initialData = [
+				new TemperatureDataPoint(21.9, 0),
+				new TemperatureDataPoint(21.8, 1),
+				new TemperatureDataPoint(21.7, 2),
+				new TemperatureDataPoint(21.2, 3),
+				new TemperatureDataPoint(21.1, 4),
+				new TemperatureDataPoint(20.6, 5),
+				new TemperatureDataPoint(20.5, 6),
+				new TemperatureDataPoint(20.8, 7),
+				new TemperatureDataPoint(21.3, 8),
+				new TemperatureDataPoint(22.6, 9),
+				new TemperatureDataPoint(23.9, 10),
+				new TemperatureDataPoint(24.9, 11),
+				new TemperatureDataPoint(25.7, 12),
+				new TemperatureDataPoint(26.8, 13),
+				new TemperatureDataPoint(25.8, 14),
+				new TemperatureDataPoint(25.4, 15),
+				new TemperatureDataPoint(24.8, 16),
+				new TemperatureDataPoint(24.9, 17),
+				new TemperatureDataPoint(24.1, 18),
+				new TemperatureDataPoint(23.9, 19),
+				new TemperatureDataPoint(24.1, 20),
+				new TemperatureDataPoint(22.1, 21),
+				new TemperatureDataPoint(18.9, 22),
+				new TemperatureDataPoint(18.8, 23)
+		]
+
+
+		def frame = new JFrame()
+		def plotter = new Plotter()
+		frame.setContentPane(plotter)
+		frame.setSize(1400, 700)
+		frame.setVisible(true)
+
+		for (i in 0..<initialData.size()) {
+			def data = initialData.subList(i, i + 1)
+			plotter.renderInputData(initialData.subList(0, i + 1))
+			amas4dc.fit(data)
+			var results = amas4dc.retrieveClusters()
+			println(results)
+			plotter.renderClusters(results.clusters())
+			sleep(1000)
+		}
+	}
+
+	@ToString
+	static class TemperatureDataPoint implements DataPoint {
+		double degrees
+		double startTime, endTime
+		double averageTime
+
+		TemperatureDataPoint(double degrees, double startTime, double endTime) {
+			this.degrees = degrees
+			this.startTime = startTime
+			this.endTime = endTime
+			this.averageTime = (startTime + endTime) / 2
+		}
+
+		TemperatureDataPoint(double degrees, double time) {
+			this(degrees, time, time)
+		}
+	}
+
+	static class TemperatureDataPointFuser implements DataPointFuser<TemperatureDataPoint> {
+
+		@Override
+		TemperatureDataPoint apply(TemperatureDataPoint dp1, TemperatureDataPoint dp2) {
+			def newStartTime = dp1.startTime
+			def newEndTime = dp1.endTime
+			if (dp2.startTime < newStartTime)
+				newStartTime = dp2.startTime
+			if (dp2.endTime > newEndTime)
+				newEndTime = dp2.endTime
+			return new TemperatureDataPoint(dp1.degrees * 0.9 + dp2.degrees * 0.1, newStartTime, newEndTime)
+		}
+	}
+
+	static class TemperatureSimilarityMethod implements SimilarityScoreMethod<TemperatureDataPoint> {
+
+		@Override
+		float apply(TemperatureDataPoint dp1, TemperatureDataPoint dp2) {
+			var temporallySimilar = false
+			if (dp1.endTime < dp2.startTime) {
+				if (dp2.startTime - dp1.endTime < 2)
+					temporallySimilar = true
+				else
+					temporallySimilar = false
+			} else if (dp2.endTime < dp1.startTime) {
+				if (dp1.startTime - dp2.endTime < 2)
+					temporallySimilar = true
+				else
+					temporallySimilar = false
+			}
+			if (Math.abs(dp1.degrees - dp2.degrees) < 1 && temporallySimilar)
+				return 1;
+			return 0;
+		}
+
+		@Override
+		boolean areRoughlySimilar(TemperatureDataPoint dp1, TemperatureDataPoint dp2) {
+			return true
+		}
+	}
+
+	static class Plotter extends JPanel {
+		ArrayList<TemperatureDataPoint> inputData
+		List<Cluster<TemperatureDataPoint>> clusters
+		Map<String, Color> clustersColors = new HashMap<>()
+
+		@Override
+		protected void paintComponent(Graphics g) {
+			var g2d = (Graphics2D) g
+
+			if (inputData == null)
+				return
+			g2d.setColor(Color.white)
+			g2d.fillRect(0, 0, 1400, 700)
+			g2d.setColor(Color.BLACK)
+			g2d.drawLine(timeToX(0), degreeToY(0), timeToX(24), degreeToY(0))
+			g2d.drawLine(timeToX(0), degreeToY(0), timeToX(0), degreeToY(30))
+
+			for (def tdp : inputData) {
+				g2d.drawOval(timeToX(tdp.startTime) - 3, degreeToY(tdp.degrees) - 3, 6, 6)
+			}
+			def random = new Random()
+			for (def c : clusters) {
+				def color = clustersColors.computeIfAbsent(c.id, id -> new Color(random.nextFloat(), random.nextFloat(), random.nextFloat()))
+				g2d.setColor(Color.BLUE)
+				g2d.setStroke(new BasicStroke(2))
+				g2d.drawLine(timeToX(c.representative.startTime), degreeToY(c.representative.degrees), timeToX(c.representative.endTime), degreeToY(c.representative.degrees))
+			}
+			g2d.setColor(Color.BLACK)
+			for (i in 0..<24) {
+				g2d.drawString(i + "", timeToX(i), 665)
+			}
+			g2d.drawString("Hour of the day", timeToX(24), 665)
+			for (i in 0..<30) {
+				g2d.drawString(i + "", 10, degreeToY(i))
+			}
+			g2d.drawString("Temperature °C", 10, degreeToY(30))
+
+		}
+
+		int timeToX(double time) {
+			return (int) (time * 40) + 50
+		}
+
+		int degreeToY(double degree) {
+			return 650 - (int) (degree * 20)
+		}
+
+		void renderInputData(List<TemperatureDataPoint> inputDataList) {
+			this.inputData = inputDataList
+			repaint();
+		}
+
+		void renderClusters(List<Cluster<TemperatureDataPoint>> clusters) {
+			this.clusters = clusters
+			repaint()
+		}
+	}
+}

src/experiments/groovy/TwoDimensionsPointsClustering.groovy

+import fr.irit.smac.amas4dc.AMAS4DC
+import fr.irit.smac.amas4dc.amas.AMASOption
+import fr.irit.smac.amas4dc.amas.MASSettings
+import fr.irit.smac.amas4dc.cluster.Cluster
+import fr.irit.smac.amas4dc.cluster.DataPoint
+import fr.irit.smac.amas4dc.cluster.SimilarityScoreMethod
+import fr.irit.smac.lxplot.LxPlot
+import fr.irit.smac.lxplot.commons.ChartType
+import groovy.transform.ToString
+
+import java.awt.geom.Point2D
+
+class TwoDimensionsPointsClustering {
+	static void main(String[] args) {
+
+		def amas4dc = new AMAS4DC<TwoDimensionsDataPoint>(new MASSettings(new TwoDimensionsSimilarityMethod(), 0.5f, EnumSet.noneOf(AMASOption), (TwoDimensionsDataPoint dp1, TwoDimensionsDataPoint dp2) -> {
+			return new TwoDimensionsDataPoint(new Point2D.Double((dp1.getPoint2D().getX() + dp2.getPoint2D().getX()) / 2,
+			                                                     (dp1.getPoint2D().getY() + dp2.getPoint2D().getY()) / 2))
+		}))
+
+		LxPlot.getChart("Data", ChartType.PLOT);
+		def initialData = [new TwoDimensionsDataPoint(new Point2D.Double(1.0, 1.0)), new TwoDimensionsDataPoint(new Point2D.Double(2.0, 2.0))]
+		render(initialData)
+		amas4dc.fit(initialData)
+		var results = amas4dc.retrieveClusters()
+		println(results)
+		render(results.clusters())
+	}
+
+	static void render(ArrayList<TwoDimensionsDataPoint> twoDimensionsDataPoints) {
+		for (def tddp : twoDimensionsDataPoints) {
+			LxPlot.getChart("Data").add("Initial", tddp.point2D.getX(), tddp.getPoint2D().getY())
+		}
+	}
+
+	static void render(List<Cluster<TwoDimensionsDataPoint>> clusters) {
+		for (def c : clusters) {
+			LxPlot.getChart("Data").add("Cluster representative point", c.getRepresentative().point2D.getX(), c.getRepresentative().point2D.getY())
+		}
+	}
+
+	@ToString
+	static class TwoDimensionsDataPoint implements DataPoint {
+		Point2D.Double point2D
+
+		TwoDimensionsDataPoint(Point2D.Double point2D) {
+			this.point2D = point2D
+		}
+	}
+
+	static class TwoDimensionsSimilarityMethod implements SimilarityScoreMethod<TwoDimensionsDataPoint> {
+
+		@Override
+		float apply(TwoDimensionsDataPoint dp1, TwoDimensionsDataPoint dp2) {
+			if (dp1.point2D.distance(dp2.point2D) < 10)
+				return 1;
+			return 0
+		}
+
+		@Override
+		boolean areRoughlySimilar(TwoDimensionsDataPoint dp1, TwoDimensionsDataPoint dp2) {
+			return true
+		}
+	}
+}