Added grid trilinear interpolation computation online. This will reduce the DLL memory requirements by a factor of 7 approximatelly

Author: fercabe

src/dllnode.hpp

@@ -77,7 +77,7 @@ class DLLNode
 		m_tfCache = false;
 
 		// Compute trilinear interpolation map 
-		m_grid3d.computeTrilinearInterpolation();
+		//m_grid3d.computeTrilinearInterpolation(); /* Now we compute the approximation online */
 
 		// Setup solver parameters
 		m_solver.setMaxNumIterations(m_solverMaxIter);

src/dllsolver.hpp

@@ -48,7 +48,7 @@ class DLLCostFunction
         nx = ca*_px - sa*_py + tx;
         ny = sa*_px + ca*_py + ty;
         nz = _pz + tz;
-        p = _grid.getPointDistInterpolation(nx, ny, nz);
+        p = _grid.computeDistInterpolation(nx, ny, nz);
         c0 = p.a0; c1 = p.a1; c2 = p.a2; c3 = p.a3; c4 = p.a4; c5 = p.a5; c6 = p.a6; c7 = p.a7;
 
         residuals[0] =  _weight*(c0 + c1*nx + c2*ny + c3*nz + c4*nx*ny + c5*nx*nz + c6*ny*nz + c7*nx*ny*nz);

src/grid3d.hpp

@@ -292,6 +292,56 @@ class Grid3d
 		return r;
 	}
 
+	TrilinearParams computeDistInterpolation(const double x, const double y, const double z)
+	{
+		TrilinearParams r;
+
+		if(isIntoMap(x, y, z))
+		{
+			// Get 3D point index
+			uint64_t i = point2grid(x, y, z); 
+
+			// Get neightbour values to compute trilinear interpolation
+			float c000, c001, c010, c011, c100, c101, c110, c111;
+			c000 = m_grid[i].dist; 
+			c001 = m_grid[i+m_gridStepZ].dist; 
+			c010 = m_grid[i+m_gridStepY].dist; 
+			c011 = m_grid[i+m_gridStepY+m_gridStepZ].dist; 
+			c100 = m_grid[i+1].dist; 
+			c101 = m_grid[i+1+m_gridStepZ].dist; 
+			c110 = m_grid[i+1+m_gridStepY].dist; 
+			c111 = m_grid[i+1+m_gridStepY+m_gridStepZ].dist; 
+
+			// Compute trilinear parameters
+			const float div = -m_oneDivRes*m_oneDivRes*m_oneDivRes;
+			float x0, y0, z0, x1, y1, z1;
+			x0 = ((int)(x*m_oneDivRes))*m_resolution;
+			x1 = x0+m_resolution;
+			y0 = ((int)(y*m_oneDivRes))*m_resolution;
+			y1 = y0+m_resolution;
+			z0 = ((int)(z*m_oneDivRes))*m_resolution;
+			z1 = z0+m_resolution;
+			r.a0 = (-c000*x1*y1*z1 + c001*x1*y1*z0 + c010*x1*y0*z1 - c011*x1*y0*z0 
+			+ c100*x0*y1*z1 - c101*x0*y1*z0 - c110*x0*y0*z1 + c111*x0*y0*z0)*div;
+			r.a1 = (c000*y1*z1 - c001*y1*z0 - c010*y0*z1 + c011*y0*z0
+			- c100*y1*z1 + c101*y1*z0 + c110*y0*z1 - c111*y0*z0)*div;
+			r.a2 = (c000*x1*z1 - c001*x1*z0 - c010*x1*z1 + c011*x1*z0 
+			- c100*x0*z1 + c101*x0*z0 + c110*x0*z1 - c111*x0*z0)*div;
+			r.a3 = (c000*x1*y1 - c001*x1*y1 - c010*x1*y0 + c011*x1*y0 
+			- c100*x0*y1 + c101*x0*y1 + c110*x0*y0 - c111*x0*y0)*div;
+			r.a4 = (-c000*z1 + c001*z0 + c010*z1 - c011*z0 + c100*z1 
+			- c101*z0 - c110*z1 + c111*z0)*div;
+			r.a5 = (-c000*y1 + c001*y1 + c010*y0 - c011*y0 + c100*y1 
+			- c101*y1 - c110*y0 + c111*y0)*div;
+			r.a6 = (-c000*x1 + c001*x1 + c010*x1 - c011*x1 + c100*x0 
+			- c101*x0 - c110*x0 + c111*x0)*div;
+			r.a7 = (c000 - c001 - c010 + c011 - c100
+			+ c101 + c110 - c111)*div;
+		}
+
+		return r;
+	}
+
 	bool computeTrilinearInterpolation(void)
 	{
 		// Delete existing parameters if the exists