File size: 9,012 Bytes
fe41391 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 |
from __future__ import annotations
from itertools import chain
from typing import TYPE_CHECKING
import numpy as np
from contourpy.typecheck import check_code_array, check_offset_array, check_point_array
from contourpy.types import CLOSEPOLY, LINETO, MOVETO, code_dtype, offset_dtype, point_dtype
if TYPE_CHECKING:
import contourpy._contourpy as cpy
def codes_from_offsets(offsets: cpy.OffsetArray) -> cpy.CodeArray:
"""Determine codes from offsets, assuming they all correspond to closed polygons.
"""
check_offset_array(offsets)
n = offsets[-1]
codes = np.full(n, LINETO, dtype=code_dtype)
codes[offsets[:-1]] = MOVETO
codes[offsets[1:] - 1] = CLOSEPOLY
return codes
def codes_from_offsets_and_points(
offsets: cpy.OffsetArray,
points: cpy.PointArray,
) -> cpy.CodeArray:
"""Determine codes from offsets and points, using the equality of the start and end points of
each line to determine if lines are closed or not.
"""
check_offset_array(offsets)
check_point_array(points)
codes = np.full(len(points), LINETO, dtype=code_dtype)
codes[offsets[:-1]] = MOVETO
end_offsets = offsets[1:] - 1
closed = np.all(points[offsets[:-1]] == points[end_offsets], axis=1)
codes[end_offsets[closed]] = CLOSEPOLY
return codes
def codes_from_points(points: cpy.PointArray) -> cpy.CodeArray:
"""Determine codes for a single line, using the equality of the start and end points to
determine if the line is closed or not.
"""
check_point_array(points)
n = len(points)
codes = np.full(n, LINETO, dtype=code_dtype)
codes[0] = MOVETO
if np.all(points[0] == points[-1]):
codes[-1] = CLOSEPOLY
return codes
def concat_codes(list_of_codes: list[cpy.CodeArray]) -> cpy.CodeArray:
"""Concatenate a list of codes arrays into a single code array.
"""
if not list_of_codes:
raise ValueError("Empty list passed to concat_codes")
return np.concatenate(list_of_codes, dtype=code_dtype)
def concat_codes_or_none(list_of_codes_or_none: list[cpy.CodeArray | None]) -> cpy.CodeArray | None:
"""Concatenate a list of codes arrays or None into a single code array or None.
"""
list_of_codes = [codes for codes in list_of_codes_or_none if codes is not None]
if list_of_codes:
return concat_codes(list_of_codes)
else:
return None
def concat_offsets(list_of_offsets: list[cpy.OffsetArray]) -> cpy.OffsetArray:
"""Concatenate a list of offsets arrays into a single offset array.
"""
if not list_of_offsets:
raise ValueError("Empty list passed to concat_offsets")
n = len(list_of_offsets)
cumulative = np.cumsum([offsets[-1] for offsets in list_of_offsets], dtype=offset_dtype)
ret: cpy.OffsetArray = np.concatenate(
(list_of_offsets[0], *(list_of_offsets[i+1][1:] + cumulative[i] for i in range(n-1))),
dtype=offset_dtype,
)
return ret
def concat_offsets_or_none(
list_of_offsets_or_none: list[cpy.OffsetArray | None],
) -> cpy.OffsetArray | None:
"""Concatenate a list of offsets arrays or None into a single offset array or None.
"""
list_of_offsets = [offsets for offsets in list_of_offsets_or_none if offsets is not None]
if list_of_offsets:
return concat_offsets(list_of_offsets)
else:
return None
def concat_points(list_of_points: list[cpy.PointArray]) -> cpy.PointArray:
"""Concatenate a list of point arrays into a single point array.
"""
if not list_of_points:
raise ValueError("Empty list passed to concat_points")
return np.concatenate(list_of_points, dtype=point_dtype)
def concat_points_or_none(
list_of_points_or_none: list[cpy.PointArray | None],
) -> cpy.PointArray | None:
"""Concatenate a list of point arrays or None into a single point array or None.
"""
list_of_points = [points for points in list_of_points_or_none if points is not None]
if list_of_points:
return concat_points(list_of_points)
else:
return None
def concat_points_or_none_with_nan(
list_of_points_or_none: list[cpy.PointArray | None],
) -> cpy.PointArray | None:
"""Concatenate a list of points or None into a single point array or None, with NaNs used to
separate each line.
"""
list_of_points = [points for points in list_of_points_or_none if points is not None]
if list_of_points:
return concat_points_with_nan(list_of_points)
else:
return None
def concat_points_with_nan(list_of_points: list[cpy.PointArray]) -> cpy.PointArray:
"""Concatenate a list of points into a single point array with NaNs used to separate each line.
"""
if not list_of_points:
raise ValueError("Empty list passed to concat_points_with_nan")
if len(list_of_points) == 1:
return list_of_points[0]
else:
nan_spacer = np.full((1, 2), np.nan, dtype=point_dtype)
list_of_points = [list_of_points[0],
*list(chain(*((nan_spacer, x) for x in list_of_points[1:])))]
return concat_points(list_of_points)
def insert_nan_at_offsets(points: cpy.PointArray, offsets: cpy.OffsetArray) -> cpy.PointArray:
"""Insert NaNs into a point array at locations specified by an offset array.
"""
check_point_array(points)
check_offset_array(offsets)
if len(offsets) <= 2:
return points
else:
nan_spacer = np.array([np.nan, np.nan], dtype=point_dtype)
# Convert offsets to int64 to avoid numpy error when mixing signed and unsigned ints.
return np.insert(points, offsets[1:-1].astype(np.int64), nan_spacer, axis=0)
def offsets_from_codes(codes: cpy.CodeArray) -> cpy.OffsetArray:
"""Determine offsets from codes using locations of MOVETO codes.
"""
check_code_array(codes)
return np.append(np.nonzero(codes == MOVETO)[0], len(codes)).astype(offset_dtype)
def offsets_from_lengths(list_of_points: list[cpy.PointArray]) -> cpy.OffsetArray:
"""Determine offsets from lengths of point arrays.
"""
if not list_of_points:
raise ValueError("Empty list passed to offsets_from_lengths")
return np.cumsum([0] + [len(line) for line in list_of_points], dtype=offset_dtype)
def outer_offsets_from_list_of_codes(list_of_codes: list[cpy.CodeArray]) -> cpy.OffsetArray:
"""Determine outer offsets from codes using locations of MOVETO codes.
"""
if not list_of_codes:
raise ValueError("Empty list passed to outer_offsets_from_list_of_codes")
return np.cumsum([0] + [np.count_nonzero(codes == MOVETO) for codes in list_of_codes],
dtype=offset_dtype)
def outer_offsets_from_list_of_offsets(list_of_offsets: list[cpy.OffsetArray]) -> cpy.OffsetArray:
"""Determine outer offsets from a list of offsets.
"""
if not list_of_offsets:
raise ValueError("Empty list passed to outer_offsets_from_list_of_offsets")
return np.cumsum([0] + [len(offsets)-1 for offsets in list_of_offsets], dtype=offset_dtype)
def remove_nan(points: cpy.PointArray) -> tuple[cpy.PointArray, cpy.OffsetArray]:
"""Remove NaN from a points array, also return the offsets corresponding to the NaN removed.
"""
check_point_array(points)
nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0]
if len(nan_offsets) == 0:
return points, np.array([0, len(points)], dtype=offset_dtype)
else:
points = np.delete(points, nan_offsets, axis=0)
nan_offsets -= np.arange(len(nan_offsets))
offsets: cpy.OffsetArray = np.empty(len(nan_offsets)+2, dtype=offset_dtype)
offsets[0] = 0
offsets[1:-1] = nan_offsets
offsets[-1] = len(points)
return points, offsets
def split_codes_by_offsets(codes: cpy.CodeArray, offsets: cpy.OffsetArray) -> list[cpy.CodeArray]:
"""Split a code array at locations specified by an offset array into a list of code arrays.
"""
check_code_array(codes)
check_offset_array(offsets)
if len(offsets) > 2:
return np.split(codes, offsets[1:-1])
else:
return [codes]
def split_points_by_offsets(
points: cpy.PointArray,
offsets: cpy.OffsetArray,
) -> list[cpy.PointArray]:
"""Split a point array at locations specified by an offset array into a list of point arrays.
"""
check_point_array(points)
check_offset_array(offsets)
if len(offsets) > 2:
return np.split(points, offsets[1:-1])
else:
return [points]
def split_points_at_nan(points: cpy.PointArray) -> list[cpy.PointArray]:
"""Split a points array at NaNs into a list of point arrays.
"""
check_point_array(points)
nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0]
if len(nan_offsets) == 0:
return [points]
else:
nan_offsets = np.concatenate(([-1], nan_offsets, [len(points)])) # type: ignore[arg-type]
return [points[s+1:e] for s, e in zip(nan_offsets[:-1], nan_offsets[1:])]
|