u - SCIAN

!
"
"
#
Procesamiento de Señales 1D
El mundo análogo de señales y sistemas
Problema de difusión
Se tiene un sistema H
D: constante de difusión isotrópica
usando
La solución en
formulación de convolución
con
con la transf. de Fourier
se puede descomponer
.:. En general
la salida
Cálculo de los coeficientes de una serie
Se puede aproximar una función x0(t) por una función x(t)
Para nuestro caso, bajo ciertas condiciones (si ω1, ω2 y ω3
son múltiplos de una frecuencia fundamental ω0)
¿Cómo se puede calcular a1, a2 y a3?
Por mínimos cuadrados
Las funciones base son ortogonales
La ortogonalidad de las funciones base evita la complejidad de la
inversión de la matriz F
Entonces, hay que resolver el sistema lineal:
/(
)
,
/*
3
4,
0
1
2
&'
(
)*
+
)
,-
.. !
"
!
!
!$
#% #
# $!
$
#
#
#"
!
#
#
## !#
! #
"
"" "
!
" ! $
!
#
$
%
!
! " ! $ % !
%
%%
" #
%! !% $ % $ !# ! %%
%%
# "
$" !
!# # " # $ $
$ !#
%# ! ! " $ " " % $"
$ % ! % % !!
% !
" "
#
%" !% %
!
!% ! " # # %
#
# % ! $ $ $ $
"
##
!
% % " !
%#
"
"
!%
!
#"
#
"
! "
"#
!
"$
% ! %
% $ $ " #%
! !
.
!
"
#
$
%
!
=
∑ ∑
= = !
"
#
$
%
!
"
#
$
%
!
!
"
#
$
%
!
!
θ = θ + θ
$%
⋅ ⋅ π + ⋅ π + α
Filtrado suavizante:
O podemos convolucionar con una función triangular
En general se realiza teóricamente mediante
una convolución conun kernel gaussiano
Podemos también convolucionar con un kernel rectangular
(promedio de media móvil)
Pero, β 2 (x) = β 1 * β 1(x)
Al convolucionar la función f(x) con hA(x)
Al aplicar el kernel a una función de entrada
La salida en una posición "x" corresponde a el promedio de la
función de entrada en la región x-A/2 y x+A/2.
Esta operación es fácil de implementar
Generalizando, podemos tener una función
En el límite n→∞, β n (x) tiende a una
función gaussiana
(por teorema central del límite)
Se puede aproximar una convolución con un kernel gaussiano por
una serie de medias móviles concatenadas
A parte de los kérneles cuadrado (β 1) y triangular (β 2), se utilizan los
splines cuadráticos (β 3)
y cúbicos (β 4)
Filtro de Gradiente
Similaridad + Reg. Gradiente
def LaplacianSmoothingGrad(img, iters=200, alfa=4.0, delta=0.02):
u = img.copy()
negLaplau = np.empty(u.shape, dtype=float)
for k in xrange(iters):
deltau = u[:,:] - img[:,:]
ATFunc.negative_Laplacian_2D(u, negLaplau)
deltaLaplau = deltau + alfa*negLaplau
u -= 2.0*delta*(deltaLaplau)
return u
Solución mediante método del gradiente
def negative_Laplacian_2D(v, nlaplac, boundary1=None, boundary2=None):
sizes = v.shape
if (boundary1==None): b1 = bound.boundary(sz=[0, sizes[0]])
else: b1 = boundary1
if (boundary2==None): b2 = bound.boundary(sz=[0, sizes[1]])
else: b2 = boundary2
nlaplac[b1.ranIn,b2.ranIn] = 4.0*v[b1.ranIn,b2.ranIn] - (v[b1.ranInpp,b2.ranIn] \
+ v[b1.ranIn,b2.ranInpp] + v[b1.ranInmm,b2.ranIn] + v[b1.ranIn,b2.ranInmm])
nlaplac[b1.ranIn,b2.start] = 4.0*v[b1.ranIn,b2.start] - v[b1.ranInpp,b2.start] \
- v[b1.ranInmm,b2.start] - v[b1.ranIn,b2.start+1] - v[b1.ranIn,b2.lower]
nlaplac[b1.start,b2.ranIn] = 4.0*v[b1.start,b2.ranIn] - v[b1.start,b2.ranInpp] \
- v[b1.start,b2.ranInmm] - v[b1.start+1,b2.ranIn] - v[b1.lower,b2.ranIn]
nlaplac[b1.ranIn,b2.stop] = 4.0*v[b1.ranIn,b2.stop] - v[b1.ranInpp,b2.stop] \
- v[b1.ranInmm,b2.stop] - v[b1.ranIn,b2.stop-1] - v[b1.ranIn,b2.upper]
nlaplac[b1.stop,b2.ranIn] = 4.0*v[b1.stop,b2.ranIn] - v[b1.stop,b2.ranInpp] \
- v[b1.stop,b2.ranInmm] - v[b1.stop-1,b2.ranIn] - v[b1.upper,b2.ranIn]
nlaplac[b1.start,b2.start] = 4.0*v[b1.start,b2.start] - v[b1.start+1,b2.start] \
- v[b1.start,b2.start+1] - v[b1.start,b2.lower] - v[b1.lower,b2.start]
nlaplac[b1.stop,b2.start] = 4.0*v[b1.stop,b2.start] - v[b1.stop,b2.start+1] \
- v[b1.stop-1,b2.start] - v[b1.stop,b2.upper] - v[b1.upper,b2.start]
nlaplac[b1.start,b2.stop] = 4.0*v[b1.start,b2.stop] - v[b1.start+1,b2.stop] \
- v[b1.start,b2.stop-1] - v[b1.start,b2.upper] - v[b1.lower,b2.stop]
nlaplac[b1.stop,b2.stop] = 4.0*v[b1.stop,b2.stop] - v[b1.stop,b2.stop-1] \
- v[b1.stop-1,b2.stop] - v[b1.stop,b2.upper] - v[b1.upper,b2.stop]
return nlaplac
Aproximación de una función por una base triangular (β2)
Si nosotros queremos aproximar una función x0 por una base de
funciones β 2
Una base de funciones triangulare, no es una base
ortogonal. Los productos internos entre diferentes
funciones (posiciones) no son todos cero. Sin
embargo, estos productos son casi todos nulo.
Bases que sean ortogonales ante la traslación:
Digital MS Ambrosio-Tort. P0 elem. (β
β 1 spline)
def MSATSmoothingGrad(img, iters=800, alfa=1.0, gamma=0.2,
epsilon=1.0, delta=0.01):
u = img.copy()
usz = img.shape
dsm2du= np.empty(usz, dtype=float)
uszmm = np.array(usz) - 1
v = np.ones(uszmm, dtype=float)
dsm2dv= np.empty(uszmm, dtype=float)
dATdv = np.empty(uszmm, dtype=float)
for k in xrange(iters):
deltau = u[:,:] - img[:,:]
ATFunc.derivatives_Functional_2D(u, v, dsm2du, dsm2dv)
ATFunc.negative_Laplacian_2D(v, dATdv)
deltaU = deltau + (0.5*alfa)*dsm2du
deltaV = alfa*dsm2dv + (gamma*2.0*epsilon)*dATdv \
+ (gamma*0.5/epsilon)*(v-1)
u -= delta * deltaU
v -= delta * deltaV
return u,v
Gradient Algorithm: