axiomextractor.java

Semantic Web Ontology Editor

package org.mindswap.swoop.explore;

import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;

import org.mindswap.swoop.SwoopModel;
import org.mindswap.swoop.reasoner.PelletReasoner;
import org.mindswap.swoop.reasoner.SwoopReasoner;
import org.mindswap.swoop.reasoner.SwoopToldReasoner;
import org.mindswap.swoop.renderer.entity.ConciseFormatEntityRenderer;
import org.mindswap.swoop.utils.graph.hierarchy.OntologyGraphNode;
import org.mindswap.swoop.utils.graph.hierarchy.OntologyWithClassHierarchyGraph;
import org.mindswap.swoop.utils.graph.hierarchy.SwoopOntologyVertex;
import org.mindswap.swoop.utils.graph.hierarchy.popup.ClassAxiomContainer;
import org.mindswap.swoop.utils.graph.hierarchy.popup.ConcisePlainVisitor;
import org.mindswap.swoop.utils.graph.hierarchy.popup.SubclassAxiomContainerComparator;
import org.mindswap.swoop.utils.owlapi.AxiomCollector;
import org.mindswap.swoop.utils.owlapi.OWLDescriptionFinder;
import org.semanticweb.owl.impl.model.OWLDataFactoryImpl;
import org.semanticweb.owl.impl.model.OWLDisjointClassesAxiomImpl;
import org.semanticweb.owl.impl.model.OWLEquivalentClassesAxiomImpl;
import org.semanticweb.owl.impl.model.OWLSubClassAxiomImpl;
import org.semanticweb.owl.model.OWLClass;
import org.semanticweb.owl.model.OWLClassAxiom;
import org.semanticweb.owl.model.OWLDescription;
import org.semanticweb.owl.model.OWLDisjointClassesAxiom;
import org.semanticweb.owl.model.OWLEquivalentClassesAxiom;
import org.semanticweb.owl.model.OWLException;
import org.semanticweb.owl.model.OWLNot;
import org.semanticweb.owl.model.OWLOntology;
import org.semanticweb.owl.model.OWLSubClassAxiom;

import aterm.pure.ATermApplImpl;

public class AxiomExtractor 
{
	private Set myOntologies = null;
	private OWLOntology myOntology = null;
	private SwoopModel myModel = null;
	private SwoopReasoner myReasoner = null;
	private ConciseFormatEntityRenderer myShortform = null;
	
	private OWLClass owlThing = null;
	private OWLClass owlNothing = null;
	
	public AxiomExtractor( OWLOntology ont, SwoopModel model, SwoopReasoner reasoner )
	{
		init( ont, model, reasoner );
	}
	
	private void init( OWLOntology ont, SwoopModel model, SwoopReasoner reasoner )
	{
		try
		{
			myModel     = model;
			myShortform = new ConciseFormatEntityRenderer();
			myShortform.setSwoopModel( myModel );	
			myOntologies = new HashSet();
			myOntologies.add( ont );
			myReasoner = reasoner;
			
			owlThing   = myReasoner.getOntology().getOWLDataFactory().getOWLThing();
			owlNothing = myReasoner.getOntology().getOWLDataFactory().getOWLNothing();
		}
		catch ( OWLException e )
		{
			e.printStackTrace();
		}
	}

	public Vector extractSubclassAxioms( boolean withReasoner )
	{
		// use  a sorted set
		Set subclassAxioms = new TreeSet( SubclassAxiomContainerComparator.getInstance() );
		try
		{
			for (Iterator it = myOntologies.iterator(); it.hasNext(); )
			{
				OWLOntology ont = (OWLOntology)it.next();
				myModel.setSelectedOntology( ont );
				try
				{
					if ( withReasoner ) // load pellet for each ontology
					{	
						System.err.println("AxiomExtractor: setting Pellet reasoner");
						PelletReasoner reasoner = new PelletReasoner();
						// use pellet.  Place it in model's reasonerCache.
						myModel.setReasonerWithThreadBlock( reasoner );						
						myReasoner = myModel.getReasonerCache().getReasoner(ont, reasoner.getName() );
					}
					else // use told reasoner
					{
						System.err.println("AxiomExtractor: setting told reasoner");
						SwoopToldReasoner reasoner = new SwoopToldReasoner();
						myModel.setReasoner( reasoner );
						myReasoner = myModel.getReasonerCache().getReasoner(ont, reasoner.getName() );
					}
				}
				catch ( Exception e )
				{
					System.err.println("** Cannot set reasoner **");
					e.printStackTrace();
				}
				
				OWLClass owlThing = ont.getOWLDataFactory().getOWLThing();
				OWLDataFactoryImpl factory = (OWLDataFactoryImpl)ont.getOWLDataFactory();
				Set classSet = ont.getClasses();
				
				for (Iterator iter = classSet.iterator(); iter.hasNext(); ) 
				{
					OWLClass clazz = (OWLClass)iter.next();
					Set supers = OWLDescriptionFinder.getSuperClasses(clazz, Collections.singleton(ont));
					//if(myReasoner.isConsistent(clazz)) 
					//{
						// remove all the named classes because reasoner will eventually add them
						Iterator iterator = supers.iterator();
						while(iterator.hasNext())
							if(iterator.next() instanceof OWLClass)
								iterator.remove();		
						// add all the named superclasses (including inferred)
						supers.addAll(myReasoner.superClassesOf(clazz));
						// remove owl:Thing from the superclass set
						iterator = supers.iterator();
						while(iterator.hasNext()) 
						{
							Object o = iterator.next();
							if(o instanceof Set && ((Set)o).contains(owlThing))
								iterator.remove();
							else
							{
								OWLDescription desc = null;
								if ( o instanceof Set)
								{
									 desc = (OWLDescription)((Set)o).iterator().next();
								}
								else
									desc = (OWLDescription)o;
								subclassAxioms.add( new ClassAxiomContainer( 
										              new OWLSubClassAxiomImpl( factory, (OWLDescription)clazz, desc),
													  myShortform, myModel ));
							}
						}
					//}
				}		
			}
			// return the sorted Vector
			return new Vector( subclassAxioms );
		}
		catch (OWLException ex)
		{
			ex.printStackTrace();
		}
		return null;
	}

	/*
	 * extracts class axioms in the import closure of the currently selected ontology in Swoop
	 * 
	 */
	public Vector extractClassAxioms( )
	{
		// maps a class/class expression (key) to its set of equivalent classes/class expressions (values)
		// each equivvalent set contains the key as well.
		Hashtable equivalenceMap = new Hashtable();

		// use a sorted set
		Set classAxiomContainers = new TreeSet( SubclassAxiomContainerComparator.getInstance() );
		
		try
		{
			Set importClosure = myReasoner.getOntologies();
			/* 	for each ontology in the import closure
			 *	find all told class axioms
			 */	
			for ( Iterator ontIter = importClosure.iterator(); ontIter.hasNext(); )
			{ 
				OWLOntology ont = (OWLOntology)ontIter.next();
				Set axioms = AxiomCollector.axiomize( ont );
				for ( Iterator it = axioms.iterator(); it.hasNext(); )
				{
					Object obj = it.next();
					if ( (obj instanceof OWLClassAxiom))
					{
						if ( obj instanceof OWLEquivalentClassesAxiom)
						{
							OWLEquivalentClassesAxiom qui = (OWLEquivalentClassesAxiom)obj;
							Set equivalentClasses = qui.getEquivalentClasses();
							if ( equivalentClasses.size() == 1 )
								continue;
							else
							{ addToEquivalents( equivalenceMap, (HashSet)equivalentClasses ); }
						}
						else //subclass or disjoint axioms
							classAxiomContainers.add( new ClassAxiomContainer( (OWLClassAxiom)obj, myShortform, myModel ) );
					}
				}
			}
			
			
			/*
			 * now get the inferred axioms
			 * 
			 */
			for ( Iterator ontIter = importClosure.iterator(); ontIter.hasNext(); )
			{
				OWLOntology ont = (OWLOntology)ontIter.next();
				OWLDataFactoryImpl factory = (OWLDataFactoryImpl)ont.getOWLDataFactory();
				
				for ( Iterator classIter = ont.getClasses().iterator(); classIter.hasNext(); )
				{
					OWLClass c = (OWLClass)classIter.next();					
					// superclasses
					Set supers = c.getSuperClasses( importClosure );
					if( myReasoner.isConsistent(c) )
					{
						supers.addAll( myReasoner.superClassesOf(c));						
						// remove owl:Thing from the superclass set
						for (Iterator i = supers.iterator(); i.hasNext(); ) 
						{
							Object o = i.next();
							if(o instanceof Set && ((Set)o).contains(owlThing))
								i.remove();
							else
							{
								OWLDescription desc = null;
								if ( o instanceof Set)								
									desc = (OWLDescription)((Set)o).iterator().next();								
								else
									desc = (OWLDescription)o;
								classAxiomContainers.add( new ClassAxiomContainer( 
										              new OWLSubClassAxiomImpl( factory, (OWLDescription)c, desc),
													  myShortform, myModel ));
							}