Menu
▾
▴
[Octave-cvsupdate] SF.net SVN: octave:[11093] trunk/octave-forge/main
|
From: <jgp...@us...> - 2012-10-01 09:15:30
|
Revision: 11093
http://octave.svn.sourceforge.net/octave/?rev=11093&view=rev
Author: jgpallero
Date: 2012-10-01 09:15:16 +0000 (Mon, 01 Oct 2012)
Log Message:
-----------
Update OctCLIP to version 1.0.2 and OctPROJ to version 1.1.1
Modified Paths:
--------------
trunk/octave-forge/main/octclip/ChangeLog
trunk/octave-forge/main/octclip/DESCRIPTION
trunk/octave-forge/main/octclip/doc/octclip.pdf
trunk/octave-forge/main/octclip/doc/octclip.tex
trunk/octave-forge/main/octclip/inst/oc_polybool.m
trunk/octave-forge/main/octclip/src/Makefile
trunk/octave-forge/main/octclip/src/_oc_polybool.cc
trunk/octave-forge/main/octclip/src/compilador.c
trunk/octave-forge/main/octclip/src/errores.c
trunk/octave-forge/main/octclip/src/eucli.c
trunk/octave-forge/main/octclip/src/fgeneral.c
trunk/octave-forge/main/octclip/src/greiner.c
trunk/octave-forge/main/octclip/src/libgeoc/compilador.h
trunk/octave-forge/main/octclip/src/libgeoc/constantes.h
trunk/octave-forge/main/octclip/src/libgeoc/errores.h
trunk/octave-forge/main/octclip/src/libgeoc/eucli.h
trunk/octave-forge/main/octclip/src/libgeoc/fgeneral.h
trunk/octave-forge/main/octclip/src/libgeoc/general.h
trunk/octave-forge/main/octclip/src/libgeoc/geom.h
trunk/octave-forge/main/octclip/src/libgeoc/greiner.h
trunk/octave-forge/main/octclip/src/libgeoc/polig.h
trunk/octave-forge/main/octclip/src/libgeoc/ptopol.h
trunk/octave-forge/main/octclip/src/libgeoc/segmento.h
trunk/octave-forge/main/octclip/src/libgeoc/ventorno.h
trunk/octave-forge/main/octclip/src/polig.c
trunk/octave-forge/main/octclip/src/ptopol.c
trunk/octave-forge/main/octclip/src/segmento.c
trunk/octave-forge/main/octclip/src/ventorno.c
trunk/octave-forge/main/octproj/ChangeLog
trunk/octave-forge/main/octproj/DESCRIPTION
trunk/octave-forge/main/octproj/doc/octproj.pdf
trunk/octave-forge/main/octproj/doc/octproj.tex
trunk/octave-forge/main/octproj/src/Makefile
Added Paths:
-----------
trunk/octave-forge/main/octclip/src/calctopo.c
trunk/octave-forge/main/octclip/src/dpeucker.c
trunk/octave-forge/main/octclip/src/geocnan.c
trunk/octave-forge/main/octclip/src/geocomp.c
trunk/octave-forge/main/octclip/src/libgeoc/calctopo.h
trunk/octave-forge/main/octclip/src/libgeoc/dpeucker.h
trunk/octave-forge/main/octclip/src/libgeoc/geocnan.h
trunk/octave-forge/main/octclip/src/libgeoc/geocomp.h
trunk/octave-forge/main/octclip/src/libgeoc/polil.h
trunk/octave-forge/main/octclip/src/libgeoc/recpolil.h
trunk/octave-forge/main/octclip/src/polil.c
trunk/octave-forge/main/octclip/src/recpolil.c
Modified: trunk/octave-forge/main/octclip/ChangeLog
===================================================================
--- trunk/octave-forge/main/octclip/ChangeLog 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/ChangeLog 2012-10-01 09:15:16 UTC (rev 11093)
@@ -1,8 +1,93 @@
+2012-10-01 José Luis García Pallero <jgp...@gm...>
+
+ * DESCRIPTION:
+ Update version number and date in DESCRIPTION file
+ [f06e99c0b026] [tip]
+
+ * .hgtags:
+ Version 1.0.2
+ [a38b95e66500]
+
+ * doc/octclip.pdf, doc/octclip.tex:
+ Update documentation
+ [2310bc775bea] [OctCLIP-1.0.2]
+
+2012-09-30 José Luis García Pallero <jgp...@gm...>
+
+ * inst/oc_polybool.m, src/_oc_polybool.cc:
+ Fix function help text
+ [ca8c9ba38288]
+
+ * src/Makefile:
+ Supression of compiler flag not common to all archs
+ [e5d734f4c6d0]
+
+2012-04-17 José Luis García Pallero <jgp...@gm...>
+
+ * src/Makefile:
+ Changes in src/Makefile in ordert to pass warning and optimisation
+ flags to mkoctfile
+ [ec407713d9ac]
+
+ * .hgignore:
+ Update .hgignore file in mercurial repo
+ [e493dfb8efb7]
+
+2012-04-13 José Luis García Pallero <jgp...@gm...>
+
+ * doc/octclip.pdf, doc/octclip.tex:
+ Change author's affiliation and dates in the reference manual
+ [6292fc806330]
+
+2011-11-21 José Luis García Pallero <jgp...@gm...>
+
+ * .hgtags:
+ Version 1.0.1
+ [c77ff2bf09d4]
+
+ * DESCRIPTION:
+ Change version number and date
+ [406c40e732a5] [OctCLIP-1.0.1]
+
+ * src/_oc_polybool.cc:
+ Minor changes due to changes in the Greiner-Hormann API
+ [ecd2084e9cea]
+
+ * src/Makefile:
+ Update Makefile with the new files
+ [9c07e48ee665]
+
+ * src/calctopo.c, src/compilador.c, src/dpeucker.c, src/errores.c,
+ src/eucli.c, src/fgeneral.c, src/geocnan.c, src/geocomp.c,
+ src/greiner.c, src/libgeoc/calctopo.h, src/libgeoc/compilador.h,
+ src/libgeoc/constantes.h, src/libgeoc/dpeucker.h,
+ src/libgeoc/errores.h, src/libgeoc/eucli.h, src/libgeoc/fgeneral.h,
+ src/libgeoc/general.h, src/libgeoc/geocnan.h, src/libgeoc/geocomp.h,
+ src/libgeoc/geom.h, src/libgeoc/greiner.h, src/libgeoc/polig.h,
+ src/libgeoc/polil.h, src/libgeoc/ptopol.h, src/libgeoc/recpolil.h,
+ src/libgeoc/segmento.h, src/libgeoc/ventorno.h, src/polig.c,
+ src/polil.c, src/ptopol.c, src/recpolil.c, src/segmento.c,
+ src/ventorno.c:
+ Add changes and new files fron the original source of my Greiner-
+ Hormann implementation. OctCLIP code comes from a personal library
+ not yet published
+ [fccf93621aa8]
+
+2011-06-12 José Luis García Pallero <jgp...@gm...>
+
+ * doc/octclip.pdf, doc/octclip.tex:
+ LaTeX documentation update
+ [9c92a3d8fd20]
+
2011-06-07 José Luis García Pallero <jgp...@gm...>
+ * inst/oc_polybool.m:
+ Fix documentation
+ [f970d69207fd]
+
* INDEX:
Remove test_octclip from 'INDEX' file
- [5e2dd1fd23fc] [tip]
+ [5e2dd1fd23fc]
* inst/oc_polybool.m:
Add the content of old 'test_octclip.m' program into 'oc_polybool.m'
Modified: trunk/octave-forge/main/octclip/DESCRIPTION
===================================================================
--- trunk/octave-forge/main/octclip/DESCRIPTION 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/DESCRIPTION 2012-10-01 09:15:16 UTC (rev 11093)
@@ -1,8 +1,8 @@
Name: OctCLIP
-Version: 1.0.0
-Date: 2011-03-01
-Author: José Luis García Pallero <jgp...@gm...>
-Maintainer: José Luis García Pallero <jgp...@gm...>
+Version: 1.0.2
+Date: 2012-10-01
+Author: José Luis García Pallero, <jgp...@gm...>
+Maintainer: José Luis García Pallero, <jgp...@gm...>
Title: GNU Octave clipping polygons tool
Description: This package allows to do boolean operations with polygons using
the Greiner-Hormann algorithm.
Modified: trunk/octave-forge/main/octclip/doc/octclip.pdf
===================================================================
(Binary files differ)
Modified: trunk/octave-forge/main/octclip/doc/octclip.tex
===================================================================
--- trunk/octave-forge/main/octclip/doc/octclip.tex 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/doc/octclip.tex 2012-10-01 09:15:16 UTC (rev 11093)
@@ -9,10 +9,12 @@
\title{Clipping polygons from \octave\footnote{This document is distributed
under the terms of the GNU Free Documentation License. Please, see
\url{http://www.gnu.org/licenses/}}}
-\author{Jos\'e Luis Garc\'ia Pallero\footnote{Instituto de Astronom\'ia y
- Geodesia, Fac. de CC Matem\'aticas, Universidad Complutense de Madrid.
- \texttt{jlg...@pd...}, \texttt{jgp...@gm...}}}
-\date{\today}
+\author{Jos\'e Luis Garc\'ia Pallero\footnote{ETSI en Topograf\'ia, Geodesia y
+ Cartograf\'ia, Universidad Polit\'ecnica de Madrid.
+ \texttt{jlg...@up...}, \texttt{jgp...@gm...}}}
+\date{October 1, 2012 (version 1.0.2)\\
+ November 21, 2011 (version 1.0.1)\\
+ May 24, 2011 (version 1.0.0)}
\begin{document}
\maketitle
@@ -32,22 +34,22 @@
\section{Overview}
The \octclip{} package allows you to perform boolean operations (intersection,
-union and difference) between two polygons in \octave{} using the
+union, difference and exclusive or) between two polygons in \octave{} using the
Greiner-Hormann algorithm\footnote{\cite{greiner1998} and
\url{http://davis.wpi.edu/~matt/courses/clipping/}}.
Greiner-Hormann is an efficient algorithm for clipping arbitrary 2D polygons.
-The algorithm can handle arbitrary closed polygons, specifically where the
+The algorithm can handle arbitrary closed polygons, specifically where the
subject and clip polygons may self-intersect.
\section{Installation}
-As several \octave{} packages, \octclip{} installation consists in compiling the
+As most of \octave{} packages, \octclip{} installation consists in compiling the
C++ kernel sources, link them against \octave{} library to generate
\texttt{*.oct} functions and copy this \texttt{*.oct} executables and other
\texttt{*.m} functions into a working directory.
-The automatic procedure can be easily done by running the command:
+The automagic procedure can be easily done by running the command:
\begin{verbatim}
octave:1> pkg install octclip-x.x.x.tar.gz
@@ -71,7 +73,7 @@
The function is:
\begin{itemize}
-\item \texttt{\_oc\_polybool}: boolean operation between two polygons.
+\item \texttt{\_oc\_polybool}: Performs boolean operation between two polygons.
\end{itemize}
\subsection{\texttt{*.m} function}
@@ -83,21 +85,21 @@
The function is the same as in section \ref{op-of} (without the \texttt{\_} at
the beginning of the name):
\begin{itemize}
-\item \texttt{oc\_polybool}: calls \texttt{\_oc\_polybool}.
+\item \texttt{oc\_polybool}: Performs boolean operation between two polygons
+ by calling the \texttt{\_oc\_polybool}.
\end{itemize}
-A test script for the package exists too:
+\texttt{oc\_polybool} includes too some demonstration code in order to test the
+functionality of the functions. The demo code can be executed as:
+\begin{verbatim}
+octave:1> demo oc_polybool
+\end{verbatim}
-\begin{itemize}
-\item \texttt{test\_octclip}: plots an example of the \texttt{oc\_polybool}
- usage.
-\end{itemize}
-
\subsection{Error handling}
-\texttt{*.oct} and \texttt{*.m} functions can emit errors, some due to errors in
-input arguments and other due to errors in functions from the C\footnote{The
-algorithm is internally implemented in C (C99 standard).} code.
+\texttt{*.oct} and \texttt{*.m} functions can emit errors, some due to errors
+with input arguments and other due to errors in functions from the
+C\footnote{The algorithm is internally implemented in C (C99 standard).} code.
Errors due to wrong input arguments (data types, dimensions, etc.) can be only
given for \texttt{*.m} function and this is the reason because the use of this
@@ -108,7 +110,7 @@
arguments, wrong value of the operation identifier and internal errors of memory
allocation.
-\section{Caveats}
+\section{Caveats of Greiner-Hormann algorithm}
To do.
@@ -116,6 +118,12 @@
To do.
+\section{Notes}
+
+Apart from \url{http://octave.sourceforge.net/octclip/index.html}, an up to date
+version of \octclip{} can be downloaded from
+\url{https://bitbucket.org/jgpallero/octclip/}.
+
% \subsection{Geodetic to geocentric and vice versa}
%
% \begin{verbatim}
Modified: trunk/octave-forge/main/octclip/inst/oc_polybool.m
===================================================================
--- trunk/octave-forge/main/octclip/inst/oc_polybool.m 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/inst/oc_polybool.m 2012-10-01 09:15:16 UTC (rev 11093)
@@ -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/).
@@ -47,11 +47,11 @@
## be repeated at the end (but is permitted). Pairs of (NaN,NaN) coordinates in
## @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/octclip/src/Makefile
===================================================================
--- trunk/octave-forge/main/octclip/src/Makefile 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/src/Makefile 2012-10-01 09:15:16 UTC (rev 11093)
@@ -1,22 +1,44 @@
# -*- coding: utf-8 -*-
+#Compiler
CC=mkoctfile
+#Common warning flags for C and C++
+FLAGSCOMW=-Wall -Wextra -Wshadow -Wcast-qual -Wcast-align -Wwrite-strings
+#Common optimization flags for C and C++
+FLAGSCOMO=-O2 -funroll-loops -fno-common -fshort-enums
+#Flags for C
+CFLAGS=-std=c99 -pedantic $(FLAGSCOMW) -Wconversion -Wmissing-prototypes
+CFLAGS+=-Wstrict-prototypes -Wnested-externs $(FLAGSCOMO)
+#Flags for C++
+CXXFLAGS=$(FLAGSCOMW) $(FLAGSCOMO)
+#Export flags for compilers and linker
+export CFLAGS CXXFLAGS
.PHONY: all
all: compile clean
.PHONY: compile
compile:
- $(CC) -c -Wall -Wextra -I. compilador.c -o compilador.o
- $(CC) -c -Wall -Wextra -I. errores.c -o errores.o
- $(CC) -c -Wall -Wextra -I. eucli.c -o eucli.o
- $(CC) -c -Wall -Wextra -I. fgeneral.c -o fgeneral.o
- $(CC) -c -Wall -Wextra -I. greiner.c -o greiner.o
- $(CC) -c -Wall -Wextra -I. polig.c -o polig.o
- $(CC) -c -Wall -Wextra -I. ptopol.c -o ptopol.o
- $(CC) -c -Wall -Wextra -I. segmento.c -o segmento.o
- $(CC) -c -Wall -Wextra -I. ventorno.c -o ventorno.o
- $(CC) -s -Wall -Wextra -I. _oc_polybool.cc *.o
+ $(CC) -c -I. calctopo.c -o calctopo.o
+ $(CC) -c -I. compilador.c -o compilador.o
+ $(CC) -c -I. dpeucker.c -o dpeucker.o
+ $(CC) -c -I. errores.c -o errores.o
+ $(CC) -c -I. eucli.c -o eucli.o
+ $(CC) -c -I. fgeneral.c -o fgeneral.o
+ $(CC) -c -I. geocnan.c -o geocnan.o
+ $(CC) -c -I. geocomp.c -o geocomp.o
+ $(CC) -c -I. greiner.c -o greiner.o
+ $(CC) -c -I. polig.c -o polig.o
+ $(CC) -c -I. polil.c -o polil.o
+ $(CC) -c -I. ptopol.c -o ptopol.o
+ $(CC) -c -I. recpolil.c -o recpolil.o
+ $(CC) -c -I. segmento.c -o segmento.o
+ $(CC) -c -I. ventorno.c -o ventorno.o
+ $(CC) -s -I. _oc_polybool.cc *.o
.PHONY: clean
clean:
rm -rf *.o *~
+
+.PHONY: cleanall
+cleanall:
+ rm -rf *~ *.o *.oct
Modified: trunk/octave-forge/main/octclip/src/_oc_polybool.cc
===================================================================
--- trunk/octave-forge/main/octclip/src/_oc_polybool.cc 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/src/_oc_polybool.cc 2012-10-01 09:15:16 UTC (rev 11093)
@@ -51,10 +51,10 @@
be repeated at the end (but is permitted). Pairs of (NaN,NaN) coordinates in\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/octclip/src/calctopo.c
===================================================================
--- trunk/octave-forge/main/octclip/src/calctopo.c (rev 0)
+++ trunk/octave-forge/main/octclip/src/calctopo.c 2012-10-01 09:15:16 UTC (rev 11093)
@@ -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/octclip/src/compilador.c
===================================================================
--- trunk/octave-forge/main/octclip/src/compilador.c 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/src/compilador.c 2012-10-01 09:15:16 UTC (rev 11093)
@@ -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/octclip/src/dpeucker.c
===================================================================
--- trunk/octave-forge/main/octclip/src/dpeucker.c (rev 0)
+++ trunk/octave-forge/main/octclip/src/dpeucker.c 2012-10-01 09:15:16 UTC (rev 11093)
@@ -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/octclip/src/errores.c
===================================================================
--- trunk/octave-forge/main/octclip/src/errores.c 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/src/errores.c 2012-10-01 09:15:16 UTC (rev 11093)
@@ -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/octclip/src/eucli.c
===================================================================
--- trunk/octave-forge/main/octclip/src/eucli.c 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/src/eucli.c 2012-10-01 09:15:16 UTC (rev 11093)
@@ -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/octclip/src/fgeneral.c
===================================================================
--- trunk/octave-forge/main/octclip/src/fgeneral.c 2012-09-24 12:24:31 UTC (rev 11092)
+++ trunk/octave-forge/main/octclip/src/fgeneral.c 2012-10-01 09:15:16 UTC (rev 11093)
@@ -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
@@ -2...
[truncated message content] |
