Move and suppression of unused code

Author: adelepoulle

setup.py

@@ -18,10 +18,8 @@
     scripts=[
         'src/scripts/EddyIdentification',
         'src/scripts/EddyTracking',
-        'src/scripts/EddyTrackingFull',
-        'src/scripts/make_eddy_track_aviso.py',
-        'src/scripts/make_eddy_track_CLS.py',
-        'src/scripts/make_eddy_track_ROMS.py'],
+        'src/scripts/EddyTrackingFull'
+        ],
     zip_safe=False,
     cmdclass={
         'build_ext': cython_build_ext,

src/py_eddy_tracker/property_functions.py

@@ -33,12 +33,54 @@
 import numpy as np
 from datetime import datetime
 from pyproj import Proj
-from .tracking_objects import uniform_resample, nearest
+from .tracking_objects import nearest
 from .observations import EddiesObservations
 from .property_objects import Amplitude
 from .tools import distance, winding_number_poly, fit_circle_c, poly_contain_poly
 from matplotlib.path import Path as BasePath
 from scipy.interpolate import griddata
+from .tools import distance_vector
+from scipy.interpolate import Akima1DInterpolator
+
+
+def uniform_resample(x_val, y_val, method='interp1d', extrapolate=None,
+        num_fac=2, fixed_size=None):
+    """
+    Resample contours to have (nearly) equal spacing
+       x_val, y_val    : input contour coordinates
+       num_fac : factor to increase lengths of output coordinates
+       method  : currently only 'interp1d' or 'Akima'
+                 (Akima is slightly slower, but may be more accurate)
+       extrapolate : IS NOT RELIABLE (sometimes nans occur)
+    """
+    # Get distances
+    dist = np.empty_like(x_val)
+    dist[0] = 0
+    distance_vector(
+        x_val[:-1], y_val[:-1], x_val[1:], y_val[1:], dist[1:])
+    dist.cumsum(out=dist)
+    # Get uniform distances
+    if fixed_size is None:
+        fixed_size = dist.size * num_fac
+    d_uniform = np.linspace(0,
+                            dist[-1],
+                            num=fixed_size,
+                            endpoint=True)
+
+    # Do 1d interpolations
+    if 'interp1d' == method:
+        x_new = np.interp(d_uniform, dist, x_val)
+        y_new = np.interp(d_uniform, dist, y_val)
+    elif 'akima' == method:
+        xfunc = Akima1DInterpolator(dist, x_val)
+        yfunc = Akima1DInterpolator(dist, y_val)
+        x_new = xfunc(d_uniform, extrapolate=extrapolate)
+        y_new = yfunc(d_uniform, extrapolate=extrapolate)
+
+    else:
+        raise Exception()
+
+    return x_new, y_new
 
 
 def datestr2datetime(datestr):

src/py_eddy_tracker/property_objects.py

@@ -33,124 +33,10 @@
 from scipy.ndimage import binary_erosion
 from scipy.ndimage import minimum_filter
 import numpy as np
-from netCDF4 import Dataset
 from .tools import index_from_nearest_path, distance_matrix
-from . import VAR_DESCR, VAR_DESCR_inv
-from .observations import EddiesObservations
 import logging
 
 
-class VirtualEddiesObservations(EddiesObservations):
-    """Class to work with virtual obs
-    """
-
-    @property
-    def elements(self):
-        elements = super(VirtualEddiesObservations, self).elements
-        elements.extend(['track', 'segment_size', 'dlon', 'dlat'])
-        return elements
-
-
-class TrackEddiesObservations(EddiesObservations):
-    
-    def extract_longer_eddies(self, nb_min, nb_obs):
-        m = nb_obs >= nb_min
-        nb_obs_select = m.sum()
-        logging.info('Selection of %d observations', nb_obs_select)
-        eddies = TrackEddiesObservations(size=nb_obs_select)
-        eddies.sign_type = self.sign_type
-        for var, _ in eddies.obs.dtype.descr:
-            eddies.obs[var] = self.obs[var][m]
-        return eddies
-    
-    @property
-    def elements(self):
-        elements = super(TrackEddiesObservations, self).elements
-        elements.extend(['track', 'n', 'virtual'])
-        return elements
-    
-    def create_variable(self, handler_nc, kwargs_variable,
-                        attr_variable, data, scale_factor=None):
-        var = handler_nc.createVariable(
-            zlib=True,
-            complevel=1,
-            **kwargs_variable)
-        for attr, attr_value in attr_variable.iteritems():
-            var.setncattr(attr, attr_value)
-            
-        var[:] = data
-        
-        #~ var.set_auto_maskandscale(False)
-        if scale_factor is not None:
-            var.scale_factor = scale_factor
-            
-        try:
-            var.setncattr('min', var[:].min())
-            var.setncattr('max', var[:].max())
-        except ValueError:
-            logging.warn('Data is empty')
-
-    def write_netcdf(self):
-        """Write a netcdf with eddy obs
-        """
-        eddy_size = len(self.observations)
-        sign_type = 'Cyclonic' if self.sign_type == -1 else 'Anticyclonic'
-        filename = '%s.nc' % sign_type
-        with Dataset(filename, 'w', format='NETCDF4') as h_nc:
-            logging.info('Create file %s', filename)
-            # Create dimensions
-            logging.debug('Create Dimensions "Nobs" : %d', eddy_size)
-            h_nc.createDimension('Nobs', eddy_size)
-            # Iter on variables to create:
-            for name, _ in self.observations.dtype.descr:
-                logging.debug('Create Variable %s', VAR_DESCR[name]['nc_name'])
-                self.create_variable(
-                    h_nc,
-                    dict(varname=VAR_DESCR[name]['nc_name'],
-                         datatype=VAR_DESCR[name]['nc_type'],
-                         dimensions=VAR_DESCR[name]['nc_dims']),
-                    VAR_DESCR[name]['nc_attr'],
-                    self.observations[name],
-                    scale_factor=None if 'scale_factor' not in VAR_DESCR[name] else VAR_DESCR[name]['scale_factor'])
-
-            # Add cyclonic information
-            self.create_variable(
-                h_nc,
-                dict(varname=VAR_DESCR['type_cyc']['nc_name'],
-                     datatype=VAR_DESCR['type_cyc']['nc_type'],
-                     dimensions=VAR_DESCR['type_cyc']['nc_dims']),
-                VAR_DESCR['type_cyc']['nc_attr'],
-                self.sign_type)
-            # Global attr
-            self.set_global_attr_netcdf(h_nc)
-
-    def set_global_attr_netcdf(self, h_nc):
-        h_nc.title = 'Cyclonic' if self.sign_type == -1 else 'Anticyclonic' + ' eddy tracks'
-        #~ h_nc.grid_filename = self.grd.grid_filename
-        #~ h_nc.grid_date = str(self.grd.grid_date)
-        #~ h_nc.product = self.product
-
-        #~ h_nc.contour_parameter = self.contour_parameter
-        #~ h_nc.shape_error = self.shape_error
-        #~ h_nc.pixel_threshold = self.pixel_threshold
-
-        #~ if self.smoothing in locals():
-            #~ h_nc.smoothing = self.smoothing
-            #~ h_nc.SMOOTH_FAC = self.SMOOTH_FAC
-        #~ else:
-            #~ h_nc.smoothing = 'None'
-
-        #~ h_nc.evolve_amp_min = self.evolve_amp_min
-        #~ h_nc.evolve_amp_max = self.evolve_amp_max
-        #~ h_nc.evolve_area_min = self.evolve_area_min
-        #~ h_nc.evolve_area_max = self.evolve_area_max
-#~ 
-        #~ h_nc.llcrnrlon = self.grd.lonmin
-        #~ h_nc.urcrnrlon = self.grd.lonmax
-        #~ h_nc.llcrnrlat = self.grd.latmin
-        #~ h_nc.urcrnrlat = self.grd.latmax
-
-
 class Amplitude (object):
     """
     Class to calculate *amplitude* and counts of *local maxima/minima*