Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/doriantaylor/owl-fresnel-label

Fresnel Labeling Extension
https://github.com/doriantaylor/owl-fresnel-label

Last synced: 24 days ago
JSON representation

Fresnel Labeling Extension

Host: GitHub
URL: https://github.com/doriantaylor/owl-fresnel-label
Owner: doriantaylor
License: apache-2.0
Created: 2022-04-26T19:29:12.000Z (over 2 years ago)
Default Branch: main
Last Pushed: 2024-03-10T17:35:34.000Z (10 months ago)
Last Synced: 2024-03-10T18:41:42.280Z (10 months ago)
Language: Makefile
Size: 21.5 KB
Stars: 0
Watchers: 3
Forks: 0
Open Issues: 0
Metadata Files:
- Readme: README.md
- License: LICENSE

Awesome Lists containing this project

README

## Fresnel Labeling Extension

Author
Dorian
Taylor

Created
June 3, 2014

Updated
January 11, 2020

Namespace URI

Preferred Namespace Prefix
flx

This document specifies additional extensions to the Fresnel vocabulary.

### Value Ordering

The Fresnel vocabulary provides a useful mechanism for encoding the
desired behaviour for rendering the presence, sequence, and additional
styling accoutrements to the properties associated with a given RDF
resource.

However, neither the core nor extended Fresnel vocabularies explicitly
depict a method for specifying the sequence of property *values*. A
resource can have multiple values for a given property, which, in
addition to resources and blank nodes, can contain languages, datatypes,
or XML content.

It is worth noting that datatype and cardinality constraints in OWL,
while convenient as such, are *not* supposed to be interpreted as
integrity constraints, and are not reliable predictors of actual
content. Therefore it is important for rendering systems to be prepared
to handle unexpected values in RDF properties.

If we are faced with the problem of selecting *exactly one* property
value to display, for instance, as a label, how would we choose it? The
`fresnel:alternateProperties` property can give us a short list, but
past that we're left on our own. We're in the same situation when we're
trying to sort multiple property values any other way than a naïve
lexical sort.

#### The Algorithm

We must first consider sorting literal values and then sorting
resources.

Literal values in RDF have three different dimensions, although only one
of the latter two can be active at once:

- lexical content
- language
- datatype

There is also a fourth quasi-dimension, which is the specific property
the literal rode in on.

you have the property which was given by the property description, and
then you have the property which was actually selected, which could be
an arbitrarily long path of subproperty/equivalent-property relations

Lexical content can also be interpreted as a number or number-like
object based on the datatype, however this ought to be amenable to being
overridden.

`xsd:dateTime` literals, for instance, should have their time zones
normalized before being compared.

There is also a “smart” sorting algorithm (à la macOS Finder) that
breaks up strings into arrays and treats runs of digits as numbers,
comparing them numerically to each other but lexically to strings.

there is the issue of sorting plain/language/datatype values wholesale

There is the issue of showing and hiding values when there is more than
one of them; we can just sort the list and take the first one, but we
need to be able to instruct the property description that all subsequent
results after the first one should be hidden.

there is the issue of subproperties and equivalent properties, ie do we
penalize topological distance from the asserted property and if so how
much

`fresnel:alternateProperties` and `fresnel:mergeProperties` have
different implications. The former implies testing for the presence of
one property and then another until you find the one you want; the
latter implies pooling all the properties together.

`fresnel:allProperties` also has no blanket policy and will have to be
sorted, but in this case we will be sorting the *properties* themselves,
not their *values*.

------------------------------------------------------------------------

resource values have their own lexical content but also tend to be
associated with some sort of label or other

resources also have types, and it is conceivable to want to sort
resource values by their own type

a property may mix literal and resource values together

### Reverse Properties

Short of FSL or SPARQL selectors, there is no denotation of *reverse*
properties in plain Fresnel.

A common scenario for reverse properties is when the subject is in a
list, collection, or other blank node-identified entity, and we are
looking for a link to a *resource*. We need to be able to eg trace up to
the head of the list and see what property ultimately connected the
subject to the reverse relation.

## Classes

### Value Ordering

#### SortingPolicy

This class encapsulates a reusable sorting policy which can be applied
to multiple property descriptions.

Subclass of:
sh:PropertyShape

#### SortPropertyList

A SortPropertyList is just an ordinary list with some additional
constraints related to sorting properties.

Subclass of:
rdf:List

Property restrictions:
rdf:first ∈
rdf:Property ∪ sh:PropertyShape

rdf:rest ∈ flx:SortPropertyList

### Formatting

#### Disposition

A `Disposition` marks out the way a term is rendered on a canvas.

Subclass of:
fresnel:PropertyValueStyle

## Properties

### Value Ordering

#### descending

Specify that the sort should be in descending order.

Domain:
flx:SortingPolicy

Range:
xsd:boolean

#### longestFirst

When this flag is set to true, if two strings are being compared where
one (starting from the beginning) is an exact substring of the other,
the *longer* string will precede the shorter one.

In a conventional sort, when two strings that start out identical but
one is longer, the longer string will be placed *after* the shorter one.
This flag signals the opposite behaviour.

Domain:
flx:SortingPolicy

Range:
xsd:boolean

#### sortValuesBy

Domain:
fresnel:PropertyDescription

Range:

rdf:Property ∪
sh:PropertyShape ∪ flx:SortPropertyList

### Reverse Properties

#### reverse

This flag signifies when a property description is intended to represent
a *reverse* relationship.

Domain:
fresnel:PropertyDescription

Range:
xsd:boolean

### Lens Selection

#### priority