 Each ODP can be associated with a visual frame that is meant to define an intuitive standard visualization for the instances of a pattern thus easing the interpretation of the information.
To assess the feasibility and benefits of our approach we conducted a pilot study.
In this study, we developed a tool, called ODPReactor, which provides us with a proof-of-concept of the pattern-based approach to KG visualization.
ODPReactor leverages the Ontology Pattern Language annotations (OPLa) for recognizing instances of patterns within a KG.
Once pattern instances are recognized, ODPReactor summarizes the content of the KG in a single concise visualization showing what are the patterns composing the KG, how they are instantiated and what are the key concepts of each pattern (cf. REF ).
ODPReactor allows the users to select a pattern for accessing and navigating the KG (cf. REF  and REF ).
ODPReactor also defines a set of visual frames that are used to display intuitively the data in a pattern occurrence (cf. REF ).
As a case study, we deployed ODPReactor for accessing (a portion of) ArCo, the Italian Cultural Heritage KG [1]}.
ArCo consists of a network of seven ontologies and 169 million triples about 820 thousand cultural entities.
ArCo's ontologies reuse ODPs from online repositories (e.g. ODP portal) whose occurrences are annotated using OPLa.
We selected the ODPs to ensure a balance between patterns involving “physical” and “abstract” concepts (for example, the visualization of the geo-localization of a cultural property involves physical objects only, while a collection of measurements of an object involves both physical and abstract concepts) and then, we associated each pattern with a cognitive-grounded visualization.
Finally, to validate our hypotheses, we conducted a user study that involved 11 participants. The results show the validity of the ODP-based visualization approach in terms of usability and rapidity in accessing the information.
The remainder of this paper is structured as follows. After a discussion of related work (Sect. ), we present the proposed ODP-based visualization approach (Sect. ) and discuss its implementation (Sect. ). Eventually we report the results of our user study (Sect. ) and conclude the paper.
Related Work
We place our research in the area of Knowledge Graph visualization.
To the best of our knowledge, the only tool that adopts patterns as guidance for the exploratory search is Aemoo [2]}.
Aemoo is a Linked Data exploration tool that uses Encyclopedic Knowledge Patterns as relevance criteria for selecting, organizing, and visualizing knowledge.
Although our work draws inspiration from Aemoo, our approach aims at broadening Aemoo's scope (which is limited to encyclopedic patterns) by developing a general method for interacting with Knowledge Graphs shaped according to any Ontology Design Pattern.
Plenty of approaches have been proposed for visualizing KGs [3]}.
Most of them fall into two categories: graph-based visualization and template-based visualization [3]}.
Tools in the former category use network layouts to visualize RDF data as they mirror the underlying RDF structure.
Tools belonging to the latter category rely on the design of predefined HTML templates which are populated with resources resulting from the execution of predefined SPARQL queries.
Graph-based visualization tools.
H-BOLD [5]} is a graph-based visualization tool whose architecture is divided in three different levels: the Cluster View, the Schema View, and the Instance View.
This approach is similar to ours, especially in the summarization provided in the Cluster View.Christian Controlla che non abbia scritto cavolate. [CC:] usano Louvain community detection algorithm. Mi pare vada bene dire "is guided by statistical correlation" 
However, the summarization is guided by statistical correlations instead of conceptual analysis of the KG.
KC-Viz [6]} was among the firsts ontologyocchio questi due sono per ontology visualization, ho cambiato. visualization tools using the notion of key concepts  [7]} (which are the statistically relevant classes for the KG at hand).
Other tools (e.g. RDFDIGEST+ [8]}) followed the KC-Viz approach.
We adopt a similar strategy for selecting the key concepts of a KG and relating them to ODPs.
Template-based visualization tools.
Exhibit [9]} is one of the first example of usage of templates (called Lens Templates) for presenting KGs.
On the same line of research we can find other works based on template based visualization, such as LodViewhttps://lodview.it/ (the tool adopted for accessing the ArCo KG) or others [10]}, [11]}, [12]}, [13]}, [14]}.
A special case is the tool proposed by McBrien et al. [15]} which includes a mechanism for recommending the most appropriate visualization for a given SPARQL query.
Our approach leverages these experiences, meaning that, the visualization strategies implemented by ODPReactor could be seen as templates for visualizing a KG.
A limit of the existing template-based approaches is that they consider as meaningful boundary for describing an entity its neighborhood only (which is typically the set of triples involving a resource), and all the entities are described with the same boundary.
However, while this is an effective strategy for “simple” KGs, it fails short with sophisticated KGs in which the meaningful boundary of each entity depends on the type of the entity and the pattern the entity is involved in.
ODPReactor goes beyond these approaches since it associates each entity of the KG with a meaningful boundary that depends on the ODPs the entity is involved in (implying that each entity might have a different boundary).

Approach
In this section we briefly review the main concepts we build upon (ODP, OPLa and key-concept classes), then we describe our framework and an example of visualization based on the ODP Part Of.
Background
Design patterns: Ontology Design Patterns (ODPs)http://ontologydesignpatterns.org [16]} are modeling solutions to recurrent ontology design problems. ODPs can be divided into multiple categories: logical, architectural, content, presentation [17]}.
In our case study, we used three ontology design patterns (implemented in the context of ArCo project [18]}). The first, Time-Indexed Typed Location, represents the locations of an object (e.g. a cultural property) in specific time intervals and with specific purposes (e.g. storage, exposition). It specializes Time-Indexed Situation, a pattern to represent situations that have an explicit time parameter. The second, Measurement Collection, represents a collection of measures. It is a specialization of pattern Collection, to represents collections and their members. Last, Cultural Property Component Of represents a cultural property and its components and specializes Part Of, a pattern to represent entities and their parts.
OPLa: OPLa ontology is an ontology design pattern representation language [19]}, which enables annotating ontologies to (1) indicate that an axiom or class belongs to a certain module or pattern, (2)
specify how an axiom or class is related to the pattern,
and (3) represent relationships between two patterns or between a pattern and a module.
We extended OPLa to represent instances of patterns.
We added the property opla:isPatternInstanceOf with domain an individual of type opla:PatternInstance and range an individual of type opla:Pattern. To indicate that an entity belongs to a pattern instance. We defined the property opla:belongsToPatternInstance (and its inverse opla:hasPatternInstanceMember), whose domain and range are respectively owl:Thing and opla:PatternInstance.
Our methodology relies on the use of this annotations to identify and distinguish specific instances of patterns in data.
Key Concepts: Knowledge graph summarization is crucial in graph visualization and other applications where large graphs need to be handled
[20]}.
In [7]} the authors introduced key concepts as elements which best summarize an ontology.
Following this approach, we adopted the Degree centrality measure [20]} (a measure often used for knowledge graph summarization [23]}) for estimating the relevance of each class of a given ontology.

Pattern-based visualization of Knowledge Graphs
We propose a general framework based on three levels of visualizations.
The top level, namely the ODP level, is a view of the knowledge graph that shows a graph whose nodes represent either an ODP instantiated in the KG or a key concept of an ODP.
Edges of this graph are modeled according to the OPLa vocabulary and its extension discussed in Sect. REF .
The second level, called exploration level, presents the occurrences of a specific ODP and allows users to filter the occurrences according to her information needs.
The third one, the visualization level, is dedicated to the visualization of a single occurrence of an ODP or an entity of the KG.
First, we intuitively describe the aim and the characteristic of these levels, and, then we formally define our visualization method.
We remark that the design of all the layers followed Gestalt psychology principles [24]}
and studies on visual language [25]}.
This principles were particularly relevant for the visualization level.
For example, Common Region Gestalt principle states that when objects are enclosed in the same region we perceive them as being grouped together. Following this idea, we enclosed all members of a collection within a line in designing the visual frame for pattern Collection.
ODP level. This is the highest level of abstraction and summarization of a knowledge graph.
This visualization provides (in the dimension of a page) a concise overview (cf. H1) of the most relevant concepts instantiated in a KG.
Specifically, the system shows a graph representation of the most relevant key concepts (i.e. classes) of a KG and a number of views related to such concept.
Each view corresponds to an ODP and identifies a perspective for exploring a KG.
Views and key concepts are represented by nodes, while edges explain the relations among them.
Figure REF  depicts an example of the graph visualized at this level.
The graph contains two views (Part Of and its specialization Cultural Property Component Of) and a key concept (Cultural Property). Edges are of two types: those describing the relation between ODPs (e.g. specializes, has component) and those relating a key concept to the ODP it appears in (has View).
It is worth noticing that both relations are retrieved from OPLa annotations, the edge has view symbolizes opla:isNativeTo property, whereas specializes edges stand for opla:specializationOfPattern.
ODPReactor also provides filters (not shown in Figure) to reduce the number of nodes in the graph visualization, including an importance threshold for classes to be visualized as key concepts.
the size of the nodes is proportional to the logarithm of the
number of occurrences of the pattern.
This provides the user with an insight of how the various components of the KG are instantiated.
Interestingly, this view gives a concise overview of the overall knowledge graph
From this view the user can rapidly perceive a summary of the information in the KG: what its main conceptual components are, what the key elements of such components are and how these components are instantiated.
<FIGURE>Exploration level. The Exploration level is the second level of visualization.
This level shows the instances of ODPs and key concepts.
The user can access to this level by clicking either on an ODP or a key concept showed at the ODP level.
In both cases instances are presented in a tabular form. A schematic representation of this level is shown in Figure REF . As for the instances of the key concepts, the table shows the list of individuals that can be filtered by the user.
The user can access to the detailed view of a single individual by clicking on a row in the table.
As for ODP instances, each column of the table is associated with an ODP dimension (e.g. for Time Indexed Typed Location dimensions are start time, end time, location type, and coordinates), while each row represents an instance.
For every dimension of an ODP, we designed a set of semantic filters that allow users to define the criteria for filtering instances.
In agreement with the open-world assumption, by default, the filters include instances that do not have a value for the filtering criteria.
However, we give the possibility to switch to the close-world assumption and exclude resources for which missing data do not consent filters to be applied.
Clearly, filters can be combined in order to restrict the set of instances according to multiple criteria defined on multiple dimensions.
Then, the user can access to the detailed view of a single pattern instance by clicking a row of the table.
It is noteworthy that the exploration and the filtering strategy implemented in the visualization depends on the ODPs which the KG is composed of.
Therefore, both the summary presented at ODP level and the interaction designed at visualization level rely on the ODPs instantiated in the KG thus complying with the hypotheses H2 and H3.
Visualization level.
The visualization level provides the users with a detailed view of an instance of a pattern or a class of the KG.
Specifically, this visualization presents the pattern instances through the lens of a visual frame.
A visual frame is a standard visualization designed for a pattern (e.g. Geo-Localization of entities are depicted as markers of a map) which presents the pattern instance by means of a set of intuitive graphical elements. Figure REF  depicts a schematic example of visual frame for pattern Part Of.
It is worth noticing that, even if the visual frame is specifically designed for an ODP, it can be reused on different KGs implementing the ODP.
Consequently, this strategy implicitly promotes visual frames as standard visualization for a pattern (cf. H4).
The visual frames are also displayed in the visualization of the individuals of the KG.
In fact, the visualization level for an individual is designed for displaying all the visual frames which the individual is involved in and all the property-value pairs associated to the individual.
Interestingly, in doing so, the boundary of information presented together an individual of the KG is delimited by the boundary of the ODPs.
Formalization of the approach. We now formally describe our approach. We define a RDF knowledge graph \(\mathcal {G}\)  as \(\mathcal {G} \subseteq (\mathcal {U} \cup \mathcal {B}) \times \mathcal {U} \times (\mathcal {U} \cup \mathcal {B} \cup \mathcal {L})\)  where \(\mathcal {U}\) , \(\mathcal {B}\)  and \(\mathcal {L}\)  are the set of URIs, the set of blank nodes and the set of literals, respectively. We assume that ODPs are annotated with OPLa ontology [19]}. Briefly, classes that belong to an ODP are annotated with a relation opla:isNativeTo connecting to the URI of the corresponding ODP pattern. We define \(\mathcal {P}\)  as the set of ODP patterns implemented in \(\mathcal {G}\) . We also define \(implementation_{\mathcal {G}}(P) \subseteq \mathcal {G}\)  as the subgraph (set of tuples) corresponding to the TBox implementation of the pattern in the knowledge graph, induced by the set of source nodes of relations opla:isNativeTo targeted in \(P\) . We also considers a special set of (key concept) nodes \(\mathcal {K}\) , which are special classes that help the user identify and distinguish specific instances of patterns.
Given an ODP pattern \(P \in \mathcal {P}\) , we can identify a number of occurrences of such a pattern in the knowledge graph, where an occurrence is an ABox implementation of \(P\) , composed by individuals and relations that respect the pattern structure. The identification of such occurrences is dependent on the specific pattern and can be performed by suitable SPARQL queries. While a general way to identify ODP occurrences is worth of further investigation, in this work we assume such occurrences have been previously identified and annotated with the extension of OPLa discussed in Sect.  REFWe implemented the code to generate such annotations for the patterns we employed in our prototype. We denote the set of occurrences of a pattern \(P\)  as \(\mathcal {Q}_P\) , where an element \(Q \in \mathcal {Q}_P\)  is a subgraph of \(\mathcal {G}\)  that concretely materializes \(P\) . Their nodes are denoted as \(nodes(Q)\) .
At the ODP level our tool shows a graph whose nodes represent patterns and key concepts (\(\mathcal {P} \cup \mathcal {K}\) ) and edges show their relations. A Key-concept node \(K\in \mathcal {K}\) , which corresponds to a class in \(\mathcal {G}\) , is connected to a pattern node \(P\)  through a relation hasView if \(K\)  is a class in \(implementation_\mathcal {G}(P)\) . Patterns are also interconnected by OPLa [19]} relations (e.g. opla:specializationOfPattern – in the tool URIs are substituted with user-friendly descriptions).
The exploration level requires a pattern-specific mapping function from data elements to visual elements and a pattern-specific set of filter controls. Since at this level data are visualized in a table, the mapping needs to associate nodes of the pattern (typically literals) to columns. Specifically, each pattern \(P\)  is associated to a set of \(c\)  columns and a function (implemented by specific code) \(emap_P : \mathcal {Q}_P \rightarrow \mathcal {L}^{c} \cup \lbrace \phi \rbrace \)  which associates a pattern instance \(Q \in \mathcal {Q}_P\)  to a list of \(c\)  literals to be shown in a row. The special symbol \(\phi \)  accounts for filters. Specifically \(emap_P(Q)=\phi \)  if \(Q\)  does not satisfy the filter constraints set by the user. The GUI for filters is pattern dependent and can be built by combining a set of filter controls, each one associated to a specific property. We implemented a set of filter control templates to account for different data types (dates, locations, numerical values, discrete values), which can be combined to construct the filter GUI of each pattern.
The visualization level consists of the visualization of a pattern instance in a specific page. Our approach requires a pattern-specific function \(vmap_P : \mathcal {Q}_P \rightarrow \mathcal {VF}\)  that associates each pattern instance \(Q\)  to its correspondent visualization frame. The correspondence between data values and visual elements is established by suitable knowledge-graph-independent SPARQL queries.
Note that our approach is completely independent of the specific implementation of patterns in the knowledge graph and therefore enable reusing the visualization code of a pattern on a different knowledge graph that implements the same pattern and is annotated with the extended OPLa. To make a pattern \(P\)  visualizable, the developer needs to compose the set of filter controls, design the visual frame and define the functions \(emap_P(Q)\)  and \(vmap_P(Q)\) . Figure REF  shows an example of a pattern and how data of specific instances is mapped into the GUI. The left part (Figure REF ) depicts the Part Of ODP, defined by property hasPart, which connects an object to its parts. We include the properties label and depiction, although not part of the pattern, since they are present (at least label) in all KGs for crucially increase their human-readability. The pattern is associated to the \(emap_P\)  and \(vmap_P\)  functions, whose implementation is reported in the right side of Figure REF  in pseudo-SPARQL. Given a pattern instance \(Q\) , identified by uri(\(Q\) ), \(emap_P(Q)\)  retrieves the object label (?l) and the number of parts (?p). It also applies the filter (user_defined_filter in the WHERE clause) and return \(\phi \)  (an empty set of tuples) if filter constraints are not satisfied. \(vmap_P(Q)\)  extracts figures of the object and every part (?d and ?dp, identified by property depiction) and maps them into the visual frame (the visual mapping is summarized by the \(visual\_frame()\)  function). The right part (Figure REF  shows a concrete example of two instances \(Q_1\)  and \(Q_2\)  of pattern Part Of and their mapping into the table for the exploration (bottom-right side) and the visual frame (top-right side). For space reasons we only show the visual frame for \(Q_1\) . For each label and depiction we report the corresponding SPARQL variable of the \(emap_P\)  and \(vmap_P\)  implementations (taken from Figure REF ).
<FIGURE>
Implementation
Design Methodology.
We put emphasys on the importance of user cognition in the visualization design process [28]} and, taking inspiration by other successful experiences (e.g. [29]})
we applied User-Centered Design (UCD) principles.
Specifically, we followed agile design methodology with brief iteration cycles (1 week sprints).
This process involved 2 developers, and 3 users collaborated in the process by continuously providing feedback on the tool.
Once the tool reached a stable version, we conducted an experiment with an 11-participants focus group and evaluated the usability according to the System Usability Scale (SUS) [30]}.
The results are discussed in Section .
ODPReactor Architecture.
ODPReactor is divided into three main components:

ODPBrowser, a service to explore and filter the ODP/key concepts graph and their instances (it encapsulates ODP level and exploration level described in Sect. );

Extended-Ld-Reactor (E-LD-R), a service to visualize resource pages with their data (it encapsulates the visualization level);

ODP-UI, the visual frames library, embedded in the E-LD-R microservice.

The two services are exposed in a client-side React.jshttps://reactjs.org/ application hosted and served by a Node.jshttps://nodejs.org/ environment. The services can be configured to retrieve data from one or more SPARQL endpoints and store configuration data (e.g. the list of KGs and their respective SPARQL endpoints) in a MongoDBhttps://www.mongodb.com/
The architecture is detailed in Figure REF .
We discuss here the three components.
<FIGURE>ODPBrowser is a service implementing the ODP level (ODPs and concepts graph visualization) and the exploration level (table with filters) discussed in Sect. .
The ODP/key concepts graph is implemented by using Graphinhttps://graphin.antv.vision/, a graph visualization library.
Every concept has an associated importance score (computed by degree centrality), which enables filtering concepts whose importance is below a user-defined threshold.
By double clicking on a node, the user can navigate to the exploration level
where all instances of the selected key concept or data associated to the selected ODP are displayed in a table.
This view contains filters semantically related to the specific ODP (e.g. the ODP Time Indexed Situation enable filtering by time interval).
ODP-based Semantic Filtering. To filter geographic locations, we implemented a map with LeafletJShttps://leafletjs.com/ where users can draw a closed perimeter.
Perimeter coordinates are then calculated and resources localized inside the area are selected while others discarded. Numeric filtering (such as measures, time intervals, number of components) can be performed by means of sliders where the user can select with a cursor interval of interest. We used React Compound Sliderhttps://react-compound-slider.netlify.app/ to develop the facets. Among other facets, we used checkboxes to select or deselect categorical data such as location types.
By double clicking on a table row, the user is redirected to Extended-Ld-Reactor, which visualizes the selected instance.
Extended-Ld-Reactor is an extension of Linked Data Reactor (LD-R) [31]}, a full stack application (based on Fluxiblehttps://fluxible.io/, React.js and Semantic UIhttps://semantic-ui.com/), which facilitates mapping URIs into visual components.
We embedded specific user interface for ODP-based visualization in LD-Reactor and configured it to visualize resources related to ODPs. The user interface makes use of a library of visual frames (namely ODP-UI, discussed below), which can be visualized singularly or through a mosaic grid with all visual frames associated to a specific resource.
ODP-UI is a library of visual frames where each frame displays data related to a specific ODP, as discussed in Sect. . Each visual frame is implemented as a React.js component. We implemented visual frames for the patterns Time-Indexed Typed Location, Measurement Collection, and Cultural Property Component Of, discussed in Sect. REF .
Deployment.
We deployed ODPReactor for the ArCo knowledge graph [1]}. ArCo is the Italian Cultural Heritage knowledge graph, consisting of a network of seven vocabularies and 169 million triples representing 820 thousand cultural entities.
The ArCo ontology has been developed following the eXtreme Design methodology, an ontolology design methodology which uses ODPs as building blocks for constructing ontologies.
This makes ArCo a good candidate for evaluating our approach.
Code. The implementation of the framework is available as open source project on GitHubhttps://github.com/ODPReactor.
Use case scenario.
We describe a use-case scenario as an example to show how the ODPReactor components interact.
A user (say Claire) is interested in getting information about all cultural properties that in 1856 were located in a specific area in Paris.
Claire accesses to the ODPBroswer, retrieves the ODPs composing ArCo and double-clicks the node representing the Time-Indexed Typed Location.
A data table with cultural property instances and associated data (according to dimensions of the pattern) is shown and a series of filter facilities are made available to her.
Claire then filters data by: (i) drawing an area around Paris on the location filter control geographical map; and (ii) selecting a time interval with the interval filter control slider. She locates the specific cultural property she is interested in, and selects it.
ODPBrowser pass the control to Extended-Ld-Reactor to load the instance data from the SPARQL endpoint and display it in a mosaic grid of visual frames.
quest'esempio mi sembra non aggiungere niente alla discussione, forse andrebbe rimosso

User Study
In this section, we report on the results of the user evaluation of the proposed approach.
As proof-of-concept of our approach, we deployed ODPReactor for a portion of the ArCo KG.
The portion included 200 cultural properties randomly selected among those participating to (at least) an instance of the three ODPs chosen for the case study.
In terms of pattern instances this selection included: 49 instances for Cultural Property Component Of, 270 for Time Indexed Typed Location and 158 for Measurement Collection.
The test was conducted by 11 users, composed by 3 researchers, 5 Phd students and 3 working professionals.
All participants were familiar with Semantic Web and Linked Data technologies and were not involved in the development process.
The purpose of the test was to evaluate the ability of the tool to perform the following tasks:

present the KG in a clear, concise and intuitive way (cf. H1, H2, H4);

give the users a usable interface for searching specific instances (cf. H3).

Each tester was asked to perform a series of searching tasks (e.g. finding the length of an object) and to answer questions about the selected items.
We dedicated a section of the questionnaire for each task.
Each section presents the task and asks the user to rate:
[label=()]
the difficulty and rapidity in performing the task;

the usability of the tool.

The scores range was on a scale of 1 (very easy/rapid/usable) to 5 (very difficult/slow/unusable).
To evaluate the general level of user satisfaction, we added to the survey a section containing the SUS-System Usability Scale questionnaire [33]}.
Before starting the test, the users were asked to perform a brief tutorial defined for the tool.
The tutorial presents the user the three visualization levels (ODP level, exploration level, visualization level) and, in each of them, it shows the position of the filters.
We measured the actual time occurred for performing each task and asked the participants to record their screen and send us the recording. The latter was useful for understanding the reason of possible failures or slowdowns.
10 of the 11 participants agreed to record their screen and share the recording.
The results of the evaluation according to the SUS scale are presented in Figure REF . They show that the tool is considered excellent by more than half of the users and good by the remaining ones except one, whose judgment was poor. The average score was \(81.4\) , with a standard deviation of \(12.6\) .
<FIGURE>Assessment of the visualization level. A first group of tasks, reported in Table REF , was designed to evaluate the clarity of the visualization level (therefore assessing the hypothesis H4).
In order to compare ODPReactor with existing tools we asked each user to perform the same task also using LodView (a widely known KGs viewer adopted for ArCo).
We considered one task per ODP View.
Each task was executed twice per tool in order to measure also the improvement with the experience. For each execution the user was asked questions about the dimensions of the ODP.
We considered as evaluation metric the number of correct answers, the time of execution and the users judgment of usability.
An answer has been evaluated as correct if the user correctly identified the entry containing the data, although the answer is only partial.
For example in tasks TITL1 and TITL2, for little-known cities the users had difficulties in distinguishing the city from the village or from the county (all reported in the same entry). Quanti sono?
Therefore we considered all such answers as correct. The results are reported in Figure REF .
Figure REF  shows the number of correct task executions. ODPReactor always performs similarly or better than LodView. Figure REF  shows the average task execution time. ODPReactor always performs better than LodView, with the exception of TITL 1, which regards retrieving the location of a cultural property.
By analyzing the recordings it emerges that the users have quickly identified the data, but have delayed the transcription, because of difficulties in distinguishing the town (specifically Caravino and Vittorio Veneto) from the village or from the province. The same behaviour is not reflected in the LodView tasks, since the answers consist in widely-known cities (specifically Rome and Turin).
Figure REF  shows the user judgment of the tool, where ODPReactor was considered significantly more adequate than LodView. This result is emphasized for the Measurement Collection tasks, where ODPReactor was evaluated unanimuosly very adequate while the judgment for LodView was almost equally distributed from Very adequate to Inadequate.
<TABLE>Assessment of the ODP and exploration level.
In order to assess H1-3 hypotheses we designed a group of tasks involving the ODP level and exploration level. These tasks, reported in Table REF , are designed for evaluating the benefits of the approach in streamline the navigation and search of information in the KG.
All the tasks required to identify the number of occurrences in the KG satisfying a given searching criterion.
The first two tasks (referred to Measurement collection ODP and Cultural property component of ODP) can be performed by applying just one filter, while the last three ones (referred to Time indexed typed location ODP) require the activation of more than one filter. We chose the ODP Time Indexed Typed Location for the multi-filter tasks since this pattern is more complex then the others and hence it has more filter controls.
To evaluate the general level of user satisfaction, we asked the users to answer a survey defined according to the SUS-System Usability Scale questionnaire [33]}.
<TABLE><FIGURE>Finally, we report on the results of the exploratory research tasks on ODPReactor. We did not compare this task with LodView since it does not provide exploratory search functionalities. In counting the number of occurrences that satisfy the given constraints, we did not make any assumption about open or close world, and considered correct both the answers that include or exclude objects that do not contain some of the properties necessary for applying the filter.
Results are summed up in Figure REF . We collected 55 (\(11 \times 5\) ) responses by aggregating correctness, usability and difficulty, from all tasks and all users. Most of the users performed the task correctly (Fig. REF ). We analyzed the recordings for understanding the reasons of failure or difficulties in executing the task. It emerged that among 10 wrong answers, 9 ones are due to failures to apply all filters necessary for the complex multi-filter tasks, while for the other one the data was correctly identified but wrongly reported.
Specifically, the testers wrongly set the filter of the Time-indexed Typed Location instances for selecting only those having a certain type (e.g. Current Location).
This indicates that the usage of such filter was not intuitive for the testers and it has to redesigned.
Finally, Figure REF  shows the result of the questions about usability of the tool.
Most of the users judged the tool very adequate or adequate. 51 answers out of 55 were positive or intermediate.
Figure REF  shows similar positive results about difficulty.
<FIGURE>Conclusions and Future Work
This work proposed a novel approach to Knowledge Graph visualization that uses Ontology Design Patterns as first-class citizens for accessing and navigating KGs.
We described a general framework that enables reusing an ODP-related visual frame to different KGs and implemented a tool for validating the concept.
The results of the execution of a set of tasks on the tool demonstrated the validity of the proposed approach, confirmed by considering both objective parameters and user perspective.
In future we plan to enrich our library of visual frames with new ODP-based views and to explore general methods for automatizing the annotation of pattern instances.
We also plan to study an automatic system for building filter facets and to make an extensive evaluation on a larger number of users.
