[DL-Learner SVN] SF.net SVN: dl-learner:[1832] trunk/src/dl-learner/org/dllearner/tools/ore

[<lor...@us...>]

Revision: 1832
          http://dl-learner.svn.sourceforge.net/dl-learner/?rev=1832&view=rev
Author:   lorenz_b
Date:     2009-08-29 14:08:33 +0000 (Sat, 29 Aug 2009)

Log Message:
-----------
added graphical coverage panel
made tool able to handle knowledge source change 

Modified Paths:
--------------
    trunk/src/dl-learner/org/dllearner/tools/ore/ExplanationManager.java
    trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java
    trunk/src/dl-learner/org/dllearner/tools/ore/RepairManager.java
    trunk/src/dl-learner/org/dllearner/tools/ore/explanation/CachedExplanationGenerator.java
    trunk/src/dl-learner/org/dllearner/tools/ore/explanation/LaconicTest.java
    trunk/src/dl-learner/org/dllearner/tools/ore/explanation/RootFinder.java
    trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/LaconicExplanationGenerator.java
    trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/OPlus.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTable.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTableModel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/ManchesterSyntaxRenderer.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/MetricsPanel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/ResultTable.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/ResultTableModel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/UnsatisfiableClassesTable.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/UnsatisfiableClassesTableModel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/WizardController.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/descriptors/KnowledgeSourcePanelDescriptor.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/descriptors/LearningPanelDescriptor.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/descriptors/RepairPanelDescriptor.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/descriptors/UnsatisfiableExplanationPanelDescriptor.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/panels/KnowledgeSourcePanel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/panels/LearningPanel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/panels/RepairPanel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/wizard/panels/UnsatisfiableExplanationPanel.java

Added Paths:
-----------
    trunk/src/dl-learner/org/dllearner/tools/ore/OREManagerListener.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/GraphicalCoveragePanel.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/IndividualsTable.java
    trunk/src/dl-learner/org/dllearner/tools/ore/ui/IndividualsTableModel.java

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ExplanationManager.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ExplanationManager.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ExplanationManager.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -24,33 +24,32 @@
 import uk.ac.manchester.cs.owl.explanation.ordering.DefaultExplanationOrderer;
 import uk.ac.manchester.cs.owl.explanation.ordering.ExplanationTree;
 
-public class ExplanationManager implements OWLOntologyChangeListener, RepairManagerListener{
+public class ExplanationManager implements OWLOntologyChangeListener, RepairManagerListener, OREManagerListener{
 
 	private static ExplanationManager instance;
 	
 	private OWLOntologyManager manager;
 	private OWLDataFactory dataFactory;
-	private PelletReasonerFactory reasonerFactory;
 	private OWLOntology ontology;
 	private Reasoner reasoner;
 
 	private RootFinder rootFinder;
 
-	private Set<OWLClass> unsatClasses;
-	private Set<OWLClass> rootClasses;
-	boolean ontologyChanged = true;
-	boolean isLaconicMode = false;
+	private boolean ontologyChanged = true;
+	private boolean isLaconicMode = false;
 	private boolean isComputeAllExplanations = false;
 	private int maxExplantionCount = 1;
+	private boolean allExplanationWarningChecked = false;
+	
 	private List<ExplanationManagerListener> listeners;
 	
-	private boolean allExplanationWarningChecked = false;
 	
+	
 	private CachedExplanationGenerator gen;
 	
 	
 	private ExplanationManager(OREManager oreMan) {
-		
+		OREManager.getInstance().addListener(this);
 		this.reasoner = oreMan.getPelletReasoner().getReasoner();
 		this.manager = reasoner.getManager();
 		this.ontology = reasoner.getLoadedOntologies().iterator().next();
@@ -59,13 +58,10 @@
 //		manager.addOntologyChangeListener(reasoner);
 		dataFactory = manager.getOWLDataFactory();
 		RepairManager.getRepairManager(oreMan).addListener(this);
-		reasonerFactory = new PelletReasonerFactory();
+	
 
-		rootFinder = new RootFinder(manager, reasoner, reasonerFactory);
+		rootFinder = new RootFinder();
 
-		rootClasses = new HashSet<OWLClass>();
-		unsatClasses = new HashSet<OWLClass>();
-		
 		listeners = new ArrayList<ExplanationManagerListener>();
 		
 		gen = new CachedExplanationGenerator(ontology, reasoner);
@@ -91,28 +87,14 @@
 		return instance;
 	}
 	
-	public Set<OWLClass> getUnsatisfiableClasses(){
-		computeRootUnsatisfiableClasses();
-		return unsatClasses;
+	public Set<OWLClass> getDerivedClasses(){
+		return rootFinder.getDerivedClasses();
 	}
 	
 	public Set<OWLClass> getRootUnsatisfiableClasses(){
-		computeRootUnsatisfiableClasses();
-		return rootClasses;
+		return rootFinder.getRootClasses();
 	}
 	
-		
-	private void computeRootUnsatisfiableClasses(){
-		if(ontologyChanged){
-			rootClasses.clear();
-			unsatClasses.clear();
-			unsatClasses.addAll(reasoner.getInconsistentClasses());
-			rootClasses.addAll(rootFinder.getRootClasses());
-			ontologyChanged = false;
-		}
-		
-	}
-	
 	public Set<List<OWLAxiom>> getUnsatisfiableExplanations(OWLClass unsat) {
 
 		OWLSubClassAxiom entailment = dataFactory.getOWLSubClassAxiom(unsat,
@@ -173,7 +155,7 @@
 	@Override
 	public void ontologiesChanged(List<? extends OWLOntologyChange> changes)
 			throws OWLException {
-		ontologyChanged = true;	
+		ontologyChanged = true;
 	}
 	
 	public int getArity(OWLClass cl, OWLAxiom ax) {
@@ -198,6 +180,10 @@
 		
 	}
 	
+	public boolean isLaconicMode(){
+		return gen.isLaconicMode();
+	}
+	
 	public void setComputeAllExplanationsMode(boolean value){
 		isComputeAllExplanations = value;
 		fireExplanationLimitChanged();
@@ -256,5 +242,20 @@
 		return allExplanationWarningChecked;
 	}
 	
+	public Set<OWLAxiom> getSourceAxioms(OWLAxiom ax){
+		return gen.getSourceAxioms(ax);
+	}
 	
+	public Set<OWLAxiom> getRemainingAxioms(OWLAxiom source, OWLAxiom part){
+		return gen.getRemainingAxioms(source, part);
+	}
+
+	@Override
+	public void activeOntologyChanged() {
+		ontology = OREManager.getInstance().getPelletReasoner().getOWLAPIOntologies();
+		reasoner = OREManager.getInstance().getPelletReasoner().getReasoner();
+		gen = new CachedExplanationGenerator(ontology, reasoner);
+	}
+	
+	
 }

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/OREManager.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -5,11 +5,14 @@
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URL;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
 import java.util.Vector;
 
 import javax.swing.JLabel;
@@ -59,17 +62,13 @@
 	private int maxExecutionTimeInSeconds = 10;
 	private int maxNrOfResults = 10;
 	
-	
+	private List<OREManagerListener> listeners;
 
-
 	private OntologyModifier modifier;
-	
-	private Thread currentClassificationThread;
 
-
-
 	public OREManager(){
 		cm = ComponentManager.getInstance();
+		listeners = new ArrayList<OREManagerListener>();
 	}
 	
 	public static synchronized OREManager getInstance() {
@@ -99,6 +98,10 @@
 		
 	}
 	
+	public KnowledgeSource getKnowledgeSource(){
+		return ks;
+	}
+	
 	public void setLearningProblem(){
 		
 		lp = cm.learningProblem(ClassLearningProblem.class, pelletReasoner);
@@ -150,30 +153,22 @@
 		baseURI = pelletReasoner.getBaseURI();
 		prefixes = pelletReasoner.getPrefixes();
 		modifier = new OntologyModifier(pelletReasoner);
+		fireActiveOntologyChanged();
 	}
 	
 	public void loadOntology(){
 		pelletReasoner.loadOntologies();
+		
 	}
 	
-	public void classifyAsynchronously(){
-		currentClassificationThread = new Thread(new Runnable() {
-			
-			@Override
-			public void run() {
-				pelletReasoner.classify();
-				
-			}
-		});
+	public void addListener(OREManagerListener listener){
+		listeners.add(listener);
 	}
 	
-	public void killCurrentClassificationThread(){
-		currentClassificationThread.stop();
-        
+	public void removeListener(OREManagerListener listener){
+		listeners.remove(listener);
 	}
 	
-	
-	
 	public boolean consistentOntology() throws InconsistentOntologyException{
 		return pelletReasoner.isConsistent();
 	}
@@ -182,8 +177,14 @@
 		return pelletReasoner;
 	}
 	
+	private void fireActiveOntologyChanged(){
+		for(OREManagerListener listener : listeners){
+			listener.activeOntologyChanged();
+		}
+	}
 	
 	
+	
 	public String getInconsistencyExplanationsString(){
 		ManchesterSyntaxExplanationRenderer renderer = new ManchesterSyntaxExplanationRenderer();
 		StringWriter buffer = new StringWriter();
@@ -239,6 +240,16 @@
 		
 	}
 	
+	public SortedSet<Individual> getPositiveFailureExamples(){
+		SortedSet<Individual> posNotCovered = pelletReasoner.getIndividuals(currentClass2Learn);
+		posNotCovered.removeAll(learnedClassDescription.getCoveredInstances());
+		return posNotCovered;
+	}
+	
+	public SortedSet<Individual> getNegativeFailureExamples(){
+		return new TreeSet<Individual>(learnedClassDescription.getAdditionalInstances());
+	}
+	
 	public void setNoisePercentage(double noisePercentage) {
 		this.noisePercentage = noisePercentage;
 	}
@@ -533,7 +544,7 @@
 	public Set<NamedClass> getComplements(Description desc, Individual ind){
 
 		Set<NamedClass> complements = new HashSet<NamedClass>();
-		System.out.println(pelletReasoner.getComplementClasses(desc));
+		
 		for(NamedClass nc : pelletReasoner.getNamedClasses()){
 			if(!(nc.toString().endsWith("Thing"))){
 				if(pelletReasoner.hasType(nc, ind)){

Added: trunk/src/dl-learner/org/dllearner/tools/ore/OREManagerListener.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/OREManagerListener.java	                        (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/OREManagerListener.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -0,0 +1,6 @@
+package org.dllearner.tools.ore;
+
+public interface OREManagerListener {
+	public abstract void activeOntologyChanged();
+
+}

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/RepairManager.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/RepairManager.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/RepairManager.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 import java.util.Stack;
 
 import org.mindswap.pellet.owlapi.Reasoner;
@@ -68,21 +69,41 @@
 		fireRepairPlanChanged();
 	}
 	
+	public void addAxioms2Remove(Set<OWLAxiom> axioms){
+		axioms2Remove.addAll(axioms);
+		fireRepairPlanChanged();
+	}
+	
 	public void removeAxiom2Remove(OWLAxiom ax){
 		axioms2Remove.remove(ax);
 		fireRepairPlanChanged();
 	}
 	
+	public void removeAxioms2Remove(Set<OWLAxiom> axioms){
+		axioms2Remove.removeAll(axioms);
+		fireRepairPlanChanged();
+	}
+	
 	public void addAxiom2Keep(OWLAxiom ax){
 		axioms2Keep.add(ax);
 		fireRepairPlanChanged();
 	}
 	
+	public void addAxioms2Keep(Set<OWLAxiom> axioms){
+		axioms2Keep.addAll(axioms);
+		fireRepairPlanChanged();
+	}
+	
 	public void removeAxiom2Keep(OWLAxiom ax){
 		axioms2Keep.remove(ax);
 		fireRepairPlanChanged();
 	}
 	
+	public void removeAxioms2Keep(Set<OWLAxiom> axioms){
+		axioms2Keep.removeAll(axioms);
+		fireRepairPlanChanged();
+	}
+	
 	public boolean isSelected(OWLAxiom ax){
 		return axioms2Remove.contains(ax);
 	}

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/explanation/CachedExplanationGenerator.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/explanation/CachedExplanationGenerator.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/explanation/CachedExplanationGenerator.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -58,6 +58,10 @@
 	public void setComputeLaconicExplanations(boolean laconic){
 		laconicMode = laconic;
 	}
+	
+	public boolean isLaconicMode(){
+		return laconicMode;
+	}
 
 	@Override
 	public Explanation getExplanation(OWLAxiom entailment){
@@ -169,4 +173,12 @@
 		}
 		
 	}
+	
+	public Set<OWLAxiom> getSourceAxioms(OWLAxiom ax){
+		return laconicExpGen.getSourceAxioms(ax);
+	}
+	
+	public Set<OWLAxiom> getRemainingAxioms(OWLAxiom source, OWLAxiom part){
+		return laconicExpGen.getRemainingAxioms(source, part);
+	}
 }

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/explanation/LaconicTest.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/explanation/LaconicTest.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/explanation/LaconicTest.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -170,7 +170,7 @@
 			Set<Explanation> preciseJusts = expGen.getExplanations(unsatAxiom);
 //			renderer.render(unsatAxiom, preciseJusts);
 			renderer.endRendering();
-			expGen.returnSourceAxioms(preciseJusts);
+		
 			
 		} catch (OWLOntologyCreationException e) {
 			// TODO Auto-generated catch block

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/explanation/RootFinder.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/explanation/RootFinder.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/explanation/RootFinder.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -9,6 +9,8 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.dllearner.tools.ore.OREManager;
+import org.dllearner.tools.ore.OREManagerListener;
 import org.mindswap.pellet.owlapi.PelletReasonerFactory;
 import org.semanticweb.owl.apibinding.OWLManager;
 import org.semanticweb.owl.inference.OWLReasoner;
@@ -26,6 +28,7 @@
 import org.semanticweb.owl.model.OWLDescriptionVisitor;
 import org.semanticweb.owl.model.OWLDisjointClassesAxiom;
 import org.semanticweb.owl.model.OWLEntity;
+import org.semanticweb.owl.model.OWLException;
 import org.semanticweb.owl.model.OWLObjectAllRestriction;
 import org.semanticweb.owl.model.OWLObjectComplementOf;
 import org.semanticweb.owl.model.OWLObjectExactCardinalityRestriction;
@@ -41,20 +44,28 @@
 import org.semanticweb.owl.model.OWLOntology;
 import org.semanticweb.owl.model.OWLOntologyChange;
 import org.semanticweb.owl.model.OWLOntologyChangeException;
+import org.semanticweb.owl.model.OWLOntologyChangeListener;
 import org.semanticweb.owl.model.OWLOntologyCreationException;
 import org.semanticweb.owl.model.OWLOntologyManager;
 import org.semanticweb.owl.model.OWLQuantifiedRestriction;
 import org.semanticweb.owl.model.RemoveAxiom;
 
-public class RootFinder implements OWLDescriptionVisitor{
+public class RootFinder implements OWLDescriptionVisitor, OREManagerListener, OWLOntologyChangeListener{
 
 	private OWLOntologyManager manager;
 	private OWLReasoner reasoner;
 	private OWLReasonerFactory reasonerFactory;
-	private Set<OWLClass> rootClasses;
+	
 	private Set<OWLClass> depend2Classes;
 	private OWLOntology ontology;
 	
+	
+	private Set<OWLClass> rootClasses;
+	private Set<OWLClass> derivedClasses;
+	
+	private boolean ontologyChanged = true;
+	
+	
 	int depth;
 	private Map<Integer, Set<OWLObjectAllRestriction>> depth2UniversalRestrictionPropertyMap;
     private Map<Integer, Set<OWLObjectPropertyExpression>> depth2ExistsRestrictionPropertyMap;
@@ -62,10 +73,11 @@
     private Map<OWLClass, Set<OWLClass>> child2Parents;
     private Map<OWLClass, Set<OWLClass>> parent2Children;
 	
-	public RootFinder(OWLOntologyManager manager, OWLReasoner reasoner, OWLReasonerFactory reasonerFactory){
-		this.manager = manager;
-		this.reasoner = reasoner;
-		this.reasonerFactory = reasonerFactory;
+	public RootFinder(){
+		
+		this.manager = OWLManager.createOWLOntologyManager();
+		this.reasoner = OREManager.getInstance().getPelletReasoner().getReasoner();
+		this.reasonerFactory = new PelletReasonerFactory();
 		try {
 			this.ontology = manager.createOntology(URI.create("all"), reasoner.getLoadedOntologies());
 		} catch (OWLOntologyCreationException e) {
@@ -74,19 +86,23 @@
 			e.printStackTrace();
 		}
 		rootClasses = new HashSet<OWLClass>();
+		derivedClasses = new HashSet<OWLClass>();
 		depend2Classes = new HashSet<OWLClass>();
 		depth2UniversalRestrictionPropertyMap = new HashMap<Integer, Set<OWLObjectAllRestriction>>();
 		depth2ExistsRestrictionPropertyMap = new HashMap<Integer, Set<OWLObjectPropertyExpression>>();
 		
 		child2Parents = new HashMap<OWLClass, Set<OWLClass>>();
 		parent2Children = new HashMap<OWLClass, Set<OWLClass>>();
+		
+		OREManager.getInstance().addListener(this);
+		OREManager.getInstance().getPelletReasoner().getOWLOntologyManager().addOntologyChangeListener(this);
 	}
 	
 	public Set<OWLClass> getRootClasses(){
-		rootClasses.clear();
-		computePossibleRoots();
-		pruneRoots();
-		rootClasses.remove(manager.getOWLDataFactory().getOWLNothing());
+		if(ontologyChanged){
+			computeRootDerivedClasses();
+			ontologyChanged = false;
+		}
 //        for(OWLClass child : child2Parents.keySet()){
 //        	for(OWLClass par : get(child, child2Parents)){
 //        		get(par, parent2Childs).add(child);
@@ -95,9 +111,27 @@
 		return Collections.unmodifiableSet(rootClasses);
 	}
 	
+	public Set<OWLClass> getDerivedClasses(){
+		if(ontologyChanged){
+			computeRootDerivedClasses();
+			ontologyChanged = false;
+		}
+		return Collections.unmodifiableSet(derivedClasses);
+	}
+	
+	public void computeRootDerivedClasses(){
+		rootClasses.clear();
+		derivedClasses.clear();
+		computePossibleRoots();
+		pruneRoots();
+		derivedClasses.removeAll(rootClasses);
+		
+		rootClasses.remove(manager.getOWLDataFactory().getOWLNothing());
+	}
+	
 	private void computePossibleRoots(){
-		try {
-			for(OWLClass cls : reasoner.getInconsistentClasses()){
+		try {derivedClasses.addAll(reasoner.getInconsistentClasses());
+			for(OWLClass cls : derivedClasses){
 				reset();
 				for(OWLDescription equi : cls.getEquivalentClasses(ontology)){
 					equi.accept(this);
@@ -327,20 +361,27 @@
 	public void visit(OWLDataMaxCardinalityRestriction arg0) {	
 	}
 
-	public static void main(String[] args){
-    	try {
-			String	file	= "file:examples/ore/tambis.owl";
-			OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
-			OWLOntology ontology = manager.loadOntologyFromPhysicalURI(URI.create(file));
-			OWLReasonerFactory factory = new PelletReasonerFactory();
-			OWLReasoner reasoner = factory.createReasoner(manager);
-			reasoner.loadOntologies(Collections.singleton(ontology));
-			RootFinder strReasoner = new RootFinder(manager, reasoner, factory);
-			System.out.println(strReasoner.getRootClasses());
+	@Override
+	public void activeOntologyChanged() {
+		this.manager = OWLManager.createOWLOntologyManager();
+		this.reasoner = OREManager.getInstance().getPelletReasoner().getReasoner();
+		this.reasonerFactory = new PelletReasonerFactory();
+		try {
+			this.ontology = manager.createOntology(URI.create("all"), reasoner.getLoadedOntologies());
 		} catch (OWLOntologyCreationException e) {
 			e.printStackTrace();
-		} catch (OWLReasonerException e) {
+		} catch (OWLOntologyChangeException e) {
 			e.printStackTrace();
 		}
-    }
+		
+		ontologyChanged = true;
+		
+	}
+
+	@Override
+	public void ontologiesChanged(List<? extends OWLOntologyChange> arg0)
+			throws OWLException {
+		ontologyChanged = true;
+		
+	}
 }

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/LaconicExplanationGenerator.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/LaconicExplanationGenerator.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/LaconicExplanationGenerator.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -10,10 +10,12 @@
 import org.dllearner.tools.ore.explanation.Explanation;
 import org.dllearner.tools.ore.explanation.ExplanationException;
 import org.dllearner.tools.ore.explanation.PelletExplanationGenerator;
+import org.mindswap.pellet.owlapi.PelletReasonerFactory;
 import org.semanticweb.owl.apibinding.OWLManager;
 import org.semanticweb.owl.inference.OWLReasonerFactory;
 import org.semanticweb.owl.model.OWLAxiom;
 import org.semanticweb.owl.model.OWLClass;
+import org.semanticweb.owl.model.OWLDataFactory;
 import org.semanticweb.owl.model.OWLDescription;
 import org.semanticweb.owl.model.OWLException;
 import org.semanticweb.owl.model.OWLLogicalAxiom;
@@ -47,7 +49,7 @@
 		} catch (OWLOntologyChangeException e) {
 			e.printStackTrace();
 		}
-		
+		oPlus = new OPlus(manager.getOWLDataFactory());
 		pelletExplanation = new PelletExplanationGenerator(manager, ontologies);
 		lastRegularExplanations = new HashSet<Explanation>();
 	}
@@ -59,7 +61,8 @@
      * @return splitted axioms
      */
     public Set<OWLAxiom> computeOPlus(Set<OWLAxiom> axioms) {
-    	oPlus = new OPlus(manager.getOWLDataFactory());
+//    	oPlus = new OPlus(manager.getOWLDataFactory());
+    
     	Set<OWLAxiom> oPlusAxioms = new HashSet<OWLAxiom>();
     	
     	for(OWLAxiom ax : axioms){
@@ -270,48 +273,137 @@
 		
 		return reconstituedExplanations;
 	}
-    	    
-    	
-    
-    public Set<Explanation> getExplanations(OWLAxiom entailment) throws ExplanationException {
-	Set<Explanation> explanations;
-	try {
-		explanations = computePreciseJusts(entailment, 2147483647);
-	} catch (OWLException e) {
-	    throw new ExplanationException(e);
+
+	public Set<Explanation> getExplanations(OWLAxiom entailment)
+			throws ExplanationException {
+		Set<Explanation> explanations;
+		try {
+			explanations = computePreciseJusts(entailment, 2147483647);
+		} catch (OWLException e) {
+			throw new ExplanationException(e);
+		}
+		return explanations;
 	}
-	return explanations;
-    }
-    
-    public Set<Explanation> getExplanations(OWLAxiom entailment, int limit)
-	throws ExplanationException {
-	Set<Explanation> explanations;
-	try {
-		explanations = computePreciseJusts(entailment, limit);
-	} catch (OWLException e) {
-	    throw new ExplanationException(e);
+
+	public Set<Explanation> getExplanations(OWLAxiom entailment, int limit)
+			throws ExplanationException {
+		Set<Explanation> explanations;
+		try {
+			explanations = computePreciseJusts(entailment, limit);
+		} catch (OWLException e) {
+			throw new ExplanationException(e);
+		}
+		return explanations;
 	}
-	return explanations;
-    }
     
     public Set<Explanation> getRegularExplanations(OWLAxiom entailment) throws ExplanationException {
     	Set<Explanation> regularJusts;
     	regularJusts = pelletExplanation.getExplanations((OWLAxiom)entailment);
     	lastRegularExplanations.addAll(regularJusts);
     	return regularJusts;
-        }
+    }
     
-    public void returnSourceAxioms(Set<Explanation> explanations){
-    	Map<OWLAxiom, Set<OWLAxiom>> sourceMap = oPlus.getAxiomsMap();
-    	System.out.println(sourceMap);
-    	for(Explanation explanation: explanations){
-    		for(OWLAxiom ax : explanation.getAxioms()){
-    			System.out.println(ax + " gehört zu " + sourceMap.get(ax));
-    			
+    public Set<OWLAxiom> getSourceAxioms(OWLAxiom axiom){
+    	Map<OWLAxiom, Set<OWLAxiom>> axioms2SourceMap = oPlus.getAxiomsMap();
+    	Set<OWLAxiom> sourceAxioms = new HashSet<OWLAxiom>();
+    	
+    	for(OWLAxiom ax : axioms2SourceMap.get(axiom)){
+    		if(ontology.containsAxiom(ax)){
+    			sourceAxioms.add(ax);
     		}
     	}
+    	
+    	return sourceAxioms;
     }
+    
+    public Set<OWLAxiom> getRemainingAxioms(OWLAxiom source, OWLAxiom part){
+    	Set<OWLAxiom> parts = computeOPlus(Collections.singleton(source));System.out.println("Parts: " + parts);
+    	parts.remove(part);System.out.println("removed part: " + part);
+    	for(OWLAxiom pa : parts){
+    		System.out.println("Part : " + pa + "has source : " + oPlus.getAxiomsMap().get(pa));
+    	}
+    	
+    	return rebuildAxioms(parts);
+    }
+    
+    private Set<OWLAxiom> rebuildAxioms(Set<OWLAxiom> axioms){
+		Map<OWLAxiom, Set<OWLAxiom>> sourceAxioms2OPlus = new HashMap<OWLAxiom, Set<OWLAxiom>>();
 
+		for (OWLAxiom ax : axioms) {
+			if (ontology.containsAxiom(ax)) {
+				sourceAxioms2OPlus.put(ax, computeOPlus(Collections
+						.singleton(ax)));
+			}
+		}
+
+    	Map<OWLClass, Map<OWLAxiom, Set<OWLSubClassAxiom>>> lhs2SubClassAxiom = new HashMap<OWLClass, Map<OWLAxiom, Set<OWLSubClassAxiom>>>();
+		Set<OWLAxiom> reconstituedAxioms = new HashSet<OWLAxiom>();
+		for (OWLAxiom laconicAx : axioms) {System.out.println("Laconic Axiom: "+ laconicAx);
+			if (laconicAx instanceof OWLSubClassAxiom) {
+				OWLSubClassAxiom subAx = (OWLSubClassAxiom) laconicAx;
+				if (subAx.getSubClass().isAnonymous()) {System.out.println(" has anomymous subclass ");System.out.println("has source axioms: " +oPlus.getAxiomsMap().get(subAx));
+					reconstituedAxioms.add(subAx);System.out.println("adding to rebuildet axioms");
+				} else {System.out.println("has no anonymous subclass");
+					Map<OWLAxiom, Set<OWLSubClassAxiom>> source2AxiomMap = lhs2SubClassAxiom.get(subAx.getSubClass().asOWLClass());
+					if (source2AxiomMap == null) {
+						source2AxiomMap = new HashMap<OWLAxiom, Set<OWLSubClassAxiom>>();
+						lhs2SubClassAxiom.put(subAx.getSubClass().asOWLClass(), source2AxiomMap);
+					}
+
+					for (OWLAxiom sourceAxiom : sourceAxioms2OPlus.keySet()) {System.out.println("source axiom: " + sourceAxiom);
+						if ((sourceAxioms2OPlus.get(sourceAxiom)).contains(subAx)) {
+							Set<OWLSubClassAxiom> subClassAxioms = source2AxiomMap.get(sourceAxiom);
+							if (subClassAxioms == null) {
+								subClassAxioms = new HashSet<OWLSubClassAxiom>();
+								source2AxiomMap.put(sourceAxiom, subClassAxioms);
+							}
+							subClassAxioms.add(subAx);System.out.println("-->subclass axioms: " + subClassAxioms);
+						}
+					}
+				}
+			} else {
+				reconstituedAxioms.add(laconicAx);
+			}
+		}
+		Set<OWLAxiom> consumedAxioms = new HashSet<OWLAxiom>();
+		for (OWLClass lhs : lhs2SubClassAxiom.keySet()) {
+			Map<OWLAxiom, Set<OWLSubClassAxiom>> source2SubClassAxiom = lhs2SubClassAxiom.get(lhs);
+			for (OWLAxiom source : source2SubClassAxiom.keySet()) {
+				Set<OWLDescription> rightHandSides = new HashSet<OWLDescription>();
+				for (OWLSubClassAxiom sub : source2SubClassAxiom.get(source)) {
+					if (!consumedAxioms.contains(sub)) {
+						rightHandSides.add(sub.getSuperClass());
+						consumedAxioms.add(sub);
+					}
+				}
+
+				if (rightHandSides.size() == 1)
+					reconstituedAxioms.add(manager.getOWLDataFactory().getOWLSubClassAxiom((OWLDescription) lhs,((OWLDescription) rightHandSides.iterator().next())));
+				else if (rightHandSides.size() > 1) {
+					org.semanticweb.owl.model.OWLObjectIntersectionOf conjunction = manager.getOWLDataFactory().getOWLObjectIntersectionOf(rightHandSides);
+					reconstituedAxioms.add(manager.getOWLDataFactory().getOWLSubClassAxiom((OWLDescription) lhs,conjunction));
+				}
+			}
+		}
+		return reconstituedAxioms;
+    }
+    
+    public static void main(String[] args) throws OWLOntologyCreationException, ExplanationException{
+    	String baseURI = "http://protege.stanford.edu/plugins/owl/owl-library/koala.owl";
+    	OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
+    	OWLOntology ontology = manager.loadOntologyFromPhysicalURI(URI.create("file:examples/ore/koala.owl"));
+    	OWLDataFactory factory = manager.getOWLDataFactory();
+    	LaconicExplanationGenerator expGen = new LaconicExplanationGenerator(manager, new PelletReasonerFactory(), Collections.singleton(ontology));
+    	OWLClass koalaWithPhD = factory.getOWLClass(URI.create(baseURI + "#KoalaWithPhD"));
+    	OWLClass koala = factory.getOWLClass(URI.create(baseURI + "#Koala"));
+    	
+    	System.out.println(expGen.getExplanations(factory.getOWLSubClassAxiom(koalaWithPhD, factory.getOWLNothing()), 1));
+    	OWLAxiom laconicAx = factory.getOWLSubClassAxiom(koalaWithPhD, koala);
+    	Set<OWLAxiom> sourceAxioms = expGen.getSourceAxioms(laconicAx);
+    	System.out.println("Source axioms: " + sourceAxioms);
+    	for(OWLAxiom sourceAx : sourceAxioms){
+    		System.out.println("Rebuildet: " + expGen.getRemainingAxioms(sourceAx, laconicAx));
+    	}
+    }
 	
-		
 }

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/OPlus.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/OPlus.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/explanation/laconic/OPlus.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -102,17 +102,23 @@
     {
         for(OWLAxiom axiom : axioms){
         	
-        	                    
-            if(!axiom.equals(source))
+        	Set<OWLAxiom> existing = (Set<OWLAxiom>)axiomsMap.get(axiom);
+            if(existing == null)
             {
-                Set<OWLAxiom> existing = (Set<OWLAxiom>)axiomsMap.get(axiom);
-                if(existing == null)
-                {
-                    existing = new HashSet<OWLAxiom>();
-                    axiomsMap.put(axiom, existing);
-                }
-                existing.add(source);
+                existing = new HashSet<OWLAxiom>();
+                axiomsMap.put(axiom, existing);
             }
+            existing.add(source);     
+//            if(!axiom.equals(source))
+//            {
+//                Set<OWLAxiom> existing = (Set<OWLAxiom>)axiomsMap.get(axiom);
+//                if(existing == null)
+//                {
+//                    existing = new HashSet<OWLAxiom>();
+//                    axiomsMap.put(axiom, existing);
+//                }
+//                existing.add(source);
+//            }
         } 
         return axioms;
     }

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTable.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTable.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTable.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -1,6 +1,7 @@
 package org.dllearner.tools.ore.ui;
 
 import java.awt.Color;
+import java.awt.event.MouseEvent;
 import java.util.Set;
 
 import javax.swing.ListSelectionModel;
@@ -28,6 +29,20 @@
 		setGridColor(Color.LIGHT_GRAY);
 	}
 	
+	@Override
+	public String getToolTipText(MouseEvent e){
+		String tip = null;
+        java.awt.Point p = e.getPoint();
+        int rowIndex = rowAtPoint(p);
+        if(rowIndex != -1){
+        	tip = getValueAt(rowIndex, 0).toString();
+        	
+        } else {
+        	tip = super.getToolTipText(e);
+        }
+        return tip;
+	}
+	
 	public void clear(){
 		((ClassesTableModel)getModel()).clear();
 	}

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTableModel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTableModel.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/ClassesTableModel.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -33,11 +33,7 @@
 
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
-		if(rowIndex >= 0){
 			return classes.get(rowIndex);
-		} else {
-			return "";
-		}
 	}
 	
 	public void clear(){

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTable.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -53,7 +53,9 @@
 		column4.setCellEditor(new ButtonCellEditor());
 		column4.setResizable(false);
 		setRowHeight(getRowHeight() + 4);
-		setColumnSizes();
+		getColumn(1).setMaxWidth(30);
+		getColumn(2).setMaxWidth(30);
+		getColumn(3).setMaxWidth(80);
 		getSelectionModel().addListSelectionListener(
 				new ListSelectionListener() {
 
@@ -109,13 +111,6 @@
 		});
 	}
 	
-		
-	private void setColumnSizes(){
-		getColumn(1).setMaxWidth(30);
-		getColumn(2).setMaxWidth(30);
-		getColumn(3).setMaxWidth(80);
-	}
-	
 	private void changeSelection() {
 
 	}

Modified: trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java	2009-08-25 15:57:36 UTC (rev 1831)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/ExplanationTableModel.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -68,7 +68,15 @@
 				impMan.removeAxiomFromImpactList(ax);
 			} else {
 				impMan.addAxiom2ImpactList(ax);
-				repMan.addAxiom2Remove(ax);
+				if(expMan.isLaconicMode()){
+					for(OWLAxiom source : expMan.getSourceAxioms(ax)){
+						repMan.addAxiom2Remove(source);
+						repMan.addAxioms2Keep(expMan.getRemainingAxioms(source, ax));
+					}		
+				} else {
+					repMan.addAxiom2Remove(ax);
+				}
+				
 			}
 		}
 		super.setValueAt(value, rowIndex, columnIndex);

Added: trunk/src/dl-learner/org/dllearner/tools/ore/ui/GraphicalCoveragePanel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/GraphicalCoveragePanel.java	                        (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/GraphicalCoveragePanel.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -0,0 +1,766 @@
+/**
+ * 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.ore.ui;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+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.learningproblems.EvaluatedDescriptionClass;
+import org.dllearner.tools.ore.OREManager;
+import org.dllearner.tools.protege.IndividualPoint;
+
+
+/**
+ * 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 SUBSTRING_SIZE = 25;
+	private static final int SPACE_SIZE = 7;
+	private static final int MAX_RANDOM_NUMBER = 300;
+
+	
+	private int shiftXAxis;
+	private int distortionOld;
+	private Ellipse2D oldConcept;
+	private Ellipse2D newConcept;
+
+	private EvaluatedDescription eval;
+
+	private String conceptNew;
+	private final Vector<IndividualPoint> posCovIndVector;
+	private final Vector<IndividualPoint> posNotCovIndVector;
+	private final Vector<IndividualPoint> additionalIndividuals;
+	private final Vector<IndividualPoint> points;
+	private final Vector<String> conceptVector;
+
+	private int adjustment;
+	private int shiftOldConcept;
+	private int shiftNewConcept;
+	private int shiftNewConceptX;
+	private int shiftCovered;
+	private int coveredIndividualSize;
+	private int additionalIndividualSize;
+	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;
+
+
+	/**
+	 * 
+	 * This is the constructor for the GraphicalCoveragePanel.
+	 * 
+	 * @param desc
+	 *            EvaluatedDescription
+	 * @param m
+	 *            DLLearnerModel
+	 * @param concept
+	 *            String
+	 * @param p
+	 *            MoreDetailForSuggestedConceptsPanel
+	 */
+	public GraphicalCoveragePanel( String concept) {
+		
+
+		this.setPreferredSize(new Dimension(540, 260));
+		
+		this.repaint();
+		darkGreen = new Color(0, 100, 0);
+		darkRed = new Color(205, 0, 0);
+		random = new Random();
+		conceptNew = concept;
+		conceptVector = new Vector<String>();
+		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) {
+			
+			Graphics2D g2D;
+			g2D = (Graphics2D) g;
+			Composite original = g2D.getComposite();
+			AlphaComposite ac = AlphaComposite.getInstance(
+					AlphaComposite.SRC_OVER, 0.5f);
+			g2D.setColor(Color.BLACK);
+			g2D.drawString(OREManager.getInstance().getCurrentClass2Learn()
+					.toString(), 320, 10);
+			g2D.setColor(Color.ORANGE);
+			g2D.fillOval(310, 20, 9, 9);
+			g2D.setColor(Color.black);
+			int p = 30;
+
+			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(455, p - 9, 9, 9);
+			g2D.setColor(Color.BLACK);
+			g2D.drawString("and", 485, p);
+			g2D.setColor(Color.YELLOW);
+			g2D.fillOval(525, 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(455, 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(455, p - 9, 9, 9);
+			g2D.setColor(Color.BLACK);
+			p = p + 20;
+			g2D.drawString("(potential problem)", 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();
+	}
+
+	private void computeGraphics() {
+		if (eval != null) {
+			this.setVisible(true);
+			getParent().repaint();
+			additionalIndividualSize = ((EvaluatedDescriptionClass) eval)
+					.getAdditionalInstances().size();
+			distortionOld = 0;
+			adjustment = 0;
+			Ellipse2D old = new Ellipse2D.Double(ELLIPSE_X_AXIS, ELLIPSE_Y_AXIS,
+					WIDTH, HEIGHT);
+			x1 = (int) old.getCenterX() - PLUS_SIZE;
+			x2 = (int) old.getCenterX() + PLUS_SIZE;
+			y1 = (int) old.getCenterY() - PLUS_SIZE;
+			y2 = (int) old.getCenterY() + PLUS_SIZE;
+			centerX = (int) old.getCenterX();
+			centerY = (int) old.getCenterY();
+			double coverage = ((EvaluatedDescriptionClass) eval).getCoverage();
+			shiftXAxis = (int) Math.round((WIDTH) * (1 - coverage));
+			
+			if (additionalIndividualSize != 0 && ((EvaluatedDescriptionClass) eval).getCoverage() == 1.0 && ((EvaluatedDescriptionClass) eval).getAddition() < 1.0) {
+				distortionOld = (int) Math.round((WIDTH) * 0.3);
+				Ellipse2D newer = new Ellipse2D.Double(ELLIPSE_X_AXIS + shiftXAxis,
+						ELLIPSE_Y_AXIS, (WIDTH), HEIGHT);
+				adjustment = (int) Math.round(newer.getCenterY() / 4);
+			}
+			this.renderPlus();
+		}
+	}
+
+	private void renderPlus() {
+		if (eval != null) {
+			coveredIndividualSize = ((EvaluatedDescriptionClass) eval)
+					.getCoveredInstances().size();
+			double newConcepts = ((EvaluatedDescriptionClass) eval)
+					.getAddition();
+			double oldConcepts = ((EvaluatedDescriptionClass) eval)
+					.getCoverage();
+			shiftNewConcept = 0;
+			shiftOldConcept = 0;
+			shiftNewConceptX = 0;
+			shiftCovered = 0;
+			if (coveredIndividualSize == 0) {
+				shiftNewConcept = (int) Math.round(((WIDTH) / 2.0) * newConcepts);
+			} else if (additionalIndividualSize != coveredIndividualSize) {
+				shiftNewConcept = (int) Math.round(((WIDTH) / 2.0)
+						* (1.0 + (1.0 - oldConcepts)));
+				shiftOldConcept = (int) Math.round(((WIDTH) / 2.0) * oldConcepts);
+				shiftCovered = (int) Math.round(((WIDTH) / 2.0)
+						* (1 - oldConcepts));
+			}
+			if (((EvaluatedDescriptionClass) eval).getAddition() != 1.0 && ((EvaluatedDescriptionClass) eval)
+					.getCoverage() == 1.0) {
+				shiftCovered = (int) Math.round(((WIDTH) / 2.0) * 0.625);
+				shiftNewConceptX = shiftCovered;
+				shiftNewConcept = 2 * shiftNewConceptX;
+			}
+		}
+
+		int i = conceptNew.length();
+		while (i > 0) {
+			int sub = 0;
+			String subString = "";
+			if(conceptNew.contains(" ")) {
+			sub = conceptNew.indexOf(" ");
+			subString = conceptNew.substring(0, sub) + " ";
+			conceptNew = conceptNew.replace(conceptNew.substring(0, sub + 1),
+					"");
+			} else {
+				subString = conceptNew;
+				conceptNew = "";
+			}
+			while (sub < SUBSTRING_SIZE) {
+				if (conceptNew.length() > 0 && conceptNew.contains(" ")) {
+					sub = conceptNew.indexOf(" ");
+					if (subString.length() + sub < SUBSTRING_SIZE) {
+						subString = subString + conceptNew.substring(0, sub)
+								+ " ";
+						conceptNew = conceptNew.replace(conceptNew.substring(0,
+								sub + 1), "");
+						sub = subString.length();
+					} else {
+						break;
+					}
+				} else {
+					if (subString.length() + conceptNew.length() > SUBSTRING_SIZE
+							+ SPACE_SIZE) {
+						conceptVector.add(subString);
+						subString = conceptNew;
+						conceptNew = "";
+						break;
+					} else {
+						subString = subString + conceptNew;
+						conceptNew = "";
+						break;
+					}
+				}
+			}
+			conceptVector.add(subString);
+			i = conceptNew.length();
+		}
+	}
+	
+	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();
+		
+		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 = OREManager.getInstance().getPositiveFailureExamples();
+			
+			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/ore/ui/IndividualsTable.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/IndividualsTable.java	                        (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/IndividualsTable.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -0,0 +1,56 @@
+package org.dllearner.tools.ore.ui;
+
+import java.awt.Color;
+import java.awt.event.MouseEvent;
+import java.util.Set;
+
+import javax.swing.ListSelectionModel;
+
+import org.dllearner.core.owl.Individual;
+import org.jdesktop.swingx.JXTable;
+import org.jdesktop.swingx.decorator.HighlighterFactory;
+
+public class IndividualsTable extends JXTable {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 6874941283913237464L;
+
+	public IndividualsTable(){
+		super(new IndividualsTableModel());
+		setBackground(Color.WHITE);
+		setHighlighters(HighlighterFactory.createAlternateStriping());
+		setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		setEditable(false);
+		setTableHeader(null);
+		setGridColor(Color.LIGHT_GRAY);
+		getColumn(0).setCellRenderer(new ManchesterSyntaxTableCellRenderer());
+	}
+	
+	@Override
+	public String getToolTipText(MouseEvent e){
+		String tip = null;
+        java.awt.Point p = e.getPoint();
+        int rowIndex = rowAtPoint(p);
+        if(rowIndex != -1){
+        	tip = getValueAt(rowIndex, 0).toString();
+        	
+        } else {
+        	tip = super.getToolTipText(e);
+        }
+        return tip;
+	}
+	
+	public void addIndividuals(Set<Individual> individuals){
+		((IndividualsTableModel)getModel()).addIndividuals(individuals);
+	}
+	
+	public void removeIndividual(Individual ind){
+		((IndividualsTableModel)getModel()).removeIndividual(ind);
+	}
+	
+	public Individual getSelectedIndividual(){
+		return ((IndividualsTableModel)getModel()).getSelectedIndividual(getSelectedRow());
+	}
+}

Added: trunk/src/dl-learner/org/dllearner/tools/ore/ui/IndividualsTableModel.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/tools/ore/ui/IndividualsTableModel.java	                        (rev 0)
+++ trunk/src/dl-learner/org/dllearner/tools/ore/ui/IndividualsTableModel.java	2009-08-29 14:08:33 UTC (rev 1832)
@@ -0...
 
[truncated message content]