Implemented chain position+topology interpolation utilities for rendering

Author: mtortora

polykit/renderers/backends.py

@@ -88,11 +88,11 @@ def _fresnel(self,
                  colors,
                  radii,
                  intensity=0.,
-                 metal=0.4,
+                 metal=0.7,
                  specular=0.8,
                  spec_trans=0.1,
-                 roughness=0.2,
-                 outline=0.05):
+                 roughness=0.1,
+                 outline=0.04):
         """
         Render individual polymer/particle configurations using the Fresnel backend library
             
@@ -148,7 +148,7 @@ def _fresnel(self,
                                                  primitive_color_mix=1.,
                                                  solid=0.)
         geometry.outline_material = fl.material.Material(color=fl.color.linear([.25,.25,.25]),
-                                                         roughness=2*roughness,
+                                                         roughness=roughness,
                                                          metal=metal,
                                                          specular=specular,
                                                          spec_trans=spec_trans,

polykit/renderers/utils.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from scipy.interpolate import InterpolatedUnivariateSpline
+
+
+def interpolate_chain(positions, extra_bonds=[], target_N=90000, fine_grain=10):
+    """
+    Converts an individual polymer of any length to a smoothed chain with fixed distance between neighboring monomers.
+    Proceeds by cubic spline interpolation as follows.
+
+    1. Interpolate the data using cubic spline
+    2. Evaluate cubic spline at targetN*10 values
+    3. Rescale the evaluated spline such that total distance is targetN
+    4. Select targetN points along the path with distance between neighboring points _along the chain_ equal to 1.
+    5. Select appropriate bonds along the interpolated path to mimic the original chain topology
+
+    Parameters
+    ----------
+		positions : Nx3 float array
+			Input xyz coordinates
+		extra_bonds : Mx2 int array
+			Non-contiguous extra bonds to be interpolated (optional)
+		target_N : int
+			Length of output polymer.
+			It is not advised to make it many times less than N
+
+    Returns
+    -------
+		(about target_N) x 3 float array of interpolated positions
+		(about target_N-1 + M) x 2 int array of interpolated bonds
+    """
+
+    N = len(positions)
+    target_data_size = target_N*fine_grain
+
+    eval_range = np.arange(N)
+    target_range = np.arange(0, N-1, N/float(target_data_size))
+
+    splined = np.zeros((len(target_range), 3), float)
+    
+    for i in range(3):
+        spline = InterpolatedUnivariateSpline(eval_range, positions[:, i], k=3)
+        splined[:, i] = spline(target_range)
+
+    pos = np.arange(1, target_N)
+    dists = np.linalg.norm(np.diff(splined, axis=0), axis=1)
+    
+    cum_dists = np.cumsum(dists)
+
+    splined /= (cum_dists[-1]  / N)
+    cum_dists /= (cum_dists[-1] / target_N)
+    
+    searched_pos = np.searchsorted(cum_dists, pos)
+    searched_bonds = np.searchsorted(target_range[searched_pos], extra_bonds)
+
+    v1 = cum_dists[searched_pos]
+    v2 = cum_dists[searched_pos-1]
+        
+    p1 = (v1-np.floor(v1)) / (v1-v2)
+    p2 = 1-p1
+
+    interp_pos = p2[:, None]*splined[searched_pos] + p1[:, None]*splined[searched_pos-1]
+    interp_bonds = np.asarray(list(zip(pos[:-1]-1, pos[:-1])) + searched_bonds.tolist())
+    
+    return interp_pos, interp_bonds