def numpy_rw_7():
if gdaltest.numpy_drv is None:
return 'skip'
import numpy
import gdalnumeric
ds = gdal.Open('data/byte.tif')
array = numpy.zeros([1, ds.RasterYSize, ds.RasterXSize], numpy.uint8)
array_res = ds.ReadAsArray(buf_obj=array)
if array is not array_res:
return 'fail'
ds2 = gdalnumeric.OpenArray(array)
if ds2.GetRasterBand(1).Checksum() != ds.GetRasterBand(1).Checksum():
return 'fail'
# Try again with a 2D array
array = numpy.zeros([ds.RasterYSize, ds.RasterXSize], numpy.uint8)
array_res = ds.ReadAsArray(buf_obj=array)
if array is not array_res:
return 'fail'
ds2 = gdalnumeric.OpenArray(array)
if ds2.GetRasterBand(1).Checksum() != ds.GetRasterBand(1).Checksum():
return 'fail'
return 'success'
def compute(self, *args):
def get_band(name):
layer = self.dict_of_bands[name][1]
b_num = self.dict_of_bands[name][2]
band = layer.get_parent().get_dataset().GetRasterBand(b_num + 1)
return band
def create_new_layer(pview, player, w, h):
"""Creates new raster layer like <player> with width = w
and height = h"""
gview.app.view_manager.set_active_view(pview)
pview.viewarea.set_active_layer(player)
target_ds = player.get_parent().get_dataset()
rl_mode_value = player.get_mode()
new_layer = gview.GvRasterLayer( \
gview.GvRaster(dataset = target_ds,real=1), \
rl_mode = rl_mode_value)
pview.viewarea.list_layers().append(new_layer)
return new_layer
# extract computing parameters
b1_name = self.list_of_bands[self.s1_list.get_history()]
b2_name = self.list_of_bands[self.s2_list.get_history()]
if b1_name <> None:
if self.switch_new_view.get_active():
gview.app.new_view()
op_index = self.operation.get_history()
type_index = self.types.get_history()
a = float(self.a_const.get_text())
b = float(self.b_const.get_text())
c = float(self.c_const.get_text())
b1 = get_band(b1_name)
b2 = get_band(b2_name)
type = \
gdal.GetDataTypeByName(self.types_list[self.types.get_history()])
self.numtype = gdalnumeric.GDALTypeCodeToNumericTypeCode(type)
if self.numtype == None:
gvutils.error("Error! Type " + self.numtype +
" is not supported!")
return FALSE
proto_ds = self.dict_of_bands[b1_name][1].get_parent().get_dataset(
)
op_func = self.operations_dict[self.op][1]
self.out_buf = Numeric.zeros((b1.YSize, b1.XSize), self.numtype)
try:
op_func(s1=b1, s2=b2, a=a, b=b, c=c)
except:
gvutils.error("Try to change coefficients.")
return FALSE
res_ds = gdalnumeric.OpenArray(self.out_buf, proto_ds)
gview.app.open_gdal_dataset(res_ds)
self.close()
else:
gvutils.error("Source1 and Source2 have to differ!")
return FALSE
def basic_region_analysis(self, cview, clayer):
import Numeric, gdalnumeric
line = int(self.RP_ToolDlg.entry_dict['start_line'].get_text())
pix = int(self.RP_ToolDlg.entry_dict['start_pix'].get_text())
sl = int(self.RP_ToolDlg.entry_dict['num_lines'].get_text())
sp = int(self.RP_ToolDlg.entry_dict['num_pix'].get_text())
clayer = self.app.sel_manager.get_active_layer()
if clayer is None:
# Target can only be extracted if a layer is selected
return 'No selected raster layer'
dsb = clayer.get_data(0).get_band()
# Modify default to be whole image.
if sl is 1 and sp is 1 and line is 1 and pix is 1:
sl = dsb.YSize - line + 1
sp = dsb.XSize - pix + 1
# Create a temporary band for sampling if we have a subrect.
temp_copy = 0
if line != 1 or pix != 1 or sp != dsb.XSize or sl != dsb.YSize:
# print line, pix, sp, sl
temp_copy = 1
filename = clayer.get_parent().get_dataset().GetDescription()
target_data = gdalnumeric.LoadFile(filename, pix - 1, line - 1, sp,
sl)
target_ds = gdalnumeric.OpenArray(target_data)
dsb = target_ds.GetRasterBand(1)
# Compute the histogram.
x_min = clayer.min_get(0)
x_max = clayer.max_get(0)
histogram = dsb.GetHistogram(x_min, x_max, 256, 1, 0)
y_min = 0
y_max = max(histogram[1:-1])
(pm, mask) = self.RP_ToolDlg.get_histview(histogram, x_min, x_max,
y_min, y_max)
self.RP_ToolDlg.viewarea.set(pm, mask)
def numpy_rw_8():
if gdaltest.numpy_drv is None:
return 'skip'
import numpy
import gdalnumeric
ds = gdal.Open('data/rgbsmall.tif')
array = numpy.zeros([ds.RasterCount, ds.RasterYSize, ds.RasterXSize],
numpy.uint8)
array_res = ds.ReadAsArray(buf_obj=array)
ds2 = gdalnumeric.OpenArray(array)
for i in range(1, ds.RasterCount):
if ds2.GetRasterBand(i).Checksum() != ds.GetRasterBand(i).Checksum():
return 'fail'
return 'success'
def numpy_rw_2():
if gdaltest.numpy_drv is None:
return 'skip'
import gdalnumeric
array = gdalnumeric.LoadFile('data/utmsmall.tif')
if array is None:
gdaltest.post_reason('Failed to load utmsmall.tif into array')
return 'fail'
ds = gdalnumeric.OpenArray(array)
if ds is None:
gdaltest.post_reason('Failed to open memory array as dataset.')
return 'fail'
bnd = ds.GetRasterBand(1)
if bnd.Checksum() != 50054:
gdaltest.post_reason('Didnt get expected checksum on reopened file')
return 'fail'
ds = None
return 'success'
def compute(self, *args):
import re
ex_exp = self.expression
type = gdal.GetDataTypeByName(
self.types_list[self.types.get_history()])
numtype = gdalnumeric.GDALTypeCodeToNumericTypeCode(type)
if numtype == None:
gvutils.error("Error! Type " + numtype + " is not supported!")
return FALSE
fun_names_dict = {}
fun_names_dict["max"] = ("maximum", 2)
fun_names_dict["min"] = ("minimum", 2)
fun_names_dict["asin"] = ("arcsin", 1)
fun_names_dict["acos"] = ("arccos", 1)
fun_names_dict["atan"] = ("arctan", 1)
fun_names_dict["AND"] = ("bitwise_and", 2)
fun_names_dict["OR"] = ("bitwise_or", 2)
fun_names_dict["XOR"] = ("bitwise_xor", 2)
fun_names_dict["inv"] = ("invert", 1)
fun_names_dict["LShift"] = ("left_shift", 2)
fun_names_dict["RShift"] = ("right_shift", 1)
fun_names_dict['NDVI'] = ("self.NDVI", 2)
sh_names_list = fun_names_dict.keys()
for item in sh_names_list:
ex_exp = re.sub(item, fun_names_dict[item][0], ex_exp)
test_exp = ex_exp
test_array = Numeric.zeros((1, 5), numtype)
for i in range(len(self.list_of_bands)):
patt_i = "%" + str(i + 1)
repl_i = "sb[" + str(i) + "]"
ex_exp = re.sub(patt_i, repl_i, ex_exp)
test_exp = re.sub(patt_i, "test_array", test_exp)
ex_exp = "rb=" + ex_exp
test_exp = "test_res=" + test_exp
try:
exec test_exp
except:
gvutils.error("Illegal expression!")
return FALSE
if self.switch_new_view.get_active():
gview.app.new_view()
b1_name = self.list_of_bands[self.s1_list.get_history()]
band_list = []
for i in range(len(self.list_of_bands)):
band_list.append(self.get_band(self.list_of_bands[i]))
b1 = self.get_band(b1_name)
proto_ds = self.dict_of_bands[b1_name][1].get_parent().get_dataset()
self.out_buf = Numeric.zeros((b1.YSize, b1.XSize), numtype)
sb = range(len(self.list_of_bands))
for y in range(b1.YSize):
for i in range(len(self.list_of_bands)):
sb[i] = \
gdalnumeric.BandReadAsArray(band_list[i],0,y,b1.XSize,1)[0]
try:
exec ex_exp
except:
gvutils.error("ZeroDivide?")
return FALSE
self.out_buf[y, 0:] = clip_result(numtype, rb).astype(numtype)
res_ds = gdalnumeric.OpenArray(self.out_buf, proto_ds)
gview.app.open_gdal_dataset(res_ds)
def classify_cb(self, *args):
if len(self.band_list_to_classify) < 2:
return
if self.metric_num == 0:
distance = L1
elif self.metric_num == 2:
distance = L3
else:
distance = L2
nClusters = int(self.clusters.get_text())
minvol = int(self.min_volume.get_text())
maxit = int(self.maxiter.get_text())
movement_treshold = float(self.mov_treshold.get_text())
nBands = len(self.band_list_to_classify)
cl_table = ClassesTable(nBands)
self.hide()
gview.app.new_view()
b1_name = self.sel_list.get_text(0, 0)
band_list = self.band_list_to_classify
b1 = self.get_band(b1_name)
proto_ds = self.dict_of_bands[b1_name][1].get_parent().get_dataset()
self.out_buf = zeros((b1.YSize, b1.XSize), UnsignedInt8)
sb = range(len(band_list))
cp = zeros(nBands)
d_means = zeros(nClusters, Float)
volumes = range(nClusters)
centres = []
disp = []
maxVal = 256.
ymax = b1.YSize / 20
ys = 20
max_percent_val = 11 * maxit * b1.YSize / 40
cur_percent_val = 0
for i in range(nClusters):
centres.append(((ones(nBands, Float) * i) * maxVal) / nClusters)
disp.append(zeros(nBands, Float))
for kit in range(maxit):
centres_s = []
for i in range(len(centres)):
volumes[i] = 0
centres_s.append(zeros(nBands, Float))
flag = 0
nc = len(centres)
if kit >= maxit / 2:
ymax = b1.YSize
ys = 1
for yc in range(ymax):
y = yc * ys
for i in range(nBands):
sb[i] = gdalnumeric.BandReadAsArray(
band_list[i], 0, y, b1.XSize, 1)[0]
rb = self.out_buf[y, 0:]
for x in range(b1.XSize):
for i in range(nBands):
cp[i] = sb[i][x]
mind = 1e29
for i in range(nc):
d = distance(centres[i], cp)
if d < mind:
mind = d
ic = i
if rb[x] != ic:
rb[x] = ic
flag = 1
centres_s[ic] += cp
disp[ic] += cp * cp
volumes[ic] += 1
if (distance == L2):
d_means[ic] += sqrt(mind)
else:
d_means[ic] += mind
self.out_buf[y, 0:] = rb
if y % 2 == 0:
cur_percent_val += 1
cl_table.show_progress(
100. * cur_percent_val / max_percent_val, y)
##########################################################
new_centres = []
d_tresh = sum(d_means) / sum(volumes)
for i in range(len(centres)):
cur_vol = volumes[i]
if cur_vol > minvol / ys:
cur_centre = centres_s[i] / cur_vol
disp[i] = disp[i] / cur_vol - cur_centre * cur_centre
disp[i] = sqrt(disp[i])
d_means[i] /= cur_vol
if len(
centres
) < nClusters and cur_vol > 2 * minvol / ys and d_means[
i] > d_tresh:
new_centres.append(cur_centre - disp[i])
new_centres.append(cur_centre + disp[i])
else:
new_centres.append(cur_centre)
ncl = len(new_centres)
if ncl > nClusters:
mind = 1e29
for i in range(ncl):
for j in range(i):
d = distance(new_centres[i], new_centres[j])
if d < mind:
mind = d
i1 = i
i2 = j
new_centres[i1] += new_centres[i2]
new_centres[i1] /= 2
new_centres.remove(new_centres[i2])
cl_table.set_data(new_centres, kit)
if cl_table.stop_pressed():
if ys > 1:
ymax = b1.YSize
ys = 1
else:
break #stop_pressed
if len(centres) == len(new_centres):
movement_flag = 0
for i in range(len(centres)):
d = distance(centres[i], new_centres[i])
d /= d_tresh
if d > movement_treshold:
movement_flag = 1
if movement_flag == 0:
if ys > 1:
ymax = b1.YSize
ys = 1
else:
break # centres movement less then treshold
centres = new_centres
disp = []
for i in range(len(centres)):
disp.append(zeros(nBands, Float))
volumes = zeros(len(centres))
d_means = zeros(len(centres))
if flag == 0:
if ys > 1:
ymax = b1.YSize
ys = 1
else:
break #no changed points
cl_table.finish()
res_ds = gdalnumeric.OpenArray(self.out_buf, proto_ds)
gview.app.open_gdal_dataset(res_ds)
self.close()
def plot3d(data=None,
xvec=None,
yvec=None,
xaxis=None,
yaxis=None,
zaxis=None,
xmin=None,
xmax=None,
ymin=None,
ymax=None,
zmin=None,
zmax=None,
title=None,
cmds=None,
terminal='openev',
output=None,
plottype="parametric",
wintitle=None):
"""plot3d(data [,xvec=xaxis_values] [,yvec=yaxis_values]
[, xaxis=text] [,yaxis=text] [,zaxis=text] [,title=text]
[, xmin=n, xmax=n] [, ymin=n, ymax=n] [, zmin=n, zmax=n]
[, cmds=cmd_list] [,terminal={"openev","gnuplot","rasterlayer"}]
[, output=ps_filename]
[,plottype = {"parametric","contour"}]
[, wintitle=text])
data -- data array to plot, should be 2-D set of Z values.
Size of data should be length(x) x length(y), if x
and y are present.'
xvec -- 1-D Vector of values for axis of first dimension of data.
yvec -- 1-D Vector of values for axis of second dimension of data.
"""
###########################################################################
# Print usage() message if no options given.
if data is None:
print 'Usage: plot3d(data [,xvec=xaxis_values] [,yvec=yaxis_values] '
print ' [, xaxis=text] [,yaxis=text] [,zaxis=text] [,title=text] '
print ' [, xmin=n, xmax=n] [, ymin=n, ymax=n] [, zmin=n, zmax=n] '
print ' [, cmds=cmd_list] [,terminal={"openev","gnuplot,"rasterlayer"}]'
print ' [, output=ps_filename] [,plottype = {"parametric","contour"}]'
print ''
print ' data -- data array to plot, should be 2-D set of Z values.'
print ' Size of data should be length(x) x length(y), if x'
print ' and y are present.'
print ' xvec -- 1-D Vector of values for axis of first dimension of data.'
print ' yvec -- 1-D Vector of values for axis of second dimension of data.'
print ''
return
###########################################################################
# Work out the shape of the data. A 1-D array is assumed to be Y
# values. An Nx2 array is assumed to be (X,Y) values. All others are
# currently invalid.
try:
dshape = Numeric.shape(data)
except:
raise ValueError, "data argument to plot() does not appear to be a NumPy array"
##########################################################################
# Make sure xvec, yvec are valid indices for x/y axis and revert to
# default if not.
if xvec is None:
xvec = Numeric.arange(dshape[0])
else:
try:
xshape = Numeric.shape(xvec)
if (len(xvec) != dshape[0]):
print 'Incorrect length for xvec- reverting to default.'
xvec = Numeric.arange(dshape[0])
elif (len(xshape) > 1):
print 'xvec should be 1-D- reverting to default.'
xvec = Numeric.arange(dshape[0])
except:
print 'xvec appears not to be a NumPy array- reverting to default.'
xvec = Numeric.arange(dshape[0])
if yvec is None:
yvec = Numeric.arange(dshape[1])
else:
try:
yshape = Numeric.shape(yvec)
if (len(yvec) != dshape[1]):
print 'Incorrect length for yvec- reverting to default.'
yvec = Numeric.arange(dshape[1])
elif (len(yshape) > 1):
print 'yvec should be 1-D- reverting to default.'
yvec = Numeric.arange(dshape[1])
except:
print 'yvec appears not to be a NumPy array- reverting to default.'
yvec = Numeric.arange(dshape[1])
###########################################################################
# Setup Plot Options.
g = llplot()
g.batch = 1
if plottype == "contour":
g.add_cmd('set nosurface')
g.add_cmd('set contour')
g.add_cmd('set view 0,0')
g.add_cmd('set data style lines')
g.add_cmd('set cntrparam levels 15')
else:
# g.add_cmd('set parametric')
g.add_cmd('set data style lines')
g.add_cmd('set hidden3d')
if xaxis is not None:
g.add_cmd('set xlabel "%s"' % xaxis)
if yaxis is not None:
g.add_cmd('set ylabel "%s"' % yaxis)
if title is not None:
g.add_cmd('set title "%s"' % title)
if xmin is not None and xmax is not None:
g.add_cmd('set xrange [%s:%s]' % (str(xmin), str(xmax)))
if ymin is not None and ymax is not None:
g.add_cmd('set yrange [%s:%s]' % (str(ymin), str(ymax)))
if plottype != "contour":
if zaxis is not None:
g.add_cmd('set zlabel "%s"' % zaxis)
if plottype != "contour":
if zmin is not None and zmax is not None:
g.add_cmd('set zrange [%s:%s]' % (str(zmin), str(zmax)))
if cmds is not None:
for cmd in cmds:
g.add_cmd(cmd)
###########################################################################
# Attach the data.
#
# Note that we emit the x and y values with each data point. It would
# be nice to rewrite this to use binary format eventually.
tup_data = []
for x_i in range(len(xvec)):
for y_i in range(len(yvec)):
tup_data.append((xvec[x_i], yvec[y_i], data[x_i][y_i]))
g.set_data(tup_data, dimension=3, xlen=len(xvec))
###########################################################################
# Generate output.
if terminal == 'gnuplot':
g.batch = 0
g.plot_current()
raw_input('Please press return to continue...\n')
elif terminal == 'postscript':
if (os.name == 'nt'):
output = string.join(string.split(output, '\\'), '/')
g.add_cmd('set terminal postscript color 10')
g.add_cmd("set output '%s'" % output)
g.plot_current()
else:
import gdal
import gdalnumeric
import time
import gview
temp_file = gvutils.tempnam()
g.add_cmd('set terminal pbm color')
g.add_cmd("set output '%s'" % temp_file)
g.plot_current()
image = gdalnumeric.LoadFile(temp_file)
image_ds = gdalnumeric.OpenArray(image)
try:
os.unlink(temp_file)
except:
pass
rlayer = gview.GvRasterLayer(gview.GvRaster(dataset=image_ds, real=1),
rl_mode=gview.RLM_RGBA)
rlayer.set_source(1, gview.GvRaster(dataset=image_ds, real=2))
rlayer.set_source(2, gview.GvRaster(dataset=image_ds, real=3))
if terminal == 'rasterlayer':
return rlayer
graphwin = GvGraphWindow(rlayer)
if wintitle is not None:
graphwin.set_title(wintitle)
def plot(data=None,
xaxis=None,
yaxis=None,
xmin=None,
xmax=None,
ymin=None,
ymax=None,
title=None,
cmds=None,
terminal='openev',
output=None,
wintitle=None,
datastyle=None,
multiplot=False,
multilabels=(),
multiopts=()):
"""plot(data [, xaxis=text] [,yaxis=text] [,title=text]
[, xmin=n] [, xmax=n] [, ymin=n] [, ymax=n]
[, cmds=cmd_list] [,terminal={"openev","gnuplot"}]
[, wintitle=text] [, datastyle=text]
[, multiplot = {True,False}] [, multilabels = list]
[, multiopts = list]
data -- data array to plot, should be 1-D set of Y data
or 2-D array with pairs of (x,y) values.
or 3-D array with pairs of (x,y,z) values '
or 2-D array with tuples of (x,y1,y2,...,yN) values.'
"""
###########################################################################
# Print usage() message if no options given.
if data is None:
print 'Usage: plot(data [, xaxis=text] [,yaxis=text] [,title=text] '
print ' [, xmin=n] [, xmax=n] [, ymin=n] [, ymax=n] '
print ' [, cmds=cmd_list] '
print ' [,terminal={"openev","gnuplot"}]'
print ' [,wintitle=text] [, datastyle=text] '
print ' [, multiplot = {True,False}]'
print ' [, multilabels = list] [, multiopts = list] )'
print ''
print ' data -- data array to plot, should be 1-D set of Y data'
print ' or 2-D array with pairs of (x,y) values.'
print ' or 3-D array with pairs of (x,y,z) values '
print ' or 2-D array with tuples of (x,y1,y2,...,yN) values.'
print ' for the last multiplot must be true, multilables is'
print ' a list of text labels for the graphs, and multiopts'
print ' is a list of gnuplot options to be added to the'
print ' individual graphs'
print ''
return
###########################################################################
# Work out the shape of the data. A 1-D array is assumed to be Y
# values. An Nx2 array is assumed to be (X,Y) values. A 3-D array is
# assumed to be (X,Y,Z) values. If multiplot is True we need
# a Nxk array, with K at least 2
try:
dshape = Numeric.shape(data)
except:
raise ValueError, "data argument to plot() does not appear to be a NumPy array"
dim = len(dshape)
###########################################################################
# Reformat the list into a uniform Nx2 format.
if multiplot == False:
if dim == 1:
dim = 2
list = []
for i in range(len(data)):
list.append((i, data[i]))
data = list
elif dim == 2 and dshape[1] == 2 and dshape[0] > 1:
pass
else:
raise ValueError, "data argument dimension or shape is not supported."
else:
#error checking for multiplot needs work
if dim > 1:
pass
else:
raise ValueError, "multiplot dimension too small"
###########################################################################
# Setup Plot Options.
g = llplot()
if datastyle is not None:
cmd = 'set data style ' + str(datastyle)
g.add_cmd(cmd)
else:
g.add_cmd('set data style linespoints')
if xaxis is not None:
g.add_cmd('set xlabel "%s"' % xaxis)
if yaxis is not None:
g.add_cmd('set ylabel "%s"' % yaxis)
if title is not None:
g.add_cmd('set title "%s"' % title)
if xmin is not None and xmax is not None:
g.add_cmd('set xrange [%s:%s]' % (str(xmin), str(xmax)))
if ymin is not None and ymax is not None:
g.add_cmd('set yrange [%s:%s]' % (str(ymin), str(ymax)))
if cmds is not None:
for cmd in cmds:
g.add_cmd(cmd)
g.set_data(data, '', dim, 1, multiplot, multilabels, multiopts)
###########################################################################
# Generate output.
if terminal == 'gnuplot':
g.batch = 0
g.plot_current()
raw_input('Please press return to continue...\n')
return
elif terminal == 'postscript':
g.batch = 1
#if (os.name == 'nt'):
# output = string.join(string.split(output,'\\'),'/')
g.add_cmd('set terminal postscript color 10')
g.add_cmd("set output '%s'" % output)
g.plot_current()
return
elif terminal == 'pbm':
g.batch = 1
g.add_cmd('set terminal pbm color')
g.add_cmd("set output '%s'" % output)
g.plot_current()
return
elif terminal == 'xpm':
import gdal
import time
g.batch = 1
out_temp = gvutils.tempnam(extension='png')
g.add_cmd('set terminal png')
g.add_cmd("set output '%s'" % out_temp)
g.plot_current()
pngDS = gdal.Open(out_temp)
if pngDS is None:
return None
xpmDriver = gdal.GetDriverByName('XPM')
if xpmDriver is None:
return None
xpmDriver.CreateCopy(output, pngDS, 0)
pngDS = None
os.unlink(out_temp)
return
else:
import gdal
import gdalnumeric
import time
import gview
g.batch = 1
temp_file = gvutils.tempnam()
# make sure the file has been created
create_temp = open(temp_file, 'w')
create_temp.close()
g.add_cmd('set terminal pbm color')
g.add_cmd("set output '%s'" % temp_file)
g.plot_current()
time.sleep(1)
image = gdalnumeric.LoadFile(temp_file)
image_ds = gdalnumeric.OpenArray(image)
try:
os.unlink(temp_file)
except:
pass
rlayer = gview.GvRasterLayer(gview.GvRaster(dataset=image_ds, real=1),
rl_mode=gview.RLM_RGBA)
rlayer.set_source(1, gview.GvRaster(dataset=image_ds, real=2))
rlayer.set_source(2, gview.GvRaster(dataset=image_ds, real=3))
if terminal == 'rasterlayer':
return rlayer
graphwin = GvGraphWindow(rlayer)
if wintitle is not None:
graphwin.set_title(wintitle)
def save_cb(self, *args):
if self.copy_but.active:
outfile = GtkExtra.file_sel_box(title=_("Output File"))
if outfile is None:
return
ds = self.viewarea1.active_layer().get_parent().get_dataset()
bright_val = math.floor(self.bright_adjustment.value * 255 / 100)
contrast_val = (100 + self.contrast_adjustment.value) / 100
gamma_val = self.gamma_adjustment.value
outarray = Numeric.zeros(
(ds.RasterCount, ds.RasterYSize, ds.RasterXSize),
typecode=Numeric.UnsignedInt8)
try:
size = ds.RasterYSize
import EasyDialogs
progress = EasyDialogs.ProgressBar(title='Working...', maxval=size)
except:
pass
lut = []
for i in range(256):
value = i + math.floor(bright_val)
if value < 0:
value = 0
elif value >= 255:
value = 255
if contrast_val != 1.0:
value = value * contrast_val
if value < 0:
value = 0
elif value >= 255:
value = 255
if gamma_val != 1:
value = 255 * math.pow(
float(abs(value)) / 255, 1.0 / gamma_val)
if value < 0:
value = 0
elif value >= 255:
value = 255
value = int(value)
lut.append(value)
lutarray = Numeric.array((lut), typecode=Numeric.UnsignedInt8)
for m in range(ds.RasterCount):
inband = ds.GetRasterBand(m + 1)
for i in range(ds.RasterYSize):
#inarray = inband.ReadAsArray()
inarray = inband.ReadAsArray(0, i, inband.XSize, 1,
inband.XSize,
1)[0].astype(Numeric.UnsignedInt8)
#outarray = Numeric.zeros(inarray.shape)
try:
progress.label('Processing Band: ' + str(m + 1) +
', Line: ' + str(i))
progress.set(i)
except:
pass
outarray[m][i].flat[:] = Numeric.take(lutarray, inarray.flat)
res_ds = gdalnumeric.OpenArray(outarray, ds)
res_ds = gview.manager.add_dataset(res_ds)
view = gview.app.sel_manager.get_active_view_window()
if self.copy_but.active:
driver = ds.GetDriver()
driver.CreateCopy(outfile, res_ds)
view.file_open_by_name(outfile)
self.destroy()
elif self.owrite_but.active:
for layer in gview.app.sel_manager.get_active_view().list_layers():
if gvutils.is_of_class(layer.__class__, 'GvRasterLayer') == 1:
if layer.get_parent().get_dataset().GetDescription(
) == ds.GetDescription():
gview.app.sel_manager.get_active_view().remove_layer(
layer)
fname = ds.GetDescription()
driver = ds.GetDriver()
driver.CreateCopy(fname, res_ds)
view.file_open_by_name(fname)
view.refresh_cb()
self.destroy()
del ds
del res_ds
del outarray
def update_roi_view(self,*args):
# Shouldn't get here if inactive anyway, but just in case...
if (self.RP_ToolDlg.is_active() == gtk.FALSE):
return
# Update view based on new frame values
line = int(float(self.RP_ToolDlg.entry_dict['start_line'].get_text()))
pix = int(float(self.RP_ToolDlg.entry_dict['start_pix'].get_text()))
sl = int(float(self.RP_ToolDlg.entry_dict['num_lines'].get_text()))
sp = int(float(self.RP_ToolDlg.entry_dict['num_pix'].get_text()))
# Find the view and layer
cview = self.app.view_manager.get_active_view_window().title
clayer = self.app.sel_manager.get_active_layer()
if (cview is None) or (clayer is None):
# Target can only be extracted if a view/layer is selected
return
if (sl == 0 or sp == 0):
print "Trying to extract region with zero lines or zero pixels!"
return
try:
filename = clayer.get_parent().get_dataset().GetDescription()
except:
gvutils.error('Unable to determine filename!')
return
try:
target_data = gdalnumeric.LoadFile(filename,pix,line,sp,sl)
target_ds = gdalnumeric.OpenArray(target_data)
rl_mode_value = clayer.get_mode()
except:
gvutils.error('Unable to extract data and/or display mode info!')
return
if self.target_view_window is not None:
# Need to delete old layer in target window and put in new one
if self.target_view_layer is not None:
self.target_view_window.viewarea.remove_layer(self.target_view_layer)
# Create new layer
self.target_view_data = target_data
self.target_view_ds = target_ds
self.target_view_layer = \
gview.GvRasterLayer(gview.GvRaster(dataset = self.target_view_ds,real=1),
rl_mode = rl_mode_value)
if ((rl_mode_value == gview.RLM_RGBA) and (self.target_view_ds.RasterCount > 2)):
green_raster = gview.GvRaster(dataset = self.target_view_ds,real=2)
blue_raster = gview.GvRaster(dataset = self.target_view_ds,real=3)
self.target_view_layer.set_source(1,green_raster)
self.target_view_layer.set_source(2,blue_raster)
if self.target_view_ds.RasterCount > 3:
band = self.target_view_ds.GetRasterBand(4)
if band.GetRasterColorInterpretation() == gdal.GCI_AlphaBand:
self.target_view_layer.blend_mode_set( gview.RL_BLEND_FILTER )
alpha_raster = gview.GvRaster(dataset = self.target_view_ds,real=4)
self.target_view_layer.set_source(3,alpha_raster)
self.target_view_layer.set_name(filename)
refresh_old_window = 0 # redraw roi first time
if self.target_view_window is None:
# Need to create a window to display the current target in
import gvviewwindow
self.target_view_window = gvviewwindow.GvViewWindow(self.app,
title=self.target_view_title,show_menu = 0, show_icons=0,
show_tracker=1,show_scrollbars=1)
self.target_view_window.connect('destroy',self.close_target_view_cb)
refresh_old_window = 1
self.target_view_window.viewarea.add_layer(self.target_view_layer)
self.target_view_window.show()
# The roi must be redrawn on the overview if a new window was created
# (it will have disappeared)
# HACK!!!
if refresh_old_window == 1:
view_list = self.app.view_manager.get_views()
for item in view_list:
if (item.title == cview):
self.app.view_manager.set_active_view(item)
item.viewarea.set_active_layer(clayer)
self.app.toolbar.roi_tool.append((pix,line,sp,sl))
