t

LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, sustainability-lab
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,3 +1,102 @@
----
-license: mit
----
+![Tests](https://github.com/sustainability-lab/polire/actions/workflows/tests.yml/badge.svg)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Coverage](https://coveralls.io/repos/github/sustainability-lab/polire/badge.svg?branch=master)](https://coveralls.io/github/sustainability-lab/polire?branch=master)
+
+## Polire
+
+```python
+pip install polire
+```
+
+
+The word "interpolation" has a Latin origin and is composed of two words - Inter, meaning between, and Polire, meaning to polish.
+
+
+This repository is a collection of several spatial interpolation algorithms. 
+
+
+## Examples
+Please refer to [the documentation](https://sustainability-lab.github.io/polire/) to check out practical examples on real datasets.
+
+### Minimal example of interpolation
+```python
+import numpy as np
+from polire import Kriging
+
+# Data
+X = np.random.rand(10, 2) # Spatial 2D points
+y = np.random.rand(10) # Observations
+X_new = np.random.rand(100, 2) # New spatial points
+
+# Fit
+model = Kriging()
+model.fit(X, y)
+
+# Predict
+y_new = model.predict(X_new)
+```
+
+### Supported Interpolation Methods
+```python
+from polire import (
+    Kriging, # Best spatial unbiased predictor
+    GP, # Gaussian process interpolator from GPy
+    IDW, # Inverse distance weighting
+    SpatialAverage,
+    Spline,
+    Trend,
+    Random, # Predict uniformly within the observation range, a reasonable baseline
+    NaturalNeighbor,
+    CustomInterpolator # Supports any regressor from Scikit-learn
+)
+```
+
+### Use GP kernels from GPy (temporarily unavailable)
+```python
+from GPy.kern import Matern32 # or any other GPy kernel
+
+# GP model
+model = GP(Matern32(input_dim=2))
+```
+
+### Regressors from sklearn
+```py
+from sklearn.linear_model import LinearRegression # or any Scikit-learn regressor
+from polire import GP, CustomInterpolator
+
+# Sklearn model
+model = CustomInterpolator(LinearRegression())
+```
+
+### Extract spatial features from spatio-temporal dataset
+```python
+# X and X_new are datasets as numpy arrays with first three dimensions as longitude, latitute and time.
+# y is corresponding observations with X
+
+from polire.preprocessing import SpatialFeatures
+spatial = SpatialFeatures(n_closest=10)
+Features = spatial.fit_transform(X, y)
+Features_new = spatial.transform(X_new)
+```
+
+## Citation
+
+If you use this library, please cite the following paper:
+
+```
+@inproceedings{10.1145/3384419.3430407,
+author = {Narayanan, S Deepak and Patel, Zeel B and Agnihotri, Apoorv and Batra, Nipun},
+title = {A Toolkit for Spatial Interpolation and Sensor Placement},
+year = {2020},
+isbn = {9781450375900},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3384419.3430407},
+doi = {10.1145/3384419.3430407},
+booktitle = {Proceedings of the 18th Conference on Embedded Networked Sensor Systems},
+pages = {653–654},
+numpages = {2},
+location = {Virtual Event, Japan},
+series = {SenSys '20}
+}
+```

_quarto.yml

@@ -0,0 +1,22 @@
+project:
+  type: website
+  output-dir: docs
+
+# render only the contents mentioned in the _quarto.yml file
+
+
+website: 
+  title: "Polire"
+  sidebar:
+    style: "docked"
+    search: true
+    contents:
+      - section: "Introduction"
+        path: "index.qmd"
+
+      - section: "Examples"
+        contents:
+          - examples/all_in_one.ipynb
+
+execute:
+  freeze: auto

index.qmd

@@ -0,0 +1,11 @@
+## Polire
+
+```python
+pip install polire
+```
+
+
+The word "interpolation" has Latin origin and is composed of two words - Inter meaning between and Polire meaning to polish.
+
+
+Polire is a collection of several spatial interpolation algorithms. 

polire.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: polire
+Version: 0.1.3
+Summary: A collection of interpolation methods.
+Home-page: https://sustainability-lab.github.io/polire
+Download-URL: https://sustainability-lab.github.io/polire
+Maintainer: Zeel B Patel, Apoorv Agnihotri, S Deepak Narayanan
+Maintainer-email: [email protected], [email protected], [email protected]
+License: new BSD
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Description-Content-Type: text/markdown
+Provides-Extra: tests
+Provides-Extra: docs
+License-File: LICENSE
+
+![Tests](https://github.com/sustainability-lab/polire/actions/workflows/tests.yml/badge.svg)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+
+## Polire
+
+```python
+pip install polire
+```
+
+
+The word "interpolation" has Latin origin and is composed of two words - Inter meaning between and Polire meaning to polish.
+
+
+This repository is a collection of several spatial interpolation algorithms. 
+
+## Examples
+### Minimal example of interpolation
+```python
+import numpy as np
+from polire import Kriging
+
+# Data
+X = np.random.rand(10, 2) # Spatial 2D points
+y = np.random.rand(10) # Observations
+X_new = np.random.rand(100, 2) # New spatial points
+
+# Fit
+model = Kriging()
+model.fit(X, y)
+
+# Predict
+y_new = model.predict(X_new)
+```
+
+### Supported Interpolation Methods
+```python
+from polire import (
+    Kriging, # Best spatial unbiased predictor
+    GP, # Gaussian process interpolator from GPy
+    IDW, # Inverse distance weighting
+    SpatialAverage,
+    Spline,
+    Trend,
+    Random, # Predict uniformly within the observation range, a reasonable baseline
+    NaturalNeighbor,
+    CustomInterpolator # Supports any regressor from Scikit-learn
+)
+```
+
+### Use GP kernels from GPy and regressors from sklearn
+```python
+from sklearn.linear_model import LinearRegression # or any Scikit-learn regressor
+from GPy.kern import Matern32 # or any other GPy kernel
+
+from polire import GP, CustomInterpolator
+
+# GP model
+model = GP(Matern32(input_dim=2))
+
+# Sklearn model
+model = CustomInterpolator(LinearRegression(normalize = True))
+```
+
+### Extract spatial features from spatio-temporal dataset
+```python
+# X and X_new are datasets as numpy arrays with first three dimensions as longitude, latitute and time.
+# y is corresponding observations with X
+
+from polire.preprocessing import SpatialFeatures
+spatial = SpatialFeatures(n_closest=10)
+Features = spatial.fit_transform(X, y)
+Features_new = spatial.transform(X_new)
+```
+
+## More info
+
+Contributors:  [S Deepak Narayanan](https://github.com/sdeepaknarayanan), [Zeel B Patel*](https://github.com/patel-zeel), [Apoorv Agnihotri](https://github.com/apoorvagnihotri), and [Nipun Batra*](https://github.com/nipunbatra) (People with * are currently active contributers).
+
+This project is a part of Sustainability Lab at IIT Gandhinagar.
+
+Acknowledgement to sklearn template for helping to package into a PiPy package.
+
+

polire.egg-info/SOURCES.txt

@@ -0,0 +1,41 @@
+LICENSE
+README.md
+setup.py
+polire/__init__.py
+polire/constants.py
+polire.egg-info/PKG-INFO
+polire.egg-info/SOURCES.txt
+polire.egg-info/dependency_links.txt
+polire.egg-info/not-zip-safe
+polire.egg-info/requires.txt
+polire.egg-info/top_level.txt
+polire/base/__init__.py
+polire/base/base.py
+polire/custom/__init__.py
+polire/custom/custom.py
+polire/gp/__init__.py
+polire/gp/gp.py
+polire/idw/__init__.py
+polire/idw/idw.py
+polire/kriging/__init__.py
+polire/kriging/kriging.py
+polire/natural_neighbors/__init__.py
+polire/natural_neighbors/natural_neighbors.py
+polire/nsgp/__init__.py
+polire/nsgp/nsgp.py
+polire/preprocessing/__init__.py
+polire/preprocessing/sptial_features.py
+polire/random/__init__.py
+polire/random/random.py
+polire/spatial/__init__.py
+polire/spatial/spatial.py
+polire/spline/__init__.py
+polire/spline/bspline.py
+polire/trend/__init__.py
+polire/trend/polynomials.py
+polire/trend/trend.py
+polire/utils/__init__.py
+polire/utils/distance.py
+polire/utils/gridding.py
+tests/__init__.py
+tests/test_basic.py

polire.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

polire.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

polire.egg-info/requires.txt

@@ -0,0 +1,21 @@
+matplotlib
+numpy
+pandas
+pykrige
+scikit_learn
+scipy
+seaborn
+Shapely
+xgboost
+GPy
+
+[docs]
+sphinx
+sphinx-gallery
+sphinx_rtd_theme
+numpydoc
+matplotlib
+
+[tests]
+pytest
+pytest-cov

polire.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+polire
+tests

polire/__init__.py

@@ -0,0 +1,12 @@
+from .random.random import Random
+from .idw.idw import IDW
+from .spline.bspline import Spline
+from .trend.trend import Trend
+from .spatial.spatial import SpatialAverage
+from .natural_neighbors.natural_neighbors import NaturalNeighbor
+from .kriging.kriging import Kriging
+
+# from .gp.gp import GP
+from .custom.custom import CustomInterpolator
+
+# from .nsgp.nsgp import NSGP

polire/base/__init__.py

@@ -0,0 +1 @@
+from .base import Base

polire/base/base.py

@@ -0,0 +1,130 @@
+from ..constants import RESOLUTION
+
+
+class Base:
+    """A class that is declared for performing Interpolation.
+    This class should not be called directly, use one of it's
+    children.
+    """
+
+    def __init__(self, resolution="standard", coordinate_types="Euclidean"):
+        self.resolution = RESOLUTION[resolution]
+        self.coordinate_type = coordinate_types
+        self._fit_called = False
+
+    def fit(self, X, y, **kwargs):
+        """The function call to fit the model on the given data.
+
+        Parameters
+        ----------
+
+        X: {array-like, 2D matrix}, shape(n_samples, 2)
+            The set of all coordinates, where we have ground truth
+            values
+        y: array-like, shape(n_samples,)
+            The set of all the ground truth values using which
+            we perform interpolation
+
+        Returns
+        -------
+
+        self : object
+            Returns self
+
+        """
+        assert len(X.shape) == 2, "X must be a 2D array got shape = " + str(
+            X.shape
+        )
+        # assert X.shape[1] == 2, "X can not have more than 2 dimensions"
+        assert len(y.shape) == 1, "y should be a 1d array"
+        assert y.shape[0] == X.shape[0], "X and y must be of the same size"
+
+        # saving that fit was called
+        self._fit_called = True
+
+        # saving boundaries
+        self.x1min_d = min(X[:, 0])
+        self.x1max_d = max(X[:, 0])
+        self.x2min_d = min(X[:, 1])
+        self.x2max_d = max(X[:, 1])
+        return self._fit(X, y, **kwargs)  # calling child specific fit method
+
+    def predict(self, X, **kwargs):
+        """The function call to return interpolated data on specific
+        points.
+
+        Parameters
+        ----------
+
+        X: {array-like, 2D matrix}, shape(n_samples, 2)
+            The set of all coordinates, where we have ground truth
+            values
+
+        Returns
+        -------
+
+        y_pred : array-like, shape(n_samples,)
+            The set of interpolated values for the points used to
+            call the function.
+        """
+
+        assert len(X.shape) == 2, "X must be a 2D array got shape = " + str(
+            X.shape
+        )
+        # assert X.shape[1] == 2, "X can not have more than 2 dimensions"
+
+        # checking if model is fitted or not
+        assert self._fit_called, "First call fit method to fit the model"
+
+        # calling child specific _predict method
+        return self._predict(X, **kwargs)
+
+    def predict_grid(self, x1lim=None, x2lim=None, support_extrapolation=True):
+        """Function to interpolate data on a grid of given size.
+        .
+        Parameters
+        ----------
+        x1lim: tuple(float, float),
+            Upper and lower bound on 1st dimension for the interpolation.
+
+        x2lim: tuple(float, float),
+            Upper and lower bound on 2nd dimension for the interpolation.
+
+        Returns
+        -------
+        y: array-like, shape(n_samples,)
+            Interpolated values on the grid requested.
+        """
+        # checking if model is fitted or not
+        assert self._fit_called, "First call fit method to fit the model"
+
+        # by default we interpolate over the whole grid
+        if x1lim is None:
+            x1lim = (self.x1min_d, self.x1max_d)
+        if x2lim is None:
+            x2lim = (self.x2min_d, self.x2max_d)
+        (x1min, x1max) = x1lim
+        (x2min, x2max) = x2lim
+
+        # extrapolation isn't supported yet
+        if not support_extrapolation:
+            assert self.x1min_d >= x1min, "Extrapolation not supported"
+            assert self.x1max_d <= x1max, "Extrapolation not supported"
+            assert self.x2min_d >= x2min, "Extrapolation not supported"
+            assert self.x2max_d <= x2max, "Extrapolation not supported"
+
+        # calling child specific _predict_grid method
+        pred_y = self._predict_grid(x1lim, x2lim)
+        return pred_y.reshape(self.resolution, self.resolution)
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+    def _fit(self, X, y):
+        raise NotImplementedError
+
+    def _predict_grid(self, x1lim, x2lim):
+        raise NotImplementedError
+
+    def _predict(self, X):
+        raise NotImplementedError

polire/constants.py

@@ -0,0 +1,9 @@
+"""This python script contains all the constants that
+might be needed in the various interpolation pacakages. 
+"""
+
+low_res = 10
+med_res = 100
+high_res = 1000
+
+RESOLUTION = {"low": low_res, "standard": med_res, "high": high_res}

polire/custom/__init__.py

@@ -0,0 +1 @@
+from .custom import CustomInterpolator

polire/custom/custom.py

@@ -0,0 +1,62 @@
+import numpy as np
+
+from ..base import Base
+
+
+class CustomInterpolator(Base):
+    """
+    Class to interpolate by fitting a sklearn type Regressor to
+    the given data.
+
+    Parameters
+    ----------
+    regressor: class definition,
+        This variable is used to pass in the Regressor we would like
+        to use for interpolation. The regressor sould be sklearn type
+        regressor. Example from sklearn.ensemble -> RandomForestRegressor
+
+    reg_kwargs: dict, optional
+        This is a dictionary that is passed into the Regressor initialization.
+        Use this to change the behaviour of the passed regressor. Default = empty dict
+
+    Attributes
+    ----------
+    reg : object
+        Object of the `regressor` class passed.
+    """
+
+    def __init__(
+        self, regressor, resolution="standard", coordinate_type="Euclidean"
+    ):
+        super().__init__(resolution, coordinate_type)
+        self.reg = regressor
+
+    def _fit(self, X, y):
+        """Function for fitting.
+        This function is not supposed to be called directly.
+        """
+        self.reg.fit(X, y)
+        return self
+
+    def _predict_grid(self, x1lim, x2lim):
+        """Function for grid interpolation.
+        This function is not supposed to be called directly.
+        """
+        # getting the boundaries for interpolation
+        x1min, x1max = x1lim
+        x2min, x2max = x2lim
+
+        # building the grid
+        x1 = np.linspace(x1min, x1max, self.resolution)
+        x2 = np.linspace(x2min, x2max, self.resolution)
+        X1, X2 = np.meshgrid(x1, x2)
+        return self.reg.predict(np.asarray([X1.ravel(), X2.ravel()]).T)
+
+    def _predict(self, X):
+        """Function for interpolation on specific points.
+        This function is not supposed to be called directly.
+        """
+        return self.reg.predict(X)
+
+    def __repr__(self):
+        return self.__class__.__name__ + "." + self.reg.__class__.__name__

polire/gp/gp.py

@@ -0,0 +1,65 @@
+"""
+This is a module for GP Interpolation
+"""
+import numpy as np
+from ..base import Base
+from GPy.models import GPRegression
+from GPy.kern import RBF
+
+
+class GP(Base):
+    """A class that is declared for performing GP interpolation.
+    GP interpolation (usually) works on the principle of finding the
+    best unbiased predictor.
+
+    Parameters
+    ----------
+    type : str, optional
+    This parameter defines the type of Kriging under consideration. This
+    implementation uses PyKrige package  (https://github.com/bsmurphy/PyKrige).
+    The user needs to choose between "Ordinary" and "Universal".
+
+    """
+
+    def __init__(
+        self,
+        kernel=RBF(2, ARD=True),
+    ):
+        super().__init__()
+        self.kernel = kernel
+
+    def _fit(self, X, y, n_restarts=5, verbose=False, random_state=None):
+        """Fit method for GP Interpolation
+        This function shouldn't be called directly.
+        """
+        np.random.seed(random_state)
+        if len(y.shape) == 1:
+            y = y.reshape(-1, 1)
+        self.model = GPRegression(X, y, self.kernel)
+        self.model.optimize_restarts(n_restarts, verbose=verbose)
+        return self
+
+    def _predict_grid(self, x1lim, x2lim):
+        """The function that is called to return the interpolated data in Kriging Interpolation
+        in a grid. This method shouldn't be called directly"""
+        lims = (*x1lim, *x2lim)
+        x1min, x1max, x2min, x2max = lims
+        x1 = np.linspace(x1min, x1max, self.resolution)
+        x2 = np.linspace(x2min, x2max, self.resolution)
+
+        X1, X2 = np.meshgrid(x1, x2)
+        X = np.array([(i, j) for i, j in zip(X1.ravel(), X2.ravel())])
+
+        predictions = self.model.predict(X)[0].reshape(len(x1), len(x2))
+
+        return predictions.ravel()
+
+    def _predict(self, X, return_variance=False):
+        """This function should be called to return the interpolated data in kriging
+        in a pointwise manner. This method shouldn't be called directly."""
+
+        predictions, variance = self.model.predict(X)
+        if return_variance:
+            return predictions.ravel(), variance
+        else:
+            return predictions.ravel()

polire/gp/tests/GP interpolation.ipynb

@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pykrige import OrdinaryKriging"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ok = OrdinaryKriging(data[:,0],data[:,1],data[:,2])\n",
+    "ok.ex"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a,b = ok.execute('grid',x[0],y[:,0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pykrige import OrdinaryKriging\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "def ordinary_kriging(dataset, resolution='standard', coordinate_type='euclidean',verbose='False',method='grid', isvariance = False):\n",
+    "    if coordinate_type == 'latlong_small':\n",
+    "        \"\"\"\n",
+    "            Assume that the Earth is a Sphere, and use polar coordinates\n",
+    "            $| \\vec{r_2}− \\vec{r_1}| ≈ \\text{R }\\times \\sqrt[]{(Lat_2 - Lat_1)^{2} + (Long_2 - Long_1)^{2}}$\n",
+    "        \"\"\"\n",
+    "        return \"To be done later\"\n",
+    "    if coordinate_type == 'latlong_large':\n",
+    "        \"\"\"\n",
+    "            Code to be written after understanding all the projections.\n",
+    "        \"\"\"\n",
+    "        return \"To be done later\"\n",
+    "    if coordinate_type==\"euclidean\":\n",
+    "        \n",
+    "        ok = OrdinaryKriging(dataset[:,0],dataset[:,1],dataset[:,2])\n",
+    "        X = dataset[:,0]\n",
+    "        y = dataset[:,1]\n",
+    "        \n",
+    "        if resolution=='high':\n",
+    "            xx,yy = make_grid(X,y,1000)\n",
+    "            \n",
+    "        elif resolution=='low':\n",
+    "            xx,yy = make_grid(X,y,10)\n",
+    "            \n",
+    "        elif resolution=='standard':\n",
+    "            xx,yy = make_grid(X,y,100)\n",
+    "            \n",
+    "        else:\n",
+    "            print('Value Error - Resolution can only be one of \\nhigh, low or standard')\n",
+    "        \n",
+    "        values, variances = ok.execute(method, xx[0], yy[:,0])\n",
+    "        \n",
+    "    if isvariance:\n",
+    "        return values, variances\n",
+    "    else:\n",
+    "        del variances\n",
+    "        return np.array(values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[129.94984945, 129.7682324 , 129.58820662, ..., 159.34079485,\n",
+       "        159.99175016, 160.63241067],\n",
+       "       [130.22090025, 130.03615966, 129.8529146 , ..., 159.9575165 ,\n",
+       "        160.61228126, 161.25625641],\n",
+       "       [130.50105231, 130.31324536, 130.12683652, ..., 160.59265384,\n",
+       "        161.25084023, 161.8977369 ],\n",
+       "       ...,\n",
+       "       [207.22133238, 207.82739139, 208.44615116, ..., 248.64646661,\n",
+       "        248.3790241 , 248.11033441],\n",
+       "       [207.92838926, 208.53490708, 209.15376273, ..., 248.91678379,\n",
+       "        248.65601627, 248.39371596],\n",
+       "       [208.61942088, 209.22595474, 209.84445913, ..., 249.17442481,\n",
+       "        248.9203453 , 248.66446245]])"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ordinary_kriging(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* What does ok('points') really do?\n",
+    "* Specifically test when points aren't really passed - they are let's say the point of an array\n",
+    "* Returns the diagonal matrix of all these coordinates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([129.94984945, 130.03615966, 130.12683652, 130.22219703,\n",
+       "       130.32258826, 130.42839089, 130.54002324, 130.65794596,\n",
+       "       130.7826674 , 130.91474976, 131.05481629, 131.20355964,\n",
+       "       131.36175158, 131.53025441, 131.71003442, 131.90217771,\n",
+       "       132.107909  , 132.32861401, 132.56586607, 132.82145795,\n",
+       "       133.0974399 , 133.39616477, 133.72034153, 134.07309736,\n",
+       "       134.45804822, 134.87937482, 135.34189663, 135.85112772,\n",
+       "       136.41328222, 137.03517039, 137.72388496, 138.48612122,\n",
+       "       139.326921  , 140.24763047, 141.24300526, 142.29757046,\n",
+       "       143.37881815, 144.38425962, 144.49187978, 143.1202101 ,\n",
+       "       141.66667134, 140.45686022, 139.66795657, 142.48270308,\n",
+       "       147.03665055, 151.8487008 , 156.90272514, 162.25791164,\n",
+       "       168.04938768, 173.63870768, 180.93567147, 190.3440156 ,\n",
+       "       199.86834472, 208.48375248, 215.75635742, 222.1915652 ,\n",
+       "       228.08641413, 233.15249702, 236.89713686, 239.83524192,\n",
+       "       242.45744315, 244.57483343, 245.52139699, 245.88236757,\n",
+       "       246.12295211, 246.3306567 , 246.52369882, 246.70598807,\n",
+       "       246.87792737, 247.03919426, 247.18952217, 247.3288843 ,\n",
+       "       247.45749059, 247.57573348, 247.68412862, 247.78326467,\n",
+       "       247.87376505, 247.95626051, 248.03137024, 248.09968963,\n",
+       "       248.16178271, 248.21817801, 248.26936683, 248.31580309,\n",
+       "       248.35790422, 248.39605277, 248.43059841, 248.46186013,\n",
+       "       248.49012851, 248.51566797, 248.53871897, 248.55950011,\n",
+       "       248.57821004, 248.59502931, 248.61012204, 248.62363741,\n",
+       "       248.63571111, 248.64646661, 248.65601627, 248.66446245])"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ordinary_kriging(data,method='points')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_grid(X,y,res):\n",
+    "    y_min = y.min()-0.2\n",
+    "    y_max = y.max()+0.2\n",
+    "    x_min = X.min()-0.2\n",
+    "    x_max = X.max()+0.2\n",
+    "    x_arr = np.linspace(x_min,x_max,res)\n",
+    "    y_arr = np.linspace(y_min,y_max,res)\n",
+    "    xx,yy = np.meshgrid(x_arr,y_arr)  \n",
+    "    return xx,yy\n",
+    "x, y = make_grid(data[:,0],data[:,1],100)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

polire/idw/idw.py

@@ -0,0 +1,91 @@
+"""
+This is a module for inverse distance weighting (IDW) Spatial Interpolation
+"""
+import numpy as np
+from ..utils.distance import haversine, euclidean
+from ..base import Base
+
+
+class IDW(Base):
+    """A class that is declared for performing IDW Interpolation.
+    For more information on how this method works, kindly refer to
+    https://en.wikipedia.org/wiki/Inverse_distance_weighting
+
+    Parameters
+    ----------
+    exponent : positive float, optional
+        The rate of fall of values from source data points.
+        Higher the exponent, lower is the value when we move
+        across space. Default value is 2.
+
+    Attributes
+    ----------
+    Interpolated Values : {array-like, 2D matrix}, shape(resolution, resolution)
+    This contains all the interpolated values when the interpolation is performed
+    over a grid, instead of interpolation over a set of points.
+
+    X : {array-like, 2D matrix}, shape(n_samples, 2)
+    Set of all the coordinates available for interpolation.
+
+    y : array-like, shape(n_samples,)
+    Set of all the available values at the specified X coordinates.
+
+    result : array_like, shape(n_to_predict, )
+    Set of all the interpolated values when interpolating over a given
+    set of data points.
+
+    """
+
+    def __init__(
+        self, exponent=2, resolution="standard", coordinate_type="Euclidean"
+    ):
+        super().__init__(resolution, coordinate_type)
+        self.exponent = exponent
+        self.interpolated_values = None
+        self.X = None
+        self.y = None
+        self.result = None
+        if self.coordinate_type == "Geographic":
+            self.distance = haversine
+        elif self.coordinate_type == "Euclidean":
+            self.distance = euclidean
+        else:
+            raise NotImplementedError(
+                "Only Geographic and Euclidean Coordinates are available"
+            )
+
+    def _fit(self, X, y):
+        """This function is for the IDW Class.
+        This is not expected to be called directly
+        """
+        self.X = X
+        self.y = y
+        return self
+
+    def _predict_grid(self, x1lim, x2lim):
+        """Gridded interpolation for natural neighbors interpolation. This function should not
+        be called directly.
+        """
+        lims = (*x1lim, *x2lim)
+        x1min, x1max, x2min, x2max = lims
+        x1 = np.linspace(x1min, x1max, self.resolution)
+        x2 = np.linspace(x2min, x2max, self.resolution)
+        X1, X2 = np.meshgrid(x1, x2)
+        return self._predict(np.array([X1.ravel(), X2.ravel()]).T)
+
+    def _predict(self, X):
+        """The function call to predict using the interpolated data
+        in IDW interpolation. This should not be called directly.
+        """
+
+        dist = self.distance(self.X, X)
+        weights = 1 / np.power(dist, self.exponent)
+        result = (weights * self.y[:, None]).sum(axis=0) / weights.sum(axis=0)
+
+        # if point is from train data, ground truth must not change
+        for i in range(X.shape[0]):
+            mask = np.equal(X[i], self.X).all(axis=1)
+            if mask.any():
+                result[i] = (self.y * mask).sum()
+
+        return result

polire/idw/tests/IDW Initial.ipynb

@@ -0,0 +1,313 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Inverse Distance Weighting (IDW) Interpolation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us suppose we have a data that shows the variation of one quantity of interest across space.\n",
+    "This could be equivalently viewed as { ($\\vec{x_1}, y_1)$,$(\\vec{x_2}, y_2)$,$(\\vec{x_3}, y_3)$, ...}, where the $\\vec{x_i}$'s represent the coordinates of the points where we have data and the $y_i$'s are the actual data at those points. <br><br>\n",
+    "We would like to perform an interpolation using these data points such that a few things are satisifed.\n",
+    "1. The interpolation is exact - the value at the known data points is the same as the estimated value, and \n",
+    "2. We would want far away points from a given source data point to receive less importance than nearby points.\n",
+    "3. Wikipedia has an excellent article on IDW. I am linking it [here](https://en.wikipedia.org/wiki/Inverse_distance_weighting)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We are using the following approximation for coordinate_type being latlong_small<br>\n",
+    "$| \\vec{r_2}− \\vec{r_1}| ≈ \\text{R }\\times \\sqrt[]{(Lat_2 - Lat_1)^{2} + (Long_2 - Long_1)^{2}}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "df = pd.read_csv('../../testdata/30-03-18.csv')\n",
+    "data = np.array(df[['longitude','latitude','value']])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_grid(X,y,res):\n",
+    "    y_min = y.min()-0.2\n",
+    "    y_max = y.max()+0.2\n",
+    "    x_min = X.min()-0.2\n",
+    "    x_max = X.max()+0.2\n",
+    "    x_arr = np.linspace(x_min,x_max,res)\n",
+    "    y_arr = np.linspace(y_min,y_max,res)\n",
+    "    xx,yy = np.meshgrid(x_arr,y_arr)  \n",
+    "    return xx,yy\n",
+    "\n",
+    "def idw(dataset, exponent = 2,  resolution='standard', coordinate_type='euclidean',verbose='False'):\n",
+    "    \"\"\"\n",
+    "        Here X is the set of spatial locations - Usually assumed to be Lat-Long\n",
+    "        To be extended to higher dimenstions y - estimated value , exponenet - how\n",
+    "        much weight to assign to far off locations to be estimated for each data point, \n",
+    "        extent - interpolate over a grid - what is xmax xmin ymax ymin\n",
+    "    \"\"\"\n",
+    "    if coordinate_type == 'latlong_small':\n",
+    "        \"\"\"\n",
+    "            Assume that the Earth is a Sphere, and use polar coordinates\n",
+    "            $| \\vec{r_2}− \\vec{r_1}| ≈ \\text{R }\\times \\sqrt[]{(Lat_2 - Lat_1)^{2} + (Long_2 - Long_1)^{2}}$\n",
+    "        \"\"\"\n",
+    "        return \"To be done later\"\n",
+    "    if coordinate_type == 'latlong_large':\n",
+    "        \"\"\"\n",
+    "            Code to be written after understanding all the projections.\n",
+    "        \"\"\"\n",
+    "        return \"To be done later\"\n",
+    "    if coordinate_type==\"euclidean\":\n",
+    "        \n",
+    "#         print(dataset)\n",
+    "        X = dataset[:,0]\n",
+    "        y = dataset[:,1]\n",
+    "        if resolution=='high':\n",
+    "            xx,yy = make_grid(X,y,1000)\n",
+    "            \n",
+    "        if resolution=='low':\n",
+    "            xx,yy = make_grid(X,y,10)\n",
+    "            \n",
+    "        if resolution=='standard':\n",
+    "            xx,yy = make_grid(X,y,100)\n",
+    "        \n",
+    "        new = []\n",
+    "        new_arr = dataset\n",
+    "        for points in new_arr:\n",
+    "            mindist = np.inf\n",
+    "            val = 0\n",
+    "            for j in range(len(yy)):\n",
+    "                temp = yy[j][0]\n",
+    "                for i in range(len(xx[0])):\n",
+    "                    dist = np.linalg.norm(np.array([xx[0][i],temp]) - points[:2])\n",
+    "                    if dist<mindist:\n",
+    "                        mindist = dist\n",
+    "                        val = (i,j)\n",
+    "            new.append((points,val))\n",
+    "        print(new)\n",
+    "        new_grid = np.zeros((len(xx),len(yy)))\n",
+    "        for i in range(len(new)):\n",
+    "            x = new[i][1][0]\n",
+    "            y = new[i][1][1]\n",
+    "            new_grid[x][y] = new[i][0][2]\n",
+    "            print(new[i])\n",
+    "        x_nz,y_nz = np.nonzero(new_grid)\n",
+    "        list_nz = []\n",
+    "        for i in range(len(x_nz)):\n",
+    "            list_nz.append((x_nz[i],y_nz[i]))\n",
+    "        \n",
+    "        final = np.copy(new_grid)\n",
+    "        \n",
+    "        for i in range(len(xx[0])):\n",
+    "            for j in range(len(yy)):\n",
+    "                normalise = 0\n",
+    "                if (i,j) in list_nz:\n",
+    "                    continue\n",
+    "                else:\n",
+    "                    \"\"\"\n",
+    "                    Could potentially have a divide by zero error here\n",
+    "                    Use a try except clause\n",
+    "                    \"\"\"\n",
+    "                    for elem in range(len(x_nz)):\n",
+    "                        source = np.array([x_nz[elem],y_nz[elem]])\n",
+    "                        target = np.array([xx[0][i],yy[j][0]])\n",
+    "                        dist = (np.abs(xx[0][source[0]] - target[0])**exponent + np.abs(yy[source[1]][0] - target[1])**exponent)**(1/exponent)\n",
+    "                        final[i][j]+=new_grid[x_nz[elem],y_nz[elem]]/dist\n",
+    "                        normalise+=1/(dist)\n",
+    "                final[i][j]/=normalise\n",
+    "    \n",
+    "    return final\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[(array([ 77.234291,  28.581197, 194.      ]), (60, 39)), (array([ 77.245721,  28.739434, 267.      ]), (62, 60)), (array([ 77.101961,  28.822931, 273.      ]), (42, 72)), (array([ 76.991463,  28.620806, 129.      ]), (27, 44)), (array([ 77.0325413,  28.60909  , 176.       ]), (33, 42)), (array([ 77.072196,  28.570859, 172.      ]), (38, 37)), (array([ 77.1670103,  28.5646102, 168.       ]), (51, 36)), (array([ 77.1180053,  28.5627763, 105.       ]), (45, 36)), (array([ 77.272404,  28.530782, 203.      ]), (66, 32)), (array([ 77.26075 ,  28.563827, 192.      ]), (64, 36)), (array([77.0996943, 28.610304 , 95.       ]), (42, 43)), (array([ 77.2273074,  28.5918245, 148.       ]), (59, 40)), (array([ 77.09211 ,  28.732219, 203.      ]), (41, 59)), (array([ 77.317084,  28.668672, 221.      ]), (72, 51)), (array([ 77.1585447,  28.6573814, 141.       ]), (50, 49)), (array([ 77.2011573,  28.6802747, 192.       ]), (56, 52)), (array([ 77.237372,  28.612561, 203.      ]), (61, 43)), (array([ 77.305651,  28.632707, 152.      ]), (70, 46)), (array([ 77.1473105,  28.6514781, 185.       ]), (49, 48)), (array([ 77.16482 ,  28.699254, 290.      ]), (51, 55)), (array([ 77.170221,  28.728722, 273.      ]), (52, 59)), (array([ 77.2005604,  28.6372688, 173.       ]), (56, 46)), (array([ 77.2011573,  28.7256504, 269.       ]), (56, 58)), (array([ 77.136777,  28.669119, 160.      ]), (47, 51)), (array([77.267246, 28.49968 , 78.      ]), (65, 27)), (array([ 77.2494387,  28.6316945, 211.       ]), (62, 45)), (array([ 77.2735737,  28.5512005, 252.       ]), (66, 34)), (array([ 77.2159377,  28.5504249, 133.       ]), (58, 34)), (array([77.1112615, 28.7500499, 77.       ]), (44, 62)), (array([77.22445, 28.63576, 96.     ]), (59, 46))]\n",
+      "(array([ 77.234291,  28.581197, 194.      ]), (60, 39))\n",
+      "(array([ 77.245721,  28.739434, 267.      ]), (62, 60))\n",
+      "(array([ 77.101961,  28.822931, 273.      ]), (42, 72))\n",
+      "(array([ 76.991463,  28.620806, 129.      ]), (27, 44))\n",
+      "(array([ 77.0325413,  28.60909  , 176.       ]), (33, 42))\n",
+      "(array([ 77.072196,  28.570859, 172.      ]), (38, 37))\n",
+      "(array([ 77.1670103,  28.5646102, 168.       ]), (51, 36))\n",
+      "(array([ 77.1180053,  28.5627763, 105.       ]), (45, 36))\n",
+      "(array([ 77.272404,  28.530782, 203.      ]), (66, 32))\n",
+      "(array([ 77.26075 ,  28.563827, 192.      ]), (64, 36))\n",
+      "(array([77.0996943, 28.610304 , 95.       ]), (42, 43))\n",
+      "(array([ 77.2273074,  28.5918245, 148.       ]), (59, 40))\n",
+      "(array([ 77.09211 ,  28.732219, 203.      ]), (41, 59))\n",
+      "(array([ 77.317084,  28.668672, 221.      ]), (72, 51))\n",
+      "(array([ 77.1585447,  28.6573814, 141.       ]), (50, 49))\n",
+      "(array([ 77.2011573,  28.6802747, 192.       ]), (56, 52))\n",
+      "(array([ 77.237372,  28.612561, 203.      ]), (61, 43))\n",
+      "(array([ 77.305651,  28.632707, 152.      ]), (70, 46))\n",
+      "(array([ 77.1473105,  28.6514781, 185.       ]), (49, 48))\n",
+      "(array([ 77.16482 ,  28.699254, 290.      ]), (51, 55))\n",
+      "(array([ 77.170221,  28.728722, 273.      ]), (52, 59))\n",
+      "(array([ 77.2005604,  28.6372688, 173.       ]), (56, 46))\n",
+      "(array([ 77.2011573,  28.7256504, 269.       ]), (56, 58))\n",
+      "(array([ 77.136777,  28.669119, 160.      ]), (47, 51))\n",
+      "(array([77.267246, 28.49968 , 78.      ]), (65, 27))\n",
+      "(array([ 77.2494387,  28.6316945, 211.       ]), (62, 45))\n",
+      "(array([ 77.2735737,  28.5512005, 252.       ]), (66, 34))\n",
+      "(array([ 77.2159377,  28.5504249, 133.       ]), (58, 34))\n",
+      "(array([77.1112615, 28.7500499, 77.       ]), (44, 62))\n",
+      "(array([77.22445, 28.63576, 96.     ]), (59, 46))\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(100, 100)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "idw(data).shape\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "temp = data[10]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([10, 10, 10]), array([0, 1, 2]))"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.where(data==temp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result  = np.nonzero(data==temp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.unique(result[0])[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "listOfCoordinates= list(zip(result[0], result[1]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(10, 0), (10, 1), (10, 2)]"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "listOfCoordinates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

polire/idw/tests/Numpy+IDWTest.ipynb

@@ -0,0 +1,411 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = np.array([[1,2,3],[4,5,6]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1, 2, 3],\n",
+       "       [4, 5, 6]])"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b = np.array([[2,3,4],[5,6,9]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[2, 3, 4],\n",
+       "       [5, 6, 9]])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1, 2, 3],\n",
+       "       [4, 5, 6]])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1, -1, -1],\n",
+       "       [-1, -1, -3]])"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a - b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.7320508075688772"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.argmin([np.linalg.norm(a[i] - b[i]) for i in range(len(a))])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.min?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\"\"\"\n",
+    "This is a module for IDW Spatial Interpolation\n",
+    "\"\"\"\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from copy import deepcopy\n",
+    "class idw():\n",
+    "    \"\"\" A class that is declared for performing IDW Interpolation.\n",
+    "    For more information on how this method works, kindly refer to\n",
+    "    https://en.wikipedia.org/wiki/Inverse_distance_weighting\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    exponent : positive float, optional\n",
+    "        The rate of fall of values from source data points.\n",
+    "        Higher the exponent, lower is the value when we move\n",
+    "        across space. Default value is 2.\n",
+    "    resolution: str, optional\n",
+    "        Decides the smoothness of the interpolation. Note that\n",
+    "        interpolation is done over a grid. Higher the resolution\n",
+    "        means more grid cells and more time for interpolation.\n",
+    "        Default value is 'standard'\n",
+    "    coordinate_type: str, optional\n",
+    "        Decides the distance metric to be used, while performing\n",
+    "        interpolation. Euclidean by default.     \n",
+    "    \"\"\"\n",
+    "    def __init__(self, exponent = 2, resolution = 'standard', coordinate_type='Euclidean'):\n",
+    "        \n",
+    "        self.exponent = exponent\n",
+    "        self.resolution = resolution\n",
+    "        self.coordinate_type = coordinate_type\n",
+    "        self.interpolated_values = None\n",
+    "        self.x_grid = None\n",
+    "        self.y_grid = None\n",
+    "\n",
+    "    def make_grid(self, x, y, res, offset=0.2):\n",
+    "\n",
+    "        \"\"\" This function returns the grid to perform interpolation on.\n",
+    "           This function is used inside the fit() attribute of the idw class.\n",
+    "        \n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        x: array-like, shape(n_samples,)\n",
+    "            The first coordinate values of all points where\n",
+    "            ground truth is available\n",
+    "        y: array-like, shape(n_samples,)\n",
+    "            The second coordinate values of all points where\n",
+    "            ground truth is available\n",
+    "        res: int\n",
+    "            The resolution value\n",
+    "        offset: float, optional\n",
+    "            A value between 0 and 0.5 that specifies the extra interpolation to be done\n",
+    "            Default is 0.2\n",
+    "        \n",
+    "        Returns\n",
+    "        -------\n",
+    "        xx : {array-like, 2D}, shape (n_samples, n_samples)\n",
+    "        yy : {array-like, 2D}, shape (n_samples, n_samples)\n",
+    "        \"\"\"\n",
+    "        y_min = y.min() - offset\n",
+    "        y_max = y.max()+ offset\n",
+    "        x_min = x.min()-offset\n",
+    "        x_max = x.max()+offset\n",
+    "        x_arr = np.linspace(x_min,x_max,res)\n",
+    "        y_arr = np.linspace(y_min,y_max,res)\n",
+    "        xx,yy = np.meshgrid(x_arr,y_arr)  \n",
+    "        return xx,yy\n",
+    "\n",
+    "    \n",
+    "    def fit(self, X, y):\n",
+    "        \"\"\" The function call to fit the model on the given data. \n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        X: {array-like, 2D matrix}, shape(n_samples, 2)\n",
+    "            The set of all coordinates, where we have ground truth\n",
+    "            values\n",
+    "        y: array-like, shape(n_samples,)\n",
+    "            The set of all the ground truth values using which\n",
+    "            we perform interpolation\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        self : object\n",
+    "            Returns self\n",
+    "        \"\"\"\n",
+    "\n",
+    "#          if self.coordinate_type == 'latlong_small':\n",
+    "# \t \t\"\"\"\n",
+    "# \t \t\tUse the conversions and projections for small changes in LatLong\n",
+    "#  \t\t\"\"\"\n",
+    "# \t \t    print (\"To be done later\")\n",
+    "#             return self\n",
+    "\n",
+    "#         if self.coordinate_type == 'latlong_large':\n",
+    "#             \"\"\"\n",
+    "#                 Code to be written after understanding all the projections.\n",
+    "#             \"\"\"\n",
+    "#             print (\"To be done later\")\n",
+    "#             return self\n",
+    "\n",
+    "        if self.coordinate_type==\"Euclidean\":\n",
+    "            \n",
+    "            X = deepcopy(np.c_[X,y])\n",
+    "\n",
+    "            if self.resolution=='high':\n",
+    "                xx,yy = self.make_grid(X,y,1000)\n",
+    "                \n",
+    "            if self.resolution=='low':\n",
+    "                xx,yy = self.make_grid(X,y,10)\n",
+    "                \n",
+    "            if self.resolution=='standard':\n",
+    "                xx,yy = self.make_grid(X,y,100)\n",
+    "\n",
+    "            new = []\n",
+    "            new_arr = deepcopy(X)\n",
+    "            for points in new_arr:\n",
+    "                min_dist = np.inf\n",
+    "                val = 0\n",
+    "                for j in range(len(yy)):\n",
+    "                    temp = yy[j][0]\n",
+    "                    for i in range(len(xx[0])):\n",
+    "                        dist = np.linalg.norm(np.array([xx[0][i],temp]) - points[:2])\n",
+    "                        if dist<min_dist:\n",
+    "                            min_dist = dist\n",
+    "                            val = (i,j)\n",
+    "                new.append((points,val))\n",
+    "            new_grid = np.zeros((len(xx),len(yy)))\n",
+    "            for i in range(len(new)):\n",
+    "                x = new[i][1][0]\n",
+    "                y = new[i][1][1]\n",
+    "                new_grid[x][y] = new[i][0][2]\n",
+    "            x_nz,y_nz = np.nonzero(new_grid)\n",
+    "            list_nz = []\n",
+    "            for i in range(len(x_nz)):\n",
+    "                list_nz.append((x_nz[i],y_nz[i]))\n",
+    "            final = np.copy(new_grid)\n",
+    "            for i in range(len(xx[0])):\n",
+    "                for j in range(len(yy)):\n",
+    "                    normalise = 0\n",
+    "                    if (i,j) in list_nz:\n",
+    "                        continue\n",
+    "                    else:\n",
+    "                        for elem in range(len(x_nz)):\n",
+    "                            source = np.array([x_nz[elem],y_nz[elem]])\n",
+    "                            target = np.array([xx[0][i],yy[j][0]])\n",
+    "                            dist = (np.abs(xx[0][source[0]] - target[0])**self.exponent + np.abs(yy[source[1]][0] - target[1])**self.exponent)**(1/self.exponent)\n",
+    "                            final[i][j]+=new_grid[x_nz[elem],y_nz[elem]]/dist\n",
+    "                            normalise+=1/(dist)\n",
+    "                    final[i][j]/=normalise\n",
+    "            self.interpolated_values = final\n",
+    "            self.x_grid = xx\n",
+    "            self.y_grid = yy\n",
+    "        \n",
+    "        return self\n",
+    "\n",
+    "#     def predict(self, X):\n",
+    "#         \"\"\" The function call to predict using the interpolated data\n",
+    "#         Parameters\n",
+    "#         ----------\n",
+    "#         X: {array-like, 2D matrix}, shape(n_samples, 2)\n",
+    "#             The set of all coordinates, where we have ground truth\n",
+    "#             values\n",
+    "        \n",
+    "\n",
+    "#         Returns\n",
+    "#         -------\n",
+    "#         y: array-like, shape(n_samples,)\n",
+    "#             The set of all the ground truth values using which\n",
+    "#             we perform interpolation \n",
+    "#         \"\"\"\n",
+    "#         if self.coordinate_type == 'Euclidean':\n",
+    "#             for i in range(self.x_grid[0]):\n",
+    "#                 for j in range()\n",
+    "        \n",
+    "#         else:\n",
+    "#             print(\"Will be done later\")\n",
+    "#             return \n",
+    "            \n",
+    "                \n",
+    "# self.x_grid\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<__main__.idw at 0x7f36db6f9c88>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = idw()\n",
+    "import pandas as pd\n",
+    "df = pd.read_csv('../../testdata/30-03-18.csv')\n",
+    "data = np.array(df[['longitude','latitude','value']])\n",
+    "a.fit(data[:,:2],data[:,2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[171.89189189, 171.89597641, 171.90813547, ..., 173.89050472,\n",
+       "        173.89261459, 173.89466512],\n",
+       "       [171.77142857, 171.77625338, 171.79060316, ..., 173.89585441,\n",
+       "        173.89787202, 173.89983245],\n",
+       "       [171.63636364, 171.64211895, 171.65921778, ..., 173.9012935 ,\n",
+       "        173.90321551, 173.90508269],\n",
+       "       ...,\n",
+       "       [174.49681529, 174.49676176, 174.49660126, ..., 174.24671184,\n",
+       "        174.24416446, 174.24164382],\n",
+       "       [174.49056604, 174.49051451, 174.49035999, ..., 174.24671343,\n",
+       "        174.24419773, 174.2417078 ],\n",
+       "       [174.48447205, 174.48442242, 174.48427358, ..., 174.2466762 ,\n",
+       "        174.24419219, 174.24173298]])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.interpolated_values"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

polire/kriging/kriging.py

@@ -0,0 +1,146 @@
+"""
+This is a module for Kriging Interpolation
+"""
+import numpy as np
+from ..base import Base
+from pykrige.ok import OrdinaryKriging
+from pykrige.uk import UniversalKriging
+
+
+class Kriging(Base):
+    """A class that is declared for performing Kriging interpolation.
+    Kriging interpolation (usually) works on the principle of finding the
+    best unbiased predictor. Ordinary Kriging, for an example, involves finding out the
+    best unbaised linear predictor.
+
+    Parameters
+    ----------
+    type : str, optional
+    This parameter defines the type of Kriging under consideration. This
+    implementation uses PyKrige package  (https://github.com/bsmurphy/PyKrige).
+    The user needs to choose between "Ordinary" and "Universal".
+
+    plotting: boolean, optional
+    This parameter plots the fit semivariogram. We use PyKrige's inbuilt plotter for the same.s
+
+    variogram_model : str, optional
+    Specifies which variogram model to use; may be one of the following:
+    linear, power, gaussian, spherical, exponential, hole-effect.
+    Default is linear variogram model. To utilize a custom variogram model,
+    specify 'custom'; you must also provide variogram_parameters and
+    variogram_function. Note that the hole-effect model is only technically
+    correct for one-dimensional problems.
+
+    require_variance : Boolean, optional
+    This variable returns the uncertainity in the interpolated values using Kriging
+    interpolation. If this is True, kindly call the attribute return_variance, of this class
+    to retreive the computed variances. False is the default value.d
+
+        nlags: int, optional
+        Number of lags to be considered for semivariogram. As in PyKrige, we set default to be 6.
+    """
+
+    def __init__(
+        self,
+        type="Ordinary",
+        plotting=False,
+        variogram_model="linear",
+        require_variance=False,
+        resolution="standard",
+        coordinate_type="Eucledian",
+        nlags=6,
+    ):
+        super().__init__(resolution, coordinate_type)
+        self.variogram_model = variogram_model
+        self.ok = None
+        self.uk = None
+        self.type = type
+        self.plotting = plotting
+        self.coordinate_type = None
+        self.require_variance = require_variance
+        self.variance = None
+
+        if coordinate_type == "Eucledian":
+            self.coordinate_type = "euclidean"
+        else:
+            self.coordinate_type = "geographic"
+
+        self.nlags = nlags
+
+    def _fit(self, X, y):
+        """This method of the Kriging Class is used to fit Kriging interpolation model to
+        the train data. This function shouldn't be called directly."""
+        if self.type == "Ordinary":
+            self.ok = OrdinaryKriging(
+                X[:, 0],
+                X[:, 1],
+                y,
+                variogram_model=self.variogram_model,
+                enable_plotting=self.plotting,
+                coordinates_type=self.coordinate_type,
+                nlags=self.nlags,
+            )
+
+        elif self.type == "Universal":
+            self.uk = UniversalKriging(
+                X[:, 0],
+                X[:, 1],
+                y,
+                variogram_model=self.variogram_model,
+                enable_plotting=self.plotting,
+            )
+
+        else:
+            raise ValueError(
+                "Choose either Universal or Ordinary - Given argument is neither"
+            )
+
+        return self
+
+    def _predict_grid(self, x1lim, x2lim):
+        """The function that is called to return the interpolated data in Kriging Interpolation
+        in a grid. This method shouldn't be called directly"""
+        lims = (*x1lim, *x2lim)
+        x1min, x1max, x2min, x2max = lims
+        x1 = np.linspace(x1min, x1max, self.resolution)
+        x2 = np.linspace(x2min, x2max, self.resolution)
+
+        if self.ok is not None:
+            predictions, self.variance = self.ok.execute(
+                style="grid", xpoints=x1, ypoints=x2
+            )
+
+        else:
+            predictions, self.variance = self.uk.execute(
+                style="grid", xpoints=x1, ypoints=x2
+            )
+
+        return predictions
+
+    def _predict(self, X):
+        """This function should be called to return the interpolated data in kriging
+        in a pointwise manner. This method shouldn't be called directly."""
+        if self.ok is not None:
+            predictions, self.variance = self.ok.execute(
+                style="points", xpoints=X[:, 0], ypoints=X[:, 1]
+            )
+
+        else:
+            predictions, self.variance = self.uk.execute(
+                style="points", xpoints=X[:, 0], ypoints=X[:, 1]
+            )
+
+        return predictions
+
+    def return_variance(self):
+        """This method of the Kriging class returns the variance at the interpolated
+        points if the user chooses to use this option at the beginning of the interpolation
+        """
+        if self.require_variance:
+            return self.variance
+
+        else:
+            print(
+                "Variance not asked for, while instantiating the object. Returning None"
+            )
+            return None

polire/kriging/tests/Kriging Interpolation.ipynb

@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pykrige import OrdinaryKriging"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ok = OrdinaryKriging(data[:,0],data[:,1],data[:,2])\n",
+    "ok.ex"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a,b = ok.execute('grid',x[0],y[:,0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pykrige import OrdinaryKriging\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "def ordinary_kriging(dataset, resolution='standard', coordinate_type='euclidean',verbose='False',method='grid', isvariance = False):\n",
+    "    if coordinate_type == 'latlong_small':\n",
+    "        \"\"\"\n",
+    "            Assume that the Earth is a Sphere, and use polar coordinates\n",
+    "            $| \\vec{r_2}− \\vec{r_1}| ≈ \\text{R }\\times \\sqrt[]{(Lat_2 - Lat_1)^{2} + (Long_2 - Long_1)^{2}}$\n",
+    "        \"\"\"\n",
+    "        return \"To be done later\"\n",
+    "    if coordinate_type == 'latlong_large':\n",
+    "        \"\"\"\n",
+    "            Code to be written after understanding all the projections.\n",
+    "        \"\"\"\n",
+    "        return \"To be done later\"\n",
+    "    if coordinate_type==\"euclidean\":\n",
+    "        \n",
+    "        ok = OrdinaryKriging(dataset[:,0],dataset[:,1],dataset[:,2])\n",
+    "        X = dataset[:,0]\n",
+    "        y = dataset[:,1]\n",
+    "        \n",
+    "        if resolution=='high':\n",
+    "            xx,yy = make_grid(X,y,1000)\n",
+    "            \n",
+    "        elif resolution=='low':\n",
+    "            xx,yy = make_grid(X,y,10)\n",
+    "            \n",
+    "        elif resolution=='standard':\n",
+    "            xx,yy = make_grid(X,y,100)\n",
+    "            \n",
+    "        else:\n",
+    "            print('Value Error - Resolution can only be one of \\nhigh, low or standard')\n",
+    "        \n",
+    "        values, variances = ok.execute(method, xx[0], yy[:,0])\n",
+    "        \n",
+    "    if isvariance:\n",
+    "        return values, variances\n",
+    "    else:\n",
+    "        del variances\n",
+    "        return np.array(values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[129.94984945, 129.7682324 , 129.58820662, ..., 159.34079485,\n",
+       "        159.99175016, 160.63241067],\n",
+       "       [130.22090025, 130.03615966, 129.8529146 , ..., 159.9575165 ,\n",
+       "        160.61228126, 161.25625641],\n",
+       "       [130.50105231, 130.31324536, 130.12683652, ..., 160.59265384,\n",
+       "        161.25084023, 161.8977369 ],\n",
+       "       ...,\n",
+       "       [207.22133238, 207.82739139, 208.44615116, ..., 248.64646661,\n",
+       "        248.3790241 , 248.11033441],\n",
+       "       [207.92838926, 208.53490708, 209.15376273, ..., 248.91678379,\n",
+       "        248.65601627, 248.39371596],\n",
+       "       [208.61942088, 209.22595474, 209.84445913, ..., 249.17442481,\n",
+       "        248.9203453 , 248.66446245]])"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ordinary_kriging(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* What does ok('points') really do?\n",
+    "* Specifically test when points aren't really passed - they are let's say the point of an array\n",
+    "* Returns the diagonal matrix of all these coordinates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([129.94984945, 130.03615966, 130.12683652, 130.22219703,\n",
+       "       130.32258826, 130.42839089, 130.54002324, 130.65794596,\n",
+       "       130.7826674 , 130.91474976, 131.05481629, 131.20355964,\n",
+       "       131.36175158, 131.53025441, 131.71003442, 131.90217771,\n",
+       "       132.107909  , 132.32861401, 132.56586607, 132.82145795,\n",
+       "       133.0974399 , 133.39616477, 133.72034153, 134.07309736,\n",
+       "       134.45804822, 134.87937482, 135.34189663, 135.85112772,\n",
+       "       136.41328222, 137.03517039, 137.72388496, 138.48612122,\n",
+       "       139.326921  , 140.24763047, 141.24300526, 142.29757046,\n",
+       "       143.37881815, 144.38425962, 144.49187978, 143.1202101 ,\n",
+       "       141.66667134, 140.45686022, 139.66795657, 142.48270308,\n",
+       "       147.03665055, 151.8487008 , 156.90272514, 162.25791164,\n",
+       "       168.04938768, 173.63870768, 180.93567147, 190.3440156 ,\n",
+       "       199.86834472, 208.48375248, 215.75635742, 222.1915652 ,\n",
+       "       228.08641413, 233.15249702, 236.89713686, 239.83524192,\n",
+       "       242.45744315, 244.57483343, 245.52139699, 245.88236757,\n",
+       "       246.12295211, 246.3306567 , 246.52369882, 246.70598807,\n",
+       "       246.87792737, 247.03919426, 247.18952217, 247.3288843 ,\n",
+       "       247.45749059, 247.57573348, 247.68412862, 247.78326467,\n",
+       "       247.87376505, 247.95626051, 248.03137024, 248.09968963,\n",
+       "       248.16178271, 248.21817801, 248.26936683, 248.31580309,\n",
+       "       248.35790422, 248.39605277, 248.43059841, 248.46186013,\n",
+       "       248.49012851, 248.51566797, 248.53871897, 248.55950011,\n",
+       "       248.57821004, 248.59502931, 248.61012204, 248.62363741,\n",
+       "       248.63571111, 248.64646661, 248.65601627, 248.66446245])"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ordinary_kriging(data,method='points')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_grid(X,y,res):\n",
+    "    y_min = y.min()-0.2\n",
+    "    y_max = y.max()+0.2\n",
+    "    x_min = X.min()-0.2\n",
+    "    x_max = X.max()+0.2\n",
+    "    x_arr = np.linspace(x_min,x_max,res)\n",
+    "    y_arr = np.linspace(y_min,y_max,res)\n",
+    "    xx,yy = np.meshgrid(x_arr,y_arr)  \n",
+    "    return xx,yy\n",
+    "x, y = make_grid(data[:,0],data[:,1],100)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

polire/natural_neighbors/natural_neighbors.py

@@ -0,0 +1,210 @@
+"""
+This is a module for Natural Neighbors Interpolation
+"""
+
+import numpy as np
+from scipy.spatial import Voronoi, voronoi_plot_2d
+import matplotlib.pyplot as plt
+from ..base import Base
+from shapely.geometry import Point
+from shapely.geometry.polygon import Polygon
+from math import atan2
+from copy import deepcopy
+
+
+def is_row_in_array(row, arr):
+    return list(row) in arr.tolist()
+
+
+def get_index(row, arr):
+    t1 = np.where(arr[:, 0] == row[0])
+    t2 = np.where(arr[:, 1] == row[1])
+    index = np.intersect1d(t1, t2)[0]
+    # If length of index exceeds one!! - Uniqueness Error
+    return index
+
+
+def order_poly(vertices):
+    """This function essentially is used to order the vertices
+    of the Voronoi polygon in a clockwise manner. This ensures
+    that Shapely doesn't produce Polygon objects that are potentially
+    non-convex and non-zero area.
+
+    Arguments
+    ---------
+    vertices : {array-like, 2D matrix}
+    This contains the list of vertices of the Polygon to be sorted
+
+    Returns
+    -------
+    new_vertices : {array-like, 2D matrix}
+    All the vertices reordered in a clockwise manner
+    """
+    mean_x = np.mean(vertices[:, 0])
+    mean_y = np.mean(vertices[:, 1])
+
+    def condition(x):
+        """This is the condition to be used while sorting. We convert the coordinates
+        to Polar and sort the points
+        """
+        return atan2(x[0] - mean_x, x[1] - mean_y) * 180 / np.pi
+
+    return sorted(vertices, key=condition)
+
+
+class NaturalNeighbor(Base):
+    """Class used for natural neighbors interpolation. This method is an implementation first
+    proposed by Sibson et al. [1] in 1981. We use the weights derived using the work in [1]
+    and leave it for future addition, the use of Laplace Weights [2].
+
+    Parameters
+    ----------
+    weights: str, optional
+        This defines the type of weights to be used for natural neighbor interpolation.
+        We use Sibson Weights, and plan to add Laplace weights in the future
+        Default value is "sibson"
+
+    display: Boolean, optional
+        True value displays the voronoi tesselation to the user after fitting the model.
+        Default value is False.
+
+    Notes
+    -----
+    This is for contributors:
+        The way in which part of the code is used is in the assumption that
+        we use the data's ordering to find its voronoi partitions.
+
+    References
+    ----------
+    [1]  Sibson, R. (1981). "A brief description of natural neighbor interpolation (Chapter 2)". In V. Barnett (ed.). Interpolating Multivariate Data. Chichester: John Wiley. pp. 21–36.
+    [2]  V.V. Belikov; V.D. Ivanov; V.K. Kontorovich; S.A. Korytnik; A.Y. Semenov (1997). "The non-Sibsonian interpolation: A new method of interpolation of the values of a function on an arbitrary set of points". Computational mathematics and mathematical physics. 37 (1): 9–15.
+    [3]  N.H. Christ; R. Friedberg, R.; T.D. Lee (1982). "Weights of links and plaquettes in a random lattice". Nuclear Physics B. 210 (3): 337–346.
+    """
+
+    def __init__(
+        self,
+        weights="sibson",
+        display=False,
+        resolution="standard",
+        coordinate_type="Eucledian",
+    ):
+        super().__init__(resolution, coordinate_type)
+        self.weights = weights
+        self.X = None
+        self.y = None
+        self.result = None
+        self.voronoi = None
+        self.vertices = (
+            None  # This variable stored the voronoi partition's vertices
+        )
+        self.vertex_poly_map = (
+            dict()
+        )  # This variable stores the polygon to data point map
+        self.display = display
+
+    def _fit(self, X, y):
+        """This function is for the natural neighbors interpolation method.
+        This is not expected to be called directly.
+        """
+        self.X = X
+        self.y = y
+        self.voronoi = Voronoi(X, incremental=True)
+        self.vertices = self.voronoi.vertices
+
+        self.vertex_poly_map = {i: 0 for i in range(len(X))}
+
+        for i in range(len(self.X)):
+            index = np.where(self.voronoi.point_region == i)[0][0]
+            point = Point(self.X[index])
+            region = self.voronoi.regions[i]
+            if -1 not in region and region != []:
+                # -1 corresponds to unbounded region - we can't have this in interpolation
+                # and the function returns an empty list anyways
+                # at least in the case of non-incremental NN
+                p = Polygon(order_poly(self.vertices[region]))
+                self.vertex_poly_map[index] = p
+        # Remove all the data points that do not contribute to Nearest Neighhbor interpolation
+        for i in range(len(self.vertex_poly_map)):
+            if self.vertex_poly_map[i] == 0:
+                self.vertex_poly_map.pop(i, None)
+
+        if self.display:
+            voronoi_plot_2d(self.voronoi)
+            plt.show()
+            self.display = False
+
+        return self
+
+    def _predict_grid(self, x1lim, x2lim):
+        """Gridded interpolation for natural neighbors interpolation. This function should not
+        be called directly.
+        """
+        lims = (*x1lim, *x2lim)
+        x1min, x1max, x2min, x2max = lims
+        x1 = np.linspace(x1min, x1max, self.resolution)
+        x2 = np.linspace(x2min, x2max, self.resolution)
+        X1, X2 = np.meshgrid(x1, x2)
+        return self._predict(np.array([X1.ravel(), X2.ravel()]).T)
+
+    def _predict(self, X):
+        """The function taht is called to predict the interpolated data in Natural Neighbors
+        interpolation. This should not be called directly.
+        If this method returns None, then we cannot interpolate because of the formed Voronoi
+        Tesselation
+        """
+        result = np.zeros(len(X))
+        # Potentially create so many class objects as the
+        # length of the to be predicted array
+        # not a bad idea if memory is not a constraints
+        for index in range(len(X)):
+            if is_row_in_array(X[index], self.X):
+                idx = get_index(X[index], self.X)
+                # Check if query data point already exists
+                result[index] = self.y[idx]
+
+            else:
+                # QHull object can't bgit ae pickled. Deepcopy doesn't work.
+                # So we need to fit the model for each and every query data point.
+                self._fit(self.X, self.y)
+
+                vor = self.voronoi
+                vor.add_points(np.array([X[index]]))
+                vor.close()
+                # We exploit the incremental processing of Scipy's Voronoi.
+                # We create a copy to ensure that the original copy is preserved.
+                new_regions = vor.regions
+                new_vertices = vor.vertices
+                final_regions = []
+
+                for i in new_regions:
+                    if i != [] and -1 not in i:
+                        final_regions.append(i)
+
+                new = []  # this stores the newly created voronoi partitions
+                for i in range(len(new_vertices)):
+                    if new_vertices[i] not in self.vertices:
+                        new.append(new_vertices[i])
+                new = np.array(new)
+                if len(new) < 3:
+                    # We need atleast a traingle to interpolate
+                    # Three new voronoi vertices form a triangle
+                    result[index] = np.nan
+                    continue
+
+                weights = {}  # Weights that we use for interpolation
+                new_polygon = Polygon(order_poly(new))
+                new_polygon_area = new_polygon.area
+
+                for i in self.vertex_poly_map:
+                    if new_polygon.intersects(self.vertex_poly_map[i]):
+                        weights[i] = (
+                            new_polygon.intersection(self.vertex_poly_map[i])
+                        ).area / new_polygon_area
+
+                prediction = np.array(
+                    [self.y[i] * weights[i] for i in weights]
+                ).sum()
+                result[index] = prediction
+                del vor, weights, new_polygon, new_polygon_area
+
+        return result