acoular 24.3__py3-none-any.whl → 24.7__py3-none-any.whl

acoular/microphones.py

@@ -1,9 +1,7 @@
-# -*- coding: utf-8 -*-
-#pylint: disable-msg=E0611, E1103, C0103, R0901, R0902, R0903, R0904, W0232
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
-"""Implements support for array microphone arrangements
+# ------------------------------------------------------------------------------
+"""Implements support for array microphone arrangements.
 
 .. autosummary::
     :toctree: generated/
@@ -13,108 +11,97 @@
 """
 
 # imports from other packages
-from numpy import array, average 
-from scipy.spatial.distance import cdist
-from traits.api import HasPrivateTraits, Property, File, \
-CArray, cached_property, on_trait_change, ListInt , Bool
-from os import path, strerror
 import errno
+from os import path, strerror
+
+from numpy import array, average
+from scipy.spatial.distance import cdist
+from traits.api import Bool, CArray, File, HasPrivateTraits, ListInt, Property, cached_property, on_trait_change
 
 from .internal import digest
 
 
-class MicGeom( HasPrivateTraits ):
-    """
-    Provides the geometric arrangement of microphones in the array.
-    
-    The geometric arrangement of microphones is read in from an 
-    xml-source with element tag names `pos` and attributes Name, `x`, `y` and `z`. 
+class MicGeom(HasPrivateTraits):
+    """Provides the geometric arrangement of microphones in the array.
+
+    The geometric arrangement of microphones is read in from an
+    xml-source with element tag names `pos` and attributes Name, `x`, `y` and `z`.
     Can also be used with programmatically generated arrangements.
     """
 
     #: Name of the .xml-file from wich to read the data.
-    from_file = File(filter=['*.xml'],
-        desc="name of the xml file to import")
+    from_file = File(filter=['*.xml'], desc='name of the xml file to import')
 
     #: Validate mic geom from file
-    validate_file = Bool(True,
-            desc="Validate mic geom from file")
+    validate_file = Bool(True, desc='Validate mic geom from file')
 
     #: Basename of the .xml-file, without the extension; is set automatically / readonly.
-    basename = Property( depends_on = 'from_file',
-        desc="basename of xml file")
+    basename = Property(depends_on='from_file', desc='basename of xml file')
 
     #: List that gives the indices of channels that should not be considered.
     #: Defaults to a blank list.
-    invalid_channels = ListInt(
-        desc="list of invalid channels")
+    invalid_channels = ListInt(desc='list of invalid channels')
 
     #: Number of microphones in the array; readonly.
-    num_mics = Property( depends_on = ['mpos', ],
-        desc="number of microphones in the geometry")
+    num_mics = Property(depends_on=['mpos'], desc='number of microphones in the geometry')
 
     #: Center of the array (arithmetic mean of all used array positions); readonly.
-    center = Property( depends_on = ['mpos', ],
-        desc="array center")
+    center = Property(depends_on=['mpos'], desc='array center')
 
     #: Aperture of the array (greatest extent between two microphones); readonly.
-    aperture = Property( depends_on = ['mpos', ],
-        desc="array aperture")
+    aperture = Property(depends_on=['mpos'], desc='array aperture')
 
     #: Positions as (3, :attr:`num_mics`) array of floats, may include also invalid
     #: microphones (if any). Set either automatically on change of the
     #: :attr:`from_file` argument or explicitely by assigning an array of floats.
-    mpos_tot = CArray(dtype=float,
-        desc="x, y, z position of all microphones")
+    mpos_tot = CArray(dtype=float, desc='x, y, z position of all microphones')
 
     #: Positions as (3, :attr:`num_mics`) array of floats, without invalid
     #: microphones; readonly.
-    mpos = Property( depends_on = ['mpos_tot', 'invalid_channels'],
-        desc="x, y, z position of microphones")
+    mpos = Property(depends_on=['mpos_tot', 'invalid_channels'], desc='x, y, z position of microphones')
 
     # internal identifier
-    digest = Property( depends_on = ['mpos', ])
+    digest = Property(depends_on=['mpos'])
 
     @cached_property
-    def _get_digest( self ):
+    def _get_digest(self):
         return digest(self)
 
     @cached_property
-    def _get_basename( self ):
+    def _get_basename(self):
         return path.splitext(path.basename(self.from_file))[0]
 
     @cached_property
-    def _get_mpos( self ):
+    def _get_mpos(self):
         if self.validate_file:
-            if len(self.invalid_channels)==0:
+            if len(self.invalid_channels) == 0:
                 return self.mpos_tot
-            allr=[i for i in range(self.mpos_tot.shape[-1]) if i not in self.invalid_channels]
+            allr = [i for i in range(self.mpos_tot.shape[-1]) if i not in self.invalid_channels]
             return self.mpos_tot[:, array(allr)]
-        else:             
-            raise FileNotFoundError(
-                    errno.ENOENT, strerror(errno.ENOENT), self.from_file)
+        raise FileNotFoundError(errno.ENOENT, strerror(errno.ENOENT), self.from_file)
 
     @cached_property
-    def _get_num_mics( self ):
+    def _get_num_mics(self):
         return self.mpos.shape[-1]
 
     @cached_property
-    def _get_center( self ):
+    def _get_center(self):
         if self.mpos.any():
-            center = average(self.mpos,axis=1)
+            center = average(self.mpos, axis=1)
             # set very small values to zero
-            center[abs(center) < 1e-16] = 0.
+            center[abs(center) < 1e-16] = 0.0
             return center
+        return None
 
     @cached_property
-    def _get_aperture( self ):
+    def _get_aperture(self):
         if self.mpos.any():
-            return cdist(self.mpos.T,self.mpos.T).max()
+            return cdist(self.mpos.T, self.mpos.T).max()
+        return None
 
     @on_trait_change('basename')
-    def import_mpos( self ):
-        """
-        Import the microphone positions from .xml file.
+    def import_mpos(self):
+        """Import the microphone positions from .xml file.
         Called when :attr:`basename` changes.
         """
         if not path.isfile(self.from_file):
@@ -124,12 +111,29 @@ class MicGeom( HasPrivateTraits ):
             self.validate_file = False
 
         import xml.dom.minidom
+
         doc = xml.dom.minidom.parse(self.from_file)
         names = []
         xyz = []
         for el in doc.getElementsByTagName('pos'):
             names.append(el.getAttribute('Name'))
-            xyz.append(list(map(lambda a : float(el.getAttribute(a)), 'xyz')))
+            xyz.append([float(el.getAttribute(a)) for a in 'xyz'])
         self.mpos_tot = array(xyz, 'd').swapaxes(0, 1)
         self.validate_file = True
 
+    def export_mpos(self, filename):
+        """Export the microphone positions to .xml file.
+
+        Parameters
+        ----------
+        filename : str
+            Name of the file to which the microphone positions are written.
+        """
+        basename = path.splitext(path.basename(filename))[0]
+        with open(filename, 'w') as f:
+            f.write(f'<?xml version="1.1" encoding="utf-8"?><MicArray name="{basename}">\n')
+            for i in range(self.mpos.shape[-1]):
+                f.write(
+                    f'  <pos Name="Point {i+1}" x="{self.mpos[0, i]}" y="{self.mpos[1, i]}" z="{self.mpos[2, i]}"/>\n',
+                )
+            f.write('</MicArray>')

acoular/sdinput.py

@@ -1,118 +1,122 @@
-# -*- coding: utf-8 -*-
-#pylint: disable-msg=E0611, E1101, C0103, R0901, R0902, R0903, R0904, W0232
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
-""" Input from soundcard hardware using the SoundDevice library
+# ------------------------------------------------------------------------------
+"""Input from soundcard hardware using the SoundDevice library.
 
 .. autosummary::
     :toctree: generated/
 
     SoundDeviceSamplesGenerator
 """
-import sounddevice as sd
-from traits.api import Int, Long, Bool, Property, Any, observe, cached_property
-from .tprocess import SamplesGenerator
+
+from traits.api import Any, Bool, Int, Long, Property, cached_property, observe
+
+from .configuration import config
 from .internal import digest
+from .tprocess import SamplesGenerator
 
-class SoundDeviceSamplesGenerator(SamplesGenerator):
+if config.have_sounddevice:
+    import sounddevice as sd
 
-    """
-    Controller for sound card hardware using sounddevice library
+
+class SoundDeviceSamplesGenerator(SamplesGenerator):
+    """Controller for sound card hardware using sounddevice library.
 
     Uses the device with index :attr:`device` to read samples
     from input stream, generates output stream via the generator
     :meth:`result`.
     """
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if config.have_sounddevice is False:
+            msg = 'SoundDevice library not found but is required for using the SoundDeviceSamplesGenerator class.'
+            raise ImportError(msg)
+
     #: input device index, refers to sounddevice list
-    device = Int(0, desc="input device index")
+    device = Int(0, desc='input device index')
 
     #: Number of input channels, maximum depends on device
-    numchannels = Long(1,
-       desc="number of analog input channels that collects data")
+    numchannels = Long(1, desc='number of analog input channels that collects data')
 
     #: Number of samples to collect; defaults to -1.
     # If is set to -1 device collects till user breaks streaming by setting Trait: collectsamples = False
-    numsamples = Long(-1,
-        desc="number of samples to collect")    
+    numsamples = Long(-1, desc='number of samples to collect')
 
     #: Indicates if samples are collected, helper trait to break result loop
-    collectsamples = Bool(True,
-        desc="Indicates if samples are collected")
+    collectsamples = Bool(True, desc='Indicates if samples are collected')
 
     #: Sampling frequency of the signal, changes with sinusdevices
-    sample_freq = Property(
-        desc="sampling frequency")
+    sample_freq = Property(desc='sampling frequency')
 
     #: Indicates that the sounddevice buffer has overflown
-    overflow = Bool(False,
-        desc="Indicates if sounddevice buffer overflow")
+    overflow = Bool(False, desc='Indicates if sounddevice buffer overflow')
 
     #: Indicates that the stream is collecting samples
-    running = Bool(False,
-        desc="Indicates that the stream is collecting samples")
+    running = Bool(False, desc='Indicates that the stream is collecting samples')
 
     #: The sounddevice InputStream object for inspection
     stream = Any
 
     # internal identifier
-    digest = Property( depends_on=['device', 'numchannels', 'numsamples'])
-    
+    digest = Property(depends_on=['device', 'numchannels', 'numsamples'])
+
     @cached_property
-    def _get_digest( self ):
+    def _get_digest(self):
         return digest(self)
 
     # checks that numchannels are not more than device can provide
     @observe('device,numchannels')
-    def _get_numchannels( self, change ):
-        self.numchannels = min(self.numchannels,sd.query_devices(self.device)['max_input_channels'])
+    def _get_numchannels(self, event):  # noqa ARG002
+        self.numchannels = min(self.numchannels, sd.query_devices(self.device)['max_input_channels'])
 
-    def _get_sample_freq( self ):
+    def _get_sample_freq(self):
         return sd.query_devices(self.device)['default_samplerate']
 
-    def device_properties( self ):
-        """
-        Returns
+    def device_properties(self):
+        """Returns
         -------
         Dictionary of device properties according to sounddevice
         """
         return sd.query_devices(self.device)
 
     def result(self, num):
-        """
-        Python generator that yields the output block-wise. Use at least a 
-        block-size of one ring cache block. 
-        
+        """Python generator that yields the output block-wise. Use at least a
+        block-size of one ring cache block.
+
         Parameters
         ----------
         num : integer
             This parameter defines the size of the blocks to be yielded
             (i.e. the number of samples per block).
-        
+
         Returns
         -------
-        Samples in blocks of shape (num, :attr:`numchannels`). 
+        Samples in blocks of shape (num, :attr:`numchannels`).
             The last block may be shorter than num.
+
         """
-        print(self.device_properties(),self.sample_freq)
+        print(self.device_properties(), self.sample_freq)
         self.stream = stream_obj = sd.InputStream(
-                device=self.device, channels=self.numchannels, 
-                clip_off=True, samplerate=self.sample_freq)
+            device=self.device,
+            channels=self.numchannels,
+            clip_off=True,
+            samplerate=self.sample_freq,
+        )
 
         with stream_obj as stream:
             self.running = True
-            if self.numsamples == -1: 
-                while self.collectsamples: # yield data as long as collectsamples is True
-                    data,self.overflow = stream.read(num)
-                    yield data[:num]   
-                                           
-            elif self.numsamples > 0: # amount of samples to collect is specified by user            
-                samples_count = 0 # numsamples counter 
-                while samples_count < self.numsamples: 
-                    anz = min(num, self.numsamples-samples_count)
+            if self.numsamples == -1:
+                while self.collectsamples:  # yield data as long as collectsamples is True
+                    data, self.overflow = stream.read(num)
+                    yield data[:num]
+
+            elif self.numsamples > 0:  # amount of samples to collect is specified by user
+                samples_count = 0  # numsamples counter
+                while samples_count < self.numsamples:
+                    anz = min(num, self.numsamples - samples_count)
                     data, self.overflow = stream.read(num)
-                    yield data[:anz]   
+                    yield data[:anz]
                     samples_count += anz
         self.running = False
-        return  
+        return