← Back to branch summary

~ubuntu-branches/ubuntu/wily/spatialite/wily-proposed

« back to all changes in this revision

Viewing changes to src/geopackage/gpkgMakePoint.c

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-07-14 11:57:46 UTC
  • mfrom: (16.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20150714115746-e2iljfmb5sq7o5hh
Tags: 4.3.0-1
Move from experimental to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/geopackage/gpkgMakePoint.c
 
1
/*
 
2
 
 
3
    GeoPackage extensions for SpatiaLite / SQLite
 
4
 
 
5
Version: MPL 1.1/GPL 2.0/LGPL 2.1
 
6
 
 
7
The contents of this file are subject to the Mozilla Public License Version
 
8
1.1 (the "License"); you may not use this file except in compliance with
 
9
the License. You may obtain a copy of the License at
 
10
http://www.mozilla.org/MPL/
 
11
 
 
12
Software distributed under the License is distributed on an "AS IS" basis,
 
13
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 
14
for the specific language governing rights and limitations under the
 
15
License.
 
16
 
 
17
The Original Code is GeoPackage Extensions
 
18
 
 
19
The Initial Developer of the Original Code is Brad Hards (bradh@frogmouth.net)
 
20
 
 
21
Portions created by the Initial Developer are Copyright (C) 2012-2015
 
22
the Initial Developer. All Rights Reserved.
 
23
 
 
24
Contributor(s):
 
25
 
 
26
Alternatively, the contents of this file may be used under the terms of
 
27
either the GNU General Public License Version 2 or later (the "GPL"), or
 
28
the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 
29
in which case the provisions of the GPL or the LGPL are applicable instead
 
30
of those above. If you wish to allow use of your version of this file only
 
31
under the terms of either the GPL or the LGPL, and not to allow others to
 
32
use your version of this file under the terms of the MPL, indicate your
 
33
decision by deleting the provisions above and replace them with the notice
 
34
and other provisions required by the GPL or the LGPL. If you do not delete
 
35
the provisions above, a recipient may use your version of this file under
 
36
the terms of any one of the MPL, the GPL or the LGPL.
 
37
 
 
38
*/
 
39
 
 
40
#include "spatialite/geopackage.h"
 
41
#include "config.h"
 
42
#include "geopackage_internal.h"
 
43
 
 
44
#ifdef ENABLE_GEOPACKAGE
 
45
 
 
46
#define GEOPACKAGE_UNUSED() if (argc || argv) argc = argc;
 
47
 
 
48
static void
 
49
gpkgMakePoint (double x, double y, int srid, unsigned char **result,
 
50
               unsigned int *size)
 
51
{
 
52
    /* build a Blob encoded Geometry representing a POINT */
 
53
    unsigned char *ptr;
 
54
    int endian_arch = gaiaEndianArch ();
 
55
 
 
56
    /* computing the Blob size and then allocating it */
 
57
    *size = GEOPACKAGE_HEADER_LEN + GEOPACKAGE_2D_ENVELOPE_LEN;
 
58
    *size += GEOPACKAGE_WKB_HEADER_LEN;
 
59
    *size += (sizeof (double) * 2);     /* [x,y] coords */
 
60
    *result = malloc (*size);
 
61
    if (*result == NULL)
 
62
      {
 
63
          return;
 
64
      }
 
65
    memset (*result, 0xD9, *size);
 
66
    ptr = *result;
 
67
 
 
68
    /* setting the Blob value */
 
69
    gpkgSetHeader2DLittleEndian (ptr, srid, endian_arch);
 
70
 
 
71
    gpkgSetHeader2DMbr (ptr + GEOPACKAGE_HEADER_LEN, x, y, x, y, endian_arch);
 
72
 
 
73
    *(ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_2D_ENVELOPE_LEN) =
 
74
        GEOPACKAGE_WKB_LITTLEENDIAN;
 
75
    gaiaExport32 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_2D_ENVELOPE_LEN + 1,
 
76
                  GEOPACKAGE_WKB_POINT, 1, endian_arch);
 
77
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_2D_ENVELOPE_LEN +
 
78
                  GEOPACKAGE_WKB_HEADER_LEN, x, 1, endian_arch);
 
79
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_2D_ENVELOPE_LEN +
 
80
                  GEOPACKAGE_WKB_HEADER_LEN + sizeof (double), y, 1,
 
81
                  endian_arch);
 
82
}
 
83
 
 
84
static void
 
85
gpkgMakePointZ (double x, double y, double z, int srid, unsigned char **result,
 
86
                unsigned int *size)
 
87
{
 
88
/* build a Blob encoded Geometry representing a POINT */
 
89
    unsigned char *ptr;
 
90
    int endian_arch = gaiaEndianArch ();
 
91
/* computing the Blob size and then allocating it */
 
92
    *size = GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN;
 
93
    *size += GEOPACKAGE_WKB_HEADER_LEN;
 
94
    *size += (sizeof (double) * 3);     /* [x,y,z] coords */
 
95
    *result = malloc (*size);
 
96
    if (*result == NULL)
 
97
      {
 
98
          return;
 
99
      }
 
100
    memset (*result, 0xD9, *size);      /* just a flag value */
 
101
    ptr = *result;
 
102
/* setting the Blob value */
 
103
    *ptr = GEOPACKAGE_MAGIC1;
 
104
    *(ptr + 1) = GEOPACKAGE_MAGIC2;
 
105
    *(ptr + 2) = GEOPACKAGE_VERSION;
 
106
    *(ptr + 3) = GEOPACKAGE_FLAGS_3D_LITTLEENDIAN;
 
107
    gaiaExport32 (ptr + 4, srid, 1, endian_arch);       /* the SRID */
 
108
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN, x, 1, endian_arch);      /* MBR - minimum X */
 
109
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + sizeof (double), x, 1, endian_arch);    /* MBR - maximum x */
 
110
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 2 * sizeof (double), y, 1, endian_arch);        /* MBR - minimum Y */
 
111
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 3 * sizeof (double), y, 1, endian_arch);        /* MBR - maximum Y */
 
112
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 4 * sizeof (double), z, 1, endian_arch);        /* MBR - maximum Z */
 
113
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 5 * sizeof (double), z, 1, endian_arch);        /* MBR - maximum Z */
 
114
    *(ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN) =
 
115
        GEOPACKAGE_WKB_LITTLEENDIAN;
 
116
    gaiaExport32 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN + 1,
 
117
                  GEOPACKAGE_WKB_POINTZ, 1, endian_arch);
 
118
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN +
 
119
                  GEOPACKAGE_WKB_HEADER_LEN, x, 1, endian_arch);
 
120
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN +
 
121
                  GEOPACKAGE_WKB_HEADER_LEN + sizeof (double), y, 1,
 
122
                  endian_arch);
 
123
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN +
 
124
                  GEOPACKAGE_WKB_HEADER_LEN + (2 * sizeof (double)), z, 1,
 
125
                  endian_arch);
 
126
}
 
127
 
 
128
static void
 
129
gpkgMakePointM (double x, double y, double m, int srid, unsigned char **result,
 
130
                unsigned int *size)
 
131
{
 
132
/* build a Blob encoded Geometry representing a POINT */
 
133
    unsigned char *ptr;
 
134
    int endian_arch = gaiaEndianArch ();
 
135
/* computing the Blob size and then allocating it */
 
136
    *size = GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN;
 
137
    *size += GEOPACKAGE_WKB_HEADER_LEN;
 
138
    *size += (sizeof (double) * 3);     /* [x,y,m] coords */
 
139
    *result = malloc (*size);
 
140
    if (*result == NULL)
 
141
      {
 
142
          return;
 
143
      }
 
144
    memset (*result, 0xD9, *size);      /* just a flag value */
 
145
    ptr = *result;
 
146
/* setting the Blob value */
 
147
    *ptr = GEOPACKAGE_MAGIC1;
 
148
    *(ptr + 1) = GEOPACKAGE_MAGIC2;
 
149
    *(ptr + 2) = GEOPACKAGE_VERSION;
 
150
    *(ptr + 3) = GEOPACKAGE_FLAGS_2DM_LITTLEENDIAN;
 
151
    gaiaExport32 (ptr + 4, srid, 1, endian_arch);       /* the SRID */
 
152
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN, x, 1, endian_arch);      /* MBR - minimum X */
 
153
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + sizeof (double), x, 1, endian_arch);    /* MBR - maximum X */
 
154
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 2 * sizeof (double), y, 1, endian_arch);        /* MBR - minimum Y */
 
155
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 3 * sizeof (double), y, 1, endian_arch);        /* MBR - maximum Y */
 
156
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 4 * sizeof (double), m, 1, endian_arch);        /* MBR - maximum M */
 
157
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 5 * sizeof (double), m, 1, endian_arch);        /* MBR - maximum M */
 
158
    *(ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN) =
 
159
        GEOPACKAGE_WKB_LITTLEENDIAN;
 
160
    gaiaExport32 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN + 1,
 
161
                  GEOPACKAGE_WKB_POINTM, 1, endian_arch);
 
162
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN +
 
163
                  GEOPACKAGE_WKB_HEADER_LEN, x, 1, endian_arch);
 
164
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN +
 
165
                  GEOPACKAGE_WKB_HEADER_LEN + sizeof (double), y, 1,
 
166
                  endian_arch);
 
167
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_3D_ENVELOPE_LEN +
 
168
                  GEOPACKAGE_WKB_HEADER_LEN + (2 * sizeof (double)), m, 1,
 
169
                  endian_arch);
 
170
}
 
171
 
 
172
static void
 
173
gpkgMakePointZM (double x, double y, double z, double m, int srid,
 
174
                 unsigned char **result, unsigned int *size)
 
175
{
 
176
/* build a Blob encoded Geometry representing a POINT */
 
177
    unsigned char *ptr;
 
178
    int endian_arch = gaiaEndianArch ();
 
179
/* computing the Blob size and then allocating it */
 
180
    *size = GEOPACKAGE_HEADER_LEN + GEOPACKAGE_4D_ENVELOPE_LEN;
 
181
    *size += GEOPACKAGE_WKB_HEADER_LEN;
 
182
    *size += (sizeof (double) * 4);     /* [x,y,z,m] coords */
 
183
    *result = malloc (*size);
 
184
    if (*result == NULL)
 
185
      {
 
186
          return;
 
187
      }
 
188
    memset (*result, 0xD9, *size);      /* just a flag value */
 
189
    ptr = *result;
 
190
/* setting the Blob value */
 
191
    *ptr = GEOPACKAGE_MAGIC1;
 
192
    *(ptr + 1) = GEOPACKAGE_MAGIC2;
 
193
    *(ptr + 2) = GEOPACKAGE_VERSION;
 
194
    *(ptr + 3) = GEOPACKAGE_FLAGS_3DM_LITTLEENDIAN;
 
195
    gaiaExport32 (ptr + 4, srid, 1, endian_arch);       /* the SRID */
 
196
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN, x, 1, endian_arch);      /* MBR - minimum X */
 
197
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 1 * sizeof (double), x, 1, endian_arch);        /* MBR - maximum X */
 
198
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 2 * sizeof (double), y, 1, endian_arch);        /* MBR - minimum Y */
 
199
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 3 * sizeof (double), y, 1, endian_arch);        /* MBR - maximum Y */
 
200
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 4 * sizeof (double), z, 1, endian_arch);        /* MBR - minimum Z */
 
201
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 5 * sizeof (double), z, 1, endian_arch);        /* MBR - maximum Z */
 
202
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 6 * sizeof (double), m, 1, endian_arch);        /* MBR - minimum M */
 
203
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + 7 * sizeof (double), m, 1, endian_arch);        /* MBR - maximum M */
 
204
    *(ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_4D_ENVELOPE_LEN) =
 
205
        GEOPACKAGE_WKB_LITTLEENDIAN;
 
206
    gaiaExport32 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_4D_ENVELOPE_LEN + 1,
 
207
                  GEOPACKAGE_WKB_POINTZM, 1, endian_arch);
 
208
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_4D_ENVELOPE_LEN +
 
209
                  GEOPACKAGE_WKB_HEADER_LEN, x, 1, endian_arch);
 
210
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_4D_ENVELOPE_LEN +
 
211
                  GEOPACKAGE_WKB_HEADER_LEN + sizeof (double), y, 1,
 
212
                  endian_arch);
 
213
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_4D_ENVELOPE_LEN +
 
214
                  GEOPACKAGE_WKB_HEADER_LEN + (2 * sizeof (double)), z, 1,
 
215
                  endian_arch);
 
216
    gaiaExport64 (ptr + GEOPACKAGE_HEADER_LEN + GEOPACKAGE_4D_ENVELOPE_LEN +
 
217
                  GEOPACKAGE_WKB_HEADER_LEN + (3 * sizeof (double)), m, 1,
 
218
                  endian_arch);
 
219
}
 
220
 
 
221
GEOPACKAGE_PRIVATE void
 
222
fnct_gpkgMakePoint (sqlite3_context * context, int argc UNUSED,
 
223
                    sqlite3_value ** argv)
 
224
{
 
225
/* SQL function:
 
226
/ gpkgMakePoint(x, y)
 
227
/
 
228
/ Creates a GeoPackage geometry POINT
 
229
/
 
230
/ returns nothing on success, raises exception on error
 
231
*/
 
232
    unsigned int len;
 
233
    int int_value;
 
234
    unsigned char *p_result = NULL;
 
235
    double x;
 
236
    double y;
 
237
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
238
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
239
      {
 
240
          x = sqlite3_value_double (argv[0]);
 
241
      }
 
242
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
243
      {
 
244
          int_value = sqlite3_value_int (argv[0]);
 
245
          x = int_value;
 
246
      }
 
247
    else
 
248
      {
 
249
          sqlite3_result_null (context);
 
250
          return;
 
251
      }
 
252
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
253
      {
 
254
          y = sqlite3_value_double (argv[1]);
 
255
      }
 
256
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
257
      {
 
258
          int_value = sqlite3_value_int (argv[1]);
 
259
          y = int_value;
 
260
      }
 
261
    else
 
262
      {
 
263
          sqlite3_result_null (context);
 
264
          return;
 
265
      }
 
266
    gpkgMakePoint (x, y, GEOPACKAGE_DEFAULT_UNDEFINED_SRID, &p_result, &len);
 
267
    if (!p_result)
 
268
      {
 
269
          sqlite3_result_null (context);
 
270
      }
 
271
    else
 
272
      {
 
273
          sqlite3_result_blob (context, p_result, len, free);
 
274
      }
 
275
}
 
276
 
 
277
GEOPACKAGE_PRIVATE void
 
278
fnct_gpkgMakePointWithSRID (sqlite3_context * context, int argc UNUSED,
 
279
                            sqlite3_value ** argv)
 
280
{
 
281
/* SQL function:
 
282
/ gpkgMakePoint(x, y, srid)
 
283
/
 
284
/ Creates a GeoPackage geometry POINT
 
285
/
 
286
/ returns nothing on success, raises exception on error
 
287
*/
 
288
    unsigned int len;
 
289
    int int_value;
 
290
    unsigned char *p_result = NULL;
 
291
    double x;
 
292
    double y;
 
293
    int srid;
 
294
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
295
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
296
      {
 
297
          x = sqlite3_value_double (argv[0]);
 
298
      }
 
299
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
300
      {
 
301
          int_value = sqlite3_value_int (argv[0]);
 
302
          x = int_value;
 
303
      }
 
304
    else
 
305
      {
 
306
          sqlite3_result_null (context);
 
307
          return;
 
308
      }
 
309
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
310
      {
 
311
          y = sqlite3_value_double (argv[1]);
 
312
      }
 
313
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
314
      {
 
315
          int_value = sqlite3_value_int (argv[1]);
 
316
          y = int_value;
 
317
      }
 
318
    else
 
319
      {
 
320
          sqlite3_result_null (context);
 
321
          return;
 
322
      }
 
323
    if (sqlite3_value_type (argv[2]) != SQLITE_INTEGER)
 
324
      {
 
325
          sqlite3_result_null (context);
 
326
          return;
 
327
      }
 
328
    srid = sqlite3_value_int (argv[2]);
 
329
 
 
330
    gpkgMakePoint (x, y, srid, &p_result, &len);
 
331
    if (!p_result)
 
332
      {
 
333
          sqlite3_result_null (context);
 
334
      }
 
335
    else
 
336
      {
 
337
          sqlite3_result_blob (context, p_result, len, free);
 
338
      }
 
339
}
 
340
 
 
341
GEOPACKAGE_PRIVATE void
 
342
fnct_gpkgMakePointZ (sqlite3_context * context, int argc UNUSED,
 
343
                     sqlite3_value ** argv)
 
344
{
 
345
/* SQL function:
 
346
/ gpkgMakePointZ(x, y, z)
 
347
/
 
348
/ Creates a GeoPackage geometry POINT Z
 
349
/
 
350
/ returns nothing on success, raises exception on error
 
351
*/
 
352
    unsigned int len;
 
353
    int int_value;
 
354
    unsigned char *p_result = NULL;
 
355
    double x;
 
356
    double y;
 
357
    double z;
 
358
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
359
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
360
      {
 
361
          x = sqlite3_value_double (argv[0]);
 
362
      }
 
363
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
364
      {
 
365
          int_value = sqlite3_value_int (argv[0]);
 
366
          x = int_value;
 
367
      }
 
368
    else
 
369
      {
 
370
          sqlite3_result_null (context);
 
371
          return;
 
372
      }
 
373
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
374
      {
 
375
          y = sqlite3_value_double (argv[1]);
 
376
      }
 
377
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
378
      {
 
379
          int_value = sqlite3_value_int (argv[1]);
 
380
          y = int_value;
 
381
      }
 
382
    else
 
383
      {
 
384
          sqlite3_result_null (context);
 
385
          return;
 
386
      }
 
387
    if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
 
388
      {
 
389
          z = sqlite3_value_double (argv[2]);
 
390
      }
 
391
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
 
392
      {
 
393
          int_value = sqlite3_value_int (argv[2]);
 
394
          z = int_value;
 
395
      }
 
396
    else
 
397
      {
 
398
          sqlite3_result_null (context);
 
399
          return;
 
400
      }
 
401
 
 
402
    gpkgMakePointZ (x, y, z, GEOPACKAGE_DEFAULT_UNDEFINED_SRID, &p_result,
 
403
                    &len);
 
404
    if (!p_result)
 
405
      {
 
406
          sqlite3_result_null (context);
 
407
      }
 
408
    else
 
409
      {
 
410
          sqlite3_result_blob (context, p_result, len, free);
 
411
      }
 
412
}
 
413
 
 
414
GEOPACKAGE_PRIVATE void
 
415
fnct_gpkgMakePointZWithSRID (sqlite3_context * context, int argc UNUSED,
 
416
                             sqlite3_value ** argv)
 
417
{
 
418
/* SQL function:
 
419
/ gpkgMakePointZ(x, y, z, srid)
 
420
/
 
421
/ Creates a GeoPackage geometry POINT Z
 
422
/
 
423
/ returns nothing on success, raises exception on error
 
424
*/
 
425
    unsigned int len;
 
426
    int int_value;
 
427
    unsigned char *p_result = NULL;
 
428
    double x;
 
429
    double y;
 
430
    double z;
 
431
    int srid;
 
432
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
433
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
434
      {
 
435
          x = sqlite3_value_double (argv[0]);
 
436
      }
 
437
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
438
      {
 
439
          int_value = sqlite3_value_int (argv[0]);
 
440
          x = int_value;
 
441
      }
 
442
    else
 
443
      {
 
444
          sqlite3_result_null (context);
 
445
          return;
 
446
      }
 
447
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
448
      {
 
449
          y = sqlite3_value_double (argv[1]);
 
450
      }
 
451
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
452
      {
 
453
          int_value = sqlite3_value_int (argv[1]);
 
454
          y = int_value;
 
455
      }
 
456
    else
 
457
      {
 
458
          sqlite3_result_null (context);
 
459
          return;
 
460
      }
 
461
    if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
 
462
      {
 
463
          z = sqlite3_value_double (argv[2]);
 
464
      }
 
465
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
 
466
      {
 
467
          int_value = sqlite3_value_int (argv[2]);
 
468
          z = int_value;
 
469
      }
 
470
    else
 
471
      {
 
472
          sqlite3_result_null (context);
 
473
          return;
 
474
      }
 
475
    if (sqlite3_value_type (argv[3]) != SQLITE_INTEGER)
 
476
      {
 
477
          sqlite3_result_null (context);
 
478
          return;
 
479
      }
 
480
    srid = sqlite3_value_int (argv[3]);
 
481
 
 
482
    gpkgMakePointZ (x, y, z, srid, &p_result, &len);
 
483
    if (!p_result)
 
484
      {
 
485
          sqlite3_result_null (context);
 
486
      }
 
487
    else
 
488
      {
 
489
          sqlite3_result_blob (context, p_result, len, free);
 
490
      }
 
491
}
 
492
 
 
493
GEOPACKAGE_PRIVATE void
 
494
fnct_gpkgMakePointM (sqlite3_context * context, int argc UNUSED,
 
495
                     sqlite3_value ** argv)
 
496
{
 
497
/* SQL function:
 
498
/ gpkgMakePointM(x, y, m)
 
499
/
 
500
/ Creates a GeoPackage geometry POINT M
 
501
/
 
502
/ returns nothing on success, raises exception on error
 
503
*/
 
504
    unsigned int len;
 
505
    int int_value;
 
506
    unsigned char *p_result = NULL;
 
507
    double x;
 
508
    double y;
 
509
    double m;
 
510
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
511
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
512
      {
 
513
          x = sqlite3_value_double (argv[0]);
 
514
      }
 
515
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
516
      {
 
517
          int_value = sqlite3_value_int (argv[0]);
 
518
          x = int_value;
 
519
      }
 
520
    else
 
521
      {
 
522
          sqlite3_result_null (context);
 
523
          return;
 
524
      }
 
525
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
526
      {
 
527
          y = sqlite3_value_double (argv[1]);
 
528
      }
 
529
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
530
      {
 
531
          int_value = sqlite3_value_int (argv[1]);
 
532
          y = int_value;
 
533
      }
 
534
    else
 
535
      {
 
536
          sqlite3_result_null (context);
 
537
          return;
 
538
      }
 
539
    if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
 
540
      {
 
541
          m = sqlite3_value_double (argv[2]);
 
542
      }
 
543
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
 
544
      {
 
545
          int_value = sqlite3_value_int (argv[2]);
 
546
          m = int_value;
 
547
      }
 
548
    else
 
549
      {
 
550
          sqlite3_result_null (context);
 
551
          return;
 
552
      }
 
553
 
 
554
    gpkgMakePointM (x, y, m, GEOPACKAGE_DEFAULT_UNDEFINED_SRID, &p_result,
 
555
                    &len);
 
556
    if (!p_result)
 
557
      {
 
558
          sqlite3_result_null (context);
 
559
      }
 
560
    else
 
561
      {
 
562
          sqlite3_result_blob (context, p_result, len, free);
 
563
      }
 
564
}
 
565
 
 
566
GEOPACKAGE_PRIVATE void
 
567
fnct_gpkgMakePointMWithSRID (sqlite3_context * context, int argc UNUSED,
 
568
                             sqlite3_value ** argv)
 
569
{
 
570
/* SQL function:
 
571
/ gpkgMakePointM(x, y, m, srid)
 
572
/
 
573
/ Creates a GeoPackage geometry POINT M
 
574
/
 
575
/ returns nothing on success, raises exception on error
 
576
*/
 
577
    unsigned int len;
 
578
    int int_value;
 
579
    unsigned char *p_result = NULL;
 
580
    double x;
 
581
    double y;
 
582
    double m;
 
583
    int srid;
 
584
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
585
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
586
      {
 
587
          x = sqlite3_value_double (argv[0]);
 
588
      }
 
589
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
590
      {
 
591
          int_value = sqlite3_value_int (argv[0]);
 
592
          x = int_value;
 
593
      }
 
594
    else
 
595
      {
 
596
          sqlite3_result_null (context);
 
597
          return;
 
598
      }
 
599
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
600
      {
 
601
          y = sqlite3_value_double (argv[1]);
 
602
      }
 
603
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
604
      {
 
605
          int_value = sqlite3_value_int (argv[1]);
 
606
          y = int_value;
 
607
      }
 
608
    else
 
609
      {
 
610
          sqlite3_result_null (context);
 
611
          return;
 
612
      }
 
613
    if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
 
614
      {
 
615
          m = sqlite3_value_double (argv[2]);
 
616
      }
 
617
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
 
618
      {
 
619
          int_value = sqlite3_value_int (argv[2]);
 
620
          m = int_value;
 
621
      }
 
622
    else
 
623
      {
 
624
          sqlite3_result_null (context);
 
625
          return;
 
626
      }
 
627
    if (sqlite3_value_type (argv[3]) != SQLITE_INTEGER)
 
628
      {
 
629
          sqlite3_result_null (context);
 
630
          return;
 
631
      }
 
632
    srid = sqlite3_value_int (argv[3]);
 
633
 
 
634
    gpkgMakePointM (x, y, m, srid, &p_result, &len);
 
635
    if (!p_result)
 
636
      {
 
637
          sqlite3_result_null (context);
 
638
      }
 
639
    else
 
640
      {
 
641
          sqlite3_result_blob (context, p_result, len, free);
 
642
      }
 
643
}
 
644
 
 
645
GEOPACKAGE_PRIVATE void
 
646
fnct_gpkgMakePointZM (sqlite3_context * context, int argc UNUSED,
 
647
                      sqlite3_value ** argv)
 
648
{
 
649
/* SQL function:
 
650
/ gpkgMakePointM(x, y, z, m)
 
651
/
 
652
/ Creates a GeoPackage geometry POINT ZM
 
653
/
 
654
/ returns nothing on success, raises exception on error
 
655
*/
 
656
    unsigned int len;
 
657
    int int_value;
 
658
    unsigned char *p_result = NULL;
 
659
    double x;
 
660
    double y;
 
661
    double z;
 
662
    double m;
 
663
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
664
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
665
      {
 
666
          x = sqlite3_value_double (argv[0]);
 
667
      }
 
668
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
669
      {
 
670
          int_value = sqlite3_value_int (argv[0]);
 
671
          x = int_value;
 
672
      }
 
673
    else
 
674
      {
 
675
          sqlite3_result_null (context);
 
676
          return;
 
677
      }
 
678
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
679
      {
 
680
          y = sqlite3_value_double (argv[1]);
 
681
      }
 
682
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
683
      {
 
684
          int_value = sqlite3_value_int (argv[1]);
 
685
          y = int_value;
 
686
      }
 
687
    else
 
688
      {
 
689
          sqlite3_result_null (context);
 
690
          return;
 
691
      }
 
692
    if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
 
693
      {
 
694
          z = sqlite3_value_double (argv[2]);
 
695
      }
 
696
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
 
697
      {
 
698
          int_value = sqlite3_value_int (argv[2]);
 
699
          z = int_value;
 
700
      }
 
701
    else
 
702
      {
 
703
          sqlite3_result_null (context);
 
704
          return;
 
705
      }
 
706
    if (sqlite3_value_type (argv[3]) == SQLITE_FLOAT)
 
707
      {
 
708
          m = sqlite3_value_double (argv[3]);
 
709
      }
 
710
    else if (sqlite3_value_type (argv[3]) == SQLITE_INTEGER)
 
711
      {
 
712
          int_value = sqlite3_value_int (argv[3]);
 
713
          m = int_value;
 
714
      }
 
715
    else
 
716
      {
 
717
          sqlite3_result_null (context);
 
718
          return;
 
719
      }
 
720
 
 
721
    gpkgMakePointZM (x, y, z, m, GEOPACKAGE_DEFAULT_UNDEFINED_SRID, &p_result,
 
722
                     &len);
 
723
    if (!p_result)
 
724
      {
 
725
          sqlite3_result_null (context);
 
726
      }
 
727
    else
 
728
      {
 
729
          sqlite3_result_blob (context, p_result, len, free);
 
730
      }
 
731
}
 
732
 
 
733
GEOPACKAGE_PRIVATE void
 
734
fnct_gpkgMakePointZMWithSRID (sqlite3_context * context, int argc UNUSED,
 
735
                              sqlite3_value ** argv)
 
736
{
 
737
/* SQL function:
 
738
/ gpkgMakePointZM(x, y, z, m, srid)
 
739
/
 
740
/ Creates a GeoPackage geometry POINT ZM
 
741
/
 
742
/ returns nothing on success, raises exception on error
 
743
*/
 
744
    unsigned int len;
 
745
    int int_value;
 
746
    unsigned char *p_result = NULL;
 
747
    double x;
 
748
    double y;
 
749
    double z;
 
750
    double m;
 
751
    int srid;
 
752
    GEOPACKAGE_UNUSED ();       /* LCOV_EXCL_LINE */
 
753
    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)
 
754
      {
 
755
          x = sqlite3_value_double (argv[0]);
 
756
      }
 
757
    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)
 
758
      {
 
759
          int_value = sqlite3_value_int (argv[0]);
 
760
          x = int_value;
 
761
      }
 
762
    else
 
763
      {
 
764
          sqlite3_result_null (context);
 
765
          return;
 
766
      }
 
767
    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)
 
768
      {
 
769
          y = sqlite3_value_double (argv[1]);
 
770
      }
 
771
    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)
 
772
      {
 
773
          int_value = sqlite3_value_int (argv[1]);
 
774
          y = int_value;
 
775
      }
 
776
    else
 
777
      {
 
778
          sqlite3_result_null (context);
 
779
          return;
 
780
      }
 
781
    if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
 
782
      {
 
783
          z = sqlite3_value_double (argv[2]);
 
784
      }
 
785
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
 
786
      {
 
787
          int_value = sqlite3_value_int (argv[2]);
 
788
          z = int_value;
 
789
      }
 
790
    else
 
791
      {
 
792
          sqlite3_result_null (context);
 
793
          return;
 
794
      }
 
795
    if (sqlite3_value_type (argv[3]) == SQLITE_FLOAT)
 
796
      {
 
797
          m = sqlite3_value_double (argv[3]);
 
798
      }
 
799
    else if (sqlite3_value_type (argv[3]) == SQLITE_INTEGER)
 
800
      {
 
801
          int_value = sqlite3_value_int (argv[3]);
 
802
          m = int_value;
 
803
      }
 
804
    else
 
805
      {
 
806
          sqlite3_result_null (context);
 
807
          return;
 
808
      }
 
809
    if (sqlite3_value_type (argv[4]) != SQLITE_INTEGER)
 
810
      {
 
811
          sqlite3_result_null (context);
 
812
          return;
 
813
      }
 
814
    srid = sqlite3_value_int (argv[4]);
 
815
 
 
816
    gpkgMakePointZM (x, y, z, m, srid, &p_result, &len);
 
817
    if (!p_result)
 
818
      {
 
819
          sqlite3_result_null (context);
 
820
      }
 
821
    else
 
822
      {
 
823
          sqlite3_result_blob (context, p_result, len, free);
 
824
      }
 
825
}
 
826
#endif