Interpolacion de datos 2D dispersos en octave

--------------------------------------------http://kip289.blogspot.com.ar/2015/04/interpolacion-de-datos-2d-dispersos-en.htm
l
La idea es ver como se pueden interpolar datos que vienen de puntos dispersos (X
i,Yi,VALi) como pueden ser precipitacin o temperatura usando Octave (version lib
re de software MatLab).
Este es mas o menos el proceso de la creacin de un script simple que resuelve el
problema (nota: estos pasos los ejecute en un ubuntu 14.04)
Primero, instalar Octave
$sudo apt-get install octave
La version 3.8.x ya viene con un GUI asi que no hay que instalar el qtoctave, so
lo es necesario lanzarlo de esta forma:
$octave --force-gui
Un ejemplo muy bueno de la base todo este experimento que se puede copiar y pega
r dentro de octave:
rand ("state", 1);
x = 2*rand (1000,1) - 1;
y = 2*rand (size (x)) - 1;
z = sin (2*(x.^2+y.^2));
[xx,yy] = meshgrid (linspace (-1,1,32));
griddata (x,y,z,xx,yy);
Este cdigo genera la siguiente figura:

Ahora el problema es un poco diferente al ejemplo ya que hay que partir por punt
os x,y,z y luego convertirlo a una grilla con los datos interpolados.
El resultado es el siguiente, primero los datos puntuales (fig1), luego en la a
grilla gruesa (fig2) y luego pasados a grilla fina por interpolacin lineal (fig3)
y por cubica (fig4), finalmente splines con p=1 (fig5) y p=0.5 (fig6):

Y el cdigo Octave es:

por: cristian orrego at ceaza dot cl
'datos_ejemplo1.txt:
'
1.0000,
1.0000,
1.1000
'
2.0000,
2.0000,
3.5000
'
1.0000,
3.0000,
6.2000
'
9.0000,
1.0000,
1.0000
'
2.0000,
4.0000,
2.8000
'
6.0000,
8.0000,
6.4000
'
10.0000,
10.0000,
4.0000
'
1.0000,
10.0000.
3.0000
'
5.0000,
5.5000.
10.0000
'si no esta instalado el paquete de splines
'pkg install -forge splines
'para usar el paquete hay que cargarlo
pkg load splines
'leer los datos desde el csv
a=csvread("datos_ejemplo1.txt")

'asignar las columnas a variables lat, lon y val (x,y,z)

lat=a(:,1);
lon=a(:,2);
val=a(:,3);
'crear una grilla gruesa (0 a 10 salto 2)
ti = 0:2:10;
[x_grueso,y_grueso] = meshgrid(ti,ti);
'interpolar valores a la grilla gruesa
val_grilla=griddata (lat,lon,val,x_grueso,y_grueso,'nearest');
'crear grilla mas fina (salto 1)
ti2 = 0:1:10;
[x_fino,y_fino] = meshgrid(ti2,ti2);
'interpolar de grilla gruesa a grilla fina lineal
val_final_lin=interp2(x_grueso,y_grueso,val_grilla,x_fino,y_fino,'linear');
'interpolar de grilla gruesa a grilla fina cubica
val_final_cub=interp2(x_grueso,y_grueso,val_grilla,x_fino,y_fino,'cubic');
'interpolar desde puntos a grilla fina con tps penalizacion 1
vals_tps1 = tpaps([lat lon], val, 1, [x_fino(:) y_fino(:)]);
'interpolar desde puntos a grilla fina con tps penalizacion 0.5
vals_tps2 = tpaps([lat lon], val, 0.5, [x_fino(:) y_fino(:)]);
'mostrar los 6 graficos en un panel
subplot (2, 3, 1);
scatter(lat,lon, 10, val, "filled")
subplot (2, 3, 2);
contourf(val_grilla);
subplot (2, 3, 3);
contourf(val_final_lin);
subplot (2, 3, 4);
contourf(val_final_cub);
subplot (2, 3, 5);
contourf(x_fino, y_fino, reshape(vals_tps1, 11, 11))
subplot (2, 3, 6);
contourf(x_fino, y_fino, reshape(vals_tps2, 11, 11));
'ref:
'http://octave.sourceforge.net/splines/function/tpaps.html
'http://en.wikipedia.org/wiki/Thin_plate_spline
'www.mssanz.org.au/modsim05/papers/knight.pdf
'pastebin: http://pastebin.com/0scs680q

Octave. Uso paquete simbolico

-----------------------------http://octave.1599824.n4.nabble.com/Examples-for-use-of-symbolic-toolbox-td16017
24.html
sudo apt-get install octave-symbolic
octave> symbols
octave> X = sym ("x");
octave> differentiate (Sin (X), X)
ans =
cos(x)
octave> expand ((X+1)*(X+2))

ans =
2.0+x^2+(3.0)*x
octave> collect ((X+1)*(X+2), X)
ans =
2.0+x^2+(3.0)*x
octave>
Note:
1) call symbols first
2) declare symbols with sym
3) capitalize functions like Sin
Para funciones paquete simbolico
--------------------------------http://octave.sourceforge.net/symbolic/overview.html
Cargar archivo con datos
-----------------------http://infocaminos.readthedocs.org/en/latest/ficheros.html
Cuando estamos trabajando con ficheros de texto hay varias funciones o comandos
de Octave que conviene conocer.
La funcin type() permite mostrar el contenido de un fichero de texto en la consol
a. La forma de utilizar la funcin es la siguiente: type(filename), siendo filenam
e una cadena de texto con el nombre de un fichero existente. Si el nombre del fi
chero incluye su ruta de directorio, se buscar el fichero en la ruta especificada
. Si solo se incluye el nombre del fichero, se buscar en el directorio de trabajo
.
El directorio de trabajo en el que estamos posicionados se puede consultar con p
wd(), que muestra en pantalla la ruta del directorio de trabajo donde estamos po
sicionados.
El contenido del directorio de trabajo se puede mostrar mediante el comando dir,
al estilo windows, o mediante el comando ls, al estilo linux. Los dos comando a
dmiten una mascara que permite especificar el tipo de fichero buscados. Por ejem
plo podramos utilizar dir *.m para mostrar un listado de los ficheros con extensin
.m. En la mscara, el arterisco hace la funcin de comodn. Podramos leer el comando a
nterior como: dir lo-que-sea punto m.
Tambin podemos cambiar el directorio de trabajo desde la consola de Octave. Para
ello se utiliza el comando cd, change directory, que admite un parmetro a continuac
in para especificar la ruta a la que se quiere acceder. Hay un atajo que hay que
conocer. Si tecleamos cd .., cd punto punto, nos moveremos al directorio padre d
el directorio en el que estemos posicionados. Para acceder a un determinado dire
ctorio utilizaremos: cd dirname, donde dirname es el nombre o la ruta completa d
el directorio en el que queremos posicionarnos.
Las funciones load() y save()
Podemos guardar variables en ficheros de texto mediante el comando Octave save.
Las variables guardadas las podremos recuperar luego mediante el comando load. E
l comando save se puede utilizar de distintas maneras:
save filename: Guarda todas las variables del workspace en el fichero filena
me, donde filename es el nombre del fichero y opcionalmente su ruta completa.

** save filename v1 v2**: Se pueden especificar qu variables concretas querem

os guardar en el fichero. En este ejemplo, solo se guardarn el el fichero filenam
e las variables de nombre v1 y v2.
** save options filename v1 v2**: donde options son una o ms opciones separad
as por espacio. Las opciones nos permiten especificar, por ejemplo, que se guard
en los ficheros en distintos formatos binarios o que se guarden los datos en for
mato comprimido zip.
La forma de operar se puede ver en el siguiente ejemplo, donde primero definimos
una matriz y a continuacin la guardamos en un fichero matriz.txt. Por ltimo se mues
tra el contenido del fichero mediante type():
La funcin fopen()
Para poder realizar operaciones de lectura y/o escritura en los ficheros de text
o es necesario primero abrir el fichero con fopen(). Una vez abierto el fichero,
se procede a realizar las distintas operaciones de lectura y/o de escritura en
el mismo. Cuando se termina de operar con el fichero hay que cerrarlo con la fun
cion fclose().
El procedimiento habitual para leer datos de un fichero se resume en el siguient
e esquema:
file = fopen( mifichero.txt , r );
% Operaciones de lectura del fichero
fclose(fid);
a funcin fopen() tiene la siguiente signatura:
file = fopen(filename, permission) Abre el fichero de nombre filename con el
tipo de acceso especificado por permission. Devuelve file, que es un nmero, un p
untero, que identifica al fichero en ulteriores operaciones de lectura escritura
. Si se producen errores al intentar abrir el fichero, la funcin fopen() devuelve
-1. El puntero ser un nmero mayor o igual a 3. Los parametros son los siguientes:
filename: cadena de texto con el nombre del fichero que se quiere ab
rir. Si incluye la ruta del fichero se utilizar, si no se buscar o creara el fiche
ro en el directorio de trabajo.
permission: especifica el modo de apertura del fichero. Lo habitual
es abrir el fichero para escribir en l o para leer de l, si bien es tambin posible
abrir el fichero en modo lectura y escritura. En los modos de escritura es posib
le aadir texto a un fichero existente o bien crear uno nuevo para la operacin, sob
reescribiendo el existente si lo hubiera. permission es una cadena de texto que
puede tener los siguientes valores:
r: Abre el fichero para lectura. Es el modo por defecto, si se
utiliza la funcin fopen() sin el argumento permission
r+: Abre el fichero en modo lectura-escritura
w: Abre o crea un nuevo fichero en modo escritura. Si existe s
e sobreescribe
w+: Abre o crea un fichero para lectura-escritura. Si existe,
se sobreescribe
a: Abre o crea un nuevo fichero para escritura. Si existe el f
ichero, aade al final del mismo.
a+: Abre o crea un nuevo fichero para lectura-escritura. Si ex
iste, se aade al final del mismo.
Note

Hay dos modos ms de apertura de ficheros: A y W que no realizan el flush automtico de

los datos.
Note
La funcin fopen() admite un tercer y cuarto parmetros que permiten especificar el
orden de lectura escritura de los bytes (Big-endian, Little-endian) y la codific
acin de caracteres del fichero (UTF-8, ISO-8859-1,...).
Note
fids = fopen(All): Devuelve un vector con los punteros a TODOS los ficheros abiert
os que haya.
La funcin fclose()
Sirve para cerrar los ficheros cuando se ha terminado de trabajar con ellos.
fclose(file): Cierra el fichero file. Devuelve 0 si pudo cerrar el fichero o
-1 si hay errores.
fclose(All): Cierra todos los ficheros que haya abiertos. Devuelve 0 si pudier
on cerrar los ficheros o -1 si hay errores.
Lectura de ficheros lnea a lnea
Una vez abierto el fichero para lectura podemos ir leyendo una lnea cada vez, que
recibiremos como una cadena de texto, con o sin carcter fin de lnea, segn la funcin
de lectura utilizada:
line = fgets(file): Lee una lnea del fichero file, incluyendo el caracter de
fin de lnea, y la devuelve en forma de cadena de texto.
line = fgets(file, nchar): Lee al menos nchar caracteres de la siguiente lnea
del fichero file. (Si se alcanza el final de lnea o el final del fichero devuelv
e lo que haya ledo hasta ah).
line = fgetl(file): Lee la siguiente lnea del fichero file, sin incluir el ca
racter fin de lnea, y la devuelve como una cadena de caracteres.
Lectura de datos formateados
Octave ofrece la posibilidad de leee los datos contenidos en el fichero, uno a u
no, y devolverlos en el formato seleccionado, pudiendo de esta manera leer , no
solo cadenas de texto, sino tambin nmeros enteros o doubles.
La funcin para leer datos formateados es fscanf(). La funcin fscanf() admite varia
s signaturas. Una forma habitual de utilizar la funcin es la siguiente:
fscanf()
---------------------------http://octave.sourceforge.net/fpl/function/savevtk.html
Function File: [ status ] = savevtk ( X, Y, Z, filename )
Save a 3-D scalar array array to the file filename in VTK structured-grid format
.
This file format is used by Mayavi2 or ParaView for example. If no write errors
occurred, output argument status is set to 1, otherwise 0.

Example:
n = 30;
X = zeros (n, n, n);
for x = 1:n
for y = 1:n
for z = 1:n
X(x, y, z) = 1 / sqrt (x*x + y*y + z*z);
endfor
endfor
endfor
X = X * 200 / max (max (max (X)));
savevtk (X, spherical.vtk );
--------------------------------------------------------Function File: [ status ] = savevtkvector (X, Y, Z, filename)
Save a 3-D vector field of components X, Y, Z to the file filename in VTK format
.
This file format is used by Mayavi2 or ParaView for example. X, Y and Z should b
e 3-D arrays of the same size, each storing vector components in a given Cartesi
an direction.
If no write errors occurred, output argument status is set to 1, otherwise 0.