ellipsis 3.1.45__tar.gz → 3.1.47__tar.gz

{ellipsis-3.1.45 → ellipsis-3.1.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ellipsis
-Version: 3.1.45
+Version: 3.1.47
 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 → ellipsis-3.1.47}/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.47'
 
 
 

{ellipsis-3.1.45 → ellipsis-3.1.47}/ellipsis/path/__init__.py

@@ -8,4 +8,6 @@ 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
+from ellipsis.path import setUpTask
 

ellipsis-3.1.47/ellipsis/path/bookmark/__init__.py

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

ellipsis-3.1.47/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-3.1.45 → ellipsis-3.1.47}/ellipsis/path/file/root.py

@@ -8,20 +8,27 @@ import json
 import pandas as pd
 
 
-def add( filePath, token, parentId = None, publicAccess =None, metadata=None):
+def add(  token, filePath=None, memFile=None, parentId = None, publicAccess =None, metadata=None,name=None):
     token = sanitize.validString('token', token, True)
     parentId = sanitize.validUuid('parentId', parentId, False)
     publicAccess = sanitize.validObject('publicAccess', publicAccess, False)
     metadata = sanitize.validObject('metadata', metadata, False)
+    filePath = sanitize.validString('filePath', filePath, False)
+    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')
 
-
-        
     seperator = os.path.sep    
     fileName = filePath.split(seperator)[len(filePath.split(seperator))-1 ]
         
     body = {'name':fileName, 'publicAccess':publicAccess, 'metadata':metadata, 'parentId':parentId}
+    if type(memFile) == type(None):
+        r = apiManager.upload('/path/file' , filePath, body, token, key = 'data')
+    else:
+        r = apiManager.upload('/path/file' , filePath , name, body, token, memfile = memFile)
 
-    r = apiManager.upload('/path/file' , filePath, body, token, key = 'data')
     return r
 
 

{ellipsis-3.1.45 → ellipsis-3.1.47}/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-3.1.45 → ellipsis-3.1.47}/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-3.1.45 → ellipsis-3.1.47}/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-3.1.45 → ellipsis-3.1.47}/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-3.1.45 → ellipsis-3.1.47}/ellipsis/path/root.py

@@ -155,24 +155,12 @@ def recover(pathId, token):
     }, token)
 
 
-def delete(pathId, token, recursive = False):
+def delete(pathId, token):
     pathId = sanitize.validUuid('pathId', pathId, True)
     token = sanitize.validString('token', token, False)
-    recursive = sanitize.validBool('recursive', recursive, True)
     
-    if recursive:
-        info = get(pathId, token)
-        if info['type'] == 'folder':
-            folders = listFolder(pathId = pathId, includeTrashed=True, pathTypes=['folder'], token=token)['result']
-            for f in folders:
-                delete(f['id'], token, True)
-            maps = listFolder(pathId=pathId, pathTypes=['raster','vector','file', 'pointCloud'], includeTrashed=True, token=token)['result']
-            for m in maps:
-                delete(m['id'], token, True)
-        apiManager.delete(f'/path/{pathId}', None, token)            
-    
-    else:
-        return apiManager.delete(f'/path/{pathId}', None, token)
+
+    return apiManager.delete(f'/path/{pathId}', None, token)
 
 def editPublicAccess(pathId, token, access = None, hidden=None, recursive = False):
     pathId = sanitize.validUuid('pathId', pathId, True)

ellipsis-3.1.47/ellipsis/path/setUpTask/__init__.py

@@ -0,0 +1,2 @@
+from ellipsis.path.setUpTask.root import get, copernicusImport, fileImport
+

ellipsis-3.1.47/ellipsis/path/setUpTask/root.py

@@ -0,0 +1,50 @@
+from ellipsis import apiManager
+from ellipsis import sanitize
+import os
+
+def get(token):
+    token = sanitize.validString('token', token, False)
+
+    r = apiManager.get('/path/setUpTask', {}, token)
+        
+    return r
+
+
+def copernicusImport( parameters, token):
+    token = sanitize.validString('token', token, True)
+    parameters = sanitize.validObject('parameters', parameters, True)
+    r = apiManager.post('/path/setUpTask', {'type':'copernicusImport', 'parameters':parameters}, token)
+        
+    return r
+
+
+def fileImport(  token, memFile=None, parentId = None, filePath=None, fileFormat = 'geopackage', name = None):
+    token = sanitize.validString('token', token, True)
+    parentId = sanitize.validUuid(('parentId', parentId, False))
+    filePath = sanitize.validString('filePath', filePath, False)
+    name = sanitize.validString('name', name, False)
+    fileFormat = sanitize.validString('fileFormat', fileFormat, True)
+
+
+    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):
+        nameToUse = name
+    else:
+        seperator = os.path.sep
+        nameToUse = filePath.split(seperator)[len(filePath.split(seperator)) - 1]
+
+    parameters = {'name': nameToUse, 'parentId': parentId}
+    body = {'type': fileFormat + 'Import', 'parameters': parameters}
+    if type(memFile) == type(None):
+        r = apiManager.post('/path/setUpTask', body, token)
+    else:
+        r = apiManager.upload('/path/setUpTask' , filePath , name, body, token, memfile = memFile)
+    return r
+
+
+
+