Group 2 - collection and visualization of statistics over feature models and configurations, with command line support

.gitignore

@@ -4,4 +4,8 @@
 /.classpath
 /.idea/
 /.settings/
-/bin/
+/bin/
+/model_invalidInput.dot
+/export.pdf
+/src/test/java/de/featjar/feature/model/visualization/VisualizeFeatureModelStatsTest.pdf
+/src/main/java/de/featjar/feature/model/analysis/visualization/Testtmp.java

build.gradle

@@ -6,6 +6,12 @@ plugins {
 dependencies {
     api 'de.featjar:formula'
     api testFixtures('de.featjar:formula')
+    api 'de.featjar:formula-analysis-javasmt'
+    implementation 'org.json:json:20240303'
+    implementation 'org.yaml:snakeyaml:2.5'
+	implementation 'tools.jackson.dataformat:jackson-dataformat-csv:3.0.0'
+	implementation 'org.knowm.xchart:xchart:3.8.8'
+    implementation 'de.rototor.pdfbox:graphics2d:3.0.5'
 }
 
 license {

settings.gradle

@@ -7,3 +7,4 @@ plugins {
 }
 
 includeBuild '../formula'
+includeBuild '../formula-analysis-javasmt'

src/main/java/de/featjar/feature/model/analysis/AnalysisTree.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2025 FeatJAR-Development-Team
+ *
+ * This file is part of FeatJAR-feature-model.
+ *
+ * feature-model is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3.0 of the License,
+ * or (at your option) any later version.
+ *
+ * feature-model is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with feature-model. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * See <https://github.com/FeatureIDE/FeatJAR-feature-model> for further information.
+ */
+package de.featjar.feature.model.analysis;
+
+import de.featjar.base.tree.structure.ATree;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * A tree of nodes with a given name and some data.
+ *
+ * @param <T> type of value this node holds
+ * @author Mohammad Khair Almekkawi
+ * @author Florian Beese
+ */
+public class AnalysisTree<T> extends ATree<AnalysisTree<?>> {
+
+    private String name;
+    private T value;
+
+    public AnalysisTree(String name, T value) {
+        this.name = name;
+        this.value = value;
+    }
+
+    public AnalysisTree(String name, AnalysisTree<?> firstchild, AnalysisTree<?>... children) {
+        super(children.length + 1);
+        ArrayList<AnalysisTree<?>> allChildren = new ArrayList<>();
+        allChildren.add(firstchild);
+        java.util.Collections.addAll(allChildren, children);
+        if (allChildren.size() > 0) super.setChildren(allChildren);
+        this.name = name;
+    }
+
+    public AnalysisTree(String name, List<? extends AnalysisTree<?>> children) {
+        super(children.size());
+        super.setChildren(children);
+        this.name = name;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public T getValue() {
+        return this.value;
+    }
+
+    public AnalysisTree(AnalysisTree<T> analysisTree) {
+        this.name = analysisTree.name;
+        this.value = analysisTree.value;
+    }
+
+    @Override
+    public AnalysisTree<?> cloneNode() {
+        return new AnalysisTree<>(this);
+    }
+
+    @Override
+    public boolean equalsNode(AnalysisTree<?> other) {
+        if (other.value == null && this.value != null) {
+            return false;
+        }
+        if (other.value != null && this.value == null) {
+            return false;
+        }
+        if (this.value == null && other.value == null) {
+            return this.name.equals(other.name);
+        }
+        return this.name.equals(other.name) && this.value.equals(other.value);
+    }
+
+    @Override
+    public int hashCodeNode() {
+        return Objects.hash(this.getClass(), this.name, this.value);
+    }
+
+    @Override
+    public String toString() {
+        if (this.value == null) {
+            return "Name: " + this.name + " - Value: " + this.value + " - Value class: " + "No class";
+        } else {
+            return "Name: " + this.name + " - Value: " + this.value + " - Value class: "
+                    + this.value.getClass().getName();
+        }
+    }
+}

src/main/java/de/featjar/feature/model/analysis/computation/ComputeDistributionFeatureSelections.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2025 FeatJAR-Development-Team
+ *
+ * This file is part of FeatJAR-feature-model.
+ *
+ * feature-model is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3.0 of the License,
+ * or (at your option) any later version.
+ *
+ * feature-model is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with feature-model. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * See <https://github.com/FeatureIDE/FeatJAR-feature-model> for further information.
+ */
+package de.featjar.feature.model.analysis.computation;
+
+import de.featjar.base.computation.AComputation;
+import de.featjar.base.computation.Dependency;
+import de.featjar.base.computation.IComputation;
+import de.featjar.base.computation.Progress;
+import de.featjar.base.data.Result;
+import de.featjar.formula.assignment.BooleanAssignment;
+import de.featjar.formula.assignment.BooleanAssignmentList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+/**
+ * Compute how often features are selected, deselected, or undefined.
+ *
+ * @author Mohammad Khair Almekkawi
+ * @author Florian Beese
+ */
+public class ComputeDistributionFeatureSelections extends AComputation<LinkedHashMap<String, Integer>> {
+
+    public static final Dependency<BooleanAssignmentList> BOOLEAN_ASSIGNMENT_LIST =
+            Dependency.newDependency(BooleanAssignmentList.class);
+
+    public ComputeDistributionFeatureSelections(IComputation<BooleanAssignmentList> booleanAssignmentList) {
+        super(booleanAssignmentList);
+    }
+
+    @Override
+    public Result<LinkedHashMap<String, Integer>> compute(List<Object> dependencyList, Progress progress) {
+        BooleanAssignmentList booleanAssigmenAssignmentList = BOOLEAN_ASSIGNMENT_LIST.get(dependencyList);
+        LinkedHashMap<String, Integer> selectionDistribution = new LinkedHashMap<String, Integer>();
+        selectionDistribution.put("selected", 0);
+        selectionDistribution.put("deselected", 0);
+        selectionDistribution.put("undefined", 0);
+
+        for (BooleanAssignment assignment : booleanAssigmenAssignmentList.getAll()) {
+            selectionDistribution.replace(
+                    "deselected", assignment.countNegatives() + selectionDistribution.get("deselected"));
+            selectionDistribution.replace(
+                    "selected", assignment.countPositives() + selectionDistribution.get("selected"));
+            selectionDistribution.replace(
+                    "undefined",
+                    -assignment.countNonZero()
+                            + booleanAssigmenAssignmentList
+                                    .getVariableMap()
+                                    .getVariableNames()
+                                    .size()
+                            + selectionDistribution.get("undefined"));
+        }
+        return Result.of(selectionDistribution);
+    }
+}

src/main/java/de/featjar/feature/model/analysis/computation/ComputeFeatureAverageNumberOfChildren.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2025 FeatJAR-Development-Team
+ *
+ * This file is part of FeatJAR-feature-model.
+ *
+ * feature-model is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3.0 of the License,
+ * or (at your option) any later version.
+ *
+ * feature-model is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with feature-model. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * See <https://github.com/FeatureIDE/FeatJAR-feature-model> for further information.
+ */
+package de.featjar.feature.model.analysis.computation;
+
+import de.featjar.base.computation.AComputation;
+import de.featjar.base.computation.Dependency;
+import de.featjar.base.computation.IComputation;
+import de.featjar.base.computation.Progress;
+import de.featjar.base.data.Result;
+import de.featjar.base.tree.Trees;
+import de.featjar.feature.model.IFeatureTree;
+import de.featjar.feature.model.analysis.visitor.TreeAvgChildrenCounterTreeVisitor;
+import java.util.List;
+
+/**
+ * Calculates the number of features that have no child features.
+ *
+ * @author Benjamin von Holt
+ */
+public class ComputeFeatureAverageNumberOfChildren extends AComputation<Double> {
+    protected static final Dependency<IFeatureTree> FEATURE_TREE = Dependency.newDependency(IFeatureTree.class);
+
+    public ComputeFeatureAverageNumberOfChildren(IComputation<IFeatureTree> featureTree) {
+        super(featureTree);
+    }
+
+    @Override
+    public Result<Double> compute(List<Object> dependencyList, Progress progress) {
+        IFeatureTree tree = FEATURE_TREE.get(dependencyList);
+        return Trees.traverse(tree, new TreeAvgChildrenCounterTreeVisitor());
+    }
+}

src/main/java/de/featjar/feature/model/analysis/computation/ComputeFeatureCounter.java

@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2025 FeatJAR-Development-Team
+ *
+ * This file is part of FeatJAR-feature-model.
+ *
+ * feature-model is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3.0 of the License,
+ * or (at your option) any later version.
+ *
+ * feature-model is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with feature-model. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * See <https://github.com/FeatureIDE/FeatJAR-feature-model> for further information.
+ */
+package de.featjar.feature.model.analysis.computation;
+
+import de.featjar.base.computation.AComputation;
+import de.featjar.base.computation.Dependency;
+import de.featjar.base.computation.IComputation;
+import de.featjar.base.computation.Progress;
+import de.featjar.base.data.Result;
+import de.featjar.formula.assignment.BooleanAssignment;
+import de.featjar.formula.assignment.BooleanAssignmentList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Compute how often features are selected, deselected, or undefined per feature.
+ *
+ * @author Mohammad Khair Almekkawi
+ * @author Florian Beese
+ */
+public class ComputeFeatureCounter extends AComputation<LinkedHashMap<String, Integer>> {
+
+    protected static final Dependency<BooleanAssignmentList> BOOLEAN_ASSIGMENT_LIST =
+            Dependency.newDependency(BooleanAssignmentList.class);
+
+    public ComputeFeatureCounter(IComputation<BooleanAssignmentList> booleanAssigmentList) {
+        super(booleanAssigmentList);
+    }
+
+    @Override
+    public Result<LinkedHashMap<String, Integer>> compute(List<Object> dependencyList, Progress progress) {
+        BooleanAssignmentList booleanAssignmentList = BOOLEAN_ASSIGMENT_LIST.get(dependencyList);
+        LinkedHashMap<String, Integer> featureCounter = new LinkedHashMap<String, Integer>();
+
+        for (int index : booleanAssignmentList.getVariableMap().getIndices()) {
+            featureCounter.put(index + "_selected", 0);
+            featureCounter.put(index + "_deselected", 0);
+            featureCounter.put(index + "_undefined", 0);
+        }
+
+        for (BooleanAssignment assignment : booleanAssignmentList.getAll()) {
+            for (int index : booleanAssignmentList.getVariableMap().getIndices()) {
+                if (assignment.contains(index)) {
+                    featureCounter.replace(index + "_selected", featureCounter.get(index + "_selected") + 1);
+                } else if (assignment.containsAnyNegated(index)) {
+                    featureCounter.replace(index + "_deselected", featureCounter.get(index + "_deselected") + 1);
+                } else {
+                    featureCounter.replace(index + "_undefined", featureCounter.get(index + "_undefined") + 1);
+                }
+            }
+        }
+
+        LinkedHashMap<String, Integer> featureNameCounter = new LinkedHashMap<String, Integer>();
+
+        for (Map.Entry<String, Integer> entry : featureCounter.entrySet()) {
+            if (entry.getKey().contains("_selected")
+                    && booleanAssignmentList
+                            .getVariableMap()
+                            .get(Integer.valueOf(entry.getKey().replace("_selected", "")))
+                            .isPresent()) {
+                featureNameCounter.put(
+                        booleanAssignmentList
+                                        .getVariableMap()
+                                        .get(Integer.valueOf(entry.getKey().replace("_selected", "")))
+                                        .get()
+                                + "_selected",
+                        entry.getValue());
+            } else if (entry.getKey().contains("_deselected")
+                    && booleanAssignmentList
+                            .getVariableMap()
+                            .get(Integer.valueOf(entry.getKey().replace("_deselected", "")))
+                            .isPresent()) {
+                featureNameCounter.put(
+                        booleanAssignmentList
+                                        .getVariableMap()
+                                        .get(Integer.valueOf(entry.getKey().replace("_deselected", "")))
+                                        .get()
+                                + "_deselected",
+                        entry.getValue());
+            } else if (entry.getKey().contains("_undefined")
+                    && booleanAssignmentList
+                            .getVariableMap()
+                            .get(Integer.valueOf(entry.getKey().replace("_undefined", "")))
+                            .isPresent()) {
+                featureNameCounter.put(
+                        booleanAssignmentList
+                                        .getVariableMap()
+                                        .get(Integer.valueOf(entry.getKey().replace("_undefined", "")))
+                                        .get()
+                                + "_undefined",
+                        entry.getValue());
+            }
+        }
+        return Result.of(featureNameCounter);
+    }
+}