Menu
▾
▴
[Octave-cvsupdate] SF.net SVN: octave:[11095] trunk/octave-forge/main/geometry/inst/octclip
|
From: <jgp...@us...> - 2012-10-01 10:35:03
|
Revision: 11095
http://octave.svn.sourceforge.net/octave/?rev=11095&view=rev
Author: jgpallero
Date: 2012-10-01 10:34:50 +0000 (Mon, 01 Oct 2012)
Log Message:
-----------
Update OctCLIP in geometry package
Modified Paths:
--------------
trunk/octave-forge/main/geometry/inst/octclip/oc_polybool.m
trunk/octave-forge/main/geometry/inst/octclip/src/Makefile
trunk/octave-forge/main/geometry/inst/octclip/src/_oc_polybool.cc
trunk/octave-forge/main/geometry/inst/octclip/src/compilador.c
trunk/octave-forge/main/geometry/inst/octclip/src/errores.c
trunk/octave-forge/main/geometry/inst/octclip/src/eucli.c
trunk/octave-forge/main/geometry/inst/octclip/src/fgeneral.c
trunk/octave-forge/main/geometry/inst/octclip/src/greiner.c
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/compilador.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/constantes.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/errores.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/eucli.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/fgeneral.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/general.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/geom.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/greiner.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/polig.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/ptopol.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/segmento.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/ventorno.h
trunk/octave-forge/main/geometry/inst/octclip/src/polig.c
trunk/octave-forge/main/geometry/inst/octclip/src/ptopol.c
trunk/octave-forge/main/geometry/inst/octclip/src/segmento.c
trunk/octave-forge/main/geometry/inst/octclip/src/ventorno.c
Added Paths:
-----------
trunk/octave-forge/main/geometry/inst/octclip/src/calctopo.c
trunk/octave-forge/main/geometry/inst/octclip/src/dpeucker.c
trunk/octave-forge/main/geometry/inst/octclip/src/geocnan.c
trunk/octave-forge/main/geometry/inst/octclip/src/geocomp.c
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/calctopo.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/dpeucker.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/geocnan.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/geocomp.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/polil.h
trunk/octave-forge/main/geometry/inst/octclip/src/libgeoc/recpolil.h
trunk/octave-forge/main/geometry/inst/octclip/src/polil.c
trunk/octave-forge/main/geometry/inst/octclip/src/recpolil.c
Modified: trunk/octave-forge/main/geometry/inst/octclip/oc_polybool.m
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/oc_polybool.m 2012-10-01 10:14:28 UTC (rev 11094)
+++ trunk/octave-forge/main/geometry/inst/octclip/oc_polybool.m 2012-10-01 10:34:50 UTC (rev 11095)
@@ -17,8 +17,8 @@
## <http://www.gnu.org/licenses/>.
## -*- texinfo -*-
-## @deftypefn{Function File}{[@var{X},@var{Y},@var{nPol},@var{nInt},@var{nPert}] =}_oc_polybool(@var{sub},@var{clip},@var{op})
-## @deftypefnx{Function File}{[@var{X},@var{Y},@var{nPol},@var{nInt},@var{nPert}] =}_oc_polybool(@var{sub},@var{clip})
+## @deftypefn{Function File}{[@var{X},@var{Y},@var{nPol},@var{nInt},@var{nPert}] =}oc_polybool(@var{sub},@var{clip},@var{op})
+## @deftypefnx{Function File}{[@var{X},@var{Y},@var{nPol},@var{nInt},@var{nPert}] =}oc_polybool(@var{sub},@var{clip})
##
## This function performs boolean operations between two polygons using the
## Greiner-Hormann algorithm (http://davis.wpi.edu/~matt/courses/clipping/).
@@ -45,13 +45,13 @@
##
## For the matrices @var{sub} and @var{clip}, the first point is not needed to
## be repeated at the end (but is permitted). Pairs of (NaN,NaN) coordinates in
-## @var{sub} and/or @var{clip} are omitted.
+## @var{sub} and/or @var{clip} are ommitted.
##
-## @var{X} is a column vector containing the X coordinates of the vertices for.
-## resultant polygon(s).
+## @var{X} is a column vector containing the X coordinates of the vertices of
+## the resultant polygon(s).
##
-## @var{Y} is a column vector containing the Y coordinates of the vertices for.
-## resultant polygon(s).
+## @var{Y} is a column vector containing the Y coordinates of the vertices of
+## the resultant polygon(s).
##
## @var{nPol} is the number of output polygons.
##
Modified: trunk/octave-forge/main/geometry/inst/octclip/src/Makefile
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/Makefile 2012-10-01 10:14:28 UTC (rev 11094)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/Makefile 2012-10-01 10:34:50 UTC (rev 11095)
@@ -3,8 +3,9 @@
MKOCTFILE := mkoctfile
endif
-CLIPOBJECT = compilador.o errores.o eucli.o fgeneral.o greiner.o polig.o \
- ptopol.o segmento.o ventorno.o
+CLIPOBJECT = calctopo.o compilador.o dpeucker.o errores.o eucli.o fgeneral.o \
+ geocnan.o geocomp.o greiner.o polig.o polil.o ptopol.o recpolil.o \
+ segmento.o ventorno.o
FLAGS = -Wall -Wextra
%.o: %.c
Modified: trunk/octave-forge/main/geometry/inst/octclip/src/_oc_polybool.cc
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/_oc_polybool.cc 2012-10-01 10:14:28 UTC (rev 11094)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/_oc_polybool.cc 2012-10-01 10:34:50 UTC (rev 11095)
@@ -49,12 +49,12 @@
\n\
For the matrices @var{sub} and @var{clip}, the first point is not needed to\n\
be repeated at the end (but is permitted). Pairs of (NaN,NaN) coordinates in\n\
-@var{sub} and/or @var{clip} are omitted.\n\
+@var{sub} and/or @var{clip} are ommitted.\n\
\n\
-@var{X} is a column vector containing the X coordinates of the vertices for.\n\
-resultant polygon(s).\n\n\
-@var{Y} is a column vector containing the Y coordinates of the vertices for.\n\
-resultant polygon(s).\n\n\
+@var{X} is a column vector containing the X coordinates of the vertices of\n\
+the resultant polygon(s).\n\n\
+@var{Y} is a column vector containing the Y coordinates of the vertices of\n\
+the resultant polygon(s).\n\n\
@var{nPol} is the number of output polygons.\n\n\
@var{nInt} is the number of intersections between @var{sub} and @var{clip}.\n\n\
@var{nPert} is the number of perturbed points of the @var{clip} polygon in\n\
@@ -117,7 +117,7 @@
//operation identifier
enum GEOC_OP_BOOL_POLIG op=GeocOpBoolInter;
//output struct
- poligGreiner* result=NULL;
+ polig* result=NULL;
//number of polygons, intersections and perturbations
size_t nPol=0,nInter=0,nPert=0;
//number of elements for the output vectors
@@ -231,7 +231,7 @@
//free memory
LibMemPoliClip(polA);
LibMemPoliClip(polB);
- LibMemPoligGreiner(result);
+ LibMemPolig(result);
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
Added: trunk/octave-forge/main/geometry/inst/octclip/src/calctopo.c
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/calctopo.c (rev 0)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/calctopo.c 2012-10-01 10:34:50 UTC (rev 11095)
@@ -0,0 +1,71 @@
+/* -*- coding: utf-8 -*- */
+/**
+\ingroup geodesia geom
+@{
+\file calctopo.c
+\brief Definición de funciones para cálculos de topografía.
+\author José Luis García Pallero, jgp...@gm...
+\date 05 de julio 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.
+*/
+/******************************************************************************/
+/******************************************************************************/
+#include"libgeoc/calctopo.h"
+/******************************************************************************/
+/******************************************************************************/
+double AcimutTopografico(const double x1,
+ const double y1,
+ const double x2,
+ const double y2)
+{
+ //acimut calculado
+ double acimut=0.0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //calculamos el acimut en el dominio [-pi pi]
+ acimut = atan2(x2-x1,y2-y1);
+ //comprobamos si ha salido un valor negativo
+ if(acimut<0.0)
+ {
+ //metemos el valor en dominio
+ acimut += 2.0*GEOC_CONST_PI;
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return acimut;
+}
+/******************************************************************************/
+/******************************************************************************/
+/** @} */
+/******************************************************************************/
+/******************************************************************************/
+/* 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; */
Modified: trunk/octave-forge/main/geometry/inst/octclip/src/compilador.c
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/compilador.c 2012-10-01 10:14:28 UTC (rev 11094)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/compilador.c 2012-10-01 10:34:50 UTC (rev 11095)
@@ -73,3 +73,10 @@
/******************************************************************************/
/******************************************************************************/
/** @} */
+/******************************************************************************/
+/******************************************************************************/
+/* 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; */
Added: trunk/octave-forge/main/geometry/inst/octclip/src/dpeucker.c
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/dpeucker.c (rev 0)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/dpeucker.c 2012-10-01 10:34:50 UTC (rev 11095)
@@ -0,0 +1,472 @@
+/* -*- coding: utf-8 -*- */
+/**
+\ingroup geom
+@{
+\file dpeucker.c
+\brief Definición de funciones para el aligerado de polilíneas basadas en el
+ algoritmo de Douglas-Peucker.
+\author José Luis García Pallero, jgp...@gm...
+\date 04 de julio 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.
+*/
+/******************************************************************************/
+/******************************************************************************/
+#include"libgeoc/dpeucker.h"
+/******************************************************************************/
+/******************************************************************************/
+size_t* AligeraPolilinea(const double* x,
+ const double* y,
+ const size_t nPtos,
+ const size_t incX,
+ const size_t incY,
+ const double tol,
+ const enum GEOC_DPEUCKER_ROBUSTO robusto,
+ const size_t nPtosRobusto,
+ const size_t nSegRobusto,
+ size_t* nPtosSal)
+{
+ //índice para recorrer bucles
+ size_t p=0;
+ //índice de los puntos de trabajo
+ size_t i=0,j=0,k=0;
+ //coordenadas de trabajo
+ double xIni=0.0,yIni=0.0,xFin=0.0,yFin=0.0,xTrab=0.0,yTrab=0.0;
+ //altura del triángulo de trabajo
+ double h=0.0;
+ //variable indicadora de punto a mantener
+ int usado=0;
+ //número de elementos de trabajo internos del vector de salida
+ size_t nElem=0;
+ //vector de salida
+ size_t* sal=NULL;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //iniciamos la variable de salida de número de puntos a 0
+ *nPtosSal = 0;
+ //comprobamos casos especiales de nPtos
+ if(nPtos==0)
+ {
+ //salimos de la función con NULL
+ return NULL;
+ }
+ else if(nPtos<=2)
+ {
+ //asignamos el número de puntos usados
+ *nPtosSal = nPtos;
+ //asignamos memoria para el vector de salida
+ sal = (size_t*)malloc((*nPtosSal)*sizeof(size_t));
+ //comprobamos los posibles errores
+ if(sal==NULL)
+ {
+ //mensaje de error
+ GEOC_ERROR("Error de asignación de memoria");
+ //salimos de la función
+ return NULL;
+ }
+ //asignamos valores al vector de salida
+ for(i=0;i<(*nPtosSal);i++)
+ {
+ //asignamos el índice de trabajo
+ sal[i] = i;
+ }
+ //salimos de la función
+ return sal;
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //inicializamos el indicador interno de tamaño del vector
+ nElem = GEOC_DPEUCKER_BUFFER_PTOS;
+ //asignamos memoria para el vector de salida
+ sal = (size_t*)malloc(nElem*sizeof(size_t));
+ //comprobamos los posibles errores
+ if(sal==NULL)
+ {
+ //mensaje de error
+ GEOC_ERROR("Error de asignación de memoria");
+ //salimos de la función
+ return NULL;
+ }
+ //indicamos que el primer punto siempre se usa
+ *nPtosSal = 1;
+ sal[0] = 0;
+ //puntos de trabajo para iniciar los cálculos
+ i = 0;
+ j = 1;
+ k = 2;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //entramos en un bucle infinito
+ while(1)
+ {
+ //comprobamos si hay que salir del bucle
+ if(k>(nPtos-1))
+ {
+ //salimos del bucle
+ break;
+ }
+ //coordenadas de la base del triángulo
+ xIni = x[i*incX];
+ yIni = y[i*incY];
+ xFin = x[k*incX];
+ yFin = y[k*incY];
+ //inicializamos a 0 la variable de punto usado
+ usado = 0;
+ //recorremos los puntos a testear
+ for(p=j;p<k;p++)
+ {
+ //coordenadas del vértice del triángulo
+ xTrab = x[p*incX];
+ yTrab = y[p*incY];
+ //calculamos la altura del triángulo
+ h = AlturaTriangulo(xTrab,yTrab,xIni,yIni,xFin,yFin);
+ //comprobamos si la altura supera a la tolerancia
+ if(h>tol)
+ {
+ //indicamos que el punto ha sido usado
+ usado = 1;
+ //comprobamos si se utiliza el algoritmo robusto
+ if(robusto!=GeocDPeuckerRobNo)
+ {
+ //comprobamos si hay que aplicar el algoritmo de
+ //intersección con puntos originales
+ if((robusto==GeocDPeuckerRobSi)||
+ (robusto==GeocDPeuckerRobOrig))
+ {
+ //aplicamos el algoritmo
+ AligPolilRobIntersecOrig(x,y,nPtos,incX,incY,
+ nPtosRobusto,i,&p);
+ }
+ //comprobamos si hay que aplicar el algoritmo de auto
+ //intersección
+ if((robusto==GeocDPeuckerRobSi)||
+ (robusto==GeocDPeuckerRobAuto))
+ {
+ //indicamos un número de puntos para el vector de salida
+ //una unidad menor que el número realmente almacenado
+ //para evitar el segmento inmediatamente anterior al que
+ //vamos a crear
+ AligPolilRobAutoIntersec(x,y,incX,incY,sal,
+ (*nPtosSal)-1,nSegRobusto,i,
+ &p);
+ }
+ }
+ //añadimos al contador este nuevo punto
+ (*nPtosSal)++;
+ //comprobamos si hay que reasignar memoria
+ if((*nPtosSal)>nElem)
+ {
+ //añadimos otro grupo de puntos
+ nElem += GEOC_DPEUCKER_BUFFER_PTOS;
+ //asignamos memoria para el vector de salida
+ sal = (size_t*)realloc(sal,nElem*sizeof(size_t));
+ //comprobamos los posibles errores
+ if(sal==NULL)
+ {
+ //mensaje de error
+ GEOC_ERROR("Error de asignación de memoria");
+ //salimos de la función
+ return NULL;
+ }
+ }
+ //añadimos el nuevo punto usado
+ sal[(*nPtosSal)-1] = p;
+ //actualizamos los índices de los puntos de trabajo
+ i = p;
+ j = i+1;
+ k = j+1;
+ //salimos del bucle
+ break;
+ }
+ }
+ //comprobamos si no se ha utilizado ninguno de los vértices candidatos
+ if(!usado)
+ {
+ //pasamos al siguiente punto como extremo del segmento
+ k++;
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //comprobamos si el último punto se ha añadido
+ if(sal[(*nPtosSal)-1]!=(nPtos-1))
+ {
+ //añadimos al contador el último punto
+ (*nPtosSal)++;
+ //comprobamos si hay que reasignar memoria
+ if((*nPtosSal)>nElem)
+ {
+ //añadimos otro grupo de puntos
+ nElem += GEOC_DPEUCKER_BUFFER_PTOS;
+ //asignamos memoria para el vector de salida
+ sal = (size_t*)realloc(sal,nElem*sizeof(size_t));
+ //comprobamos los posibles errores
+ if(sal==NULL)
+ {
+ //mensaje de error
+ GEOC_ERROR("Error de asignación de memoria");
+ //salimos de la función
+ return NULL;
+ }
+ }
+ //asignamos el último punto
+ sal[(*nPtosSal)-1] = nPtos-1;
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //comprobamos si el vector de salida tiene demasiada memoria asignada
+ if(nElem>(*nPtosSal))
+ {
+ //ajustamos el tamaño del vector de salida
+ sal = (size_t*)realloc(sal,(*nPtosSal)*sizeof(size_t));
+ //comprobamos los posibles errores
+ if(sal==NULL)
+ {
+ //mensaje de error
+ GEOC_ERROR("Error de asignación de memoria");
+ //salimos de la función
+ return NULL;
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return sal;
+}
+/******************************************************************************/
+/******************************************************************************/
+void AligPolilRobIntersecOrig(const double* x,
+ const double* y,
+ const size_t nPtos,
+ const size_t incX,
+ const size_t incY,
+ const size_t ptosAUsar,
+ const size_t posIni,
+ size_t* posFin)
+{
+ //índices para recorrer bucles
+ size_t i=0,j=0;
+ //coordenadas de trabajo
+ double xA=0.0,yA=0.0,xB=0.0,yB=0.0,xC=0.0,yC=0.0,xD=0.0,yD=0.0;
+ //punto de parada para comprobar la intersección de segmentos
+ size_t parada=0;
+ //identificador de intersección
+ int inter=0;
+ //variables auxiliares
+ size_t aux=0;
+ double xAux=0.0,yAux=0.0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //contemplamos una posible salida rápida
+ if((*posFin)<=(posIni+1))
+ {
+ //salimos de la función
+ return;
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //calculamos el número de puntos que quedan hasta el final de los vectores
+ //de coordenadas desde la posición de fin de segmento (contándola)
+ aux = nPtos-(*posFin);
+ //calculamos el punto de parada para la intersección de segmentos
+ if((aux>ptosAUsar)&&(ptosAUsar!=0))
+ {
+ //paramos en un pnto tal que usemos ptosAUsar puntos
+ parada = *posFin+ptosAUsar-1;
+ }
+ else
+ {
+ //paramos en el penúltimo punto
+ parada = nPtos-2;
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //las coordenadas del punto inicial del segmento base no cambian nunca
+ xA = x[posIni*incX];
+ yA = y[posIni*incY];
+ //recorremos los puntos candidatos hasta el anterior al punto base
+ for(i=(*posFin);i>posIni;i--)
+ {
+ //comprobamos si estamos ante el punto posterior al inicial
+ if(i==(posIni+1))
+ {
+ //terminamos, porque este punto es el siguiente al punto base en el
+ //listado original
+ *posFin = i;
+ //salimos del bucle
+ break;
+ }
+ else
+ {
+ //coordenadas de los puntos inicial y final del segmento base
+ xB = x[i*incX];
+ yB = y[i*incY];
+ //recorremos los puntos posteriores hasta el de parada
+ for(j=i;j<=parada;j++)
+ {
+ //coordenadas de los puntos inicial y final del siguiente
+ //segmento
+ xC = x[j*incX];
+ yC = y[j*incY];
+ xD = x[(j+1)*incX];
+ yD = y[(j+1)*incY];
+ //calculamos la intersección entre los segmentos
+ inter = IntersecSegmentos2D(xA,yA,xB,yB,xC,yC,xD,yD,&xAux,
+ &yAux);
+ //comprobamos si hay intersección entre los segmentos
+ if(inter!=GEOC_SEG_NO_INTERSEC)
+ {
+ //salimos del bucle
+ break;
+ }
+ }
+ //comprobamos si no ha habido ninguna intersección
+ if(inter==GEOC_SEG_NO_INTERSEC)
+ {
+ //indicamos el índice del vértice final
+ *posFin = i;
+ //salimos del bucle
+ break;
+ }
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return;
+}
+/******************************************************************************/
+/******************************************************************************/
+void AligPolilRobAutoIntersec(const double* x,
+ const double* y,
+ const size_t incX,
+ const size_t incY,
+ const size_t* posAlig,
+ const size_t nPosAlig,
+ const size_t segAUsar,
+ const size_t posIni,
+ size_t* posFin)
+{
+ //índices para recorrer bucles
+ size_t i=0,j=0;
+ //variables de posición
+ size_t k=0,l=0,pos=0;
+ //coordenadas de trabajo
+ double xA=0.0,yA=0.0,xB=0.0,yB=0.0,xC=0.0,yC=0.0,xD=0.0,yD=0.0;
+ //número de segmentos calculados hasta ahora, excepto el último
+ size_t nSeg=0;
+ //identificador de intersección
+ int inter=0;
+ //variables auxiliares
+ double xAux=0.0,yAux=0.0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //contemplamos una posible salida rápida
+ if(((*posFin)<=(posIni+1))||(nPosAlig<2))
+ {
+ //salimos de la función
+ return;
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //calculamos el número de segmentos calculados hasta ahora, excepto el
+ //anterior al de trabajo
+ nSeg = nPosAlig-1;
+ //comprobamos si se usan todos los segmentos o sólo parte
+ if(segAUsar!=0)
+ {
+ //asignamos el número de segmentos a utilizar
+ nSeg = (nSeg>segAUsar) ? segAUsar : nSeg;
+ }
+ //las coordenadas del punto inicial del segmento base no cambian nunca
+ xA = x[posIni*incX];
+ yA = y[posIni*incY];
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //recorremos los puntos candidatos hasta el anterior al punto base
+ for(i=(*posFin);i>posIni;i--)
+ {
+ //comprobamos si estamos ante el punto posterior al inicial
+ if(i==(posIni+1))
+ {
+ //terminamos, porque este punto es el siguiente al punto inicial
+ *posFin = i;
+ //salimos del bucle
+ break;
+ }
+ else
+ {
+ //coordenadas del punto final del segmento base
+ xB = x[i*incX];
+ yB = y[i*incY];
+ //recorremos el número de segmentos de trabajo
+ for(j=0;j<nSeg;j++)
+ {
+ //posición del punto inicial del siguiente segmento anterior
+ pos = nPosAlig-1-j;
+ //índices inicial y final del siguiente segmento anterior
+ k = posAlig[pos];
+ l = posAlig[pos-1];
+ //puntos inicial y final del siguiente segmento
+ xC = x[k*incX];
+ yC = y[k*incY];
+ xD = x[l*incX];
+ yD = y[l*incY];
+ //calculamos la intersección entre los segmentos
+ inter = IntersecSegmentos2D(xA,yA,xB,yB,xC,yC,xD,yD,&xAux,
+ &yAux);
+ //comprobamos si hay intersección entre los segmentos
+ if(inter!=GEOC_SEG_NO_INTERSEC)
+ {
+ //salimos del bucle
+ break;
+ }
+ }
+ //comprobamos si no ha habido ninguna intersección
+ if(inter==GEOC_SEG_NO_INTERSEC)
+ {
+ //indicamos el índice del vértice final
+ *posFin = i;
+ //salimos del bucle
+ break;
+ }
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return;
+}
+/******************************************************************************/
+/******************************************************************************/
+/** @} */
+/******************************************************************************/
+/******************************************************************************/
+/* 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; */
Modified: trunk/octave-forge/main/geometry/inst/octclip/src/errores.c
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/errores.c 2012-10-01 10:14:28 UTC (rev 11094)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/errores.c 2012-10-01 10:34:50 UTC (rev 11095)
@@ -110,3 +110,10 @@
/******************************************************************************/
/******************************************************************************/
/** @} */
+/******************************************************************************/
+/******************************************************************************/
+/* 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; */
Modified: trunk/octave-forge/main/geometry/inst/octclip/src/eucli.c
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/eucli.c 2012-10-01 10:14:28 UTC (rev 11094)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/eucli.c 2012-10-01 10:34:50 UTC (rev 11095)
@@ -8,7 +8,7 @@
\author José Luis García Pallero, jgp...@gm...
\date 27 de octubre de 2009
\section Licencia Licencia
-Copyright (c) 2009-2010, José Luis García Pallero. All rights reserved.
+Copyright (c) 2009-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:
@@ -157,4 +157,82 @@
}
/******************************************************************************/
/******************************************************************************/
+double AnguloVecPlano(const double x1,
+ const double y1,
+ const double x2,
+ const double y2)
+{
+ //variables auxiliares
+ double num=0.0,den=0.0;
+ //variable de salida
+ double alfa=0.0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //calculamos el numerador de la fórmula que da el coseno del ángulo
+ num = x1*x2+y1*y2;
+ //calculamos el denominador de la fórmula que da el coseno del ángulo
+ den = sqrt((x1*x1+y1*y1)*(x2*x2+y2*y2));
+ //calculamos el coseno del ángulo, teniendo en cuenta casos singulares
+ if(den==0.0)
+ {
+ //si el denominador es 0.0, el ángulo es 0.0 y su coseno 1.0
+ alfa = 1.0;
+ }
+ else
+ {
+ //no hay singularidad
+ alfa = num/den;
+ }
+ //calculamos el ángulo
+ alfa = acos(alfa);
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return alfa;
+}
+/******************************************************************************/
+/******************************************************************************/
+double AlturaTriangulo(const double xVert,
+ const double yVert,
+ const double xBase1,
+ const double yBase1,
+ const double xBase2,
+ const double yBase2)
+{
+ //ángulo entra la base en el punto 1 y el vértice
+ double alfa=0.0;
+ //longitud del punto 1 de la base al vértice
+ double lon=0.0;
+ //variables auxiliares
+ double dxv=0.0,dyv=0.0,dxb=0.0,dyb=0.0;
+ //variable de salida
+ double h=0.0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //calculamos los incrementos de coordenadas auxiliares
+ dxv = xVert-xBase1;
+ dyv = yVert-yBase1;
+ dxb = xBase2-xBase1;
+ dyb = yBase2-yBase1;
+ //calculamos el ángulo entre la base y el segmento que une el punto inicial
+ //de ésta con el vértice
+ alfa = AnguloVecPlano(dxv,dyv,dxb,dyb);
+ //longitud del lado que une la base con el vértice 1 de la base
+ lon = sqrt(dxv*dxv+dyv*dyv);
+ //calculamos la altura
+ h = fabs(lon*sin(alfa));
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return h;
+}
+/******************************************************************************/
+/******************************************************************************/
/** @} */
+/******************************************************************************/
+/******************************************************************************/
+/* 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; */
Modified: trunk/octave-forge/main/geometry/inst/octclip/src/fgeneral.c
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/fgeneral.c 2012-10-01 10:14:28 UTC (rev 11094)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/fgeneral.c 2012-10-01 10:34:50 UTC (rev 11095)
@@ -5,6 +5,7 @@
\file fgeneral.c
\brief Definición de funciones de utilidad general.
\author José Luis García Pallero, jgp...@gm...
+\note Este fichero contiene funciones paralelizadas con OpenMP.
\date 10 de octubre de 2009
\version 1.0
\section Licencia Licencia
@@ -38,6 +39,65 @@
#include"libgeoc/fgeneral.h"
/******************************************************************************/
/******************************************************************************/
+int GeocParOmpFgeneral(char version[])
+{
+ //comprobamos si hay paralelización
+#if defined(_OPENMP)
+ //comprobamos si hay que extraer versión
+ if(version!=NULL)
+ {
+ //calculamos la versión
+ VersionOpenMP(_OPENMP,version);
+ }
+ //salimos de la función
+ return 1;
+#else
+ if(version!=NULL)
+ {
+ //utilizamos la variable version para que no dé warming al compilar
+ strcpy(version,"");
+ }
+ //salimos de la función
+ return 0;
+#endif
+}
+/******************************************************************************/
+/******************************************************************************/
+double PonAnguloDominio(const double angulo)
+{
+ //signo del ángulo de trabajo
+ double signo=0.0;
+ //2.0*pi
+ double dosPi=2.0*GEOC_CONST_PI;
+ //variable auxiliar
+ double aux=angulo;
+ //variable de salida
+ double sal=0.0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //sólo trabajamos si el valor de entrada está fuera de los límites
+ if((angulo<=-dosPi)||(angulo>=dosPi))
+ {
+ //extraemos el signo del ángulo pasado
+ signo = GEOC_SIGNO(angulo);
+ //valor absoluto del ángulo pasado
+ aux = fabs(angulo);
+ //metemos el ángulo en dominio eliminando la cantidad que se pase de
+ //2.0*pi
+ sal = signo*(aux-floor(aux/dosPi)*dosPi);
+ }
+ else
+ {
+ //el valor de entrada no cambia
+ sal = angulo;
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return sal;
+}
+/******************************************************************************/
+/******************************************************************************/
void BuscaSegmento1DInc(const double valor,
const double* lista,
const size_t nDatos,
@@ -171,7 +231,7 @@
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//calculamos la fila y comprobamos si es el extremo S
- *fil = f-1-(size_t)((yPto-yMin)/pasoY);
+ *fil = (size_t)(fabs(yPto-yMax)/pasoY);
if(*fil==(f-1))
{
//retrasamos una fila
@@ -191,13 +251,250 @@
}
/******************************************************************************/
/******************************************************************************/
+double Minimo(const double* lista,
+ const size_t nDatos,
+ const size_t incDatos)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ //variable de salida, inicializada como el máximo valor para un double
+ double salida=DBL_MAX;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //paralelización con OpenMP, sólo si la versión es superior a la 3.0
+ //en versiones anteriores no existe la posibilidad de usar reduction(min:)
+#if defined(_OPENMP)&&(_OPENMP>=GEOC_OMP_F_3_1)
+#pragma omp parallel for default(none) \
+ shared(lista) \
+ private(i,pos) \
+ reduction(min:salida)
+#endif
+ //recorremos el resto de elementos de la lista
+ for(i=0;i<nDatos;i++)
+ {
+ //posición del elemento a comprobar
+ pos = i*incDatos;
+ //comprobamos si el elemento actual es menor que el considerado menor
+ if(lista[pos]<salida)
+ {
+ //asignamos el nuevo valor menor
+ salida = lista[pos];
+ }
+ } // --> fin del #pragma omp parallel for
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return salida;
+}
+/******************************************************************************/
+/******************************************************************************/
+double Maximo(const double* lista,
+ const size_t nDatos,
+ const size_t incDatos)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ //variable de salida, inicializada como el mínimo valor para un double
+ double salida=DBL_MIN;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //paralelización con OpenMP, sólo si la versión es superior a la 3.0
+ //en versiones anteriores no existe la posibilidad de usar reduction(max:)
+#if defined(_OPENMP)&&(_OPENMP>=GEOC_OMP_F_3_1)
+#pragma omp parallel for default(none) \
+ shared(lista) \
+ private(i,pos) \
+ reduction(max:salida)
+#endif
+ //recorremos el resto de elementos de la lista
+ for(i=0;i<nDatos;i++)
+ {
+ //posición del elemento a comprobar
+ pos = i*incDatos;
+ //comprobamos si el elemento actual es mayor que el considerado mayor
+ if(lista[pos]>salida)
+ {
+ //asignamos el nuevo valor menor
+ salida = lista[pos];
+ }
+ } // --> fin del #pragma omp parallel for
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return salida;
+}
+/******************************************************************************/
+/******************************************************************************/
+double MinimoAbs(const double* lista,
+ const size_t nDatos,
+ const size_t incDatos)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ //variable de salida, inicializada como el máximo valor para un double
+ double salida=DBL_MAX;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //paralelización con OpenMP, sólo si la versión es superior a la 3.0
+ //en versiones anteriores no existe la posibilidad de usar reduction(min:)
+#if defined(_OPENMP)&&(_OPENMP>=GEOC_OMP_F_3_1)
+#pragma omp parallel for default(none) \
+ shared(lista) \
+ private(i,pos) \
+ reduction(min:salida)
+#endif
+ //recorremos el resto de elementos de la lista
+ for(i=0;i<nDatos;i++)
+ {
+ //posición del elemento a comprobar
+ pos = i*incDatos;
+ //comprobamos si el elemento actual es menor que el considerado menor
+ if(fabs(lista[pos])<salida)
+ {
+ //asignamos el nuevo valor menor
+ salida = fabs(lista[pos]);
+ }
+ } // --> fin del #pragma omp parallel for
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return salida;
+}
+/******************************************************************************/
+/******************************************************************************/
+double MaximoAbs(const double* lista,
+ const size_t nDatos,
+ const size_t incDatos)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ //variable de salida, inicializada como 0.0 (trabajamos en valor absoluto)
+ double salida=0.0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //paralelización con OpenMP, sólo si la versión es superior a la 3.0
+ //en versiones anteriores no existe la posibilidad de usar reduction(max:)
+#if defined(_OPENMP)&&(_OPENMP>=GEOC_OMP_F_3_1)
+#pragma omp parallel for default(none) \
+ shared(lista) \
+ private(i,pos) \
+ reduction(max:salida)
+#endif
+ //recorremos el resto de elementos de la lista
+ for(i=0;i<nDatos;i++)
+ {
+ //posición del elemento a comprobar
+ pos = i*incDatos;
+ //comprobamos si el elemento actual es mayor que el considerado mayor
+ if(fabs(lista[pos])>salida)
+ {
+ //asignamos el nuevo valor menor
+ salida = fabs(lista[pos]);
+ }
+ } // --> fin del #pragma omp parallel for
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return salida;
+}
+/******************************************************************************/
+/******************************************************************************/
+size_t MinimoSizeT(const size_t* lista,
+ const size_t nDatos,
+ const size_t incDatos)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ //variable de salida, inicializada como el máximo valor para un size_t
+ size_t salida=SIZE_MAX;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //paralelización con OpenMP, sólo si la versión es superior a la 3.0
+ //en versiones anteriores no existe la posibilidad de usar reduction(min:)
+#if defined(_OPENMP)&&(_OPENMP>=GEOC_OMP_F_3_1)
+#pragma omp parallel for default(none) \
+ shared(lista) \
+ private(i,pos) \
+ reduction(min:salida)
+#endif
+ //recorremos el resto de elementos de la lista
+ for(i=0;i<nDatos;i++)
+ {
+ //posición del elemento a comprobar
+ pos = i*incDatos;
+ //comprobamos si el elemento actual es menor que el considerado menor
+ if(lista[pos]<salida)
+ {
+ //asignamos el nuevo valor menor
+ salida = lista[pos];
+ }
+ } // --> fin del #pragma omp parallel for
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return salida;
+}
+/******************************************************************************/
+/******************************************************************************/
+size_t MaximoSizeT(const size_t* lista,
+ const size_t nDatos,
+ const size_t incDatos)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ //variable de salida, inicializada como 0 (size_t es sólo positivo)
+ size_t salida=0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //paralelización con OpenMP, sólo si la versión es superior a la 3.0
+ //en versiones anteriores no existe la posibilidad de usar reduction(max:)
+#if defined(_OPENMP)&&(_OPENMP>=GEOC_OMP_F_3_1)
+#pragma omp parallel for default(none) \
+ shared(lista) \
+ private(i,pos) \
+ reduction(max:salida)
+#endif
+ //recorremos el resto de elementos de la lista
+ for(i=0;i<nDatos;i++)
+ {
+ //posición del elemento a comprobar
+ pos = i*incDatos;
+ //comprobamos si el elemento actual es mayor que el considerado mayor
+ if(lista[pos]>salida)
+ {
+ //asignamos el nuevo valor menor
+ salida = lista[pos];
+ }
+ } // --> fin del #pragma omp parallel for
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return salida;
+}
+/******************************************************************************/
+/******************************************************************************/
void MinMax(const double* lista,
const size_t nDatos,
+ const size_t incDatos,
size_t* posMin,
size_t* posMax)
{
//índice para recorrer bucles
size_t i=0;
+ //variable de posición
+ size_t pos=0;
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//consideramos que el primer elemento es el mayor y el menor
@@ -206,14 +503,16 @@
//recorremos el resto de elementos de la lista
for(i=1;i<nDatos;i++)
{
+ //posición del elemento a comprobar
+ pos = i*incDatos;
//comprobamos si el elemento actual es menor que el considerado menor
- if(lista[i]<lista[*posMin])
+ if(lista[pos]<lista[(*posMin)*incDatos])
{
//asignamos la nueva posición
*posMin = i;
}
//comprobamos si el elemento actual es mayor que el considerado mayor
- if(lista[i]>lista[*posMax])
+ if(lista[pos]>lista[(*posMax)*incDatos])
{
//asignamos la nueva posición
*posMax = i;
@@ -228,11 +527,14 @@
/******************************************************************************/
void MinMaxAbs(const double* lista,
const size_t nDatos,
+ const size_t incDatos,
size_t* posMin,
size_t* posMax)
{
//índice para recorrer bucles
size_t i=0;
+ //variable de posición
+ size_t pos=0;
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//consideramos que el primer elemento es el mayor y el menor
@@ -241,14 +543,16 @@
//recorremos el resto de elementos de la lista
for(i=1;i<nDatos;i++)
{
+ //posición del elemento a comprobar
+ pos = i*incDatos;
//comprobamos si el elemento actual es menor que el considerado menor
- if(fabs(lista[i])<fabs(lista[*posMin]))
+ if(fabs(lista[pos])<fabs(lista[(*posMin)*incDatos]))
{
//asignamos la nueva posición
*posMin = i;
}
//comprobamos si el elemento actual es mayor que el considerado mayor
- if(fabs(lista[i])>fabs(lista[*posMax]))
+ if(fabs(lista[pos])>fabs(lista[(*posMax)*incDatos]))
{
//asignamos la nueva posición
*posMax = i;
@@ -263,11 +567,14 @@
/******************************************************************************/
void MinMaxSizeT(const size_t* lista,
const size_t nDatos,
+ const size_t incDatos,
size_t* posMin,
size_t* posMax)
{
//índice para recorrer bucles
size_t i=0;
+ //variable de posición
+ size_t pos=0;
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//consideramos que el primer elemento es el mayor y el menor
@@ -276,14 +583,16 @@
//recorremos el resto de elementos de la lista
for(i=1;i<nDatos;i++)
{
+ //posición del elemento a comprobar
+ pos = i*incDatos;
//comprobamos si el elemento actual es menor que el considerado menor
- if(lista[i]<lista[*posMin])
+ if(lista[pos]<lista[(*posMin)*incDatos])
{
//asignamos la nueva posición
*posMin = i;
}
//comprobamos si el elemento actual es mayor que el considerado mayor
- if(lista[i]>lista[*posMax])
+ if(lista[pos]>lista[(*posMax)*incDatos])
{
//asignamos la nueva posición
*posMax = i;
@@ -363,22 +672,6 @@
}
/******************************************************************************/
/******************************************************************************/
-double GeocNan(void)
-{
- //devolvemos el valor de NaN
- //le calculamos el valor absoluto porque, en algunos sistemas, al imprimir
- //un valor GEOC_NAN normal, éste sale con un signo negativo delante
- return fabs(GEOC_NAN);
-}
-/******************************************************************************/
-/******************************************************************************/
-int EsGeocNan(const double valor)
-{
- //comparamos y salimos de la función
- return valor!=valor;
-}
-/******************************************************************************/
-/******************************************************************************/
size_t* PosRepeEnVector(const double* datos,
const size_t nDatos,
const size_t incDatos,
@@ -497,4 +790,91 @@
}
/******************************************************************************/
/******************************************************************************/
+void EscalaYTrasladaVector(double* vector,
+ const size_t nElem,
+ const size_t inc,
+ const double escala,
+ const double traslada)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //distinguimos entre incremento igual a 1 o mayor
+ if(inc==1)
+ {
+ //recorremos los elementos del vector
+ for(i=0;i<nElem;i++)
+ {
+ //primero factor de escala y luego traslación
+ vector[i] = vector[i]*escala+traslada;
+ }
+ }
+ else
+ {
+ //recorremos los elementos del vector
+ for(i=0;i<nElem;i++)
+ {
+ //posición en el vector de trabajo
+ pos = i*inc;
+ //primero factor de escala y luego traslación
+ vector[pos] = vector[pos]*escala+traslada;
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return;
+}
+/******************************************************************************/
+/******************************************************************************/
+void TrasladaYEscalaVector(double* vector,
+ const size_t nElem,
+ const size_t inc,
+ const double escala,
+ const double traslada)
+{
+ //índice para recorrer bucles
+ size_t i=0;
+ //variable de posición
+ size_t pos=0;
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //distinguimos entre incremento igual a 1 o mayor
+ if(inc==1)
+ {
+ //recorremos los elementos del vector
+ for(i=0;i<nElem;i++)
+ {
+ //primero traslación y luego factor de escala
+ vector[i] = (vector[i]+traslada)*escala;
+ }
+ }
+ else
+ {
+ //recorremos los elementos del vector
+ for(i=0;i<nElem;i++)
+ {
+ //posición en el vector de trabajo
+ pos = i*inc;
+ //primero traslación y luego factor de escala
+ vector[pos] = (vector[pos]+traslada)*escala;
+ }
+ }
+ ////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////
+ //salimos de la función
+ return;
+}
+/******************************************************************************/
+/******************************************************************************/
/** @} */
+/******************************************************************************/
+/******************************************************************************/
+/* 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; */
Added: trunk/octave-forge/main/geometry/inst/octclip/src/geocnan.c
===================================================================
--- trunk/octave-forge/main/geometry/inst/octclip/src/geocnan.c (rev 0)
+++ trunk/octave-forge/main/geometry/inst/octclip/src/geocnan.c 2012-10-01 10:34:50 UTC (rev 11095)
@@ -0,0 +1,184 @@
+/* -*- coding: utf-8 -*- */
+/**
+\ingroup geocnan geom matriz gshhs
+@{
+\file geocnan.c
+\brief Definición de funciones para el trabajo con constantes Not-a-Number.
+\author José Luis García Pallero, jgp...@gm...
+\date 26 de mayo de 2011
+\version 1.0
+\section Licencia Licencia
+Copyright (c) 2010-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
+...
[truncated message content] |
