def perform_subset(self,
src_ds,
range_type,
subset_rect,
dst_rect,
rangesubset=None):
vrt = VRTBuilder(*subset_rect.size)
input_bands = list(range_type)
# list of band indices/names. defaults to all bands
if rangesubset:
subset_bands = rangesubset.get_band_indices(range_type, 1)
else:
subset_bands = xrange(1, len(range_type) + 1)
for dst_index, src_index in enumerate(subset_bands, start=1):
input_band = input_bands[src_index - 1]
vrt.add_band(input_band.data_type)
vrt.add_simple_source(dst_index, src_ds, src_index, subset_rect,
dst_rect)
vrt.copy_metadata(src_ds)
vrt.copy_gcps(src_ds, subset_rect)
return vrt.dataset
def get_source_dataset(self, coverage, data_items, range_type):
if len(data_items) == 1:
return gdal.OpenShared(abspath(connect(data_items[0])))
else:
vrt = VRTBuilder(
coverage.size_x, coverage.size_y,
vrt_filename=temp_vsimem_filename()
)
# sort in ascending order according to semantic
data_items = sorted(data_items, key=(lambda d: d.semantic))
gcps = []
compound_index = 0
for data_item in data_items:
path = abspath(connect(data_item))
# iterate over all bands of the data item
for set_index, item_index in self._data_item_band_indices(data_item):
if set_index != compound_index + 1:
raise ValueError
compound_index = set_index
band = range_type[set_index]
vrt.add_band(band.data_type)
vrt.add_simple_source(
set_index, path, item_index
)
return vrt.dataset
def get_source_and_dest_rect(self, dataset, subsets):
size_x, size_y = dataset.RasterXSize, dataset.RasterYSize
image_rect = Rect(0, 0, size_x, size_y)
if not subsets:
subset_rect = image_rect
# pixel subset
elif subsets.srid is None: # means "imageCRS"
minx, miny, maxx, maxy = subsets.xy_bbox
minx = int(minx) if minx is not None else image_rect.offset_x
miny = int(miny) if miny is not None else image_rect.offset_y
maxx = int(maxx) if maxx is not None else image_rect.upper_x
maxy = int(maxy) if maxy is not None else image_rect.upper_y
subset_rect = Rect(minx, miny, maxx - minx + 1, maxy - miny + 1)
# subset in geographical coordinates
else:
vrt = VRTBuilder(*image_rect.size)
vrt.copy_gcps(dataset)
options = reftools.suggest_transformer(dataset)
subset_rect = reftools.rect_from_subset(vrt.dataset, subsets.srid, *subsets.xy_bbox, **options)
# check whether or not the subsets intersect with the image
if not image_rect.intersects(subset_rect):
raise RenderException("Subset outside coverage extent.", "subset")
src_rect = subset_rect # & image_rect # TODO: why no intersection??
dst_rect = src_rect - subset_rect.offset
return src_rect, dst_rect
def get_subset(src_ds, range_type, subset_rect, dst_rect, rangesubset=None):
""" Get subset of the image (as GDAL dataset) matching the requsted
pixel rectangle.
"""
vrt = VRTBuilder(*subset_rect.size)
input_bands = list(range_type)
# list of band indices/names. defaults to all bands
if rangesubset:
subset_bands = rangesubset.get_band_indices(range_type, 1)
else:
subset_bands = xrange(1, len(range_type) + 1)
for dst_index, src_index in enumerate(subset_bands, start=1):
input_band = input_bands[src_index-1]
vrt.add_band(input_band.data_type)
vrt.add_simple_source(
dst_index, src_ds, src_index, subset_rect, dst_rect
)
vrt.copy_metadata(src_ds)
vrt.copy_gcps(src_ds, subset_rect)
return vrt.dataset
def perform_range_subset(self, src_ds, range_type, subset_bands,
subset_rect):
vrt = VRTBuilder(src_ds.RasterXSize, src_ds.RasterYSize)
dst_rect = Rect(0, 0, src_ds.RasterXSize, src_ds.RasterYSize)
input_bands = list(range_type)
for index, subset_band in enumerate(subset_bands, start=1):
if isinstance(subset_band, int):
if subset_band > 0:
subset_band = len(range_type) + subset_band
else:
subset_band = index_of(input_bands,
lambda band: (
band.name == subset_band
or band.identifier == subset_band
)
)
if subset_band is None:
raise ValueError("Invalid range subset.")
# prepare and add a simple source for the band
input_band = input_bands[subset_band]
vrt.add_band(input_band.data_type)
vrt.add_simple_source(
index, src_ds, subset_band, subset_rect, dst_rect
)
vrt.copy_metadata(src_ds)
vrt.copy_gcps(src_ds, subset_rect)
return vrt.dataset
def perform_subset(self, src_ds, subset_rect):
vrt = VRTBuilder(src_ds.RasterXSize, src_ds.RasterYSize)
dst_rect = Rect(0, 0, src_ds.RasterXSize, src_ds.RasterYSize)
for index in xrange(1, src_ds.RasterCount + 1):
src_band = src_ds.GetRasterBand(index)
vrt.add_band(src_band.DataType)
vrt.add_simple_source(index, src_ds, index, subset_rect, dst_rect)
vrt.copy_metadata(src_ds)
vrt.copy_gcps(src_ds, subset_rect)
return vrt.dataset
def get_source_dataset(self, coverage, data_items, range_type):
if len(data_items) == 1:
return gdal.OpenShared(abspath(connect(data_items[0])))
else:
vrt = VRTBuilder(coverage.size_x,
coverage.size_y,
vrt_filename=temp_vsimem_filename())
# sort in ascending order according to semantic
data_items = sorted(data_items, key=(lambda d: d.semantic))
gcps = []
compound_index = 0
for data_item in data_items:
path = abspath(connect(data_item))
# iterate over all bands of the data item
for set_index, item_index in self._data_item_band_indices(
data_item):
if set_index != compound_index + 1:
raise ValueError
compound_index = set_index
band = range_type[set_index]
vrt.add_band(band.data_type)
vrt.add_simple_source(set_index, path, item_index)
return vrt.dataset
def get_source_image_rect(self, dataset, subsets):
size_x, size_y = dataset.RasterXSize, dataset.RasterYSize
image_rect = Rect(0, 0, size_x, size_y)
if not subsets:
subset_rect = image_rect
# pixel subset
elif subsets.xy_srid is None: # means "imageCRS"
minx, miny, maxx, maxy = subsets.xy_bbox
minx = minx if minx is not None else image_rect.offset_x
miny = miny if miny is not None else image_rect.offset_y
maxx = maxx if maxx is not None else image_rect.upper_x
maxy = maxy if maxy is not None else image_rect.upper_y
subset_rect = Rect(minx, miny, maxx-minx, maxy-miny)
else:
vrt = VRTBuilder(size_x, size_y)
vrt.copy_gcps(dataset)
minx, miny, maxx, maxy = subsets.xy_bbox
# subset in geographical coordinates
subset_rect = reftools.rect_from_subset(
vrt.dataset, subsets.xy_srid, minx, miny, maxx, maxy
)
# check whether or not the subsets intersect with the image
if not image_rect.intersects(subset_rect):
raise Exception("Subset outside coverage extent.") # TODO: correct exception
# in case the input and output rects are the same, return None to
# indicate this
#if image_rect == subset_rect:
# return None
return image_rect & subset_rect
def get_source_and_dest_rect(self, dataset, subsets):
size_x, size_y = dataset.RasterXSize, dataset.RasterYSize
image_rect = Rect(0, 0, size_x, size_y)
if not subsets:
subset_rect = image_rect
# pixel subset
elif subsets.srid is None: # means "imageCRS"
minx, miny, maxx, maxy = subsets.xy_bbox
minx = int(minx) if minx is not None else image_rect.offset_x
miny = int(miny) if miny is not None else image_rect.offset_y
maxx = int(maxx) if maxx is not None else image_rect.upper_x
maxy = int(maxy) if maxy is not None else image_rect.upper_y
subset_rect = Rect(minx, miny, maxx - minx + 1, maxy - miny + 1)
# subset in geographical coordinates
else:
vrt = VRTBuilder(*image_rect.size)
vrt.copy_gcps(dataset)
options = reftools.suggest_transformer(dataset)
subset_rect = reftools.rect_from_subset(vrt.dataset, subsets.srid,
*subsets.xy_bbox,
**options)
# check whether or not the subsets intersect with the image
if not image_rect.intersects(subset_rect):
raise RenderException("Subset outside coverage extent.", "subset")
src_rect = subset_rect #& image_rect # TODO: why no intersection??
dst_rect = src_rect - subset_rect.offset
return src_rect, dst_rect
def perform_subset(self, src_ds, range_type, subset_rect, dst_rect, rangesubset=None):
vrt = VRTBuilder(*subset_rect.size)
input_bands = list(range_type)
# list of band indices/names. defaults to all bands
if rangesubset:
subset_bands = rangesubset.get_band_indices(range_type, 1)
else:
subset_bands = xrange(1, len(range_type) + 1)
for dst_index, src_index in enumerate(subset_bands, start=1):
input_band = input_bands[src_index - 1]
vrt.add_band(input_band.data_type)
vrt.add_simple_source(dst_index, src_ds, src_index, subset_rect, dst_rect)
vrt.copy_metadata(src_ds)
vrt.copy_gcps(src_ds, subset_rect)
return vrt.dataset
def create_diff_label(self, master_id, slave_id, bbox, num_bands, crs, unit):
""" The main execution function for the process.
"""
#srid = crss.parseEPSGCode(str(crs), (crss.fromShortCode, crss.fromURN, crss.fromURL))
master = models.RectifiedDataset.objects.get(identifier=master_id)
slave = models.RectifiedDataset.objects.get(identifier=slave_id)
filename_master = connect(master.data_items.get(semantic__startswith="bands"))
filename_slave = connect(slave.data_items.get(semantic__startswith="bands"))
ds_master = gdal.Open(filename_master, gdalconst.GA_ReadOnly)
ds_slave = gdal.Open(filename_slave, gdalconst.GA_ReadOnly)
master_bbox = master.footprint.extent
slave_bbox = slave.footprint.extent
res_x_master = (master_bbox[2] - master_bbox[0]) / ds_master.RasterXSize
res_y_master = (master_bbox[3] - master_bbox[1]) / ds_master.RasterYSize
res_x_slave = (slave_bbox[2] - slave_bbox[0]) / ds_slave.RasterXSize
res_y_slave = (slave_bbox[3] - slave_bbox[1]) / ds_slave.RasterYSize
size_x = int((bbox[2]-bbox[0])/res_x_master)
size_y = int((bbox[3]-bbox[1])/res_y_master)
builder = VRTBuilder(size_x, size_y, (num_bands*2), master.range_type.bands.all()[0].data_type)
dst_rect_master = (
int( math.floor((master_bbox[0] - bbox[0]) / res_x_master) ), # x offset
int( math.floor((bbox[3] - master_bbox[3]) / res_y_master) ), # y offset
ds_master.RasterXSize, # x size
ds_master.RasterYSize # y size
)
dst_rect_slave = (
int( math.floor((slave_bbox[0] - bbox[0]) / res_x_slave) ), # x offset
int( math.floor((bbox[3] - slave_bbox[3]) / res_y_slave) ), # y offset
ds_slave.RasterXSize, # x size
ds_slave.RasterYSize # y size
)
for i in range(1, num_bands+1):
builder.add_simple_source(i, str(filename_master), i, src_rect=(0, 0, ds_master.RasterXSize, ds_master.RasterYSize), dst_rect=dst_rect_master)
builder.add_simple_source(num_bands+i , str(filename_slave), i, src_rect=(0, 0, ds_slave.RasterXSize, ds_slave.RasterYSize), dst_rect=dst_rect_slave)
ext = Rect(0,0,size_x, size_y)
pix_master = builder.dataset.GetRasterBand(1).ReadAsArray()
pix_slave = builder.dataset.GetRasterBand(num_bands +1).ReadAsArray()
if num_bands == 1:
pix_master = np.dstack((pix_master, builder.dataset.GetRasterBand(1).ReadAsArray()))
pix_slave = np.dstack((pix_slave, builder.dataset.GetRasterBand(2).ReadAsArray()))
else:
for i in range(2, num_bands+1):
pix_master = np.dstack((pix_master, builder.dataset.GetRasterBand(i).ReadAsArray()))
pix_slave = np.dstack((pix_slave, builder.dataset.GetRasterBand(num_bands+i).ReadAsArray()))
def _diff(a,b):
d = np.array(a[:,:,0],'float32') - np.array(b[:,:,0],'float32')
return d
pix_res = _diff(pix_master, pix_slave)
res_max = np.max(pix_res)
res_min = np.min(pix_res)
# Make a figure and axes with dimensions as desired.
fig = pyplot.figure(figsize=(8,1))
fig.patch.set_alpha(0.8)
ax1 = fig.add_axes([0.05, 0.75, 0.9, 0.15])
def savefig_pix(fig,fname,width,height,dpi=100):
rdpi = 1.0/float(dpi)
fig.set_size_inches(width*rdpi,height*rdpi)
fig.savefig(fname,dpi=dpi)
# Set the colormap and norm to correspond to the data for which
# the colorbar will be used.
cmap = mpl.cm.RdBu
#norm = mpl.colors.Normalize(vmin=res_min, vmax=res_max)
res_ = max(abs(res_max), abs(res_min))
norm = mpl.colors.Normalize(vmin=-res_, vmax=res_)
cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap,
norm=norm,
orientation='horizontal')
mis = master_id.split("_")
master_id_label = " ".join( (mis[0], mis[1], mis[2], isoformat(master.begin_time)) )
sis = slave_id.split("_")
slave_id_label = " ".join( (sis[0], sis[1], sis[2], isoformat(slave.begin_time)) )
if unit:
label = "Difference from %s \n to %s; Unit: %s"%(slave_id_label, master_id_label, unit)
else:
label = "Difference from %s \n to %s"%(slave_id_label, master_id_label)
cb1.set_label(label)
# the output image
basename = "%s_%s"%( self.identifier,uuid4().hex )
filename_png = "/tmp/%s.png" %( basename )
try:
fig.savefig(filename_png, dpi=80)
with open(filename_png) as f:
output = f.read()
except Exception as e:
if os.path.isfile(filename_png):
os.remove(filename_png)
raise e
else:
os.remove(filename_png)
return output
def diff_process(self, master_id, slave_id, bbox, num_bands, crs):
""" The main execution function for the process.
"""
#srid = crss.parseEPSGCode(str(crs), (crss.fromShortCode, crss.fromURN, crss.fromURL))
master = models.RectifiedDataset.objects.get(identifier=master_id)
slave = models.RectifiedDataset.objects.get(identifier=slave_id)
filename_master = connect(master.data_items.get(semantic__startswith="bands"))
filename_slave = connect(slave.data_items.get(semantic__startswith="bands"))
ds_master = gdal.Open(filename_master, gdalconst.GA_ReadOnly)
ds_slave = gdal.Open(filename_slave, gdalconst.GA_ReadOnly)
master_bbox = master.footprint.extent
slave_bbox = slave.footprint.extent
res_x_master = (master_bbox[2] - master_bbox[0]) / ds_master.RasterXSize
res_y_master = (master_bbox[3] - master_bbox[1]) / ds_master.RasterYSize
res_x_slave = (slave_bbox[2] - slave_bbox[0]) / ds_slave.RasterXSize
res_y_slave = (slave_bbox[3] - slave_bbox[1]) / ds_slave.RasterYSize
size_x = int((bbox[2]-bbox[0])/res_x_master)
size_y = int((bbox[3]-bbox[1])/res_y_master)
builder = VRTBuilder(size_x, size_y, (num_bands*2), master.range_type.bands.all()[0].data_type)
dst_rect_master = (
int( math.floor((master_bbox[0] - bbox[0]) / res_x_master) ), # x offset
int( math.floor((bbox[3] - master_bbox[3]) / res_y_master) ), # y offset
ds_master.RasterXSize, # x size
ds_master.RasterYSize # y size
)
dst_rect_slave = (
int( math.floor((slave_bbox[0] - bbox[0]) / res_x_slave) ), # x offset
int( math.floor((bbox[3] - slave_bbox[3]) / res_y_slave) ), # y offset
ds_slave.RasterXSize, # x size
ds_slave.RasterYSize # y size
)
for i in range(1, num_bands+1):
builder.add_simple_source(i, str(filename_master), i, src_rect=(0, 0, ds_master.RasterXSize, ds_master.RasterYSize), dst_rect=dst_rect_master)
builder.add_simple_source(num_bands+i , str(filename_slave), i, src_rect=(0, 0, ds_slave.RasterXSize, ds_slave.RasterYSize), dst_rect=dst_rect_slave)
ext = Rect(0,0,size_x, size_y)
pix_master = builder.dataset.GetRasterBand(1).ReadAsArray()
pix_slave = builder.dataset.GetRasterBand(num_bands +1).ReadAsArray()
if num_bands == 1:
pix_master = np.dstack((pix_master, builder.dataset.GetRasterBand(1).ReadAsArray()))
pix_slave = np.dstack((pix_slave, builder.dataset.GetRasterBand(2).ReadAsArray()))
else:
for i in range(2, num_bands+1):
pix_master = np.dstack((pix_master, builder.dataset.GetRasterBand(i).ReadAsArray()))
pix_slave = np.dstack((pix_slave, builder.dataset.GetRasterBand(num_bands+i).ReadAsArray()))
def _diff(a,b):
d = np.array(a[:,:,0],'float32') - np.array(b[:,:,0],'float32')
return d
pix_res = _diff(pix_master, pix_slave)
res_max = np.max(pix_res)
res_min = np.min(pix_res)
res_ = max(abs(res_max), abs(res_min))
# the output image
basename = "%s_%s"%( self.identifier,uuid4().hex )
filename_png = "/tmp/%s.png" %( basename )
try:
#fig = pyplot.imshow(pix_res,interpolation='nearest')
fig = pyplot.imshow(pix_res,vmin=-res_, vmax=res_, interpolation='nearest')
fig.set_cmap('RdBu')
fig.write_png(filename_png, True)
with open(filename_png) as f:
output = f.read()
except Exception as e:
if os.path.isfile(filename_png):
os.remove(filename_png)
raise e
else:
os.remove(filename_png)
#return base64.b64encode(output)
return output
def convert_collection_GeoTIFF_2_NiFTi (coverage_collection, out_fname, bbox, crs):
srid = crss.parseEPSGCode(crs, (crss.fromShortCode, crss.fromURN, crss.fromURL))
raster_collection = []
dataset = gdal.Open(coverage_collection[0][1], gdalconst.GA_ReadOnly)
image_bbox = coverage_collection[0][0].footprint.extent
res_x = (image_bbox[2] - image_bbox[0]) / dataset.RasterXSize
res_y = (image_bbox[1] - image_bbox[3]) / dataset.RasterYSize
size_x = abs(int((bbox[2]-bbox[0])/res_x))
size_y = abs(int((bbox[3]-bbox[1])/res_y))
builder = VRTBuilder(size_x, size_y, len(coverage_collection), coverage_collection[0][0].range_type.bands.all()[0].data_type)
for i, (coverage, in_fname) in enumerate(coverage_collection, start=1):
dataset = gdal.Open(str(in_fname), gdalconst.GA_ReadOnly)
in_sr = osr.SpatialReference()
in_sr.ImportFromEPSG(4326) # TODO: get real projection value
out_sr = osr.SpatialReference()
out_sr.ImportFromEPSG(srid)
if not in_sr.IsSame(out_sr):
raise Exception(dataset.GetProjection())
ct = osr.CoordinateTransformation(out_sr, in_sr)
p0 = ct.TransformPoint(bbox[0], bbox[1])
p1 = ct.TransformPoint(bbox[2], bbox[3])
image_bbox = coverage.footprint.extent
res_x = abs(image_bbox[2] - image_bbox[0]) / dataset.RasterXSize
res_y = abs(image_bbox[1] - image_bbox[3]) / dataset.RasterYSize
dst_rect = (
int( math.floor((image_bbox[0] - bbox[0]) / res_x) ), # x offset
int( math.floor((bbox[3] - image_bbox[3]) / res_y) ), # y offset
dataset.RasterXSize, # x size
dataset.RasterYSize # y size
)
builder.add_simple_source(i, str(in_fname), 1, src_rect=(0, 0, dataset.RasterXSize, dataset.RasterYSize), dst_rect=dst_rect)
volume = builder.dataset.GetRasterBand(1).ReadAsArray()
for i in range(2, len(coverage_collection) + 1):
volume = np.dstack((volume, builder.dataset.GetRasterBand(i).ReadAsArray()))
offset = random.uniform(0.00000000000000, 0.00000000000001)
scale = np.array([res_y*800+offset,res_x*800+offset,res_x*2400+offset,1])
affine = np.diag(scale)
img = nib.Nifti1Image(volume, affine)
#img = nib.Nifti1Image(volume, np.eye(4))
img.to_filename(out_fname)
