def test_get_latlng_centroid(self):
"""Ensures correct output from _get_latlng_centroid."""
(this_centroid_lat_deg,
this_centroid_lng_deg) = polygons.get_latlng_centroid(
LATITUDE_POINTS_DEG, LONGITUDE_POINTS_DEG)
self.assertTrue(
numpy.isclose(this_centroid_lat_deg,
CENTROID_LAT_DEG,
atol=TOLERANCE))
self.assertTrue(
numpy.isclose(this_centroid_lng_deg,
CENTROID_LNG_DEG,
atol=TOLERANCE))
def _init_azimuthal_equidistant_projection(storm_centroid_latitudes_deg,
storm_centroid_longitudes_deg):
"""Initializes azimuthal equidistant projection.
This projection will be centered at the "global centroid" (centroid of
centroids) of all storm objects.
N = number of storm objects
:param storm_centroid_latitudes_deg: length-N numpy array with latitudes
(deg N) of storm centroids.
:param storm_centroid_longitudes_deg: length-N numpy array with longitudes
(deg E) of storm centroids.
:return: projection_object: Instance of `pyproj.Proj`, which can be used to
convert between lat-long and x-y coordinates.
"""
(global_centroid_lat_deg,
global_centroid_lng_deg) = polygons.get_latlng_centroid(
storm_centroid_latitudes_deg, storm_centroid_longitudes_deg)
return projections.init_azimuthal_equidistant_projection(
global_centroid_lat_deg, global_centroid_lng_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 make_buffers_around_polygons(storm_object_table,
min_buffer_dists_metres=None,
max_buffer_dists_metres=None):
"""Creates one or more buffers around each storm polygon.
N = number of buffers
V = number of vertices in a given polygon
:param storm_object_table: pandas DataFrame with the following columns.
storm_object_table.storm_id: String ID for storm cell.
storm_object_table.polygon_object_latlng: Instance of
`shapely.geometry.Polygon`, with vertices in lat-long coordinates.
:param min_buffer_dists_metres: length-N numpy array of minimum buffer
distances. If min_buffer_dists_metres[i] is NaN, the [i]th buffer
includes the original polygon. If min_buffer_dists_metres[i] is
defined, the [i]th buffer is a "nested" buffer, not including the
original polygon.
:param max_buffer_dists_metres: length-N numpy array of maximum buffer
distances. Must be all real numbers (no NaN).
:return: storm_object_table: Same as input, but with N extra columns.
storm_object_table.polygon_object_latlng_buffer_<D>m: Instance of
`shapely.geometry.Polygon` for D-metre buffer around storm.
storm_object_table.polygon_object_latlng_buffer_<d>_<D>m: Instance of
`shapely.geometry.Polygon` for d-to-D-metre buffer around storm.
"""
error_checking.assert_is_geq_numpy_array(min_buffer_dists_metres,
0.,
allow_nan=True)
error_checking.assert_is_numpy_array(min_buffer_dists_metres,
num_dimensions=1)
num_buffers = len(min_buffer_dists_metres)
error_checking.assert_is_geq_numpy_array(max_buffer_dists_metres,
0.,
allow_nan=False)
error_checking.assert_is_numpy_array(max_buffer_dists_metres,
exact_dimensions=numpy.array(
[num_buffers]))
for j in range(num_buffers):
if numpy.isnan(min_buffer_dists_metres[j]):
continue
error_checking.assert_is_greater(max_buffer_dists_metres[j],
min_buffer_dists_metres[j],
allow_nan=False)
num_storm_objects = len(storm_object_table.index)
centroid_latitudes_deg = numpy.full(num_storm_objects, numpy.nan)
centroid_longitudes_deg = numpy.full(num_storm_objects, numpy.nan)
for i in range(num_storm_objects):
this_centroid_object = storm_object_table[
POLYGON_OBJECT_LATLNG_COLUMN].values[0].centroid
centroid_latitudes_deg[i] = this_centroid_object.y
centroid_longitudes_deg[i] = this_centroid_object.x
global_centroid_lat_deg, global_centroid_lng_deg = (
polygons.get_latlng_centroid(centroid_latitudes_deg,
centroid_longitudes_deg))
projection_object = projections.init_azimuthal_equidistant_projection(
global_centroid_lat_deg, global_centroid_lng_deg)
object_array = numpy.full(num_storm_objects, numpy.nan, dtype=object)
argument_dict = {}
buffer_column_names = [''] * num_buffers
for j in range(num_buffers):
buffer_column_names[j] = distance_buffer_to_column_name(
min_buffer_dists_metres[j], max_buffer_dists_metres[j])
argument_dict.update({buffer_column_names[j]: object_array})
storm_object_table = storm_object_table.assign(**argument_dict)
for i in range(num_storm_objects):
orig_vertex_dict_latlng = polygons.polygon_object_to_vertex_arrays(
storm_object_table[POLYGON_OBJECT_LATLNG_COLUMN].values[i])
(orig_vertex_x_metres,
orig_vertex_y_metres) = projections.project_latlng_to_xy(
orig_vertex_dict_latlng[polygons.EXTERIOR_Y_COLUMN],
orig_vertex_dict_latlng[polygons.EXTERIOR_X_COLUMN],
projection_object=projection_object)
for j in range(num_buffers):
buffer_polygon_object_xy = polygons.buffer_simple_polygon(
orig_vertex_x_metres,
orig_vertex_y_metres,
min_buffer_dist_metres=min_buffer_dists_metres[j],
max_buffer_dist_metres=max_buffer_dists_metres[j])
buffer_vertex_dict = polygons.polygon_object_to_vertex_arrays(
buffer_polygon_object_xy)
(buffer_vertex_dict[polygons.EXTERIOR_Y_COLUMN],
buffer_vertex_dict[polygons.EXTERIOR_X_COLUMN]) = (
projections.project_xy_to_latlng(
buffer_vertex_dict[polygons.EXTERIOR_X_COLUMN],
buffer_vertex_dict[polygons.EXTERIOR_Y_COLUMN],
projection_object=projection_object))
this_num_holes = len(buffer_vertex_dict[polygons.HOLE_X_COLUMN])
for k in range(this_num_holes):
(buffer_vertex_dict[polygons.HOLE_Y_COLUMN][k],
buffer_vertex_dict[polygons.HOLE_X_COLUMN][k]) = (
projections.project_xy_to_latlng(
buffer_vertex_dict[polygons.HOLE_X_COLUMN][k],
buffer_vertex_dict[polygons.HOLE_Y_COLUMN][k],
projection_object=projection_object))
buffer_polygon_object_latlng = (
polygons.vertex_arrays_to_polygon_object(
buffer_vertex_dict[polygons.EXTERIOR_X_COLUMN],
buffer_vertex_dict[polygons.EXTERIOR_Y_COLUMN],
hole_x_coords_list=buffer_vertex_dict[
polygons.HOLE_X_COLUMN],
hole_y_coords_list=buffer_vertex_dict[
polygons.HOLE_Y_COLUMN]))
storm_object_table[buffer_column_names[j]].values[
i] = buffer_polygon_object_latlng
return storm_object_table
def read_storm_objects_from_raw_file(json_file_name):
"""Reads storm objects from raw file.
This file should contain all storm objects for one tracking scale and one
time step.
P = number of grid points in given storm object
V = number of vertices in bounding polygon of given storm object
:param json_file_name: Path to input file.
:return: storm_object_table: pandas DataFrame with the following columns.
storm_object_table.storm_id: String ID for storm cell.
storm_object_table.unix_time_sec: Time in Unix format.
storm_object_table.spc_date_unix_sec: SPC date in Unix format.
storm_object_table.tracking_start_time_unix_sec: Start time for tracking
period.
storm_object_table.tracking_end_time_unix_sec: End time for tracking
period.
storm_object_table.east_velocity_m_s01: Eastward velocity (m/s).
storm_object_table.north_velocity_m_s01: Northward velocity (m/s).
storm_object_table.age_sec: Age of storm cell (seconds).
storm_object_table.centroid_lat_deg: Latitude at centroid of storm object
(deg N).
storm_object_table.centroid_lng_deg: Longitude at centroid of storm object
(deg E).
storm_object_table.grid_point_latitudes_deg: length-P numpy array with
latitudes (deg N) of grid points in storm object.
storm_object_table.grid_point_longitudes_deg: length-P numpy array with
longitudes (deg E) of grid points in storm object.
storm_object_table.grid_point_rows: length-P numpy array with row indices
(integers) of grid points in storm object.
storm_object_table.grid_point_columns: length-P numpy array with column
indices (integers) of grid points in storm object.
storm_object_table.polygon_object_latlng: Instance of
`shapely.geometry.Polygon` with vertices in lat-long coordinates.
storm_object_table.polygon_object_rowcol: Instance of
`shapely.geometry.Polygon` with vertices in row-column coordinates.
"""
error_checking.assert_file_exists(json_file_name)
with open(json_file_name) as json_file_handle:
probsevere_dict = json.load(json_file_handle)
unix_time_sec = time_conversion.string_to_unix_sec(
probsevere_dict[TIME_COLUMN_ORIG].encode('ascii', 'ignore'),
TIME_FORMAT_IN_RAW_FILES)
spc_date_unix_sec = time_conversion.time_to_spc_date_unix_sec(unix_time_sec)
num_storms = len(probsevere_dict[FEATURES_COLUMN_ORIG])
unix_times_sec = numpy.full(num_storms, unix_time_sec, 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)
storm_ids = [None] * num_storms
east_velocities_m_s01 = numpy.full(num_storms, numpy.nan)
north_velocities_m_s01 = numpy.full(num_storms, numpy.nan)
for i in range(num_storms):
storm_ids[i] = str(
probsevere_dict[FEATURES_COLUMN_ORIG][i][PROPERTIES_COLUMN_ORIG][
STORM_ID_COLUMN_ORIG])
east_velocities_m_s01[i] = float(
probsevere_dict[FEATURES_COLUMN_ORIG][i][PROPERTIES_COLUMN_ORIG][
EAST_VELOCITY_COLUMN_ORIG])
north_velocities_m_s01[i] = -1 * float(
probsevere_dict[FEATURES_COLUMN_ORIG][i][PROPERTIES_COLUMN_ORIG][
NORTH_VELOCITY_COLUMN_ORIG])
storm_object_dict = {
tracking_io.STORM_ID_COLUMN: storm_ids,
tracking_io.EAST_VELOCITY_COLUMN: east_velocities_m_s01,
tracking_io.NORTH_VELOCITY_COLUMN: north_velocities_m_s01,
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}
storm_object_table = pandas.DataFrame.from_dict(storm_object_dict)
storm_object_table = tracking_io.remove_rows_with_nan(storm_object_table)
num_storms = len(storm_object_table.index)
storm_ages_sec = numpy.full(num_storms, numpy.nan)
simple_array = numpy.full(num_storms, numpy.nan)
object_array = numpy.full(num_storms, numpy.nan, dtype=object)
nested_array = storm_object_table[[
tracking_io.STORM_ID_COLUMN,
tracking_io.STORM_ID_COLUMN]].values.tolist()
argument_dict = {tracking_io.AGE_COLUMN: storm_ages_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.GRID_POINT_ROW_COLUMN: nested_array,
tracking_io.GRID_POINT_COLUMN_COLUMN: nested_array,
tracking_io.POLYGON_OBJECT_LATLNG_COLUMN: object_array,
tracking_io.POLYGON_OBJECT_ROWCOL_COLUMN: object_array}
storm_object_table = storm_object_table.assign(**argument_dict)
for i in range(num_storms):
this_vertex_matrix_deg = numpy.asarray(
probsevere_dict[FEATURES_COLUMN_ORIG][i][GEOMETRY_COLUMN_ORIG][
COORDINATES_COLUMN_ORIG][0])
these_vertex_lat_deg = this_vertex_matrix_deg[:, LAT_COLUMN_INDEX_ORIG]
these_vertex_lng_deg = this_vertex_matrix_deg[:, LNG_COLUMN_INDEX_ORIG]
(these_vertex_rows, these_vertex_columns) = radar_io.latlng_to_rowcol(
these_vertex_lat_deg, these_vertex_lng_deg,
nw_grid_point_lat_deg=NW_GRID_POINT_LAT_DEG,
nw_grid_point_lng_deg=NW_GRID_POINT_LNG_DEG,
lat_spacing_deg=GRID_LAT_SPACING_DEG,
lng_spacing_deg=GRID_LNG_SPACING_DEG)
these_vertex_rows, these_vertex_columns = (
polygons.fix_probsevere_vertices(
these_vertex_rows, these_vertex_columns))
these_vertex_lat_deg, these_vertex_lng_deg = radar_io.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=GRID_LAT_SPACING_DEG,
lng_spacing_deg=GRID_LNG_SPACING_DEG)
(storm_object_table[tracking_io.GRID_POINT_ROW_COLUMN].values[i],
storm_object_table[tracking_io.GRID_POINT_COLUMN_COLUMN].values[i]) = (
polygons.simple_polygon_to_grid_points(
these_vertex_rows, these_vertex_columns))
(storm_object_table[tracking_io.GRID_POINT_LAT_COLUMN].values[i],
storm_object_table[tracking_io.GRID_POINT_LNG_COLUMN].values[i]) = (
radar_io.rowcol_to_latlng(
storm_object_table[tracking_io.GRID_POINT_ROW_COLUMN].values[i],
storm_object_table[
tracking_io.GRID_POINT_COLUMN_COLUMN].values[i],
nw_grid_point_lat_deg=NW_GRID_POINT_LAT_DEG,
nw_grid_point_lng_deg=NW_GRID_POINT_LNG_DEG,
lat_spacing_deg=GRID_LAT_SPACING_DEG,
lng_spacing_deg=GRID_LNG_SPACING_DEG))
(storm_object_table[tracking_io.CENTROID_LAT_COLUMN].values[i],
storm_object_table[tracking_io.CENTROID_LNG_COLUMN].values[i]) = (
polygons.get_latlng_centroid(
these_vertex_lat_deg, these_vertex_lng_deg))
storm_object_table[
tracking_io.POLYGON_OBJECT_ROWCOL_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(
these_vertex_columns, these_vertex_rows))
storm_object_table[
tracking_io.POLYGON_OBJECT_LATLNG_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(
these_vertex_lng_deg, these_vertex_lat_deg))
return storm_object_table
tracking_io.
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_io.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 = polygons.get_latlng_centroid(
THESE_VERTEX_LATITUDES_DEG, THESE_VERTEX_LONGITUDES_DEG)
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_io.CENTROID_LAT_COLUMN].values[i] = THIS_CENTROID_LAT_DEG
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_io.CENTROID_LNG_COLUMN].values[i] = THIS_CENTROID_LNG_DEG
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_io.POLYGON_OBJECT_LATLNG_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(
THESE_VERTEX_LONGITUDES_DEG, THESE_VERTEX_LATITUDES_DEG))
STORM_OBJECT_TABLE_SMALL_SCALE[
tracking_io.POLYGON_OBJECT_ROWCOL_COLUMN].values[i] = (
polygons.vertex_arrays_to_polygon_object(THESE_VERTEX_COLUMNS,
THESE_VERTEX_ROWS))