Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[2022] trunk
|
From: <lor...@us...> - 2010-02-12 22:53:20
|
Revision: 2022
http://dl-learner.svn.sourceforge.net/dl-learner/?rev=2022&view=rev
Author: lorenz_b
Date: 2010-02-12 22:53:03 +0000 (Fri, 12 Feb 2010)
Log Message:
-----------
Added DL-Learner evaluation plugin for Protege.
Added build and install task in build.xml. For 'install task' set ANT environment variable PROTEGE_HOME to the target Protege directory.
Modified Paths:
--------------
trunk/build.xml
Added Paths:
-----------
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationPlugin.java
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTable.java
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTableModel.java
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/GraphicalCoveragePanel.java
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/MANIFEST.MF
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/plugin.xml
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/viewconfig-evalTab.xml
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonEditor.java
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonRenderer.java
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalCaption.java
trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalHeaderRenderer.java
Modified: trunk/build.xml
===================================================================
--- trunk/build.xml 2010-02-12 10:47:37 UTC (rev 2021)
+++ trunk/build.xml 2010-02-12 22:53:03 UTC (rev 2022)
@@ -18,6 +18,9 @@
<property name="release_ore_dir" value="release/ore-${today}" />
<property name="version_ore_dir" value="ore-${today}" />
+ <property environment="env"/>
+ <property name = "protege.home" location="${env.PROTEGE_HOME}"/>
+ <property name = "protege.plugins" location="${protege.home}/plugins"/>
<!-- other settings -->
<!-- maximum amount of allocated memory in startup scripts -->
@@ -552,5 +555,50 @@
</tar>
<delete dir="release"/>
</target>
+
+ <!-- build the DL-Learner evaluation plugin for Protege -->
+ <target name="buildEvaluationProtegePlugin">
+ <property name="source" value="src/dl-learner/org/dllearner/tools/evaluationplugin" />
+ <property name="temp" value="${source}/temp" />
+ <property name="build" value="${source}/build" />
+ <mkdir dir="${temp}" />
+ <mkdir dir="${build}" />
+ <mkdir dir="${temp}/META-INF" />
+ <mkdir dir="${temp}/lib" />
+ <copy toDir="${temp}/META-INF" >
+ <fileset dir="${source}/META-INF" includes="MANIFEST.MF," />
+ </copy>
+ <copy toDir="${temp}/lib" >
+ <fileset dir="${lib_dir}/ore-tool" includes="swingx-1.0.jar" />
+ </copy>
+ <copy toDir="${temp}/lib" >
+ <fileset dir="${lib_dir}/jena" includes="json.jar" />
+ </copy>
+ <copy toDir="${temp}" >
+ <fileset dir="${class_dir}" />
+ </copy>
+ <copy toDir="${temp}" >
+ <fileset dir="${source}/META-INF" includes="**/*.xml," excludes="build.xml" />
+ </copy>
+ <javac srcdir="${source}"
+ destdir="${temp}"
+ debug="on"
+ target="1.5">
+ <classpath refid="classpath"/>
+ </javac>
+ <jar destfile="${build}/DL-Learner-evaluation-protege-plugin.jar" manifest="${temp}/META-INF/MANIFEST.MF">
+ <fileset dir="${temp}" />
+ </jar>
+ </target>
+
+ <!-- build and install the DL-Learner evaluation plugin for Protege to the given Protege directory -->
+ <target name="installEvaluationProtegePlugin" depends="buildEvaluationProtegePlugin">
+ <copy file="${build}/DL-Learner-evaluation-protege-plugin.jar"
+ todir = "${protege.plugins}"
+ overwrite = "true"/>
+ <delete dir="${temp}" />
+ <delete dir="${build}" />
+ </target>
+
</project>
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationPlugin.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationPlugin.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationPlugin.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,293 @@
+package org.dllearner.tools.evaluationplugin;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.event.ActionEvent;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.swing.AbstractAction;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.ScrollPaneConstants;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.learningproblems.EvaluatedDescriptionClass;
+import org.dllearner.utilities.owl.ConceptComparator;
+import org.dllearner.utilities.owl.OWLAPIDescriptionConvertVisitor;
+import org.protege.editor.owl.ui.view.AbstractOWLViewComponent;
+import org.semanticweb.owl.model.OWLDescription;
+import org.semanticweb.owl.model.OWLEntity;
+import org.semanticweb.owl.model.OWLOntology;
+
+
+
+public class EvaluationPlugin extends AbstractOWLViewComponent implements ListSelectionListener{
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ private EvaluationTable evaluationTable;
+ private GraphicalCoveragePanel coveragePanel;
+ private JLabel inconsistencyLabel;
+ private JButton nextSaveButton;
+ private JLabel currentClassLabel;
+
+ private List<NamedClass> classes = new ArrayList<NamedClass>();
+ private int currentClassIndex = 0;
+
+
+ private final ConceptComparator comparator = new ConceptComparator();
+
+ private static final String CURRENT_CLASS_MESSAGE = "Showing equivalent class expressions for class ";
+ private static final String INCONSISTENCY_WARNING =
+ "<html>Warning. Selected class expressions leads to an inconsistent ontology!<br>" +
+ "(Often, suggestions leading to an inconsistency should still be added. They help to detect problems in " +
+ "the ontology elsewhere.<br>" +
+ " See http://dl-learner.org/files/screencast/protege/screencast.htm .)</html>";
+
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastEquivalenceStandardMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastEquivalenceFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastEquivalencePredaccMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastEquivalenceGenFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastEquivalenceJaccardMap;
+
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastSuperStandardMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastSuperFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastSuperPredaccMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastSuperGenFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> fastSuperJaccardMap;
+
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlEquivalenceStandardMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlEquivalenceFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlEquivalencePredaccMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlEquivalenceGenFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlEquivalenceJaccardMap;
+
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlSuperStandardMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlSuperFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlSuperPredaccMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlSuperGenFMeasureMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> owlSuperJaccardMap;
+
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> defaultEquivalenceMap;
+ private Map<NamedClass, List<EvaluatedDescriptionClass>> defaultSuperMap;
+
+
+ @Override
+ protected void initialiseOWLView() throws Exception {
+ System.out.println("Initializing DL-Learner Evaluation Plugin...");
+ createUI();
+ parseEvaluationFile();
+ showNextEvaluatedDescriptions();
+ }
+
+ @Override
+ protected void disposeOWLView() {
+ evaluationTable.getSelectionModel().removeListSelectionListener(this);
+ evaluationTable.dispose();
+ }
+
+ /**
+ * Create the user interface.
+ */
+ private void createUI(){
+ setLayout(new BorderLayout());
+
+ currentClassLabel = new JLabel();
+ add(currentClassLabel, BorderLayout.NORTH);
+
+ JPanel tableHolderPanel = new JPanel(new BorderLayout());
+ evaluationTable = new EvaluationTable(getOWLEditorKit());
+ evaluationTable.getSelectionModel().addListSelectionListener(this);
+ JScrollPane sp = new JScrollPane(evaluationTable);
+ sp.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+ tableHolderPanel.add(sp);
+ inconsistencyLabel = new JLabel(INCONSISTENCY_WARNING);
+ inconsistencyLabel.setForeground(getBackground());
+ tableHolderPanel.add(inconsistencyLabel, BorderLayout.SOUTH);
+ add(tableHolderPanel);
+
+
+ JPanel coverageHolderPanel = new JPanel(new BorderLayout());
+ coveragePanel = new GraphicalCoveragePanel(getOWLEditorKit());
+ coverageHolderPanel.add(coveragePanel);
+
+ nextSaveButton = new JButton();
+ nextSaveButton.setActionCommand("next");
+ nextSaveButton.setAction(new AbstractAction("Next"){
+ /**
+ *
+ */
+ private static final long serialVersionUID = 6982520538511324236L;
+
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ showNextEvaluatedDescriptions();
+ }
+ });
+ coverageHolderPanel.add(nextSaveButton, BorderLayout.SOUTH);
+ add(coverageHolderPanel, BorderLayout.SOUTH);
+
+ }
+
+ /**
+ * Show the descriptions for next class to evaluate.
+ */
+ private void showNextEvaluatedDescriptions(){
+ showInconsistencyWarning(false);
+ NamedClass currentClass = classes.get(currentClassIndex++);
+
+ //show the name for the current class in manchester syntax
+ String renderedClass = getOWLModelManager().getRendering(OWLAPIDescriptionConvertVisitor.getOWLDescription(currentClass));
+ currentClassLabel.setText(CURRENT_CLASS_MESSAGE + renderedClass);
+ System.out.println("Showing evaluated descriptions for class " + currentClass.toString());
+
+ //refresh coverage panel to the current class
+ coveragePanel.setConcept(currentClass);
+
+ //necessary to set the current class to evaluate as activated entity
+ OWLDescription desc = OWLAPIDescriptionConvertVisitor.getOWLDescription(currentClass);
+ OWLEntity curEntity = desc.asOWLClass();
+ getOWLEditorKit().getWorkspace().getOWLSelectionModel().setSelectedEntity(curEntity);
+
+ evaluationTable.setDescriptions(getMergedDescriptions(currentClass));
+ //if the currently shown class expressions are for the last class to evaluate, change
+ //button text and action to save the user input
+ if(currentClassIndex == classes.size()){
+ nextSaveButton.setAction(new AbstractAction("Save"){
+
+ @Override
+ public void actionPerformed(ActionEvent arg0) {
+ // TODO Auto-generated method stub
+
+ }
+
+ });
+
+ }
+ }
+
+ /**
+ * Load the computed DL-Learner results from a file, which name corresponds to the loaded owl-file.
+ */
+ @SuppressWarnings("unchecked")
+ private void parseEvaluationFile(){
+ OWLOntology activeOnt = getOWLModelManager().getActiveOntology();
+ URI uri = getOWLModelManager().getOntologyPhysicalURI(activeOnt);
+ String resultFile = uri.toString().substring(0, uri.toString().lastIndexOf('.') + 1) + "res";
+ InputStream fis = null;
+ try {
+ fis = new FileInputStream(new File(URI.create(resultFile)));
+ ObjectInputStream o = new ObjectInputStream(fis);
+ owlEquivalenceStandardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlEquivalenceFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlEquivalencePredaccMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlEquivalenceJaccardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlEquivalenceGenFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+
+ owlSuperStandardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlSuperFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlSuperPredaccMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlSuperJaccardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ owlSuperGenFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+
+ fastEquivalenceStandardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastEquivalenceFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastEquivalencePredaccMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastEquivalenceJaccardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastEquivalenceGenFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+
+ fastSuperStandardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastSuperFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastSuperPredaccMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastSuperJaccardMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ fastSuperGenFMeasureMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+
+ defaultEquivalenceMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+ defaultSuperMap = (HashMap<NamedClass, List<EvaluatedDescriptionClass>>) o.readObject();
+
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (ClassNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ classes.addAll(new TreeSet<NamedClass>(owlEquivalenceStandardMap.keySet()));
+
+
+ }
+
+ /**
+ * Get a disjoint list of all computed evaluated descriptions.
+ * @param nc The class which is currently to evaluate.
+ * @return A List of disjoint evaluated descriptions - here disjointness only by the description
+ * not the accuracy.
+ */
+ private List<EvaluatedDescriptionClass> getMergedDescriptions(NamedClass nc){
+
+ Set<EvaluatedDescriptionClass> evaluatedDescriptions = new TreeSet<EvaluatedDescriptionClass>(new Comparator<EvaluatedDescriptionClass>(){
+
+ public int compare(EvaluatedDescriptionClass o1, EvaluatedDescriptionClass o2) {
+ return comparator.compare(o1.getDescription(), o2.getDescription());
+
+ };
+ });
+ evaluatedDescriptions.addAll(owlEquivalenceStandardMap.get(nc));
+ evaluatedDescriptions.addAll(owlEquivalenceJaccardMap.get(nc));
+ evaluatedDescriptions.addAll(owlEquivalenceGenFMeasureMap.get(nc));
+ evaluatedDescriptions.addAll(owlEquivalenceFMeasureMap.get(nc));
+ evaluatedDescriptions.addAll(owlEquivalencePredaccMap.get(nc));
+ evaluatedDescriptions.addAll(fastEquivalenceStandardMap.get(nc));
+ evaluatedDescriptions.addAll(fastEquivalenceJaccardMap.get(nc));
+ evaluatedDescriptions.addAll(fastEquivalenceGenFMeasureMap.get(nc));
+ evaluatedDescriptions.addAll(fastEquivalenceFMeasureMap.get(nc));
+ evaluatedDescriptions.addAll(fastEquivalencePredaccMap.get(nc));
+ List<EvaluatedDescriptionClass> merged = new ArrayList<EvaluatedDescriptionClass>(evaluatedDescriptions);
+
+ return merged;
+ }
+
+ /**
+ * Show a red colored warning, if adding the selected class expression would lead to an inconsistent
+ * ontology.
+ * @param show If true a warning is displayed, otherwise not.
+ */
+ private void showInconsistencyWarning(boolean show){
+ if(show){
+ inconsistencyLabel.setForeground(Color.RED);
+ } else {
+ inconsistencyLabel.setForeground(getBackground());
+ }
+ }
+
+ @Override
+ public void valueChanged(ListSelectionEvent e) {
+ if (!e.getValueIsAdjusting() && evaluationTable.getSelectedRow() >= 0) {
+ coveragePanel.setNewClassDescription(evaluationTable.getSelectedEvaluatedDescription());
+ showInconsistencyWarning(!evaluationTable.getSelectedEvaluatedDescription().isConsistent());
+ }
+ }
+
+}
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTable.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTable.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTable.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,132 @@
+package org.dllearner.tools.evaluationplugin;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.MouseEvent;
+import java.util.List;
+
+import javax.swing.JComponent;
+import javax.swing.table.JTableHeader;
+
+import org.dllearner.learningproblems.EvaluatedDescriptionClass;
+import org.jdesktop.swingx.JXTable;
+import org.protege.editor.owl.OWLEditorKit;
+import org.protege.editor.owl.ui.renderer.LinkedObjectComponent;
+import org.protege.editor.owl.ui.renderer.LinkedObjectComponentMediator;
+import org.protege.editor.owl.ui.renderer.OWLCellRenderer;
+import org.semanticweb.owl.model.OWLObject;
+
+public class EvaluationTable extends JXTable implements LinkedObjectComponent{
+ /**
+ *
+ */
+ private static final long serialVersionUID = 6293382971051635859L;
+
+ private LinkedObjectComponentMediator mediator;
+
+ private static final String[] TOOLTIPS = {
+ "The learned equivalent class expression.",
+ "Improvement",
+ "Equal Quality (+)",
+ "Equal Quality (-)",
+ "Inferior",
+ "Not acceptable",
+ "Error" };
+
+ public EvaluationTable(OWLEditorKit editorKit){
+ super(new EvaluationTableModel());
+ mediator = new LinkedObjectComponentMediator(editorKit, this);
+ OWLCellRenderer renderer = new OWLCellRenderer(editorKit, true, false);
+ renderer.setHighlightKeywords(true);
+ getColumn(0).setCellRenderer(renderer);
+ setRenderers();
+ setColumnSizes();
+ }
+
+ @Override
+ protected JTableHeader createDefaultTableHeader() {
+ return new JTableHeader(columnModel) {
+ /**
+ *
+ */
+ private static final long serialVersionUID = -3386641672808329591L;
+
+ @Override
+ public String getToolTipText(MouseEvent e) {
+
+ java.awt.Point p = e.getPoint();
+ int index = columnModel.getColumnIndexAtX(p.x);
+ int realIndex =
+ columnModel.getColumn(index).getModelIndex();
+ return TOOLTIPS[realIndex];
+ }
+
+
+ };
+
+ }
+
+ private void setRenderers(){
+ for(int i = 1; i < getColumnCount(); i++){
+ getColumn(i).setCellRenderer(new RadioButtonRenderer());
+ getColumn(i).setCellEditor(new RadioButtonEditor());
+ getColumn(i).setHeaderRenderer(new VerticalHeaderRenderer());
+ }
+ }
+
+ private void setColumnSizes(){
+ for(int i = 1; i < getColumnCount(); i++){
+ getColumn(i).setMaxWidth(30);
+ }
+ }
+
+ @Override
+ public JComponent getComponent() {
+ return this;
+ }
+
+ @Override
+ public OWLObject getLinkedObject() {
+ return mediator.getLinkedObject();
+ }
+
+ @Override
+ public Point getMouseCellLocation() {
+ Point mouseLoc = getMousePosition();
+ if (mouseLoc == null) {
+ return null;
+ }
+ int index = rowAtPoint(mouseLoc);
+ Rectangle cellRect = getCellRect(index, 0, true);
+
+ return new Point(mouseLoc.x - cellRect.x, mouseLoc.y - cellRect.y);
+ }
+
+ @Override
+ public Rectangle getMouseCellRect() {
+ Point loc = getMousePosition();
+ if (loc == null) {
+ return null;
+ }
+ int index = rowAtPoint(loc);
+ return getCellRect(index, 0, true);
+ }
+
+ @Override
+ public void setLinkedObject(OWLObject object) {
+ mediator.setLinkedObject(object);
+ }
+
+ public void setDescriptions(List<EvaluatedDescriptionClass> descriptions){
+ ((EvaluationTableModel)getModel()).setDescriptions(descriptions);
+ }
+
+ public EvaluatedDescriptionClass getSelectedEvaluatedDescription(){
+ return ((EvaluationTableModel)getModel()).getSelectedEvaluatedDescription(getSelectedRow());
+ }
+
+ public void dispose(){
+ mediator.dispose();
+ }
+
+}
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTableModel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTableModel.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/EvaluationTableModel.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,91 @@
+package org.dllearner.tools.evaluationplugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.table.AbstractTableModel;
+
+import org.dllearner.core.owl.Description;
+import org.dllearner.learningproblems.EvaluatedDescriptionClass;
+import org.dllearner.utilities.owl.OWLAPIDescriptionConvertVisitor;
+
+public class EvaluationTableModel extends AbstractTableModel {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private List<EvaluatedDescriptionClass> descriptions = new ArrayList<EvaluatedDescriptionClass>();
+ private List<Integer> selected;
+
+ private static final String[] COLUMN_NAMES = {
+ "equivalent class expression",
+ "Improvement",
+ "Equal Quality (+)",
+ "Equal Quality (-)",
+ "Inferior",
+ "Not acceptable",
+ "Error" };
+
+ @Override
+ public int getColumnCount() {
+ return 7;
+ }
+
+ @Override
+ public int getRowCount() {
+ return descriptions.size();
+ }
+
+ @Override
+ public Class<?> getColumnClass(int columnIndex) {
+ if(columnIndex == 0){
+ return Description.class;
+ } else {
+ return Object.class;
+ }
+ }
+
+ @Override
+ public Object getValueAt(int rowIndex, int columnIndex) {
+ if(columnIndex == 0){
+ return OWLAPIDescriptionConvertVisitor.getOWLDescription(descriptions.get(rowIndex).getDescription());
+ } else {
+ return Boolean.valueOf(selected.get(rowIndex) == columnIndex);
+ }
+ }
+
+ @Override
+ public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
+ if(columnIndex >= 1){
+ selected.set(rowIndex, Integer.valueOf(columnIndex));
+ fireTableRowsUpdated(rowIndex, rowIndex);
+ } else {
+ super.setValueAt(aValue, rowIndex, columnIndex);
+ }
+ }
+
+ @Override
+ public boolean isCellEditable(int rowIndex, int columnIndex) {
+ return columnIndex >= 1;
+ }
+
+ @Override
+ public String getColumnName(int columnIndex) {
+ return COLUMN_NAMES[columnIndex];
+ }
+
+ public void setDescriptions(List<EvaluatedDescriptionClass> descriptions){
+ this.descriptions = descriptions;
+ this.selected = new ArrayList<Integer>(descriptions.size());
+ for(int i = 0; i < descriptions.size(); i++){
+ selected.add(i, Integer.valueOf(2));
+ }
+ fireTableDataChanged();
+ }
+
+ public EvaluatedDescriptionClass getSelectedEvaluatedDescription(int rowIndex){
+ return descriptions.get(rowIndex);
+ }
+
+}
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/GraphicalCoveragePanel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/GraphicalCoveragePanel.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/GraphicalCoveragePanel.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,707 @@
+/**
+ * Copyright (C) 2007-2009, Jens Lehmann
+ *
+ * This file is part of DL-Learner.
+ *
+ * DL-Learner is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * DL-Learner 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package org.dllearner.tools.evaluationplugin;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionListener;
+import java.awt.geom.Ellipse2D;
+import java.util.Random;
+import java.util.Set;
+import java.util.Vector;
+
+import javax.swing.JPanel;
+
+import org.dllearner.core.EvaluatedDescription;
+import org.dllearner.core.owl.Individual;
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.learningproblems.EvaluatedDescriptionClass;
+import org.dllearner.tools.protege.IndividualPoint;
+import org.dllearner.utilities.owl.OWLAPIDescriptionConvertVisitor;
+import org.protege.editor.owl.OWLEditorKit;
+
+
+/**
+ * This class draws the graphical coverage of a learned concept.
+ *
+ * @author Christian Koetteritzsch
+ *
+ */
+public class GraphicalCoveragePanel extends JPanel implements MouseMotionListener{
+
+ private static final long serialVersionUID = 855436961912515267L;
+ private static final int HEIGHT = 200;
+ private static final int WIDTH = 200;
+ private static final int ELLIPSE_X_AXIS = 30;
+ private static final int ELLIPSE_Y_AXIS = 30;
+ private static final int MAX_NUMBER_OF_INDIVIDUAL_POINTS = 20;
+// private static final int PLUS_SIZE = 5;
+ private static final int MAX_RANDOM_NUMBER = 300;
+
+
+// private int shiftXAxis;
+// private int distortionOld;
+ private Ellipse2D oldConcept;
+ private Ellipse2D newConcept;
+
+ private EvaluatedDescription eval;
+ private NamedClass concept;
+
+ private OWLEditorKit editorKit;
+
+
+ private final Vector<IndividualPoint> posCovIndVector;
+ private final Vector<IndividualPoint> posNotCovIndVector;
+ private final Vector<IndividualPoint> additionalIndividuals;
+ private final Vector<IndividualPoint> points;
+
+// private int adjustment;
+ private int shiftOldConcept;
+ private int shiftNewConcept;
+ private int shiftNewConceptX;
+ private int shiftCovered;
+ private int x1;
+ private int x2;
+ private int y1;
+ private int y2;
+// private int centerX;
+// private int centerY;
+ private final Random random;
+ private final Color darkGreen;
+ private final Color darkRed;
+// private int notCoveredInd;
+
+ private String coverageString = "";
+ private String coversAdditionalString = "";
+
+
+ /**
+ *
+ * This is the constructor for the GraphicalCoveragePanel.
+ *
+ * @param desc
+ * EvaluatedDescription
+ * @param concept
+ * String
+ * @param p
+ * MoreDetailForSuggestedConceptsPanel
+ */
+ public GraphicalCoveragePanel(OWLEditorKit editorKit) {
+ this.editorKit = editorKit;
+
+ this.setPreferredSize(new Dimension(640, 260));
+
+// this.repaint();
+ darkGreen = new Color(0, 100, 0);
+ darkRed = new Color(205, 0, 0);
+ random = new Random();
+ posCovIndVector = new Vector<IndividualPoint>();
+ posNotCovIndVector = new Vector<IndividualPoint>();
+ additionalIndividuals = new Vector<IndividualPoint>();
+ points = new Vector<IndividualPoint>();
+
+
+
+ oldConcept = new Ellipse2D.Double(ELLIPSE_X_AXIS,
+ ELLIPSE_Y_AXIS, WIDTH, HEIGHT);
+ newConcept = new Ellipse2D.Double(0, 0, 0, 0);
+ addMouseMotionListener(this);
+// this.computeIndividualPoints();
+
+ }
+
+
+ @Override
+ protected void paintComponent(Graphics g) {
+// g.clearRect(0, 0, 400, 400);
+// g.clearRect(320, 130, 320, 50);
+ Graphics2D g2D;
+ g2D = (Graphics2D) g;
+// Composite original = g2D.getComposite();
+ AlphaComposite ac = AlphaComposite.getInstance(
+ AlphaComposite.SRC_OVER, 0.5f);
+ g2D.setColor(Color.BLACK);
+
+ if(concept != null){
+ String rendering = editorKit.getOWLModelManager().getRendering(OWLAPIDescriptionConvertVisitor.getOWLDescription(concept));
+ g2D.drawString(rendering, 320, 10);
+ }
+ if(eval != null){
+ String rendering = editorKit.getOWLModelManager().getRendering(OWLAPIDescriptionConvertVisitor.getOWLDescription(eval.getDescription()));
+ g2D.drawString(rendering, 320, 30);
+ }
+
+
+ g2D.setColor(Color.ORANGE);
+ g2D.fillOval(310, 20, 9, 9);
+ g2D.setColor(Color.black);
+ int p = 50;
+
+ g2D.setColor(darkGreen);
+ Ellipse2D circlePoint = new Ellipse2D.Double(315 - 1, p - 6, 4, 4);
+ g2D.fill(circlePoint);
+ g2D.setColor(Color.BLACK);
+ g2D.drawString("individuals covered by", 320, p);
+ g2D.setColor(Color.ORANGE);
+ g2D.fillOval(460, p - 9, 9, 9);
+ g2D.setColor(Color.BLACK);
+ g2D.drawString("and", 475, p);
+ g2D.setColor(Color.YELLOW);
+ g2D.fillOval(505, p - 9, 9, 9);
+ g2D.setColor(Color.BLACK);
+ p = p + 20;
+ g2D.drawString("(OK)", 320, p);
+ p = p + 20;
+
+ g2D.setColor(darkRed);
+ Ellipse2D circlePoint2 = new Ellipse2D.Double(315 - 1, p - 6, 4, 4);
+ g2D.fill(circlePoint2);
+ g2D.setColor(Color.BLACK);
+ g2D.drawString("individuals covered by", 320, p);
+ g2D.setColor(Color.ORANGE);
+ g2D.fillOval(460, p - 9, 9, 9);
+ g2D.setColor(Color.BLACK);
+ p = p + 20;
+ g2D.drawString("(potential problem)", 320, p);
+ p = p + 20;
+ g2D.setColor(darkRed);
+ Ellipse2D circlePoint3 = new Ellipse2D.Double(315 - 1, p - 6, 4, 4);
+ g2D.fill(circlePoint3);
+ g2D.setColor(Color.BLACK);
+ g2D.drawString("individuals covered by", 320, p);
+ g2D.setColor(Color.YELLOW);
+ g2D.fillOval(460, p - 9, 9, 9);
+ g2D.setColor(Color.BLACK);
+ p = p + 20;
+ g2D.drawString("(potential problem)", 320, p);
+
+ p = p +20;
+ g2D.drawString(coverageString , 320, p);
+ p = p +20;
+ g2D.drawString(coversAdditionalString , 320, p);
+
+
+
+ g2D.setColor(Color.YELLOW);
+ g2D.fill(oldConcept);
+ g2D.fillOval(310, 0, 9, 9);
+ g2D.setColor(Color.ORANGE);
+ g2D.setComposite(ac);
+ g2D.fill(newConcept);
+ g2D.setColor(Color.BLACK);
+ for (int i = 0; i < posCovIndVector.size(); i++) {
+ g2D.setColor(darkGreen);
+ g2D.fill(posCovIndVector.get(i).getIndividualPoint());
+ }
+
+ for (int i = 0; i < posNotCovIndVector.size(); i++) {
+ g2D.setColor(darkRed);
+ g2D.fill(posNotCovIndVector.get(i).getIndividualPoint());
+ }
+
+ for (int i = 0; i < additionalIndividuals.size(); i++) {
+ g2D.setColor(Color.BLACK);
+ g2D.fill(additionalIndividuals.get(i).getIndividualPoint());
+ }
+
+// if(eval != null){
+// // Plus 1
+// if (coveredIndividualSize != OREManager.getInstance()
+// .getPelletReasoner().getIndividuals(
+// OREManager.getInstance().getCurrentClass2Learn())
+// .size()
+// && notCoveredInd != 0) {
+// g2D.drawLine(x1 - 1 - shiftOldConcept, y1 - 1, x2 + 1
+// - shiftOldConcept, y1 - 1);
+// g2D.drawLine(x1 - shiftOldConcept, centerY - 1, x2
+// - shiftOldConcept, centerY - 1);
+// g2D.drawLine(x1 - shiftOldConcept, centerY, x2
+// - shiftOldConcept, centerY);
+// g2D.drawLine(x1 - shiftOldConcept, centerY + 1, x2
+// - shiftOldConcept, centerY + 1);
+// g2D.drawLine(x1 - 1 - shiftOldConcept, y2 + 1, x2 + 1
+// - shiftOldConcept, y2 + 1);
+//
+// g2D.drawLine(x1 - 1 - shiftOldConcept, y1 - 1, x1 - 1
+// - shiftOldConcept, y2 + 1);
+// g2D.drawLine(centerX - 1 - shiftOldConcept, y1, centerX - 1
+// - shiftOldConcept, y2);
+// g2D.drawLine(centerX - shiftOldConcept, y1, centerX
+// - shiftOldConcept, y2);
+// g2D.drawLine(centerX + 1 - shiftOldConcept, y1, centerX + 1
+// - shiftOldConcept, y2);
+// g2D.drawLine(x2 + 1 - shiftOldConcept, y1 - 1, x2 + 1
+// - shiftOldConcept, y2 + 1);
+// }
+// // Plus 2
+//
+// g2D.drawLine(x1 - 1 + shiftCovered, y1 - 1, x2 + 1 + shiftCovered,
+// y1 - 1);
+// g2D.drawLine(x1 + shiftCovered, centerY - 1, x2 + shiftCovered,
+// centerY - 1);
+// g2D
+// .drawLine(x1 + shiftCovered, centerY, x2 + shiftCovered,
+// centerY);
+// g2D.drawLine(x1 + shiftCovered, centerY + 1, x2 + shiftCovered,
+// centerY + 1);
+// g2D.drawLine(x1 - 1 + shiftCovered, y2 + 1, x2 + 1 + shiftCovered,
+// y2 + 1);
+//
+// g2D.drawLine(x1 - 1 + shiftCovered, y1 - 1, x1 - 1 + shiftCovered,
+// y2 + 1);
+// g2D.drawLine(centerX - 1 + shiftCovered, y1, centerX - 1
+// + shiftCovered, y2);
+// g2D
+// .drawLine(centerX + shiftCovered, y1, centerX
+// + shiftCovered, y2);
+// g2D.drawLine(centerX + 1 + shiftCovered, y1, centerX + 1
+// + shiftCovered, y2);
+// g2D.drawLine(x2 + 1 + shiftCovered, y1 - 1, x2 + 1 + shiftCovered,
+// y2 + 1);
+//
+// // Plus 3
+// if (coveredIndividualSize != OREManager.getInstance()
+// .getPelletReasoner().getIndividuals(
+// OREManager.getInstance().getCurrentClass2Learn())
+// .size()
+// && ((EvaluatedDescriptionClass) eval)
+// .getAdditionalInstances().size() != 0) {
+// g2D.drawLine(x1 - 1 + shiftNewConcept, y1 - 1, x2 + 1
+// + shiftNewConcept, y1 - 1);
+// g2D.drawLine(x1 + shiftNewConcept, centerY - 1, x2
+// + shiftNewConcept, centerY - 1);
+// g2D.drawLine(x1 + shiftNewConcept, centerY, x2
+// + shiftNewConcept, centerY);
+// g2D.drawLine(x1 + shiftNewConcept, centerY + 1, x2
+// + shiftNewConcept, centerY + 1);
+// g2D.drawLine(x1 - 1 + shiftNewConcept, y2 + 1, x2 + 1
+// + shiftNewConcept, y2 + 1);
+//
+// g2D.drawLine(x1 - 1 + shiftNewConcept, y1 - 1, x1 - 1
+// + shiftNewConcept, y2 + 1);
+// g2D.drawLine(centerX - 1 + shiftNewConcept, y1, centerX - 1
+// + shiftNewConcept, y2);
+// g2D.drawLine(centerX + shiftNewConcept, y1, centerX
+// + shiftNewConcept, y2);
+// g2D.drawLine(centerX + 1 + shiftNewConcept, y1, centerX + 1
+// + shiftNewConcept, y2);
+// g2D.drawLine(x2 + 1 + shiftNewConcept, y1 - 1, x2 + 1
+// + shiftNewConcept, y2 + 1);
+// }
+// // Plus 4
+// if (((EvaluatedDescriptionClass) eval).getAddition() != 1.0
+// && ((EvaluatedDescriptionClass) eval).getCoverage() == 1.0) {
+// g2D.drawLine(x1 - 1 + shiftNewConceptX, y1 - 1
+// + shiftNewConcept, x2 + 1 + shiftNewConceptX, y1 - 1
+// + shiftNewConcept);
+// g2D.drawLine(x1 + shiftNewConceptX, centerY - 1
+// + shiftNewConcept, x2 + shiftNewConceptX, centerY - 1
+// + shiftNewConcept);
+// g2D.drawLine(x1 + shiftNewConceptX, centerY + shiftNewConcept,
+// x2 + shiftNewConceptX, centerY + shiftNewConcept);
+// g2D.drawLine(x1 + shiftNewConceptX, centerY + 1
+// + shiftNewConcept, x2 + shiftNewConceptX, centerY + 1
+// + shiftNewConcept);
+// g2D.drawLine(x1 - 1 + shiftNewConceptX, y2 + 1
+// + shiftNewConcept, x2 + 1 + shiftNewConceptX, y2 + 1
+// + shiftNewConcept);
+//
+// g2D.drawLine(x1 - 1 + shiftNewConceptX, y1 - 1
+// + shiftNewConcept, x1 - 1 + shiftNewConceptX, y2 + 1
+// + shiftNewConcept);
+// g2D.drawLine(centerX - 1 + shiftNewConceptX, y1
+// + shiftNewConcept, centerX - 1 + shiftNewConceptX, y2
+// + shiftNewConcept);
+// g2D.drawLine(centerX + shiftNewConceptX, y1 + shiftNewConcept,
+// centerX + shiftNewConceptX, y2 + shiftNewConcept);
+// g2D.drawLine(centerX + 1 + shiftNewConceptX, y1
+// + shiftNewConcept, centerX + 1 + shiftNewConceptX, y2
+// + shiftNewConcept);
+// g2D.drawLine(x2 + 1 + shiftNewConceptX, y1 - 1
+// + shiftNewConcept, x2 + 1 + shiftNewConceptX, y2 + 1
+// + shiftNewConcept);
+// }
+// }
+//
+// for (int i = 0; i < posCovIndVector.size(); i++) {
+// g2D.setColor(darkGreen);
+// g2D.fill(posCovIndVector.get(i).getIndividualPoint());
+// }
+//
+// for (int i = 0; i < posNotCovIndVector.size(); i++) {
+// g2D.setColor(darkRed);
+// g2D.fill(posNotCovIndVector.get(i).getIndividualPoint());
+// }
+//
+// for (int i = 0; i < additionalIndividuals.size(); i++) {
+// g2D.setColor(Color.BLACK);
+// g2D.fill(additionalIndividuals.get(i).getIndividualPoint());
+// }
+// if (!((EvaluatedDescriptionClass) eval).isConsistent()) {
+// g2D.setComposite(original);
+// g2D.setColor(darkRed);
+// g2D
+// .drawString(
+// "Adding this class expression may lead to an inconsistent ontology.",
+// 0, 220);
+// }
+// if (eval.getAccuracy() == 1.0) {
+// g2D.setComposite(original);
+// g2D.setColor(Color.ORANGE);
+// g2D.fillOval(0, 211, 9, 9);
+// g2D.setColor(darkRed);
+// g2D.drawString("and", 25, 220);
+// g2D.setColor(Color.YELLOW);
+// g2D.fillOval(65, 211, 9, 9);
+// g2D.setColor(darkRed);
+// g2D.drawString("cover the same instances.", 95, 220);
+// }
+
+// }
+// getParent().repaint();
+ }
+
+
+
+ public void setNewClassDescription(EvaluatedDescription desc) {
+ this.eval = desc;
+
+
+ boolean hasAdditional = !((EvaluatedDescriptionClass) eval).getAdditionalInstances().isEmpty();
+ boolean allPosCovered = ((EvaluatedDescriptionClass) eval).getCoverage() == 1.0;
+
+ if (allPosCovered && hasAdditional) {
+ newConcept = new Ellipse2D.Double(ELLIPSE_X_AXIS -25
+ , ELLIPSE_Y_AXIS -25, WIDTH + 50,
+ HEIGHT + 50);
+
+
+ } else if(!allPosCovered && hasAdditional){
+ newConcept = new Ellipse2D.Double(ELLIPSE_X_AXIS + 20
+ , ELLIPSE_Y_AXIS, WIDTH,
+ HEIGHT);
+ } else if(allPosCovered && !hasAdditional){
+ newConcept = new Ellipse2D.Double(ELLIPSE_X_AXIS
+ , ELLIPSE_Y_AXIS, WIDTH,
+ HEIGHT);
+ } else if(!allPosCovered && !hasAdditional){
+ newConcept = new Ellipse2D.Double(ELLIPSE_X_AXIS + 20
+ , ELLIPSE_Y_AXIS, WIDTH - 20,
+ HEIGHT);
+ }
+// computeGraphics();
+ computeIndividualPoints();
+ int coveredInstanceCount = ((EvaluatedDescriptionClass) eval).getCoveredInstances().size();
+ int instanceCount = coveredInstanceCount + ((EvaluatedDescriptionClass) eval).getNotCoveredInstances().size();
+ int coverage = (int)(((EvaluatedDescriptionClass) eval).getCoverage() * 100);
+ int additionalCount = ((EvaluatedDescriptionClass) eval).getAdditionalInstances().size();
+ coverageString = "Covers " + coveredInstanceCount + " of " + instanceCount +
+ "(" + coverage + " %) of all instances.";
+ coversAdditionalString = "Covers " + additionalCount + " additional instances.";
+ getParent().repaint();
+
+ }
+
+ public void setConcept(NamedClass nc){
+ eval = null;
+ clear();
+ concept = nc;
+ getParent().repaint();
+ }
+
+ public void clear(){
+ newConcept = new Ellipse2D.Double(0, 0, 0, 0);
+ posCovIndVector.clear();
+ posNotCovIndVector.clear();
+ additionalIndividuals.clear();
+ points.clear();
+ coverageString = "";
+ coversAdditionalString = "";
+ getParent().repaint();
+ }
+
+
+
+ public void computeIndividualPoints() {
+ posCovIndVector.clear();
+ posNotCovIndVector.clear();
+ additionalIndividuals.clear();
+ points.clear();
+
+ if (eval != null) {
+ Set<Individual> posInd = ((EvaluatedDescriptionClass) eval)
+ .getCoveredInstances();
+ int i = 0;
+ double x = random.nextInt(MAX_RANDOM_NUMBER);
+ double y = random.nextInt(MAX_RANDOM_NUMBER);
+ boolean flag = true;
+ for (Individual ind : posInd) {
+ flag = true;
+ if (i < MAX_NUMBER_OF_INDIVIDUAL_POINTS) {
+ while (flag) {
+ if (newConcept.contains(x, y)
+ && oldConcept.contains(x, y)
+ && !(x >= this.getX1() + this.getShiftCovered()
+ && x <= this.getX2()
+ + this.getShiftCovered()
+ && y >= this.getY1() && y <= this
+ .getY2())) {
+
+ posCovIndVector.add(new IndividualPoint("*",
+ (int) x, (int) y, ind.toString()));
+
+ i++;
+ flag = false;
+
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ break;
+ } else {
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ }
+
+ }
+ }
+ }
+
+ Set<Individual> posNotCovInd = ((EvaluatedDescriptionClass) eval)
+ .getAdditionalInstances();
+ int j = 0;
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ for (Individual ind : posNotCovInd) {
+ flag = true;
+ if (j < MAX_NUMBER_OF_INDIVIDUAL_POINTS) {
+ while (flag) {
+ if (!oldConcept.contains(x, y)
+ && newConcept.contains(x, y)
+ && !(x >= this.getX1()
+ + this.getShiftNewConcept()
+ && x <= this.getX2()
+ + this.getShiftNewConcept()
+ && y >= this.getY1() && y <= this
+ .getY2())
+ && !(x >= this.getX1()
+ + this.getShiftNewConceptX()
+ && x <= this.getX2()
+ + this.getShiftNewConceptX()
+ && y >= this.getY1()
+ + this.getShiftNewConcept() && y <= this
+ .getY2()
+ + this.getShiftNewConcept())) {
+
+
+ posNotCovIndVector.add(new IndividualPoint("*",
+ (int) x, (int) y, ind.toString()));
+
+
+ j++;
+ flag = false;
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ break;
+ } else {
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ }
+
+ }
+ }
+ }
+
+ Set<Individual> notCovInd = ((EvaluatedDescriptionClass) eval).getNotCoveredInstances();
+
+
+// notCoveredInd = notCovInd.size();
+ int k = 0;
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ for (Individual ind : notCovInd) {
+ flag = true;
+ if (k < MAX_NUMBER_OF_INDIVIDUAL_POINTS) {
+ while (flag) {
+ if (oldConcept.contains(x, y)
+ && !newConcept.contains(x, y)
+ && !(x >= this.getX1()
+ - this.getShiftOldConcept()
+ && x <= this.getX2()
+ - this.getShiftOldConcept()
+ && y >= this.getY1() && y <= this
+ .getY2())) {
+
+ posNotCovIndVector.add(new IndividualPoint("*",
+ (int) x, (int) y, ind.toString()));
+
+ k++;
+ flag = false;
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ break;
+ } else {
+ x = random.nextInt(MAX_RANDOM_NUMBER);
+ y = random.nextInt(MAX_RANDOM_NUMBER);
+ }
+
+ }
+ }
+ }
+ points.addAll(posCovIndVector);
+ points.addAll(posNotCovIndVector);
+ points.addAll(additionalIndividuals);
+ }
+ }
+
+ /**
+ * This method returns a Vector of all individuals that are drawn in the
+ * panel.
+ *
+ * @return Vector of Individuals
+ */
+ public Vector<IndividualPoint> getIndividualVector() {
+ return points;
+ }
+
+ /**
+ * This method returns the GraphicalCoveragePanel.
+ *
+ * @return GraphicalCoveragePanel
+ */
+ public GraphicalCoveragePanel getGraphicalCoveragePanel() {
+ return this;
+ }
+
+
+
+ /**
+ * Returns the min. x value of the plus.
+ *
+ * @return int min X Value
+ */
+ public int getX1() {
+ return x1;
+ }
+
+ /**
+ * Returns the max. x value of the plus.
+ *
+ * @return int max X Value
+ */
+ public int getX2() {
+ return x2;
+ }
+
+ /**
+ * Returns the min. y value of the plus.
+ *
+ * @return int min Y Value
+ */
+ public int getY1() {
+ return y1;
+ }
+
+ /**
+ * Returns the max. y value of the plus.
+ *
+ * @return int max Y Value
+ */
+ public int getY2() {
+ return y2;
+ }
+
+ /**
+ * This method returns how much the old concept must be shifted.
+ * @return shift of the old concept
+ */
+ public int getShiftOldConcept() {
+ return shiftOldConcept;
+ }
+
+ /**
+ * This method returns how much the plus in the middle must be shifted.
+ * @return shift of the middle plus
+ */
+ public int getShiftCovered() {
+ return shiftCovered;
+ }
+
+ /**
+ * This method returns how much the new concept must be shifted.
+ * @return shift of the new concept
+ */
+ public int getShiftNewConcept() {
+ return shiftNewConcept;
+ }
+
+ /**
+ * This method returns how much the new concept must be shifted.
+ * @return shift of the new concept
+ */
+ public int getShiftNewConceptX() {
+ return shiftNewConceptX;
+ }
+
+ /**
+ * Unsets the panel after plugin is closed.
+ */
+ public void unsetPanel() {
+ this.removeAll();
+ eval = null;
+ }
+
+ /**
+ * Returns the currently selected evaluated description.
+ *
+ * @return EvaluatedDescription
+ */
+ public EvaluatedDescription getEvaluateddescription() {
+ return eval;
+ }
+
+ @Override
+ public void mouseDragged(MouseEvent e) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void mouseMoved(MouseEvent e) {
+ double x = e.getPoint().getX();
+ double y = e.getPoint().getY();
+ String toolTip = null;
+ for(IndividualPoint point : points){
+ if(Math.abs(point.getIndividualPoint().getCenterX() - x) <= 8
+ && Math.abs(point.getIndividualPoint().getCenterY() - y) <= 8 ){
+ toolTip = point.getIndividualName();
+ break;
+
+ }
+
+ }
+ setToolTipText(toolTip);
+
+
+ }
+
+}
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/MANIFEST.MF
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/MANIFEST.MF (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/MANIFEST.MF 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,43 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: DL-Learner Evaluation Plugin
+Bundle-SymbolicName: org.coode.dlquery;singleton:=true
+Bundle-Category: protege
+Bundle-Description: A plugin for evaluating DL-Learner class descriptions
+Bundle-Vendor: Lorenz Buehmann
+Bundle-DocURL: http://www.co-ode.org
+Bundle-ClassPath: .,lib/dllearner.jar,lib/json.jar,lib/swingx-1.0.jar
+Import-Package: org.osgi.framework,
+ org.apache.log4j,
+ javax.swing,
+ javax.swing.border,
+ javax.swing.colorchooser,
+ javax.swing.event,
+ javax.swing.filechooser,
+ javax.swing.plaf,
+ javax.swing.plaf.basic,
+ javax.swing.plaf.metal,
+ javax.swing.plaf.multi,
+ javax.swing.plaf.synth,
+ javax.swing.table,
+ javax.swing.text,
+ javax.swing.text.html,
+ javax.swing.text.html.parser,
+ javax.swing.text.rtf,
+ javax.swing.tree,
+ javax.swing.undo,
+ org.w3c.dom,
+ org.w3c.dom.bootstrap,
+ org.w3c.dom.events,
+ org.w3c.dom.ls,
+ org.xml.sax,
+ org.xml.sax.ext,
+ org.xml.sax.helpers,
+ javax.xml.parsers
+Bundle-Version: 1.0.3
+Bundle-Activator: org.protege.editor.core.plugin.DefaultPluginActivator
+Require-Bundle: org.eclipse.equinox.registry,
+ org.eclipse.equinox.common,
+ org.protege.editor.core.application,
+ org.protege.editor.owl,
+ org.semanticweb.owl.owlapi
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/plugin.xml
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/plugin.xml (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/plugin.xml 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,17 @@
+<?xml version="1.0" ?>
+ <plugin>
+ <extension id="org.dllearner.EvaluationPlugin"
+ point="org.protege.editor.core.application.ViewComponent">
+ <label value="DL-Learner Evaluation"/>
+ <class value="org.dllearner.tools.evaluationplugin.EvaluationPlugin"/>
+ <headerColor value="@org.protege.classcolor"/>
+ <category value="@org.protege.classcategory"/>
+ </extension>
+ <extension id="DLLearnerEvaluationTab" point="org.protege.editor.core.application.WorkspaceTab">
+ <label value="DL-Learner Evaluation Tab"/>
+ <class value="org.protege.editor.owl.ui.OWLWorkspaceViewsTab"/>
+ <index value="X"/>
+ <editorKitId value="OWLEditorKit"/>
+ <defaultViewConfigFileName value="viewconfig-evalTab.xml"/>
+ </extension>
+ </plugin>
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/viewconfig-evalTab.xml
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/viewconfig-evalTab.xml (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/META-INF/viewconfig-evalTab.xml 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<layout>
+ <VSNode splits="0.5712651314140688 0.42873486858593135">
+ <CNode>
+ <Component label="DL-Learner Evaluation">
+ <Property id="pluginId" value="org.coode.dlquery.org.dllearner.EvaluationPlugin"/>
+ </Component>
+ </CNode>
+ <HSNode splits="0.19774193548387098 0.17725806451612902 0.125">
+ <CNode>
+ <Component label="Asserted class hierarchy">
+ <Property id="pluginId" value="org.protege.editor.owl.OWLAssertedClassHierarchy"/>
+ </Component>
+ </CNode>
+ <CNode>
+ <Component label="Annotations">
+ <Property id="pluginId" value="org.protege.editor.owl.OWLClassAnnotations"/>
+ </Component>
+ </CNode>
+ <CNode>
+ <Component label="Description">
+ <Property id="pluginId" value="org.protege.editor.owl.OWLClassDescription"/>
+ </Component>
+ </CNode>
+ </HSNode>
+ </VSNode>
+</layout>
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonEditor.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonEditor.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonEditor.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,37 @@
+package org.dllearner.tools.evaluationplugin;
+
+import java.awt.Color;
+import java.awt.Component;
+
+import javax.swing.AbstractCellEditor;
+import javax.swing.JRadioButton;
+import javax.swing.JTable;
+import javax.swing.SwingConstants;
+import javax.swing.table.TableCellEditor;
+
+public class RadioButtonEditor extends AbstractCellEditor implements TableCellEditor {
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1124942535574963403L;
+
+ private JRadioButton button;
+
+ public RadioButtonEditor(){
+ button = new JRadioButton();
+ button.setHorizontalAlignment(SwingConstants.CENTER);
+ button.setBackground(Color.WHITE);
+ }
+ @Override
+ public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
+ button.setSelected((Boolean)value);
+ return button;
+ }
+
+
+
+ @Override
+ public Object getCellEditorValue() {
+ return button.isSelected();
+ }
+}
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonRenderer.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonRenderer.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/RadioButtonRenderer.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,25 @@
+package org.dllearner.tools.evaluationplugin;
+
+import java.awt.Color;
+import java.awt.Component;
+
+import javax.swing.JRadioButton;
+import javax.swing.JTable;
+import javax.swing.SwingConstants;
+import javax.swing.table.TableCellRenderer;
+
+public class RadioButtonRenderer extends JRadioButton implements TableCellRenderer {
+ /**
+ *
+ */
+ private static final long serialVersionUID = -688293293192402900L;
+
+
+ public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+ int row, int column) {
+ setSelected((Boolean)value);
+ setHorizontalAlignment(SwingConstants.CENTER);
+ setBackground(Color.WHITE);
+ return this;
+ }
+}
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalCaption.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalCaption.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalCaption.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,45 @@
+package org.dllearner.tools.evaluationplugin;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+
+import javax.swing.Icon;
+import javax.swing.ImageIcon;
+import javax.swing.JComponent;
+
+public class VerticalCaption {
+
+ static Icon getVerticalCaption (JComponent component, String caption, boolean clockwise) {
+ Font f = component.getFont ();
+ FontMetrics fm = component.getFontMetrics (f);
+ int captionHeight = fm.getHeight ();
+ int captionWidth = fm.stringWidth (caption);
+ BufferedImage bi = new BufferedImage (captionHeight + 4,
+ captionWidth + 4, BufferedImage.TYPE_INT_ARGB);
+ Graphics2D g = (Graphics2D) bi.getGraphics ();
+
+ g.setColor (new Color (0, 0, 0, 0)); // transparent
+ g.fillRect (0, 0, bi.getWidth (), bi.getHeight ());
+
+ g.setColor (component.getForeground ());
+ g.setFont (f);
+ g.setRenderingHint (RenderingHints.KEY_TEXT_ANTIALIASING,
+ RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+
+ if (clockwise) {
+ g.rotate (Math.PI / 2);
+ } else {
+ g.rotate (- Math.PI / 2);
+ g.translate (-bi.getHeight (), bi.getWidth ());
+ }
+ g.drawString (caption, 2, -6);
+
+ Icon icon = new ImageIcon (bi);
+ return icon;
+ }
+}
+
Added: trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalHeaderRenderer.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalHeaderRenderer.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/evaluationplugin/VerticalHeaderRenderer.java 2010-02-12 22:53:03 UTC (rev 2022)
@@ -0,0 +1,32 @@
+package org.dllearner.tools.evaluationplugin;
+
+import java.awt.Component;
+
+import javax.swing.Icon;
+import javax.swing.JLabel;
+import javax.swing.JTable;
+import javax.swing.SwingConstants;
+import javax.swing.border.BevelBorder;
+import javax.swing.table.DefaultTableCellRenderer;
+
+public class VerticalHeaderRenderer extends DefaultTableCellRenderer {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -877134005972107198L;
+
+ @Override
+ public Component getTableCellRendererComponent (JTable table,
+ Object value, boolean isSelected, boolean hasFocus,
+ int row, int column) {
+
+ JLabel label = new JLabel ();
+ Icon icon = VerticalCaption.getVerticalCaption (label, value.toString (), false);
+ label.setIcon (icon);
+ label.setHorizontalAlignment (SwingConstants.CENTER);
+ label.setBorder (new BevelBorder (BevelBorder.RAISED));
+ return label;
+ }
+
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
