ontologyanalyzer.java

来自「Semantic Web Ontology Editor」· Java 代码 · 共 904 行 · 第 1/3 页

				StringWriter st = new StringWriter();
				CorrectedRDFRenderer rdfRenderer = new CorrectedRDFRenderer();
				
				// source code in RDF
				String code = "";
				try
				{
					rdfRenderer.renderOntology(ont, st);
					code = st.toString();
				}
				catch ( RendererException ex )
				{
					ex.printStackTrace();
					throw new AnalysisException("Failed in trying to analyze (Fixing RDFS vocaublary) <OWLException>: " + ex.toString() + "\n" + Utils.getExceptionTrace( ex ) );
				}
				
				StringReader reader = new StringReader( code );
	    		OWLOntology ontology = model.getSelectedOntology();
	    		
	    		// add updated ontology 
				OWLOntology updatedOntology = null;
				updatedOntology = model.loadOntologyInRDF(reader, ontology.getURI());
	    		// restore old ontology, if exception loading new one
	    		if (updatedOntology==null) 
	    		{
					throw new AnalysisException("Failed in trying to analyze (Updating RDFS vocaublary) <OWLException>" );
	    		}
	    		else {
	    			// remove current ontology and clear its cache
	    			
					SwoopFrame frame = model.getFrame();
					model.clearCaches( ontology );             // force clearing!
					model.removeOntStats( ontology );          // force clearing!
					model.removeOntology( ontology.getURI() ); // force removing!
	        		frame.termDisplay.removeFromCache(ontology);
					frame.clearWorkspace( false );        // just in case
					
	        		model.addOntology(updatedOntology);
	        		model.setSelectedOntology(updatedOntology);
	    		}
				
				/*
				BufferedWriter writer = new BufferedWriter( new FileWriter( "tempOntology.owl"));
				writer.write( code );
				writer.flush();
				writer.close();
				SwoopFrame frame = model.getFrame();
				
				model.clearCaches( ont );             // force clearing!
				model.removeOntStats( ont );          // force clearing!
				model.removeOntology( ont.getURI() ); // force removing!
				frame.clearWorkspace( false );        // just in case
				File file = new File("tempOntology.owl");
				
				ont = model.loadOntology( file.toURI() );
				model.setSelectedOntology( ont );
				model.setReasonerWithThreadBlock( new SwoopToldReasoner() );
				model.setShowImportsWithThreadBlock( true );
				*/
	  			}
		}
		catch ( OWLException e )
		{
			e.printStackTrace();
			throw new AnalysisException("Failed in trying to analyze (Setting ontology and imports) <OWLException>: " + e.toString() + "\n" + Utils.getExceptionTrace( e ) );
		}
 		catch ( Exception e )
		{
			e.printStackTrace();
			throw new AnalysisException("Failed in trying to analyze (Loading Ontology) <Exception>: " + e.toString() + "\n" + Utils.getExceptionTrace( e ) );
		}
		
 		try
		{
 			Thread.sleep( 5000 );
		}
 		catch ( Exception e )
		{ e.printStackTrace(); }
 		
		SwoopReasoner reasoner = model.getReasoner();

		// construct class tree
		display.termTabPane.setSelectedIndex( 0 );
		display.updateTreeDisplay();
		// construct prop tree
		display.termTabPane.setSelectedIndex( 1 );
		display.updateTreeDisplay();
		
		Hashtable stats = this.getBasicStats( model, ont );
		if ( IS_DEBUG )
			System.out.println("Doing Individual Stats");
		getIndividualStats( reasoner, ont, stats);

		if ( IS_DEBUG )
			System.out.println("Doing Advanced Stats");
		
		HashMap advStats = model.getOntStats( ont );
		String expressivity = getExpressivity();
		advStats.put( EXPRESSIVITY, expressivity);
		HashMap advReasonedStats = null;
		
		// check to see if it's consistent
		saveConsistency( advStats, model );
		// check graph structure
		doGraphAnalysis( advStats, model, ont);
		
		if ( IS_DEBUG )
		{
			StatsPrinter.printBasicStats( stats );
			StatsPrinter.printAdvancedStats( advStats );
			System.out.println("----");
		}

		// now we clear the stats cache so the reasoned stats won't mess with the told stats
		model.removeOntStatsWithoutNotification( ont );
		
		if ( !INFERRED_STATS )
		{
			System.err.println(" *** Inferred Stats have been disabled [check OntologyAnalyzer.INFERRED_STATS] ***");
			return new OntologyAnalysis(  stats, advStats, null );
		}
		
		try
		{
			model.setReasonerWithThreadBlock( new PelletReasoner() );
		}
		catch ( Exception e )
		{
			e.printStackTrace();
			throw new AnalysisException("Failed in trying to analyze( creating Pellet Reasoner) <Exception>: " + e.toString() + "\n" + Utils.getExceptionTrace( e ) );
		}
		// construct class tree
		display.termTabPane.setSelectedIndex( 0 );
		display.updateTreeDisplay();
		// construct prop tree
		display.termTabPane.setSelectedIndex( 1 );
		display.updateTreeDisplay();
		advReasonedStats = model.getOntStats( ont );
		
		expressivity = getExpressivity();
		advReasonedStats.put( EXPRESSIVITY, expressivity);
		
		// check to see if it's consistent
		saveConsistency( advReasonedStats, model );
		// check graph structure
		doGraphAnalysis( advReasonedStats, model, ont);
		
		if ( IS_DEBUG )
			StatsPrinter.printAdvancedStats( advReasonedStats );
		
		return new OntologyAnalysis(  stats, advStats, advReasonedStats);
	}

	/* Computes statistics for individuals of an ontology
	 *  - # type assertions
	 *  - # data prop assertions
	 *  - # obj prop assertions 
	 */
	public static Hashtable getIndividualStats( SwoopReasoner reasoner, OWLOntology ont, Hashtable stats ) throws AnalysisException
	{
		try
		{
			int numTypeAssertions = 0;
			int numDataPropAssertions = 0;
			int numObjPropAssertions  = 0;
			
			if ( reasoner.getOntology() == null )
			{
				System.out.println(" -.getIndividualStats: Ontology = null");
				System.exit(1);
			}
			if ( reasoner.getOntology().getOWLDataFactory() == null)
			{
				System.out.println(" -.getIndividualStats: DATAFACTORY= null");
				System.exit(1);
			}
			OWLClass owlThing = reasoner.getOntology().getOWLDataFactory().getOWLThing();
			Set inds = ont.getIndividuals();
			for ( Iterator it = inds.iterator(); it.hasNext(); )
			{
				OWLIndividual ind = (OWLIndividual)it.next();
				
				Set types = ind.getTypes( ont );
				types.remove( owlThing );
				numTypeAssertions = numTypeAssertions + types.size();
				
				Map objVals = ind.getObjectPropertyValues( ont );
				Set Objkeys = objVals.keySet();
				for (Iterator iter = Objkeys.iterator(); iter.hasNext(); )
				{
					HashSet obj = (HashSet)objVals.get( iter.next() ) ;
					numObjPropAssertions = numObjPropAssertions + obj.size(); 
				}
	
				Map dataVals = ind.getDataPropertyValues( ont );
				Set DataKeys = dataVals.keySet();
				for (Iterator iter = DataKeys.iterator(); iter.hasNext(); )
				{
					HashSet obj = (HashSet)dataVals.get( iter.next() ) ;
					numDataPropAssertions = numDataPropAssertions + obj.size();
				}
			}
			stats.put( NUM_TYPE_ASSERTIONS, numTypeAssertions + "");
			stats.put( NUM_DPROP_ASSERTIONS, numDataPropAssertions + "");
			stats.put( NUM_OPROP_ASSERTIONS, numObjPropAssertions + "");			
			return stats;
		}
		catch ( Exception e )
		{
			e.printStackTrace();
			throw new AnalysisException("Failed in Individual Stats Checking: " + e.toString() + "\n" + Utils.getExceptionTrace( e ) );
		}
	}
	
	/* see if ontology is consistent.  
	 */
	private static HashMap saveConsistency( HashMap advStats, SwoopModel model ) throws AnalysisException
	{
		try
		{
			SwoopReasoner reasoner = model.getReasoner();
			if ( reasoner.isConsistent() )
				advStats.put( OntologyAnalyzer.CONSISTENCY, "true");
			else
				advStats.put( OntologyAnalyzer.CONSISTENCY, "false");			
			return advStats;
		}
		catch ( Exception e )
		{
			e.printStackTrace();
			throw new AnalysisException("Failed in extracting Consistency Stats: " + e.toString() + "\n" + Utils.getExceptionTrace( e ) );			
		}
	}
	
	/* Decides what kind of graph morphology this onotlogy is.
	 *   can be one of { list, tree, multitree, DAG}
	 */
	private static HashMap doGraphAnalysis( HashMap advStats, SwoopModel model, OWLOntology ont ) throws AnalysisException
	{
		try
		{
			if (IS_DEBUG)
				System.out.println("Doing Graph Analysis");

			// get reasoner
			SwoopReasoner reasoner = model.getReasoner();
			//System.out.println("<<<<<< Reasoner type: " + reasoner.getClass().getName() );
			
			// get multiple inheritance stats
			Set multC = (HashSet) advStats.get(SwoopStatistics.MULTIPLE_INHERITANCE_CLASS);
			
			// if is inconsistent, there is no real semantic structure :/
			String consistency = (String)advStats.get( CONSISTENCY );
			if ( consistency.equals("false") )
			{
				advStats.put( GRAPH_MORPHOLOGY, INCONSISTENT );
				return advStats;
			}
			
			// if it has NO class structure, then return NONE
			OWLClass owlThing   = reasoner.getOntology().getOWLDataFactory().getOWLThing();
			OWLClass owlNothing = reasoner.getOntology().getOWLDataFactory().getOWLNothing();
			
			Set topLevels = reasoner.subClassesOf( owlThing );
			
			// if owl:Thing has no children (toldreasoner will say this) or owl:Thing has owl:Nothing as only child (pellet says this)
			if ( topLevels.size() == 0 )
			{
				//System.out.println(" *** Told says NONE");
				advStats.put( GRAPH_MORPHOLOGY, NONE);
				return advStats;					
			}
			if ( topLevels.size() == 1 )
			{
				HashSet hs = (HashSet)topLevels.iterator().next();
				OWLClass cls = (OWLClass)hs.iterator().next();
				if ( cls.getURI().toString().equals( owlNothing.getURI().toString()) )
				{
					//System.out.println(" *** Reasoned says None");
					advStats.put( GRAPH_MORPHOLOGY, NONE);
					return advStats;				
				}
			}
			
			boolean hasMultipleTop = ( (reasoner.subClassesOf( owlThing )).size() > 1);
			// Either a list or a tree
			if ( (multC == null) || (multC.size() == 0))
			{
				Set classes = ont.getClasses();
				for ( Iterator it = classes.iterator(); it.hasNext(); )
				{
					OWLClass cls = (OWLClass)it.next();
					//System.out.println( "++++" + cls.getURI().toString() );
					Set children = reasoner.subClassesOf( cls );
					if ( children == null )
						continue;
					else if ( children.size() > 1 )
					{
						if ( hasMultipleTop )
							advStats.put( GRAPH_MORPHOLOGY, TREES);	
						else
							advStats.put( GRAPH_MORPHOLOGY, TREE);