Ejemplo n.º 1
0
    def connect(self, coverage, data_items, layer):
        filtered = filter(lambda d: d.semantic.startswith("bands"), data_items)
        data = connect(filtered[0])

        if isinstance(coverage, models.ReferenceableDataset):
            vrt_path = join("/vsimem", uuid4().hex)
            reftools.create_rectified_vrt(data, vrt_path)
            data = vrt_path
            layer.setMetaData("eoxs_ref_data", data)

        if not layer.metadata.get("eoxs_wrap_dateline") == "true":
            layer.data = data
        else:
            e = wrap_extent_around_dateline(coverage.extent, coverage.srid)

            vrt_path = join("/vsimem", uuid4().hex)
            ds = gdal.Open(data)
            vrt_ds = create_simple_vrt(ds, vrt_path)
            size_x = ds.RasterXSize
            size_y = ds.RasterYSize
            
            dx = abs(e[0] - e[2]) / size_x
            dy = abs(e[1] - e[3]) / size_y 
            
            vrt_ds.SetGeoTransform([e[0], dx, 0, e[3], 0, -dy])
            vrt_ds = None
            
            layer.data = vrt_path
Ejemplo n.º 2
0
    def connect(self, coverage, data_items, layer, options):
        path = join("/vsimem", uuid4().hex)
        range_type = coverage.range_type
        num_bands = len(coverage.range_type)

        vrt_builder = vrt.VRTBuilder(coverage.size_x, coverage.size_y, vrt_filename=path)

        bands_re = re.compile(r"bands\[(\d+)(,\d+)?\]")

        for data_item in sorted(data_items, key=lambda d: d.semantic):
            start, end = bands_re.match(data_item.semantic).groups()
            start = int(start)
            end = int(end) if end is not None else None
            if end is None:
                dst_band_indices = range(start + 1, start + 2)
                src_band_indices = range(1, 2)
            else:
                dst_band_indices = range(start + 1, end + 2)
                src_band_indices = range(1, end - start + 1)

            for src_index, dst_index in zip(src_band_indices, dst_band_indices):
                vrt_builder.add_band(range_type[dst_index - 1].data_type)
                vrt_builder.add_simple_source(
                    dst_index,
                    # gdal.OpenShared(data_item.location),
                    data_item.location,
                    src_index,
                )

        print data_items[0].location
        print gdal.OpenShared(data_items[0].location).GetGCPs()
        if isinstance(coverage, models.ReferenceableDataset):
            vrt_builder.copy_gcps(gdal.OpenShared(data_items[0].location))
            layer.setMetaData("eoxs_ref_data", path)

        layer.data = path

        # with vsi.open(path, "w+") as f:
        #    print type(vrt_builder.build())
        #    f.write(vrt_builder.build())

        del vrt_builder
        with vsi.open(path) as f:
            print f.read(100000)

        # layer.clearProcessing()
        # layer.addProcessing("SCALE_1=1,4")
        # layer.addProcessing("BANDS=2")
        # layer.offsite = mapserver.colorObj(0,0,0)

        if isinstance(coverage, models.ReferenceableDataset):
            vrt_path = join("/vsimem", uuid4().hex)
            reftools.create_rectified_vrt(path, vrt_path)
            layer.data = vrt_path
            layer.setMetaData("eoxs_ref_data", path)

            with vsi.open(vrt_path) as f:
                print f.read(100000)

        """
Ejemplo n.º 3
0
    def connect(self, coverage, data_items, layer, options):
        data = data_items[0].path

        if coverage.grid.is_referenceable:
            vrt_path = join("/vsimem", uuid4().hex)
            reftools.create_rectified_vrt(data, vrt_path)
            data = vrt_path
            layer.setMetaData("eoxs_ref_data", data)

        if not layer.metadata.get("eoxs_wrap_dateline") == "true":
            layer.data = data
        else:
            sr = coverage.grid.spatial_reference
            extent = coverage.extent
            e = wrap_extent_around_dateline(extent, sr.srid)

            vrt_path = join("/vsimem", uuid4().hex)
            ds = gdal.Open(data)
            vrt_ds = create_simple_vrt(ds, vrt_path)
            size_x = ds.RasterXSize
            size_y = ds.RasterYSize

            dx = abs(e[0] - e[2]) / size_x
            dy = abs(e[1] - e[3]) / size_y

            vrt_ds.SetGeoTransform([e[0], dx, 0, e[3], 0, -dy])
            vrt_ds = None

            layer.data = vrt_path
Ejemplo n.º 4
0
    def connect(self, coverage, data_items, layer, options):
        filtered = filter(lambda d: d.semantic.startswith("bands"), data_items)
        data = connect(filtered[0])

        if isinstance(coverage, models.ReferenceableDataset):
            vrt_path = join("/vsimem", uuid4().hex)
            reftools.create_rectified_vrt(data, vrt_path)
            data = vrt_path
            layer.setMetaData("eoxs_ref_data", data)

        if not layer.metadata.get("eoxs_wrap_dateline") == "true":
            layer.data = data
        else:
            e = wrap_extent_around_dateline(coverage.extent, coverage.srid)

            vrt_path = join("/vsimem", uuid4().hex)
            ds = gdal.Open(data)
            vrt_ds = create_simple_vrt(ds, vrt_path)
            size_x = ds.RasterXSize
            size_y = ds.RasterYSize

            dx = abs(e[0] - e[2]) / size_x
            dy = abs(e[1] - e[3]) / size_y

            vrt_ds.SetGeoTransform([e[0], dx, 0, e[3], 0, -dy])
            vrt_ds = None

            layer.data = vrt_path
Ejemplo n.º 5
0
    def connect(self, coverage, data_items, layer, options):
        path = join("/vsimem", uuid4().hex)
        range_type = coverage.range_type

        # size_x, size_y = coverage.size[:2]
        # vrt_builder = vrt.VRTBuilder(size_x, size_y, vrt_filename=path)

        # for data_item in data_items:
        #     start = data_item.start_field
        #     end = data_item.end_field
        #     if end is None:
        #         dst_band_indices = range(start+1, start+2)
        #         src_band_indices = range(1, 2)
        #     else:
        #         dst_band_indices = range(start+1, end+2)
        #         src_band_indices = range(1, end-start+1)

        #     for src_index, dst_index in zip(src_band_indices, dst_band_indices):
        #         vrt_builder.add_band(range_type[dst_index-1].data_type)
        #         vrt_builder.add_simple_source(
        #             dst_index,
        #             data_item.path,
        #             src_index
        #         )

        # if coverage.grid.is_referenceable:
        #     vrt_builder.copy_gcps(gdal.OpenShared(data_items[0].path))
        #     layer.setMetaData("eoxs_ref_data", path)

        # layer.data = path

        # del vrt_builder

        # with vsi.open(path) as f:
        #     print f.read(100000)

        vrt.gdalbuildvrt(
            path, [location.path for location in coverage.arraydata_locations],
            separate=True)

        layer.data = path

        #layer.clearProcessing()
        #layer.addProcessing("SCALE_1=1,4")
        #layer.addProcessing("BANDS=2")
        #layer.offsite = mapserver.colorObj(0,0,0)

        if coverage.grid.is_referenceable:
            vrt_path = join("/vsimem", uuid4().hex)
            reftools.create_rectified_vrt(path, vrt_path)
            layer.data = vrt_path
            layer.setMetaData("eoxs_ref_data", path)

            with vsi.open(vrt_path) as f:
                print(f.read(100000))
        """
Ejemplo n.º 6
0
    def create_coverage_layer(self, map_obj, coverage, fields,
                              style=None, ranges=None):
        """ Creates a mapserver layer object for the given coverage
        """
        filename_generator = FilenameGenerator(
            '/vsimem/{uuid}.{extension}', 'vrt'
        )

        field_locations = [
            (field, coverage.get_location_for_field(field))
            for field in fields
        ]
        locations = [
            location
            for _, location in field_locations
        ]

        # TODO: apply subsets in time/elevation dims
        num_locations = len(set(locations))
        if num_locations == 1:
            if not coverage.grid.is_referenceable:
                location = field_locations[0][1]
                data = location.path
                ms.set_env(map_obj, location.env, True)
            else:
                vrt_path = filename_generator.generate()
                e = map_obj.extent
                resx = (e.maxx - e.minx) / map_obj.width
                resy = (e.maxy - e.miny) / map_obj.height

                wkt = osr.SpatialReference(map_obj.getProjection()).wkt

                # TODO: env?
                reftools.create_rectified_vrt(
                    field_locations[0][1].path, vrt_path,
                    order=1, max_error=10,
                    resolution=(resx, -resy), srid_or_wkt=wkt
                )
                data = vrt_path

        elif num_locations > 1:
            paths_set = set(
                field_location[1].path for field_location in field_locations
            )
            if len(paths_set) == 1:
                location = field_locations[0][1]
                data = location.path
                ms.set_env(map_obj, location.env, True)

            else:
                # TODO
                _build_vrt(coverage.size, field_locations)

        if not coverage.grid.is_referenceable:
            extent = coverage.extent
            sr = coverage.grid.spatial_reference
        else:
            map_extent = map_obj.extent
            extent = (
                map_extent.minx, map_extent.miny,
                map_extent.maxx, map_extent.maxy
            )
            sr = osr.SpatialReference(map_obj.getProjection())

        layer_objs = _create_raster_layer_objs(
            map_obj, extent, sr, data, filename_generator
        )

        for i, layer_obj in enumerate(layer_objs):
            layer_obj.name = '%s__%d' % (coverage.identifier, i)
            layer_obj.setProcessingKey("CLOSE_CONNECTION", "CLOSE")

        if num_locations == 1:
            for layer_obj in layer_objs:
                layer_obj.setProcessingKey("BANDS", ",".join([
                    str(coverage.get_band_index_for_field(field))
                    for field in fields
                ]))
        elif num_locations > 1:
            for layer_obj in layer_objs:
                if len(field_locations) == 3:
                    layer_obj.setProcessingKey("BANDS", "1,2,3")
                else:
                    layer_obj.setProcessingKey("BANDS", "1")

        # make a color-scaled layer
        if len(fields) == 1:
            field = fields[0]
            if ranges:
                range_ = ranges[0]
            else:
                range_ = _get_range(field)

            for layer_obj in layer_objs:
                _create_raster_style(
                    style or "blackwhite", layer_obj, range_[0], range_[1], [
                        nil_value[0] for nil_value in field.nil_values
                    ]
                )
        elif len(fields) in (3, 4):
            for i, field in enumerate(fields, start=1):
                if ranges:
                    if len(ranges) == 1:
                        range_ = ranges[0]
                    else:
                        range_ = ranges[i - 1]
                else:
                    range_ = _get_range(field)

                for layer_obj in layer_objs:
                    layer_obj.setProcessingKey(
                        "SCALE_%d" % i,
                        "%s,%s" % range_
                    )
                    layer_obj.offsite = ms.colorObj(0, 0, 0)

        else:
            raise Exception("Too many bands specified")

        return filename_generator
Ejemplo n.º 7
0
    def connect(self, coverage, data_items, layer, options):
        path = join("/vsimem", uuid4().hex)
        range_type = coverage.range_type
        num_bands = len(coverage.range_type)

        vrt_builder = vrt.VRTBuilder(coverage.size_x,
                                     coverage.size_y,
                                     vrt_filename=path)

        bands_re = re.compile(r"bands\[(\d+)(,\d+)?\]")

        for data_item in sorted(data_items, key=lambda d: d.semantic):
            start, end = bands_re.match(data_item.semantic).groups()
            start = int(start)
            end = int(end) if end is not None else None
            if end is None:
                dst_band_indices = range(start + 1, start + 2)
                src_band_indices = range(1, 2)
            else:
                dst_band_indices = range(start + 1, end + 2)
                src_band_indices = range(1, end - start + 1)

            for src_index, dst_index in zip(src_band_indices,
                                            dst_band_indices):
                vrt_builder.add_band(range_type[dst_index - 1].data_type)
                vrt_builder.add_simple_source(
                    dst_index,
                    #gdal.OpenShared(data_item.location),
                    data_item.location,
                    src_index)

        print data_items[0].location
        print gdal.OpenShared(data_items[0].location).GetGCPs()
        if isinstance(coverage, models.ReferenceableDataset):
            vrt_builder.copy_gcps(gdal.OpenShared(data_items[0].location))
            layer.setMetaData("eoxs_ref_data", path)

        layer.data = path

        #with vsi.open(path, "w+") as f:
        #    print type(vrt_builder.build())
        #    f.write(vrt_builder.build())

        del vrt_builder
        with vsi.open(path) as f:
            print f.read(100000)

        #layer.clearProcessing()
        #layer.addProcessing("SCALE_1=1,4")
        #layer.addProcessing("BANDS=2")
        #layer.offsite = mapserver.colorObj(0,0,0)

        if isinstance(coverage, models.ReferenceableDataset):
            vrt_path = join("/vsimem", uuid4().hex)
            reftools.create_rectified_vrt(path, vrt_path)
            layer.data = vrt_path
            layer.setMetaData("eoxs_ref_data", path)

            with vsi.open(vrt_path) as f:
                print f.read(100000)
        """