Soluzione di superficie minima in Python

Question

Ho una serie di punti 3D che definiscono un contorno 3D. Quello che voglio fare è ottenere la rappresentazione superficiale minima corrispondente a questo profilo (see Minimal Surfaces in Wikipedia). Fondamentalmente ciò richiede di risolvere un'equazione differenziale parziale non lineare.

In Matlab questo è quasi immediato utilizzando la funzione pdenonlin(see Matlab's documentation). Un esempio del suo utilizzo per risolvere un problema superficiale minimo può essere trovato qui: Minimal Surface Problem on the Unit Disk.

Ho bisogno di fare una tale implementazione in Python, ma fino a sapere che non ho trovato alcuna risorsa web su come farlo.

Qualcuno può indicarmi risorse/esempi di tale implementazione?

Grazie, Miguel.

UPDATE

La superficie 3D (idealmente una rappresentazione maglia triangolare) voglio trovare è delimitata da questo insieme di punti 3D (come si vede in tale figura, i punti giacciono nel piano best-fit) :

Ok, così facendo qualche ricerca ho scoperto che questo problema superficie minima è correlato con la soluzione del Biharmonic Equation, e ho anche scoperto che il Thin-plate spline è la soluzione fondamentale per questa equazione.

Quindi penso che l'approccio sarebbe quello di provare ad adattare questa rappresentazione sparsa della superficie (data dal contorno 3D dei punti) usando spline sottili. Ho trovato this example in scipy.interpolate dove i dati sparsi (formato x, y, z) sono interpolati usando spline sottili per ottenere le coordinate ZI su una griglia uniforme (XI, YI).

Due domande: (1) L'interpolazione con spline sottili sarebbe l'approccio corretto per il problema di calcolare la superficie dall'insieme di punti di contorno 3D? (2) In caso affermativo, come eseguire l'interpolazione su lastra sottile su scipy con una griglia NON UNIFORME?

Grazie ancora! Miguel

UPDATE: ATTUAZIONE IN MATLAB (MA NON FUNZIONA SU SciPy Python)

ho seguito this example utilizzando la funzione di Matlab tpaps e ottenuto la superficie minima montato il mio contorno su una griglia uniforme. Questo è il risultato in Matlab (sembra grande!):

però ho bisogno di implementare questo in Python, quindi sto usando il pacchetto scipy.interpolate.Rbf e la funzione thin-plate.Ecco il codice in pitone (XYZ contiene le coordinate 3D di ciascun punto del contorno):

GRID_POINTS = 25 
x_min = XYZ[:,0].min() 
x_max = XYZ[:,0].max() 
y_min = XYZ[:,1].min() 
y_max = XYZ[:,1].max() 
xi = np.linspace(x_min, x_max, GRID_POINTS) 
yi = np.linspace(y_min, y_max, GRID_POINTS) 
XI, YI = np.meshgrid(xi, yi) 

from scipy.interpolate import Rbf 
rbf = Rbf(XYZ[:,0],XYZ[:,1],XYZ[:,2],function='thin-plate',smooth=0.0) 
ZI = rbf(XI,YI) 

tuttavia questo è il risultato (molto diverso da quello ottenuto in Matlab):

È evidente che il risultato di scipy non corrisponde ad una superficie minima.

Scipy.interpolate.Rbf + lastra sottile funziona come previsto, perché differisce dal risultato di Matlab?

Answer 1

La domanda afferma che è necessario risolvere un'equazione differenziale parziale non lineare. Tuttavia, Wikipedia afferma che "sono difficili da studiare: non esistono quasi tecniche generali che funzionano per tutte queste equazioni, e di solito ogni singola equazione deve essere studiata come un problema separato". Tuttavia, non hai dato l'equazione! E Matlab a volte usa algoritmi genetici per arrivare alle sue superfici? Vale a dire, usa una regola empirica per fare una buona ipotesi e poi prova piccole variazioni nei quadrati dei componenti fino a quando non si trova una superficie più piccola. Implementare quel tipo di soluzione sarebbe laborioso ma non concettualmente difficile (assumendo che ti piaccia questo genere di cose). Ricorda inoltre che il calcolo delle funzioni continue è solo un caso speciale del calcolo di tutte le approssimazioni lineari delle funzioni (l'incremento è impostato a zero invece di un valore finito). Ciò mi è stato chiarito leggendo i libri di J L Bell su un'analisi infinitesimale liscia: basta usare quell'algebra con incrementi finiti e lasciare i fattori risultanti nelle derivazioni invece di "trascurarli".

Answer 2

Ovviamente Matlab e SciPy comprendono il TPS in modi diversi. L'implementazione di Matlab sembra corretta. SciPy tratta il TPS allo stesso modo degli altri RBF, quindi è possibile implementarlo correttamente in Python: sarebbe sufficiente formare una matrice del relativo sistema di equazioni lineari e risolverlo per ricevere i coefficienti di TPS.