- In SciPy a signal is considered as an array of real or complex numbers or as a NumPy array.

- In signal processing a  system that modifies or changes the content of an input signal is called a filter.

- The function of linear filters are described using convolution operation. 


Filtering

SciPy contains signal processing functions for

- B-splines

- Filtering

- Spectral Analysis

- Detrend

San Jose State University

The SciPy library is one of the core packages that make up the SciPy stack. It provides many user-friendly and efficient numerical routines, such as routines for numerical integration, interpolation, optimization, linear algebra, and statistics. SciPy is NumPy extension of Python.

-Interacting with NumPy
-Linear Algebra with SciPy

SciPy Library

https://docs.scipy.org/doc/scipy/tutorial/index.html

SciPy Documentation

```
np.transpose(b) #Permute array dimensions a.k.a transpose

b.flatten() #Flatten the array

np.hstack((b,c)) #Stack arrays horizontally (column-wise) 

np.vstack((a,b)) #Stack arrays vertically (row-wise)

np.hsplit(c,2) #Split the array horizontally at the 2nd index

np.vpslit(d,2) #Split the array vertically at the 2nd index
```

Index Tricks

```
from numpy import poly1d

p = poly1d([3,4,5]) #Create a polynomial object
```

Polynomials

def myfunc(a): #vectorize functions

      if a < 0:

           return a*2

      else:

           return a/2

np.vectorize(myfunc)

Vectorizing Functions

```
np.real(b) #Return the real part of the array elements

np.imag(b) #Return the imaginary part of the array elements

np.real_if_close(c,tol=1000) #Return a real array if complex parts close to 0

np.cast['f'](np.pi) #Cast object to a data type
```

Type Handling

You’ll use the linalg and sparse modules. Note that scipy.linalg contains and expands on numpy.linalg. 
```
from scipy import linalg, sparse
```

Linear Algebra

```
help(scipy.linalg.diagsvd)
np.info(np.matrix)
```

Asking for help

SciPy is a great tool for reading certain kinds of files into Python or passing SciPy/NumPy variables into a program such as MATLAB. 

File IO with SciPy

Fourier transform is a mathematical tool which helps to break up  any kind of function or waveform existing in the universe into sinusoids. Discrete Fourier Transform ( DFT) is the main tool used in digital signal processing and Fast Fourier Transform(FFT) algorithms helps to  compute DFT efficiently..

- 1-D discrete Fourier transforms
- 2- and N-D discrete Fourier transforms

Fourier Transform using SciPy

scipy.ndimage is SciPy's submodule for processing n-dimensional NumPy arrays, most commonly used for image data. It provides core computer-vision primitives such as convolutions, filters, gradients, and morphological operations. Compared to OpenCV, it offers lower-level, more barebone functionality rather than application-specific computer-vision routines.

Computer Vision in Scipy (ndimage)

The `scipy.ndimage` module provides functions for multidimensional image processing in Python. It includes operations for filtering, mathematical morphology, interpolation, object measurements, and feature extraction on NumPy arrays that represent n-dimensional images.

SciPy ndimage Module

```python
# Return the angle of the complex argument
np.angle(b, deg=True)

# Create an array of evenly spaced values (number of samples below)
g = np.linspace(0, np.pi, num=5)
g[3:] += np.pi

# Unwrap
np.unwrap(g)

# Create an array of evenly spaced values (log scale)
np.logspace(0, 10, 3)

# Return values from a list of arrays depending on conditions
np.select([c < 4], [c * 2])

# Factorial
misc.factorial(a)

# Combine N things taken at k time
misc.comb(10, 3, exact=True)

# Weights for Np-point central derivative
misc.central_diff_weights(3)

# Find the n-th derivative of a function at a point
misc.derivative(myfunc, 1.0)
```

SciPy and NumPy Miscellaneous Functions

SciPy builds directly on NumPy arrays. This snippet shows how to create NumPy arrays of different dimensionality and dtype, including 1-D, 2-D, and complex-valued arrays:
```python
import numpy as np
a = np.array([1, 2, 3])
b = np.array([(1+5j, 2j, 3j), (4j, 5j, 6j)])
c = np.array([[(1.5, 2, 3), (4, 5, 6)], [(3, 2, 1), (4, 5, 6)]])
```

Learn Before

Related

Learn After

Learn After

Related