template.sensor.rul Maven / Gradle / Ivy

Go to download






prefix sosa:  
prefix geo:  
prefix aqio:  .

template st:resource {

   st:apply-templates(?uri, st:number())
    
}
where {
    select distinct ?uri where {
        filter xt:print('resource')
        bind (st:focus() as ?uri)
        ?uri a geo:Point .
        ?mesure sosa:hasFeatureOfInterest ?uri ;
            sosa:observedProperty ?p .
        ?p a aqio:AirQualityIndexProperty .        
        ?mesure sosa:hasSimpleResult ?value 
        
        # filter (us:value(?value) <= 30)
    }
    order by desc(us:value(?value))
}

]]>












template st:main {

    format {  }
    
    # generate a map
    st:call-template(st:place)

    format  {
        
        
        st:call-template(st:header)
        ?agg        
        st:call-template(st:header)
        st:call-template(st:resource)        
    }    
}
where {
    bind (st:call-template(st:aggregate)  as ?agg)
}

]]>






prefix sosa:  
prefix ex:    .
prefix aqio:  .
prefix ft:   

template st:place {

    st:call-template-with(st:navlab, st:maplist, ft:map.html, ?list, "")  
    
}
where {
    filter xt:print('place')
    
    { select  (aggregate(xt:list(?x, ?lat, ?lon, us:value(?val))) as ?list) 
    where {

        ?x geo:lat ?lat ; geo:long ?lon  .
        
        ?mesure sosa:hasFeatureOfInterest ?x ;
            sosa:observedProperty ?p .
        ?p a aqio:AirQualityIndexProperty .
        ?mesure sosa:hasSimpleResult ?val 
    }}
}

]]>






template st:header {
    format  {
        
        group { format { "%s. %s" st:number() us:pretty(?pname)  } }
    }
}
where {
   values ?pname { unnest(us:plist()) }
}

]]>





 .
prefix sosa:  
prefix aqio:  .
prefix ft:   

template st:profile {}
where {}


function us:sort(?p, ?v) {
    if (?p = rdf:type,          0,
    if (strstarts(?p, rdfs:),   1, 
    if (strstarts(?p, rdf:),    2, 
    if (isLiteral(?v),          3, 4))))
}


function us:display(?t) {
    us:clean(st:turtle(?t))
}

function us:displayLiteral(?t) {
    if (strstarts(datatype(?t), cdt:) , str(?t), 
    if (isNumeric(?t), 
        if (datatype(?t) = xsd:double || datatype(?t) = xsd:decimal, st:format("%.2f", ?t), ?t), 
        us:clean(st:turtle(?t))))
}

function us:clean(?str) {
    replace(?str, "<", "<")
}

function us:url(?x) {
    if (coalesce(st:getprofile(?x) = st:lod, false), ?x, st:pplink(?x)) 
}

function us:protect(?url) {
    replace (?url, "'", "%27")
}

function us:align(?n) {
    if (?n < 10,  concat(00, ?n), 
    if (?n < 100, concat(0, ?n),
    ?n))
}

function us:pretty(?pname) {
    strbefore(strafter(?pname, aqio:), "Property")
}

function us:show(?val) {
    if (isLiteral(?val), 
        us:displayLiteral(?val), 
        st:format(, us:protect(st:url(?val)), us:display(?val)))
}


function us:value(?val) {
    if (strstarts(datatype(?val), cdt:),
        if (contains(str(?val), " "), 
            xsd:double(strbefore(str(?val), " ")),
            ?val), 
        if (datatype(?val) = xsd:string, 0, ?val))
}




function us:index(?pname, ?plist) {
    let (?i = 0) {
        for (?p in ?plist) {
            if (?p = ?pname) { 
                return (?i)
            } ;
            set (?i = ?i + 1)
        } 
    } ;
    return (-1)
}


# compute list of relevant measure properties
function us:init() {
    let (select 
            (aggregate(distinct ?p) as ?l)
            (xt:sort(us:splitWith(?l,    us:element())) as ?l1)
            (xt:sort(us:splitWithout(?l, us:element())) as ?l2)
            (xt:append(?l1, ?l2) as ?list) 
        where {
            ?x sosa:observedProperty ?q .
            ?q a ?p
        }) { 
        xt:print("measure: ",  ?list) ;
        return(?list)
    }
}

function us:define() {
    set(?plist = us:init()) 
}

function us:plist() {
    return (?plist)
}

function us:element() {
    xt:list("Wind", "Temperature", "Humidity", "Dew", "Air", "Atmospheric")
}

function us:splitWith(?list, ?code) {
    mapfindlist(
        lambda(?elem, ?code) 
        { mapany (lambda(?key, ?elem) { contains(?elem, ?key) }, ?code, ?elem) },
        ?list, xt:list(?code))
}

function us:splitWithout(?list, ?code) {
    mapfindlist(
        lambda(?elem, ?code) 
        { mapevery (lambda(?key, ?elem) { ! contains(?elem, ?key) }, ?code, ?elem) },
        ?list, xt:list(?code))
}

















]]>





 
prefix geo:  
prefix ft:   

template  st:aggregate {

    format {    "Min"
        group { format { "%s %s" coalesce(us:show(?min), "") us:unit(?val) }}}            
          
    format {    "Max"
        group { format { "%s %s" coalesce(us:show(?max), "") us:unit(?val) }}}
                
    format {    "Median"
        group { format { "%s %s" coalesce(us:show(?med), "") us:unit(?val) }}}           
                
    format {    "Average"
        group { format { "%s %s" coalesce(us:show(?avg), "") us:unit(?val) }}}  
                                
    format {    "Std Deviation"
        group { format { "%s" coalesce(us:show(?stdev), "")  }}}   
}
where {
    {select ?pname (sample(?y) as ?val)
        (max(us:value(?y)) as ?max) (min(us:value(?y)) as ?min)
        (avg(us:value(?y)) as ?avg) (xt:sort(aggregate(us:value(?y))) as ?list) 
        (us:stdev(?list, ?avg) as ?stdev)
        (us:quartile(?list, 0.25) as ?q1)
        (us:quartile(?list, 0.5)  as ?med)
        (us:quartile(?list, 0.75) as ?q3)
    where { 
        filter xt:print('aggregate')
        ?in a geo:Point ; rdfs:label ?l .
        
        # iterate property names
        values ?pname { unnest(us:plist()) }
        
        ?mesure sosa:hasFeatureOfInterest ?in ;
            sosa:observedProperty ?p .
        ?p a ?pname .   
        ?mesure sosa:hasSimpleResult ?y   
    } 
    group by ?pname
    order by us:index(?pname, us:plist())
    }
    
    # record some aggregates 
    bind (st:cset(st:max,    ?pname, ?max) as ?t1)
    bind (st:cset(st:median, ?pname, ?med) as ?t2)
    bind (st:cset(st:quart1, ?pname, ?q1)  as ?t3)
    bind (st:cset(st:quart3, ?pname, ?q3)  as ?t4)
}





function us:median(?list) {
    if (xt:size(?list) = 0, 0,
        xt:get(xt:sort(?list), xt:size(?list) / 2))
}

function us:quartile(?list, ?n) {
    if (xt:size(?list) = 0, 0,    
        xt:get(?list, xt:size(?list) * ?n))
}

function us:stdev(?list, ?avg) {
    let (?dev = maplist(lambda(?val, ?avg) { power(?val - ?avg, 2) }, ?list, ?avg)) {
        power(reduce(rq:plus, ?dev) / xt:size(?list), 0.5)
    }
}

function us:unit(?val) {
    strafter(?val, " ")
}



]]>





 
prefix geo:  
prefix ex:    
prefix ft:   

template (?in, ?num) {
    format {
        
               
        # name
        ?num 
        str(?l) 
        us:date(?date)
        coalesce(us:link(?uri, ?l), "")
        
        # one row with property values of one Point
        group { 
            format {
                # one cell with value ?val of property ?pname
                format { 
                      
                    coalesce(us:color(?pname, ?val), "black")  "%s"    
                }
                coalesce(us:show(?val), "")
            }
        }
    }
    if (strends(?num, "0"), st:call-template(st:header), "")
}
where {
    # ?in is the focus node
    ?in a geo:Point ; rdfs:label ?l .
    
    # iterate property names
    values ?pname { unnest(us:plist()) }
    
    optional {   
        # some sensor properties have values, some have not
        select distinct ?in ?pname ?val ?date where {
            ?mesure sosa:hasFeatureOfInterest ?in ;
                sosa:observedProperty ?p .
            ?p a ?pname .
            ?mesure sosa:hasSimpleResult ?val  ; 
                sosa:resultTime ?date
        }
    }
    
    # some points may have a DBpedia URI
    optional { ?in ex:dbpedia ?uri }
}



# color of property value depends on the quartile of the value
function us:color(?pname, ?val) {
    us:quartile(?pname, ?val)
}



function us:quartile(?pname, ?val) {
    if (us:value(?val) >= st:cget(st:quart3, ?pname), "black",
    if (us:value(?val) >= st:cget(st:median, ?pname), "red",
    if (us:value(?val) >= st:cget(st:quart1, ?pname), "green",
        "blue"  )))
}


function us:median(?pname, ?val) {
    if (us:value(?val) =  st:cget(st:max, ?pname),    "red",
    if (us:value(?val) >= st:cget(st:median, ?pname), "brown",
        "black"))
}



function us:date(?date) {
    if (contains(?date, "T"), strbefore(?date, "T"), ?date)
}

function us:link(?url, ?lab) {
    st:format(, us:protect(st:url(?url)), ?lab)
}
]]>