def raster_to_vector(raster, vector, type):
"""Converts a raster to a vector map
Parameters
----------
raster :
Name of the input raster map
vector :
Name for the output vector map
type :
Type for the output vector map
Returns
-------
Examples
--------
..
"""
r.to_vect(input=flow_in_category,
output=flow_in_category,
type="area",
quiet=True)
# Value is the ecosystem type
v.db_renamecolumn(map=flow_in_category, column=("value", "ecosystem"))
# New column for flow values
addcolumn_string = flow_column_name + " double"
v.db_addcolumn(map=flow_in_category, columns=addcolumn_string)
# The raster category 'label' is the 'flow'
v.db_update(map=flow_in_category, column="flow", query_column="label")
v.db_dropcolumn(map=flow_in_category, columns="label")
# Update the aggregation raster categories
v.db_addcolumn(map=flow_in_category, columns="aggregation_id int")
v.db_update(map=flow_in_category, column="aggregation_id", value=category)
v.colors(map=flow_in_category, raster=flow_in_category, quiet=True)
def raster_to_vector(raster_category_flow, vector_category_flow,
flow_column_name, category, type):
"""Converts a raster to a vector map
Parameters
----------
raster_category_flow :
Name of the input raster map 'flow in category'
vector_category_flow :
Name for the output vector map 'flow in category'
type :
Type for the output vector map
Returns
-------
Examples
--------
..
"""
msg = " * Vectorising raster map '{r}'"
grass.verbose(
_(
msg.format(
c=category,
r=raster_category_flow,
v=vector_category_flow,
)))
r.to_vect(
input=raster_category_flow,
output=vector_category_flow,
type="area",
quiet=True,
)
msg = " * Updating the attribute table"
grass.verbose(_(msg))
# Value is the ecosystem type
v.db_renamecolumn(
map=vector_category_flow,
column=("value", "ecosystem"),
quiet=True,
)
# New column for flow values
addcolumn_string = flow_column_name + " double"
v.db_addcolumn(
map=vector_category_flow,
columns=addcolumn_string,
quiet=True,
)
# The raster category 'label' is the 'flow'
v.db_update(
map=vector_category_flow,
column="flow",
query_column="label",
quiet=True,
)
v.db_dropcolumn(
map=vector_category_flow,
columns="label",
quiet=True,
)
# Update the aggregation raster categories
v.db_addcolumn(
map=vector_category_flow,
columns="aggregation_id int",
quiet=True,
)
v.db_update(
map=vector_category_flow,
column="aggregation_id",
value=category,
quiet=True,
)
v.colors(
map=vector_category_flow,
raster=raster_category_flow,
quiet=True,
)
def del_color_table(self):
out = v.colors(map=self.full_name, flags='r', stdout_=PIPE, stderr_=PIPE)
if out.outputs.stderr:
return out.outputs.stderr.split('\n')[0]
else:
print 'Color table of map %r was deleted' % self.name
def add_color_table(self, cbrew=False, color=None, column=None, attr=None, layer='1',
nk=5, s=None, cramp=('Diverging','RdYlBu'), method='Equal_Interval',
invert_ramp=False, *args, **kwargs):
"""
Add/replace color table
Keyword Description
---------- ----------------------------------------------------------------------
nk number of classes
column layer column to color classify, If s is not provided, column is needed.
Default=None
s pandas series or numpy array. If column is not provided, s is needed.
Default=None
ccramp Boolean. If true, color scheme and color ramp use Color Brewer
(http://colorbrewer2.org/)
method pysal.mapclassify methods. Options: Map_Classifier, Box_Plot,
Equal_Interval, Fisher_Jenks, Jenks_Caspall, Jenks_Caspall_Forced,
Jenks_Caspall_Sampled, Max_P_Classifier, Maximum_Breaks,
Natural_Breaks, Quantiles, Percentiles, Std_Mean, User_Defined.
Default User_Defined. See PySal documentation for valid parameters
in each case (http://pysal.org/1.2/library/esda/mapclassify.html).
invert_ramp Boolean. Default False.
layer Grass layer where rgb column will be added
*args Additional arguments for v.colors
**kwargs Additional arguments for rgb_classify. For example, if method='User_Defined'
then the arguments bins is required.
---------- ----------------------------------------------------------------------
"""
#todo: allow editing if current mapset and mapset are PERMANENT
#assert self.mapset is not 'PERMANENT',\
# '%r is in PERMANENT and is not writable by user' % self.name
assert int(layer) <= self.dblinks.num_dblinks(), 'layer %r does not exist' % layer
if cbrew:
table_name = self.dblinks.by_layer(int(layer)).name
sqlfilter = gtable.Table(name=table_name, connection=self._con)
assert sqlfilter.exist(), 'table %r not found in mapset %r. Verify dblinks.'\
% (sqlfilter.name, self.mapset)
if hasattr(s, '__len__'):
dtype = s.dtype.type
assert (np.issubdtype(dtype, np.integer) or np.issubdtype(dtype, np.float)),\
'Numpy array dtype must be integer or float'
sqlfilter.filters.select(sqlfilter.key)
cur = sqlfilter.execute()
cat = cur.fetchall()
cat = np.array(cat)
cat = cat.flatten()
assert s.shape == cat.shape, 'Series does not match map key shape'
if column:
assert column in sqlfilter.columns.names(),\
'%r has not column %r' % (table_name, column)
sqlfilter.filters.select(sqlfilter.key, column)
cur = sqlfilter.execute()
col = cur.fetchall()
col = np.array(col).T
s = col[1]
cat = col[0]
dtype = s.dtype.type
if not (np.issubdtype(dtype, np.integer) or np.issubdtype(dtype, np.float)):
nulls = np.where(s == '')[0]
if nulls.any:
s[s == ''] = np.nan
s = s.astype(float)
s = pd.Series(s)
s_rgb = rgb_classify(s, nk, cramp=cramp, method=method, invert_ramp=invert_ramp,
**kwargs)
#TODO convert this into a save_colr_file function
# Write color table
mapset = Mapset()
mapset.current()
if self.mapset is mapset.name:
filename = os.path.join('$GISDBASE','$LOCATION_NAME', self.mapset,
'vector', self.name, 'colr')
else:
filename = os.path.join('$GISDBASE','$LOCATION_NAME', mapset.name,
'vcolr2', self.mapset, self.name)
filename = gtable.get_path(filename)
directory = os.path.dirname(filename)
if not os.path.exists(directory):
os.makedirs(directory)
with open(filename,'w') as f:
f.write('% ' + '%r %r' % (int(min(cat)), self.table.n_rows()) + '\n')
for i,item in enumerate(s_rgb):
f.write(str(cat[i]) + ':' + item + '\n')
else:
assert color, 'color attribute is required'
if column:
v.colors(map=self.full_name, layer=layer, column=column, color=color, *args)
else:
v.colors(map=self.full_name, color=color, *args)
