OntView: Ontology Visualization Tool

• OntView is an ontology visualization tool that provides semantically faithful, scalable graphical representations of OWL 2 ontologies by leveraging DL reasoner inferences.
• It integrates a Java-based architecture with DL reasoners and dynamic, on-demand GCI visualization, summarization, and percentage-stepped expansion methods for effective ontology management.
• The open-source tool demonstrates high performance, managing large ontologies with sub-0.5 s interactivity and memory usage below 500 MB, making it ideal for detailed ontology analysis.

OntView is an ontology visualization tool designed to provide semantically faithful, scalable, and adaptive graphical representations of OWL 2 ontologies. Operating under the principle of "What You See Is What You Meant," OntView directly leverages description logic (DL) reasoner inferences to ensure that every displayed node, edge, and relationship exactly reflects both asserted and inferred ontology semantics. OntView uniquely features on-demand visualization of General Concept Inclusions (GCIs), ontology summarization with multiple algorithms, focused sub-TBox extraction, and dynamic, percentage-stepped expansion for interactive management of large ontological structures. The tool is released as open-source software for broad community adoption and addresses notable limitations of traditional ontology editors and viewers in handling semantic complexity and information overload (Bobed et al., 18 Jul 2025).

1. System Architecture and DL Reasoner Integration

OntView is implemented as a standalone Java application, and its architecture centers around tight integration with DL reasoners and high-fidelity rendering pipelines:

• Ontology Loading: Uses OWLAPI (v5.x) to load OWL 2 ontologies, preserving all asserted axioms.
• Reasoner Integration: Supports Openllet 2.5 and HermiT, interfaced via OWLAPI’s OWLReasoner API. At load time, OntView computes the classified model including all inferred subclass relations, property domains/ranges, and disjointness relationships.
• Dual Knowledge State: Maintains both the base OWLOntology object (asserted axioms) and a precomputed OWLReasoner instance (inferred relationships). All expand, hide, and search queries are resolved by consulting the reasoner, guaranteeing that visualizations reflect current entailments.
• Visualization Backend: GUI is rendered with JavaFX; graph layouts employ pedviz’s Sugiyama-style minimization of edge crossings.

This architecture underpins OntView’s ability to remain fully consistent with the ontology’s semantic closure, a critical requirement for tasks such as error detection and ontology engineering (Bobed et al., 18 Jul 2025).

2. Visualization Paradigm: “What You See Is What You Meant”

OntView's central innovation is in enforcing a direct correspondence between the ontology’s formal semantics and its visual representation:

• Level-based Layout: The visualization arranges more general classes near $\top$ (left), and specific classes to the right, with faint vertical grid lines marking logical depth.
• Node Typing: Primitive classes are rendered as light-gray boxes; anonymous expressions as nameless white boxes; defined (equivalent) classes highlight the main atomic label in gray above the full green-formula expression.
• Connector Types: All graphical relations (subsumption, property range/domain, property hierarchies, disjointness) are materialized from the reasoner. Edges are color-coded (e.g., subclass in blue, data-property in light blue).
• Semantic Fidelity: The visual graph, including invisible GCIs and anonymous expressions, always matches the DL reasoner’s current semantic output, preventing the misalignments common in traditional ontology viewers.

Previous tools often failed to display inferred relationships or complex axioms, resulting in incomplete perspectives on ontology structure and meaning (Bobed et al., 18 Jul 2025).

3. Visualization of General Concept Inclusions (GCIs)

GCIs are critical for modeling domain-specific constraints and capturing inferential structure but are routinely ignored or hidden in mainstream ontology visualizers:

• Definition: A GCI is any axiom of the form $C \sqsubseteq D$, where $C, D$ are arbitrary class expressions, e.g., “Pizza ⊓ VegetarianPizza ⊑ ¬MeatTopping.”
• On-demand Harvesting: OntView extracts all complex expressions and GCIs at ontology load-time but only inserts corresponding nodes and edges into the visualization when requested.
• Display Conventions: Each GCI side is visualized as a white (anonymous) or labeled class box; solid blue “IsA” arrows connect antecedent $C$ to consequent $D$, with intermediate hidden nodes indicated by dashed connectors.
• Interactivity: Clicking on any GCI node reveals the axiom’s full expression via tooltip or green subpanel.

This capability enables users to trace semantic impacts of GCIs within large ontologies and to expose dependencies hidden under standard viewing paradigms (Bobed et al., 18 Jul 2025).

4. Ontology Summarization and Abstraction Methods

To address information overload in large ontologies, OntView implements multiple summarization algorithms and pruning strategies:

Summarization Method	Principle	Selection Criteria
Key Concept Extraction (KCE$_n$)	Composite topological, statistical, cognitive scoring	Top-$n$ by score, all ties included
PageRank/RDFRank$_n$	Stationary distribution of class/property network	Top-$n$ by $PR(v)$, directed or undirected
Custom selection	User-selected seed classes	As chosen, plus required ancestors/descendants

• Subgraph Induction: Given a top-$C \sqsubseteq D$0 summarization, OntView renders every selected seed, its inferred superclasses (up to $C \sqsubseteq D$1), and the minimal property edge set required for connectivity. Excluded sections remain hidden and can be incrementally restored.
• Use-case Guidance: For ontologies exceeding 2,000 classes, summarization (e.g., revealing the “spine” via top 20–50 PageRank or KCE concepts) is recommended before further exploration.

This automated and customizable approach to abstraction prevents the cognitive overload associated with dense, high-fanout ontological hierarchies (Bobed et al., 18 Jul 2025).

5. Focused Extraction, Dynamic Hiding, and Progressive Expansion

OntView offers granular control over displayed ontology regions and adapts to various user exploration patterns:

• Focused View: Users specify two classes $C \sqsubseteq D$2 with $C \sqsubseteq D$3; OntView filters the TBox to the segment where all expressions $C \sqsubseteq D$4 satisfy $C \sqsubseteq D$5, visualizing only relevant GCIs and anonymous classes.
• Node-based Controls: Every class node provides handles for expanding/collapsing parent (superclass) and child (subclass) relationships. A green progress bar tracks the fraction of visible descendants.
• Percentage-stepped Expansion: Users define a global percentage $C \sqsubseteq D$6. Each expansion reveals the top $C \sqsubseteq D$7 of hidden descendants by specified criteria (e.g., PageRank), maintaining logical connectivity by introducing dashed connectors to omitted branches. Real-time adjustments are supported via sliding node handles.

This interactive, logic-preserving expansion approach mitigates “hierarchy blow-up” when examining deep or bushy branches and supports agile ontology navigation (Bobed et al., 18 Jul 2025).

6. User Interface Capabilities

OntView’s interface implements interaction and visualization patterns for rigorous, scalable, and repeatable ontology analysis:

• Navigation: Offers mouse-based zoom, pan, and click-to-expand/hide per node.
• Search and Highlighting: Supports incremental search for both named and anonymous classes with real-time node highlighting.
• Connector Toggling: Allows selective hiding of IsA and property edges for label-focused inspection.
• Session Management: Enables saving and restoration of current visibility states, alongside exporting the viewport as a PNG snapshot for documentation.
• Stateless Reasoning: All interface operations are stateless with respect to ontology classification, as all logic queries address the cached OWLReasoner inferences, preserving model integrity (no cycles, valid subsumptions).

These features facilitate both detailed semantic inspection and the documentation/sharing of exploratory analyses (Bobed et al., 18 Jul 2025).

7. Performance and Empirical Evaluation

OntView’s computational scalability and responsiveness were validated across diverse benchmark ontologies:

Dataset	Classes	Properties	Load/Classify + Initial Render	Expand/Hide Ops (≤1,000 node subgraphs)	Peak RAM (≤5,000 classes)
Pizza ontology	≈70	N/A	N/A	N/A	N/A
DBpedia 3.8 core	≈470	278	<10 s	100–300 ms	<500 MB
ORE benchmarks (supplementary)	up to ≈2,000	N/A	PageRank summary in ~2 s

• Metrics: Aggregate times are reported for loading with reasoner startup, anonymous/GCI graph building, GUI rendering, and interactivity (expand/hide).
• Scalability: Memory usage remains below 500 MB for up to 5,000 classes (Java 17, OWLAPI 5.x); interactive operations show latency well below 0.5 s for subgraphs of practical size.

These results demonstrate that OntView is suitable for large-scale ontology analysis and responsive visual inspection workflows (Bobed et al., 18 Jul 2025).

Conclusion and Practical Implications

OntView integrates full DL-reasoner semantics with adaptive summarization and high-fidelity visualization, addressing key limitations of previous ontology viewers. Its architecture directly supports ontology engineering, verification, legacy exploration, and Linked-Data schema analysis. For exceptionally large ontologies, initial summarization reveals the dominant structural “spine,” while focused, logic-preserving views and percentage-stepped expansion control complexity. OntView is positioned as a robust, community-accessible tool for both research and practical OWL 2 ontology management (Bobed et al., 18 Jul 2025).