ellipsis 3.1.45__py3-none-any.whl → 3.1.46__py3-none-any.whl

ellipsis/__init__.py

@@ -4,10 +4,9 @@
 from ellipsis import account
 from ellipsis import user
 from ellipsis import path
-from ellipsis import view
 from ellipsis import util
 
-__version__ = '3.1.45'
+__version__ = '3.1.46'
 
 
 

ellipsis/path/__init__.py

@@ -8,4 +8,5 @@ from ellipsis.path import pointCloud
 from ellipsis.path import usage
 from ellipsis.path import folder
 from ellipsis.path import file
+from ellipsis.path import bookmark
 

ellipsis/path/bookmark/__init__.py

@@ -0,0 +1,2 @@
+
+from ellipsis.path.bookmark.root import add, get, edit

ellipsis/path/bookmark/root.py

@@ -0,0 +1,39 @@
+from ellipsis import apiManager
+from ellipsis import sanitize
+
+
+def get(pathId, token=None):
+    token = sanitize.validString('token', token, False)
+    pathId = sanitize.validUuid('pathId', pathId, True)
+
+    r = apiManager.get('/path/' + pathId + '/bookmark', {}, token)
+        
+    return r
+
+
+
+def add(name, bookmark, token, parentId = None, publicAccess = None, metadata=None):
+    token = sanitize.validString('token', token, True)
+    bookmark = sanitize.validObject('bookmark', bookmark, True)
+    name = sanitize.validString('pathId', name, False)
+    metadata = sanitize.validObject('metadata', metadata, False)
+    publicAccess = sanitize.validObject('publicAccess', publicAccess, False)
+    parentId = sanitize.validUuid('parentId', parentId, False)
+
+    r = apiManager.post('/path/bookmark', {'name':name, 'bookmark':bookmark , 'parentId':parentId, 'publicAccess':publicAccess, 'metadata':metadata}, token)
+        
+    return r
+
+
+def edit(pathId, token, layers=None, dems=None):
+    layers = sanitize.validObject('layers', layers, False)
+    dems = sanitize.validObject('dems', dems, False)
+    pathId = sanitize.validUuid('pathId', pathId, True)
+
+    r = apiManager.patch('/path/' + pathId + '/bookmark', {'layers':layers, 'dems':dems}, token)
+        
+    return r
+
+
+
+

ellipsis/path/pointCloud/timestamp/file/root.py

@@ -6,19 +6,34 @@ import os
 import numpy as np
 import geopandas as gpd
 
-def add(pathId, timestampId, filePath, token, fileFormat, epsg = None):
+def add(pathId, timestampId, token, fileFormat, filePath = None, memFile =None, name=None, epsg = None):
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
-    filePath = sanitize.validString('filePath', filePath, True)
+    filePath = sanitize.validString('filePath', filePath, False)
     epsg = sanitize.validInt('epsg', epsg, True)
     fileFormat = sanitize.validString('fileFormat', fileFormat, True)    
+    name = sanitize.validString('name', name, False)
+
+    if type(memFile) == type(None) and type(filePath) == type(None):
+        raise ValueError('You need to specify either a filePath or a memFile')
+
+    if type(memFile) != type(None) and type(name) == type(None):
+        raise ValueError('Parameter name is required when using a memory file')
+
+    if type(name ) == type(None):
+        seperator = os.path.sep
+        fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
+    else:
+        fileName = name
 
-    seperator = os.path.sep    
-    fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
     
     body = {'name':fileName, 'epsg':epsg, 'format':fileFormat}
-    r = apiManager.upload('/path/' + pathId + '/pointCloud/timestamp/' + timestampId + '/file' , filePath, body, token)
+    if type(memFile) == type(None):
+        r = apiManager.upload('/path/' + pathId + '/pointCloud/timestamp/' + timestampId + '/file' , filePath, body, token)
+    else:
+        r = apiManager.upload('/path/' + pathId + '/pointCloud/timestamp/' + timestampId + '/file' , name, body, token, memfile=memFile)
+
     return r
 
 def get(pathId, timestampId, token, pageStart= None, listAll = True):

ellipsis/path/raster/timestamp/__init__.py

@@ -6,13 +6,11 @@ from ellipsis.path.raster.timestamp.root import deactivate
 from ellipsis.path.raster.timestamp.root import getBounds
 from ellipsis.path.raster.timestamp.root import analyse
 from ellipsis.path.raster.timestamp.root import getRaster
-from ellipsis.path.raster.timestamp.root import getDownsampledRaster
 from ellipsis.path.raster.timestamp.root import trash
 from ellipsis.path.raster.timestamp.root import recover
 from ellipsis.path.raster.timestamp.root import getSampledRaster
-from ellipsis.path.raster.timestamp.root import getValuesAlongLine
 from ellipsis.path.raster.timestamp.root import contour
-
+from ellipsis.path.raster.timestamp.root import getLocationInfo
 from ellipsis.path.raster.timestamp import file
 from ellipsis.path.raster.timestamp import order
 

ellipsis/path/raster/timestamp/file/root.py

@@ -6,21 +6,35 @@ import os
 import numpy as np
 import geopandas as gpd
 
-def add(pathId, timestampId, filePath, token, fileFormat, epsg = None, noDataValue = None, mosaicPriority = None):
+def add(pathId, timestampId, token, fileFormat, filePath=None, memFile = None, epsg = None, noDataValue = None, mosaicPriority = None, name = None):
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
-    filePath = sanitize.validString('filePath', filePath, True)
-    noDataValue = sanitize.validFloat('noDataValue', noDataValue, False)    
+    filePath = sanitize.validString('filePath', filePath, False)
+    name = sanitize.validString('name', name, False)
+    noDataValue = sanitize.validFloat('noDataValue', noDataValue, False)
     epsg = sanitize.validInt('epsg', epsg, False)    
     fileFormat = sanitize.validString('fileFormat', fileFormat, True)    
     mosaicPriority = sanitize.validString('mosaicPriority', mosaicPriority, False)    
-        
-    seperator = os.path.sep    
-    fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
-    
+
+    if type(memFile) == type(None) and type(filePath) == type(None):
+        raise ValueError('You need to specify either a filePath or a memFile')
+
+    if type(memFile) != type(None) and type(name) == type(None):
+        raise ValueError('Parameter name is required when using a memory file')
+
+    if type(name ) == type(None):
+        seperator = os.path.sep
+        fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
+    else:
+        fileName = name
+
     body = {'name':fileName, 'epsg':epsg, 'noDataValue': noDataValue, 'format':fileFormat, 'mosaicPriority':mosaicPriority}
-    r = apiManager.upload('/path/' + pathId + '/raster/timestamp/' + timestampId + '/file' , filePath, body, token)
+    if type(memFile) == type(None):
+        r = apiManager.upload('/path/' + pathId + '/raster/timestamp/' + timestampId + '/file' , filePath, body, token)
+    else:
+        r = apiManager.upload('/path/' + pathId + '/raster/timestamp/' + timestampId + '/file' , name, body, token, memfile = memFile)
+
     return r
 
 def get(pathId, timestampId, token, pageStart= None, listAll = True):

ellipsis/path/raster/timestamp/root.py

@@ -23,42 +23,41 @@ import requests
 from skimage.measure import find_contours
 from shapely.geometry import Point, LineString
 
-def getDownsampledRaster(pathId, timestampId, extent, width, height, epsg=3857, style = None, token = None):
-    return getSampledRaster(pathId, timestampId, extent, width, height, epsg, style, token)
-
-def getSampledRaster(pathId, timestampId, extent, width, height, epsg=4326, style = None, token = None):
-    bounds = extent
+def getSampledRaster(pathId, timestampId, extent, width, height, epsg=3857, token = None):
     token = sanitize.validString('token', token, False)
     pathId = sanitize.validUuid('pathId', pathId, True)
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
-    bounds = sanitize.validBounds('bounds', bounds, True)
-    style = sanitize.validObject('style', style, False)
+    extent = sanitize.validBounds('extent', extent, True)
     epsg = sanitize.validInt('epsg', epsg, True)
-    body = {'pathId':pathId, 'timestampId':timestampId, 'extent':bounds, 'width':width, 'height':height, 'style':style, 'epsg':epsg}
 
-    if str(type(style)) == str(type(None)):
-        body['applyStyle'] = False
+    res = getActualExtent(extent['xMin'], extent['xMax'], extent['yMin'], extent['yMax'], 'EPSG:' + str(epsg))
+
+    if res['status'] == '400':
+        raise ValueError('Invalid epsg and extent combination')
+
+    extentWeb = res['message']
+
+
+
+    body = {'pathId':pathId, 'timestampId':timestampId, 'extent':extentWeb, 'width':width, 'height':height, 'applyStyle':False}
+
 
     r = apiManager.get('/path/' + pathId + '/raster/timestamp/' + timestampId + '/rasterByExtent', body, token, crash = True, parseJson = False)
 
 
-    if type(style) == type(None):
-        r = tifffile.imread(BytesIO(r.content))
-    else:
-        r = np.array(Image.open(BytesIO(r.content)))
-    #tif also has bands in last channel
-    r = np.transpose(r, [2,0,1])
+    r = tifffile.imread(BytesIO(r.content))
 
-    xMin = bounds['xMin']
-    yMin = bounds['yMin']
-    xMax = bounds['xMax']
-    yMax = bounds['yMax']
+    r = np.transpose(r, [2,0,1])
 
 
 
-    trans = rasterio.transform.from_bounds(xMin, yMin, xMax, yMax, r.shape[2], r.shape[1])
 
-    return {'raster': r, 'transform':trans, 'extent': {'xMin' : xMin, 'yMin': yMin, 'xMax': xMax, 'yMax': yMax}, 'crs':"EPSG:" + str(epsg) }
+    if epsg != 3857:
+        return reprojectRaster(r=r, sourceExtent=extentWeb, targetExtent=extent, targetWidth=r.shape[2],
+                               targetHeight=r.shape[1], sourceEpsg=3857, targetEpsg=epsg, interpolation='nearest')
+    else:
+        trans = rasterio.transform.from_bounds( extent['xMin'], extent['yMin'], extent['xMax'], extent['yMax'], r.shape[2], r.shape[1])
+        return {'raster': r, 'transform':trans, 'extent': extent, 'crs':"EPSG:" + str(epsg) }
 
 
 def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg = 4326, bandNumber = 1, token = None):
@@ -93,9 +92,11 @@ def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg
     if type(intervals) == type(None):
         minVal = np.min(raster[bandNumber-1, raster[-1,:,:] == 1])
         maxVal = np.max(raster[bandNumber-1, raster[-1,:,:] == 1])
+
+        if type(interval) == type(None):
+            interval = (maxVal - minVal) /10
         
-        
-        cont = minVal + interval
+        cont = minVal
 
         conts = []
         while cont < maxVal:
@@ -114,7 +115,6 @@ def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg
         lines = find_contours(raster[bandNumber-1,:,:],  mask=raster[-1,:,:] == 1, level = cont)
          
         newLines = []
-        line = lines[0]
         for line in lines:
             newLine = LineString([ Point( xMinWeb + x[0] * Lx  , yMinWeb +  x[1] * Ly )  for x in line])
             newLines = newLines + [newLine]
@@ -130,69 +130,25 @@ def contour(pathId, timestampId, extent, interval = None, intervals = None, epsg
     return sh
 
 
-def getValuesAlongLine(pathId, timestampId, line, token = None, epsg = 4326):
+def getLocationInfo(pathId, timestampId, locations, epsg = 4326, token= None):
     pathId = sanitize.validUuid('pathId', pathId, True)
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
     token = sanitize.validString('token', token, False)
-    line = sanitize.validShapely('line', line, True)
     epsg = sanitize.validInt('epsg', epsg, True)
 
-    if line.type != 'LineString':
-        raise ValueError('line must be a shapely lineString')
+    if epsg != 4326:
+        points = [Point(l) for l in locations]
+        sh = gpd.GeoDataFrame({'geometry':points})
+        sh.crs = 'EPSG:' + str(epsg)
+        sh.to_crs('EPSG:4326')
+        locations = [ l for l in zip(sh.bounds['minx'], sh.bounds['miny'] )]
+    body = {'locations':locations}
 
-    temp = gpd.GeoDataFrame({'geometry':[line]})
-    temp.crs = 'EPSG:' + str(epsg)
-    temp = temp.to_crs('EPSG:3857')
-    line = temp['geometry'].values[0]
-    line = list(line.coords)
-        
-    x_of_line = [p[0] for p in line]
-    y_of_line = [p[1] for p in line]
-
-    #the first action is to cacluate a bounding box for the raster we need to retrieve
-    xMin = min(x_of_line)
-    xMax = max(x_of_line)
-    yMin = min(y_of_line)
-    yMax = max(y_of_line)
-    
-    d = (xMax - xMin) * 0.1
-    xMax = xMax + d
-    xMin = xMin -d
-    d = (yMax - yMin) * 0.1
-    yMax = yMax + d
-    yMin = yMin -d
-    
-    
-    
-    #now we retrieve the needed raster we use epsg = 4326 but we can use other coordinates as well
-    extent = {'xMin': xMin, 'xMax':xMax, 'yMin':yMin, 'yMax':yMax}
-
-    size = 1000
-    r = getSampledRaster(pathId = pathId, timestampId = timestampId, extent = extent, width = size, height = size, epsg=3857, token = token)
-    raster = r['raster']
-
-    memfile =  MemoryFile()
-    dataset = memfile.open( driver='GTiff', dtype='float32', height=size, width=size, count = raster.shape[0], crs= r['crs'], transform=r['transform'])
-    dataset.write(raster)
-
-
-
-    values = list(dataset.sample(line))
-
-    memfile.close()
-    return values
-
-def getLocationInfo(pathId, timestampId, locations, epsg = 4326, token= None):
-    pathId = sanitize.validUuid('pathId', pathId, True)
-    timestampId = sanitize.validUuid('timestampId', timestampId, True)
-    token = sanitize.validString('token', token, False)
-    epsg = sanitize.validInt('epsg', epsg, True)
-    body = {'locations':locations,'epsg':epsg}
-    r = apiManager.post('/path/' + pathId + '/raster/timestamp/' + timestampId + '/location', body, token)
+    r = apiManager.get('/path/' + pathId + '/raster/timestamp/' + timestampId + '/location', body, token)
     return r
 
     
-def getRaster(pathId, timestampId, extent, token = None, showProgress = True, epsg = 4326, reproject = False, threads = None, style = None):
+def getRaster(pathId, timestampId, extent, token = None, showProgress = True, epsg = 3857):
     bounds = extent
     
     token = sanitize.validString('token', token, False)
@@ -200,12 +156,7 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
     bounds = sanitize.validBounds('bounds', bounds, True)
     showProgress = sanitize.validBool('showProgress', showProgress, True)
-    reproject = sanitize.validBool('reproject', reproject, True)
-    
-    if type(threads)!= type(None):
-        Warning('The parameter threads is deprecated')
-    if type(style)!= type(None):
-        Warning('The parameter style is deprecated')
+
         
     xMin = bounds['xMin']
     yMin = bounds['yMin']
@@ -241,7 +192,6 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
 
     zoom = t['zoom']
 
-    body = {"applyStyle":False}
 
     LEN = 2.003751e+07
 
@@ -294,7 +244,6 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
             
     def fetch(tileX, tileY):
         if tarred:
-
             cuts = cutOfTilesPerZoom[zoom]
             
             zones = [{'name': 'zone0', 'offset':0, 'start':cuts['start'][0] , 'end':cuts['end'][0]},  ]
@@ -316,8 +265,8 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
             frac_w = int(w/2**offset)
             
             url = apiManager.baseUrl + '/path/' + pathId + '/raster/timestamp/' + timestampId + '/tarTile/' + str(zoom_c) + '/' + str(tileX_c) + '/' + str(tileY_c)
-            if str(type(style)) == str(type(None)):
-                url = url + '?applyStyle=false'
+            url = url + '?applyStyle=false'
+
             if str(type(token)) == str(type(None)):
                 r = requests.get(url)
             else:
@@ -327,6 +276,7 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
                     r = requests.get(url, headers={"Authorization":  token})
             
         else:
+            body = {'applyStyle':False}
             r = apiManager.get('/path/' + pathId + '/raster/timestamp/' + timestampId + '/tile/' + str(zoom) + '/' + str(tileX) + '/' + str(tileY), body, token, False)
             
         if r.status_code == 403:
@@ -395,10 +345,10 @@ def getRaster(pathId, timestampId, extent, token = None, showProgress = True, ep
     r_total = r_total[:,min_y_index:max_y_index,min_x_index:max_x_index]
 
     mercatorExtent =  {'xMin' : xMinWeb, 'yMin': yMinWeb, 'xMax': xMaxWeb, 'yMax': yMaxWeb}
-    if (not reproject) or epsg == 3857:
+    if epsg == 3857:
         trans = rasterio.transform.from_bounds(xMinWeb, yMinWeb, xMaxWeb, yMaxWeb, r_total.shape[2], r_total.shape[1])
     
-        return {'raster': r_total, 'transform':trans, 'extent':mercatorExtent, 'epsg':3857}
+        return {'raster': r_total, 'transform':trans, 'extent':mercatorExtent, 'crs': 'EPSG:' + str(3857)}
     else:
         return reprojectRaster(r = r_total, sourceExtent = mercatorExtent, targetExtent = extent, targetWidth=r_total.shape[2], targetHeight=r_total.shape[1], sourceEpsg = 3857, targetEpsg= epsg, interpolation = 'nearest')
 

ellipsis/path/vector/timestamp/feature/root.py

@@ -10,73 +10,8 @@ import json
 import geopandas as gpd
 
 
-def manageLevels(levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5, features):
-    levelOfDetail1 = sanitize.validGeoSeries('levelOfDetail1', levelOfDetail1, False)
-    levelOfDetail2 = sanitize.validGeoSeries('levelOfDetail2', levelOfDetail2, False)
-    levelOfDetail3 = sanitize.validGeoSeries('levelOfDetail3', levelOfDetail3, False)
-    levelOfDetail4 = sanitize.validGeoSeries('levelOfDetail4', levelOfDetail4, False)
-    levelOfDetail5 = sanitize.validGeoSeries('levelOfDetail5', levelOfDetail5, False)
-
-    if type(levelOfDetail1) != type(None) and len(levelOfDetail1) != features.shape[0]:
-        raise ValueError('levelsOfDetail1 must have same length as number of rows in features')
-    if type(levelOfDetail2) != type(None) and len(levelOfDetail2) != features.shape[0]:
-        raise ValueError('levelsOfDetail2 must have same length as number of rows in features')
-    if type(levelOfDetail3) != type(None) and len(levelOfDetail3) != features.shape[0]:
-        raise ValueError('levelsOfDetail3 must have same length as number of rows in features')
-    if type(levelOfDetail4) != type(None) and len(levelOfDetail4) != features.shape[0]:
-        raise ValueError('levelsOfDetail4 must have same length as number of rows in features')
-    if type(levelOfDetail5) != type(None) and len(levelOfDetail5) != features.shape[0]:
-        raise ValueError('levelsOfDetail5 must have same length as number of rows in features')
-
-    if type(levelOfDetail2) != type(None) and type(levelOfDetail1) == type(None):
-        raise ValueError('If levelOfDetail2 is defined so should levelOfDetail1')
-    if type(levelOfDetail3) != type(None) and type(levelOfDetail2) == type(None):
-        raise ValueError('If levelOfDetail3 is defined so should levelOfDetail2')
-    if type(levelOfDetail4) != type(None) and type(levelOfDetail3) == type(None):
-        raise ValueError('If levelOfDetail4 is defined so should levelOfDetail3')
-    if type(levelOfDetail5) != type(None) and type(levelOfDetail4) == type(None):
-        raise ValueError('If levelOfDetail5 is defined so should levelOfDetail4')
-
-
-    if type(levelOfDetail1) != type(None):
-        levelOfDetail1 = levelOfDetail1.to_json()
-        levelOfDetail1 = json.loads(levelOfDetail1)
-        levelOfDetail1 = np.array( [ x['geometry'] for x in levelOfDetail1['features'] ])
-    if type(levelOfDetail2) != type(None):
-        levelOfDetail2 = levelOfDetail2.to_json()
-        levelOfDetail2 = json.loads(levelOfDetail2)
-        levelOfDetail2 = np.array( [ x['geometry'] for x in levelOfDetail2['features'] ])
-    if type(levelOfDetail3) != type(None):
-        levelOfDetail3 = levelOfDetail3.to_json()
-        levelOfDetail3 = json.loads(levelOfDetail3)
-        levelOfDetail3 = np.array( [ x['geometry'] for x in levelOfDetail3['features'] ])
-    if type(levelOfDetail4) != type(None):
-        levelOfDetail4 = levelOfDetail4.to_json()
-        levelOfDetail4 = json.loads(levelOfDetail4)
-        levelOfDetail4 = np.array( [ x['geometry'] for x in levelOfDetail4['features'] ])
-    if type(levelOfDetail5) != type(None):
-        levelOfDetail5 = levelOfDetail5.to_json()
-        levelOfDetail5 = json.loads(levelOfDetail5)
-        levelOfDetail5 = np.array( [ x['geometry'] for x in levelOfDetail5['features'] ])
-        
-    return levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5
-
-def zipLevels(levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5, indices_sub):
-    if type(levelOfDetail5) != type(None):         
-        levels = list(zip(levelOfDetail1[indices_sub], levelOfDetail2[indices_sub], levelOfDetail3[indices_sub], levelOfDetail4[indices_sub], levelOfDetail5[indices_sub]))
-    elif type(levelOfDetail4) != type(None):         
-        levels = list(zip(levelOfDetail1[indices_sub], levelOfDetail2[indices_sub], levelOfDetail3[indices_sub], levelOfDetail4[indices_sub]))
-    elif type(levelOfDetail3) != type(None):         
-        levels = list(zip(levelOfDetail1[indices_sub], levelOfDetail2[indices_sub], levelOfDetail3[indices_sub]))
-    elif type(levelOfDetail2) != type(None):         
-        levels = list(zip(levelOfDetail1[indices_sub], levelOfDetail2[indices_sub]))                      
-    elif type(levelOfDetail1) != type(None):         
-        levels = list(zip(levelOfDetail1[indices_sub]))
-    else:
-        levels = None
-    return levels
-    
-def add(pathId, timestampId, features, token, showProgress = True, levelOfDetail1 = None, levelOfDetail2 = None, levelOfDetail3 = None, levelOfDetail4 = None, levelOfDetail5 = None, cores = 1):
+
+def add(pathId, timestampId, features, token, showProgress = True, cores = 1):
     pathId = sanitize.validUuid('pathId', pathId, True)
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
     token = sanitize.validString('token', token, True)
@@ -84,17 +19,16 @@ def add(pathId, timestampId, features, token, showProgress = True, levelOfDetail
     cores = sanitize.validInt('cores', cores, True)
     features = sanitize.validGeopandas('features', features, True, cores = cores)
 
-    levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5 = manageLevels(levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5, features)
     features_json = features.to_json(na='drop')
     features_json = json.loads(features_json)
     features_json = np.array(features_json['features'])
-    
+
     #check if first time
     firstTime = apiManager.get('/path/' + pathId, None, token)
     if not 'vector' in firstTime.keys():
         raise ValueError('Can only add features if path is of type vector')
     firstTime = len(firstTime['vector']['properties']) ==0
-    
+
     if firstTime:
         print('no properties known for this timestamp adding them automatically')
         columns = features.columns
@@ -123,38 +57,33 @@ def add(pathId, timestampId, features, token, showProgress = True, levelOfDetail
         indices_sub = indices[i]
         features_sub = features_json[indices_sub]
 
-        levels = zipLevels(levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5, indices_sub)
-                      
-        if type(levels) != type(None):
-            featuresBody = [{'feature': features_sub[i], 'levelsOfDetail': levels[i] } for i in np.arange(len(indices_sub))]
-        else:
-            featuresBody = [{'feature': features_sub[i] } for i in np.arange(len(indices_sub))]
+
+        featuresBody = [{'feature': features_sub[i] } for i in np.arange(len(indices_sub))]
         body = {"features":featuresBody}
         r = apiManager.post('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature', body, token)
         addedIds = addedIds + r
         if showProgress:
             loadingBar(i*3000 + len(indices_sub),features.shape[0])
         i = i+1
-        
+
     return(addedIds)
 
 
-    
-def edit(pathId, timestampId, featureIds, token, features = None, showProgress = True, levelOfDetail1 = None, levelOfDetail2 = None, levelOfDetail3 = None, levelOfDetail4 = None, levelOfDetail5 = None, cores = 1):
-    pathId = sanitize.validUuid('pathId', pathId, True) 
-    timestampId = sanitize.validUuid('timestampId', timestampId, True) 
+
+def edit(pathId, timestampId, featureIds, token, features, showProgress = True, cores = 1):
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
     token = sanitize.validString('token', token, True)
     featureIds = sanitize.validUuidArray('featureIds', featureIds, True)
     showProgress = sanitize.validBool('showProgress', showProgress, True)
     cores = sanitize.validInt('cores', cores, True)
     features = sanitize.validGeopandas('features', features, False, cores=cores)
 
-    levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5 = manageLevels(levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5, features)
 
 
     if type(features) != type(None) and features.shape[0] != len(featureIds):
         raise ValueError('featureIds must be of same length as the features geopandas dataframe')
-        
+
 
     indices = chunks(np.arange(len(featureIds)),1000)
     i=0
@@ -163,17 +92,13 @@ def edit(pathId, timestampId, featureIds, token, features = None, showProgress =
         featureIds_sub = list( np.array(featureIds)[indices_sub])
 
         if type(features) != type(None):
-            features_sub = features.iloc[indices_sub]        
+            features_sub = features.iloc[indices_sub]
             features_sub =features_sub.to_json(na='drop')
             features_sub = json.loads(features_sub)
 
-        levels = zipLevels(levelOfDetail1, levelOfDetail2, levelOfDetail3, levelOfDetail4, levelOfDetail5, indices_sub)
 
-        if type(levels) == type(None):
-                changes = [{'featureId':x[0] , 'newProperties':x[1]['properties'], 'newGeometry':x[1]['geometry']} for x in zip(featureIds_sub, features_sub['features'])]
-        else:
-                changes = [{'featureId':x[0], 'levelsOfDetail': levels , 'newProperties':x[1]['properties'], 'newGeometry':x[1]['geometry']} for x in zip(featureIds_sub, features_sub['features'])]
-            
+        changes = [{'featureId':x[0] , 'newProperties':x[1]['properties'], 'newGeometry':x[1]['geometry']} for x in zip(featureIds_sub, features_sub['features'])]
+
         body = {'changes':changes}
         r = apiManager.patch('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature', body, token)
 
@@ -184,8 +109,8 @@ def edit(pathId, timestampId, featureIds, token, features = None, showProgress =
 
 
 def trash(pathId, timestampId, featureIds, token, showProgress = True):
-    pathId = sanitize.validUuid('pathId', pathId, True) 
-    timestampId = sanitize.validUuid('timestampId', timestampId, True) 
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
     token = sanitize.validString('token', token, True)
     featureIds = sanitize.validUuidArray('featureIds', featureIds, True)
     showProgress = sanitize.validBool('showProgress', showProgress, True)
@@ -206,8 +131,8 @@ def trash(pathId, timestampId, featureIds, token, showProgress = True):
 
 
 def recover(pathId, timestampId, featureIds, token, showProgress = True):
-    pathId = sanitize.validUuid('pathId', pathId, True) 
-    timestampId = sanitize.validUuid('timestampId', timestampId, True) 
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
     token = sanitize.validString('token', token, True)
     featureIds = sanitize.validUuidArray('featureIds', featureIds, True)
     showProgress = sanitize.validBool('showProgress', showProgress, True)
@@ -229,13 +154,13 @@ def recover(pathId, timestampId, featureIds, token, showProgress = True):
 
 
 def versions(pathId, timestampId, featureId, token = None, pageStart = None, listAll = True):
-    pathId = sanitize.validUuid('pathId', pathId, True) 
-    timestampId = sanitize.validUuid('timestampId', timestampId, True) 
+    pathId = sanitize.validUuid('pathId', pathId, True)
+    timestampId = sanitize.validUuid('timestampId', timestampId, True)
     token = sanitize.validString('token', token, False)
     featureId = sanitize.validUuid('featureId', featureId, True)
     pageStart = sanitize.validUuid('pageStart', pageStart, False)
     listAll = sanitize.validBool('listAll', listAll, True)
-    
+
     body = {'returnType':'all'}
     def f(body):
         return apiManager.get('/path/' + pathId + '/vector/timestamp/' + timestampId + '/feature/' + featureId + '/version', body, token)
@@ -247,11 +172,11 @@ def versions(pathId, timestampId, featureId, token = None, pageStart = None, lis
     usernames = [x['user']['username'] for x in r['result'] ]
     userIds = [x['user']['id'] for x in r['result'] ]
 
-    sh = gpd.GeoDataFrame.from_features(features)     
+    sh = gpd.GeoDataFrame.from_features(features)
     sh['username'] = usernames
     sh['userId'] = userIds
     sh['dates'] = dates
-    
+
     sh.crs = {'init': 'epsg:4326'}
     r['result'] = sh
     return(r)

ellipsis/path/vector/timestamp/file/root.py

@@ -5,27 +5,43 @@ from ellipsis.util.root import recurse
 import numpy as np
 import geopandas as gpd
 
-def add(pathId, timestampId, filePath, token, fileFormat, epsg = None, dateColumns = None, datePatterns = None, method= 'simplify', fastUpload = True):
+def add(pathId, timestampId, token, fileFormat, filePath=None, memFile = None, name = None, epsg = None, dateColumns = None, datePatterns = None, method= 'simplify', fastUpload = True):
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
-    filePath = sanitize.validString('filePath', filePath, True)
+    filePath = sanitize.validString('filePath', filePath, False)
     epsg = sanitize.validInt('epsg', epsg, False)
-    method = sanitize.validString('method', method, True)
-    fileFormat = sanitize.validString('fileFormat', fileFormat, True)    
+    fileFormat = sanitize.validString('fileFormat', fileFormat, True)
     dateColumns = sanitize.validStringArray('dateColumns', dateColumns, False)    
     datePatterns = sanitize.validStringArray('datePatterns', datePatterns, False)    
+    name = sanitize.validString('name', name, False)
     fastUpload = sanitize.validBool('fastUpload', fastUpload, True)
     if fastUpload:
         fastUpload='true'
     else:
         fastUpload = 'false'
 
-    seperator = os.path.sep    
-    fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
-    
+
+    if type(memFile) == type(None) and type(filePath) == type(None):
+        raise ValueError('You need to specify either a filePath or a memFile')
+
+    if type(memFile) != type(None) and type(name) == type(None):
+        raise ValueError('Parameter name is required when using a memory file')
+
+    if type(name ) == type(None):
+        seperator = os.path.sep
+        fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
+    else:
+        fileName = name
+
+
     body = {'name':fileName, 'epsg':epsg, 'format':fileFormat, 'dateColumns': dateColumns, 'datePatterns':datePatterns, 'fastUpload':fastUpload}
-    r = apiManager.upload('/path/' + pathId + '/vector/timestamp/' + timestampId + '/file' , filePath, body, token)
+    if type(memFile) == type(None):
+        r = apiManager.upload('/path/' + pathId + '/vector/timestamp/' + timestampId + '/file' , filePath, body, token)
+    else:
+        r = apiManager.upload('/path/' + pathId + '/vector/timestamp/' + timestampId + '/file', name, body, token,
+                              memfile=memFile)
+
     return r
 
 def get(pathId, timestampId, token, pageStart = None, listAll = True):

ellipsis/path/vector/timestamp/order/root.py

@@ -6,16 +6,17 @@ def get(token):
     r = apiManager.get('/path/vector/timestamp/order', None, token)
     return r
 
-def add(pathId, timestampId, token, extent = None, fileFormat = 'geojson'):
+def add(pathId, timestampId, token, extent = None, fileFormat = 'geojson', epsg = 4326):
     
     token = sanitize.validString('token', token, True)
     pathId = sanitize.validUuid('pathId', pathId, True)
     timestampId = sanitize.validUuid('timestampId', timestampId, True)
     extent = sanitize.validBounds('extent', extent, False)
     fileFormat = sanitize.validString('fileFormat', fileFormat, True)
+    epsg = sanitize.validInt('epsg', epsg, True)
 
 
-    body = { 'extent':extent, 'format' :fileFormat}
+    body = { 'extent':extent, 'format' :fileFormat, 'epsg':epsg}
     
     r = apiManager.post('/path/' + pathId + '/vector/timestamp/' + timestampId + '/order', body, token)    
 

ellipsis/path/vector/timestamp/root.py

@@ -116,21 +116,20 @@ def getChanges(pathId, timestampId, token = None, pageStart = None, listAll = Fa
 
 
 
-def getFeaturesByIds(pathId, timestampId, featureIds, token = None, showProgress = True, levelOfDetail = None):
+def getFeaturesByIds(pathId, timestampId, featureIds, token = None, showProgress = True, epsg = 4326):
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
     token = sanitize.validString('token', token, False)
     featureIds = sanitize.validUuidArray('featureIds', featureIds, True)
     showProgress = sanitize.validBool('showProgress', showProgress, True)
-    levelOfDetail = sanitize.validInt('levelOfDetail', levelOfDetail, False)
-    
+
     id_chunks = chunks(featureIds, 10)
 
     r = {'size': 0 , 'result': [], 'nextPageStart' : None}
     ids = id_chunks[0]
     i=0
     for ids in id_chunks:
-        body = {'geometryIds': ids, levelOfDetail:levelOfDetail}
+        body = {'geometryIds': ids}
         r_new = apiManager.get('/path/' + pathId + '/vector/timestamp/' + timestampId + '/featuresByIds' , body, token)
         
         r['result'] = r['result'] + r_new['result']['features']
@@ -147,17 +146,17 @@ def getFeaturesByIds(pathId, timestampId, featureIds, token = None, showProgress
                 del r['result']['features'][i]['properties']['crs']
         sh = gpd.GeoDataFrame.from_features(r['result']['features'])
         
-
+    sh.crs = 'EPSG:4326'
+    sh = sh.to_crs('EPSG:' + str(epsg))
     r['result'] = sh
     return r
     
 
-def getFeaturesByExtent(pathId, timestampId, extent, propertyFilter = None, token = None, listAll = True, pageStart = None, epsg = 4326, coordinateBuffer = None, levelOfDetail = None, onlyIfCenterPointInExtent = False):
+def getFeaturesByExtent(pathId, timestampId, extent, propertyFilter = None, token = None, listAll = True, pageStart = None, epsg = 4326, coordinateBuffer = None, onlyIfCenterPointInExtent = False):
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
     token = sanitize.validString('token', token, False)
     extent = sanitize.validBounds('extent', extent, True)
-    levelOfDetail = sanitize.validInt('levelOfDetail', levelOfDetail, False)
     propertyFilter = sanitize.validObject('propertyFilter', propertyFilter, False)
     listAll = sanitize.validBool('listAll', listAll, True)
     epsg = sanitize.validInt('epsg', epsg, True)
@@ -187,7 +186,7 @@ def getFeaturesByExtent(pathId, timestampId, extent, propertyFilter = None, toke
     extent_new['yMax'] = min(85, extent['yMax'] + coordinateBuffer)
 
 
-    body = {'pageStart': pageStart, 'propertyFilter':propertyFilter, 'extent':extent_new, 'levelOfDetail':levelOfDetail}
+    body = {'pageStart': pageStart, 'propertyFilter':propertyFilter, 'extent':extent_new}
 
     def f(body):
         return apiManager.get('/path/' + pathId + '/vector/timestamp/' + timestampId + '/featuresByExtent' , body, token)
@@ -224,15 +223,14 @@ def getFeaturesByExtent(pathId, timestampId, extent, propertyFilter = None, toke
     return r
 
 
-def listFeatures(pathId, timestampId, token = None, listAll = True, pageStart = None, levelOfDetail = None):
+def listFeatures(pathId, timestampId, token = None, listAll = True, pageStart = None, epsg = 4326):
     pathId = sanitize.validUuid('pathId', pathId, True) 
     timestampId = sanitize.validUuid('timestampId', timestampId, True) 
     token = sanitize.validString('token', token, False)
     listAll = sanitize.validBool('listAll', listAll, True)
     pageStart = sanitize.validObject('pageStart', pageStart, False) 
-    levelOfDetail = sanitize.validInt('levelOfDetail', levelOfDetail, False)
 
-    body = {'pageStart': pageStart, 'levelOfDetail':levelOfDetail, 'pageSize':10000}
+    body = {'pageStart': pageStart, 'pageSize':10000}
 
 
     def f(body):
@@ -258,6 +256,7 @@ def listFeatures(pathId, timestampId, token = None, listAll = True, pageStart =
     
 
     sh.crs = {'init': 'epsg:4326'}
+    sh = sh.to_crs('EPSG:' + str(epsg))
     r['result'] = sh
 
     return r

ellipsis/util/__init__.py

@@ -2,6 +2,7 @@ from ellipsis.util.root import reprojectRaster
 from ellipsis.util.root import reprojectVector
 
 from ellipsis.util.root import saveRaster
+from ellipsis.util.root import saveVector
 
 from ellipsis.util.root import parseGlb
 

ellipsis/util/root.py

@@ -5,7 +5,7 @@ import numpy as np
 import pandas as pd
 import math
 import sys
-
+from rasterio.io import MemoryFile
 from datetime import datetime
 from shapely import geometry
 import rasterio
@@ -85,10 +85,6 @@ def plotPointCloud(df, method = 'cloud', width = 800, height = 600, scale = 0.00
 
 
 
-
-
-
-
 def parseGlb(stream):
     gltf = pygltflib.GLTF2.load_from_bytes(stream)
     binary_blob = gltf.binary_blob()
@@ -304,7 +300,7 @@ def reprojectRaster(r, sourceExtent, targetExtent, targetWidth, targetHeight, so
             resampling=interpolation)
     
 
-    return {'raster':destination, 'transform':dst_transform, 'extent':targetExtent, 'epsg':targetEpsg}
+    return {'raster':destination, 'transform':dst_transform, 'extent':targetExtent, 'crs': 'EPSG:' + str(targetEpsg)}
 
 
 def swapXY(extent):
@@ -334,8 +330,8 @@ def transformPoint( point, sourceEpsg, targetEpsg):
     return(x,y)
 
 #funciton to store image given bounds, and raster and crs
-def saveRaster(targetFile, r, epsg, extent = None, transform = None):
-    
+def saveRaster(r, epsg, targetFile, extent = None, transform = None):
+
     if type(extent) == type(None) and type(transform) == type(None):
         raise ValueError('You must provide either an extent or a transform')
         
@@ -352,17 +348,36 @@ def saveRaster(targetFile, r, epsg, extent = None, transform = None):
     h = r.shape[1]
     if transform == None:
         transform = rasterio.transform.from_bounds(extent['xMin'], extent['yMin'], extent['xMax'], extent['yMax'], w, h)
+
     con = rasterio.open(targetFile , 'w', driver='Gtiff',compress="lzw",
                     height = h, width = w,
                     count= r.shape[0], dtype=r.dtype,
                     crs=  crs ,
                     transform=transform)
-    
+
     con.write(r)
     con.close()
+    if type(targetFile) != type('x'):
+        return targetFile
 
 def saveVector(targetFile, features):
-    features.to_file(targetFile)
+    features.to_file(targetFile, driver="GPKG")
+    if type(targetFile) != type('x'):
+        return targetFile
+
+
+def savePointCloud(targetFile, df):
+    import laspy
+    las = laspy.create(point_format=2, file_version='1.2')
+    las.x = df.x
+    las.y = df.y
+    las.z = df.z
+    las.red = df['red'].values
+    las.green = df['green'].values
+    las.blue = df['blue'].values
+    las.write(targetFile)
+    if type(targetFile) != type('x'):
+        return targetFile
 
 
 q_running = multiprocessing.Queue()

{ellipsis-3.1.45.dist-info → ellipsis-3.1.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ellipsis
-Version: 3.1.45
+Version: 3.1.46
 Summary: Package to interact with the Ellipsis API
 Home-page: https://github.com/ellipsis-drive-internal/python-package
 Author: Daniel van der Maas

{ellipsis-3.1.45.dist-info → ellipsis-3.1.46.dist-info}/RECORD

@@ -1,12 +1,14 @@
-ellipsis/__init__.py,sha256=PjCKP1j39kGObADgMz9G9gbAIXlEkn0vjMUSKsp3zpE,236
+ellipsis/__init__.py,sha256=R6MNlybVTKLz0IBT7OihsOuFtHSwX6YvXctY1vI5LXg,210
 ellipsis/apiManager.py,sha256=JJ-1nT29BIcVSzMvEdkm1Wq6PsXT7Jq5OmJrRdg7C2o,5463
 ellipsis/sanitize.py,sha256=T5FawJRZ2eqGv0itiMkZ1fuJpahsSyhBMFty9cG-wwA,10194
 ellipsis/account/__init__.py,sha256=K40DMBaUDSxt3rO2WZv63Wmpfy49ocqBxvWqyIYHR24,92
 ellipsis/account/root.py,sha256=tgGAT2BzP3zgAqsevvkeognn5S67T-MrIP52BLN9rbE,1791
 ellipsis/account/accessToken/__init__.py,sha256=ivwhK1eC4g74PAKaeTReb1QhIpKXyvmfdqZV6wDY-EY,66
 ellipsis/account/accessToken/root.py,sha256=TYo8wTyWyzytaqOTsuQC-Vn3y7BhYMC88EItZafpISA,1281
-ellipsis/path/__init__.py,sha256=jqmyE8UyYLua23_zRP79BoiFvekMlZO6oTdAs_sFCyw,435
+ellipsis/path/__init__.py,sha256=cc03CEyQvWmdaFPo4T8KBeyYiz-04VtzcCDwMrHADmU,470
 ellipsis/path/root.py,sha256=3HaKJhjAeHMqK1rBjcvT92aG6kBWllpu3prUqO3Ov6s,8618
+ellipsis/path/bookmark/__init__.py,sha256=vNrqGcWl5MN_xVAiClP6W6NilmsV-fqYOnJukbYcNwc,56
+ellipsis/path/bookmark/root.py,sha256=knhVIVAJS0jBT6JLdVgnufVRdxIR0VZBYfv292hg6xY,1285
 ellipsis/path/file/__init__.py,sha256=i_KB1S1J9pZjcPTKdyGMnjJf2tCoHFzptLGaxmTi55A,107
 ellipsis/path/file/root.py,sha256=3aqUFHQ7JLZf2arFoxOruOEKU-yOqUooj_LexGdPZ_s,4418
 ellipsis/path/folder/__init__.py,sha256=5keiFbsuXj5bYQHt8NahGkUYvXrJk8C7cQhgHA-4VBc,139
@@ -23,18 +25,18 @@ ellipsis/path/pointCloud/timestamp/__init__.py,sha256=V5tUr351MX2f9ox7zNQ2UQnlOj
 ellipsis/path/pointCloud/timestamp/root.py,sha256=_a8JJN8qx4KnwovNj61Y1AZyu7ddPUGR39Hr2z9cNyg,7009
 ellipsis/path/pointCloud/timestamp/util.py,sha256=eupFFSBp5CaTDIRg6DYnZnfWY61h81JZ7c15NdJ-j5E,2580
 ellipsis/path/pointCloud/timestamp/file/__init__.py,sha256=CyWtj9Q49GatQg0sVyYDp6Lua7ZQCv40BWjP6dvStKo,101
-ellipsis/path/pointCloud/timestamp/file/root.py,sha256=izu-AVe5xM_KmW85MhHpraAU-GOk_i3vrf8lLWkysqE,3647
+ellipsis/path/pointCloud/timestamp/file/root.py,sha256=oRzKt60sQ1UfwYWq6jqMHUCv7q17x944R9G1ENnQgI8,4290
 ellipsis/path/pointCloud/timestamp/order/__init__.py,sha256=DA2mNfP_glsUJZZkUcpN5rAGCOfDMathASWdpZD-PCs,78
 ellipsis/path/pointCloud/timestamp/order/root.py,sha256=ni4lYOmatqLg5NQ1VTLeG9R7nI9dcLpONFp3JUj9LQw,1184
 ellipsis/path/raster/__init__.py,sha256=xWEsdpQxsqnwSdRqmZujS3pEUAmemHmUCtMKCaWLK0M,217
 ellipsis/path/raster/root.py,sha256=-y0SEukHEYUDvyJyDI1x7gtcDm-Wum_Ze7ekSYJr6O4,1749
 ellipsis/path/raster/style/__init__.py,sha256=mxlqVtSd2dsKai3DAVQjtNsh2KnTrZVyF8loRwUNT7E,61
 ellipsis/path/raster/style/root.py,sha256=YFQlGTdgjpwXn4h0ug7LrQZFLmRp2bdJN71A0iqZRFo,1627
-ellipsis/path/raster/timestamp/__init__.py,sha256=_2rt8Kcpu-Zj7FwyzmvAbbxoENv-R5dNbjRbJdnjpz4,915
-ellipsis/path/raster/timestamp/root.py,sha256=r6WO9bFjnLLTv7oT-R4bJe-1XpQgWJygMV9paQu5oRI,19152
+ellipsis/path/raster/timestamp/__init__.py,sha256=brmFXg69CKRcWaAfPbxWfsvHvnn5q8GBQhVzUTVb4_w,842
+ellipsis/path/raster/timestamp/root.py,sha256=qhJALjYVCdNmH3atGNmIe89Zm5xj_EAd8fczHWW4CQg,17257
 ellipsis/path/raster/timestamp/util.py,sha256=eupFFSBp5CaTDIRg6DYnZnfWY61h81JZ7c15NdJ-j5E,2580
 ellipsis/path/raster/timestamp/file/__init__.py,sha256=Ln9_dQ4-PMwb5VP--Qh09IV5zmr-47RShpe0-f_NVh4,97
-ellipsis/path/raster/timestamp/file/root.py,sha256=T-vcD5o257-8t2M1l-c7WUxpq4ZmSApWFLqFhIL5Kb0,3920
+ellipsis/path/raster/timestamp/file/root.py,sha256=KD8E64eZtS62C-WCl3BTeVjsc08BaLXpuLwxfbmnTLI,4545
 ellipsis/path/raster/timestamp/order/__init__.py,sha256=4YEK4XW9TM-HsjoFlFeyGMtI3OKX2VCXfb4NsTsugBo,74
 ellipsis/path/raster/timestamp/order/root.py,sha256=zWcfI_q9KlfevzyvwWY8ni27KCvOyAiaJvohVfasjXg,1176
 ellipsis/path/usage/__init__.py,sha256=2BHmLV9soOYDhyQFH2B86bBjmWXGsfuX4KneEBDo6O4,96
@@ -46,25 +48,23 @@ ellipsis/path/vector/featureProperty/root.py,sha256=eb2bw4UGO3eYGaYgjwu43pZyA4iA
 ellipsis/path/vector/style/__init__.py,sha256=riiDnL4FDq4EFhSYAYHBSe_o5oltRTSrj4sc72F6IVQ,63
 ellipsis/path/vector/style/root.py,sha256=09PsRbCJ35YV8bl8xoWFoeGRpdmf5IBmmqwhRj30OTM,1641
 ellipsis/path/vector/timestamp/__init__.py,sha256=n0ncRxXoQIDX1WeV0lbpJH1BND793CdZ5swGgeu1Kfk,330
-ellipsis/path/vector/timestamp/root.py,sha256=YYSFKTC7Vs51EFeytZ1eqX2kPuMAS6JtqoA9yaDl-HI,11558
+ellipsis/path/vector/timestamp/root.py,sha256=kcLdfBWpoqRXWswz-nqrEM0mxw6oEZc5sUFCD_B4JRk,11296
 ellipsis/path/vector/timestamp/feature/__init__.py,sha256=miaLCHkogL9KJ_eUr4K_N15BShAe2ivcppDFJuE_SgI,210
-ellipsis/path/vector/timestamp/feature/root.py,sha256=BQdXZCgF5fi1sIovmUdNAV5aUrPizjJuLqfwzPguVQw,13011
+ellipsis/path/vector/timestamp/feature/root.py,sha256=Y_GiT1vBEvZxxvJdUvzhjGqYsfPfi1L6qHBS5jNcnBY,7212
 ellipsis/path/vector/timestamp/feature/message/__init__.py,sha256=XfX3MIa4RjpToFnxNyfxCKTvRlNtJFRQ44j31wDyhGc,100
 ellipsis/path/vector/timestamp/feature/message/root.py,sha256=isLzkITTiluKoIsH0PYT0K5Cr-LBzTA0TSE4-2tZU5M,3949
 ellipsis/path/vector/timestamp/feature/series/__init__.py,sha256=vPi57QdUPTEnQE31abgxzwWU3Gzu-Xxi3ZVD4z5MMwg,107
 ellipsis/path/vector/timestamp/feature/series/root.py,sha256=KCm28pQ8E6WREftuSi4wge_2QpojDW11b55j7_tG7Js,7519
 ellipsis/path/vector/timestamp/file/__init__.py,sha256=qJtOXI9MEv4KifDjMW3zUDKnef8PD69SQmgRc3wDShQ,73
-ellipsis/path/vector/timestamp/file/root.py,sha256=UPmcyJ4oWsOpDrsiM-sM5wtXGwkijKSIXLqpnQd4icA,4132
+ellipsis/path/vector/timestamp/file/root.py,sha256=STswXCVZMtLmYceXKQsLKhyNmWzifDHp084mdS9fYLQ,4736
 ellipsis/path/vector/timestamp/order/__init__.py,sha256=w11nMYDQJzZJU_q8o7ApadV2EOdCX93gNkHZ7PO1gUo,74
-ellipsis/path/vector/timestamp/order/root.py,sha256=F0j2niJ73jRUposYNuviKFDOutlS-TECfk6O1slLW4c,1174
+ellipsis/path/vector/timestamp/order/root.py,sha256=kknhHJSuj91WaRF-qzfovummHwplwyizi5q-V8cA0To,1249
 ellipsis/user/__init__.py,sha256=um_b42pc2otFiQRGqMajcEtONQpC2ei4r-EY3j7bsfQ,43
 ellipsis/user/root.py,sha256=dsMK6wGBdeCmOd3YsbIv9cEcQ6tAiSGr0jmtBhQl5-0,484
-ellipsis/util/__init__.py,sha256=G0LaqqipkJXqZZnW78pqOw-gDQWZYLMa2ioLoCac-NI,714
-ellipsis/util/root.py,sha256=keGn515Dnxyja8kNG9p-xdsX6gRa8pHCh6AJaQXLoig,23445
-ellipsis/view/__init__.py,sha256=91KyJzbSvwSP9hvJQyo1LLM48b5NixLz6G40I9h6sdY,67
-ellipsis/view/root.py,sha256=6actiBwIsM0f7sJhQl_U4j-C6Dhe0z5XGGtxIOIKdY8,1726
-ellipsis-3.1.45.dist-info/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
-ellipsis-3.1.45.dist-info/METADATA,sha256=EvbSCQd_-LxFDFpDO3xv6xgegAoVPuoYHpNGEDlMVN8,1823
-ellipsis-3.1.45.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-ellipsis-3.1.45.dist-info/top_level.txt,sha256=eG8gfaVDyprKdb-dsGSh_lFMSa3DiZCsJFqze239RjA,9
-ellipsis-3.1.45.dist-info/RECORD,,
+ellipsis/util/__init__.py,sha256=_sNBUXDKJVGffRyt93xdUrJ4gON651Sp-unr7LKVCEc,756
+ellipsis/util/root.py,sha256=Ts7DeaD_X7x-csmq5V2sa_hYrt1mCd59T7-NUQcWj3Y,23980
+ellipsis-3.1.46.dist-info/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+ellipsis-3.1.46.dist-info/METADATA,sha256=GD17VF-4T2g_Ff-HUy-02yXLnP6eT_YucVKjzYzBhzg,1823
+ellipsis-3.1.46.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+ellipsis-3.1.46.dist-info/top_level.txt,sha256=eG8gfaVDyprKdb-dsGSh_lFMSa3DiZCsJFqze239RjA,9
+ellipsis-3.1.46.dist-info/RECORD,,

ellipsis/view/__init__.py

@@ -1,3 +0,0 @@
-
-from ellipsis.view.root import add, get, edit, listViews, delete
-

ellipsis/view/root.py

@@ -1,59 +0,0 @@
-from ellipsis import apiManager
-from ellipsis import sanitize
-from ellipsis.util.root import recurse
-
-def listViews(token):
-
-    token = sanitize.validString('token', token, True)
-
-
-
-    r = apiManager.get('/view', {}, token)
-
-    return r
-
-def get(viewId, token=None):
-    token = sanitize.validString('token', token, False)
-    viewId = sanitize.validString('viewId', viewId, True)
-
-    r = apiManager.get('/view/' + viewId, {}, token)
-        
-    return r
-
-
-
-def add(pathId, layers, name = None, persistent=False, dems=[], token = None):
-    token = sanitize.validString('token', token, False)
-    pathId = sanitize.validString('pathId', pathId, True)
-    layers = sanitize.validObject('layers', layers, True)
-    dems = sanitize.validObject('dems', dems, True)
-    name = sanitize.validString('pathId', name, False)
-    persistent = sanitize.validBool('persistent', persistent, True)
-
-    r = apiManager.post('/view', {'name':name, 'layers':layers, 'dems':dems, 'pathId':pathId, 'persistent':persistent}, token)
-        
-    return r
-
-
-def edit(viewId, token, layers=None, name=None, dems=None):
-    viewId = sanitize.validString('viewId', viewId, True)
-    token = sanitize.validString('token', token, False)
-    layers = sanitize.validObject('layers', layers, False)
-    dems = sanitize.validObject('dems', dems, False)
-    name = sanitize.validString('pathId', name, False)
-
-    r = apiManager.patch('/view/' + viewId, {'layers':layers, 'dems':dems, 'name':name}, token)
-        
-    return r
-
-
-
-def delete(viewId, token):
-    viewId = sanitize.validString('viewId', viewId, True)
-    token = sanitize.validString('token', token, False)
-
-    r = apiManager.delete('/view/' + viewId, {}, token)
-
-        
-    return r
-