M-FIRE: A METAPHOR-BASED FRAMEWORK FOR

INFORMATION REPRESENTATION AND EXPLORATION

Matteo Golfarelli, Andrea Proli and Stefano Rizzi

DEIS, University of Bologna

Via Risorgimento 2, Bologna, Italy

Keywords:

Ontology, visualization, navigation, metaphor, RDF.

Abstract:

An open problem in the construction of an environment for visualizing and navigating information in the

context of the Semantic Web is to guarantee a satisfactory compromise between expressivity and domain-

independence. In this paper we ﬁrst introduce M-FIRE, a conﬁgurable framework for instantiating visual-

ization and navigation systems based on the adoption of custom metaphors: metaphors drive the process for

obtaining a visual representation of a given piece of information and deﬁne how queries are generated upon

user actions. Then, the paper describes in detail how presentation is achieved. The possible applications for

our framework range from semantic browsing to ontology-enabled Web site design.

1 INTRODUCTION

The Semantic Web vision is built upon the ability

of formally deﬁning and processing the semantics of

knowledge. Knowledge deﬁnition languages of in-

creasing expressivity, allowing for increasingly so-

phisticated (and computationally complex) reasoning,

have been developed by the W3C organization: they

are structured as a layered tower of languages, where

each layer builds on the lower one as its semantic

extension (W3C, 2004). At the bottom of the tower

is RDF, which allows for the assertion of statements

about resources and their properties.

Since expressive languages like RDF Schema

(RDFS) and OWL are semantic extensions of RDF,

RDFS and OWL documents share the same syntax

and structure of RDF documents. Though the syn-

tax of RDF is designed to be human-readable, most

end-users are not familiar with it, and (most impor-

tant) neither they are with the semantics of abstract

concepts like ‘restriction’, ‘specialization’, ‘cardinal-

ity’, and so on: because of this, they should be pro-

vided with tools that (1) translate low-level statements

into easy-to-interpret visual renderings and (2) trans-

late user actions performed on those visual renderings

into low-level queries over the underlying knowledge

base.

An open problem in the ﬁeld of visualization

and navigation of RDF documents is to guarantee

a satisfactory compromise between expressivity and

domain-independence. The former is meant as the

capability of delivering an intuitive representation of

knowledge and some tailored navigation primitives

to end-users working in a given application domain,

while the latter is aimed at accomplishing a high de-

gree of reusability. Most existing tools favor domain-

independence, and represent entities in a way that

is closer to the abstract form used to formally de-

ﬁne them: in fact, they adopt visual items to rep-

resent things – such as classes, properties, special-

izations, and instantiation relationships – that are fa-

miliar to knowledge engineers (a narrow category of

end-users) but not to domain experts. Indeed, though

domain-speciﬁc formalisms have a lower degree of

reusability, they provide graphically richer constructs

allowing for a representation that is closer to how en-

tities appear in the application domain.

An approach to address this issue is to decouple the

mechanism for transforming RDF documents into an

expressive representation from the criteria that drive

the representation itself. In this paper, we present

M-FIRE, an original, conﬁgurable framework for eas-

ily instantiating visualization and navigation systems

for RDF-based knowledge, relying on the adoption

of custom metaphors. Metaphors drive the process

through which visual representations are obtained for

a given document, and deﬁne how queries are gen-

erated upon user actions. This allows users to per-

332

Golfarelli M., Proli A. and Rizzi S. (2006).

M-FIRE: A METAPHOR-BASED FRAMEWORK FOR INFORMATION REPRESENTATION AND EXPLORATION.

In Proceedings of WEBIST 2006 - Second International Conference on Web Information Systems and Technologies - Internet Technology / Web

Interface and Applications, pages 332-340

DOI: 10.5220/0001241303320340

 SciTePress

Figure 1: Overall functional architecture of M-FIRE.

form semantic browsing by relying on intuitive con-

cept representations and to interact in a simple man-

ner with complex knowledge.

The overall functional architecture of our frame-

work is sketched in Figure 1. First of all, we pos-

tulate the existence of a back-end module that, given

a query in a supported query language, returns a result

as an RDF document (from now on, the source doc-

ument). The metaphor selector component takes the

source document and returns the best suited metaphor

for its visualization (visualization metaphor,VMin

Figure 1) and navigation (navigation metaphor,NM

in Figure 1); many criteria could drive this choice, for

instance the vocabulary of the source document. The

chosen visualization metaphor is then given as input

to the visualizer module, which applies the directives

contained in the visualization metaphor to generate

a representation document for the source document;

the representation document describes the visualiza-

tion to be produced in an abstract form, independently

of any implementation detail. Then, a properly cho-

sen encoder translates the representation document

into a concrete form, called encoding (e.g., an HTML

document), which can be given as input to the end-

user’s visualization program (e.g., a Web browser).

The choice of the best suited encoder for a given rep-

resentation document is carried out by the encoder se-

lector and could depend, again, on different decision

criteria. The reason for this two-layer visualization

architecture (visualization followed by encoding) is

to obtain ﬂexibility and independence with respect to

any visualization device, program, and language.

Once rendering has been completed by the visu-

alization program, end-users are allowed to interact

with the produced visualization. Events generated

by user actions are captured by the event controller,

which creates an event description in the form of an

OWL document describing the occurred event (for in-

stance, a user’s double click on an icon representing a

soccer player). The event description is then given

as input to the navigator module together with the

chosen navigation metaphor. In the same way as the

visualization metaphor tells the visualizer which rep-

resentation must be produced for a given RDF doc-

ument, the navigation metaphor tells the navigator

which query must be formulated for a given event.

The resulting query is then forwarded to the back-end,

and the process is repeated.

In this paper we focus on presentation, meant as the

process through which an encoding is generated start-

ing from the source document returned by the back-

end. Such path is tracked in Figure 1 by means of

thick lines.

2 RELATED WORK

Several general-purpose tools currently exist, that

highlight the semantics of a few basic terms from the

RDF(S) or OWL vocabulary only (e.g., instances of

rdfs:subClassOf, instances of rdfs:Class, and so on)

and allow users to perform simple navigation actions,

mainly resulting in graph node expansion. This is a

reasonable limitation if we consider that those for-

malisms are intended to give a presentation for a wide

range of RDF-based documents, no matter what their

application domain is. However, they fail in offering

end-users intuitive representations of the described

objects and concepts, thus missing the main goal of

our approach. The front-ends of well-known ontol-

ogy management systems such as KAON (Volz et al.,

2003), Spectacle (Harmelen et al., 2001), Ontolin-

M-FIRE: A METAPHOR-BASED FRAMEWORK FOR INFORMATION REPRESENTATION AND EXPLORATION

333

gua (Farquhar et al., 1995), Ontosaurus (Swartout

et al., 1996), Ontorama (Furnas, 1986), and WebOnto

(Domingue et al., 1999) all fall into this category;

the same also applies to Prot

e plug-ins for ontol-

ogy visualization and navigation, except for Jambal-

aya (Storey et al., 2001).

Jambalaya is a signiﬁcant step toward the develop-

ment of a highly conﬁgurable tool, in that a visual-

ization for the semantics of a given piece of informa-

tion is generated according to user-speciﬁed parame-

ters. In Jambalaya, graphical containment is used, by

default, to encode the semantics of both sub-classing

and instantiation, but users are allowed to modify this

behavior by associating whatever property they prefer

to the graphical containment drawing primitive. Our

approach generalizes the one of Jambalaya one by al-

lowing any kind of semantic structure to be rendered

by any kind of graphical structure.

In the context of the W3C’s IsaViz visual environ-

ment for browsing and authoring RDF documents

language called Graph Stylesheets (GSS) is deﬁned

as a way to associate style to node-edge representa-

tions of RDF graphs and to offer alternative layouts

for some elements. Actually, with respect to our ap-

proach, GSS plays three roles at the same time: it re-

sembles representation metaphors because it allows to

associate graphical styles to some semantic patterns;

it can also be seen as a representation language, since

it deﬁnes a vocabulary of graphical styles interpreted

by a rendering engine; last, it can be classiﬁed as an

encoding language because it directly feeds a visual-

ization program (the IsaViz tool). Our approach aims

at disambiguating this multifold nature by introduc-

ing a clean separation of each aspect, and generalizes

GSS in that representations are not limited to graph-

based drawing primitives.

FRESNEL

is a simple vocabulary for specify-

ing which parts of an RDF graph are displayed and

how they are styled using existing style languages

like CSS. There are analogies between M-FIRE and

FRESNEL, but also signiﬁcant differences. First, the

representation paradigm of FRESNEL is centered on

resources, while the one of M-FIRE is centered on

statements: this means that in FRESNEL representa-

tions are generated for individuals, while in M-FIRE

representations are associated to (sets of) RDF triples.

The approach based on statements is more general,

because the representation of an existing resource

can always be obtained as the representation of the

statement

X rdf:type rdf:Resource, while representing

an arbitrary statement in the resource-based approach

requires reiﬁcation. Moreover, M-FIRE allows the

same graphical drawing to be the representation of

more than one statement: for instance, a picture may

http://www.w3.org/2001/11/IsaViz/

http://www.w3.org/2005/04/fresnel-info/

represent both the fact that a person is a soccer player

and the fact that he plays in a particular soccer team.

Besides, in M-FIRE navigation metaphors are inde-

pendent from representation, while the two aspects

are not well separated in FRESNEL. Finally, FRES-

NEL comes with a built-in vocabulary for formatting

displayed information in a browser-independent way,

while M-FIRE, as a pure framework, does not com-

mit to any graphical vocabulary and relies on the ex-

istence of a proper encoder capable of translating the

produced representation into the chosen format.

3 VISUALIZATION

We now provide a simpliﬁed deﬁnition of an RDF

document which is useful for our purpose of detail-

ing how the framework works.

Deﬁnition 1 (RDF document) A statement is a

triple subj , pred , obj  where the subject subj is

a resource identiﬁed by a URI (Berners-Lee et al.,

1998), the predicate pred is a property identiﬁed by

a URI too, and the object obj is either a resource or

literal (e.g. a string). An RDF document d is a set of

statements, and its vocabulary, denoted by Voc (d),is

the union of the set of the URIs and literals appearing

as the subject, object, or predicate of its statements.

Visualization is the process of obtaining a represen-

tation document in which certain graphical drawings

are associated to certain (kinds of) statements belong-

ing to the source document, according to the direc-

tives contained in a visualization metaphor. In other

words, disjoint subsets of the source document d

are

deﬁned such that statements in the same subset are

represented by instantiating the same type of repre-

sentation. The problem of classifying statements in

raises expressiveness and tractability issues con-

cerning the complexity of queries which can be for-

mulated to select them.

In order to provide a very general solution, visual-

ization in M-FIRE is conceived as a two-step process.

Although statement selection is performed through

conjunctive queries over RDF triples by relying on a

structural pattern matching engine without any rea-

soning capability (see Subsection 3.2), we allow for

a sort of preprocessing step, called enrichment and

described in Subsection 3.1, during which the source

document is augmented with new concept deﬁnitions

of arbitrary complexity; reasoning w.r.t. such concept

deﬁnitions allows to infer useful classiﬁcations for ex-

isting resources in d

, which are then exploited to for-

mulate expressive statement selections.

Thus, the visualizer module shown in Figure 1 ac-

tually consists of two separate modules: the enricher,

which augments the source document with new clas-

siﬁcations and concept deﬁnitions for obtaining an en-

WEBIST 2006 - WEB INTERFACES AND APPLICATIONS

334

riched document, and the representer, carrying out the

association of particular visual items and graphical

styles to certain kinds of statements in the enriched

document, in order to produce the representation doc-

ument (an RDF document describing the drawing that

must be presented to the end-user). Both the new

concept deﬁnitions and the styling instructions come

from the metaphor: indeed, parallel to the above

separation, visualization metaphors are divided into

two components, namely the enrichment metaphor,

which drives the transformation of the source docu-

ment into the enriched document, and the representa-

tion metaphor, which drives the production of a rep-

resentation document for the enriched document. The

vocabulary of the representation document is called

the representation vocabulary and is not bound to any

predeﬁned set of URIs (this will be further discussed

in Section 4).

3.1 Enrichment

An enrichment metaphor em is a pair o

,

where o

is an OWL document containing concept

deﬁnitions and r

is a compatible reasoner provid-

ing classiﬁcation services. Ontology o

can only

contain concept deﬁnitions of the form A = C, where

A is a concept name and C is a complex concept de-

ﬁned through concept constructors provided by the

language that r

supports.

The enricher merges

to the source document and lets r

add new

classiﬁcations to produce the enriched document d

Example 1 Let d

be the source document in Figure

2(a), and let o

be the OWL ontology in Figure 2(b).

If r

is an OWL-DL reasoner, then the enriched doc-

ument d

will include both statements in (d

∪ o

)

and 

soccer:ply01 rdf:type soccer:Goalscorer. 

As previously discussed, visualization is split into

two phases because the query language used to se-

lect those statements for which a certain representa-

tion must be drawn might have limited expressive-

ness. Our implementation of the representer mod-

ule is based on SPARQL

; as a plain RDF query lan-

guage, SPARQL does not support any kind of non-

trivial reasoning. Should SPARQL interpreters have

a built-in support for reasoning with (suppose) OWL-

DL vocabulary, enrichment could be unnecessary, as

implicit classiﬁcation could be inferred by the rea-

soner.

Besides, moving the reasoning step out of the rep-

resentation process into the enrichment phase en-

ables the support of new languages (or new reason-

ers) by simply deﬁning different metaphors. Thus,

This limitation is necessary to enable query unfolding

during navigation, which is out of the scope of this paper.

http://www.w3.org/TR/rdf-sparql-query/

a crisp separation between enrichment and represen-

tation gives metaphor designers a better control over

the kind of inferences and classiﬁcations that are per-

formed, also increasing the ﬂexibility and the modu-

larity of the design.

3.2 Representation

Representation is the process of associating proper

graphical structures to certain semantic structures,

and is carried out by the representer. More precisely,

the representer produces a representation document

for the enriched document d

, where sets of resources

in the former represent single statements in the lat-

ter, by interpreting the directives contained into the

representation metaphor. A representation metaphor

is a pair rm = R, F , where R is a set of repre-

sentation rules, and F is a set of fusion rules.Inor-

der to provide a formal account for the semantics of

representation and fusion rules, we need some auxil-

iary deﬁnitions that recall the usage of graph patterns

and templates in SPARQL. Due to space limitations,

however, we present the syntax for expressing rules

through illustrative examples instead of providing the

rigorous grammar deﬁnition.

Deﬁnition 2 (RDF Document Pattern) A statement

pattern is a statement where variable names can ap-

pear instead of URIs and literals as the subject, the

object, and the predicate. The set of variable names

appearing in a statement pattern sp is denoted by

Var (sp).AnRDF document pattern dp is a set

of statement patterns, and we deﬁne Var (dp)=



∈dp

Var (sp

). Given an RDF document pattern

dp and an RDF document d, we say that d matches

dp iff there exists at least one d



⊆ d and a mapping

β : Var (dp) → Voc (d



) such that d



is obtained from

dp by replacing each variable name v ∈ Var (dp)

with β(v). Mapping β is called a binding, and d



is a

solution for dp in d.

Deﬁnition 3 (RDF Document Template) A state-

ment template is a statement pattern where new

names used as resource templates can appear in

place of URIs and variable names as the subject

and the object only. The set of resource tem-

plates appearing in a statement template st is

denoted by Tem (st ).AnRDF document template

dt is a set of statement templates, and we deﬁne

Tem (dt)=



∈dt

Tem (st

). Given an RDF

document template dt, an RDF document d is said

to be an instance of dt iff there exists a mapping

τ : Tem (dt ) → U, where U is the set of URIs

contained in Voc (d), such that d is obtained from dt

by replacing each resource template t ∈ Tem (dt)

with τ (t). Mapping τ is called the instantiation

function from dt to d.

M-FIRE: A METAPHOR-BASED FRAMEWORK FOR INFORMATION REPRESENTATION AND EXPLORATION

335

(a) (b)

soccer:ply01 rdf:type soccer:Player, soccer:ply01 soccer:hasName “Zlatan Ibrahimovic” soccer:Goalscorer rdf:type owl:Restriction

soccer:ply01 soccer:playsIn soccer:juve, soccer:juve soccer:hasNation soccer:cty07 soccer:Goalscorer owl:onProperty soccer:hasScored

soccer:ply01 soccer:hasNation soccer:cty15, soccer:cty15 soccer:hasFlag “Sweden.bmp” soccer:Goalscorer owl:minCardinality 1

soccer:cty07 soccer:hasFlag “Italy.bmp”, soccer:ply01 soccer:hasScored soccer:goal15A4

Figure 2: Sample source document from the soccer domain (a) and enrichment ontology for the same domain (b).

Intuitively, representation rules in R are used to

create one partial representation document for each

set of statements in d

matching a particular docu-

ment pattern, while fusion rules in F properly merge

multiple such documents whenever a condition ex-

pressed over the sets of statements they represent is

satisﬁed.

Deﬁnition 4 (Representation Rule) A repre-

sentation rule is a pair r = ss, rt, where ss

(statement selector) is a document pattern, and

rt (representation template) is an RDF document

template, with Var (rt) ⊆ Var (ss).

Example 2 With reference to the enriched document

from Example 1, representation rule

PlayerInItaly in

Figure 3(a) deﬁnes the visualization of soccer players

who play in an Italian team, while rule

Nationality in

Figure 3(b) deﬁnes a visualization for the nationality

of a person, a team or anything else. The ﬁrst rule

generates, for each graph describing the fact that a

soccer player with a certain name plays in an Italian

team, an RDF document describing a blue box which

contains his name; the second one represents the fact

that a person (or a team) belongs to a nation which is

symbolized by a ﬂag, and whose picture is stored in a

ﬁle, by generating a description where the picture of

the ﬂag is placed next to the person’s representation.



Clauses

FOR PATTERN and WITH in Figure 3 de-

note, respectively, the statement selector and the rep-

resentation template for a representation rule. Names

beginning with ‘

?’ and ‘#’ are, respectively, variables

and resource templates.

The semantics of representation rules can be de-

scribed by illustrating how the representer exploits

them for generating partial representation documents.

Iteratively, a representation rule r is extracted from

R, and the set Z

of solutions for r.ss in the en-

riched document d

is computed. For each solution

z ∈ Z

, there exists exactly one set of statements in

that matches r.ss. The binding that corresponds

to z, say β

, is then used to transform the repre-

sentation template r .rt into a matching RDF doc-

ument template t

by replacing each variable name

v ∈ Var (r.rt) with β

(v) (with reference to Ex-

ample 2, statement 

#b geom:hasText ?y becomes



#b geom:hasText “Zlatan Ibrahimovic”). Thus, for

every solution z, we obtain an RDF document tem-

plate t

. An instance is then created for all such t

where the images of the corresponding instantiation

functions are pairwise disjoint (thus producing, e.g.

geom:123 geom:hasText “Zlatan Ibrahimovic”).

The procedure is repeated until all of the represen-

tation rules in R have been processed.

Example 3 The partial representation document

shown in Figure 4(a) is generated by rule

PlayerInItaly

in Figure 3(a), and the partial representation docu-

ment in Figure 4(b) is generated by rule

Nationality in

Figure 3(b), when applied to the enriched document

obtained in Example 1. 

This way, for each representation rule r ∈ R, many

partial representation documents are instantiated (one

for each set of statements in d

matching the state-

ment selector of r). Once all r ∈ R have been

processed, fusion rules come into play.

Deﬁnition 5 (Fusion Rule) A fusion rule is a triple

f = S, fp, ft, where the fusion set S is a mul-

tiset containing representation rules in R, fp is an

RDF document pattern called the fusion pattern, and

ft is an RDF document template called the fusion

template. Variables in the fusion template must also

appear in the fusion pattern: formally, Var (ft) ⊆

Var (fp).

The representer uses fusion rules to link partial rep-

resentation documents, among those created by repre-

sentation rules in S, whose represented sets of state-

ments meet the join conditions expressed in the fusion

pattern fp. A helpful analogy can be set up with rela-

tional algebra, where a join operator merges several

tables (and the same table can be included multiple

times with different roles in the

FROM clause) much

like a fusion rule merges the existing partial represen-

tation documents generated by a number of represen-

tation rules; the difference here is that applying fusion

rules leads to the creation of new sets of statements

linking the partial representation documents, whereas

a join operation in relational algebra produces a mere

concatenation of tuples, without new information be-

ing created. Representation rules in S thus corre-

spond to the joined tables, and the partial representa-

tion documents generated by them correspond to the

instances of those tables (tuples).

Fusion pattern fp (corresponding to the join predi-

cate in our analogy with relational algebra) can refer

variables used in the statement selectors of any repre-

sentation rule in S, thus allowing to express a cross-

representation condition, involving their represented

WEBIST 2006 - WEB INTERFACES AND APPLICATIONS

336

(a) (b)

REPRESENTATION RULE PlayerInItaly REPRESENTATION RULE Nationality

FOR PATTERN { ?x rdf:type soccer:Player . ?x soccer:playsIn ?y . FOR PATTERN { ?a misc:hasNation ?b . ?b misc:hasFlag ?c . }

?x misc:hasName ?z . } ?c misc:hasSourceFile ?d . }

WITH { #b rdf:type geom:Box . #b geom:hasColor “Blue” . #b geom:hasText ?z . } WITH { #i rdf:type geom:Img . #i geom:hasSrc ?d . #i geom:nextTo #p . }

Figure 3: Two sample representation rules for the soccer domain.

(a) (b)

geom:b1 rdf:type geom:Box geom:i1 rdf:type geom:Image

geom:b1 geom:hasColor “Blue” geom:i1 geom:hasSource “Sweden.bmp”

geom:b1 geom:hasText “Zlatan Ibrahimovic” geom:i1 geom:nextTo geom:p1

Figure 4: Partial representations generated by rules in Figure 3(a) and 3(b) when applied to Example 1.

statements, that must be satisﬁed in order to instanti-

ate ft; similarly, fusion template ft can refer resource

templates used in the representation templates of any

representation rule in S, allowing to create a connec-

tion among the partial representation documents pre-

viously produced (see Example 4 below).

// d

is the document to represent, vm is the visualization metaphor

// This function returns the ﬁnal representation document

RDFDocument visualizer(d

,vm) {

RDFDocument d

= enricher(d

,vm.em );

RDFDocument r = representer(d

,vm.rm );

return r;

}

// d

is the source document, em is the enrichment metaphor

// This function returns the enr iched document

RDFDocument enricher(d

,em) {

RDFDocument d

merge

= merge(em .o

)

RDFDocument d

= em.r

.inferClassiﬁcations(d

merge

);

return d

;

}

// d

is the enriched document, rm is the representation metaphor

// This function returns the ﬁnal representation document

RDFDocument representer(d

,rm) {

Set A = ∅; // Stores semantic annotations

for each r ∈ rm.R { // Apply representation rules

Set Z

= match(d

, r .ss); // Stores the matching solutions

for each z ∈ Z

{ // A solution is a set of represented statements

Binding β

= z.getBinding();

RDFDocument repr = β

.bind(r.rt).instantiate();

// Associates a partial representation to the set of statements

// it represents, and to the rule it was generated by.

Annotation a = new Annotation(repr ,z,r); A = A ∪ a;

}

for each f ∈ rm.F { // Apply fusion rules

for each a

,...,a

|f.S|

∈A

|f.S|

{ // Assume a

.rule = f.S

Set Z

= match(

i=1,...,|f.S|

.solution, f.sp);

for each z ∈ Z

{ // Instantiate the fusion template

Binding β

= z.getBinding();

RDFDocument repr = β

.bind(f .ft).instantiate();

Annotation a = new Annotation(repr ,z,f); A = A ∪ a;

}

RDFDocument repr

ﬁnal

= ∅;

for each a ∈ A { // Merge the created partial representations

repr

ﬁnal

= merge(repr

ﬁnal

,a.representation);

}

return repr

ﬁnal

;

}

Figure 5: The visualization algorithm.

Example 4 The following fusion rule establishes an

identity equivalence between the blue box generated

by representation rule

PlayerInItaly and the graphical

placeholder generated by the

#p resource template in

representation rule

Nationality, whenever their repre-

sented set of statements describe, respectively, the fact

that a person is a soccer player in an Italian team, and

the fact that the same person belongs to a certain na-

tion. As a result, taking into account the semantics of

the

owl:sameAs property, the two graphical objects

described by those resources are identiﬁed as one –

so, practically, they are merged.

FUSION RULE PlayerWithNationality

JOINS PlayerInItaly AS P, Nationality AS N

WHEN { P.?x mﬁre:sameAs N.?a . }

GENERATES { P.#b owl:sameAs N.#p . }

The above fusion rule speciﬁes how to graphi-

cally link any two partial representations, gener-

ated by rules

PlayerInItaly and Nationality, that rep-

resent two corresponding sets of statements where

the former describes a soccer player and the lat-

ter describes his nationality. The statement pattern

P.?x mﬁre:sameAs N.?x is intended to ensure that,

for two given partial representations obtained by the

above representation rules, the fusion template is in-

stantiated only if the resource that was bound to vari-

able

?x during the generation of the former actually is

the same resource that was bound to variable

?a dur-

ing the generation of the latter. Identiﬁers

P.#b and

N.#p denote the resources that were generated, in the

corresponding partial representations, as instances of

resource templates

#b and #p, respectively. 

In Example 4, clause

JOINS denotes the fusion set

S, clause

WHEN deﬁnes the fusion pattern fp, and

clause

GENERATES deﬁnes the fusion template ft.

From a high-level perspective, the application of fu-

sion rules does not differ signiﬁcantly from the appli-

cation of representation rules: iteratively, a rule f is

extraced from F and a corresponding set of |f.S|-ples

is computed, such that the elements of each tuple are

partial representation documents that were generated

by rules in f.S, and that match the join condition ex-

M-FIRE: A METAPHOR-BASED FRAMEWORK FOR INFORMATION REPRESENTATION AND EXPLORATION

337

pressed by f.fp. For every such tuple, the correspond-

ing set of solutions and related bindings is found, and

the RDF document template f.ft is eventually instan-

tiated.

Example 5 With reference to the partial representa-

tion documents obtained in Example 3, the applica-

tion of the fusion rule

PlayerWithNationality in Exam-

ple 4 yields to the generation of the following partial

representation document, consisting of a single RDF

statement:

geom:b1 owl:sameAs geom:p1 

Finally, after all fusion rules have been processed,

partial representation documents created by represen-

tation and fusion rules are all merged together in or-

der to obtain the ﬁnal representation document. Fig-

ure 5 summarizes the overall visualization process by

means of an illustrative algorithm.

4 ENCODING

The encoding process is carried out by the encoder

module, that is entitled to translate the representation

document into a concrete form, i.e., a document that

can be parsed by a proper program to produce a visu-

alization.

In principle, many formats could be used to encode

a drawing described in the representation document.

Two colored circles connected by a dotted, directed

edge could be encoded as both a GraphML

document

and an SVG

document; a table containing names and

photos could be encoded as an SVG document as well

as an HTML document.

The choice of the proper encoding can be carried

out by considering many criteria, among which user

preferences. As users of the Web usually retrieve in-

formation by means of a Web browser parsing HTML

documents, an HTML encoder could be an option if

the drawings described by the representation docu-

ment can be rendered in HTML. Still, the main de-

cision criterion is, of course, the content of the rep-

resentation document: if the vocabulary contains in-

stances of a class named

geom:DottedArrow (from a

ﬁctive

geom namespace) which designate edges con-

necting pairs of objects, it is preferable to drop HTML

and to target a visualization program which is able to

reproduce graph structures, thus choosing its corre-

sponding encoding format (for instance, GraphML).

The encoder selector module solves the aforemen-

tioned task: given a set of encoders, it extracts the

http://graphml.graphdrawing.org/

http://www.w3.org/Graphics/SVG/

most suited one according to user preferences, docu-

ment representation content, and so on.

Formally, an encoder can be deﬁned as a triple

e = p, f, V , where p is a program translating the

input representation document into the ﬁnal encod-

ing, f is the target encoding format, and V is the en-

coder vocabulary, i.e. the set of class URIs for which

the encoder is able to perform a translation into the

target format. Let E = {p

}

i=1,...,n

be a

set of available encoders, and let d

be a given rep-

resentation document. Then, a valid decision crite-

rion would be to select the encoder for which the

value |Voc (r)∩V

|/|Voc (r)| is maximum, to have the

broadest representation vocabulary coverage. Other

methods could assign different weights to the URIs in

the representation vocabulary, so that some drawing

primitives are considered more important than others.

A crucial issue involving the encoding process is

semantic annotation. Semantic annotation traces a

mapping between the graphical items that are used to

represent a given set of statements and the represented

statements themselves. Such mapping is ﬁrst estab-

lished at a conceptual level by the representer (see the

pseudo-code in Figure 5), by linking each partial rep-

resentation document to the set of statements it rep-

resents. Annotations are then parsed by the encoder,

which has the responsibility of embedding them into

the encoding document. There, such information can

be exploited by the end-user’s visualization program

to integrate graphical drawings with their semantics.

Notably, an HTML encoder would be able to trans-

late representation documents into automatically an-

notated (pieces of) Web pages.

5 IMPLEMENTATION

The architecture of our framework has been designed

in order to maximize ﬂexibility, reusability and ex-

tensibility. As to the visualization process, the frame-

work provides an implementation for the enricher and

the representer modules, but only deﬁnes the inter-

face for the metaphor selector, the encoder and the en-

coder selector: visualization systems are instantiated

by plugging custom implementations of these compo-

nents into the framework.

We have built the presentation engine (see Fig-

ure 1) as a simple Java program taking as input an

RDF document and forwarding it to the metaphor se-

lector program. The metaphor selector returns the

most suited visualization metaphor for the source doc-

ument, which is then given as input to the visual-

izer together with the source document itself. In our

prototypical implementation, the metaphor selector

does nothing more than presenting the user a list of

metaphors, so the decision on which metaphor to ap-

WEBIST 2006 - WEB INTERFACES AND APPLICATIONS

338

soccer:t1113 rdf:type soccer:Team

soccer:t1113 misc:hasName “Juventus F.C.”

geo:it39 rdf:type geo:Nation

geo:it39 geo:hasFlag “italy.jpg”

geo:it44 rdf:type geo:Nation

geo:it44 geo:hasFlag “france.jpg”

soccer:00980 rdf:type soccer:Player

soccer:00980 misc:hasName ”Gianluigi Buffon”

soccer:00980 sports:hasRole “Goalkeeper”

soccer:00980 misc:hasPhoto “gianbuf.jpg”

soccer:00980 sports:playsIn soccer:t1113

soccer:00980 misc:hasNation geo:it39

soccer:82136 rdf:type soccer:Player

soccer:82136 misc:hasName ”Lilian Thuram”

soccer:82136 sports:hasRole “Defender”

soccer:82136 misc:hasPhoto “lilthur.jpg”

soccer:82136 sports:playsIn soccer:t1113

soccer:82136 misc:hasNation geo:fr44

soccer:14756 rdf:type soccer:Coach

soccer:14756 misc:hasName “Fabio Capello”

soccer:14756 sports:hasRole “Coach”

(a) (b) (c)

Figure 6: Rendering of the HTML encoding of two representation documents obtained by applying different visualization

metaphors to the same (RDFS) source document containing information about Juventus players, of which an excerpt is shown

in (c). In (a), soccer teams are the focus of interest and they are rendered as a list of players (in this case, only Juventus

appears); in (b), goalscorers are the relevant information to be highlighted and they are shown together with their score.

ply is actually delegated to the end-user (though, this

is neither a desirable nor a realistic behavior). The

visualizer is in turn coded as two independent Java

programs, implementing the routines listed in Figure

Both the enricher and the representer rely on the

Jena

library for generic processing of RDF docu-

ments; the enricher makes use of Pellet

for support-

ing OWL(-DL and -Lite) reasoning, while the rep-

resenter module makes additional use of the ARQ

SPARQL engine provided by Jena; representation

rules are executed by internally translating them into

SPARQL queries with a CONSTRUCT clause, which

are then parsed by the ARQ interpreter for instanti-

ating the representation templates and generating the

partial representation documents.

Since HTML is the standard format used for pre-

senting information across the World Wide Web, we

have chosen to implement an HTML encoder. Our

HTML encoder is a Java program based on Jena;

screenshots in Figure 6(a) and (b) depict the encoding

of two representation documents, obtained by apply-

ing two different visualization metaphors to the same

source document (partly) listed in Figure 6(c).

Since RDF documents can be conceptually under-

stood as graphs, and most tools render them as such,

we are currently working on the implementation of a

GraphML encoder too.

http://jena.sourceforge.net/

http://www.mindswap.org/2003/pellet/

http://jena.sourceforge.net/ARQ/

6 CONCLUSIONS

In this paper we presented M-FIRE, an original ap-

proach to RDF-based knowledge visualization and

navigation where ad-hoc presentations of contents are

generated according to different metaphors. We be-

lieve that the strength of M-FIRE lies in its abil-

ity to deliver expressive, domain-speciﬁc presenta-

tions to end-users without affecting reusability, which

constitutes a signiﬁcant advance over existing ap-

proaches. Navigation primitives are also expressed by

metaphors and complete the framework by providing

a uniﬁed approach to knowledge fruition.

As to the presentation process, we have shown that

the architectural design of our framework enjoys a

double degree of reusability and ﬂexibility: during vi-

sualization, different metaphors could be applied to

the same source document (ﬂexibility), and the same

metaphor could be applied to two different source

documents (reusability); during encoding, different

encoders could be used to translate the same represen-

tation document (ﬂexibility), and the same encoder

could be used to translate two different representation

documents (reusability). Figures 6 and 7 provide an

illustrative example of this potential.

Regarding the creation of metaphors, deﬁning rep-

resentation and fusion rules is perhaps as difﬁcult

as writing a SPARQL query: transformations of

source documents into representation documents are

expressed by means of a declarative language which

recalls the

CONSTRUCT form of SPARQL queries.

Nonetheless, the same visualization metaphor could

be deﬁned by different sets of rules, and the quality of

design could have an impact on modularity, reusabil-

ity, readability, and extendibility of the metaphor.

M-FIRE: A METAPHOR-BASED FRAMEWORK FOR INFORMATION REPRESENTATION AND EXPLORATION

339

volley:t1790 rdf:type volley:Team

volley:t1790 misc:hasName “Sisley Treviso”

geo:it39 rdf:type geo:Nation

geo:it39 geo:hasFlag “italy.jpg”

volley:15189 rdf:type volley:Player

volley:15189 misc:hasName ”Valerio Vermiglio”

volley:15189 sports:hasRole “Dribbler”

volley:15189 misc:hasPhoto “valver.jpg”

volley:15189 sports:playsIn volley:t1790

volley:50040 misc:hasNation volley:it39

volley:50040 rdf:type volley:Player

volley:50040 misc:hasName ”Alberto Cisolla”

volley:50040 sports:hasRole “Smasher”

volley:50040 misc:hasPhoto “albcis.jpg”

volley:50040 sports:playsIn volley:t1790

volley:50040 misc:hasNation volley:it39

volley:44331 rdf:type volley:Coach

volley:44331 misc:hasName “Daniele Bagnoli”

volley:44331 sports:hasRole “Coach”

volley:44331 misc:hasPhoto “danbag.jpg”

volley:44331 sports:playsIn volley:t1790

(a) (b) (c)

Figure 7: Rendering of two encodings, obtained by applying different visualization metaphors to the same (RDFS) source

document (c) containing information about a volley team. In (a), the same visualization metaphor and encoder were used as

in Figure 6(a). In (b), the applied visualization metaphor produced a representation document describing a graph, which was

then processed by a GraphML encoder.

We plan to develop a visual tool aimed at assisting

metaphor designers in the deﬁnition of rules, as well

as in building coherent visualization metaphors.

M-FIRE is a very general environment, aimed at

supporting several different classes of applications.

Among those, ontology browsing is probably the

one which most promises to impact on the deploy-

ment of the Semantic Web. A key feature of on-

tology browsers is that of allowing users to switch

between multiple fruition paradigms, either transpar-

ently or intentionally; this is accomplished in M-

FIRE through metaphors and by plugging different

metaphor selectors, that perform either automatic or

manual selection of metaphors, into the framework.

In case of manual selection, a desirable feature is that

of proposing a list of valid metaphors, integrated with

legends and previewing functionalities.

Another interesting ﬁeld of application for M-

FIRE, aimed at enhancing the potentiality of cur-

rent Web technologies, is the support to the develop-

ment of semantically annotated Web sites. In fact,

M-FIRE would allow a domain-dependent translation

of RDF documents into HTML encodings to be eas-

ily speciﬁed. We believe that this would push Web

site owners to publish their content by (1) directly

implementing knowledge bases on ontology-enabled

repositories and (2) translating them into HTML doc-

uments whose elements are semantically annotated

with the information they represent. Thus, for in-

stance, it would be possible to drag an image from

a Web browser and drop it into an ontology editor for

exploring the formal description of the resource that

image depicts. In general, semantic annotation will

allow RDF-aware presentation programs to be inte-

grated with other tools capable of handling the seman-

tics of the underlying information, thus forming a rich

environment for knowledge fruition and retrieval.

REFERENCES

Berners-Lee, T., Fielding, R., Irvine, U., and Masinter, L.

(1998). Uniform resource identiﬁers (URI): Generic

syntax. http://www.ietf.org/rfc/rfc2396.txt.

Domingue, J., Motta, E., and Garcia, O. (1999). Knowledge

Modelling in WebOnto and OCML: A User Guide.

Knowledge Media Institute, Milton Keynes, UK.

Farquhar, A., Fikes, R., Pratt, W., and Rice, J. (1995). Col-

laborative ontology construction for information inte-

gration.

Furnas, G. W. (1986). Generalized ﬁsheye views. SIGCHI

Bull., 17(4):16–23.

Harmelen, F. V. et al. (2001). Ontology-based information

visualisation. In Proc. Workshop on Visualisation of

the Semantic Web, pages 546–554.

Storey, M. et al. (2001). Jambalaya: Interactive visualiza-

tion to enhance ontology authoring and knowledge ac-

quisition in Prot

e. In Proc. Workshop on Interactive

Tools for Knowledge Capture, Victoria, Canada.

Swartout, B., Patil, R., Knight, K., and Russ, T. (1996).

Toward distributed use of large-scale ontologies. In

Proc. 10th Knowledge Acquisition Workshop, Banff,

Canada.

Volz, R., Oberle, D., Staab, S., and Motik, B. (2003).

KAON SERVER - a semantic web management sys-

tem. In Proc. WWW, Budapest, Hungary.

W3C (2004). Rdf semantics. http://www.w3.org/TR/rdf-

mt/.

WEBIST 2006 - WEB INTERFACES AND APPLICATIONS

340