├── .gitignore ├── README.md ├── __init__.py ├── cpd.py ├── cpd ├── __init__.py ├── comp.pxd ├── comp.pyx ├── fast_gaussian_transform.pxd ├── fast_gaussian_transform.pyx ├── nonrigid.py ├── rigid.py └── util.py ├── include ├── comp.h └── fgt │ ├── dval.h │ ├── fgt_model.h │ └── fgt_predict.h ├── setup.py ├── src ├── comp.c ├── cpd │ ├── cpd_P.c │ ├── cpd_Pappmex.c │ └── cpd_Pcorrespondence.c └── fgt │ ├── dval.c │ ├── fgt_model.c │ └── fgt_predict.c └── test └── test_fgt.py /.gitignore: -------------------------------------------------------------------------------- 1 | *.swp 2 | *.pyc 3 | .DS_Store 4 | /config.mk 5 | /build 6 | /release 7 | /relwithdebinfo 8 | /debug 9 | *.d 10 | *.prog 11 | *.dSYM 12 | /microscopes/io/schema_pb2.py 13 | /microscopes/**/*.cpp 14 | /microscopes/**/*.so 15 | /microscopes_common.egg-info 16 | /microscopes/common/githash.txt 17 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | A Python package implementing Coherent Point Drift for Point Set Registration 2 | 3 | This package is a refactored version of the CPD2 package by Andriy Myronenko: 4 | https://sites.google.com/site/myronenko/research/cpd 5 | -------------------------------------------------------------------------------- /__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dpfau/pycpd/aaa83409dfdf1a526d04992b4976ce9b5f90be5f/__init__.py -------------------------------------------------------------------------------- /cpd.py: -------------------------------------------------------------------------------- 1 | def register(X, Y, method='rigid', 2 | corresp=0, normalize=1, max_it=150, tol=1e-5, viz=1, outliers=0.1, fgt=0, 3 | rot=1, scale=1, 4 | beta=2, lambda=3): 5 | pass 6 | -------------------------------------------------------------------------------- /cpd/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dpfau/pycpd/aaa83409dfdf1a526d04992b4976ce9b5f90be5f/cpd/__init__.py -------------------------------------------------------------------------------- /cpd/comp.pxd: -------------------------------------------------------------------------------- 1 | cdef extern from "comp.h": 2 | void comp_p(double*, double*, double*, double*, double*, double*, double*, double*, int, int, int) 3 | void comp_truncate(double*, double*, double*, double*, double*, double*, double*, double*, int, int, int, double*) 4 | void comp_correspondence(double*, double*, double*, double*, double*, int, int, int) 5 | -------------------------------------------------------------------------------- /cpd/comp.pyx: -------------------------------------------------------------------------------- 1 | #distutils: language = c 2 | #distutils: sources = src/comp.c 3 | 4 | from comp cimport * 5 | import numpy as np 6 | cimport numpy as np 7 | 8 | cpdef p(np.ndarray[np.double_t, ndim=2] x, 9 | np.ndarray[np.double_t, ndim=2] y, 10 | np.ndarray[np.double_t, ndim=2] sigma2, 11 | np.ndarray[np.double_t, ndim=2] outlier): 12 | 13 | cdef int N, M, D 14 | N = x.shape[0] 15 | M = y.shape[0] 16 | D = x.shape[1] 17 | assert D == y.shape[1] 18 | 19 | cdef np.ndarray[np.double_t, ndim=2] P1, Pt1, Px, E 20 | P1 = np.ndarray([M,1], dtype=np.double); 21 | Pt1 = np.ndarray([N,1], dtype=np.double); 22 | Px = np.ndarray([M,D], dtype=np.double); 23 | E = np.ndarray([1,1], dtype=np.double); 24 | 25 | comp_p( x.data, y.data, sigma2.data, outlier.data, 26 | P1.data, Pt1.data, Px.data, E.data, N, M, D) 27 | 28 | return P1, Pt1, Px, E 29 | 30 | cpdef truncate(): 31 | pass 32 | 33 | cpdef correspondence(): 34 | pass 35 | -------------------------------------------------------------------------------- /cpd/fast_gaussian_transform.pxd: -------------------------------------------------------------------------------- 1 | cdef extern from "fgt/fgt_predict.h": 2 | int invnchoosek(int, int) 3 | void fgt_predict(double *, double *, double *, int, double, int, double, int, int, 4 | double *, 5 | double *, double *, int *) 6 | 7 | cdef extern from "fgt/fgt_model.h": 8 | int nchoosek(int, int) 9 | int idmax(double *, int) 10 | double ddist(double *, double *, int) 11 | void Kcenter(double *, int, int, int, 12 | double *, int *, int *, int *, 13 | double *) 14 | void Compute_C_k(int, int, double *, int *, int *) 15 | void Compute_A_k(double *, double *, double *, double *, double, int, int, int, int, int, 16 | double *, 17 | int *, double *, double *, int *) 18 | void fgt_model(double *, double *, double, int, int, double, 19 | double *, double *, 20 | int, int, 21 | int *, int *, int *, int *, 22 | double *, double *, int *, int *, double *, double *, 23 | int) 24 | 25 | cdef extern from "fgt/dval.h": 26 | void c_dval(double *, double *, double *, double, double *, int, int, int) 27 | -------------------------------------------------------------------------------- /cpd/fast_gaussian_transform.pyx: -------------------------------------------------------------------------------- 1 | #distutils: language = c 2 | #distutils: sources = src/fgt/fgt_model.c src/fgt/fgt_predict.c src/fgt/dval.c 3 | 4 | from fast_gaussian_transform cimport * 5 | import numpy as np 6 | cimport numpy as np 7 | 8 | cpdef predict(np.ndarray[np.double_t, ndim=2] y, 9 | np.ndarray[np.double_t, ndim=2] xc, 10 | np.ndarray[np.double_t, ndim=2] Ak, 11 | double sigma=1, double e=10): 12 | """predict: returns the Fast Gauss Transform approximation of the test points y 13 | given the model \theta=(xc,A_k) 14 | 15 | Parameters 16 | ---------- 17 | y: test point (d x Ny) numpy array 18 | xc: Kcenter point (d x K) numpy array 19 | Ak: Polynomial coefficient (pd x K), where pd = nchoosek(p+d-1, d) 20 | sigma: Noise Standard deviation of the kernel (default sigma = 1) 21 | e: Ratio of far field (default e = 10) 22 | 23 | Returns 24 | ------- 25 | v: density (1 x Ny) numpy array 26 | """ 27 | cdef int d, pd, K, Ny 28 | cdef np.ndarray[np.double_t, ndim=1] dx, prods 29 | cdef np.ndarray[np.int_t, ndim=1] heads 30 | 31 | d = y.shape[0] 32 | Ny = y.shape[1] 33 | K = xc.shape[1] 34 | assert d == xc.shape[0] 35 | 36 | pd = Ak.shape[0] 37 | assert K == Ak.shape[1] 38 | 39 | cdef np.ndarray[np.double_t, ndim=2] v = np.ndarray([1,Ny], dtype=np.double) 40 | 41 | dx = np.ndarray([d], dtype=np.double) 42 | prods = np.ndarray([pd], dtype=np.double) 43 | heads = np.ndarray([d+1], dtype=np.int) 44 | 45 | fgt_predict( y.data, xc.data, Ak.data, Ny, sigma, K, e, d, pd, 46 | v.data, 47 | dx.data, prods.data, heads.data) 48 | 49 | return v 50 | 51 | cpdef model(np.ndarray[np.double_t, ndim=2] x, 52 | np.ndarray w=np.empty([0, 0], dtype=np.double), 53 | double sigma=1, double e=10, int K=-1, int p=8): 54 | """model: returns the Fast Gauss Transform Aprroximation Model of a Kernel density 55 | 56 | Parameters 57 | ---------- 58 | x: Source data (d x Nx) numpy array 59 | w: Weigths (1 x Nx) numpy array ( default w = ones(1 , Nx) ) 60 | sigma: Noise Standard deviation of the kernel (default sigma = 1) 61 | e: Ratio of far field (default e = 10) 62 | K: Number of centers (default K = sqrt(Nx)) 63 | p: Order of truncation (default p = 8) 64 | 65 | Returns 66 | ------- 67 | xc: The K center points of the training set (d x K) numpy array 68 | Ak: Polynomial coefficient (pd x K) numpy array, 69 | where pd = nchoosek(p + d - 1 , d) = prod(1:p + d - 1)/(prod(1:p - 1)*prod(1:d)) 70 | """ 71 | cdef int d, Nx, wx, pd 72 | cdef np.ndarray[np.double_t, ndim=2] xc, Ak 73 | cdef np.ndarray[np.double_t, ndim=1] C_k, dist_C, dx, prods 74 | cdef np.ndarray[np.int_t, ndim=1] indxc, indx, xhead, xboxsz, heads, cinds 75 | 76 | d = x.shape[0] 77 | Nx = x.shape[1] 78 | 79 | if w.shape[0] == 0: 80 | w = np.ones([1,Nx], dtype=np.double) 81 | else: 82 | assert w.dtype == np.double and w.ndim == 2 83 | assert w.shape[0] == 1 and w.shape[1] == Nx 84 | 85 | if K == -1: 86 | K = np.sqrt(Nx) 87 | else: 88 | assert K <= Nx 89 | 90 | pd = nchoosek(p+d-1, d); 91 | xc = np.ndarray([d,K], dtype=np.double) 92 | Ak = np.ndarray([pd,K], dtype=np.double) 93 | 94 | C_k = np.ndarray([pd], dtype=np.double) 95 | dist_C = np.ndarray([Nx], dtype=np.double) 96 | dx = np.ndarray([d], dtype=np.double) 97 | prods = np.ndarray([pd], dtype=np.double) 98 | 99 | indxc = np.ndarray([K], dtype=np.int) 100 | indx = np.ndarray([Nx], dtype=np.int) 101 | xhead = np.ndarray([K], dtype=np.int) 102 | xboxsz = np.ndarray([K], dtype=np.int) 103 | heads = np.ndarray([d + 1], dtype=np.int) 104 | cinds = np.ndarray([pd], dtype=np.int) 105 | 106 | fgt_model( x.data, w.data, sigma, p, K, e, 107 | xc.data, Ak.data, 108 | d, Nx, 109 | indxc.data, indx.data, xhead.data, xboxsz.data, 110 | dist_C.data, C_k.data, heads.data, cinds.data, 111 | dx.data, prods.data, 112 | pd) 113 | 114 | return xc, Ak 115 | 116 | cpdef dval(np.ndarray[np.double_t, ndim=2] x, 117 | np.ndarray[np.double_t, ndim=2] y, 118 | np.ndarray w=np.empty([0, 0], dtype=np.double), double sigma=1): 119 | """Evaluate weighted gaussian RBF between vectors x,y 120 | 121 | Parameters 122 | ---------- 123 | x: Source data (d x Nx) numpy array 124 | y: Target data (d x Ny) numpy array 125 | w: Weigths (1 x Nx) numpy array ( default w = ones(1 , Nx) ) 126 | sigma: Noise Standard deviation of the kernel (default sigma = 1) 127 | 128 | Returns 129 | ------- 130 | 131 | v density (1 x Ny) 132 | """ 133 | 134 | cdef int d, Nx, Ny 135 | d = x.shape[0] 136 | Nx = x.shape[1] 137 | 138 | assert d == y.shape[0] 139 | Ny = y.shape[1] 140 | 141 | if w.shape[0] == 0: 142 | w = np.ones([1,Nx], dtype=np.double) 143 | else: 144 | assert w.dtype == np.double and w.ndim == 2 145 | assert w.shape[0] == 1 and w.shape[1] == Nx 146 | 147 | cdef np.ndarray[np.double_t, ndim=2] v = np.ndarray([1,Ny], dtype=np.double) 148 | c_dval( x.data, y.data, w.data, sigma, v.data, d, Nx, Ny) 149 | return v 150 | -------------------------------------------------------------------------------- /cpd/nonrigid.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dpfau/pycpd/aaa83409dfdf1a526d04992b4976ce9b5f90be5f/cpd/nonrigid.py -------------------------------------------------------------------------------- /cpd/rigid.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dpfau/pycpd/aaa83409dfdf1a526d04992b4976ce9b5f90be5f/cpd/rigid.py -------------------------------------------------------------------------------- /cpd/util.py: -------------------------------------------------------------------------------- 1 | def deform(X, sampling, power, sigma, lambda): 2 | pass 3 | 4 | def denormalize(Y): 5 | pass 6 | 7 | def gaussian_affinity(x, y, beta): 8 | pass 9 | 10 | def normalize(x, y): 11 | pass 12 | 13 | def p_fgt(X, Y, sigma2, outliers, sigma2_init): 14 | pass 15 | 16 | def p_fast(X, T, sigma2, outliers, sigma2_init, fgt): 17 | pass 18 | 19 | def plot(X, Y, C): 20 | pass 21 | 22 | def rotate(a,b,g): 23 | def rot: 24 | pass 25 | 26 | def transform(Z, trans): 27 | pass 28 | -------------------------------------------------------------------------------- /include/comp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Andriy Myronenko 3 | * Adapted for Python by David Pfau 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #define max(A, B) ((A) > (B) ? (A) : (B)) 10 | #define min(A, B) ((A) < (B) ? (A) : (B)) 11 | 12 | void comp_p(double*, double*, double*, double*, double*, double*, double*, double*, int, int, int); 13 | void comp_truncate(double*, double*, double*, double*, double*, double*, double*, double*, int, int, int, double*); 14 | void comp_correspondence(double*, double*, double*, double*, double*, int, int, int); 15 | -------------------------------------------------------------------------------- /include/fgt/dval.h: -------------------------------------------------------------------------------- 1 | /* 2 | Evaluate weighted gaussian RBF between vectors x,y 3 | Author : Sébastien PARIS : sebastien.paris@lsis.org 4 | Modified for Python by David PFAU : david.pfau@gmail.com 5 | */ 6 | 7 | #include 8 | #ifdef OMP 9 | #include 10 | #endif 11 | 12 | #ifndef MAX_THREADS 13 | #define MAX_THREADS 64 14 | #endif 15 | #ifndef max 16 | #define max(a,b) (a >= b ? a : b) 17 | #define min(a,b) (a <= b ? a : b) 18 | #endif 19 | 20 | void c_dval(double * , double * , double * , double , double * , int , int , int ); 21 | -------------------------------------------------------------------------------- /include/fgt/fgt_model.h: -------------------------------------------------------------------------------- 1 | /* 2 | Author : S�bastien PARIS : sebastien.paris@lsis.org 3 | Adapted to Python by David PFAU : david.pfau@gmail.com 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #define min(a , b) ((a) <= (b) ? (a) : (b)) 10 | #define max(a , b) ((a) >= (b) ? (a) : (b)) 11 | 12 | int nchoosek(int , int ); 13 | 14 | int idmax(double * , int ); 15 | 16 | double ddist(double * , double * , int ); 17 | 18 | void Kcenter(double * , int , int , int , 19 | double * , int * , int * , int * , 20 | double *); 21 | 22 | void Compute_C_k(int , int , double * , int * , int *); 23 | 24 | void Compute_A_k(double * , double * , double *, double * , double , int , int , int , int , int , 25 | double * , 26 | int * , double * , double * , int * ); 27 | 28 | void fgt_model(double * , double * , double , int , int , double , 29 | double * , double * , 30 | int , int , 31 | int * , int * , int * , int * , 32 | double * , double * , int * , int * , double * , double * , 33 | int ); 34 | -------------------------------------------------------------------------------- /include/fgt/fgt_predict.h: -------------------------------------------------------------------------------- 1 | /* 2 | Fast Gauss Transform approximation of the test points y given the model \theta=(xc,A_k) 3 | Author : S�bastien PARIS : sebastien.paris@lsis.org 4 | Modified for Python by David PFAU : david.pfau@gmail.com 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #define min(a , b) ((a) <= (b) ? (a) : (b)) 11 | #define max(a , b) ((a) >= (b) ? (a) : (b)) 12 | 13 | int invnchoosek(int , int ); 14 | void fgt_predict(double * , double * , double * , int , double , int , double , int , int , 15 | double * , 16 | double * , double * , int *); 17 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | from distutils.core import setup 2 | from distutils.extension import Extension 3 | from Cython.Build import cythonize 4 | from numpy import get_include 5 | 6 | extensions = [ 7 | Extension("cpd.fast_gaussian_transform", ["cpd/fast_gaussian_transform.pyx"], 8 | include_dirs = ["include", get_include()]) 9 | ] 10 | 11 | setup( 12 | name = "PyCPD", 13 | ext_modules = cythonize(extensions) 14 | ) 15 | -------------------------------------------------------------------------------- /src/comp.c: -------------------------------------------------------------------------------- 1 | #include "comp.h" 2 | 3 | void comp_p( 4 | double* x, 5 | double* y, 6 | double* sigma2, 7 | double* outlier, 8 | double* P1, 9 | double* Pt1, 10 | double* Px, 11 | double* E, 12 | int N, 13 | int M, 14 | int D) 15 | { 16 | int n, m, d; 17 | double ksig, diff, razn, outlier_tmp, sp; 18 | double *P, *temp_x; 19 | 20 | P = (double*) calloc(M, sizeof(double)); 21 | temp_x = (double*) calloc(D, sizeof(double)); 22 | 23 | ksig = -2.0 * *sigma2; 24 | outlier_tmp=(*outlier*M*pow (-ksig*3.14159265358979,0.5*D))/((1-*outlier)*N); 25 | /* printf ("ksig = %lf\n", *sigma2);*/ 26 | /* outlier_tmp=*outlier*N/(1- *outlier)/M*(-ksig*3.14159265358979); */ 27 | 28 | 29 | for (n=0; n < N; n++) { 30 | 31 | sp=0; 32 | for (m=0; m < M; m++) { 33 | razn=0; 34 | for (d=0; d < D; d++) { 35 | diff=*(x+n+d*N)-*(y+m+d*M); diff=diff*diff; 36 | razn+=diff; 37 | } 38 | 39 | *(P+m)=exp(razn/ksig); 40 | sp+=*(P+m); 41 | } 42 | 43 | sp+=outlier_tmp; 44 | *(Pt1+n)=1-outlier_tmp/ sp; 45 | 46 | for (d=0; d < D; d++) { 47 | *(temp_x+d)=*(x+n+d*N)/ sp; 48 | } 49 | 50 | for (m=0; m < M; m++) { 51 | 52 | *(P1+m)+=*(P+m)/ sp; 53 | 54 | for (d=0; d < D; d++) { 55 | *(Px+m+d*M)+= *(temp_x+d)**(P+m); 56 | } 57 | 58 | } 59 | 60 | *E += -log(sp); 61 | } 62 | *E +=D*N*log(*sigma2)/2; 63 | 64 | 65 | free((void*)P); 66 | free((void*)temp_x); 67 | 68 | return; 69 | } 70 | 71 | void comp_truncate( 72 | double* x, 73 | double* y, 74 | double* sigma2, 75 | double* outlier, 76 | double* P1, 77 | double* Pt1, 78 | double* Px, 79 | double* E, 80 | int N, 81 | int M, 82 | int D, 83 | double* truncate) 84 | { 85 | int n, m, d; 86 | double ksig, diff, razn, outlier_tmp, sp; 87 | double *P; 88 | 89 | P = (double*) calloc(M, sizeof(double)); 90 | 91 | ksig = -2.0 * *sigma2; 92 | *truncate=log(*truncate); 93 | if (*outlier==0) *outlier=1e-8; 94 | 95 | outlier_tmp=(*outlier*M*pow (-ksig*3.14159265358979,0.5*D))/((1-*outlier)*N); 96 | /* printf ("ksig = %lf\n", *sigma2);*/ 97 | /* outlier_tmp=*outlier*N/(1- *outlier)/M*(-ksig*3.14159265358979); */ 98 | 99 | 100 | for (n=0; n < N; n++) { 101 | sp=0; 102 | 103 | for (m=0; m < M; m++) { 104 | razn=0; 105 | for (d=0; d < D; d++) { 106 | diff=*(x+n+d*N)-*(y+m+d*M); diff=diff*diff; 107 | razn+=diff; 108 | }; 109 | 110 | razn=razn/ksig; 111 | 112 | if (razn< *truncate) 113 | {*(P+m)=0;} 114 | else 115 | { 116 | *(P+m)=exp(razn); 117 | sp+=*(P+m); 118 | }; 119 | } 120 | 121 | sp+=outlier_tmp; 122 | *(Pt1+n)=1-outlier_tmp/ sp; 123 | 124 | 125 | for (m=0; m < M; m++) { 126 | 127 | if (*(P+m)==0){} 128 | else 129 | { 130 | *(P1+m)+=*(P+m)/sp; 131 | for (d=0; d < D; d++) { 132 | *(Px+m+d*M)+= *(x+n+d*N)/ sp* *(P+m); 133 | } 134 | } 135 | 136 | } 137 | 138 | *E += -log(sp); 139 | } 140 | *E +=D*N*log(*sigma2)/2; 141 | 142 | 143 | free((void*)P); 144 | 145 | 146 | return; 147 | } 148 | 149 | void comp_correspondence( 150 | double* x, 151 | double* y, 152 | double* sigma2, 153 | double* outlier, 154 | double* Pc, 155 | int N, 156 | int M, 157 | int D) 158 | { 159 | int n, m, d; 160 | double ksig, diff, razn, outlier_tmp,temp_x,sp; 161 | double *P, *P1; 162 | 163 | 164 | P = (double*) calloc(M, sizeof(double)); 165 | P1 = (double*) calloc(M, sizeof(double)); 166 | 167 | 168 | ksig = -2.0 * (*sigma2+1e-3); 169 | outlier_tmp=(*outlier*M*pow (-ksig*3.14159265358979,0.5*D))/((1-*outlier)*N); 170 | if (outlier_tmp==0) outlier_tmp=1e-10; 171 | 172 | 173 | /* printf ("ksig = %lf\n", *sigma2);*/ 174 | 175 | 176 | for (n=0; n < N; n++) { 177 | sp=0; 178 | for (m=0; m < M; m++) { 179 | razn=0; 180 | for (d=0; d < D; d++) { 181 | diff=*(x+n+d*N)-*(y+m+d*M); diff=diff*diff; 182 | razn+=diff; 183 | } 184 | 185 | *(P+m)=exp(razn/ksig); 186 | sp+=*(P+m); 187 | 188 | } 189 | 190 | sp+=outlier_tmp; 191 | 192 | 193 | for (m=0; m < M; m++) { 194 | 195 | temp_x=*(P+m)/ sp; 196 | 197 | if (n==0) 198 | {*(P1+m)= *(P+m)/ sp; 199 | *(Pc+m)=n+1;}; 200 | 201 | if (temp_x > *(P1+m)) 202 | { 203 | *(P1+m)= *(P+m)/ sp; 204 | *(Pc+m)=n+1; 205 | } 206 | 207 | 208 | } 209 | 210 | } 211 | 212 | 213 | free((void*)P); 214 | free((void*)P1); 215 | 216 | return; 217 | } 218 | -------------------------------------------------------------------------------- /src/cpd/cpd_P.c: -------------------------------------------------------------------------------- 1 | /* 2 | Andriy Myronenko 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include "mex.h" 9 | #define max(A, B) ((A) > (B) ? (A) : (B)) 10 | #define min(A, B) ((A) < (B) ? (A) : (B)) 11 | 12 | void cpd_comp_default( 13 | double* x, 14 | double* y, 15 | double* sigma2, 16 | double* outlier, 17 | double* P1, 18 | double* Pt1, 19 | double* Px, 20 | double* E, 21 | int N, 22 | int M, 23 | int D 24 | ) 25 | 26 | { 27 | int n, m, d; 28 | double ksig, diff, razn, outlier_tmp, sp; 29 | double *P, *temp_x; 30 | 31 | P = (double*) calloc(M, sizeof(double)); 32 | temp_x = (double*) calloc(D, sizeof(double)); 33 | 34 | ksig = -2.0 * *sigma2; 35 | outlier_tmp=(*outlier*M*pow (-ksig*3.14159265358979,0.5*D))/((1-*outlier)*N); 36 | /* printf ("ksig = %lf\n", *sigma2);*/ 37 | /* outlier_tmp=*outlier*N/(1- *outlier)/M*(-ksig*3.14159265358979); */ 38 | 39 | 40 | for (n=0; n < N; n++) { 41 | 42 | sp=0; 43 | for (m=0; m < M; m++) { 44 | razn=0; 45 | for (d=0; d < D; d++) { 46 | diff=*(x+n+d*N)-*(y+m+d*M); diff=diff*diff; 47 | razn+=diff; 48 | } 49 | 50 | *(P+m)=exp(razn/ksig); 51 | sp+=*(P+m); 52 | } 53 | 54 | sp+=outlier_tmp; 55 | *(Pt1+n)=1-outlier_tmp/ sp; 56 | 57 | for (d=0; d < D; d++) { 58 | *(temp_x+d)=*(x+n+d*N)/ sp; 59 | } 60 | 61 | for (m=0; m < M; m++) { 62 | 63 | *(P1+m)+=*(P+m)/ sp; 64 | 65 | for (d=0; d < D; d++) { 66 | *(Px+m+d*M)+= *(temp_x+d)**(P+m); 67 | } 68 | 69 | } 70 | 71 | *E += -log(sp); 72 | } 73 | *E +=D*N*log(*sigma2)/2; 74 | 75 | 76 | free((void*)P); 77 | free((void*)temp_x); 78 | 79 | return; 80 | } 81 | 82 | /* Input arguments */ 83 | #define IN_x prhs[0] 84 | #define IN_y prhs[1] 85 | #define IN_sigma2 prhs[2] 86 | #define IN_outlier prhs[3] 87 | 88 | 89 | /* Output arguments */ 90 | #define OUT_P1 plhs[0] 91 | #define OUT_Pt1 plhs[1] 92 | #define OUT_Px plhs[2] 93 | #define OUT_E plhs[3] 94 | 95 | 96 | /* Gateway routine */ 97 | void cpd_P( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) 98 | { 99 | double *x, *y, *sigma2, *outlier, *P1, *Pt1, *Px, *E; 100 | int N, M, D; 101 | 102 | /* Get the sizes of each input argument */ 103 | N = mxGetM(IN_x); 104 | M = mxGetM(IN_y); 105 | D = mxGetN(IN_x); 106 | 107 | /* Create the new arrays and set the output pointers to them */ 108 | OUT_P1 = mxCreateDoubleMatrix(M, 1, mxREAL); 109 | OUT_Pt1 = mxCreateDoubleMatrix(N, 1, mxREAL); 110 | OUT_Px = mxCreateDoubleMatrix(M, D, mxREAL); 111 | OUT_E = mxCreateDoubleMatrix(1, 1, mxREAL); 112 | 113 | /* Assign pointers to the input arguments */ 114 | x = mxGetPr(IN_x); 115 | y = mxGetPr(IN_y); 116 | sigma2 = mxGetPr(IN_sigma2); 117 | outlier = mxGetPr(IN_outlier); 118 | 119 | 120 | 121 | /* Assign pointers to the output arguments */ 122 | P1 = mxGetPr(OUT_P1); 123 | Pt1 = mxGetPr(OUT_Pt1); 124 | Px = mxGetPr(OUT_Px); 125 | E = mxGetPr(OUT_E); 126 | 127 | /* Do the actual computations in a subroutine */ 128 | cpd_comp(x, y, sigma2, outlier, P1, Pt1, Px, E, N, M, D); 129 | 130 | return; 131 | } 132 | 133 | 134 | -------------------------------------------------------------------------------- /src/cpd/cpd_Pappmex.c: -------------------------------------------------------------------------------- 1 | /* 2 | Andriy Myronenko 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include "mex.h" 9 | #define max(A, B) ((A) > (B) ? (A) : (B)) 10 | #define min(A, B) ((A) < (B) ? (A) : (B)) 11 | 12 | void cpd_comp_truncate( 13 | double* x, 14 | double* y, 15 | double* sigma2, 16 | double* outlier, 17 | double* P1, 18 | double* Pt1, 19 | double* Px, 20 | double* E, 21 | int N, 22 | int M, 23 | int D, 24 | double* truncate) 25 | { 26 | int n, m, d; 27 | double ksig, diff, razn, outlier_tmp, sp; 28 | double *P; 29 | 30 | P = (double*) calloc(M, sizeof(double)); 31 | 32 | ksig = -2.0 * *sigma2; 33 | *truncate=log(*truncate); 34 | if (*outlier==0) *outlier=1e-8; 35 | 36 | outlier_tmp=(*outlier*M*pow (-ksig*3.14159265358979,0.5*D))/((1-*outlier)*N); 37 | /* printf ("ksig = %lf\n", *sigma2);*/ 38 | /* outlier_tmp=*outlier*N/(1- *outlier)/M*(-ksig*3.14159265358979); */ 39 | 40 | 41 | for (n=0; n < N; n++) { 42 | sp=0; 43 | 44 | for (m=0; m < M; m++) { 45 | razn=0; 46 | for (d=0; d < D; d++) { 47 | diff=*(x+n+d*N)-*(y+m+d*M); diff=diff*diff; 48 | razn+=diff; 49 | }; 50 | 51 | razn=razn/ksig; 52 | 53 | if (razn< *truncate) 54 | {*(P+m)=0;} 55 | else 56 | { 57 | *(P+m)=exp(razn); 58 | sp+=*(P+m); 59 | }; 60 | } 61 | 62 | sp+=outlier_tmp; 63 | *(Pt1+n)=1-outlier_tmp/ sp; 64 | 65 | 66 | for (m=0; m < M; m++) { 67 | 68 | if (*(P+m)==0){} 69 | else 70 | { 71 | *(P1+m)+=*(P+m)/sp; 72 | for (d=0; d < D; d++) { 73 | *(Px+m+d*M)+= *(x+n+d*N)/ sp* *(P+m); 74 | } 75 | } 76 | 77 | } 78 | 79 | *E += -log(sp); 80 | } 81 | *E +=D*N*log(*sigma2)/2; 82 | 83 | 84 | free((void*)P); 85 | 86 | 87 | return; 88 | } 89 | 90 | /* Input arguments */ 91 | #define IN_x prhs[0] 92 | #define IN_y prhs[1] 93 | #define IN_sigma2 prhs[2] 94 | #define IN_outlier prhs[3] 95 | #define IN_truncate prhs[4] 96 | 97 | /* Output arguments */ 98 | #define OUT_P1 plhs[0] 99 | #define OUT_Pt1 plhs[1] 100 | #define OUT_Px plhs[2] 101 | #define OUT_E plhs[3] 102 | 103 | 104 | /* Gateway routine */ 105 | void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) 106 | { 107 | double *x, *y, *sigma2, *outlier, *truncate, *P1, *Pt1, *Px, *E; 108 | int N, M, D; 109 | 110 | /* Get the sizes of each input argument */ 111 | N = mxGetM(IN_x); 112 | M = mxGetM(IN_y); 113 | D = mxGetN(IN_x); 114 | 115 | /* Create the new arrays and set the output pointers to them */ 116 | OUT_P1 = mxCreateDoubleMatrix(M, 1, mxREAL); 117 | OUT_Pt1 = mxCreateDoubleMatrix(N, 1, mxREAL); 118 | OUT_Px = mxCreateDoubleMatrix(M, D, mxREAL); 119 | OUT_E = mxCreateDoubleMatrix(1, 1, mxREAL); 120 | 121 | /* Assign pointers to the input arguments */ 122 | x = mxGetPr(IN_x); 123 | y = mxGetPr(IN_y); 124 | sigma2 = mxGetPr(IN_sigma2); 125 | outlier = mxGetPr(IN_outlier); 126 | truncate = mxGetPr(IN_truncate); 127 | 128 | 129 | /* Assign pointers to the output arguments */ 130 | P1 = mxGetPr(OUT_P1); 131 | Pt1 = mxGetPr(OUT_Pt1); 132 | Px = mxGetPr(OUT_Px); 133 | E = mxGetPr(OUT_E); 134 | 135 | /* Do the actual computations in a subroutine */ 136 | cpd_comp(x, y, sigma2, outlier, P1, Pt1, Px, E, N, M, D, truncate); 137 | 138 | return; 139 | } 140 | 141 | 142 | -------------------------------------------------------------------------------- /src/cpd/cpd_Pcorrespondence.c: -------------------------------------------------------------------------------- 1 | /* 2 | Andriy Myronenko 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include "mex.h" 9 | #define max(A, B) ((A) > (B) ? (A) : (B)) 10 | #define min(A, B) ((A) < (B) ? (A) : (B)) 11 | 12 | void cpd_comp_correspondence( 13 | double* x, 14 | double* y, 15 | double* sigma2, 16 | double* outlier, 17 | double* Pc, 18 | int N, 19 | int M, 20 | int D) 21 | { 22 | int n, m, d; 23 | double ksig, diff, razn, outlier_tmp,temp_x,sp; 24 | double *P, *P1; 25 | 26 | 27 | P = (double*) calloc(M, sizeof(double)); 28 | P1 = (double*) calloc(M, sizeof(double)); 29 | 30 | 31 | ksig = -2.0 * (*sigma2+1e-3); 32 | outlier_tmp=(*outlier*M*pow (-ksig*3.14159265358979,0.5*D))/((1-*outlier)*N); 33 | if (outlier_tmp==0) outlier_tmp=1e-10; 34 | 35 | 36 | /* printf ("ksig = %lf\n", *sigma2);*/ 37 | 38 | 39 | for (n=0; n < N; n++) { 40 | sp=0; 41 | for (m=0; m < M; m++) { 42 | razn=0; 43 | for (d=0; d < D; d++) { 44 | diff=*(x+n+d*N)-*(y+m+d*M); diff=diff*diff; 45 | razn+=diff; 46 | } 47 | 48 | *(P+m)=exp(razn/ksig); 49 | sp+=*(P+m); 50 | 51 | } 52 | 53 | sp+=outlier_tmp; 54 | 55 | 56 | for (m=0; m < M; m++) { 57 | 58 | temp_x=*(P+m)/ sp; 59 | 60 | if (n==0) 61 | {*(P1+m)= *(P+m)/ sp; 62 | *(Pc+m)=n+1;}; 63 | 64 | if (temp_x > *(P1+m)) 65 | { 66 | *(P1+m)= *(P+m)/ sp; 67 | *(Pc+m)=n+1; 68 | } 69 | 70 | 71 | } 72 | 73 | } 74 | 75 | 76 | free((void*)P); 77 | free((void*)P1); 78 | 79 | return; 80 | } 81 | 82 | /* Input arguments */ 83 | #define IN_x prhs[0] 84 | #define IN_y prhs[1] 85 | #define IN_sigma2 prhs[2] 86 | #define IN_outlier prhs[3] 87 | 88 | 89 | /* Output arguments */ 90 | #define OUT_Pc plhs[0] 91 | 92 | 93 | 94 | /* Gateway routine */ 95 | void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) 96 | { 97 | double *x, *y, *sigma2, *outlier, *Pc; 98 | int N, M, D; 99 | 100 | /* Get the sizes of each input argument */ 101 | N = mxGetM(IN_x); 102 | M = mxGetM(IN_y); 103 | D = mxGetN(IN_x); 104 | 105 | /* Create the new arrays and set the output pointers to them */ 106 | OUT_Pc = mxCreateDoubleMatrix(M, 1, mxREAL); 107 | 108 | /* Assign pointers to the input arguments */ 109 | x = mxGetPr(IN_x); 110 | y = mxGetPr(IN_y); 111 | sigma2 = mxGetPr(IN_sigma2); 112 | outlier = mxGetPr(IN_outlier); 113 | 114 | 115 | 116 | /* Assign pointers to the output arguments */ 117 | Pc = mxGetPr(OUT_Pc); 118 | 119 | /* Do the actual computations in a subroutine */ 120 | cpd_comp(x, y, sigma2, outlier, Pc, N, M, D); 121 | 122 | return; 123 | } 124 | 125 | 126 | -------------------------------------------------------------------------------- /src/fgt/dval.c: -------------------------------------------------------------------------------- 1 | /* 2 | Evaluate weighted gaussian RBF between vectors x,y 3 | Author : Sébastien PARIS : sebastien.paris@lsis.org 4 | Modified for Python by David PFAU : david.pfau@gmail.com 5 | */ 6 | 7 | void c_dval(double *x , double *y , double *w , double sigma , double *v , int d , int Nx , int Ny ) 8 | { 9 | int i , j , l , id , jd; 10 | register double temp , res ; 11 | double tempv; 12 | double cte = -1.0/(sigma*sigma); 13 | int num_threads; 14 | 15 | #ifdef OMP 16 | num_threads = min(MAX_THREADS,omp_get_num_procs()); 17 | omp_set_num_threads(num_threads); 18 | #endif 19 | 20 | for (i = 0; i < Ny ; i++) 21 | { 22 | id = i*d; 23 | tempv = 0.0; 24 | #ifdef OMP 25 | /* #pragma omp parallel for default(none) private(j,l,temp,jd,res) shared(x,y,w,d,id,Nx,cte,tempv) */ 26 | #pragma omp parallel for default(none) firstprivate(l,temp,res) lastprivate(j,jd,tempv) shared(x,y,w,d,id,Nx,cte) 27 | #endif 28 | for (j = 0 ; j < Nx ; j++) 29 | { 30 | jd = j*d; 31 | res = 0.0; 32 | for (l = 0 ; l < d ; l++) 33 | { 34 | temp = (y[l + id] - x[l + jd]); 35 | res +=temp*temp; 36 | } 37 | tempv += w[j]*exp(cte*res); 38 | } 39 | v[i] = tempv; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/fgt/fgt_model.c: -------------------------------------------------------------------------------- 1 | #include "fgt/fgt_model.h" 2 | #include 3 | 4 | void fgt_model(double *x , double *w , double sigma , int p , int K , double e , 5 | double *xc , double *A_k , 6 | int d , int Nx , 7 | int *indxc , int *indx , int *xhead , int *xboxsz , 8 | double *dist_C , double *C_k , int *heads , int *cinds , double *dx , double *prods , 9 | int pd) 10 | { 11 | Kcenter(x , d , Nx , K , 12 | xc , indxc , indx , xboxsz , 13 | dist_C); 14 | Compute_C_k(d , p , 15 | C_k , 16 | heads , cinds); 17 | Compute_A_k(x , w , xc , C_k , sigma , d , Nx , p , K , pd , 18 | A_k , 19 | indx , dx , prods , heads ); 20 | } 21 | 22 | void Kcenter(double *x , int d , int Nx , int K , 23 | double *xc , int *indxc , int *indx , int *xboxsz , 24 | double *dist_C) 25 | { 26 | double *x_ind , *x_j; 27 | register double temp ; 28 | int i , j , ind , nd , ibase; 29 | 30 | /* randomly pick one node as the first center. */ 31 | /* srand( (unsigned)time( NULL ) ); */ 32 | /* ind = rand() % Nx; */ 33 | ind = 1; 34 | *indxc++ = ind; 35 | x_j = x; 36 | x_ind = x + ind*d; 37 | 38 | for (j = 0 ; j < Nx ; x_j += d , j++) 39 | { 40 | dist_C[j] = (j==ind) ? 0.0 : ddist(x_j , x_ind , d); 41 | indx[j] = 0; 42 | } 43 | 44 | for(i = 1 ; i < K ; i++) 45 | { 46 | ind = idmax(dist_C , Nx); 47 | *indxc++ = ind; 48 | x_j = x; 49 | x_ind = x + ind*d; 50 | for (j = 0 ; j < Nx ; x_j += d, j++) 51 | { 52 | temp = (j==ind) ? 0.0 : ddist(x_j , x_ind , d); 53 | if (temp < dist_C[j]) 54 | { 55 | dist_C[j] = temp; 56 | indx[j] = i; 57 | } 58 | } 59 | } 60 | 61 | for (i = 0 ; i < K ; i++) 62 | { 63 | xboxsz[i] = 0; 64 | } 65 | 66 | for (i = 0; i < d*K; i++) 67 | { 68 | xc[i] = 0.0; 69 | } 70 | 71 | for (i = 0 , nd = 0 ; i < Nx ; i++ , nd += d) 72 | { 73 | xboxsz[indx[i]]++; 74 | ibase = indx[i]*d; 75 | for (j = 0 ; j < d; j++) 76 | { 77 | xc[j + ibase ] += x[j + nd]; 78 | } 79 | } 80 | 81 | for (i = 0 , ibase = 0 ; i < K ; i++ , ibase += d) 82 | { 83 | temp = 1.0/xboxsz[i]; 84 | for (j = 0; j < d; j++) 85 | { 86 | xc[j + ibase] *= temp; 87 | } 88 | } 89 | } 90 | 91 | void Compute_C_k(int d , int p , 92 | double *C_k , 93 | int *heads , int *cinds) 94 | { 95 | int i , k , t , j , tail , head; 96 | for (i = 0; i < d; i++) 97 | { 98 | heads[i] = 0; 99 | } 100 | heads[d] = INT_MAX; 101 | cinds[0] = 0; 102 | C_k[0] = 1.0; 103 | for (k=1 , t=1, tail = 1 ; k < p ; k++ , tail=t) 104 | { 105 | for (i = 0; i < d; i++) 106 | { 107 | head = heads[i]; 108 | heads[i] = t; 109 | for ( j = head ; j < tail ; j++ , t++) 110 | { 111 | cinds[t] = (j < heads[i+1]) ? cinds[j] + 1 : 1; 112 | C_k[t] = 2.0 * C_k[j]; 113 | C_k[t] /= (double) cinds[t]; 114 | } 115 | } 116 | } 117 | } 118 | 119 | void Compute_A_k(double *x , double *w , double *xc, double *C_k , double sigma , int d , int Nx , int p , int K , int pd , 120 | double *A_k , 121 | int *indx , double *dx , double *prods , int *heads ) 122 | { 123 | int n , i , k , t , tail , j , head , ind; 124 | int nbase , ix2c , ix2cbase; 125 | register double sum , ctesigma = 1.0/(sigma) , temp , temp1; 126 | 127 | for (i = 0; i < pd*K; i++) 128 | { 129 | A_k[i] = 0.0; 130 | } 131 | 132 | for (n = 0 ; n < Nx ; n++) 133 | { 134 | nbase = n*d; 135 | ix2c = indx[n]; 136 | ix2cbase = ix2c*d; 137 | ind = ix2c*pd; 138 | temp = w[n]; 139 | sum = 0.0; 140 | 141 | for (i = 0 ; i < d ; i++) 142 | { 143 | dx[i] = (x[i + nbase] - xc[i + ix2cbase])*ctesigma; 144 | sum += dx[i] * dx[i]; 145 | heads[i] = 0; 146 | } 147 | prods[0] = exp(-sum); 148 | 149 | for (k = 1 , t = 1 , tail = 1 ; k < p ; k++ , tail = t) 150 | { 151 | for (i = 0 ; i < d; i++) 152 | { 153 | head = heads[i]; 154 | heads[i] = t; 155 | temp1 = dx[i]; 156 | for ( j = head; j < tail ; j++, t++) 157 | { 158 | prods[t] = temp1 * prods[j]; 159 | } 160 | } 161 | } 162 | 163 | for (i = 0 ; i < pd ; i++) 164 | { 165 | A_k[i + ind] += temp*prods[i]; 166 | } 167 | } 168 | 169 | for (k = 0 ; k < K ; k++) 170 | { 171 | ind = k*pd; 172 | for (i = 0 ; i < pd ; i++) 173 | { 174 | A_k[i + ind] *= C_k[i]; 175 | } 176 | } 177 | } 178 | 179 | int nchoosek(int n , int k) 180 | { 181 | int i , n_k = n - k , nchsk = 1; 182 | if (k < n_k) 183 | { 184 | k = n_k; 185 | n_k = n - k; 186 | } 187 | for ( i = 1 ; i <= n_k ; i++) 188 | { 189 | nchsk *= (++k); 190 | nchsk /= i; 191 | } 192 | return nchsk; 193 | } 194 | 195 | double ddist(double *x , double *y , int d) 196 | { 197 | int i; 198 | register double t , s = 0.0; 199 | for (i = 0 ; i < d ; i++) 200 | { 201 | t = (x[i] - y[i]); 202 | s += (t * t); 203 | } 204 | return s; 205 | } 206 | 207 | int idmax(double *x , int N) 208 | { 209 | int i , k = 0; 210 | double t = -1.0; 211 | for (i = 0 ; i < N ; i++ ) 212 | { 213 | if( t < x[i] ) 214 | { 215 | t = x[i]; 216 | k = i; 217 | } 218 | } 219 | return k; 220 | } 221 | -------------------------------------------------------------------------------- /src/fgt/fgt_predict.c: -------------------------------------------------------------------------------- 1 | #include "fgt/fgt_predict.h" 2 | 3 | void fgt_predict(double *y , double *xc , double *A_k , int Ny, double sigma , int K , double e , int d , int pd , 4 | double *v , 5 | double *dy , double *prods , int *heads) 6 | { 7 | int p , i , j , m , k , t , tail , mbase , kn , xbase , head , ind; 8 | double sum2 , ctesigma = 1.0/(sigma) , temp , temp1; 9 | p = invnchoosek(d , pd); 10 | for (m=0 ; m < Ny ; m++) 11 | { 12 | temp = 0.0; 13 | mbase = m*d; 14 | for (kn = 0 ; kn < K ; kn++) 15 | { 16 | xbase = kn*d; 17 | ind = kn*pd; 18 | sum2 = 0.0; 19 | for (i = 0 ; i < d ; i++) 20 | { 21 | dy[i] = (y[i + mbase] - xc[i + xbase])*ctesigma; 22 | sum2 += dy[i] * dy[i]; 23 | heads[i] = 0; 24 | } 25 | if (sum2 > e) continue; /* skip to next kn */ 26 | prods[0] = exp(-sum2); 27 | for (k=1, t=1, tail=1 ; k < p ; k++ , tail=t) 28 | { 29 | for (i = 0 ; i < d; i++) 30 | { 31 | head = heads[i]; 32 | heads[i] = t; 33 | temp1 = dy[i]; 34 | for (j = head ; j < tail ; j++ , t++) 35 | { 36 | prods[t] = temp1 * prods[j]; 37 | } 38 | } 39 | } 40 | 41 | for (i = 0 ; i < pd ; i++) 42 | { 43 | temp += A_k[i + ind]*prods[i]; 44 | } 45 | } 46 | v[m] = temp; 47 | } 48 | } 49 | 50 | int invnchoosek(int d , int cnk) 51 | { 52 | int i , j , cted=1 , ctep , cte , p ; 53 | for(i = 2 ; i <= d ; i++) 54 | { 55 | cted *=i; 56 | } 57 | 58 | cte = cnk*cted; 59 | p = 2; 60 | ctep = p; 61 | 62 | for (i = p + 1 ; i < p + d ; i++) 63 | { 64 | ctep *=i ; 65 | } 66 | 67 | while(ctep != cte) 68 | { 69 | ctep = ((p+d)*ctep)/p; 70 | p++; 71 | } 72 | 73 | return p; 74 | } 75 | -------------------------------------------------------------------------------- /test/test_fgt.py: -------------------------------------------------------------------------------- 1 | from cpd.fast_gaussian_transform import * 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from mpl_toolkits.mplot3d import Axes3D 5 | from matplotlib import cm 6 | 7 | def test_fgt_run(): 8 | d = 3 9 | Nx = 100 10 | x = np.random.randn(d, Nx) 11 | 12 | xc, Ak = model(x) 13 | 14 | def test_fgt_value(): 15 | d = 3 16 | Nx = 10 17 | Ny = 100 18 | x = np.random.randn(d, Nx) 19 | y = np.random.randn(d, Ny) 20 | w = np.random.rand(1 , Nx) 21 | h = 2 22 | 23 | e = 10 24 | p = 6 25 | K = 5 26 | 27 | xc, Ak = model(x, w, h, e, K, p) 28 | v = predict(y, xc, Ak, h, e) 29 | 30 | 31 | def test_fgt_plot(): 32 | d = 2 33 | R = np.array([[2 , 0.4], [0.4, 3]]) 34 | Nx = 1000 35 | 36 | h = 1 37 | e = 10 38 | K = np.round(np.sqrt(Nx)) 39 | p = 6 40 | 41 | vect = np.arange(-5,5,0.3) 42 | Ny = len(vect) 43 | w = (1.0/Nx)*np.ones((1, Nx)) 44 | 45 | x = (np.linalg.cholesky(R).transpose().dot(np.random.randn(d, Nx))) 46 | 47 | X, Y = np.meshgrid(vect, vect) 48 | y = np.zeros((d,Ny*Ny)) 49 | 50 | y[0,:] = X.flatten() 51 | y[1,:] = Y.flatten() 52 | 53 | xc, Ak = model(x, w, h, e, K, p); 54 | vy = predict(y, xc, Ak, h, e); 55 | 56 | density = vy.reshape((Ny, Ny)); 57 | 58 | fig = plt.figure() 59 | ax = fig.gca(projection='3d') 60 | surf = ax.plot_surface(X, Y, density, rstride=1, cstride=1, cmap=cm.coolwarm, 61 | linewidth=0, antialiased=False, alpha=0.5) 62 | ax.plot(x[0, :], x[1, :], 'r+', xc[0, :], xc[1, :], 'ko', ms=10) 63 | 64 | fig.colorbar(surf, shrink=0.5, aspect=5) 65 | plt.show() 66 | 67 | def test_dval_1(): 68 | d = 10 69 | Nx = 100 70 | Ny = 10000 71 | x = np.random.randn(d, Nx) 72 | y = np.random.randn(d, Ny) 73 | v = dval(x, y) 74 | 75 | def test_dval_2(): 76 | d = 10 77 | Nx = 100 78 | Ny = 10000 79 | x = np.random.randn(d, Nx) 80 | y = np.random.randn(d, Ny) 81 | u = np.random.rand(1, Nx) 82 | sigma = 2 83 | v = dval(x, y, u, sigma) 84 | --------------------------------------------------------------------------------