[dadc52]: src / octclip / libgeoc / polil.h Maximize Restore History

Download this file

polil.h    800 lines (792 with data), 43.7 kB

  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
/* -*- coding: utf-8 -*- */
/**
\ingroup geom gshhs
@{
\file polil.h
\brief Definición de estructuras y declaración de funciones para el trabajo con
polilíneas.
\author José Luis García Pallero, jgpallero@gmail.com
\note Este fichero contiene funciones paralelizadas con OpenMP.
\date 03 de junio de 2011
\section Licencia Licencia
Copyright (c) 2011, José Luis García Pallero. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
- Neither the name of the copyright holders nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/******************************************************************************/
/******************************************************************************/
#ifndef _POLIL_H_
#define _POLIL_H_
/******************************************************************************/
/******************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include"libgeoc/dpeucker.h"
#include"libgeoc/errores.h"
#include"libgeoc/fgeneral.h"
#include"libgeoc/geocnan.h"
#include"libgeoc/geocomp.h"
#include"libgeoc/polig.h"
/******************************************************************************/
/******************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
/******************************************************************************/
/******************************************************************************/
/** \struct polil
\brief Estructura contenedora de los vértices que definen el contorno de una o
varias polilíneas.
\date 03 de junio de 2011: Creación de la estructura.
*/
typedef struct
{
/** \brief Número de elementos de los vectores de coordenadas. */
size_t nElem;
/**
\brief Vector de polil::nElem elementos, que almacena las coordenadas X de
los vértices de la polilínea (o las polilíneas), así como los
separadores entre polilíneas. La primera coordenada de cada polilínea
se repite al final.
*/
double* x;
/**
\brief Vector de polil::nElem elementos, que almacena las coordenadas Y de
los vértices de la polilínea (o las polilíneas), así como los
separadores entre polilíneas. La primera coordenada de cada polilínea
se repite al final.
*/
double* y;
/** \brief Número de polilíneas almacenadas. */
size_t nPolil;
/**
\brief Vector de polil::nPolig elementos, que almacena las posiciones en los
vectores \em x e \em y de inicio de cada polilínea almacenada.
*/
size_t* posIni;
/**
\brief Vector de polil::nPolig elementos, que almacena el número de vértices
de cada polilínea almacenada.
*/
size_t* nVert;
/**
\brief Identificador de si la estructura contiene información acerca de los
límites del rectángulo que encierra a cada polilínea almacenada.
Dos posibilidades:
- 0: La estructura no contiene información de los límites.
- Distinto de 0: La estructura sí contiene información de los
límites.
*/
int hayLim;
/**
\brief Vector de polil::nPolig elementos, que almacena la coordenada X
mínima de cada polilínea almacenada. Este campo sólo contiene
información si el campo polil::hayLim es distinto de 0; si no, es
igual a \p NULL.
*/
double* xMin;
/**
\brief Vector de polil::nPolig elementos, que almacena la coordenada X
máxima de cada polilínea almacenada. Este campo sólo contiene
información si el campo polil::hayLim es distinto de 0; si no, es
igual a \p NULL.
*/
double* xMax;
/**
\brief Vector de polil::nPolig elementos, que almacena la coordenada Y
mínima de cada polilínea almacenada. Este campo sólo contiene
información si el campo polil::hayLim es distinto de 0; si no, es
igual a \p NULL.
*/
double* yMin;
/**
\brief Vector de polil::nPolig elementos, que almacena la coordenada Y
máxima de cada polilínea almacenada. Este campo sólo contiene
información si el campo polil::hayLim es distinto de 0; si no, es
igual a \p NULL.
*/
double* yMax;
}polil;
/******************************************************************************/
/******************************************************************************/
/**
\brief Indica si hay alguna función compilada en paralelo con OpenMP en el
fichero \ref polil.c.
\param[out] version Cadena identificadora de la versión de OpenMP utilizada.
Este argumento sólo se utiliza si su valor de entrada es distinto de
\p NULL y si hay alguna función compilada con OpenMP.
\return Dos posibles valores:
- 0: No hay ninguna función compilada en paralelo con OpenMP.
- Distinto de 0: Sí hay alguna función compilada en paralelo con OpenMP.
\note Esta función asume que el argumento \em version tiene suficiente memoria
asignada (si es distinto de \p NULL).
\date 03 de junio de 2011: Creación de la función.
\date 25 de agosto de 2011: Adición del argumento de entrada \em version.
*/
int GeocParOmpPolil(char version[]);
/******************************************************************************/
/******************************************************************************/
/**
\brief Crea una estructura \ref polil vacía.
\return Estructura \ref polil vacía. Los campos escalares se inicializan con el
valor 0 y los vectoriales con \p NULL. Si se devuelve \p NULL ha
ocurrido un error de asignación de memoria.
\date 26 de mayo de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
polil* IniciaPolilVacia(void);
/******************************************************************************/
/******************************************************************************/
/**
\brief Función auxiliar para la rutina de creación de una estructura \ref polil
a partir de dos vectores que contienen las coordenadas de los vértices.
Esta función calcula el número máximo de elementos que almacenarán los
vectores de coordenadas de una estructura \ref polil y el número de
polilíneas almacenadas en los vectores de trabajo.
\param[in] nElem Número de elementos de los vectores de coordenadas originales.
\param[in] posNanX Vector que almacena las posiciones de los elementos #GEOC_NAN
en el vector \em x de coordenadas originales.
\param[in] posNanY Vector que almacena las posiciones de los elementos #GEOC_NAN
en el vector \em y de coordenadas originales.
\param[in] nNanX Número de elementos del vector \em posNanX.
\param[in] nNanY Número de elementos del vector \em posNanY.
\param[out] nElemMax Número máximo de elementos que contendrán los vectores de
coordenadas de los elementos de la estructura.
\param[out] nPolil Número de polilíneas almacenadas en los vectores \em x e
\em y de coordenadas originales.
\return Variable de error. Tres posibilidades:
- #GEOC_ERR_NO_ERROR: Si todo ha ido bien.
- #GEOC_ERR_POLIL_VEC_DISTINTO_NUM_POLIL: Si los vectores \em x e \em y
de coordenadas originales almacenan un número distinto de polilíneas,
es decir, \em nNanX es distinto que \em nNanY.
- #GEOC_ERR_POLIL_VEC_DISTINTAS_POLIL: Si algunas polilíneas almacenadas
en \em x e \em y son distintas, es decir, las posiciones almacenadas
en \em posNanX son distintas de las almacenadas en \em posNanY.
\note Esta función no comprueba si el número de elementos de los vectores
\em posNanX y \em posNanY es congruente con los valores pasados en
\em nNanX y \em nNanY.
\date 03 de junio de 2011: Creación de la función.
\date 13 de junio de 2011: Corrección de error que hacía que el argumento
\em nElemMax que calculase mal si los argumentos \em nNanX y/o \em nNanY
valían 0.
\note Esta función todavía no está probada.
*/
int AuxCreaPolil1(const size_t nElem,
const size_t* posNanX,
const size_t* posNanY,
const size_t nNanX,
const size_t nNanY,
size_t* nElemMax,
size_t* nPolil);
/******************************************************************************/
/******************************************************************************/
/**
\brief Función auxiliar para la rutina de creación de una estructura \ref polil
a partir de dos vectores que contienen las coordenadas de los vértices.
Esta función copia una serie de datos de dos vectores en otros dos.
\param[in] x Vector que contiene las coordenadas X de los vértices a copiar.
\param[in] y Vector que contiene las coordenadas Y de los vértices a copiar.
\param[in] nElem Número de elementos de los vectores \em x e \em y.
\param[in] incX Posiciones de separación entre los elementos del vector \em x.
Este argumento siempre ha de ser un número positivo.
\param[in] incY Posiciones de separación entre los elementos del vector \em y.
Este argumento siempre ha de ser un número positivo.
\param[out] xSal Vector de \em nElem elementos para almacenar los elementos
copiados del vector \em x.
\param[out] ySal Vector de \em nElem elementos para almacenar los elementos
copiados del vector \em y.
\note Esta función no comprueba si el número de elementos de los vectores \em x,
\em y, \em xSal e \em ySal es congruente con los valores pasados en
\em nElem, \em incX e \em incY.
\date 03 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
void AuxCreaPolil2(const double* x,
const double* y,
const size_t nElem,
const size_t incX,
const size_t incY,
double* xSal,
double* ySal);
/******************************************************************************/
/******************************************************************************/
/**
\brief Función auxiliar para las rutinas de creación de estructuras \ref polil
a partir de dos vectores que contienen las coordenadas de los vértices.
Esta función crea las polilíneas en el formato de almacenamiento de
\ref polil a partir de los vectores de entrada.
\param[in] x Vector que contiene las coordenadas X de los vértices de trabajo.
\param[in] y Vector que contiene las coordenadas Y de los vértices de trabajo.
\param[in] nElem Número de elementos de los vectores \em x e \em y.
\param[in] incX Posiciones de separación entre los elementos del vector \em x.
Este argumento siempre ha de ser un número positivo.
\param[in] incY Posiciones de separación entre los elementos del vector \em y.
Este argumento siempre ha de ser un número positivo.
\param[in] posNan Vector que almacena las posiciones de los elementos #GEOC_NAN
en los vectores \em x e \em y.
\param[in] nNan Número de elementos del vector \em posNan.
\param[out] xSal Vector para almacenar las coordenadas X de los vértices de las
polilíneas creadas.
\param[out] ySal Vector para almacenar las coordenadas Y de los vértices de las
polilíneas creadas.
\param[out] posIni Vector para almacenar las posiciones de inicio de las
polilíneas creadas.
\param[out] nVert Vector para almacenar el número de vértices de las polilíneas
creadas.
\param[out] nPtos Número de posiciones con información almacenada en los
vectores \em xSal e \em ySal.
\param[out] nPolil Número de posiciones con información almacenada en los
vectores \em posIni y \em nVert.
\note Esta función no comprueba si el número de elementos de los vectores \em x,
\em y y \em posNan es congruente con los valores pasados en \em nElem,
\em incX, \em incY y \em nNan.
\note Esta función asume que los vectores \em xSal, \em ySal, \em posIni y
\em nVert tienen asignada suficiente memoria.
\date 03 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
void AuxCreaPolil3(const double* x,
const double* y,
const size_t nElem,
const size_t incX,
const size_t incY,
const size_t* posNan,
const size_t nNan,
double* xSal,
double* ySal,
size_t* posIni,
size_t* nVert,
size_t* nPtos,
size_t* nPolil);
/******************************************************************************/
/******************************************************************************/
/**
\brief Crea una estructura \ref polil a partir de dos vectores que contienen las
coordenadas de los vértices de una o varias polilíneas.
\param[in] x Vector que contiene las coordenadas X de los vértices de la
polilínea o polilíneas de trabajo. Si hay varias polilíneas, han de
estar separados por un valor #GEOC_NAN.
\param[in] y Vector que contiene las coordenadas Y de los vértices de la
polilínea o polilíneas de trabajo. Si hay varias polilíneas, han de
estar separados por un valor #GEOC_NAN.
\param[in] nElem Número de elementos de los vectores \em x e \em y.
\param[in] incX Posiciones de separación entre los elementos del vector \em x.
Este argumento siempre ha de ser un número positivo.
\param[in] incY Posiciones de separación entre los elementos del vector \em y.
Este argumento siempre ha de ser un número positivo.
\param[out] idError Identificador de error. Varias posibilidades:
- #GEOC_ERR_NO_ERROR: Todo ha ido bien.
- #GEOC_ERR_ASIG_MEMORIA: Ha ocurrido un error de asignación de
memoria.
- #GEOC_ERR_POLIL_VEC_DISTINTO_NUM_POLIL: Los vectores \em x e \em y
contienen un número distinto de polilíneas. No contienen el mismo
número de identificadores #GEOC_NAN.
- #GEOC_ERR_POLIL_VEC_DISTINTAS_POLIL: Los vectores \em x e \em y
contienen distintas polilíneas. Los marcadores #GEOC_NAN no están
colocados en las mismas posiciones.
\return Estructura \ref polil con las polilíneas pasadas. Si ocurre algún error,
se devuelve \p NULL y el motivo del fallo se codifica en la variable
\em idError.
\note Esta función está paralelizada con OpenMP.
\note Esta función no comprueba si el número de elementos de los vectores \em x
e \em y es congruente con los valores pasados de \em nElem, \em incX e
\em incY.
\note Si los vectores \em x e \em y almacenan varias polilíneas, éstas se
separan mediante valores #GEOC_NAN. Poner #GEOC_NAN en la primera posición
y/o la última es opcional.
\note Los posibles valores #GEOC_NAN han de estar en las mismas posiciones en
\em x e \em y.
\note Esta función no calcula los límites de las polilíneas, por lo que el
campo polil::hayLim se inicializa a 0 y los campos polil::xMin,
polil::xMax, polil::yMin y polil::yMax se inicializan a \p NULL.
\date 03 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
polil* CreaPolil(const double* x,
const double* y,
const size_t nElem,
const size_t incX,
const size_t incY,
int* idError);
/******************************************************************************/
/******************************************************************************/
/**
\brief Enlaza el contenido de una estructura \ref polil a otra.
\param[in] poliEnt Estructura \ref polil de entrada, que almacena los datos a
enlazar.
\param[out] poliSal Estructura \ref polil, cuyos campos serán enlazados a los de
la estructura \em poliEnt. Esta estructura ha de estar, como mínimo,
inicializada. Al término de la ejecución de la función, las
estructuras \em poliEnt y \em poliSal comparten el mismo espacio de
memoria en sus argumentos vectoriales.
\note Esta función asume que la estructura de entrada \em poligEnt tiene memoria
asignada.
\note Esta función asume que la estructura de salida \em poligSal está, como
mínimo, inicializada.
\note Esta función libera la posible memoria asignada a los campos de
\em poliSal antes de realizar el enlace.
\date 19 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
void EnlazaCamposPolil(polil* poliEnt,
polil* poliSal);
/******************************************************************************/
/******************************************************************************/
/**
\brief Copia el contenido de una estructura \ref polil en otra.
\param[in] poli Estructura \ref polil de entrada, que almacena los datos a
copiar.
\param[out] idError Identificador de error. Varias posibilidades:
- #GEOC_ERR_NO_ERROR: Todo ha ido bien.
- #GEOC_ERR_ASIG_MEMORIA: Ha ocurrido un error de asignación de
memoria.
- #GEOC_ERR_POLIL_VEC_DISTINTO_NUM_POLIL: Los campos polil::x e
polil::y de la polilínea de entrada contienenun número distinto de
polilíneas. No contienen el mismo número de identificadores
#GEOC_NAN.
- #GEOC_ERR_POLIL_VEC_DISTINTAS_POLIL: Los campos polig::x e
polig::y de la polilínea de entrada contienen distintas
polilíneas. Los marcadores #GEOC_NAN no están colocados en las
mismas posiciones.
\return Polilínea con los datos contenidos en \em poli copiados. Si ocurre algún
error se devuelve \p NULL y la causa se almacena en el argumento
\em idError.
\note Esta función asume que la estructura de entrada \em poli tiene memoria
asignada.
\date 09 de julio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
polil* CopiaPolil(const polil* poli,
int* idError);
/******************************************************************************/
/******************************************************************************/
/**
\brief Añade el contenido de una estructura \ref polil a otra.
\param[in,out] poli Estructura \ref polil, que almacena una serie de polilíneas.
Al término de la ejecución de la función, se han añadido las
polilíneas de la estructura \em anyade.
\param[in] anyade Estructura cuyo contenido será añadido a \em poli.
\return Variable de error. Dos posibilidades:
- #GEOC_ERR_NO_ERROR: Todo ha ido bien.
- #GEOC_ERR_ASIG_MEMORIA: Ha ocurrido un error de asignación de memoria.
\note Esta función asume que la estructura de entrada \ref polil tiene memoria
asignada.
\note En caso de error de asignación de memoria, la memoria de las estructuras
de entrada no se libera.
\note Si la estructura \em poli guarda información de límites de las polilíneas
almacenadas, esta información se calcula también para los nuevos datos (en
realidad, si la estructura \em anyade ya los tiene calculados, simplemente
se copian).
\date 03 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
int AnyadePolilPolil(polil* poli,
const polil* anyade);
/******************************************************************************/
/******************************************************************************/
/**
\brief Añade al contenido de una estructura \ref polil un conjunto de polilíneas
definidas a partir de un listado con las coordenadas de sus vértices, de
la misma forma que el utilizado en la función \ref CreaPolil.
\param[in,out] poli Estructura \ref polil, que almacena una serie de polilíneas.
Al término de la ejecución de la función, se han añadido las
polilíneas pasados en \em x e \em y.
\param[in] x Vector que contiene las coordenadas X de los vértices de la
polilínea o polilíneas a añadir. Si hay varias polilíneas, han de
estar separadas por un valor #GEOC_NAN.
\param[in] y Vector que contiene las coordenadas Y de los vértices de la
polilínea o polilíneas a añadir. Si hay varias polilíneas, han de
estar separadas por un valor #GEOC_NAN.
\param[in] nElem Número de elementos de los vectores \em x e \em y.
\param[in] incX Posiciones de separación entre los elementos del vector \em x.
Este argumento siempre ha de ser un número positivo.
\param[in] incY Posiciones de separación entre los elementos del vector \em y.
Este argumento siempre ha de ser un número positivo.
\return Variable de error. Dos posibilidades:
- #GEOC_ERR_NO_ERROR: Todo ha ido bien.
- #GEOC_ERR_ASIG_MEMORIA: Ha ocurrido un error de asignación de memoria.
- #GEOC_ERR_POLIL_VEC_DISTINTO_NUM_POLIL: Los vectores \em x e \em y
contienen un número distinto de polilíneas. No contienen el mismo
número de identificadores #GEOC_NAN.
- #GEOC_ERR_POLIL_VEC_DISTINTAS_POLIL: Los vectores \em x e \em y
contienen distintas polilíneas. Los marcadores #GEOC_NAN no están
colocados en las mismas posiciones.
\note Esta función asume que la estructura de entrada \em poli tiene memoria
asignada.
\note En caso de error de asignación de memoria, la memoria de la estructura y
los vectores de entrada no se libera.
\note Si la estructura \em poli guarda información de límites de las polilíneas
almacenadas, esta información se calcula también para los nuevos datos.
\note Esta función no comprueba si el número de elementos de los vectores \em x
e \em y es congruente con los valores pasados de \em nElem, \em incX e
\em incY.
\note Si los vectores \em x e \em y almacenan varias polilíneas, éstas se
separan mediante valores #GEOC_NAN. Poner #GEOC_NAN en la primera posición
y/o la última es opcional.
\note Los posibles valores #GEOC_NAN han de estar en las mismas posiciones en
\em x e \em y.
\note Esta función crea internamente una estructura \ref polil para luego
añadirla a \em poli con la función \ref AnyadePolilPolil.
\date 03 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
int AnyadeDatosPolil(polil* poli,
const double* x,
const double* y,
const size_t nElem,
const size_t incX,
const size_t incY);
/******************************************************************************/
/******************************************************************************/
/**
\brief Libera la memoria asignada a una estructura \ref polil.
\param[in] datos Estructura \ref polil.
\date 03 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
void LibMemPolil(polil* datos);
/******************************************************************************/
/******************************************************************************/
/**
\brief Calcula los límites de todas las polilíneas almacenados en una estructura
\ref polil.
\param[in,out] poli Estructura \ref polil, que almacena una serie de polilíneas.
Al término de la ejecución de la función, se han añadido los
límites de las polilíneas almacenadas.
\return Variable de error. Dos posibilidades:
- #GEOC_ERR_NO_ERROR: Todo ha ido bien.
- #GEOC_ERR_ASIG_MEMORIA: Ha ocurrido un error de asignación de memoria.
\note Esta función está paralelizada con OpenMP.
\note Esta función asume que la estructura de entrada \ref polil tiene memoria
asignada.
\note En caso de error de asignación de memoria, la memoria de la estructura de
entrada no se libera.
\date 03 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
int CalcLimitesPolil(polil* poli);
/******************************************************************************/
/******************************************************************************/
/**
\brief Aplica un factor de escala y una traslación (en este orden) a las
coordenadas de todas las polilíneas almacenadas en una estructura
\ref polil.
\param[in,out] poli Estructura \ref polil, que almacena una serie de polilíneas.
Al término de la ejecución de la función, se ha aplicado un
factor de escala y una traslación (en este orden) a las
coordenadas de todas las polilíneas almacenadas y, si se indica,
a los límites.
\param[in] escalaX Factor de escala a aplicar a las coordenadas X.
\param[in] escalaY Factor de escala a aplicar a las coordenadas Y.
\param[in] trasladaX Traslación a aplicar a las coordenadas X.
\param[in] trasladaY Traslación a aplicar a las coordenadas Y.
\param[in] aplicaLim Identificador para aplicar o no los factores de escala y
las traslaciones a los límites de las polilíneas (sólo si están
previemente calculados). Dos posibilidades:
- 0: No se aplican los factores de escala ni las traslaciones a los
límites.
- Distinto de 0: Sí se aplican los factores de escala y las
traslaciones a los límites, si estos están calculados en la
estructura de entrada.
\note Esta función está paralelizada con OpenMP.
\note Primero se aplican los factores de escala y luego las traslaciones.
\note Esta función asume que la estructura de entrada \em poli tiene memoria
asignada.
\date 03 de junio de 2011: Creación de la función.
\date 18 de junio de 2011: Distinción entre factores de escala y traslaciones
para las coordenadas X e Y.
\note Esta función todavía no está probada.
*/
void EscalaYTrasladaPolil(polil* poli,
const double escalaX,
const double escalaY,
const double trasladaX,
const double trasladaY,
const int aplicaLim);
/******************************************************************************/
/******************************************************************************/
/**
\brief Aplica una traslación y un factor de escala (en este orden) a las
coordenadas de todas las polilíneas almacenadss en una estructura
\ref polil.
\param[in,out] poli Estructura \ref polil, que almacena una serie de polilíneas.
Al término de la ejecución de la función, se ha aplicado una
traslación y un factor de escala (en este orden) a las
coordenadas de todas las polilíneas almacenadas y, si se indica,
a los límites.
\param[in] escalaX Factor de escala a aplicar a las coordenadas X.
\param[in] escalaY Factor de escala a aplicar a las coordenadas Y.
\param[in] trasladaX Traslación a aplicar a las coordenadas X.
\param[in] trasladaY Traslación a aplicar a las coordenadas Y.
\param[in] aplicaLim Identificador para aplicar o no las traslaciones y los
factores de escala a los límites de las polilíneas (sólo si están
previemente calculados). Dos posibilidades:
- 0: No se aplican las traslaciones ni los factores de escala a los
límites.
- Distinto de 0: Sí se aplican las traslaciones y los factores de
escala a los límites, si estos están calculados en la estructura de
entrada.
\note Esta función está paralelizada con OpenMP.
\note Primero se aplican las traslaciones y luego los factores de escala.
\note Esta función asume que la estructura de entrada \em poli tiene memoria
asignada.
\date 03 de junio de 2011: Creación de la función.
\date 18 de junio de 2011: Distinción entre factores de escala y traslaciones
para las coordenadas X e Y.
\note Esta función todavía no está probada.
*/
void TrasladaYEscalaPolil(polil* poli,
const double escalaX,
const double escalaY,
const double trasladaX,
const double trasladaY,
const int aplicaLim);
/******************************************************************************/
/******************************************************************************/
/**
\brief Aplica un factor de escala y una traslación (el orden de aplicación se ha
de seleccionar) a las coordenadas de todas las polilíneas almacenadas en
una estructura \ref polil.
\param[in,out] poli Estructura \ref polil, que almacena una serie de polilíneas.
Al término de la ejecución de la función, se ha aplicado un
factor de escala y una traslación (orden a seleccionar) a las
coordenadas de todas las polilíneas almacenadas y, si se indica,
a los límites.
\param[in] escalaX Factor de escala a aplicar a las coordenadas X.
\param[in] escalaY Factor de escala a aplicar a las coordenadas Y.
\param[in] trasladaX Traslación a aplicar a las coordenadas X.
\param[in] trasladaY Traslación a aplicar a las coordenadas Y.
\param[in] orden Orden de aplicación de los factores de escala y traslación. Dos
posibilidades:
- 0: Primero se aplican los factores de escala y luego las
traslaciones \f$x'=f\cdot x+t\f$.
- Distinto de 0: Primero se aplican las traslaciones y luego los
factores de escala \f$x'=(x+t)\cdot f\f$.
\param[in] aplicaLim Identificador para aplicar o no los factores de escala y
las traslaciones a los límites de las polilíneas (sólo si están
previemente calculados). Dos posibilidades:
- 0: No se aplican los factores de escala ni las traslaciones a los
límites.
- Distinto de 0: Sí se aplican los factores de escala y las
traslaciones a los límites, si estos están calculados en la
estructura de entrada.
\note Esta función asume que la estructura de entrada \em poli tiene memoria
asignada.
\date 03 de junio de 2011: Creación de la función.
\date 18 de junio de 2011: Distinción entre factores de escala y traslaciones
para las coordenadas X e Y.
\note Esta función todavía no está probada.
*/
void MuevePolil(polil* poli,
const double escalaX,
const double escalaY,
const double trasladaX,
const double trasladaY,
const int orden,
const int aplicaLim);
/******************************************************************************/
/******************************************************************************/
/**
\brief Elimina vértices de las polilíneas almacenadas en una estructura
\ref polil mediante un algoritmo inspirado en el de Douglas-Peucker. Se
usa internamente la función \ref AligeraPolilinea.
\param[in,out] poli Estructura \ref polil, que almacena una serie de polilíneas.
Al término de la ejecución de la función, almacena el resultado
de la aplicación a cada polilínea del algoritmo de aligerado de
vértices implementado en la función \ref AligeraPolilinea.
\param[in] tol Tolerancia para eliminar vértices, en las mismas unidades que las
coordenadas de los vértices. Ver la ayuda de la función
\ref AligeraPolilinea.
\param[in] robusto Identificador para realizar o no un aligerado robusto. Ha de
ser un elemento del tipo enumerado #GEOC_DPEUCKER_ROBUSTO. Varias
posibilidades:
- #GeocDPeuckerRobNo: No se aplica el algoritmo robusto.
- #GeocDPeuckerRobSi: Se aplica el algoritmo robusto completo, que
garantiza la no ocurrencia de auto intersecciones en la polilínea
resultante. Internamente, primero se aplica el tratamiento robusto
de la opción #GeocDPeuckerRobOrig y luego el de la opción
#GeocDPeuckerRobAuto.
- #GeocDPeuckerRobOrig: Se aplica un algoritmo semi robusto que
consiste en garantizar que los segmentos de la polilínea aligerada
que se van creando no intersectarán con ninguno de los segmentos
que forman los vértices que quedan por procesar de la polilínea
original. En casos muy especiales, este algoritmo puede seguir
dando lugar a auto intersecciones.
- #GeocDPeuckerRobAuto: Se aplica un algoritmo semi robusto que
consiste en garantizar que los segmentos de la polilínea aligerada
que se van creando no intersectarán con ninguno de los segmentos de
la polilínea aligerada creados con anterioridad. En casos muy
especiales, este algoritmo puede seguir dando lugar a auto
intersecciones.
\param[in] nPtosRobusto Número de puntos de la polilínea original a utilizar en
el caso de tratamiento robusto con las opciones #GeocDPeuckerRobSi o
#GeocDPeuckerRobOrig. Si se pasa el valor 0, se utilizan todos los
puntos hasta el final de la polilínea original.
\param[in] nSegRobusto Número de segmentos de la polilínea aligerada a utilizar
en el caso de tratamiento robusto con las opciones #GeocDPeuckerRobSi
o #GeocDPeuckerRobAuto. Si se pasa el valor 0, se utilizan todos los
segmentos hasta el inicio de la polilínea aligerada.
\return Variable de error. Dos posibilidades:
- #GEOC_ERR_NO_ERROR: Todo ha ido bien.
- #GEOC_ERR_ASIG_MEMORIA: Ha ocurrido un error de asignación de memoria.
\note Esta función asume que \em poli está, como mínimo, inicializada.
\note Si \em poli tiene límites calculados en la entrada, también los tendrá en
la salida.
\note Una polilínea aligerada sólo será válida si después de aplicarle la
función \ref AligeraPolilinea mantiene un mínimo de 2 puntos que no sean
el mismo (esto sólo puede ocurrir si se pasa un polígono -los vértices de
inicio y final coinciden- y sólo quedan al final los extremos). Al término
de la ejecución de esta función, el resultado puede ser una estructura
\ref polil vacía.
\date 09 de julio de 2011: Creación de la función.
\date 10 de julio de 2011: Cambio del tipo del argumento \em robusto al tipo
enumerado #GEOC_DPEUCKER_ROBUSTO.
\date 31 de julio de 2011: Corregido error con índices a la hora de guardar los
resultados y modificación para no tomar como válidas las polilíneas que se
quedan en sólo dos vértices que sean el mismo.
\todo Esta función todavía no está probada.
*/
int AligeraPolil(polil* poli,
const double tol,
const enum GEOC_DPEUCKER_ROBUSTO robusto,
const size_t nPtosRobusto,
const size_t nSegRobusto);
/******************************************************************************/
/******************************************************************************/
/**
\brief Imprime una línea de cabecera para una polilínea almacenada en una
estructura \ref polil.
\param[in] poli Estructura \ref polil.
\param[in] indice Índice de la polilínea de trabajo en la estructura.
\param[in] iniCab Cadena de texto con la que comenzará la cabecera.
\param[in] impLim Identificador para imprimir o no los límites de coordenadas
de la polilínea de trabajo. Dos posibles valores:
- 0: No se imprimen.
- Distinto de 0: Sí se imprimen.
\param[in] formCoor Cadena de carácteres indicadora del formato para escribir
las coordenadas de los límites. Este argumento sólo se usa
internamente si se ha indicado la impresión de límites.
\param[in] factorX Factor para multiplicar las coordenadas X de los vértices
antes de imprimirlas.
\param[in] factorY Factor para multiplicar las coordenadas Y de los vértices
antes de imprimirlas.
\param[in] idFich Identificador de fichero abierto para escribir.
\note Esta función está paralelizada con OpenMP.
\note La cabecera completa tiene el siguiente formato:
<tt>iniCab númVert xMín xMáx yMín yMáx</tt>.
\note Si la estructura no tiene información de límites y se indica que se
impriman, los valores se calculan internamente.
\note Esta función asume que \em poli es una estructura \ref polil correctamente
almacenada.
\note Esta función no comprueba si la estructura pasada tiene memoria asignada.
\note Esta función no comprueba internamente la validez de los argumentos de
formato.
\note Esta función no comprueba internamente si el identificador pasado
corresponde a un fichero abierto para escribir.
\date 18 de junio de 2011: Creación de la función.
\note Esta función todavía no está probada.
*/
void ImprimeCabeceraPolilFichero(const polil* poli,
const size_t indice,
const char iniCab[],
const int impLim,
const char formCoor[],
const double factorX,
const double factorY,
FILE* idFich);
/******************************************************************************/
/******************************************************************************/
/**
\brief Imprime una estructura \ref polil en un fichero.
\param[in] poli Estructura \ref polil.
\param[in] factorX Factor para multiplicar las coordenadas X de los vértices
antes de imprimirlas.
\param[in] factorY Factor para multiplicar las coordenadas Y de los vértices
antes de imprimirlas.
\param[in] iniNan Identificador para imprimir o no la marca de separación de
polilíneas (\p NaN) delante de la primera polilínea. Dos posibles
valores:
- 0: No se imprime.
- Distinto de 0: Sí se imprime.
\param[in] finNan Identificador para imprimir o no la marca de separación de
polilíneas (\p NaN) delante de la última polilínea. Dos posibles
valores:
- 0: No se imprime.
- Distinto de 0: Sí se imprime.
\param[in] formCoor Cadena de carácteres indicadora del formato de cada
coordenada a imprimir.
\param[in] impCabecera Identificador para imprimir o no una cabecera con
información general por cada polilínea. Dos posibles valores:
- 0: No se imprime.
- Distinto de 0: Sí se imprime.
\param[in] iniCab Cadena de texto con la que comenzará la cabecera.
\param[in] impLim Identificador para imprimir o no en la cabecera los límites de
coordenadas de las polilíneas de trabajo. Dos posibles valores:
- 0: No se imprimen.
- Distinto de 0: Sí se imprimen.
\param[in] idFich Identificador de fichero abierto para escribir.
\note La cabecera completa tiene el siguiente formato:
<tt>iniCab númVert xMín xMáx yMín yMáx</tt>.
\note Si la estructura no tiene información de límites y se indica que se
impriman, los valores se calculan internamente.
\note Esta función asume que \em poli es una estructura \ref polil correctamente
almacenada.
\note Esta función no comprueba si la estructura pasada tiene memoria asignada.
\note Esta función no comprueba internamente la validez de los argumentos de
formato.
\note Esta función no comprueba internamente si el identificador pasado
corresponde a un fichero abierto para escribir.
\date 03 de junio de 2011: Creación de la función.
\date 18 de junio de 2011: Adición de la capacidad de escritura de una cabecera
y del uso de factores de escala independientes para las coordenadas X e Y.
\date 22 de septiembre de 2011: Corregido bug que hacía que, dependiendo del
compilador y/o los flags de optimización en la compilación, se imprimiesen
mal (con un signo menos delante) los valores Not-a-Number.
\note Esta función todavía no está probada.
*/
void ImprimePolilFichero(const polil* poli,
const double factorX,
const double factorY,
const int iniNan,
const int finNan,
const char formCoor[],
const int impCabecera,
const char iniCab[],
const int impLim,
FILE* idFich);
/******************************************************************************/
/******************************************************************************/
#ifdef __cplusplus
}
#endif
/******************************************************************************/
/******************************************************************************/
#endif
/******************************************************************************/
/******************************************************************************/
/** @} */
/******************************************************************************/
/******************************************************************************/
/* kate: encoding utf-8; end-of-line unix; syntax c; indent-mode cstyle; */
/* kate: replace-tabs on; space-indent on; tab-indents off; indent-width 4; */
/* kate: line-numbers on; folding-markers on; remove-trailing-space on; */
/* kate: backspace-indents on; show-tabs on; */
/* kate: word-wrap-column 80; word-wrap-marker-color #D2D2D2; word-wrap off; */