parselmouth.Spectrum

parselmouth.Spectrum#

class parselmouth.Spectrum#

Bases: Matrix

Methods

`__init__`
`as_array`
`at_xy`
`cepstral_smoothing`
`copy`
`formula`
`get_band_density`
`get_band_density_difference`
`get_band_energy`
`get_band_energy_difference`
`get_bin_number_from_frequency`
`get_bin_width`
`get_center_of_gravity`
`get_central_moment`
`get_centre_of_gravity`
`get_column_distance`
`get_frequency_from_bin_number`
`get_highest_frequency`
`get_highest_x`
`get_highest_y`
`get_imaginary_value_in_bin`
`get_kurtosis`
`get_lowest_frequency`
`get_lowest_x`
`get_lowest_y`
`get_maximum`
`get_minimum`
`get_number_of_bins`
`get_number_of_columns`
`get_number_of_rows`
`get_real_value_in_bin`
`get_row_distance`
`get_skewness`
`get_standard_deviation`
`get_sum`
`get_value_at_xy`
`get_value_in_bin`
`get_value_in_cell`
`get_x_of_column`
`get_y_of_row`
`info`
`lpc_smoothing`
`read`	Read a file into a `parselmouth.Data` object.
`save`
`save_as_binary_file`
`save_as_headerless_spreadsheet_file`
`save_as_matrix_text_file`
`save_as_short_text_file`
`save_as_text_file`
`scale_x_by`
`scale_x_to`
`set_imaginary_value_in_bin`
`set_real_value_in_bin`
`set_value`
`set_value_in_bin`
`shift_x_by`
`shift_x_to`
`to_sound`
`to_spectrogram`
`x_bins`
`x_grid`
`xs`
`y_bins`
`y_grid`
`ys`

Attributes

`bin_width`
`class_name`
`df`
`dx`
`dy`
`fmax`
`fmin`
`full_name`
`highest_frequency`
`lowest_frequency`
`n_bins`
`n_columns`
`n_rows`
`name`
`nf`
`nx`
`ny`
`values`
`x1`
`xmax`
`xmin`
`xrange`
`y1`
`ymax`
`ymin`
`yrange`

class FileFormat#

Bases: pybind11_object

__eq__(self: object, other: object) → bool#

__hash__(self: object) → int#

__index__(self: parselmouth.Data.FileFormat) → int#

__init__(self: parselmouth.Data.FileFormat, value: int) → None#
__init__(self: parselmouth.Data.FileFormat, arg0: str) → None

__int__(self: parselmouth.Data.FileFormat) → int#

__ne__(self: object, other: object) → bool#

__new__(**kwargs)#

__repr__(self: object) → str#

__str__()#: name(self: handle) -> str

BINARY = <FileFormat.BINARY: 2>#

SHORT_TEXT = <FileFormat.SHORT_TEXT: 1>#

TEXT = <FileFormat.TEXT: 0>#

property name#

property value#

__copy__(self: parselmouth.Data) → parselmouth.Data#

__deepcopy__(self: parselmouth.Data, memo: dict) → parselmouth.Data#

__eq__(self: parselmouth.Data, other: parselmouth.Data) → bool#

__getitem__(self: parselmouth.Spectrum, index: int) → complex#

__init__(self: parselmouth.Spectrum, values: numpy.ndarray[numpy.float64], maximum_frequency: Positive[float]) → None#
__init__(self: parselmouth.Spectrum, values: numpy.ndarray[numpy.complex128], maximum_frequency: Positive[float]) → None

__len__(self: parselmouth.Sampled) → int#

__ne__(self: parselmouth.Data, other: parselmouth.Data) → bool#

__new__(**kwargs)#

__setitem__(self: parselmouth.Spectrum, index: int, value: complex) → None#

__str__(self: parselmouth.Thing) → str#

as_array(self: parselmouth.Matrix) → numpy.ndarray[numpy.float64]#

at_xy(self: parselmouth.Matrix, x: float, y: float) → float#

cepstral_smoothing(self: parselmouth.Spectrum, bandwidth: Positive[float] = 500.0) → parselmouth.Spectrum#

copy(self: parselmouth.Data) → parselmouth.Data#

formula(self: parselmouth.Matrix, formula: str, from_x: float | None = None, to_x: float | None = None, from_y: float | None = None, to_y: float | None = None) → None#
formula(self: parselmouth.Matrix, formula: str, x_range: Tuple[float | None, float | None] = (None, None), y_range: Tuple[float | None, float | None] = (None, None)) → None

get_band_density(self: parselmouth.Spectrum, band_floor: float | None = None, band_ceiling: float | None = None) → float#
get_band_density(self: parselmouth.Spectrum, band: Tuple[float | None, float | None] = (None, None)) → float

get_band_density_difference(self: parselmouth.Spectrum, low_band_floor: float | None = None, low_band_ceiling: float | None = None, high_band_floor: float | None = None, high_band_ceiling: float | None = None) → float#
get_band_density_difference(self: parselmouth.Spectrum, low_band: Tuple[float | None, float | None] = (None, None), high_band: Tuple[float | None, float | None] = (None, None)) → float

get_band_energy(self: parselmouth.Spectrum, band_floor: float | None = None, band_ceiling: float | None = None) → float#
get_band_energy(self: parselmouth.Spectrum, band: Tuple[float | None, float | None] = (None, None)) → float

get_band_energy_difference(self: parselmouth.Spectrum, low_band_floor: float | None = None, low_band_ceiling: float | None = None, high_band_floor: float | None = None, high_band_ceiling: float | None = None) → float#
get_band_energy_difference(self: parselmouth.Spectrum, low_band: Tuple[float | None, float | None] = (None, None), high_band: Tuple[float | None, float | None] = (None, None)) → float

get_bin_number_from_frequency(self: parselmouth.Spectrum, frequency: float) → float#

get_bin_width(self: parselmouth.Spectrum) → float#

get_center_of_gravity(self: parselmouth.Spectrum, power: Positive[float] = 2.0) → float#

get_central_moment(self: parselmouth.Spectrum, moment: Positive[float], power: Positive[float] = 2.0) → float#

get_centre_of_gravity(self: parselmouth.Spectrum, power: Positive[float] = 2.0) → float#

get_column_distance(self: parselmouth.Matrix) → float#

get_frequency_from_bin_number(self: parselmouth.Spectrum, band_number: Positive[int]) → float#

get_highest_frequency(self: parselmouth.Spectrum) → float#

get_highest_x(self: parselmouth.Matrix) → float#

get_highest_y(self: parselmouth.Matrix) → float#

get_imaginary_value_in_bin(self: parselmouth.Spectrum, bin_number: Positive[int]) → float#

get_kurtosis(self: parselmouth.Spectrum, power: Positive[float] = 2.0) → float#

get_lowest_frequency(self: parselmouth.Spectrum) → float#

get_lowest_x(self: parselmouth.Matrix) → float#

get_lowest_y(self: parselmouth.Matrix) → float#

get_maximum(self: parselmouth.Matrix) → float#

get_minimum(self: parselmouth.Matrix) → float#

get_number_of_bins(self: parselmouth.Spectrum) → int#

get_number_of_columns(self: parselmouth.Matrix) → int#

get_number_of_rows(self: parselmouth.Matrix) → int#

get_real_value_in_bin(self: parselmouth.Spectrum, bin_number: Positive[int]) → float#

get_row_distance(self: parselmouth.Matrix) → float#

get_skewness(self: parselmouth.Spectrum, power: Positive[float] = 2.0) → float#

get_standard_deviation(self: parselmouth.Spectrum, power: Positive[float] = 2.0) → float#

get_sum(self: parselmouth.Matrix) → float#

get_value_at_xy(self: parselmouth.Matrix, x: float, y: float) → float#

get_value_in_bin(self: parselmouth.Spectrum, bin_number: Positive[int]) → complex#

get_value_in_cell(self: parselmouth.Matrix, row_number: Positive[int], column_number: Positive[int]) → float#

get_x_of_column(self: parselmouth.Matrix, column_number: Positive[int]) → float#

get_y_of_row(self: parselmouth.Matrix, row_number: Positive[int]) → float#

info(self: parselmouth.Thing) → str#

lpc_smoothing(self: parselmouth.Spectrum, num_peaks: Positive[int] = 5, pre_emphasis_from: Positive[float] = 50.0) → parselmouth.Spectrum#

static read(file_path: str) → parselmouth.Data#

Read a file into a parselmouth.Data object.

Parameters:: file_path (str) – The path of the file on disk to read.
Returns:: The Praat Data object that was read.
Return type:: parselmouth.Data

parselmouth.Spectrum

Contents

parselmouth.Spectrum#