def run(self):
if self.state == Node.SUCCESS:
return
try:
with open(self.filename):
pass
except PermissionError:
self.fail('Access denied.')
return
self.data = PolylineData()
is_i2s = self.filename[-4:] == '.i2s'
if is_i2s:
with BlueKenue.Read(self.filename) as f:
f.read_header()
for poly in f.get_open_polylines():
self.data.add_line(poly)
self.data.set_fields(['Value'])
else:
try:
for poly in Shapefile.get_open_polylines(self.filename):
self.data.add_line(poly)
except ShapefileException as e:
self.fail(e)
return
self.data.set_fields(Shapefile.get_all_fields(self.filename))
if self.data.is_empty():
self.fail('the file does not contain any 2D open polyline.')
return
self.success('The file contains {} open line{}.'.format(
len(self.data), 's' if len(self.data) > 1 else ''))
def get_lines_from_file(filename, interp_coord='LINEAR'):
"""
Returns a list of ConstraintLine from an input file
TODO 1: Value is ignored in i2s file format
"""
lines = []
if filename is not None:
if filename.endswith('.i2s'):
with bk.Read(filename) as in_i2s:
in_i2s.read_header()
for i, line in enumerate(in_i2s.get_open_polylines()):
lines.append(
ConstraintLine(i, list(line.polyline().coords),
interp_coord))
elif filename.endswith('.shp'):
if shp.get_shape_type(filename) not in (shapefile.POLYLINE,
shapefile.POLYLINEZ,
shapefile.POLYLINEM):
raise TatooineException(
"The type of file %s is not POLYLINEZ[M]" % filename)
for i, line in enumerate(shp.get_open_polylines(filename)):
lines.append(
ConstraintLine(i, list(line.polyline().coords),
interp_coord))
else:
raise NotImplementedError(
"Only shp and i2s formats are supported for constraint lines"
)
return lines
def get_hydraulic_axis(infile_axis):
"""
@brief: Extract a unique line from i2s input file
@param infile_axis <str>: path to file
@return <shapely.geometry.LineString>: polyline representing the hydraulic axis
"""
if infile_axis.endswith('.i2s'):
with bk.Read(infile_axis) as in_i2s:
in_i2s.read_header()
lines = list(in_i2s.get_open_polylines())
elif infile_axis.endswith('.shp'):
if shp.get_shape_type(infile_axis) not in (shapefile.POLYLINE,
shapefile.POLYLINEZ,
shapefile.POLYLINEM):
raise TatooineException("The type of file %s is not POLYLINE[ZM]" %
infile_axis)
lines = list(shp.get_open_polylines(infile_axis))
else:
raise NotImplementedError(
"Only shp and i2s formats are supported for hydraulic axis")
nb_lines = len(lines)
if nb_lines != 1:
raise TatooineException(
"The file '{}' contains {} polylines instead of a unique line to define "
"the hydraulic axis".format(infile_axis, nb_lines))
return lines[0].polyline()
def from_file(filename, label, field_id=None, project_straight_line=False):
section_seq = CrossSectionSequence()
if filename.endswith('.i3s'):
with bk.Read(filename) as in_i3s:
in_i3s.read_header()
for i, line in enumerate(in_i3s.get_open_polylines()):
line_id = i if field_id is None else line.attributes()[
0] # Use `Value` if field is not None
z_array = np.array([(coord[2], )
for coord in line.polyline().coords],
dtype=float_vars('Z'))
line = line.to_2d()
section = CrossSection(line_id,
list(line.polyline().coords), label)
section.coord.values = z_array
section_seq.add_section(section)
elif filename.endswith('.shp'):
shp_type = shp.get_shape_type(filename)
if shp_type in (shapefile.POLYLINEZ, shapefile.POLYLINEM):
field_id_index = get_field_index(filename, field_id)
for i, line in enumerate(shp.get_open_polylines(filename)):
line_id = i if field_id is None else line.attributes(
)[field_id_index]
z_array = np.array([(coord[2], )
for coord in line.polyline().coords],
dtype=float_vars(['Z']))
line = line.to_2d()
section = CrossSection(line_id,
list(line.polyline().coords), label)
section.coord.values = z_array
section_seq.add_section(section)
elif shp_type in (shapefile.POINT, shapefile.POINTZ):
field_id_index = get_field_index(filename, field_id)
field_indexes, field_names = [], []
if shp_type == shapefile.POINTZ:
field_names.append('Z')
for index, name in shp.get_numeric_attribute_names(filename):
if name.startswith('Z'):
field_indexes.append(index)
field_names.append(name)
coords, z_layers = [], []
last_point_id = None
for i, (point, attributes) in enumerate(
shp.get_points(filename,
with_z=shp_type == shapefile.POINTZ)):
point_id = attributes[
field_id_index] # FIXME: should raise exception if field_id_index is None!
if i > 0 and point_id != last_point_id:
z_array = np.array(z_layers,
dtype=float_vars(field_names))
section = CrossSection(last_point_id, coords, label)
section.coord.values = z_array
section_seq.add_section(section)
coords, z_layers = [], []
coords.append(point[:2])
if shp_type == shapefile.POINTZ:
z_layers.append((point[2], ) +
tuple(attributes[index]
for index in field_indexes))
else:
z_layers.append(
tuple(attributes[index]
for index in field_indexes))
last_point_id = point_id
z_array = np.array(z_layers, dtype=float_vars(field_names))
section = CrossSection(last_point_id, coords, label)
section.coord.values = z_array
section_seq.add_section(section)
else:
raise TatooineException(
"The type of file %s is not POINT[Z] or POLYLINEZ[M]" %
filename)
else:
raise NotImplementedError(
"Only shp and i3s formats are supported for cross-sections")
if project_straight_line:
for section in section_seq:
section.project_straight_line()
return section_seq
def slf_flux2d(args):
if len(args.scalars) > 2:
logger.critical('Only two scalars can be integrated!')
sys.exit(2)
# Read set of lines from input file
polylines = []
if args.in_sections.endswith('.i2s'):
with BlueKenue.Read(args.in_sections) as f:
f.read_header()
for polyline in f.get_open_polylines():
polylines.append(polyline)
elif args.in_sections.endswith('.shp'):
try:
for polyline in Shapefile.get_open_polylines(args.in_sections):
polylines.append(polyline)
except ShapefileException as e:
logger.critical(e)
sys.exit(3)
else:
logger.critical('File "%s" is not a i2s or shp file.' %
args.in_sections)
sys.exit(2)
if not polylines:
logger.critical('The file does not contain any open polyline.')
sys.exit(1)
logger.debug('The file contains {} open polyline{}.'.format(
len(polylines), 's' if len(polylines) > 1 else ''))
# Read Serafin file
with Serafin.Read(args.in_slf, args.lang) as resin:
resin.read_header()
logger.info(resin.header.summary())
resin.get_time()
if not resin.header.is_2d:
logger.critical('The file has to be a 2D Serafin!')
sys.exit(3)
# Determine flux computations properties
var_IDs = args.vectors + args.scalars
variables_missing = [
var_ID for var_ID in var_IDs if var_ID not in resin.header.var_IDs
]
if variables_missing:
if len(variables_missing) > 1:
logger.critical(
'Variables {} are not present in the Serafin file'.format(
variables_missing))
else:
logger.critical(
'Variable {} is not present in the Serafin file'.format(
variables_missing[0]))
logger.critical(
'Check also `--lang` argument for variable detection.')
sys.exit(1)
if var_IDs not in PossibleFluxComputation.common_fluxes():
logger.warn(
'Flux computations is not common. Check what you are doing (or the language).'
)
flux_type = PossibleFluxComputation.get_flux_type(var_IDs)
section_names = ['Section %i' % (i + 1) for i in range(len(polylines))]
calculator = FluxCalculator(flux_type, var_IDs, resin, section_names,
polylines, args.ech)
calculator.construct_triangles(tqdm)
calculator.construct_intersections()
result = []
for time_index, time in enumerate(tqdm(resin.time, unit='frame')):
i_result = [str(time)]
values = []
for var_ID in calculator.var_IDs:
values.append(resin.read_var_in_frame(time_index, var_ID))
for j in range(len(polylines)):
intersections = calculator.intersections[j]
flux = calculator.flux_in_frame(intersections, values)
i_result.append(settings.FMT_FLOAT.format(flux))
result.append(i_result)
# Write CSV
mode = 'w' if args.force else 'x'
with open(args.out_csv, mode) as out_csv:
calculator.write_csv(result, out_csv, args.sep)
def slf_volume(args):
# Read set of lines from input file
polygons = []
if args.in_polygons.endswith('.i2s'):
with BlueKenue.Read(args.in_polygons) as f:
f.read_header()
for poly in f.get_polygons():
polygons.append(poly)
elif args.in_polygons.endswith('.shp'):
try:
for polygon in Shapefile.get_polygons(args.in_polygons):
polygons.append(polygon)
except ShapefileException as e:
logger.error(e)
sys.exit(3)
else:
logger.error('File "%s" is not a i2s or shp file.' % args.in_polygons)
sys.exit(2)
if not polygons:
logger.error('The file does not contain any polygon.')
sys.exit(1)
logger.debug('The file contains {} polygon{}.'.format(len(polygons), 's' if len(polygons) > 1 else ''))
names = ['Polygon %d' % (i + 1) for i in range(len(polygons))]
# Read Serafin file
with Serafin.Read(args.in_slf, args.lang) as resin:
resin.read_header()
logger.info(resin.header.summary())
resin.get_time()
if not resin.header.is_2d:
logger.error('The file has to be a 2D Serafin!')
sys.exit(3)
# Check variables consistency
if args.upper_var not in resin.header.var_IDs:
logger.error('Upper variable "%s" is not in Serafin file' % args.upper_var)
sys.exit(1)
upper_var = args.upper_var
lower_var = args.lower_var
if args.lower_var is not None:
if args.lower_var == 'init':
lower_var = VolumeCalculator.INIT_VALUE
else:
if lower_var not in resin.header.var_IDs:
logger.error('Lower variable "%s" is not in Serafin file' % lower_var)
sys.exit(1)
if args.detailed:
volume_type = VolumeCalculator.POSITIVE
else:
volume_type = VolumeCalculator.NET
calculator = VolumeCalculator(volume_type, upper_var, lower_var, resin, names, polygons, args.ech)
calculator.construct_triangles(tqdm)
calculator.construct_weights(tqdm)
result = []
for time_index in tqdm(calculator.time_indices, unit='frame'):
i_result = [str(resin.time[time_index])]
values = calculator.read_values_in_frame(time_index)
for j in range(len(calculator.polygons)):
weight = calculator.weights[j]
volume = calculator.volume_in_frame_in_polygon(weight, values, calculator.polygons[j])
if calculator.volume_type == VolumeCalculator.POSITIVE:
for v in volume:
i_result.append(settings.FMT_FLOAT.format(v))
else:
i_result.append(settings.FMT_FLOAT.format(volume))
result.append(i_result)
# Write CSV
mode = 'w' if args.force else 'x'
with open(args.out_csv, mode) as out_csv:
calculator.write_csv(result, out_csv, args.sep)