Simplify VES curves functions

lilvadim · lilvadim · commit cb5b6a4bc301 · 2025-09-01T13:01:40.000+07:00
diff --git a/src/main/java/ru/nucodelabs/gem/fxmodel/ves/app/VesFxAppModel.kt b/src/main/java/ru/nucodelabs/gem/fxmodel/ves/app/VesFxAppModel.kt
@@ -10,7 +10,7 @@ import ru.nucodelabs.geo.ves.calc.initialModel.MIN_TARGET_FUNCTION_VALUE
 import ru.nucodelabs.kfx.snapshot.HistoryManager
 
 /**
- * Сюда по-хорошему надо вынести функционал из контроллеров
+ * TODO: Сюда по-хорошему надо вынести функционал из контроллеров
  */
 class VesFxAppModel @Inject constructor(
     selectedIndexObservable: IntegerProperty,
diff --git a/src/main/java/ru/nucodelabs/gem/view/controller/charts/MisfitStacksController.kt b/src/main/java/ru/nucodelabs/gem/view/controller/charts/MisfitStacksController.kt
@@ -20,7 +20,7 @@ import ru.nucodelabs.gem.fxmodel.ves.app.VesFxAppModel
 import ru.nucodelabs.gem.view.AlertsFactory
 import ru.nucodelabs.gem.view.control.chart.log.LogarithmicAxis
 import ru.nucodelabs.geo.ves.Picket
-import ru.nucodelabs.geo.ves.calc.graph.vesCurvesContext
+import ru.nucodelabs.geo.ves.calc.graph.experimentalCurve
 import ru.nucodelabs.kfx.core.AbstractViewController
 import ru.nucodelabs.kfx.ext.Point
 import ru.nucodelabs.kfx.ext.forCharts
@@ -89,7 +89,7 @@ class MisfitStacksController @Inject constructor(
         var misfitStacksSeriesList: MutableList<Series<Number, Number>> = ArrayList()
         try {
             val misfits = appModel.misfits()
-            val expPoints = picket.vesCurvesContext.experimentalCurve
+            val expPoints = experimentalCurve(picket)
 
             misfitStacksSeriesList = observableListOf()
 
diff --git a/src/main/java/ru/nucodelabs/gem/view/controller/charts/VesCurvesController.kt b/src/main/java/ru/nucodelabs/gem/view/controller/charts/VesCurvesController.kt
@@ -32,8 +32,7 @@ import ru.nucodelabs.geo.forward.ForwardSolver
 import ru.nucodelabs.geo.ves.Picket
 import ru.nucodelabs.geo.ves.Section
 import ru.nucodelabs.geo.ves.calc.effectiveToSortedIndicesMapping
-import ru.nucodelabs.geo.ves.calc.graph.VesCurvesContext
-import ru.nucodelabs.geo.ves.calc.graph.vesCurvesContext
+import ru.nucodelabs.geo.ves.calc.graph.*
 import ru.nucodelabs.geo.ves.calc.resistanceApparentLowerBoundByError
 import ru.nucodelabs.geo.ves.calc.resistanceApparentUpperBoundByError
 import ru.nucodelabs.geo.ves.calc.zOfModelLayers
@@ -93,7 +92,6 @@ class VesCurvesController @Inject constructor(
 
     private val isModelVisible = SimpleBooleanProperty(true)
 
-    private lateinit var vesCurvesContext: VesCurvesContext
     private var effectiveToSortedMapping = intArrayOf()
 
     private lateinit var uiProperties: ResourceBundle
@@ -118,7 +116,6 @@ class VesCurvesController @Inject constructor(
 
         picketObservable.addListener { _, _, newValue: Picket? ->
             if (newValue != null) {
-                vesCurvesContext = picket.vesCurvesContext
                 if (isDraggingModel) {
                     updateTheoreticalCurve()
                     applyStyle()
@@ -144,8 +141,8 @@ class VesCurvesController @Inject constructor(
 
     private fun initData(): ObjectProperty<ObservableList<Series<Number, Number>>> {
         return SimpleObjectProperty(
-            FXCollections.observableArrayList<Series<Number, Number>>().also {
-                for (i in 0..<TOTAL_COUNT) it += Series<Number, Number>()
+            FXCollections.observableArrayList<Series<Number, Number>>().apply {
+                (0..<TOTAL_COUNT).forEach { _ -> add(Series<Number, Number>()) }
             }
         )
     }
@@ -277,7 +274,7 @@ class VesCurvesController @Inject constructor(
         val theorCurveSeries = Series<Number, Number>()
         try {
             theorCurveSeries.data.addAll(
-                vesCurvesContext.theoreticalCurveBy(forwardSolver).map { (x, y) -> Data(x as Number, y as Number) }
+                theoreticalCurve(picket, forwardSolver).map { (x, y) -> Data(x as Number, y as Number) }
             )
         } catch (e: UnsatisfiedLinkError) {
             alertsFactory.unsatisfiedLinkErrorAlert(e, stage)
@@ -289,7 +286,7 @@ class VesCurvesController @Inject constructor(
     private fun updateModelCurve() {
         val modelCurveSeries = Series<Number, Number>()
         modelCurveSeries.data.addAll(
-            vesCurvesContext.modelStepGraph().map { (x, y) -> Data(x as Number, y as Number) }
+            modelStepGraph(picket).map { (x, y) -> Data(x as Number, y as Number) }
         )
         modelCurveSeries.name = uiProperties["modCurve"]
         dataProperty.get()[MOD_CURVE_SERIES_INDEX] = modelCurveSeries
@@ -331,26 +328,26 @@ class VesCurvesController @Inject constructor(
 
     private fun updateExpCurves() {
         val expCurveSeries = Series(
-            vesCurvesContext.experimentalCurve.map { (x, y) -> Data(x as Number, y as Number) }.toObservableList()
+            experimentalCurve(picket).map { (x, y) -> Data(x as Number, y as Number) }.toObservableList()
         )
         expCurveSeries.name = uiProperties["expCurve"]
 
         val errUpperExp = Series(
-            vesCurvesContext.experimentalCurveErrorUpperBound.map { (x, y) ->
+            experimentalCurveErrorUpperBound(picket).map { (x, y) ->
                 Data(x as Number, y as Number)
             }.toObservableList()
         )
         errUpperExp.name = uiProperties["expCurveUpper"]
 
         val errLowerExp = Series(
-            vesCurvesContext.experimentalCurveErrorLowerBound.map { (x, y) ->
+            experimentalCurveErrorLowerBound(picket).map { (x, y) ->
                 Data(x as Number, y as Number)
             }.toObservableList()
         )
         errLowerExp.name = uiProperties["expCurveLower"]
 
         val hiddenPoints = Series(
-            vesCurvesContext.experimentalHiddenPoints.map { (x, y) ->
+            experimentalHiddenPoints(picket).map { (x, y) ->
                 Data(x as Number, y as Number)
             }.toObservableList()
         )
@@ -403,7 +400,7 @@ class VesCurvesController @Inject constructor(
                     picket.sortedExperimentalData[pointIndex].resistanceApparentUpperBoundByError
                 )
                 val y = decimalFormat.format(picket.sortedExperimentalData[pointIndex].resistanceApparent)
-                val theorRes = picket.vesCurvesContext.theoreticalCurveBy(forwardSolver).getOrNull(pointIndex)?.y
+                val theorRes = theoreticalCurve(picket, forwardSolver).getOrNull(pointIndex)?.y
                 Tooltip(
                     """
                     №${pointIndex + 1}
diff --git a/src/main/java/ru/nucodelabs/geo/ves/calc/graph/VesCurvesFunctions.kt b/src/main/java/ru/nucodelabs/geo/ves/calc/graph/VesCurvesFunctions.kt
@@ -7,74 +7,66 @@ import ru.nucodelabs.geo.ves.calc.resistanceApparentLowerBoundByError
 import ru.nucodelabs.geo.ves.calc.resistanceApparentUpperBoundByError
 import ru.nucodelabs.util.Point
 
-class VesCurvesContext(val picket: Picket) {
-    val experimentalCurve by lazy {
-        picket.effectiveExperimentalData.map { Point(it.ab2, it.resistanceApparent) }
-    }
+fun experimentalCurve(picket: Picket) =
+    picket.effectiveExperimentalData.map { Point(it.ab2, it.resistanceApparent) }
 
-    val experimentalCurveErrorUpperBound by lazy {
-        picket.effectiveExperimentalData.map { Point(it.ab2, it.resistanceApparentUpperBoundByError) }
-    }
 
-    val experimentalCurveErrorLowerBound by lazy {
-        picket.effectiveExperimentalData.map { Point(it.ab2, it.resistanceApparentLowerBoundByError) }
-    }
+fun experimentalCurveErrorUpperBound(picket: Picket) =
+    picket.effectiveExperimentalData.map { Point(it.ab2, it.resistanceApparentUpperBoundByError) }
 
-    val experimentalHiddenPoints by lazy {
-        picket.sortedExperimentalData.filter { it.isHidden }.map { Point(it.ab2, it.resistanceApparent) }
-    }
+fun experimentalCurveErrorLowerBound(picket: Picket) =
+    picket.effectiveExperimentalData.map { Point(it.ab2, it.resistanceApparentLowerBoundByError) }
 
-    fun theoreticalCurveBy(forwardSolver: ForwardSolver): List<Point> {
-        if (picket.sortedExperimentalData.isEmpty() || picket.modelData.isEmpty()) {
-            return listOf()
-        }
-        val solvedResistance = forwardSolver(picket.sortedExperimentalData, picket.modelData)
-        return List(picket.sortedExperimentalData.size) { i ->
-            Point(picket.sortedExperimentalData[i].ab2, solvedResistance[i])
-        }
-    }
-
-    fun misfitsBy(misfitsFunction: MisfitsFunction): List<Double> =
-        misfitsFunction(picket.effectiveExperimentalData, picket.modelData)
+fun experimentalHiddenPoints(picket: Picket) =
+    picket.sortedExperimentalData.filter { it.isHidden }.map { Point(it.ab2, it.resistanceApparent) }
 
-    fun modelStepGraph(beginX: Double = 1e-3, endX: Double = 1e100): List<Point> {
-        val modelData = picket.modelData
+fun theoreticalCurve(picket: Picket, forwardSolver: ForwardSolver): List<Point> {
+    if (picket.sortedExperimentalData.isEmpty() || picket.modelData.isEmpty()) {
+        return listOf()
+    }
+    val solvedResistance = forwardSolver(picket.sortedExperimentalData, picket.modelData)
+    return List(picket.sortedExperimentalData.size) { i ->
+        Point(picket.sortedExperimentalData[i].ab2, solvedResistance[i])
+    }
+}
 
-        if (modelData.isEmpty()) {
-            return mutableListOf()
-        }
-        val points = mutableListOf<Point>()
+fun misfits(picket: Picket, misfitsFunction: MisfitsFunction): List<Double> =
+    misfitsFunction(picket.effectiveExperimentalData, picket.modelData)
 
-        // first point
-        points += Point(beginX, picket.modelData.first().resistance)
+fun modelStepGraph(picket: Picket, beginX: Double = 1e-3, endX: Double = 1e100): List<Point> {
+    val modelData = picket.modelData
 
-        var prevSum = 0.0
-        for (i in 0 until modelData.size - 1) {
-            val currentResistance = modelData[i].resistance
-            val currentPower = modelData[i].power
+    if (modelData.isEmpty()) {
+        return mutableListOf()
+    }
+    val points = mutableListOf<Point>()
 
-            points += Point(
-                currentPower + prevSum,
-                currentResistance
-            )
+    // first point
+    points += Point(beginX, modelData.first().resistance)
 
-            val nextResistance = modelData[i + 1].resistance
-            points += Point(
-                currentPower + prevSum,
-                nextResistance
-            )
-            prevSum += currentPower
-        }
+    var prevSum = 0.0
+    for (i in 0 until modelData.size - 1) {
+        val currentResistance = modelData[i].resistance
+        val currentPower = modelData[i].power
 
-        // last point
         points += Point(
-            endX,
-            modelData.last().resistance
+            currentPower + prevSum,
+            currentResistance
         )
 
-        return points
+        val nextResistance = modelData[i + 1].resistance
+        points += Point(
+            currentPower + prevSum,
+            nextResistance
+        )
+        prevSum += currentPower
     }
-}
 
-val Picket.vesCurvesContext
-    get() = VesCurvesContext(this)
+    // last point
+    points += Point(
+        endX,
+        modelData.last().resistance
+    )
+
+    return points
+}
