def test_grid_points_in_poly_to_vertices(self):
"""Ensures correct output from grid_points_in_poly_to_vertices."""
these_vertex_rows, these_vertex_columns = (
polygons.grid_points_in_poly_to_vertices(
ROW_INDICES_IN_POLYGON, COLUMN_INDICES_IN_POLYGON))
self.assertTrue(
numpy.array_equal(these_vertex_rows,
VERTEX_ROWS_GRID_CELL_EDGES_NON_REDUNDANT))
self.assertTrue(
numpy.array_equal(these_vertex_columns,
VERTEX_COLUMNS_GRID_CELL_EDGES_NON_REDUNDANT))
for i in range(NUM_STORMS_SMALL_SCALE):
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_utils.
GRID_POINT_LAT_COLUMN].values[i] = GRID_POINT_LAT_BY_STORM_DEG[i]
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_utils.
GRID_POINT_LNG_COLUMN].values[i] = GRID_POINT_LNG_BY_STORM_DEG[i]
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_utils.
GRID_POINT_ROW_COLUMN].values[i] = GRID_POINT_ROWS_BY_STORM[i]
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_utils.
GRID_POINT_COLUMN_COLUMN].values[i] = GRID_POINT_COLUMNS_BY_STORM[i]
THESE_VERTEX_ROWS, THESE_VERTEX_COLUMNS = (
polygons.grid_points_in_poly_to_vertices(
GRID_POINT_ROWS_BY_STORM[i], GRID_POINT_COLUMNS_BY_STORM[i]))
THESE_VERTEX_LATITUDES_DEG, THESE_VERTEX_LONGITUDES_DEG = (
radar_utils.rowcol_to_latlng(
THESE_VERTEX_ROWS,
THESE_VERTEX_COLUMNS,
nw_grid_point_lat_deg=NW_GRID_POINT_LAT_DEG,
nw_grid_point_lng_deg=NW_GRID_POINT_LNG_DEG,
lat_spacing_deg=LATITUDE_SPACING_DEG,
lng_spacing_deg=LONGITUDE_SPACING_DEG))
(THIS_CENTROID_LAT_DEG,
THIS_CENTROID_LNG_DEG) = geodetic_utils.get_latlng_centroid(
latitudes_deg=THESE_VERTEX_LATITUDES_DEG,
longitudes_deg=THESE_VERTEX_LONGITUDES_DEG)
def read_polygons_from_netcdf(netcdf_file_name,
metadata_dict=None,
spc_date_unix_sec=None,
tracking_start_time_unix_sec=None,
tracking_end_time_unix_sec=None,
raise_error_if_fails=True):
"""Reads storm polygons (outlines of storm cells) from NetCDF file.
P = number of grid points in storm cell (different for each storm cell)
V = number of vertices in storm polygon (different for each storm cell)
If file cannot be opened, returns None.
:param netcdf_file_name: Path to input file.
:param metadata_dict: Dictionary with metadata for NetCDF file, created by
`radar_io.read_metadata_from_raw_file`.
:param spc_date_unix_sec: SPC date;
:param tracking_start_time_unix_sec: Start time for tracking period. This
can be found by `get_start_end_times_for_spc_date`.
:param tracking_end_time_unix_sec: End time for tracking period. This can
be found by `get_start_end_times_for_spc_date`.
:param raise_error_if_fails: Boolean flag. If True and file cannot be
opened, this method will raise an error.
:return: polygon_table: If file cannot be opened and raise_error_if_fails =
False, this is None. Otherwise, it is a pandas DataFrame with the
following columns.
polygon_table.storm_id: String ID for storm cell.
polygon_table.unix_time_sec: Time in Unix format.
polygon_table.spc_date_unix_sec: SPC date in Unix format.
polygon_table.tracking_start_time_unix_sec: Start time for tracking period.
polygon_table.tracking_end_time_unix_sec: End time for tracking period.
polygon_table.centroid_lat_deg: Latitude at centroid of storm cell (deg N).
polygon_table.centroid_lng_deg: Longitude at centroid of storm cell (deg E).
polygon_table.grid_point_latitudes_deg: length-P numpy array with latitudes
(deg N) of grid points in storm cell.
polygon_table.grid_point_longitudes_deg: length-P numpy array with
longitudes (deg E) of grid points in storm cell.
polygon_table.grid_point_rows: length-P numpy array with row indices (all
integers) of grid points in storm cell.
polygon_table.grid_point_columns: length-P numpy array with column indices
(all integers) of grid points in storm cell.
polygon_table.polygon_object_latlng: Instance of `shapely.geometry.Polygon`
with vertices in lat-long coordinates.
polygon_table.polygon_object_rowcol: Instance of `shapely.geometry.Polygon`
with vertices in row-column coordinates.
"""
error_checking.assert_file_exists(netcdf_file_name)
error_checking.assert_is_integer(spc_date_unix_sec)
error_checking.assert_is_not_nan(spc_date_unix_sec)
error_checking.assert_is_integer(tracking_start_time_unix_sec)
error_checking.assert_is_not_nan(tracking_start_time_unix_sec)
error_checking.assert_is_integer(tracking_end_time_unix_sec)
error_checking.assert_is_not_nan(tracking_end_time_unix_sec)
netcdf_dataset = netcdf_io.open_netcdf(netcdf_file_name,
raise_error_if_fails)
if netcdf_dataset is None:
return None
storm_id_var_name = metadata_dict[radar_io.FIELD_NAME_COLUMN]
storm_id_var_name_orig = metadata_dict[radar_io.FIELD_NAME_COLUMN_ORIG]
num_values = len(netcdf_dataset.variables[radar_io.GRID_ROW_COLUMN_ORIG])
if num_values == 0:
sparse_grid_dict = {
radar_io.GRID_ROW_COLUMN: numpy.array([], dtype=int),
radar_io.GRID_COLUMN_COLUMN: numpy.array([], dtype=int),
radar_io.NUM_GRID_CELL_COLUMN: numpy.array([], dtype=int),
storm_id_var_name: numpy.array([], dtype=int)
}
else:
sparse_grid_dict = {
radar_io.GRID_ROW_COLUMN:
netcdf_dataset.variables[radar_io.GRID_ROW_COLUMN_ORIG][:],
radar_io.GRID_COLUMN_COLUMN:
netcdf_dataset.variables[radar_io.GRID_COLUMN_COLUMN_ORIG][:],
radar_io.NUM_GRID_CELL_COLUMN:
netcdf_dataset.variables[radar_io.NUM_GRID_CELL_COLUMN_ORIG][:],
storm_id_var_name:
netcdf_dataset.variables[storm_id_var_name_orig][:]
}
netcdf_dataset.close()
sparse_grid_table = pandas.DataFrame.from_dict(sparse_grid_dict)
numeric_storm_id_matrix, _, _ = (radar_s2f.sparse_to_full_grid(
sparse_grid_table, metadata_dict))
polygon_table = _storm_id_matrix_to_coord_lists(numeric_storm_id_matrix)
num_storms = len(polygon_table.index)
unix_times_sec = numpy.full(num_storms,
metadata_dict[radar_io.UNIX_TIME_COLUMN],
dtype=int)
spc_dates_unix_sec = numpy.full(num_storms, spc_date_unix_sec, dtype=int)
tracking_start_times_unix_sec = numpy.full(num_storms,
tracking_start_time_unix_sec,
dtype=int)
tracking_end_times_unix_sec = numpy.full(num_storms,
tracking_end_time_unix_sec,
dtype=int)
spc_date_string = time_conversion.time_to_spc_date_string(
spc_date_unix_sec)
storm_ids = _append_spc_date_to_storm_ids(
polygon_table[tracking_io.STORM_ID_COLUMN].values, spc_date_string)
simple_array = numpy.full(num_storms, numpy.nan)
object_array = numpy.full(num_storms, numpy.nan, dtype=object)
nested_array = polygon_table[[
tracking_io.STORM_ID_COLUMN, tracking_io.STORM_ID_COLUMN
]].values.tolist()
argument_dict = {
tracking_io.STORM_ID_COLUMN: storm_ids,
tracking_io.TIME_COLUMN: unix_times_sec,
tracking_io.SPC_DATE_COLUMN: spc_dates_unix_sec,
tracking_io.TRACKING_START_TIME_COLUMN: tracking_start_times_unix_sec,
tracking_io.TRACKING_END_TIME_COLUMN: tracking_end_times_unix_sec,
tracking_io.CENTROID_LAT_COLUMN: simple_array,
tracking_io.CENTROID_LNG_COLUMN: simple_array,
tracking_io.GRID_POINT_LAT_COLUMN: nested_array,
tracking_io.GRID_POINT_LNG_COLUMN: nested_array,
tracking_io.POLYGON_OBJECT_LATLNG_COLUMN: object_array,
tracking_io.POLYGON_OBJECT_ROWCOL_COLUMN: object_array
}
polygon_table = polygon_table.assign(**argument_dict)
for i in range(num_storms):
these_vertex_rows, these_vertex_columns = (
polygons.grid_points_in_poly_to_vertices(
polygon_table[tracking_io.GRID_POINT_ROW_COLUMN].values[i],
polygon_table[tracking_io.GRID_POINT_COLUMN_COLUMN].values[i]))
(polygon_table[tracking_io.GRID_POINT_ROW_COLUMN].values[i],
polygon_table[tracking_io.GRID_POINT_COLUMN_COLUMN].values[i]) = (
polygons.simple_polygon_to_grid_points(these_vertex_rows,
these_vertex_columns))
(polygon_table[tracking_io.GRID_POINT_LAT_COLUMN].values[i],
polygon_table[tracking_io.GRID_POINT_LNG_COLUMN].values[i]) = (
radar_io.rowcol_to_latlng(
polygon_table[tracking_io.GRID_POINT_ROW_COLUMN].values[i],
polygon_table[tracking_io.GRID_POINT_COLUMN_COLUMN].values[i],
nw_grid_point_lat_deg=metadata_dict[
radar_io.NW_GRID_POINT_LAT_COLUMN],
nw_grid_point_lng_deg=metadata_dict[
radar_io.NW_GRID_POINT_LNG_COLUMN],
lat_spacing_deg=metadata_dict[radar_io.LAT_SPACING_COLUMN],
lng_spacing_deg=metadata_dict[radar_io.LNG_SPACING_COLUMN]))
these_vertex_lat_deg, these_vertex_lng_deg = radar_io.rowcol_to_latlng(
these_vertex_rows,
these_vertex_columns,
nw_grid_point_lat_deg=metadata_dict[
radar_io.NW_GRID_POINT_LAT_COLUMN],
nw_grid_point_lng_deg=metadata_dict[
radar_io.NW_GRID_POINT_LNG_COLUMN],
lat_spacing_deg=metadata_dict[radar_io.LAT_SPACING_COLUMN],
lng_spacing_deg=metadata_dict[radar_io.LNG_SPACING_COLUMN])
(polygon_table[tracking_io.CENTROID_LAT_COLUMN].values[i],
polygon_table[tracking_io.CENTROID_LNG_COLUMN].values[i]) = (
polygons.get_latlng_centroid(these_vertex_lat_deg,
these_vertex_lng_deg))
polygon_table[tracking_io.POLYGON_OBJECT_ROWCOL_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(these_vertex_columns,
these_vertex_rows))
polygon_table[tracking_io.POLYGON_OBJECT_LATLNG_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(these_vertex_lng_deg,
these_vertex_lat_deg))
return polygon_table
def read_polygons_from_netcdf(netcdf_file_name,
metadata_dict,
spc_date_string,
tracking_start_time_unix_sec,
tracking_end_time_unix_sec,
raise_error_if_fails=True):
"""Reads storm polygons (outlines of storm cells) from NetCDF file.
P = number of grid points in storm cell (different for each storm cell)
V = number of vertices in storm polygon (different for each storm cell)
If file cannot be opened, returns None.
:param netcdf_file_name: Path to input file.
:param metadata_dict: Dictionary with metadata for NetCDF file, created by
`myrorss_and_mrms_io.read_metadata_from_raw_file`.
:param spc_date_string: SPC date (format "yyyymmdd").
:param tracking_start_time_unix_sec: Start time for tracking period. This
can be found by `get_start_end_times_for_spc_date`.
:param tracking_end_time_unix_sec: End time for tracking period. This can
be found by `get_start_end_times_for_spc_date`.
:param raise_error_if_fails: Boolean flag. If True and file cannot be
opened, this method will raise an error.
:return: polygon_table: pandas DataFrame with the following columns. Each
row is one storm object.
polygon_table.primary_id_string: See documentation for
`storm_tracking_io.write_file`.
polygon_table.valid_time_unix_sec: Same.
polygon_table.spc_date_string: Same.
polygon_table.tracking_start_time_unix_sec: Same.
polygon_table.tracking_end_time_unix_sec: Same.
polygon_table.centroid_latitude_deg: Same.
polygon_table.centroid_longitude_deg: Same.
polygon_table.grid_point_latitudes_deg: Same.
polygon_table.grid_point_longitudes_deg: Same.
polygon_table.grid_point_rows: Same.
polygon_table.grid_point_columns: Same.
polygon_table.polygon_object_latlng_deg: Same.
polygon_table.polygon_object_rowcol: Same.
"""
error_checking.assert_file_exists(netcdf_file_name)
error_checking.assert_is_integer(tracking_start_time_unix_sec)
error_checking.assert_is_not_nan(tracking_start_time_unix_sec)
error_checking.assert_is_integer(tracking_end_time_unix_sec)
error_checking.assert_is_not_nan(tracking_end_time_unix_sec)
netcdf_dataset = netcdf_io.open_netcdf(netcdf_file_name,
raise_error_if_fails)
if netcdf_dataset is None:
return None
storm_id_column = metadata_dict[radar_utils.FIELD_NAME_COLUMN]
storm_id_column_orig = metadata_dict[
myrorss_and_mrms_io.FIELD_NAME_COLUMN_ORIG]
num_values = len(
netcdf_dataset.variables[myrorss_and_mrms_io.GRID_ROW_COLUMN_ORIG])
if num_values == 0:
sparse_grid_dict = {
myrorss_and_mrms_io.GRID_ROW_COLUMN: numpy.array([], dtype=int),
myrorss_and_mrms_io.GRID_COLUMN_COLUMN: numpy.array([], dtype=int),
myrorss_and_mrms_io.NUM_GRID_CELL_COLUMN: numpy.array([],
dtype=int),
storm_id_column: numpy.array([], dtype=int)
}
else:
sparse_grid_dict = {
myrorss_and_mrms_io.GRID_ROW_COLUMN:
netcdf_dataset.variables[myrorss_and_mrms_io.GRID_ROW_COLUMN_ORIG]
[:],
myrorss_and_mrms_io.GRID_COLUMN_COLUMN:
netcdf_dataset.variables[
myrorss_and_mrms_io.GRID_COLUMN_COLUMN_ORIG][:],
myrorss_and_mrms_io.NUM_GRID_CELL_COLUMN:
netcdf_dataset.variables[
myrorss_and_mrms_io.NUM_GRID_CELL_COLUMN_ORIG][:],
storm_id_column:
netcdf_dataset.variables[storm_id_column_orig][:]
}
netcdf_dataset.close()
sparse_grid_table = pandas.DataFrame.from_dict(sparse_grid_dict)
numeric_id_matrix = radar_s2f.sparse_to_full_grid(sparse_grid_table,
metadata_dict)[0]
polygon_table = _id_matrix_to_coord_lists(numeric_id_matrix)
num_storms = len(polygon_table.index)
valid_times_unix_sec = numpy.full(
num_storms, metadata_dict[radar_utils.UNIX_TIME_COLUMN], dtype=int)
spc_date_strings = num_storms * [
time_conversion.time_to_spc_date_string(valid_times_unix_sec[0])
]
tracking_start_times_unix_sec = numpy.full(num_storms,
tracking_start_time_unix_sec,
dtype=int)
tracking_end_times_unix_sec = numpy.full(num_storms,
tracking_end_time_unix_sec,
dtype=int)
simple_array = numpy.full(num_storms, numpy.nan)
object_array = numpy.full(num_storms, numpy.nan, dtype=object)
nested_array = polygon_table[[
tracking_utils.PRIMARY_ID_COLUMN, tracking_utils.PRIMARY_ID_COLUMN
]].values.tolist()
argument_dict = {
tracking_utils.VALID_TIME_COLUMN: valid_times_unix_sec,
tracking_utils.SPC_DATE_COLUMN: spc_date_strings,
tracking_utils.TRACKING_START_TIME_COLUMN:
tracking_start_times_unix_sec,
tracking_utils.TRACKING_END_TIME_COLUMN: tracking_end_times_unix_sec,
tracking_utils.CENTROID_LATITUDE_COLUMN: simple_array,
tracking_utils.CENTROID_LONGITUDE_COLUMN: simple_array,
tracking_utils.LATITUDES_IN_STORM_COLUMN: nested_array,
tracking_utils.LONGITUDES_IN_STORM_COLUMN: nested_array,
tracking_utils.LATLNG_POLYGON_COLUMN: object_array,
tracking_utils.ROWCOL_POLYGON_COLUMN: object_array
}
polygon_table = polygon_table.assign(**argument_dict)
for i in range(num_storms):
these_vertex_rows, these_vertex_columns = (
polygons.grid_points_in_poly_to_vertices(
grid_point_row_indices=polygon_table[
tracking_utils.ROWS_IN_STORM_COLUMN].values[i],
grid_point_column_indices=polygon_table[
tracking_utils.COLUMNS_IN_STORM_COLUMN].values[i]))
(polygon_table[tracking_utils.ROWS_IN_STORM_COLUMN].values[i],
polygon_table[tracking_utils.COLUMNS_IN_STORM_COLUMN].values[i]
) = polygons.simple_polygon_to_grid_points(
vertex_row_indices=these_vertex_rows,
vertex_column_indices=these_vertex_columns)
(polygon_table[tracking_utils.LATITUDES_IN_STORM_COLUMN].values[i],
polygon_table[tracking_utils.LONGITUDES_IN_STORM_COLUMN].values[i]
) = radar_utils.rowcol_to_latlng(
grid_rows=polygon_table[
tracking_utils.ROWS_IN_STORM_COLUMN].values[i],
grid_columns=polygon_table[
tracking_utils.COLUMNS_IN_STORM_COLUMN].values[i],
nw_grid_point_lat_deg=metadata_dict[
radar_utils.NW_GRID_POINT_LAT_COLUMN],
nw_grid_point_lng_deg=metadata_dict[
radar_utils.NW_GRID_POINT_LNG_COLUMN],
lat_spacing_deg=metadata_dict[radar_utils.LAT_SPACING_COLUMN],
lng_spacing_deg=metadata_dict[radar_utils.LNG_SPACING_COLUMN])
these_vertex_lat_deg, these_vertex_lng_deg = (
radar_utils.rowcol_to_latlng(
grid_rows=these_vertex_rows,
grid_columns=these_vertex_columns,
nw_grid_point_lat_deg=metadata_dict[
radar_utils.NW_GRID_POINT_LAT_COLUMN],
nw_grid_point_lng_deg=metadata_dict[
radar_utils.NW_GRID_POINT_LNG_COLUMN],
lat_spacing_deg=metadata_dict[radar_utils.LAT_SPACING_COLUMN],
lng_spacing_deg=metadata_dict[radar_utils.LNG_SPACING_COLUMN]))
(polygon_table[tracking_utils.CENTROID_LATITUDE_COLUMN].values[i],
polygon_table[tracking_utils.CENTROID_LONGITUDE_COLUMN].values[i]
) = geodetic_utils.get_latlng_centroid(
latitudes_deg=these_vertex_lat_deg,
longitudes_deg=these_vertex_lng_deg)
polygon_table[tracking_utils.ROWCOL_POLYGON_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(
exterior_x_coords=these_vertex_columns,
exterior_y_coords=these_vertex_rows))
polygon_table[tracking_utils.LATLNG_POLYGON_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(
exterior_x_coords=these_vertex_lng_deg,
exterior_y_coords=these_vertex_lat_deg))
primary_id_strings = _append_spc_date_to_storm_ids(
primary_id_strings=polygon_table[
tracking_utils.PRIMARY_ID_COLUMN].values,
spc_date_string=spc_date_string)
return polygon_table.assign(
**{tracking_utils.PRIMARY_ID_COLUMN: primary_id_strings})