def launch_properties(self, action):
layer = self.get_selected_layer()
ret = 'Yes'
if layer.get_property('Class_sn'):
if layer.parent[0].get_property('_gv_ogrfs'):
msg = "This layer is classified.\nSetting properties on this layer "
msg += "will remove\nexisting classification.\n"
msg += "Do you wish to continue?"
ret = yesno(_("Classified Layer"), _(msg))
if ret == 'Yes':
layer.declassify()
if ret == 'Yes':
layer.launch_properties()
def save(self, filename, cwd):
import pickle
self.cwd = cwd
path, ext = os.path.splitext(filename)
if ext != '.leg':
ext = '.leg'
filename = path + ext
if os.path.exists(filename):
ret = yesno(title=_("File exists"), text=_("Do you wish to overwrite the existing file?"))
if ret == 'No':
return
file = open(filename, 'w')
d = self.cls.serialize()
try:
pickle.dump(d, file)
except PicklingError:
msg = _("An error occurred saving the classification:")
error('%s\n%s' % (msg, filename))
def export_cb(self,*args):
ipfile = self.frame_dict['Files'].get('Input')
opfile = self.frame_dict['Files'].get('Output')
if os.path.isfile(opfile):
resp = gvutils.yesno('Confirmation', '%s exists. Overwrite?' % opfile)
if resp == 'No':
return
elif len(opfile) == 0:
gvutils.error('No output filename entered!')
return
use_viewscale = 0
rast = gdal.OpenShared(ipfile, gdal.GA_ReadOnly)
if rast is None:
if not ipfile:
gvutils.error('Please specify an input file!')
else:
gvutils.error('Unable to open %s as a GDAL supported file!' % ipfile)
return
# Catch the case where the input file consists of in-memory VRT lines
# and the output format is also VRT. In this case, the new VRT would
# no longer be valid once openev was exited because the input file
# is not on disk (filename looks something like '<VRTDataset....').
# If the user is just exporting the file as-is, simply copying the
# original lines to disk will suffice. However, if they want to
# window or scale, we'd need more complicated manipulations. For now,
# give an error message in that case.
opformat = self.format_list[self.format_menu.get_history()]
if ipfile.startswith('<') and opformat == 'VRT':
if self.res_list[self.res_menu.get_history()] != 'Full':
msg = 'Only full output resolution is currently\n'+\
'supported for export of in-memory VRTs\nto on-disk VRTs.'
gvutils.error(msg)
return
if self.button_dict['Mode'].get_active() and \
(self.button_dict['IP_window'].get_active() or
self.button_dict['Scale'].get_active() or
self.optentry.get_text()):
msg = 'Scaling, windowing, and advanced creation\n'+\
'options are not yet supported for export of \n'+\
'in-memory VRTs to on-disk VRTs'
gvutils.error(msg)
return
linelist = ipfile.split('\n')
newlinelist = []
for item in linelist:
newlinelist.append(item+'\n')
fh = open(opfile,'w')
fh.writelines(newlinelist)
fh.close()
ovrs = self._overview_list[self.overview_menu.get_history()]
if ovrs != 'None':
outds = gdal.OpenShared(opfile)
if outds is None:
gvutils.error('Error opening %s for overview creation!' % opfile)
return
## progress = pgu.ProgressDialog('Building overviews...', cancel=True)
if ovrs is 'Nearest':
outds.BuildOverviews("nearest")
else:
outds.BuildOverviews("average_magphase")
## progress.destroy()
return
vrt_opts = vrtutils.VRTCreationOptions(rast.RasterCount)
if self._geocode_list[self.geocoding_menu.get_history()] == 'GCP':
vrt_opts.set_geopref('gcps')
elif self._geocode_list[self.geocoding_menu.get_history()] == 'Geotransform':
vrt_opts.set_geopref('geotransform')
band_list = None
# Scale the output file according to the current view's min/max
laststretch = 'none_lut'
clayer = None
if self.button_dict['Scale'].get_active():
try:
clayer = self.app.sel_manager.get_active_layer()
dtype = rast.GetRasterBand(1).DataType
if clayer.get_mode() == gview.RLM_COMPLEX or \
dtype in (gdal.GDT_CInt16,gdal.GDT_CInt32,gdal.GDT_CFloat32,gdal.GDT_CFloat64):
# This doesn't deal with complex yet...
gvutils.error('View scaling option is not yet supported for complex data!')
return
if clayer.parent.get_dataset().GetDescription() != ipfile:
wtxt = 'Input file and active layer file names do not match- may '
wtxt += 'result in unexpected scaling!'
gvutils.warning(wtxt)
if not gvutils.is_of_class(clayer.__class__,'GvRasterLayer'):
gvutils.warning('Active layer is not a raster- view scaling ignored!')
else:
src_count = clayer.sources
band_list = []
RGBAlist = ['Red','Green','Blue','Alpha']
for src in range(src_count):
# layer sources are numbered 0...3; band sources are numbered 1,2,...
src_bandnum = clayer.get_data(src).get_band_number()
band_list.append(src_bandnum)
vrt_opts.set_scaling((clayer.min_get(src), clayer.max_get(src),0,255), (src_bandnum,))
vrt_opts.set_datatype(gdal.GDT_Byte, (src_bandnum,))
if src_count == 3:
vrt_opts.set_color_interp(RGBAlist[src], (src_bandnum,))
# src_count is three even when there is an alpha channel
# for rgb/rgba case
if src_count == 3:
try:
src = 3
src_bandnum = clayer.get_data(src).get_band_number()
band_list.append(src_bandnum)
vrt_opts.set_scaling((clayer.min_get(src),
clayer.max_get(src),0,255),
(src_bandnum,))
vrt_opts.set_datatype(gdal.GDT_Byte,(src_bandnum,))
vrt_opts.set_color_interp(RGBAlist[src],
(src_bandnum,))
except:
pass
use_viewscale = 1
laststretch = clayer.get_property('last_stretch')
except:
gvutils.error('Unable to find active raster layer for scaling!')
return
# Get windowing options
if self.button_dict['IP_window'].get_active():
try:
dic = self.frame_dict['IP_window'].entry_dict
spix = int(dic['start_pix'].get_text())
sline = int(dic['start_line'].get_text())
npix = int(dic['num_pix'].get_text())
nlines = int(dic['num_lines'].get_text())
if spix < 0 or sline < 0:
gvutils.error('Negative start pixel and/or line! Aborting...')
return
if npix+spix > rast.RasterXSize:
gvutils.error('Window is too large (last column in input: %s)! Aborting...' % rast.RasterXSize)
return
if nlines+sline > rast.RasterYSize:
gvutils.error('Window is too large (last row in input: %s)! Aborting...' % rast.RasterYSize)
return
except:
gvutils.error('Error retrieving window options! Aborting...')
return
else:
spix = 0
sline = 0
npix = rast.RasterXSize
nlines = rast.RasterYSize
vrt_opts.set_src_window((spix, sline, npix, nlines))
if self.res_list[self.res_menu.get_history()] != 'Full':
ovrlevel = int(self.res_list[self.res_menu.get_history()][2])
else:
ovrlevel = 1
vrt_opts.set_dst_window((0, 0, npix/ovrlevel, nlines/ovrlevel))
vrt_tree = vrtutils.serializeDataset(rast, vrt_opts, band_list)
vrt_lines = gdal.SerializeXMLTree(vrt_tree)
vrtdataset = gdal.Open(vrt_lines)
driver = gdal.GetDriverByName(opformat)
# Parse creation options:
optstr = self.optentry.get_text().strip()
if optstr:
# should be able to deal with several
# types of entries, eg.
# 'TILED=YES','TFW=YES'
# and
# TILED=YES,TFW=YES
if optstr[0] in ("'",'"'):
split1 = optstr.split(",")
copts=[]
for item in split1:
if len(item) > 2:
copts.append(item[1:len(item)-1])
else:
copts = optstr.split(',')
else:
copts = []
progress = pgu.ProgressDialog('Export to '+opfile, cancel=True)
progress.SetDefaultMessage("translated")
progress.show()
progress.ProgressCB(0)
if use_viewscale and laststretch != 'linear':
gvutils.error('Sorry, not working yet...')
progress.destroy()
return
outdataset = driver.Create(opfile, vrtdataset.RasterXSize, vrtdataset.RasterYSize,
bands=vrtdataset.RasterCount, options=copts)
outdataset.SetProjection(vrtdataset.GetProjection())
outdataset.SetGeoTransform(vrtdataset.GetGeoTransform())
lut = clayer.get_source_lut(0)
prg = 1
denom = vrtdataset.RasterCount * vrtdataset.RasterYSize
for b in range(vrtdataset.RasterCount):
band = vrtdataset.GetRasterBand(b+1)
outband = outdataset.GetRasterBand(b+1)
offset = float(b * vrtdataset.RasterYSize)
for ln in range(vrtdataset.RasterYSize):
line = band.ReadRaster(0, ln, vrtdataset.RasterXSize, 1)
enhline = map(lambda x: lut[ord(x)], line)
buf = ''.join(enhline)
outband.WriteRaster(0, ln, vrtdataset.RasterXSize, 1, buf)
prg = progress.ProgressCB((float(ln) + offset)/denom, '')
if not prg:
print 'Cancelled!'
break
if not prg:
outdataset = None
break
else:
outdataset = driver.CreateCopy(opfile, vrtdataset, options=copts)
if outdataset is None:
progress.destroy()
gvutils.error('Unable to create output file '+opfile)
return
progress.ProgressCB(1, 'Done')
ovrs = self._overview_list[self.overview_menu.get_history()]
if ovrs is 'Nearest':
progress.SetDefaultMessage("overviews built")
outdataset.BuildOverviews("nearest")
elif ovrs is 'Average':
progress.SetDefaultMessage("overviews built")
outdataset.BuildOverviews("average_magphase")
progress.ProgressCB(1, 'Done')
progress.destroy()
