File: ogr_arch.dox

package info (click to toggle)
gdal 2.4.2+dfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye
  • size: 106,252 kB
  • sloc: cpp: 1,034,818; ansic: 177,912; python: 23,610; perl: 7,420; sh: 6,283; java: 5,382; xml: 3,100; cs: 2,343; yacc: 1,198; makefile: 519; sql: 112
file content (255 lines) | stat: -rw-r--r-- 12,129 bytes parent folder | download | duplicates (6)
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
/*! \page ogr_arch OGR Architecture

This document is intended to document the OGR classes.  The OGR
classes are intended to be generic (not specific to OLE DB or COM or
Windows) but are used as a foundation for implementing OLE DB Provider
support, as well as client side support for SFCOM.  It is intended that
these same OGR classes could be used by an implementation of SFCORBA
for instance or used directly by C++ programs wanting to use an OpenGIS
simple features inspired API.<p>

Because OGR is modeled on the OpenGIS simple features data model, it is
very helpful to review the SFCOM, or other simple features interface
specifications which can be retrieved from the
<a href="http://www.opengeospatial.org">Open Geospatial Consortium</a> web site.  Data
types, and method names are modeled on those from the interface
specifications.<p>

\section ogr_arch_overview Class Overview

<ul>
<li> <b>Geometry</b> (<a href="ogr__geometry_8h_source.html">ogr_geometry.h</a>):
The geometry classes (OGRGeometry, etc) encapsulate the OpenGIS model vector
data as well as providing some geometry operations, and translation to/from
well known binary and text format.  A geometry includes a spatial reference
system (projection).<p>

<li> <b>Spatial Reference</b>
(<a href="ogr__spatialref_8h_source.html">ogr_spatialref.h</a>):
An OGRSpatialReference encapsulates the definition of a projection and
datum.<p>

<li> <b>Feature</b> (<a href="ogr__feature_8h_source.html">ogr_feature.h</a>):
The OGRFeature encapsulates the definition of a whole feature, that is a
geometry and a set of attributes.<p>

<li> <b>Feature Class Definition</b>
(<a href="ogr__feature_8h_source.html">ogr_feature.h</a>):
The OGRFeatureDefn class captures the schema (set of field definitions) for
a group of related features (normally a whole layer).<p>

<li> <b>Layer</b>
(<a href="ogrsf__frmts_8h_source.html">ogrsf_frmts.h</a>):
OGRLayer is an abstract base class represent a layer of features in an
GDALDataset.<p>

<li> <b>Dataset</b>
(<a href="gdal__priv_8h_source.html">gdal_priv.h</a>):
A GDALDataset is an abstract base class
representing a file or database containing one or more OGRLayer
objects.<p>

<li> <b>Drivers</b>
(<a href="gdal__priv_8h_source.html">gdal_priv.h</a>):
A GDALDriver represents a translator for a specific
format, opening GDALDataset objects.  All available drivers are managed
by the GDALDriverManager.<p>

</ul>

\section ogr_arch_geometry Geometry

The geometry classes are represent various kinds of vector geometry.  All
the geometry classes derived from OGRGeometry which defines the common
services of all geometries.  Types of geometry include OGRPoint, OGRLineString,
OGRPolygon, OGRGeometryCollection, OGRMultiPolygon, OGRMultiPoint,
and OGRMultiLineString.

GDAL 2.0 extends those geometry type with non-linear geometries with the
OGRCircularString, OGRCompoundCurve, OGRCurvePolygon, OGRMultiCurve and
OGRMultiSurface classes.

Additional intermediate abstract base classes contain functionality that
could eventually be implemented by other geometry types.  These include
OGRCurve (base class for OGRLineString) and OGRSurface (base class for
OGRPolygon).  Some intermediate interfaces modeled in the simple features
abstract model and SFCOM are not modeled in OGR at this time.  In most
cases the methods are aggregated into other classes.<p>

The OGRGeometryFactory is used to convert well known text, and well known
binary format data into geometries.  These are predefined ASCII and binary
formats for representing all the types of simple features geometries.<p>

In a manner based on the geometry object in SFCOM, the OGRGeometry includes
a reference to an OGRSpatialReference object, defining the spatial reference
system of that geometry.  This is normally a reference to a shared
spatial reference object with reference counting for each of the
OGRGeometry objects using it.<p>

Many of the spatial analysis methods (such as computing overlaps and so
forth) are not implemented at this time for OGRGeometry.<p>

While it is theoretically possible to derive other or more specific
geometry classes from the existing OGRGeometry classes, this isn't an
aspect that has been well thought out.  In particular, it would be
possible to create specialized classes using the OGRGeometryFactory without
modifying it.<p>

\subsection ogr_arch_geometry_compat_curves Compatibility issues with GDAL 2.0 non-linear geometries

Generic mechanisms have been introduced so that creating or modifying a feature
with a non-linear geometry in a layer of a driver that does not support it will
transform that geometry in the closest matching linear geometry.

On the other side, when retrieving data from the OGR C API, the OGRSetNonLinearGeometriesEnabledFlag()
function can be used, so that geometries and layer geometry type returned are
also converted to their linear approximation if necessary.

\section ogr_arch_srs Spatial Reference

The OGRSpatialReference class is intended to store an OpenGIS Spatial
Reference System definition.  Currently local, geographic and projected
coordinate systems are supported.  Vertical coordinate systems, geocentric
coordinate systems, and compound (horizontal + vertical) coordinate systems
are as well supported in recent GDAL versions.<p>

The spatial coordinate system data model is inherited from the OpenGIS
<b>Well Known Text</b> format.  A simple form of this is defined in the
Simple Features specifications.  A more sophisticated form is found in
the Coordinate Transformation specification.  The OGRSpatialReference is
built on the features of the Coordinate Transformation specification but
is intended to be compatible with the earlier simple features form.<p>

There is also an associated OGRCoordinateTransformation class that
encapsulates use of PROJ.4 for converting between different coordinate
systems.  There is a <a href="osr_tutorial.html">tutorial</a> available
describing how to use the OGRSpatialReference class.<p>

\section ogr_arch_feature Feature / Feature Definition

The OGRGeometry captures the geometry of a vector feature ... the
spatial position/region of a feature.  The OGRFeature contains this
geometry, and adds feature attributes, feature id,
and a feature class identifier. Starting with OGR 1.11,
<a href="http://trac.osgeo.org/gdal/wiki/rfc41_multiple_geometry_fields">
several geometries</a> can be associated to a OGRFeature.<p>

The set of attributes, their types, names and so forth is represented
via the OGRFeatureDefn class.  One OGRFeatureDefn normally exists for a
layer of features.  The same definition is shared in a reference counted
manner by the feature of that type (or feature class).<p>

The feature id (FID) of a feature is intended to be a unique identifier for
the feature within the layer it is a member of.  Freestanding features, or
features not yet written to a layer may have a null (OGRNullFID) feature id.
The feature ids are modeled in OGR as a 64-bit integer (GDAL 2.0 or later);
however, this is not sufficiently expressive to model the natural feature ids in some
formats.  For instance, the GML feature id is a string.<p>

The feature class
also contains an indicator of the types of geometry allowed for that feature
class (returned as an OGRwkbGeometryType from OGRFeatureDefn::GetGeomType()).
If this is wkbUnknown then any type of geometry is allowed.  This implies that
features in a given layer can potentially be of different geometry types
though they will always share a common attribute schema. <p>

Starting with OGR 1.11, several geometry fields can be associated to a feature
class. Each geometry field has its own indicator of geometry type allowed,
returned by OGRGeomFieldDefn::GetType(), and its spatial reference system,
returned by OGRGeomFieldDefn::GetSpatialRef().

The OGRFeatureDefn also contains a feature class name (normally
used as a layer name).<p>


\section ogr_arch_layer Layer

An OGRLayer represents a layer of features within a data source.  All
features in an OGRLayer share a common schema and are of the same
OGRFeatureDefn.  An OGRLayer class also contains methods for reading
features from the data source.
The OGRLayer can be thought of as a gateway for reading and
writing features from an underlying data source, normally a file format.
In SFCOM and other table based simple features implementation an OGRLayer
represents a spatial table.<p>

The OGRLayer includes methods for sequential and random reading and writing.
Read access (via the
OGRLayer::GetNextFeature() method) normally reads all features, one at a
time sequentially; however, it can be limited to return features intersecting
a particular geographic region by installing a spatial filter on the
OGRLayer (via the OGRLayer::SetSpatialFilter() method).<p>

One flaw in the
current OGR architecture is that the spatial filter is set directly on
the OGRLayer which is intended to be the only representative of a given
layer in a data source.  This means it isn't possible to have multiple
read operations active at one time with different spatial filters on
each.  This aspect may be revised in the future to introduce an OGRLayerView
class or something similar.<p>

Another question that might arise is why the OGRLayer and OGRFeatureDefn
classes are distinct.  An OGRLayer always has a one-to-one relationship to
an OGRFeatureDefn, so why not amalgamate the classes.  There are two reasons:

<ol>

<li> As defined now OGRFeature and OGRFeatureDefn don't depend on OGRLayer,
so they can exist independently in memory without regard to a particular
layer in a data store. <p>

<li> The SF CORBA model does not have a concept of a layer with a single
fixed schema the way that the SFCOM and SFSQL models do.  The fact that
features belong to a feature collection that is potentially not directly
related to their current feature grouping may be important to implementing
SFCORBA support using OGR.

</ol>

The OGRLayer class is an abstract base class.  An implementation is
expected to be subclassed for each file format driver implemented.
OGRLayers are normally owned directly by their GDALDataset, and aren't
instantiated or destroyed directly.<p>

\section ogr_arch_dataset Dataset

A GDALDataset represents a set of OGRLayer objects.  This usually
represents a single file, set of files, database or gateway.  A GDALDataset
has a list of OGRLayers which it owns but can return references to.<p>

GDALDataset is an abstract base class.  An implementation is
expected to be subclassed for each file format driver implemented.
GDALDataset objects are not normally instantiated directly but rather with
the assistance of an GDALDriver.  Deleting an GDALDataset closes access
to the underlying persistent data source, but does not normally result in
deletion of that file.<p>

A GDALDataset has a name (usually a filename) that can be used to reopen
the data source with a GDALDriver.<p>

The GDALDataset also has support for executing a datasource specific
command, normally a form of SQL.   This is accomplished via the
GDALDataset::ExecuteSQL() method.  While some datasources (such as PostGIS
and Oracle) pass the SQL through to an underlying database, OGR also includes
support for evaluating a subset of the SQL SELECT statement against any
datasource. <p>

\section ogr_arch_drivers Drivers

A GDALDriver object is instantiated for each file format supported.
The GDALDriver objects are registered with the GDALDriverManager, a
singleton class that is normally used to open new datasets.<p>

It is intended that a new GDALDriver object is instantiated and define function
pointers for operations like Identify(), Open() for each
file format to be supported (along with a file format specific
GDALDataset, and OGRLayer classes).<p>

On application startup registration
functions are normally called for each desired file format.  These functions
instantiate the appropriate GDALDriver objects, and register them with the
GDALDriverManager.  When a dataset is to be opened, the driver manager
will normally try each GDALDataset in turn, until one succeeds, returning
a GDALDataset object.<p>

*/