Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Dynamic Exposure
Legacy
gde_calculations_prototype
Commits
e31cbb26
Commit
e31cbb26
authored
May 06, 2021
by
Cecilia Nievas
Browse files
Added function determine_cardinal_point and its test
parent
2bfbb2a4
Changes
2
Hide whitespace changes
Inline
Sidebyside
GDE_TOOLS_create_industrial_cells.py
View file @
e31cbb26
...
...
@@ 746,3 +746,103 @@ def guarantee_radians(in_theta, theta_thr, inputangle):
)
return
in_theta
,
theta_thr
def
determine_cardinal_point
(
in_theta
,
theta_thr
,
inputangle
=
"radians"
):
"""This function "translates" each angle in the array in_theta into a direction in terms of
"cardinal points". The array in_theta contains angles between an EW ("horizontal") line
and another line, in the range [pi, +pi], measured from the EW ("horizontal") line. If
positive, it is measured counterclockwise, if positive, it is measured clockwise. They are
expected to stem from the use of numpy.arctan2(), which yields an angle in this range,
under this same convention. The "translation" is done in terms of the tautological
definition of cardinal points (e.g. that 0 is east, pi/2 is north, pi and pi are west,
pi/2 is south) and an angle theta_thr that defines how much can the line deviate from,
for example, pi/2, and still be considered north. The exact ranges associated with each
of the eight possible outcomes (N, S, E, W, NE, NW, SE, SW) are defined within the code.
This function does exactly the same as determine_cardinal_point_indiv, but this function
needs in_theta to be an array while in determine_cardinal_point_indiv in_theta is a float.
Args:
in_theta (array of floats): Angle between an EW ("horizontal") line and another line,
in the range [pi, +pi], measure from the EW
("horizontal") line. If positive, it is measured counter
clockwise, if negative, it is measured clockwise. It is
expected to stem from the use of numpy.arctan2(), which
yields an angle in this range, under this same convention.
If in_theta is outside the range [pi, +pi], this function
will return an array with 'UU', meaning "unknown".
theta_thr (float): Angle used to divide all possible values of in_theta into east (E),
northeast (NE), north (N), northwest (NW), and so on. It needs to
be positive. The ranges that relate to each categories are defined
in the code.
inputangle (str): Units of in_theta and theta_thr, either "radians" or "degrees".
Returns:
out_card (array of str): Array of the same length as in_theta. Each individual value
can only be one of these values: N, S, E, W, NE, NW, SE, SW,
or U, the latter meaning "unknown", i.e. something is wrong
in the input.
"""
in_theta
,
theta_thr
=
guarantee_radians
(
in_theta
,
theta_thr
,
inputangle
)
# Initialise output array with "unknown":
out_card
=
np
.
array
([
"UU"
for
i
in
range
(
len
(
in_theta
))])
if
theta_thr
<
0.0
:
# theta_thr cannot be negative
return
out_card
# East
out_card
[
np
.
where
(
np
.
logical_and
(
in_theta
>=

theta_thr
,
in_theta
<=
theta_thr
))[
0
]]
=
"E"
# Northeast
out_card
[
np
.
where
(
np
.
logical_and
(
in_theta
>
theta_thr
,
in_theta
<
(
np
.
pi
/
2.0

theta_thr
)))[
0
]
]
=
"NE"
# North
out_card
[
np
.
where
(
np
.
logical_and
(
in_theta
>=
(
np
.
pi
/
2.0

theta_thr
),
in_theta
<=
(
np
.
pi
/
2.0
+
theta_thr
)
)
)[
0
]
]
=
"N"
# Northwest
out_card
[
np
.
where
(
np
.
logical_and
(
in_theta
>
(
np
.
pi
/
2.0
+
theta_thr
),
in_theta
<
(
np
.
pi

theta_thr
))
)[
0
]
]
=
"NW"
# West (below, *1.00001 is the marging for floating point precision)
out_card
[
np
.
where
(
np
.
logical_or
(
np
.
logical_and
(
in_theta
>=
(
np
.
pi

theta_thr
),
in_theta
<=
np
.
pi
*
1.00001
),
np
.
logical_and
(
in_theta
>=

np
.
pi
*
1.00001
,
in_theta
<=
(

np
.
pi
+
theta_thr
)),
)
)[
0
]
]
=
"W"
# Southwest
out_card
[
np
.
where
(
np
.
logical_and
(
in_theta
>
(

np
.
pi
+
theta_thr
),
in_theta
<
(

np
.
pi
/
2.0

theta_thr
)
)
)[
0
]
]
=
"SW"
# South
out_card
[
np
.
where
(
np
.
logical_and
(
in_theta
>=
(

np
.
pi
/
2.0

theta_thr
),
in_theta
<=
(

np
.
pi
/
2.0
+
theta_thr
)
)
)[
0
]
]
=
"S"
# Southeast
out_card
[
np
.
where
(
np
.
logical_and
(
in_theta
>
(

np
.
pi
/
2.0
+
theta_thr
),
in_theta
<

theta_thr
))[
0
]
]
=
"SE"
return
out_card
tests/test_GDE_TOOLS_create_industrial_cells.py
View file @
e31cbb26
...
...
@@ 746,3 +746,97 @@ def test_swell_cells_with_buffer():
for
i
in
range
(
len
(
expected_geometries
)):
assert
expected_geometries
[
i
]
==
function_gdf
[
"geometry"
].
values
[
i
]
def
test_determine_cardinal_point
():
# Create input data for a realistic test:
theta_threshold
=
25.0
angles_deg
=
np
.
array
(
[
0.0
,
24.0
,
26.0
,
64.0
,
66.0
,
90.0
,
114.0
,
116.0
,
154.0
,
156.0
,
180.0
,
185.0
,

0.1
,

24.0
,

26.0
,

64.0
,

66.0
,

90.0
,

114.0
,

116.0
,

154.0
,

156.0
,

180.0
,

185.0
,
]
)
expected_output
=
np
.
array
(
[
"E"
,
"E"
,
"NE"
,
"NE"
,
"N"
,
"N"
,
"N"
,
"NW"
,
"NW"
,
"W"
,
"W"
,
"UU"
,
"E"
,
"E"
,
"SE"
,
"SE"
,
"S"
,
"S"
,
"S"
,
"SW"
,
"SW"
,
"W"
,
"W"
,
"UU"
,
]
)
# Call function to test:
function_cardinal_pts
=
gdet_cr_ind
.
determine_cardinal_point
(
angles_deg
,
theta_threshold
,
inputangle
=
"degrees"
)
# Go one by one the elements of the output array:
for
i
in
range
(
len
(
expected_output
)):
assert
function_cardinal_pts
[
i
]
==
expected_output
[
i
]
# Same test as above, but giving the angles in radians instead of degrees:
angles_rad
=
np
.
deg2rad
(
angles_deg
)
theta_threshold_rad
=
np
.
deg2rad
(
theta_threshold
)
# Call function to test:
function_cardinal_pts
=
gdet_cr_ind
.
determine_cardinal_point
(
angles_rad
,
theta_threshold_rad
,
inputangle
=
"radians"
)
# Go one by one the elements of the output array:
for
i
in
range
(
len
(
expected_output
)):
assert
function_cardinal_pts
[
i
]
==
expected_output
[
i
]
# Test that all results are unknown ("UU") if the threshold angle is negative:
theta_threshold
=

25.0
# Call function to test:
function_cardinal_pts
=
gdet_cr_ind
.
determine_cardinal_point
(
angles_deg
,
theta_threshold
,
inputangle
=
"degrees"
)
# Go one by one the elements of the output array:
for
i
in
range
(
len
(
expected_output
)):
assert
function_cardinal_pts
[
i
]
==
"UU"
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment