Como calcular numericamente uma função a partir do seu gradiente barulhento?

Eu tenho o modelo s ( x , y ) = x 2 + y 2 , 0 ≤ x ≤ 1 , 0 ≤ y ≤ 1 .$\ s(x,y)=x^2+y^2, 0 \leq x \leq 1, 0 \leq y \leq 1$

Em vez de observar o modelo diretamente, estou observando as derivadas do modelo + algum ruído (e):

$\ p(x,y)=s_x+e, q(x,y)=s_y+e$

A partir das medidas de p (x, y e q (x, y), quero estimar s (x), digamos que sei que s (0,0) = 0.

De acordo com o teorema do gradiente: s ( x , y ) = ∫ ( x , y ) ( 0 , 0 ) [ s x , s y ] d → r$\ s(x,y) = \int_{(0,0)}^{(x,y)} [s_x,s_y]d\vec{r}$

independentemente do caminho que integramos.

Como um pequeno experimento (no Matlab), adicionei ruído distribuído normal, N (0,1), a p = 2x e q = 2y. Em seguida, integrei primeiro ao longo de x seguido pelo y: SXY. Em seguida, integrei primeiro ao longo de y, seguido pelo x: SYX.

Os resultados mostram que o teorema do gradiente não se sustenta neste caso (por causa do ruído):

Os erros quadráticos médios da raiz em relação ao modelo são:

ErmsXY =
    0.1125
ErmsYX =
    0.0920

Como posso encontrar uma estimativa melhor (menos erro RMS e mais suave) de s de peq?

EDITAR:

Pelo que eu li; o uso da integral da curva é conhecido como integração local. Existem também métodos de integração global em que se tenta escolher um S (x, y) que minimiza:

$\ \int_0^1\int_0^1 [|S_x - P|^2 + |S_y - Q|^2] dxdy$

Os métodos de integração global devem fornecer melhores resultados quando o gradiente é barulhento, mas como faço isso na prática?

EDIT 2:

Uma abordagem que eu usei é esta:

$\ s_x = D_x*s,s_y = D_y*s$

O resultado é o seguinte sistema de equações lineares:

$\ D_x*s=p, D_y*s=q$

Em seguida, encontre uma solução de erro do quadrado mínimo para essas equações. Supõe-se que uma solução LSE para essas equações seja equivalente a minimizar a integral de cima. Como isso pode ser mostrado?

Os resultados são bons:

O erro RMS é cerca de 1/5 do SXY e SYX e a solução também é mais suave.

No entanto, existem algumas desvantagens nessa abordagem:

1. é difícil de implementar; deve usar diferenças centrais e "achatar" a matriz 2D s no vetor etc.

2. As matrizes de derivação são muito grandes e esparsas, portanto, podem consumir muita RAM.

Outra abordagem que parece potencialmente mais simples de codificar, consumindo menos RAM e mais rápido é usar o FFT. No espaço de Fourier, esses pds se tornam uma equação algébrica. Isso é conhecido como algoritmo de Frankot-Chellappa, mas infelizmente não consegui que ele funcionasse nos meus dados de exemplo.

$s$