def handle(self, request): decoder = WMS11GetFeatureInfoDecoder(request.GET) bbox = decoder.bbox time = decoder.time srs = decoder.srs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=srs) if time: subsets.append(time) renderer = self.renderer root_group = lookup_layers(layers, subsets, renderer.suffixes) result, _ = renderer.render(root_group, request.GET.items(), request, time=decoder.time, bands=decoder.dim_bands) return to_http_response(result)
def handle(self, request): decoder = WMS11GetMapDecoder(request.GET) bbox = decoder.bbox time = decoder.time srs = decoder.srs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") srid = crss.parseEPSGCode( srs, (crss.fromShortCode, crss.fromURN, crss.fromURL) ) if srid is None: raise InvalidCRS(srs, "srs") # WMS 1.1 knows no swapped axes minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=srs) if time: subsets.append(time) renderer = self.renderer root_group = lookup_layers(layers, subsets, renderer.suffixes) result, _ = renderer.render( root_group, request.GET.items(), time=decoder.time, bands=decoder.dim_bands ) return to_http_response(result)
def handle(self, request): decoder = WMS10GetMapDecoder(request.GET) bbox = decoder.bbox srs = decoder.srs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") srid = crss.parseEPSGCode( srs, (crss.fromShortCode, crss.fromURN, crss.fromURL) ) if srid is None: raise InvalidCRS(srs, "srs") # WMS 1.1 knows no swapped axes minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=srs) root_group = lookup_layers(layers, subsets) result, _ = self.renderer.render( root_group, request.GET.items(), subsets=subsets, width=int(decoder.width), height=int(decoder.height) ) return to_http_response(result)
def handle(self, request): decoder = WMS11GetFeatureInfoDecoder(request.GET) bbox = decoder.bbox time = decoder.time srs = decoder.srs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=srs) if time: subsets.append(time) renderer = self.renderer root_group = lookup_layers(layers, subsets, renderer.suffixes) result, _ = renderer.render( root_group, request.GET.items(), request, time=decoder.time, bands=decoder.dim_bands ) return to_http_response(result)
def handle(self, request): collections_qs = models.Collection.objects \ .order_by("identifier") \ .exclude( footprint__isnull=True, begin_time__isnull=True, end_time__isnull=True ) coverages = [ coverage for coverage in models.Coverage.objects \ .filter(visible=True) if not issubclass(coverage.real_type, models.Collection) ] result, _ = self.renderer.render( collections_qs, coverages, request.GET.items(), request ) return to_http_response(result)
def handle(self, request): decoder = WMS13GetMapDecoder(request.GET) bbox = decoder.bbox time = decoder.time crs = decoder.crs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") srid = crss.parseEPSGCode( crs, (crss.fromShortCode, crss.fromURN, crss.fromURL) ) if srid is None: raise InvalidCRS(crs, "crs") if crss.hasSwappedAxes(srid): miny, minx, maxy, maxx = bbox else: minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=crs) if time: subsets.append(time) renderer = self.renderer root_group = lookup_layers(layers, subsets, renderer.suffixes) result, _ = renderer.render( root_group, request.GET.items(), width=int(decoder.width), height=int(decoder.height), time=decoder.time, bands=decoder.dim_bands, subsets=subsets, elevation=decoder.elevation, dimensions=dict( (key[4:], values) for key, values in decoder.dimensions ) ) return to_http_response(result)
def handle(self, request): decoder = WMS13GetMapDecoder(request.GET) bbox = decoder.bbox time = decoder.time crs = decoder.crs layers = decoder.layers elevation = decoder.elevation if not layers: raise InvalidParameterException("No layers specified", "layers") srid = crss.parseEPSGCode( crs, (crss.fromShortCode, crss.fromURN, crss.fromURL) ) if srid is None: raise InvalidCRS(crs, "crs") if crss.hasSwappedAxes(srid): miny, minx, maxy, maxx = bbox else: minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx, crs), Trim("y", miny, maxy, crs), )) if time: subsets.append(time) renderer = self.renderer result, _ = renderer.render( layers, (minx, miny, maxx, maxy), crs, (decoder.width, decoder.height), decoder.format, time, elevation, decoder.styles ) return to_http_response(result)
def handle(self, request): decoder = WMS13GetFeatureInfoDecoder(request.GET) bbox = decoder.bbox time = decoder.time crs = decoder.crs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") srid = crss.parseEPSGCode( crs, (crss.fromShortCode, crss.fromURN, crss.fromURL)) if srid is None: raise InvalidParameterException("Invalid CRS specifier.", "crs") if crss.hasSwappedAxes(srid): miny, minx, maxy, maxx = bbox else: minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=crs) if time: subsets.append(time) renderer = self.renderer root_group = lookup_layers(layers, subsets, renderer.suffixes) result, _ = renderer.render(root_group, request.GET.items(), request, time=decoder.time, bands=decoder.dim_bands) return to_http_response(result)
def handle(self, request): decoder = WMS10GetFeatureInfoDecoder(request.GET) bbox = decoder.bbox srs = decoder.srs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=srs) root_group = lookup_layers(layers, subsets) result, _ = self.renderer.render( root_group, request.GET.items(), request ) return to_http_response(result)
def handle(self, request): decoder = WMS10GetFeatureInfoDecoder(request.GET) bbox = decoder.bbox srs = decoder.srs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=srs) root_group = lookup_layers(layers, subsets) result, _ = self.renderer.render(root_group, request.GET.items(), request) return to_http_response(result)
def handle(self, request): decoder = WMS13GetFeatureInfoDecoder(request.GET) bbox = decoder.bbox time = decoder.time crs = decoder.crs layers = decoder.layers if not layers: raise InvalidParameterException("No layers specified", "layers") srid = crss.parseEPSGCode( crs, (crss.fromShortCode, crss.fromURN, crss.fromURL) ) if srid is None: raise InvalidParameterException("Invalid CRS specifier.", "crs") if crss.hasSwappedAxes(srid): miny, minx, maxy, maxx = bbox else: minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx), Trim("y", miny, maxy), ), crs=crs) if time: subsets.append(time) renderer = self.renderer root_group = lookup_layers(layers, subsets, renderer.suffixes) result, _ = renderer.render( root_group, request.GET.items(), time=decoder.time, bands=decoder.dim_bands ) return to_http_response(result)
def handle(self, request): decoder = WMS13GetMapDecoder(request.GET) bbox = decoder.bbox time = decoder.time crs = decoder.crs layers = decoder.layers elevation = decoder.elevation if not layers: raise InvalidParameterException("No layers specified", "layers") srid = crss.parseEPSGCode( crs, (crss.fromShortCode, crss.fromURN, crss.fromURL)) if srid is None: raise InvalidCRS(crs, "crs") if crss.hasSwappedAxes(srid): miny, minx, maxy, maxx = bbox else: minx, miny, maxx, maxy = bbox subsets = Subsets(( Trim("x", minx, maxx, crs), Trim("y", miny, maxy, crs), )) if time: subsets.append(time) renderer = self.renderer result, _ = renderer.render(layers, (minx, miny, maxx, maxy), crs, (decoder.width, decoder.height), decoder.format, time, elevation, decoder.styles) return to_http_response(result)
def to_http_response(self, result_set): """ Default result to response conversion method. """ return to_http_response(result_set)
def handle(self, request): result, _ = self.renderer.render() return to_http_response(result)
def serialize(result_items, **kwargs): """ Serialize the result items to the HTTP response object. """ # pylint: disable=unused-argument return to_http_response(result_items)
def handle(self, request): decoder = WMS13GetLegendGraphicDecoder(request.GET) layer_name = decoder.layer coverage_id = decoder.coverage suffixes = self.renderer.suffixes for suffix in suffixes: try: if len(suffix or "") == 0: identifier = layer_name else: identifier = layer_name[-len(suffix):] eo_object = models.EOObject.objects.get(identifier=identifier) break except models.EOObject.DoesNotExist: pass else: raise InvalidParameterException( "No such layer '%s'." % layer_name, "layer" ) if models.iscollection(eo_object): def recursive_lookup(collection, used_ids, suffix): eo_objects = models.EOObject.objects.filter( collections__in=[collection.pk] ).exclude( pk__in=used_ids ) result = [] for eo_object in eo_objects: used_ids.add(eo_object.pk) if models.iscoverage(eo_object): result.append((eo_object.cast(), suffix)) elif models.iscollection(eo_object): result.extend( recursive_lookup(eo_object, used_ids, suffix) ) else: pass return result used_ids = set() coverages = recursive_lookup(eo_object, used_ids, suffix) collection = eo_object if coverage_id: for coverage in coverages: if coverage.identifier == coverage_id: coverages = ((coverage, suffix),) break else: raise InvalidParameterException( "Layer '%s' does not contain a coverage with ID '%s'.", "coverage" ) else: collection = None coverages = ((eo_object.cast(), suffix),) layer_selection = LayerSelection( collection if collection else None ) layer_selection.extend(coverages) result, _ = self.renderer.render(layer_selection, request.GET.items()) return to_http_response(result)
def serialize(result_items, **kwargs): return to_http_response(result_items)
def handle(self, request): decoder = WMS13GetLegendGraphicDecoder(request.GET) layer_name = decoder.layer coverage_id = decoder.coverage suffixes = (None, "_bands", "_outlines") for suffix in suffixes: try: if len(suffix or "") == 0: identifier = layer_name else: layer_name[-len(suffix):] eo_object = models.EOObject.objects.get(identifier=identifier) break except models.EOObject.DoesNotExist: pass else: raise InvalidParameterException( "No such layer '%s'." % layer_name, "layer" ) if models.iscollection(eo_object): def recursive_lookup(collection, used_ids, suffix): eo_objects = models.EOObject.objects.filter( collections__in=[collection.pk] ).exclude( pk__in=used_ids ) result = [] for eo_object in eo_objects: used_ids.add(eo_object.pk) if models.iscoverage(eo_object): result.append((eo_object.cast(), suffix)) elif models.iscollection(eo_object): result.extend( recursive_lookup(eo_object, used_ids, suffix) ) else: pass return result used_ids = set() coverages = recursive_lookup(eo_object, used_ids, suffix) collection = eo_object if coverage_id: for coverage in coverages: if coverage.identifier == coverage_id: coverages = ((coverage, suffix),) break else: raise InvalidParameterException( "Layer '%s' does not contain a coverage with ID '%s'.", "coverage" ) else: collection = None coverages = ((eo_object.cast(), suffix),) layer_selection = LayerSelection( collection.identifier if collection else None ) layer_selection.extend(coverages) result, _ = self.renderer.render(layer_selection, request.GET.items()) return to_http_response(result)
def serialize(self, result_items): return to_http_response(result_items)
def handle(self, request): # For data/metadata extraction import json from eoxserver.contrib import gdal min_level = -40 # maps to 0 in output texture max_level = 50 # maps to 255 in output texture exaggeration = 10 # multiplier for curtain height in visualization dae_converter_path="/var/vmanip/lib/collada2gltf" obj_converter_path="/var/vmanip/lib/blender/blender --background --python /var/vmanip/lib/dae2obj.py -- " decoder = W3DSGetSceneKVPDecoder(request.GET) print "Layer: %s"%decoder.layer print "Bounding box: ", decoder.boundingBox print "Time from ", decoder.time.low, " to ", decoder.time.high base_path = '/var/vmanip/data/' layer = decoder.layer[0] try: bl = BrowseLayer.objects.get(pk=layer) except BrowseLayer.DoesNotExist: bl = False #print("contains curtains: %s, contains volumes: %s, format: %s"%(bl.contains_vertical_curtains, bl.contains_volumes, decoder.format)) if layer == 'h2o_vol_demo': model_filename = join(base_path, 'H2O.nii.gz') print '[MeshFactory] delivered h2o_vol_demo product' return (open(model_filename,"r"), 'text/plain') elif layer == 'pressure_vol': model_filename = join(base_path, 'Pressure.nii.gz') print '[MeshFactory] delivered pressure_vol_demo product' return (open(model_filename,"r"), 'text/plain') elif layer == 'temperature_vol': model_filename = join(base_path, 'Temperature.nii.gz') print '[MeshFactory] delivered temperature_vol_demo product' return (open(model_filename,"r"), 'text/plain') TextureResolutionPerTile = 256 GeometryResolutionPerTile = 16 MaximalCurtainsPerResponse = 32 output_dir=tempfile.mkdtemp(prefix='tmp_meshfactory_') print "creating %s"%output_dir # create new collada scene mesh = Collada() geom_nodes=[] # list for all the curtain parts # debug response generation! response = [] result_set = [] bbox=Polygon.from_bbox(tuple(decoder.boundingBox)) mybbox=BoundingBox(decoder.boundingBox[0], decoder.boundingBox[1], decoder.boundingBox[2], decoder.boundingBox[3]) # use a minimal step size of (diagonal of bbox) / GeometryResolutionPerTile minimalStepSize = v2dp(decoder.boundingBox[0], decoder.boundingBox[1], 0.0).great_circle_distance( v2dp(decoder.boundingBox[2], decoder.boundingBox[3], 0.0)) / GeometryResolutionPerTile #response.append( "minimal step size: %6.4f<br>" % minimalStepSize ) timesubset = Subsets([Trim("t", decoder.time.low, decoder.time.high)]) # trim to requested time interval if bl and bl.contains_vertical_curtains: print "Curtain creation" # iterate over all "curtain" coverages for l in decoder.layer: layer = models.DatasetSeries.objects.get(identifier=l) #pdb.set_trace() for coverage in timesubset.filter(models.CurtainCoverage.objects.filter(collections__in=[layer.pk]).filter(footprint__intersects=bbox)): logger.info('Creating Curtain data for coverage: %s' % (coverage.identifier,)) # write the ID of the coverage response.append("%s: " % coverage.identifier) # retrieve the data item pointing to the raster data raster_item = coverage.data_items.get( semantic__startswith="bands" ) in_name=raster_item.location # texture file name # construct the texture names for conversion name=str(uuid4()) # generate a REALLY unique identifier out_name=os.path.join(output_dir, name+'.png') textureImage = Image.open(in_name) # textureImage = Image.open('/vagrant/shares/data/UV_map.png') # debug texture print "Texture="+in_name (width, height) = textureImage.size if textureImage.mode == 'F': # still a float image: (we expect 8bit) # map a subrange of a float image to an 8 bit PNG i = np.array(list(textureImage.getdata())).reshape(textureImage.size[::-1]) g = np.divide(np.subtract(i, min_level), (max_level - min_level) / 255.0) g[g < 0] = 0 textureImage = Image.fromarray(g.astype(np.uint8), 'L') # open it with GDAL to get the width/height of the raster # ds = gdal.Open(raster_item.location) # width=ds.RasterXSize # height=ds.RasterYSize # retrieve the data item pointing to the height values/levels height_values_item = coverage.data_items.get( semantic__startswith="heightvalues" ) # retrieve the data item pointing to the coordinates gcps_item = coverage.data_items.get( semantic__startswith="gcps" ) # load the json files to lists with open(height_values_item.location) as f: height_values = json.load(f) heightLevelsList=np.array(height_values) with open(gcps_item.location) as f: gcps = json.load(f) coords=np.array(gcps) X=coords[:,0] Y=coords[:,1] # write out the coordinates #print "%d coordinates (Xmin: %d, Xmax: %d, Ymin: %d, Ymax: %d), %d height levels (min: %d, max: %d)<br/>" % (len(gcps), X.min(), X.max(), Y.min(), Y.max(), len(height_values), heightLevelsList.min(), heightLevelsList.max()) # now build the geometry: # stuff curtain piece footprint in polyline polyline=list() [x, y, u, v] = gcps[0] previous_position = v2dp(x, y, u) polyline.append(v2dp(x, y, u)) # insert first ColRow entry for [x, y, u, v] in gcps[1:-1]: # loop over inner ColRows position = v2dp(x, y, u) if position.great_circle_distance(previous_position) >= minimalStepSize: polyline.append(position) # append only ColRows with minimal step size previous_position = position #[u, v, x, y] = UVXY[-1] [x, y, u, v] = gcps[-1] polyline.append(v2dp(x, y, u)) # insert last ColRow entry #print "- %d nodes, length curtain = %6.3f" % ( # len(polyline), polyline[0].great_circle_distance(polyline[-1])) # clip curtain on bounding box polylist=clipPolylineBoundingBoxOnSphere(polyline, mybbox) u_min = sys.float_info.max u_max = -sys.float_info.max #print " width=%d"%width if len(polylist)>0: # create a unique material for each texture matnode = make_emissive_material(mesh, "Material-"+name, name+".png") # determine texture coordinate U range for pl in polylist: if len(pl)>0: # now build the geometry t=trianglestrip() for p in pl: u = p.u u_min = min (u_min, u) u_max = max (u_max, u) #print "U: min=%f, max=%f"%(u_min, u_max) u_scale=u_max-u_min # convert all clipped polylines to triangle strips n=0 if (u_scale>sys.float_info.min): for pl in polylist: if len(pl)>0: # now build the geometry t=trianglestrip() for p in pl: x=p.x y=p.y u = ((p.u - u_min)/ u_scale) # normalize u to range [0,1] print ("U(%5.2f %5.2f) X, Y=(%5.2f,%5.2f), " % (p.u, u, x, y)) point = geocoord.fromGeoTo3D(np.array((x, y, heightLevelsList.min()))) t.add_point(point, [u, 0], [0, 0, 1]) point = geocoord.fromGeoTo3D(np.array((x, y, heightLevelsList.max() * exaggeration))) t.add_point(point, [u, 1], [0, 0, 1]) n=n+1 # put everything in a geometry node geomnode = t.make_geometry(mesh, "Strip-%d-" % n + name, # return time interval as meta data appended in geometry id "%s-%s_%s"%(name, coverage.begin_time.isoformat(), coverage.end_time.isoformat()), matnode) # all these pieces have the same material geom_nodes.append(geomnode) # now crop the image to the resolution we need: textureImage = textureImage.crop((int(round(u_min)), 0, int(round(u_max)) + 1, height)) # and resize it to the maximum allowed tile size (width, height) = textureImage.size if width > TextureResolutionPerTile: height = float(height) * float(TextureResolutionPerTile) / float(width) width = float(TextureResolutionPerTile) if height > TextureResolutionPerTile: height = float(TextureResolutionPerTile) width = float(width) * float(TextureResolutionPerTile) / float(height) textureImage = textureImage.resize((int(round(width)), int(round(height))), Image.ANTIALIAS) textureImage.save(out_name, "PNG") print 'texture %s resized to w=%5.2f h=%5.2f'%(out_name, width, height) # put all the geometry nodes in a scene node node = scene.Node("node0", children=geom_nodes) myscene = scene.Scene("myscene", [node]) mesh.scenes.append(myscene) mesh.scene = myscene id = str(uuid4()) out_file_dae=os.path.join(output_dir, id + '.dae') out_file_gltf=os.path.join(output_dir, id + '.json') out_file_obj=os.path.join(output_dir, id + '.obj') # now write the collada file to a temporary location mesh.write(out_file_dae) ##print("Format = '%s'"%decoder.format) logger.info('Creating response data for curtain in format: %s' % (decoder.format,)) if decoder.format == "model/obj": # and convert it to obj converter_output=os.popen(obj_converter_path+out_file_dae+" "+out_file_obj).read() print("convert from %s to %s:"%(out_file_dae, out_file_obj)) else: # or convert it to glTF converter_output=os.popen(dae_converter_path+" -f "+out_file_dae+" -o "+out_file_gltf).read() print("convert from %s to %s:"%(out_file_dae, out_file_gltf)) print converter_output #pdb.set_trace() #response.append(converter_path+" -f "+out_file_dae+" -o "+out_file_gltf) #response.append("<h3>converter output</h3><pre>") #response.append(converter_output+"</pre>") os.remove(out_file_dae) # we do not need the collada file anymore # now put all files generated by the converter in the multipart response outfiles = glob.glob(output_dir + '/*.*') for of in outfiles: print "attaching file: ", of contenttype = "" if of.endswith('.obj'): contenttype = "model/obj" elif of.endswith('.mtl'): contenttype = "text/plain" elif of.endswith('.png'): contenttype = "image/png" else: contenttype = "application/octet-stream" result_set.append(ResultFile(of, filename=os.path.split(of)[1], content_type=contenttype)) logger.info('Returning curtain response') response=to_http_response(result_set) elif bl and bl.contains_volumes: print "Volumes!" # iterate over all "volume" coverages result = [] for l in decoder.layer: layer = models.DatasetSeries.objects.get(identifier=l) #pdb.set_trace() for coverage in timesubset.filter(models.CubeCoverage.objects.filter(collections__in=[layer.pk]).filter(footprint__intersects=bbox)): #for coverage in models.CubeCoverage.objects.filter(collections__in=[layer.pk]).filter(footprint__intersects=bbox): # retrieve the data item pointing to the raster data raster_item = coverage.data_items.get( semantic__startswith="bands" ) in_name=raster_item.location # texture file name print("ID=%s, Name=%s " % (coverage.identifier, in_name)) id = str(uuid4()) out_file_nii=os.path.join(output_dir, id + '.nii.gz') convert_GeoTIFF_2_NiFTi(coverage, in_name, out_file_nii, decoder.boundingBox, decoder.crs) #pdb.set_trace() result.append(ResultFile(out_file_nii, content_type='application/x-nifti')) response = to_http_response(result) elif decoder.format == "model/nii-gz": print "2D Volume creation" # iterate over all "volume" coverages result = [] for l in decoder.layer: layer = models.DatasetSeries.objects.get(identifier=l) coverage_collection = [] id = str(uuid4()) out_file_nii=os.path.join(output_dir, id + '.nii.gz') for coverage in timesubset.filter(models.RectifiedDataset.objects.filter(collections__in=[layer.pk]).filter(footprint__intersects=bbox)): #retrieve the data item pointing to the raster data raster_item = coverage.data_items.get( semantic__startswith="bands" ) in_name=raster_item.location # texture file name coverage_collection.append((coverage, in_name)) convert_collection_GeoTIFF_2_NiFTi(coverage_collection, out_file_nii, decoder.boundingBox, decoder.crs) result.append(ResultFile(out_file_nii, content_type='application/x-nifti')) response = to_http_response(result) print "removing %s"%output_dir shutil.rmtree(output_dir) # remove temp directory return response # return response