Add a filter panel

build.gradle.kts

@@ -52,6 +52,7 @@ dependencies {
     implementation("junit:junit:$junitVersion")
     implementation("org.junit.jupiter:junit-jupiter:$junitJupiterVersion")
     implementation("org.controlsfx:controlsfx:$controlsfxVersion")
+    implementation("de.codecentric.centerdevice:javafxsvg:1.3.0")
 
     testImplementation("org.junit.jupiter:junit-jupiter:$junitJupiterVersion")
     testImplementation("org.junit.jupiter:junit-jupiter-params:$junitJupiterParamsVersion")

src/main/kotlin/solve/SolveApp.kt

@@ -1,27 +1,45 @@
 package solve
 
+import de.codecentric.centerdevice.javafxsvg.SvgImageLoaderFactory
 import javafx.stage.Stage
 import solve.main.MainView
 import solve.scene.view.landmarks.AnimationProvider
 import solve.scene.view.landmarks.JavaFXAnimationProvider
+import solve.styles.ApplicationStylesheet
+import solve.utils.SVGImageLoaderDimensionProvider
 import solve.utils.ServiceLocator
 import tornadofx.App
+import tornadofx.FX.Companion.stylesheets
 import tornadofx.launch
 
-class SolveApp : App(MainView::class) {
+class SolveApp : App(MainView::class, ApplicationStylesheet::class) {
     override fun start(stage: Stage) {
+        initializeDependencies()
+        registerServices()
+
         with(stage) {
             width = 1000.0
             height = 600.0
             isMaximized = true
         }
-        registerServices()
         super.start(stage)
     }
 
     private fun registerServices() {
         ServiceLocator.registerService<AnimationProvider>(JavaFXAnimationProvider())
     }
+
+    private fun initializeDependencies() {
+        SvgImageLoaderFactory.install(SVGImageLoaderDimensionProvider())
+
+        initializeStyle()
+    }
+
+    private fun initializeStyle() {
+        stylesheets.add("https://fonts.googleapis.com/css2?family=Roboto+Condensed")
+        stylesheets.add("https://fonts.googleapis.com/css2?family=Roboto+Condensed:wght@700")
+        stylesheets.add("https://fonts.googleapis.com/css2?family=Roboto")
+    }
 }
 
 fun main(args: Array<String>) = launch<SolveApp>(args)

src/main/kotlin/solve/catalogue/CatalogueUtils.kt

@@ -9,8 +9,6 @@ import tornadofx.tooltip
 val ProjectFrame.layers: List<ProjectLayer>
     get() = landmarkFiles.map { it.projectLayer }.distinct()
 
-fun Double.floor(): Int = kotlin.math.floor(this).toInt()
-
 fun <T> synchronizeListViewsSelections(firstListView: ListView<T>, secondListView: ListView<T>) {
     secondListView.selectionModel = firstListView.selectionModel
 }

src/main/kotlin/solve/catalogue/view/CatalogueView.kt

@@ -21,6 +21,7 @@ import solve.catalogue.view.fields.CatalogueFieldsView
 import solve.catalogue.view.fields.CatalogueFileNamesFieldsView
 import solve.catalogue.view.fields.CataloguePreviewImagesFieldsView
 import solve.constants.IconsCatalogueApplyPath
+import solve.filters.view.FilterPanelView
 import solve.project.model.ProjectFrame
 import solve.utils.addSafely
 import solve.utils.createInsetsWithValue
@@ -42,6 +43,7 @@ class CatalogueView : View() {
         }
 
     private val settingsView: CatalogueSettingsView by inject()
+    private val filterPanelView: FilterPanelView by inject()
     private val controller: CatalogueController by inject()
 
     private val fields = FXCollections.observableArrayList<CatalogueField>()
@@ -91,7 +93,13 @@ class CatalogueView : View() {
         vgrow = Priority.ALWAYS
     }
 
-    override val root = catalogueNode.also { initializeNodes() }
+    override val root = vbox {
+        add(catalogueNode)
+        initializeNodes()
+        add(filterPanelView)
+
+        vgrow = Priority.ALWAYS
+    }
 
     init {
         accelerators[KeyCodeCombination(KeyCode.ENTER)] = {

src/main/kotlin/solve/catalogue/view/fields/CatalogueFieldsView.kt

@@ -13,11 +13,11 @@ import javafx.scene.input.TransferMode
 import javafx.scene.layout.Priority
 import javafx.scene.paint.Color
 import solve.catalogue.controller.CatalogueController
-import solve.catalogue.floor
 import solve.catalogue.model.CatalogueField
 import solve.project.model.ProjectFrame
 import solve.scene.view.SceneView
 import solve.utils.deselectAllItems
+import solve.utils.floorToInt
 import solve.utils.onSelectionChanged
 import solve.utils.selectAllItems
 import solve.utils.selectedItems
@@ -115,16 +115,16 @@ abstract class CatalogueFieldsView : View() {
 
     private fun createFileNameFieldsSnapshot(fields: List<CatalogueField>): Image {
         val snapshotFields = fields.take(dragViewMaxFieldsNumber)
-        val prefSnapshotHeight = (snapshotFields.count() * listViewCellHeight).floor()
+        val prefSnapshotHeight = (snapshotFields.count() * listViewCellHeight).floorToInt()
 
         val fieldsSnapshotNode = createFieldsSnapshotNode(snapshotFields)
         fieldsListView.getChildList()?.remove(fieldsSnapshotNode)
 
         val nodeSnapshot = fieldsSnapshotNode.snapshot(null, null)
         return WritableImage(
             nodeSnapshot.pixelReader,
-            nodeSnapshot.width.floor(),
-            min(nodeSnapshot.height.floor(), prefSnapshotHeight)
+            nodeSnapshot.width.floorToInt(),
+            min(nodeSnapshot.height.floorToInt(), prefSnapshotHeight)
         )
     }
 }

src/main/kotlin/solve/catalogue/view/fields/CatalogueFileNamesFieldsView.kt

@@ -2,8 +2,10 @@ package solve.catalogue.view.fields
 
 import javafx.scene.control.Labeled
 import javafx.scene.image.ImageView
+import javafx.scene.text.Font
 import solve.catalogue.model.CatalogueField
 import solve.constants.IconsCatalogueImagePath
+import solve.styles.Style
 import solve.utils.loadResourcesImage
 import tornadofx.*
 
@@ -44,7 +46,9 @@ class CatalogueFileNamesFieldsView : CatalogueFieldsView() {
                 if (iconImageView != null) {
                     add(iconImageView)
                 }
-                label(it.fileName)
+                text(it.fileName) {
+                    font = Font.font(Style.Font, 14.0)
+                }
             }
         }
     }

src/main/kotlin/solve/constants/ResourcesPaths.kt

@@ -27,3 +27,9 @@ const val IconsLayers = "/icons/sidepanel/Layers.png"
 const val IconsLayersFilled = "/icons/sidepanel/LayersFilled.png"
 const val IconsGrid = "/icons/sidepanel/Grid.png"
 const val IconsGridSelected = "/icons/sidepanel/GridSelected.png"
+const val IconsFiltersAddPath = "icons/filters/add.svg"
+const val IconsFiltersOrCheckBoxPath = "icons/filters/or_checkbox.svg"
+
+// Common icons.
+const val IconsEditPath = "icons/common/edit.svg"
+const val IconsDeletePath = "icons/common/delete.svg"

src/main/kotlin/solve/filters/controller/FilterPanelController.kt

@@ -0,0 +1,59 @@
+package solve.filters.controller
+
+import solve.catalogue.controller.CatalogueController
+import solve.filters.model.Filter
+import solve.filters.model.FilterPanelModel
+import solve.project.controller.ProjectController
+import solve.project.model.ProjectFrame
+import tornadofx.*
+
+class FilterPanelController : Controller() {
+    val model = FilterPanelModel()
+
+    private val projectController: ProjectController by inject()
+    private val catalogueController: CatalogueController by inject()
+
+    init {
+        addBindings()
+    }
+
+    fun addFilter(filter: Filter) {
+        model.addFilter(filter)
+    }
+
+    fun removeFilter(filter: Filter) {
+        model.removeFilter(filter)
+    }
+
+    fun editFilter(editingFilter: Filter, editedFilter: Filter) {
+        model.replaceFilter(editingFilter, editedFilter)
+    }
+
+    fun applyFilters() {
+        val filteredFrames = getFilteredProjectFrames()
+        catalogueController.setCatalogueFrames(filteredFrames)
+    }
+
+    private fun addBindings() {
+        projectController.model.projectProperty.onChange {
+            applyFilters()
+        }
+        model.filters.onChange {
+            applyFilters()
+        }
+    }
+
+    private fun getFilteredProjectFrames(): List<ProjectFrame> {
+        val projectFrames = projectController.model.project.frames
+
+        if (model.filters.isEmpty() || model.filters.all { !it.enabled }) {
+            return projectFrames
+        }
+
+        val enabledFilters = model.filters.filter { it.enabled }
+        val notOrderedFilteredFrames = enabledFilters.map { it.apply(projectFrames) }.flatten().distinct()
+        val projectFrameToIndexMap = projectFrames.indices.associateBy { index -> projectFrames[index] }
+
+        return notOrderedFilteredFrames.sortedBy { frame -> projectFrameToIndexMap[frame] }
+    }
+}

src/main/kotlin/solve/filters/model/Filter.kt

@@ -0,0 +1,48 @@
+package solve.filters.model
+
+import solve.filters.settings.model.FilterSetting
+import solve.filters.settings.model.IndicesStepFilterSetting
+import solve.filters.settings.model.TimePeriodFilterSetting
+import solve.filters.settings.model.UIDFilterSetting
+import solve.project.model.ProjectFrame
+
+class Filter(val settings: List<FilterSetting<out Any>>) {
+    var enabled: Boolean = true
+    val preview: String by lazy { createPreviewText() }
+
+    fun apply(frames: List<ProjectFrame>): List<ProjectFrame> {
+        if (!enabled) {
+            return frames
+        }
+
+        var suitableFrames = frames
+        settings.forEach { suitableFrames = it.apply(suitableFrames) }
+
+        return suitableFrames
+    }
+
+    private fun createPreviewText(): String {
+        val indicesStepSetting = settings.firstOrNull { it is IndicesStepFilterSetting } as? IndicesStepFilterSetting
+        val timePeriodSetting = settings.firstOrNull { it is TimePeriodFilterSetting } as? TimePeriodFilterSetting
+        val uidSetting = settings.firstOrNull { it is UIDFilterSetting } as? UIDFilterSetting
+
+        val prefix = "Show "
+        val indicesStepPart = if (indicesStepSetting != null) {
+            "every ${indicesStepSetting.settingValue} image "
+        } else {
+            "images "
+        }
+        val timePeriodPart = if (timePeriodSetting != null) {
+            "from ${timePeriodSetting.settingValue.x} to ${timePeriodSetting.settingValue.y} "
+        } else {
+            ""
+        }
+        val uidPart = if (uidSetting != null) {
+            "with landmark ${uidSetting.settingValue}"
+        } else {
+            ""
+        }
+
+        return "$prefix$indicesStepPart$timePeriodPart$uidPart"
+    }
+}

src/main/kotlin/solve/filters/model/FilterPanelModel.kt

@@ -0,0 +1,27 @@
+package solve.filters.model
+
+import javafx.collections.FXCollections
+import javafx.collections.ObservableList
+
+class FilterPanelModel {
+    private val _filters = FXCollections.observableArrayList<Filter>()
+    val filters: ObservableList<Filter> = FXCollections.synchronizedObservableList(_filters)
+
+    fun addFilter(filter: Filter) {
+        _filters.add(filter)
+    }
+
+    fun removeFilter(filter: Filter) {
+        _filters.remove(filter)
+    }
+
+    fun replaceFilter(oldFilter: Filter, newFilter: Filter) {
+        if (!_filters.contains(oldFilter)) {
+            return
+        }
+
+        val oldFilterIndex = _filters.indexOf(oldFilter)
+        _filters.remove(oldFilter)
+        _filters.add(oldFilterIndex, newFilter)
+    }
+}

src/main/kotlin/solve/filters/settings/controller/FilterSettingsController.kt

@@ -0,0 +1,22 @@
+package solve.filters.settings.controller
+
+import solve.filters.controller.FilterPanelController
+import solve.filters.model.Filter
+import solve.filters.settings.model.FilterSetting
+import tornadofx.*
+
+class FilterSettingsController : Controller() {
+    private val panelController: FilterPanelController by inject()
+
+    fun createFilter(filterSettings: List<FilterSetting<out Any>>) {
+        val filter = Filter(filterSettings)
+        panelController.addFilter(filter)
+    }
+
+    fun editFilter(editingFilter: Filter, editedFilterSettings: List<FilterSetting<out Any>>) {
+        val newFilter = Filter(editedFilterSettings)
+        newFilter.enabled = editingFilter.enabled
+
+        panelController.editFilter(editingFilter, newFilter)
+    }
+}

src/main/kotlin/solve/filters/settings/model/FilterSetting.kt

@@ -0,0 +1,20 @@
+package solve.filters.settings.model
+
+import solve.project.model.ProjectFrame
+
+abstract class FilterSetting<T>(settingValue: T) {
+    var enabled: Boolean = true
+
+    var settingValue: T = settingValue
+        protected set
+
+    fun apply(fields: List<ProjectFrame>) : List<ProjectFrame> {
+        if (!enabled)
+            return fields;
+
+        return applySetting(fields)
+    }
+    protected abstract fun applySetting(fields: List<ProjectFrame>): List<ProjectFrame>
+
+    abstract fun edit(newValue: T)
+}

src/main/kotlin/solve/filters/settings/model/IndicesStepFilterSetting.kt

@@ -0,0 +1,13 @@
+package solve.filters.settings.model
+
+import solve.project.model.ProjectFrame
+
+class IndicesStepFilterSetting(step: Int) : FilterSetting<Int>(step) {
+    override fun applySetting(fields: List<ProjectFrame>) = fields.slice(
+        (settingValue - 1)..fields.lastIndex step this.settingValue
+    )
+
+    override fun edit(newValue: Int) {
+        settingValue = newValue
+    }
+}

src/main/kotlin/solve/filters/settings/model/TimePeriodFilterSetting.kt

@@ -0,0 +1,13 @@
+package solve.filters.settings.model
+
+import solve.project.model.ProjectFrame
+import solve.utils.structures.IntPoint
+
+class TimePeriodFilterSetting(timePeriod: IntPoint) : FilterSetting<IntPoint>(timePeriod) {
+    override fun applySetting(fields: List<ProjectFrame>): List<ProjectFrame> =
+        fields.filter { it.timestamp in settingValue.x..settingValue.y }
+
+    override fun edit(newValue: IntPoint) {
+        settingValue = newValue
+    }
+}

src/main/kotlin/solve/filters/settings/model/UIDFilterSetting.kt

@@ -0,0 +1,11 @@
+package solve.filters.settings.model
+
+import solve.project.model.ProjectFrame
+
+class UIDFilterSetting(uid: Long) : FilterSetting<Long>(uid) {
+    override fun applySetting(fields: List<ProjectFrame>) = fields.filter { it.uids.contains(settingValue) }
+
+    override fun edit(newValue: Long) {
+        settingValue = newValue
+    }
+}