sgptools 1.0.5__py3-none-any.whl → 1.0.6__py3-none-any.whl

sgptools/models/core/transformations.py

@@ -15,17 +15,9 @@
 """Provides transforms to model complex sensor field of views and handle informative path planning
 """
 
-try:
-    from tensorflow_graphics.math.interpolation import bspline
-except:
-  pass
-
 import tensorflow as tf
 import numpy as np
 
-from scipy.optimize import linear_sum_assignment
-from sklearn.metrics import pairwise_distances
-
 
 class Transform:
     """Base class for transformations of the inducing points, including expansion and aggregation transforms.
@@ -98,84 +90,6 @@ class Transform:
         """
         return 0.
 
-    def distance(self, Xu):
-        """Computes the distance incured by sequentially visiting the inducing points
-
-        Args:
-            Xu (ndarray): Inducing points from which to compute the path length
-
-        Returns:
-            dist (float): path length
-        """
-        dist = tf.math.reduce_sum(tf.norm(Xu[1:]-Xu[:-1], axis=1))
-        return dist
-    
-
-class SquareTransform(Transform):
-    """Non-point Transform to model a square FoV. Only works for single robot cases. 
-    ToDo: update expand function to handle multi-robot case.
-
-    Args:
-        length (float): Length of the square FoV
-        num_side (int): Number of points along each side of the FoV
-    """
-    def __init__(self, length, num_side, **kwargs):
-        super().__init__(**kwargs)
-        self.length = length
-        self.num_side = num_side
-        self.length_factor=length/(self.num_side)
-        self.num_length = int(length/self.length_factor)
-
-        if self.aggregation_size == 0:
-            self.aggregation_size = None
-        elif self.aggregation_size is None:
-            self.aggregation_size = num_side**2
-
-    def expand(self, Xu):
-        """Applies the expansion transformation to the inducing points
-
-        Args:
-            Xu (ndarray): (1, m, 3); Inducing points in the position and orientation space.
-                            `m` is the number of inducing points,
-                            `3` is the dimension of the space (x, y, angle in radians)
-                        
-        Returns:
-            Xu (ndarray): (mp, 2); Inducing points in input space.
-                        `p` is the number of points each inducing point is mapped 
-                         to in order to form the FoV.
-        """
-        x, y, theta = tf.split(Xu, num_or_size_splits=3, axis=2)
-        x = tf.squeeze(x)
-        y = tf.squeeze(y)
-        theta = tf.squeeze(theta)
-
-        points = []
-        for i in range(-int(np.floor((self.num_side)/2)), int(np.ceil((self.num_side)/2))):
-            points.append(tf.linspace([(x + (i * self.length_factor) * tf.cos(theta)) - self.length/2 * tf.cos(theta+np.pi/2), 
-                                       (y + (i * self.length_factor) * tf.sin(theta)) - self.length/2 * tf.sin(theta+np.pi/2)], 
-                                      [(x + (i * self.length_factor) * tf.cos(theta)) + self.length/2 * tf.cos(theta+np.pi/2), 
-                                       (y + (i * self.length_factor) * tf.sin(theta)) + self.length/2 * tf.sin(theta+np.pi/2)], 
-                                      self.num_side, axis=1))
-        xy = tf.concat(points, axis=1)
-        xy = tf.transpose(xy, [2, 1, 0])
-        xy = tf.reshape(xy, [-1, 2])
-        xy = self._reshape(xy, tf.shape(Xu)[1])
-        return xy
-    
-    def _reshape(self, X, num_inducing):
-        """Reorder the inducing points to be in the correct order for aggregation with square FoV.
-
-        Args:
-            X (ndarray): (mp, 2); Inducing points in input space. `p` is the number of points each 
-                        inducing point is mapped to in order to form the FoV.
-                            
-        Returns:
-            Xu (ndarray): (mp, 2); Reorder inducing points
-        """
-        X = tf.reshape(X, (num_inducing, -1, self.num_side, self.num_side, 2))
-        X = tf.transpose(X, (0, 2, 1, 3, 4))
-        X = tf.reshape(X, (-1, 2))
-        return X
 
 class IPPTransform(Transform):
     """Transform to model IPP problems
@@ -184,6 +98,7 @@ class IPPTransform(Transform):
         * For point sensing, set `sampling_rate = 2`
         * For continuous sensing, set `sampling_rate > 2` (account for the information along the path)
         * For continuous sensing with aggregation, set `sampling_rate > 2` and `aggregate_fov = True` (faster but solution quality is a bit diminished)
+        * If using a non-point FoV model with continuous sampling, only the FoV inducing points are aggregated
         * For multi-robot case, set `num_robots > 1`
         * For onlineIPP use `update_fixed` to freeze the visited waypoints
 
@@ -192,7 +107,7 @@ class IPPTransform(Transform):
         distance_budget (float): Distance budget for the path
         num_robots (int): Number of robots
         Xu_fixed (ndarray): (num_robots, num_visited, num_dim); Visited waypoints that don't need to be optimized
-        num_dim (int): Dimension of the data collection environment
+        num_dim (int): Number of dimensions of the inducing points
         sensor_model (Transform): Transform object to expand each inducing point to `p` points 
                                   approximating each sensor's FoV
         aggregate_fov (bool): Used only when sampling_rate > 2, i.e., when using a continuous sensing model. 
@@ -220,8 +135,11 @@ class IPPTransform(Transform):
 
         # Set aggregation size to sampling rate if aggregate_fov is True
         # and sampling rate is enabled (greater than 2)
-        if aggregate_fov and sampling_rate > 2:
-            self.aggregation_size = sampling_rate
+        if aggregate_fov:
+            if self.sensor_model is not None:
+                self.sensor_model.enable_aggregation()
+            elif sampling_rate > 2:
+                self.aggregation_size = sampling_rate
     
         # Initilize variable to store visited waypoints for onlineIPP
         if Xu_fixed is not None:
@@ -278,7 +196,10 @@ class IPPTransform(Transform):
             Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
 
         if self.sensor_model is not None:
-            Xu = self.sensor_model.expand(Xu)
+            Xu_ = []
+            for i in range(self.num_robots):
+                Xu_.append(self.sensor_model.expand(Xu[i]))
+            Xu = tf.concat(Xu_, axis=0)
             return Xu
 
         Xu = tf.reshape(Xu, (-1, self.num_dim))
@@ -315,6 +236,7 @@ class IPPTransform(Transform):
         if self.distance_budget is None:
             return 0.
         else:
+            # Only do fixed points expansion transform
             Xu = self.expand(Xu, expand_sensor_model=False)
             dist = self.distance(Xu)-self.distance_budget
             dist = tf.reduce_sum(tf.nn.relu(dist))
@@ -323,39 +245,146 @@ class IPPTransform(Transform):
 
     def distance(self, Xu):
         """Computes the distance incured by sequentially visiting the inducing points
-        ToDo: Change distance from 2d to nd. Currently limited to 2d 
-            to ensure the rotation angle is not included when using
-            a square FoV sensor.
+        Args:
+            Xu (ndarray): (m, num_dim); Inducing points from which to compute the path lengths
+                          `m` is the number of inducing points
+                          `num_dim` dimension of the data collection environment
+        Returns:
+            dist (float or tensor of floats): path length(s)
+        """
+        Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
+        if self.sensor_model is not None:
+            dists = []
+            for i in range(self.num_robots):
+                dists.append(self.sensor_model.distance(Xu[i]))
+            dists = tf.concat(dists, axis=0)
+            return dists
+        else:
+            # Assumes 2D waypoints by default
+            dist = tf.norm(Xu[:, 1:, :2] - Xu[:, :-1, :2], axis=-1)
+            dist = tf.reduce_sum(dist, axis=1)
+            return dist
+
+
+class SquareTransform(Transform):
+    """Non-point Transform to model a square FoV. Only works for single robot cases. 
+
+    Args:
+        length (float): Length of the square FoV
+        num_side (int): Number of points along each side of the FoV
+        aggregate_fov (bool): If `True`, covariances corresponding to interpolated inducing points used to 
+                              approximate the sensor FoV are aggregated to reduce the matrix inversion cost
+    """
+    def __init__(self, length, num_side, aggregate_fov=False, **kwargs):
+        super().__init__(**kwargs)
+        self.length = length
+        self.num_side = num_side
+        self.length_factor=length/(self.num_side)
+        self.num_length = int(length/self.length_factor)
+
+        if aggregate_fov:
+            self.enable_aggregation()
+
+    def enable_aggregation(self, size=None):
+        """Enable FoV covariance aggregation, which reduces the covariance matrix inversion cost by reducing the 
+        covariance matrix size.
+
+        Args:
+            size (int): If None, all the interpolated inducing points within the FoV are aggregated. Alternatively, 
+                        the number of inducing points to aggregate can be explicitly defined using this variable.
+        """
+        if size is None:
+            self.aggregation_size = self.num_side**2
+        else:
+            self.aggregation_size = size
+
+    def expand(self, Xu):
+        """Applies the expansion transformation to the inducing points
+
+        Args:
+            Xu (ndarray): (m, 3); Inducing points in the position and orientation space.
+                          `m` is the number of inducing points,
+                          `3` is the dimension of the space (x, y, angle in radians)
+                        
+        Returns:
+            Xu (ndarray): (mp, 2); Inducing points in input space.
+                        `p` is the number of points each inducing point is mapped 
+                         to in order to form the FoV.
+        """
+        x, y, theta = tf.split(Xu, num_or_size_splits=3, axis=1)
+        x     = tf.reshape(x, [-1,])
+        y     = tf.reshape(y, [-1,])
+        theta = tf.reshape(theta, [-1,])
+
+        points = []
+        for i in range(-int(np.floor((self.num_side)/2)), int(np.ceil((self.num_side)/2))):
+            points.append(tf.linspace([(x + (i * self.length_factor) * tf.cos(theta)) - self.length/2 * tf.cos(theta+np.pi/2), 
+                                       (y + (i * self.length_factor) * tf.sin(theta)) - self.length/2 * tf.sin(theta+np.pi/2)], 
+                                      [(x + (i * self.length_factor) * tf.cos(theta)) + self.length/2 * tf.cos(theta+np.pi/2), 
+                                       (y + (i * self.length_factor) * tf.sin(theta)) + self.length/2 * tf.sin(theta+np.pi/2)], 
+                                      self.num_side, axis=1))
+        xy = tf.concat(points, axis=1)
+        xy = tf.transpose(xy, [2, 1, 0])
+        xy = self._reshape(xy)
+        return xy
+    
+    def _reshape(self, X):
+        """Reorder the inducing points to be in the correct order for aggregation with square FoV.
 
         Args:
-            Xu (ndarray): Inducing points from which to compute the path lengths
+            X (ndarray): (mp, 2); Inducing points in input space. `p` is the number of points each 
+                        inducing point is mapped to in order to form the FoV.
+                            
+        Returns:
+            Xu (ndarray): (mp, 2); Reorder inducing points
+        """
+        X = tf.reshape(X, (-1, self.num_side, self.num_side, 2))
+        X = tf.transpose(X, (1, 0, 2, 3))
+        X = tf.reshape(X, (-1, 2))
+        return X
+    
+    def distance(self, Xu):
+        """Computes the distance incured by sequentially visiting the inducing points
+        Args:
+            Xu (ndarray): (m, 3); Inducing points from which to compute the path lengths.
+                          `m` is the number of inducing points.
 
         Returns:
             dist (float): path lengths
         """
-        Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
-        dist = tf.norm(Xu[:, 1:, :2] - Xu[:, :-1, :2], axis=-1)
-        dist = tf.reduce_sum(dist, axis=1)
+        Xu = tf.reshape(Xu, (-1, 3))[:, :2]
+        dist = tf.norm(Xu[1:] - Xu[:-1], axis=-1)
+        dist = tf.reduce_sum(dist, axis=0)
         return dist
-    
+
 
 class SquareHeightTransform(Transform):
-    """Non-point Transform to model a height-dependent square FoV. Only works for single robot cases. 
-    ToDo: Convert from single to multi-robot setup and make it compatible with IPPTransform
+    """Non-point Transform to model a height-dependent square FoV
 
     Args:
-        num_points (int): Number of points along each side of the FoV
-        distance_budget (float): Distance budget for the path
+        num_side (int): Number of points along each side of the FoV
+        aggregate_fov (bool): If `True`, covariances corresponding to interpolated inducing points used to 
+                              approximate the sensor FoV are aggregated to reduce the matrix inversion cost
     """
-    def __init__(self, num_points, distance_budget=None, **kwargs):
+    def __init__(self, num_side, aggregate_fov=False, **kwargs):
         super().__init__(**kwargs)
-        self.num_points = num_points
-        self.distance_budget = distance_budget
-    
-        if self.aggregation_size == 0:
-            self.aggregation_size = None
-        elif self.aggregation_size is None:
-            self.aggregation_size = num_points**2
+        self.num_side = num_side
+
+        if aggregate_fov:
+            self.enable_aggregation()
+
+    def enable_aggregation(self, size=None):
+        """Enable FoV covariance aggregation, which reduces the covariance matrix inversion cost by reducing the 
+        covariance matrix size.
+
+        Args:
+            size (int): If None, all the interpolated inducing points within the FoV are aggregated. Alternatively, 
+                        the number of inducing points to aggregate can be explicitly defined using this variable.
+        """
+        if size is None:
+            self.aggregation_size = self.num_side**2
+        else:
+            self.aggregation_size = size
 
     def expand(self, Xu):     
         """
@@ -372,17 +401,17 @@ class SquareHeightTransform(Transform):
                         to in order to form the FoV.
         """
         x, y, h = tf.split(Xu, num_or_size_splits=3, axis=1)
-        x = tf.squeeze(x)
-        y = tf.squeeze(y)
-        h = tf.squeeze(h)
+        x = tf.reshape(x, [-1,])
+        y = tf.reshape(y, [-1,])
+        h = tf.reshape(h, [-1,])
 
-        delta = h / (self.num_points - 1)
+        delta = h / (self.num_side - 1)
 
         pts = []
-        for i in range(self.num_points):
+        for i in range(self.num_side):
             pts.append(tf.linspace([x - h/2, y - (h/2) + (delta * i)], 
                                    [x + h/2, y - (h/2) + (delta * i)], 
-                                   self.num_points, 
+                                   self.num_side, 
                                    axis=1))
         xy = tf.concat(pts, axis=1)
         xy = tf.transpose(xy, [2, 1, 0])
@@ -400,7 +429,22 @@ class SquareHeightTransform(Transform):
         Returns:
             Xu (ndarray): (mp, 2); Reorder inducing points
         """
-        X = tf.reshape(X, (num_inducing, -1, self.num_points, self.num_points, 2))
+        X = tf.reshape(X, (num_inducing, -1, self.num_side, self.num_side, 2))
         X = tf.transpose(X, (0, 2, 1, 3, 4))
         X = tf.reshape(X, (-1, 2))
         return X
+    
+    def distance(self, Xu):
+        """Computes the distance incured by sequentially visiting the inducing points
+        Args:
+            Xu (ndarray): (m, 3); Inducing points from which to compute the path lengths.
+                          `m` is the number of inducing points.
+
+        Returns:
+            dist (float): path lengths
+        """
+        Xu = tf.reshape(Xu, (-1, 3))
+        dist = tf.norm(Xu[1:] - Xu[:-1], axis=-1)
+        dist = tf.reduce_sum(dist, axis=0)
+        return dist
+    

sgptools/utils/data.py

@@ -91,8 +91,8 @@ def prep_tif_dataset(dataset_path):
         dataset_path (str): Path to the dataset file, used only when dataset_type is 'tif'.
 
     Returns:
-       X: (n, d); Dataset input features
-       y: (n, 1); Dataset labels
+       X (ndarray): (n, d); Dataset input features
+       y (ndarray): (n, 1); Dataset labels
     '''
     data = PIL.Image.open(dataset_path)
     data = np.array(data)
@@ -116,22 +116,31 @@ def prep_tif_dataset(dataset_path):
 
 ####################################################
 
-def prep_synthetic_dataset():
+def prep_synthetic_dataset(shape=(50, 50), 
+                           min_height=0.0, 
+                           max_height=30.0, 
+                           roughness=0.5,
+                           **kwargs):
     '''Generates a 50x50 grid of synthetic elevation data using the diamond square algorithm.
     
     Refer to the following repo for more details:
         - [https://github.com/buckinha/DiamondSquare](https://github.com/buckinha/DiamondSquare)
     
     Args:
+        shape (tuple): (x, y); Grid size along the x and y axis
+        min_height (float): Minimum allowed height in the sampled data
+        max_height (float): Maximum allowed height in the sampled data
+        roughness (float): Roughness of the sampled data
 
     Returns:
-       X: (n, d); Dataset input features
-       y: (n, 1); Dataset labels
+       X (ndarray): (n, d); Dataset input features
+       y (ndarray): (n, 1); Dataset labels
     '''
-    data = diamond_square(shape=(50,50), 
-                          min_height=0, 
-                          max_height=30, 
-                          roughness=0.5)
+    data = diamond_square(shape=shape,
+                          min_height=min_height, 
+                          max_height=max_height, 
+                          roughness=roughness,
+                          **kwargs)
 
     # create x and y coordinates from the extent
     x_coords = np.arange(0, data.shape[0])/10
@@ -145,17 +154,16 @@ def prep_synthetic_dataset():
 
 ####################################################
 
-def get_dataset(dataset_type, dataset_path=None,
+def get_dataset(dataset_path=None,
                 num_train=1000,
                 num_test=2500, 
-                num_candidates=150):
+                num_candidates=150,
+                **kwargs):
     """Method to generate/load datasets and preprocess them for SP/IPP. The method uses kmeans to 
     generate train and test sets.
     
     Args:
-        dataset_type (str): 'tif' or 'synthetic'. 'tif' will load and proprocess data from a GeoTIFF file. 
-                        'synthetic' will use the diamond square algorithm to generate synthetic elevation data.
-        dataset_path (str): Path to the dataset file, used only when dataset_type is 'tif'.
+        dataset_path (str): Path to a tif dataset file. If None, the method will generate synthetic data.
         num_train (int): Number of training samples to generate.
         num_test (int): Number of testing samples to generate.
         num_candidates (int): Number of candidate locations to generate.
@@ -170,10 +178,10 @@ def get_dataset(dataset_type, dataset_path=None,
        y (ndarray): (n, 1); Full dataset labels
     """
     # Load the data
-    if dataset_type == 'tif':
+    if dataset_path is not None:
         X, y = prep_tif_dataset(dataset_path=dataset_path)
-    elif dataset_type == 'synthetic':
-        X, y = prep_synthetic_dataset()
+    else:
+        X, y = prep_synthetic_dataset(**kwargs)
 
     X_train = get_inducing_pts(X, num_train)
     X_train, y_train = cont2disc(X_train, X, y)

sgptools/utils/gpflow.py

@@ -18,6 +18,7 @@ from gpflow.utilities.traversal import print_summary
 import tensorflow as tf
 import tensorflow_probability as tfp
 
+import numpy as np
 import matplotlib.pyplot as plt
 
 
@@ -87,6 +88,43 @@ def get_model_params(X_train, y_train,
     
     return loss, gpr_gt.likelihood.variance, kernel
 
+
+class TraceInducingPts(gpflow.monitor.MonitorTask):
+    '''
+    GPflow monitoring task, used to trace the inducing points
+    states at every step during optimization. 
+
+    Args:
+        model (gpflow.models.sgpr): GPflow GP/SGP model
+    '''
+    def __init__(self, model):
+        super().__init__()
+        self.trace = []
+        self.model = model
+
+    def run(self, **kwargs):
+        '''
+        Method used to extract the inducing points and 
+        apply IPP fixed points transform if available
+        '''
+        Xu = self.model.inducing_variable.Z
+        Xu_exp = self.model.transform.expand(Xu, 
+                            expand_sensor_model=False).numpy()
+        self.trace.append(Xu_exp)
+
+    def get_trace(self):
+        '''
+        Returns the inducing points collected at each optimization step
+
+        Returns:
+            trace (ndarray): (n, m, d); Array with the inducing points.
+                            `n` is the number of optimization steps;
+                            `m` is the number of inducing points;
+                            `d` is the dimension of the inducing points.
+        '''
+        return np.array(self.trace)
+
+
 def optimize_model(model, 
                    max_steps=2000, 
                    kernel_grad=True, 
@@ -102,21 +140,22 @@ def optimize_model(model,
     Trains a GP/SGP model
 
     Args:
-        model (gpflow.models): GPflow GP/SGP model to train
-        max_steps (int): Maximum number of training steps
-        kernel_grad (bool): If False, the kernel parameters will not be optimized
-        lr (float): Optimization learning rate
-        optimizer (str): Optimizer to use for training (`scipy` or `tf`)
+        model (gpflow.models): GPflow GP/SGP model to train.
+        max_steps (int): Maximum number of training steps.
+        kernel_grad (bool): If `False`, the kernel parameters will not be optimized. 
+                            Ignored when `trainable_variables` are passed.
+        lr (float): Optimization learning rate.
+        optimizer (str): Optimizer to use for training (`scipy` or `tf`).
         method (str): Optimization method refer to [scipy minimize](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize) 
                       and [tf optimizers](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) for full list
-        verbose (bool): If true, the training progress will be printed
+        verbose (bool): If `True`, the training progress will be printed when using Scipy.
         trace_fn (str): Function to trace metrics during training. 
-                        If `None`, the loss values are traced;
-                        if `traceXu`, it the inducing points states at each optimization step are traced
-        convergence_criterion (bool): It True, enables early stopping when the loss plateaus
-        trainable_variables (list): List of model variables to train 
-                                    (can be used to limit training to a subset of variables)
-        tol (float): Convergence tolerance to decide when to stop optimization
+                        If `None`, the loss values are returned;
+                        If `traceXu`, it the inducing points states at each optimization step are returned (increases computation time).
+        convergence_criterion (bool): If `True` and using a tensorflow optimizer, it 
+                                      enables early stopping when the loss plateaus.
+        trainable_variables (list): List of model variables to train.
+        tol (float): Convergence tolerance to decide when to stop optimization.
     """
     # Train all variables if trainable_variables are not provided
     # If kernel_gradient is False, disable the kernel parameter gradient updates
@@ -128,13 +167,24 @@ def optimize_model(model,
     if optimizer == 'scipy':
         if method is None:
             method = 'L-BFGS-B'
+
+        if trace_fn == 'traceXu':
+            execute_task = TraceInducingPts(model)
+            task_group = gpflow.monitor.MonitorTaskGroup(execute_task, 
+                                                         period=1)
+            trace_fn = gpflow.monitor.Monitor(task_group)
+
         opt = gpflow.optimizers.Scipy()
         losses = opt.minimize(model.training_loss,
                               trainable_variables,
                               method=method,
                               options=dict(disp=verbose, maxiter=max_steps),
-                              tol=tol)
-        losses = losses.fun
+                              tol=tol,
+                              step_callback=trace_fn)
+        if trace_fn is None:
+            losses = losses.fun
+        else:
+            losses = trace_fn.task_groups[0].tasks[0].get_trace()
     else:
         if trace_fn is None:
             trace_fn = lambda x: x.loss

sgptools/utils/metrics.py

@@ -131,12 +131,12 @@ def get_rmse(y_pred, y_test):
     """
     return np.sqrt(np.mean(np.square(y_pred - y_test)))
 
-def get_reconstruction(Xu, X_test, noise_variance, kernel):
+def get_reconstruction(sensor_data, X_test, noise_variance, kernel):
     """Computes the GP-based data field estimates with the solution placements as the training set
 
     Args:
-        Xu (tuple): (ndarray (m, d); ndarray (m, 1)); Sensing locations' input 
-                    and corresponding ground truth labels
+        sensor_data (ndarray tuple): ((m, d), (m, 1)); Sensing locations' input 
+                             and corresponding ground truth labels
         X_test (ndarray): (n, d); Testing data input locations
         noise_variance (float): data variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
@@ -145,7 +145,7 @@ def get_reconstruction(Xu, X_test, noise_variance, kernel):
         y_pred (ndarray): (n, 1); Predicted data field estimates
         y_var (ndarray): (n, 1); Prediction variance at each location in the data field
     """
-    Xu_X, Xu_y = Xu
+    Xu_X, Xu_y = sensor_data
 
     # Get the GP predictions
     gpr = gpflow.models.GPR((Xu_X, Xu_y),

sgptools/utils/misc.py

@@ -51,7 +51,10 @@ def cont2disc(Xu, candidates, candidate_labels=None):
     """
     # Sanity check to ensure that there are sensing locations and candidates to match
     if len(candidates)==0 or len(Xu)==0:
-        return []
+        if candidate_labels is not None:
+            return [], []
+        else:
+            return []
     
     dists = pairwise_distances(candidates, Y=Xu, metric='euclidean')
     row_ind, _ = linear_sum_assignment(dists)
@@ -133,4 +136,4 @@ def project_waypoints(waypoints, candidates):
     """
     waypoints_disc = cont2disc(waypoints, candidates)
     waypoints_valid = _reoder_path(waypoints, waypoints_disc)
-    return waypoints_valid
+    return waypoints_valid

{sgptools-1.0.5.dist-info → sgptools-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sgptools
-Version: 1.0.5
+Version: 1.0.6
 Summary: Software Suite for Sensor Placement and Informative Path Planning
 Home-page: https://www.itskalvik.com/sgp-tools
 Author: Kalvik

{sgptools-1.0.5.dist-info → sgptools-1.0.6.dist-info}/RECORD

@@ -11,15 +11,15 @@ sgptools/models/core/__init__.py,sha256=TlUdvrM0A7vSzc5IM8C2Y2kliB1ip7YLEcHHzvuw
 sgptools/models/core/augmented_gpr.py,sha256=NuYwlggz7ho7pvW4-so3ghos5vZ8oK7nRZqvHpAt0Zk,3497
 sgptools/models/core/augmented_sgpr.py,sha256=qMP9J4AnOUx9AEZfaPhoyb3RP_2AOhOUCUY4eh7uOi0,7185
 sgptools/models/core/osgpr.py,sha256=gqliUdXdnt3fea206LP0rqGIggmIdKh8WP2DtFWzdBw,11798
-sgptools/models/core/transformations.py,sha256=NTj3yZjTQXTHBr24XFI_W5dh2-TVginisEiT6LPeMeg,16742
+sgptools/models/core/transformations.py,sha256=avluSP7g4EWjijlpFQYobO_CHKA0-V7PemC6SdVwrG8,18976
 sgptools/utils/__init__.py,sha256=jgWqzSDgUbqOTFo8mkqZaTlyz44l3v2XYPJfcHYHjqM,376
-sgptools/utils/data.py,sha256=5HX4YwxZX4Q1J6UekB9GARMVhjsF806kTh2eRCrU79I,6978
-sgptools/utils/gpflow.py,sha256=bnrtKl9tvKVh1Wz969KQJQf8UtApa7i0SkOj-KMOWNc,6816
-sgptools/utils/metrics.py,sha256=0tyMPoZgA-dRNs-Ye69paMNFpWgLuLNE1t8ywOnRmaE,5806
-sgptools/utils/misc.py,sha256=W8lx6n1eJeeiq6cyRGzhZMCnWItoiQzODHQkqVAQi4U,5322
+sgptools/utils/data.py,sha256=oTXq4oRuzJdXpZC6frUfja8jhwy_ZdDDi7L1BYZcdQs,7309
+sgptools/utils/gpflow.py,sha256=LnFYufnMW4ch7qsKnru53QUxEtIzJqE822qj6w8ssRg,8576
+sgptools/utils/metrics.py,sha256=tu8H129n8GuxV5fQIKLcfzPUxd7sp8zEF9qZBOZjNKo,5834
+sgptools/utils/misc.py,sha256=_6hZRoSnbnKCt9H3XRlPT74Wh5VO5zArFddE1dszHGo,5408
 sgptools/utils/tsp.py,sha256=RJAQ4_uE7CUtR1ei3nSnGy-1kNhw82E9P_HyaCkc4iI,7007
-sgptools-1.0.5.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sgptools-1.0.5.dist-info/METADATA,sha256=GqxkIaxPKoQjZhyU2505xFvNs5xqBu40Ncah6BWFDm4,944
-sgptools-1.0.5.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
-sgptools-1.0.5.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
-sgptools-1.0.5.dist-info/RECORD,,
+sgptools-1.0.6.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sgptools-1.0.6.dist-info/METADATA,sha256=fdUW1EPBQkGG-rKXi6xVa8i4Qt5gIwKDr_8MPsI-Lh4,944
+sgptools-1.0.6.dist-info/WHEEL,sha256=ixB2d4u7mugx_bCBycvM9OzZ5yD7NmPXFRtKlORZS2Y,91
+sgptools-1.0.6.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
+sgptools-1.0.6.dist-info/RECORD,,

{sgptools-1.0.5.dist-info → sgptools-1.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.1)
+Generator: setuptools (74.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any