diff --git a/python/cuspatial/cuspatial/bindings/soa_readers.pyx b/python/cuspatial/cuspatial/bindings/soa_readers.pyx
index de13f8ba3..9d03f6e59 100644
--- a/python/cuspatial/cuspatial/bindings/soa_readers.pyx
+++ b/python/cuspatial/cuspatial/bindings/soa_readers.pyx
@@ -1,5 +1,5 @@
-from cudf.dataframe.column import Column
-from cudf.bindings.cudf_cpp import * 
+from cudf.core.column import Column
+from cudf.core._lib import *
 from libc.stdlib cimport calloc, malloc, free
 from libcpp.pair cimport pair
 
diff --git a/python/cuspatial/cuspatial/bindings/spatial.pyx b/python/cuspatial/cuspatial/bindings/spatial.pyx
index b323c6e21..7df3032d7 100644
--- a/python/cuspatial/cuspatial/bindings/spatial.pyx
+++ b/python/cuspatial/cuspatial/bindings/spatial.pyx
@@ -1,20 +1,28 @@
-from cudf.bindings.cudf_cpp import *
-from cudf.dataframe.column import Column
+from cudf._lib.cudf import *
+from cudf._lib.cudf cimport *
+from cudf.core.column import Column
+from cudf import Series
 from libcpp.pair cimport pair
 
 from libc.stdlib cimport calloc, malloc, free
-                        
+
 cpdef cpp_point_in_polygon_bitmap(points_x, points_y,
                                   poly_fpos, poly_rpos,
-                                  poly_x, poly_y): 
+                                  poly_x, poly_y):
+    points_x = points_x.astype('float64')._column
+    points_y = points_y.astype('float64')._column
+    poly_fpos = poly_fpos.astype('int32')._column
+    poly_rpos = poly_rpos.astype('int32')._column
+    poly_x = poly_x.astype('float64')._column
+    poly_y = poly_y.astype('float64')._column
     cdef gdf_column* c_points_x = column_view_from_column(points_x)
     cdef gdf_column* c_points_y = column_view_from_column(points_y)
-    
+
     cdef gdf_column* c_poly_fpos = column_view_from_column(poly_fpos)
     cdef gdf_column* c_poly_rpos = column_view_from_column(poly_rpos)
- 
+
     cdef gdf_column* c_poly_x = column_view_from_column(poly_x)
-    cdef gdf_column* c_poly_y = column_view_from_column(poly_y)    
+    cdef gdf_column* c_poly_y = column_view_from_column(poly_y)
     cdef gdf_column* result_bitmap = <gdf_column*>malloc(sizeof(gdf_column))
 
     with nogil:
@@ -28,13 +36,18 @@ cpdef cpp_point_in_polygon_bitmap(points_x, points_y,
     free(c_poly_fpos)
     free(c_poly_rpos)
     free(c_poly_x)
-    free(c_poly_y)  
+    free(c_poly_y)
     free(result_bitmap)
-    bitmap = Column.from_mem_views(data, mask) 
+    bitmap = Column.from_mem_views(data, mask)
 
     return bitmap
 
-cpdef cpp_haversine_distance(x1,y1,x2,y2): 
+cpdef cpp_haversine_distance(x1,y1,x2,y2):
+    x1 = x1.astype('float64')._column
+    y1 = y1.astype('float64')._column
+    x2 = x2.astype('float64')._column
+    y2 = y2.astype('float64')._column
+
     cdef gdf_column* c_x1= column_view_from_column(x1)
     cdef gdf_column* c_y1 = column_view_from_column(y1)
     cdef gdf_column* c_x2= column_view_from_column(x2)
@@ -51,11 +64,15 @@ cpdef cpp_haversine_distance(x1,y1,x2,y2):
     free(c_x2)
     free(c_y2)
     free(c_h_dist)
-    h_dist=Column.from_mem_views(data, mask) 
+    h_dist=Column.from_mem_views(data, mask)
 
-    return h_dist  
+    return Series(h_dist)
 
 cpdef cpp_lonlat2coord(cam_lon, cam_lat, in_lon, in_lat):
+    cam_lon = np.float64(cam_lon)
+    cam_lat = np.float64(cam_lat)
+    in_lon = in_lon.astype('float64')._column
+    in_lat = in_lat.astype('float64')._column
     cdef gdf_scalar* c_cam_lon = gdf_scalar_from_scalar(cam_lon)
     cdef gdf_scalar* c_cam_lat = gdf_scalar_from_scalar(cam_lat)
     cdef gdf_column* c_in_lon = column_view_from_column(in_lon)
@@ -76,9 +93,12 @@ cpdef cpp_lonlat2coord(cam_lon, cam_lat, in_lon, in_lat):
     x=Column.from_mem_views(x_data, x_mask)
     y=Column.from_mem_views(y_data, y_mask)
 
-    return x,y
+    return Series(x), Series(y)
 
 cpdef cpp_directed_hausdorff_distance(coor_x,coor_y,cnt):
+    coor_x = coor_x.astype('float64')._column
+    coor_y = coor_y.astype('float64')._column
+    cnt = cnt.astype('int32')._column
     cdef gdf_column* c_coor_x = column_view_from_column(coor_x)
     cdef gdf_column* c_coor_y = column_view_from_column(coor_y)
     cdef gdf_column* c_cnt = column_view_from_column(cnt)
@@ -86,7 +106,7 @@ cpdef cpp_directed_hausdorff_distance(coor_x,coor_y,cnt):
     with nogil:
      c_dist[0]=directed_hausdorff_distance(c_coor_x[0],c_coor_y[0],c_cnt[0])
 
-    dist_data, dist_mask = gdf_column_to_column_mem(c_dist)    
+    dist_data, dist_mask = gdf_column_to_column_mem(c_dist)
     dist=Column.from_mem_views(dist_data,dist_mask)
 
-    return dist   
\ No newline at end of file
+    return Series(dist)
diff --git a/python/cuspatial/cuspatial/bindings/trajectory.pxd b/python/cuspatial/cuspatial/bindings/trajectory.pxd
index 22316fa54..21f6ce714 100644
--- a/python/cuspatial/cuspatial/bindings/trajectory.pxd
+++ b/python/cuspatial/cuspatial/bindings/trajectory.pxd
@@ -10,9 +10,12 @@ from libcpp.pair cimport pair
 
 cdef extern from "trajectory.hpp" namespace "cuspatial" nogil:
 
-   cdef int derive_trajectories(gdf_column& coor_x, gdf_column& coor_y,
-                                gdf_column& pid, gdf_column& ts,
-                                gdf_column& tid, gdf_column& len,
+   cdef int derive_trajectories(gdf_column& coor_x,
+                                gdf_column& coor_y,
+                                gdf_column& pid,
+                                gdf_column& ts,
+                                gdf_column& tid,
+                                gdf_column& len,
                                 gdf_column& pos) except +
 
    cdef pair[gdf_column, gdf_column] trajectory_distance_and_speed(
@@ -20,7 +23,8 @@ cdef extern from "trajectory.hpp" namespace "cuspatial" nogil:
       const gdf_column& y,
       const gdf_column& ts,
       const gdf_column& len,
-      const gdf_column& pos) except +
+      const gdf_column& pos
+  ) except +
 
    cdef void trajectory_spatial_bounds(const gdf_column& x,
                                        const gdf_column& y,
diff --git a/python/cuspatial/cuspatial/bindings/trajectory.pyx b/python/cuspatial/cuspatial/bindings/trajectory.pyx
index 1b8b2539c..7e6afcd24 100644
--- a/python/cuspatial/cuspatial/bindings/trajectory.pyx
+++ b/python/cuspatial/cuspatial/bindings/trajectory.pyx
@@ -1,5 +1,5 @@
-from cudf.dataframe.column import Column
-from cudf.bindings.cudf_cpp import *
+from cudf.core.column import Column
+from cudf._lib.cudf import *
 
 from libc.stdlib cimport calloc, malloc, free
 from libcpp.pair cimport pair
diff --git a/python/cuspatial/cuspatial/tests/hausdorff_clustering_test_toy.py b/python/cuspatial/cuspatial/demos/hausdorff_clustering_test_toy.py
similarity index 90%
rename from python/cuspatial/cuspatial/tests/hausdorff_clustering_test_toy.py
rename to python/cuspatial/cuspatial/demos/hausdorff_clustering_test_toy.py
index a80508eae..d2cd1155e 100644
--- a/python/cuspatial/cuspatial/tests/hausdorff_clustering_test_toy.py
+++ b/python/cuspatial/cuspatial/demos/hausdorff_clustering_test_toy.py
@@ -11,7 +11,7 @@
 
 import numpy as np
 import time
-from cudf.dataframe import columnops
+from cudf.core import column
 import cuspatial.bindings.spatial as gis
 from scipy.spatial.distance import directed_hausdorff
 from sklearn.cluster import AgglomerativeClustering,DBSCAN
@@ -26,9 +26,9 @@
 py_cnt = []
 for traj in in_trajs:
  py_cnt.append(len(traj))
-pnt_x=columnops.as_column(py_x,dtype=np.float64)
-pnt_y=columnops.as_column(py_y,dtype=np.float64)
-cnt=columnops.as_column(py_cnt,dtype=np.int32)
+pnt_x=column.as_column(py_x,dtype=np.float64)
+pnt_y=column.as_column(py_y,dtype=np.float64)
+cnt=column.as_column(py_cnt,dtype=np.int32)
 distance=gis.cpp_directed_hausdorff_distance(pnt_x,pnt_y,cnt)
 
 num_set=len(cnt)
diff --git a/python/cuspatial/cuspatial/demos/hausdorff_distance_verify_locust256.py b/python/cuspatial/cuspatial/demos/hausdorff_distance_verify_locust256.py
index cd05c5941..d2029c97e 100644
--- a/python/cuspatial/cuspatial/demos/hausdorff_distance_verify_locust256.py
+++ b/python/cuspatial/cuspatial/demos/hausdorff_distance_verify_locust256.py
@@ -16,94 +16,101 @@
 import cuspatial.bindings.spatial as gis
 import cuspatial.bindings.soa_readers as readers
 
-data_dir="/home/jianting/trajcode/"
-data_set="locust256"
+data_dir = "/home/jianting/trajcode/"
+data_set = "locust256"
 
-#scipy_res='scipyres.mat'
-#cuspatial_res='cuspatialres.mat'
-#if(len(sys.argv)>=2):
+# scipy_res='scipyres.mat'
+# cuspatial_res='cuspatialres.mat'
+# if(len(sys.argv)>=2):
 # scipy_res=sys.argv[1]
-#if(len(sys.argv)>=3):
+# if(len(sys.argv)>=3):
 # cuspatial_res=sys.argv[2]
 
-if(len(sys.argv)>=2):
- data_set=sys.argv[1]
+if len(sys.argv) >= 2:
+    data_set = sys.argv[1]
 
-#reading poing xy coordinate data (relative to a camera origin)
-pnt_x,pnt_y=readers.cpp_read_pnt_xy_soa(data_dir+data_set+".coor");
-#reading numbers of points in trajectories
-cnt=readers.cpp_read_uint_soa(data_dir+data_set+".objcnt")
-#reading object(vehicle) id
-id=readers.cpp_read_uint_soa(data_dir+data_set+".objectid")
+# reading poing xy coordinate data (relative to a camera origin)
+pnt_x, pnt_y = readers.cpp_read_pnt_xy_soa(data_dir + data_set + ".coor")
+# reading numbers of points in trajectories
+cnt = readers.cpp_read_uint_soa(data_dir + data_set + ".objcnt")
+# reading object(vehicle) id
+id = readers.cpp_read_uint_soa(data_dir + data_set + ".objectid")
 
-num_traj=cnt.data.size
-dist0=gis.cpp_directed_hausdorff_distance(pnt_x,pnt_y,cnt)
-cuspatial_dist0=dist0.data.to_array().reshape((num_traj,num_traj))
+num_traj = cnt.data.size
+dist0 = gis.cpp_directed_hausdorff_distance(pnt_x, pnt_y, cnt)
+cuspatial_dist0 = dist0.data.to_array().reshape((num_traj, num_traj))
 
 start = time.time()
-dist=gis.cpp_directed_hausdorff_distance(pnt_x,pnt_y,cnt)
-print("dis.size={} num_traj*num_traj={}".format(dist.data.size,num_traj*num_traj))
+dist = gis.cpp_directed_hausdorff_distance(pnt_x, pnt_y, cnt)
+print("dis.size={} num_traj*num_traj={}".format(dist.data.size, num_traj * num_traj))
 end = time.time()
-print(end - start)  
-print("python Directed Hausdorff distance GPU end-to-end time in ms (end-to-end)={}".format((end - start)*1000)) 
+print(end - start)
+print(
+    "python Directed Hausdorff distance GPU end-to-end time in ms (end-to-end)={}".format(
+        (end - start) * 1000
+    )
+)
 
 start = time.time()
-cuspatial_dist=dist.data.to_array().reshape((num_traj,num_traj))
+cuspatial_dist = dist.data.to_array().reshape((num_traj, num_traj))
 print("num_traj={}".format(num_traj))
 print("cuspatial_dist[0[1]={}".format(cuspatial_dist[0][1]))
 
-#with open(cuspatial_res, 'wb') as f:
+# with open(cuspatial_res, 'wb') as f:
 #        pickle.dump(cuspatial_dist, f)
 
-mis_match=0
+mis_match = 0
 for i in range(num_traj):
- for j in range(num_traj):
-  if(abs(cuspatial_dist0[i][j]-cuspatial_dist[i][j])>0.00001):
-   mis_match=mis_match+1
-print('mis_match between two rounds ={}'.format(mis_match))
+    for j in range(num_traj):
+        if abs(cuspatial_dist0[i][j] - cuspatial_dist[i][j]) > 0.00001:
+            mis_match = mis_match + 1
+print("mis_match between two rounds ={}".format(mis_match))
 
 
-x=pnt_x.data.to_array()
-y=pnt_y.data.to_array()
-n=cnt.data.to_array()
-end = time.time()  
-print("data conversion time={}".format((end - start)*1000)) 
+x = pnt_x.data.to_array()
+y = pnt_y.data.to_array()
+n = cnt.data.to_array()
+end = time.time()
+print("data conversion time={}".format((end - start) * 1000))
 
 start = time.time()
-trajs=[]
-c=0
+trajs = []
+c = 0
 for i in range(num_traj):
- traj=np.zeros((n[i],2),dtype=np.float64)
- for j in range(n[i]):
-  traj[j][0]=x[c+j]
-  traj[j][1]=y[c+j]
- trajs.append(traj.reshape(-1,2))
- c=c+n[i]
-#print('c={}'.format(c))
-end=time.time()
-print("CPU traj prep time={}".format((end - start)*1000)) 
-#print("trajs[0]")
-#print(trajs[0])
-
-mis_match=0
-d=np.zeros((num_traj,num_traj), dtype=np.float64)
+    traj = np.zeros((n[i], 2), dtype=np.float64)
+    for j in range(n[i]):
+        traj[j][0] = x[c + j]
+        traj[j][1] = y[c + j]
+    trajs.append(traj.reshape(-1, 2))
+    c = c + n[i]
+# print('c={}'.format(c))
+end = time.time()
+print("CPU traj prep time={}".format((end - start) * 1000))
+# print("trajs[0]")
+# print(trajs[0])
+
+mis_match = 0
+d = np.zeros((num_traj, num_traj), dtype=np.float64)
 for i in range(num_traj):
- if(i%100==99):
-  print("i={}".format(i))
- for j in range(num_traj):
-  dij=directed_hausdorff(trajs[i],trajs[j])
-  d[i][j]=dij[0]
-  if(abs(d[i][j]-cuspatial_dist[i][j])>0.00001):
-   print('{} {} {} {}'.format(i,j,d[i][j],cuspatial_dist[i][j]))
-   mis_match=mis_match+1
-print('mis_match={}'.format(mis_match))  
-end = time.time()  
-print("python Directed Hausdorff distance cpu end-to-end time in ms (end-to-end)={}".format((end - start)*1000)) 
-
-#for val in d[0]:
+    if i % 100 == 99:
+        print("i={}".format(i))
+    for j in range(num_traj):
+        dij = directed_hausdorff(trajs[i], trajs[j])
+        d[i][j] = dij[0]
+        if abs(d[i][j] - cuspatial_dist[i][j]) > 0.00001:
+            print("{} {} {} {}".format(i, j, d[i][j], cuspatial_dist[i][j]))
+            mis_match = mis_match + 1
+print("mis_match={}".format(mis_match))
+end = time.time()
+print(
+    "python Directed Hausdorff distance cpu end-to-end time in ms (end-to-end)={}".format(
+        (end - start) * 1000
+    )
+)
+
+# for val in d[0]:
 # print('{}'.format(val))
-#print
+# print
 
-#with open(scipy_res, 'wb') as f:
+# with open(scipy_res, 'wb') as f:
 #        pickle.dump(d, f)
-        
\ No newline at end of file
diff --git a/python/cuspatial/cuspatial/demos/haversine_distance_test_nyctaxi.py b/python/cuspatial/cuspatial/demos/haversine_distance_test_nyctaxi.py
index 59b6a0d24..02280a47a 100644
--- a/python/cuspatial/cuspatial/demos/haversine_distance_test_nyctaxi.py
+++ b/python/cuspatial/cuspatial/demos/haversine_distance_test_nyctaxi.py
@@ -1,25 +1,25 @@
 import time
 import cudf
-from cudf.dataframe import columnops
+from cudf.core import column
 import cuspatial.bindings.spatial as gis
 
 start = time.time()
-#data dowloaded from https://s3.amazonaws.com/nyc-tlc/trip+data/yellow_tripdata_2009-01.csv
+# data dowloaded from https://s3.amazonaws.com/nyc-tlc/trip+data/yellow_tripdata_2009-01.csv
 df = cudf.read_csv("/home/jianting/hardbd19/data/nyctaxi/yellow_tripdata_2009-01.csv")
 end = time.time()
-print("data ingesting time (from SSD) in ms={}".format((end - start)*1000)) 
+print("data ingesting time (from SSD) in ms={}".format((end - start) * 1000))
 df.head().to_pandas().columns
 
 start = time.time()
-x1=columnops.as_column(df['Start_Lon'])
-y1=columnops.as_column(df['Start_Lat'])
-x2=columnops.as_column(df['End_Lon'])
-y2=columnops.as_column(df['End_Lat'])
+x1 = column.as_column(df["Start_Lon"])
+y1 = column.as_column(df["Start_Lat"])
+x2 = column.as_column(df["End_Lon"])
+y2 = column.as_column(df["End_Lat"])
 end = time.time()
-print("data frame to gdf column conversion time in ms={}".format((end - start)*1000)) 
+print("data frame to gdf column conversion time in ms={}".format((end - start) * 1000))
 
 start = time.time()
-h_dist=gis.cpp_haversine_distance(x1,y1,x2,y1)
+h_dist = gis.cpp_haversine_distance(x1, y1, x2, y1)
 end = time.time()
-print("python computing distance time in ms={}".format((end - start)*1000)) 
-#h_dist.data.to_array()
\ No newline at end of file
+print("python computing distance time in ms={}".format((end - start) * 1000))
+# h_dist.data.to_array()
diff --git a/python/cuspatial/cuspatial/demos/pip_test_gdal_locust.py b/python/cuspatial/cuspatial/demos/pip_test_gdal_locust.py
index 1818e77d2..4b08a6e0d 100644
--- a/python/cuspatial/cuspatial/demos/pip_test_gdal_locust.py
+++ b/python/cuspatial/cuspatial/demos/pip_test_gdal_locust.py
@@ -4,35 +4,38 @@
 under cudef_dev environment 
 """
 
-import numpy as np 
+import numpy as np
 from osgeo import ogr
 
-data_dir="/home/jianting/cuspatial/data/"
-shapefile =data_dir+"its_4326_roi.shp"
+data_dir = "/home/jianting/cuspatial/data/"
+shapefile = data_dir + "its_4326_roi.shp"
 driver = ogr.GetDriverByName("ESRI Shapefile")
 spatialReference = ogr.osr.SpatialReference()
 spatialReference.SetWellKnownGeogCS("WGS84")
 pt = ogr.Geometry(ogr.wkbPoint)
 pt.AssignSpatialReference(spatialReference)
-pnt_x=np.array([ -90.666418409895840,-90.665136925928721,-90.671840534675397],dtype=np.float64)
-pnt_y=np.array([42.492199401857071 ,42.492104092138952,42.490649501411141],dtype=np.float64)
+pnt_x = np.array(
+    [-90.666418409895840, -90.665136925928721, -90.671840534675397], dtype=np.float64
+)
+pnt_y = np.array(
+    [42.492199401857071, 42.492104092138952, 42.490649501411141], dtype=np.float64
+)
 
 for i in range(3):
- pt.SetPoint(0,pnt_x[i],pnt_y[i])
- res=''
+    pt.SetPoint(0, pnt_x[i], pnt_y[i])
+    res = ""
 
- """
+    """
  features can not be saved for later reuse
  known issue: https://trac.osgeo.org/gdal/wiki/PythonGotchas
  """
 
- dataSource = driver.Open(shapefile, 0)
- layer = dataSource.GetLayer()
- for f in layer:
-  pip= pt.Within(f.geometry())
-  if(pip):
-   res+='1'
-  else: 
-   res+='0'
- print(res)
-  
\ No newline at end of file
+    dataSource = driver.Open(shapefile, 0)
+    layer = dataSource.GetLayer()
+    for f in layer:
+        pip = pt.Within(f.geometry())
+        if pip:
+            res += "1"
+        else:
+            res += "0"
+    print(res)
diff --git a/python/cuspatial/cuspatial/demos/pip_test_shapely_locust.py b/python/cuspatial/cuspatial/demos/pip_test_shapely_locust.py
index 950c70ab9..5f36f586f 100644
--- a/python/cuspatial/cuspatial/demos/pip_test_shapely_locust.py
+++ b/python/cuspatial/cuspatial/demos/pip_test_shapely_locust.py
@@ -6,29 +6,33 @@
 under cudef_dev environment 
 """
 
-import numpy as np 
+import numpy as np
 from shapely.geometry import Polygon, Point
 from shapely.geometry import shape
 import shapefile
 
-data_dir="/home/jianting/cuspatial/data/"
+data_dir = "/home/jianting/cuspatial/data/"
 
-plyreader = shapefile.Reader(data_dir+"its_4326_roi.shp")
-polygon = plyreader.shapes() 
-plys=[]
+plyreader = shapefile.Reader(data_dir + "its_4326_roi.shp")
+polygon = plyreader.shapes()
+plys = []
 for shape in polygon:
- plys.append(Polygon(shape.points)) 
+    plys.append(Polygon(shape.points))
 
-pnt_x=np.array([ -90.666418409895840,-90.665136925928721,-90.671840534675397],dtype=np.float64)
-pnt_y=np.array([42.492199401857071 ,42.492104092138952,42.490649501411141],dtype=np.float64)
+pnt_x = np.array(
+    [-90.666418409895840, -90.665136925928721, -90.671840534675397], dtype=np.float64
+)
+pnt_y = np.array(
+    [42.492199401857071, 42.492104092138952, 42.490649501411141], dtype=np.float64
+)
 
 for i in range(3):
- pt=Point(pnt_x[i],pnt_y[i])
- res=''
- for j in range(len(plys)):
-  pip= plys[len(plys)-1-j].contains(pt)
-  if(pip):
-   res+='1'
-  else: 
-   res+='0'
- print(res)
+    pt = Point(pnt_x[i], pnt_y[i])
+    res = ""
+    for j in range(len(plys)):
+        pip = plys[len(plys) - 1 - j].contains(pt)
+        if pip:
+            res += "1"
+        else:
+            res += "0"
+    print(res)
diff --git a/python/cuspatial/cuspatial/demos/pip_verify_shapely_locust.py b/python/cuspatial/cuspatial/demos/pip_verify_shapely_locust.py
index da1feae0b..af643c790 100644
--- a/python/cuspatial/cuspatial/demos/pip_verify_shapely_locust.py
+++ b/python/cuspatial/cuspatial/demos/pip_verify_shapely_locust.py
@@ -8,44 +8,44 @@
 import time
 import cuspatial.bindings.spatial as gis
 import cuspatial.bindings.soa_readers as readers
-from cudf.dataframe import columnops
+from cudf.core import column
 from shapely.geometry import Polygon, Point
 from shapely.geometry import shape
 import shapefile
 
-data_dir="/home/jianting/cuspatial/data/"
-plyreader = shapefile.Reader(data_dir+"its_4326_roi.shp")
-polygon = plyreader.shapes() 
-plys=[]
+data_dir = "/home/jianting/cuspatial/data/"
+plyreader = shapefile.Reader(data_dir + "its_4326_roi.shp")
+polygon = plyreader.shapes()
+plys = []
 for shape in polygon:
- plys.append(Polygon(shape.points)) 
+    plys.append(Polygon(shape.points))
 
-pnt_lon,pnt_lat=readers.cpp_read_pnt_lonlat_soa(data_dir+"locust.location");
-fpos,rpos,plyx,plyy=readers.cpp_read_ply_soa(data_dir+"itsroi.ply")
+pnt_lon, pnt_lat = readers.cpp_read_pnt_lonlat_soa(data_dir + "locust.location")
+fpos, rpos, plyx, plyy = readers.cpp_read_ply_soa(data_dir + "itsroi.ply")
 
 start = time.time()
-bm=gis.cpp_pip_bm(pnt_lon,pnt_lat,fpos,rpos,plyx,plyy)
+bm = gis.cpp_pip_bm(pnt_lon, pnt_lat, fpos, rpos, plyx, plyy)
 end = time.time()
-print("Python GPU Time in ms (end-to-end)={}".format((end - start)*1000)) 
+print("Python GPU Time in ms (end-to-end)={}".format((end - start) * 1000))
 
-bma=bm.data.to_array()
-pntx=pnt_lon.data.to_array()
-pnty=pnt_lat.data.to_array()
+bma = bm.data.to_array()
+pntx = pnt_lon.data.to_array()
+pnty = pnt_lat.data.to_array()
 
 start = time.time()
-mis_match=0
+mis_match = 0
 for i in range(pnt_lon.data.size):
- pt=Point(pntx[i],pnty[i])
- res=0
- for j in range(len(plys)):
-  pip= plys[len(plys)-1-j].contains(pt)
-  if(pip):
-   res|=(0x01<<(len(plys)-1-j))
- if (res!=bma[i]):
-  mis_match=mis_match+1
+    pt = Point(pntx[i], pnty[i])
+    res = 0
+    for j in range(len(plys)):
+        pip = plys[len(plys) - 1 - j].contains(pt)
+        if pip:
+            res |= 0x01 << (len(plys) - 1 - j)
+    if res != bma[i]:
+        mis_match = mis_match + 1
 
 end = time.time()
-print(end - start)  
-print("python(shapely) CPU Time in ms (end-to-end)={}".format((end - start)*1000)) 
+print(end - start)
+print("python(shapely) CPU Time in ms (end-to-end)={}".format((end - start) * 1000))
 
 print("CPU and GPU results mismatch={}".format(mis_match))
diff --git a/python/cuspatial/cuspatial/demos/stq_test_soa_locust.py b/python/cuspatial/cuspatial/demos/stq_test_soa_locust.py
index 28551940c..ae9ac2aa1 100644
--- a/python/cuspatial/cuspatial/demos/stq_test_soa_locust.py
+++ b/python/cuspatial/cuspatial/demos/stq_test_soa_locust.py
@@ -6,16 +6,16 @@
 
 import numpy as np
 import pandas as pd
-import cuspatial.bindings.traj as traj
+import cuspatial.bindings.trajectory as traj
 import cuspatial.bindings.stq as stq
 import cuspatial.bindings.soa_readers as readers
-from cudf.dataframe import columnops
+from cudf.core import column
 import cudf
 
-data_dir="/home/jianting/cuspatial/data/"
-pnt_lon,pnt_lat=readers.cpp_read_pnt_lonlat_soa(data_dir+"locust.location");
-num,nlon,nlat=stq.cpp_sw_xy(np.double(-180),np.double(180),np.double(-90),np.double(90),pnt_lon,pnt_lat)
+data_dir = "/home/jianting/cuspatial/data/"
+pnt_lon, pnt_lat = readers.cpp_read_pnt_lonlat_soa(data_dir + "locust.location")
+num, nlon, nlat = stq.cpp_sw_xy(
+    np.double(-180), np.double(180), np.double(-90), np.double(90), pnt_lon, pnt_lat
+)
 print(num)
 print(pnt_lon.data.size)
-
-	
diff --git a/python/cuspatial/cuspatial/demos/traj_test_soa_locust.py b/python/cuspatial/cuspatial/demos/traj_test_soa_locust.py
index 29ebb6b3b..2a90a02f7 100644
--- a/python/cuspatial/cuspatial/demos/traj_test_soa_locust.py
+++ b/python/cuspatial/cuspatial/demos/traj_test_soa_locust.py
@@ -6,36 +6,41 @@
 import numpy as np
 import pandas as pd
 import cuspatial.bindings.spatial as gis
-import cuspatial.bindings.traj as traj
+import cuspatial.bindings.trajectory as traj
 import cuspatial.bindings.soa_readers as readers
 import cuspatial.utils.traj_utils as tools
 
-data_dir="/home/jianting/cuspatial/data/"
-df = pd.read_csv(data_dir+"its_camera_2.csv")
-this_cam=df.loc[df["cameraIdString"] == 'HWY_20_AND_LOCUST']
-cam_lon= np.double(this_cam.iloc[0]['originLon'])
-cam_lat=np.double(this_cam.iloc[0]['originLat'])
+data_dir = "/home/jianting/cuspatial/data/"
+df = pd.read_csv(data_dir + "its_camera_2.csv")
+this_cam = df.loc[df["cameraIdString"] == "HWY_20_AND_LOCUST"]
+cam_lon = np.double(this_cam.iloc[0]["originLon"])
+cam_lat = np.double(this_cam.iloc[0]["originLat"])
 
-pnt_lon,pnt_lat=readers.cpp_read_pnt_lonlat_soa(data_dir+"locust.location");
-id=readers.cpp_read_uint_soa(data_dir+"locust.objectid")
-ts=readers.cpp_read_ts_soa(data_dir+"locust.time")
+pnt_lon, pnt_lat = readers.cpp_read_pnt_lonlat_soa(data_dir + "locust.location")
+id = readers.cpp_read_uint_soa(data_dir + "locust.objectid")
+ts = readers.cpp_read_ts_soa(data_dir + "locust.time")
 
-#examine binary representatons 
-ts_0=ts.data.to_array()[0]
-out1=format(ts_0,'016x')
+# examine binary representatons
+ts_0 = ts.data.to_array()[0]
+out1 = format(ts_0, "016x")
 print(out1)
-out2=format(ts_0,'064b')
+out2 = format(ts_0, "064b")
 print(out2)
 
-y,m,d,hh,mm,ss,wd,yd,ms,pid=tools.get_ts_struct(ts_0)
+y, m, d, hh, mm, ss, wd, yd, ms, pid = tools.get_ts_struct(ts_0)
 
-pnt_x,pnt_y=gis.cpp_lonlat2coord(cam_lon,cam_lat,pnt_lon,pnt_lat)
-num_traj, tid,len,pos=traj.cpp_coord2traj(pnt_x,pnt_y,id,ts)
+pnt_x, pnt_y = gis.cpp_lonlat2coord(cam_lon, cam_lat, pnt_lon, pnt_lat)
+num_traj, tid, len, pos = traj.cpp_coord2traj(pnt_x, pnt_y, id, ts)
 
-y,m,d,hh,mm,ss,wd,yd,ms,pid=tools.get_ts_struct(ts_0)
+y, m, d, hh, mm, ss, wd, yd, ms, pid = tools.get_ts_struct(ts_0)
 
-dist,speed=traj.cpp_traj_distspeed(pnt_x,pnt_y,ts,len,pos)
-print(dist.data.to_array()[0],speed.data.to_array()[0])
+dist, speed = traj.cpp_traj_distspeed(pnt_x, pnt_y, ts, len, pos)
+print(dist.data.to_array()[0], speed.data.to_array()[0])
 
-x1,y1,x2,y2=traj.cpp_traj_sbbox(pnt_x,pnt_y,len,pos)
-print(x1.data.to_array()[0],x2.data.to_array()[0],y1.data.to_array()[0],y2.data.to_array()[0])
+x1, y1, x2, y2 = traj.cpp_traj_sbbox(pnt_x, pnt_y, len, pos)
+print(
+    x1.data.to_array()[0],
+    x2.data.to_array()[0],
+    y1.data.to_array()[0],
+    y2.data.to_array()[0],
+)
diff --git a/python/cuspatial/cuspatial/tests/hausdorff_distance_test_toy.py b/python/cuspatial/cuspatial/tests/hausdorff_distance_test_toy.py
index f9e0998c6..c3e99cfbf 100644
--- a/python/cuspatial/cuspatial/tests/hausdorff_distance_test_toy.py
+++ b/python/cuspatial/cuspatial/tests/hausdorff_distance_test_toy.py
@@ -5,12 +5,12 @@
 
 import numpy as np
 import time
-from cudf.dataframe import columnops
+from cudf.core import column
 import cuspatial.bindings.spatial as gis
 
-pnt_x=columnops.as_column(np.array([0,-8,6],dtype=np.float64))
-pnt_y=columnops.as_column(np.array([0,-8,6],dtype=np.float64))
-cnt=columnops.as_column(np.array([1,2],dtype=np.int32))
+pnt_x=column.as_column(np.array([0,-8,6],dtype=np.float64))
+pnt_y=column.as_column(np.array([0,-8,6],dtype=np.float64))
+cnt=column.as_column(np.array([1,2],dtype=np.int32))
 num_set=len(cnt)
 matrix=gis.cpp_directed_hausdorff_distance(pnt_x,pnt_y,cnt)
 d=matrix.data.to_array().reshape((num_set,num_set))
diff --git a/python/cuspatial/cuspatial/tests/haversine_distance_test_toy.py b/python/cuspatial/cuspatial/tests/haversine_distance_test_toy.py
index 4ad26e372..9627fd9a2 100644
--- a/python/cuspatial/cuspatial/tests/haversine_distance_test_toy.py
+++ b/python/cuspatial/cuspatial/tests/haversine_distance_test_toy.py
@@ -7,7 +7,7 @@
 
 import numpy as np
 import time
-from cudf.dataframe import columnops
+from cudf.core import column
 import cuspatial.bindings.spatial as gis
 
 cities=[]
@@ -24,10 +24,10 @@
   pnt_y1.append(cities[i][2])
   pnt_x2.append(cities[j][1])
   pnt_y2.append(cities[j][2])
-x1=columnops.as_column(pnt_x1,dtype=np.float64)
-y1=columnops.as_column(pnt_y1,dtype=np.float64)
-x2=columnops.as_column(pnt_x2,dtype=np.float64)
-y2=columnops.as_column(pnt_y2,dtype=np.float64)
+x1=column.as_column(pnt_x1,dtype=np.float64)
+y1=column.as_column(pnt_y1,dtype=np.float64)
+x2=column.as_column(pnt_x2,dtype=np.float64)
+y2=column.as_column(pnt_y2,dtype=np.float64)
 dis=gis.cpp_haversine_distance(x1,y1,x2,y2)
 dis.data.to_array().reshape(3,3)
 
diff --git a/python/cuspatial/cuspatial/tests/lonlat2coord_test_toy.py b/python/cuspatial/cuspatial/tests/lonlat2coord_test_toy.py
index bdd9bea2c..2e8a97984 100644
--- a/python/cuspatial/cuspatial/tests/lonlat2coord_test_toy.py
+++ b/python/cuspatial/cuspatial/tests/lonlat2coord_test_toy.py
@@ -4,8 +4,9 @@
 Note:  make sure cudf_dev conda environment is activated
 """
 
+import cudf
 import numpy as np
-from cudf.dataframe import columnops
+import cudf.core.column as column
 import cuspatial.bindings.spatial as gis
 
 cam_lon= np.double(-90.66511046)
@@ -13,10 +14,12 @@
 
 py_lon=[-90.66518941, -90.66540743, -90.66489239]
 py_lat=[42.49207437, 42.49202408,42.49266787]
-pnt_lon=columnops.as_column(py_lon,dtype=np.float64)
-pnt_lat=columnops.as_column(py_lat,dtype=np.float64)
+pnt_lon=column.as_column(py_lon,dtype=np.float64)
+pnt_lat=column.as_column(py_lat,dtype=np.float64)
 
 #note: x/y coordinates in killometers -km 
 x,y=gis.cpp_lonlat2coord(cam_lon,cam_lat,pnt_lon,pnt_lat)
 x.data.to_array()
-y.data.to_array()
\ No newline at end of file
+y.data.to_array()
+print(cudf.Series(x))
+print(cudf.Series(y))
diff --git a/python/cuspatial/cuspatial/tests/pip_test_soa_toy.py b/python/cuspatial/cuspatial/tests/pip_test_soa_toy.py
index 7503c8e97..0d80e39ac 100644
--- a/python/cuspatial/cuspatial/tests/pip_test_soa_toy.py
+++ b/python/cuspatial/cuspatial/tests/pip_test_soa_toy.py
@@ -5,18 +5,18 @@
 """
 
 import numpy as np
-from cudf.dataframe import columnops
+import cudf.core.column as column
 import cuspatial.bindings.spatial as gis
 
-pnt_x=columnops.as_column(np.array([0,-8,6],dtype=np.float64))
-pnt_y=columnops.as_column(np.array([0,-8,6],dtype=np.float64))
+pnt_x=column.as_column(np.array([0,-8,6],dtype=np.float64))
+pnt_y=column.as_column(np.array([0,-8,6],dtype=np.float64))
 
-ply_fpos=columnops.as_column(np.array([1, 2],dtype=np.int32))
-ply_rpos=columnops.as_column(np.array([5, 10],dtype=np.int32))
-ply_x=columnops.as_column(np.array([-10,   5, 5, -10, -10,  0, 10, 10,  0, 0],dtype=np.float64))
-ply_y=columnops.as_column(np.array([-10, -10, 5,   5, -10,  0,  0, 10, 10, 0],dtype=np.float64))
+ply_fpos=column.as_column(np.array([1, 2],dtype=np.int32))
+ply_rpos=column.as_column(np.array([5, 10],dtype=np.int32))
+ply_x=column.as_column(np.array([-10,   5, 5, -10, -10,  0, 10, 10,  0, 0],dtype=np.float64))
+ply_y=column.as_column(np.array([-10, -10, 5,   5, -10,  0,  0, 10, 10, 0],dtype=np.float64))
 
-bm=gis.cpp_pip_bm(pnt_x,pnt_y,ply_fpos,ply_rpos,ply_x,ply_y)
+bm=gis.cpp_point_in_polygon_bitmap(pnt_x,pnt_y,ply_fpos,ply_rpos,ply_x,ply_y)
 bma=bm.data.to_array()
 #look into binary represenation in Python of the resulting bitmap
 print(np.binary_repr(bma[0], width=ply_fpos.data.size))
diff --git a/python/cuspatial/cuspatial/tests/test_hausdorff_distance.py b/python/cuspatial/cuspatial/tests/test_hausdorff_distance.py
new file mode 100644
index 000000000..73c5e8abb
--- /dev/null
+++ b/python/cuspatial/cuspatial/tests/test_hausdorff_distance.py
@@ -0,0 +1,120 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.
+
+"""
+A toy example to demonstrate how to convert python arrays into cuSpatial inputs,
+invoke the GPU accelerated directed Hausdorff distance computing function in
+cuSpatial, convert the results back to python array(s) again to be feed into 
+scipy clustering APIs.
+
+For the toy example, by desgin, both AgglomerativeClustering and DBSCAN cluster 
+the 2nd and third trajectories into one cluster while leaving the first 
+trajectory as the second cluster. 
+
+To run the demo, first install scipy and scikit-learn
+by "conda install -c conda-forge scipy scikit-learn"  under cudf_dev environment
+"""
+
+import pytest
+import numpy as np
+import time
+import cudf
+from cudf.tests.utils import assert_eq
+from cudf.core import column
+import cuspatial.bindings.spatial as gis
+
+def test_zeros():
+    distance = gis.cpp_directed_hausdorff_distance(
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+        cudf.Series([1])
+    )
+    assert cudf.Series(distance)[0] == 0
+
+def test_empty_x():
+    with pytest.raises(RuntimeError):
+        distance = gis.cpp_directed_hausdorff_distance(
+            cudf.Series(),
+            cudf.Series([0]),
+            cudf.Series([0])
+        )
+
+def test_empty_y():
+    with pytest.raises(RuntimeError):
+        distance = gis.cpp_directed_hausdorff_distance(
+            cudf.Series([0]),
+            cudf.Series(),
+            cudf.Series([0])
+        )
+
+def test_empty_counts():
+    with pytest.raises(RuntimeError):
+        distance = gis.cpp_directed_hausdorff_distance(
+            cudf.Series([0]),
+            cudf.Series([0]),
+            cudf.Series()
+        )
+
+def test_large():
+    in_trajs=[]
+    in_trajs.append(np.array([[0,0],[1,0]]))
+    in_trajs.append(np.array([[0,-1],[1,-1]]))
+    out_trajs = np.concatenate([np.asarray(traj) for traj in in_trajs],0)
+    py_x=np.array(out_trajs[:,0])
+    py_y=np.array(out_trajs[:,1])
+    py_cnt = []
+    for traj in in_trajs:
+     py_cnt.append(len(traj))
+    pnt_x = cudf.Series(py_x)
+    pnt_y = cudf.Series(py_y)
+    cnt = cudf.Series(py_cnt)
+    distance=gis.cpp_directed_hausdorff_distance(pnt_x,pnt_y,cnt)
+
+    num_set=len(cnt)
+    matrix=distance.data.to_array().reshape(num_set,num_set)
+    expect = np.array([0, 1, 1, 0])
+    assert np.allclose(distance.data.to_array(), expect)
+
+def test_count_one():
+    distance = gis.cpp_directed_hausdorff_distance(
+            cudf.Series([0.0, 0.0]),
+            cudf.Series([0.0, 1.0]),
+            cudf.Series([1, 1]))
+    assert_eq(cudf.Series([0, 1.0, 1, 0]), cudf.Series(distance))
+
+def test_count_two():
+    distance = gis.cpp_directed_hausdorff_distance(
+            cudf.Series([0.0, 0.0, 1.0, 0.0]),
+            cudf.Series([0.0, -1.0, 1.0, -1.0]),
+            cudf.Series([2, 2]))
+    print(cudf.Series(distance))
+    assert_eq(cudf.Series([0.0, 1, 1.4142135623730951, 0]),
+              cudf.Series(distance))
+
+def test_values():
+    in_trajs=[]
+    in_trajs.append(np.array([[1,0],[2,1],[3,2],[5,3],[7,1]]))
+    in_trajs.append(np.array([[0,3],[2,5],[3,6],[6,5]]))
+    in_trajs.append(np.array([[1,4],[3,7],[6,4]]))
+    out_trajs = np.concatenate([np.asarray(traj) for traj in in_trajs],0)
+    py_x=np.array(out_trajs[:,0])
+    py_y=np.array(out_trajs[:,1])
+    py_cnt = []
+    for traj in in_trajs:
+     py_cnt.append(len(traj))
+    pnt_x =cudf.Series(py_x)
+    pnt_y= cudf.Series(py_y)
+    cnt= cudf.Series(py_cnt)
+    distance=gis.cpp_directed_hausdorff_distance(pnt_x,pnt_y,cnt)
+
+    num_set=len(cnt)
+    matrix=distance.data.to_array().reshape(num_set,num_set)
+    expect = np.array([
+        0, 4.12310563, 4.0,
+        3.60555128,  0.0, 1.41421356,
+        4.47213595,1.41421356, 0.0])
+    assert np.allclose(distance.data.to_array(), expect)
+
+# def test_count_1():
+# def test_count_2():
+# def test_mismatched_x_y():
+# def test_count_greater_than_x():
diff --git a/python/cuspatial/cuspatial/tests/test_haversine_distance.py b/python/cuspatial/cuspatial/tests/test_haversine_distance.py
new file mode 100644
index 000000000..06b4ebfd2
--- /dev/null
+++ b/python/cuspatial/cuspatial/tests/test_haversine_distance.py
@@ -0,0 +1,85 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.
+
+"""
+GPU-accelerated Haversine distance computation among three cities: New York, Paris and Sydney
+Results match https://www.vcalc.com/wiki/vCalc/Haversine+-+Distance
+
+Note: make sure cudf_dev conda environment is activated
+"""
+
+import pytest
+import numpy as np
+import cudf
+from cudf.core import column
+from cudf.tests.utils import assert_eq
+import cuspatial.bindings.spatial as gis
+
+def test_zeros():
+    distance = gis.cpp_haversine_distance(
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+    )
+    assert cudf.Series(distance)[0] == 0
+
+def test_empty_x1():
+    with pytest.raises(RuntimeError):
+        distance = gis.cpp_haversine_distance(
+            cudf.Series(),
+            cudf.Series([0]),
+            cudf.Series([0]),
+            cudf.Series([0]),
+        )
+
+def test_empty_y1():
+    with pytest.raises(RuntimeError):
+        distance = gis.cpp_haversine_distance(
+            cudf.Series([0]),
+            cudf.Series(),
+            cudf.Series([0]),
+            cudf.Series([0]),
+        )
+
+def test_empty_x2():
+    with pytest.raises(RuntimeError):
+        distance = gis.cpp_haversine_distance(
+            cudf.Series([0]),
+            cudf.Series([0]),
+            cudf.Series([0]),
+            cudf.Series(),
+        )
+
+def test_empty_y2():
+    with pytest.raises(RuntimeError):
+        distance = gis.cpp_haversine_distance(
+            cudf.Series([0]),
+            cudf.Series([0]),
+            cudf.Series([0]),
+            cudf.Series(),
+        )
+
+def test_triple():
+    cities = cudf.DataFrame({
+        'New York': [-74.0060,40.7128],
+        'Paris': [2.3522,48.8566],
+        'Sydney': [151.2093,-33.8688]
+    })
+    cities = cities.set_index(['lat', 'lon'])
+    pnt_x1 = []
+    pnt_y1 = []
+    pnt_x2 = []
+    pnt_y2 = []
+    for i in cities:
+        for j in cities:
+            pnt_x1.append(cities[i][0])
+            pnt_y1.append(cities[i][1])
+            pnt_x2.append(cities[j][0])
+            pnt_y2.append(cities[j][1])
+    distance = gis.cpp_haversine_distance(
+        cudf.Series(pnt_x1),
+        cudf.Series(pnt_y1),
+        cudf.Series(pnt_x2),
+        cudf.Series(pnt_y2)
+    )
+    assert np.allclose(distance.to_array(), [[0.0, 5.83724090e+03, 1.59887555e+04, 5.83724090e+03, 0.0, 1.69604974e+04, 1.59887555e+04, 1.69604974e+04, 0.0]])
diff --git a/python/cuspatial/cuspatial/tests/test_lonlat2coord.py b/python/cuspatial/cuspatial/tests/test_lonlat2coord.py
new file mode 100644
index 000000000..effe89925
--- /dev/null
+++ b/python/cuspatial/cuspatial/tests/test_lonlat2coord.py
@@ -0,0 +1,98 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.
+
+import pytest
+import cudf
+from cudf.tests.utils import assert_eq
+import numpy as np
+import cuspatial.bindings.spatial as gis
+
+"""
+GPU accelerated coordinate transformation test: (log/lat)==>(x/y), relative to a camera origin
+
+Note:  make sure cudf_dev conda environment is activated
+"""
+
+def test_camera_oob_0():
+    with pytest.raises(RuntimeError):
+        x, y = gis.cpp_lonlat2coord(-200, 0,
+            cudf.Series([0]),
+            cudf.Series([0])
+        )
+
+def test_camera_oob_1():
+    with pytest.raises(RuntimeError):
+        x, y = gis.cpp_lonlat2coord(200, 0,
+            cudf.Series([0]),
+            cudf.Series([0])
+        )
+
+def test_camera_oob_2():
+    with pytest.raises(RuntimeError):
+        x, y = gis.cpp_lonlat2coord(0, -100,
+            cudf.Series([0]),
+            cudf.Series([0])
+        )
+
+def test_camera_oob_3():
+    with pytest.raises(RuntimeError):
+        x, y = gis.cpp_lonlat2coord(0, 100,
+            cudf.Series([0]),
+            cudf.Series([0])
+        )
+
+@pytest.mark.parametrize("corner", [0, 1, 2, 3])
+def test_camera_corners(corner):
+    x = [-180, 180, -180, 180]
+    y = [-90, 90, 90, -90]
+    x, y = gis.cpp_lonlat2coord(x[corner], y[corner],
+        cudf.Series(x[corner]),
+        cudf.Series(y[corner])
+    )
+    assert x[0] == 0
+    assert y[0] == 0
+
+def test_longest_distance():
+    x, y = gis.cpp_lonlat2coord(-180, -90,
+        cudf.Series([180]),
+        cudf.Series([90])
+    )
+    assert x[0] == -40000.0
+    assert y[0] == -20000.0
+
+def test_half_distance():
+    x, y = gis.cpp_lonlat2coord(-180, -90,
+        cudf.Series([0]),
+        cudf.Series([0])
+    )
+    assert x[0] == -14142.135623730952
+    assert y[0] == -10000.0
+
+def test_missing_coords():
+    with pytest.raises(RuntimeError):
+        x, y = gis.cpp_lonlat2coord(-180, -90,
+            cudf.Series(),
+            cudf.Series([0])
+        )
+
+def test_zeros():
+    coords_x, coords_y = gis.cpp_lonlat2coord(
+        0.0,
+        0.0,
+        cudf.Series([0.0]),
+        cudf.Series([0.0])
+    )
+    assert_eq(cudf.Series(coords_x), cudf.Series(coords_y))
+    assert cudf.Series(coords_x)[0] == 0
+    assert cudf.Series(coords_y)[0] == 0
+
+def test_values():
+    cam_lon = -90.66511046
+    cam_lat = 42.49197018
+
+    py_lon=cudf.Series([-90.66518941, -90.66540743, -90.66489239])
+    py_lat=cudf.Series([42.49207437, 42.49202408,42.49266787])
+
+    #note: x/y coordinates in killometers -km 
+    x,y=gis.cpp_lonlat2coord(cam_lon, cam_lat, py_lon, py_lat)
+    print(cudf.Series(x))
+    print(cudf.Series(y))
diff --git a/python/cuspatial/cuspatial/tests/test_pip.py b/python/cuspatial/cuspatial/tests/test_pip.py
new file mode 100644
index 000000000..a485626d9
--- /dev/null
+++ b/python/cuspatial/cuspatial/tests/test_pip.py
@@ -0,0 +1,121 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.
+
+import pytest
+import cudf
+from cudf.tests.utils import assert_eq
+import numpy as np
+import cuspatial.bindings.spatial as gis
+
+def test_missing_0():
+    with pytest.raises(RuntimeError):
+        result = gis.cpp_point_in_polygon_bitmap(
+            cudf.Series(),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0])
+        )
+
+def test_missing_1():
+    with pytest.raises(RuntimeError):
+        result = gis.cpp_point_in_polygon_bitmap(
+            cudf.Series([0.0]),
+            cudf.Series(),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0])
+        )
+
+def test_missing_2():
+    with pytest.raises(RuntimeError):
+        result = gis.cpp_point_in_polygon_bitmap(
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series(),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0])
+        )
+
+def test_missing_3():
+    with pytest.raises(RuntimeError):
+        result = gis.cpp_point_in_polygon_bitmap(
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series(),
+            cudf.Series([0.0]),
+            cudf.Series([0.0])
+        )
+
+def test_missing_4():
+    with pytest.raises(RuntimeError):
+        result = gis.cpp_point_in_polygon_bitmap(
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series(),
+            cudf.Series([0.0])
+        )
+
+def test_missing_5():
+    with pytest.raises(RuntimeError):
+        result = gis.cpp_point_in_polygon_bitmap(
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series([0.0]),
+            cudf.Series()
+        )
+
+def test_zeros():
+    result = gis.cpp_point_in_polygon_bitmap(
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+        cudf.Series([0.0]),
+        cudf.Series([0.0])
+    )
+    assert_eq(cudf.Series(result), cudf.Series([0]).astype('int32'))
+
+def test_one_point_in():
+    result = gis.cpp_point_in_polygon_bitmap(
+        cudf.Series([0]),
+        cudf.Series([0]),
+        cudf.Series([1]),
+        cudf.Series([3]),
+        cudf.Series([-1, 0, 1]),
+        cudf.Series([-1, 1, -1])
+    )
+    assert_eq(cudf.Series(result), cudf.Series([1]).astype('int32'))
+
+def test_one_point_out():
+    result = gis.cpp_point_in_polygon_bitmap(
+        cudf.Series([1]),
+        cudf.Series([1]),
+        cudf.Series([1]),
+        cudf.Series([3]),
+        cudf.Series([-1, 0, 1]),
+        cudf.Series([-1, 1, -1])
+    )
+    assert_eq(cudf.Series(result), cudf.Series([0]).astype('int32'))
+
+def test_dataset():
+    result = gis.cpp_point_in_polygon_bitmap(
+        cudf.Series([0, -8, 6.0]),
+        cudf.Series([0, -8, 6.0]),
+        cudf.Series([1, 2]),
+        cudf.Series([5, 10]),
+        cudf.Series([-10.0, 5, 5, -10, -10, 0, 10, 10, 0, 0]),
+        cudf.Series([-10.0, -10, 5, 5, -10, 0, 0, 10, 10, 0]),
+    )
+    # The result of cpp_point_in_polygon_bitmap is a binary bitmap of
+    # coordinates inside of the polgyon.
+    print(np.binary_repr(result.data.to_array()[0], width=2))
+    assert_eq(cudf.Series(result), cudf.Series([3, 1, 2]).astype('int32'))
+