acoular 25.7__py3-none-any.whl → 26.1__py3-none-any.whl

acoular/tools/helpers.py

@@ -17,17 +17,7 @@
 from pathlib import Path
 from warnings import warn
 
-from numpy import (
-    array,
-    concatenate,
-    isscalar,
-    newaxis,
-    searchsorted,
-    sum,  # noqa A004
-    where,
-    zeros_like,
-)
-from numpy.ma import masked_where
+import numpy as np
 
 from acoular.tools.utils import mole_fraction_of_water_vapor
 
@@ -79,20 +69,20 @@ def synthetic(data, freqs, f, num=3):
         and used :attr:`FFT block size<acoular.spectra.PowerSpectra.block_size>`.
 
     """
-    if isscalar(f):
+    if np.isscalar(f):
         f = (f,)
     if num == 0:
         # single frequency lines
         res = []
         for i in f:
-            ind = searchsorted(freqs, i)
+            ind = np.searchsorted(freqs, i)
             if ind >= len(freqs):
                 warn(
                     f'Queried frequency ({i:g} Hz) not in resolved frequency range. Returning zeros.',
                     Warning,
                     stacklevel=2,
                 )
-                h = zeros_like(data[0])
+                h = np.zeros_like(data[0])
             else:
                 if freqs[ind] != i:
                     warn(
@@ -110,8 +100,8 @@ def synthetic(data, freqs, f, num=3):
         for i in f:
             f1 = i * 2.0 ** (-0.5 / num)
             f2 = i * 2.0 ** (+0.5 / num)
-            ind1 = searchsorted(freqs, f1)
-            ind2 = searchsorted(freqs, f2)
+            ind1 = np.searchsorted(freqs, f1)
+            ind2 = np.searchsorted(freqs, f2)
             if ind1 == ind2:
                 warn(
                     f'Queried frequency band ({f1:g} to {f2:g} Hz) does not '
@@ -120,11 +110,11 @@ def synthetic(data, freqs, f, num=3):
                     Warning,
                     stacklevel=2,
                 )
-                h = zeros_like(data[0])
+                h = np.zeros_like(data[0])
             else:
-                h = sum(data[ind1:ind2], 0)
+                h = np.sum(data[ind1:ind2], 0)
             res += [h]
-    return array(res)
+    return np.array(res)
 
 
 def return_result(source, nmax=-1, num=128):
@@ -154,8 +144,8 @@ def return_result(source, nmax=-1, num=128):
 
     if nmax > 0:
         nblocks = (nmax - 1) // num + 1
-        return concatenate([res for _, res in zip(range(nblocks), resulter)])[:nmax]
-    return concatenate(list(resulter))
+        return np.concatenate([res for _, res in zip(range(nblocks), resulter, strict=True)])[:nmax]
+    return np.concatenate(list(resulter))
 
 
 def barspectrum(data, fftfreqs, num=3, bar=True, xoffset=0.0):
@@ -203,9 +193,9 @@ def barspectrum(data, fftfreqs, num=3, bar=True, xoffset=0.0):
         return (0, 0, 0)
 
     # preferred center freqs after din en iso 266 for third-octave bands
-    fcbase = array([31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250])
+    fcbase = np.array([31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250])
     # DIN band center frequencies from 31.5 Hz to 25 kHz
-    fc = concatenate((fcbase, fcbase * 10.0, fcbase[:] * 100.0))[:: (3 // num)]
+    fc = np.concatenate((fcbase, fcbase * 10.0, fcbase[:] * 100.0))[:: (3 // num)]
 
     # exponent for band width calculation
     ep = 1.0 / (2.0 * num)
@@ -215,16 +205,16 @@ def barspectrum(data, fftfreqs, num=3, bar=True, xoffset=0.0):
     f_low = fftfreqs[1] * 2**ep
     f_high = fftfreqs[-1] * 2**-ep
     # get possible index range
-    i_low = 0 if fc[0] >= f_low else where(fc < f_low)[0][-1]
+    i_low = 0 if fc[0] >= f_low else np.where(fc < f_low)[0][-1]
 
-    i_high = fc.shape[0] if fc[-1] <= f_high else where(fc > f_high)[0][0]
+    i_high = fc.shape[0] if fc[-1] <= f_high else np.where(fc > f_high)[0][0]
 
     # synthesize sound pressure values
-    p = array([synthetic(data, fftfreqs, list(fc[i_low:i_high]), num)])
+    p = np.array([synthetic(data, fftfreqs, list(fc[i_low:i_high]), num)])
 
     if bar:
         # upper and lower band borders
-        flu = concatenate(
+        flu = np.concatenate(
             (
                 fc[i_low : i_low + 1] * 2**-ep,
                 (fc[i_low : i_high - 1] * 2**ep + fc[i_low + 1 : i_high] * 2**-ep) / 2.0,
@@ -232,9 +222,9 @@ def barspectrum(data, fftfreqs, num=3, bar=True, xoffset=0.0):
             ),
         )
         # band borders as coordinates for bar plotting
-        flulist = 2 ** (2 * xoffset * ep) * (array([1, 1])[:, newaxis] * flu[newaxis, :]).T.reshape(-1)[1:-1]
+        flulist = 2 ** (2 * xoffset * ep) * (np.array([1, 1])[:, np.newaxis] * flu[np.newaxis, :]).T.reshape(-1)[1:-1]
         # sound pressures as list for bar plotting
-        plist = (array([1, 1])[:, newaxis] * p[newaxis, :]).T.reshape(-1)
+        plist = (np.array([1, 1])[:, np.newaxis] * p[np.newaxis, :]).T.reshape(-1)
     else:
         flulist = fc[i_low:i_high]
         plist = p[0, :]
@@ -280,17 +270,19 @@ def bardata(data, fc, num=3, bar=True, xoffset=0.0, masked=-360):
 
     if bar:
         # upper and lower band borders
-        flu = concatenate((fc[:1] * 2**-ep, (fc[:-1] * 2**ep + fc[1:] * 2**-ep) / 2.0, fc[-1:] * 2**ep))
+        flu = np.concatenate((fc[:1] * 2**-ep, (fc[:-1] * 2**ep + fc[1:] * 2**-ep) / 2.0, fc[-1:] * 2**ep))
         # band borders as coordinates for bar plotting
-        flulist = 2 ** (xoffset * 1.0 / num) * (array([1, 1])[:, newaxis] * flu[newaxis, :]).T.reshape(-1)[1:-1]
+        flulist = (
+            2 ** (xoffset * 1.0 / num) * (np.array([1, 1])[:, np.newaxis] * flu[np.newaxis, :]).T.reshape(-1)[1:-1]
+        )
         # sound pressures as list for bar plotting
-        plist = (array([1, 1])[:, newaxis] * data[newaxis, :]).T.reshape(-1)
+        plist = (np.array([1, 1])[:, np.newaxis] * data[np.newaxis, :]).T.reshape(-1)
     else:
         flulist = fc
         plist = data
     # print(flulist.shape, plist.shape)
     if masked > -360:
-        plist = masked_where(plist <= masked, plist)
+        plist = np.ma.masked_where(plist <= masked, plist)
     return (flulist, plist)
 
 

acoular/tools/metrics.py

@@ -11,12 +11,7 @@
 
 from copy import copy
 
-from numpy import (
-    empty,
-    inf,
-    minimum,
-    ones,
-)
+import numpy as np
 from scipy.spatial.distance import cdist
 from traits.api import Bool, CArray, HasStrictTraits, Instance, Property
 
@@ -82,13 +77,13 @@ class MetricEvaluator(HasStrictTraits):
 
     def _get_sector_radii(self):
         ns = self.target_data.shape[1]
-        radii = ones(ns) * self.sector.r
+        radii = np.ones(ns) * self.sector.r
         if self.adaptive_sector_size:
             locs = self.target_grid.pos.T
             intersrcdist = cdist(locs, locs)
-            intersrcdist[intersrcdist == 0] = inf
+            intersrcdist[intersrcdist == 0] = np.inf
             intersrcdist = intersrcdist.min(0) / 2
-            radii = minimum(radii, intersrcdist)
+            radii = np.minimum(radii, intersrcdist)
         return radii
 
     def _get_sectors(self):
@@ -115,7 +110,7 @@ class MetricEvaluator(HasStrictTraits):
 
         """
         sectors = self.sectors
-        results = empty(shape=self.target_data.shape)
+        results = np.empty(shape=self.target_data.shape)
         for f in range(self.target_data.shape[0]):
             data = self.data[f]
             for i in range(self.target_data.shape[1]):

acoular/tools/utils.py

@@ -6,6 +6,7 @@
     get_file_basename
     find_basename
     mole_fraction_of_water_vapor
+    Polygon
 """
 
 from pathlib import Path
@@ -13,6 +14,173 @@ from pathlib import Path
 import numpy as np
 
 
+def _det(xvert, yvert):
+    xvert = np.asarray(xvert, dtype=float)
+    yvert = np.asarray(yvert, dtype=float)
+    x_prev = np.concatenate(([xvert[-1]], xvert[:-1]))
+    y_prev = np.concatenate(([yvert[-1]], yvert[:-1]))
+    return np.sum(yvert * x_prev - xvert * y_prev, axis=0)
+
+
+class Polygon:
+    """
+    Create an object representing a general polygon in a 2D plane.
+
+    This class allows defining a polygon by specifying the coordinates of its vertices and provides
+    methods for checking whether a set of points lies inside the polygon, or if a point is closer to
+    a side or vertex of the polygon.
+
+    Parameters
+    ----------
+    x : array_like
+        Array of x-coordinates of the vertices that define the polygon. These coordinates should
+        form a closed shape (i.e., the last point should be the same as the first point).
+
+    y : array_like
+        Array of y-coordinates of the vertices that define the polygon. These coordinates should
+        correspond to the x-coordinates, forming a closed shape.
+
+    Attributes
+    ----------
+    x : :class:`numpy.ndarray`
+        Array of x-coordinates of the polygon vertices.
+
+    y : :class:`numpy.ndarray`
+        Array of y-coordinates of the polygon vertices.
+    """
+
+    def __init__(self, x, y):
+        if len(x) != len(y):
+            msg = 'x and y must be equally sized.'
+            raise IndexError(msg)
+        self.x = np.asarray(x, dtype=float)
+        self.y = np.asarray(y, dtype=float)
+        # Closes the polygon if it were open
+        x1, y1 = x[0], y[0]
+        xn, yn = x[-1], y[-1]
+        if x1 != xn or y1 != yn:
+            self.x = np.concatenate((self.x, [x1]))
+            self.y = np.concatenate((self.y, [y1]))
+        # Anti-clockwise coordinates
+        if _det(self.x, self.y) < 0:
+            self.x = self.x[::-1]
+            self.y = self.y[::-1]
+
+    def is_inside(self, xpoint, ypoint, smalld=1e-12):
+        """
+        Check if a point or set of points are inside the polygon.
+
+        Parameters
+        ----------
+        xpoint : :class:`float` or array_like
+            Array of x-coordinates of the points to be tested.
+
+        ypoint : :class:`float` or array_like
+            Array of y-coordinates of the points to be tested.
+
+        smalld : :class:`float`, optional
+            Tolerance used for floating point comparisons when checking if a point is exactly on a
+            polygon's edge. The default value is ``1e-12``.
+
+        Returns
+        -------
+        :class:`float` or array_like
+            The distance from the point to the nearest point on the polygon. The values returned
+            have the following meanings:
+            - ``mindst < 0``: Point is outside the polygon.
+            - ``mindst = 0``: Point is on an edge of the polygon.
+            - ``mindst > 0``: Point is inside the polygon.
+
+        Notes
+        -----
+        The method uses an improved algorithm based on Nordbeck and Rydstedt for determining
+        whether a point is inside a polygon :cite:`SLOAN198545`.
+        """
+        xpoint = np.asarray(xpoint, dtype=float)
+        ypoint = np.asarray(ypoint, dtype=float)
+        # Scalar to array
+        if xpoint.shape == ():
+            xpoint = np.array([xpoint], dtype=float)
+            ypoint = np.array([ypoint], dtype=float)
+            scalar = True
+        else:
+            scalar = False
+        # Check consistency
+        if xpoint.shape != ypoint.shape:
+            msg = 'x and y have different shapes'
+            raise IndexError(msg)
+        # If snear = True: Dist to nearest side < nearest vertex
+        # If snear = False: Dist to nearest vertex < nearest side
+        snear = np.ma.masked_all(xpoint.shape, dtype=bool)
+        # Initialize arrays
+        mindst = np.ones_like(xpoint, dtype=float) * np.inf
+        j = np.ma.masked_all(xpoint.shape, dtype=int)
+        x = self.x
+        y = self.y
+        n = len(x) - 1  # Number of sides/vertices defining the polygon
+        # Loop over each side defining polygon
+        for i in range(n):
+            d = np.ones_like(xpoint, dtype=float) * np.inf
+            # Start of side has coords (x1, y1)
+            # End of side has coords (x2, y2)
+            # Point has coords (xpoint, ypoint)
+            x1 = x[i]
+            y1 = y[i]
+            x21 = x[i + 1] - x1
+            y21 = y[i + 1] - y1
+            x1p = x1 - xpoint
+            y1p = y1 - ypoint
+            # Points on infinite line defined by
+            #     x = x1 + t * (x1 - x2)
+            #     y = y1 + t * (y1 - y2)
+            # where
+            #     t = 0    at (x1, y1)
+            #     t = 1    at (x2, y2)
+            # Find where normal passing through (xpoint, ypoint) intersects
+            # infinite line
+            t = -(x1p * x21 + y1p * y21) / (x21**2 + y21**2)
+            tlt0 = t < 0
+            tle1 = (t >= 0) & (t <= 1)
+            # Normal intersects side
+            d[tle1] = (x1p[tle1] + t[tle1] * x21) ** 2 + (y1p[tle1] + t[tle1] * y21) ** 2
+            # Normal does not intersects side
+            # Point is closest to vertex (x1, y1)
+            # Compute square of distance to this vertex
+            d[tlt0] = x1p[tlt0] ** 2 + y1p[tlt0] ** 2
+            # Store distances
+            mask = d < mindst
+            mindst[mask] = d[mask]
+            j[mask] = i
+            # Point is closer to (x1, y1) than any other vertex or side
+            snear[mask & tlt0] = False
+            # Point is closer to this side than to any other side or vertex
+            snear[mask & tle1] = True
+        if np.ma.count(snear) != snear.size:
+            msg = 'Error computing distances'
+            raise IndexError(msg)
+        mindst **= 0.5
+        # Point is closer to its nearest vertex than its nearest side, check if
+        # nearest vertex is concave.
+        # If the nearest vertex is concave then point is inside the polygon,
+        # else the point is outside the polygon.
+        jo = j.copy()
+        jo[j == 0] -= 1
+        area = _det([x[j + 1], x[j], x[jo - 1]], [y[j + 1], y[j], y[jo - 1]])
+        mindst[~snear] = np.copysign(mindst, area)[~snear]
+        # Point is closer to its nearest side than to its nearest vertex, check
+        # if point is to left or right of this side.
+        # If point is to left of side it is inside polygon, else point is
+        # outside polygon.
+        area = _det([x[j], x[j + 1], xpoint], [y[j], y[j + 1], ypoint])
+        mindst[snear] = np.copysign(mindst, area)[snear]
+        # Point is on side of polygon
+        mindst[np.fabs(mindst) < smalld] = 0
+        # If input values were scalar then the output should be too
+        if scalar:
+            mindst = float(mindst[0])
+        return mindst
+
+
 def get_file_basename(file, alternative_basename='void'):
     """Return the basename of the file.