-
Notifications
You must be signed in to change notification settings - Fork 18
/
11-Part-08.adoc
1218 lines (883 loc) · 62 KB
/
11-Part-08.adoc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
== Geometry Extension (serialization, version)
This clause establishes the _Geometry Extension (serialization, version)_ parameterized requirements class, with IRI `/req/geometry-extension`, which has a single corresponding conformance class _Geometry Extension (serialization, version)_, with IRI `/conf/geometry-extension`. This requirements class defines a vocabulary for asserting and querying information about geometry data, and it defines query functions for operating on geometry data.
As part of the vocabulary, RDFS datatypes are defined for encoding detailed geometry information as a literal value. A literal representation of a geometry is needed so that geometric values may be treated as a single unit. Such a representation allows geometries to be passed to external functions for computations and to be returned from a query.
=== Rationale
Other schemes for encoding simple geometry data in RDF have been implemented. The W3C Basic Geo vocabularyfootnote:[http://www.w3.org/2003/01/geo/] was an early (2003) RDF vocabulary for "representing lat(itude), long(itude) and other information about spatially-located things, using WGS84 as a reference datum" and many widely used Semantic Web vocabularies contain some spatial data support. For example, _Dublin Core Terms_ provides a _Location_ classfootnote:[http://purl.org/dc/terms/Location] for "A spatial region or named place." and _schema.org_ provides a number of spatial object and geometry classes, such as `GeoCoordinates` footnote:[https://schema.org/GeoCoordinates] and `GeoShape` footnote:[https://schema.org/GeoShape].
Many vocabularies, such as these two, provide little specific support for detailed geometries and only support the WGS84 Coordinate Reference System (CRS).
Since 2012 and the first version of GeoSPARQL, many ontologies have imported GeoSPARQL, for example, the _ISA Programme Location Core Vocabulary_ footnote:[https://www.w3.org/ns/locn] whose usage notes provide examples containing GeoSPARQL literals and the use of GeoSPARQL's "geometry class". The W3C's more recent _Data Catalog Vocabulary, Version 2_ (DCAT2) standardfootnote:[https://www.w3.org/TR/vocab-dcat/#spatial-properties] similarly contains usage notes for `geometry`, `bbox` and other properties that suggest the use of GeoSPARQL literals.
Some of the properties defined in these vocabularies, such as DCAT2's `spatialResolution` have motivated the inclusion of new properties in this version of GeoSPARQL. In this case the equivalent property is <<Property: geo:hasSpatialResolution, `geo:hasSpatialResolution`>>. The GeoSPARQL 1.1 Standards Working Group charter <<CHARTER>> contains references to a number of vocabularies/ontologies that were influential in the generation of this version of GeoSPARQL.
=== GeoSPARQL and Simple Features (SFA-CA)
The GeoSPARQL Geometry Extension is largely based on the the specification Simple Features Access - Common Architecture (SFA-CA) <<OGCSFACA>>. Contrary to what the name may imply, SFA-CA is about Geometry, not about Features. SFA-CA describes simple geometry, meaning that geometric shapes are based on points and straight lines (lineair interpolations) between points. Within a single Geometry, these lines may not cross.
Neither GeoSPARQL nor SFA-CA support full three dimensional geometry. Coordinates may be three-dimensional, which means that points may have a Z-coordinate next to an X- and Y-coordinate. The Z-coordinate then holds the value of height or depth. However, lines or surfaces can only have one Z value for any explicit or interpolated X,Y pair. This is often referred to as 2.5 dimensional geometry. Geometric functions working with Geometries that have Z values will ignore Z values in calculations and first project geometry onto the Z=0 level.
SFA-CA also describes M coordinate values that may be part of geometry encodings. The M value represents a measure, a value that can be used in information systems that support linear referencing. GeoSPARQL at the moment does not support linear referencing. Like Z values in coordinates, M values are to be ignored.
SFA-CA specifies a class hierarchy for Geometry. Although these classes are not part of the GeoSPARQL ontology, the GeoSPARQL DWG does publish a vocabulary of Simple Features geometry: http://www.opengis.net/ont/sf. Geometry types defined in this vocabulary can be considered safe to use with GeoSPARQL. The two Geometry serializations that were specified in GeoSPARQL 1.0, WKT and GML, fully support all SFA-CA geometry types. However, the two Geometry serializations that were introduced in GeoSPARQL 1.1 do not. Some SFA-CA geometry types are not supported by the KML or GeoJSON format. For example, neither KML nor GeoJSON support the TIN or Triangle geometry types.
=== Recommendation for specification of units of measurement
For geometric data to be interpreted and used correctly, the unit of distance should be known. Typically, the particular Coordinate Reference System (CRS) that is associated with a Geometry instance will specify a unit of measurement. However, some elements of GeoSPARQL allow arbitrary units of distance to be used, for example the property <<Property: geo:hasSpatialResolution, `geo:hasSpatialResolution`>> or the function <<Function: geof:buffer, `geof:buffer`>>. In those cases it is advisable to make use of a well known web vocabulary for units of measurement. That will improve data interoperability. The recommended vocabulary for units of measurement for GeoSPARQL is the _Quantities, Units, Dimensions and Types (QUDT)_ ontologyfootnote:[http://www.qudt.org].
=== Influence of Coordinate Reference Systems on geometric computations
Geometric computations must always be mindful of the kind of space that is described by a Coordinate Reference System (CRS). A Geometry object consists of a set of coordinates and a specification on how the coordinates should be interpreted: the CRS. Taken together, coordinates and CRS allow performing computations on Geometry objects. For example, sizes can be calculated or new Geometry objects can be created. Some Coordinate Reference Systems describe a two-dimensional flat space. In that case, coordinates are understood to be Cartesian, and Cartesian geometric computations can be performed. But Coordinate Reference Systems can describe other types of spaces, to which Cartesian computations are not applicable. For example, if CRS http://www.opengis.net/def/crs/OGC/1.3/CRS84[`+<http://www.opengis.net/def/crs/OGC/1.3/CRS84>+`] is used, coordinates are to be interpreted as degrees of latitude and longitude, designating positions on a spheroid. The distance between two points using this CRS is different from the distance between two points that have the same coordinates but are based on a Cartesian CRS.
To avoid erroreneous computations involving Geometry, data publishers are recommended to clearly make the type of space that is described by the CRS known.
=== Parameters
The following parameters are defined for the _Geometry Extension_ requirements class.
serialization:: Specifies the serialization standard to use when generating geometry literals and also the supported geometry types.
NOTE: a serialization strongly affects the geometry conceptualization. The WKT serialization aligns the geometry types with _ISO 19125 Simple Features_ <<ISO19125-1>>, and the GML serialization aligns the geometry types with _ISO 19107 Spatial Schema_ <<ISO19107>>.
version:: Specifies the version of the serialization format used.
=== Geometry Class
A single root geometry class is defined: <<Class: geo:Geometry, `geo:Geometry`>>. In addition, properties are defined for describing geometry data and for associating geometries with features.
One container class is defined: <<Class: geo:GeometryCollection, Geometry Collection>>.
==== Class: geo:Geometry
The class http://www.opengis.net/ont/geosparql#Geometry[`geo:Geometry`] is equivalent to `GM_Object` <<ISO19107>> and is defined by the following:
```turtle
geo:Geometry
a rdfs:Class, owl:Class ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "Geometry"@en ;
rdfs:subClassOf geo:SpatialObject ;
owl:disjointWith geo:Feature;
skos:definition "The class represents the top-level geometry type. This class
is equivalent to the UML class GM_Object defined in ISO 19107,
and it is superclass of all geometry types."@en ;
.
```
[#req_geometry-extension_geometry-class]
|===
| *Req 12* Implementations shall allow the RDFS class <<Class: geo:Geometry, `geo:Geometry`>> to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/geometry-class[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/geometry-class`]
|===
==== Class: geo:GeometryCollection
The class <<Class: geo:GeometryCollection, Geometry Collection>> is defined by the following:
```turtle
geo:GeometryCollection
a owl:Class ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "Geometry Collection"@en ;
skos:definition "The class Geometry Collection represents any collection of individual Geometries."@en ;
rdfs:subClassOf geo:SpatialObjectCollection ;
rdfs:subClassOf [
a owl:Restriction ;
owl:allValuesFrom geo:Geometry ;
owl:onProperty rdfs:member ;
] ;
.
```
The restriction imposed on the more general <<Class: SpatialObjectCollection, Spatial Object Collection>> that defines this class is that only instances of <<Class: Geometry, Geometry>> are allowed to be members of it and these are to be indicated with the `rdfs:member` property.
[NOTE]
====
There is no RDF/ontology relationship between this `geo:GeometryCollection` class and the Simple Features Vocabulary's `sf:GeometryCollection` class since the former is a collection of `geo:Geometry` objects and the latter is to be used for compound geometry literals.
`sf:GeometryCollection` instances can act as input or output of GeoSPARQL functions whereas `geo:GeometryCollection` instances are more likely to be used for grouping `geo:Geometry` objects for other purposes.
Many geometry literal formats also have the ability to represent multiple geometries. GML & KML use a _MultiGeometry_ type and WKT & GeoJSON use a _GeometryCollection_ type. While the names of some of these objects is the same as this class' and all the concepts are similar, there is also no RDF/ontology relationship between this class and these literals. This class contains whole `geo:Geometry` instances, which may have more information within them than just a geometry serialization.
As per the expected use of `sf:GeometryCollection` instances mentioned above: the uses of multi-geometry literals and `geo:GeometryCollection` instances is expected to be different too.
====
[#req_core_geometry-collection-class]
|===
| *Req 13* Implementations shall allow the RDFS class <<Class: geo:GeometryCollection, `geo:GeometryCollection`>> to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.1/req/core/geometry-collection-class[`http://www.opengis.net/spec/geosparql/1.1/req/core/geometry-collection-class`]
|===
=== Standard Properties for geo:Geometry
Properties are defined for describing geometry metadata.
|===
| *Req 14* Implementations shall allow the properties
<<Property: geo:dimension, `geo:dimension`>>,
<<Property: geo:coordinateDimension, `geo:coordinateDimension`>>,
<<Property: geo:spatialDimension, `geo:spatialDimension`>>,
<<Property: geo:hasSpatialResolution, `geo:hasSpatialResolution`>>,
<<Property: geo:hasMetricSpatialResolution, `geo:hasMetricSpatialResolution`>>,
<<Property: geo:hasSpatialAccuracy, `geo:hasSpatialAccuracy`>>,
<<Property: geo:hasMetricSpatialAccuracy, `geo:hasMetricSpatialAccuracy`>>,
<<Property: geo:isEmpty, `geo:isEmpty`>>,
<<Property: geo:isSimple, `geo:isSimple`>> and
<<Property: geo:hasSerialization, `geo:hasSerialization`>>
to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/geometry-properties[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geometry-properties`]
|===
==== Property: geo:dimension
The property http://www.opengis.net/ont/geosparql#dimension[`geo:dimension`] is used to link the a Geometry object to its topological dimension, which must be less than or equal to the coordinate dimension. In non-homogeneous collections, this will return the largest topological dimension of the contained objects.
```turtle
geo:dimension
a rdf:Property, owl:DatatypeProperty ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "dimension"@en ;
skos:definition "The topological dimension of this geometric object, which
must be less than or equal to the coordinate dimension. In
non-homogeneous collections, this is the largest
topological dimension of the contained objects."@en ;
rdfs:domain geo:Geometry ;
rdfs:range xsd:integer ;
.
```
==== Property: geo:coordinateDimension
The property http://www.opengis.net/ont/geosparql#coordinateDimension[`geo:coordinateDimension`] is defined to link a Geometry object to the dimension of direct positions (coordinate tuples) used in the Geometry's definition.
```turtle
geo:coordinateDimension
a rdf:Property, owl:DatatypeProperty;
rdfs:isDefinedBy geo: ;
skos:prefLabel "coordinate dimension"@en ;
skos:definition "The number of measurements or axes needed to describe the
position of this Geometry in a coordinate system."@en ;
rdfs:domain geo:Geometry ;
rdfs:range xsd:integer ;
.
```
==== Property: geo:spatialDimension
The property http://www.opengis.net/ont/geosparql#spatialDimension[`geo:spatialDimension`] is defined to link a Geometry object to the dimension of the spatial portion of the direct positions (coordinate tuples) used in its serializations. If the direct positions do not carry a measure coordinate, this will be equal to the coordinate dimension.
```turtle
geo:spatialDimension
a rdf:Property, owl:DatatypeProperty;
rdfs:isDefinedBy geo: ;
skos:prefLabel "spatial dimension"@en ;
skos:definition "The number of measurements or axes needed to describe the
spatial position of this Geometry in a coordinate system."@en ;
rdfs:domain geo:Geometry ;
rdfs:range xsd:integer ;
.
```
==== Property: geo:hasSpatialResolution
The property http://www.opengis.net/ont/geosparql#hasSpatialResolution[`geo:hasSpatialResolution`] is defined to indicate spatial resolution of the elements within a Geometry. Spatial resolution specifies the level of detail of a Geometry. It the smallest dinstinghuishable distance between adjacent coordinate sets. Therefore this property is not applicable to a point Geometry, because it consists of a single coordinate set.
Since this property is defined for a <<Class: geo:Geometry, `geo:Geometry`>>, all literal representations of that Geometry instance must have the same spatial resolution.
```turtle
geo:hasSpatialResolution
a rdf:Property, owl:ObjectProperty;
rdfs:isDefinedBy geo: ;
skos:prefLabel "has spatial resolution"@en ;
skos:definition "The spatial resolution of a Geometry"@en ;
rdfs:domain geo:Geometry ;
.
```
NOTE: See the <<Recommendation for specification of units of measurement>>.
==== Property: geo:hasMetricSpatialResolution
The property http://www.opengis.net/ont/geosparql#hasMetricSpatialResolution[`geo:hasMetricSpatialResolution`] is similar to <<Property: geo:hasSpatialResolution, `geo:hasSpatialResolution`>>, specifies that the unit of resolution is always meter (the standard distance unit of the International System of Units).
```turtle
geo:hasMetricSpatialResolution
a rdf:Property, owl:ObjectProperty;
rdfs:isDefinedBy geo: ;
skos:prefLabel "has spatial resolution in meters"@en ;
skos:definition "The spatial resolution of a Geometry in meters."@en ;
rdfs:domain geo:Geometry ;
rdfs:range xsd:double ;
.
```
==== Property: geo:hasSpatialAccuracy
The property http://www.opengis.net/ont/geosparql#hasSpatialAccuracy[`geo:hasSpatialAccuracy`] is applicable when a Geometry is used to represent a Feature. It is expressed as a distance that indicates the truthfullness of the positions (coordinates) that define the Geometry. In this case accuracy defines a zone surrounding each coordinate within wich the real positions are known to be. The accuracy value defines this zone as a distance from the coordinate(s) in all directions (e.g. a line, a circle or a sphere, depending on spatial dimension).
```turtle
geo:hasSpatialAccuracy
a rdf:Property, owl:ObjectProperty;
rdfs:isDefinedBy geo: ;
skos:prefLabel "has spatial accuracy"@en ;
skos:definition "The positional accuracy of the coordinates of a Geometry."@en ;
rdfs:domain geo:Geometry ;
.
```
NOTE: See the <<Recommendation for specification of units of measurement>>.
==== Property: geo:hasMetricSpatialAccuracy
The property http://www.opengis.net/ont/geosparql#hasMetricSpatialAccuracy[`geo:hasMetricSpatialAccuracy`] is similar to <<Property: geo:hasSpatialAccuracy, has spatial accuracy>>, but it is easier to specify and use because the unit of distance is always meter (the standard distance unit of the International System of Units).
```turtle
geo:hasMetricSpatialAccuracy
a rdf:Property, owl:ObjectProperty;
rdfs:isDefinedBy geo: ;
skos:prefLabel "has spatial accuracy in meters"@en ;
skos:definition "The positional accuracy of the coordinates of a Geometry in meters."@en ;
rdfs:domain geo:Geometry ;
rdfs:range xsd:double ;
.
```
==== Property: geo:isEmpty
The property http://www.opengis.net/ont/geosparql#isEmpty[`geo:isEmpty`] will indicate a Boolean object set to `true` if and only if the Geometry contains no information.
```turtle
geo:isEmpty
a rdf:Property, owl:DatatypeProperty ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "is empty"@en ;
skos:definition "(true) if this geometric object is the empty Geometry. If
true, then this geometric object represents the empty point
set for the coordinate space."@en ;
rdfs:domain geo:Geometry ;
rdfs:range xsd:boolean ;
.
```
==== Property: geo:isSimple
The property http://www.opengis.net/ont/geosparql#isSimple[`geo:isSimple`] will indicate a Boolean object set to `true`, only if the Geometry contains no self-intersections, with the possible exception of its boundary.
```turtle
geo:isSimple
a rdf:Property, owl:DatatypeProperty ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "is simple"@en ;
skos:definition "(true) if this geometric object has no anomalous geometric
points, such as self intersection or self tangency."@en ;
rdfs:domain geo:Geometry ;
rdfs:range xsd:boolean ;
.
```
==== Property: geo:hasSerialization
The property http://www.opengis.net/ont/geosparql#hasSerialization[`geo:hasSerialization`] is defined to connect a Geometry with its text-based serialization (e.g., its WKT serialization).
```turtle
geo:hasSerialization
a rdf:Property, owl:DatatypeProperty ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "has serialization"@en ;
skos:definition "Connects a Geometry object with its text-based serialization."@en ;
rdfs:domain geo:Geometry ;
rdfs:range rdfs:Literal ;
.
```
NOTE: this property is the generic property used to connect a Geometry with its serialization. GeoSPARQL also contains a number of sub properties of this one for connecting serializations of common types with geometries, for example <<Property: geo:asGeoJSON, as GeoJSON>> which can be used for GeoJSON <<GEOJSON>> literals.
=== Geometry Serializations
This section establishes the requirements for representing Geometry data in RDF literals, according to different non-RDF systems.
GeoSPARQL presents specializations of the `geo:hasSerialization` property for indicating particular serializations and specialized datatype literals for containing them but does not provide comprehensive definitions of their content since these are given in standards external to GeoSPARQL, all of which are referenced.
GeoSPARQL does present some requirements for literal structure which extend the serialization-defining standards, for example the requirement to allow indications of spatial reference systems within WKT geometry representations.
[[NOTE]]
====
GeoSPARQL's expectation of RDF literal representations of geometry data is that it is related to the _Simple Features Access_ (SFA) <<ISO19125-1>> standard's conceptualization of geometry which defines classes such as `Point`, `Curve` and `Surface` and specialised variants of them which it presents in a hierarchy. All SFA classes are represented in OWL in the _Simple Features Vocabulary_ presented within GeoSPARQL as an independent profile element, see <<GeoSPARQL Standard structure, GeoSPARQL Standard structure>>.
Some geometry represenation systems given here do not use the same terminology as SFA, in particular the Discrete Global Grid System representation. To know the extent to which geometry literal representations listed here support SFA, or map to SFA, please see their definitions.
====
==== Well-Known Text (serialization=WKT)
This section establishes the requirements for representing Geometry data in RDF based on Well-Known Text (WKT) as defined by _Simple Features Access_ <<ISO19125-1>>. It defines one RDFS Datatype: <<RDFS Datatype: geo:wktLiteral, WKT Literal>> and one property, <<Function: geof:asWKT, as WKT>>.
===== RDFS Datatype: geo:wktLiteral
The datatype http://www.opengis.net/ont/geosparql#wktLiteral[`geo:wktLiteral`] is used to contain the Well-Known Text (WKT) serialization of a Geometry.
```turtle
geo:wktLiteral
a rdfs:Datatype ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "Well-known Text literal"@en ;
skos:definition "A Well-known Text serialization of a Geometry object."@en ;
.
```
[#req_geometry_extension_wkt-literal]
|===
| *Req 15* All RDFS Literals of type <<RDFS Datatype: geo:wktLiteral, `geo:wktLiteral`>> shall consist of an optional IRI identifying the coordinate reference system and a required Well Known Text (WKT) description of a geometric value. Valid <<RDFS Datatype: geo:wktLiteral, `geo:wktLiteral`>> instances are formed by either a WKT string as defined in <<ISO13249>> or by concatenating a valid absolute IRI, as defined in <<IETF3987>>, enclose in angled brackets (`<` & `>`) followed by a single space (Unicode U+0020 character) as a separator, and a WKT string as defined in <<ISO13249>>.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-literal[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-literal`]
|===
The following _ABNF_ <<IETF5234>> syntax specification formally defines this literal:
```
wktLiteral ::= opt-iri-and-space geometric-data
opt-iri-and-space = "<" IRI ">" LWSP / ""
```
The token `opt-iri-and-space` may be either an IRI and space or nothing (`""`), the token `IRI` (Internationalized Resource Identifier) is essentially a web address and is defined in <<IETF3987>> and the token `LWSP`, is one or more white space characters, as defined in <<IETF5234>>. `geometric-data` is the Well-Known Text representation of the Geometry, defined in <<ISO13249>>.
In the absence of a leading spatial reference system IRI, the following spatial reference system IRI will be assumed: http://www.opengis.net/def/crs/OGC/1.3/CRS84[`+<http://www.opengis.net/def/crs/OGC/1.3/CRS84>+`]. This IRI denotes WGS 84 longitude-latitude.
[#req_geometry_extension_wkt-literal-default-srs]
|===
| *Req 16* The IRI http://www.opengis.net/def/crs/OGC/1.3/CRS84[`+<http://www.opengis.net/def/crs/OGC/1.3/CRS84>+`] shall be assumed as the spatial reference system for <<RDFS Datatype: geo:wktLiteral, `geo:wktLiteral`>> instances that do not specify an explicit spatial reference system IRI.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-literal-default-srs[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-literal-default-srs`]
|===
The OGC maintains a set of SRS IRIs under the `+http://www.opengis.net/def/crs/+` namespace and IRIs from this set are recommended for use, however others may also be used, as long as they are valid IRIs.
[#req_geometry_extension_wkt-axis-order]
|===
| *Req 17* Coordinate tuples within <<RDFS Datatype: geo:wktLiteral, `geo:wktLiteral`>> shall be interpreted using the axis order defined in the spatial reference system used.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-axis-order[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-axis-order`]
|===
The example <<RDFS Datatype: geo:wktLiteral, WKT Literal>> below encodes a point Geometry using the default WGS84 geodetic longitude-latitude spatial reference system:
```turtle
"Point(-83.38 33.95)"^^<http://www.opengis.net/ont/geosparql#wktLiteral>
```
A second example below encodes the same point as encoded in the example above but using a SRS identified by http://www.opengis.net/def/SRS/EPSG/0/4326[`+http://www.opengis.net/def/SRS/EPSG/0/4326+`]: a WGS 84 geodetic latitude-longitude spatial reference system (note that this spatial reference system defines a different axis order):
```turtle
"<http://www.opengis.net/def/crs/EPSG/0/4326> Point(33.95 -83.38)"^^<http://www.opengis.net/ont/geosparql#wktLiteral>
```
[#req_geometry_extension_wkt-literal-empty]
|===
| *Req 18* An empty RDFS Literal of type <<RDFS Datatype: geo:wktLiteral, `geo:wktLiteral`>> shall be interpreted as an empty Geometry.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-literal-empty[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/wkt-literal-empty`]
|===
===== Property: geo:asWKT
The property http://www.opengis.net/ont/geosparql#asWKT[`geo:asWKT`] is defined to link a Geometry with its WKT serialization.
[#req_geometry_extension_geometry-as-wkt-literal]
|===
| *Req 19* Implementations shall allow the RDF property <<Property: geo:asWKT, `geo:asWKT`>> to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/geometry-as-wkt-literal[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/geometry-as-wkt-literal`]
|===
```turtle
geo:asWKT
a rdf:Property, owl:DatatypeProperty ;
rdfs:subPropertyOf geo:hasSerialization ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "as WKT"@en ;
skos:definition "The WKT serialization of a Geometry."@en ;
rdfs:domain geo:Geometry ;
rdfs:range geo:wktLiteral ;
.
```
===== Function: geof:asWKT
```
geof:asWKT (geom: ogc:geomLiteral): geo:wktLiteral
```
The function http://www.opengis.net/def/function/geosparql/asWKT[`geof:asWKT`] converts `geom` to an equivalent WKT representation preserving the coordinate reference system.
[#req_geometry_extension_asWKT-function]
|===
| *Req 20* Implementations shall support <<Property: geo:asWKT, `geo:asWKT`>> as a SPARQL extension function.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asWKT-function[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asWKT-function`]
|===
==== Geography Markup Language (serialization=GML)
This section establishes requirements for representing Geometry data in RDF based on GML as defined by Geography Markup Language Encoding Standard <<OGC07-036>>. It defines one RDFS Datatype:
<<RDFS Datatype: geo:gmlLiteral, GML Literal>> and one property, <<Function: geof:asGML, as GML>>.
===== RDFS Datatype: geo:gmlLiteral
The datatype http://www.opengis.net/ont/geosparql#gmlLiteral[`geo:gmlLiteral`] is used to contain the Geography Markup Language (GML) serialization of a Geometry.
```turtle
geo:gmlLiteral
a rdfs:Datatype ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "GML literal"@en ;
skos:definition "The datatype of GML literal values"@en ;
.
```
Valid <<RDFS Datatype: geo:gmlLiteral, GML Literal>> instances are formed by encoding Geometry information as a valid element from the GML schema that implements a subtype of `GM_Object`. For example, in GML 3.2.1 this is every element directly or indirectly in the substitution group of the element `{http://www.opengis.net/ont/gml/3.2}AbstractGeometry`. In GML 3.1.1 and GML 2.1.2 this is every element directly or indirectly in the substitution group of the element `{http://www.opengis.net/ont/gml}_Geometry`.
[#req_geometry_extension_gml-literal]
|===
| *Req 21* All <<RDFS Datatype: geo:gmlLiteral, `geo:gmlLiteral`>> instances shall consist of a valid element from the GML schema that implements a subtype of `GM_Object` as defined in <<OGC07-036>>.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/gml-literal[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/gml-literal`]
|===
The example <<RDFS Datatype: geo:gmlLiteral, GML Literal>> below encodes a point Geometry in the WGS 84 geodetic longitude-latitude spatial reference system using GML version 3.2:
```turtle
"""
<gml:Point
srsName=\"http://www.opengis.net/def/crs/OGC/1.3/CRS84\"
xmlns:gml=\"http://www.opengis.net/ont/gml\">
<gml:pos>-83.38 33.95</gml:pos>
</gml:Point>
"""^^<http://www.opengis.net/ont/geosparql#gmlLiteral>
```
[#req_geometry_extension_gml-literal-empty]
|===
| *Req 22* An empty <<RDFS Datatype: geo:gmlLiteral, `geo:gmlLiteral`>> shall be interpreted as an empty Geometry.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/gml-literal-empty[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/gml-literal-empty`]
|===
[#req_geometry_extension_gml-profile]
|===
| *Req 23* Implementations shall document supported GML profiles.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/gml-profile[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/gml-profile`]
|===
===== Property: geo:asGML
The property http://www.opengis.net/ont/geosparql#asGML[`geo:asGML`] is defined to link a Geometry with its GML serialization.
[#req_geometry_extension_geometry-as-gml-literal]
|===
| *Req 24* Implementations shall allow the RDF property <<Property: geo:asGML, `geo:asGML`>> to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/geometry-as-gml-literal[`http://www.opengis.net/spec/geosparql/1.0/req/geometry-extension/geometry-as-gml-literal`]
|===
```turtle
geo:asGML
a rdf:Property ;
rdfs:subPropertyOf geo:hasSerialization ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "as GML"@en ;
skos:definition "The GML serialization of a Geometry."@en ;
rdfs:domain geo:Geometry ;
rdfs:range geo:gmlLiteral ;
.
```
===== Function: geof:asGML
```
geof:asGML (geom: ogc:geomLiteral, gmlProfile: xsd:string): geo:gmlLiteral
```
The function http://www.opengis.net/def/function/geosparql/asGML[`geof:asGML`] converts `geom` to an equivalent GML representation defined by a gmlProfile version string preserving the coordinate reference system.
[#req_geometry_extension_asGML-function]
|===
| *Req 25* Implementations shall support <<Function: geof:asGML, `geof:asGML`>> as a SPARQL extension function.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asGML-function[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asGML-function`]
|===
==== GeoJSON (serialization=GEOJSON)
This section establishes requirements for representing Geometry data in RDF based on GeoJSON as defined by <<GeoJSON>>. It defines one RDFS Datatype:
<<RDFS Datatype: geo:geoJSONLiteral, GeoJSON Literal>> and one property, <<Function: geof:asGeoJSON, as GeoJSON>>.
===== RDFS Datatype: geo:geoJSONLiteral
The datatype http://www.opengis.net/ont/geosparql#gmlLiteral[`geo:geoJSONLiteral`] is used to contain the Geo JavaScript Object Notation (GeoJSON) serialization of a Geometry.
```turtle
geo:geoJSONLiteral a rdfs:Datatype ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "GeoJSON Literal"@en ;
skos:definition "A GeoJSON serialization of a Geometry object."@en .
```
Valid <<RDFS Datatype: geo:geoJSONLiteral, GeoJSON Literal>> instances are formed by encoding Geometry information as a Geometry object as defined in the GeoJSON specification <<GEOJSON>>.
[#req_geometry_extension_geojson-literal]
|===
| *Req 26* All <<RDFS Datatype: geo:geoJSONLiteral, `geo:geoJSONLiteral`>> instances shall consist of the Geometry objects as defined in the GeoJSON specification <<GEOJSON>>.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geojson-literal[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geojson-literal`]
|===
[#req_geometry_extension_geojson-literal-srs]
|===
| *Req 27* RDFS Literals of type <<RDFS Datatype: geo:geoJSONLiteral, `geo:geoJSONLiteral`>> do not contain a SRS definition. All literals of this type shall, according to the GeoJSON specification, be encoded only in, and be assumed to use, the WGS84 geodetic longitude-latitude spatial reference system (http://www.opengis.net/def/crs/OGC/1.3/CRS84[`http://www.opengis.net/def/crs/OGC/1.3/CRS84`]).
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geojson-literal-srs[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geojson-literal-srs`]
|===
The example <<RDFS Datatype: geo:geoJSONLiteral, GeoJSON Literal>> below encodes a point Geometry using the default WGS84 geodetic longitude-latitude spatial reference system for Simple Features 1.0:
```turtle
"""
{"type": "Point", "coordinates": [-83.38,33.95]}
"""^^<http://www.opengis.net/ont/geosparql#geoJSONLiteral>
```
[#req_geometry_extension_geojson-literal-empty]
|===
| *Req 28* An empty RDFS Literal of type <<RDFS Datatype: geo:geoJSONLiteral, `geo:geoJSONLiteral`>> shall be interpreted as an empty Geometry, i.e. `{"geometry": null}` in GeoJSON .
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geojson-literal-empty[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geojson-literal-empty`]
|===
===== Property: geo:asGeoJSON
The property http://www.opengis.net/ont/geosparql#asGeoJSON[`geo:asGeoJSON`] is defined to link a Geometry with its GeoJSON serialization.
[#req_geometry_extension_geojson-as-geojson-literal]
|===
| *Req 29* Implementations shall allow the RDF property <<Property: geo:asGeoJSON, `geo:asGeoJSON`>> to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geometry-as-geojson-literal[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geometry-as-geojson-literal`]
|===
```turtle
geo:asGeoJSON
a rdf:Property, owl:DatatypeProperty ;
rdfs:subPropertyOf geo:hasSerialization ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "as GeoJSON"@en ;
skos:definition "The GeoJSON serialization of a Geometry."@en ;
rdfs:domain geo:Geometry ;
rdfs:range geo:geoJSONLiteral ;
.
```
===== Function: geof:asGeoJSON
```
geof:asGeoJSON (geom: ogc:geomLiteral): geo:geoJSONLiteral
```
The function http://www.opengis.net/def/function/geosparql/asGeoJSON[`geof:asGeoJSON`] converts `geom` to an equivalent GeoJSON representation. Coordinates are converted to the CRS84 coordinate system, the only valid coordinate system to be used in a GeoJSON literal.
[#req_geometry_extension_asGeoJSON-function]
|===
| *Req 30* Implementations shall support <<Function: geof:asGeoJSON, `geof:asGeoJSON`>> as a SPARQL extension function.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asGeoJSON-function[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asGeoJSON-function`]
|===
==== Keyhole Markup Language (serialization=KML)
This section establishes requirements for representing Geometry data in RDF based on KML as defined by <<OGCKML>>. It defines one RDFS Datatype:
<<RDFS Datatype: geo:kmlLiteral, KML Literal>> and one property, <<Function: geof:asKML, as KML>>.
===== RDFS Datatype: geo:kmlLiteral
The datatype http://www.opengis.net/ont/geosparql#kmlLiteral[`geo:kmlLiteral`] is used to contain the Keyhole Markup Language (KML) serialization of a Geometry.
```turtle
geo:kmlLiteral
a rdfs:Datatype ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "KML Literal"@en ;
skos:definition "A KML serialization of a Geometry object."@en ;
.
```
Valid <<RDFS Datatype: geo:kmlLiteral, KML Literal>> instances are formed by encoding Geometry information as a Geometry object as defined in the KML specification <<OGCKML>>.
[#req_geometry_extension_kml-literal]
|===
| *Req 31* All <<RDFS Datatype: geo:kmlLiteral, `geo:kmlLiteral`>> instances shall consist of the Geometry objects as defined in the KML specification <<OGCKML>>.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/kml-literal[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/kml-literal`]
|===
[#req_geometry_extension_kml-literal-srs]
|===
| *Req 32* RDFS Literals of type <<RDFS Datatype: geo:kmlLiteral, `geo:kmlLiteral`>> do not contain a SRS definition. All literals of this type shall according to the KML specification only be encoded in and assumed to use the WGS84 geodetic longitude-latitude spatial reference system (http://www.opengis.net/def/crs/OGC/1.3/CRS84[`http://www.opengis.net/def/crs/OGC/1.3/CRS84`]).
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/kml-literal-srs[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/kml-literal-srs`]
|===
The example <<RDFS Datatype: geo:kmlLiteral, KML Literal>> below encodes a point Geometry using the default WGS84 geodetic longitude-latitude spatial reference system for Simple Features 1.0:
```turtle
"""
<Point xmlns=\"http://www.opengis.net/kml/2.2\">
<coordinates>-83.38,33.95</coordinates>
</Point>
"""^^<http://www.opengis.net/ont/geosparql#kmlLiteral>
```
[#req_geometry_extension_kml-literal-empty]
|===
| *Req 33* An empty RDFS Literal of type <<RDFS Datatype: geo:kmlLiteral, `geo:kmlLiteral`>> shall be interpreted as an empty Geometry .
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/kml-literal-empty[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/kml-literal-empty`]
|===
===== Property: geo:asKML
The property http://www.opengis.net/ont/geosparql#asKML[`geo:asKML`] is defined to link a Geometry with its KML serialization.
[#req_geometry_extension_as-kml-literal]
|===
| *Req 34* Implementations shall allow the RDF property <<Property: geo:asKML, `geo:asKML`>> to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geometry-as-kml-literal[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geometry-as-kml-literal`]
|===
The property <<Property: geo:asKML, as KML>> is used to link a geometric element with its KML serialization.
```turtle
geo:asKML
a rdf:Property, owl:DatatypeProperty;
rdfs:subPropertyOf geo:hasSerialization ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "as KML"@en ;
skos:definition "The KML serialization of a Geometry."@en ;
rdfs:domain geo:Geometry ;
rdfs:range geo:kmlLiteral ;
.
```
===== Function: geof:asKML
```
geof:asKML (geom: ogc:geomLiteral): geo:kmlLiteral
```
The function http://www.opengis.net/def/function/geosparql/asKML[`geof:asKML`] converts `geom` to an equivalent KML representation. Coordinates are converted to the CRS84 coordinate system, the only valid coordinate system to be used in a KML literal.
[#req_geometry_extension_asKML-function]
|===
| *Req 35* Implementations shall support <<Function: geof:asKML, `geof:asKML`>> as a SPARQL extension function.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asKML-function[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asKML-function`]
|===
==== Discrete Global Grid System (serialization=DGGS)
This section establishes the requirements for representing Discrete Global Grid System (DGGS) Geometry data as RDF literals. The form of representation is specific to individual DGGS implementations: known DGGSes are not compatible or even very similar.
Here is defined one RDFS Datatypes:
http://www.opengis.net/ont/geosparql#dggsLiteral[`+http://www.opengis.net/ont/geosparql#dggsLiteral+`] and one property, http://www.opengis.net/ont/geosparql#asDGGS[`+http://www.opengis.net/ont/geosparql#asDGGS+`].
NOTE: The datatype defined here is for an abstract DGGS implementation (<<RDFS Datatype: geo:dggsLiteral, DGGS Literal>>) but concrete ones should be used in real implementations. For example, the AusPIX DGGS <<AUSPIX>> might implement something similar to `ex:auspixDggsLiteral`.
===== RDFS Datatype: geo:dggsLiteral
The datatype http://www.opengis.net/ont/geosparql#dggsLiteral[`geo:dggsLiteral`] is used to contain the Discrete Global Grid System (DGGS) serialization of a Geometry.
```turtle
geo:dggsLiteral
a rdfs:Datatype ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "DGGS Literal"@en ;
skos:definition "A textual serialization of a Discrete Global Grid System (DGGS) Geometry object."@en
.
```
Valid <<RDFS Datatype: geo:dggsLiteral, DGGS Literal>> instances are formed by encoding Geometry information according to specific DGGS implementation. The specific implementation should be indicated by use of a subclass of the `geo:dggsLiteral` datatype.
[#req_geometry_extension_dggs-literal]
|===
| *Req 36* All RDFS Literals of type <<RDFS Datatype: geo:dggsLiteral, `geo:dggsLiteral`>> shall consist of a DGGS Geometry serialization formulated according to a specific DGGS.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/dggs-literal[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/dggs-literal`]
|===
[#req_geometry_extension_dggs-literal-empty]
|===
| *Req 37* An empty RDFS Literal of type <<RDFS Datatype: geo:dggsLiteral, `geo:dggsLiteral`>>, or one of its data subtypes, shall be interpreted as an empty `geo:Geometry`.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/dggs-literal-empty[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/dggs-literal-empty`]
|===
An example of a literal for concrete DGGS, AusPIX, could be
```turtle
ex:auspixDggsLiteral
a rdfs:Datatype ;
skos:prefLabel "AusPIX DGGS Literal"@en ;
skos:definition "A textual serialization of an AusPIX Discrete Global Grid System (DGGS) Geometry object."@en ;
.
```
A single _Cell_ Geometry encoded according to the AusPIX DGGS using the example literal above is given below. The single cell value of _R3234_ is analogous to either a `Point` or simple `Polygon` in WKT geometries.
```turtle
"CellList (R3234)"^^<http://example.com#auspixDggsLiteral>
```
NOTE: What `R3234` means, or the meaning of any other element within a concrete DGGS literal is not handled by GeoSPARQL but is expected to be handled by that DGGS' specification, just as GeoPSARQL does not delve into the internals of other Geometry formats such as WKT or GeoJSON.
===== Property: geo:asDGGS
The property http://www.opengis.net/ont/geosparql#asDGGS[`geo:asDGGS`] is defined to link a Geometry with its DGGS serialization.
[#req_geometry_extension_geometry-as-dggs-literal]
|===
| *Req 38* Implementations shall allow the RDF property
<<Property: geo:asDGGS, `geo:asDGGS`>>
to be used in SPARQL graph patterns.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geometry-as-dggs-literal[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/geometry-as-dggs-literal`]
|===
```turtle
geo:asDGGS
a rdf:Property, owl:DatatypeProperty ;
rdfs:subPropertyOf geo:hasSerialization ;
rdfs:isDefinedBy geo: ;
skos:prefLabel "as DGGS"@en ;
skos:definition "A DGGS serialization of a Geometry."@en ;
rdfs:domain geo:Geometry ;
rdfs:range geo:dggsLiteral ;
.
```
NOTE: It is expected that this property will be used to indicate specific DGGS data types, such as the example `ex:auspixDggsLiteral`, described above, as opposed to the generic <<RDFS Datatype: geo:dggsLiteral, DGGS Literal>>.
===== Function: geof:asDGGS
```
geof:asDGGS (geom: ogc:geomLiteral, specificDggsDatatype: xsd:anyURI): geo:DggsLiteral
```
The function http://www.opengis.net/def/function/geosparql/asDGGS[`geof:asDGGS`] converts `geom` to an equivalent DGGS representation, formulated according to the specific DGGS literal indicated using the `specificDggsDatatype` parameter.
[#req_geometry_extension_asDGGS-function]
|===
| *Req 39* Implementations shall support <<Function: geof:asDGGS, `geof:asDGGS`>> as a SPARQL extension function.
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asDGGS-function[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/asDGGS-function`]
|===
=== Non-topological Query Functions
This clause defines SPARQL functions for performing non-topological spatial operations.
[#req_geometry_extension_query-functions]
|===
| *Req 40* Implementations shall support the functions
<<Function: geof:boundary, `geof:boundary`>>
<<Function: geof:metricBuffer, `geof:metricBuffer`>>,
<<Function: geof:buffer, `geof:buffer`>>,
<<Function: geof:convexHull, `geof:convexHull`>>,
<<Function: geof:coordinateDimension, `geof:coordinateDimension`>>,
<<Function: geof:difference, `geof:difference`>>,
<<Function: geof:dimension, `geof:dimension`>>,
<<Function: geof:metricDistance, `geof:metricDistance`>>,
<<Function: geof:distance, `geof:distance`>>,
<<Function: geof:envelope, `geof:envelope`>>,
<<Function: geof:geometryType, `geof:geometryType`>>,
<<Function: geof:getSRID, `geof:getSRID`>>,
<<Function: geof:intersection, `geof:intersection`>>,
<<Function: geof:is3D, `geof:is3D`>>,
<<Function: geof:isEmpty, `geof:isEmpty`>>,
<<Function: geof:isMeasured, `geof:isMeasured`>>,
<<Function: geof:isSimple, `geof:isSimple`>>,
<<Function: geof:spatialDimension, `geof:spatialDimension`>>,
<<Function: geof:symDifference, `geof:symDifference`>>,
<<Function: geof:transform, `geof:transform`>> and
<<Function: geof:union, `geof:union`>>
as SPARQL extension functions, consistent with definitions of these functions in Simple Features <<ISO19125-1>>, for non-DGGS geometry literals
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions`]
|===
|===
| *Req 41* Implementations shall support the functions
<<Function: geof:area, `geof:area`>>,
<<Function: geof:geometryN, `geof:geometryN`>>,
<<Function: geof:length, `geof:length`>>,
<<Function: geof:maxX, `geof:maxX`>>,
<<Function: geof:maxY, `geof:maxY`>>,
<<Function: geof:maxZ, `geof:maxZ`>>,
<<Function: geof:minX, `geof:minX`>>,
<<Function: geof:minY, `geof:minY`>>,
<<Function: geof:minZ, `geof:minZ`>>,
<<Function: geof:numGeometries, `geof:numGeometries`>> and
<<Function: geof:projectTo, `geof:projectTo`>>,
as SPARQL extension functions which are defined in this standard, for non-DGGS geometry literals
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions-non-sf[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions-non-sf`]
|===
NOTE: The requirements to support non-topological query functions for DGGS geometry literals are separated from the requirements to support them for traditional
geometry literals as it is expected that implementing these functions for DGGS literals will be significantly more difficult. This is due to the novelty of DGGS
literals and thus the lack of existing software libraries for their manipulation.
|===
| *Req 42* Implementations shall support the functions of Requirement 40 for DGGS geometry literals
as SPARQL extension functions, consistent with definitions of these functions in Simple Features <<ISO19125-1>>, for non-DGGS geometry literals
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions-dggs[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions-dggs`]
|===
|===
| *Req 43* Implementations shall support the functions of Requirement 41 for DGGS geometry literals
as SPARQL extension functions which are defined in this standard, for non-DGGS geometry literals
|http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions-non-sf-dggs[`http://www.opengis.net/spec/geosparql/1.1/req/geometry-extension/query-functions-non-sf-dggs`]
|===
Functions from both requirements above are listed below, alphabetically.
==== Function notes
These notes apply to all of the following functions in this section.
An invocation of any of the following functions with invalid arguments produces an error. An invalid argument includes any of the following:
* An argument of an unexpected type
* An invalid geometry literal value
* An non-fitting geometry type for the given function
* A geometry literal from a spatial reference system that is incompatible with the spatial reference system used for calculations
* An invalid units IRI
A more detailed description of expected inputs and expected outputs of the given functions is shown in Annex B.
Unless otherwise stated in the function definition, the following behaviors should be followed by all SPARQL extension functions defined in the GeoSPARQL standard:
* Functions returning a new geometry literal should follow the literal format of the first geometry literal input parameter. If no geometry literal input parameter is present, a WKT literal shall be returned
* Functions returning a new geometry literal should follow the SRS defined in the literal format of the first geometry literal input parameter. If no geometry literal input parameter is present, a geometry result should be returned in the CRS84 coordinate reference system
For further discussion of the effects of errors during FILTER evaluation, consult Section 17footnote:[<https://www.w3.org/TR/sparql11-query/#expressions>] of the SPARQL specification <<SPARQL>>.
Note that returning values instead of raising an error serves as an extension mechanism of SPARQL.
From Section 17.3.1footnote:[<https://www.w3.org/TR/sparql11-query/#operatorExtensibility>] of the SPARQL specification <<SPARQL>>:
[quote]
SPARQL language extensions may provide additional associations between operators and operator functions; ... No additional operator may yield a result that replaces any result other ... . The consequence of this rule is that SPARQL `FILTER` s will produce at least the same intermediate bindings after applying a `FILTER` as an unextended implementation.
This extension mechanism enables GeoSPARQL implementations to simultaneously support multiple geometry serializations. For example, a system that supports <<RDFS Datatype: geo:wktLiteral, WKT Literal>> serializations may also support <<RDFS Datatype: geo:gmlLiteral, GML Literal>> serializations and consequently would not raise an error if it encounters multiple geometry datatypes while processing a given query.
NOTE: Several non-topological query functions use a unit of measure IRI. The OGC has recommended units of measure vocabularies for use, see the OGC Definitions Serverfootnote:[https://www.ogc.org/def-server].
==== Function: geof:area
```
geof:area (geom1: ogc:geomLiteral): xsd:double
```
Returns the area of `geom1` in square meters. Must return zero for all geometry types other than Polygon.
==== Function: geof:boundary
```
geof:boundary (geom1: ogc:geomLiteral): ogc:geomLiteral
```
This function returns the closure of the boundary of `geom1`. Calculations are in the spatial reference system of `geom1`.
==== Function: geof:metricBuffer
```
geof:metricBuffer (geom: ogc:geomLiteral,
radius: xsd:double): ogc:geomLiteral
```
Returns a geometric object that represents all Points whose distance from `geom` is less than or equal to the `radius` measured in meters. Calculations are in the coordinate reference system of `geom`. This function is similar to <<Function: geof:buffer, `geof:buffer`>>, but does not need a specification of distance unit.
==== Function: geof:buffer
```
geof:buffer (geom: ogc:geomLiteral,
radius: xsd:double,
units: xsd:anyURI): ogc:geomLiteral
```
Returns a geometric object that represents all Points whose distance from `geom` is less than or equal to the `radius` measured in `units`. Calculations are in the spatial reference system of `geom`. This function is similar to <<Function: geof:metricBuffer, `geof:metricBuffer`>>, which does not need a specification of distance unit.
NOTE: See the <<Recommendation for specification of units of measurement, Recommendation for specification of units of measurement>>.
==== Function: geof:convexHull
```
geof:convexHull (geom: ogc:geomLiteral): ogc:geomLiteral
```
The function http://www.opengis.net/def/function/geosparql/convexHull[`geof:convexHull`] returns a geometric object that represents all Points in the convex hull of `geom1`. Calculations are in the spatial reference system of `geom`.
==== Function: geof:coordinateDimension
```
geof:coordinateDimension (geom1: ogc:geomLiteral): xsd:integer
```
Returns the coordinate dimension of `geom1`.
==== Function: geof:difference
```
geof:difference (geom1: ogc:geomLiteral,
geom2: ogc:geomLiteral): ogc:geomLiteral
```
This function returns a geometric object that represents all Points in the set difference of `geom1` with `geom2`. Calculations are in the spatial reference system of `geom1`.
==== Function: geof:dimension
```
geof:dimension (geom1: ogc:geomLiteral): xsd:integer
```
Returns the dimension of `geom1`. In non-homogeneous geometry collections, this will return the largest topological dimension of the contained objects.
==== Function: geof:metricDistance
```
geof:metricDistance (geom1: ogc:geomLiteral,
geom2: ogc:geomLiteral): xsd:double
```
Returns the shortest distance in meters between any two Points in the two geometric objects. Calculations are in coordinate reference system of `geom1`. This function is similar to <<Function: geof:distance, `geof:distance`>>, but does not need a specification of distance unit.
==== Function: geof:distance
```
geof:distance (geom1: ogc:geomLiteral,
geom2: ogc:geomLiteral,
units: xsd:anyURI): xsd:double
```
Returns the shortest distance in `units` between any two Points in the two geometric objects. Calculations are in spatial reference system of `geom1`. This function is similar to <<Function: geof:metricDistance, `geof:metricDistance`>>, which does not need a specification of distance unit.
NOTE: See the <<Recommendation for specification of units of measurement, Recommendation for specification of units of measurement>>.
==== Function: geof:envelope
```
geof:envelope (geom1: ogc:geomLiteral): ogc:geomLiteral
```
This function returns the minimum bounding box - a rectangle - of `geom1`. Calculations are in the spatial reference system of `geom1`.
==== Function: geof:geometryN
```
geof:geometryN (geom1: ogc:geomLiteral): xsd:integer
```
Returns the nth geometry of `geom1` if it is a GeometryCollection or `geom1` if it is a Geometry.
==== Function: geof:geometryType
```
geof:geometryType (geom1: ogc:geomLiteral): xsd:anyURI
```
Returns the URI of the subtype of Geometry of which this geometric object is an member. No attempt to reconcile different geometry subtypes across all support literals need be made.
==== Function: geof:getSRID
```
geof:getSRID (geom: ogc:geomLiteral): xsd:anyURI
```
Returns the spatial reference system IRI for `geom`.
==== Function: geof:intersection
```
geof:intersection (geom1: ogc:geomLiteral,
geom2: ogc:geomLiteral): ogc:geomLiteral
```
Returns a geometric object that represents all Points in the intersection of `geom1` with `geom2`. Calculations are in the spatial reference system of `geom1`.
==== Function: geof:is3D
```
geof:is3D (geom1: ogc:geomLiteral): xsd:boolean
```
Returns true if `geom1` has z coordinate values.
==== Function: geof:isEmpty