pax_global_header 0000666 0000000 0000000 00000000064 13023464014 0014507 g ustar 00root root 0000000 0000000 52 comment=fb9a3cd049ed980fc435040aa6429643a4289862
praat-6.0.23/ 0000775 0000000 0000000 00000000000 13023464014 0012706 5 ustar 00root root 0000000 0000000 praat-6.0.23/EEG/ 0000775 0000000 0000000 00000000000 13023464014 0013306 5 ustar 00root root 0000000 0000000 praat-6.0.23/EEG/EEG.cpp 0000664 0000000 0000000 00000066144 13023464014 0014425 0 ustar 00root root 0000000 0000000 /* EEG.cpp
*
* Copyright (C) 2011-2012,2013,2014,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "EEG.h"
#include "Sound_and_Spectrum.h"
#include "oo_DESTROY.h"
#include "EEG_def.h"
#include "oo_COPY.h"
#include "EEG_def.h"
#include "oo_EQUAL.h"
#include "EEG_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "EEG_def.h"
#include "oo_WRITE_TEXT.h"
#include "EEG_def.h"
#include "oo_READ_TEXT.h"
#include "EEG_def.h"
#include "oo_WRITE_BINARY.h"
#include "EEG_def.h"
#include "oo_READ_BINARY.h"
#include "EEG_def.h"
#include "oo_DESCRIPTION.h"
#include "EEG_def.h"
Thing_implement (EEG, Function, 0);
void structEEG :: v_info () {
structDaata :: v_info ();
MelderInfo_writeLine (U"Time domain:");
MelderInfo_writeLine (U" Start time: ", our xmin, U" seconds");
MelderInfo_writeLine (U" End time: ", our xmax, U" seconds");
MelderInfo_writeLine (U" Total duration: ", our xmax - our xmin, U" seconds");
if (our sound) {
MelderInfo_writeLine (U"Time sampling of the signal:");
MelderInfo_writeLine (U" Number of samples: ", our sound -> nx);
MelderInfo_writeLine (U" Sampling period: ", our sound -> dx, U" seconds");
MelderInfo_writeLine (U" Sampling frequency: ", Melder_single (1.0 / our sound -> dx), U" Hz");
MelderInfo_writeLine (U" First sample centred at: ", our sound -> x1, U" seconds");
}
MelderInfo_writeLine (U"Number of cap electrodes: ", EEG_getNumberOfCapElectrodes (this));
MelderInfo_writeLine (U"Number of external electrodes: ", EEG_getNumberOfExternalElectrodes (this));
MelderInfo_writeLine (U"Number of extra sensors: ", EEG_getNumberOfExtraSensors (this));
}
void structEEG :: v_shiftX (double xfrom, double xto) {
EEG_Parent :: v_shiftX (xfrom, xto);
if (our sound ) Function_shiftXTo (our sound.get(), xfrom, xto);
if (our textgrid) Function_shiftXTo (our textgrid.get(), xfrom, xto);
}
void structEEG :: v_scaleX (double xminfrom, double xmaxfrom, double xminto, double xmaxto) {
EEG_Parent :: v_scaleX (xminfrom, xmaxfrom, xminto, xmaxto);
if (our sound ) our sound -> v_scaleX (xminfrom, xmaxfrom, xminto, xmaxto);
if (our textgrid) our textgrid -> v_scaleX (xminfrom, xmaxfrom, xminto, xmaxto);
}
void EEG_init (EEG me, double tmin, double tmax) {
my xmin = tmin;
my xmax = tmax;
}
autoEEG EEG_create (double tmin, double tmax) {
try {
autoEEG me = Thing_new (EEG);
EEG_init (me.get(), tmin, tmax);
return me;
} catch (MelderError) {
Melder_throw (U"EEG object not created.");
}
}
long EEG_getChannelNumber (EEG me, const char32 *channelName) {
for (long ichan = 1; ichan <= my numberOfChannels; ichan ++) {
if (Melder_equ (my channelNames [ichan], channelName)) {
return ichan;
}
}
return 0;
}
autoEEG EEG_readFromBdfFile (MelderFile file) {
try {
autofile f = Melder_fopen (file, "rb");
char buffer [81];
fread (buffer, 1, 8, f); buffer [8] = '\0';
bool is24bit = buffer [0] == (char) 255;
fread (buffer, 1, 80, f); buffer [80] = '\0';
trace (U"Local subject identification: \"", Melder_peek8to32 (buffer), U"\"");
fread (buffer, 1, 80, f); buffer [80] = '\0';
trace (U"Local recording identification: \"", Melder_peek8to32 (buffer), U"\"");
fread (buffer, 1, 8, f); buffer [8] = '\0';
trace (U"Start date of recording: \"", Melder_peek8to32 (buffer), U"\"");
fread (buffer, 1, 8, f); buffer [8] = '\0';
trace (U"Start time of recording: \"", Melder_peek8to32 (buffer), U"\"");
fread (buffer, 1, 8, f); buffer [8] = '\0';
long numberOfBytesInHeaderRecord = atol (buffer);
trace (U"Number of bytes in header record: ", numberOfBytesInHeaderRecord);
fread (buffer, 1, 44, f); buffer [44] = '\0';
trace (U"Version of data format: \"", Melder_peek8to32 (buffer), U"\"");
fread (buffer, 1, 8, f); buffer [8] = '\0';
long numberOfDataRecords = strtol (buffer, nullptr, 10);
trace (U"Number of data records: ", numberOfDataRecords);
fread (buffer, 1, 8, f); buffer [8] = '\0';
double durationOfDataRecord = atof (buffer);
trace (U"Duration of a data record: ", durationOfDataRecord);
fread (buffer, 1, 4, f); buffer [4] = '\0';
long numberOfChannels = atol (buffer);
trace (U"Number of channels in data record: ", numberOfChannels);
if (numberOfBytesInHeaderRecord != (numberOfChannels + 1) * 256)
Melder_throw (U"Number of bytes in header record (", numberOfBytesInHeaderRecord,
U") doesn't match number of channels (", numberOfChannels, U").");
autostring32vector channelNames (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 16, f); buffer [16] = '\0'; // labels of the channels
/*
* Strip all final spaces.
*/
for (int i = 15; i >= 0; i --) {
if (buffer [i] == ' ') {
buffer [i] = '\0';
} else {
break;
}
}
channelNames [ichannel] = Melder_8to32 (buffer);
trace (U"Channel <<", channelNames [ichannel], U">>");
}
bool hasLetters = str32equ (channelNames [numberOfChannels], U"EDF Annotations");
double samplingFrequency = NUMundefined;
for (long channel = 1; channel <= numberOfChannels; channel ++) {
fread (buffer, 1, 80, f); buffer [80] = '\0'; // transducer type
}
for (long channel = 1; channel <= numberOfChannels; channel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0'; // physical dimension of channels
}
autoNUMvector physicalMinimum (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0';
physicalMinimum [ichannel] = atof (buffer);
}
autoNUMvector physicalMaximum (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0';
physicalMaximum [ichannel] = atof (buffer);
}
autoNUMvector digitalMinimum (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0';
digitalMinimum [ichannel] = atof (buffer);
}
autoNUMvector digitalMaximum (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0';
digitalMaximum [ichannel] = atof (buffer);
}
for (long channel = 1; channel <= numberOfChannels; channel ++) {
fread (buffer, 1, 80, f); buffer [80] = '\0'; // prefiltering
}
long numberOfSamplesPerDataRecord = 0;
for (long channel = 1; channel <= numberOfChannels; channel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0'; // number of samples in each data record
long numberOfSamplesInThisDataRecord = atol (buffer);
if (samplingFrequency == NUMundefined) {
numberOfSamplesPerDataRecord = numberOfSamplesInThisDataRecord;
samplingFrequency = numberOfSamplesInThisDataRecord / durationOfDataRecord;
}
if (numberOfSamplesInThisDataRecord / durationOfDataRecord != samplingFrequency)
Melder_throw (U"Number of samples per data record in channel ", channel,
U" (", numberOfSamplesInThisDataRecord,
U") doesn't match sampling frequency of channel 1 (", samplingFrequency, U").");
}
for (long channel = 1; channel <= numberOfChannels; channel ++) {
fread (buffer, 1, 32, f); buffer [32] = '\0'; // reserved
}
double duration = numberOfDataRecords * durationOfDataRecord;
autoEEG him = EEG_create (0, duration);
his numberOfChannels = numberOfChannels;
autoSound me = Sound_createSimple (numberOfChannels, duration, samplingFrequency);
Melder_assert (my nx == numberOfSamplesPerDataRecord * numberOfDataRecords);
autoNUMvector dataBuffer (0L, 3 * numberOfSamplesPerDataRecord - 1);
for (long record = 1; record <= numberOfDataRecords; record ++) {
for (long channel = 1; channel <= numberOfChannels; channel ++) {
double factor = channel == numberOfChannels ? 1.0 : physicalMinimum [channel] / digitalMinimum [channel];
if (channel < numberOfChannels - EEG_getNumberOfExtraSensors (him.get())) factor /= 1000000.0;
if (is24bit) {
fread (& dataBuffer [0], 3, numberOfSamplesPerDataRecord, f);
unsigned char *p = & dataBuffer [0];
for (long i = 1; i <= numberOfSamplesPerDataRecord; i ++) {
long sample = i + (record - 1) * numberOfSamplesPerDataRecord;
Melder_assert (sample <= my nx);
uint8_t lowByte = *p ++, midByte = *p ++, highByte = *p ++;
uint32_t externalValue = ((uint32_t) highByte << 16) | ((uint32_t) midByte << 8) | (uint32_t) lowByte;
if ((highByte & 128) != 0) // is the 24-bit sign bit on?
externalValue |= 0xFF000000; // extend negative sign to 32 bits
my z [channel] [sample] = (int32_t) externalValue * factor;
}
} else {
fread (& dataBuffer [0], 2, numberOfSamplesPerDataRecord, f);
unsigned char *p = & dataBuffer [0];
for (long i = 1; i <= numberOfSamplesPerDataRecord; i ++) {
long sample = i + (record - 1) * numberOfSamplesPerDataRecord;
Melder_assert (sample <= my nx);
uint8 lowByte = *p ++, highByte = *p ++;
uint16 externalValue = (uint16) ((uint16) highByte << 8) | (uint16) lowByte;
my z [channel] [sample] = (int16) externalValue * factor;
}
}
}
}
int numberOfStatusBits = 8;
for (long i = 1; i <= my nx; i ++) {
unsigned long value = (long) my z [numberOfChannels] [i];
if (value & 0x0000FF00) {
numberOfStatusBits = 16;
}
}
autoTextGrid thee;
if (hasLetters) {
thee = TextGrid_create (0, duration, U"Mark Trigger", U"Mark Trigger");
autoMelderString letters;
double time = NUMundefined;
for (long i = 1; i <= my nx; i ++) {
unsigned long value = (long) my z [numberOfChannels] [i];
for (int byte = 1; byte <= numberOfStatusBits / 8; byte ++) {
unsigned long mask = byte == 1 ? 0x000000ff : 0x0000ff00;
char32 kar = byte == 1 ? (value & mask) : (value & mask) >> 8;
if (kar != U'\0' && kar != 20) {
MelderString_appendCharacter (& letters, kar);
} else if (letters. string [0] != U'\0') {
if (letters. string [0] == U'+') {
if (NUMdefined (time)) {
try {
TextGrid_insertPoint (thee.get(), 1, time, U"");
} catch (MelderError) {
Melder_throw (U"Did not insert empty mark (", letters. string, U") on Mark tier.");
}
time = NUMundefined; // defensive
}
time = Melder_atof (& letters. string [1]);
MelderString_empty (& letters);
} else {
if (! NUMdefined (time)) {
Melder_throw (U"Undefined time for label at sample ", i, U".");
}
try {
if (Melder_nequ (letters. string, U"Trigger-", 8)) {
try {
TextGrid_insertPoint (thee.get(), 2, time, & letters. string [8]);
} catch (MelderError) {
Melder_clearError ();
trace (U"Duplicate trigger at ", time, U" seconds: ", & letters. string [8]);
}
} else {
TextGrid_insertPoint (thee.get(), 1, time, & letters. string [0]);
}
} catch (MelderError) {
Melder_throw (U"Did not insert mark (", letters. string, U") on Trigger tier.");
}
time = NUMundefined; // crucial
MelderString_empty (& letters);
}
}
}
}
if (NUMdefined (time)) {
TextGrid_insertPoint (thee.get(), 1, time, U"");
time = NUMundefined; // defensive
}
} else {
thee = TextGrid_create (0, duration,
numberOfStatusBits == 8 ? U"S1 S2 S3 S4 S5 S6 S7 S8" : U"S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15 S16", U"");
for (int bit = 1; bit <= numberOfStatusBits; bit ++) {
unsigned long bitValue = 1 << (bit - 1);
IntervalTier tier = (IntervalTier) thy tiers->at [bit];
for (long i = 1; i <= my nx; i ++) {
unsigned long previousValue = i == 1 ? 0 : (long) my z [numberOfChannels] [i - 1];
unsigned long thisValue = (long) my z [numberOfChannels] [i];
if ((thisValue & bitValue) != (previousValue & bitValue)) {
double time = i == 1 ? 0.0 : my x1 + (i - 1.5) * my dx;
if (time != 0.0)
TextGrid_insertBoundary (thee.get(), bit, time);
if ((thisValue & bitValue) != 0)
TextGrid_setIntervalText (thee.get(), bit, tier -> intervals.size, U"1");
}
}
}
}
f.close (file);
his channelNames = channelNames.transfer();
his sound = me.move();
his textgrid = thee.move();
if (EEG_getNumberOfCapElectrodes (him.get()) == 32) {
EEG_setChannelName (him.get(), 1, U"Fp1");
EEG_setChannelName (him.get(), 2, U"AF3");
EEG_setChannelName (him.get(), 3, U"F7");
EEG_setChannelName (him.get(), 4, U"F3");
EEG_setChannelName (him.get(), 5, U"FC1");
EEG_setChannelName (him.get(), 6, U"FC5");
EEG_setChannelName (him.get(), 7, U"T7");
EEG_setChannelName (him.get(), 8, U"C3");
EEG_setChannelName (him.get(), 9, U"CP1");
EEG_setChannelName (him.get(), 10, U"CP5");
EEG_setChannelName (him.get(), 11, U"P7");
EEG_setChannelName (him.get(), 12, U"P3");
EEG_setChannelName (him.get(), 13, U"Pz");
EEG_setChannelName (him.get(), 14, U"PO3");
EEG_setChannelName (him.get(), 15, U"O1");
EEG_setChannelName (him.get(), 16, U"Oz");
EEG_setChannelName (him.get(), 17, U"O2");
EEG_setChannelName (him.get(), 18, U"PO4");
EEG_setChannelName (him.get(), 19, U"P4");
EEG_setChannelName (him.get(), 20, U"P8");
EEG_setChannelName (him.get(), 21, U"CP6");
EEG_setChannelName (him.get(), 22, U"CP2");
EEG_setChannelName (him.get(), 23, U"C4");
EEG_setChannelName (him.get(), 24, U"T8");
EEG_setChannelName (him.get(), 25, U"FC6");
EEG_setChannelName (him.get(), 26, U"FC2");
EEG_setChannelName (him.get(), 27, U"F4");
EEG_setChannelName (him.get(), 28, U"F8");
EEG_setChannelName (him.get(), 29, U"AF4");
EEG_setChannelName (him.get(), 30, U"Fp2");
EEG_setChannelName (him.get(), 31, U"Fz");
EEG_setChannelName (him.get(), 32, U"Cz");
} else if (EEG_getNumberOfCapElectrodes (him.get()) == 64) {
EEG_setChannelName (him.get(), 1, U"Fp1");
EEG_setChannelName (him.get(), 2, U"AF7");
EEG_setChannelName (him.get(), 3, U"AF3");
EEG_setChannelName (him.get(), 4, U"F1");
EEG_setChannelName (him.get(), 5, U"F3");
EEG_setChannelName (him.get(), 6, U"F5");
EEG_setChannelName (him.get(), 7, U"F7");
EEG_setChannelName (him.get(), 8, U"FT7");
EEG_setChannelName (him.get(), 9, U"FC5");
EEG_setChannelName (him.get(), 10, U"FC3");
EEG_setChannelName (him.get(), 11, U"FC1");
EEG_setChannelName (him.get(), 12, U"C1");
EEG_setChannelName (him.get(), 13, U"C3");
EEG_setChannelName (him.get(), 14, U"C5");
EEG_setChannelName (him.get(), 15, U"T7");
EEG_setChannelName (him.get(), 16, U"TP7");
EEG_setChannelName (him.get(), 17, U"CP5");
EEG_setChannelName (him.get(), 18, U"CP3");
EEG_setChannelName (him.get(), 19, U"CP1");
EEG_setChannelName (him.get(), 20, U"P1");
EEG_setChannelName (him.get(), 21, U"P3");
EEG_setChannelName (him.get(), 22, U"P5");
EEG_setChannelName (him.get(), 23, U"P7");
EEG_setChannelName (him.get(), 24, U"P9");
EEG_setChannelName (him.get(), 25, U"PO7");
EEG_setChannelName (him.get(), 26, U"PO3");
EEG_setChannelName (him.get(), 27, U"O1");
EEG_setChannelName (him.get(), 28, U"Iz");
EEG_setChannelName (him.get(), 29, U"Oz");
EEG_setChannelName (him.get(), 30, U"POz");
EEG_setChannelName (him.get(), 31, U"Pz");
EEG_setChannelName (him.get(), 32, U"CPz");
EEG_setChannelName (him.get(), 33, U"Fpz");
EEG_setChannelName (him.get(), 34, U"Fp2");
EEG_setChannelName (him.get(), 35, U"AF8");
EEG_setChannelName (him.get(), 36, U"AF4");
EEG_setChannelName (him.get(), 37, U"AFz");
EEG_setChannelName (him.get(), 38, U"Fz");
EEG_setChannelName (him.get(), 39, U"F2");
EEG_setChannelName (him.get(), 40, U"F4");
EEG_setChannelName (him.get(), 41, U"F6");
EEG_setChannelName (him.get(), 42, U"F8");
EEG_setChannelName (him.get(), 43, U"FT8");
EEG_setChannelName (him.get(), 44, U"FC6");
EEG_setChannelName (him.get(), 45, U"FC4");
EEG_setChannelName (him.get(), 46, U"FC2");
EEG_setChannelName (him.get(), 47, U"FCz");
EEG_setChannelName (him.get(), 48, U"Cz");
EEG_setChannelName (him.get(), 49, U"C2");
EEG_setChannelName (him.get(), 50, U"C4");
EEG_setChannelName (him.get(), 51, U"C6");
EEG_setChannelName (him.get(), 52, U"T8");
EEG_setChannelName (him.get(), 53, U"TP8");
EEG_setChannelName (him.get(), 54, U"CP6");
EEG_setChannelName (him.get(), 55, U"CP4");
EEG_setChannelName (him.get(), 56, U"CP2");
EEG_setChannelName (him.get(), 57, U"P2");
EEG_setChannelName (him.get(), 58, U"P4");
EEG_setChannelName (him.get(), 59, U"P6");
EEG_setChannelName (him.get(), 60, U"P8");
EEG_setChannelName (him.get(), 61, U"P10");
EEG_setChannelName (him.get(), 62, U"PO8");
EEG_setChannelName (him.get(), 63, U"PO4");
EEG_setChannelName (him.get(), 64, U"O2");
}
return him;
} catch (MelderError) {
Melder_throw (U"BDF file not read.");
}
}
static void detrend (double *a, long numberOfSamples) {
double firstValue = a [1], lastValue = a [numberOfSamples];
a [1] = a [numberOfSamples] = 0.0;
for (long isamp = 2; isamp < numberOfSamples; isamp ++) {
a [isamp] -= ((isamp - 1.0) * lastValue + (numberOfSamples - isamp) * firstValue) / (numberOfSamples - 1);
}
}
void EEG_detrend (EEG me) {
for (long ichan = 1; ichan <= my numberOfChannels - EEG_getNumberOfExtraSensors (me); ichan ++) {
detrend (my sound -> z [ichan], my sound -> nx);
}
}
void EEG_filter (EEG me, double lowFrequency, double lowWidth, double highFrequency, double highWidth, bool doNotch50Hz) {
try {
/*
long nsampFFT = 1;
while (nsampFFT < my sound -> nx)
nsampFFT *= 2;
autoNUMfft_Table fftTable;
NUMfft_Table_init (& fftTable, nsampFFT);
*/
for (long ichan = 1; ichan <= my numberOfChannels - EEG_getNumberOfExtraSensors (me); ichan ++) {
autoSound channel = Sound_extractChannel (my sound.get(), ichan);
autoSpectrum spec = Sound_to_Spectrum (channel.get(), true);
Spectrum_passHannBand (spec.get(), lowFrequency, 0.0, lowWidth);
Spectrum_passHannBand (spec.get(), 0.0, highFrequency, highWidth);
if (doNotch50Hz) {
Spectrum_stopHannBand (spec.get(), 48.0, 52.0, 1.0);
}
autoSound him = Spectrum_to_Sound (spec.get());
NUMvector_copyElements (his z [1], my sound -> z [ichan], 1, my sound -> nx);
}
} catch (MelderError) {
Melder_throw (me, U": not filtered.");
}
}
void EEG_setChannelName (EEG me, long channelNumber, const char32 *a_name) {
autostring32 l_name = Melder_dup (a_name);
Melder_free (my channelNames [channelNumber]);
my channelNames [channelNumber] = l_name.transfer();
}
void EEG_setExternalElectrodeNames (EEG me,
const char32 *nameExg1, const char32 *nameExg2, const char32 *nameExg3, const char32 *nameExg4,
const char32 *nameExg5, const char32 *nameExg6, const char32 *nameExg7, const char32 *nameExg8)
{
if (EEG_getNumberOfExternalElectrodes (me) != 8)
Melder_throw (U"There aren't 8 external electrodes.");
const long firstExternalElectrode = EEG_getNumberOfCapElectrodes (me) + 1;
EEG_setChannelName (me, firstExternalElectrode, nameExg1);
EEG_setChannelName (me, firstExternalElectrode + 1, nameExg2);
EEG_setChannelName (me, firstExternalElectrode + 2, nameExg3);
EEG_setChannelName (me, firstExternalElectrode + 3, nameExg4);
EEG_setChannelName (me, firstExternalElectrode + 4, nameExg5);
EEG_setChannelName (me, firstExternalElectrode + 5, nameExg6);
EEG_setChannelName (me, firstExternalElectrode + 6, nameExg7);
EEG_setChannelName (me, firstExternalElectrode + 7, nameExg8);
}
void EEG_subtractReference (EEG me, const char32 *channelNumber1_text, const char32 *channelNumber2_text) {
long channelNumber1 = EEG_getChannelNumber (me, channelNumber1_text);
if (channelNumber1 == 0)
Melder_throw (me, U": no channel named \"", channelNumber1_text, U"\".");
long channelNumber2 = EEG_getChannelNumber (me, channelNumber2_text);
if (channelNumber2 == 0 && channelNumber2_text [0] != '\0')
Melder_throw (me, U": no channel named \"", channelNumber2_text, U"\".");
const long numberOfElectrodeChannels = my numberOfChannels - EEG_getNumberOfExtraSensors (me);
for (long isamp = 1; isamp <= my sound -> nx; isamp ++) {
double referenceValue = channelNumber2 == 0 ? my sound -> z [channelNumber1] [isamp] :
0.5 * (my sound -> z [channelNumber1] [isamp] + my sound -> z [channelNumber2] [isamp]);
for (long ichan = 1; ichan <= numberOfElectrodeChannels; ichan ++) {
my sound -> z [ichan] [isamp] -= referenceValue;
}
}
}
void EEG_subtractMeanChannel (EEG me, long fromChannel, long toChannel) {
if (fromChannel < 1 || fromChannel > my numberOfChannels)
Melder_throw (U"No channel ", fromChannel, U".");
if (toChannel < 1 || toChannel > my numberOfChannels)
Melder_throw (U"No channel ", toChannel, U".");
if (fromChannel > toChannel)
Melder_throw (U"Channel range cannot run from ", fromChannel, U" to ", toChannel, U". Please reverse.");
const long numberOfElectrodeChannels = my numberOfChannels - EEG_getNumberOfExtraSensors (me);
for (long isamp = 1; isamp <= my sound -> nx; isamp ++) {
double referenceValue = 0.0;
for (long ichan = fromChannel; ichan <= toChannel; ichan ++) {
referenceValue += my sound -> z [ichan] [isamp];
}
referenceValue /= (toChannel - fromChannel + 1);
for (long ichan = 1; ichan <= numberOfElectrodeChannels; ichan ++) {
my sound -> z [ichan] [isamp] -= referenceValue;
}
}
}
void EEG_setChannelToZero (EEG me, long channelNumber) {
try {
if (channelNumber < 1 || channelNumber > my numberOfChannels)
Melder_throw (U"No channel ", channelNumber, U".");
long numberOfSamples = my sound -> nx;
double *channel = my sound -> z [channelNumber];
for (long isample = 1; isample <= numberOfSamples; isample ++) {
channel [isample] = 0.0;
}
} catch (MelderError) {
Melder_throw (me, U": channel ", channelNumber, U" not set to zero.");
}
}
void EEG_setChannelToZero (EEG me, const char32 *channelName) {
try {
long channelNumber = EEG_getChannelNumber (me, channelName);
if (channelNumber == 0)
Melder_throw (U"No channel named \"", channelName, U"\".");
EEG_setChannelToZero (me, channelNumber);
} catch (MelderError) {
Melder_throw (me, U": channel ", channelName, U" not set to zero.");
}
}
void EEG_removeTriggers (EEG me, int which_Melder_STRING, const char32 *criterion) {
try {
if (my textgrid -> tiers->size < 2 || ! Melder_equ (my textgrid -> tiers->at [2] -> name, U"Trigger"))
Melder_throw (me, U" does not have a Trigger channel.");
TextGrid_removePoints (my textgrid.get(), 2, which_Melder_STRING, criterion);
} catch (MelderError) {
Melder_throw (me, U": triggers not removed.");
}
}
autoEEG EEG_extractChannel (EEG me, long channelNumber) {
try {
if (channelNumber < 1 || channelNumber > my numberOfChannels)
Melder_throw (U"No channel ", channelNumber, U".");
autoEEG thee = EEG_create (my xmin, my xmax);
thy numberOfChannels = 1;
thy channelNames = NUMvector (1, 1);
thy channelNames [1] = Melder_dup (my channelNames [1]);
thy sound = Sound_extractChannel (my sound.get(), channelNumber);
thy textgrid = Data_copy (my textgrid.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": channel ", channelNumber, U" not extracted.");
}
}
autoEEG EEG_extractChannel (EEG me, const char32 *channelName) {
try {
long channelNumber = EEG_getChannelNumber (me, channelName);
if (channelNumber == 0)
Melder_throw (U"No channel named \"", channelName, U"\".");
return EEG_extractChannel (me, channelNumber);
} catch (MelderError) {
Melder_throw (me, U": channel ", channelName, U" not extracted.");
}
}
autoEEG EEGs_concatenate (OrderedOf* me) {
try {
if (my size < 1)
Melder_throw (U"Cannot concatenate zero EEG objects.");
EEG first = my at [1];
long numberOfChannels = first -> numberOfChannels;
char32 **channelNames = first -> channelNames;
for (long ieeg = 2; ieeg <= my size; ieeg ++) {
EEG other = my at [ieeg];
if (other -> numberOfChannels != numberOfChannels)
Melder_throw (U"The number of channels of ", other, U" does not match the number of channels of ", first, U".");
for (long ichan = 1; ichan <= numberOfChannels; ichan ++) {
if (! Melder_equ (other -> channelNames [ichan], channelNames [ichan]))
Melder_throw (U"Channel ", ichan, U" has a different name in ", other, U" (", other -> channelNames [ichan], U") than in ", first, U" (", channelNames [ichan], U").");
}
}
OrderedOf soundList;
OrderedOf textgridList;
for (long ieeg = 1; ieeg <= my size; ieeg ++) {
EEG eeg = my at [ieeg];
soundList. addItem_ref (eeg -> sound.get());
textgridList. addItem_ref (eeg -> textgrid.get());
}
autoEEG thee = Thing_new (EEG);
thy numberOfChannels = numberOfChannels;
thy channelNames = NUMvector (1, numberOfChannels);
for (long ichan = 1; ichan <= numberOfChannels; ichan ++) {
thy channelNames [ichan] = Melder_dup (channelNames [ichan]);
}
thy sound = Sounds_concatenate (soundList, 0.0);
thy textgrid = TextGrids_concatenate (& textgridList);
thy xmin = thy textgrid -> xmin;
thy xmax = thy textgrid -> xmax;
return thee;
} catch (MelderError) {
Melder_throw (U"TextGrids not concatenated.");
}
}
autoEEG EEG_extractPart (EEG me, double tmin, double tmax, bool preserveTimes) {
try {
autoEEG thee = Thing_new (EEG);
thy numberOfChannels = my numberOfChannels;
thy channelNames = NUMvector (1, my numberOfChannels);
for (long ichan = 1; ichan <= my numberOfChannels; ichan ++) {
thy channelNames [ichan] = Melder_dup (my channelNames [ichan]);
}
thy sound = Sound_extractPart (my sound.get(), tmin, tmax, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
thy textgrid = TextGrid_extractPart (my textgrid.get(), tmin, tmax, preserveTimes);
thy xmin = thy textgrid -> xmin;
thy xmax = thy textgrid -> xmax;
return thee;
} catch (MelderError) {
Melder_throw (me, U": part not extracted.");
}
}
void EEG_replaceTextGrid (EEG me, TextGrid textgrid) {
try {
my textgrid = Data_copy (textgrid);
} catch (MelderError) {
Melder_throw (me, U": TextGrid not replaced with ", textgrid, U".");
}
}
autoMixingMatrix EEG_to_MixingMatrix (EEG me, long maxNumberOfIterations, double tol, int method) {
try {
autoCrossCorrelationTableList tables = Sound_to_CrossCorrelationTableList (my sound.get(), 0.0, 0.0, 0.002, 1);
autoMixingMatrix thee = MixingMatrix_create (my sound -> ny, my sound -> ny);
for (long ichan = 1; ichan <= my numberOfChannels; ichan ++) {
TableOfReal_setRowLabel (thee.get(), ichan, my channelNames [ichan]);
TableOfReal_setColumnLabel (thee.get(), ichan, Melder_cat (U"ic", ichan));
}
MixingMatrix_and_CrossCorrelationTableList_improveUnmixing (thee.get(), tables.get(), maxNumberOfIterations, tol, method);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no MixingMatrix created.");
}
}
/* End of file EEG.cpp */
praat-6.0.23/EEG/EEG.h 0000664 0000000 0000000 00000005551 13023464014 0014065 0 ustar 00root root 0000000 0000000 #ifndef _EEG_h_
#define _EEG_h_
/* EEG.h
*
* Copyright (C) 2011-2012,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Sound.h"
#include "TextGrid.h"
#include "../dwtools/ICA.h"
#include "EEG_def.h"
autoEEG EEG_create (double tmin, double tmax);
autoEEG EEG_readFromBdfFile (MelderFile file);
autoEEG EEGs_concatenate (OrderedOf* me);
void EEG_init (EEG me, double tmin, double tmax);
long EEG_getChannelNumber (EEG me, const char32 *channelName);
void EEG_setChannelName (EEG me, long channelNumber, const char32 *a_name);
static inline long EEG_getNumberOfCapElectrodes (EEG me) {
return (my numberOfChannels - 1) & ~ 15L; // BUG
}
static inline long EEG_getNumberOfExtraSensors (EEG me) {
return my numberOfChannels == 1 ? 0 : my numberOfChannels & 1 ? 1 : 8; // BUG
}
static inline long EEG_getNumberOfExternalElectrodes (EEG me) {
return my numberOfChannels - EEG_getNumberOfCapElectrodes (me) - EEG_getNumberOfExtraSensors (me);
}
void EEG_setExternalElectrodeNames (EEG me, const char32 *nameExg1, const char32 *nameExg2, const char32 *nameExg3, const char32 *nameExg4,
const char32 *nameExg5, const char32 *nameExg6, const char32 *nameExg7, const char32 *nameExg8);
void EEG_detrend (EEG me);
void EEG_filter (EEG me, double lowFrequency, double lowWidth, double highFrequency, double highWidth, bool doNotch50Hz);
void EEG_subtractReference (EEG me, const char32 *channelNumber1, const char32 *channelNumber2);
void EEG_subtractMeanChannel (EEG me, long fromChannel, long toChannel);
void EEG_setChannelToZero (EEG me, long channelNumber);
void EEG_setChannelToZero (EEG me, const char32 *channelName);
void EEG_removeTriggers (EEG me, int which_Melder_STRING, const char32 *criterion);
autoEEG EEG_extractChannel (EEG me, long channelNumber);
autoEEG EEG_extractChannel (EEG me, const char32 *channelName);
static inline autoSound EEG_extractSound (EEG me) { return Data_copy (my sound.get()); }
static inline autoTextGrid EEG_extractTextGrid (EEG me) { return Data_copy (my textgrid.get()); }
autoEEG EEG_extractPart (EEG me, double tmin, double tmax, bool preserveTimes);
void EEG_replaceTextGrid (EEG me, TextGrid textgrid);
autoMixingMatrix EEG_to_MixingMatrix (EEG me, long maxNumberOfIterations, double tol, int method);
/* End of file EEG.h */
#endif
praat-6.0.23/EEG/EEGWindow.cpp 0000664 0000000 0000000 00000006612 13023464014 0015607 0 ustar 00root root 0000000 0000000 /* EEGWindow.cpp
*
* Copyright (C) 2011-2012,2013,2014,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "EEGWindow.h"
#include "EditorM.h"
Thing_implement (EEGWindow, TextGridEditor, 0);
#include "prefs_define.h"
#include "EEGWindow_prefs.h"
#include "prefs_install.h"
#include "EEGWindow_prefs.h"
#include "prefs_copyToInstance.h"
#include "EEGWindow_prefs.h"
static void menu_cb_EEGWindowHelp (EEGWindow, EDITOR_ARGS_DIRECT) { Melder_help (U"EEG window"); }
void structEEGWindow :: v_createMenus () {
EEGWindow_Parent :: v_createMenus ();
}
void structEEGWindow :: v_createHelpMenuItems (EditorMenu menu) {
TextGridEditor_Parent :: v_createHelpMenuItems (menu);
EditorMenu_addCommand (menu, U"EEGWindow help", '?', menu_cb_EEGWindowHelp);
}
const char32 * structEEGWindow :: v_getChannelName (long channelNumber) {
Melder_assert (our eeg != nullptr);
return our eeg -> channelNames [channelNumber];
}
static void menu_cb_ExtractSelectedEEG_preserveTimes (EEGWindow me, EDITOR_ARGS_DIRECT) {
if (my d_endSelection <= my d_startSelection) Melder_throw (U"No selection.");
autoEEG extract = EEG_extractPart (my eeg, my d_startSelection, my d_endSelection, true);
Editor_broadcastPublication (me, extract.move());
}
static void menu_cb_ExtractSelectedEEG_timeFromZero (EEGWindow me, EDITOR_ARGS_DIRECT) {
if (my d_endSelection <= my d_startSelection) Melder_throw (U"No selection.");
autoEEG extract = EEG_extractPart (my eeg, my d_startSelection, my d_endSelection, false);
Editor_broadcastPublication (me, extract.move());
}
void structEEGWindow :: v_createMenuItems_file_extract (EditorMenu menu) {
EEGWindow_Parent :: v_createMenuItems_file_extract (menu);
our extractSelectedEEGPreserveTimesButton =
EditorMenu_addCommand (menu, U"Extract selected EEG (preserve times)", 0, menu_cb_ExtractSelectedEEG_preserveTimes);
our extractSelectedEEGTimeFromZeroButton =
EditorMenu_addCommand (menu, U"Extract selected EEG (time from zero)", 0, menu_cb_ExtractSelectedEEG_timeFromZero);
}
void structEEGWindow :: v_updateMenuItems_file () {
EEGWindow_Parent :: v_updateMenuItems_file ();
GuiThing_setSensitive (our extractSelectedEEGPreserveTimesButton, d_endSelection > d_startSelection);
GuiThing_setSensitive (our extractSelectedEEGTimeFromZeroButton, d_endSelection > d_startSelection);
}
void EEGWindow_init (EEGWindow me, const char32 *title, EEG eeg) {
my eeg = eeg; // before initing, because initing will already draw!
TextGridEditor_init (me, title, eeg -> textgrid.get(), eeg -> sound.get(), false, nullptr, nullptr);
}
autoEEGWindow EEGWindow_create (const char32 *title, EEG eeg) {
try {
autoEEGWindow me = Thing_new (EEGWindow);
EEGWindow_init (me.get(), title, eeg);
return me;
} catch (MelderError) {
Melder_throw (U"EEG window not created.");
}
}
/* End of file EEGWindow.cpp */
praat-6.0.23/EEG/EEGWindow.h 0000664 0000000 0000000 00000003133 13023464014 0015247 0 ustar 00root root 0000000 0000000 #ifndef _EEGWindow_h_
#define _EEGWindow_h_
/* EEGWindow.h
*
* Copyright (C) 2011-2012,2013,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "TextGridEditor.h"
#include "EEG.h"
Thing_define (EEGWindow, TextGridEditor) {
EEG eeg;
GuiMenuItem extractSelectedEEGPreserveTimesButton, extractSelectedEEGTimeFromZeroButton;
bool v_hasPitch ()
override { return false; }
bool v_hasIntensity ()
override { return false; }
bool v_hasFormants ()
override { return false; }
bool v_hasPulses ()
override { return false; }
void v_createMenus ()
override;
void v_createHelpMenuItems (EditorMenu menu)
override;
const char32 * v_getChannelName (long channelNumber)
override;
void v_createMenuItems_file_extract (EditorMenu menu)
override;
void v_updateMenuItems_file ()
override;
#include "EEGWindow_prefs.h"
};
void EEGWindow_init (EEGWindow me, const char32 *title, EEG eeg);
autoEEGWindow EEGWindow_create (const char32 *title, EEG eeg);
/* End of file EEGWindow.h */
#endif
praat-6.0.23/EEG/EEGWindow_prefs.h 0000664 0000000 0000000 00000005063 13023464014 0016452 0 ustar 00root root 0000000 0000000 /* EEGWindow_prefs.h
*
* Copyright (C) 2013,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
prefs_begin (EEGWindow)
prefs_override_bool (EEGWindow, showSelectionViewer, 1, false)
prefs_override_enum (EEGWindow, sound_scalingStrategy, 1, kTimeSoundEditor_scalingStrategy, DEFAULT)
prefs_override_double (EEGWindow, sound_scaling_height, 1, U"20e-6")
prefs_override_double (EEGWindow, sound_scaling_minimum, 1, U"-10e-6")
prefs_override_double (EEGWindow, sound_scaling_maximum, 1, U"10e-6")
prefs_override_double (EEGWindow, picture_bottom, 1, U"0.0")
prefs_override_double (EEGWindow, picture_top, 1, U"0.0 (= auto)")
prefs_override_bool (EEGWindow, spectrogram_show, 1, false);
prefs_override_double (EEGWindow, spectrogram_viewFrom, 1, U"0.0") // Hz
prefs_override_double (EEGWindow, spectrogram_viewTo, 1, U"60.0") // Hz
prefs_override_double (EEGWindow, spectrogram_windowLength, 1, U"0.5") // seconds
prefs_override_double (EEGWindow, spectrogram_dynamicRange, 1, U"40.0") // dB
prefs_override_long (EEGWindow, spectrogram_timeSteps, 1, U"1000")
prefs_override_long (EEGWindow, spectrogram_frequencySteps, 1, U"250")
prefs_override_enum (EEGWindow, spectrogram_method, 1, kSound_to_Spectrogram_method, DEFAULT)
prefs_override_enum (EEGWindow, spectrogram_windowShape, 1, kSound_to_Spectrogram_windowShape, DEFAULT)
prefs_override_bool (EEGWindow, spectrogram_autoscaling, 1, true)
prefs_override_double (EEGWindow, spectrogram_maximum, 1, U"100.0") // dB/Hz
prefs_override_double (EEGWindow, spectrogram_preemphasis, 1, U"0.0") // dB/octave
prefs_override_double (EEGWindow, spectrogram_dynamicCompression, 1, U"0.0")
prefs_override_bool (EEGWindow, spectrogram_picture_garnish, 1, true)
prefs_end (EEGWindow)
/* End of file EEGWindow_prefs.h */
praat-6.0.23/EEG/EEG_def.h 0000664 0000000 0000000 00000002357 13023464014 0014704 0 ustar 00root root 0000000 0000000 /* EEG_def.h
*
* Copyright (C) 2011,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT EEG
oo_DEFINE_CLASS (EEG, Function)
oo_LONG (numberOfChannels)
oo_STRING_VECTOR (channelNames, numberOfChannels)
oo_AUTO_OBJECT (Sound, 2, sound)
oo_AUTO_OBJECT (TextGrid, 0, textgrid)
#if oo_DECLARING
void v_info ()
override;
int v_domainQuantity ()
override { return MelderQuantity_TIME_SECONDS; }
void v_shiftX (double xfrom, double xto)
override;
void v_scaleX (double xminfrom, double xmaxfrom, double xminto, double xmaxto)
override;
#endif
oo_END_CLASS (EEG)
#undef ooSTRUCT
/* End of file EEG_def.h */
praat-6.0.23/EEG/ERP.cpp 0000664 0000000 0000000 00000011420 13023464014 0014436 0 ustar 00root root 0000000 0000000 /* ERP.cpp
*
* Copyright (C) 2011-2012,2013,2014,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "ERP.h"
#include "oo_DESTROY.h"
#include "ERP_def.h"
#include "oo_COPY.h"
#include "ERP_def.h"
#include "oo_EQUAL.h"
#include "ERP_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "ERP_def.h"
#include "oo_WRITE_TEXT.h"
#include "ERP_def.h"
#include "oo_READ_TEXT.h"
#include "ERP_def.h"
#include "oo_WRITE_BINARY.h"
#include "ERP_def.h"
#include "oo_READ_BINARY.h"
#include "ERP_def.h"
#include "oo_DESCRIPTION.h"
#include "ERP_def.h"
/********** class ERPTier **********/
Thing_implement (ERP, Sound, 2);
long ERP_getChannelNumber (ERP me, const char32 *channelName) {
for (long ichan = 1; ichan <= my ny; ichan ++) {
if (Melder_equ (my channelNames [ichan], channelName)) {
return ichan;
}
}
return 0;
}
void ERP_drawChannel_number (ERP me, Graphics graphics, long channelNumber, double tmin, double tmax, double vmin, double vmax, bool garnish) {
if (channelNumber < 1 || channelNumber > my ny) return;
/*
* Automatic domain.
*/
if (tmin == tmax) {
tmin = my xmin;
tmax = my xmax;
}
/*
* Domain expressed in sample numbers.
*/
long ixmin, ixmax;
Matrix_getWindowSamplesX (me, tmin, tmax, & ixmin, & ixmax);
/*
* Automatic vertical range.
*/
if (vmin == vmax) {
Matrix_getWindowExtrema (me, ixmin, ixmax, channelNumber, channelNumber, & vmin, & vmax);
if (vmin == vmax) {
vmin -= 1.0;
vmax += 1.0;
}
}
/*
* Set coordinates for drawing.
*/
Graphics_setInner (graphics);
Graphics_setWindow (graphics, tmin, tmax, vmin, vmax);
Graphics_function (graphics, my z [channelNumber], ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax));
Graphics_unsetInner (graphics);
if (garnish) {
Graphics_drawInnerBox (graphics);
Graphics_textTop (graphics, true, Melder_cat (U"Channel ", my channelNames [channelNumber]));
Graphics_textBottom (graphics, true, U"Time (s)");
Graphics_marksBottom (graphics, 2, true, true, false);
if (0.0 > tmin && 0.0 < tmax)
Graphics_markBottom (graphics, 0.0, true, true, true, nullptr);
Graphics_markLeft (graphics, vmin, true, true, false, nullptr);
Graphics_markLeft (graphics, vmax, true, true, false, nullptr);
Graphics_markBottom (graphics, 0.0, true, true, true, nullptr);
if (vmin != 0.0 && vmax != 0.0 && (vmin > 0.0) != (vmax > 0.0)) {
Graphics_markLeft (graphics, 0.0, true, true, true, nullptr);
}
}
}
void ERP_drawChannel_name (ERP me, Graphics graphics, const char32 *channelName, double tmin, double tmax, double vmin, double vmax, bool garnish) {
ERP_drawChannel_number (me, graphics, ERP_getChannelNumber (me, channelName), tmin, tmax, vmin, vmax, garnish);
}
autoTable ERP_tabulate (ERP me, bool includeSampleNumbers, bool includeTime, int timeDecimals, int voltageDecimals, int units) {
double voltageScaling = 1.0;
const char32 *unitText = U"(V)";
if (units == 2) {
voltageDecimals -= 6;
voltageScaling = 1000000.0;
unitText = U"(uV)";
}
try {
autoTable thee = Table_createWithoutColumnNames (my nx, includeSampleNumbers + includeTime + my ny);
long icol = 0;
if (includeSampleNumbers) Table_setColumnLabel (thee.get(), ++ icol, U"sample");
if (includeTime) Table_setColumnLabel (thee.get(), ++ icol, U"time(s)");
for (long ichan = 1; ichan <= my ny; ichan ++) {
Table_setColumnLabel (thee.get(), ++ icol, Melder_cat (my channelNames [ichan], unitText));
}
for (long isamp = 1; isamp <= my nx; isamp ++) {
icol = 0;
if (includeSampleNumbers) Table_setNumericValue (thee.get(), isamp, ++ icol, isamp);
if (includeTime) Table_setStringValue (thee.get(), isamp, ++ icol, Melder_fixed (my x1 + (isamp - 1) * my dx, timeDecimals));
for (long ichan = 1; ichan <= my ny; ichan ++) {
Table_setStringValue (thee.get(), isamp, ++ icol, Melder_fixed (voltageScaling * my z [ichan] [isamp], voltageDecimals));
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Table.");
}
}
autoSound ERP_downto_Sound (ERP me) {
try {
autoSound thee = Thing_new (Sound);
my structSound :: v_copy (thee.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Sound.");
}
}
/* End of file ERP.cpp */
praat-6.0.23/EEG/ERP.h 0000664 0000000 0000000 00000003444 13023464014 0014112 0 ustar 00root root 0000000 0000000 #ifndef _ERP_h_
#define _ERP_h_
/* ERP.h
*
* Copyright (C) 2011,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Sound.h"
#include "ERP_def.h"
/**
Look up the channel number from its name.
*/
long ERP_getChannelNumber (ERP me, const char32 *channelName);
/**
* Draw the scalp distribution.
* @param tmin: the time window.
* @param tmax: the time window.
*/
void ERP_drawScalp (ERP me,
Graphics graphics, double tmin, double tmax, double vmin, double vmax,
enum kGraphics_colourScale colourScale, bool garnish);
void ERP_drawScalp_garnish (Graphics graphics, double vmin, double vmax, enum kGraphics_colourScale colourScale);
void ERP_drawChannel_number (ERP me, Graphics graphics, long channelNumber, double tmin, double tmax, double vmin, double vmax, bool garnish);
void ERP_drawChannel_name (ERP me, Graphics graphics, const char32 *channelName, double tmin, double tmax, double vmin, double vmax, bool garnish);
autoTable ERP_tabulate (ERP me, bool includeSampleNumbers, bool includeTime, int timeDecimals, int voltageDecimals, int units);
/**
Extract the Sound part from the ERP. The channel names are lost.
*/
autoSound ERP_downto_Sound (ERP me);
/* End of file ERP.h */
#endif
praat-6.0.23/EEG/ERPTier.cpp 0000664 0000000 0000000 00000033165 13023464014 0015274 0 ustar 00root root 0000000 0000000 /* ERPTier.cpp
*
* Copyright (C) 2011-2012,2014,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "ERPTier.h"
#include "oo_DESTROY.h"
#include "ERPTier_def.h"
#include "oo_COPY.h"
#include "ERPTier_def.h"
#include "oo_EQUAL.h"
#include "ERPTier_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "ERPTier_def.h"
#include "oo_WRITE_TEXT.h"
#include "ERPTier_def.h"
#include "oo_READ_TEXT.h"
#include "ERPTier_def.h"
#include "oo_WRITE_BINARY.h"
#include "ERPTier_def.h"
#include "oo_READ_BINARY.h"
#include "ERPTier_def.h"
#include "oo_DESCRIPTION.h"
#include "ERPTier_def.h"
/***** ERPPoint *****/
Thing_implement (ERPPoint, AnyPoint, 0);
/***** ERPTier *****/
Thing_implement (ERPTier, AnyTier, 0);
long ERPTier_getChannelNumber (ERPTier me, const char32 *channelName) {
for (long ichan = 1; ichan <= my numberOfChannels; ichan ++) {
if (Melder_equ (my channelNames [ichan], channelName)) {
return ichan;
}
}
return 0;
}
double ERPTier_getMean (ERPTier me, long pointNumber, long channelNumber, double tmin, double tmax) {
if (pointNumber < 1 || pointNumber > my points.size) return NUMundefined;
if (channelNumber < 1 || channelNumber > my numberOfChannels) return NUMundefined;
ERPPoint point = my points.at [pointNumber];
return Vector_getMean (point -> erp.get(), tmin, tmax, channelNumber);
}
double ERPTier_getMean (ERPTier me, long pointNumber, const char32 *channelName, double tmin, double tmax) {
return ERPTier_getMean (me, pointNumber, ERPTier_getChannelNumber (me, channelName), tmin, tmax);
}
static autoERPTier EEG_PointProcess_to_ERPTier (EEG me, PointProcess events, double fromTime, double toTime) {
try {
autoERPTier thee = Thing_new (ERPTier);
Function_init (thee.get(), fromTime, toTime);
thy numberOfChannels = my numberOfChannels - EEG_getNumberOfExtraSensors (me);
Melder_assert (thy numberOfChannels > 0);
thy channelNames = NUMvector (1, thy numberOfChannels);
for (long ichan = 1; ichan <= thy numberOfChannels; ichan ++) {
thy channelNames [ichan] = Melder_dup (my channelNames [ichan]);
}
long numberOfEvents = events -> nt;
double soundDuration = toTime - fromTime;
double samplingPeriod = my sound -> dx;
long numberOfSamples = (long) floor (soundDuration / samplingPeriod) + 1;
if (numberOfSamples < 1)
Melder_throw (U"Time window too short.");
double midTime = 0.5 * (fromTime + toTime);
double soundPhysicalDuration = numberOfSamples * samplingPeriod;
double firstTime = midTime - 0.5 * soundPhysicalDuration + 0.5 * samplingPeriod; // distribute the samples evenly over the time domain
for (long ievent = 1; ievent <= numberOfEvents; ievent ++) {
double eegEventTime = events -> t [ievent];
autoERPPoint event = Thing_new (ERPPoint);
event -> number = eegEventTime;
event -> erp = Sound_create (thy numberOfChannels, fromTime, toTime, numberOfSamples, samplingPeriod, firstTime);
double erpEventTime = 0.0;
double eegSample = 1 + (eegEventTime - my sound -> x1) / samplingPeriod;
double erpSample = 1 + (erpEventTime - firstTime) / samplingPeriod;
long sampleDifference = lround (eegSample - erpSample);
for (long ichannel = 1; ichannel <= thy numberOfChannels; ichannel ++) {
for (long isample = 1; isample <= numberOfSamples; isample ++) {
long jsample = isample + sampleDifference;
event -> erp -> z [ichannel] [isample] = jsample < 1 || jsample > my sound -> nx ? 0.0 : my sound -> z [ichannel] [jsample];
}
}
thy points. addItem_move (event.move());
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": ERP analysis not performed.");
}
}
autoERPTier EEG_to_ERPTier_bit (EEG me, double fromTime, double toTime, int markerBit) {
try {
autoPointProcess events = TextGrid_getStartingPoints (my textgrid.get(), markerBit, kMelder_string_EQUAL_TO, U"1");
autoERPTier thee = EEG_PointProcess_to_ERPTier (me, events.get(), fromTime, toTime);
return thee;
} catch (MelderError) {
Melder_throw (me, U": ERPTier not created.");
}
}
static autoPointProcess TextGrid_getStartingPoints_multiNumeric (TextGrid me, uint16_t number) {
try {
autoPointProcess thee;
int numberOfBits = my tiers->size;
for (int ibit = 0; ibit < numberOfBits; ibit ++) {
(void) TextGrid_checkSpecifiedTierIsIntervalTier (me, ibit + 1);
if (number & (1 << ibit)) {
autoPointProcess bitEvents = TextGrid_getStartingPoints (me, ibit + 1, kMelder_string_EQUAL_TO, U"1");
if (thee) {
thee = PointProcesses_intersection (thee.get(), bitEvents.get());
} else {
thee = bitEvents.move();
}
}
}
for (int ibit = 0; ibit < numberOfBits; ibit ++) {
autoPointProcess bitEvents = TextGrid_getStartingPoints (me, ibit + 1, kMelder_string_EQUAL_TO, U"1");
if (! (number & (1 << ibit))) {
if (thee) {
thee = PointProcesses_difference (thee.get(), bitEvents.get());
} else {
thee = PointProcess_create (my xmin, my xmax, 10);
}
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": starting points not converted to PointProcess.");
}
}
autoERPTier EEG_to_ERPTier_marker (EEG me, double fromTime, double toTime, uint16_t marker) {
try {
autoPointProcess events = TextGrid_getStartingPoints_multiNumeric (my textgrid.get(), marker);
autoERPTier thee = EEG_PointProcess_to_ERPTier (me, events.get(), fromTime, toTime);
return thee;
} catch (MelderError) {
Melder_throw (me, U": ERPTier not created.");
}
}
autoERPTier EEG_to_ERPTier_triggers (EEG me, double fromTime, double toTime,
int which_Melder_STRING, const char32 *criterion)
{
try {
autoPointProcess events = TextGrid_getPoints (my textgrid.get(), 2, which_Melder_STRING, criterion);
autoERPTier thee = EEG_PointProcess_to_ERPTier (me, events.get(), fromTime, toTime);
return thee;
} catch (MelderError) {
Melder_throw (me, U": ERPTier not created.");
}
}
autoERPTier EEG_to_ERPTier_triggers_preceded (EEG me, double fromTime, double toTime,
int which_Melder_STRING, const char32 *criterion,
int which_Melder_STRING_precededBy, const char32 *criterion_precededBy)
{
try {
autoPointProcess events = TextGrid_getPoints_preceded (my textgrid.get(), 2,
which_Melder_STRING, criterion,
which_Melder_STRING_precededBy, criterion_precededBy);
autoERPTier thee = EEG_PointProcess_to_ERPTier (me, events.get(), fromTime, toTime);
return thee;
} catch (MelderError) {
Melder_throw (me, U": ERPTier not created.");
}
}
void ERPTier_subtractBaseline (ERPTier me, double tmin, double tmax) {
long numberOfEvents = my points.size;
if (numberOfEvents < 1)
return; // nothing to do
ERPPoint firstEvent = my points.at [1];
long numberOfChannels = firstEvent -> erp -> ny;
long numberOfSamples = firstEvent -> erp -> nx;
for (long ievent = 1; ievent <= numberOfEvents; ievent ++) {
ERPPoint event = my points.at [ievent];
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
double mean = Vector_getMean (event -> erp.get(), tmin, tmax, ichannel);
double *channel = event -> erp -> z [ichannel];
for (long isample = 1; isample <= numberOfSamples; isample ++) {
channel [isample] -= mean;
}
}
}
}
void ERPTier_rejectArtefacts (ERPTier me, double threshold) {
long numberOfEvents = my points.size;
if (numberOfEvents < 1)
return; // nothing to do
ERPPoint firstEvent = my points.at [1];
long numberOfChannels = firstEvent -> erp -> ny;
long numberOfSamples = firstEvent -> erp -> nx;
if (numberOfSamples < 1)
return; // nothing to do
for (long ievent = numberOfEvents; ievent >= 1; ievent --) { // cycle down because of removal
ERPPoint event = my points.at [ievent];
double minimum = event -> erp -> z [1] [1];
double maximum = minimum;
for (long ichannel = 1; ichannel <= (numberOfChannels & ~ 15); ichannel ++) {
double *channel = event -> erp -> z [ichannel];
for (long isample = 1; isample <= numberOfSamples; isample ++) {
double value = channel [isample];
if (value < minimum) minimum = value;
if (value > maximum) maximum = value;
}
}
if (minimum < - threshold || maximum > threshold) {
my points. removeItem (ievent);
}
}
}
autoERP ERPTier_extractERP (ERPTier me, long eventNumber) {
try {
long numberOfEvents = my points.size;
if (numberOfEvents < 1)
Melder_throw (U"No events.");
ERPTier_checkEventNumber (me, eventNumber);
ERPPoint event = my points.at [eventNumber];
long numberOfChannels = event -> erp -> ny;
long numberOfSamples = event -> erp -> nx;
autoERP thee = Thing_new (ERP);
event -> erp -> structSound :: v_copy (thee.get());
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
double *oldChannel = event -> erp -> z [ichannel];
double *newChannel = thy z [ichannel];
for (long isample = 1; isample <= numberOfSamples; isample ++) {
newChannel [isample] = oldChannel [isample];
}
}
thy channelNames = NUMvector (1, thy ny);
for (long ichan = 1; ichan <= thy ny; ichan ++) {
thy channelNames [ichan] = Melder_dup (my channelNames [ichan]);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": ERP not extracted.");
}
}
autoERP ERPTier_to_ERP_mean (ERPTier me) {
try {
long numberOfEvents = my points.size;
if (numberOfEvents < 1)
Melder_throw (U"No events.");
ERPPoint firstEvent = my points.at [1];
long numberOfChannels = firstEvent -> erp -> ny;
long numberOfSamples = firstEvent -> erp -> nx;
autoERP mean = Thing_new (ERP);
firstEvent -> erp -> structSound :: v_copy (mean.get());
for (long ievent = 2; ievent <= numberOfEvents; ievent ++) {
ERPPoint event = my points.at [ievent];
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
double *erpChannel = event -> erp -> z [ichannel];
double *meanChannel = mean -> z [ichannel];
for (long isample = 1; isample <= numberOfSamples; isample ++) {
meanChannel [isample] += erpChannel [isample];
}
}
}
double factor = 1.0 / numberOfEvents;
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
double *meanChannel = mean -> z [ichannel];
for (long isample = 1; isample <= numberOfSamples; isample ++) {
meanChannel [isample] *= factor;
}
}
mean -> channelNames = NUMvector (1, mean -> ny);
for (long ichan = 1; ichan <= mean -> ny; ichan ++) {
mean -> channelNames [ichan] = Melder_dup (my channelNames [ichan]);
}
return mean;
} catch (MelderError) {
Melder_throw (me, U": mean not computed.");
}
}
autoERPTier ERPTier_extractEventsWhereColumn_number (ERPTier me, Table table, long columnNumber, int which_Melder_NUMBER, double criterion) {
try {
Table_checkSpecifiedColumnNumberWithinRange (table, columnNumber);
Table_numericize_Assert (table, columnNumber); // extraction should work even if cells are not defined
if (my points.size != table -> rows.size)
Melder_throw (me, U" & ", table, U": the number of rows in the table (", table -> rows.size,
U") doesn't match the number of events (", my points.size, U").");
autoERPTier thee = Thing_new (ERPTier);
Function_init (thee.get(), my xmin, my xmax);
thy numberOfChannels = my numberOfChannels;
thy channelNames = NUMvector (1, thy numberOfChannels);
for (long ichan = 1; ichan <= thy numberOfChannels; ichan ++) {
thy channelNames [ichan] = Melder_dup (my channelNames [ichan]);
}
for (long ievent = 1; ievent <= my points.size; ievent ++) {
ERPPoint oldEvent = my points.at [ievent];
TableRow row = table -> rows.at [ievent];
if (Melder_numberMatchesCriterion (row -> cells [columnNumber]. number, which_Melder_NUMBER, criterion)) {
autoERPPoint newEvent = Data_copy (oldEvent);
thy points. addItem_move (newEvent.move());
}
}
if (thy points.size == 0) {
Melder_warning (U"No event matches criterion.");
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": events not extracted.");
}
}
autoERPTier ERPTier_extractEventsWhereColumn_string (ERPTier me, Table table,
long columnNumber, int which_Melder_STRING, const char32 *criterion)
{
try {
Table_checkSpecifiedColumnNumberWithinRange (table, columnNumber);
if (my points.size != table -> rows.size)
Melder_throw (me, U" & ", table, U": the number of rows in the table (", table -> rows.size,
U") doesn't match the number of events (", my points.size, U").");
autoERPTier thee = Thing_new (ERPTier);
Function_init (thee.get(), my xmin, my xmax);
thy numberOfChannels = my numberOfChannels;
thy channelNames = NUMvector (1, thy numberOfChannels);
for (long ichan = 1; ichan <= thy numberOfChannels; ichan ++) {
thy channelNames [ichan] = Melder_dup (my channelNames [ichan]);
}
for (long ievent = 1; ievent <= my points.size; ievent ++) {
ERPPoint oldEvent = my points.at [ievent];
TableRow row = table -> rows.at [ievent];
if (Melder_stringMatchesCriterion (row -> cells [columnNumber]. string, which_Melder_STRING, criterion)) {
autoERPPoint newEvent = Data_copy (oldEvent);
thy points. addItem_move (newEvent.move());
}
}
if (thy points.size == 0) {
Melder_warning (U"No event matches criterion.");
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": events not extracted.");
}
}
/* End of file ERPTier.cpp */
praat-6.0.23/EEG/ERPTier.h 0000664 0000000 0000000 00000004732 13023464014 0014737 0 ustar 00root root 0000000 0000000 #ifndef _ERPTier_h_
#define _ERPTier_h_
/* ERPTier.h
*
* Copyright (C) 2011,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "EEG.h"
#include "ERP.h"
#include "ERPTier_def.h"
long ERPTier_getChannelNumber (ERPTier me, const char32 *channelName);
static inline void ERPTier_checkEventNumber (ERPTier me, long eventNumber) {
if (eventNumber < 1)
Melder_throw (U"The specified event number is ", eventNumber, U" but should have been positive.");
if (eventNumber > my points.size)
Melder_throw (U"The specified event number (", eventNumber, U") exceeds the number of events (", my points.size, U").");
}
double ERPTier_getMean (ERPTier me, long pointNumber, long channelNumber, double tmin, double tmax);
double ERPTier_getMean (ERPTier me, long pointNumber, const char32 *channelName, double tmin, double tmax);
void ERPTier_subtractBaseline (ERPTier me, double tmin, double tmax);
void ERPTier_rejectArtefacts (ERPTier me, double threshold);
autoERP ERPTier_extractERP (ERPTier me, long pointNumber);
autoERP ERPTier_to_ERP_mean (ERPTier me);
autoERPTier ERPTier_extractEventsWhereColumn_number (ERPTier me, Table table, long columnNumber, int which_Melder_NUMBER, double criterion);
autoERPTier ERPTier_extractEventsWhereColumn_string (ERPTier me, Table table, long columnNumber, int which_Melder_STRING, const char32 *criterion);
autoERPTier EEG_to_ERPTier_bit (EEG me, double fromTime, double toTime, int markerBit);
autoERPTier EEG_to_ERPTier_marker (EEG me, double fromTime, double toTime, uint16 marker);
autoERPTier EEG_to_ERPTier_triggers (EEG me, double fromTime, double toTime,
int which_Melder_STRING, const char32 *criterion);
autoERPTier EEG_to_ERPTier_triggers_preceded (EEG me, double fromTime, double toTime,
int which_Melder_STRING, const char32 *criterion,
int which_Melder_STRING_precededBy, const char32 *criterion_precededBy);
/* End of file ERPTier.h */
#endif
praat-6.0.23/EEG/ERPTier_def.h 0000664 0000000 0000000 00000002341 13023464014 0015547 0 ustar 00root root 0000000 0000000 /* ERPTier_def.h
*
* Copyright (C) 2011,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT ERPPoint
oo_DEFINE_CLASS (ERPPoint, AnyPoint)
oo_AUTO_OBJECT (Sound, 2, erp)
oo_END_CLASS (ERPPoint)
#undef ooSTRUCT
#define ooSTRUCT ERPTier
oo_DEFINE_CLASS (ERPTier, Function)
oo_COLLECTION_OF (SortedSetOfDoubleOf, points, ERPPoint, 0)
oo_LONG (numberOfChannels)
oo_STRING_VECTOR (channelNames, numberOfChannels)
#if oo_DECLARING
AnyTier_METHODS
int v_domainQuantity ()
override { return MelderQuantity_TIME_SECONDS; }
#endif
oo_END_CLASS (ERPTier)
#undef ooSTRUCT
/* End of file ERPTier_def.h */
praat-6.0.23/EEG/ERPWindow.cpp 0000664 0000000 0000000 00000036304 13023464014 0015636 0 ustar 00root root 0000000 0000000 /* ERPWindow.cpp
*
* Copyright (C) 2012,2013,2014,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "ERPWindow.h"
#include "EditorM.h"
#include "Preferences.h"
Thing_implement (ERPWindow, SoundEditor, 0);
#include "prefs_define.h"
#include "ERPWindow_prefs.h"
#include "prefs_install.h"
#include "ERPWindow_prefs.h"
#include "prefs_copyToInstance.h"
#include "ERPWindow_prefs.h"
typedef struct { int inclination, azimuth; double topX, topY; } BiosemiLocationData;
static BiosemiLocationData biosemiCapCoordinates64 [1+64] =
{
/*
* BioSemi says:
* "Spherical coordinates in degrees,
* by inclination (from Cz, pos is right hemisphere, neg is left hemisphere),
* and azimuth (from T7 for left hemisphere, and from T8 for the right hemisphere, pos is anti-clockwise, neg is clockwise)"
*/
{0,0},
{ -92, -72 }, // 1 Fp1
{ -92, -54 }, // 2 AF7
{ -74, -65 }, // 3 AF3
{ -50, -68 }, // 4 F1
{ -60, -51 }, // 5 F3
{ -75, -41 }, // 6 F5
{ -92, -36 }, // 7 F7
{ -92, -18 }, // 8 FT7
{ -72, -21 }, // 9 FC5
{ -50, -28 }, // 10 FC3
{ -32, -45 }, // 11 FC1
{ -23, 0 }, // 12 C1
{ -46, 0 }, // 13 C3
{ -69, 0 }, // 14 C5
{ -92, 0 }, // 15 T7
{ -92, 18 }, // 16 TP7
{ -72, 21 }, // 17 CP5
{ -50, 28 }, // 18 CP3
{ -32, 45 }, // 19 CP1
{ -50, 68 }, // 20 P1
{ -60, 51 }, // 21 P3
{ -75, 41 }, // 22 P5
{ -92, 36 }, // 23 P7
{-115, 40 }, // 24 P9
{ -92, 54 }, // 25 PO7
{ -74, 65 }, // 26 PO3
{ -92, 72 }, // 27 O1
{ 115, -90 }, // 28 Iz
{ 92, -90 }, // 29 Oz
{ 69, -90 }, // 30 POz
{ 46, -90 }, // 31 Pz
{ 23, -90 }, // 32 CPz
{ 92, 90 }, // 33 Fpz
{ 92, 72 }, // 34 Fp2
{ 92, 54 }, // 35 AF8
{ 74, 65 }, // 36 AF4
{ 69, 90 }, // 37 AFz
{ 46, 90 }, // 38 Fz
{ 50, 68 }, // 39 F2
{ 60, 51 }, // 40 F4
{ 75, 41 }, // 41 F6
{ 92, 36 }, // 42 F8
{ 92, 18 }, // 43 FT8
{ 72, 21 }, // 44 FC6
{ 50, 28 }, // 45 FC4
{ 32, 45 }, // 46 FC2
{ 23, 90 }, // 47 FCz
{ 0, 0 }, // 48 Cz
{ 23, 0 }, // 49 C2
{ 46, 0 }, // 50 C4
{ 69, 0 }, // 51 C6
{ 92, 0 }, // 52 T8
{ 92, -18 }, // 53 TP8
{ 72, -21 }, // 54 CP6
{ 50, -28 }, // 55 CP4
{ 32, -45 }, // 56 CP2
{ 50, -68 }, // 57 P2
{ 60, -51 }, // 58 P4
{ 75, -41 }, // 59 P6
{ 92, -36 }, // 60 P8
{ 115, -40 }, // 61 P10
{ 92, -54 }, // 62 PO8
{ 74, -65 }, // 63 PO4
{ 92, -72 } // 64 O2
};
static BiosemiLocationData biosemiCapCoordinates32 [1+32] =
{
/*
* BioSemi says:
* "Spherical coordinates in degrees,
* by inclination (from Cz, pos is right hemisphere, neg is left hemisphere),
* and azimuth (from T7 for left hemisphere, and from T8 for the right hemisphere, pos is anti-clockwise, neg is clockwise)"
*/
{0,0},
{ -92, -72 }, // 1 Fp1
{ -74, -65 }, // 2 AF3
{ -92, -36 }, // 3 F7
{ -60, -51 }, // 4 F3
{ -32, -45 }, // 5 FC1
{ -72, -21 }, // 6 FC5
{ -92, 0 }, // 7 T7
{ -46, 0 }, // 8 C3
{ -32, 45 }, // 9 CP1
{ -72, 21 }, // 10 CP5
{ -92, 36 }, // 11 P7
{ -60, 51 }, // 12 P3
{ 46, -90 }, // 13 Pz
{ -74, 65 }, // 14 PO3
{ -92, 72 }, // 15 O1
{ 92, -90 }, // 16 Oz
{ 92, -72 }, // 17 O2
{ 74, -65 }, // 18 PO4
{ 60, -51 }, // 19 P4
{ 92, -36 }, // 20 P8
{ 72, -21 }, // 21 CP6
{ 32, -45 }, // 22 CP2
{ 46, 0 }, // 23 C4
{ 92, 0 }, // 24 T8
{ 72, 21 }, // 25 FC6
{ 32, 45 }, // 26 FC2
{ 60, 51 }, // 27 F4
{ 92, 36 }, // 28 F8
{ 74, 65 }, // 29 AF4
{ 92, 72 }, // 30 Fp2
{ 46, 90 }, // 31 Fz
{ 0, 0 }, // 32 Cz
};
void ERP_drawScalp_garnish (Graphics graphics, double vmin, double vmax, enum kGraphics_colourScale colourScale) {
long n = 201;
autoNUMmatrix legend (1, n, 1, 2);
for (long irow = 1; irow <= n; irow ++) {
for (long icol = 1; icol <= 2; icol ++) {
legend [irow] [icol] = (irow - 1) / (n - 1.0);
}
}
Graphics_setColourScale (graphics, colourScale);
Graphics_image (graphics, legend.peek(), 1, 2, 0.85, 0.98, 1, n, -0.8, +0.8, 0.0, 1.0);
Graphics_setColourScale (graphics, kGraphics_colourScale_GREY);
Graphics_rectangle (graphics, 0.85, 0.98, -0.8, +0.8);
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_TOP);
Graphics_text (graphics, 1.0, -0.8, vmin * 1e6, U" μV");
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_BOTTOM);
Graphics_text (graphics, 1.0, +0.8, vmax * 1e6, U" μV");
}
void ERP_drawScalp (ERP me, Graphics graphics, double tmin, double tmax, double vmin, double vmax, enum kGraphics_colourScale colourScale, bool garnish) {
Graphics_setInner (graphics);
Graphics_setWindow (graphics, -1.0, 1.0, -1.0, 1.0);
//Graphics_setGrey (graphics, 1.0);
//Graphics_fillRectangle (graphics, -1.1, 1.1, -1.01, 1.19);
//Graphics_setColour (graphics, Graphics_BLACK);
long numberOfDrawableChannels =
my ny >= 64 && Melder_equ (my channelNames [64], U"O2") ? 64 :
my ny >= 32 && Melder_equ (my channelNames [32], U"Cz") ? 32 :
0;
BiosemiLocationData *biosemiLocationData = numberOfDrawableChannels == 64 ? biosemiCapCoordinates64 : numberOfDrawableChannels == 32 ? biosemiCapCoordinates32 : 0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double inclination = (double) biosemiLocationData [ichan]. inclination;
double azimuth = (double) biosemiLocationData [ichan]. azimuth;
bool rightHemisphere = inclination >= 0.0;
double r = fabs (inclination / 115.0);
double theta = rightHemisphere ? azimuth * (NUMpi / 180.0) : (azimuth + 180.0) * (NUMpi / 180.0);
biosemiLocationData [ichan]. topX = r * cos (theta);
biosemiLocationData [ichan]. topY = r * sin (theta);
}
long n = 201;
double d = 2.0 / (n - 1);
autoNUMvector mean (1, numberOfDrawableChannels);
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
mean [ichan] = tmin == tmax ?
Sampled_getValueAtX (me, tmin, ichan, 0, true) :
Vector_getMean (me, tmin, tmax, ichan);
}
autoNUMmatrix image (1, n, 1, n);
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y <= 1.0) {
double value = NUMundefined, sum = 0.0, weight = 0.0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double dx = x - biosemiLocationData [ichan]. topX;
double dy = y - biosemiLocationData [ichan]. topY;
double distance = sqrt (dx * dx + dy * dy);
if (distance < 1e-12) {
value = mean [ichan];
break;
}
distance = distance * distance * distance * distance * distance * distance;
sum += mean [ichan] / distance;
weight += 1.0 / distance;
}
if (value == NUMundefined)
value = ( sum == 0.0 ? 0.0 : sum / weight );
image [irow] [icol] = value;
}
}
}
double whiteValue = colourScale == kGraphics_colourScale_BLUE_TO_RED ? 0.5 * (vmin + vmax) : vmin;
Graphics_setColourScale (graphics, colourScale);
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y > 1.0) {
image [irow] [icol] = whiteValue;
}
}
}
Graphics_image (graphics, image.peek(), 1, n, -1.0-0.5/n, 1.0+0.5/n, 1, n, -1.0-0.5/n, 1.0+0.5/n, vmin, vmax);
Graphics_setColourScale (graphics, kGraphics_colourScale_GREY);
Graphics_setLineWidth (graphics, 2.0);
/*
* Nose.
*/
Graphics_setGrey (graphics, colourScale == kGraphics_colourScale_BLUE_TO_RED ? 1.0 : 0.5);
{// scope
double x [3] = { -0.08, 0.0, 0.08 }, y [3] = { 0.99, 1.18, 0.99 };
Graphics_fillArea (graphics, 3, x, y);
}
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_line (graphics, -0.08, 0.99, 0.0, 1.18);
Graphics_line (graphics, 0.08, 0.99, 0.0, 1.18);
/*
* Ears.
*/
Graphics_setGrey (graphics, colourScale == kGraphics_colourScale_BLUE_TO_RED ? 1.0 : 0.5);
Graphics_fillRectangle (graphics, -1.09, -1.00, -0.08, 0.08);
Graphics_fillRectangle (graphics, 1.09, 1.00, -0.08, 0.08);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_line (graphics, -0.99, 0.08, -1.09, 0.08);
Graphics_line (graphics, -1.09, 0.08, -1.09, -0.08);
Graphics_line (graphics, -1.09, -0.08, -0.99, -0.08);
Graphics_line (graphics, 0.99, 0.08, 1.09, 0.08);
Graphics_line (graphics, 1.09, 0.08, 1.09, -0.08);
Graphics_line (graphics, 1.09, -0.08, 0.99, -0.08);
/*
* Scalp.
*/
Graphics_ellipse (graphics, -1.0, 1.0, -1.0, 1.0);
Graphics_setLineWidth (graphics, 1.0);
Graphics_unsetInner (graphics);
if (garnish) {
ERP_drawScalp_garnish (graphics, vmin, vmax, colourScale);
}
}
void structERPWindow :: v_drawSelectionViewer () {
ERP erp = (ERP) data;
Graphics_setWindow (d_graphics.get(), -1.1, 1.1, -1.01, 1.19);
Graphics_setColour (d_graphics.get(), Graphics_WINDOW_BACKGROUND_COLOUR);
Graphics_fillRectangle (d_graphics.get(), -1.1, 1.1, -1.01, 1.19);
Graphics_setColour (d_graphics.get(), Graphics_BLACK);
long numberOfDrawableChannels =
erp -> ny >= 64 && Melder_equ (erp -> channelNames [64], U"O2") ? 64 :
erp -> ny >= 32 && Melder_equ (erp -> channelNames [32], U"Cz") ? 32 :
0;
BiosemiLocationData *biosemiLocationData = numberOfDrawableChannels == 64 ? biosemiCapCoordinates64 : numberOfDrawableChannels == 32 ? biosemiCapCoordinates32 : 0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double inclination = (double) biosemiLocationData [ichan]. inclination;
double azimuth = (double) biosemiLocationData [ichan]. azimuth;
bool rightHemisphere = inclination >= 0.0;
double r = fabs (inclination / 115.0);
double theta = rightHemisphere ? azimuth * (NUMpi / 180.0) : (azimuth + 180.0) * (NUMpi / 180.0);
biosemiLocationData [ichan]. topX = r * cos (theta);
biosemiLocationData [ichan]. topY = r * sin (theta);
}
long n = 201;
double d = 2.0 / (n - 1);
autoNUMvector means (1, numberOfDrawableChannels);
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
means [ichan] =
d_startSelection == d_endSelection ?
Sampled_getValueAtX (erp, d_startSelection, ichan, 0, true) :
Vector_getMean (erp, d_startSelection, d_endSelection, ichan);
}
autoNUMmatrix image (1, n, 1, n);
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y <= 1.0) {
double value = NUMundefined, sum = 0.0, weight = 0.0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double dx = x - biosemiLocationData [ichan]. topX;
double dy = y - biosemiLocationData [ichan]. topY;
double distance = sqrt (dx * dx + dy * dy);
if (distance < 1e-12) {
value = means [ichan];
break;
}
distance = distance * distance * distance * distance * distance * distance;
sum += means [ichan] / distance;
weight += 1.0 / distance;
}
if (value == NUMundefined)
value = ( sum == 0.0 ? 0.0 : sum / weight );
image [irow] [icol] = value;
}
}
}
double minimum = 0.0, maximum = 0.0;
for (long irow = 1; irow <= n; irow ++) {
for (long icol = 1; icol <= n; icol ++) {
double value = image [irow] [icol];
if (value < minimum) minimum = value;
else if (value > maximum) maximum = value;
}
}
double absoluteExtremum = - minimum > maximum ? - minimum : maximum;
if (p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_RANGE) {
minimum = p_sound_scaling_minimum;
maximum = p_sound_scaling_maximum;
} else if (p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_HEIGHT) {
double mean = 0.5 * (minimum + maximum);
minimum = mean - 0.5 * p_sound_scaling_height;
maximum = mean + 0.5 * p_sound_scaling_height;
} else {
minimum = - absoluteExtremum;
maximum = absoluteExtremum;
}
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y > 1.0) {
image [irow] [icol] = minimum +
( our p_scalp_colourScale == kGraphics_colourScale_BLUE_TO_RED ? 0.46 : 0.1875 ) * (maximum - minimum);
// -0.625 * absoluteExtremum;
}
}
}
Graphics_setColourScale (our d_graphics.get(), our p_scalp_colourScale);
Graphics_image (our d_graphics.get(), image.peek(), 1, n, -1.0-0.5/n, 1.0+0.5/n, 1, n, -1.0-0.5/n, 1.0+0.5/n, minimum, maximum);
Graphics_setColourScale (our d_graphics.get(), kGraphics_colourScale_GREY);
Graphics_setLineWidth (our d_graphics.get(), 2.0);
/*
* Nose.
*/
Graphics_setGrey (our d_graphics.get(), our p_scalp_colourScale == kGraphics_colourScale_BLUE_TO_RED ? 1.0 : 0.5);
{// scope
double x [3] = { -0.08, 0.0, 0.08 }, y [3] = { 0.99, 1.18, 0.99 };
Graphics_fillArea (our d_graphics.get(), 3, x, y);
}
Graphics_setColour (our d_graphics.get(), Graphics_BLACK);
Graphics_line (our d_graphics.get(), -0.08, 0.99, 0.0, 1.18);
Graphics_line (our d_graphics.get(), 0.08, 0.99, 0.0, 1.18);
/*
* Ears.
*/
Graphics_setGrey (our d_graphics.get(), our p_scalp_colourScale == kGraphics_colourScale_BLUE_TO_RED ? 1.0 : 0.5);
Graphics_fillRectangle (our d_graphics.get(), -1.09, -1.00, -0.08, 0.08);
Graphics_fillRectangle (our d_graphics.get(), 1.09, 1.00, -0.08, 0.08);
Graphics_setColour (our d_graphics.get(), Graphics_BLACK);
Graphics_line (our d_graphics.get(), -0.99, 0.08, -1.09, 0.08);
Graphics_line (our d_graphics.get(), -1.09, 0.08, -1.09, -0.08);
Graphics_line (our d_graphics.get(), -1.09, -0.08, -0.99, -0.08);
Graphics_line (our d_graphics.get(), 0.99, 0.08, 1.09, 0.08);
Graphics_line (our d_graphics.get(), 1.09, 0.08, 1.09, -0.08);
Graphics_line (our d_graphics.get(), 1.09, -0.08, 0.99, -0.08);
/*
* Scalp.
*/
Graphics_ellipse (our d_graphics.get(), -1.0, 1.0, -1.0, 1.0);
Graphics_setLineWidth (our d_graphics.get(), 1.0);
}
void structERPWindow :: v_prefs_addFields (EditorCommand cmd) {
UiField radio;
OPTIONMENU_ENUM (U"Scalp colour space", kGraphics_colourScale, kGraphics_colourScale_BLUE_TO_RED)
}
void structERPWindow :: v_prefs_setValues (EditorCommand cmd) {
SET_ENUM (U"Scalp colour space", kGraphics_colourScale, p_scalp_colourScale)
}
void structERPWindow :: v_prefs_getValues (EditorCommand cmd) {
pref_scalp_colourScale () = p_scalp_colourScale = GET_ENUM (kGraphics_colourScale, U"Scalp colour space");
FunctionEditor_redraw (this);
}
autoERPWindow ERPWindow_create (const char32 *title, ERP data) {
Melder_assert (data);
try {
autoERPWindow me = Thing_new (ERPWindow);
SoundEditor_init (me.get(), title, data);
return me;
} catch (MelderError) {
Melder_throw (U"ERP window not created.");
}
}
/* End of file ERPWindow.cpp */
praat-6.0.23/EEG/ERPWindow.h 0000664 0000000 0000000 00000003036 13023464014 0015277 0 ustar 00root root 0000000 0000000 #ifndef _ERPWindow_h_
#define _ERPWindow_h_
/* ERPWindow.h
*
* Copyright (C) 2012,2013,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "SoundEditor.h"
#include "ERP.h"
Thing_define (ERPWindow, SoundEditor) {
const char32 * v_getChannelName (long channelNumber)
override {
ERP erp = (ERP) our data;
return erp -> channelNames [channelNumber];
}
void v_drawSelectionViewer ()
override;
bool v_hasPitch ()
override { return false; }
bool v_hasIntensity ()
override { return false; }
bool v_hasFormants ()
override { return false; }
bool v_hasPulses ()
override { return false; }
void v_prefs_addFields (EditorCommand cmd)
override;
void v_prefs_setValues (EditorCommand cmd)
override;
void v_prefs_getValues (EditorCommand cmd)
override;
#include "ERPWindow_prefs.h"
};
/**
Create an ERPWindow.
*/
autoERPWindow ERPWindow_create (const char32 *title, ERP data);
/* End of file ERPWindow.h */
#endif
praat-6.0.23/EEG/ERPWindow_prefs.h 0000664 0000000 0000000 00000005242 13023464014 0016477 0 ustar 00root root 0000000 0000000 /* ERPWindow_prefs.h
*
* Copyright (C) 2013,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
prefs_begin (ERPWindow)
prefs_override_bool (ERPWindow, showSelectionViewer, 1, true)
prefs_override_enum (ERPWindow, sound_scalingStrategy, 1, kTimeSoundEditor_scalingStrategy, DEFAULT)
prefs_override_double (ERPWindow, sound_scaling_height, 1, U"20e-6")
prefs_override_double (ERPWindow, sound_scaling_minimum, 1, U"-10e-6")
prefs_override_double (ERPWindow, sound_scaling_maximum, 1, U"10e-6")
prefs_override_double (ERPWindow, picture_bottom, 1, U"0.0")
prefs_override_double (ERPWindow, picture_top, 1, U"0.0 (= auto)")
prefs_override_bool (ERPWindow, spectrogram_show, 1, false);
prefs_override_double (ERPWindow, spectrogram_viewFrom, 1, U"0.0") // Hz
prefs_override_double (ERPWindow, spectrogram_viewTo, 1, U"60.0") // Hz
prefs_override_double (ERPWindow, spectrogram_windowLength, 1, U"0.5") // seconds
prefs_override_double (ERPWindow, spectrogram_dynamicRange, 1, U"40.0") // dB
prefs_override_long (ERPWindow, spectrogram_timeSteps, 1, U"1000")
prefs_override_long (ERPWindow, spectrogram_frequencySteps, 1, U"250")
prefs_override_enum (ERPWindow, spectrogram_method, 1, kSound_to_Spectrogram_method, DEFAULT)
prefs_override_enum (ERPWindow, spectrogram_windowShape, 1, kSound_to_Spectrogram_windowShape, DEFAULT)
prefs_override_bool (ERPWindow, spectrogram_autoscaling, 1, true)
prefs_override_double (ERPWindow, spectrogram_maximum, 1, U"100.0") // dB/Hz
prefs_override_double (ERPWindow, spectrogram_preemphasis, 1, U"0.0") // dB/octave
prefs_override_double (ERPWindow, spectrogram_dynamicCompression, 1, U"0.0")
prefs_override_bool (ERPWindow, spectrogram_picture_garnish, 1, true)
prefs_add_enum_with_data (ERPWindow, scalp_colourScale, 1, kGraphics_colourScale, BLUE_TO_RED)
prefs_end (ERPWindow)
/* End of file ERPWindow_prefs.h */
praat-6.0.23/EEG/ERP_def.h 0000664 0000000 0000000 00000001540 13023464014 0014723 0 ustar 00root root 0000000 0000000 /* ERP_def.h
*
* Copyright (C) 2011-2012,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT ERP
oo_DEFINE_CLASS (ERP, Sound)
oo_STRING_VECTOR (channelNames, ny)
oo_END_CLASS (ERP)
#undef ooSTRUCT
/* End of file ERP_def.h */
praat-6.0.23/EEG/Makefile 0000664 0000000 0000000 00000001072 13023464014 0014746 0 ustar 00root root 0000000 0000000 # Makefile of the library "EEG"
# Paul Boersma, 24 August 2013
include ../makefile.defs
CPPFLAGS = -I ../num -I ../kar -I ../sys -I ../dwsys -I ../stat -I ../dwtools -I ../fon
OBJECTS = EEG.o EEGWindow.o ERPTier.o ERP.o ERPWindow.o \
praat_EEG.o manual_EEG.o
.PHONY: all clean
all: libEEG.a
clean:
$(RM) $(OBJECTS)
$(RM) libEEG.a
libEEG.a: $(OBJECTS)
touch libEEG.a
rm libEEG.a
$(AR) cq libEEG.a $(OBJECTS)
$(RANLIB) libEEG.a
$(OBJECTS): *.h ../num/NUM.h ../kar/*.h ../sys/*.h ../dwsys/*.h ../stat/*.h ../dwtools/*.h ../fon/*.h
praat-6.0.23/EEG/manual_EEG.cpp 0000664 0000000 0000000 00000016100 13023464014 0015745 0 ustar 00root root 0000000 0000000 /* manual_EEG.cpp
*
* Copyright (C) 2012,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "ManPagesM.h"
void manual_EEG_init (ManPages me);
void manual_EEG_init (ManPages me) {
MAN_BEGIN (U"EEG", U"ppgb", 20120511)
INTRO (U"EEG means electro-encephalography: brain potentials recorded via e.g. 32 or 64 electrodes on the scalp. "
"In Praat, an EEG object looks like a combination of a Sound object with e.g. 32 or 64 channels "
"and a TextGrid object that marks the events.")
ENTRY (U"1. How to get an EEG object in Praat")
NORMAL (U"You typically create an EEG object in Praat by opening a BDF/EDF file with @@Read from file...@. "
"Praat tries to read the whole file into memory, so you may want to work with a 64-bit edition of Praat "
"if you want to avoid \"out of memory\" messages.")
NORMAL (U"After you do ##Read from file...#, an EEG object will appear in the list of objects.")
ENTRY (U"2. How to look into an EEG object")
NORMAL (U"Once you have an EEG object in the list, you can click ##View & Edit# to look into it. "
"You will typically see the first 8 channels, but you scroll to the other channels by clicking on the up and down arrows. "
"You can scroll and zoom in the same way as in a Sound window.")
NORMAL (U"The channel names that you see are often A1, A2, ... A32, B1, B2, ... B32, C1, C2, ... C32, and so on. These represent the cap electrodes. "
"If the number of cap electrodes is 32, though, the channel names are Fp1, AF3, ... Cz, "
"and if it is 64, the channel names are Fp1, AF7, ... O2. You can change these names with "
"##Set channel name...# from the #Modify menu.")
NORMAL (U"Below the cap electrodes you may see a number of channels for the external electrodes. "
"These are typically named EXG1, EXG2, ... EXG8, but you can change these names with ##Edit external electrode names...# "
"from the #Modify menu.")
NORMAL (U"Below the external electrodes you may see a number of special channels, "
"perhaps named GSR1, GSR2, Erg1, Erg2, Resp, Plet, Temp, and Status. "
"These represent recordings from other sensors than the electrodes.")
NORMAL (U"The Status channel is special. It is the 8-bit digital signal that you fed to your EEG apparatus. "
"When reading the BDF file, Praat extracts all 8 bits from this status signal, "
"and these 8 bits are shown in the EEG window as TextGrid interval tiers named S1, S2, ... S8. "
"These bits are the place to mark events. For instance, in our lab we use S8 to mark any event, "
"S5 to mark a \"standard\" event, and S4 to mark a \"deviant\" event.")
ENTRY (U"3. What to do to an EEG object")
NORMAL (U"The raw EEG signal that you have read from a file is typically quite noisy and may have a very large "
"DC (direct-current) component as compared to the small vibrations that you are interested in. "
"There are several ways to clean it up.")
NORMAL (U"##Subtracting a reference signal.# The voltage on the whole scalp may rise and fall in time. "
"You are unlikely to be interested in these global movements; instead, you are likely to be interested only "
"in the voltage movements on the brain-influenced part of the scalp (the cap electrodes) "
"with respect to the voltage movements on the non-brain-influenced part of the scalp (the external electrodes). "
"If you have external electrode recordings that include the left and right mastoids, you can use these channels as a %%reference signal%, i.e., "
"you can use ##Subtract reference...# to subtract the average of the two mastoid channels from all electrode channels (including the external electrodes themselves). "
"If you have no such recordings, you can still regard the average of a range of electrode channels as a reference signal, "
"and use ##Subtract mean channel...# to subtract this from each electrode channel.")
NORMAL (U"##Detrending.# With #Detrend, you subtract from each electrode channel a line in such a way that the first sample and the last sample become zero. "
"Detrending and reference subtraction can be performed in either order.")
NORMAL (U"##Filtering.# With ##Filter...#, you band-pass filter each electrode channel. Filtering has to be done after detrending, but "
"filtering and reference subtraction can be performed in either order.")
ENTRY (U"4. How to do an ERP analysis")
NORMAL (U"An ERP is an Event-Related Potential. Events are marked somewhere in S1, S2, ... S8. In the above example, "
"we extract all the \"deviant\" events by doing ##To ERPTier...#, setting ##From time# to -0.11 seconds, "
"##To Time# to 0.39 seconds, and ##Marker bit# to 4. This way, an ERPTier object appears in the list, containing "
"the parts of the EEG signal that lie in a time window of [-0.11, 0.39] seconds around each event on the S4 (deviant) tier. "
"Thus, if S4 contains 150 events, the resulting ERPTier will contain 150 pieces of the original EEG signal (without the extra sensors).")
NORMAL (U"You are typically interested in the part of each ERP in the ERPTier after the event. "
"That is, you are probably interested in how this part compares to the part not influenced by the event, "
"i.e. the part before the event. To make this comparison easier, you can do ##Subtract baseline...#: "
"the waveform of the ERP will be moved up or down in such a way that the average amplitude of the part between the specified times becomes zero; "
"the times you will typically fill in here are the starting time of the ERP (a negative number) and the time of the event (0.0).")
NORMAL (U"After you subtract the baseline, the part after the event contains the interesting part of the ERP: "
"even its sign (positive or negative) is meaningful now. Some ERPs, however, will contain very large positive or negative peaks "
"because of eye movements and other disturbing signals. To remove those ERPs from the ERPTier, "
"do ##Reject artefacts...#, while specifying the amount by which you allow the amplitude of an ERP to go above or below zero.")
NORMAL (U"Once you have an ERPTier, you can extract each of the 150 ERPs from it with ##Extract ERP...#. "
"It is perhaps more interesting to compute the average of all those 150 ERPs with ##To ERP (mean)#. "
"These commands put a new ERP object in the list.")
NORMAL (U"Once you have an ERP object, you can look into it with ##View & Edit#. "
"If you want to see in the ERP window the scalp distribution at the time of the cursor, or the average scalp distribution in the selected time stretch, "
"you have to switch on ##Show selection viewer# in the #Preferences window (available from the #File menu).")
MAN_END
}
/* End of file manual_EEG.cpp */
praat-6.0.23/EEG/praat_EEG.cpp 0000664 0000000 0000000 00000074642 13023464014 0015616 0 ustar 00root root 0000000 0000000 /* praat_EEG.cpp
*
* Copyright (C) 2011-2012,2013,2014,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "EEGWindow.h"
#include "ERPWindow.h"
#include "ERPTier.h"
#include "SpectrumEditor.h"
#include "praat_TimeTier.h"
// MARK: - EEG
// MARK: Help
DIRECT (HELP_EEG_help) {
HELP (U"EEG")
}
// MARK: View & Edit
static void cb_EEGWindow_publication (Editor /* editor */, autoDaata publication) {
/*
* Keep the gate for error handling.
*/
try {
bool isaSpectralSlice = Thing_isa (publication.get(), classSpectrum) && str32equ (Thing_getName (publication.get()), U"slice");
praat_new (publication.move());
praat_updateSelection ();
if (isaSpectralSlice) {
int IOBJECT;
LOOP {
iam_LOOP (Spectrum);
autoSpectrumEditor editor2 = SpectrumEditor_create (ID_AND_FULL_NAME, me);
praat_installEditor (editor2.get(), IOBJECT);
editor2.releaseToUser();
}
}
} catch (MelderError) {
Melder_flushError ();
}
}
DIRECT (WINDOW_EEG_viewAndEdit) {
if (theCurrentPraatApplication -> batch) Melder_throw (U"Cannot view or edit an EEG from batch.");
LOOP {
iam_LOOP (EEG);
autoEEGWindow editor = EEGWindow_create (ID_AND_FULL_NAME, me);
Editor_setPublicationCallback (editor.get(), cb_EEGWindow_publication);
praat_installEditor (editor.get(), IOBJECT);
editor.releaseToUser();
}
END }
// MARK: Query
FORM (STRING_EEG_getChannelName, U"Get channel name", nullptr) {
NATURALVAR (channelNumber, U"Channel number", U"1")
OK
DO
STRING_ONE (EEG)
if (channelNumber > my numberOfChannels)
Melder_throw (me, U": there are only ", my numberOfChannels, U" channels.");
const char32 *result = my channelNames [channelNumber];
STRING_ONE_END
}
FORM (INTEGER_EEG_getChannelNumber, U"Get channel number", nullptr) {
WORDVAR (channelName, U"Channel name", U"Cz")
OK
DO
NUMBER_ONE (EEG)
long result = EEG_getChannelNumber (me, channelName);
NUMBER_ONE_END (U"")
}
// MARK: Modify
DIRECT (MODIFY_EEG_detrend) {
MODIFY_EACH (EEG)
EEG_detrend (me);
MODIFY_EACH_END
}
FORM (MODIFY_EEG_editExternalElectrodeNames, U"Edit external electrode names", nullptr) {
WORD4 (externalElectrode1, U"External electrode 1", U"EXG1")
WORD4 (externalElectrode2, U"External electrode 2", U"EXG2")
WORD4 (externalElectrode3, U"External electrode 3", U"EXG3")
WORD4 (externalElectrode4, U"External electrode 4", U"EXG4")
WORD4 (externalElectrode5, U"External electrode 5", U"EXG5")
WORD4 (externalElectrode6, U"External electrode 6", U"EXG6")
WORD4 (externalElectrode7, U"External electrode 7", U"EXG7")
WORD4 (externalElectrode8, U"External electrode 8", U"EXG8")
OK
FIND_ONE (EEG)
if (EEG_getNumberOfExternalElectrodes (me) == 8) {
const long offsetExternalElectrode = EEG_getNumberOfCapElectrodes (me);
SET_STRING (U"External electrode 1", my channelNames [offsetExternalElectrode + 1])
SET_STRING (U"External electrode 2", my channelNames [offsetExternalElectrode + 2])
SET_STRING (U"External electrode 3", my channelNames [offsetExternalElectrode + 3])
SET_STRING (U"External electrode 4", my channelNames [offsetExternalElectrode + 4])
SET_STRING (U"External electrode 5", my channelNames [offsetExternalElectrode + 5])
SET_STRING (U"External electrode 6", my channelNames [offsetExternalElectrode + 6])
SET_STRING (U"External electrode 7", my channelNames [offsetExternalElectrode + 7])
SET_STRING (U"External electrode 8", my channelNames [offsetExternalElectrode + 8])
}
DO
MODIFY_EACH (EEG)
if (EEG_getNumberOfExternalElectrodes (me) != 8)
Melder_throw (U"You can do this only if there are 8 external electrodes.");
EEG_setExternalElectrodeNames (me, externalElectrode1, externalElectrode2, externalElectrode3,
externalElectrode4, externalElectrode5, externalElectrode6,
externalElectrode7, externalElectrode8);
MODIFY_EACH_END
}
FORM (MODIFY_EEG_removeTriggers, U"Remove triggers", nullptr) {
OPTIONMENU_ENUM4 (removeEveryTriggerThat___, U"Remove every trigger that...", kMelder_string, DEFAULT)
SENTENCE4 (___theText, U"...the text", U"hi")
OK
DO
MODIFY_EACH (EEG)
EEG_removeTriggers (me, removeEveryTriggerThat___, ___theText);
MODIFY_EACH_END
}
FORM (MODIFY_EEG_setChannelName, U"Set channel name", nullptr) {
NATURALVAR (channelNumber, U"Channel number", U"1")
WORDVAR (newName, U"New name", U"BLA")
OK
DO
MODIFY_EACH (EEG)
EEG_setChannelName (me, channelNumber, newName);
MODIFY_EACH_END
}
FORM (MODIFY_EEG_setChannelToZero, U"Set channel to zero", nullptr) {
SENTENCE (U"Channel", U"Iz")
OK
DO
MODIFY_EACH (EEG)
EEG_setChannelToZero (me, GET_STRING (U"Channel"));
MODIFY_EACH_END
}
FORM (MODIFY_EEG_subtractMeanChannel, U"Subtract mean channel", nullptr) {
LABEL (U"label", U"Range of reference channels:")
NATURALVAR (fromChannel, U"From channel", U"1")
NATURALVAR (toChannel, U"To channel", U"32")
OK
DO
MODIFY_EACH (EEG)
EEG_subtractMeanChannel (me, fromChannel, toChannel);
MODIFY_EACH_END
}
FORM (MODIFY_EEG_subtractReference, U"Subtract reference", nullptr) {
WORDVAR (referenceChannel1, U"Reference channel 1", U"MASL")
WORDVAR (referenceChannel2, U"Reference channel 2 (optional)", U"MASR")
OK
DO
MODIFY_EACH (EEG)
EEG_subtractReference (me, referenceChannel1, referenceChannel2);
MODIFY_EACH_END
}
FORM (MODIFY_EEG_filter, U"Filter", nullptr) {
REALVAR (lowFrequency, U"Low frequency (Hz)", U"1.0")
REALVAR (lowWidth, U"Low width (Hz)", U"0.5")
REALVAR (highFrequency, U"High frequency (Hz)", U"25.0")
REALVAR (highWidth, U"High width (Hz)", U"12.5")
BOOLEANVAR (notchAt50Hz, U"Notch at 50 Hz", true)
OK
DO
MODIFY_EACH (EEG)
EEG_filter (me, lowFrequency, lowWidth, highFrequency, highWidth, notchAt50Hz);
MODIFY_EACH_END
}
// MARK: Extract
FORM (NEW_EEG_extractChannel, U"EEG: Extract channel", nullptr) {
SENTENCEVAR (channelName, U"Channel name", U"Cz")
OK
DO
CONVERT_EACH (EEG)
autoEEG result = EEG_extractChannel (me, channelName);
CONVERT_EACH_END (my name, U"_", channelName)
}
FORM (NEW_EEG_extractPart, U"EEG: Extract part", nullptr) {
REALVAR (fromTime, U"left Time range (s)", U"0.0")
REALVAR (toTime, U"right Time range (s)", U"1.0")
BOOLEANVAR (preserveTimes, U"Preserve times", false)
OK
DO
CONVERT_EACH (EEG)
autoEEG result = EEG_extractPart (me, fromTime, toTime, preserveTimes);
CONVERT_EACH_END (my name, U"_part")
}
DIRECT (NEW_EEG_extractSound) {
CONVERT_EACH (EEG)
if (! my sound) Melder_throw (me, U": I don't contain a waveform.");
autoSound result = EEG_extractSound (me);
CONVERT_EACH_END (my name)
}
DIRECT (NEW_EEG_extractTextGrid) {
CONVERT_EACH (EEG)
if (! my textgrid) Melder_throw (me, U": I don't contain marks.");
autoTextGrid result = EEG_extractTextGrid (me);
CONVERT_EACH_END (my name)
}
FORM (NEW_EEG_to_ERPTier_bit, U"To ERPTier (bit)", nullptr) {
REALVAR (fromTime, U"From time (s)", U"-0.11")
REALVAR (toTime, U"To time (s)", U"0.39")
NATURALVAR (markerBit, U"Marker bit", U"8")
OK
DO
CONVERT_EACH (EEG)
autoERPTier result = EEG_to_ERPTier_bit (me, fromTime, toTime, markerBit);
CONVERT_EACH_END (my name, U"_bit", markerBit)
}
FORM (NEW_EEG_to_ERPTier_marker, U"To ERPTier (marker)", nullptr) {
REALVAR (fromTime, U"From time (s)", U"-0.11")
REALVAR (toTime, U"To time (s)", U"0.39")
NATURALVAR (markerNumber, U"Marker number", U"12")
OK
DO
CONVERT_EACH (EEG)
autoERPTier result = EEG_to_ERPTier_marker (me, fromTime, toTime, (uint16) markerNumber);
CONVERT_EACH_END (my name, U"_", markerNumber)
}
FORM (NEW_EEG_to_ERPTier_triggers, U"To ERPTier (triggers)", nullptr) {
REALVAR (fromTime, U"From time (s)", U"-0.11")
REALVAR (toTime, U"To time (s)", U"0.39")
OPTIONMENU_ENUMVAR (getEveryEventWithATriggerThat, U"Get every event with a trigger that", kMelder_string, DEFAULT)
SENTENCEVAR (theText, U"...the text", U"1")
OK
DO
CONVERT_EACH (EEG)
autoERPTier result = EEG_to_ERPTier_triggers (me, fromTime, toTime, getEveryEventWithATriggerThat, theText);
CONVERT_EACH_END (my name, U"_trigger", theText)
}
FORM (NEW_EEG_to_ERPTier_triggers_preceded, U"To ERPTier (triggers, preceded)", nullptr) {
REALVAR (fromTime, U"From time (s)", U"-0.11")
REALVAR (toTime, U"To time (s)", U"0.39")
OPTIONMENU_ENUMVAR (getEveryEventWithATriggerThat, U"Get every event with a trigger that", kMelder_string, DEFAULT)
SENTENCEVAR (text1, U"...the text", U"1")
OPTIONMENU_ENUMVAR (andIsPrecededByATriggerThat, U"and is preceded by a trigger that", kMelder_string, DEFAULT)
SENTENCEVAR (text2, U" ...the text", U"4")
OK
DO
CONVERT_EACH (EEG)
autoERPTier result = EEG_to_ERPTier_triggers_preceded (me, fromTime, toTime,
getEveryEventWithATriggerThat, text1, andIsPrecededByATriggerThat, text2);
CONVERT_EACH_END (my name, U"_trigger", text2)
}
// MARK: Convert
DIRECT (NEW1_EEGs_concatenate) {
CONVERT_LIST (EEG)
autoEEG result = EEGs_concatenate (& list);
CONVERT_LIST_END (U"chain")
}
FORM (NEW_EEG_to_MixingMatrix, U"To MixingMatrix", nullptr) {
NATURAL4 (maximumNumberOfIterations, U"Maximum number of iterations", U"100")
POSITIVE4 (tolerance, U"Tolerance", U"0.001")
OPTIONMENU4x (diagonalizationMethod, U"Diagonalization method", 2, 1)
OPTION (U"qdiag")
OPTION (U"ffdiag")
OK
DO
CONVERT_EACH (EEG)
autoMixingMatrix result = EEG_to_MixingMatrix (me,
maximumNumberOfIterations, tolerance, diagonalizationMethod);
CONVERT_EACH_END (my name)
}
// MARK: - EEG & TextGrid
DIRECT (MODIFY_EEG_TextGrid_replaceTextGrid) {
MODIFY_FIRST_OF_TWO (EEG, TextGrid)
EEG_replaceTextGrid (me, you);
MODIFY_FIRST_OF_TWO_END
}
// MARK: - ERP
// MARK: View & Edit
static void cb_ERPWindow_publication (Editor /* editor */, autoDaata publication) {
/*
* Keep the gate for error handling.
*/
try {
bool isaSpectralSlice = Thing_isa (publication.get(), classSpectrum) && str32equ (Thing_getName (publication.get()), U"slice");
praat_new (publication.move());
praat_updateSelection ();
if (isaSpectralSlice) {
int IOBJECT;
LOOP {
iam_LOOP (Spectrum);
autoSpectrumEditor editor2 = SpectrumEditor_create (ID_AND_FULL_NAME, me);
praat_installEditor (editor2.get(), IOBJECT);
editor2.releaseToUser();
}
}
} catch (MelderError) {
Melder_flushError ();
}
}
DIRECT (WINDOW_ERP_viewAndEdit) {
if (theCurrentPraatApplication -> batch) Melder_throw (U"Cannot view or edit an ERP from batch.");
LOOP {
iam_LOOP (ERP);
autoERPWindow editor = ERPWindow_create (ID_AND_FULL_NAME, me);
Editor_setPublicationCallback (editor.get(), cb_ERPWindow_publication);
praat_installEditor (editor.get(), IOBJECT);
editor.releaseToUser();
}
END }
// MARK: Tabulate
FORM (NEW_ERP_downto_Table, U"ERP: Down to Table", nullptr) {
BOOLEAN4 (includeSampleNumber, U"Include sample number", false)
BOOLEAN4 (includeTime, U"Include time", true)
NATURAL4 (timeDecimals, U"Time decimals", U"6")
NATURAL4 (voltageDecimals, U"Voltage decimals", U"12")
RADIO4x (voltageUnits, U"Voltage units", 1, 1)
OPTION (U"volt")
OPTION (U"microvolt")
OK
DO
CONVERT_EACH (ERP)
autoTable result = ERP_tabulate (me, includeSampleNumber,
includeTime, timeDecimals, voltageDecimals, voltageUnits);
CONVERT_EACH_END (my name)
}
// MARK: Draw
FORM (GRAPHICS_ERP_draw, U"ERP: Draw", nullptr) {
SENTENCE4 (channelName, U"Channel name", U"Cz")
REAL4 (fromTime, U"left Time range (s)", U"0.0")
REAL4 (toTime, U"right Time range", U"0.0 (= all)")
REAL4 (fromVoltage, U"left Voltage range (V)", U"10e-6")
REAL4 (toVoltage, U"right Voltage range", U"-10e-6")
BOOLEAN4 (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (ERP)
ERP_drawChannel_name (me, GRAPHICS, channelName, fromTime, toTime, fromVoltage, toVoltage, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_ERP_drawScalp, U"ERP: Draw scalp", nullptr) {
REAL4 (fromTime, U"left Time range (s)", U"0.1")
REAL4 (toTime, U"right Time range", U"0.2")
REAL4 (fromVoltage, U"left Voltage range (V)", U"10e-6")
REAL4 (toVoltage, U"right Voltage range", U"-10e-6")
BOOLEAN4 (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (ERP)
ERP_drawScalp (me, GRAPHICS, fromTime, toTime,
fromVoltage, toVoltage, kGraphics_colourScale_GREY, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_ERP_drawScalp_colour, U"ERP: Draw scalp (colour)", nullptr) {
REAL4 (fromTime, U"left Time range (s)", U"0.1")
REAL4 (toTime, U"right Time range", U"0.2")
REAL4 (fromVoltage, U"left Voltage range (V)", U"10e-6")
REAL4 (toVoltage, U"right Voltage range", U"-10e-6")
RADIO_ENUM4 (colourScale, U"Colour scale", kGraphics_colourScale, BLUE_TO_RED)
BOOLEAN4 (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (ERP)
ERP_drawScalp (me, GRAPHICS, fromTime, toTime,
fromVoltage, toVoltage, (kGraphics_colourScale) colourScale, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_ERP_drawScalp_garnish, U"ERP: Draw scalp (garnish)", nullptr) {
REAL4 (fromVoltage, U"left Voltage range (V)", U"10e-6")
REAL4 (toVoltage, U"right Voltage range", U"-10e-6")
RADIO_ENUM4 (colourScale, U"Colour scale", kGraphics_colourScale, BLUE_TO_RED)
OK
DO
GRAPHICS_NONE
ERP_drawScalp_garnish (GRAPHICS, fromVoltage, toVoltage, (kGraphics_colourScale) colourScale);
GRAPHICS_NONE_END
}
// MARK: Query
FORM (STRING_ERP_getChannelName, U"Get channel name", nullptr) {
NATURAL4 (channelNumber, U"Channel number", U"1")
OK
DO
STRING_ONE (ERP)
if (channelNumber > my ny)
Melder_throw (me, U": there are only ", my ny, U" channels.");
const char32 *result = my channelNames [channelNumber];
STRING_ONE_END
}
FORM (INTEGER_ERP_getChannelNumber, U"Get channel number", nullptr) {
WORD4 (channelName, U"Channel name", U"Cz")
OK
DO
NUMBER_ONE (ERP)
long result = ERP_getChannelNumber (me, channelName);
NUMBER_ONE_END (U" (number of channel ", channelName, U")")
}
FORM (REAL_ERP_getMinimum, U"ERP: Get minimum", U"Sound: Get minimum...") {
SENTENCE4 (channelName, U"Channel name", U"Cz")
REAL4 (fromTime, U"left Time range (s)", U"0.0")
REAL4 (toTime, U"right Time range (s)", U"0.0 (= all)")
RADIO4x (interpolation, U"Interpolation", 4, 0)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
RADIOBUTTON (U"Sinc700")
OK
DO
NUMBER_ONE (ERP)
long channelNumber = ERP_getChannelNumber (me, channelName);
if (channelNumber == 0) Melder_throw (me, U": no channel named \"", channelName, U"\".");
double result;
Vector_getMinimumAndX (me, fromTime, toTime, channelNumber, interpolation, & result, nullptr);
NUMBER_ONE_END (U" Volt")
}
FORM (REAL_ERP_getTimeOfMinimum, U"ERP: Get time of minimum", U"Sound: Get time of minimum...") {
SENTENCE4 (channelName, U"Channel name", U"Cz")
REAL4 (fromTime, U"left Time range (s)", U"0.0")
REAL4 (toTime, U"right Time range (s)", U"0.0 (= all)")
RADIO4x (interpolation, U"Interpolation", 4, 0)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
RADIOBUTTON (U"Sinc700")
OK
DO
NUMBER_ONE (ERP)
long channelNumber = ERP_getChannelNumber (me, channelName);
if (channelNumber == 0) Melder_throw (me, U": no channel named \"", channelName, U"\".");
double result;
Vector_getMinimumAndX (me, fromTime, toTime, channelNumber, interpolation, nullptr, & result);
NUMBER_ONE_END (U" seconds")
}
FORM (REAL_ERP_getMaximum, U"ERP: Get maximum", U"Sound: Get maximum...") {
SENTENCE4 (channelName, U"Channel name", U"Cz")
REAL4 (fromTime, U"left Time range (s)", U"0.0")
REAL4 (toTime, U"right Time range (s)", U"0.0 (= all)")
RADIO4x (interpolation, U"Interpolation", 4, 0)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
RADIOBUTTON (U"Sinc700")
OK
DO
NUMBER_ONE (ERP)
long channelNumber = ERP_getChannelNumber (me, channelName);
if (channelNumber == 0) Melder_throw (me, U": no channel named \"", channelName, U"\".");
double result;
Vector_getMaximumAndX (me, GET_REAL (U"left Time range"), GET_REAL (U"right Time range"), channelNumber, GET_INTEGER (U"Interpolation") - 1, & result, nullptr);
NUMBER_ONE_END (U" Volt")
}
FORM (REAL_ERP_getTimeOfMaximum, U"ERP: Get time of maximum", U"Sound: Get time of maximum...") {
SENTENCE4 (channelName, U"Channel name", U"Cz")
REAL4 (fromTime, U"left Time range (s)", U"0.0")
REAL4 (toTime, U"right Time range (s)", U"0.0 (= all)")
RADIO4x (interpolation, U"Interpolation", 4, 0)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
RADIOBUTTON (U"Sinc700")
OK
DO
NUMBER_ONE (ERP)
long channelNumber = ERP_getChannelNumber (me, channelName);
if (channelNumber == 0) Melder_throw (me, U": no channel named \"", channelName, U"\".");
double result;
Vector_getMaximumAndX (me, fromTime, toTime, channelNumber, interpolation, nullptr, & result);
NUMBER_ONE_END (U" seconds")
}
FORM (REAL_ERP_getMean, U"ERP: Get mean", U"ERP: Get mean...") {
SENTENCE4 (channelName, U"Channel name", U"Cz")
REAL4 (fromTime, U"left Time range (s)", U"0.0")
REAL4 (toTime, U"right Time range (s)", U"0.0 (= all)")
OK
DO
NUMBER_ONE (ERP)
long channelNumber = ERP_getChannelNumber (me, channelName);
if (channelNumber == 0) Melder_throw (me, U": no channel named \"", channelName, U"\".");
double result = Vector_getMean (me, fromTime, toTime, channelNumber);
NUMBER_ONE_END (U" Volt")
}
// MARK: Modify
FORM (MODIFY_ERP_formula, U"ERP: Formula", U"ERP: Formula...") {
LABEL (U"label1", U"! `x' is the time in seconds, `col' is the sample number.")
LABEL (U"label2", U"x = x1 ! time associated with first sample")
LABEL (U"label3", U"for col from 1 to ncol")
LABEL (U"label4", U" self [col] = ...")
TEXTFIELD4 (formula, U"formula", U"self")
LABEL (U"label5", U" x = x + dx")
LABEL (U"label6", U"endfor")
OK
DO
MODIFY_EACH_WEAK (ERP)
Matrix_formula (me, formula, interpreter, nullptr);
MODIFY_EACH_WEAK_END
}
FORM (MODIFY_ERP_formula_part, U"ERP: Formula (part)", U"ERP: Formula...") {
REAL4 (fromTime, U"From time", U"0.0")
REAL4 (toTime, U"To time", U"0.0 (= all)")
NATURAL4 (fromChannel, U"From channel", U"1")
NATURAL4 (toChannel, U"To channel", U"2")
TEXTFIELD4 (formula, U"formula", U"2 * self")
OK
DO
MODIFY_EACH_WEAK (ERP)
Matrix_formula_part (me, fromTime, toTime,
fromChannel - 0.5, toChannel + 0.5, formula, interpreter, nullptr);
MODIFY_EACH_WEAK_END
}
// MARK: Extract
FORM (NEW_ERP_extractOneChannelAsSound, U"ERP: Extract one channel as Sound", nullptr) {
WORDVAR (channelName, U"Channel name", U"Cz")
OK
DO
CONVERT_EACH (ERP)
long channelNumber = ERP_getChannelNumber (me, channelName);
if (channelNumber == 0) Melder_throw (me, U": no channel named \"", channelName, U"\".");
autoSound result = Sound_extractChannel (me, channelNumber);
CONVERT_EACH_END (my name, U"_", channelName)
}
// MARK: Convert
DIRECT (NEW_ERP_downto_Sound) {
CONVERT_EACH (ERP)
autoSound result = ERP_downto_Sound (me);
CONVERT_EACH_END (my name)
}
// MARK: - ERPTIER
// MARK: Help
DIRECT (HELP_ERPTier_help) {
HELP (U"ERPTier")
}
// MARK: Query
FORM (STRING_ERPTier_getChannelName, U"Get channel name", nullptr) {
NATURALVAR (channelNumber, U"Channel number", U"1")
OK
DO
STRING_ONE (ERPTier)
if (channelNumber > my numberOfChannels)
Melder_throw (me, U": there are only ", my numberOfChannels, U" channels.");
const char32 *result = my channelNames [channelNumber];
STRING_ONE_END
}
FORM (INTEGER_ERPTier_getChannelNumber, U"Get channel number", nullptr) {
WORDVAR (channelName, U"Channel name", U"Cz")
OK
DO
NUMBER_ONE (ERPTier)
long result = ERPTier_getChannelNumber (me, channelName);
NUMBER_ONE_END (U" (number of channel ", channelName, U")")
}
FORM (REAL_ERPTier_getMean, U"ERPTier: Get mean", U"ERPTier: Get mean...") {
NATURALVAR (pointNumber, U"Point number", U"1")
SENTENCEVAR (channelName, U"Channel name", U"Cz")
REALVAR (fromTime, U"left Time range (s)", U"0.0")
REALVAR (toTime, U"right Time range (s)", U"0.0 (= all)")
OK
DO
NUMBER_ONE (ERPTier)
double result = ERPTier_getMean (me, pointNumber, channelName, fromTime, toTime);
NUMBER_ONE_END (U" Volt")
}
// MARK: Modify
FORM (MODIFY_ERPTier_rejectArtefacts, U"Reject artefacts", nullptr) {
POSITIVEVAR (threshold, U"Threshold (V)", U"75e-6")
OK
DO
MODIFY_EACH (ERPTier)
ERPTier_rejectArtefacts (me, threshold);
MODIFY_EACH_END
}
FORM (MODIFY_ERPTier_removeEventsBetween, U"Remove events", U"ERPTier: Remove events between...") {
REAL4 (fromTime, U"left Time range (s)", U"0.0")
REAL4 (toTime, U"right Time range (s)", U"1.0")
OK
DO
MODIFY_EACH (ERPTier)
AnyTier_removePointsBetween (me->asAnyTier(), fromTime, toTime);
MODIFY_EACH_END
}
FORM (MODIFY_ERPTier_subtractBaseline, U"Subtract baseline", nullptr) {
REAL4 (baselineStartTime, U"Baseline start time (s)", U"-0.11")
REAL4 (baselineEndTime, U"Baseline end time (s)", U"0.0")
OK
DO
MODIFY_EACH (ERPTier)
ERPTier_subtractBaseline (me, baselineStartTime, baselineEndTime);
MODIFY_EACH_END
}
// MARK: Analyse
FORM (NEW_ERPTier_to_ERP, U"ERPTier: To ERP", nullptr) {
NATURAL4 (eventNumber, U"Event number", U"1")
OK
DO
CONVERT_EACH (ERPTier)
autoERP result = ERPTier_extractERP (me, eventNumber);
CONVERT_EACH_END (my name, U"_", eventNumber)
}
DIRECT (NEW_ERPTier_to_ERP_mean) {
CONVERT_EACH (ERPTier)
autoERP result = ERPTier_to_ERP_mean (me);
CONVERT_EACH_END (my name, U"_mean")
}
// MARK: - ERPTIER & TABLE
FORM (NEW1_ERPTier_Table_extractEventsWhereColumn_number, U"Extract events where column (number)", nullptr) {
WORD4 (extractAllEventsWhereColumn___, U"Extract all events where column...", U"")
RADIO_ENUM4 (___is___, U"...is...", kMelder_number, DEFAULT)
REAL4 (___theNumber, U"...the number", U"0.0")
OK
DO
CONVERT_TWO (ERPTier, Table)
long columnNumber = Table_getColumnIndexFromColumnLabel (you, extractAllEventsWhereColumn___);
autoERPTier result = ERPTier_extractEventsWhereColumn_number (me, you, columnNumber, ___is___, ___theNumber);
CONVERT_TWO_END (my name)
}
FORM (NEW1_ERPTier_Table_extractEventsWhereColumn_text, U"Extract events where column (text)", nullptr) {
WORD4 (extractAllEventsWhereColumn___, U"Extract all events where column...", U"")
OPTIONMENU_ENUM4 (___, U"...", kMelder_string, DEFAULT)
SENTENCE4 (___theText, U"...the text", U"hi")
OK
DO
CONVERT_TWO (ERPTier, Table)
long columnNumber = Table_getColumnIndexFromColumnLabel (you, extractAllEventsWhereColumn___);
autoERPTier result = ERPTier_extractEventsWhereColumn_string (me, you, columnNumber, ___, ___theText);
CONVERT_TWO_END (my name)
}
// MARK: - file recognizers
static autoDaata bdfFileRecognizer (int nread, const char * /* header */, MelderFile file) {
const char32 *fileName = MelderFile_name (file);
bool isBdfFile = Melder_stringMatchesCriterion (fileName, kMelder_string_ENDS_WITH, U".bdf") ||
Melder_stringMatchesCriterion (fileName, kMelder_string_ENDS_WITH, U".BDF");
bool isEdfFile = Melder_stringMatchesCriterion (fileName, kMelder_string_ENDS_WITH, U".edf") ||
Melder_stringMatchesCriterion (fileName, kMelder_string_ENDS_WITH, U".EDF");
if (nread < 512 || (! isBdfFile && ! isEdfFile)) return autoDaata ();
return EEG_readFromBdfFile (file);
}
// MARK: - buttons
void praat_EEG_init ();
void praat_EEG_init () {
Thing_recognizeClassesByName (classEEG, classERPTier, classERP, nullptr);
Data_recognizeFileType (bdfFileRecognizer);
praat_addAction1 (classEEG, 0, U"EEG help", nullptr, 0, HELP_EEG_help);
praat_addAction1 (classEEG, 1, U"View & Edit", nullptr, praat_ATTRACTIVE, WINDOW_EEG_viewAndEdit);
praat_addAction1 (classEEG, 0, U"Query -", nullptr, 0, nullptr);
praat_addAction1 (classEEG, 1, U"Get channel name...", nullptr, 1, STRING_EEG_getChannelName);
praat_addAction1 (classEEG, 1, U"Get channel number...", nullptr, 1, INTEGER_EEG_getChannelNumber);
praat_addAction1 (classEEG, 0, U"Modify -", nullptr, 0, nullptr);
praat_addAction1 (classEEG, 0, U"Set channel name...", nullptr, 1, MODIFY_EEG_setChannelName);
praat_addAction1 (classEEG, 1, U"Edit external electrode names...", nullptr, 1, MODIFY_EEG_editExternalElectrodeNames);
praat_addAction1 (classEEG, 0, U"-- processing --", nullptr, 1, nullptr);
praat_addAction1 (classEEG, 0, U"Subtract reference...", nullptr, 1, MODIFY_EEG_subtractReference);
praat_addAction1 (classEEG, 0, U"Subtract mean channel...", nullptr, 1, MODIFY_EEG_subtractMeanChannel);
praat_addAction1 (classEEG, 0, U"Detrend", nullptr, 1, MODIFY_EEG_detrend);
praat_addAction1 (classEEG, 0, U"Filter...", nullptr, 1, MODIFY_EEG_filter);
praat_addAction1 (classEEG, 0, U"Remove triggers...", nullptr, 1, MODIFY_EEG_removeTriggers);
praat_addAction1 (classEEG, 0, U"Set channel to zero...", nullptr, 1, MODIFY_EEG_setChannelToZero);
praat_addAction1 (classEEG, 0, U"Analyse", nullptr, 0, nullptr);
praat_addAction1 (classEEG, 0, U"Extract channel...", nullptr, 0, NEW_EEG_extractChannel);
praat_addAction1 (classEEG, 0, U"Extract part...", nullptr, 0, NEW_EEG_extractPart);
praat_addAction1 (classEEG, 0, U"To ERPTier -", nullptr, 0, nullptr);
praat_addAction1 (classEEG, 0, U"To ERPTier (bit)...", nullptr, 1, NEW_EEG_to_ERPTier_bit);
praat_addAction1 (classEEG, 0, U"To ERPTier (marker)...", nullptr, 1, NEW_EEG_to_ERPTier_marker);
praat_addAction1 (classEEG, 0, U"To ERPTier (triggers)...", nullptr, 1, NEW_EEG_to_ERPTier_triggers);
praat_addAction1 (classEEG, 0, U"To ERPTier (triggers, preceded)...", nullptr, 1, NEW_EEG_to_ERPTier_triggers_preceded);
praat_addAction1 (classEEG, 0, U"To ERPTier...", nullptr, praat_DEPTH_1 + praat_HIDDEN, NEW_EEG_to_ERPTier_bit);
praat_addAction1 (classEEG, 0, U"To MixingMatrix...", nullptr, 0, NEW_EEG_to_MixingMatrix);
praat_addAction1 (classEEG, 0, U"Synthesize", nullptr, 0, nullptr);
praat_addAction1 (classEEG, 0, U"Concatenate", nullptr, 0, NEW1_EEGs_concatenate);
praat_addAction1 (classEEG, 0, U"Hack -", nullptr, 0, nullptr);
praat_addAction1 (classEEG, 0, U"Extract waveforms as Sound", nullptr, 1, NEW_EEG_extractSound);
praat_addAction1 (classEEG, 0, U"Extract marks as TextGrid", nullptr, 1, NEW_EEG_extractTextGrid);
praat_addAction1 (classERP, 1, U"View & Edit", nullptr, praat_ATTRACTIVE, WINDOW_ERP_viewAndEdit);
praat_addAction1 (classERP, 0, U"Draw -", nullptr, 0, nullptr);
praat_addAction1 (classERP, 0, U"Draw...", nullptr, 1, GRAPHICS_ERP_draw);
praat_addAction1 (classERP, 0, U"Draw scalp...", nullptr, 1, GRAPHICS_ERP_drawScalp);
praat_addAction1 (classERP, 0, U"Draw scalp (colour)...", nullptr, 1, GRAPHICS_ERP_drawScalp_colour);
praat_addAction1 (classERP, 0, U"Draw scalp (garnish)...", nullptr, 1, GRAPHICS_ERP_drawScalp_garnish);
praat_addAction1 (classERP, 0, U"Tabulate -", nullptr, 0, nullptr);
praat_addAction1 (classERP, 0, U"Down to Table...", nullptr, 1, NEW_ERP_downto_Table);
praat_addAction1 (classERP, 0, U"Query -", nullptr, 0, nullptr);
praat_addAction1 (classERP, 0, U"Get channel name...", nullptr, 1, STRING_ERP_getChannelName);
praat_addAction1 (classERP, 0, U"Get channel number...", nullptr, 1, INTEGER_ERP_getChannelNumber);
praat_addAction1 (classERP, 0, U"-- get shape --", nullptr, 1, nullptr);
praat_addAction1 (classERP, 0, U"Get minimum...", nullptr, 1, REAL_ERP_getMinimum);
praat_addAction1 (classERP, 0, U"Get time of minimum...", nullptr, 1, REAL_ERP_getTimeOfMinimum);
praat_addAction1 (classERP, 0, U"Get maximum...", nullptr, 1, REAL_ERP_getMaximum);
praat_addAction1 (classERP, 0, U"Get time of maximum...", nullptr, 1, REAL_ERP_getTimeOfMaximum);
praat_addAction1 (classERP, 0, U"-- get statistics --", nullptr, 1, nullptr);
praat_addAction1 (classERP, 0, U"Get mean...", nullptr, 1, REAL_ERP_getMean);
praat_addAction1 (classERP, 0, U"Modify -", nullptr, 0, nullptr);
praat_addAction1 (classERP, 0, U"Formula...", nullptr, 1, MODIFY_ERP_formula);
praat_addAction1 (classERP, 0, U"Formula (part)...", nullptr, 1, MODIFY_ERP_formula_part);
// praat_addAction1 (classERP, 0, U"Analyse -", nullptr, 0, nullptr);
// praat_addAction1 (classERP, 0, U"To ERP (difference)", nullptr, 1, NEW_ERP_to_ERP_difference);
// praat_addAction1 (classERP, 0, U"To ERP (mean)", nullptr, 1, NEW_ERP_to_ERP_mean);
praat_addAction1 (classERP, 0, U"Hack -", nullptr, 0, nullptr);
praat_addAction1 (classERP, 0, U"Down to Sound", nullptr, 1, NEW_ERP_downto_Sound);
praat_addAction1 (classERP, 0, U"Extract one channel as Sound...", nullptr, 1, NEW_ERP_extractOneChannelAsSound);
praat_addAction1 (classERPTier, 0, U"ERPTier help", nullptr, 0, HELP_ERPTier_help);
// praat_addAction1 (classERPTier, 1, U"View & Edit", nullptr, praat_ATTRACTIVE, WINDOW_ERPTier_viewAndEdit);
praat_addAction1 (classERPTier, 0, U"Query -", nullptr, 0, nullptr);
praat_TimeTier_query_init (classERPTier);
praat_addAction1 (classERPTier, 0, U"-- channel names --", nullptr, 1, nullptr);
praat_addAction1 (classERPTier, 0, U"Get channel name...", nullptr, 1, STRING_ERPTier_getChannelName);
praat_addAction1 (classERPTier, 0, U"Get channel number...", nullptr, 1, INTEGER_ERPTier_getChannelNumber);
praat_addAction1 (classERPTier, 0, U"-- erp --", nullptr, 1, nullptr);
praat_addAction1 (classERPTier, 0, U"Get mean...", nullptr, 1, REAL_ERPTier_getMean);
praat_addAction1 (classERPTier, 0, U"Modify -", nullptr, 0, nullptr);
praat_addAction1 (classERPTier, 0, U"Subtract baseline...", nullptr, 1, MODIFY_ERPTier_subtractBaseline);
praat_addAction1 (classERPTier, 0, U"Reject artefacts...", nullptr, 1, MODIFY_ERPTier_rejectArtefacts);
praat_addAction1 (classERPTier, 0, U"-- structure --", nullptr, 1, nullptr);
praat_addAction1 (classERPTier, 0, U"Remove events between...", nullptr, 1, MODIFY_ERPTier_removeEventsBetween);
praat_addAction1 (classERPTier, 0, U"Analyse", nullptr, 0, nullptr);
praat_addAction1 (classERPTier, 0, U"Extract ERP...", nullptr, 0, NEW_ERPTier_to_ERP);
praat_addAction1 (classERPTier, 0, U"To ERP (mean)", nullptr, 0, NEW_ERPTier_to_ERP_mean);
praat_addAction2 (classEEG, 1, classTextGrid, 1, U"Replace TextGrid", nullptr, 0, MODIFY_EEG_TextGrid_replaceTextGrid);
praat_addAction2 (classERPTier, 1, classTable, 1, U"Extract -", nullptr, 0, nullptr);
praat_addAction2 (classERPTier, 1, classTable, 1, U"Extract events where column (number)...", nullptr, 1, NEW1_ERPTier_Table_extractEventsWhereColumn_number);
praat_addAction2 (classERPTier, 1, classTable, 1, U"Extract events where column (text)...", nullptr, 1, NEW1_ERPTier_Table_extractEventsWhereColumn_text);
structEEGWindow :: f_preferences ();
structERPWindow :: f_preferences ();
}
/* End of file praat_EEG.cpp */
praat-6.0.23/FFNet/ 0000775 0000000 0000000 00000000000 13023464014 0013650 5 ustar 00root root 0000000 0000000 praat-6.0.23/FFNet/FFNet.cpp 0000664 0000000 0000000 00000065725 13023464014 0015335 0 ustar 00root root 0000000 0000000 /* FFNet.cpp
*
* Copyright (C) 1997-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020712 GPL header
djmw 20040420 Modified FFNet_create and FFNet_init parameters.
djmw 20040422 FFNet_drawActivation: nodes with activity > 0.05 had incorrect size.
djmw 20040422 FFNet_extractWeights added.
djmw 20040425 FFNet_drawTopology fill input units; increase distance from arrow for output labels
djmw 20040513 Info changes.
djmw 20040526 Adapted FFNet_drawCostHistory.
djmw 20050131 Reversed sign of derivative in minimumCrossEntropy.
djmw 20060811 Changed %d to %ld in sprintf for longs.
djmw 20061212 Changed info to Melder_writeLine format.
djmw 20070902 FFNet_createNameFromTopology to wchar
djmw 20071014 Melder_error
djmw 20080121 float -> double
djmw 20110304 Thing_new
*/
#include "FFNet_Matrix.h"
#include "Matrix_extensions.h"
#include "TableOfReal_extensions.h"
#include "PatternList.h"
#include "Collection.h"
#include "Categories.h"
static void bookkeeping (FFNet me);
#include "oo_DESTROY.h"
#include "FFNet_def.h"
#include "oo_COPY.h"
#include "FFNet_def.h"
#include "oo_EQUAL.h"
#include "FFNet_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "FFNet_def.h"
#include "oo_WRITE_TEXT.h"
#include "FFNet_def.h"
#include "oo_WRITE_BINARY.h"
#include "FFNet_def.h"
#include "oo_READ_TEXT.h"
#include "FFNet_def.h"
#include "oo_READ_BINARY.h"
#include "FFNet_def.h"
#include "oo_DESCRIPTION.h"
#include "FFNet_def.h"
Thing_implement (FFNet, Daata, 0);
static void FFNet_checkLayerNumber (FFNet me, long layer) {
if (layer < 1 || layer > my nLayers) {
if (layer == 0) {
Melder_throw (U"A layer number of 0 is not allowed.");
} else if (layer < 0) {
Melder_throw (U"A negative layer number is not allowed.");
} else if (layer > my nLayers) {
Melder_throw (U"A layer number of ", layer, U" is too big.");
}
Melder_appendError (U"This FFNet has ", layer, U" layer", (my nLayers > 1 ? U"s\n" : U"\n"));
if (my nLayers == 1) {
Melder_throw (U"Layer number must be equal to 1.");
} else if (my nLayers == 2) {
Melder_throw (U"Layer number must be equal to 1 or 2.");
} else if (my nLayers == 3) {
Melder_throw (U"Layer number must be equal to 1, 2 or 3.");
} else {
Melder_throw (U"Layer number must be in the range 1 to ", my nLayers);
}
}
}
autostring32 FFNet_createNameFromTopology (FFNet me) {
autoMelderString name;
MelderString_copy (&name, my nUnitsInLayer[0]);
for (long i = 1; i <= my nLayers; i++) {
MelderString_appendCharacter (&name, U'-');
MelderString_append (&name, my nUnitsInLayer[i]);
}
autostring32 naam = Melder_dup (name.string);
return naam.transfer();
}
/****** non-linearities ****************************************************/
static double sigmoid (FFNet /*me*/, double x, double *deriv) {
double act = NUMsigmoid (x);
*deriv = act * (1.0 - act);
return act;
}
/* ******************* cost functions ****************************************/
/*
For the errors calculated in the cost functions:
if target > activity ==> error > 0
if target < activity ==> error < 0
*/
static double minimumSquaredError (FFNet me, const double target[]) {
long k = my nNodes - my nOutputs + 1;
double cost = 0.0;
for (long i = 1; i <= my nOutputs; i++, k++) {
double e = my error[k] = target[i] - my activity[k];
cost += e * e;
}
return 0.5 * cost;
}
/* E = - sum (i=1; i=nPatterns; sum (k=1;k=nOutputs; t[k]*ln (o[k]) + (1-t[k])ln (1-o[k]))) */
/* dE/do[k] = -(1-t[k])/ (1-o[k]) + t[k]/o[k] */
/* werkt niet bij (grote?) netten */
static double minimumCrossEntropy (FFNet me, const double target[]) {
long k = my nNodes - my nOutputs + 1;
double cost = 0.0;
for (long i = 1; i <= my nOutputs; i++, k++) {
double t1 = 1.0 - target[i];
double o1 = 1.0 - my activity[k];
cost -= target[i] * log (my activity[k]) + t1 * log (o1);
my error[k] = -t1 / o1 + target[i] / my activity[k];
}
return cost;
}
/* *********************************************************************** */
static void bookkeeping (FFNet me) {
long nWeights = 0;
my nNodes = my nUnitsInLayer[0];
for (long i = 1; i <= my nLayers; i++) {
my nNodes += my nUnitsInLayer[i] + 1;
nWeights += my nUnitsInLayer[i] * (my nUnitsInLayer[i - 1] + 1);
}
if (my nWeights > 0 && my nWeights != nWeights) {
Melder_throw (U"Number of weights is incorret.");
}
my nWeights = nWeights;
// The following test is essential because when an FFNet is read from file the w array already exists
if (! my w) {
my w = NUMvector (1, my nWeights);
}
my activity = NUMvector (1, my nNodes);
my isbias = NUMvector (1, my nNodes);
my nodeFirst = NUMvector (1, my nNodes);
my nodeLast = NUMvector (1, my nNodes);
my wFirst = NUMvector (1, my nNodes);
my wLast = NUMvector (1, my nNodes);
my wSelected = NUMvector (1, my nWeights);
my error = NUMvector (1, my nNodes);
my deriv = NUMvector (1, my nNodes);
my dwi = NUMvector (1, my nWeights);
my dw = NUMvector (1, my nWeights);
my nInputs = my nUnitsInLayer[0];
my nOutputs = my nUnitsInLayer[my nLayers];
my isbias[my nInputs + 1] = 1;
my activity[my nInputs + 1] = 1.0;
long n = my nUnitsInLayer[0] + 2;
long firstNodeInPrevious = 1, lastWeightInPrevious = 0;
for (long j = 1; j <= my nLayers; j++, n++) {
for (long i = 1; i <= my nUnitsInLayer[j]; i++, n++) {
my isbias[n] = 0;
my nodeFirst[n] = firstNodeInPrevious;
my nodeLast[n] = my nodeFirst[n] + my nUnitsInLayer[j - 1];
my wFirst[n] = lastWeightInPrevious + (i - 1) * (my nUnitsInLayer[j - 1] + 1) + 1;
my wLast[n] = my wFirst[n] + my nUnitsInLayer[j - 1];
}
if (j != my nLayers) {
my isbias[n] = 1;
my activity[n] = 1.0;
}
lastWeightInPrevious = my wLast[n - 1];
firstNodeInPrevious += my nUnitsInLayer[j - 1] + 1;
}
FFNet_selectAllWeights (me);
}
void structFFNet :: v_info () {
our structDaata :: v_info ();
MelderInfo_writeLine (U"Number of layers: ", our nLayers);
MelderInfo_writeLine (U"Total number of units: ", FFNet_getNumberOfUnits (this));
MelderInfo_writeLine (U" Number of units in layer ", our nLayers, U" (output): ", our nUnitsInLayer [nLayers]);
for (long i = our nLayers - 1; i >= 1; i --) {
MelderInfo_writeLine (U" Number of units in layer ", i, U" (hidden): ", our nUnitsInLayer [i]);
}
MelderInfo_writeLine (U" Number of units in layer 0 (input): ", our nUnitsInLayer [0]);
MelderInfo_writeLine (U"Outputs are linear: ", Melder_boolean (our outputsAreLinear));
MelderInfo_writeLine (U"Number of weights: ", our nWeights, U" (",
FFNet_dimensionOfSearchSpace (this), U" selected)");
MelderInfo_writeLine (U"Number of nodes: ", our nNodes);
}
void FFNet_init (FFNet me, long numberOfInputs, long nodesInLayer1, long nodesInLayer2, long numberOfOutputs, bool outputsAreLinear) {
long numberOfLayers = 3;
if (numberOfInputs < 1) {
Melder_throw (U"Number of inputs must be a natural number.");
}
if (numberOfOutputs < 1) {
Melder_throw (U"Number of outputs must be a natural number.");
}
if (nodesInLayer1 < 1) {
numberOfLayers --;
}
if (nodesInLayer2 < 1) {
numberOfLayers --;
}
my nLayers = numberOfLayers;
my nUnitsInLayer = NUMvector (0, numberOfLayers);
my nUnitsInLayer [numberOfLayers --] = numberOfOutputs;
if (nodesInLayer2 > 0) {
my nUnitsInLayer [numberOfLayers --] = nodesInLayer2;
}
if (nodesInLayer1 > 0) {
my nUnitsInLayer [numberOfLayers --] = nodesInLayer1;
}
my nUnitsInLayer [numberOfLayers] = numberOfInputs;
Melder_assert (numberOfLayers == 0);
my outputsAreLinear = outputsAreLinear;
bookkeeping (me);
FFNet_setCostFunction (me, FFNet_COST_MSE);
FFNet_setNonLinearity (me, FFNet_NONLIN_SIGMOID);
FFNet_reset (me, 0.1);
}
void FFNet_setOutputCategories (FFNet me, Categories thee) {
autoCategories uniq = Categories_selectUniqueItems (thee);
if (uniq->size == thy size) {
my outputCategories = uniq.move();
}
}
autoFFNet FFNet_create (long numberOfInputs, long numberInLayer1, long numberInLayer2, long numberOfOutputs, bool outputsAreLinear) {
try {
autoFFNet me = Thing_new (FFNet);
FFNet_init (me.get(), numberOfInputs, numberInLayer1, numberInLayer2, numberOfOutputs, outputsAreLinear);
return me;
} catch (MelderError) {
Melder_throw (U"FFNet not created.");
}
}
void FFNet_setNonLinearity (FFNet me, int nonLinearityType) {
my nonLinearityType = nonLinearityType;
my nonLinearity = sigmoid;
my nlClosure = nullptr;
}
void FFNet_setCostFunction (FFNet me, int costType) {
my costFunctionType = costType;
if (costType == 2) {
my costFunction = minimumCrossEntropy;
} else {
my costFunction = minimumSquaredError;
}
my cfClosure = nullptr;
}
double FFNet_getBias (FFNet me, long layer, long unit) {
try {
long node = FFNet_getNodeNumberFromUnitNumber (me, unit, layer);
if (node < 1) {
Melder_throw (U"Not a valid unit / layer combination.");
}
long bias_unit = my wLast[node];
return my w[bias_unit];
} catch (MelderError) {
return NUMundefined;
}
}
void FFNet_setBias (FFNet me, long layer, long unit, double value) {
long node = FFNet_getNodeNumberFromUnitNumber (me, unit, layer);
if (node < 1) {
Melder_throw (U"Not a valid unit / layer combination.");
}
long bias_unit = my wLast [node]; // ??? +1
my w[bias_unit] = value;
}
void FFNet_setWeight (FFNet me, long layer, long unit, long unit_from, double value) {
long node = FFNet_getNodeNumberFromUnitNumber (me, unit, layer);
if (node < 1) {
Melder_throw (U"Not a valid unit / layer combination.");
}
long nodef = FFNet_getNodeNumberFromUnitNumber (me, unit_from, layer - 1);
if (nodef < 1) {
Melder_throw (U"Not a valid unit / layer combination.");
}
long w_unit = my wFirst [node] + unit_from - 1;
my w[w_unit] = value;
}
double FFNet_getWeight (FFNet me, long layer, long unit, long unit_from) {
long node = FFNet_getNodeNumberFromUnitNumber (me, unit, layer);
if (node < 1) {
Melder_throw (U"Not a valid unit / layer combination.");
}
long nodef = FFNet_getNodeNumberFromUnitNumber (me, unit_from, layer - 1);
if (nodef < 1) {
Melder_throw (U"Not a valid unit / layer combination.");
}
long w_unit = my wFirst[node] + unit_from - 1;
return my w[w_unit];
}
void FFNet_reset (FFNet me, double weightRange) {
for (long i = 1; i <= my nWeights; i ++) {
if (my wSelected [i]) {
my w [i] = NUMrandomUniform (- weightRange, weightRange);
}
}
for (long i = 1; i <= my nNodes; i ++) {
my activity [i] = ( my isbias [i] ? 1.0 : 0.0 );
}
my accumulatedCost = 0.0;
my minimizer.reset();
}
const char32* FFNet_getCategoryOfOutputUnit (FFNet me, long outputUnit) {
const char32 *result = U"-- undefined --";
if (my outputCategories && outputUnit <= my outputCategories -> size) {
SimpleString ss = my outputCategories->at [outputUnit];
result = ss -> string;
}
return result;
}
long FFNet_getOutputUnitOfCategory (FFNet me, const char32* category) {
long result = 0;
if (my outputCategories) {
for (long i = 1; i <= my outputCategories -> size; i ++) {
SimpleString s = my outputCategories->at [i];
if (Melder_equ (s -> string, category)) {
result = i;
break;
}
}
}
return result;
}
/***** OPERATION: ***********************************************************/
/* step 1 */
void FFNet_propagate (FFNet me, const double input[], double output[]) {
// clamp input pattern on the network
for (long i = 1; i <= my nUnitsInLayer[0]; i++) {
my activity[i] = input[i];
}
// on hidden units use activation function
long k = 1, nNodes = my outputsAreLinear ? my nNodes - my nOutputs : my nNodes;
for (long i = my nUnitsInLayer[0] + 2; i <= nNodes; i++) {
if (my isbias[i]) {
continue;
}
double act = 0.0;
for (long j = my nodeFirst[i]; j <= my nodeLast[i]; j++, k++) {
act += my w[k] * my activity[j];
}
my activity[i] = my nonLinearity (me, act, & my deriv[i]);
}
// on output units use another activation function
if (my outputsAreLinear) {
for (long i = nNodes + 1; i <= my nNodes; i++) {
if (my isbias[i]) {
continue;
}
double act = 0.0;
for (long j = my nodeFirst[i]; j <= my nodeLast[i]; j++, k++) {
act += my w[k] * my activity[j];
}
my activity[i] = act;
my deriv[i] = 1.0;
}
}
k = my nNodes - my nOutputs + 1;
if (output) {
for (long i = 1; i <= my nOutputs; i++, k++) {
output[i] = my activity[k];
}
}
}
double FFNet_computeError (FFNet me, const double target[]) {
// compute error at output layer
double cost = my costFunction (me, target);
for (long i = 1; i <= my nNodes - my nOutputs; i++) {
my error[i] = 0.0;
}
// backpropagation of errors from output to first hidden layer
for (long i = my nNodes; i > my nInputs + 1; i--) {
if (my isbias[i]) {
continue;
}
my error[i] *= my deriv[i];
if (my nodeFirst[i] > my nInputs + 1) {
long k = my wFirst[i];
for (long j = my nodeFirst[i]; j <= my nodeLast[i] - 1; j++, k++) {
my error[j] += my error[i] * my w[k];
}
}
}
return cost;
}
void FFNet_computeDerivative (FFNet me) {
long k = 1;
for (long i = my nInputs + 2; i <= my nNodes; i++) {
if (! my isbias[i]) {
for (long j = my nodeFirst[i]; j <= my nodeLast[i]; j++, k++) {
my dwi[k] = - my error[i] * my activity[j];
}
}
}
}
/******* end operation ******************************************************/
long FFNet_getWinningUnit (FFNet me, int labeling) {
long pos = 1, k = my nNodes - my nOutputs;
if (labeling == 2) { /* stochastic */
double sum = 0.0;
for (long i = 1; i <= my nOutputs; i++) {
sum += my activity[k + i];
}
double random = NUMrandomUniform (0.0, sum);
for (pos = my nOutputs; pos >= 2; pos--) {
if (random > (sum -= my activity[k + pos])) {
break;
}
}
} else { /* winner-takes-all */
double max = my activity[k + 1];
for (long i = 2; i <= my nOutputs; i++) if (my activity[k + i] > max) {
max = my activity[k + i];
pos = i;
}
}
return pos;
}
void FFNet_propagateToLayer (FFNet me, const double input[], double activity[], long layer) {
Melder_assert (activity);
long k = 0;
FFNet_propagate (me, input, nullptr);
for (long i = 0; i < layer; i++) {
k += my nUnitsInLayer[i] + 1;
}
for (long i = 1; i <= my nUnitsInLayer[layer]; i++) {
activity[i] = my activity[k + i];
}
}
void FFNet_selectAllWeights (FFNet me) {
for (long i = 1; i <= my nWeights; i++) {
my wSelected[i] = 1;
}
my dimension = my nWeights;
}
long FFNet_dimensionOfSearchSpace (FFNet me) {
long n = 0;
for (long i = 1; i <= my nWeights; i++) {
if (my wSelected[i]) {
n++;
}
}
return n;
}
void FFNet_selectBiasesInLayer (FFNet me, long layer) {
long node = my nUnitsInLayer[0] + 1;
if (layer < 1 || layer > my nLayers) {
return;
}
for (long i = 1; i <= my nWeights; i++) {
my wSelected[i] = 0.0;
}
for (long i = 1; i < layer; i++) {
node += my nUnitsInLayer[i] + 1;
}
for (long i = node + 1; i <= node + my nUnitsInLayer[layer]; i++) {
my wSelected[my wLast[i]] = 1;
}
my dimension = my nUnitsInLayer[layer];
}
void FFNet_weightConnectsUnits (FFNet me, long index, long *fromUnit, long *toUnit, long *layer) {
Melder_assert (index > 0 && index <= my nWeights);
long i = 1, np = 0, nw = my nUnitsInLayer[1] * (my nInputs + 1);
while (index > nw) {
i++;
nw += (np = my nUnitsInLayer[i] * (my nUnitsInLayer[i - 1] + 1));
}
if (i > 1) {
index -= nw - np;
}
if (fromUnit) {
*fromUnit = index % (my nUnitsInLayer[i - 1] + 1);
}
if (toUnit) {
*toUnit = (index - 1) / (my nUnitsInLayer[i - 1] + 1) + 1;
}
if (layer) {
*layer = i;
}
}
long FFNet_getNodeNumberFromUnitNumber (FFNet me, long unit, long layer) {
if (layer < 0 || layer > my nLayers || unit > my nUnitsInLayer[layer]) {
return -1;
}
long node = unit;
for (long i = 0; i < layer; i++) {
node += my nUnitsInLayer[i] + 1;
}
return node;
}
void FFNet_nodeToUnitInLayer (FFNet me, long node, long *unit, long *layer) {
Melder_assert (node > 0 && node <= my nNodes);
long i = 0, nn = my nUnitsInLayer[0] + 1;
while (node > nn) {
nn += my nUnitsInLayer[++i] + 1;
}
if (i > 0) {
node -= nn - (my nUnitsInLayer[i] + 1);
}
*unit = node % (my nUnitsInLayer[i] + 1);
*layer = i;
}
long FFNet_getNumberOfWeights (FFNet me) {
return my nWeights;
}
long FFNet_getNumberOfLayers (FFNet me) {
return my nLayers;
}
long FFNet_getNumberOfUnits (FFNet me) {
return my nNodes - my nLayers;
}
long FFNet_getNumberOfHiddenLayers (FFNet me) {
return my nLayers - 1;
}
long FFNet_getNumberOfUnitsInLayer (FFNet me, int layer) {
if (layer > my nLayers || layer < 0) {
return 0;
}
return my nUnitsInLayer[layer];
}
double FFNet_getMinimum (FFNet me) {
return my minimizer ? Minimizer_getMinimum (my minimizer.get()) : NUMundefined;
}
void FFNet_drawTopology (FFNet me, Graphics g) {
long maxNumOfUnits = my nUnitsInLayer[0];
int dxIsFixed = 1;
double dy = 1.0 / (my nLayers + 1);
for (long i = 1; i <= my nLayers; i++) {
if (my nUnitsInLayer[i] > maxNumOfUnits) {
maxNumOfUnits = my nUnitsInLayer[i];
}
}
double dx = 1.0 / maxNumOfUnits;
double radius = dx / 10.0;
Graphics_setInner (g);
Graphics_setWindow (g, 0.0, 1.0, 0.0, 1.0);
for (long i = 0; i <= my nLayers; i++) {
double dx2 = dx, x2WC, y2WC = dy / 2 + i * dy;
double x2 = (maxNumOfUnits - my nUnitsInLayer[i] + 1) * dx2 / 2;
/* draw the units */
if (! dxIsFixed) {
dx2 = 1.0 / my nUnitsInLayer[i];
x2 = dx2 / 2.0;
}
if (i == 0) {
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_TOP);
x2WC = x2;
for (long j = 1; j <= my nInputs; j++) {
Graphics_arrow (g, x2WC, y2WC - radius - dy / 4.0, x2WC, y2WC - radius);
x2WC += dx2;
}
}
Graphics_setColour (g, Graphics_RED);
x2WC = x2;
for (long j = 1; j <= my nUnitsInLayer[i]; j++) {
Graphics_circle (g, x2WC, y2WC, radius);
if (i > 0) {
Graphics_fillCircle (g, x2WC, y2WC, radius);
}
x2WC += dx2;
}
Graphics_setColour (g, Graphics_BLACK);
if (i > 0) {
double dx1 = dx;
double x1 = (maxNumOfUnits - my nUnitsInLayer[i - 1] + 1) * dx1 / 2.0;
double y1WC = y2WC - dy;
if (! dxIsFixed) {
dx1 = 1.0 / my nUnitsInLayer[i - 1];
x1 = dx1 / 2.0;
}
x2WC = x2;
for (long j = 1; j <= my nUnitsInLayer[i]; j++) {
double x1WC = x1;
for (long k = 1; k <= my nUnitsInLayer[i - 1]; k++) {
double xd = x2WC - x1WC;
double cosa = xd / sqrt (xd * xd + dy * dy);
double sina = dy / sqrt (xd * xd + dy * dy);
Graphics_line (g, x1WC + radius * cosa, y1WC + radius * sina, x2WC - radius * cosa, y2WC - radius * sina);
x1WC += dx1;
}
x2WC += dx2;
}
}
if (i == my nLayers) {
x2WC = x2;
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_BOTTOM);
for (long j = 1; j <= my nOutputs; j++) {
Graphics_arrow (g, x2WC, y2WC + radius, x2WC, y2WC + radius + dy / 4.0);
if (my outputCategories) {
Categories_drawItem (my outputCategories.get(), g, j, x2WC, y2WC + radius + dy / 4.0);
}
x2WC += dx2;
}
}
}
Graphics_unsetInner (g);
}
void FFNet_drawActivation (FFNet me, Graphics g) {
long node = 1, maxNumOfUnits = my nUnitsInLayer[0];
int dxIsFixed = 1;
Graphics_Colour colour = Graphics_inqColour (g);
double dy = 1.0 / (my nLayers + 1);
Graphics_setInner (g);
Graphics_setWindow (g, 0.0, 1.0, 0.0, 1.0);
for (long i = 1; i <= my nLayers; i++) {
if (my nUnitsInLayer[i] > maxNumOfUnits) {
maxNumOfUnits = my nUnitsInLayer[i];
}
}
double dx = 1.0 / maxNumOfUnits;
double r1 = dx / 2.0; /* May touch when neighbouring activities are both 1 (very rare). */
for (long i = 0; i <= my nLayers; i++, node++) {
double dx2 = dx, x2WC, y2WC = dy / 2.0 + i * dy;
double x2 = (maxNumOfUnits - my nUnitsInLayer[i] + 1) * dx2 / 2.0;
if (! dxIsFixed) {
dx2 = 1.0 / my nUnitsInLayer[i];
x2 = dx2 / 2.0;
}
x2WC = x2;
for (long j = 1; j <= my nUnitsInLayer[i]; j++, node++) {
double activity = my activity[node];
double radius = r1 * (fabs (activity) < 0.05 ? 0.05 : fabs (activity));
/*Graphics_setColour (g, activity < 0 ? Graphics_BLACK : Graphics_RED);*/
Graphics_circle (g, x2WC, y2WC, radius);
if (activity < 0) {
Graphics_fillCircle (g, x2WC, y2WC, radius);
}
x2WC += dx2;
}
}
Graphics_setColour (g, colour);
Graphics_unsetInner (g);
}
/* This routine is deprecated since praat-4.2.4 20040422 and will be removed in the future. */
void FFNet_drawWeightsToLayer (FFNet me, Graphics g, int layer, int scaling, int garnish) {
if (layer < 1 || layer > my nLayers) {
Melder_throw (U"Layer must be in [1,", my nLayers, U"].");
}
autoMatrix weights = FFNet_weightsToMatrix (me, layer, false);
Matrix_scale (weights.get(), scaling);
Matrix_drawAsSquares (weights.get(), g, 0.0, 0.0, 0.0, 0.0, 0);
if (garnish) {
double x1WC, x2WC, y1WC, y2WC;
Graphics_inqWindow (g, & x1WC, & x2WC, & y1WC, & y2WC);
Graphics_textBottom (g, false, Melder_cat (U"Units in layer ", layer, U" ->"));
if (layer == 1) {
Graphics_textLeft (g, false, U"Input units ->");
} else {
Graphics_textLeft (g, false, Melder_cat (U"Units in layer ", layer - 1, U" ->"));
}
/* how do I find out the current settings ??? */
Graphics_setTextAlignment (g, Graphics_RIGHT, Graphics_HALF);
Graphics_setInner (g);
Graphics_text (g, 0.5, weights->ny, U"bias");
Graphics_unsetInner (g);
}
}
void FFNet_drawWeights (FFNet me, Graphics g, long layer, int garnish) {
autoTableOfReal thee = FFNet_extractWeights (me, layer);
TableOfReal_drawAsSquares (thee.get(), g, 1, thy numberOfRows, 1, thy numberOfColumns, garnish);
}
void FFNet_drawCostHistory (FFNet me, Graphics g, long iFrom, long iTo, double costMin, double costMax, int garnish) {
if (my minimizer) {
Minimizer_drawHistory (my minimizer.get(), g, iFrom, iTo, costMin, costMax, 0);
}
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textLeft (g, true, my costFunctionType == FFNet_COST_MSE ?
U"Minimum squared error" : U"Minimum cross entropy");
Graphics_marksLeft (g, 2, true, true, false);
Graphics_textBottom (g, true, U"Number of epochs");
Graphics_marksBottom (g, 2, true, true, false);
}
}
autoCollection FFNet_createIrisExample (long numberOfHidden1, long numberOfHidden2) {
try {
autoCollection collection = Collection_create ();
autoCategories uniq = Categories_createWithSequentialNumbers (3);
autoFFNet me = FFNet_create (4, numberOfHidden1, numberOfHidden2, 3, false);
FFNet_setOutputCategories (me.get(), uniq.get());
autostring32 name = FFNet_createNameFromTopology (me.get());
Thing_setName (me.get(), name.peek());
collection -> addItem_move (me.move());
autoTableOfReal iris = TableOfReal_createIrisDataset ();
/*
* Scale data to interval [0-1]
*/
for (long i = 1; i <= 150; i ++) {
for (long j = 1; j <= 4; j ++) {
iris -> data [i] [j] /= 10.0;
}
}
autoPatternList ap;
autoCategories ac;
TableOfReal_to_PatternList_and_Categories (iris.get(), 0, 0, 0, 0, & ap, & ac);
Thing_setName (ap.get(), U"iris");
Thing_setName (ac.get(), U"iris");
collection -> addItem_move (ap.move());
collection -> addItem_move (ac.move());
return collection;
} catch (MelderError) {
Melder_throw (U"Iris example not created.");
}
}
autoTableOfReal FFNet_extractWeights (FFNet me, long layer) {
try {
FFNet_checkLayerNumber (me, layer);
long numberOfUnitsFrom = my nUnitsInLayer [layer - 1] + 1;
long numberOfUnitsTo = my nUnitsInLayer [layer];
autoTableOfReal thee = TableOfReal_create (numberOfUnitsFrom, numberOfUnitsTo);
char32 label [40];
for (long i = 1; i <= numberOfUnitsFrom - 1; i ++) {
Melder_sprint (label,40, U"L", layer - 1, U"-", i);
TableOfReal_setRowLabel (thee.get(), i, label);
}
TableOfReal_setRowLabel (thee.get(), numberOfUnitsFrom, U"Bias");
for (long i = 1; i <= numberOfUnitsTo; i++) {
Melder_sprint (label,40, U"L", layer, U"-", i);
TableOfReal_setColumnLabel (thee.get(), i, label);
}
long node = 1;
for (long i = 0; i < layer; i ++) {
node += my nUnitsInLayer[i] + 1;
}
for (long i = 1; i <= numberOfUnitsTo; i ++, node ++) {
long k = 1;
for (long j = my wFirst [node]; j <= my wLast [node]; j ++) {
thy data [k ++] [i] = my w [j];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no TableOfReal created.");
}
}
autoFFNet FFNet_and_TabelOfReal_to_FFNet (FFNet me, TableOfReal him, long layer) {
try {
FFNet_checkLayerNumber (me, layer);
if (my nUnitsInLayer [layer] != his numberOfColumns || my nUnitsInLayer [layer - 1] + 1 == his numberOfRows) {
long trys[1+3], rows[1+3], cols[1+3], ntry = my nLayers > 3 ? 3 : my nLayers, ok = 0;
if (my nLayers > 3) {
Melder_throw (U"Dimensions don't fit.");
}
for (long i = 1; i <= ntry; i++) {
cols[i] = my nUnitsInLayer[i] == his numberOfColumns;
rows[i] = my nUnitsInLayer[i - 1] + 1 == his numberOfRows;
trys[i] = rows[i] && cols[i];
if (trys[i]) {
ok ++;
}
}
if (! rows[layer]){
Melder_throw (U"The number of rows in the TableOfReal does not equal \n"
U"the number of units in the layer that connect to layer ", layer, U".");
} else {
Melder_throw (U"The number of columns in the TableOfReal does not equal \n"
U"the number of units in layer ", layer, U".");
}
if (ok == 0) {
Melder_throw (U"Please quit, there is no appropriate layer in the FFNet for this TableOfReal.");
} else {
if (ok == 1) {
Melder_throw (U"Please try again with layer number ", trys[1] ? trys[1] : (trys[2] ? trys[2] : trys[3]), U".");
} else {
Melder_throw (U"Please try again with one of the other two layer numbers.");
}
}
}
autoFFNet thee = Data_copy (me);
long node = 1;
for (long i = 0; i < layer; i++) {
node += thy nUnitsInLayer[i] + 1;
}
for (long i = 1; i <= thy nUnitsInLayer[layer]; i++, node++) {
long k = 1;
for (long j = thy wFirst[node]; j <= thy wLast[node]; j++, k++) {
thy w[j] = his data[k][i];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no FFNet created.");
}
}
autoFFNet PatternList_Categories_to_FFNet (PatternList me, Categories you, long numberOfUnits1, long numberOfUnits2) {
try {
numberOfUnits1 = numberOfUnits1 > 0 ? numberOfUnits1 : 0;
numberOfUnits2 = numberOfUnits2 > 0 ? numberOfUnits2 : 0;
autoCategories uniq = Categories_selectUniqueItems (you);
long numberOfOutputs = uniq -> size;
if (numberOfOutputs < 1) {
Melder_throw (U"There are no categories in the Categories.");
}
autoFFNet result = FFNet_create (my nx, numberOfUnits1, numberOfUnits2, numberOfOutputs, false);
FFNet_setOutputCategories (result.get(), uniq.get());
autostring32 ffnetName = FFNet_createNameFromTopology (result.get());
Thing_setName (result.get(), ffnetName.peek());
return result;
} catch (MelderError) {
Melder_throw (me, you, U": no FFNet created.");
}
}
/* End of file FFNet.cpp */
praat-6.0.23/FFNet/FFNet.h 0000664 0000000 0000000 00000022562 13023464014 0014772 0 ustar 00root root 0000000 0000000 #ifndef _FFNet_h_
#define _FFNet_h_
/* FFNet.h
*
* Copyright (C) 1997-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19970515
djmw 20020712 GPL header.
djmw 20031025 Added FFNet_getMinimum.
djmw 20040420 FFNet_create and Pattern&Categories: To FFNet changes.
djmw 20040422 FFNet_extractWeights added.
djmw 20040505 FFNet_getNodeNumberFromUnitNumber added.
djmw 20071024 Latest modification.
djmw 20080121 float -> double
*/
#include "Data.h"
#include "Categories.h"
#include "Minimizers.h"
#include "PatternList.h"
#include "TableOfReal.h"
#include "FFNet_def.h"
/* Parameters:
* long nLayers : the #layers in the net (exclusive the inputs)
* nUnitsInLayer : array[0..nLayers] the #units in each layer
* nUnitsInLayer[0] : #inputs
* nUnitsInLayer[nLayers] :#outputs
* nWeights : the total #weights in the net (inclusive bias)
* double *w : array[1..nWeights] with the connection strengths
* *activity : array[1..nNodes] with activities
* outputLabels : labels belonging to the outputs
* BOOKKEEPING:
* long nNodes : total #nodes: bias modelled as unit with constant activity)
* *isbias : array[1..nNodes] set 1 if node is bias else 0
* *nodeFirst : array[1..nNodes] first node connected to this unit
* *nodeLast: : array[1..nNodes] last node connected to this unit
* *wFirst : array[1..nNodes] first index in *w for this unit
* *wLast : array[1..nNodes] last (inclusive the bias)
* LEARNING:
* int *wSelected : array[1..nWeights] weights selected for minimization
* double *deriv : array[1..nNodes] derivative of nonlinearity at node
* *error : array[1..nNodes] the error at node
* *dw : array[1..nWeights] total derivative for weights
* *dwi : array[1..nWeights] derivative per pattern
* long dimension : dimension of minimizer space (<= my nWeights)
* long nPatterns : the #patterns to be learned
* double **inputPattern: matrix[1..nPatterns][1..nInputs]
* double **targetActivation: matrix[1..nPatterns][1..nOutputs]
* double accumulatedCost : accumulated costs of testing/training with patterns
*
* A network consists of nLayers layers. Layer numbering is from 0...nLayers.
* Layer 0 is the input layer, the highest numbered layer is the output layer
* (nLayers <= 4)
* Each layer consists of a number of units. The biases of all the units in a layer
* are modelled with connections to an extra unit in the lower layer (with constant
* activity 1.0). Nodes refers to 'units' + 'bias units'.
* The variable 'nNodes' is the total number of nodes (inclusive bias nodes).
* E.g. the topology (2,3,4), i.e., 2 inputs, 3 units in the first layer
* and 4 units in the second layer (outputs) is modelled
* with (2+1)+ (3+1)+ (4) = 11 nodes.
* The numbering of the weights is as follows (indices 1..nWeights):
* E.g., topology (I,H,O) (I inputs, H hidden units and O output units)
* There are a total of H* (I+1) + O* (H+1) weights in this net.
* w[1] - w[I] : I (1)->H (1), I (2)->H (1) ... I (I)->H (1)
* w[I+1] : bias->H (1)
* w[ (I+1)+1] - w[2 (I+1)-1] : I (1)->H (2), I (2)->H (2) ... I (I)->H (2)
* w[2 (I+1)] : bias->H (2)
* ...
* w[ (H-1) (I+1)+1] - w[H (I+1)-1] : I (1)->H (H), I (2)->H (H) ... I (I)->H (H)
* w[H (I+1)] : bias->H (H)
* M = H (I+1)
* w[M+1] - w[M+H] : H (1)->O (1), H (2)->O (1) ... H (H)->O (1)
* w[M+H+1] : bias->O (1)
* w[M+ (H+1)+1] - w (M+2 (H+1)-1) : H (1)->O (2), H (2)->O (2) ... H (H)->O (2)
* w[M+2 (H+1)] : bias->O (1)
* ...
* w[M+ (O-1)* (H+1)+1] - w[M+O (H+1)-1] : H (1)->O (O), H (2)->O (O) ... H (H)->O (O)
* w[m+o (h+1)-1] : bias->O (O)
*
* Internals:
*
* A number of auxiliary arrays for efficient calculations have been setup.
* For a node k we need to know:
* 1. isbias[1..nNodes] : usage: if (isbias[k]) ...
* true if node k is a bias node. There are nLayers bias nodes
* 2. nodeFirst[1..nNodes] : usage is j=nodeFirst[k];
* j is the first node that is connected to k .
* 3. nodeLast[1..nNodes] : usage is j=nodeLast[k]
* j is the last node that is connected to k (bias included).
* For the calculation of the errors, during learning, in unit k we need to
* know which weights from the preceeding layer connect to it.
* 4. wFirst[1..nNodes] : usage j=wFirst[k]
* w[j] is first weight to node k.
* 5. wLast[1..nNodes] : usage j=wLast[k]
* w[j] is last weight to node k.
*/
/* FFNet::copy
* copy everything except minimizer, patterns and inputs.
*/
void FFNet_init (FFNet me, long numberOfInputs, long nodesInLayer1, long nodesInLayer2,
long numberOfOutputs, bool outputsAreLinear);
autoFFNet FFNet_create (long numberOfInputs, long numberInLayer1, long numberInLayer2,
long numberOfOutputs, bool outputsAreLinear);
autostring32 FFNet_createNameFromTopology (FFNet me);
/* Create names as -, --,
--- for 1, 2 or 3 layer networks.
*/
#define FFNet_COST_MSE 1
void FFNet_setCostFunction (FFNet me, int type);
#define FFNet_NONLIN_SIGMOID 1
void FFNet_setNonLinearity (FFNet me, int type);
void FFNet_setOutputCategories (FFNet me, Categories thee);
double FFNet_getBias (FFNet me, long layer, long unit);
void FFNet_setBias (FFNet me, long layer, long node, double value);
void FFNet_setWeight (FFNet me, long later, long node, long node_from, double value);
double FFNet_getWeight (FFNet me, long later, long node, long node_from);
void FFNet_reset (FFNet me, double wrange);
/* reset the neural net:
* initialize all (selected) weights and biases with random numbers from the
* interval (-wrange, wrange).
* forget links with minimizer.
*/
const char32* FFNet_getCategoryOfOutputUnit (FFNet me, long outputUnit);
long FFNet_getOutputUnitOfCategory (FFNet me, const char32* category);
void FFNet_propagateToLayer (FFNet me, const double input[], double activity[], long layer);
/* propagate the input through the net to layer and calculate the activities */
void FFNet_propagate (FFNet me, const double input[], double output[]);
/* step (1) feed forward input from "input layer" to "output layer"
* if output != nullptr the output activity is copied into output.
* postcondition: my activities defined
*/
double FFNet_computeError (FFNet me, const double target[]);
/* step (2) calculate error on output nodes w.r.t. desired output */
/* step (3) backpropagate this error to previous nodes */
/* precondition: step (1) */
void FFNet_computeDerivative (FFNet me);
/* step (4) compute derivative in my dwi */
/* Precondition: step (3) */
long FFNet_getWinningUnit (FFNet me, int labeling);
/* labeling = 1 : winner-takes-all */
/* labeling = 2 : stochastic */
void FFNet_selectAllWeights (FFNet me);
void FFNet_selectBiasesInLayer (FFNet me, long layer);
long FFNet_dimensionOfSearchSpace (FFNet me);
/* count the selected weights */
long FFNet_getNumberOfWeights (FFNet me);
/* return my nWeights */
void FFNet_weightConnectsUnits (FFNet me, long index, long *fromUnit, long *toUnit, long *layer);
/*
* w[index] connects unit fromUnit in "layer-1" with unit toUnit in "layer".
* fromUnit returns 0 then w[index] is bias.
*/
long FFNet_getNodeNumberFromUnitNumber (FFNet me, long unit, long layer);
void FFNet_nodeToUnitInLayer (FFNet me, long node, long *unit, long *layer);
/* translate node index to unit "unit" in layer "layer" */
long FFNet_getNumberOfLayers (FFNet me);
long FFNet_getNumberOfUnits (FFNet me);
long FFNet_getNumberOfHiddenLayers (FFNet me);
long FFNet_getNumberOfUnitsInLayer (FFNet me, int layer);
double FFNet_getMinimum (FFNet me);
void FFNet_drawTopology (FFNet me, Graphics g);
void FFNet_drawActivation (FFNet me, Graphics g);
void FFNet_drawWeightsToLayer (FFNet me, Graphics g, int toLayer, int scaling, int garnish);
/* Deprecated: the strengths of the weights that connect to the nodes in later 'layer' */
/* are drawn with boxes. The area of each box corresponds to the strength. */
/* Black boxes have negative strength? */
void FFNet_drawCostHistory (FFNet me, Graphics g, long from_iteration, long to_iteration,
double from_cost, double to_cost, int garnish);
/* draw cost vs epochs */
autoCollection FFNet_createIrisExample (long numberOfHidden1, long numberOfHidden2);
autoTableOfReal FFNet_extractWeights (FFNet me, long layer);
void FFNet_drawWeights (FFNet me, Graphics g, long layer, int garnish);
autoFFNet FFNet_and_TabelOfReal_to_FFNet (FFNet me, TableOfReal him, long layer);
autoFFNet PatternList_Categories_to_FFNet (PatternList me, Categories you, long numberOfUnits1, long numberOfUnits2);
#endif /* _FFNet_h_ */
praat-6.0.23/FFNet/FFNet_ActivationList_Categories.cpp 0000664 0000000 0000000 00000006312 13023464014 0022502 0 ustar 00root root 0000000 0000000 /* FFNet_ActivationList_Categories.cpp
*
* Copyright (C) 1997-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19960322
djmw 20020712 GPL header
djmw 20040416 Better error messages
djmw 20071014 Melder_error
*/
#include "FFNet_ActivationList_Categories.h"
static long winnerTakesAll (FFNet me, const double activation[]) {
long pos = 1;
double max = activation[1];
for (long i = 2; i <= my nOutputs; i++) {
if (activation[i] > max) {
max = activation[i]; pos = i;
}
}
return pos;
}
static long stochastic (FFNet me, const double activation[]) {
long i;
double range = 0.0, lower = 0.0;
for (i = 1; i <= my nOutputs; i++) {
range += activation[i];
}
double number = NUMrandomUniform (0.0, range);
for (i = 1; i <= my nOutputs; i++) {
lower += activation[i];
if (number < lower) {
break;
}
}
return i;
}
autoCategories FFNet_ActivationList_to_Categories (FFNet me, ActivationList activation, int labeling) {
try {
long (*labelingFunction) (FFNet me, const double act[]);
if (! my outputCategories) {
Melder_throw (U"No Categories (has the FFNet been trained yet?).");
}
if (my nOutputs != activation -> nx) {
Melder_throw (U"Number of columns and number of outputs must be equal.");
}
autoCategories thee = Categories_create ();
labelingFunction = labeling == 2 ? stochastic : winnerTakesAll;
for (long i = 1; i <= activation->ny; i++) {
long index = labelingFunction (me, activation -> z[i]);
autoSimpleString item = Data_copy (my outputCategories->at [index]);
thy addItem_move (item.move());
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Categories created.");
}
}
autoActivationList FFNet_Categories_to_ActivationList (FFNet me, Categories thee) {
try {
autoCategories uniq = Categories_selectUniqueItems (thee);
if (! my outputCategories) {
Melder_throw (U"The FFNet does not have categories.");
}
long nl = OrderedOfString_isSubsetOf (uniq.get(), my outputCategories.get(), 0);
if (nl == 0) {
Melder_throw (U"The Categories do not match the categories of the FFNet.");
}
autoActivationList him = ActivationList_create (thy size, my nOutputs);
for (long i = 1; i <= thy size; i ++) {
const char32 *citem = OrderedOfString_itemAtIndex_c (thee, i);
long pos = OrderedOfString_indexOfItem_c (my outputCategories.get(), citem);
if (pos < 1) {
Melder_throw (U"The FFNet doesn't know the category ", citem, U".");
}
his z [i] [pos] = 1.0;
}
return him;
} catch (MelderError) {
Melder_throw (me, U": no ActivationList created.");
}
}
/* End of file FFNet_ActivationList_Categories.cpp */
praat-6.0.23/FFNet/FFNet_ActivationList_Categories.h 0000664 0000000 0000000 00000002475 13023464014 0022155 0 ustar 00root root 0000000 0000000 #ifndef _FFNet_ActivationList_Categories_h_
#define _FFNet_ActivationList_Categories_h_
/* FFNet_ActivationList_Categories.h
*
* Copyright (C) 1997-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19950109
djmw 20020712 GPL header
djmw 20110307 Latest modification
*/
#include "FFNet.h"
#include "ActivationList.h"
#include "Categories.h"
autoCategories FFNet_ActivationList_to_Categories (FFNet me, ActivationList activation, int labeling);
/* labeling = 1 : winner-takes-all */
/* labeling = 2 : stochastic */
autoActivationList FFNet_Categories_to_ActivationList (FFNet me, Categories labels);
/* Postcondition: my outputCategories != nullptr; */
#endif /* _FFNet_ActivationList_Categories_h_ */
praat-6.0.23/FFNet/FFNet_Eigen.cpp 0000664 0000000 0000000 00000012714 13023464014 0016432 0 ustar 00root root 0000000 0000000 /* FFNet_Eigen.cpp
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020712 GPL header
djmw 20071202 Melder_warning
*/
#include "FFNet_Eigen.h"
#include "Graphics.h"
#include "NUM2.h"
void FFNet_Eigen_drawIntersection (FFNet me, Eigen eigen, Graphics g, long pcx, long pcy, double xmin, double xmax, double ymin, double ymax) {
long ix = labs (pcx), iy = labs (pcy);
long numberOfEigenvalues = eigen -> numberOfEigenvalues;
long dimension = eigen -> dimension;
if (ix > numberOfEigenvalues || iy > numberOfEigenvalues || my nInputs != dimension) {
return;
}
Melder_assert (ix > 0 && iy > 0);
double x1, x2, y1, y2;
if (xmax <= xmin || ymax <= ymin) {
Graphics_inqWindow (g, & x1, & x2, & y1, & y2);
}
if (xmax <= xmin) {
xmin = x1;
xmax = x2;
}
if (ymax <= ymin) {
ymin = y1;
ymax = y2;
}
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
for (long i = 1; i <= my nUnitsInLayer[1]; i++) {
long unitOffset = my nInputs + 1;
double c1 = 0.0, c2 = 0.0, bias = my w[ my wLast[unitOffset + i] ];
double x[6], y[6], xs[3], ys[3]; int ns = 0;
for (long j = 1; j <= my nInputs; j++) {
c1 += my w[ my wFirst[unitOffset + i] + j - 1 ] * eigen->eigenvectors[ix][j];
c2 += my w[ my wFirst[unitOffset + i] + j - 1 ] * eigen->eigenvectors[iy][j];
}
x[1] = x[2] = x[5] = xmin; x[3] = x[4] = xmax;
y[1] = y[4] = y[5] = ymin; y[2] = y[3] = ymax;
for (long j = 1; j <= 4; j++) {
double p1 = c1 * x[j ] + c2 * y[j ] + bias;
double p2 = c1 * x[j + 1] + c2 * y[j + 1] + bias;
double r = fabs (p1) / (fabs (p1) + fabs (p2));
if (p1 *p2 > 0 || r == 0.0) {
continue;
}
if (++ns > 2) {
break;
}
xs[ns] = x[j] + (x[j + 1] - x[j]) * r;
ys[ns] = y[j] + (y[j + 1] - y[j]) * r;
}
if (ns < 2) {
Melder_casual (U"Intersection for unit ", i, U" outside range");
} else {
Graphics_line (g, xs[1], ys[1], xs[2], ys[2]);
}
}
Graphics_unsetInner (g);
}
/*
Draw the intersection line of the decision hyperplane 'w.e-b' of the weights of unit i
from layer j with the plane spanned by eigenvectors pcx and pcy.
*/
void FFNet_Eigen_drawDecisionPlaneInEigenspace (FFNet me, Eigen thee, Graphics g, long unit, long layer,
long pcx, long pcy, double xmin, double xmax, double ymin, double ymax)
{
if (layer < 1 || layer > my nLayers) {
return;
}
if (unit < 1 || unit > my nUnitsInLayer[layer]) {
return;
}
if (pcx > thy numberOfEigenvalues || pcy > thy numberOfEigenvalues) {
return;
}
if (my nUnitsInLayer[layer - 1] != thy dimension) {
return;
}
double x1, x2, y1, y2;
Graphics_inqWindow (g, & x1, & x2, & y1, & y2);
if (xmax <= xmin) {
xmin = x1; xmax = x2;
}
if (ymax <= ymin) {
ymin = y1; ymax = y2;
}
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
long node = FFNet_getNodeNumberFromUnitNumber (me, unit, layer);
if (node < 1) {
return;
}
/*
Suppose p1 and p2 are the two points in the eigenplane, spanned by the eigenvectors
e1 and e2, where the neural net decision hyperplane intersects these eigenvectors.
Their coordinates in the eigenplane will be (x0*e1, 0) and (0,y0*e2).
At the same time, the two points are part of the decision hyperplane of the
chosen unit. The hyperplane equation is:
w.e+bias = 0,
where 'w' is the weight vector, 'e' is the input vector and 'b' is the bias.
This results in two equations for the unknown x0 and y0:
w.(x0*e1)+bias = 0
w.(y0*e2)+bias = 0
This suggests the solution for x0 and y0:
x0 = -bias / (w.e1)
y0 = -bias / (w.e2)
If w.e1 != 0 && w.e2 != 0
p1 = (x0, 0) and p2 = (0, y0)
If w.e1 == 0 && w.e2 != 0
The line is parallel to e1 and intersects e2 at y0.
If w.e2 == 0 && w.e1 != 0
The line is parallel to e2 and intersects e1 at x0.
If w.e1 == 0 && w.e2 == 0
Both planes are parallel, no intersection.
*/
long iw = my wFirst[node] - 1;
double we1 = 0.0, we2 = 0.0;
for (long i = 1; i <= my nUnitsInLayer[layer - 1]; i++) {
we1 += my w[iw + i] * thy eigenvectors[pcx][i];
we2 += my w[iw + i] * thy eigenvectors[pcy][i];
}
double bias = my w[my wLast[node]];
x1 = xmin; x2 = xmax;
y1 = ymin; y2 = ymax;
if (we1 != 0.0) {
x1 = -bias / we1; y1 = 0.0;
}
if (we2 != 0.0) {
x2 = 0.0; y2 = -bias / we2;
}
if (we1 == 0.0 && we2 == 0.0) {
Melder_warning (U"We cannot draw the intersection of the neural net decision plane\n"
"for unit ", unit, U" in layer ", layer, U" with the plane spanned by the eigenvectors because \nboth planes are parallel.");
return;
}
double xi[3], yi[3]; /* Intersections */
double ni = NUMgetIntersectionsWithRectangle (x1, y1, x2, y2, xmin, ymin, xmax, ymax, xi, yi);
if (ni == 2) {
Graphics_line (g, xi[1], yi[1], xi[2], yi[2]);
} else {
Melder_warning (U"There were no intersections in the drawing area.\nPlease enlarge the drawing area.");
}
Graphics_unsetInner (g);
}
/* End of file FFNet_Eigen.cpp */
praat-6.0.23/FFNet/FFNet_Eigen.h 0000664 0000000 0000000 00000002643 13023464014 0016077 0 ustar 00root root 0000000 0000000 #ifndef _FFNet_Eigen_h_
#define _FFNet_Eigen_h_
/* FFNet_Eigen.h
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19940726
djmw 20110307 Latest modification.
*/
#include "FFNet.h"
#include "Eigen.h"
void FFNet_Eigen_drawIntersection (FFNet me, Eigen eigen, Graphics g, long pcx, long pcy,
double xmin, double xmax, double ymin, double ymax);
/* Draw intersections of hyperplanes of units in layer 1 with eigenplane */
/* formed by pcx and pcy. */
/* pcx (pcy) > 0 : negative values left (bottom), positive right (top) */
/* pcx (pcy) < 0 : negative values right (top). */
void FFNet_Eigen_drawDecisionPlaneInEigenspace (FFNet me, Eigen thee, Graphics g, long unit,
long layer, long pcx, long pcy, double xmin, double xmax, double ymin, double ymax);
#endif /* _FFNet_Eigen_h_ */
praat-6.0.23/FFNet/FFNet_Matrix.cpp 0000664 0000000 0000000 00000005010 13023464014 0016636 0 ustar 00root root 0000000 0000000 /* FFNet_Matrix.cpp
*
* Copyright (C) 1997-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19950206
djmw 20020712 GPL header
*/
#include "FFNet_Matrix.h"
autoMatrix FFNet_weightsToMatrix (FFNet me, long layer, bool deltaWeights) {
try {
if (layer < 1 || layer > my nLayers) {
Melder_throw (U"Layer must be > 0 and < ", my nLayers, U".");
}
autoMatrix thee = Matrix_create (0.5, my nUnitsInLayer[layer] + 0.5, my nUnitsInLayer[layer], 1.0, 1.0,
0.5, my nUnitsInLayer[layer - 1] + 1 + 0.5, my nUnitsInLayer[layer - 1] + 1, 1.0, 1.0);
long node = 1;
for (long i = 0; i < layer; i++) {
node += my nUnitsInLayer[i] + 1;
}
for (long i = 1; i <= my nUnitsInLayer[layer]; i++, node++) {
long k = 1;
for (long j = my wFirst[node]; j <= my wLast[node]; j++) {
thy z[k++][i] = deltaWeights ? my dwi[j] : my w[j];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Matrix created.");
}
}
autoFFNet FFNet_weightsFromMatrix (FFNet me, Matrix him, long layer) {
try {
if (layer < 1 || layer > my nLayers) {
Melder_throw (U"Layer must be > 0 and < ", my nLayers, U".");
}
if (my nUnitsInLayer[layer] != his nx) {
Melder_throw (U"The #columns (", his nx, U") must equal #units (", my nUnitsInLayer[layer], U") in layer ", layer, U".");
}
long nunits = my nUnitsInLayer[layer - 1] + 1;
if (nunits != his ny) {
Melder_throw (U" The #rows (", his ny, U") must equal #units (", nunits , U") in layer ", layer - 1, U".");
}
autoFFNet thee = Data_copy (me);
long node = 1;
for (long i = 0; i < layer; i++) {
node += thy nUnitsInLayer[i] + 1;
}
for (long i = 1; i <= thy nUnitsInLayer[layer]; i++, node++) {
long k = 1;
for (long j = thy wFirst[node]; j <= thy wLast[node]; j++, k++) {
thy w[j] = his z[k][i];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no FFNet created.");
}
}
/* End of file FFNet_Matrix.cpp */
praat-6.0.23/FFNet/FFNet_Matrix.h 0000664 0000000 0000000 00000003052 13023464014 0016307 0 ustar 00root root 0000000 0000000 #ifndef _FFNet_Matrix_h_
#define _FFNet_Matrix_h_
/* FFNet_Matrix.h
*
* Copyright (C) 1997-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19950206
djmw 20020712 GPL header
djmw 20110307 Latest modification
*/
#include "Matrix.h"
#include "FFNet.h"
/* The Matrix organization is as follows: */
/* */
/* nx = nUnitsInLayer[layer] */
/* ny = nUnitsInLayer[layer-1]+1 */
/* xmin = 1 xmax = nx */
/* ymin = 1 ymax = ny */
/* dx = dy = 1 */
/* x1 = y1 = 1 */
/* */
autoMatrix FFNet_weightsToMatrix (FFNet me, long layer, bool deltaWeights);
/* (delta) weights connected to layer into Matrix */
autoFFNet FFNet_weightsFromMatrix (FFNet me, Matrix matrix, long layer);
/* creates a new FFNet in which the weights that connect to layer are */
/* replaced by the weights in the matrix */
#endif /* _FFNet_Matrix_h_ */
praat-6.0.23/FFNet/FFNet_PatternList.cpp 0000664 0000000 0000000 00000002062 13023464014 0017647 0 ustar 00root root 0000000 0000000 /* FFNet_PatternList.cpp
*
* Copyright (C) 1997-2011, 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19950113
djmw 20020712 GPL header
*/
#include "FFNet_PatternList.h"
void FFNet_PatternList_drawActivation (FFNet me, PatternList pattern, Graphics g, long index) {
if (index < 1 || index > pattern->ny) {
return;
}
FFNet_propagate (me, pattern->z[index], nullptr);
FFNet_drawActivation (me, g);
}
/* End of file FFNet_PatternList.cpp */
praat-6.0.23/FFNet/FFNet_PatternList.h 0000664 0000000 0000000 00000002020 13023464014 0017306 0 ustar 00root root 0000000 0000000 #ifndef _FFNet_PatternList_h_
#define _FFNet_PatternList_h_
/* FFNet_PatternList.h
*
* Copyright (C) 1997-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19950113
djmw 20020712 GPL header
djmw 20110307 Latest modification
*/
#include "PatternList.h"
#include "FFNet.h"
void FFNet_PatternList_drawActivation( FFNet me, PatternList pattern, Graphics g, long ipattern );
#endif /* _FFNet_PatternList_h_ */
praat-6.0.23/FFNet/FFNet_PatternList_ActivationList.cpp 0000664 0000000 0000000 00000015705 13023464014 0022674 0 ustar 00root root 0000000 0000000 /* FFNet_PatternList_ActivationList.cpp
*
* Copyright (C) 1994-2011,2015-2016 David Weenink, 2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19960826
djmw 20020712 GPL header
djmw 20030701 Removed non-GPL minimizations
djmw 20040416 More precise error messages.
djmw 20041118 Added FFNet_PatternList_Categories_getCosts.
*/
#include "Graphics.h"
#include "FFNet_PatternList_ActivationList.h"
static double func (Daata object, const double p[]) {
FFNet me = (FFNet) object;
Minimizer thee = my minimizer.get();
double fp = 0.0;
for (long j = 1, k = 1; k <= my nWeights; k++) {
my dw[k] = 0.0;
if (my wSelected[k]) {
my w[k] = p[j++];
}
}
for (long i = 1; i <= my nPatterns; i++) {
FFNet_propagate (me, my inputPattern[i], nullptr);
fp += FFNet_computeError (me, my targetActivation[i]);
FFNet_computeDerivative (me);
/* derivative (cumulative) */
for (long k = 1; k <= my nWeights; k++) {
my dw[k] += my dwi[k];
}
}
thy funcCalls++;
return fp;
}
static void dfunc_optimized (Daata object, const double p[], double dp[]) {
FFNet me = (FFNet) object;
(void) p;
long j = 1;
for (long k = 1; k <= my nWeights; k++) {
if (my wSelected[k]) {
dp[j++] = my dw[k];
}
}
}
static void _FFNet_PatternList_ActivationList_checkDimensions (FFNet me, PatternList p, ActivationList a) {
if (my nInputs != p -> nx) {
Melder_throw (U"The PatternList and the FFNet do not match.\nThe number of columns in the PatternList must equal the number of inputs in the FFNet.");
}
if (my nOutputs != a -> nx) {
Melder_throw (U"The Activation and the FFNet do not match.\nThe number of columns in the Activation must equal the number of outputs in the FFNet.");
}
if (p -> ny != a -> ny) {
Melder_throw (U"The PatternList and the ActivationList do not match.\nThe number of rows in the PatternList must equal the number of rows in the Activation.");
}
if (! _PatternList_checkElements (p)) {
Melder_throw (U"All PatternList elements must be in the interval [0, 1].\nYou could use \"Formula...\" to scale the PatternList values first."); }
if (! _ActivationList_checkElements (a)) {
Melder_throw (U"All Activation elements must be in the interval [0, 1].\nYou could use \"Formula...\" to scale the Activation values first.");
}
}
static void _FFNet_PatternList_ActivationList_learn (FFNet me, PatternList pattern, ActivationList activation, long maxNumOfEpochs, double tolerance, int costFunctionType, bool reset) {
try {
_FFNet_PatternList_ActivationList_checkDimensions (me, pattern, activation);
// Link the things to be learned
my nPatterns = pattern -> ny;
my inputPattern = pattern -> z;
my targetActivation = activation -> z;
FFNet_setCostFunction (me, costFunctionType);
if (reset) {
autoNUMvector wbuf (1, my dimension);
long k = 1;
for (long i = 1; i <= my nWeights; i++) {
if (my wSelected[i]) {
wbuf[k++] = my w[i];
}
}
Minimizer_reset (my minimizer.get(), wbuf.peek());
}
Minimizer_minimize (my minimizer.get(), maxNumOfEpochs, tolerance, 1);
// Unlink
my nPatterns = 0;
my inputPattern = nullptr;
my targetActivation = nullptr;
} catch (MelderError) {
my nPatterns = 0;
my inputPattern = nullptr;
my targetActivation = nullptr;
}
}
void FFNet_PatternList_ActivationList_learnSD (FFNet me, PatternList p, ActivationList a, long maxNumOfEpochs, double tolerance, double learningRate, double momentum, int costFunctionType) {
int resetMinimizer = 0;
/* Did we choose another minimizer */
if (my minimizer && ! Thing_isa (my minimizer.get(), classSteepestDescentMinimizer)) {
my minimizer.reset();
resetMinimizer = 1;
}
/* create the minimizer if it doesn't exist */
if (! my minimizer) {
resetMinimizer = 1;
my minimizer = SteepestDescentMinimizer_create (my dimension, me, func, dfunc_optimized);
}
((SteepestDescentMinimizer) my minimizer.get()) -> eta = learningRate;
((SteepestDescentMinimizer) my minimizer.get()) -> momentum = momentum;
_FFNet_PatternList_ActivationList_learn (me, p, a, maxNumOfEpochs, tolerance, costFunctionType, resetMinimizer);
}
void FFNet_PatternList_ActivationList_learnSM (FFNet me, PatternList p, ActivationList a, long maxNumOfEpochs, double tolerance, int costFunctionType) {
int resetMinimizer = 0;
// Did we choose another minimizer
if (my minimizer.get() && ! Thing_isa (my minimizer.get(), classVDSmagtMinimizer)) {
my minimizer.reset();
resetMinimizer = 1;
}
// create the minimizer if it doesn't exist
if (! my minimizer.get()) {
resetMinimizer = 1;
my minimizer = VDSmagtMinimizer_create (my dimension, me, func, dfunc_optimized);
}
_FFNet_PatternList_ActivationList_learn (me, p, a, maxNumOfEpochs, tolerance, costFunctionType, resetMinimizer);
}
double FFNet_PatternList_ActivationList_getCosts_total (FFNet me, PatternList p, ActivationList a, int costFunctionType) {
try {
_FFNet_PatternList_ActivationList_checkDimensions (me, p, a);
FFNet_setCostFunction (me, costFunctionType);
double cost = 0.0;
for (long i = 1; i <= p -> ny; i++) {
FFNet_propagate (me, p -> z[i], nullptr);
cost += FFNet_computeError (me, a -> z[i]);
}
return cost;
} catch (MelderError) {
return NUMundefined;
}
}
double FFNet_PatternList_ActivationList_getCosts_average (FFNet me, PatternList p, ActivationList a, int costFunctionType) {
double costs = FFNet_PatternList_ActivationList_getCosts_total (me, p, a, costFunctionType);
return costs == NUMundefined ? NUMundefined : costs / p -> ny;
}
autoActivationList FFNet_PatternList_to_ActivationList (FFNet me, PatternList p, long layer) {
try {
if (layer < 1 || layer > my nLayers) {
layer = my nLayers;
}
if (my nInputs != p -> nx) {
Melder_throw (U"The PatternList and the FFNet do not match. The number of colums in the PatternList (", p -> nx, U") should equal the number of inputs in the FFNet (", my nInputs, U").");
}
if (! _PatternList_checkElements (p)) {
Melder_throw (U"All PatternList elements must be in the interval [0, 1].\nYou could use \"Formula...\" to scale the PatternList values first.");
}
long nPatterns = p -> ny;
autoActivationList thee = ActivationList_create (nPatterns, my nUnitsInLayer[layer]);
for (long i = 1; i <= nPatterns; i++) {
FFNet_propagateToLayer (me, p -> z[i], thy z[i], layer);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no ActivationList created.");
}
}
/* End of file FFNet_PatternList_ActivationList.cpp */
praat-6.0.23/FFNet/FFNet_PatternList_ActivationList.h 0000664 0000000 0000000 00000003643 13023464014 0022337 0 ustar 00root root 0000000 0000000 #ifndef _FFNet_PatternList_ActivationList_h_
#define _FFNet_PatternList_ActivationList_h_
/* FFNet_PatternList_ActivationList.h
*
* Copyright (C) 1994-2011,2015-2016 David Weenink, 2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 1994.
djmw 20020712 GPL header.
djmw 20030701 Removed non-GPL minimizations.
djmw 20110714 Latest modification.
*/
#include "FFNet.h"
#include "PatternList.h"
#include "ActivationList.h"
#include "Minimizers.h"
void FFNet_PatternList_ActivationList_learnSD (FFNet me, PatternList p, ActivationList a, long maxNumOfEpochs,
double tolerance, double learningRate, double momentum, int costFunctionType);
/* Steepest Descent minimization */
void FFNet_PatternList_ActivationList_learnSM (FFNet me, PatternList p, ActivationList a, long maxNumOfEpochs,
double tolerance, int costFunctionType);
double FFNet_PatternList_ActivationList_getCosts_total (FFNet me, PatternList p, ActivationList a, int costFunctionType);
double FFNet_PatternList_ActivationList_getCosts_average (FFNet me, PatternList p, ActivationList a, int costFunctionType);
autoActivationList FFNet_PatternList_to_ActivationList (FFNet me, PatternList p, long layer);
/* Calculate the activations at a layer */
/* if (layer<1 || layer > my nLayers) layer = my nLayers; */
#endif /* _FFNet_PatternList_ActivationList_h_ */
praat-6.0.23/FFNet/FFNet_PatternList_Categories.cpp 0000664 0000000 0000000 00000010467 13023464014 0022024 0 ustar 00root root 0000000 0000000 /* FFNet_PatternList_Categories.cpp
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020712 GPL header.
djmw 20020910 changes.
djmw 20030701 Removed non-GPL minimizations.
djmw 20041118 Added FFNet_PatternList_Categories_getCosts.
*/
#include "FFNet_ActivationList_Categories.h"
#include "FFNet_PatternList_Categories.h"
#include "FFNet_PatternList_ActivationList.h"
static void _FFNet_PatternList_Categories_checkDimensions (FFNet me, PatternList p, Categories c) {
if (my nInputs != p -> nx) {
Melder_throw (U"The PatternList and the FFNet do not match.\nThe number of colums in the PatternList must equal the number of inputs in the FFNet.");
}
if (p -> ny != c->size) {
Melder_throw (U"The PatternList and the categories do not match.\nThe number of rows in the PatternList must equal the number of categories.");
}
if (! _PatternList_checkElements (p)) {
Melder_throw (U"All PatternList elements must be in the interval [0, 1].\nYou could use \"Formula...\" to scale the PatternList values first.");
}
}
double FFNet_PatternList_Categories_getCosts_total (FFNet me, PatternList p, Categories c, int costFunctionType) {
try {
_FFNet_PatternList_Categories_checkDimensions (me, p, c);
autoActivationList activation = FFNet_Categories_to_ActivationList (me, c);
return FFNet_PatternList_ActivationList_getCosts_total (me, p, activation.get(), costFunctionType);
} catch (MelderError) {
return NUMundefined;
}
}
double FFNet_PatternList_Categories_getCosts_average (FFNet me, PatternList p, Categories c, int costFunctionType) {
double costs = FFNet_PatternList_Categories_getCosts_total (me, p, c, costFunctionType);
return costs == NUMundefined ? NUMundefined : costs / p -> ny;
}
void FFNet_PatternList_Categories_learnSD (FFNet me, PatternList p, Categories c, long maxNumOfEpochs, double tolerance, double learningRate, double momentum, int costFunctionType) {
_FFNet_PatternList_Categories_checkDimensions (me, p, c);
autoActivationList activation = FFNet_Categories_to_ActivationList (me, c);
double min, max;
Matrix_getWindowExtrema (p, 0, 0, 0, 0, & min, & max);
FFNet_PatternList_ActivationList_learnSD (me, p, activation.get(), maxNumOfEpochs, tolerance, learningRate, momentum, costFunctionType);
}
void FFNet_PatternList_Categories_learnSM (FFNet me, PatternList p, Categories c, long maxNumOfEpochs, double tolerance, int costFunctionType) {
_FFNet_PatternList_Categories_checkDimensions (me, p, c);
autoActivationList activation = FFNet_Categories_to_ActivationList (me, c);
double min, max;
Matrix_getWindowExtrema (p, 0, 0, 0, 0, & min, & max);
FFNet_PatternList_ActivationList_learnSM (me, p, activation.get(), maxNumOfEpochs, tolerance, costFunctionType);
}
autoCategories FFNet_PatternList_to_Categories (FFNet me, PatternList thee, int labeling) {
try {
if (! my outputCategories) {
Melder_throw (U"The FFNet has no output categories.");
}
if (my nInputs != thy nx) {
Melder_throw (U"The number of colums in the PatternList (", thy nx, U") should equal the number of inputs in the FFNet (", my nInputs, U").");
}
if (! _PatternList_checkElements (thee)) {
Melder_throw (U"All PatternList elements must be in the interval [0, 1].\nYou could use \"Formula...\" to scale the PatternList values first.");
}
autoCategories him = Categories_create ();
for (long k = 1; k <= thy ny; k ++) {
FFNet_propagate (me, thy z [k], nullptr);
long index = FFNet_getWinningUnit (me, labeling);
autoSimpleString item = Data_copy (my outputCategories->at [index]);
his addItem_move (item.move());
}
return him;
} catch (MelderError) {
Melder_throw (me, U": no Categories created.");
}
}
/* End of file FFNet_PatternList_Categories.cpp */
praat-6.0.23/FFNet/FFNet_PatternList_Categories.h 0000664 0000000 0000000 00000003532 13023464014 0021464 0 ustar 00root root 0000000 0000000 #ifndef _FFNet_PatternList_Categories_h_
#define _FFNet_PatternList_Categories_h_
/* FFNet_PatternList_Categories.h
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19960821
djmw 20020712 GPL header
djmw 20110307 Latest mofification.
*/
#include "FFNet.h"
#include "PatternList.h"
#include "Categories.h"
#include "Minimizers.h"
void FFNet_PatternList_Categories_learnSD (FFNet me, PatternList p, Categories c, long maxNumOfEpochs,
double tolerance, double learningRate, double momentum, int costFunctionType);
/* Steepest descent */
void FFNet_PatternList_Categories_learnSM (FFNet me, PatternList p, Categories c, long maxNumOfEpochs,
double tolerance, int costFunctionType);
/* Conj. Gradient vdSmagt */
double FFNet_PatternList_Categories_getCosts_total (FFNet me, PatternList p, Categories c, int costFunctionType);
double FFNet_PatternList_Categories_getCosts_average (FFNet me, PatternList p, Categories c, int costFunctionType);
autoCategories FFNet_PatternList_to_Categories (FFNet me, PatternList p, int labeling);
/* classify the PatternList */
/* labeling = 1 : winner-takes-all */
/* labeling = 2 : stochastic */
/* Preconditions: I have labels */
#endif /* _FFNet_PatternList_Categories_h_ */
praat-6.0.23/FFNet/FFNet_def.h 0000664 0000000 0000000 00000005152 13023464014 0015604 0 ustar 00root root 0000000 0000000 /* FFNet_def.h
*
* Copyright (C) 1994-2008 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19961104
djmw 20020712 GPL header
djmw 20060529 Added version number to oo_Collection
djmw 20080122 float -> double
*/
#define ooSTRUCT FFNet
oo_DEFINE_CLASS (FFNet, Daata)
oo_LONG (nLayers) /* number of layers */
oo_LONG_VECTOR_FROM (nUnitsInLayer, 0, nLayers)
oo_INT (outputsAreLinear)
oo_INT (nonLinearityType)
oo_INT (costFunctionType)
oo_AUTO_COLLECTION (Categories, outputCategories, SimpleString, 0)
oo_LONG (nWeights) /* number of weights */
oo_DOUBLE_VECTOR (w, nWeights)
#if ! oo_READING && ! oo_WRITING && ! oo_COMPARING
oo_LONG (nNodes)
oo_LONG (nInputs)
oo_LONG (nOutputs)
oo_LONG (dimension)
#if oo_DECLARING
double (*nonLinearity) (FFNet /* me */, double /* x */, double * /* deriv */);
void *nlClosure;
double (*costFunction) (FFNet /* me */, const double * /* target */);
void *cfClosure;
#endif
#if oo_DECLARING
oo_DOUBLE (accumulatedCost)
oo_LONG (nPatterns)
oo_LONG (currentPattern)
double **inputPattern, **targetActivation;
#endif
#if oo_DECLARING || oo_DESTROYING
oo_AUTO_OBJECT (Minimizer, 0, minimizer)
#endif
oo_DOUBLE_VECTOR (activity, nNodes)
oo_LONG_VECTOR (isbias, nNodes)
oo_LONG_VECTOR (nodeFirst, nNodes)
oo_LONG_VECTOR (nodeLast, nNodes)
oo_LONG_VECTOR (wFirst, nNodes)
oo_LONG_VECTOR (wLast, nNodes)
oo_DOUBLE_VECTOR (deriv, nNodes)
oo_DOUBLE_VECTOR (error, nNodes)
oo_LONG_VECTOR (wSelected, nWeights)
oo_DOUBLE_VECTOR (dw, nWeights)
oo_DOUBLE_VECTOR (dwi, nWeights)
#endif
#if oo_READING
bookkeeping (this);
FFNet_setNonLinearity (this, nonLinearityType);
FFNet_setCostFunction (this, costFunctionType);
#endif
#if oo_COPYING
thy nonLinearity = nonLinearity;
thy nlClosure = nlClosure;
thy costFunction = costFunction;
thy cfClosure = cfClosure;
#endif
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS (FFNet)
#undef ooSTRUCT
/* End of file FFNet_def.h */
praat-6.0.23/FFNet/Makefile 0000664 0000000 0000000 00000001265 13023464014 0015314 0 ustar 00root root 0000000 0000000 # Makefile of the library "FFNet"
# David Weenink, 24 May 2016
include ../makefile.defs
CPPFLAGS = -I ../num -I ../dwtools -I ../gram -I ../fon -I ../sys -I ../dwsys -I ../stat
OBJECTS = FFNet.o \
FFNet_Eigen.o FFNet_Matrix.o FFNet_PatternList.o \
FFNet_ActivationList_Categories.o FFNet_PatternList_ActivationList.o \
FFNet_PatternList_Categories.o RBM_extensions.o \
praat_FFNet_init.o manual_FFNet.o
.PHONY: all clean
all: libFFNet.a
clean:
$(RM) $(OBJECTS)
$(RM) libFFNet.a
libFFNet.a: $(OBJECTS)
touch libFFNet.a
rm libFFNet.a
$(AR) cq libFFNet.a $(OBJECTS)
$(RANLIB) libFFNet.a
$(OBJECTS): *.h ../num/NUM.h ../sys/*.h ../dwtools/*.h ../fon/*.h ../dwsys/*.h ../stat/*.h
praat-6.0.23/FFNet/RBM_extensions.cpp 0000664 0000000 0000000 00000002521 13023464014 0017253 0 ustar 00root root 0000000 0000000 /* RBM_extensions.cpp
*
* Copyright (C) 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "RBM_extensions.h"
#include "NUM2.h"
autoActivationList RBM_PatternList_to_ActivationList (RBM me, PatternList thee) {
try {
autoActivationList activations = ActivationList_create (thy ny, my numberOfOutputNodes);
for (long ipattern = 1; ipattern <= thy ny; ipattern ++) {
RBM_PatternList_applyToInput (me, thee, ipattern);
RBM_spreadUp (me);
RBM_sampleOutput (me);
NUMvector_copyElements (my outputActivities, activations -> z [ipattern], 1, my numberOfOutputNodes);
}
return activations;
} catch (MelderError) {
Melder_throw (me, thee, U"No ActivationList created.");
}
}
/* End of file RBM_extensions.cpp */
praat-6.0.23/FFNet/RBM_extensions.h 0000664 0000000 0000000 00000001656 13023464014 0016730 0 ustar 00root root 0000000 0000000 #ifndef _RBM_extensions_h_
#define _RBM_extensions_h_
/* RBM_extensions.h
*
* Copyright (C) 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "ActivationList.h"
#include "PatternList.h"
#include "RBM.h"
autoActivationList RBM_PatternList_to_ActivationList (RBM me, PatternList thee);
#endif /* _RBM_extensions_h_ */
praat-6.0.23/FFNet/manual_FFNet.cpp 0000664 0000000 0000000 00000063544 13023464014 0016667 0 ustar 00root root 0000000 0000000 /* manual_FFNet.c
*
* Copyright (C) 1994-2013, 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020408 GPL
*/
#include "ManPagesM.h"
#include "FFNet.h"
static void drawFFNet_345 (Graphics g)
{
autoFFNet me = FFNet_create (3, 4, 0, 5, false);
FFNet_drawTopology (me.get(), g);
}
void manual_FFNet_init (ManPages me);
void manual_FFNet_init (ManPages me)
{
MAN_BEGIN (U"epoch", U"djmw", 20040428)
INTRO (U"A term that is often used in the context of machine learning. An epoch is one complete "
"presentation of the %%data set to be learned% to a learning machine.")
NORMAL (U"Learning machines like @@FFNet|feedforward neural nets@ that use iterative algorithms "
"often need many epochs during their learning phase.")
NORMAL (U"A @@Discriminant|discriminant classifier@ is also a learning machine. "
"However, in contrast with neural nets a discriminant classifier only needs one epoch to learn.")
MAN_END
MAN_BEGIN (U"Feedforward neural networks", U"djmw", 20040511)
INTRO (U"This tutorial describes the use of @FFNet feedforward neural networks in P\\s{RAAT}. ")
NORMAL (U"@@Feedforward neural networks 1. What is a feedforward neural network?|1. What is a feedforward neural network?@")
LIST_ITEM (U" @@Feedforward neural networks 1.1. The learning phase|1.1 The learning phase")
LIST_ITEM (U" @@Feedforward neural networks 1.2. The classification phase|1.2 The classification phase")
NORMAL (U"@@Feedforward neural networks 2. Quick start|2. Quick start@")
NORMAL (U"@@Feedforward neural networks 3. FFNet versus discriminant classifier|3. FFNet versus discriminant classifier@")
NORMAL (U"@@Feedforward neural networks 4. Command overview|4. Command overview@")
MAN_END
MAN_BEGIN (U"Feedforward neural networks 1. What is a feedforward neural network?", U"djmw", 20040426)
INTRO (U"A feedforward neural network is a biologically inspired classification algorithm. "
"It consist of a (possibly large) number of simple neuron-like processing %units, organized in %layers. "
"Every unit in a layer is connected with all the units in the previous layer. "
"These connections are not all equal: each connection may have a different strength or %weight. "
"The weights on these connections encode the knowledge of a network. "
"Often the units in a neural network are also called %nodes.")
NORMAL (U"Data enters at the inputs and passes through the network, layer by layer, until it arrives at the outputs. "
"During normal operation, that is when it acts as a classifier, there is no feedback between layers. "
"This is why they are called %%feedforward% neural networks. ")
NORMAL (U"In the following figure we see an example of a 2-layered network with, from top to bottom: "
"an output layer with 5 units, a %hidden layer with 4 units, respectively. The network has 3 input units.")
PICTURE (5, 5, drawFFNet_345)
NORMAL (U"The 3 inputs are shown as circles and these do not belong to any layer of the network (although the inputs "
"sometimes are considered as a virtual layer with layer number 0). Any layer that is not an output layer is a "
"%hidden layer. This network therefore has 1 hidden layer and 1 output layer. The figure also shows all the "
"connections between the units in different layers. A layer only connects to the previous layer. ")
NORMAL (U"The operation of this network can be divided into two phases:")
NORMAL (U"@@Feedforward neural networks 1.1. The learning phase|1. The learning phase")
NORMAL (U"@@Feedforward neural networks 1.2. The classification phase|2. The classification phase")
MAN_END
MAN_BEGIN (U"Feedforward neural networks 1.1. The learning phase", U"djmw", 20040428)
INTRO (U"During the learning phase the weights in the FFNet will be modified. "
"All weights are modified in such a way that when a pattern is presented, "
"the output unit with the correct category, hopefully, will have the largest output value.")
ENTRY (U"How does learning take place?")
NORMAL (U"The FFNet uses a %supervised learning algorithm: besides the input pattern, "
"the neural net also needs to know to what category the pattern belongs. "
"Learning proceeds as follows: a pattern is presented at the inputs. "
"The pattern will be transformed in its passage through the layers of the network until it "
"reaches the output layer. The units in the output layer all belong to a different category. "
"The outputs of the network as they are now are compared with the outputs as they ideally would "
"have been if this pattern were correctly classified: in the latter case "
"the unit with the correct category would have had the largest output value and the "
"output values of the other output units would have been very small. "
"On the basis of this comparison all the connection weights are modified a little bit to guarantee that, the next time "
"this same pattern is presented at the inputs, the value of the output unit that corresponds with the correct category "
"is a little bit higher than it is now and that, at the same time, the output values of all the other incorrect outputs are a "
"little bit lower than they are now. (The differences between the actual outputs and the idealized outputs "
"are propagated back from the top layer to lower layers to be used at these layers to modify connection weights. "
"This is why the term %%backpropagation network% is also often used to describe this type of neural network.)")
NORMAL (U"If you perform the procedure above once for every pattern and category pair in your data "
"set you have performed one @epoch of learning.")
NORMAL (U"The hope is that eventually, probably after many epochs, "
"the neural net will come to remember these pattern-category pairs. "
"You even hope that the neural net, when the learning phase has terminated, will be able to %generalize "
"and has learned to "
"@@FFNet & PatternList: To Categories...|classify@ correctly any unknown pattern presented to it. ")
NORMAL (U"Because real-life data often contains noise as well as partly contradictory information, "
"these hopes can be fulfilled only partly. ")
NORMAL (U"For @@FFNet & PatternList & Categories: Learn...|learning@ you "
"need to select three different objects together: a FFNet (the %classifier), "
"a PatternList (the %inputs) and a Categories (the %%correct outputs%).")
ENTRY (U"How long will the learning phase take?")
NORMAL (U"In general, this question is hard to answer. It depends on the size of the neural network, "
"the number of patterns to be learned, the number of epochs, the tolerance of the minimizer "
"and the speed of your computer, how much computing time the learning phase may take. ")
NORMAL (U"If computing time becomes excessive in your interactive environment then consider using the "
"powerful @@Scripting|scripting@ facilities in Praat to process your learning job as a batch job. ")
MAN_END
MAN_BEGIN (U"Feedforward neural networks 1.2. The classification phase", U"djmw", 20040428)
INTRO (U"In the classification phase, the weights of the network are fixed. ")
NORMAL (U"A pattern, presented at the inputs, will be transformed from layer to layer until it reaches the output layer. "
"Now classification can occur by selecting the category associated with the output unit that has "
"the largest output value. "
"For classification we only need to select an FFNet and a PatternList together and "
"choose @@FFNet & PatternList: To Categories...|To Categories...@. ")
NORMAL (U"In contrast to the @@Feedforward neural networks 1.1. The learning phase|learning phase@ classification is very fast.")
MAN_END
MAN_BEGIN (U"Feedforward neural networks 2. Quick start", U"djmw", 20040426)
INTRO (U"You may create the iris example set with the @@Create iris example...@ command "
"that you will find under the ##Feedforward neural networks# option in the #New menu. "
"Three new objects will appear in the @@List of Objects@: a @FFNet, a @Categories and "
"a @PatternList.")
NORMAL (U"The #PatternList contains the @@iris data set@ in a matrix of 150 rows by 4 columns. "
"To guarantee that every cell in the PatternList is in the [0,1] interval, all measurement "
"values were divided by 10. In the #Categories the three iris species %setosa, "
"%versicolor, and %virginica were categorized with the numbers #1, #2 and #3, respectively. "
"Because there are 4 data columns in the PatternList and 3 different iris species in the Categories, "
"the newly created #FFNet has 4 inputs and 3 outputs. "
"If you enter a positive number in one of the fields in the form, the FFNet will have "
"this number of units in a %%hidden layer%. The name of the newly created FFNet "
"will reflect its topology. If you opt for the standard setting, which is 0 hidden units, the FFNet will be named 4-3.")
ENTRY (U"Learning the iris data")
NORMAL (U"The first thing you probably might want to do is to let the #FFNet learn the association in "
"each pattern-category pair. To do this select all three objects together and choose "
"@@FFNet & PatternList & Categories: Learn...|Learn...@. "
"A form will appear, asking you to supply some settings for "
"the learning algorithm. Learning starts after you have clicked the OK button. "
"As the example network has only a small number of weights that need to be adjusted, "
"and the learning data set is very small, this will only take a very short time.")
ENTRY (U"Classification")
NORMAL (U"Now, if you are curious how well the FFNet has learned the iris data, you may select the "
"#FFNet and the #PatternList together and choose @@FFNet & PatternList: To Categories...|To Categories...@. "
"A new #Categories appears in the ##List of Objects# with the name %%4-3_iris% (if %%4-3% was the name of the FFNet and %iris% the name of the PatternList). "
"We have two different Categories in the list of objects, the topmost one has the original categories, the other "
"the categories as were assigned by the FFNet classifier. The obvious thing to do now is to compare the "
"original categories with the assigned categories by making a @@Confusion|confusion table@. "
"Select the two #Categories and choose @@Categories: To Confusion|To Confusion@ and a newly "
"created @Confusion appears. Pressing the @Info button will show you an info window with, "
"among others, the fraction correct. ")
NORMAL (U"You may also want to "
"@@Feedforward neural networks 3. FFNet versus discriminant classifier|compare the FFNet classifier with a discriminant classifier@.")
ENTRY (U"Create other neural net topologies")
NORMAL (U"With a #PatternList and a #Categories selected together, you can for example create a new #FFNet of a different topology.")
MAN_END
MAN_BEGIN (U"Feedforward neural networks 3. FFNet versus discriminant classifier", U"djmw", 20040426)
NORMAL (U"You may want to compare the FFNet classifier with a discriminant classifier. "
"Unlike the FFNet, a @@Discriminant|discriminant@ classifier does not need any iterative procedure in the "
"learning phase and can be used immediately after creation for classification. "
"The following three simple steps will give you the confusion matrix based on discriminant analysis:")
LIST_ITEM (U"1. Select the PatternList and the Categories together and choose ##To Discriminant#. "
"A newly created Discriminant will appear.")
LIST_ITEM (U"2. Select the Discriminant and the PatternList together and choose ##To Categories...#. A newly created @Categories will appear.")
LIST_ITEM (U"3. Select the two appropriate Categories and choose @@categories: To Confusion|To Confusion@. "
"A newly created @Confusion will appear. After pushing the @Info button, the info window will "
"show you the fraction correct.")
NORMAL (U"See also the @@Discriminant analysis@ tutorial for more information.")
MAN_END
MAN_BEGIN (U"Feedforward neural networks 4. Command overview", U"djmw", 20040426)
INTRO (U"FFNet commands")
ENTRY (U"Creation:")
LIST_ITEM (U"\\bu @@PatternList & Categories: To FFNet...@")
LIST_ITEM (U"\\bu @@Create FFNet...@")
ENTRY (U"Learning:")
LIST_ITEM (U"\\bu @@FFNet & PatternList & Categories: Learn...@")
LIST_ITEM (U"\\bu @@FFNet & PatternList & Categories: Learn slow...@")
ENTRY (U"Classification:")
LIST_ITEM (U"\\bu @@FFNet & PatternList: To Categories...@")
ENTRY (U"Drawing:")
LIST_ITEM (U"\\bu @@FFNet: Draw topology@")
LIST_ITEM (U"\\bu @@FFNet: Draw weights...@")
LIST_ITEM (U"\\bu @@FFNet: Draw cost history...@")
ENTRY (U"Queries")
LIST_ITEM (U"\\bu @@FFNet & PatternList & Categories: Get total costs...@")
LIST_ITEM (U"\\bu @@FFNet & PatternList & Categories: Get average costs...@")
LIST_ITEM (U"\\bu @@FFNet & PatternList & ActivationList: Get total costs...@")
LIST_ITEM (U"\\bu @@FFNet & PatternList & ActivationList: Get average costs...@")
ENTRY (U"Analysis:")
LIST_ITEM (U"\\bu ##FFNet & PatternList: To ActivationList...#")
LIST_ITEM (U"\\bu @@FFNet & PatternList & Categories: Get total costs...@")
LIST_ITEM (U"\\bu @@FFNet & PatternList & Categories: Get average costs...@")
LIST_ITEM (U"\\bu @@FFNet & PatternList & ActivationList: Get total costs...@")
LIST_ITEM (U"\\bu @@FFNet & PatternList & ActivationList: Get average costs...@")
ENTRY (U"Analysis:")
LIST_ITEM (U"\\bu ##FFNet & PatternList: To Activation...#")
ENTRY (U"Modification:")
LIST_ITEM (U"\\bu @@FFNet: Reset...@")
LIST_ITEM (U"\\bu ##FFNet: Select biases...#")
LIST_ITEM (U"\\bu ##FFNet: Select all weights#")
MAN_END
MAN_BEGIN (U"FFNet", U"djmw", 19961015)
INTRO (U"One of the @@types of objects@ in P\\s{RAAT}.")
NORMAL (U"A #FFNet models a feedforward neural net. A feedforward "
"neural net can %learn associations between its %input and its %output. "
"The @@Feedforward neural networks@ tutorial gives you an introduction to feedforward neural nets.")
MAN_END
MAN_BEGIN (U"FFNet: Draw topology", U"djmw", 19970218)
INTRO (U"You can choose this command after selecting 1 or more @FFNet's.")
ENTRY (U"Behaviour")
NORMAL (U"Draws all units and all connections of a feedforward neural net.")
MAN_END
MAN_BEGIN (U"FFNet: Draw weights...", U"djmw", 20040422)
INTRO (U"Draws the weights in a layer of the selected @FFNet feedforward neural net.")
ENTRY (U"Settings")
TAG (U"##Layer number")
DEFINITION (U"determines the layer.")
TAG (U"##Garnish")
DEFINITION (U"determines whether additional information is drawn.")
ENTRY (U"Behaviour")
NORMAL (U"The weights are arranged in a matrix. The columns of this matrix are indexed by the units in the layer, "
"while the rows are indexed by the units in the previous layer. There is one extra row for the biases."
"The values of the weights are shown as rectangles. The area of a rectangle is proportional "
"to the value. Negative values are shown as filled black rectangles.")
MAN_END
MAN_BEGIN (U"FFNet: Draw cost history...", U"djmw", 19970218)
INTRO (U"You can choose this command after selecting 1 or more @FFNet's.")
ENTRY (U"Settings")
TAG (U"##Iteration range")
DEFINITION (U"determines the horizontal range of the plot.")
TAG (U"##Cost range")
DEFINITION (U"determines the vertical range of the plot.")
TAG (U"##Garnish")
DEFINITION (U"determines whether a box and axis labels are drawn.")
ENTRY (U"Behaviour")
NORMAL (U"Draws the history of the cost versus iteration number during previous learning.")
MAN_END
MAN_BEGIN (U"FFNet: Extract weights...", U"djmw", 20040422)
INTRO (U"Extract all the weights, from all the units in the specified layer of the selected "
"@FFNet, to a @TableOfReal.")
ENTRY (U"Settings")
TAG (U"##Layer number")
DEFINITION (U"determines the layer.")
ENTRY (U"Behaviour")
NORMAL (U"The weights will be arranged in the TableOfReal as follows: ")
NORMAL (U"The table columns will be indexed by the unit numbers in the selected layer, "
"while the rows will be indexed by the unit numbers from the previous layer. "
"There will be one extra row to accommodate the bias weights. "
"The rows and columns are labelled with layer number and unit number as \"L%i-%j\", where %i is the layer number and "
"%j the unit number from that layer. The layer number for the rows is one less than the layer number in the columns. "
"The last row is labelled as \"Bias\".")
MAN_END
MAN_BEGIN (U"FFNet: Get number of outputs", U"djmw", 20040420)
INTRO (U"Queries the selected @FFNet for the number of output units in the output layer. ")
MAN_END
MAN_BEGIN (U"FFNet: Get number of inputs", U"djmw", 20040420)
INTRO (U"Queries the selected @FFNet for the number of inputs. ")
NORMAL (U"For a network with only one layer, the inputs are connected directly to the output layer. "
"In a two-layer network the inputs are connected to a hidden layer.")
MAN_END
MAN_BEGIN (U"FFNet: Get number of hidden units...", U"djmw", 20040420)
INTRO (U"Queries the selected @FFNet for the number of units in a hidden layer.")
ENTRY (U"Settings")
TAG (U"##Hidden layer number")
DEFINITION (U"determines the layer that is queried.")
ENTRY (U"Layer numbering")
NORMAL (U"The number of hidden layers is always one less than the total number of layers in a FFNet. "
"A network with the output units connected to the inputs therefore has only 1 layer, the output layer and "
"no hidden layers. ")
MAN_END
MAN_BEGIN (U"FFNet: Get number of hidden weights...", U"djmw", 20040420)
INTRO (U"Queries the selected @FFNet for the number of weights in a hidden layer.")
ENTRY (U"Settings")
TAG (U"##Hidden layer number")
DEFINITION (U"determines the layer that is queried.")
MAN_END
MAN_BEGIN (U"FFNet: Reset...", U"djmw", 20040420)
INTRO (U"You can choose this command after selecting 1 or more @FFNet's.")
ENTRY (U"WARNING")
NORMAL (U"This command destroys all previous learning.")
ENTRY (U"Settings")
TAG (U"##Range")
DEFINITION (U"determines the upper limit of the [-%range, +%range] interval from "
"which new weights will be randomly selected.")
ENTRY (U"Behaviour")
NORMAL (U"All (selected) weights are reset to random numbers uniformly drawn from the interval [-%range, +%range]. "
"This command also clears the cost history.")
MAN_END
MAN_BEGIN (U"FFNet: Select biases...", U"djmw", 20040422)
INTRO (U"Selects only the biases in one particular layer as subject for modification during learning of the @FFNet.")
ENTRY (U"Settings")
TAG (U"##Layer number")
DEFINITION (U"determines the layer whose biases will be modified.")
ENTRY (U"Behaviour")
NORMAL (U"This command induces very specific behaviour during a following learning phase. "
"Instead of all the weights, only the biases in the specified layer will be changed during learning and the "
"rest of the weights stay fixed. ")
MAN_END
#define FFNet_Create_COMMON_HELP_INOUT \
ENTRY (U"Settings")\
TAG (U"##Number of inputs")\
DEFINITION (U"the dimension of the input of the neural net.")\
TAG (U"##Number of outputs (\\>_ 1)#")\
DEFINITION (U"the number of different categories that you want the net to learn.")
#define FFNet_Create_COMMON_HELP_HIDDEN \
TAG (U"##Number of units in hidden layer 1#, ##Number of units in hidden layer 2#") \
DEFINITION (U"determine the number of units in the hidden layers. " \
"If you want a neural net with no hidden layers, both numbers have to be 0. "\
"If you want a neural net with only 1 hidden layer then one of these numbers has to differ from 0. ")
MAN_BEGIN (U"Create FFNet...", U"djmw", 20040420)
INTRO (U"Create a new feedforward neural net of type @FFNet.")
FFNet_Create_COMMON_HELP_INOUT
FFNet_Create_COMMON_HELP_HIDDEN
MAN_END
MAN_BEGIN (U"Create FFNet (linear outputs)...", U"djmw", 20040422)
INTRO (U"Create a @FFNet feedforward neural network whose output units are linear.")
FFNet_Create_COMMON_HELP_INOUT
FFNet_Create_COMMON_HELP_HIDDEN
MAN_END
MAN_BEGIN (U"Create iris example...", U"djmw", 20160524)
INTRO (U"A @FFNet feedforward neural net will be created together with two other objects: "
"a @PatternList and a @Categories. The PatternList will contain the observations in the @@iris data set@, "
"and the Categories will contain the 3 different iris species categorized by numbers.")
ENTRY (U"Settings")
FFNet_Create_COMMON_HELP_HIDDEN
NORMAL (U"For this simple data you can leave both hidden layers empty.")
MAN_END
MAN_BEGIN (U"iris data set", U"djmw", 19961015)
NORMAL (U"A data set with 150 random samples of flowers from the iris species %setosa, "
"%versicolor, and %virginica collected by @@Anderson (1935)@. From each species there are 50 observations for "
"sepal length, sepal width, petal length, and petal width in cm. This dataset was "
"used by @@Fisher (1936)@ in his initiation of the linear-discriminant-function technique.")
MAN_END
MAN_BEGIN (U"FFNet: Categories", U"djmw", 19960918)
INTRO (U"The categories for training a neural net with a @PatternList. ")
ENTRY (U"Preconditions")
NORMAL (U"The number of categories in a @Categories must equal the number of rows in #PatternList.")
MAN_END
MAN_BEGIN (U"ActivationList", U"djmw", 20160524)
INTRO (U"A list of activations, organized as a @Matrix whose elements must be >= 0 and <= 1. "
"Classification: the response of a particular layer in a neural net to a @PatternList."
"Learning: the desired response of the output layer in a neural net to a @PatternList.")
MAN_END
MAN_BEGIN (U"FFNet: Principal components", U"djmw", 19960918)
INTRO (U"When you select @FFNet and @Eigen the decision planes of layer 1 are drawn in the PC-plane.\n")
MAN_END
MAN_BEGIN (U"FFNet & PatternList: To Categories...", U"djmw", 19960918)
INTRO (U"The @FFNet is used as a classifier. Each pattern from the @PatternList will be "
"classified into one of the FFNet's categories.")
MAN_END
MAN_BEGIN (U"PatternList & Categories: To FFNet...", U"djmw", 20040422)
INTRO (U"Create a new @FFNet feedforward neural network. "
"The number of inputs of the newly created FFNet will be equal to the number of "
"columns in the @PatternList and the number of outputs "
"will be equal to the number of unique categories in the @Categories.")
ENTRY (U"Settings")
FFNet_Create_COMMON_HELP_HIDDEN
MAN_END
MAN_BEGIN (U"FFNet & PatternList & Categories: Learn slow...", U"djmw", 19960918)
INTRO (U"To learn an association you have to select a @FFNet, a @PatternList and a @Categories object.")
ENTRY (U"Preconditions")
LIST_ITEM (U"The number of columns in a #PatternList must equal the number of input units of #FFNet.")
ENTRY (U" Algorithm")
NORMAL (U"Steepest descent")
ENTRY (U"Preconditions")
LIST_ITEM (U"The number of rows in a #PatternList must equal the number of categories in a #Categories.")
LIST_ITEM (U"The number of unique categories in a #Categories must equal the number of output units in #FFNet.")
MAN_END
MAN_BEGIN (U"FFNet & PatternList & Categories: Learn...", U"djmw", 20040511)
INTRO (U"You can choose this command after selecting one @PatternList, one @Categories and one @FFNet.")
ENTRY (U"Settings")
TAG (U"##Maximum number of epochs")
DEFINITION (U"the maximum number of times that the complete #PatternList dataset will be presented to the neural net.")
TAG (U"##Tolerance of minimizer")
DEFINITION (U"when the difference in costs between two successive learning cycles is "
"smaller than this value, the minimization process will be stopped.")
NORMAL (U"##Cost function")
LIST_ITEM (U"Minimum-squared-error:")
LIST_ITEM (U" %costs = \\su__%allPatterns_ \\su__%allOutputs_ (%o__%k_ - d__%k_)^2, where")
LIST_ITEM (U" %o__%k_ : actual output of unit %k")
LIST_ITEM (U" %d__%k_ : desired output of unit %k")
LIST_ITEM (U"Minimum-cross-entropy:")
LIST_ITEM (U" %costs = - \\su__%allPatterns_ \\su__%allOutputs_ (%d__%k_ \\.c ln %o__%k_ + (1-%d__%k_) \\.c ln (1-%o__%k_))")
ENTRY (U"Algorithm")
NORMAL (U"The minimization procedure is a variant of conjugate gradient minimization, "
"see for example @@Press et al. (1992)@, chapter 10, or @@Nocedal & Wright (1999)@, chapter 5.")
MAN_END
MAN_BEGIN (U"FFNet & PatternList & Categories: Get total costs...", U"djmw", 20041118)
INTRO (U"Query the selected @FFNet, @PatternList and @Categories for the total costs.")
ENTRY (U"Algorithm")
NORMAL (U"All patterns are propagated and the total costs are calculated as is shown in @@FFNet & PatternList & Categories: Learn...@. ")
MAN_END
MAN_BEGIN (U"FFNet & PatternList & ActivationList: Get total costs...", U"djmw", 20160524)
INTRO (U"Query the selected @FFNet, @PatternList and @ActivationList for the total costs.")
ENTRY (U"Algorithm")
NORMAL (U"All patterns are propagated and the total costs are calculated as is shown in @@FFNet & PatternList & Categories: Learn...@. ")
MAN_END
MAN_BEGIN (U"FFNet & PatternList & Categories: Get average costs...", U"djmw", 20041118)
INTRO (U"Query the selected @FFNet, @PatternList and @Categories for the average costs.")
ENTRY (U"Algorithm")
NORMAL (U"All patterns are propagated and the total costs are calculated as is shown in @@FFNet & PatternList & Categories: Learn...@. "
"These total costs are then divided by the number of patterns.")
MAN_END
MAN_BEGIN (U"FFNet & PatternList & ActivationList: Get average costs...", U"djmw", 20160526)
INTRO (U"Query the selected @FFNet, @PatternList and @ActivationList for the average costs.")
ENTRY (U"Algorithm")
NORMAL (U"All patterns are propagated and the total costs are calculated as is shown in @@FFNet & PatternList & Categories: Learn...@. "
"These total costs are then divided by the number of patterns.")
MAN_END
MAN_BEGIN (U"Anderson (1935)", U"djmw", 20040423)
NORMAL (U"E. Anderson (1935): \"The irises of the Gasp\\e' peninsula.\" "
"%%Bulletin of the American Iris Society% #59: 2\\--5.")
MAN_END
MAN_BEGIN (U"Fisher (1936)", U"djmw", 19980114)
NORMAL (U"R.A. Fisher (1936): \"The use of multiple measurements in taxonomic "
"problems.\" %%Annals of Eugenics% #7: 179\\--188.")
MAN_END
MAN_BEGIN (U"Nocedal & Wright (1999)", U"djmw", 20040511)
NORMAL (U"J. Nocedal & S.J. Wright (1999): %%Numerical optimization.% Springer.")
MAN_END
}
/* End of file manual_FFNet.c */
praat-6.0.23/FFNet/praat_FFNet.h 0000664 0000000 0000000 00000002201 13023464014 0016145 0 ustar 00root root 0000000 0000000 #ifndef _praat_FFNet_h_
#define _praat_FFNet_h_
/* praat_FFNet.h
*
* Copyright (C) 2016 David Weenink & Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
Interface functions for time-based subclasses of Function.
*/
#include "FFNet.h"
#include "praat.h"
void praat_uvafon_FFNet_init ();
/*
Special request from contrib/Ola, who wants to include these commands in the KNN menu.
*/
extern "C" void NEW1_PatternList_create (UiCallback_ARGS);
extern "C" void NEW1_Categories_create (UiCallback_ARGS);
/* End of file praat_FFNet.h */
#endif
praat-6.0.23/FFNet/praat_FFNet_init.cpp 0000664 0000000 0000000 00000065304 13023464014 0017540 0 ustar 00root root 0000000 0000000 /* praat_FFNet_init.cpp
*
* Copyright (C) 1994-2011, 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020408 GPL
djmw 20020408 added FFNet_help
djmw 20030701 Removed non-GPL minimizations
djmw 20040526 Removed bug in FFNet_drawCostHistory interface.
djmw 20041123 Latest modification
djmw 20061218 Changed to Melder_information format.
djmw 20080902 Melder_error<1...>
djmw 20071011 REQUIRE requires U"".
djmw 20071024 Use MelderString_append in FFNet_createNameFromTopology
djmw 20100511 FFNet query outputs
*/
#include
#include "Discriminant.h"
#include "PCA.h"
#include "Minimizers.h"
#include "FFNet_Eigen.h"
#include "FFNet_Matrix.h"
#include "FFNet_PatternList.h"
#include "FFNet_ActivationList_Categories.h"
#include "FFNet_PatternList_ActivationList.h"
#include "FFNet_PatternList_Categories.h"
#include "RBM_extensions.h"
#include "praat_FFNet.h"
/* Routines to be removed sometime in the future:
20040422, 2.4.04: FFNet_drawWeightsToLayer use FFNet_drawWeights
20040422, 2.4.04: FFNet_weightsToMatrix use FFNet_extractWeights
*/
#undef iam
#define iam iam_LOOP
static char32 const *QUERY_BUTTON = U"Query -";
static char32 const *DRAW_BUTTON = U"Draw -";
static char32 const *MODIFY_BUTTON = U"Modify -";
static char32 const *EXTRACT_BUTTON = U"Extract -";
/**************** New FFNet ***************************/
FORM (NEW1_FFNet_create, U"Create FFNet", U"Create FFNet...") {
WORDVAR (name, U"Name", U"4-3")
NATURALVAR (numberOfInputs, U"Number of inputs", U"4")
NATURALVAR (numberOfOutputs, U"Number of outputs", U"3")
INTEGERVAR (numberOfUnits1, U"Number of units in hidden layer 1", U"0")
INTEGERVAR (numberOfUnits2, U"Number of units in hidden layer 2", U"0")
OK
DO
CREATE_ONE
autoFFNet result = FFNet_create (numberOfInputs, numberOfUnits1, numberOfUnits2, numberOfOutputs, false);
CREATE_ONE_END (name);
}
FORM (NEWMANY_FFNet_createIrisExample, U"Create iris example", U"Create iris example...") {
LABEL (U"", U"For the feedforward neural net we need to know the:")
INTEGERVAR (numberOfUnits1, U"Number of units in hidden layer 1", U"0")
INTEGERVAR (numberOfUnits2, U"Number of units in hidden layer 2", U"0")
OK
DO
autoCollection result = FFNet_createIrisExample (numberOfUnits1, numberOfUnits2);
praat_new (result.move());
END }
FORM (NEW1_FFNet_create_linearOutputs, U"Create FFNet", U"Create FFNet (linear outputs)...") {
WORDVAR (name, U"Name", U"4-3")
NATURALVAR (numberOfInputs, U"Number of inputs", U"4")
NATURALVAR (numberOfOutputs, U"Number of outputs", U"3")
INTEGERVAR (numberOfUnits1, U"Number of units in hidden layer 1", U"0")
INTEGERVAR (numberOfUnits2, U"Number of units in hidden layer 2", U"0")
OK
DO
CREATE_ONE
autoFFNet result = FFNet_create (numberOfInputs, numberOfUnits1, numberOfUnits2, numberOfOutputs, true);
CREATE_ONE_END (name);
}
/**************** New PatternList ***************************/
FORM (NEW1_PatternList_create, U"Create PatternList", nullptr) {
WORDVAR (name, U"Name", U"1x1")
NATURALVAR (patternDimension, U"Dimension of a pattern", U"1")
NATURALVAR (numberOfPatterns, U"Number of patterns", U"1")
OK
DO
CREATE_ONE
autoPatternList result = PatternList_create (numberOfPatterns, patternDimension);
CREATE_ONE_END (name);
}
/**************** New Categories ***************************/
FORM (NEW1_Categories_create, U"Create Categories", nullptr) {
WORDVAR (name, U"Name", U"empty")
OK
DO
CREATE_ONE
autoCategories result = Categories_create ();
CREATE_ONE_END (name);
}
DIRECT (HELP_FFNet_help) {
HELP (U"Feedforward neural networks")
}
DIRECT (GRAPHICS_FFNet_drawTopology) {
GRAPHICS_EACH (FFNet)
FFNet_drawTopology (me, GRAPHICS);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_FFNet_drawWeights, U"FFNet: Draw weights", U"FFNet: Draw weights...") {
NATURALVAR (layer, U"Layer number", U"1")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (FFNet)
FFNet_drawWeights (me, GRAPHICS, layer, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_FFNet_drawWeightsToLayer, U"FFNet: Draw weights to layer", nullptr) {
LABEL (U"", U"Warning: Disapproved. Use \"Draw weights..\" instead.")
NATURALVAR (layer, U"Layer number", U"1")
RADIOVAR (scale, U"Scale", 1)
RADIOBUTTON (U"by maximum of all weights to layer")
RADIOBUTTON (U"by maximum weight from 'from-unit'")
RADIOBUTTON (U"by maximum weight to 'to-unit'")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (FFNet)
FFNet_drawWeightsToLayer (me, GRAPHICS, layer, scale, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_FFNet_drawCostHistory, U"FFNet: Draw cost history", U"FFNet: Draw cost history...") {
INTEGERVAR (fromIteration, U"left Iteration_range", U"0")
INTEGERVAR (toIteration, U"right Iteration_range", U"0")
REALVAR (fromCost, U"left Cost_range", U"0.0")
REALVAR (toCost, U"right Cost_range", U"0.0")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (FFNet)
FFNet_drawCostHistory (me, GRAPHICS, fromIteration, toIteration, fromCost, toCost, garnish);
GRAPHICS_EACH_END
}
DIRECT (INTEGER_FFNet_getNumberOfLayers) {
INTEGER_ONE (FFNet)
long result = my nLayers;
INTEGER_ONE_END (U" layer", (my nLayers > 1 ? U"s" : U""))
}
DIRECT (INTEGER_FFNet_getNumberOfOutputs) {
INTEGER_ONE (FFNet)
long result = my nUnitsInLayer[my nLayers];
INTEGER_ONE_END (U" units")
}
FORM (INTEGER_FFNet_getNumberOfHiddenUnits, U"FFNet: Get number of hidden units", U"FFNet: Get number of hidden units...") {
NATURALVAR (layer, U"Hidden layer number", U"1")
OK
DO
INTEGER_ONE (FFNet)
long result = layer > 0 && layer <= my nLayers - 1 ? my nUnitsInLayer[layer] : 0;
INTEGER_ONE_END (U" units")
}
DIRECT (INTEGER_FFNet_getNumberOfInputs) {
INTEGER_ONE (FFNet)
long result = my nUnitsInLayer[0];
INTEGER_ONE_END (U" units")
}
FORM (INTEGER_FFNet_getNumberOfHiddenWeights, U"FFNet: Get number of hidden weights", U"FFNet: Get number of hidden weights...") {
NATURALVAR (layer, U"Hidden layer number", U"1")
OK
DO
INTEGER_ONE (FFNet)
long result = (layer > 0 && layer <= my nLayers - 1) ? (my nUnitsInLayer[layer] * (my nUnitsInLayer[layer - 1] + 1)) : 0;
INTEGER_ONE_END (U" weights (including biases)")
}
DIRECT (INTEGER_FFNet_getNumberOfOutputWeights) {
INTEGER_ONE (FFNet)
long result = my nUnitsInLayer[my nLayers] * (my nUnitsInLayer[my nLayers - 1] + 1);
INTEGER_ONE_END (U" weights");
}
FORM (INFO_FFNet_getCategoryOfOutputUnit, U"FFNet: Get category of output unit", nullptr) {
NATURALVAR (outputUnit, U"Output unit", U"1")
OK
DO
STRING_ONE (FFNet)
const char32 *result = FFNet_getCategoryOfOutputUnit (me, outputUnit);
STRING_ONE_END
}
FORM (INTEGER_FFNet_getOutputUnitOfCategory, U"FFNet: Get output unit of category", nullptr) {
SENTENCEVAR (category, U"Category", U"u")
OK
DO
INTEGER_ONE (FFNet)
long result = FFNet_getOutputUnitOfCategory (me, category);
INTEGER_ONE_END (U" (output unit)")
}
FORM (REAL_FFNet_getBias, U"FFNet: Get bias", nullptr) {
NATURALVAR (layer, U"Layer", U"1")
NATURALVAR (unit, U"Unit", U"1")
OK
DO
NUMBER_ONE (FFNet)
double result = FFNet_getBias (me, layer, unit);
NUMBER_ONE_END (U" (bias)")
}
FORM (REAL_FFNet_getWeight, U"FFNet: Get weight", nullptr) {
NATURALVAR (layer, U"Layer", U"1")
NATURALVAR (unitTo, U"Unit", U"1")
NATURALVAR (unitFrom, U"Unit from", U"1")
OK
DO
NUMBER_ONE (FFNet)
double result = FFNet_getWeight (me, layer, unitTo, unitFrom);
NUMBER_ONE_END (U"(weight between unit ", unitTo, U" in layer ", layer, U", and unit ", unitFrom, U"in layer ", layer - 1, U")")
}
DIRECT (REAL_FFNet_getMinimum) {
NUMBER_ONE (FFNet)
double result = FFNet_getMinimum (me);
NUMBER_ONE_END (U" (minimum)");
}
FORM (MODIFY_FFNet_setBias, U"FFNet: Set bias", nullptr) {
NATURALVAR (layer, U"Layer", U"1")
NATURALVAR (unit, U"Unit", U"1")
REALVAR (value, U"Value", U"0.0")
OK
DO
MODIFY_EACH (FFNet)
FFNet_setBias (me, layer, unit, value);
MODIFY_EACH_END
}
FORM (MODIFY_FFNet_setWeight, U"FFNet: Set weight", nullptr) {
NATURALVAR (layer, U"Layer", U"1")
NATURALVAR (unitTo, U"Unit", U"1")
NATURALVAR (unitFrom, U"Unit (from)", U"1")
REALVAR (value, U"Value", U"0.0")
OK
DO
MODIFY_EACH (FFNet)
FFNet_setWeight (me, layer, unitTo, unitFrom, value);
MODIFY_EACH_END
}
FORM (MODIFY_FFNet_reset, U"FFNet: Reset", U"FFNet: Reset...") {
LABEL (U"", U"Warning: this command destroys all previous learning.")
LABEL (U"", U"New weights will be randomly chosen from the interval [-range, +range].")
POSITIVEVAR (range, U"Range", U"0.1")
OK
DO
MODIFY_EACH (FFNet)
FFNet_reset (me, range);
MODIFY_EACH_END
}
FORM (MODIFY_FFNet_selectBiasesInLayer, U"FFNet: Select biases", U"FFNet: Select biases...") {
LABEL (U"", U"WARNING: This command induces very specific behaviour ")
LABEL (U"", U"during a following learning phase.")
NATURALVAR (layer, U"Layer number", U"1")
OK
DO
MODIFY_EACH (FFNet)
FFNet_selectBiasesInLayer (me, layer);
MODIFY_EACH_END
}
DIRECT (MODIFY_FFNet_selectAllWeights) {
MODIFY_EACH (FFNet)
FFNet_selectAllWeights (me);
MODIFY_EACH_END
}
FORM (NEW_FFNet_extractWeights, U"FFNet: Extract weights", U"FFNet: Extract weights...") {
NATURALVAR (layer, U"Layer number", U"1")
OK
DO
CONVERT_EACH (FFNet)
autoTableOfReal result = FFNet_extractWeights (me, layer);
CONVERT_EACH_END (my name)
}
FORM (NEW_FFNet_weightsToMatrix, U"FFNet: Weights to Matrix ", nullptr) {
LABEL (U"", U"Warning: Use \"Extract weights..\" instead.")
NATURALVAR (layer, U"Layer number", U"1")
OK
DO
CONVERT_EACH (FFNet)
autoMatrix result = FFNet_weightsToMatrix (me, layer, false);
CONVERT_EACH_END (my name)
}
DIRECT (HINT_hint_FFNet_and_PatternList_classify) {
Melder_information (U"You can use the FFNet as a classifier by selecting a\n"
"FFNet and a PatternList together and choosing \"To Categories...\".");
END }
DIRECT (HINT_hint_FFNet_and_PatternList_and_Categories_learn) {
Melder_information (U"You can teach a FFNet to classify by selecting a\n"
"FFNet, a PatternList and a Categories together and choosing \"Learn...\".");
END }
/******************* FFNet && ActivationList ******************************************/
FORM (NEW1_FFNet_ActivationList_to_Categories, U"FFNet & ActivationList: To Categories", 0) {
RADIOVAR (categorizationgMethod, U"Categorization method", 1)
RADIOBUTTON (U"Winner-takes-all")
RADIOBUTTON (U"Stochastic")
OK
DO
CONVERT_TWO (FFNet, ActivationList)
autoCategories result = FFNet_ActivationList_to_Categories (me, you, categorizationgMethod);
CONVERT_TWO_END (my name, U"_", you -> name)
}
/******************* FFNet && Eigen ******************************************/
FORM (GRAPHICS_FFNet_Eigen_drawIntersection, U"FFnet & Eigen: Draw intersection", 0) {
NATURALVAR (pcx, U"X-component", U"1")
NATURALVAR (pcy, U"Y-component", U"2")
REALVAR (xmin, U"Xmin", U"0.0")
REALVAR (xmax, U"Xmax", U"0.0")
REALVAR (ymin, U"Ymin", U"0.0")
REALVAR (ymax, U"Ymax", U"0.0")
OK
DO
GRAPHICS_TWO (FFNet, Eigen)
FFNet_Eigen_drawIntersection (me, you, GRAPHICS, pcx, pcy, xmin, xmax, ymin, ymax);
GRAPHICS_TWO_END
}
/************************* FFNet && Categories **********************************/
DIRECT (NEW1_FFNet_Categories_to_ActivationList) {
CONVERT_TWO (FFNet, Categories)
autoActivationList result = FFNet_Categories_to_ActivationList (me, you);
CONVERT_TWO_END (my name);
}
/************************* FFNet && Matrix **********************************/
FORM (NEW1_FFNet_weightsFromMatrix, U"Replace weights by values from Matrix", nullptr) {
NATURALVAR (layer, U"Layer", U"1")
OK
DO
CONVERT_TWO (FFNet, Matrix)
autoFFNet result = FFNet_weightsFromMatrix (me, you, layer);
CONVERT_TWO_END (my name);
}
/************************* FFNet && PatternList **********************************/
FORM (GRAPHICS_FFNet_PatternList_drawActivation, U"Draw an activation", nullptr) {
NATURALVAR (row, U"PatternList (row) number", U"1");
OK
DO
GRAPHICS_TWO (FFNet, PatternList)
FFNet_PatternList_drawActivation (me, you, GRAPHICS, row);
GRAPHICS_TWO_END
}
FORM (NEW1_FFNet_PatternList_to_Categories, U"FFNet & PatternList: To Categories", U"FFNet & PatternList: To Categories...") {
RADIOVAR (categorizationgMethod, U"Categorization method", 1)
RADIOBUTTON (U"Winner-takes-all")
RADIOBUTTON (U"Stochastic")
OK
DO
GRAPHICS_TWO (FFNet, PatternList)
autoCategories result = FFNet_PatternList_to_Categories (me, you, categorizationgMethod);
CONVERT_TWO_END (my name, U"_", you -> name)
}
FORM (NEW1_FFNet_PatternList_to_ActivationList, U"To activations in layer", nullptr) {
NATURALVAR (layer, U"Layer", U"1")
OK
DO
GRAPHICS_TWO (FFNet, PatternList)
autoActivationList result = FFNet_PatternList_to_ActivationList (me, you, layer);
CONVERT_TWO_END (my name, U"_", you -> name)
}
/*********** FFNet & PatternList & ActivationList **********************************/
FORM (REAL_FFNet_PatternList_ActivationList_getTotalCosts, U"FFNet & PatternList & ActivationList: Get total costs", U"FFNet & PatternList & ActivationList: Get total costs...") {
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
NUMBER_THREE (FFNet, PatternList, ActivationList)
double result = FFNet_PatternList_ActivationList_getCosts_total (me, you, him, costFunctionType);
NUMBER_THREE_END (U"")
}
FORM (REAL_FFNet_PatternList_ActivationList_getAverageCosts, U"FFNet & PatternList & ActivationList: Get average costs", U"FFNet & PatternList & ActivationList: Get average costs...") {
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
NUMBER_THREE (FFNet, PatternList, ActivationList)
double result = FFNet_PatternList_ActivationList_getCosts_average (me, you, him, costFunctionType);
NUMBER_THREE_END (U"")
}
FORM (MODIFY_FFNet_PatternList_ActivationList_learn, U"FFNet & PatternList & ActivationList: Learn", nullptr) {
// NATURAL (U"Layer", U"1")
NATURALVAR (maximumNumberOfEpochs, U"Maximum number of epochs", U"100")
POSITIVEVAR (tolerance, U"Tolerance of minimizer", U"1e-7")
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
MODIFY_FIRST_OF_THREE (FFNet, PatternList, ActivationList)
FFNet_PatternList_ActivationList_learnSM (me, you, him, maximumNumberOfEpochs, tolerance, costFunctionType);
MODIFY_FIRST_OF_THREE_END
}
FORM (MODIFY_FFNet_PatternList_ActivationList_learnSlow, U"FFNet & PatternList & ActivationList: Learn slow", nullptr) {
// NATURAL (U"Layer", U"1")
NATURALVAR (maximumNumberOfEpochs, U"Maximum number of epochs", U"100")
POSITIVEVAR (tolerance, U"Tolerance of minimizer", U"1e-7")
LABEL (U"Specifics", U"Specific for this minimization")
POSITIVEVAR (learningRate, U"Learning rate", U"0.1")
REALVAR (momentum, U"Momentum", U"0.9")
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
MODIFY_FIRST_OF_THREE (FFNet, PatternList, ActivationList)
FFNet_PatternList_ActivationList_learnSD (me, you, him, maximumNumberOfEpochs, tolerance, learningRate, momentum, costFunctionType);
MODIFY_FIRST_OF_THREE_END
}
/*********** FFNet & PatternList & Categories **********************************/
FORM (REAL_FFNet_PatternList_Categories_getTotalCosts, U"FFNet & PatternList & Categories: Get total costs", U"FFNet & PatternList & Categories: Get total costs...") {
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
NUMBER_THREE (FFNet, PatternList, Categories)
double result = FFNet_PatternList_Categories_getCosts_total (me, you, him, costFunctionType);
NUMBER_THREE_END (U" (total costs)")
}
FORM (REAL_FFNet_PatternList_Categories_getAverageCosts, U"FFNet & PatternList & Categories: Get average costs", U"FFNet & PatternList & Categories: Get average costs...") {
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
NUMBER_THREE (FFNet, PatternList, Categories)
double result = FFNet_PatternList_Categories_getCosts_average (me, you, him, costFunctionType);
NUMBER_THREE_END (U" (average costs)")
}
FORM (MODIFY_FFNet_PatternList_Categories_learn, U"FFNet & PatternList & Categories: Learn", U"FFNet & PatternList & Categories: Learn...") {
NATURALVAR (maximumNumberOfEpochs, U"Maximum number of epochs", U"100")
POSITIVEVAR (tolerance, U"Tolerance of minimizer", U"1e-7")
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
MODIFY_FIRST_OF_THREE (FFNet, PatternList, Categories)
FFNet_PatternList_Categories_learnSM (me, you, him, maximumNumberOfEpochs, tolerance, costFunctionType);
MODIFY_FIRST_OF_THREE_END
}
FORM (MODIFY_FFNet_PatternList_Categories_learnSlow, U"FFNet & PatternList & Categories: Learn slow", U"FFNet & PatternList & Categories: Learn slow...") {
NATURALVAR (maximumNumberOfEpochs, U"Maximum number of epochs", U"100")
POSITIVEVAR (tolerance, U"Tolerance of minimizer", U"1e-7")
LABEL (U"Specifics", U"Specific for this minimization")
POSITIVEVAR (learningRate, U"Learning rate", U"0.1")
REALVAR (momentum, U"Momentum", U"0.9")
RADIOVAR (costFunctionType, U"Cost function", 1)
RADIOBUTTON (U"Minimum-squared-error")
RADIOBUTTON (U"Minimum-cross-entropy")
OK
DO
MODIFY_FIRST_OF_THREE (FFNet, PatternList, Categories)
FFNet_PatternList_Categories_learnSD (me, you, him, maximumNumberOfEpochs,tolerance, learningRate, momentum, costFunctionType);
MODIFY_FIRST_OF_THREE_END
}
/*********** FFNet & PCA **********************************/
FORM (GRAPHICS_FFNet_PCA_drawDecisionPlaneInEigenspace, U"FFNet & PCA: Draw decision plane", nullptr) {
NATURALVAR (unitNumber, U"Unit number", U"1")
NATURALVAR (layer, U"Layer number", U"1")
NATURALVAR (horizontalEigenvectorNumber, U"Horizontal eigenvector number", U"1")
NATURALVAR (verticalEigenvectorNumber, U"Vertical eigenvector number", U"2")
REALVAR (xmin, U"left Horizontal range", U"0.0")
REALVAR (xmax, U"right Horizontal range", U"0.0")
REALVAR (ymin, U"left Vertical range", U"0.0")
REALVAR (ymax, U"right Vertical range", U"0.0")
OK
DO
GRAPHICS_TWO (FFNet, PCA)
FFNet_Eigen_drawDecisionPlaneInEigenspace (me, you, GRAPHICS, unitNumber, layer, horizontalEigenvectorNumber, verticalEigenvectorNumber, xmin, xmax, ymin, ymax);
GRAPHICS_TWO_END
}
/*********** PatternList & Categories **********************************/
FORM (NEW1_PatternList_Categories_to_FFNet, U"PatternList & Categories: To FFNet", U"PatternList & Categories: To FFNet...") {
INTEGERVAR (numberOfUnitsInHiddenLayer1, U"Number of units in hidden layer 1", U"0")
INTEGERVAR (numberOfUnitsInHiddenLayer2, U"Number of units in hidden layer 2", U"0")
OK
DO
CONVERT_TWO (PatternList, Categories)
autoFFNet result = PatternList_Categories_to_FFNet (me, you, numberOfUnitsInHiddenLayer1, numberOfUnitsInHiddenLayer2);
CONVERT_TWO_END (result -> name)
}
/*********** RBM & PatternList **********************************/
DIRECT (NEW1_RBM_PatternList_to_ActivationList) {
CONVERT_TWO (RBM, PatternList)
autoActivationList result = RBM_PatternList_to_ActivationList (me, you);
CONVERT_TWO_END (my name, U"_", you -> name)
}
void praat_uvafon_FFNet_init () {
Thing_recognizeClassesByName (classFFNet, NULL);
praat_addMenuCommand (U"Objects", U"New", U"Feedforward neural networks", nullptr, 0, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Create FFNet...", nullptr, 1, NEW1_FFNet_create);
praat_addMenuCommand (U"Objects", U"New", U"Create iris example...", nullptr, 1, NEWMANY_FFNet_createIrisExample);
praat_addMenuCommand (U"Objects", U"New", U"Advanced", nullptr, 1, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Create FFNet (linear outputs)...", nullptr, 2, NEW1_FFNet_create_linearOutputs);
praat_addMenuCommand (U"Objects", U"New", U"Create PatternList...", nullptr, 2, NEW1_PatternList_create);
praat_addMenuCommand (U"Objects", U"New", U"Create Categories...", nullptr, 2, NEW1_Categories_create);
praat_addAction1 (classFFNet, 0, U"FFNet help", nullptr, 0, HELP_FFNet_help);
praat_addAction1 (classFFNet, 0, DRAW_BUTTON, nullptr, 0, nullptr);
praat_addAction1 (classFFNet, 0, U"Draw topology", nullptr, 1, GRAPHICS_FFNet_drawTopology);
praat_addAction1 (classFFNet, 0, U"Draw weights...", nullptr, 1, GRAPHICS_FFNet_drawWeights);
praat_addAction1 (classFFNet, 0, U"Draw weights to layer...", nullptr, praat_DEPTH_1 | praat_HIDDEN, GRAPHICS_FFNet_drawWeightsToLayer);
praat_addAction1 (classFFNet, 0, U"Draw cost history...", nullptr, 1, GRAPHICS_FFNet_drawCostHistory);
praat_addAction1 (classFFNet, 0, QUERY_BUTTON, nullptr, 0, nullptr);
praat_addAction1 (classFFNet, 0, U"Query structure", nullptr, 1, nullptr);
praat_addAction1 (classFFNet, 1, U"Get number of layers", nullptr, 2, INTEGER_FFNet_getNumberOfLayers);
praat_addAction1 (classFFNet, 1, U"Get number of outputs", nullptr, 2, INTEGER_FFNet_getNumberOfOutputs);
praat_addAction1 (classFFNet, 1, U"Get number of hidden units...", nullptr, 2, INTEGER_FFNet_getNumberOfHiddenUnits);
praat_addAction1 (classFFNet, 1, U"Get number of inputs", nullptr, 2, INTEGER_FFNet_getNumberOfInputs);
praat_addAction1 (classFFNet, 1, U"Get number of hidden weights...", nullptr, 2, INTEGER_FFNet_getNumberOfHiddenWeights);
praat_addAction1 (classFFNet, 1, U"Get number of output weights", nullptr, 2, INTEGER_FFNet_getNumberOfOutputWeights);
praat_addAction1 (classFFNet, 1, U"Get category of output unit...", nullptr, 2, INFO_FFNet_getCategoryOfOutputUnit);
praat_addAction1 (classFFNet, 1, U"Get output unit of category...", nullptr, 2, INTEGER_FFNet_getOutputUnitOfCategory);
praat_addAction1 (classFFNet, 0, U"-- FFNet weights --", nullptr, 1, nullptr);
praat_addAction1 (classFFNet, 1, U"Get bias...", nullptr, 1, REAL_FFNet_getBias);
praat_addAction1 (classFFNet, 1, U"Get weight...", nullptr, 1, REAL_FFNet_getWeight);
praat_addAction1 (classFFNet, 1, U"Get minimum", nullptr, 1, REAL_FFNet_getMinimum);
praat_addAction1 (classFFNet, 0, MODIFY_BUTTON, nullptr, 0, nullptr);
praat_addAction1 (classFFNet, 0, U"Set bias...", nullptr, 1, MODIFY_FFNet_setBias);
praat_addAction1 (classFFNet, 0, U"Set weight...", nullptr, 1, MODIFY_FFNet_setWeight);
praat_addAction1 (classFFNet, 0, U"Reset...", nullptr, 1, MODIFY_FFNet_reset);
praat_addAction1 (classFFNet, 0, U"Select biases...", nullptr, 1, MODIFY_FFNet_selectBiasesInLayer);
praat_addAction1 (classFFNet, 0, U"Select all weights", nullptr, 1, MODIFY_FFNet_selectAllWeights);
praat_addAction1 (classFFNet, 0, EXTRACT_BUTTON, nullptr, 0, nullptr);
praat_addAction1 (classFFNet, 0, U"Extract weights...", nullptr, 1, NEW_FFNet_extractWeights);
praat_addAction1 (classFFNet, 0, U"Weights to Matrix...", nullptr, praat_DEPTH_1 | praat_HIDDEN, NEW_FFNet_weightsToMatrix);
praat_addAction1 (classFFNet, 0, U"& PatternList: Classify?", nullptr, 0, HINT_hint_FFNet_and_PatternList_classify);
praat_addAction1 (classFFNet, 0, U"& PatternList & Categories: Learn?", nullptr, 0, HINT_hint_FFNet_and_PatternList_and_Categories_learn);
praat_addAction2 (classFFNet, 1, classActivationList, 1, U"Analyse", nullptr, 0, nullptr);
praat_addAction2 (classFFNet, 1, classActivationList, 1, U"To Categories...", nullptr, 0, NEW1_FFNet_ActivationList_to_Categories);
praat_addAction2 (classFFNet, 1, classEigen, 1, U"Draw", nullptr, 0, nullptr);
praat_addAction2 (classFFNet, 1, classEigen, 1, U"Draw hyperplane intersections", nullptr, 0, GRAPHICS_FFNet_Eigen_drawIntersection);
praat_addAction2 (classFFNet, 1, classCategories, 1, U"Analyse", nullptr, 0, nullptr);
praat_addAction2 (classFFNet, 1, classCategories, 1, U"To ActivationList", nullptr, 0, NEW1_FFNet_Categories_to_ActivationList);
praat_addAction2 (classFFNet, 1, classMatrix, 1, U"Modify", nullptr, 0, nullptr);
praat_addAction2 (classFFNet, 1, classMatrix, 1, U"Weights from Matrix...", nullptr, 0, NEW1_FFNet_weightsFromMatrix);
praat_addAction2 (classFFNet, 1, classPatternList, 1, U"Draw", nullptr, 0, nullptr);
praat_addAction2 (classFFNet, 1, classPatternList, 1, U"Draw activation...", nullptr, 0, GRAPHICS_FFNet_PatternList_drawActivation);
praat_addAction2 (classFFNet, 1, classPatternList, 1, U"Analyse", nullptr, 0, nullptr);
praat_addAction2 (classFFNet, 1, classPatternList, 1, U"To Categories...", nullptr, 0, NEW1_FFNet_PatternList_to_Categories);
praat_addAction2 (classFFNet, 1, classPatternList, 1, U"To ActivationList...", nullptr, 0, NEW1_FFNet_PatternList_to_ActivationList);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classActivationList, 1, U"Get total costs...", nullptr, 0, REAL_FFNet_PatternList_ActivationList_getTotalCosts);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classActivationList, 1, U"Get average costs...", nullptr, 0, REAL_FFNet_PatternList_ActivationList_getAverageCosts);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classActivationList, 1, U"Learn", nullptr, 0, nullptr);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classActivationList, 1, U"Learn...", nullptr, 0, MODIFY_FFNet_PatternList_ActivationList_learn);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classActivationList, 1, U"Learn slow...", nullptr, 0, MODIFY_FFNet_PatternList_ActivationList_learnSlow);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classCategories, 1, U"Get total costs...", nullptr, 0, REAL_FFNet_PatternList_Categories_getTotalCosts);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classCategories, 1, U"Get average costs...", nullptr, 0, REAL_FFNet_PatternList_Categories_getAverageCosts);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classCategories, 1, U"Learn", nullptr, 0, nullptr);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classCategories, 1, U"Learn...", nullptr, 0, MODIFY_FFNet_PatternList_Categories_learn);
praat_addAction3 (classFFNet, 1, classPatternList, 1, classCategories, 1, U"Learn slow...", nullptr, 0, MODIFY_FFNet_PatternList_Categories_learnSlow);
praat_addAction2 (classFFNet, 1, classPCA, 1, U"Draw decision plane...", nullptr, 0, GRAPHICS_FFNet_PCA_drawDecisionPlaneInEigenspace);
praat_addAction2 (classPatternList, 1, classCategories, 1, U"To FFNet...", nullptr, 0, NEW1_PatternList_Categories_to_FFNet);
praat_addAction2 (classRBM, 1, classPatternList, 1, U"To ActivationList", nullptr, 0, NEW1_RBM_PatternList_to_ActivationList);
INCLUDE_MANPAGES (manual_FFNet_init)
}
/* End of file praat_FFnet_init.cpp */
praat-6.0.23/LPC/ 0000775 0000000 0000000 00000000000 13023464014 0013324 5 ustar 00root root 0000000 0000000 praat-6.0.23/LPC/Cepstrogram.cpp 0000664 0000000 0000000 00000044222 13023464014 0016322 0 ustar 00root root 0000000 0000000 /* Cepstrogram.cpp
*
* Copyright (C) 2013, 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20010514
djmw 20020812 GPL header
djmw 20080122 Version 1: float -> double
djmw 20110304 Thing_new
*/
#include "Cepstrogram.h"
#include "Cepstrum_and_Spectrum.h"
#include "NUM2.h"
#include "Sound_and_Spectrum.h"
#include "Sound_extensions.h"
#define TOLOG(x) ((1 / NUMln10) * log ((x) + 1e-30))
#define TO10LOG(x) ((10 / NUMln10) * log ((x) + 1e-30))
#define FROMLOG(x) (exp ((x) * (NUMln10 / 10.0)) - 1e-30)
Thing_implement (Cepstrogram, Matrix, 2);
Thing_implement (PowerCepstrogram, Cepstrogram, 2); // derives from Matrix -> also version 2
autoCepstrogram Cepstrogram_create (double tmin, double tmax, long nt, double dt, double t1,
double qmin, double qmax, long nq, double dq, double q1) {
try {
autoCepstrogram me = Thing_new (Cepstrogram);
Matrix_init (me.get(), tmin, tmax, nt, dt, t1, qmin, qmax, nq, dq, q1);
return me;
} catch (MelderError) {
Melder_throw (U"Cepstrogram not created.");
}
}
autoPowerCepstrogram PowerCepstrogram_create (double tmin, double tmax, long nt, double dt, double t1,
double qmin, double qmax, long nq, double dq, double q1) {
try {
autoPowerCepstrogram me = Thing_new (PowerCepstrogram);
Matrix_init (me.get(), tmin, tmax, nt, dt, t1, qmin, qmax, nq, dq, q1);
return me;
} catch (MelderError) {
Melder_throw (U"PowerCepstrogram not created.");
}
}
void PowerCepstrogram_paint (PowerCepstrogram me, Graphics g, double tmin, double tmax, double qmin, double qmax, double dBmaximum, int autoscaling, double dynamicRangedB, double dynamicCompression, int garnish) {
if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; }
if (qmax <= qmin) { qmin = my ymin; qmax = my ymax; }
long itmin, itmax, ifmin, ifmax;
if (! Matrix_getWindowSamplesX (me, tmin - 0.49999 * my dx, tmax + 0.49999 * my dx, & itmin, & itmax) ||
! Matrix_getWindowSamplesY (me, qmin - 0.49999 * my dy, qmax + 0.49999 * my dy, & ifmin, & ifmax)) {
return;
}
autoMatrix thee = Data_copy (me);
double min = 1e308, max = -min;
for (long i = 1; i <= my ny; i++) {
for (long j = 1; j <= my nx; j++) {
double val = TO10LOG (my z[i][j]);
min = val < min ? val : min;
max = val > max ? val : max;
thy z[i][j] = val;
}
}
double dBminimum = dBmaximum - dynamicRangedB;
if (autoscaling) {
dBminimum = min; dBmaximum = max;
}
for (long j = 1; j <= my nx; j++) {
double lmax = thy z[1][j];
for (long i = 2; i <= my ny; i++) {
if (thy z[i][j] > lmax) {
lmax = thy z[i][j];
}
}
double factor = dynamicCompression * (max - lmax);
for (long i = 1; i <= my ny; i++) {
thy z[i][j] += factor;
}
}
Graphics_setInner (g);
Graphics_setWindow (g, tmin, tmax, qmin, qmax);
Graphics_image (g, thy z,
itmin, itmax,
Matrix_columnToX (thee.get(), itmin - 0.5),
Matrix_columnToX (thee.get(), itmax + 0.5),
ifmin, ifmax,
Matrix_rowToY (thee.get(), ifmin - 0.5),
Matrix_rowToY (thee.get(), ifmax + 0.5),
dBminimum, dBmaximum);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, true, U"Time (s)");
Graphics_marksBottom (g, 2, true, true, false);
Graphics_marksLeft (g, 2, true, true, false);
Graphics_textLeft (g, true, U"Quefrency (s)");
}
}
void PowerCepstrogram_subtractTilt_inline (PowerCepstrogram me, double qstartFit, double qendFit, int lineType, int fitMethod) {
try {
autoPowerCepstrum thee = PowerCepstrum_create (my ymax, my ny);
for (long i = 1; i <= my nx; i++) {
for (long j = 1; j <= my ny; j++) {
thy z[1][j] = my z[j][i];
}
PowerCepstrum_subtractTilt_inline (thee.get(), qstartFit, qendFit, lineType, fitMethod);
for (long j = 1; j <= my ny; j++) {
my z[j][i] = thy z[1][j];
}
}
} catch (MelderError) {
Melder_throw (me, U": no tilt subtracted (inline).");
}
}
autoPowerCepstrogram PowerCepstrogram_subtractTilt (PowerCepstrogram me, double qstartFit, double qendFit, int lineType, int fitMethod) {
try {
autoPowerCepstrogram thee = Data_copy (me);
PowerCepstrogram_subtractTilt_inline (thee.get(), qstartFit, qendFit, lineType, fitMethod);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no tilt subtracted.");
}
}
autoTable PowerCepstrogram_to_Table_hillenbrand (PowerCepstrogram me, double pitchFloor, double pitchCeiling) {
try {
autoTable thee = Table_createWithColumnNames (my nx, U"time quefrency cpp f0");
autoPowerCepstrum him = PowerCepstrum_create (my ymax, my ny);
for (long i = 1; i <= my nx; i++) {
for (long j = 1; j <= my ny; j++) {
his z[1][j] = my z[j][i];
}
double qpeak, cpp = PowerCepstrum_getPeakProminence_hillenbrand (him.get(), pitchFloor, pitchCeiling, &qpeak);
double time = Sampled_indexToX (me, i);
Table_setNumericValue (thee.get(), i, 1, time);
Table_setNumericValue (thee.get(), i, 2, qpeak);
Table_setNumericValue (thee.get(), i, 3, cpp); // Cepstrogram_getCPPS depends on this index 3!!
Table_setNumericValue (thee.get(), i, 4, 1.0 / qpeak);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Table with cepstral peak prominence values created.");
}
}
autoTable PowerCepstrogram_to_Table_cpp (PowerCepstrogram me, double pitchFloor, double pitchCeiling, double deltaF0, int interpolation, double qstartFit, double qendFit, int lineType, int fitMethod) {
try {
autoTable thee = Table_createWithColumnNames (my nx, U"time quefrency cpp f0 rnr");
autoPowerCepstrum him = PowerCepstrum_create (my ymax, my ny);
for (long i = 1; i <= my nx; i++) {
for (long j = 1; j <= my ny; j++) {
his z[1][j] = my z[j][i];
}
double qpeak, cpp = PowerCepstrum_getPeakProminence (him.get(), pitchFloor, pitchCeiling, interpolation,
qstartFit, qendFit, lineType, fitMethod, &qpeak);
double rnr = PowerCepstrum_getRNR (him.get(), pitchFloor, pitchCeiling, deltaF0);
double time = Sampled_indexToX (me, i);
Table_setNumericValue (thee.get(), i, 1, time);
Table_setNumericValue (thee.get(), i, 2, qpeak);
Table_setNumericValue (thee.get(), i, 3, cpp); // Cepstrogram_getCPPS depends on this index!!
Table_setNumericValue (thee.get(), i, 4, 1.0 / qpeak);
Table_setNumericValue (thee.get(), i, 5, rnr);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Table with cepstral peak prominence values created.");
}
}
autoPowerCepstrogram PowerCepstrogram_smooth (PowerCepstrogram me, double timeAveragingWindow, double quefrencyAveragingWindow) {
try {
autoPowerCepstrogram thee = Data_copy (me);
// 1. average across time
long numberOfFrames = (long) floor (timeAveragingWindow / my dx);
if (numberOfFrames > 1) {
autoNUMvector qin (1, my nx);
autoNUMvector qout (1, my nx);
for (long iq = 1; iq <= my ny; iq++) {
for (long iframe = 1; iframe <= my nx; iframe++) {
//qin[iframe] = TO10LOG (my z[iq][iframe]);
qin[iframe] = thy z[iq][iframe];
}
NUMvector_smoothByMovingAverage (qin.peek(), my nx, numberOfFrames, qout.peek());
for (long iframe = 1; iframe <= my nx; iframe++) {
//thy z[iq][iframe] = FROMLOG (qout[iframe]); // inverse
thy z[iq][iframe] = qout[iframe]; // inverse
}
}
}
// 2. average across quefrencies
long numberOfQuefrencyBins = (long) floor (quefrencyAveragingWindow / my dy);
if (numberOfQuefrencyBins > 1) {
autoNUMvector qin (1, thy ny);
autoNUMvector qout (1, thy ny);
for (long iframe = 1; iframe <= my nx; iframe++) {
for (long iq = 1; iq <= thy ny; iq++) {
//qin[iq] = TO10LOG (my z[iq][iframe]);
qin[iq] = thy z[iq][iframe];
}
NUMvector_smoothByMovingAverage (qin.peek(), thy ny, numberOfQuefrencyBins, qout.peek());
for (long iq = 1; iq <= thy ny; iq++) {
//thy z[iq][iframe] = FROMLOG (qout[iq]);
thy z[iq][iframe] = qout[iq];
}
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": not smoothed.");
}
}
autoMatrix PowerCepstrogram_to_Matrix (PowerCepstrogram me) {
try {
autoMatrix thee = Thing_new (Matrix);
my structMatrix :: v_copy (thee.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Matrix.");
}
}
autoPowerCepstrum PowerCepstrogram_to_PowerCepstrum_slice (PowerCepstrogram me, double time) {
try {
long iframe = Sampled_xToNearestIndex (me, time);
iframe = iframe < 1 ? 1 : iframe > my nx ? my nx : iframe;
autoPowerCepstrum thee = PowerCepstrum_create (my ymax, my ny);
for (long i = 1; i <= my ny; i++) {
thy z[1][i] = my z[i][iframe];
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": Cepstrum not extracted.");
}
}
autoPowerCepstrogram Matrix_to_PowerCepstrogram (Matrix me) {
try {
autoPowerCepstrogram thee = Thing_new (PowerCepstrogram);
my structMatrix :: v_copy (thee.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to PowerCepstrogram.");
}
}
autoPowerCepstrogram Sound_to_PowerCepstrogram (Sound me, double pitchFloor, double dt, double maximumFrequency, double preEmphasisFrequency) {
try {
// minimum analysis window has 3 periods of lowest pitch
double analysisWidth = 3.0 / pitchFloor;
double windowDuration = 2.0 * analysisWidth; /* gaussian window */
long nFrames;
// Convenience: analyse the whole sound into one Cepstrogram_frame
if (windowDuration > my dx * my nx) {
windowDuration = my dx * my nx;
}
double t1, samplingFrequency = 2 * maximumFrequency;
autoSound sound = Sound_resample (me, samplingFrequency, 50);
Sound_preEmphasis (sound.get(), preEmphasisFrequency);
Sampled_shortTermAnalysis (me, windowDuration, dt, & nFrames, & t1);
autoSound sframe = Sound_createSimple (1, windowDuration, samplingFrequency);
autoSound window = Sound_createGaussian (windowDuration, samplingFrequency);
// find out the size of the FFT
long nfft = 2;
while (nfft < sframe -> nx) nfft *= 2;
long nq = nfft / 2 + 1;
double qmax = 0.5 * nfft / samplingFrequency, dq = qmax / (nq - 1);
autoPowerCepstrogram thee = PowerCepstrogram_create (my xmin, my xmax, nFrames, dt, t1, 0, qmax, nq, dq, 0);
autoMelderProgress progress (U"Cepstrogram analysis");
for (long iframe = 1; iframe <= nFrames; iframe++) {
double t = Sampled_indexToX (thee.get(), iframe);
Sound_into_Sound (sound.get(), sframe.get(), t - windowDuration / 2);
Vector_subtractMean (sframe.get());
Sounds_multiply (sframe.get(), window.get());
autoSpectrum spec = Sound_to_Spectrum (sframe.get(), 1); // FFT yes
autoPowerCepstrum cepstrum = Spectrum_to_PowerCepstrum (spec.get());
for (long i = 1; i <= nq; i++) {
thy z[i][iframe] = cepstrum -> z[1][i];
}
if ((iframe % 10) == 1) {
Melder_progress ((double) iframe / nFrames, U"PowerCepstrogram analysis of frame ",
iframe, U" out of ", nFrames, U".");
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no PowerCepstrogram created.");
}
}
autoCepstrum Spectrum_to_Cepstrum_hillenbrand (Spectrum me);
autoCepstrum Spectrum_to_Cepstrum_hillenbrand (Spectrum me) {
try {
autoNUMfft_Table fftTable;
// originalNumberOfSamplesProbablyOdd irrelevant
if (my x1 != 0.0) {
Melder_throw (U"A Fourier-transformable Spectrum must have a first frequency of 0 Hz, not ", my x1, U" Hz.");
}
long numberOfSamples = my nx - 1;
autoCepstrum thee = Cepstrum_create (0.5 / my dx, my nx);
NUMfft_Table_init (&fftTable, my nx);
autoNUMvector amp (1, my nx);
for (long i = 1; i <= my nx; i++) {
amp [i] = my v_getValueAtSample (i, 0, 2);
}
NUMfft_forward (&fftTable, amp.peek());
for (long i = 1; i <= my nx; i++) {
double val = amp[i] / numberOfSamples;// scaling 1/n because ifft(fft(1))= n;
thy z[1][i] = val * val; // power cepstrum
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Sound.");
}
}
// 1 2 nfftdiv2
// re im re im re im
// ((fft[1],0) (fft[2],fft[3]), (,), (,), (fft[nfft], 0)) nfft even
// ((fft[1],0) (fft[2],fft[3]), (,), (,), (fft[nfft-1], fft[nfft])) nfft uneven
static void complexfftoutput_to_power (double *fft, long nfft, double *dbs, bool to_db) {
double valsq = fft[1] * fft[1];
dbs[1] = to_db ? TOLOG (valsq) : valsq;
long nfftdiv2p1 = (nfft + 2) / 2;
long nend = nfft % 2 == 0 ? nfftdiv2p1 : nfftdiv2p1 + 1;
for (long i = 2; i < nend; i++) {
double re = fft[i + i - 2], im = fft[i + i - 1];
valsq = re * re + im * im;
dbs[i] = to_db ? TOLOG (valsq) : valsq;
}
if (nfft % 2 == 0) {
valsq = fft[nfft] * fft[nfft];
dbs[nfftdiv2p1] = to_db ? TOLOG (valsq) : valsq;
}
}
autoPowerCepstrogram Sound_to_PowerCepstrogram_hillenbrand (Sound me, double pitchFloor, double dt) {
try {
// minimum analysis window has 3 periods of lowest pitch
double analysisWidth = 3 / pitchFloor;
if (analysisWidth > my dx * my nx) {
analysisWidth = my dx * my nx;
}
double samplingFrequency = 1.0 / my dx;
autoSound thee;
if (samplingFrequency > 30000) {
samplingFrequency = samplingFrequency / 2.0;
thee = Sound_resample (me, samplingFrequency, 1);
} else {
thee = Data_copy (me);
}
// pre-emphasis with fixed coefficient 0.9
for (long i = thy nx; i > 1; i--) {
thy z[1][i] -= 0.9 * thy z[1][i - 1];
}
long nosInWindow = (long) floor (analysisWidth * samplingFrequency), nFrames;
if (nosInWindow < 8) {
Melder_throw (U"Analysis window too short.");
}
double t1;
Sampled_shortTermAnalysis (thee.get(), analysisWidth, dt, & nFrames, & t1);
autoNUMvector hamming (1, nosInWindow);
for (long i = 1; i <= nosInWindow; i++) {
hamming[i] = 0.54 -0.46 * cos(2 * NUMpi * (i - 1) / (nosInWindow - 1));
}
long nfft = 8; // minimum possible
while (nfft < nosInWindow) { nfft *= 2; }
long nfftdiv2 = nfft / 2;
autoNUMvector fftbuf (1, nfft); // "complex" array
autoNUMvector spectrum (1, nfftdiv2 + 1); // +1 needed
autoNUMfft_Table fftTable;
NUMfft_Table_init (&fftTable, nfft); // sound to spectrum
double qmax = 0.5 * nfft / samplingFrequency, dq = qmax / (nfftdiv2 + 1);
autoPowerCepstrogram him = PowerCepstrogram_create (my xmin, my xmax, nFrames, dt, t1, 0, qmax, nfftdiv2+1, dq, 0);
autoMelderProgress progress (U"Cepstrogram analysis");
for (long iframe = 1; iframe <= nFrames; iframe++) {
double tbegin = t1 + (iframe - 1) * dt - analysisWidth / 2;
tbegin = tbegin < thy xmin ? thy xmin : tbegin;
long istart = Sampled_xToLowIndex (thee.get(), tbegin); // ppgb: afronding naar beneden?
istart = istart < 1 ? 1 : istart;
long iend = istart + nosInWindow - 1;
iend = iend > thy nx ? thy nx : iend;
for (long i = 1; i <= nosInWindow; i++) {
fftbuf[i] = thy z[1][istart + i - 1] * hamming[i];
}
for (long i = nosInWindow + 1; i <= nfft; i++) {
fftbuf[i] = 0;
}
NUMfft_forward (&fftTable, fftbuf.peek());
complexfftoutput_to_power (fftbuf.peek(), nfft, spectrum.peek(), true); // log10(|fft|^2)
// subtract average
double specmean = spectrum[1];
for (long i = 2; i <= nfftdiv2 + 1; i++) {
specmean += spectrum[i];
}
specmean /= nfftdiv2 + 1;
for (long i = 1; i <= nfftdiv2 + 1; i++) {
spectrum[i] -= specmean;
}
/*
* Here we diverge from Hillenbrand as he takes the fft of half of the spectral values.
* H. forgets that the actual spectrum has nfft/2+1 values. Thefore, we take the inverse
* transform because this keeps the number of samples a power of 2.
* At the same time this results in twice as many numbers in the quefrency domain, i.e. we end up with nfft/2+1
* numbers while H. has only nfft/4!
*/
fftbuf[1] = spectrum[1];
for (long i = 2; i < nfftdiv2 + 1; i++) {
fftbuf[i+i-2] = spectrum[i];
fftbuf[i+i-1] = 0;
}
fftbuf[nfft] = spectrum[nfftdiv2 + 1];
NUMfft_backward (&fftTable, fftbuf.peek());
for (long i = 1; i <= nfftdiv2 + 1; i++) {
his z[i][iframe] = fftbuf[i] * fftbuf[i];
}
if ((iframe % 10) == 1) {
Melder_progress ((double) iframe / nFrames, U"Cepstrogram analysis of frame ",
iframe, U" out of ", nFrames, U".");
}
}
return him;
} catch (MelderError) {
Melder_throw (me, U": no Cepstrogram created.");
}
}
double PowerCepstrogram_getCPPS (PowerCepstrogram me, bool subtractTiltBeforeSmoothing, double timeAveragingWindow, double quefrencyAveragingWindow, double pitchFloor, double pitchCeiling, double deltaF0, int interpolation, double qstartFit, double qendFit, int lineType, int fitMethod) {
try {
autoPowerCepstrogram flattened;
if (subtractTiltBeforeSmoothing) {
flattened = PowerCepstrogram_subtractTilt (me, qstartFit, qendFit, lineType, fitMethod);
}
autoPowerCepstrogram smooth = PowerCepstrogram_smooth (flattened ? flattened.get() : me, timeAveragingWindow, quefrencyAveragingWindow);
autoTable table = PowerCepstrogram_to_Table_cpp (smooth.get(), pitchFloor, pitchCeiling, deltaF0, interpolation, qstartFit, qendFit, lineType, fitMethod);
double cpps = Table_getMean (table.get(), 3);
return cpps;
} catch (MelderError) {
Melder_throw (me, U": no CPPS value calculated.");
}
}
double PowerCepstrogram_getCPPS_hillenbrand (PowerCepstrogram me, bool subtractTiltBeforeSmoothing, double timeAveragingWindow, double quefrencyAveragingWindow, double pitchFloor, double pitchCeiling) {
try {
autoPowerCepstrogram him;
if (subtractTiltBeforeSmoothing) {
him = PowerCepstrogram_subtractTilt (me, 0.001, 0, 1, 1);
}
autoPowerCepstrogram smooth = PowerCepstrogram_smooth (subtractTiltBeforeSmoothing ? him.get() : me, timeAveragingWindow, quefrencyAveragingWindow);
autoTable table = PowerCepstrogram_to_Table_hillenbrand (smooth.get(), pitchFloor, pitchCeiling);
double cpps = Table_getMean (table.get(), 3);
return cpps;
} catch (MelderError) {
Melder_throw (me, U": no CPPS value calculated.");
}
}
/* End of file Cepstrogram.cpp */
praat-6.0.23/LPC/Cepstrogram.h 0000664 0000000 0000000 00000006735 13023464014 0015776 0 ustar 00root root 0000000 0000000 #ifndef _Cepstrogram_h_
#define _Cepstrogram_h_
/* Cepstrogram.h
*
* Copyright (C) 2012-2013, 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20121017
djmw 20130502 Latest modification.
*/
/*
The Cepstrogram is a matrix of REAL numbers.
It is the inverse-fourier-transformed logarithm of the spectrum
of a (sound) signal.
*/
#include "Cepstrum.h"
#include "Sound.h"
#include "Table.h"
Thing_define (Cepstrogram, Matrix) {
};
Thing_define (PowerCepstrogram, Cepstrogram) {
};
/*
xmin, xmax : time domain
nx, dx, x1 : sampling in the time domain
ymin // Lowest quefrency.
ymax // Highest quefrency.
ny // Number of quefrencies.
dy // Quefrency step.
y1 // First quefrency.
*/
autoCepstrogram Cepstrogram_create (double tmin, double tmax, long nt, double dt, double t1, double qmin, double qmax, long nq, double dq, double q1);
autoPowerCepstrogram PowerCepstrogram_create (double tmin, double tmax, long nt, double dt, double t1, double qmin, double qmax, long nq, double dq, double q1);
void PowerCepstrogram_paint (PowerCepstrogram me, Graphics g, double tmin, double tmax, double qmin, double qmax, double dBmaximum, int autoscaling, double dynamicRangedB, double dynamicCompression, int garnish);
autoPowerCepstrogram PowerCepstrogram_smooth (PowerCepstrogram me, double timeAveragingWindow, double quefrencyAveragingWindow);
autoPowerCepstrogram Sound_to_PowerCepstrogram (Sound me, double pitchFloor, double dt, double maximumFrequency, double preEmphasisFrequency);
autoPowerCepstrogram Sound_to_PowerCepstrogram_hillenbrand (Sound me, double analysisWidth, double dt);
autoTable PowerCepstrogram_to_Table_hillenbrand (PowerCepstrogram me, double pitchFloor, double pitchCeiling);
autoTable PowerCepstrogram_to_Table_cpp (PowerCepstrogram me, double pitchFloor, double pitchCeiling, double deltaF0, int interpolation, double qstartFit, double qendFit, int lineType, int method);
autoPowerCepstrum PowerCepstrogram_to_PowerCepstrum_slice (PowerCepstrogram me, double time);
autoPowerCepstrogram PowerCepstrogram_subtractTilt (PowerCepstrogram me, double qstartFit, double qendFit, int lineType, int fitMethod);
void PowerCepstrogram_subtractTilt_inline (PowerCepstrogram me, double qstartFit, double qendFit, int lineType, int fitMethod);
double PowerCepstrogram_getCPPS_hillenbrand (PowerCepstrogram me, bool subtractTiltBeforeSmoothing, double timeAveragingWindow, double quefrencyAveragingWindow, double pitchFloor, double pitchCeiling);
double PowerCepstrogram_getCPPS (PowerCepstrogram me, bool subtractTiltBeforeSmoothing, double timeAveragingWindow, double quefrencyAveragingWindow, double pitchFloor, double pitchCeiling, double deltaF0, int interpolation, double qstartFit, double qendFit, int lineType, int fitMethod);
autoMatrix PowerCepstrogram_to_Matrix (PowerCepstrogram me);
autoPowerCepstrogram Matrix_to_PowerCepstrogram (Matrix me);
#endif /* _Cepstrogram_h_ */
praat-6.0.23/LPC/Cepstrum.cpp 0000664 0000000 0000000 00000040031 13023464014 0015630 0 ustar 00root root 0000000 0000000 /* Cepstrum.cpp
*
* Copyright (C) 1994-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20010514
djmw 20020812 GPL header
djmw 20080122 Version 1: float -> double
djmw 20110304 Thing_new
*/
#include "Cepstrum.h"
#include "NUM2.h"
#include "Vector.h"
Thing_implement (Cepstrum, Matrix, 2);
Thing_implement (PowerCepstrum, Cepstrum, 2); // derives from Matrix therefore also version 2
double structCepstrum :: v_getValueAtSample (long isamp, long which, int units) {
(void) units;
if (which == 0) {
return z[1][isamp];
} else {
// dB's
return 20.0 * log10 (fabs(z[1][isamp]) + 1e-30);
}
return NUMundefined;
}
double structPowerCepstrum :: v_getValueAtSample (long isamp, long which, int units) {
(void) units;
if (which == 0) {
return z[1][isamp];
} else {
// dB's
return 10.0 * log10 (z[1][isamp] + 1e-30); // always positive
}
return NUMundefined;
}
autoCepstrum Cepstrum_create (double qmax, long nq) {
try {
autoCepstrum me = Thing_new (Cepstrum);
double dq = qmax / (nq - 1);
Matrix_init (me.get(), 0.0, qmax, nq, dq, 0.0, 1.0, 1.0, 1, 1, 1.0);
return me;
} catch (MelderError) {
Melder_throw (U"Cepstrum not created.");
}
}
autoPowerCepstrum Cepstrum_downto_PowerCepstrum (Cepstrum me ) {
try {
autoPowerCepstrum thee = PowerCepstrum_create (my xmax, my nx);
for (long i = 1; i <= my nx; i++) {
thy z[1][i] = my z[1][i] * my z[1][i];
}
return thee;
} catch (MelderError) {
Melder_throw (me, U" not converted.");
}
}
autoPowerCepstrum PowerCepstrum_create (double qmax, long nq) {
try {
autoPowerCepstrum me = Thing_new (PowerCepstrum);
double dq = qmax / (nq - 1);
Matrix_init (me.get(), 0.0, qmax, nq, dq, 0.0, 1.0, 1.0, 1, 1, 1.0);
return me;
} catch (MelderError) {
Melder_throw (U"PowerCepstrum not created.");
}
}
static void _Cepstrum_draw (Cepstrum me, Graphics g, double qmin, double qmax, double minimum, double maximum, int power, int garnish) {
int autoscaling = minimum >= maximum;
Graphics_setInner (g);
if (qmax <= qmin) {
qmin = my xmin; qmax = my xmax;
}
long imin, imax;
if (! Matrix_getWindowSamplesX (me, qmin, qmax, & imin, & imax)) {
return;
}
autoNUMvector y (imin, imax);
for (long i = imin; i <= imax; i++) {
y[i] = my v_getValueAtSample (i, (power ? 1 : 0), 0);
}
if (autoscaling) {
NUMvector_extrema (y.peek(), imin, imax, & minimum, & maximum);
} else {
for (long i = imin; i <= imax; i ++) {
if (y[i] > maximum) {
y[i] = maximum;
} else if (y[i] < minimum) {
y[i] = minimum;
}
}
}
Graphics_setWindow (g, qmin, qmax, minimum, maximum);
Graphics_function (g, y.peek(), imin, imax, Matrix_columnToX (me, imin), Matrix_columnToX (me, imax));
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, true, U"Quefrency (s)");
Graphics_marksBottom (g, 2, true, true, false);
Graphics_textLeft (g, true, power ? U"Amplitude (dB)" : U"Amplitude");
Graphics_marksLeft (g, 2, true, true, false);
}
}
void Cepstrum_drawLinear (Cepstrum me, Graphics g, double qmin, double qmax, double minimum, double maximum, int garnish) {
_Cepstrum_draw (me, g, qmin, qmax, minimum, maximum, 0, garnish);
}
void PowerCepstrum_draw (PowerCepstrum me, Graphics g, double qmin, double qmax, double dBminimum, double dBmaximum, int garnish) {
_Cepstrum_draw (me, g, qmin, qmax, dBminimum, dBmaximum, 1, garnish);
}
void PowerCepstrum_drawTiltLine (PowerCepstrum me, Graphics g, double qmin, double qmax, double dBminimum, double dBmaximum, double qstart, double qend, int lineType, int method) {
Graphics_setInner (g);
if (qmax <= qmin) {
qmin = my xmin; qmax = my xmax;
}
if (dBminimum >= dBmaximum) { // autoscaling
long imin, imax;
if (! Matrix_getWindowSamplesX (me, qmin, qmax, & imin, & imax)) {
return;
}
long numberOfPoints = imax - imin + 1;
dBminimum = dBmaximum = my v_getValueAtSample (imin, 1, 0);
for (long i = 2; i <= numberOfPoints; i++) {
long isamp = imin + i - 1;
double y = my v_getValueAtSample (isamp, 1, 0);
dBmaximum = y > dBmaximum ? y : dBmaximum;
dBminimum = y < dBminimum ? y : dBminimum;
}
}
Graphics_setWindow (g, qmin, qmax, dBminimum, dBmaximum);
qend = qend == 0 ? my xmax : qend;
if (qend <= qstart) {
qend = my xmax; qstart = my xmin;
}
qstart = qstart < my xmin ? my xmin : qstart;
qend = qend > my xmax ? my xmax : qend;
double a, intercept;
PowerCepstrum_fitTiltLine (me, qstart, qend, &a, &intercept, lineType, method);
/*
* Don't draw part outside window
*/
double lineWidth = Graphics_inqLineWidth (g);
Graphics_setLineWidth (g, 2);
if (lineType == 2) {
long n = 500;
double dq = (qend - qstart) / (n + 1);
double q1 = qstart;
if (qstart <= 0) {
qstart = 0.1 * dq; // some small offset to avoid log(0)
n--;
}
autoNUMvector y (1, n);
for (long i = 1; i <= n; i++) {
double q = q1 + (i - 1) * dq;
y[i] = a * log (q) + intercept;
}
Graphics_function (g, y.peek(), 1, n, qstart, qend);
} else {
double y1 = a * qstart + intercept, y2 = a * qend + intercept;
if (y1 >= dBminimum && y2 >= dBminimum) {
Graphics_line (g, qstart, y1, qend, y2);
} else if (y1 < dBminimum) {
qstart = (dBminimum - intercept) / a;
Graphics_line (g, qstart, dBminimum, qend, y2);
} else if (y2 < dBminimum) {
qend = (dBminimum - intercept) / a;
Graphics_line (g, qstart, y1, qend, dBminimum);
} else {
// don't draw anything below lower limit?
}
}
Graphics_setLineWidth (g, lineWidth);
Graphics_unsetInner (g);
}
/* Fit line y = ax+b (lineType ==1) or y = a log(x) + b (lineType == 2) on interval [qmin,qmax]
* method == 1 : Least squares fit
* method == 2 : Theil's partial robust fit
*/
void PowerCepstrum_fitTiltLine (PowerCepstrum me, double qmin, double qmax, double *p_a, double *p_intercept, int lineType, int method) {
try {
double a, intercept;
if (qmax <= qmin) {
qmin = my xmin; qmax = my xmax;
}
long imin, imax;
if (! Matrix_getWindowSamplesX (me, qmin, qmax, & imin, & imax)) {
return;
}
imin = (lineType == 2 && imin == 1) ? 2 : imin; // log(0) is undefined!
long numberOfPoints = imax - imin + 1;
if (numberOfPoints < 2) {
Melder_throw (U"Not enough points for fit.");
}
autoNUMvector y (1, numberOfPoints);
autoNUMvector x (1, numberOfPoints);
for (long i = 1; i <= numberOfPoints; i++) {
long isamp = imin + i - 1;
x[i] = my x1 + (isamp - 1) * my dx;
if (lineType == 2) {
x[i] = log (x[i]);
}
y[i] = my v_getValueAtSample (isamp, 1, 0);
}
if (method == 3) { // try local maxima first
autoNUMvector ym (1, numberOfPoints / 2 + 1);
autoNUMvector xm (1, numberOfPoints / 2 + 1);
long numberOfLocalPeaks = 0;
// forget y[1] if y[2] y[i + 1]) {
ym[++numberOfLocalPeaks] = y[i];
xm[numberOfLocalPeaks] = x[i];
}
}
if (numberOfLocalPeaks > numberOfPoints / 10) {
for (long i = 1; i <= numberOfLocalPeaks; i++) {
x[i] = xm[i]; y[i] = ym[i];
}
numberOfPoints = numberOfLocalPeaks;
}
method = 2; // robust fit of peaks
}
// fit a straight line through (x,y)'s
NUMlineFit (x.peek(), y.peek(), numberOfPoints, & a, & intercept, method);
if (p_intercept) { *p_intercept = intercept; }
if (p_a) { *p_a = a; }
} catch (MelderError) {
Melder_throw (me, U": couldn't fit a line.");
}
}
#if 0
// Hillenbrand subtracts dB values and if the result is negative it is made zero
static void PowerCepstrum_subtractTiltLine_inline2 (PowerCepstrum me, double slope, double intercept, int lineType) {
for (long j = 1; j <= my nx; j++) {
double q = my x1 + (j - 1) * my dx;
q = j == 1 ? 0.5 * my dx : q; // approximation
double xq = lineType == 2 ? log(q) : q;
double db_background = slope * xq + intercept;
double db_cepstrum = my v_getValueAtSample (j, 1, 0);
double diff = exp ((db_cepstrum - db_background) * NUMln10 / 10) - 1e-30;
my z[1][j] = diff;
}
}
#endif
// clip with tilt line
static void PowerCepstrum_subtractTiltLine_inline (PowerCepstrum me, double slope, double intercept, int lineType) {
for (long j = 1; j <= my nx; j++) {
double q = my x1 + (j - 1) * my dx;
q = j == 1 ? 0.5 * my dx : q; // approximation
double xq = lineType == 2 ? log(q) : q;
double db_background = slope * xq + intercept;
double db_cepstrum = my v_getValueAtSample (j, 1, 0);
double diff = db_cepstrum - db_background;
if (diff < 0) {
diff = 0;
}
my z[1][j] = exp (diff * NUMln10 / 10.0) - 1e-30;
}
}
void PowerCepstrum_subtractTilt_inline (PowerCepstrum me, double qstartFit, double qendFit, int lineType, int fitMethod) {
double slope, intercept;
PowerCepstrum_fitTiltLine (me, qstartFit, qendFit, &slope, &intercept, lineType, fitMethod);
PowerCepstrum_subtractTiltLine_inline (me, slope, intercept, lineType);
}
autoPowerCepstrum PowerCepstrum_subtractTilt (PowerCepstrum me, double qstartFit, double qendFit, int lineType, int fitMethod) {
try {
autoPowerCepstrum thee = Data_copy (me);
PowerCepstrum_subtractTilt_inline (thee.get(), qstartFit, qendFit, lineType, fitMethod);
return thee;
} catch (MelderError) {
Melder_throw (me, U": couldn't subtract tilt line.");
}
}
void PowerCepstrum_smooth_inline (PowerCepstrum me, double quefrencyAveragingWindow, long numberOfIterations) {
try {
long numberOfQuefrencyBins = (long) floor (quefrencyAveragingWindow / my dx);
if (numberOfQuefrencyBins > 1) {
autoNUMvector qin (1, my nx);
autoNUMvector qout (1, my nx);
for (long iq = 1; iq <= my nx; iq ++) {
qin [iq] = my z [1] [iq];
}
double *xin, *xout;
for (long k = 1; k <= numberOfIterations; k ++) {
xin = k % 2 == 1 ? qin.peek() : qout.peek ();
xout = k % 2 == 1 ? qout.peek () : qin.peek();
NUMvector_smoothByMovingAverage (xin, my nx, numberOfQuefrencyBins, xout);
}
for (long iq = 1; iq <= my nx; iq++) {
my z [1] [iq] = xout [iq];
}
}
} catch (MelderError) {
Melder_throw (me, U": not smoothed.");
}
}
autoPowerCepstrum PowerCepstrum_smooth (PowerCepstrum me, double quefrencyAveragingWindow, long numberOfIterations) {
autoPowerCepstrum thee = Data_copy (me);
PowerCepstrum_smooth_inline (thee.get(), quefrencyAveragingWindow, numberOfIterations);
return thee;
}
void PowerCepstrum_getMaximumAndQuefrency (PowerCepstrum me, double pitchFloor, double pitchCeiling, int interpolation, double *p_peakdB, double *p_quefrency) {
double peakdB, quefrency;
autoPowerCepstrum thee = Data_copy (me);
double lowestQuefrency = 1.0 / pitchCeiling, highestQuefrency = 1.0 / pitchFloor;
for (long i = 1; i <= my nx; i ++) {
thy z[1][i] = my v_getValueAtSample (i, 1, 0); // 10 log val^2
}
Vector_getMaximumAndX ((Vector) thee.get(), lowestQuefrency, highestQuefrency, 1, interpolation, & peakdB, & quefrency); // FIXME cast
if (p_peakdB) {
*p_peakdB = peakdB;
}
if (p_quefrency) {
*p_quefrency = quefrency;
}
}
#if 0
static void Cepstrum_getZ (Cepstrum me, long imin, long imax, double peakdB, double slope, double intercept, int lineType, double *z) {
long ndata = imax - imin + 1;
autoNUMvector dabs (1, ndata);
for (long i = imin; i <= imax; i ++) {
double q = my x1 + (i - 1) * my dx;
q = ( i == 1 ? 0.5 * my dx : q ); // approximation
double xq = ( lineType == 2 ? log (q) : q );
double db_background = slope * xq + intercept;
double db_cepstrum = my v_getValueAtSample (i, 1, 0);
double diff = exp ((db_cepstrum - db_background) * NUMln10 / 10.0) - 1e-30;
//double diff = fabs (db_cepstrum - db_background);
dabs [i - imin + 1] = diff;
}
double q50 = NUMquantile (ndata, dabs.peek(), 0.5);
double peak = exp (peakdB * NUMln10 / 10.0) - 1e-30;
if (z) {
*z = peak / q50;
}
}
#endif
double PowerCepstrum_getRNR (PowerCepstrum me, double pitchFloor, double pitchCeiling, double f0fractionalWidth) {
double rnr = NUMundefined;
double qmin = 1.0 / pitchCeiling, qmax = 1.0 / pitchFloor, peakdB, qpeak;
PowerCepstrum_getMaximumAndQuefrency (me, pitchFloor, pitchCeiling, 2, &peakdB, &qpeak);
long imin, imax;
if (! Matrix_getWindowSamplesX (me, qmin, qmax, & imin, & imax)) {
return rnr;
}
long ndata = imax - imin + 1;
if (ndata < 2) {
return rnr;
}
// how many peaks in interval ?
long npeaks = 2;
while (qpeak > 0 && qpeak * npeaks <= qmax) { npeaks++; }
npeaks--;
double sum = 0, sumr = 0;
for (long i = imin; i <= imax; i++) {
double val = my v_getValueAtSample (i, 0, 0);
double qx = my x1 + (i - 1) * my dx;
sum += val;
// is qx within an interval around a multiple of the peak's q ?
for (long j = 1; j <= npeaks; j ++) {
double f0c = 1.0 / (j * qpeak);
double f0clow = f0c * (1.0 - f0fractionalWidth);
double f0chigh = f0c * (1.0 + f0fractionalWidth);
double qclow = 1.0 / f0chigh;
double qchigh = ( f0fractionalWidth >= 1 ? qmax : 1.0 / f0clow );
if (qx >= qclow && qx <= qchigh) { // yes in rahmonic interval
sumr += val;
break;
}
}
}
rnr = sumr >= sum ? 1000000 : sumr / (sum - sumr);
return rnr;
}
double PowerCepstrum_getPeakProminence_hillenbrand (PowerCepstrum me, double pitchFloor, double pitchCeiling, double *qpeak) {
double slope, intercept, quefrency, peakdB;
PowerCepstrum_fitTiltLine (me, 0.001, 0, &slope, &intercept, 1, 1);
autoPowerCepstrum thee = Data_copy (me);
PowerCepstrum_subtractTiltLine_inline (thee.get(), slope, intercept, 1);
PowerCepstrum_getMaximumAndQuefrency (thee.get(), pitchFloor, pitchCeiling, 0, & peakdB, & quefrency);
if (qpeak) {
*qpeak = quefrency;
}
return peakdB;
}
double PowerCepstrum_getPeakProminence (PowerCepstrum me, double pitchFloor, double pitchCeiling, int interpolation, double qstartFit, double qendFit, int lineType, int fitMethod, double *p_qpeak) {
double slope, intercept, qpeak, peakdB;
PowerCepstrum_fitTiltLine (me, qstartFit, qendFit, &slope, &intercept, lineType, fitMethod);
PowerCepstrum_getMaximumAndQuefrency (me, pitchFloor, pitchCeiling, interpolation, & peakdB, & qpeak);
double xq = lineType == 2 ? log(qpeak) : qpeak;
double db_background = slope * xq + intercept;
double cpp = peakdB - db_background;
if (p_qpeak) {
*p_qpeak = qpeak;
}
return cpp;
}
autoMatrix PowerCepstrum_to_Matrix (PowerCepstrum me) {
try {
autoMatrix thee = Thing_new (Matrix);
my structMatrix :: v_copy (thee.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Matrix created.");
}
}
autoPowerCepstrum Matrix_to_PowerCepstrum (Matrix me) {
try {
if (my ny != 1) {
Melder_throw (U"Matrix should have exactly 1 row.");
}
autoPowerCepstrum thee = Thing_new (PowerCepstrum);
my structMatrix :: v_copy (thee.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to PowerCepstrum.");
}
}
autoPowerCepstrum Matrix_to_PowerCepstrum_row (Matrix me, long row) {
try {
autoPowerCepstrum thee = PowerCepstrum_create (my xmax, my nx);
if (row < 1 || row > my ny) {
Melder_throw (U"Row number should be between 1 and ", my ny, U" inclusive.");
}
NUMvector_copyElements (my z[row], thy z[1], 1, my nx);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no PowerCepstrum created.");
}
}
autoPowerCepstrum Matrix_to_PowerCepstrum_column (Matrix me, long col) {
try {
autoPowerCepstrum thee = PowerCepstrum_create (my ymax, my ny);
if (col < 1 || col > my nx) {
Melder_throw (U"Column number should be between 1 and ", my nx, U" inclusive.");
}
for (long i = 1; i <= my ny; i++) {
thy z[1][i] = my z[i][col];
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no PowerCepstrum created.");
}
}
/* End of file Cepstrum.cpp */
praat-6.0.23/LPC/Cepstrum.h 0000664 0000000 0000000 00000010217 13023464014 0015300 0 ustar 00root root 0000000 0000000 #ifndef _Cepstrum_h_
#define _Cepstrum_h_
/* Cepstrum.h
*
* Copyright (C) 1994-2013, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20010111
djmw 20020812 GPL header
djmw 20121117 Latest modification.
*/
/*
The Cepstrum is a sequence of REAL numbers.
It is the spectrum of the power spectrum of a (sound) signal.
*/
#include "Matrix.h"
Thing_define (Cepstrum, Matrix) {
// overridden methods:
public:
virtual double v_getValueAtSample (long isamp, long which, int units);
};
/*
The Cepstrum is a sequence of REAL numbers.
It is the power spectrum of the power spectrum of a (sound) signal.
*/
Thing_define (PowerCepstrum, Cepstrum) {
// overridden methods:
public:
virtual double v_getValueAtSample (long isamp, long which, int units);
};
/*
xmin // Lowest quefrency.
xmax // Highest quefrency.
nx // Number of quefrencies.
dx // Quefrency step.
x1 // First quefrency.
ymin = ymax = dy = y1 = 1
ny = 1
*/
autoCepstrum Cepstrum_create (double qmax, long nq);
autoPowerCepstrum PowerCepstrum_create (double qmax, long nq);
/* Preconditions:
nq >= 2;
Postconditions:
my xmin = 0; my ymin = 1;
my xmax = qmax; my ymax = 1;
my nx = nq; my ny = 1;
my dx = qmax / (nq -1); my dy = 1;
my x1 = 0; my y1 = 1;
my z [1..ny] [1..nx] = 0.0;
*/
void PowerCepstrum_draw (PowerCepstrum me, Graphics g, double qmin, double qmax, double dBminimum, double dBmaximum, int garnish);
void Cepstrum_drawLinear (Cepstrum me, Graphics g, double qmin, double qmax, double minimum, double maximum, int garnish);
void PowerCepstrum_drawTiltLine (PowerCepstrum me, Graphics g, double qmin, double qmax, double dBminimum, double dBmaximum, double qstart, double qend, int lineType, int method);
/*
Function:
Draw a Cepstrum
Preconditions:
maximum > minimum;
Arguments:
[qmin, qmax]: quefrencies; x domain of drawing;
Autowindowing: if qmax <= qmin, x domain of drawing is
[my xmin, my xmax].
[minimum, maximum]: amplitude; y range of drawing.
*/
void PowerCepstrum_getMaximumAndQuefrency (PowerCepstrum me, double pitchFloor, double pitchCeiling, int interpolation, double *maximum, double *quefrency);
// The standard of Hillenbrand with fitting options
double PowerCepstrum_getPeakProminence_hillenbrand (PowerCepstrum me, double pitchFloor, double pitchCeiling, double *qpeak);
double PowerCepstrum_getRNR (PowerCepstrum me, double pitchFloor, double pitchCeiling, double f0fractionalWidth);
double PowerCepstrum_getPeakProminence (PowerCepstrum me, double pitchFloor, double pitchCeiling, int interpolation, double qstartFit, double qendFit, int lineType, int fitMethod, double *qpeak);
void PowerCepstrum_fitTiltLine (PowerCepstrum me, double qmin, double qmax, double *slope, double *intercept, int lineType, int method);
autoPowerCepstrum PowerCepstrum_subtractTilt (PowerCepstrum me, double qstartFit, double qendFit, int lineType, int fitMethod);
void PowerCepstrum_subtractTilt_inline (PowerCepstrum me, double qstartFit, double qendFit, int lineType, int fitMethod);
void PowerCepstrum_smooth_inline (PowerCepstrum me, double quefrencyAveragingWindow, long numberOfIterations);
autoPowerCepstrum PowerCepstrum_smooth (PowerCepstrum me, double quefrencyAveragingWindow, long numberOfIterations);
autoMatrix PowerCepstrum_to_Matrix (PowerCepstrum me);
autoPowerCepstrum Matrix_to_PowerCepstrum (Matrix me);
autoPowerCepstrum Matrix_to_PowerCepstrum_row (Matrix me, long row);
autoPowerCepstrum Matrix_to_PowerCepstrum_column (Matrix me, long col);
autoPowerCepstrum Cepstrum_downto_PowerCepstrum (Cepstrum me);
#endif /* _Cepstrum_h_ */
praat-6.0.23/LPC/Cepstrum_and_Spectrum.cpp 0000664 0000000 0000000 00000006755 13023464014 0020353 0 ustar 00root root 0000000 0000000 /* Cepstrum_and_Spectrum.cpp
*
* Copyright (C) 1994-2012, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20041124 Changed call to Sound_to_Spectrum.
djmw 20070103 Sound interface changes
djmw 20080122 float -> double
djmw 20121015
*/
#include "Cepstrum_and_Spectrum.h"
#include "NUM2.h"
#include "Spectrum_extensions.h"
#include "Sound_and_Spectrum.h"
#if 0
static autoCepstrum Spectrum_to_Cepstrum_cmplx (Spectrum me) {
try {
autoMatrix unwrap = Spectrum_unwrap (me);
autoSpectrum sx = Data_copy (me);
// Copy magnitude-squared and unwrapped phase.
for (long i = 1; i <= my nx; i ++) {
double xa = unwrap -> z[1][i];
sx -> z[1][i] = xa > 0.0 ? 0.5 * log (xa) : -300.0;
sx -> z[2][i] = unwrap -> z[2][i];
}
// Compute complex cepstrum x.
autoSound x = Spectrum_to_Sound (sx.get());
autoCepstrum thee = Cepstrum_create (x -> xmax - x -> xmin, x -> nx);
NUMvector_copyElements (x -> z[1], thy z[1], 1, x -> nx);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Cepstrum created.");
}
}
#endif
autoPowerCepstrum Spectrum_to_PowerCepstrum (Spectrum me) {
try {
autoSpectrum dBspectrum = Data_copy (me);
double *re = dBspectrum -> z[1], *im = dBspectrum -> z[2];
for (long i = 1; i <= dBspectrum -> nx; i ++) {
re[i] = log (re[i] * re[i] + im[i] * im[i] + 1e-300);
im[i] = 0.0;
}
autoSound cepstrum = Spectrum_to_Sound (dBspectrum.get());
autoPowerCepstrum thee = PowerCepstrum_create (0.5 / my dx, my nx);
for (long i = 1; i <= thy nx; i++) {
double val = cepstrum -> z[1][i];
thy z[1][i] = val * val;
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Sound.");
}
}
autoCepstrum Spectrum_to_Cepstrum (Spectrum me) {
try {
autoSpectrum dBspectrum = Data_copy (me);
double *re = dBspectrum -> z[1], *im = dBspectrum -> z[2];
for (long i = 1; i <= dBspectrum -> nx; i++) {
re[i] = log (re[i] * re[i] + im[i] * im[i] + 1e-300);
im[i] = 0.0;
}
autoSound cepstrum = Spectrum_to_Sound (dBspectrum.get());
autoCepstrum thee = Cepstrum_create (0.5 / my dx, my nx);
for (long i = 1; i <= thy nx; i++) {
double val = cepstrum -> z[1][i];
thy z[1][i] = val;
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Sound.");
}
}
autoSpectrum Cepstrum_to_Spectrum (Cepstrum me) { //TODO power cepstrum
try {
autoCepstrum cepstrum = Data_copy (me);
cepstrum -> z[1][1] = my z[1][1];
for (long i = 2; i <= cepstrum -> nx; i++) {
cepstrum -> z[1][i] = 2 * my z[1][i];
}
autoSpectrum thee = Sound_to_Spectrum ((Sound) cepstrum.get(), 1);
double *re = thy z[1], *im = thy z[2];
for (long i = 1; i <= thy nx; i ++) {
re[i] = exp (0.5 * re[i]); // i.e., sqrt (exp(re [i]))
im[i] = 0.0;
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Spectrum created.");
}
}
/* End of file Cepstrum_and_Spectrum.cpp */
praat-6.0.23/LPC/Cepstrum_and_Spectrum.h 0000664 0000000 0000000 00000002011 13023464014 0017775 0 ustar 00root root 0000000 0000000 #ifndef _Cepstrum_and_Spectrum_h_
#define _Cepstrum_and_Spectrum_h_
/* Cepstrum_and_Spectrum.h
*
* Copyright (C) 1994-2012, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Spectrum.h"
#include "Cepstrum.h"
autoCepstrum Spectrum_to_Cepstrum (Spectrum me);
autoSpectrum Cepstrum_to_Spectrum (Cepstrum me);
autoPowerCepstrum Spectrum_to_PowerCepstrum (Spectrum me);
#endif /* _Cepstrum_and_Spectrum_h_ */
praat-6.0.23/LPC/Cepstrumc.cpp 0000664 0000000 0000000 00000013527 13023464014 0016005 0 ustar 00root root 0000000 0000000 /* Cepstrumc.c
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20061218 Changed info to Melder_writeLine format.
djmw 20071017 oo_CAN_WRITE_AS_ENCODING.h
djmw 20080122 Version 1: float -> double
djmw 20110304 Thing_new
*/
#include "Cepstrumc.h"
#include "DTW.h"
#include "oo_DESTROY.h"
#include "Cepstrumc_def.h"
#include "oo_COPY.h"
#include "Cepstrumc_def.h"
#include "oo_EQUAL.h"
#include "Cepstrumc_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "Cepstrumc_def.h"
#include "oo_WRITE_TEXT.h"
#include "Cepstrumc_def.h"
#include "oo_WRITE_BINARY.h"
#include "Cepstrumc_def.h"
#include "oo_READ_TEXT.h"
#include "Cepstrumc_def.h"
#include "oo_READ_BINARY.h"
#include "Cepstrumc_def.h"
#include "oo_DESCRIPTION.h"
#include "Cepstrumc_def.h"
Thing_implement (Cepstrumc, Sampled, 1);
void structCepstrumc :: v_info () {
structDaata :: v_info ();
MelderInfo_writeLine (U" Start time: ", xmin);
MelderInfo_writeLine (U" End time: ", xmax);
MelderInfo_writeLine (U" Number of frames: ", nx);
MelderInfo_writeLine (U" Time step: ", dx);
MelderInfo_writeLine (U" First frame at: ", x1);
MelderInfo_writeLine (U" Number of coefficients: ", maxnCoefficients);
}
void Cepstrumc_Frame_init (Cepstrumc_Frame me, int nCoefficients) {
my c = NUMvector (0, nCoefficients);
my nCoefficients = nCoefficients;
}
void Cepstrumc_init (Cepstrumc me, double tmin, double tmax, long nt, double dt, double t1,
int nCoefficients, double samplingFrequency) {
my samplingFrequency = samplingFrequency;
my maxnCoefficients = nCoefficients;
Sampled_init (me, tmin, tmax, nt, dt, t1);
my frame = NUMvector (1, nt);
}
autoCepstrumc Cepstrumc_create (double tmin, double tmax, long nt, double dt, double t1,
int nCoefficients, double samplingFrequency) {
try {
autoCepstrumc me = Thing_new (Cepstrumc);
Cepstrumc_init (me.get(), tmin, tmax, nt, dt, t1, nCoefficients, samplingFrequency);
return me;
} catch (MelderError) {
Melder_throw (U"Cepstrum not created.");
}
}
static void regression (Cepstrumc me, long frame, double r[], long nr) {
long nc = 1e6; double sumsq = 0;
for (long i = 0; i <= my maxnCoefficients; i++) {
r[i] = 0;
}
if (frame <= nr / 2 || frame >= my nx - nr / 2) {
return;
}
for (long j = -nr / 2; j <= nr / 2; j++) {
Cepstrumc_Frame f = & my frame[frame + j];
if (f->nCoefficients < nc) {
nc = f->nCoefficients;
}
sumsq += j * j;
}
for (long i = 0; i <= nc; i++) {
for (long j = -nr / 2; j <= nr / 2; j++) {
Cepstrumc_Frame f = & my frame[frame + j];
r[i] += f->c[i] * j / sumsq / my dx;
}
}
}
autoDTW Cepstrumc_to_DTW (Cepstrumc me, Cepstrumc thee, double wc, double wle, double wr, double wer, double dtr, int matchStart, int matchEnd, int constraint) {
try {
long nr = (long) floor (dtr / my dx);
if (my maxnCoefficients != thy maxnCoefficients) {
Melder_throw (U"Cepstrumc orders must be equal.");
}
if (wr != 0 && nr < 2) {
Melder_throw (U"Time window for regression coefficients too small.");
}
if (nr % 2 == 0) {
nr++;
}
if (wr != 0) {
Melder_casual (U"Number of frames used for regression coefficients ", nr);
}
autoDTW him = DTW_create (my xmin, my xmax, my nx, my dx, my x1, thy xmin, thy xmax, thy nx, thy dx, thy x1);
autoNUMvector ri (0L, my maxnCoefficients);
autoNUMvector rj (0L, my maxnCoefficients);
// Calculate distance matrix
autoMelderProgress progress (U"");
for (long i = 1; i <= my nx; i++) {
Cepstrumc_Frame fi = & my frame[i];
regression (me, i, ri.peek(), nr);
for (long j = 1; j <= thy nx; j++) {
Cepstrumc_Frame fj = & thy frame[j];
double d, dist = 0, distr = 0;
if (wc != 0) { /* cepstral distance */
for (long k = 1; k <= fj -> nCoefficients; k++) {
d = fi -> c[k] - fj -> c[k];
dist += d * d;
}
dist *= wc;
}
// log energy distance
d = fi -> c[0] - fj -> c[0];
dist += wle * d * d;
if (wr != 0) { // regression distance
regression (thee, j, rj.peek(), nr);
for (long k = 1; k <= fj -> nCoefficients; k++) {
d = ri[k] - rj[k];
distr += d * d;
}
dist += wr * distr;
}
if (wer != 0) { // regression on c[0]: log(energy)
if (wr == 0) {
regression (thee, j, rj.peek(), nr);
}
d = ri[0] - rj[0];
dist += wer * d * d;
}
dist /= wc + wle + wr + wer;
his z[i][j] = sqrt (dist); // prototype along y-direction
}
Melder_progress ( (double) i / my nx, U"Calculate distances: frame ",
i, U" from ", my nx, U".");
}
DTW_findPath (him.get(), matchStart, matchEnd, constraint);
return him;
} catch (MelderError) {
Melder_throw (U"DTW not created.");
}
}
autoMatrix Cepstrumc_to_Matrix (Cepstrumc me) {
try {
autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1,
0, my maxnCoefficients, my maxnCoefficients + 1, 1, 0);
for (long i = 1; i <= my nx; i++) {
Cepstrumc_Frame him = & my frame[i];
for (long j = 1; j <= his nCoefficients + 1; j++) {
thy z[j][i] = his c[j - 1];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Matrix created.");
}
}
/* End of file Cepstrumc.cpp */
praat-6.0.23/LPC/Cepstrumc.h 0000664 0000000 0000000 00000004341 13023464014 0015444 0 ustar 00root root 0000000 0000000 #ifndef _Cepstrumc_h_
#define _Cepstrumc_h_
/* Cepstrumc.h
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19950822
djmw 20020812 GPL header
djmw 20110306 Latest modification.
*/
#include "Sampled.h"
#include "Matrix.h"
#include "Graphics.h"
#include "DTW.h"
#include "Cepstrumc_def.h"
void Cepstrumc_init (Cepstrumc me, double tmin, double tmax, long nt, double dt, double t1,
int nCoefficients, double samplingFrequency);
autoCepstrumc Cepstrumc_create (double tmin, double tmax, long nt, double dt, double t1,
int nCoefficients, double samplingFrequency);
/******************* Frames ************************************************/
void Cepstrumc_Frame_init (Cepstrumc_Frame me, int nCoefficients);
autoDTW Cepstrumc_to_DTW ( Cepstrumc me, Cepstrumc thee, double wc, double wle,
double wr, double wer, double dtr, int matchStart, int matchEnd, int constraint);
/*
1. Calculate distances between Cepstra:
Distance between frame i (from me) and j (from thee) is
wc * d1 + wle * d2 + wr * d3 + wer * d4,
where wc, wle, wr & wer are weights and
d1 = Sum (k=1; k=nCoefficients; (c[i,k]-c[j,k])^2)
d2 = (c[0,k]-c[0,k])^2
d3 = Sum (k=1; k=nCoefficients; (r[i,k]-r[j,k])^2), with
r[i,k] the regression coefficient of the cepstral coefficients
from the frames within a time span of 'dtr' seconds.
c[i,j] is jth cepstral coefficient in frame i.
d4 = regression on energy (c[0])
2. Find optimum path through the distance matrix (see DTW).
PRECONDITIONS:
at least one of wc, wle, wr, wer != 0
*/
autoMatrix Cepstrumc_to_Matrix (Cepstrumc me);
#endif /* _Cepstrumc_h_ */
praat-6.0.23/LPC/Cepstrumc_def.h 0000664 0000000 0000000 00000002675 13023464014 0016272 0 ustar 00root root 0000000 0000000 /* Cepstrumc_def.h
*
* Copyright (C) 1994-2008 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20080122 Version 1: float -> double
*/
#define ooSTRUCT Cepstrumc_Frame
oo_DEFINE_STRUCT (Cepstrumc_Frame)
oo_INT (nCoefficients)
#if oo_READING_BINARY
if (formatVersion == 0) {
oo_FLOAT_VECTOR_FROM (c, 0, nCoefficients)
} else {
oo_DOUBLE_VECTOR_FROM (c, 0, nCoefficients)
}
#else
oo_DOUBLE_VECTOR_FROM (c, 0, nCoefficients)
#endif
oo_END_STRUCT (Cepstrumc_Frame)
#undef ooSTRUCT
#define ooSTRUCT Cepstrumc
oo_DEFINE_CLASS (Cepstrumc, Sampled)
oo_DOUBLE (samplingFrequency) // from Sound
oo_INT (maxnCoefficients)
oo_STRUCT_VECTOR (Cepstrumc_Frame, frame, nx)
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS (Cepstrumc)
#undef ooSTRUCT
/* End of file Cepstrumc_def.h */
praat-6.0.23/LPC/Formant_extensions.cpp 0000664 0000000 0000000 00000012265 13023464014 0017723 0 ustar 00root root 0000000 0000000 /* Formant_extensions.cpp
*
* Copyright (C) 2012,2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Formant_extensions.h"
#include "NUM2.h"
void Formant_formula (Formant me, double tmin, double tmax, long formantmin, long formantmax, Interpreter interpreter, char32 *expression) {
try {
long numberOfPossibleFormants = my maxnFormants;
if (tmax <= tmin) {
tmin = my xmin; tmax = my xmax;
}
if (formantmax >= formantmin) {
formantmin = 1; formantmax = numberOfPossibleFormants;
}
formantmin = formantmin < 1 ? 1 : formantmin;
formantmax = formantmax > numberOfPossibleFormants ? numberOfPossibleFormants : formantmax;
autoMatrix fb = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 1.0, 2 * numberOfPossibleFormants, 2 * numberOfPossibleFormants, 1.0, 1.0);
for (long iframe = 1; iframe <= my nx; iframe ++) {
Formant_Frame frame = & my d_frames [iframe];
int numberOfFormants = frame -> nFormants < numberOfPossibleFormants ? frame -> nFormants : numberOfPossibleFormants;
for (long iformant = 1; iformant <= numberOfFormants; iformant++) {
if (iformant <= frame -> nFormants) {
fb -> z[2 * iformant - 1][iframe] = frame -> formant[iformant].frequency;
fb -> z[2 * iformant ][iframe] = frame -> formant[iformant].bandwidth;
}
}
}
// Apply formula
double ymin = 2.0 * formantmin - 1.0, ymax = 2.0 * formantmax;
Matrix_formula_part (fb.get(), tmin, tmax, ymin, ymax, expression, interpreter, nullptr);
// Put results back in Formant
long ixmin, ixmax, iymin, iymax;
(void) Matrix_getWindowSamplesX (fb.get(), tmin, tmax, & ixmin, & ixmax);
(void) Matrix_getWindowSamplesY (fb.get(), ymin, ymax, & iymin, & iymax);
for (long iframe = ixmin; iframe <= ixmax; iframe++) {
// if some of the formant frequencies are set to zero => remove the formant
Formant_Frame frame = & my d_frames [iframe];
int numberOfFormants = frame -> nFormants < formantmax ? frame -> nFormants : formantmax;
int iformantto = formantmin > 1 ? formantmin - 1 : 0;
for (long iformant = formantmin; iformant <= numberOfFormants; iformant++) {
double frequency = fb -> z[2 * iformant - 1][iframe];
double bandWidth = fb -> z[2 * iformant ][iframe];
if (frequency > 0 && bandWidth > 0) {
iformantto++;
frame -> formant[iformantto].frequency = frequency;
frame -> formant[iformantto].bandwidth = bandWidth;
} else {
frame -> formant[iformant].frequency = frame -> formant[iformant].bandwidth = 0;
}
}
// shift the (higher) formants down if necessary.
for (long iformant = formantmax + 1; iformant <= frame -> nFormants; iformant++) {
double frequency = fb -> z[2 * iformant - 1][iframe];
double bandWidth = fb -> z[2 * iformant ][iframe];
if (frequency > 0 && bandWidth > 0) {
iformantto++;
frame -> formant[iformantto].frequency = frequency;
frame -> formant[iformantto].bandwidth = bandWidth;
} else {
frame -> formant[iformant].frequency = frame -> formant[iformant].bandwidth = 0;
}
}
frame -> nFormants = iformantto;
}
} catch (MelderError) {
Melder_throw (me, U": not filtered.");
}
}
autoIntensityTier Formant_and_Spectrogram_to_IntensityTier (Formant me, Spectrogram thee, long iformant) {
try {
if (my xmin != thy xmin || my xmax != thy xmax) {
Melder_throw (U"The start and end times of the Formant and the Spectrogram must be equal.");
}
if (iformant < 1 || iformant > my maxnFormants) {
Melder_throw (U"Formant number not in range [1, ", my maxnFormants, U"].");
}
autoIntensityTier him = IntensityTier_create (my xmin, my xmax);
double previousValue = -80000.0; // can never occur
double previousTime = my xmin;
for (long iframe = 1; iframe <= my nx; iframe++) {
Formant_Frame frame = & my d_frames [iframe];
long numberOfFormants = frame -> nFormants;
double time = Sampled_indexToX (me, iframe);
double value = 0;
if (iformant <= numberOfFormants) {
double f = frame -> formant[iformant].frequency;
value = Matrix_getValueAtXY (thee, time, f);
value = value == NUMundefined ? 0.0 : value;
}
value = 10.0 * log10 ((value + 1e-30) / 4.0e-10); /* dB / Hz */
if (value != previousValue) {
if (iframe > 1 && previousTime < time - 1.5 * my dx) { // mark the end of the same interval
RealTier_addPoint (him.get(), time - my dx, previousValue);
}
RealTier_addPoint (him.get(), time, value);
previousTime = time;
}
previousValue = value;
}
return him;
} catch (MelderError) {
Melder_throw (U"IntensityTier not created from ", me, U" and ", thee, U".");
}
}
/* End of file Formant_extensions.cpp */
praat-6.0.23/LPC/Formant_extensions.h 0000664 0000000 0000000 00000002224 13023464014 0017362 0 ustar 00root root 0000000 0000000 #ifndef _Formant_extensions_h_
#define _Formant_extensions_h_
/* Formant_extensions.h
*
* Copyright (C) 2012, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20121214 Initial version
*/
#include "Formant.h"
#include "IntensityTier.h"
#include "Spectrogram.h"
void Formant_formula (Formant me, double tmin, double tmax, long formantmin, long formantmax, Interpreter interpreter, char32 *expression);
autoIntensityTier Formant_and_Spectrogram_to_IntensityTier (Formant me, Spectrogram thee, long iformant);
#endif /* _Formant_extensions_h_ */
praat-6.0.23/LPC/LPC.cpp 0000664 0000000 0000000 00000013355 13023464014 0014455 0 ustar 00root root 0000000 0000000 /* LPC.cpp
*
* Copyright (C) 1994-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20030612 Removed LPC_Frame_free
djmw 20060510 LPC_drawPoles error cleared if something goes wrong.
djmw 20061212 Changed info to Melder_writeLine format.
djmw 20071017 oo_CAN_WRITE_AS_ENCODING.h
djmw 20080122 float -> double
djmw 20081223 Corrected a bug in Matrix LPC_to_Matrix (last coefficient was not copied)
djmw 20110304 Thing_new
*/
#include "LPC_and_Polynomial.h"
#include "NUM2.h"
#include "oo_DESTROY.h"
#include "LPC_def.h"
#include "oo_COPY.h"
#include "LPC_def.h"
#include "oo_EQUAL.h"
#include "LPC_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "LPC_def.h"
#include "oo_WRITE_TEXT.h"
#include "LPC_def.h"
#include "oo_WRITE_BINARY.h"
#include "LPC_def.h"
#include "oo_READ_TEXT.h"
#include "LPC_def.h"
#include "oo_READ_BINARY.h"
#include "LPC_def.h"
#include "oo_DESCRIPTION.h"
#include "LPC_def.h"
Thing_implement (LPC, Sampled, 1);
void structLPC :: v_info () {
structDaata :: v_info ();
MelderInfo_writeLine (U"Time domain: ", xmin, U" to ", xmax, U" (s).");
MelderInfo_writeLine (U"Prediction order: ", maxnCoefficients);
MelderInfo_writeLine (U"Number of frames: ", nx);
MelderInfo_writeLine (U"Time step: ", dx, U" (s).");
MelderInfo_writeLine (U"First frame at: ", x1, U" (s).");
}
void LPC_Frame_init (LPC_Frame me, int nCoefficients) {
if (nCoefficients != 0) {
my a = NUMvector (1, nCoefficients);
}
my nCoefficients = nCoefficients;
}
void LPC_init (LPC me, double tmin, double tmax, long nt, double dt, double t1,
int predictionOrder, double samplingPeriod) {
my samplingPeriod = samplingPeriod;
my maxnCoefficients = predictionOrder;
Sampled_init (me, tmin, tmax, nt, dt, t1);
my d_frames = NUMvector (1, nt);
}
autoLPC LPC_create (double tmin, double tmax, long nt, double dt, double t1,
int predictionOrder, double samplingPeriod) {
try {
autoLPC me = Thing_new (LPC);
LPC_init (me.get(), tmin, tmax, nt, dt, t1, predictionOrder, samplingPeriod);
return me;
} catch (MelderError) {
Melder_throw (U"LPC not created.");
}
}
void LPC_drawGain (LPC me, Graphics g, double tmin, double tmax, double gmin, double gmax, int garnish) {
if (tmax <= tmin) {
tmin = my xmin;
tmax = my xmax;
}
long itmin, itmax;
if (! Sampled_getWindowSamples (me, tmin, tmax, & itmin, & itmax)) {
return;
}
autoNUMvector gain (itmin, itmax);
for (long iframe = itmin; iframe <= itmax; iframe++) {
gain[iframe] = my d_frames[iframe].gain;
}
if (gmax <= gmin) {
NUMvector_extrema (gain.peek(), itmin, itmax, & gmin, & gmax);
}
if (gmax == gmin) {
gmin = 0;
gmax += 0.5;
}
Graphics_setInner (g);
Graphics_setWindow (g, tmin, tmax, gmin, gmax);
for (long iframe = itmin; iframe <= itmax; iframe++) {
double x = Sampled_indexToX (me, iframe);
Graphics_speckle (g, x, gain[iframe]);
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, true, U"Time (seconds)");
Graphics_textLeft (g, true, U"Gain");
Graphics_marksBottom (g, 2, true, true, false);
Graphics_marksLeft (g, 2, true, true, false);
}
}
void LPC_drawPoles (LPC me, Graphics g, double time, int garnish) {
autoPolynomial p = LPC_to_Polynomial (me, time);
autoRoots r = Polynomial_to_Roots (p.get());
Roots_draw (r.get(), g, -1.0, 1.0, -1.0, 1.0, U"+", 12, garnish);
}
autoMatrix LPC_downto_Matrix_lpc (LPC me) {
try {
autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 0.5, 0.5 + my maxnCoefficients, my maxnCoefficients, 1.0, 1.0);
for (long j = 1; j <= my nx; j++) {
LPC_Frame lpc = & my d_frames[j];
for (long i = 1; i <= lpc -> nCoefficients; i++) {
thy z[i][j] = lpc -> a[i];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Matrix with linear prediction coefficients created.");
}
}
autoMatrix LPC_downto_Matrix_rc (LPC me) {
try {
autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 0.5, 0.5 + my maxnCoefficients, my maxnCoefficients, 1.0, 1.0);
autoNUMvector rc (1, my maxnCoefficients);
for (long j = 1; j <= my nx; j++) {
LPC_Frame lpc = & my d_frames[j];
NUMlpc_lpc_to_rc (lpc -> a, lpc -> nCoefficients, rc.peek());
for (long i = 1; i <= lpc -> nCoefficients; i++) {
thy z[i][j] = rc[i];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Matrix with relection coefficients created.");
}
}
autoMatrix LPC_downto_Matrix_area (LPC me) {
try {
autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 0.5, 0.5 + my maxnCoefficients, my maxnCoefficients, 1.0, 1.0);
autoNUMvector rc (1, my maxnCoefficients);
autoNUMvector area (1, my maxnCoefficients);
for (long j = 1; j <= my nx; j++) {
LPC_Frame lpc = & my d_frames[j];
NUMlpc_lpc_to_rc (lpc -> a, lpc -> nCoefficients, rc.peek());
NUMlpc_rc_to_area (rc.peek(), lpc -> nCoefficients, area.peek());
for (long i = 1; i <= lpc -> nCoefficients; i++) {
thy z[i][j] = area[i];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Matrix with areas created.");
}
}
/* End of file LPC.cpp */
praat-6.0.23/LPC/LPC.h 0000664 0000000 0000000 00000003153 13023464014 0014115 0 ustar 00root root 0000000 0000000 #ifndef _LPC_h_
#define _LPC_h_
/* LPC.h
*
* Copyright (C) 1994-2012, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Matrix.h"
#include "Graphics.h"
#include "LPC_def.h"
/*
From Sampled:
xmin, xmax : range of time (s)
x1 : position of first frame (s)
dx : step size (s)
nx : number of frames
*/
void LPC_init (LPC me, double tmin, double tmax, long nt, double dt, double t1, int predictionOrder, double samplingPeriod);
autoLPC LPC_create (double tmin, double tmax, long nt, double dt, double t1, int predictionOrder, double samplingPeriod);
void LPC_drawGain (LPC me, Graphics g, double t1, double t2, double gmin, double gmax, int garnish);
void LPC_drawPoles (LPC me, Graphics g, double time, int garnish);
autoMatrix LPC_downto_Matrix_lpc (LPC me);
autoMatrix LPC_downto_Matrix_rc (LPC me);
autoMatrix LPC_downto_Matrix_area (LPC me);
/******************* Frames ************************************************/
void LPC_Frame_init (LPC_Frame me, int nCoefficients);
#endif /* _LPC_h_ */
praat-6.0.23/LPC/LPC_and_Cepstrumc.cpp 0000664 0000000 0000000 00000005256 13023464014 0017325 0 ustar 00root root 0000000 0000000 /* LPC_and_Cepstrumc.cpp
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20080122 float -> double
*/
/* LPC_and_Cepstrumc.c */
#include "LPC_and_Cepstrumc.h"
void LPC_Frame_into_Cepstrumc_Frame (LPC_Frame me, Cepstrumc_Frame thee) {
long n = my nCoefficients > thy nCoefficients ? thy nCoefficients : my nCoefficients;
double *c = thy c, *a = my a;
c[0] = 0.5 * log (my gain);
if (n == 0) {
return;
}
c[1] = -a[1];
for (long i = 2; i <= n; i++) {
c[i] = 0;
for (long k = 1; k < i; k++) {
c[i] += a[i - k] * c[k] * k;
}
c[i] = -a[i] - c[i] / i;
}
}
void Cepstrumc_Frame_into_LPC_Frame (Cepstrumc_Frame me, LPC_Frame thee) {
double *c = my c, *a = thy a;
thy gain = exp (2.0 * c[0]);
if (thy nCoefficients == 0) {
return;
}
a[1] = -c[1];
for (long i = 2; i <= thy nCoefficients; i++) {
c[i] *= i;
}
for (long i = 2; i <= thy nCoefficients; i++) {
a[i] = c[i];
for (long j = 1 ; j < i; j++) {
a[i] += a[j] * c[i - j];
}
a[i] /= -i;
}
for (long i = 2; i <= thy nCoefficients; i++) {
c[i] /= i;
}
}
autoCepstrumc LPC_to_Cepstrumc (LPC me) {
try {
autoCepstrumc thee = Cepstrumc_create (my xmin, my xmax, my nx, my dx, my x1,
my maxnCoefficients, 1.0 / my samplingPeriod);
for (long i = 1; i <= my nx; i++) {
Cepstrumc_Frame_init (& thy frame[i], my d_frames[i].nCoefficients);
LPC_Frame_into_Cepstrumc_Frame (& my d_frames[i], & thy frame[i]);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Cepstrum created.");
}
}
autoLPC Cepstrumc_to_LPC (Cepstrumc me) {
try {
autoLPC thee = LPC_create (my xmin, my xmax, my nx, my dx, my x1,
my maxnCoefficients, 1.0 / my samplingFrequency);
for (long i = 1; i <= my nx; i++) {
LPC_Frame_init (& thy d_frames[i], my frame[i].nCoefficients);
Cepstrumc_Frame_into_LPC_Frame (& my frame[i], & thy d_frames[i]);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U":no LPC created.");
}
}
/* End of file LPC_and_Cepstrumc.cpp */
praat-6.0.23/LPC/LPC_and_Cepstrumc.h 0000664 0000000 0000000 00000002221 13023464014 0016757 0 ustar 00root root 0000000 0000000 #ifndef _LPC_and_Cepstrumc_h_
#define _LPC_and_Cepstrumc_h_
/* LPC_and_Cepstrumc.h
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19950410
djmw 20020812 GPL header
djmw 20110307 Latest modification
*/
#include "LPC.h"
#include "Cepstrumc.h"
autoCepstrumc LPC_to_Cepstrumc (LPC me);
autoLPC Cepstrumc_to_LPC (Cepstrumc me);
void LPC_Frame_into_Cepstrumc_Frame (LPC_Frame me, Cepstrumc_Frame thee);
void Cepstrumc_Frame_into_LPC_Frame (Cepstrumc_Frame me, LPC_Frame thee);
#endif /* _LPC_and_Cepstrumc_h_ */
praat-6.0.23/LPC/LPC_and_Formant.cpp 0000664 0000000 0000000 00000012334 13023464014 0016761 0 ustar 00root root 0000000 0000000 /* LPC_and_Formant.cpp
*
* Copyright (C) 1994-2013, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20030616 Formant_Frame_into_LPC_Frame: remove formant with f >= Nyquist +
change lpc indexing from -1..m
djmw 20080122 float -> double
*/
#include "LPC_and_Formant.h"
#include "LPC_and_Polynomial.h"
#include "NUM2.h"
void Formant_Frame_init (Formant_Frame me, long nFormants) {
my nFormants = nFormants;
if (nFormants > 0) {
my formant = NUMvector (1, my nFormants);
}
}
void Formant_Frame_scale (Formant_Frame me, double scale) {
for (long i = 1; i <= my nFormants; i++) {
my formant[i].frequency *= scale;
my formant[i].bandwidth *= scale;
}
}
void Roots_into_Formant_Frame (Roots me, Formant_Frame thee, double samplingFrequency, double margin) {
long n = my max - my min + 1;
autoNUMvector fc (1, n);
autoNUMvector bc (1, n);
// Determine the formants and bandwidths
thy nFormants = 0;
double fLow = margin, fHigh = samplingFrequency / 2 - margin;
for (long i = my min; i <= my max; i++) {
if (my v[i].im < 0) {
continue;
}
double f = fabs (atan2 (my v[i].im, my v[i].re)) * samplingFrequency / 2.0 / NUMpi;
if (f >= fLow && f <= fHigh) {
/*b = - log (my v[i].re * my v[i].re + my v[i].im * my v[i].im) * samplingFrequency / 2 / NUMpi;*/
double b = - log (dcomplex_abs (my v[i])) * samplingFrequency / NUMpi;
thy nFormants++;
fc[thy nFormants] = f;
bc[thy nFormants] = b;
}
}
Formant_Frame_init (thee, thy nFormants);
for (long i = 1; i <= thy nFormants; i++) {
thy formant[i].frequency = fc[i];
thy formant[i].bandwidth = bc[i];
}
}
void LPC_Frame_into_Formant_Frame (LPC_Frame me, Formant_Frame thee, double samplingPeriod, double margin) {
thy intensity = my gain;
if (my nCoefficients == 0) {
return;
}
autoPolynomial p = LPC_Frame_to_Polynomial (me);
autoRoots r = Polynomial_to_Roots (p.get());
Roots_fixIntoUnitCircle (r.get());
Roots_into_Formant_Frame (r.get(), thee, 1 / samplingPeriod, margin);
}
autoFormant LPC_to_Formant (LPC me, double margin) {
try {
double samplingFrequency = 1.0 / my samplingPeriod;
long nmax = my maxnCoefficients, err = 0;
long interval = nmax > 20 ? 1 : 10;
if (nmax > 99) {
Melder_throw (U"We cannot find the roots of a polynomial of order > 99.");
}
if (margin >= samplingFrequency / 4) {
Melder_throw (U"Margin should be smaller than ", samplingFrequency / 4, U".");
}
autoFormant thee = Formant_create (my xmin, my xmax, my nx, my dx, my x1, (nmax + 1) / 2);
autoMelderProgress progress (U"LPC to Formant");
for (long i = 1; i <= my nx; i++) {
Formant_Frame formant = & thy d_frames[i];
LPC_Frame lpc = & my d_frames[i];
// Initialisation of Formant_Frame is taken care of in Roots_into_Formant_Frame!
try {
LPC_Frame_into_Formant_Frame (lpc, formant, my samplingPeriod, margin);
} catch (MelderError) {
Melder_clearError();
err++;
}
if ( (interval == 1 || (i % interval) == 1)) {
Melder_progress ( (double) i / my nx, U"LPC to Formant: frame ", i,
U" out of ", my nx, U".");
}
}
Formant_sort (thee.get());
if (err > 0) {
Melder_warning (err, U" formant frames out of ", my nx, U" are suspect.");
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Formant created.");
}
}
void Formant_Frame_into_LPC_Frame (Formant_Frame me, LPC_Frame thee, double samplingPeriod) {
long m = 2, n = 2 * my nFormants;
if (my nFormants < 1) {
return;
}
autoNUMvector lpc (-1, n);
lpc[0] = 1;
double nyquist = 2.0 / samplingPeriod;
for (long i = 1; i <= my nFormants; i++) {
double f = my formant[i].frequency;
if (f > nyquist) {
continue;
}
// D(z): 1 + p z^-1 + q z^-2
double r = exp (- NUMpi * my formant[i].bandwidth * samplingPeriod);
double p = - 2 * r * cos (2 * NUMpi * f * samplingPeriod);
double q = r * r;
for (long j = m; j > 0; j--) {
lpc[j] += p * lpc[j - 1] + q * lpc[j - 2];
}
m += 2;
}
n = thy nCoefficients < n ? thy nCoefficients : n;
for (long i = 1; i <= n ; i++) {
thy a[i] = lpc[i];
}
thy gain = my intensity;
}
autoLPC Formant_to_LPC (Formant me, double samplingPeriod) {
try {
autoLPC thee = LPC_create (my xmin, my xmax, my nx, my dx, my x1, 2 * my maxnFormants, samplingPeriod);
for (long i = 1; i <= my nx; i++) {
Formant_Frame f = & my d_frames[i];
LPC_Frame lpc = & thy d_frames[i];
long m = 2 * f -> nFormants;
LPC_Frame_init (lpc, m);
Formant_Frame_into_LPC_Frame (f, lpc, samplingPeriod);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LPC created.");
}
}
/* End of file LPC_and_Formant.cpp */
praat-6.0.23/LPC/LPC_and_Formant.h 0000664 0000000 0000000 00000002607 13023464014 0016430 0 ustar 00root root 0000000 0000000 #ifndef _LPC_and_Formant_h_
#define _LPC_and_Formant_h_
/* LPC_and_Formant.h
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "LPC.h"
#include "Polynomial.h"
#include "Formant.h"
autoFormant LPC_to_Formant (LPC me, double margin);
autoLPC Formant_to_LPC (Formant me, double samplingPeriod);
void LPC_Frame_into_Formant_Frame (LPC_Frame me, Formant_Frame thee, double samplingPeriod, double margin);
void Formant_Frame_into_LPC_Frame (Formant_Frame me, LPC_Frame thee, double samplingPeriod);
void Formant_Frame_scale (Formant_Frame me, double scale);
void Roots_into_Formant_Frame (Roots me, Formant_Frame thee, double samplingFrequency, double margin);
void Formant_Frame_init (Formant_Frame me, long nFormants);
#endif /* _LPC_and_Formant_h_ */
praat-6.0.23/LPC/LPC_and_LFCC.cpp 0000664 0000000 0000000 00000005705 13023464014 0016066 0 ustar 00root root 0000000 0000000 /* LPC_and_LFCC.cpp
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20030205 Latest modifiation
*/
#include "LPC_and_LFCC.h"
#include "NUM2.h"
#define MIN(m,n) ((m) < (n) ? (m) : (n))
void LPC_Frame_into_CC_Frame (LPC_Frame me, CC_Frame thee) {
double *c = thy c, *a = my a;
thy c0 = 0.5 * log (my gain);
if (my nCoefficients < 1) {
return;
}
c[1] = -a[1];
for (long n = 2; n <= MIN (my nCoefficients, thy numberOfCoefficients); n++) {
double s = 0;
for (long k = 1; k < n; k++) {
s += a[k] * c[n - k] * (n - k);
}
c[n] = -a[n] - s / n;
}
for (long n = my nCoefficients + 1; n <= thy numberOfCoefficients; n++) {
double s = 0;
for (long k = 1; k <= my nCoefficients; k++) {
s += a[k] * c[n - k] * (n - k);
}
c[n] = - s / n;
}
}
void CC_Frame_into_LPC_Frame (CC_Frame me, LPC_Frame thee) {
long n = MIN (my numberOfCoefficients, thy nCoefficients);
double *c = my c, *a = thy a;
thy gain = exp (2.0 * my c0);
if (n < 1) {
return;
}
a[1] = -c[1];
for (long i = 2; i <= n; i++) {
double ai = c[i] * i;
for (long j = 1; j < i; j++) {
ai += a[j] * c[i - j] * (i - j);
}
a[i] = -ai / i;
}
}
autoLFCC LPC_to_LFCC (LPC me, long numberOfCoefficients) {
try {
if (numberOfCoefficients < 1) {
numberOfCoefficients = my maxnCoefficients;
}
autoLFCC thee = LFCC_create (my xmin, my xmax, my nx, my dx, my x1, numberOfCoefficients, 0, 0.5 / my samplingPeriod);
for (long i = 1; i <= my nx; i++) {
CC_Frame_init (& thy frame[i], numberOfCoefficients);
LPC_Frame_into_CC_Frame (& my d_frames[i], & thy frame[i]);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LFCC created.");
}
}
autoLPC LFCC_to_LPC (LFCC me, long numberOfCoefficients) {
try {
if (numberOfCoefficients < 1) {
numberOfCoefficients = my maximumNumberOfCoefficients;
}
numberOfCoefficients = MIN (numberOfCoefficients, my maximumNumberOfCoefficients);
autoLPC thee = LPC_create (my xmin, my xmax, my nx, my dx, my x1, numberOfCoefficients, 0.5 / my fmax);
for (long i = 1; i <= my nx; i++) {
LPC_Frame_init (& thy d_frames[i], numberOfCoefficients);
CC_Frame_into_LPC_Frame (& my frame[i], & thy d_frames[i]);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LPC created.");
}
}
#undef MIN
/* End of file LPC_and_LFCC.cpp */
praat-6.0.23/LPC/LPC_and_LFCC.h 0000664 0000000 0000000 00000003346 13023464014 0015532 0 ustar 00root root 0000000 0000000 #ifndef _LPC_and_LFCC_h_
#define _LPC_and_LFCC_h_
/* LPC_and_LFCC.h
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20001228
djmw 20020812 GPL header
djmw 20110307 Latest modification
*/
#include "LPC.h"
#include "LFCC.h"
autoLFCC LPC_to_LFCC (LPC me, long numberOfCoefficients);
autoLPC LFCC_to_LPC (LFCC me, long numberOfCoefficients);
void LPC_Frame_into_CC_Frame (LPC_Frame me, CC_Frame thee);
/*
Transformation of lp-coefficients to cepstral coefficients.
The number of cepstral coefficients may be larger than
the number of lp-coefficients (equation 5).
Reference: Digital Signal Processing Committee (eds.),
Programs for Digital Signal Processing, IEEE Press,
1979 (Formulas 4a, 4b, 4c and 5, page 4.3-2).
*/
void CC_Frame_into_LPC_Frame (CC_Frame me, LPC_Frame thee);
/*
Transformation of cepstral coefficients to lp-coefficients.
The number of lp-coefficients can never exceed the number
of cepstral coefficients.
Reference: Digital Signal Processing Committee (eds.),
Programs for Digital Signal Processing, IEEE Press,
1979 (page 4.3-6).
*/
#endif /* _LPC_and_LFCC_h_ */
praat-6.0.23/LPC/LPC_and_LineSpectralFrequencies.cpp 0000664 0000000 0000000 00000027373 13023464014 0022143 0 ustar 00root root 0000000 0000000 /* LPC_and_LineSpectralFrequencies.cpp
*
* Copyright (C) 2016 David Weenink
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
djmw 20160421 Initial version
*/
#include "LPC_and_LineSpectralFrequencies.h"
#include "NUM2.h"
#include "Polynomial.h"
/* Conversion from Y(w) to a polynomial in x (= 2 cos (w))
* From: Joseph Rothweiler (1999), "On Polynomial Reduction in the Computation of LSP Frequencies."
* IEEE Trans. on ASSP 7, 592--594.
*/
static void cos2x (double *g, long order) {
for (long i = 2; i <= order; i ++) {
for (long j = order; j > i; j--) {
g [j - 2] -= g[j];
}
g [i - 2] -= 2.0 * g [i];
}
}
static void Polynomial_fromLPC_Frame_lspsum (Polynomial me, LPC_Frame lpc) {
/* Fs (z) = A(z) + z^-(p+1) A(1/z) */
long order = lpc -> nCoefficients, g_order = (order + 1) / 2; // orders
my coefficients [order + 2] = 1.0;
for (long i = 1; i <= order; i++) {
my coefficients [order + 2 - i] = lpc -> a [i] + lpc -> a [order + 1 - i];
}
my coefficients [1] = 1.0;
my numberOfCoefficients = order + 2;
if (order % 2 == 0) { // order even
Polynomial_divide_firstOrderFactor (me, -1.0, nullptr);
}
/* transform to cos(w) terms */
for (long i = 1; i <= g_order + 1; i++) {
my coefficients [i] = my coefficients [g_order + i];
}
my numberOfCoefficients = g_order + 1;
/* to Chebychev */
cos2x (& my coefficients [1], g_order);
}
static void Polynomial_fromLPC_Frame_lspdif (Polynomial me, LPC_Frame lpc) {
/* Fa (z) = A(z) - z^-(p+1)A(1/z) */
long order = lpc -> nCoefficients;
my coefficients [order + 2] = -1.0;
for (long i = 1; i <= order; i++) {
my coefficients [order + 2 - i] = -lpc -> a [i] + lpc -> a [order + 1 - i];
}
my coefficients [1] = 1.0;
my numberOfCoefficients = order + 2;
if (order % 2 == 0) { // Fa(z)/(z-1)
Polynomial_divide_firstOrderFactor (me, 1.0, nullptr);
} else { // Fa(z) / (z^2 - 1)
Polynomial_divide_secondOrderFactor (me, 1.0);
}
/* transform to cos(w) terms */
long g_order = my numberOfCoefficients / 2;
for (long i = 1; i <= g_order + 1; i++) {
my coefficients [i] = my coefficients [g_order + i];
}
my numberOfCoefficients = g_order + 1;
/* to Chebychev */
cos2x (& my coefficients [1], g_order);
}
#if 0
/* g[0]+g[1]x + ... g[m]*x^ m = 0 ; m must be even
* Semenov, Kalyuzhny, Kovtonyuk (2003), Efficient calculation of line spectral frequencies based on new method for solution of transcendental equations,
* ICASSP 2003, 457--460
* g[0 .. g_order]
* work [0.. g_order + 1 + (numberOfDerivatives + 1) * 5]
* root [1 .. (g_order+1)/2]
*/
static void Roots_fromPolynomial (Roots me, Polynomial g, long numberOfDerivatives, double *work) {
if (numberOfDerivatives < 3) {
Melder_throw (U"Number of derivatives must be at least 3.");
}
double xmin = -1.0, xmax = 1.0;
long numberOfRootsFound = 0;
long g_order = g -> numberOfCoefficients - 1;
double *gabs = work, *fact = gabs + g_order + 1, *p2 = fact + numberOfDerivatives + 1;
double *derivatives = p2 + numberOfDerivatives + 1, *constraints = derivatives + numberOfDerivatives + 1;
double *intervals = constraints + numberOfDerivatives + 1;
/* Fill vectors with j! and 2^j only once */
fact [0] = p2 [0] = 1.0;
for (long j = 1; j <= numberOfDerivatives; j ++) {
fact [j] = fact [j - 1] * j; // j!
p2 [j] = p2 [j - 1] * 2.0; // 2^j
}
/* The constraints M[j] (Semenov et al. eq. (8)) can be calculated by taking absolute values of
* the polynomial coefficients and evaluating the polynomial and the derivatives at x = 1.0
*/
for (long k = 0; k <= g_order; k++) {
gabs [k] = fabs (g -> coefficients [k + 1]);
}
evaluatePolynomialAndDerivatives (gabs, g_order, 1.0, constraints, numberOfDerivatives);
intervals [0] = 1.0;
while (numberOfRootsFound < g_order || xmin == xmax) {
double dsum1 = 0.0, dsum2 = 0.0;
double xmid = (xmin + xmax) / 2.0;
evaluatePolynomialAndDerivatives (g, g_order, xmid, derivatives, numberOfDerivatives);
double fxmid = derivatives[0], fdxmin = derivatives[1];
long j = 1;
bool rootsOnIntervalPossible_f = true, rootsOnIntervalPossible_df = true;
while (j <= numberOfDerivatives && (rootsOnIntervalPossible_f || rootsOnIntervalPossible_df)) {
intervals [j] = intervals [j - 1] * (xmax - xmin);
long k = j - 1;
if (j > 1) { // start at first derivative
dsum1 += fabs (derivatives [k]) * intervals [k] / (p2 [k] * fact [k]);
}
if (j > 2) { // start at second derivative
dsum2 += fabs (derivatives [k]) * intervals [k - 1] / (p2 [k - 1] * fact [k - 1]);
if (rootsOnIntervalPossible_f) {
double testValue1 = dsum1 + constraints [j] * intervals [j] / (p2 [j] * fact [j]);
rootsOnIntervalPossible_f = ! (fxmid + testValue1 < 0 || fxmid - testValue1 > 0);
}
if (rootsOnIntervalPossible_df) {
double testValue2 = dsum2 + constraints [j] * intervals [j - 1] / (p2 [j - 1] * fact [j - 1]);
rootsOnIntervalPossible_df = ! (fdxmin + testValue2 < 0 || fdxmin - testValue2 > 0);
}
}
j++;
}
if (rootsOnIntervalPossible_f) {
if (rootsOnIntervalPossible_df) { // f(x) uncertain && f'(x) uncertain : bisect
xmax = xmid;
} else {// f(x) uncertain; f'(x) certain
double fxmin = evaluatePolynomial (g, g_order, xmin);
double fxmax = evaluatePolynomial (g, g_order, xmax);
if (fxmin * fxmax <= 0.0) {
double root;
NUMnrbis (dpoly, xmin, xmax, &poly, &root);
roots [++numberOfRootsFound] = root;
} else {
xmin = xmax; xmax = 1.0;
}
}
} else {
xmin = xmax; xmax = 1.0;
}
}
}
#endif
static long Roots_fromPolynomial_grid (Roots me, Polynomial thee, double gridSize) {
Melder_assert (my max >= thy numberOfCoefficients - 1);
double xmin = thy xmin;
long numberOfRootsFound = 0;
while (xmin < thy xmax && numberOfRootsFound < thy numberOfCoefficients - 1) {
double xmax = xmin + gridSize;
xmax = xmax > thy xmax ? thy xmax : xmax;
//double root = Polynomial_findOneRealRoot_nr (thee, xmin, xmax);
double root = Polynomial_findOneSimpleRealRoot_ridders (thee, xmin, xmax);
if (root != NUMundefined && (numberOfRootsFound == 0 || my v [numberOfRootsFound].re != root)) {
my v [++numberOfRootsFound].re = root; // root not at border of interval
my v [numberOfRootsFound].im = 0.0;
}
xmin = xmax;
}
// make rest of storage undefined (not necessary)
return numberOfRootsFound;
}
static void LineSpectralFrequencies_Frame_initFromLPC_Frame_grid (LineSpectralFrequencies_Frame me, LPC_Frame thee, Polynomial g1, Polynomial g2, Roots roots, double gridSize, double maximumFrequency) {
/* Construct Fs and Fa
* divide out the zeros
* transform to polynomial equations g1 and g2 of half the order
*/
LineSpectralFrequencies_Frame_init (me, thy nCoefficients);
Polynomial_fromLPC_Frame_lspsum (g1, thee);
long half_order_g1 = g1 -> numberOfCoefficients - 1;
Polynomial_fromLPC_Frame_lspdif (g2, thee);
long half_order_g2 = g2 -> numberOfCoefficients - 1;
long numberOfBisections = 0, numberOfRootsFound = 0;
while (numberOfRootsFound < half_order_g1 && numberOfBisections < 10) {
numberOfRootsFound = Roots_fromPolynomial_grid (roots, g1, gridSize);
gridSize *= 0.5; numberOfBisections++;
}
if (numberOfBisections == 10) {
Melder_throw (U"Too many bisections.");
}
// [g1-> xmin, g1 -> xmax] <==> [nyquistFrequency, 0] i.e. highest root corresponds to lowest frequency
for (long i = 1; i <= half_order_g1; i++) {
my frequencies [2 * i - 1] = acos (roots -> v [half_order_g1 + 1 - i].re / 2.0) / NUMpi * maximumFrequency;
}
// the roots of g2 lie inbetween the roots of g1
for (long i = 1; i <= half_order_g2; i++) {
double xmax = roots -> v [half_order_g1 + 1 - i].re;
double xmin = i == half_order_g1 ? g1 -> xmin : roots -> v [half_order_g1 - i].re;
double root = Polynomial_findOneSimpleRealRoot_ridders (g2, xmin, xmax);
if (root != NUMundefined) {
my frequencies [2 * i] = acos (root / 2.0) / NUMpi * maximumFrequency;
} else {
my numberOfFrequencies --;
}
}
}
autoLineSpectralFrequencies LPC_to_LineSpectralFrequencies (LPC me, double gridSize) {
try {
if (gridSize == 0.0) {
gridSize = 0.02;
}
double nyquistFrequency = 0.5 / my samplingPeriod;
autoLineSpectralFrequencies thee = LineSpectralFrequencies_create (my xmin, my xmax, my nx, my dx, my x1, my maxnCoefficients, nyquistFrequency);
autoPolynomial g1 = Polynomial_create (-2.0, 2.0, my maxnCoefficients + 1); // large enough
autoPolynomial g2 = Polynomial_create (-2.0, 2.0, my maxnCoefficients + 1);
autoRoots roots = Roots_create ((my maxnCoefficients + 1) / 2);
for (long iframe = 1; iframe <= my nx; iframe ++) {
LPC_Frame lpf = & my d_frames [iframe];
LineSpectralFrequencies_Frame lsf = & thy d_frames [iframe];
/* Construct Fs and Fa
* divide out the zeros
* transform to polynomial equations g1 and g2 of half the order
* find zeros
*/
LineSpectralFrequencies_Frame_initFromLPC_Frame_grid (lsf, lpf, g1.get(), g2.get(), roots.get(), gridSize, nyquistFrequency);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LineSpectralFrequencies created.");
}
}
static void LPC_Frame_initFromLineSpectralFrequencies_Frame (LPC_Frame me, LineSpectralFrequencies_Frame thee, Polynomial fs, Polynomial fa, double maximumFrequency) {
LPC_Frame_init (me, thy numberOfFrequencies);
/* Reconstruct Fs (z) */
long numberOfOmegas = (thy numberOfFrequencies + 1) / 2;
for (long i = 1; i <= numberOfOmegas; i++) {
double omega = thy frequencies [2 * i -1] / maximumFrequency * NUMpi;
my a[i] = -2.0 * cos (omega);
}
Polynomial_initFromProductOfSecondOrderTerms (fs, my a, numberOfOmegas);
/* Reconstruct Fa (z) */
numberOfOmegas = thy numberOfFrequencies / 2;
for (long i = 1; i <= numberOfOmegas; i++) {
double omega = thy frequencies [2 * i] / maximumFrequency * NUMpi;
my a [i] = -2.0 * cos (omega);
}
Polynomial_initFromProductOfSecondOrderTerms (fa, my a, numberOfOmegas);
if (thy numberOfFrequencies % 2 == 0) {
Polynomial_multiply_firstOrderFactor (fs, -1.0); // * (z + 1)
Polynomial_multiply_firstOrderFactor (fa, 1.0); // * (z - 1)
} else {
Polynomial_multiply_secondOrderFactor (fa, 1.0); // * (z^2 - 1)
}
Melder_assert (fs -> numberOfCoefficients == fa -> numberOfCoefficients);
/* A(z) = (Fs(z) + Fa(z) / 2 */
for (long i = 1; i <= fs -> numberOfCoefficients - 2; i++) {
my a [thy numberOfFrequencies - i + 1] = 0.5 * (fs -> coefficients [i+1] + fa -> coefficients [i+1]);
}
}
autoLPC LineSpectralFrequencies_to_LPC (LineSpectralFrequencies me) {
try {
autoLPC thee = LPC_create (my xmin, my xmax, my nx, my dx, my x1, my maximumNumberOfFrequencies,0.5 / my maximumFrequency);
autoPolynomial fs = Polynomial_create (-1.0, 1.0, my maximumNumberOfFrequencies + 2);
autoPolynomial fa = Polynomial_create (-1.0, 1.0, my maximumNumberOfFrequencies + 2);
for (long iframe = 1; iframe <= my nx; iframe ++) {
LineSpectralFrequencies_Frame lsf = & my d_frames [iframe];
LPC_Frame lpf = & thy d_frames [iframe];
/* Construct Fs and Fa
* A(z) = (Fs(z) + Fa(z))/2
*/
LPC_Frame_initFromLineSpectralFrequencies_Frame (lpf, lsf, fs.get(), fa.get(), my maximumFrequency);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LPC created from LineSpectralFrequencies.");
}
}
/* End of file LPC_and_LineSpectralFrequencies.cpp */
praat-6.0.23/LPC/LPC_and_LineSpectralFrequencies.h 0000664 0000000 0000000 00000002157 13023464014 0021601 0 ustar 00root root 0000000 0000000 #ifndef _LPC_and_LineSpectralFrequencies_h_
#define _LPC_and_LineSpectralFrequencies_h_
/* LPC_and_LineLineSpectralFrequencies.h
*
* Copyright (C) 2016 David Weenink
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "LPC.h"
#include "LineSpectralFrequencies.h"
autoLineSpectralFrequencies LPC_to_LineSpectralFrequencies (LPC me, double gridSize);
autoLPC LineSpectralFrequencies_to_LPC (LineSpectralFrequencies me);
#endif /* _LPC_and_LineSpectralFrequencies_h_ */
praat-6.0.23/LPC/LPC_and_Polynomial.cpp 0000664 0000000 0000000 00000002721 13023464014 0017475 0 ustar 00root root 0000000 0000000 /* LPC_and_Polynomial.cpp
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
*/
#include "LPC_and_Polynomial.h"
autoPolynomial LPC_Frame_to_Polynomial (LPC_Frame me) {
long degree = (long) my nCoefficients;
autoPolynomial thee = Polynomial_create (-1, 1, degree);
for (long i = 1; i <= degree; i++) {
thy coefficients[i] = my a[degree - i + 1];
}
thy coefficients[degree + 1] = 1.0;
return thee;
}
autoPolynomial LPC_to_Polynomial (LPC me, double time) {
try {
long iFrame = Sampled_xToIndex (me, time);
if (iFrame < 1) {
iFrame = 1;
}
if (iFrame > my nx) {
iFrame = my nx;
}
autoPolynomial thee = LPC_Frame_to_Polynomial (&my d_frames[iFrame]);
return thee;
} catch (MelderError) {
Melder_throw (me, U":no Polynomial created.");
}
}
/* End of file LPC_and_Polynomial.cpp */
praat-6.0.23/LPC/LPC_and_Polynomial.h 0000664 0000000 0000000 00000002034 13023464014 0017137 0 ustar 00root root 0000000 0000000 #ifndef _LPC_and_Polynomial_h_
#define _LPC_and_Polynomial_h_
/* LPC_and_Polynomial.h
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19990607
djmw 20020812 GPL header
djmw 20110307 Latest modification
*/
#include "LPC.h"
#include "Polynomial.h"
autoPolynomial LPC_to_Polynomial (LPC me, double t);
autoPolynomial LPC_Frame_to_Polynomial (LPC_Frame me);
#endif /* _LPC_and_Polynomial_h_ */
praat-6.0.23/LPC/LPC_and_Tube.cpp 0000664 0000000 0000000 00000017757 13023464014 0016270 0 ustar 00root root 0000000 0000000 /* LPC_and_Tube.cpp
*
* Copyright (C) 1993-2012, 2014-2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020612 GPL header
djmw 20041020 struct Tube_Frame -> struct structTube_Frame; struct LPC_Frame -> struct structLPC_Frame;
struct Formant_Frame->struct structFormant_Frame
djmw 20051005 Always make a VocalTract with length 0.01 m when wakita_length==NUMundefined.
*/
#include "LPC_and_Tube.h"
#include "LPC_and_Formant.h"
#include "LPC_to_Spectrum.h"
#include "SpectrumTier.h"
#include "VocalTract_to_Spectrum.h"
#include "NUM2.h"
// IEEE: Programs fo digital signal processing section 4.3 LPTRN
void LPC_Frame_into_Tube_Frame_rc (LPC_Frame me, Tube_Frame thee) {
long p = my nCoefficients;
Melder_assert (p <= thy nSegments); //TODO
autoNUMvector b (1, p);
autoNUMvector a (1, p);
for (long i = 1; i <= p; i++) {
a[i] = my a[i];
}
double *rc = thy c;
for (long m = p; m > 0; m--) {
rc[m] = a[m];
if (fabs (rc[m]) > 1) {
Melder_throw (U"Relection coefficient [", m, U"] larger 1."); // TODO kan er geen Tube worden gemaakt?
}
for (long i = 1; i < m; i++) {
b[i] = a[i];
}
for (long i = 1; i < m; i++) {
a[i] = (b[i] - rc[m] * b[m - i]) / (1.0 - rc[m] * rc[m]);
}
}
}
void LPC_Frame_into_Tube_Frame_area (LPC_Frame me, Tube_Frame thee) {
struct structTube_Frame rc_struct = { 0 };
Tube_Frame rc = & rc_struct;
Tube_Frame_init (rc, my nCoefficients, thy length);
LPC_Frame_into_Tube_Frame_rc (me, rc);
Tube_Frames_rc_into_area (rc, thee);
rc -> destroy ();
}
double VocalTract_and_LPC_Frame_getMatchingLength (VocalTract me, LPC_Frame thee, double glottalDamping, bool radiationDamping, bool internalDamping) {
try {
// match the average distance between the first two formants in the VocaTract and the LPC spectrum
long numberOfFrequencies = 1000;
double maximumFrequency = 5000.0;
autoSpectrum vts = VocalTract_to_Spectrum (me, numberOfFrequencies, maximumFrequency, glottalDamping, radiationDamping, internalDamping);
double samplingFrequency = 1000.0 * my nx;
autoSpectrum lps = Spectrum_create (0.5 * samplingFrequency, numberOfFrequencies);
LPC_Frame_into_Spectrum (thee, lps.get(), 0, 50);
autoSpectrumTier vtst = Spectrum_to_SpectrumTier_peaks (vts.get());
autoSpectrumTier lpst = Spectrum_to_SpectrumTier_peaks (lps.get());
double vt_f1 = vtst -> points.at [1] -> number, vt_f2 = vtst -> points.at [2] -> number;
double lp_f1 = lpst -> points.at [1] -> number, lp_f2 = lpst -> points.at [2] -> number;
double df1 = lp_f1 - vt_f1, df2 = lp_f2 - vt_f2, df = 0.5 * (df1 + df2);
double dl = - df / lp_f2;
return my dx * my nx * (1 + dl);
} catch (MelderError) {
Melder_throw (U"Length could not be determined from VocalTract and LPC_Frame.");
}
}
double LPC_Frame_getVTL_wakita (LPC_Frame me, double samplingPeriod, double refLength) {
struct structLPC_Frame lpc_struct;
LPC_Frame lpc = & lpc_struct;
struct structFormant_Frame f_struct;
Formant_Frame f = & f_struct;
struct structTube_Frame rc_struct, af_struct;
Tube_Frame rc = & rc_struct, af = & af_struct;
try {
long m = my nCoefficients;
double length, dlength = 0.001, wakita_length = NUMundefined;
double varMin = 1e308;
memset (& lpc_struct, 0, sizeof (lpc_struct));
memset (& f_struct, 0, sizeof (f_struct));
memset (& rc_struct, 0, sizeof (rc_struct));
memset (& af_struct, 0, sizeof (af_struct));
LPC_Frame_init (lpc, m);
Tube_Frame_init (rc, m, refLength);
Tube_Frame_init (af, m, refLength);
// Step 2
LPC_Frame_into_Formant_Frame (me, f, samplingPeriod, 0);
// LPC_Frame_into_Formant_Frame performs the Formant_Frame_init !!
if (f -> nFormants < 1) {
Melder_throw (U"Not enough formants.");
}
double *area = af -> c;
double lmin = length = 0.10;
double plength = refLength;
while (length <= 0.25) {
// Step 3
double fscale = plength / length;
for (long i = 1; i <= f -> nFormants; i++) {
f -> formant[i].frequency *= fscale;
f -> formant[i].bandwidth *= fscale;
}
/*
20000125: Bovenstaande schaling van f1/b1 kan ook gedaan worden door
MGfb_to_a (f, b, nf, samplingFrequency*length/refLength, a1)
De berekening is extreem gevoelig voor de samplefrequentie: een zelfde
stel f,b waardes geven andere lengtes afhankelijk van Fs. Ook het
weglaten van een hogere formant heeft consekwenties.
De refLength zou eigenlijk vast moeten liggen op
refLength=c*aantalFormanten/Fs waarbij c=340 m/s (geluidssnelheid).
Bij Fs=10000 zou aantalFormanten=5 zijn en refLength -> 0.17 m
*/
// step 4
Formant_Frame_into_LPC_Frame (f, lpc, samplingPeriod);
// step 5
rc -> length = length;
LPC_Frame_into_Tube_Frame_rc (lpc, rc);
// step 6.1
Tube_Frames_rc_into_area (rc, af);
// step 6.2 Log(areas)
double logSum = 0.0;
for (long i = 1; i <= af -> nSegments; i++) {
area[i] = log (area[i]);
logSum += area[i];
}
// step 6.3 and 7
double var = 0.0;
for (long i = 1; i <= af -> nSegments; i++) {
double delta = area[i] - logSum / af -> nSegments;
var += delta * delta;
}
if (var < varMin) {
lmin = length; varMin = var;
}
plength = length;
length += dlength;
}
wakita_length = lmin;
f -> destroy ();
lpc -> destroy ();
rc -> destroy ();
af -> destroy ();
return wakita_length;
} catch (MelderError) {
f -> destroy ();
lpc -> destroy ();
rc -> destroy ();
af -> destroy ();
return NUMundefined;
}
}
int Tube_Frame_into_LPC_Frame_area (Tube_Frame me, LPC_Frame thee) {
(void) me;
(void) thee;
return 0;
}
int Tube_Frame_into_LPC_Frame_rc (Tube_Frame me, LPC_Frame thee) {
(void) me;
(void) thee;
return 0;
}
void VocalTract_setLength (VocalTract me, double newLength) {
my xmax = newLength;
my dx = newLength / my nx;
my x1 = 0.5 * my dx;
}
autoVocalTract LPC_to_VocalTract (LPC me, double time, double glottalDamping, bool radiationDamping, bool internalDamping) {
try {
long iframe = Sampled_xToLowIndex (me, time); // ppgb: BUG? Is rounding down the correct thing to do? not nearestIndex?
if (iframe < 1) {
iframe = 1;
}
if (iframe > my nx) {
iframe = my nx;
}
LPC_Frame lpc = & my d_frames[iframe];
autoVocalTract thee = LPC_Frame_to_VocalTract (lpc, 0.17);
double length = VocalTract_and_LPC_Frame_getMatchingLength (thee.get(), lpc, glottalDamping, radiationDamping, internalDamping);
VocalTract_setLength (thee.get(), length);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no VocalTract created.");
}
}
autoVocalTract LPC_Frame_to_VocalTract (LPC_Frame me, double length) {
try {
long m = my nCoefficients;
autoNUMvector area (1, m + 1);
NUMlpc_lpc_to_area (my a, m, area.peek());
autoVocalTract thee = VocalTract_create (m, length / m);
// area[lips..glottis] (m^2) to VocalTract[glottis..lips] (m^2)
for (long i = 1; i <= m; i++) {
thy z[1][i] = area[m + 1 - i];
}
return thee;
} catch (MelderError) {
Melder_throw (U"No VocalTract created from LPC_Frame.");
}
}
autoVocalTract LPC_to_VocalTract (LPC me, double time, double length) {
try {
long iframe = Sampled_xToLowIndex (me, time); // ppgb: BUG? Is rounding down the correct thing to do?
if (iframe < 1) {
iframe = 1;
}
if (iframe > my nx) {
iframe = my nx;
}
LPC_Frame lpc = & my d_frames[iframe];
autoVocalTract thee = LPC_Frame_to_VocalTract (lpc, length);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no VocalTract created.");
}
}
/* End of file LPC_and_Tube.cpp */
praat-6.0.23/LPC/LPC_and_Tube.h 0000664 0000000 0000000 00000003342 13023464014 0015716 0 ustar 00root root 0000000 0000000 #ifndef _LPC_and_Tube_h_
#define _LPC_and_Tube_h_
/* LPC_and_Tube.h
*
* Copyright (C) 1994-2012, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20030612 GPL header
djmw 20110307 Latest modification
*/
#include "LPC.h"
#include "Tube.h"
#include "VocalTract.h"
void LPC_Frame_into_Tube_Frame_rc (LPC_Frame me, Tube_Frame thee);
void LPC_Frame_into_Tube_Frame_area (LPC_Frame me, Tube_Frame thee);
autoVocalTract LPC_Frame_to_VocalTract (LPC_Frame me, double length);
double LPC_Frame_getVTL_wakita (LPC_Frame me, double samplingPeriod, double refLength);
double VocalTract_and_LPC_Frame_getMatchingLength (VocalTract me, LPC_Frame thee, double glottalDamping, bool radiationDamping, bool internalDamping);
int Tube_Frame_into_LPC_Frame_area (Tube_Frame me, LPC_Frame thee);
int Tube_Frame_into_LPC_Frame_rc (Tube_Frame me, LPC_Frame thee);
autoVocalTract LPC_to_VocalTract (LPC me, double time, double length);
void VocalTract_setLength (VocalTract me, double newLength);
autoVocalTract LPC_to_VocalTract (LPC me, double time, double glottalDamping, bool radiationDamping, bool internalDamping);
#endif /* _LPC_and_Tube_h_ */
praat-6.0.23/LPC/LPC_def.h 0000664 0000000 0000000 00000002572 13023464014 0014737 0 ustar 00root root 0000000 0000000 /* LPC_def.h
*
* Copyright (C) 1994-2008 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT LPC_Frame
oo_DEFINE_STRUCT (LPC_Frame)
oo_INT (nCoefficients)
#if oo_READING_BINARY
if (formatVersion == 0)
{
oo_FLOAT_VECTOR (a, nCoefficients)
oo_FLOAT (gain)
}
else
{
oo_DOUBLE_VECTOR (a, nCoefficients)
oo_DOUBLE (gain)
}
#else
oo_DOUBLE_VECTOR (a, nCoefficients)
oo_DOUBLE (gain)
#endif
oo_END_STRUCT (LPC_Frame)
#undef ooSTRUCT
#define ooSTRUCT LPC
oo_DEFINE_CLASS (LPC, Sampled)
/* samplingPeriod */
oo_DOUBLE (samplingPeriod) /* from Sound */
oo_INT (maxnCoefficients)
oo_STRUCT_VECTOR (LPC_Frame, d_frames, nx)
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS (LPC)
#undef ooSTRUCT
/* End of file LPC_def.h */
praat-6.0.23/LPC/LPC_to_Spectrogram.cpp 0000664 0000000 0000000 00000003520 13023464014 0017516 0 ustar 00root root 0000000 0000000 /* LPC_to_Spectrogram.cpp
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20080122 float -> double
*/
#include "LPC_to_Spectrogram.h"
autoSpectrogram LPC_to_Spectrogram (LPC me, double dfMin, double bandwidthReduction, double deEmphasisFrequency) {
try {
double samplingFrequency = 1.0 / my samplingPeriod;
long nfft = 2;
if (dfMin <= 0) {
nfft = 512; dfMin = samplingFrequency / nfft;
}
while (samplingFrequency / nfft > dfMin || nfft <= my maxnCoefficients) {
nfft *= 2;
}
double freqStep = samplingFrequency / nfft;
autoSpectrogram thee = Spectrogram_create (my xmin, my xmax, my nx, my dx, my x1,
0.0, samplingFrequency / 2.0, nfft / 2 + 1, freqStep, 0.0);
for (long i = 1; i <= my nx; i++) {
double t = Sampled_indexToX (me, i);
autoSpectrum spec = LPC_to_Spectrum (me, t, dfMin, bandwidthReduction, deEmphasisFrequency);
for (long j = 1; j <= spec -> nx; j++) {
double re = spec -> z[1][j], im = spec -> z[2][j];
thy z[j][i] = re * re + im * im;
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Spectrogram created.");
}
}
/* End of file LPC_to_Spectrogram.cpp */
praat-6.0.23/LPC/LPC_to_Spectrogram.h 0000664 0000000 0000000 00000002201 13023464014 0017156 0 ustar 00root root 0000000 0000000 #ifndef _LPC_to_Spectrogram_h_
#define _LPC_to_Spectrogram_h_
/* LPC_to_Spectrogram.h
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19980322
djmw 20020812 GPL header
djmw 20110307 Latest modification
*/
#include "LPC.h"
#include "Spectrogram.h"
#include "LPC_to_Spectrum.h"
autoSpectrogram LPC_to_Spectrogram (LPC me, double dfMin, double bandwidthReduction, double deEmphasisFrequency);
/* if(dfMin >= 0) df <= dfMin else df = NyquistFrequency / 512 */
#endif /* _LPC_and_Spectrogram_h_ */
praat-6.0.23/LPC/LPC_to_Spectrum.cpp 0000664 0000000 0000000 00000007537 13023464014 0017046 0 ustar 00root root 0000000 0000000 /* LPC_to_Spectrum.cpp
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020529 GPL header
djmw 20020529 Changed NUMrealft to NUMforwardRealFastFourierTransform_f
djmw 20030708 Added NUM2.h
djmw 20080122 float -> double
*/
#include "LPC_to_Spectrum.h"
#include "NUM2.h"
/*
PSD(f) = (sigma^2 T) /|1 + Sum (k=1..p, a[k] exp(-2 pi i f k T))|^2,
where sigma^2 == gain, T is samplinginterval
LPC-spectrum is approximately 20 dB too high (w.r.t. 25 ms spectrum from Sound)
*/
void LPC_Frame_into_Spectrum (LPC_Frame me, Spectrum thee, double bandwidthReduction, double deEmphasisFrequency) {
if (my nCoefficients == 0) {
for (long i = 1; i <= thy nx; i++) {
thy z[1][i] = thy z[2][i] = 0.0;
}
return;
}
// When deEmphasisFrequency is effective we need 1 extra position in the fftbuffer.
long nfft = 2 * (thy nx - 1), ndata = my nCoefficients + 1;
double scale = 1.0 / sqrt (2.0 * thy xmax * thy dx);
if (ndata >= nfft - 1 && (deEmphasisFrequency < thy xmax || ndata > nfft)) {
Melder_throw (U"Spectrum size not large enough.");
}
autoNUMvector fftbuffer (1, nfft);
// Copy 1, a[1], ... a[p] into fftbuffer
fftbuffer[1] = 1;
for (long i = 2; i <= ndata; i++) {
fftbuffer[i] = my a[i - 1];
}
if (deEmphasisFrequency < thy xmax) {
// Multiply (1, a[1] z^-1, ... a[p] z^-p) by (1 - b z^-1)
double b = exp (- 2.0 * NUMpi * deEmphasisFrequency / thy xmax);
ndata ++;
for (long i = ndata; i > 1; i--) {
fftbuffer[i] -= b * fftbuffer[i - 1];
}
}
/*
Calculate sum (k=0..ndata; a[k] (z)^-k) along a contour with radius r:
sum (k=0..ndata; a[k] (rz)^-k) = sum (k=0..ndata; (a[k]r^-k) z^-k)
*/
double g = exp (NUMpi * bandwidthReduction / (thy dx * nfft)); /* r = 1/g */
for (long i = 2; i <= ndata; i++) {
fftbuffer[i] *= pow (g, i - 1);
}
/*
Perform the fft.
The LPC spectrum is obtained by inverting this spectrum.
The imaginary parts of the frequencies 0 and Nyquist are 0.
*/
NUMforwardRealFastFourierTransform (fftbuffer.peek(), nfft);
if (my gain > 0.0) {
scale *= sqrt (my gain);
}
thy z[1][1] = scale / fftbuffer[1];
thy z[2][1] = 0.0;
for (long i = 2; i <= nfft / 2; i++) {
// We use: 1 / (a + ib) = (a - ib) / (a^2 + b^2)
double re = fftbuffer[i + i - 1], im = fftbuffer[i + i];
double invSquared = scale / (re * re + im * im);
thy z[1][i] = re * invSquared;
thy z[2][i] = -im * invSquared;
}
thy z[1][thy nx] = scale / fftbuffer[2];
thy z[2][thy nx] = 0.0;
}
autoSpectrum LPC_to_Spectrum (LPC me, double t, double dfMin, double bandwidthReduction, double deEmphasisFrequency) {
try {
double samplingFrequency = 1.0 / my samplingPeriod;
long nfft = 2, index = Sampled_xToNearestIndex (me, t);
if (index < 1) {
index = 1;
}
if (index > my nx) {
index = my nx;
}
if (dfMin <= 0) {
nfft = 512; dfMin = samplingFrequency / nfft;
}
while (samplingFrequency / nfft > dfMin || nfft <= my d_frames[index].nCoefficients) {
nfft *= 2;
}
autoSpectrum thee = Spectrum_create (samplingFrequency / 2.0, nfft / 2 + 1);
LPC_Frame_into_Spectrum (& my d_frames[index], thee.get(), bandwidthReduction, deEmphasisFrequency);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Spectrum created.");
}
}
/* End of file LPC_to_Spectrum.cpp */
praat-6.0.23/LPC/LPC_to_Spectrum.h 0000664 0000000 0000000 00000002601 13023464014 0016476 0 ustar 00root root 0000000 0000000 #ifndef _LPC_to_Spectrum_h_
#define _LPC_to_Spectrum_h_
/* LPC_to_Spectrum.h
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19980224
djmw 20020812 GPL header
djmw 20110702 Latest modification
*/
#include "LPC.h"
#include "Spectrum.h"
void LPC_Frame_into_Spectrum (LPC_Frame me, Spectrum thee, double bandwidthReduction, double deEmphasisFrequency);
autoSpectrum LPC_to_Spectrum (LPC me, double t, double dfMin, double bandwidthReduction, double deEmphasisFrequency);
autoSpectrum LPC_to_Spectrum2 (LPC me, double t, double dfMin, double bandwidthReduction);
/* if(dfMin >= 0) df <= dfMin else df = NyquistFrequency / 512 */
/* integration radius r = exp (- pi * bandwidthReduction / samplingFrequency) */
#endif /* _LPC_and_Spectrum_h_ */
praat-6.0.23/LPC/LineSpectralFrequencies.cpp 0000664 0000000 0000000 00000012020 13023464014 0020602 0 ustar 00root root 0000000 0000000 /* LineSpectralFrequencies.cpp
*
* Copyright (C) 2016 David Weenink
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
djmw 20160421 Initial version
*/
#include "LineSpectralFrequencies.h"
#include "NUM2.h"
#include "oo_DESTROY.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_COPY.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_EQUAL.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_WRITE_TEXT.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_WRITE_BINARY.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_READ_TEXT.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_READ_BINARY.h"
#include "LineSpectralFrequencies_def.h"
#include "oo_DESCRIPTION.h"
#include "LineSpectralFrequencies_def.h"
Thing_implement (LineSpectralFrequencies, Sampled, 1);
void structLineSpectralFrequencies :: v_info () {
structDaata :: v_info ();
MelderInfo_writeLine (U"Time domain: ", xmin, U" to ", xmax, U" (s).");
MelderInfo_writeLine (U"Number of frequencies: ", maximumNumberOfFrequencies);
MelderInfo_writeLine (U"Number of frames: ", nx);
MelderInfo_writeLine (U"Time step: ", dx, U" (s).");
MelderInfo_writeLine (U"First frame at: ", x1, U" (s).");
}
void LineSpectralFrequencies_Frame_init (LineSpectralFrequencies_Frame me, int numberOfFrequencies) {
my frequencies = NUMvector (1, numberOfFrequencies);
my numberOfFrequencies = numberOfFrequencies;
}
static void LineSpectralFrequencies_init (LineSpectralFrequencies me, double tmin, double tmax, long nt, double dt, double t1, int numberOfFrequencies, double maximumFrequency) {
my maximumFrequency = maximumFrequency;
my maximumNumberOfFrequencies = numberOfFrequencies;
Sampled_init (me, tmin, tmax, nt, dt, t1);
my d_frames = NUMvector (1, nt);
}
autoLineSpectralFrequencies LineSpectralFrequencies_create (double tmin, double tmax, long nt, double dt, double t1, int numberOfFrequencies, double maximumFrequency) {
try {
autoLineSpectralFrequencies me = Thing_new (LineSpectralFrequencies);
LineSpectralFrequencies_init (me.get(), tmin, tmax, nt, dt, t1, numberOfFrequencies, maximumFrequency);
return me;
} catch (MelderError) {
Melder_throw (U"LineSpectralFrequencies not created.");
}
}
void LineSpectralFrequencies_drawFrequencies (LineSpectralFrequencies me, Graphics g, double tmin, double tmax, double fmin, double fmax, bool garnish) {
if (tmax <= tmin) {
tmin = my xmin;
tmax = my xmax;
}
long itmin, itmax;
if (! Sampled_getWindowSamples (me, tmin, tmax, & itmin, & itmax)) {
return;
}
if (fmax <= fmin) {
double f1max, f2min;
autoNUMvector f1 (itmin, itmax), f2 (itmin, itmax);
for (long iframe = itmin; iframe <= itmax; iframe++) {
f1[iframe] = my d_frames[iframe].frequencies[1];
f2[iframe] = my d_frames[iframe].frequencies[my d_frames[iframe].numberOfFrequencies];
}
NUMvector_extrema (f1.peek(), itmin, itmax, & fmin, & f1max);
NUMvector_extrema (f2.peek(), itmin, itmax, & f2min, & fmax);
}
if (fmax == fmin) {
fmin = 0;
fmax += 0.5;
}
Graphics_setInner (g);
Graphics_setWindow (g, tmin, tmax, fmin, fmax);
for (long iframe = itmin; iframe <= itmax; iframe++) {
LineSpectralFrequencies_Frame lsf = & my d_frames[iframe];
double x = Sampled_indexToX (me, iframe);
for (long ifreq = 1; ifreq <= lsf -> numberOfFrequencies; ifreq++) {
double y = lsf -> frequencies [ifreq];
if (y >= fmin && y <= fmax) {
Graphics_speckle (g, x, y);
}
}
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, true, U"Time (seconds)");
Graphics_textLeft (g, true, U"Frequency (Hz)");
Graphics_marksBottom (g, 2, true, true, false);
Graphics_marksLeft (g, 2, true, true, false);
}
}
autoMatrix LineSpectralFrequencies_downto_Matrix (LineSpectralFrequencies me) {
try {
autoMatrix thee = Matrix_create (my xmin, my xmax, my nx, my dx, my x1, 0.5, 0.5 + my maximumNumberOfFrequencies, my maximumNumberOfFrequencies, 1.0, 1.0);
for (long j = 1; j <= my nx; j++) {
LineSpectralFrequencies_Frame lsf = & my d_frames[j];
for (long i = 1; i <= lsf -> numberOfFrequencies; i++) {
thy z [i][j] = lsf -> frequencies [i];
}
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Matrix with linear prediction coefficients created.");
}
}
/* End of file LineSpectralFrequencies.cpp */
praat-6.0.23/LPC/LineSpectralFrequencies.h 0000664 0000000 0000000 00000003534 13023464014 0020261 0 ustar 00root root 0000000 0000000 #ifndef _LineSpectralFrequencies_h_
#define _LineSpectralFrequencies_h_
/* LineSpectralFrequencies.h
*
* Copyright (C) 2016 David Weenink
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "LPC.h"
#include "Matrix.h"
#include "Graphics.h"
#include "LineSpectralFrequencies_def.h"
/*
From Sampled:
xmin, xmax : range of time (s)
x1 : position of first frame (s)
dx : step size (s)
nx : number of frames
*/
void LineSpectralFrequencies_init (LineSpectralFrequencies me, double tmin, double tmax, long nt, double dt, double t1, long numberOfFrequencies, double maximumFrequency);
autoLineSpectralFrequencies LineSpectralFrequencies_create (double tmin, double tmax, long nt, double dt, double t1, int numberOfFrequencies, double maximumFrequency);
void LineSpectralFrequencies_drawFrequencies (LineSpectralFrequencies me, Graphics g, double fromTime, double toTime, double fmin, double fmax, bool garnish);
autoMatrix LineSpectralFrequencies_downto_Matrix (LineSpectralFrequencies me);
/******************* Frames ************************************************/
void LineSpectralFrequencies_Frame_init (LineSpectralFrequencies_Frame me, int numberOfFrequencies);
#endif /* _LineSpectralFrequencies_h_ */
praat-6.0.23/LPC/LineSpectralFrequencies_def.h 0000664 0000000 0000000 00000002603 13023464014 0021073 0 ustar 00root root 0000000 0000000 /* LineSpectralFrequencies_def.h
*
* Copyright (C) 2016 David Weenink
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define ooSTRUCT LineSpectralFrequencies_Frame
oo_DEFINE_STRUCT (LineSpectralFrequencies_Frame)
oo_INT (numberOfFrequencies)
oo_DOUBLE_VECTOR (frequencies, numberOfFrequencies)
oo_END_STRUCT (LineSpectralFrequencies_Frame)
#undef ooSTRUCT
#define ooSTRUCT LineSpectralFrequencies
oo_DEFINE_CLASS (LineSpectralFrequencies, Sampled)
oo_DOUBLE (maximumFrequency)
oo_INT (maximumNumberOfFrequencies)
oo_STRUCT_VECTOR (LineSpectralFrequencies_Frame, d_frames, nx)
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS (LineSpectralFrequencies)
#undef ooSTRUCT
/* End of file LineSpectralFrequencies_def.h */
praat-6.0.23/LPC/Makefile 0000664 0000000 0000000 00000001543 13023464014 0014767 0 ustar 00root root 0000000 0000000 # Makefile of the library "LPC"
# David Weenink, 20130826
include ../makefile.defs
CPPFLAGS = -I ../num -I ../dwtools -I ../fon -I ../sys -I ../dwsys -I ../stat
OBJECTS = Cepstrum.o Cepstrumc.o Cepstrum_and_Spectrum.o \
Cepstrogram.o \
Formant_extensions.o LineSpectralFrequencies.o \
LPC.o LPC_and_Cepstrumc.o LPC_and_Formant.o LPC_and_LFCC.o \
LPC_and_LineSpectralFrequencies.o LPC_and_Polynomial.o \
LPC_to_Spectrum.o LPC_to_Spectrogram.o \
LPC_and_Tube.o \
Sound_and_LPC.o Sound_and_LPC_robust.o \
Sound_and_Cepstrum.o Tube.o \
VocalTractTier.o \
praat_LPC_init.o manual_LPC.o
.PHONY: all clean
all: libLPC.a
clean:
$(RM) $(OBJECTS)
$(RM) libLPC.a
libLPC.a: $(OBJECTS)
touch libLPC.a
rm libLPC.a
$(AR) cq libLPC.a $(OBJECTS)
$(RANLIB) libLPC.a
$(OBJECTS): *.h ../num/NUM.h ../dwtools/*.h ../fon/*.h ../sys/*.h ../dwsys/*.h ../stat/*.h
praat-6.0.23/LPC/Sound_and_Cepstrum.cpp 0000664 0000000 0000000 00000006654 13023464014 0017637 0 ustar 00root root 0000000 0000000 /* Sound_and_Cepstrum.cpp
*
* Copyright (C) 1994-2011,2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020516 GPL header
djmw 20020529 changed NUMrealft to NUM...RealFastFourierTransform_f
djmw 20041124 Changed call to Sound_to_Spectrum.
*/
#include "Sound_and_Cepstrum.h"
#include "Sound_and_Spectrum.h"
#include "Cepstrum_and_Spectrum.h"
#include "NUM2.h"
/*
Algorithm:
J.B. Bednar & T.L. Watt (1985), Calculating the Complex Cepstrum
without Phase Unwrapping or Integration, IEEE Trans. on ASSP 33,
1014-1017 (Does not work yet).
*/
autoCepstrum Sound_to_Cepstrum_bw (Sound me) {
try {
long nfft = 2;
while (nfft < my nx) {
nfft *= 2;
}
double qmax = (my xmax - my xmin) * nfft / my nx;
autoCepstrum thee = Cepstrum_create (qmax, nfft);
autoNUMvector x (1, nfft);
autoNUMvector nx (1, nfft);
for (long i = 1; i <= my nx; i++) {
x[i] = my z[1][i];
nx[i] = (i - 1) * x[i];
}
// Step 1: Fourier transform x(n) -> X(f)
// and n*x(n) -> NX(f)
NUMforwardRealFastFourierTransform (x.peek() , nfft);
NUMforwardRealFastFourierTransform (nx.peek(), nfft);
// Step 2: Multiply {X^*(f) * NX(f)} / |X(f)|^2
// Compute Avg (ln |X(f)|) as Avg (ln |X(f)|^2) / 2.
// Treat i=1 separately: x[1] * nx[1] / |x[1]|^2
double lnxa = 0.0;
if (x[1] != 0.0) {
lnxa = 2.0 * log (fabs (x[1]));
x[1] = nx[1] / x[1];
}
if (x[2] != 0.0) {
lnxa = 2.0 * log (fabs (x[2]));
x[2] = nx[2] / x[2];
}
for (long i = 3; i < nfft; i += 2) {
double xr = x[i], nxr = nx[i];
double xi = x[i + 1], nxi = nx[i + 1];
double xa = xr * xr + xi * xi;
if (xa > 0.0) {
x[i] = (xr * nxr + xi * nxi) / xa;
x[i + 1] = (xr * nxi - xi * nxr) / xa;
lnxa += log (xa);
} else {
x[i] = x[i + 1] = 0.0;
}
}
lnxa /= 2.0 * nfft / 2.0; // TODO
// Step 4: Inverse transform of complex array x
// results in: n * xhat (n)
NUMreverseRealFastFourierTransform (x.peek(), nfft);
// Step 5: Inverse fft-correction factor: 1/nfftd2
// Divide n * xhat (n) by n
for (long i = 2; i <= my nx; i++) {
thy z[1][i] = x[i] / ( (i - 1) * nfft);
}
// Step 6: xhat[0] = Avg (ln |X(f)|)
thy z[1][1] = lnxa;
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Cepstrum created.");
}
}
/* Zijn nog niet elkaars inverse!!!!*/
autoCepstrum Sound_to_Cepstrum (Sound me) {
try {
autoSpectrum spectrum = Sound_to_Spectrum (me, true);
autoCepstrum thee = Spectrum_to_Cepstrum (spectrum.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Cepstrum calculated.");
}
}
autoSound Cepstrum_to_Sound (Cepstrum me) {
try {
autoSpectrum sx = Cepstrum_to_Spectrum (me);
autoSound thee = Spectrum_to_Sound (sx.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": no Sound calculated.");
}
}
/* End of file Sound_and_Cepstrum.cpp */
praat-6.0.23/LPC/Sound_and_Cepstrum.h 0000664 0000000 0000000 00000002045 13023464014 0017272 0 ustar 00root root 0000000 0000000 #ifndef _Sound_and_Cepstrum_h_
#define _Sound_and_Cepstrum_h_
/* Sound_and_Cepstrum.h
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20110307 Latest modification
*/
#include "Sound.h"
#include "Cepstrum.h"
autoCepstrum Sound_to_Cepstrum (Sound me);
autoCepstrum Sound_to_Cepstrum_bw (Sound me);
autoSound Cepstrum_to_Sound (Cepstrum me);
#endif /* _Sound_and_Cepstrum_h_ */
praat-6.0.23/LPC/Sound_and_LPC.cpp 0000664 0000000 0000000 00000043661 13023464014 0016452 0 ustar 00root root 0000000 0000000 /* Sound_and_LPC.cpp
*
* Copyright (C) 1994-2013, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020625 GPL header
djmw corrected a bug in Sound_into_LPC_Frame_marple that could crash praat when signal has only zero samples.
djmw 20040303 Removed warning in Sound_to_LPC.
djmw 20070103 Sound interface changes
djmw 20080122 float -> double
djmw 20101009 Filter and inverseFilter with one frame.
*/
#include "Sound_and_LPC.h"
#include "Sound_extensions.h"
#include "Vector.h"
#include "Spectrum.h"
#include "NUM2.h"
#define LPC_METHOD_AUTO 1
#define LPC_METHOD_COVAR 2
#define LPC_METHOD_BURG 3
#define LPC_METHOD_MARPLE 4
/* Markel&Gray, LP of S, page 219
work[1..3*m+2]
r = & work[1]; // r[1..m+1]
a= & work[m+1+1]; // a[1..m+1]
rc = & work[m+1+m+1+1]; // rc[1..m]
for (i=1; i<= m+1+m+1+m;i++) work[i] = 0;
*/
#define LPC_METHOD_AUTO_WINDOW_CORRECTION 1
static void LPC_Frame_and_Sound_filter (LPC_Frame me, Sound thee, int channel) {
double *y = thy z[channel], *a = my a;
for (long i = 1; i <= thy nx; i++) {
long m = i > my nCoefficients ? my nCoefficients : i - 1;
for (long j = 1; j <= m; j++) {
y[i] -= a[j] * y[i - j];
}
}
}
void LPC_Frame_and_Sound_filterInverse (LPC_Frame me, Sound thee, int channel) {
double *x = thy z[channel];
autoNUMvector y (0L, my nCoefficients);
for (long i = 1; i <= thy nx; i++) {
y[0] = x[i];
for (long j = 1; j <= my nCoefficients; j++) {
x[i] += my a[j] * y[j];
}
for (long j = my nCoefficients; j > 0; j--) {
y[j] = y[j - 1];
}
}
}
static int Sound_into_LPC_Frame_auto (Sound me, LPC_Frame thee) {
long i = 1; // For error condition at end
long m = thy nCoefficients;
autoNUMvector r (1, m + 1);
autoNUMvector a (1, m + 1);
autoNUMvector rc (1, m);
double *x = my z[1];
for (i = 1; i <= m + 1; i++) {
for (long j = 1; j <= my nx - i + 1; j++) {
r[i] += x[j] * x[j + i - 1];
}
}
if (r[1] == 0.0) {
i = 1; /* ! */ goto end;
}
a[1] = 1.0; a[2] = rc[1] = - r[2] / r[1];
thy gain = r[1] + r[2] * rc[1];
for (i = 2; i <= m; i++) {
double s = 0.0;
for (long j = 1; j <= i; j++) {
s += r[i - j + 2] * a[j];
}
rc[i] = - s / thy gain;
for (long j = 2; j <= i / 2 + 1; j++) {
double at = a[j] + rc[i] * a[i - j + 2];
a[i - j + 2] += rc[i] * a[j];
a[j] = at;
}
a[i + 1] = rc[i]; thy gain += rc[i] * s;
if (thy gain <= 0) {
goto end;
}
}
end:
i--;
for (long j = 1; j <= i; j++) {
thy a[j] = a[j + 1];
}
if (i == m) {
return 1;
}
thy nCoefficients = i;
for (long j = i + 1; j <= m; j++) {
thy a[j] = 0.0;
}
return 0; // Melder_warning ("Less coefficienst than asked for.");
}
/* Markel&Gray, LP of S, page 221
work[1..m(m+1)/2+m+m+1+m+m+1]
b = & work[1]
grc = & work[m*(m+1)/2+1];
a = & work[m*(m+1)/2+m+1];
beta = & work [m+1)/2+m+m+1+1];
cc = & work[m+1)/2+m+m+1+m+1]
for (i=1; i<=m(m+1)/2+m+m+1+m+m+1;i++) work[i] = 0;
*/
static int Sound_into_LPC_Frame_covar (Sound me, LPC_Frame thee) {
long i = 1, n = my nx, m = thy nCoefficients;
double *x = my z[1];
autoNUMvector b (1, m * (m + 1) / 2);
autoNUMvector grc (1, m);
autoNUMvector a (1, m + 1);
autoNUMvector beta (1, m);
autoNUMvector cc (1, m + 1);
thy gain = 0.0;
for (i = m + 1; i <= n; i++) {
thy gain += x[i] * x[i];
cc[1] += x[i] * x[i - 1];
cc[2] += x[i - 1] * x[i - 1];
}
if (thy gain == 0.0) {
i = 1; /* ! */ goto end;
}
b[1] = 1.0;
beta[1] = cc[2];
a[1] = 1.0;
a[2] = grc[1] = -cc[1] / cc[2];
thy gain += grc[1] * cc[1];
for (i = 2; i <= m; i++) { /*130*/
double s = 0.0; /* 20 */
for (long j = 1; j <= i; j++) {
cc[i - j + 2] = cc[i - j + 1] + x[m - i + 1] * x[m - i + j] - x[n - i + 1] * x[n - i + j];
}
cc[1] = 0.0;
for (long j = m + 1; j <= n; j++) {
cc[1] += x[j - i] * x[j]; /* 30 */
}
b[i * (i + 1) / 2] = 1.0;
for (long j = 1; j <= i - 1; j++) { /* 70 */
double gam = 0.0;
if (beta[j] < 0.0) {
goto end;
} else if (beta[j] == 0.0) {
continue;
}
for (long k = 1; k <= j; k++) {
gam += cc[k + 1] * b[j * (j - 1) / 2 + k]; /*50*/
}
gam /= beta[j];
for (long k = 1; k <= j; k++) {
b[i * (i - 1) / 2 + k] -= gam * b[j * (j - 1) / 2 + k]; /*60*/
}
}
beta[i] = 0.0;
for (long j = 1; j <= i; j++) {
beta[i] += cc[j + 1] * b[i * (i - 1) / 2 + j]; /*80*/
}
if (beta[i] <= 0.0) {
goto end;
}
for (long j = 1; j <= i; j++) {
s += cc[j] * a[j]; /*100*/
}
grc[i] = -s / beta[i];
for (long j = 2; j <= i; j++) {
a[j] += grc[i] * b[i * (i - 1) / 2 + j - 1]; /*110*/
}
a[i + 1] = grc[i];
s = grc[i] * grc[i] * beta[i];
thy gain -= s;
if (thy gain <= 0.0) {
goto end;
}
}
end:
i--;
for (long j = 1; j <= i; j++) {
thy a[j] = a[j + 1];
}
if (i == m) {
return 1;
}
thy nCoefficients = i;
for (long j = i + 1; j <= m; j++) {
thy a[j] = 0.0;
}
return 0; // Melder_warning ("Less coefficienst than asked for.");
}
static int Sound_into_LPC_Frame_burg (Sound me, LPC_Frame thee) {
int status = NUMburg (my z[1], my nx, thy a, thy nCoefficients, &thy gain);
thy gain *= my nx;
for (long i = 1; i <= thy nCoefficients; i++) {
thy a[i] = -thy a[i];
}
return status;
}
static int Sound_into_LPC_Frame_marple (Sound me, LPC_Frame thee, double tol1, double tol2) {
long m = 1, n = my nx, mmax = thy nCoefficients;
int status = 1;
double *a = thy a, *x = my z[1];
autoNUMvector c (1, mmax + 1);
autoNUMvector d (1, mmax + 1);
autoNUMvector r (1, mmax + 1);
double e0 = 0.0;
for (long k = 1; k <= n; k++) {
e0 += x[k] * x[k];
}
e0 *= 2.0;
if (e0 == 0.0) {
m = 0; thy gain *= 0.5; /* because e0 is twice the energy */
thy nCoefficients = m; return 0; // warning no signal
}
double q1 = 1.0 / e0;
double q2 = q1 * x[1], q = q1 * x[1] * x[1], w = q1 * x[n] * x[n];
double v = q, u = w;
double den = 1.0 - q - w;
double q4 = 1.0 / den, q5 = 1.0 - q, q6 = 1.0 - w;
double h = q2 * x[n], s = h;
thy gain = e0 * den;
q1 = 1.0 / thy gain;
c[1] = q1 * x[1];
d[1] = q1 * x[n];
double s1 = 0.0;
for (long k = 1; k <= n - 1; k++) {
s1 += x[k + 1] * x[k];
}
r[1] = 2.0 * s1;
a[1] = - q1 * r[1];
thy gain *= (1.0 - a[1] * a[1]);
while (m < mmax) {
double eOld = thy gain, f = x[m + 1], b = x[n - m]; /*n-1 ->n-m*/
for (long k = 1; k <= m; k++) {
/* n-1 -> n-m */
f += x[m + 1 - k] * a[k];
b += x[n - m + k] * a[k];
}
q1 = 1.0 / thy gain;
q2 = q1 * f;
double q3 = q1 * b;
for (long k = m; k >= 1; k--) {
c[k + 1] = c[k] + q2 * a[k];
d[k + 1] = d[k] * q3 * a[k];
}
c[1] = q2; d[1] = q3;
double q7 = s * s;
double y1 = f * f;
double y2 = v * v;
double y3 = b * b;
double y4 = u * u;
double y5 = 2.0 * h * s;
q += y1 * q1 + q4 * (y2 * q6 + q7 * q5 + v * y5);
w += y3 * q1 + q4 * (y4 * q5 + q7 * q6 + u * y5);
h = s = u = v = 0.0;
for (long k = 0; k <= m; k++) {
h += x[n - m + k] * c[k + 1];
s += x[n - k] * c[k + 1];
u += x[n - k] * d[k + 1];
v += x[k + 1] * c[k + 1];
}
q5 = 1.0 - q;
q6 = 1.0 - w;
den = q5 * q6 - h * h;
if (den <= 0.0) {
status = 2; goto end; /* 2: ill-conditioning */
}
q4 = 1.0 / den;
q1 *= q4;
double alf = 1.0 / (1.0 + q1 * (y1 * q6 + y3 * q5 + 2.0 * h * f * b));
thy gain *= alf;
y5 = h * s;
double c1 = q4 * (f * q6 + b * h);
double c2 = q4 * (b * q5 + h * f);
double c3 = q4 * (v * q6 + y5);
double c4 = q4 * (s * q5 + v * h);
double c5 = q4 * (s * q6 + h * u);
double c6 = q4 * (u * q5 + y5);
for (long k = 1; k <= m; k++) {
a[k] = alf * (a[k] + c1 * c[k + 1] + c2 * d[k + 1]);
}
for (long k = 1; k <= m / 2 + 1; k++) {
s1 = c[k];
double s2 = d[k], s3 = c[m + 2 - k], s4 = d[m + 2 - k];
c[k] += c3 * s3 + c4 * s4;
d[k] += c5 * s3 + c6 * s4;
if (m + 2 - k == k) {
continue;
}
c[m + 2 - k] += c3 * s1 + c4 * s2;
d[m + 2 - k] += c5 * s1 + c6 * s2;
}
m++; c1 = x[n + 1 - m]; c2 = x[m];
double delta = 0;
for (long k = m - 1; k >= 1; k--) {
r[k + 1] = r[k] - x[n + 1 - k] * c1 - x[k] * c2;
delta += r[k + 1] * a[k];
}
s1 = 0.0;
for (long k = 1; k <= n - m; k++) {
s1 += x[k + m] * x[k];
}
r[1] = 2.0 * s1;
delta += r[1];
q2 = - delta / thy gain;
a[m] = q2;
for (long k = 1; k <= m / 2; k++) {
s1 = a[k];
a[k] += q2 * a[m - k];
if (k == m - k) {
continue;
}
a[m - k] += q2 * s1;
}
y1 = q2 * q2;
thy gain *= 1.0 - y1;
if (y1 >= 1.0) {
status = 3; goto end; /* |a[m]| > 1 */
}
if (thy gain < e0 * tol1) {
status = 4; goto end;
}
if (eOld - thy gain < eOld * tol2) {
status = 5; goto end;
}
}
end:
thy gain *= 0.5; /* because e0 is twice the energy */
thy nCoefficients = m;
return status == 1 || status == 4 || status == 5;
}
static autoLPC _Sound_to_LPC (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency, int method, double tol1, double tol2) {
double t1, samplingFrequency = 1.0 / my dx;
double windowDuration = 2 * analysisWidth; /* gaussian window */
long nFrames, frameErrorCount = 0;
if (floor (windowDuration / my dx) < predictionOrder + 1) {
Melder_throw (U"Analysis window duration too short.\n For a prediction order of ", predictionOrder,
U" the analysis window duration has to be greater than ", my dx * (predictionOrder + 1), U"Please increase the analysis window duration or lower the prediction order.");
}
// Convenience: analyse the whole sound into one LPC_frame
if (windowDuration > my dx * my nx) {
windowDuration = my dx * my nx;
}
Sampled_shortTermAnalysis (me, windowDuration, dt, & nFrames, & t1);
autoSound sound = Data_copy (me);
autoSound sframe = Sound_createSimple (1, windowDuration, samplingFrequency);
autoSound window = Sound_createGaussian (windowDuration, samplingFrequency);
autoLPC thee = LPC_create (my xmin, my xmax, nFrames, dt, t1, predictionOrder, my dx);
autoMelderProgress progress (U"LPC analysis");
if (preEmphasisFrequency < samplingFrequency / 2) {
Sound_preEmphasis (sound.get(), preEmphasisFrequency);
}
for (long i = 1; i <= nFrames; i++) {
LPC_Frame lpcframe = (LPC_Frame) & thy d_frames[i];
double t = Sampled_indexToX (thee.get(), i);
LPC_Frame_init (lpcframe, predictionOrder);
Sound_into_Sound (sound.get(), sframe.get(), t - windowDuration / 2);
Vector_subtractMean (sframe.get());
Sounds_multiply (sframe.get(), window.get());
if (method == LPC_METHOD_AUTO) {
if (! Sound_into_LPC_Frame_auto (sframe.get(), lpcframe)) {
frameErrorCount++;
}
} else if (method == LPC_METHOD_COVAR) {
if (! Sound_into_LPC_Frame_covar (sframe.get(), lpcframe)) {
frameErrorCount++;
}
} else if (method == LPC_METHOD_BURG) {
if (! Sound_into_LPC_Frame_burg (sframe.get(), lpcframe)) {
frameErrorCount++;
}
} else if (method == LPC_METHOD_MARPLE) {
if (! Sound_into_LPC_Frame_marple (sframe.get(), lpcframe, tol1, tol2)) {
frameErrorCount++;
}
}
if ((i % 10) == 1) {
Melder_progress ( (double) i / nFrames, U"LPC analysis of frame ", i, U" out of ", nFrames, U".");
}
}
return thee;
}
autoLPC Sound_to_LPC_auto (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency) {
try {
autoLPC thee = _Sound_to_LPC (me, predictionOrder, analysisWidth, dt, preEmphasisFrequency, LPC_METHOD_AUTO, 0, 0);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LPC (auto) created.");
}
}
autoLPC Sound_to_LPC_covar (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency) {
try {
autoLPC thee = _Sound_to_LPC (me, predictionOrder, analysisWidth, dt, preEmphasisFrequency, LPC_METHOD_COVAR, 0, 0);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LPC (covar) created.");
}
}
autoLPC Sound_to_LPC_burg (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency) {
try {
autoLPC thee = _Sound_to_LPC (me, predictionOrder, analysisWidth, dt, preEmphasisFrequency, LPC_METHOD_BURG, 0, 0);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LPC (burg) created.");
}
}
autoLPC Sound_to_LPC_marple (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency, double tol1, double tol2) {
try {
autoLPC thee = _Sound_to_LPC (me, predictionOrder, analysisWidth, dt, preEmphasisFrequency, LPC_METHOD_MARPLE, tol1, tol2);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no LPC (marple) created.");
}
}
autoSound LPC_and_Sound_filterInverse (LPC me, Sound thee) {
try {
if (my samplingPeriod != thy dx) {
Melder_throw (U"Sampling frequencies are not the same.");
}
if (my xmin != thy xmin || thy xmax != my xmax) {
Melder_throw (U"Domains of LPC and Sound are not equal.");
}
autoSound him = Data_copy (thee);
double *e = his z[1], *x = thy z[1];
for (long i = 1; i <= his nx; i++) {
double t = his x1 + (i - 1) * his dx; /* Sampled_indexToX (him, i) */
long iFrame = lround ( (t - my x1) / my dx + 1.0); /* Sampled_xToNearestIndex (me, t) */
double *a;
if (iFrame < 1 || iFrame > my nx) {
e[i] = 0.0;
continue;
}
a = my d_frames[iFrame].a;
long m = i > my d_frames[iFrame].nCoefficients ? my d_frames[iFrame].nCoefficients : i - 1;
for (long j = 1; j <= m; j++) {
e[i] += a[j] * x[i - j];
}
}
return him;
} catch (MelderError) {
Melder_throw (thee, U": not inverse filtered.");
}
}
/*
gain used as a constant amplitude multiplyer within a frame of duration my dx.
future alternative: convolve gain with a smoother.
*/
autoSound LPC_and_Sound_filter (LPC me, Sound thee, int useGain) {
try {
double xmin = my xmin > thy xmin ? my xmin : thy xmin;
double xmax = my xmax < thy xmax ? my xmax : thy xmax;
if (xmin >= xmax) {
Melder_throw (U"Domains of Sound [", thy xmin, U",", thy xmax, U"] and LPC [",
my xmin, U",", my xmax, U"] do not overlap.");
}
// resample sound if samplings don't match
autoSound source;
if (my samplingPeriod != thy dx) {
source = Sound_resample (thee, 1.0 / my samplingPeriod, 50);
thee = source.get(); // reference copy; remove at end
}
autoSound him = Data_copy (thee);
double *x = his z[1];
long ifirst = Sampled_xToHighIndex (thee, xmin);
long ilast = Sampled_xToLowIndex (thee, xmax);
for (long i = ifirst; i <= ilast; i++) {
double t = his x1 + (i - 1) * his dx; /* Sampled_indexToX (him, i) */
long iFrame = lround ( (t - my x1) / my dx + 1.0); /* Sampled_xToNearestIndex (me, t) */
if (iFrame < 1) {
continue;
}
if (iFrame > my nx) {
break;
}
double *a = my d_frames[iFrame].a;
long m = i > my d_frames[iFrame].nCoefficients ? my d_frames[iFrame].nCoefficients : i - 1;
for (long j = 1; j <= m; j++) {
x[i] -= a[j] * x[i - j];
}
}
// Make samples before first frame and after last frame zero.
for (long i = 1; i < ifirst; i++) {
x[i] = 0.0;
}
for (long i = ilast + 1; i <= his nx; i++) {
x[i] = 0.0;
}
if (useGain) {
for (long i = ifirst; i <= ilast; i++) {
double t = his x1 + (i - 1) * his dx; /* Sampled_indexToX (him, i) */
double riFrame = (t - my x1) / my dx + 1; /* Sampled_xToIndex (me, t); */
long iFrame = (long) floor (riFrame);
double phase = riFrame - iFrame;
if (iFrame < 0 || iFrame > my nx) {
x[i] = 0.0;
} else if (iFrame == 0) {
x[i] *= sqrt (my d_frames[1].gain) * phase;
} else if (iFrame == my nx) {
x[i] *= sqrt (my d_frames[my nx].gain) * (1.0 - phase);
} else x[i] *=
phase * sqrt (my d_frames[iFrame + 1].gain) + (1.0 - phase) * sqrt (my d_frames[iFrame].gain);
}
}
return him;
} catch (MelderError) {
Melder_throw (thee, U": not filtered.");
}
}
void LPC_and_Sound_filterWithFilterAtTime_inline (LPC me, Sound thee, int channel, double time) {
long frameIndex = Sampled_xToNearestIndex (me, time);
if (frameIndex < 1) {
frameIndex = 1;
}
if (frameIndex > my nx) {
frameIndex = my nx;
}
if (channel > thy ny) {
channel = 1;
}
if (frameIndex < 1 || frameIndex > my nx) {
Melder_throw (U"Frame number out of range.");
}
if (channel > 0) {
LPC_Frame_and_Sound_filter (& (my d_frames[frameIndex]), thee, channel);
} else {
for (long ichan = 1; ichan <= thy ny; ichan++) {
LPC_Frame_and_Sound_filter (& (my d_frames[frameIndex]), thee, ichan);
}
}
}
autoSound LPC_and_Sound_filterWithFilterAtTime (LPC me, Sound thee, int channel, double time) {
try {
autoSound him = Data_copy (thee);
LPC_and_Sound_filterWithFilterAtTime_inline (me, him.get(), channel, time);
return him;
} catch (MelderError) {
Melder_throw (thee, U": not filtered.");
}
}
void LPC_and_Sound_filterInverseWithFilterAtTime_inline (LPC me, Sound thee, int channel, double time) {
try {
long frameIndex = Sampled_xToNearestIndex (me, time);
if (frameIndex < 1) {
frameIndex = 1;
}
if (frameIndex > my nx) {
frameIndex = my nx;
}
if (channel > thy ny) {
channel = 1;
}
if (channel > 0) {
LPC_Frame_and_Sound_filterInverse (& (my d_frames[frameIndex]), thee, channel);
} else {
for (long ichan = 1; ichan <= thy ny; ichan++) {
LPC_Frame_and_Sound_filterInverse (& (my d_frames[frameIndex]), thee, ichan);
}
}
} catch (MelderError) {
Melder_throw (thee, U": not inverse filtered.");
}
}
autoSound LPC_and_Sound_filterInverseWithFilterAtTime (LPC me, Sound thee, int channel, double time) {
try {
autoSound him = Data_copy (thee);
LPC_and_Sound_filterInverseWithFilterAtTime_inline (me, him.get(), channel, time);
return him;
} catch (MelderError) {
Melder_throw (thee, U": not inverse filtered.");
}
}
/* End of file Sound_and_LPC.cpp */
praat-6.0.23/LPC/Sound_and_LPC.h 0000664 0000000 0000000 00000006606 13023464014 0016115 0 ustar 00root root 0000000 0000000 #ifndef _Sound_and_LPC_h_
#define _Sound_and_LPC_h_
/* Sound_and_LPC.h
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 19971103
djmw 20020812 GPL header
djmw 20110307 Latest modification
*/
#include "LPC.h"
#include "Sound.h"
autoLPC Sound_to_LPC_auto (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency);
autoLPC Sound_to_LPC_covar (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency);
autoLPC Sound_to_LPC_burg (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency);
autoLPC Sound_to_LPC_marple (Sound me, int predictionOrder, double analysisWidth, double dt, double preEmphasisFrequency, double tol1, double tol2);
/*
* Function:
* Calculate linear prediction coefficients according to following model:
* Minimize E(m) = Sum(n=n0;n=n1; (x[n] + Sum(k=1;k=m; a[k]*x[n-k])))
* Method:
* The minimization is carried out by solving the equations:
* Sum(i=1;i=m; a[i]*c[i][k]) = -c[0][k] for k=1,2,...,m
* where c[i][k] = Sum(n=n0;n=n1;x[n-i]*x[n-k])
* 1. Covariance:
* n0=m; n1 = N-1;
* c[i][k] is symmetric, positive semi-definite matrix
* Markel&Gray, LP of Speech, page 221;
* 2. Autocorrelation
* signal is zero outside the interval;
* n0=-infinity; n1=infinity
* c[i][k] symmetric, positive definite Toeplitz matrix
* Markel&Gray, LP of Speech, page 219;
* Preconditions:
* predictionOrder > 0;
* preEmphasisFrequency >= 0;
*
* Burg method: see Numerical recipes Chapter 13.
*
* Marple method: see Marple, L. (1980), A new autoregressive spectrum analysis
* algorithm, IEEE Trans. on ASSP 28, 441-453.
* tol1 : stop iteration when E(m) / E(0) < tol1
* tol2 : stop iteration when (E(m)-E(m-1)) / E(m-1) < tol2,
*/
void LPC_Frame_and_Sound_filterInverse (LPC_Frame me, Sound thee, int channel);
autoSound LPC_and_Sound_filter (LPC me, Sound thee, int useGain);
/*
E(z) = X(z)A(z),
A(z) = 1 + Sum (k=1, k=m, a(k)z^-k);
filter:
given e & a, determine x;
x(n) = e(n) - Sum (k=1, m, a(k)x(n-k))
useGain determines whether the LPC-gain is used in the synthesis.
*/
void LPC_and_Sound_filterWithFilterAtTime_inline (LPC me, Sound thee, int channel, double time);
autoSound LPC_and_Sound_filterWithFilterAtTime (LPC me, Sound thee, int channel, double time);
autoSound LPC_and_Sound_filterInverse (LPC me, Sound thee);
/*
E(z) = X(z)A(z),
A(z) = 1 + Sum (k=1, k=m, a(k)z^-k);
filter inverse:
given x & a, determine e;
e(n) = x(n) + Sum (k=1, m, a(k)x(n-k))
*/
autoSound LPC_and_Sound_filterInverseWithFilterAtTime (LPC me, Sound thee, int channel, double time);
void LPC_and_Sound_filterInverseWithFilterAtTime_inline (LPC me, Sound thee, int channel, double time);
#endif /* _Sound_and_LPC_h_ */
praat-6.0.23/LPC/Sound_and_LPC_robust.cpp 0000664 0000000 0000000 00000021023 13023464014 0020034 0 ustar 00root root 0000000 0000000 /* Sound_and_LPC_robust.cpp
*
* Copyright (C) 1994-2013, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20030814 First version
djmw 20061218 To Melder_information format
djmw 20070103 Sound interface changes
djmw 20080122 float -> double
djmw 20101008 New LPC_Frame_filterInverse interface.
djmw 20110302 Corrected a number of pointer initialisations
djmw 20111027 +Sound_to_Formant_robust
*/
#include "LPC_and_Formant.h"
#include "Sound_and_LPC.h"
#include "Sound_and_LPC_robust.h"
#include "Sound_extensions.h"
#include "SVD.h"
#include "Vector.h"
#include "NUM2.h"
struct huber_struct {
autoSound e;
double k, tol, tol_svd;
long iter, itermax;
int wantlocation, wantscale;
double location, scale;
long n, p;
double *w, *work;
double *a;
double **covar, *c;
autoSVD svd;
};
static void huber_struct_init (struct huber_struct *hs, double windowDuration, long p, double samplingFrequency, double location, int wantlocation) {
hs -> w = hs -> work = hs -> a = hs -> c = nullptr;
hs -> covar = nullptr;
hs -> svd = autoSVD();
hs -> e = Sound_createSimple (1, windowDuration, samplingFrequency);
long n = hs -> e -> nx;
hs -> n = n;
hs -> p = p;
hs -> w = NUMvector (1, n);
hs -> work = NUMvector (1, n);
hs -> a = NUMvector (1, p);
hs -> covar = NUMmatrix (1, p, 1, p);
hs -> c = NUMvector (1, p);
hs -> svd = SVD_create (p, p);
hs -> wantlocation = wantlocation;
if (! wantlocation) {
hs -> location = location;
}
hs -> wantscale = 1;
}
static void huber_struct_destroy (struct huber_struct *hs) {
hs -> e.reset();
hs -> svd.reset();
NUMvector_free (hs -> w, 1);
NUMvector_free (hs -> work, 1);
NUMvector_free (hs -> a, 1);
NUMmatrix_free (hs -> covar, 1, 1);
NUMvector_free (hs -> c, 1);
}
static void huber_struct_getWeights (struct huber_struct *hs, double *e) {
double ks = hs -> k * hs -> scale;
double *w = hs -> w;
for (long i = 1 ; i <= hs -> n; i++) {
double ei = e[i] - hs -> location;
w[i] = ei > -ks && ei < ks ? 1.0 : ks / fabs (ei);
}
}
static void huber_struct_getWeightedCovars (struct huber_struct *hs, double *s) {
long p = hs -> p, n = hs -> n;
double *w = hs -> w, **covar = hs -> covar, *c = hs -> c;
for (long i = 1; i <= p; i++) {
for (long j = i; j <= p; j++) {
double tmp = 0;
for (long k = p + 1; k <= n; k++) {
tmp += s[k - j] * s[k - i] * w[k];
}
covar[i][j] = covar[j][i] = tmp;
}
double tmp = 0;
for (long k = p + 1; k <= n; k++) {
tmp += s[k - i] * s[k] * w[k];
}
c[i] = -tmp;
}
}
static void huber_struct_solvelpc (struct huber_struct *hs) {
SVD me = hs -> svd.get();
double **covar = hs -> covar;
for (long i = 1; i <= my numberOfRows; i++) {
for (long j = 1; j <= my numberOfColumns; j++) {
my u[i][j] = covar[i][j];
}
}
SVD_setTolerance (me, hs -> tol_svd);
SVD_compute (me);
//long nzeros = SVD_zeroSmallSingularValues (me, 0);
SVD_solve (me, hs -> c, hs -> a);
}
void LPC_Frames_and_Sound_huber (LPC_Frame me, Sound thee, LPC_Frame him, struct huber_struct *hs) {
long p = my nCoefficients > his nCoefficients ? his nCoefficients : my nCoefficients;
long n = hs -> e -> nx > thy nx ? thy nx : hs -> e -> nx;
double *e = hs -> e -> z[1], *s = thy z[1];
hs -> iter = 0;
hs -> scale = 1e308;
hs -> p = p;
double s0;
do {
Sound hse = hs -> e.get();
for (long i = 1; i <= thy nx; i++) {
hse -> z[1][i] = thy z[1][i];
}
LPC_Frame_and_Sound_filterInverse (him, hse, 1);
s0 = hs -> scale;
NUMstatistics_huber (e, n, & (hs -> location), hs -> wantlocation, & (hs -> scale), hs -> wantscale, hs -> k, hs -> tol, hs -> work);
huber_struct_getWeights (hs, e);
huber_struct_getWeightedCovars (hs, s);
// Solve C a = [-] c */
try {
huber_struct_solvelpc (hs);
} catch (MelderError) {
// Copy the starting lpc coeffs */
for (long i = 1; i <= p; i++) {
his a[i] = my a[i];
}
throw MelderError();
}
for (long i = 1; i <= p; i++) {
his a[i] = hs -> a[i];
}
(hs -> iter) ++;
} while ( (hs -> iter < hs -> itermax) && (fabs (s0 - hs -> scale) > hs -> tol * s0));
}
#if 0
autoSound e;
double k, tol, tol_svd;
long iter, itermax;
int wantlocation, wantscale;
double location, scale;
long n, p;
double *w, *work;
double *a;
double **covar, *c;
autoSVD svd;
#endif
autoLPC LPC_and_Sound_to_LPC_robust (LPC thee, Sound me, double analysisWidth, double preEmphasisFrequency, double k,
int itermax, double tol, int wantlocation) {
struct huber_struct struct_huber { autoSound(), 0.0, 0.0, 0.0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, autoSVD() };
try {
double t1, samplingFrequency = 1.0 / my dx, tol_svd = 0.000001;
double location = 0, windowDuration = 2 * analysisWidth; /* Gaussian window */
long nFrames, frameErrorCount = 0, iter = 0;
long p = thy maxnCoefficients;
if (my xmin != thy xmin || my xmax != thy xmax) {
Melder_throw (U"Time domains differ.");
}
if (my dx != thy samplingPeriod) {
Melder_throw (U"Sampling intervals differ.");
}
if (floor (windowDuration / my dx) < p + 1) {
Melder_throw (U"Analysis window too short.");
}
Sampled_shortTermAnalysis (me, windowDuration, thy dx, & nFrames, & t1);
if (nFrames != thy nx || t1 != thy x1) {
Melder_throw (U"Incorrect retrieved analysis width");
}
autoSound sound = Data_copy (me);
autoSound sframe = Sound_createSimple (1, windowDuration, samplingFrequency);
autoSound window = Sound_createGaussian (windowDuration, samplingFrequency);
autoLPC him = Data_copy (thee);
huber_struct_init (&struct_huber, windowDuration, p, samplingFrequency, location, wantlocation);
struct_huber.k = k;
struct_huber.tol = tol;
struct_huber.tol_svd = tol_svd;
struct_huber.itermax = itermax;
autoMelderProgress progess (U"LPC analysis");
Sound_preEmphasis (sound.get(), preEmphasisFrequency);
for (long i = 1; i <= nFrames; i++) {
LPC_Frame lpc = (LPC_Frame) & thy d_frames[i];
LPC_Frame lpcto = (LPC_Frame) & his d_frames[i];
double t = Sampled_indexToX (thee, i);
Sound_into_Sound (sound.get(), sframe.get(), t - windowDuration / 2);
Vector_subtractMean (sframe.get());
Sounds_multiply (sframe.get(), window.get());
try {
LPC_Frames_and_Sound_huber (lpc, sframe.get(), lpcto, & struct_huber);
} catch (MelderError) {
frameErrorCount++;
}
iter += struct_huber.iter;
if ( (i % 10) == 1) {
Melder_progress ( (double) i / nFrames, U"LPC analysis of frame ", i, U" out of ", nFrames, U".");
}
}
if (frameErrorCount) Melder_warning (U"Results of ", frameErrorCount,
U" frame(s) out of ", nFrames, U" could not be optimised.");
MelderInfo_writeLine (U"Number of iterations: ", iter,
U"\n Average per frame: ", ((double) iter) / nFrames);
huber_struct_destroy (&struct_huber);
return him;
} catch (MelderError) {
huber_struct_destroy (&struct_huber);
Melder_throw (me, U": no robust LPC created.");
}
}
autoFormant Sound_to_Formant_robust (Sound me, double dt_in, double numberOfFormants, double maximumFrequency,
double halfdt_window, double preEmphasisFrequency, double safetyMargin, double k, int itermax, double tol, int wantlocation)
{
double dt = dt_in > 0.0 ? dt_in : halfdt_window / 4.0;
double nyquist = 0.5 / my dx;
int predictionOrder = (long) floor (2 * numberOfFormants);
try {
autoSound sound;
if (maximumFrequency <= 0.0 || fabs (maximumFrequency / nyquist - 1.0) < 1.0e-12) {
sound = Data_copy (me); // will be modified
} else {
sound = Sound_resample (me, maximumFrequency * 2.0, 50);
}
autoLPC lpc = Sound_to_LPC_auto (sound.get(), predictionOrder, halfdt_window, dt, preEmphasisFrequency);
autoLPC lpcr = LPC_and_Sound_to_LPC_robust (lpc.get(), sound.get(), halfdt_window, preEmphasisFrequency, k, itermax, tol, wantlocation);
autoFormant thee = LPC_to_Formant (lpcr.get(), safetyMargin);
return thee;
} catch (MelderError) {
Melder_throw (me, U": no robust Formant created.");
}
}
/* End of file Sound_and_LPC_robust.cpp */
praat-6.0.23/LPC/Sound_and_LPC_robust.h 0000664 0000000 0000000 00000003405 13023464014 0017505 0 ustar 00root root 0000000 0000000 #ifndef _Sound_and_LPC_robust_h_
#define _Sound_and_LPC_robust_h_
/* Sound_and_LPC_robust.h
*
* Copyright (C) 1993-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20030815 GPL header
djmw 20111027 Latest modification
*/
#include "LPC.h"
#include "Formant.h"
#include "Sound.h"
void LPC_Frames_and_Sound_huber (LPC_Frame me, Sound thee, LPC_Frame him, struct huber_struct *hs);
/*int LPC_Frames_and_Sound_huber (LPC_Frame me, Sound thee, LPC_Frame him, void *huber);
The gnu c compiler (version 3.3.1) complaints about having two LPC_Frame types
in the argument list:
error: two or more data types in declaration of `LPC_Frame_and_Sound_into_LPC_Frame_huber
By defining a void pointer we circumvent the complaint.
*/
autoLPC LPC_and_Sound_to_LPC_robust (LPC thee, Sound me, double analysisWidth,
double preEmphasisFrequency, double k, int itermax, double tol, int wantlocation);
autoFormant Sound_to_Formant_robust (Sound me, double dt_in, double numberOfFormants, double maximumFrequency,
double halfdt_window, double preemphasisFrequency, double safetyMargin, double k, int itermax, double tol, int wantlocation);
#endif /* _Sound_and_LPC_robust_h_ */
praat-6.0.23/LPC/Tube.cpp 0000664 0000000 0000000 00000007541 13023464014 0014736 0 ustar 00root root 0000000 0000000 /* Tube.cpp
*
* Copyright (C) 1994-2012, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20030613 Creation
djmw 20061212 Changed info to Melder_writeLine format.
djmw 20110304 Thing_new
*/
#include "Tube.h"
#include "NUM2.h"
#include "oo_DESTROY.h"
#include "Tube_def.h"
#include "oo_COPY.h"
#include "Tube_def.h"
#include "oo_EQUAL.h"
#include "Tube_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "Tube_def.h"
#include "oo_WRITE_TEXT.h"
#include "Tube_def.h"
#include "oo_WRITE_BINARY.h"
#include "Tube_def.h"
#include "oo_READ_TEXT.h"
#include "Tube_def.h"
#include "oo_READ_BINARY.h"
#include "Tube_def.h"
#include "oo_DESCRIPTION.h"
#include "Tube_def.h"
Thing_implement (Tube, Sampled, 0);
void structTube :: v_info () {
structDaata :: v_info ();
MelderInfo_writeLine (U"Time domain: ", xmin, U" to ", xmax, U" seconds");
MelderInfo_writeLine (U"Maximum number of segments: ", maxnSegments);
MelderInfo_writeLine (U"Number of frames: ", nx);
MelderInfo_writeLine (U"Time step: ", dx, U" seconds");
MelderInfo_writeLine (U"First frame at: ", x1, U" seconds");
}
void Tube_Frame_init (Tube_Frame me, long nSegments, double length) {
my nSegments = nSegments;
my length = length;
if (nSegments <= 0) {
Melder_throw (U"Number of segments must be a natural number.");
}
my c = NUMvector (1, nSegments);
}
/* Gray & Markel (1979), LPTRN */
void Tube_Frames_rc_into_area (Tube_Frame me, Tube_Frame thee) {
if (my nSegments > thy nSegments) {
Melder_throw (U"Number of segments to big.");
}
double s = 0.0001; /* 1.0 cm^2 at glottis */
double *rc = my c, *area = thy c;
for (long i = my nSegments; i > 0; i--) {
s *= (1.0 + rc[i]) / (1.0 - rc[i]);
area[i] = s;
}
}
static void Tube_setLengths (Tube me, double length) {
for (long i = 1; i <= my nx; i++) {
Tube_Frame f = & my frame[i];
if (f) {
f -> length = length;
}
}
}
void Tube_init (Tube me, double tmin, double tmax, long nt, double dt, double t1, long maxnSegments, double defaultLength) {
my maxnSegments = maxnSegments;
Sampled_init (me, tmin, tmax, nt, dt, t1);
my frame = NUMvector (1, nt);
Tube_setLengths (me, defaultLength);
}
Thing_implement (Area, Tube, 0);
void Area_init (Area me, double tmin, double tmax, long nt, double dt, double t1, long maxnSegments, double defaultLength) {
Tube_init (me, tmin, tmax, nt, dt, t1, maxnSegments, defaultLength);
}
autoArea Area_create (double tmin, double tmax, long nt, double dt, double t1, long maxnSegments, double defaultLength) {
try {
autoArea me = Thing_new (Area);
Area_init (me.get(), tmin, tmax, nt, dt, t1, maxnSegments, defaultLength);
return me;
} catch (MelderError) {
Melder_throw (U"Area not crteated.");
}
}
Thing_implement (RC, Tube, 0);
void RC_init (RC me, double tmin, double tmax, long nt, double dt, double t1, long maxnSegments, double defaultLength) {
Tube_init (me, tmin, tmax, nt, dt, t1, maxnSegments, defaultLength);
}
autoRC RC_create (double tmin, double tmax, long nt, double dt, double t1, long maxnCoefficients, double defaultLength) {
try {
autoRC me = Thing_new (RC);
RC_init (me.get(), tmin, tmax, nt, dt, t1, maxnCoefficients, defaultLength);
return me;
} catch (MelderError) {
Melder_throw (U"RC not crteated.");
}
}
/* End of file Tube.cpp */
praat-6.0.23/LPC/Tube.h 0000664 0000000 0000000 00000003514 13023464014 0014377 0 ustar 00root root 0000000 0000000 #ifndef _Tube_h_
#define _Tube_h_
/* Tube.h
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Sampled.h"
#include "Tube_def.h"
/*
Tube's as a function of time.
Tube_frame: c[1] -> mouth
c[nSegments] -> glottis.
*/
void Tube_Frame_init (Tube_Frame me, long nSegments, double length);
void Tube_Frame_free (Tube_Frame me);
void Tube_Frames_rc_into_area (Tube_Frame me, Tube_Frame thee);
void Tube_init (Tube me, double tmin, double tmax, long nt, double dt, double t1, long maxnSegments, double defaultLength);
Thing_define (Area, Tube) {
};
/*
Areas as a function of time.
units in m^2.
*/
void Area_init (Area me, double tmin, double tmax, long nt, double dt, double t1, long maxnSegments, double defaultLength);
autoArea Area_create (double tmin, double tmax, long nt, double dt, double t1, long maxnSegments, double defaultLength);
Thing_define (RC, Tube) {
};
// Reflection Coefficients as a function of time.
void RC_init (RC me, double tmin, double tmax, long nt, double dt, double t1, long maxnCoefficients, double defaultLength);
autoRC RC_create (double tmin, double tmax, long nt, double dt, double t1, long maxnCoefficients, double defaultLength);
#endif // _Tube_h_
praat-6.0.23/LPC/Tube_def.h 0000664 0000000 0000000 00000002150 13023464014 0015210 0 ustar 00root root 0000000 0000000 /* Tube_def.h
*
* Copyright (C) 1994-2011 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT Tube_Frame
oo_DEFINE_STRUCT (Tube_Frame)
oo_INT (nSegments)
oo_DOUBLE (length)
oo_DOUBLE_VECTOR (c, nSegments)
oo_END_STRUCT (Tube_Frame)
#undef ooSTRUCT
#define ooSTRUCT Tube
oo_DEFINE_CLASS (Tube, Sampled)
oo_INT (maxnSegments)
oo_STRUCT_VECTOR (Tube_Frame, frame, nx)
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS (Tube)
#undef ooSTRUCT
/* End of file Tube_def.h */
praat-6.0.23/LPC/VocalTractTier.cpp 0000664 0000000 0000000 00000014745 13023464014 0016731 0 ustar 00root root 0000000 0000000 /* VocalTractTier.cpp
*
* Copyright (C) 2012, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "NUM2.h"
#include "RealTier.h"
#include "VocalTractTier.h"
#include "oo_DESTROY.h"
#include "VocalTractTier_def.h"
#include "oo_COPY.h"
#include "VocalTractTier_def.h"
#include "oo_EQUAL.h"
#include "VocalTractTier_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "VocalTractTier_def.h"
#include "oo_WRITE_TEXT.h"
#include "VocalTractTier_def.h"
#include "oo_READ_TEXT.h"
#include "VocalTractTier_def.h"
#include "oo_WRITE_BINARY.h"
#include "VocalTractTier_def.h"
#include "oo_READ_BINARY.h"
#include "VocalTractTier_def.h"
#include "oo_DESCRIPTION.h"
#include "VocalTractTier_def.h"
void VocalTract_drawSegments (VocalTract me, Graphics g, double maxLength, double maxArea, bool closedAtGlottis)
{
Graphics_setInner (g);
double maxCrossection = sqrt (maxArea);
Graphics_setWindow (g, 0.0, maxLength, -maxCrossection, maxCrossection);
for (long isection = 1; isection <= my nx; isection++) {
double x1 = (isection - 1.0) * my dx, x2 = x1 + my dx;
double crosssection2 = sqrt (my z[1][isection]);
Graphics_line (g, x1, crosssection2, x2, crosssection2);
Graphics_line (g, x1, -crosssection2, x2, -crosssection2);
if (isection > 1) {
double crosssection1 = sqrt (my z[1][isection - 1]);
Graphics_line (g, x1, crosssection1, x1, crosssection2);
Graphics_line (g, x1, -crosssection1, x1, -crosssection2);
} else if (isection == 1 and closedAtGlottis) {
Graphics_line (g, x1, crosssection2, x1, -crosssection2);
}
}
Graphics_unsetInner (g);
}
/***** VocalTractPoint *****/
Thing_implement (VocalTractPoint, AnyPoint, 0);
autoVocalTractPoint VocalTract_to_VocalTractPoint (VocalTract me, double time) {
try {
autoVocalTractPoint thee = Thing_new (VocalTractPoint);
thy number = time;
thy d_vocalTract = Data_copy (me);
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to VocalTractPoint.");
}
}
/***** VocalTractTier *****/
Thing_implement (VocalTractTier, Function, 0);
autoVocalTractTier VocalTractTier_create (double fromTime, double toTime) {
try {
autoVocalTractTier me = Thing_new (VocalTractTier);
Function_init (me.get(), fromTime, toTime);
return me;
} catch (MelderError) {
Melder_throw (U": VocalTractTier not created.");
}
}
autoVocalTractTier VocalTract_to_VocalTractTier (VocalTract me, double startTime, double endTime, double time) {
try {
autoVocalTractTier thee = VocalTractTier_create (startTime, endTime);
VocalTractTier_addVocalTract_copy (thee.get(), time, me);
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to VocalTractTier");
}
}
void VocalTractTier_addVocalTract_copy (VocalTractTier me, double time, VocalTract vocaltract) {
try {
autoVocalTractPoint thee = VocalTract_to_VocalTractPoint (vocaltract, time);
if (my d_vocalTracts.size > 0) {
VocalTractPoint vtp = my d_vocalTracts.at [1];
long numberOfSections = vtp -> d_vocalTract -> nx;
if (numberOfSections != vocaltract -> nx) {
Melder_throw (U"The number of sections must be equal to ", numberOfSections, U".");
}
}
my d_vocalTracts. addItem_move (thee.move());
} catch (MelderError) {
Melder_throw (me, U": no VocalTract added.");
}
}
autoVocalTract VocalTractTier_to_VocalTract (VocalTractTier me, double time) {
try {
Melder_assert (my d_vocalTracts.size > 0);
VocalTractPoint vtp = my d_vocalTracts.at [1];
long numberOfSections = vtp -> d_vocalTract -> nx;
autoVocalTract thee = VocalTract_create (numberOfSections, vtp -> d_vocalTract -> dx);
for (long isection = 1; isection <= numberOfSections; isection ++) {
autoRealTier section = RealTier_create (my xmin, my xmax);
for (long i = 1; i <= my d_vocalTracts.size; i ++) {
VocalTractPoint vtpi = my d_vocalTracts.at [i];
double areai = vtpi -> d_vocalTract -> z [1] [isection];
RealTier_addPoint (section.get(), vtpi -> number, areai);
}
thy z[1][isection] = RealTier_getValueAtTime (section.get(), time);
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": no VocalTract created.");
}
}
autoLPC VocalTractTier_to_LPC (VocalTractTier me, double timeStep) {
try {
if (my d_vocalTracts.size == 0) {
Melder_throw (U"Empty VocalTractTier");
}
long numberOfFrames = (long) floor ((my xmax - my xmin) / timeStep);
VocalTractPoint vtp = my d_vocalTracts.at [1];
long numberOfSections = vtp -> d_vocalTract -> nx;
double samplingPeriod = 1.0 / (1000.0 * numberOfSections);
autoNUMmatrix area (1, numberOfFrames, 1, numberOfSections + 1);
autoNUMvector areavec (1, numberOfSections + 1);
autoLPC thee = LPC_create (my xmin, my xmax, numberOfFrames, timeStep, timeStep / 2.0, numberOfSections, samplingPeriod);
// interpolate each section
for (long isection = 1; isection <= numberOfSections; isection ++) {
autoRealTier sectioni = RealTier_create (my xmin, my xmax);
for (long i = 1; i <= my d_vocalTracts.size; i ++) {
VocalTractPoint vtpi = my d_vocalTracts.at [i];
double areai = vtpi -> d_vocalTract -> z [1] [isection];
RealTier_addPoint (sectioni.get(), vtpi -> number, areai);
}
for (long iframe = 1; iframe <= numberOfFrames; iframe ++) {
double time = thy x1 + (iframe - 1) * thy dx;
area [iframe] [isection] = RealTier_getValueAtTime (sectioni.get(), time);
area [iframe] [numberOfSections + 1] = 0.0001; // normalisation is area[n+1] = 0.0001
}
}
for (long iframe = 1; iframe <= numberOfFrames; iframe ++) {
LPC_Frame frame = & thy d_frames [iframe];
LPC_Frame_init (frame, numberOfSections);
for (long i = 1; i <= numberOfSections + 1; i ++) {
areavec [i] = area [iframe] [numberOfSections + 1 - i];
}
NUMlpc_area_to_lpc (areavec.peek(), numberOfSections + 1, frame -> a);
frame -> gain = 1e-6; // something
}
return thee;
} catch (MelderError) {
Melder_throw (U": not converted to LPC.");
}
}
/* End of file VocalTractTier.cpp */
praat-6.0.23/LPC/VocalTractTier.h 0000664 0000000 0000000 00000002764 13023464014 0016374 0 ustar 00root root 0000000 0000000 #ifndef _VocalTractTier_h_
#define _VocalTractTier_h_
/* VocalTractTier.h
*
* Copyright (C) 2012, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "AnyTier.h"
#include "LPC.h"
#include "VocalTract.h"
#include "VocalTractTier_def.h"
void VocalTract_drawSegments (VocalTract me, Graphics g, double maxLength, double maxArea, bool closedAtGlottis);
autoVocalTractPoint VocalTract_to_VocalTractPoint (VocalTract me, double time);
autoVocalTractTier VocalTractTier_create (double fromTime, double toTime);
autoVocalTractTier VocalTract_to_VocalTractTier (VocalTract me, double startTime, double endTime, double time);
void VocalTractTier_addVocalTract_copy (VocalTractTier me, double time, VocalTract thee);
autoLPC VocalTractTier_to_LPC (VocalTractTier me, double timeStep);
autoVocalTract VocalTractTier_to_VocalTract (VocalTractTier me, double time);
/* End of file VocalTractTier.h */
#endif
praat-6.0.23/LPC/VocalTractTier_def.h 0000664 0000000 0000000 00000002156 13023464014 0017205 0 ustar 00root root 0000000 0000000 /* VocalTractTier_def.h
*
* Copyright (C) 2012 David Weenink, 2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT VocalTractPoint
oo_DEFINE_CLASS (VocalTractPoint, AnyPoint)
oo_AUTO_OBJECT (VocalTract, 0, d_vocalTract)
oo_END_CLASS (VocalTractPoint)
#undef ooSTRUCT
#define ooSTRUCT VocalTractTier
oo_DEFINE_CLASS (VocalTractTier, Function)
oo_COLLECTION_OF (SortedSetOfDoubleOf, d_vocalTracts, VocalTractPoint, 0)
oo_END_CLASS (VocalTractTier)
#undef ooSTRUCT
/* End of file VocalTract_def.h */
praat-6.0.23/LPC/manual_LPC.cpp 0000664 0000000 0000000 00000116440 13023464014 0016011 0 ustar 00root root 0000000 0000000 /* manual_LPC.cpp
*
* Copyright (C) 1994-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020422 GPL + removed "C syntax" part of manpage
djmw 20101009 Latest modification
*/
#include "ManPagesM.h"
#include "MFCC.h"
void manual_LPC (ManPages me);
void manual_LPC (ManPages me)
{
MAN_BEGIN (U"CC: Paint...", U"djmw", 20040407)
INTRO (U"A command to paint the cepstral coefficients in shades of grey.")
ENTRY (U"Settings")
TAG (U"##From coefficient#, ##To coefficient#")
DEFINITION (U"the range of coefficients that will be represented.")
MAN_END
MAN_BEGIN (U"CC: To DTW...", U"djmw", 19960918)
INTRO (U"You can choose this command after selecting 2 objects with cepstral "
"coefficients (two @MFCC's or @LFCC's). "
"With this command you perform dynamic time warping. ")
ENTRY (U"Algorithm")
NORMAL (U"First we calculate distances between cepstral coefficients: ")
LIST_ITEM (U"The distance between frame %i (from me) and %j (from thee) is:")
LIST_ITEM (U" %wc \\.c %d1 + %wle \\.c %d2 + %wr \\.c %d3,")
LIST_ITEM (U" where %wc, %wle & %wr are user-supplied weights and")
LIST_ITEM (U" %d1 = \\su (%k=1..%nCoefficients; (%c__%ik_ - %c__%jk_)^2)")
LIST_ITEM (U" %d2 = (c__%i0_ - c__%j0_)^2")
LIST_ITEM (U" %d3 = \\su (%k=1..%nCoefficients; (%r__%ik_ - %r__%jk_)^2), with ")
LIST_ITEM (U" %r__%ik_ the regression coefficient of the cepstral coefficients "
"from the frames within a time span of %dtr seconds. "
"c__%ij_ is %j-th cepstral coefficient in frame %i. ")
NORMAL (U"Next we find the optimum path through the distance matrix with a "
"Viterbi-algorithm.")
MAN_END
MAN_BEGIN (U"CC: To Matrix", U"djmw", 20011123)
INTRO (U"Copies the cepstral coefficients of the selected @CC "
"object to a newly created @Matrix object.")
ENTRY (U"Behaviour")
FORMULA (U"%z__%ji_ = %c__%ij_, with 1 \\<_ %i \\<_ %nx and "
"1 \\<_ j \\<_ %numberOfCoefficients__%i_,")
NORMAL (U"where %z__%ji_ is the matrix element in row %j and column %i and "
"%c__%ij_ is the %j-th cepstral coefficient in frame %i.")
MAN_END
MAN_BEGIN (U"Formants: Extract smoothest part...", U"djmw", 20140313)
INTRO (U"Extracts the part from one of the selected formants which shows the smoothest formant tracks in a given interval.")
ENTRY (U"Settings")
SCRIPT (5, Manual_SETTINGS_WINDOW_HEIGHT (5), U""
Manual_DRAW_SETTINGS_WINDOW (U"Formants: Extract smoothest part", 5)
Manual_DRAW_SETTINGS_WINDOW_RANGE (U"Time range (s)", U"0.0", U"0.0")
Manual_DRAW_SETTINGS_WINDOW_RANGE (U"Fitter formant range", U"1", U"3")
Manual_DRAW_SETTINGS_WINDOW_FIELD (U"Order of polynomials", U"3")
Manual_DRAW_SETTINGS_WINDOW_BOOLEAN (U"Use bandwidths to model formant tracks", 1)
Manual_DRAW_SETTINGS_WINDOW_BOOLEAN (U"Bandwidths for smoothing test", 0)
)
TAG (U"##Time range (s)#")
DEFINITION (U"determines the position of the intervals that have to be compared.")
TAG (U"##Fitter formant range")
DEFINITION (U"determines which formant tracks will be modelled with a polynomial function. The goodness of fit of these models will be used in the comparison.")
TAG (U"##Order of polynomials")
DEFINITION (U"determines the maximum order of the polynomials that are used in modeling each formant track. Order 0 means a model which is a constant function; this model needs only one parameter. Order 1 means a model that is a straight line function; this order needs two parameters. Order 2 means that an additional parabolic function is used in the modeling; order 2 needs therefore 3 parameters. In general an order %p model needs %p+1 parameters.")
TAG (U"##Use bandwidths to model formant tracks")
DEFINITION (U"Bandwidths give an indication about the sharpness of a spectral peak. Sharp peaks have small bandwidths and, vice versa, broad peaks have large bandwidths. The width of a peak can also be interpreted as a measure of certainty for its formant frequency value. Setting this option %%on%, the default setting, means that you force the modeling function to be closer to frequencies that are well defined, i.e. that have sharp peaks, than to the frequencies of broad peaks, if choices have to be made. The consequence is that in the model sharp peaks will be better represented than broad peaks.")
TAG (U"##Bandwidths for smoothing test")
DEFINITION (U"determines whether for the smoothnes determination the formant frequencies are still needed. Not using them anymore probably gives a better indication of the smoothness of a track.")
MAN_END
MAN_BEGIN (U"PowerCepstrogram", U"djmw", 20130616)
INTRO (U"One of the @@types of objects@ in P\\s{RAAT}.")
ENTRY (U"Description")
NORMAL (U"The PowerCepstrogram shows @@PowerCepstrum|cepstral slices@ as a function of time.")
MAN_END
MAN_BEGIN (U"PowerCepstrogram: To Table (peak prominence)...", U"djmw", 20130616)
INTRO (U"A command to create a table with @@PowerCepstrum: Get peak prominence...|cepstral peak prominence@ values.")
ENTRY (U"Settings")
SCRIPT (5, Manual_SETTINGS_WINDOW_HEIGHT (7), U""
Manual_DRAW_SETTINGS_WINDOW ("PowerCepstrogram: To Table (peak prominence)", 7)
Manual_DRAW_SETTINGS_WINDOW_RANGE("Peak search pitch range (Hz)", U"60.0", U"300.0")
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"Interpolation", U"None", 0)
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"", U"Parabolic", 0)
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"", U"Cubic", 1)
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"", U"Sinc70", 0)
Manual_DRAW_SETTINGS_WINDOW_RANGE("Tilt line quefrency range (s)", U"0.001", U"0.0 (= end)")
Manual_DRAW_SETTINGS_WINDOW_OPTIONMENU(U"Fit method", U"Robust")
)
NORMAL (U"The meaning of these settings is explained @@PowerCepstrum: Get peak prominence...|here@.")
MAN_END
MAN_BEGIN(U"PowerCepstrogram: Paint...", U"djmw", 20131001)
INTRO (U"A command to draw the selected @@PowerCepstrogram@ object(s) in shades of grey.")
ENTRY (U"Settings")
SCRIPT (5, Manual_SETTINGS_WINDOW_HEIGHT (7), U""
Manual_DRAW_SETTINGS_WINDOW (U"PowerCepstrogram: Paint", 7)
Manual_DRAW_SETTINGS_WINDOW_RANGE("Time range (s)", U"0.0", U"0.0")
Manual_DRAW_SETTINGS_WINDOW_RANGE("Quefrency range (s)", U"0.0", U"0.0")
Manual_DRAW_SETTINGS_WINDOW_FIELD("Maximum (dB)", U"80.0")
Manual_DRAW_SETTINGS_WINDOW_BOOLEAN("Autoscaling",0)
Manual_DRAW_SETTINGS_WINDOW_FIELD("Dynamic range (dB)", U"30.0")
Manual_DRAW_SETTINGS_WINDOW_FIELD("Dynamic compression (0-1)", U"0.0")
Manual_DRAW_SETTINGS_WINDOW_BOOLEAN("Garnish",1)
)
TAG (U"##Time range (s)")
DEFINITION (U"the time domain along the %%x% axis.")
TAG (U"##Quefrency range (s)")
DEFINITION (U"the quefency domain along the %%y% axis.")
TAG (U"##Maximum (dB)")
DEFINITION (U"cells that have cepstral values greater or equal than this value are drawn in black.")
TAG (U"##Autoscaling")
DEFINITION (U"If %%on%, overrules the effects of the previous option and the following three options. I.e. the global maximum and the "
"global minimum cepstral values determine the maximum blackness and the minimal blackness. Values in-between have apropriate "
"values of grey.")
TAG (U"##Dynamic range (dB)")
DEFINITION (U"All values more than %%Dynamic range% below the maximum will be drawn in white. Values in-between have apropriate "
"values of grey.")
TAG (U"##Dynamic compression (0-1)")
DEFINITION (U"determines how much stronger weak frames should be made before drawing. Normally this parameter is between 0 and 1. "
"If it is 0, no dynamic compression will take place. If it is 1, all time frames (vertical bands) will contain cepstral values "
"that are drawn in black. If the global %%maximum% is set at 80 dB, %%autoscaling% is off, %%dynamic range% is 30 dB and "
"%%dynamic compression% is 0.4 then for a frame with a local maximum of 40 dB all values will be lifted by 0.4*(80-40)=16 dB, "
"so that its maximum will be seen at 56 dB (thus making the corresponding cell visible).")
TAG (U"##Garnish")
DEFINITION (U"Draws a box around the cepstrogram and labels the axes.")
MAN_END
MAN_BEGIN (U"PowerCepstrogram: Smooth...", U"djmw", 20140117)
INTRO (U"Smoothes the selected @PowerCepstrogram by averaging cepstra. The smoothed PowerCepstrogram is the result of two separate steps. "
"In the first step, cepsta are averaged across time. In the second step, cepstra are averaged across quefrency.")
ENTRY (U"Settings")
TAG (U"##Time averaging window (s)")
DEFINITION (U"determines how many frames will used in the first step, averaging across time. The user-supplied value will be divided "
"by the Cepstrograms's time step value (its %dx). If %%numberOfFramesToAverage%, the result of the division, turns out to be one or less, no averaging across time is performed. "
"If %%numberOfFramesToAverage% is larger than one and is even, one will be added. "
"Each new cepstral frame will be the average of %numberOfFramesToAverage frames of the input Cepstrogram. "
"For example, if %numberOfFramesToAverage turns out to be 5, then the %j-th new cepstral frame is the result of averaging the 5 frames with indices %j\\--2 , %j\\--1, %j, %j+1 and %j+2 for all frames %j=3..%%numberOfFrames%\\--2, i.e. besides frame %j, the 2 frames on either side are used in the averaging. The %numberOfFramesToAverage has to be uneven to allow for this symmetric behaviour. ")
TAG (U"##Quefrency averaging window (s)")
DEFINITION (U"determines how many quefrency bins will be used for the averaging across quefrency step. The number of bins used in this step "
"is the result of the division of the user-supplied value by the quefrency step value (the Cepstrogram's %dy). "
"If the result turns out to be one or less, no averaging across quefrencies is performed. If the resulting value is even, one will be added. "
"If, for example, the result happens to be 3 then the value in quefrency bin %k will be the average value of the values in quefrency bins "
"%k\\--1, %k and %k+1. ")
ENTRY (U"Note")
NORMAL (U"The following commands should reproduce the smoothing described in the @@Hillenbrand & Houde (1996)@ article, where they use a 20 ms "
"(10 frame) time smoothing and a 1 ms (10 bin) quefrency smoothing. ")
CODE (U"selectObject (\"Sound xxx\")")
CODE (U"To PowerCepstrogram: 0.041, 0.002, 5000.0")
CODE (U"Smooth: 0.02, 0.001")
MAN_END
MAN_BEGIN (U"Cepstrum", U"djmw", 20130616)
INTRO (U"One of the @@types of objects@ in P\\s{RAAT}.")
ENTRY (U"Description")
NORMAL (U"A Cepstrum is the log spectrum of the log power spectrum.")
MAN_END
MAN_BEGIN (U"PowerCepstrum", U"djmw", 20130616)
INTRO (U"One of the @@types of objects@ in P\\s{RAAT}.")
ENTRY (U"Description")
NORMAL (U"A PowerCepstrum is the log power spectrum of the log power spectrum. The vertical scale will show the amplitude expressed in dB. The horizontal scale shows %%quefrency% in units of seconds.")
MAN_END
MAN_BEGIN (U"PowerCepstrum: Get peak prominence...", U"djmw", 20130616)
INTRO (U"Calculates the cepstral peak prominence measure (CPP) as defined by @@Hillenbrand et al. (1994)@")
NORMAL (U"The CPP measure is the difference in amplitude between the cepstral peak and the corresponding value on the regression "
"line that is directly below the peak (i.e., the predicted magnitude for the quefrency at the cepstral peak). "
"The CPP measure represents how far the cepstral peak emerges from the cepstrum background. ")
ENTRY (U"Settings")
SCRIPT (7, Manual_SETTINGS_WINDOW_HEIGHT (7), U""
Manual_DRAW_SETTINGS_WINDOW (U"PowerCepstrum: Get peak prominence", 7)
Manual_DRAW_SETTINGS_WINDOW_RANGE("Search peak in pitch range (s)", U"60.0", U"333.3")
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"Interpolation", U"None", 0)
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"", U"Parabolic", 0)
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"", U"Cubic", 1)
Manual_DRAW_SETTINGS_WINDOW_RADIO (U"", U"Sinc70", 0)
Manual_DRAW_SETTINGS_WINDOW_RANGE (U"Tilt line quefrency range (s)", U"0.001", U"0.0 (= end)")
Manual_DRAW_SETTINGS_WINDOW_OPTIONMENU (U"Fit method", U"Robust")
)
TAG (U"##Search peak in pitch range")
DEFINITION (U"determine the limits of the quefrency range where a peak is searched for. The lower quefrency is determined as "
"1 / %%pitchCeiling% and this value is in general more critical than "
"the value of the upper quefrency which equals 1 / %%pitchFloor%. A %%pitchCeiling% of 300 Hz will correspond to a lower quefrency of 1/300\\~~0.0033 seconds.")
TAG (U"##Interpolation")
DEFINITION (U"determines how the @@vector peak interpolation|amplitude of a peak is determined@.")
TAG (U"##Tilt line quefrency range")
DEFINITION (U"the quefrency range for which the amplitudes (in dB) will be modelled by a straight line. "
"The lower value for this range in the Hillenbrand article was chosen as 0.001 s "
"in order to reduce the effect of the low quefrency data on the straight line fit. In our analysis this value is not so critical "
"as we use a more robust straight line fit.")
TAG (U"##Fit method")
DEFINITION (U"the default method is @@theil regression|Theil's robust line fit@. However, to be compatible with the past, a standard least squares line fit has also been implemented.")
ENTRY (U"Note")
NORMAL (U"The CPP value does not depend on the reference value used in the dB calculation of the power cepstrum.")
MAN_END
MAN_BEGIN (U"PowerCepstrum: Draw tilt line...", U"djmw", 20130616)
INTRO (U"Draws the line that models the backgound of the power cepstrum.")
MAN_END
MAN_BEGIN (U"Formant & Spectrogram: To IntensityTier...", U"djmw", 20130109)
INTRO (U"Determines the formant intensities from the selected Spectrogram.")
NORMAL (U"The intensities at the frequencies of the selected formant are copied from the corresponding positions in the spectrogram. "
"If the selected formant doesn't exist in a particular frame, then a large negative value (< -200 dB) is substituted instead. "
"Because the values in the spectrogram are expressed in Pa^^2^/Hz, the units in the intensity tier are in dB/Hz. ")
MAN_END
MAN_BEGIN (U"LFCC", U"djmw", 20040421)
INTRO (U"One of the @@types of objects@ in P\\s{RAAT}.")
NORMAL (U"An object of type LFCC represents cepstral "
"coefficients on a linear frequency scale as a function of time. "
"The coefficients are represented in frames with constant sampling "
"period.")
ENTRY (U"#LFCC commands")
NORMAL (U"Creation:")
LIST_ITEM (U"\\bu @@LPC: To LFCC...")
MAN_END
MAN_BEGIN (U"LFCC: To LPC...", U"djmw", 20040407)
INTRO (U"You can choose this command after selecting 1 or more @LFCC's.")
ENTRY (U"Settings")
TAG (U"##Number of coefficients")
DEFINITION (U"the desired number of linear predictive coefficients.")
ENTRY (U"Behaviour")
NORMAL (U"The transformation from cepstral coefficients to %a-coefficients "
"as described in @@Markel & Gray (1976)@.")
MAN_END
MAN_BEGIN (U"LPC", U"djmw", 19990610)
INTRO (U"One of the @@types of objects@ in P\\s{RAAT}.")
NORMAL (U"An object of type LPC represents filter coefficients as a function of time. "
"The coefficients are represented in frames with constant sampling period.")
ENTRY (U"LPC commands")
NORMAL (U"Creation:")
LIST_ITEM (U"\\bu @@Sound: To LPC (autocorrelation)...@")
LIST_ITEM (U"\\bu @@Sound: To LPC (covariance)...@")
LIST_ITEM (U"\\bu @@Sound: To LPC (burg)...@")
LIST_ITEM (U"\\bu @@Sound: To LPC (marple)...@")
ENTRY (U"Conversion")
LIST_ITEM (U"\\bu @@LPC: To LFCC...|To LFCC...@")
LIST_ITEM (U"\\bu @@LPC: To Spectrogram...|To Spectrogram...@")
LIST_ITEM (U"\\bu @@LPC: To Spectrum (slice)...|To Spectrum (slice)...@")
LIST_ITEM (U"\\bu @@LPC: To Polynomial (slice)...|To Polynomial (slice)...@")
MAN_END
MAN_BEGIN (U"LPC: Draw gain...", U"djmw", 20040407)
INTRO (U"You can choose this command after selecting 1 or more @LPC objects.")
ENTRY (U"Settings")
TAG (U"##From time (s)#, ##To time (seconds)#")
DEFINITION (U"the time domain along the %x-axis.")
TAG (U"##Minimum gain#, ##Maximum gain#")
DEFINITION (U"the range for the %y-axis.")
TAG (U"##Garnish")
DEFINITION (U"determines whether to draw a bounding box and axis labels.")
ENTRY (U"Behaviour")
NORMAL (U"Gain will be drawn as a function of time (gain also equals the prediction error "
"energy). ")
MAN_END
MAN_BEGIN (U"LPC: Draw poles...", U"djmw", 20040407)
INTRO (U"You can choose this command after selecting 1 or more @LPC objects.")
ENTRY (U"Settings")
TAG (U"##Time (s)")
DEFINITION (U"the time of the nearest frame.")
ENTRY (U"Behaviour")
NORMAL (U"The @@Roots|roots@ of the @@LPC: To Polynomial (slice)...|linear prediction "
"polynomial@, constructed from the coefficients "
"of the analysis frame, will be drawn in the complex plane.")
MAN_END
MAN_BEGIN (U"LPC: To LFCC...", U"djmw", 20040407)
INTRO (U"You can choose this command after selecting 1 or more @LPC objects.")
ENTRY (U"Behaviour")
NORMAL (U"The transformation from a-coefficients to cepstral coefficients "
"as described in @@Markel & Gray (1976)@.")
ENTRY (U"Settings")
TAG (U"%%Number of coefficients%")
DEFINITION (U"the desired number of cepstral coefficients.")
MAN_END
MAN_BEGIN (U"LPC: To Matrix", U"djmw", 20011123)
INTRO (U"Copies the linear prediction coefficients of the selected @LPC "
"object to a newly created @Matrix object.")
ENTRY (U"Behaviour")
FORMULA (U"%z__%ji_ = %a__%ij_, with 1 \\<_ %i \\<_ %nx and "
"1 \\<_ j \\<_ %nCoefficients__%i_,")
NORMAL (U"where %z__%ji_ is the matrix element in row %j and column %i and "
"%a__%ij_ is the %j-th linear prediction coefficient in frame %i.")
MAN_END
MAN_BEGIN (U"LPC: To Formant", U"djmw", 19970123)
INTRO (U"You can choose this command after selecting 1 or more @LPC objects.")
ENTRY (U"Behaviour")
NORMAL (U"For each LPC_Frame, the zeros of the linear prediction polynomial are extracted. "
"Zeros that are outside the unit circle are reflected into it. "
"Next, formant frequencies and bandwidths are calculated from all the roots that have the "
"imaginary part positive, i.e., that lie in the upper half of the unit circle. "
"Formant frequencies smaller than 50 Hz or larger than (%Nyquist_frequency - 50) are discarded. "
"The remaining frequencies and bandwidths are sorted "
"and copied to the Formant_Frame. Finally, the %gain field of the LPC is copied to the %intensity "
"field of the Formant_Frame.")
ENTRY (U"Algorithm")
NORMAL (U"The root finder is Laguerre's method followed by root polishing, see @@Press "
"et al. (1992)@.")
ENTRY (U"Warning")
LIST_ITEM (U"\\bu The formant values can be very inaccurate if you did not resample the Sound "
"before the LPC-analysis (consult the @@Source-filter synthesis@ tutorial).")
LIST_ITEM (U"\\bu The results of the root finder may not always be accurate when more than 30 "
"roots have to be found.")
MAN_END
MAN_BEGIN (U"LPC: To Polynomial (slice)...", U"djmw", 20040407)
INTRO (U"A command that creates a Polynomial object from each selected @LPC object.")
ENTRY (U"Settings")
TAG (U"##Time (s)")
DEFINITION (U"defines the LPC frame whose coefficents will be selected.")
ENTRY (U"Behaviour")
NORMAL (U"The linear prediction coefficients %a__1..%n_ of the selected LPC "
"frame will be copied to polynomial coefficients %c__1..%n+1_ as follows:")
FORMULA (U"%c__%i_ = %a__%n\\--%i+1_, ")
FORMULA (U"%c__%n+1_ = 1")
MAN_END
MAN_BEGIN (U"LPC: To Spectrum (slice)...", U"djmw", 20071120)
INTRO (U"You can choose this command after selecting 1 or more @LPC objects.")
ENTRY (U"Settings")
TAG (U"##Time (s)")
DEFINITION (U"the time at which the Spectrum must be calculated.")
TAG (U"##Minimum frequency resolution (Hz)")
DEFINITION (U"successive frequencies in the @Spectrum "
"will be maximally this distance apart.")
TAG (U"##Bandwidth reduction (Hz)")
DEFINITION (U"formants with small bandwidths show up very well as peaks in the spectrum because the poles "
"lie close to the contour along which the spectrum is computed (the unit circle in the z-plane). "
"Peak enhancement can be realized by computing the spectrum in the z-plane along a contour of radius "
"%r = exp (\\-- %\\pi \\.c %bandwidthReduction / %samplingFrequency). "
"This technique is also called off-axis spectrum computation. "
"Negative values evaluate the spectrum on a contour %outside the unit circle and therefore result in a "
"flattened spectrum.")
TAG (U"##De-emphasis frequency (Hz)")
DEFINITION (U"Performs de-emphasis when frequency is in the interval (0, @@Nyquist frequency@)")
ENTRY (U"Algorithm")
NORMAL (U"The Spectrum at time %t will be calculated from the %nearest LPC_Frame according to:")
FORMULA (U"Spectrum (%f) = \\Vr(%gain\\.c%T/%df) / (1 + \\su__%k=1..%numberOfCoefficients_ %a__%k_%z^^\\--%k^),")
NORMAL (U"where %T is the sampling period and %z = exp (\\--2 %\\pi %i %f %T) and %df is the distance in Hz "
"between two successive components in the Spectrum.")
LIST_ITEM (U"1. Allocate a large enough buffer[1..%nfft] to perform an FFT analysis.")
LIST_ITEM (U"2. Make the first value of the buffer 1 and copy the prediction coefficients #a into "
"the buffer. This results in buffer values: (1, %a__1_, ..., %a__%numberOfCoefficients_, 0, ..., 0).")
LIST_ITEM (U"3. If ##De-emphasis frequency# is in the interval (0, %nyquistFrequency) then \"multiply\" "
"the buffer with (1 - %b %z^^\\--1^), where %b = exp (\\-- %\\pi %deEmphasisFrequency %T). "
"This results in buffer values: (1, %a__1_\\--%b, %a__2_\\--%b\\.c%a__1_, ..., "
"%a__%numberOfCoefficients_\\--%b\\.c%a__%numberOfCoefficients\\--1_, "
"\\--%b\\.c%a__%numberOfCoefficients_, 0, ..., 0). Note that the number of values in the buffer that differ from 0 "
"has increased by one.")
LIST_ITEM (U"4. If ##Bandwidth reduction# is greater than 0 then multiply corresponding values in the buffer by %g^^%i\\--1^ where "
"%g = exp (2%\\pi %bandwidthReduction %T / %nfft), and %i is the position index in the buffer. "
"%i runs from 1 to %numberOfCoefficients+1+%t, where %t equals 1 when de-emphasis was performed, "
"else 0.")
LIST_ITEM (U"5. Calculate the FFT spectrum of the buffer with the coefficients. This results in complex "
"amplitudes (%a__%j_,%b__%j_), %j=1..%nfft/2+1.")
LIST_ITEM (U"6. Calculate the LPC Spectrum by taking the inverse of the FFT spectrum, i.e., each complex "
"amplitude becomes (%a__%j_,%b__%j_)^^\\--1^ = (%a__%j_,\\--%b__%j_) / (%a__%j_^2 + %b__%j_^2)")
LIST_ITEM (U"7. Multiply all values with the scale factor \\Vr(%gain\\.c%T/%df).")
MAN_END
MAN_BEGIN (U"LPC: To Spectrogram...", U"djmw", 20040407)
INTRO (U"You can choose this command after selecting 1 or more @LPC objects.")
ENTRY (U"Settings")
TAG (U"##Minimum frequency resolution (Hz)")
DEFINITION (U"successive frequencies in the Spectrum will be maximally this distance apart")
TAG (U"##Bandwidth reduction (Hz)")
DEFINITION (U"formants with small bandwidths show up very well as darker regions in the spectrogram "
"because the poles lie close to the contour along which a spectrum is computed (the unit circle "
"in the z-plane). "
"Peak enhancement can be realized by computing a spectrum in the z-plane along a contour of radius "
"%r = exp (\\-- %\\pi \\.c %bandwidthReduction / %samplingFrequency).")
TAG (U"##De-emphasis frequency (Hz)")
DEFINITION (U"Performs de-emphasis when value is in the interval (0, @@Nyquist frequency@)")
ENTRY (U"Algorithm")
NORMAL (U"For each LPC_Frame the corresponding Spectrum will be calculated according to the algorithm "
"explained in @@LPC: To Spectrum (slice)...@. "
"For each frequency the power, i.e., the square of the complex values, will be stored in the "
"corresponding area in the Spectrogram.")
MAN_END
MAN_BEGIN (U"LPC: To VocalTract (slice)...", U"djmw", 20050615)
INTRO (U"You can choose this command after selecting 1 or more @LPC objects.")
ENTRY (U"Settings")
TAG (U"##Time (s)")
DEFINITION (U"the time of the nearest frame, in seconds.")
TAG (U"##Length (m)")
DEFINITION (U"the length of the vocal tract, in metres.")
/*
TAG (U"##Compute length according to Wakita")
DEFINITION (U"the length of the vocal tract is calculated according "
"to the algorithm as described in @@Wakita (1977)@.")
ENTRY (U"Behaviour")
NORMAL (U"A new @VocalTract area function is calculated from the prediction coefficients in the frame. ")
ENTRY (U"Warning")
NORMAL (U"If ##Compute length according to Wakita# is on, the optimal length is searched for in the range from 0.1 m to "
"0.25 m. This length calculation is extremely sensitive to the number of and the positions of the formants "
"with respect to the @@Nyquist frequency@. For example, there is a large difference "
"between the vocal tract length estimates if the highest formant is just below or just above the "
"Nyquist frequency. "
"The algorithm is not very reliable in vocal tract length estimation and we do not recommend using it. " )*/
MAN_END
MAN_BEGIN (U"LPC & Sound: Filter...", U"djmw", 20040407)
INTRO (U"A command that creates a new Sound object from one @Sound and one @LPC "
"object which have been selected together.")
ENTRY (U"Settings")
TAG (U"##Use LPC gain")
DEFINITION (U"Determines whether the gain from the LPC is used in the synthesis.")
ENTRY (U"Behaviour")
NORMAL (U"Filters the selected Sound by the selected LPC-filter.")
NORMAL (U"When the LPC-gain is used the samples in the new Sound will be "
"multiplied with the square root of the corresponding LPC-gain value.")
NORMAL (U"In #Z-domain notation: #O(%z) = #H(%z) \\.c #E(%z), where "
"#E(%z) is the selected filter input Sound, #H(%z) the selected LPC filter, "
"and, #O(%z) the filter output (the new Sound that will appear in the List of objects).")
MAN_END
MAN_BEGIN (U"LPC & Sound: Filter with filter at time...", U"djmw", 20101009)
INTRO (U"Filters the selected @Sound with a static filter that is formed by the filter coefficients "
"from only one @LPC frame.")
ENTRY (U"Settings")
TAG (U"##Channel")
DEFINITION (U"determines the sound channel to be filtered.")
TAG (U"##Use filter at time (s)")
DEFINITION (U"determines which LPC frame will be chosen to filter the sound. ")
MAN_END
MAN_BEGIN (U"LPC & Sound: Filter (inverse)", U"djmw", 19970126)
INTRO (U"A command that creates a new Sound object from one @Sound and one @LPC "
"object which have been selected together.")
ENTRY (U"Behaviour")
NORMAL (U"Given a filter (the selected LPC) and its output (the selected Sound), "
"its input is reconstructed (the new Sound that will appear in the List of objects).")
NORMAL (U"In Z-domain notation: #E(%z) = #O(%z) / #H(%z), where "
"#O(%z) is the filter output Sound, #H(%z) the LPC filter, and, #E(%z) the filter "
"input Sound. (Selecting this newly generated Sound and the LPC, choosing the option "
"`Filter...' generates a Sound that is identical to the Sound that originated "
"the LPC.)")
MAN_END
MAN_BEGIN (U"LPC & Sound: Filter (inverse) with filter at time...", U"djmw", 20101009)
INTRO (U"%%Inverse% filters the selected @Sound with a static inverse filter that is formed by the filter coefficients "
"from only one @LPC frame.")
ENTRY (U"Settings")
TAG (U"##Channel")
DEFINITION (U"determines the sound channel to be filtered.")
TAG (U"##Use filter at time (s)")
DEFINITION (U"determines which LPC frame will be chosen to inverse filter the sound. ")
MAN_END
MAN_BEGIN (U"MFCC", U"djmw", 20160225)
INTRO (U"One of the @@types of objects@ in P\\s{RAAT}.")
NORMAL (U"An object of type MFCC represents mel frequency cepstral coefficients "
"as a function of time. The coefficients are represented in a number of frames centred at equally spaced times. "
"at constant sampling period.")
ENTRY (U"MFCC commands")
NORMAL (U"Creation:")
LIST_ITEM (U"\\bu @@Sound: To MFCC...@")
LIST_ITEM (U"\\bu @@MelSpectrogram: To MFCC...@")
MAN_END
MAN_BEGIN (U"MFCC: To MelFilter...", U"djmw", 20141023)
INTRO (U"A #deprecated command replaced by @@MFCC: To MelSpectrogram...@.")
ENTRY (U"Settings")
TAG (U"##From coefficient#, ##To coefficient#")
DEFINITION (U"the range of coefficients that will be used in the reconstruction.")
ENTRY (U"Details")
NORMAL (U"The output of the triangular filters in a mel filter bank will be "
"reconstructed by applying the inverse cosine transform:")
FORMULA (U"%P__%j_ = 2/N (%c__0_/2 + \\Si__%k=1_^^%N-1^ %c__%k_ cos (\\pi%k(%j-0.5)/%N))),")
NORMAL (U"where %N represents the number of filters, %j runs from 1 to %N, and coefficients %c__%k_ with %k less than "
"%%fromCoefficient% and %k larger than %%toCoefficient% take zero values in the evaluation.")
MAN_END
MAN_BEGIN (U"MFCC: To MelSpectrogram...", U"djmw", 20141023)
INTRO (U"A command to (re)construct a @MelSpectrogram object from the selected @MFCC object.")
ENTRY (U"Settings")
TAG (U"##From coefficient#, ##To coefficient#")
DEFINITION (U"the range of coefficients that will be used in the reconstruction.")
TAG (U"##Include constant term")
DEFINITION (U"selects whether or not to include the %c__0_ coefficient in the reconstruction. As can be seen from the formula below, the contribution of the %c__0_ term is equal for each filter.")
ENTRY (U"Details")
NORMAL (U"The values %P__%j_ in each frame of the MelSpectrogram will be constructed by applying the inverse Discrete Cosine Transform to the corresponding frame of the MFCC object:")
FORMULA (U"%P__%j_ = 2/N (%c__0_/2 + \\Si__%k=1_^^%N-1^ %c__%k_ cos (\\pi%k(%j-0.5)/%N))),")
NORMAL (U"where %N represents the number of filters that were used to get the MFCC object, %j runs from 1 to %N, and coefficients %c__%k_ with %k less than "
"%%fromCoefficient% and %k larger than %%toCoefficient% take zero values in the evaluation.")
MAN_END
MAN_BEGIN (U"Sound: To PowerCepstrogram...", U"djmw", 20130616)
INTRO (U"A command that creates a @@PowerCepstrogram@ from every selected @@Sound@.")
ENTRY (U"Settings")
TAG (U"##Pitch floor (Hz)")
DEFINITION (U"determines the effective length of the analysis window: it will be 3 longest periods long, i.e. if the pitch floor is 60 Hz, the window will be 3/60 = 0.05 seconds long.")
TAG (U"##Time step (s)")
TAG (U"##Maximum frequency (Hz)")
TAG (U"##Pre-emphasis from (Hz)")
MAN_END
MAN_BEGIN (U"Sound: To Formant (robust)...", U"djmw", 20111027)
INTRO (U"A command that creates a @@Formant@ object from every selected @@Sound@. ")
ENTRY (U"Settings")
NORMAL (U"The settings for ##Time step (s)#, ##Maximum number of formants#, ##Maximum formant (Hz), "
"##Window length (s)# and ##Pre emphasis from (Hz)# are as in @@Sound: To Formant (burg)...@. "
" The following settings determine aspects of the iterative formant frequency refinement.")
TAG (U"%%Number of std. dev.%,")
DEFINITION (U"determines the number of standard deviation from where selective weighing of samples starts. ")
TAG (U"%%Maximum number of iterations%,")
DEFINITION (U"determines the maximum number of iterations allowed in the refinement step.")
TAG (U"%%Tolerance%,")
DEFINITION (U"detemines another stop ctriterion for the refinement step. If the relative change in variance "
"between successive iterations is less then this value, iteration stops. Iteration stops whenever "
"one of the two defined stop criteria is reached.")
ENTRY (U"Algorithm")
NORMAL (U"First the sound is downsampled to twice the maximum formant frequency. Next the LPC coefficients are determined by the autocorrelation method. Finally, in an iterative procedure as described by @@Lee (1988)@ the formant frequencies and bandwidths are refined by selectively weighting of samples values.")
MAN_END
MAN_BEGIN (U"Sound: LPC analysis", U"djmw", 19970126)
INTRO (U"You can perform this analysis by selecting one or more @Sound objects and "
"choosing the appropriate command to generate an @LPC.")
NORMAL (U"The acronym LPC stands for Linear Predictive Coding.")
NORMAL (U"In the LPC analysis one tries to predict %x__%n_ on the basis of the %p previous samples,")
FORMULA (U"%x\\'p__%n_ = \\su %a__%k_ %x__%%n-k%_")
NORMAL (U"then {%a__1_, %a__2_, ..., %a__%p_} can be chosen to minimize the prediction power %%Q__p_% where")
FORMULA (U"%%Q__p_% = E[ |%x__%n_ - %x\\'p__%n_|^2].")
NORMAL (U"Several different algorithms exist for minimizing %%Q__p_%:")
LIST_ITEM (U"\\bu @@Sound: To LPC (autocorrelation)...|To LPC (autocorrelation)...@")
LIST_ITEM (U"\\bu @@Sound: To LPC (covariance)...|To LPC (covariance)...@")
LIST_ITEM (U"\\bu @@Sound: To LPC (burg)...|To LPC (burg)...@")
LIST_ITEM (U"\\bu @@Sound: To LPC (marple)...|To LPC (marple)...@")
MAN_END
#define Sound_to_LPC_COMMON_HELP(method) \
INTRO (U"With this command you create a new @LPC from every selected @Sound, " \
"using " method " method.") \
ENTRY (U"Warning") \
NORMAL (U"You are advised not to use this command for formant analysis. " \
"For formant analysis, instead use @@Sound: To Formant (burg)...@, " \
"which also works via LPC (linear predictive coding). This is because " \
"##Sound: To Formant (burg)...# lets you specify a maximum frequency, " \
"whereas the ##To LPC# commands automatically use the @@Nyquist frequency@ " \
"as their maximum frequency. If you do use one of the ##To LPC# commands " \
"for formant analysis, you may therefore want to downsample the sound first. " \
"For instance, if you want five formants below 5500 Hz but your Sound has a sampling frequency " \
"of 44100 Hz, you have to downsample the sound to 11000 Hz with the @@Sound: Resample...@ command. " \
"After that, you can use the ##To LPC# commands, with a prediction order of 10 or 11.") \
ENTRY (U"Settings") \
TAG (U"##Prediction order#") \
DEFINITION (U"the number of linear prediction coefficients, also called the %%number of poles%. " \
"Choose this number at least twice as large as the number of spectral peaks that you want " \
"to detect.") \
TAG (U"##Analysis window duration (s)") \
DEFINITION (U"the effective duration of each analysis frame, in seconds.") \
TAG (U"##Time step (s)") \
DEFINITION (U"the time step between two consecutive analysis frames.") \
TAG (U"##Pre-emphasis frequency (Hz)") \
DEFINITION (U"a +6dB / octave filtering will be applied above this frequency. " \
"A pre-emphasis frequency of 48.47 Hz for a signal with a sampling frequency of 10 kHz " \
"approximately corresponds to a value of %a = 0.97 for the filter %y__%n_ = %x__%n_ - %a \\.c %x__%n-1_. " \
"The relation between %a and the pre-emphasis frequency is: " \
"%a = exp (\\--2\\.c%\\pi\\.c%preemphasisFrequency/%samplingFrequency). " \
"If you do not want pre-emphasis, choose a frequency greater than the @@Nyquist frequency@.")
MAN_BEGIN (U"Sound: To LPC (autocorrelation)...", U"David Weenink & Paul Boersma", 20040407)
Sound_to_LPC_COMMON_HELP ("the autocorrelation")
ENTRY (U"Algorithm")
NORMAL (U"The autocorrelation algorithm is decribed in @@Markel & Gray (1976)@.")
MAN_END
MAN_BEGIN (U"Sound: To LPC (covariance)...", U"David Weenink & Paul Boersma", 20040407)
Sound_to_LPC_COMMON_HELP ("the covariance")
ENTRY (U"Algorithm")
NORMAL (U"The covariance algorithm is decribed in @@Markel & Gray (1976)@.")
MAN_END
MAN_BEGIN (U"Sound: To LPC (marple)...", U"djmw", 19970126)
Sound_to_LPC_COMMON_HELP ("Marple's")
TAG (U"##Tolerance 1")
DEFINITION (U"stop the iteration when %E(%m) / %E(0) < %%Tolerance 1%, where %E(%m) is the "
"prediction error for order %m.")
TAG (U"##Tolerance 2")
DEFINITION (U"stop the iteration when (%E(%m) - %E(%m-1)) / %E(%m-1) < %%Tolerance 2.")
ENTRY (U"Algorithm")
NORMAL (U"The algorithm is described in @@Marple (1980)@.")
MAN_END
MAN_BEGIN (U"Sound: To LPC (burg)...", U"David Weenink & Paul Boersma", 20040407)
Sound_to_LPC_COMMON_HELP ("Burg's")
ENTRY (U"Algorithm")
NORMAL (U"Burg's algorithm is described in @@Anderson (1978)@")
MAN_END
MAN_BEGIN (U"Sound: To MFCC...", U"djmw", 20141022)
INTRO (U"A command that creates a @MFCC object from every selected @Sound "
"object.")
NORMAL (U"The analysis proceeds in two steps:")
LIST_ITEM (U"1. We perform a spectrum analysis on a mel frequency scale "
"(see @@Sound: To MelSpectrogram...@ for details).")
LIST_ITEM (U"2. We convert the melspectrogram values to mel frequency cepstral "
"coefficients (see @@MelSpectrogram: To MFCC...@ for details).")
MAN_END
MAN_BEGIN (U"Spectrum: To PowerCepstrum", U"djmw", 20160909)
INTRO (U"A command to create a @PowerCepstrum from every selected @Spectrum.")
ENTRY (U"Mathematical procedure")
MAN_END
MAN_BEGIN (U"VocalTractTier", U"djmw", 20120423)
INTRO (U"One of the @@types of objects@ in Praat. A VocalTractTier objects contains a number of (%time, %VocalTract) points, where a @@VocalTract@ represents the area function of the vocal tract expressed as m^^2^, running from the glottis to the lips.")
MAN_END
MAN_BEGIN (U"theil regression", U"djmw", 20130710)
NORMAL (U"a robust linear regression method, first proposed by @@Theil (1950)@. The slope of the regression line is estimated as "
"the median of all pairwise slopes between each pair of points in the data set. Because this number of pairs increases quadratically "
"with the number of data points, we have implemented a somewhat less computationally intensive procedure, the %%incomplete% theil regression. In the incomplete method we first split the data set of %N data points (%x__%i_, %y__%i_), %i = 1..%N, in two equal sets "
"of size %N/2 and then calculate %N/2 slopes as ")
FORMULA (U"%m__%i_ = (%y__%N/2+%i_ - %y__%i_) / (%x__%N/2+%i_ - %x__%i_), for %i = 1..%N/2.")
NORMAL (U"The regression slope %m is calculated as the median of these %N/2 values %m__%i_.")
NORMAL (U"Given the slope %m, the offset %b is calculated as the median of the %N values %b__%i_= %y__%i_ - %m\\.c%x__%i_.")
NORMAL (U"The theil regression has a breakdown point of 29.3\\% , which means that it can tolerate arbitrary corruption of up to 29.3% of the input data-points without degradation of its accuracy")
MAN_END
MAN_BEGIN (U"Anderson (1978)", U"djmw", 20030701)
NORMAL (U"N. Anderson (1978): \"On the calculation of filter coefficients for "
"maximum entropy spectral analysis.\" In Childers: %%Modern Spectrum Analysis%, "
"IEEE Press: 252\\--255.")
MAN_END
MAN_BEGIN (U"Hillenbrand et al. (1994)", U"djmw", 20121017)
NORMAL (U"J. Hillenbrand, R.A. Cleveland & R.L. Erickson (1994): \"Acoustic correlates of breathy vocal quality\", %%Journal of speech and hearing research% #37: 769\\--778.")
MAN_END
MAN_BEGIN (U"Hillenbrand & Houde (1996)", U"djmw", 20121203)
NORMAL (U"J. Hillenbrand & R.A. Houde (1996): \"Acoustic correlates of breathy vocal quality: Dysphonic voices and continuous speech\", %%Journal of speech and hearing research% #39: 311\\--321.")
MAN_END
MAN_BEGIN (U"Lee (1988)", U"djmw", 20111027)
NORMAL (U"C.-H. Lee (1988): \"On Robust Linear Prediction of Speech.\", %%IEEE Trans. on ASSP% #36: 642\\--649.")
MAN_END
MAN_BEGIN (U"Markel & Gray (1976)", U"djmw", 19980114)
NORMAL (U"J.D. Markel & A.H. Gray, Jr. (1976): %%Linear Prediction of Speech.% "
"Springer Verlag, Berlin.")
MAN_END
MAN_BEGIN (U"Marple (1980)", U"djmw", 19980114)
NORMAL (U"L. Marple (1980): \"A new autoregressive spectrum analysis algorithm.\" "
"%%IEEE Trans. on ASSP% #28, 441\\--454.")
MAN_END
MAN_BEGIN (U"Rothweiler (1999)", U"djmw", 20160507)
NORMAL (U"J. Rothweiler (1999): \"On Polynomial Reduction in the Computation of LSP Frequencies.\" "
"%%IEEE Trans. on ASSP% #7, 592\\--594.")
MAN_END
MAN_BEGIN (U"Theil (1950)", U"djmw", 20121118)
NORMAL (U"H. Theil (1950): \"A rank-invariant method of linear and polynomial regression analysis\", "
"%%Proceedings of Koninklijke Nederlandse Akademie van Wetenschappen% ##A.53#: 1397\\--1412.")
MAN_END
MAN_BEGIN (U"Wakita (1977)", U"djmw", 19980114)
NORMAL (U"H. Wakita (1977): \"Normalization of vowels by vocal-tract "
"length and its application to vowel identification.\" %%IEEE Trans. on ASSP% "
"#25: 183\\--192.")
MAN_END
}
/*
BUGS:
19980217 djmw LPC_and_Sound_filter ilast was not always defined.
19980322 djmw Sound_into_LPC_Frame_auto did not return (nCoefficients == 0) when (r[1] == 0).
*/
/* End of file manual_LPC.cpp */
praat-6.0.23/LPC/praat_LPC_init.cpp 0000664 0000000 0000000 00000141523 13023464014 0016666 0 ustar 00root root 0000000 0000000 /* praat_LPC_init.cpp
*
* Copyright (C) 1994-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20030613 Latest modification
djmw 20040414 Forms texts.
djmw 20060428 Latest modification
djmw 20061218 Changed to Melder_information format.
djmw 20070902 Melder_error<1...>
djmw 20071011 REQUIRE requires L"".
djmw 20080313 Cepstrum_formula
djmw 20100212 Analysis window length is now "Window length"
*/
#include
#include "Cepstrumc.h"
#include "Cepstrogram.h"
#include "Cepstrum_and_Spectrum.h"
#include "DTW.h"
#include "FilterBank.h"
#include "Formant_extensions.h"
#include "LPC.h"
#include "MFCC.h"
#include "LFCC.h"
#include "LPC_and_Cepstrumc.h"
#include "LPC_and_Formant.h"
#include "LPC_and_LFCC.h"
#include "LPC_and_LineSpectralFrequencies.h"
#include "LPC_and_Polynomial.h"
#include "LPC_and_Tube.h"
#include "LPC_to_Spectrogram.h"
#include "LPC_to_Spectrum.h"
#include "NUM2.h"
#include "Sound_and_LPC.h"
#include "Sound_and_LPC_robust.h"
#include "Sound_and_Cepstrum.h"
#include "Sound_to_MFCC.h"
#include "VocalTractTier.h"
#include "praat_TimeFunction.h"
#include "praat_Matrix.h"
#define praat_Quefrency_RANGE(fromQuefrency,toQuefrency) \
REALVAR (fromQuefrency, U"left Quefrency range (s)", U"0.0") \
REALVAR (toQuefrency, U"right Quefrency range (s)", U"0.0 (= all)")
static const char32 *DRAW_BUTTON = U"Draw -";
static const char32 *QUERY_BUTTON = U"Query -";
static const char32 *MODIFY_BUTTON = U"Modify -";
void praat_CC_init (ClassInfo klas);
void praat_TimeFrameSampled_query_init (ClassInfo klas);
/********************** Cepstrum ****************************************/
DIRECT (NEW_Cepstrum_downto_PowerCepstrum) {
CONVERT_EACH (Cepstrum)
autoPowerCepstrum result = Cepstrum_downto_PowerCepstrum (me);
CONVERT_EACH_END (my name)
}
DIRECT (HELP_PowerCepstrum_help) {
HELP (U"PowerCepstrum")
}
FORM (GRAPHICS_Cepstrum_drawLinear, U"Cepstrum: Draw linear", U"Cepstrum: Draw (linear)...") {
praat_Quefrency_RANGE(fromQuefrency,toQuefrency)
REALVAR (ymin, U"Minimum", U"0.0")
REALVAR (ymax, U"Maximum", U"0.0")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (Cepstrum)
Cepstrum_drawLinear (me, GRAPHICS, fromQuefrency, toQuefrency, ymin, ymax, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_PowerCepstrum_draw, U"PowerCepstrum: Draw", U"PowerCepstrum: Draw...") {
praat_Quefrency_RANGE(fromQuefrency,toQuefrency)
REALVAR (ymin, U"Minimum (dB)", U"0.0")
REALVAR (ymax, U"Maximum (dB)", U"0.0")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (PowerCepstrum)
PowerCepstrum_draw (me, GRAPHICS, fromQuefrency, toQuefrency, ymin, ymax, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_PowerCepstrum_drawTiltLine, U"PowerCepstrum: Draw tilt line", U"PowerCepstrum: Draw tilt line...") {
praat_Quefrency_RANGE(fromQuefrency,toQuefrency)
REALVAR (fromAmplitude_dB, U"left Amplitude range (dB)", U"0.0")
REALVAR (toAmplitude_dB, U"right Amplitude range (dB)", U"0.0")
LABEL (U"", U"Parameters for the tilt line fit")
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 1)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
GRAPHICS_EACH (PowerCepstrum)
PowerCepstrum_drawTiltLine (me, GRAPHICS, fromQuefrency, toQuefrency,fromAmplitude_dB,toAmplitude_dB, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod);
GRAPHICS_EACH_END
}
FORM (MODIFY_PowerCepstrum_formula, U"PowerCepstrum: Formula...", U"PowerCepstrum: Formula...") {
LABEL (U"label", U"y := y1; for row := 1 to nrow do { x := x1; "
"for col := 1 to ncol do { self [row, col] := `formula' ; x := x + dx } y := y + dy }")
TEXTVAR (formula, U"formula", U"self")
OK
DO
MODIFY_EACH (PowerCepstrum)
Matrix_formula (me, formula, interpreter, nullptr);
MODIFY_EACH_END
}
FORM (REAL_PowerCepstrum_getPeak, U"PowerCepstrum: Get peak", nullptr) {
REALVAR (fromPitch, U"left Search peak in pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Search peak in pitch range (Hz)", U"333.3")
RADIOVAR (interpolationMethod, U"Interpolation", 2)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
OK
DO
NUMBER_ONE (PowerCepstrum)
double result;
PowerCepstrum_getMaximumAndQuefrency (me, fromPitch, toPitch, interpolationMethod - 1, & result, nullptr);
NUMBER_ONE_END (U" dB")
}
FORM (REAL_PowerCepstrum_getQuefrencyOfPeak, U"PowerCepstrum: Get quefrency of peak", nullptr) {
REALVAR (fromPitch, U"left Search peak in pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Search peak in pitch range (Hz)", U"333.3")
RADIOVAR (interpolationMethod, U"Interpolation", 2)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
OK
DO
NUMBER_ONE (PowerCepstrum)
double result, quefrency;
PowerCepstrum_getMaximumAndQuefrency (me, fromPitch, toPitch, interpolationMethod - 1, & quefrency, & result);
double f = 1.0 / quefrency;
NUMBER_ONE_END (U" s (f =", f, U" Hz)")
}
FORM (REAL_PowerCepstrum_getRNR, U"PowerCepstrum: Get rhamonics to noise ration", nullptr) {
REALVAR (fromPitch, U"left Pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Pitch range (Hz)", U"333.3")
POSITIVEVAR (fractionalWIdth, U"Fractional width (0-1)", U"0.05")
OK
DO
NUMBER_ONE (PowerCepstrum)
double result = PowerCepstrum_getRNR (me, fromPitch, toPitch, fractionalWIdth);
NUMBER_ONE_END (U" (rnr)")
}
FORM (REAL_PowerCepstrum_getPeakProminence_hillenbrand, U"PowerCepstrum: Get peak prominence (hillenbrand)", U"PowerCepstrum: Get peak prominence (hillenbrand)...") {
REALVAR (fromPitch, U"left Search peak in pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Search peak in pitch range (Hz)", U"333.3")
OK
DO
NUMBER_ONE (PowerCepstrum)
double qpeak, result = PowerCepstrum_getPeakProminence_hillenbrand (me, fromPitch, toPitch, & qpeak);
NUMBER_ONE_END (U" dB; quefrency=", qpeak, U" s (f=", 1.0 / qpeak, U" Hz).")
}
FORM (REAL_PowerCepstrum_getTiltLineSlope, U"PowerCepstrum: Get tilt line slope", nullptr) {
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 1)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
NUMBER_ONE (PowerCepstrum)
double result;
PowerCepstrum_fitTiltLine (me, fromQuefrency_tiltLine, toQuefrency_tiltLine, & result, nullptr, lineType, fitMethod);
NUMBER_ONE_END (U" dB / ", lineType == 1 ? U"s" : U"ln (s)");
}
FORM (REAL_PowerCepstrum_getTiltLineIntercept, U"PowerCepstrum: Get tilt line intercept", nullptr) {
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 1)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
NUMBER_ONE (PowerCepstrum)
double result;
PowerCepstrum_fitTiltLine (me, fromQuefrency_tiltLine, toQuefrency_tiltLine, nullptr, & result, lineType, fitMethod);
NUMBER_ONE_END (U" dB")
}
FORM (REAL_PowerCepstrum_getPeakProminence, U"PowerCepstrum: Get peak prominence", U"PowerCepstrum: Get peak prominence...") {
REALVAR (fromPitch, U"left Search peak in pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Search peak in pitch range (Hz)", U"333.3")
RADIOVAR (interpolationMethod, U"Interpolation", 2)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 1)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
NUMBER_ONE (PowerCepstrum)
double qpeak, result = PowerCepstrum_getPeakProminence (me, fromPitch, toPitch, interpolationMethod - 1, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod, & qpeak);
NUMBER_ONE_END (U" dB; quefrency=", qpeak, U" s (f=", 1.0 / qpeak, U" Hz).");
}
FORM (MODIFY_PowerCepstrum_subtractTilt_inline, U"PowerCepstrum: Subtract tilt (in-line)", nullptr) {
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 1)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
MODIFY_EACH (PowerCepstrum)
PowerCepstrum_subtractTilt_inline (me, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod);
MODIFY_EACH_END
}
FORM (MODIFY_PowerCepstrum_smooth_inline, U"PowerCepstrum: Smooth (in-line)", nullptr) {
REALVAR (quefrencySmoothingWindowDuration, U"Quefrency averaging window (s)", U"0.0005")
NATURALVAR (numberOfIterations, U"Number of iterations", U"1");
OK
DO
MODIFY_EACH (PowerCepstrum)
PowerCepstrum_smooth_inline (me, quefrencySmoothingWindowDuration, numberOfIterations);
MODIFY_EACH_END
}
FORM (NEW_PowerCepstrum_smooth, U"PowerCepstrum: Smooth", nullptr) {
REALVAR (quefrencySmoothingWindowDuration, U"Quefrency averaging window (s)", U"0.0005")
NATURALVAR (numberOfIterations, U"Number of iterations", U"1");
OK
DO
CONVERT_EACH (PowerCepstrum)
autoPowerCepstrum result = PowerCepstrum_smooth (me, quefrencySmoothingWindowDuration, numberOfIterations);
CONVERT_EACH_END (my name, U"_smooth")
}
FORM (NEW_PowerCepstrum_subtractTilt, U"PowerCepstrum: Subtract tilt", nullptr) {
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 1)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
CONVERT_EACH (PowerCepstrum)
autoPowerCepstrum result = PowerCepstrum_subtractTilt (me, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod);
CONVERT_EACH_END (my name, U"_minusTilt")
}
DIRECT (NEW_Cepstrum_to_Spectrum) {
CONVERT_EACH (Cepstrum)
autoSpectrum result = Cepstrum_to_Spectrum (me);
CONVERT_EACH_END (my name)
}
DIRECT (NEW_PowerCepstrum_to_Matrix) {
CONVERT_EACH (PowerCepstrum)
autoMatrix result = PowerCepstrum_to_Matrix (me);
CONVERT_EACH_END (my name)
}
/********************** Cepstrogram ****************************************/
DIRECT (HELP_PowerCepstrogram_help) {
HELP (U"PowerCepstrogram")
}
FORM (GRAPHICS_old_PowerCepstrogram_paint, U"PowerCepstrogram: Paint", nullptr) {
praat_TimeFunction_RANGE(fromTime,toTime)
praat_Quefrency_RANGE(fromQuefrency,toQuefrency)
REALVAR (minimum_dB, U"Minimum (dB)", U"0.0")
REALVAR (maximum_dB, U"Maximum (dB)", U"0.0")
BOOLEANVAR (garnish, U"Garnish", true);
OK
DO
GRAPHICS_EACH (PowerCepstrogram)
PowerCepstrogram_paint (me, GRAPHICS, fromTime, toTime, fromQuefrency, toQuefrency, maximum_dB, false, maximum_dB - minimum_dB, 0.0, garnish);
GRAPHICS_EACH_END
}
FORM (GRAPHICS_PowerCepstrogram_paint, U"PowerCepstrogram: Paint", U"PowerCepstrogram: Paint...") {
praat_TimeFunction_RANGE(fromTime,toTime)
praat_Quefrency_RANGE(fromQuefrency,toQuefrency)
REALVAR (maximum_dB, U"Maximum (dB)", U"80.0")
BOOLEANVAR (autoscaling, U"Autoscaling", false);
REALVAR (dynamicRange_dB, U"Dynamic range (dB)", U"30.0");
REALVAR (compression, U"Dynamic compression (0-1)", U"0.0");
BOOLEANVAR (garnish, U"Garnish", true);
OK
DO_ALTERNATIVE (GRAPHICS_old_PowerCepstrogram_paint)
GRAPHICS_EACH (PowerCepstrogram)
PowerCepstrogram_paint (me, GRAPHICS, fromTime, toTime, fromQuefrency, toQuefrency, maximum_dB, autoscaling, dynamicRange_dB, compression, garnish);
GRAPHICS_EACH_END
}
FORM (NEW_PowerCepstrogram_smooth, U"PowerCepstrogram: Smooth", U"PowerCepstrogram: Smooth...") {
REALVAR (smoothingWindowDuration, U"Time averaging window (s)", U"0.02")
REALVAR (quefrencySmoothingWindowDuration, U"Quefrency averaging window (s)", U"0.0005")
OK
DO
CONVERT_EACH (PowerCepstrogram)
autoPowerCepstrogram result = PowerCepstrogram_smooth (me, smoothingWindowDuration, quefrencySmoothingWindowDuration);
CONVERT_EACH_END (my name, U"_smoothed")
}
DIRECT (REAL_PowerCepstrogram_getStartQuefrency) {
NUMBER_ONE (PowerCepstrogram)
double result = my ymin;
NUMBER_ONE_END (U" (s)")
}
DIRECT (REAL_PowerCepstrogram_getEndQuefrency) {
NUMBER_ONE (PowerCepstrogram)
double result = my ymax;
NUMBER_ONE_END (U" (s)")
}
DIRECT (INTEGER_PowerCepstrogram_getNumberOfQuefrencyBins) {
INTEGER_ONE (PowerCepstrogram)
long result = my ny;
INTEGER_ONE_END (U" quefrency bins")
}
DIRECT (REAL_PowerCepstrogram_getQuefrencyStep) {
NUMBER_ONE (PowerCepstrogram)
double result = my dy;
NUMBER_ONE_END (U" s (quefrency step)")
}
FORM (NEW_PowerCepstrogram_subtractTilt, U"PowerCepstrogram: Subtract tilt", nullptr) {
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 2)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
CONVERT_EACH (PowerCepstrogram)
autoPowerCepstrogram result = PowerCepstrogram_subtractTilt (me, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod);
CONVERT_EACH_END (my name, U"_minusTilt")
}
FORM (MODIFY_PowerCepstrogram_subtractTilt_inline, U"PowerCepstrogram: Subtract tilt (in-line)", nullptr) {
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 2)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
MODIFY_EACH (PowerCepstrogram)
PowerCepstrogram_subtractTilt_inline (me, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod);
MODIFY_EACH_END
}
FORM (REAL_PowerCepstrogram_getCPPS_hillenbrand, U"PowerCepstrogram: Get CPPS", nullptr) {
LABEL (U"", U"Smoothing:")
BOOLEANVAR (subtractTiltBeforeSmoothing, U"Subtract tilt before smoothing", true)
REALVAR (smoothinWindowDuration, U"Time averaging window (s)", U"0.001")
REALVAR (quefrencySmoothinWindowDuration, U"Quefrency averaging window (s)", U"0.00005")
LABEL (U"", U"Peak search:")
REALVAR (fromPitch, U"left Peak search pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Peak search pitch range (Hz)", U"330.0")
OK
DO
NUMBER_ONE (PowerCepstrogram)
double result = PowerCepstrogram_getCPPS_hillenbrand (me, subtractTiltBeforeSmoothing, smoothinWindowDuration, quefrencySmoothinWindowDuration, fromPitch, toPitch);
NUMBER_ONE_END (U" dB")
}
FORM (REAL_PowerCepstrogram_getCPPS, U"PowerCepstrogram: Get CPPS", nullptr) {
LABEL (U"", U"Smoothing:")
BOOLEANVAR (subtractTiltBeforeSmoothing, U"Subtract tilt before smoothing", true)
REALVAR (smoothingWindowDuration, U"Time averaging window (s)", U"0.02")
REALVAR (quefrencySmoothingWindowDuration, U"Quefrency averaging window (s)", U"0.0005")
LABEL (U"", U"Peak search:")
REALVAR (fromPitch, U"left Peak search pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Peak search pitch range (Hz)", U"330.0")
POSITIVEVAR (tolerance, U"Tolerance (0-1)", U"0.05")
RADIOVAR (interpolationMethod, U"Interpolation", 2)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
LABEL (U"", U"Tilt line:")
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 2)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
NUMBER_ONE (PowerCepstrogram)
double result = PowerCepstrogram_getCPPS (me, subtractTiltBeforeSmoothing, smoothingWindowDuration, quefrencySmoothingWindowDuration, fromPitch, toPitch, tolerance, interpolationMethod - 1, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod);
NUMBER_ONE_END (U" dB");
}
FORM (MODIFY_PowerCepstrogram_formula, U"PowerCepstrogram: Formula", nullptr) {
LABEL (U"label", U"Do for all times and quefrencies:")
LABEL (U"label", U" `x' is the time in seconds")
LABEL (U"label", U" `y' is the quefrency in seconds")
LABEL (U"label", U" `self' is the current value")
LABEL (U"label", U" Replace all values with:")
TEXTVAR (formula, U"formula", U"sqrt(self)")
OK
DO
MODIFY_EACH_WEAK (PowerCepstrogram)
Matrix_formula (me, formula, interpreter, nullptr);
MODIFY_EACH_WEAK_END
}
FORM (NEW_PowerCepstrogram_to_PowerCepstrum_slice, U"PowerCepstrogram: To PowerCepstrum (slice)", nullptr) {
REALVAR (time, U"Time (s)", U"0.1")
OK
DO
CONVERT_EACH (PowerCepstrogram)
autoPowerCepstrum result = PowerCepstrogram_to_PowerCepstrum_slice (me, time);
CONVERT_EACH_END (my name, NUMstring_timeNoDot (time));
}
FORM (NEW_PowerCepstrogram_to_Table_cpp, U"PowerCepstrogram: To Table (peak prominence)", U"PowerCepstrogram: To Table (peak prominence)...") {
REALVAR (fromPitch, U"left Peak search pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Peak search pitch range (Hz)", U"330.0")
POSITIVEVAR (tolerance, U"Tolerance (0-1)", U"0.05")
RADIOVAR (interpolationMethod, U"Interpolation", 2)
RADIOBUTTON (U"None")
RADIOBUTTON (U"Parabolic")
RADIOBUTTON (U"Cubic")
RADIOBUTTON (U"Sinc70")
REALVAR (fromQuefrency_tiltLine, U"left Tilt line quefrency range (s)", U"0.001")
REALVAR (toQuefrency_tiltLine, U"right Tilt line quefrency range (s)", U"0.0 (= end)")
OPTIONMENUVAR (lineType, U"Line type", 2)
OPTION (U"Straight")
OPTION (U"Exponential decay")
OPTIONMENUVAR (fitMethod, U"Fit method", 2)
OPTION (U"Least squares")
OPTION (U"Robust")
OK
DO
CONVERT_EACH (PowerCepstrogram)
autoTable result = PowerCepstrogram_to_Table_cpp (me, fromPitch, toPitch, tolerance, interpolationMethod - 1, fromQuefrency_tiltLine, toQuefrency_tiltLine, lineType, fitMethod);
CONVERT_EACH_END (my name, U"_cpp");
}
FORM (NEW_PowerCepstrogram_to_Table_hillenbrand, U"PowerCepstrogram: To Table (hillenbrand)", U"PowerCepstrogram: To Table (peak prominence...") {
REALVAR (fromPitch, U"left Peak search pitch range (Hz)", U"60.0")
REALVAR (toPitch, U"right Peak search pitch range (Hz)", U"330.0")
OK
DO
CONVERT_EACH (PowerCepstrogram)
autoTable result = PowerCepstrogram_to_Table_hillenbrand (me,fromPitch, toPitch);
CONVERT_EACH_END (my name, U"_cpp")
}
DIRECT (NEW_PowerCepstrogram_to_Matrix) {
CONVERT_EACH (PowerCepstrogram)
autoMatrix result = PowerCepstrogram_to_Matrix (me);
CONVERT_EACH_END (my name)
}
/********************** Cepstrumc ****************************************/
DIRECT (NEW_Cepstrumc_to_LPC) {
CONVERT_EACH (Cepstrumc)
autoLPC result = Cepstrumc_to_LPC (me);
CONVERT_EACH_END (my name)
}
FORM (NEW1_Cepstrumc_to_DTW, U"Cepstrumc: To DTW", U"Cepstrumc: To DTW...") {
LABEL (U"", U"Distance calculation between Cepstra")
REALVAR (cepstralWeight, U"Cepstral weight", U"1.0")
REALVAR (logEnergyWeight, U"Log energy weight", U"0.0")
REALVAR (regressionWeight, U"Regression weight", U"0.0")
REALVAR (regressionLogEnergyWeight, U"Regression weight log energy", U"0.0")
REALVAR (windowDuration, U"Window for regression coefficients (seconds)", U"0.056")
LABEL (U"", U"Boundary conditions for time warp")
BOOLEANVAR (matchBeginPositions, U"Match begin positions", false)
BOOLEANVAR (matchEndPositions, U"Match end positions", false)
RADIOVAR (slopeConstraintType, U"Slope constraints", 1)
RADIOBUTTON (U"no restriction")
RADIOBUTTON (U"1/3 < slope < 3")
RADIOBUTTON (U"1/2 < slope < 2")
RADIOBUTTON (U"2/3 < slope < 3/2")
OK
DO
CONVERT_COUPLE (Cepstrumc)
autoDTW result = Cepstrumc_to_DTW (me, you, cepstralWeight, logEnergyWeight, regressionWeight, regressionLogEnergyWeight, windowDuration, matchBeginPositions, matchEndPositions, slopeConstraintType);
CONVERT_COUPLE_END (my name, U"_", your name)
}
DIRECT (NEW_Cepstrumc_to_Matrix) {
CONVERT_EACH (Cepstrumc)
autoMatrix result = Cepstrumc_to_Matrix (me);
CONVERT_EACH_END (my name)
}
/******************** Formant ********************************************/
FORM (NEW_Formant_to_LPC, U"Formant: To LPC", nullptr) {
POSITIVEVAR (samplingFrequency, U"Sampling frequency (Hz)", U"16000.0")
OK
DO
CONVERT_EACH (Formant)
autoLPC result = Formant_to_LPC (me, 1.0 / samplingFrequency);
CONVERT_EACH_END (my name)
}
FORM (MODIFY_Formant_formula, U"Formant: Formula", nullptr) {
praat_TimeFunction_RANGE(fromTime,toTime)
NATURALVAR (fromFormant, U"left Formant range", U"1")
NATURALVAR (toFormant, U"right Formant range", U"5")
LABEL (U"", U"Formant frequencies in odd numbered rows")
LABEL (U"", U"Formant bandwidths in even numbered rows")
SENTENCEVAR (formula, U"Formula", U"if row mod 2 = 1 and self[row,col]/self[row+1,col] < 5 then 0 else self fi")
OK
DO
MODIFY_EACH_WEAK (Formant)
Formant_formula (me, fromTime, toTime, fromFormant, toFormant, interpreter, formula);
MODIFY_EACH_WEAK_END
}
/******************** Formant & Spectrogram ************************************/
FORM (NEW1_Formant_and_Spectrogram_to_IntensityTier, U"Formant & Spectrogram: To IntensityTier", U"Formant & Spectrogram: To IntensityTier...") {
NATURALVAR (formantNumber, U"Formant number", U"1")
OK
DO
CONVERT_TWO (Formant, Spectrogram)
autoIntensityTier result = Formant_and_Spectrogram_to_IntensityTier (me, you, formantNumber);
CONVERT_TWO_END (my name, U"_", formantNumber)
}
/********************LFCC ********************************************/
DIRECT (HELP_LFCC_help) {
HELP (U"LFCC")
}
FORM (NEW_LFCC_to_LPC, U"LFCC: To LPC", U"LFCC: To LPC...") {
INTEGERVAR (numberOfCoefficients, U"Number of coefficients", U"0")
OK
DO
REQUIRE (numberOfCoefficients >= 0, U"Number of coefficients must be greater or equal zero.")
CONVERT_EACH (LFCC)
autoLPC result = LFCC_to_LPC (me, numberOfCoefficients);
CONVERT_EACH_END (my name);
}
/********************LineSpectralFrequencies ********************************************/
DIRECT (HELP_LineSpectralFrequencies_help) {
HELP (U"LineSpectralFrequencies")
}
FORM (GRAPHICS_LineSpectralFrequencies_drawFrequencies, U"LineSpectralFrequencies: Draw frequencies", nullptr) {
praat_TimeFunction_RANGE(fromTime,toTime)
REALVAR (fromFrequency, U"left Frequency range (Hz)", U"0.0")
REALVAR (toFrequency, U"right Frequency range (Hz)", U"5000.0")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (LineSpectralFrequencies)
LineSpectralFrequencies_drawFrequencies (me, GRAPHICS, fromTime, toTime, fromFrequency, toFrequency, garnish);
GRAPHICS_EACH_END
}
DIRECT (NEW_LineSpectralFrequencies_to_LPC) {
CONVERT_EACH (LineSpectralFrequencies)
autoLPC result = LineSpectralFrequencies_to_LPC (me);
CONVERT_EACH_END (my name);
}
/********************LPC ********************************************/
DIRECT (HELP_LPC_help) {
HELP (U"LPC")
}
FORM (GRAPHICS_LPC_drawGain, U"LPC: Draw gain", U"LPC: Draw gain...") {
praat_TimeFunction_RANGE(fromTime,toTime)
REALVAR (minimumGain, U"Minimum gain", U"0.0")
REALVAR (maximumGain, U"Maximum gain", U"0.0")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (LPC)
LPC_drawGain (me, GRAPHICS, fromTime, toTime, minimumGain, maximumGain, garnish);
GRAPHICS_EACH_END
}
DIRECT (REAL_LPC_getSamplingInterval) {
NUMBER_ONE (LPC)
double result = my samplingPeriod;
NUMBER_ONE_END (U" s");
}
FORM (INTEGER_LPC_getNumberOfCoefficients, U"LPC: Get number of coefficients", U"LPC: Get number of coefficients...") {
NATURALVAR (frameNumber, U"Frame number", U"1")
OK
DO
INTEGER_ONE (LPC)
REQUIRE (frameNumber <= my nx, Melder_cat (U"Frame number is too large.\n\nPlease choose a number between 1 and ", my nx))
long result = my d_frames[frameNumber].nCoefficients;
INTEGER_ONE_END (U" coefficients")
}
FORM (GRAPHICS_LPC_drawPoles, U"LPC: Draw poles", U"LPC: Draw poles...") {
REALVAR (time, U"Time (seconds)", U"0.0")
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (LPC)
LPC_drawPoles (me, GRAPHICS, time, garnish);
GRAPHICS_EACH_END
}
DIRECT (NEW_LPC_to_Formant) {
CONVERT_EACH (LPC)
autoFormant result = LPC_to_Formant (me, 50.0);
CONVERT_EACH_END (my name)
}
DIRECT (NEW_LPC_to_Formant_keep_all) {
CONVERT_EACH (LPC)
autoFormant result = LPC_to_Formant (me, 0.0);
CONVERT_EACH_END (my name)
}
FORM (NEW_LPC_to_LFCC, U"LPC: To LFCC", U"LPC: To LFCC...") {
INTEGERVAR (numberOfCoefficients, U"Number of coefficients", U"0")
OK
DO
REQUIRE (numberOfCoefficients >= 0, U"The number of coefficients should be greater than or equal to zero.")
CONVERT_EACH (LPC)
autoLFCC result = LPC_to_LFCC (me, numberOfCoefficients);
CONVERT_EACH_END (my name)
}
FORM (NEW_LPC_to_LineSpectralFrequencies, U"LPC: To LineSpectralFrequencies", nullptr) {
REALVAR (gridSize, U"Grid size", U"0.0")
OK
DO
CONVERT_EACH (LPC)
autoLineSpectralFrequencies result = LPC_to_LineSpectralFrequencies (me, gridSize);
CONVERT_EACH_END (my name)
}
FORM (NEW_LPC_to_Polynomial, U"LPC: To Polynomial", U"LPC: To Polynomial (slice)...") {
REALVAR (time, U"Time (s)", U"0.0")
OK
DO
CONVERT_EACH (LPC)
autoPolynomial result = LPC_to_Polynomial (me, time);
CONVERT_EACH_END (my name, NUMstring_timeNoDot (time))
}
FORM (NEW_LPC_to_Spectrum, U"LPC: To Spectrum", U"LPC: To Spectrum (slice)...") {
REALVAR (time, U"Time (seconds)", U"0.0")
REALVAR (minimumFrequencyResolution, U"Minimum frequency resolution (Hz)", U"20.0")
REALVAR (bandwidthReduction, U"Bandwidth reduction (Hz)", U"0.0")
REALVAR (deemphasisFrequency, U"De-emphasis frequency (Hz)", U"50.0")
OK
DO
CONVERT_EACH (LPC)
autoSpectrum result = LPC_to_Spectrum (me, time, minimumFrequencyResolution, bandwidthReduction, deemphasisFrequency);
CONVERT_EACH_END (my name, NUMstring_timeNoDot (time))
}
FORM (NEW_LPC_to_Spectrogram, U"LPC: To Spectrogram", U"LPC: To Spectrogram...") {
REALVAR (minimumFrequencyResolution, U"Minimum frequency resolution (Hz)", U"20.0")
REALVAR (bandwidthReduction, U"Bandwidth reduction (Hz)", U"0.0")
REALVAR (deemphasisFrequency, U"De-emphasis frequency (Hz)", U"50.0")
OK
DO
CONVERT_EACH (LPC)
autoSpectrogram result = LPC_to_Spectrogram (me, minimumFrequencyResolution, bandwidthReduction, deemphasisFrequency);
CONVERT_EACH_END (my name)
}
FORM (NEW_LPC_to_VocalTract_special, U"LPC: To VocalTract", U"LPC: To VocalTract (slice, special)...") {
REALVAR (time, U"Time (s)", U"0.0")
REALVAR (glottalDamping, U"Glottal damping", U"0.1")
BOOLEANVAR (radiationDamping, U"Radiation damping", true)
BOOLEANVAR (internalDamping, U"Internal damping", true)
OK
DO
CONVERT_EACH (LPC)
autoVocalTract result = LPC_to_VocalTract (me, time, glottalDamping, radiationDamping, internalDamping);
CONVERT_EACH_END (my name, NUMstring_timeNoDot (time))
}
FORM (NEW_LPC_to_VocalTract, U"LPC: To VocalTract", U"LPC: To VocalTract (slice)...") {
REALVAR (time, U"Time (s)", U"0.0")
POSITIVEVAR (lenght, U"Length (m)", U"0.17")
OK
DO
CONVERT_EACH (LPC)
autoVocalTract result = LPC_to_VocalTract (me, time, lenght);
CONVERT_EACH_END (my name, NUMstring_timeNoDot (time))
}
DIRECT (NEW_LPC_downto_Matrix_lpc) {
CONVERT_EACH (LPC)
autoMatrix result = LPC_downto_Matrix_lpc (me);
CONVERT_EACH_END (my name, U"_lpc")
}
DIRECT (NEW_LPC_downto_Matrix_rc) {
CONVERT_EACH (LPC)
autoMatrix result = LPC_downto_Matrix_rc (me);
CONVERT_EACH_END (my name, U"_rc");
}
DIRECT (NEW_LPC_downto_Matrix_area) {
CONVERT_EACH (LPC)
autoMatrix result = LPC_downto_Matrix_area (me);
CONVERT_EACH_END (my name, U"_area");
}
/********************** Sound *******************************************/
FORM (NEW_Sound_to_PowerCepstrogram, U"Sound: To PowerCepstrogram", U"Sound: To PowerCepstrogram...") {
POSITIVEVAR (pitchFloor, U"Pitch floor (Hz)", U"60.0")
POSITIVEVAR (timeStep,U"Time step (s)", U"0.002")
POSITIVEVAR (maximumFrequency, U"Maximum frequency (Hz)", U"5000.0")
POSITIVEVAR (preEmphasisFrequency, U"Pre-emphasis from (Hz)", U"50")
OK
DO
CONVERT_EACH (Sound)
autoPowerCepstrogram result = Sound_to_PowerCepstrogram (me, pitchFloor, timeStep, maximumFrequency, preEmphasisFrequency);
CONVERT_EACH_END (my name)
}
FORM (NEW_Sound_to_PowerCepstrogram_hillenbrand, U"Sound: To PowerCepstrogram (hillenbrand)", U"Sound: To PowerCepstrogram...") {
POSITIVEVAR (pitchFloor, U"Pitch floor (Hz)", U"60.0")
POSITIVEVAR (timeStep, U"Time step (s)", U"0.002")
OK
DO
CONVERT_EACH (Sound)
autoPowerCepstrogram result = Sound_to_PowerCepstrogram_hillenbrand (me, pitchFloor, timeStep);
CONVERT_EACH_END (my name)
}
FORM (NEW_Sound_to_Formant_robust, U"Sound: To Formant (robust)", U"Sound: To Formant (robust)...") {
REALVAR (timeStep, U"Time step (s)", U"0.0 (= auto)")
POSITIVEVAR (maximumNumberOfFormants, U"Max. number of formants", U"5.0")
REALVAR (maximumFormantFrequency, U"Maximum formant (Hz)", U"5500.0 (= adult female)")
POSITIVEVAR (windowLength, U"Window length (s)", U"0.025")
POSITIVEVAR (preEmphasisFrequency, U"Pre-emphasis from (Hz)", U"50.0")
POSITIVEVAR (numberOfStandardDeviations, U"Number of std. dev.", U"1.5")
NATURALVAR (maximumNumberOfIterations, U"Maximum number of iterations", U"5")
REALVAR (tolerance, U"Tolerance", U"0.000001")
OK
DO
CONVERT_EACH (Sound)
autoFormant result = Sound_to_Formant_robust (me, timeStep, maximumNumberOfFormants, maximumFormantFrequency, windowLength, preEmphasisFrequency, 50.0, numberOfStandardDeviations, maximumNumberOfIterations, tolerance, 1);
CONVERT_EACH_END (my name)
}
static void Sound_to_LPC_addWarning (UiForm dia) {
LABEL (U"", U"Warning 1: for formant analysis, use \"To Formant\" instead.")
LABEL (U"", U"Warning 2: if you do use \"To LPC\", you may want to resample first.")
LABEL (U"", U"Click Help for more details.")
LABEL (U"", U"")
}
FORM (NEW_Sound_to_LPC_auto, U"Sound: To LPC (autocorrelation)", U"Sound: To LPC (autocorrelation)...") {
Sound_to_LPC_addWarning (dia);
NATURALVAR (predictionOrder, U"Prediction order", U"16")
POSITIVEVAR (windowLength, U"Window length (s)", U"0.025")
POSITIVEVAR (timeStep, U"Time step (s)", U"0.005")
REALVAR (preEmphasisFrequency, U"Pre-emphasis frequency (Hz)", U"50.0")
OK
DO
preEmphasisFrequency = preEmphasisFrequency < 0.0 ? 0.0 : preEmphasisFrequency;
CONVERT_EACH (Sound)
autoLPC result = Sound_to_LPC_auto (me, predictionOrder, windowLength, timeStep, preEmphasisFrequency);
CONVERT_EACH_END (my name)
}
FORM (NEW_Sound_to_LPC_covar, U"Sound: To LPC (covariance)", U"Sound: To LPC (covariance)...") {
Sound_to_LPC_addWarning (dia);
NATURALVAR (predictionOrder, U"Prediction order", U"16")
POSITIVEVAR (windowLength, U"Window length (s)", U"0.025")
POSITIVEVAR (timeStep, U"Time step (s)", U"0.005")
REALVAR (preEmphasisFrequency, U"Pre-emphasis frequency (Hz)", U"50.0")
OK
DO
preEmphasisFrequency = preEmphasisFrequency < 0.0 ? 0.0 : preEmphasisFrequency;
CONVERT_EACH (Sound)
autoLPC result = Sound_to_LPC_covar (me, predictionOrder, windowLength, timeStep, preEmphasisFrequency);
CONVERT_EACH_END (my name)
}
FORM (NEW_Sound_to_LPC_burg, U"Sound: To LPC (burg)", U"Sound: To LPC (burg)...") {
Sound_to_LPC_addWarning (dia);
NATURALVAR (predictionOrder, U"Prediction order", U"16")
POSITIVEVAR (windowLength, U"Window length (s)", U"0.025")
POSITIVEVAR (timeStep, U"Time step (s)", U"0.005")
REALVAR (preEmphasisFrequency, U"Pre-emphasis frequency (Hz)", U"50.0")
OK
DO
preEmphasisFrequency = preEmphasisFrequency < 0.0 ? 0.0 : preEmphasisFrequency;
CONVERT_EACH (Sound)
autoLPC result = Sound_to_LPC_burg (me, predictionOrder, windowLength, timeStep, preEmphasisFrequency);
CONVERT_EACH_END (my name)
}
FORM (NEW_Sound_to_LPC_marple, U"Sound: To LPC (marple)", U"Sound: To LPC (marple)...") {
Sound_to_LPC_addWarning (dia);
NATURALVAR (predictionOrder, U"Prediction order", U"16")
POSITIVEVAR (windowLength, U"Window length (s)", U"0.025")
POSITIVEVAR (timeStep, U"Time step (s)", U"0.005")
REALVAR (preEmphasisFrequency, U"Pre-emphasis frequency (Hz)", U"50.0")
POSITIVEVAR (tolerance1, U"Tolerance 1", U"1e-6")
POSITIVEVAR (tolerance2, U"Tolerance 2", U"1e-6")
OK
DO
preEmphasisFrequency = preEmphasisFrequency < 0.0 ? 0.0 : preEmphasisFrequency;
CONVERT_EACH (Sound)
autoLPC result = Sound_to_LPC_marple (me, predictionOrder, windowLength, timeStep, preEmphasisFrequency, tolerance1, tolerance2);
CONVERT_EACH_END (my name)
}
FORM (NEW_Sound_to_MFCC, U"Sound: To MFCC", U"Sound: To MFCC...") {
NATURALVAR (numberOfCoefficients, U"Number of coefficients", U"12")
POSITIVEVAR (windowLength, U"Window length (s)", U"0.015")
POSITIVEVAR (timeStep, U"Time step (s)", U"0.005")
LABEL (U"", U"Filter bank parameters")
POSITIVEVAR (firstFilterFrequency, U"First filter frequency (mel)", U"100.0")
POSITIVEVAR (distancBetweenFilters, U"Distance between filters (mel)", U"100.0")
REALVAR (maximumFrequency, U"Maximum frequency (mel)", U"0.0");
OK
DO
REQUIRE (numberOfCoefficients < 25, U"The number of coefficients should be less than 25.")
CONVERT_EACH (Sound)
autoMFCC result = Sound_to_MFCC (me, numberOfCoefficients, windowLength, timeStep, firstFilterFrequency, maximumFrequency, distancBetweenFilters);
CONVERT_EACH_END (my name)
}
FORM (GRAPHICS_VocalTract_drawSegments, U"VocalTract: Draw segments", nullptr) {
POSITIVEVAR (maximumLength, U"Maximum length (cm)", U"20.0")
POSITIVEVAR (maximumArea, U"Maximum area (cm^2)", U"90.0")
BOOLEANVAR (glottisClosed, U"Closed at glottis", true)
OK
DO
GRAPHICS_EACH (VocalTract)
VocalTract_drawSegments (me, GRAPHICS, maximumLength, maximumArea, glottisClosed);
GRAPHICS_EACH_END
}
DIRECT (REAL_VocalTract_getLength) {
NUMBER_ONE (VocalTract)
double result = my xmax - my xmin;
NUMBER_ONE_END (U" metres")
}
FORM (MODIFY_VocalTract_setLength, U"", nullptr) {
POSITIVEVAR (length, U"New length (m)", U"0.17")
OK
DO
MODIFY_EACH (VocalTract)
VocalTract_setLength (me, length);
MODIFY_EACH_END
}
FORM (NEW_VocalTract_to_VocalTractTier, U"VocalTract: To VocalTractTier", nullptr) {
REALVAR (fromTime, U"Tier start time (s)", U"0.0")
REALVAR (toTime, U"Tier end time (s)", U"1.0")
REALVAR (time, U"Insert at time (s)", U"0.5")
OK
DO
REQUIRE (fromTime < toTime, U"The start time must be before the end time.")
REQUIRE (time >= fromTime && time <= toTime, U"The insert time must be between start and end time.")
CONVERT_EACH (VocalTract)
autoVocalTractTier result = VocalTract_to_VocalTractTier (me, fromTime, toTime, time);
CONVERT_EACH_END (my name)
}
DIRECT (HELP_VocalTractTier_help) {
HELP (U"VocalTractTier")
}
FORM (NEW_VocalTractTier_to_LPC, U"VocalTractTier: To LPC", nullptr) {
POSITIVEVAR (timeStep, U"Time step", U"0.005")
OK
DO
CONVERT_EACH (VocalTractTier)
autoLPC result = VocalTractTier_to_LPC (me, timeStep);
CONVERT_EACH_END (my name)
}
FORM (NEW_VocalTractTier_to_VocalTract, U"", nullptr) {
REALVAR (time, U"Time (s)", U"0.1")
OK
DO
CONVERT_EACH (VocalTractTier)
autoVocalTract result = VocalTractTier_to_VocalTract (me, time);
CONVERT_EACH_END (my name)
}
FORM (MODIFY_VocalTractTier_addVocalTract, U"VocalTractTier: Add VocalTract", nullptr) {
REALVAR (time, U"Time (s)", U"0.1")
OK
DO
MODIFY_FIRST_OF_TWO (VocalTractTier, VocalTract)
VocalTractTier_addVocalTract_copy (me, time, you);
MODIFY_FIRST_OF_TWO_END
}
/******************* LPC & Sound *************************************/
FORM (NEW1_LPC_and_Sound_filter, U"LPC & Sound: Filter", U"LPC & Sound: Filter...") {
BOOLEANVAR (useGain, U"Use LPC gain", false)
OK
DO
CONVERT_TWO (LPC, Sound)
autoSound result = LPC_and_Sound_filter (me , you, useGain);
CONVERT_TWO_END (my name)
}
FORM (NEW1_LPC_and_Sound_filterWithFilterAtTime, U"LPC & Sound: Filter with one filter at time", U"LPC & Sound: Filter with filter at time...") {
OPTIONMENUVAR (channel, U"Channel", 2)
OPTION (U"Both")
OPTION (U"Left")
OPTION (U"Right")
REALVAR (time, U"Use filter at time (s)", U"0.0")
OK
DO
CONVERT_TWO (LPC, Sound)
autoSound result = LPC_and_Sound_filterWithFilterAtTime (me , you, channel - 1, time);
CONVERT_TWO_END (my name)
}
DIRECT (NEW1_LPC_and_Sound_filterInverse) {
CONVERT_TWO (LPC, Sound)
autoSound result = LPC_and_Sound_filterInverse (me , you);
CONVERT_TWO_END (my name)
}
FORM (NEW1_LPC_and_Sound_filterInverseWithFilterAtTime, U"LPC & Sound: Filter (inverse) with filter at time",
U"LPC & Sound: Filter (inverse) with filter at time...") {
OPTIONMENUVAR (channel, U"Channel", 2)
OPTION (U"Both")
OPTION (U"Left")
OPTION (U"Right")
REALVAR (time, U"Use filter at time (s)", U"0.0")
OK
DO
CONVERT_TWO (LPC, Sound)
autoSound result = LPC_and_Sound_filterInverseWithFilterAtTime (me , you, channel - 1, time);
CONVERT_TWO_END (my name)
}
FORM (NEW1_LPC_and_Sound_to_LPC_robust, U"Robust LPC analysis", U"LPC & Sound: To LPC (robust)...") {
POSITIVEVAR (windowLength, U"Window length (s)", U"0.025")
POSITIVEVAR (preEmphasisFrequency, U"Pre-emphasis frequency (Hz)", U"50.0")
POSITIVEVAR (numberOfStandardDeviations, U"Number of std. dev.", U"1.5")
NATURALVAR (maximumNumberOfIterations, U"Maximum number of iterations", U"5")
REALVAR (tolerance, U"Tolerance", U"0.000001")
BOOLEANVAR (locationVariable, U"Variable location", false)
OK
DO
CONVERT_TWO (LPC, Sound)
autoLPC result = LPC_and_Sound_to_LPC_robust (me, you, windowLength, preEmphasisFrequency, numberOfStandardDeviations, maximumNumberOfIterations, tolerance, locationVariable);
CONVERT_TWO_END (my name, U"_r");
}
extern void praat_TimeTier_query_init (ClassInfo klas);
extern void praat_TimeTier_modify_init (ClassInfo klas);
void praat_uvafon_LPC_init ();
void praat_uvafon_LPC_init () {
Thing_recognizeClassesByName (classCepstrumc, classPowerCepstrum, classCepstrogram, classPowerCepstrogram, classLPC, classLFCC, classLineSpectralFrequencies, classMFCC, classVocalTractTier, nullptr);
praat_addAction1 (classPowerCepstrum, 0, U"PowerCepstrum help", 0, 0, HELP_PowerCepstrum_help);
praat_addAction1 (classPowerCepstrum, 0, U"Draw...", 0, 0, GRAPHICS_PowerCepstrum_draw);
praat_addAction1 (classPowerCepstrum, 0, U"Draw tilt line...", 0, 0, GRAPHICS_PowerCepstrum_drawTiltLine);
praat_addAction1 (classCepstrum, 0, U"Draw (linear)...", 0, praat_HIDDEN, GRAPHICS_Cepstrum_drawLinear);
praat_addAction1 (classCepstrum, 0, U"Down to PowerCepstrum", 0, 0, NEW_Cepstrum_downto_PowerCepstrum);
praat_addAction1 (classPowerCepstrum, 1, U"Query -", 0, 0, 0);
praat_addAction1 (classPowerCepstrum, 0, U"Get peak...", 0, 1, REAL_PowerCepstrum_getPeak);
praat_addAction1 (classPowerCepstrum, 0, U"Get quefrency of peak...", 0, 1, REAL_PowerCepstrum_getQuefrencyOfPeak);
praat_addAction1 (classPowerCepstrum, 0, U"Get peak prominence (hillenbrand)...", 0, praat_DEPTH_1 + praat_HIDDEN, REAL_PowerCepstrum_getPeakProminence_hillenbrand);
praat_addAction1 (classPowerCepstrum, 0, U"Get peak prominence...", 0, 1, REAL_PowerCepstrum_getPeakProminence);
praat_addAction1 (classPowerCepstrum, 0, U"Get tilt line slope...", 0, 1, REAL_PowerCepstrum_getTiltLineSlope);
praat_addAction1 (classPowerCepstrum, 0, U"Get tilt line intercept...", 0, 1, REAL_PowerCepstrum_getTiltLineIntercept);
praat_addAction1 (classPowerCepstrum, 0, U"Get rhamonics to noise ratio...", 0, 1, REAL_PowerCepstrum_getRNR);
praat_addAction1 (classPowerCepstrum, 1, U"Modify -", 0, 0, 0);
praat_addAction1 (classPowerCepstrum, 0, U"Formula...", 0, 1, MODIFY_PowerCepstrum_formula);
praat_addAction1 (classPowerCepstrum, 0, U"Subtract tilt (in-line)...", 0, 1, MODIFY_PowerCepstrum_subtractTilt_inline);
praat_addAction1 (classPowerCepstrum, 0, U"Smooth (in-line)...", 0, 1, MODIFY_PowerCepstrum_smooth_inline);
praat_addAction1 (classPowerCepstrum, 0, U"Subtract tilt...", 0, 0, NEW_PowerCepstrum_subtractTilt);
praat_addAction1 (classPowerCepstrum, 0, U"Smooth...", 0, 0, NEW_PowerCepstrum_smooth);
praat_addAction1 (classCepstrum, 0, U"To Spectrum", 0, praat_HIDDEN, NEW_Cepstrum_to_Spectrum);
praat_addAction1 (classPowerCepstrum, 0, U"To Matrix", 0, 0, NEW_PowerCepstrum_to_Matrix);
praat_addAction1 (classPowerCepstrogram, 0, U"PowerCepstrogram help", 0, 0, HELP_PowerCepstrogram_help);
praat_addAction1 (classPowerCepstrogram, 0, U"Paint...", 0, 0, GRAPHICS_PowerCepstrogram_paint);
praat_addAction1 (classPowerCepstrogram, 1, U"Query -", 0, 0, 0);
praat_TimeFrameSampled_query_init (classPowerCepstrogram);
praat_addAction1 (classPowerCepstrogram, 1, U"Query quefrency domain", 0, 1, 0);
praat_addAction1 (classPowerCepstrogram, 1, U"Get start quefrency", 0, 2, REAL_PowerCepstrogram_getStartQuefrency);
praat_addAction1 (classPowerCepstrogram, 1, U"Get end quefrency", 0, 2, REAL_PowerCepstrogram_getEndQuefrency);
praat_addAction1 (classPowerCepstrogram, 1, U"Query quefrency sampling", 0, 1, 0);
praat_addAction1 (classPowerCepstrogram, 1, U"Get number of quefrency bins", 0, 2, INTEGER_PowerCepstrogram_getNumberOfQuefrencyBins);
praat_addAction1 (classPowerCepstrogram, 1, U"Get quefrency step", 0, 2, REAL_PowerCepstrogram_getQuefrencyStep);
praat_addAction1 (classPowerCepstrogram, 0, U"Get CPPS (hillenbrand)...", 0, praat_DEPTH_1 + praat_HIDDEN, REAL_PowerCepstrogram_getCPPS_hillenbrand);
praat_addAction1 (classPowerCepstrogram, 0, U"Get CPPS...", 0, 1, REAL_PowerCepstrogram_getCPPS);
praat_addAction1 (classPowerCepstrogram, 0, U"Modify -", nullptr, 0, nullptr);
praat_TimeFunction_modify_init (classPowerCepstrogram);
praat_addAction1 (classPowerCepstrogram, 0, U"Formula...", 0, 1, MODIFY_PowerCepstrogram_formula);
praat_addAction1 (classPowerCepstrogram, 0, U"Subtract tilt (in-line)...", 0, 1, MODIFY_PowerCepstrogram_subtractTilt_inline);
praat_addAction1 (classPowerCepstrogram, 0, U"To PowerCepstrum (slice)...", 0, 0, NEW_PowerCepstrogram_to_PowerCepstrum_slice);
praat_addAction1 (classPowerCepstrogram, 0, U"Smooth...", 0, 0, NEW_PowerCepstrogram_smooth);
praat_addAction1 (classPowerCepstrogram, 0, U"Subtract tilt...", 0, 0, NEW_PowerCepstrogram_subtractTilt);
praat_addAction1 (classPowerCepstrogram, 0, U"To Table (hillenbrand)...", 0, praat_HIDDEN, NEW_PowerCepstrogram_to_Table_hillenbrand);
praat_addAction1 (classPowerCepstrogram, 0, U"To Table (peak prominence)...", 0, praat_HIDDEN, NEW_PowerCepstrogram_to_Table_cpp);
praat_addAction1 (classPowerCepstrogram, 0, U"To Matrix", 0, 0, NEW_PowerCepstrogram_to_Matrix);
praat_addAction1 (classCepstrumc, 0, U"Analyse", 0, 0, 0);
praat_addAction1 (classCepstrumc, 0, U"To LPC", 0, 0, NEW_Cepstrumc_to_LPC);
praat_addAction1 (classCepstrumc, 2, U"To DTW...", 0, 0, NEW1_Cepstrumc_to_DTW);
praat_addAction1 (classCepstrumc, 0, U"Hack", 0, 0, 0);
praat_addAction1 (classCepstrumc, 0, U"To Matrix", 0, 0, NEW_Cepstrumc_to_Matrix);
praat_addAction1 (classFormant, 0, U"Analyse", 0, 0, 0);
praat_addAction1 (classFormant, 0, U"To LPC...", 0, 0, NEW_Formant_to_LPC);
praat_addAction1 (classFormant, 0, U"Formula...", U"Formula (bandwidths)...", 1, MODIFY_Formant_formula);
praat_addAction2 (classFormant, 1, classSpectrogram, 1, U"To IntensityTier...", 0, 0, NEW1_Formant_and_Spectrogram_to_IntensityTier);
praat_addAction1 (classLFCC, 0, U"LFCC help", 0, 0, HELP_LFCC_help);
praat_CC_init (classLFCC);
praat_addAction1 (classLFCC, 0, U"To LPC...", 0, 0, NEW_LFCC_to_LPC);
praat_addAction1 (classLineSpectralFrequencies, 0, U"LineSpectralFrequencies help", 0, 0, HELP_LineSpectralFrequencies_help);
praat_addAction1 (classLineSpectralFrequencies, 0, U"Draw frequencies...", 0, 0, GRAPHICS_LineSpectralFrequencies_drawFrequencies);
praat_addAction1 (classLineSpectralFrequencies, 0, U"To LPC", 0, 0, NEW_LineSpectralFrequencies_to_LPC);
praat_addAction1 (classLPC, 0, U"LPC help", 0, 0, HELP_LPC_help);
praat_addAction1 (classLPC, 0, DRAW_BUTTON, 0, 0, 0);
praat_addAction1 (classLPC, 0, U"Draw gain...", 0, 1, GRAPHICS_LPC_drawGain);
praat_addAction1 (classLPC, 0, U"Draw poles...", 0, 1, GRAPHICS_LPC_drawPoles);
praat_addAction1 (classLPC, 0, QUERY_BUTTON, 0, 0, 0);
praat_TimeFrameSampled_query_init (classLPC);
praat_addAction1 (classLPC, 1, U"Get sampling interval", 0, 1, REAL_LPC_getSamplingInterval);
praat_addAction1 (classLPC, 1, U"Get number of coefficients...", 0, 1, INTEGER_LPC_getNumberOfCoefficients);
praat_addAction1 (classLPC, 0, MODIFY_BUTTON, 0, 0, 0);
praat_TimeFunction_modify_init (classLPC);
praat_addAction1 (classLPC, 0, U"Extract", 0, 0, 0);
praat_addAction1 (classLPC, 0, U"To Spectrum (slice)...", 0, 0, NEW_LPC_to_Spectrum);
praat_addAction1 (classLPC, 0, U"To VocalTract (slice)...", 0, 0, NEW_LPC_to_VocalTract);
praat_addAction1 (classLPC, 0, U"To VocalTract (slice, special)...", 0, 0, NEW_LPC_to_VocalTract_special);
praat_addAction1 (classLPC, 0, U"To Polynomial (slice)...", 0, 0, NEW_LPC_to_Polynomial);
praat_addAction1 (classLPC, 0, U"Down to Matrix (lpc)", 0, 0, NEW_LPC_downto_Matrix_lpc);
praat_addAction1 (classLPC, 0, U"Down to Matrix (rc)", 0, praat_HIDDEN, NEW_LPC_downto_Matrix_rc);
praat_addAction1 (classLPC, 0, U"Down to Matrix (area)", 0, praat_HIDDEN, NEW_LPC_downto_Matrix_area);
praat_addAction1 (classLPC, 0, U"Analyse", 0, 0, 0);
praat_addAction1 (classLPC, 0, U"To Formant", 0, 0, NEW_LPC_to_Formant);
praat_addAction1 (classLPC, 0, U"To Formant (keep all)", 0, 0, NEW_LPC_to_Formant_keep_all);
praat_addAction1 (classLPC, 0, U"To LFCC...", 0, 0, NEW_LPC_to_LFCC);
praat_addAction1 (classLPC, 0, U"To Spectrogram...", 0, 0, NEW_LPC_to_Spectrogram);
praat_addAction1 (classLPC, 0, U"To LineSpectralFrequencies...", 0, 0, NEW_LPC_to_LineSpectralFrequencies);
praat_addAction2 (classLPC, 1, classSound, 1, U"Analyse", 0, 0, 0);
praat_addAction2 (classLPC, 1, classSound, 1, U"Filter...", 0, 0, NEW1_LPC_and_Sound_filter);
praat_addAction2 (classLPC, 1, classSound, 1, U"Filter (inverse)", 0, 0, NEW1_LPC_and_Sound_filterInverse);
praat_addAction2 (classLPC, 1, classSound, 1, U"To LPC (robust)...", 0, praat_HIDDEN + praat_DEPTH_1, NEW1_LPC_and_Sound_to_LPC_robust);
praat_addAction2 (classLPC, 1, classSound, 1, U"Filter with filter at time...", 0, 0, NEW1_LPC_and_Sound_filterWithFilterAtTime);
praat_addAction2 (classLPC, 1, classSound, 1, U"Filter (inverse) with filter at time...", 0, 0, NEW1_LPC_and_Sound_filterInverseWithFilterAtTime);
praat_addAction1 (classSound, 0, U"To LPC (autocorrelation)...", U"To Formant (sl)...", 1, NEW_Sound_to_LPC_auto);
praat_addAction1 (classSound, 0, U"To LPC (covariance)...", U"To LPC (autocorrelation)...", 1, NEW_Sound_to_LPC_covar);
praat_addAction1 (classSound, 0, U"To LPC (burg)...", U"To LPC (covariance)...", 1, NEW_Sound_to_LPC_burg);
praat_addAction1 (classSound, 0, U"To LPC (marple)...", U"To LPC (burg)...", 1, NEW_Sound_to_LPC_marple);
praat_addAction1 (classSound, 0, U"To MFCC...", U"To LPC (marple)...", 1, NEW_Sound_to_MFCC);
praat_addAction1 (classSound, 0, U"To Formant (robust)...", U"To Formant (sl)...", 2, NEW_Sound_to_Formant_robust);
praat_addAction1 (classSound, 0, U"To PowerCepstrogram...", U"To Harmonicity (gne)...", 1, NEW_Sound_to_PowerCepstrogram);
praat_addAction1 (classSound, 0, U"To PowerCepstrogram (hillenbrand)...", U"To Harmonicity (gne)...", praat_HIDDEN + praat_DEPTH_1, NEW_Sound_to_PowerCepstrogram_hillenbrand);
praat_addAction1 (classVocalTract, 0, U"Draw segments...", U"Draw", 0, GRAPHICS_VocalTract_drawSegments);
praat_addAction1 (classVocalTract, 1, U"Get length", U"Draw segments...", 0, REAL_VocalTract_getLength);
praat_addAction1 (classVocalTract, 1, U"Set length", U"Formula...", 0, MODIFY_VocalTract_setLength);
praat_addAction1 (classVocalTract, 0, U"To VocalTractTier...", U"To Spectrum...", 0, NEW_VocalTract_to_VocalTractTier);
praat_addAction1 (classVocalTractTier, 0, U"VocalTractTier help", 0, 0, HELP_VocalTractTier_help);
praat_addAction1 (classVocalTractTier, 0, U"Query -", 0, 0, 0);
praat_TimeTier_query_init (classVocalTractTier);
praat_addAction1 (classVocalTractTier, 0, U"Modify -", 0, 0, 0);
praat_TimeTier_modify_init (classVocalTractTier);
praat_addAction1 (classVocalTractTier, 0, U"To LPC...", 0, 0, NEW_VocalTractTier_to_LPC);
praat_addAction1 (classVocalTractTier, 0, U"To VocalTract...", 0, 0, NEW_VocalTractTier_to_VocalTract);
praat_addAction2 (classVocalTractTier, 1, classVocalTract, 1, U"Add VocalTract...", 0, 0, MODIFY_VocalTractTier_addVocalTract);
INCLUDE_MANPAGES (manual_LPC)
INCLUDE_MANPAGES (manual_DataModeler)
INCLUDE_LIBRARY (praat_DataModeler_init)
}
/* End of file praat_LPC_init.c */
praat-6.0.23/README.md 0000664 0000000 0000000 00000017224 13023464014 0014173 0 ustar 00root root 0000000 0000000 # Praat: doing phonetics by computer
Most information on how the program works is in its manual and on http://www.praat.org,
which is also where you can download the latest binary executables from.
## 1. Compiling the source code
You need the Praat source code only in the following cases:
1. you want to extend Praat’s functionality by adding C or C++ code to it; or
2. you want to understand or reuse Praat’s source code; or
3. you want to compile Praat for a computer for which we do not provide binary executables,
e.g. Linux for non-Intel computers, FreeBSD, HP-UX, SGI, or SPARC Solaris.
Before trying to dive into Praat’s source code, you should be familiar with the working of the Praat program
and with writing Praat scripts. The Praat program can be downloaded from http://www.praat.org.
### 1.1. License
All of the code is available on GitHub under the
[GNU General Public License](http://www.fon.hum.uva.nl/praat/GNU_General_Public_License.txt).
Of course, any improvements are welcomed by the authors.
### 1.2. Downloading the archive
To download the latest source code of Praat from GitHub,
click on the *zip* or *tar.gz* archive at the latest release,
or fork ("clone") the praat/praat repository at any later change.
### 1.3. Steps to take if you want to extend Praat
First make sure that the source code can be compiled as is.
Then add your own buttons by editing `main/main_Praat.cpp` or `fon/praat_Fon.cpp`.
Consult the manual page on [Programming](http://www.fon.hum.uva.nl/praat/manual/Programming_with_Praat.html).
### 1.4. The programming language
Most of the source code is written in C++, but some parts are written in C.
The code requires that your compiler supports C99 and C++11 (for e.g. `char32_t` and rvalue references).
### 1.5. Compiling for Windows
To compile Praat's Windows edition on a 64-bit Windows computer,
install Cygwin on that computer,
and under Cygwin install the Devel packages i686-w64-mingw32 (for 32-bit targets)
and/or x86_64-w64-mingw32 (for 64-bit targets).
Move the Praat sources directory somewhere in your `/home/yourname` tree.
Go into this sources directory (where the folders `fon` and `sys` are).
Then if you want to build Praat's 32-bit edition, type
cp makefiles/makefile.defs.mingw32 ./makefile.defs
or if you want to build Praat's 64-bit edition, type
cp makefiles/makefile.defs.mingw64 ./makefile.defs
Then type `make` to build `Praat.exe`
(use `make -j4` to speed this up, i.e. to use 4 processors in parallel).
Cross-compiling for Windows on a Mac or Linux computer is slightly more difficult, but not impossible.
You can use the [MinGW](http://www.mingw.org) compiler,
for which you can find 32- and 64-bit toolchains
[here](http://sourceforge.net/projects/mingw-w64/files/) (look for Automated Builds).
Install the GDI+ headers and the GDI+ library ([32-bit](http://www.fon.hum.uva.nl/praat/libgdiplus.a-32.zip);
for 64-bit Windows just extract a GDI+ DLL from somewhere).
Then copy the file `makefiles/makefile.defs.darmin32` or `makefiles/makefile.defs.darmin64`
to the sources directory and rename it to `makefile.defs`.
Then type `make`.
### 1.6. Compiling for Macintosh
Extract the *praatXXXX_xcodeproj64.zip* file from the [latest release](https://github.com/praat/praat/releases)
into the directory that contains
`sys`, `fon`, `dwtools` and so on. Then open the project `praat64.xcodeproj` in Xcode
and choose Build or Run for the target `praat_mac64`.
If you get an error message like “Code Signing Identity xxx does not match any valid, non-expired,
code-signing certificate in your keychain”, then select the target `praat_mac64`, go to Info → Build,
and switch “Code Signing Identity” to “Don’t Code Sign”,
or sign with your own certificate if you have one as a registered Apple developer.
If you get lots of errors saying “Expected unqualified-id” or “Unknown type name NSString”,
then you may have to switch the Type of some .cpp file from “C++ Source” to “Objective-C++ Source”
(under “Identity and Type” in the righthand sidebar).
If you want to build Praat as a library instead of as an executable,
try the target `praat_mac64_a` (static) or `praat_mac64_so` (dynamic).
### 1.7. Compiling on Linux and other Unixes
To set up the required system libraries, install some graphics and sound packages:
sudo apt-get install libgtk2.0-dev
sudo apt-get install libasound2-dev
sudo apt-get install libpulse-dev
To set up your source tree for Linux, go to Praat's sources directory (where the folders `fon` and `sys` are) and type
cp makefiles/makefile.defs.linux.pulse ./makefile.defs
To build the Praat executable, type `make`.
If your Unix isn’t Linux, you may have to edit the library names in the makefile
(you may need pthread, gtk-x11-2.0, gdk-x11-2.0, atk-1.0, pangoft2-1.0, gdk_pixbuf-2.0, m, pangocairo-1.0,
cairo, gio-2.0, pango-1.0, freetype, fontconfig, gobject-2.0, gmodule-2.0, gthread-2.0, rt, glib-2.0, asound).
When compiling Praat on an external supercomputer or so, you will not have sound.
If you do have `libgtk2.0-dev` (and its dependencies), do
cp makefiles/makefile.defs.linux.silent ./makefile.defs
Then type `make` to build the program. If your Unix isn’t Linux,
you may have to edit the library names in the makefile (you may need pthread, gtk-x11-2.0, gdk-x11-2.0, atk-1.0,
pangoft2-1.0, gdk_pixbuf-2.0, m, pangocairo-1.0, cairo, gio-2.0, pango-1.0, freetype, fontconfig, gobject-2.0,
gmodule-2.0, gthread-2.0, rt, glib-2.0).
## 2. Binary executables
While the [Praat website](http://www.praat.org) contains the latest executable for all platforms that we support
(or used to support), the [releases on GitHub](https://github.com/praat/praat/releases) contain many older executables as well.
The meaning of the names of binary files available on GitHub is as follows:
### 2.1. Windows binaries
- `praatXXXX_win64.zip`: zipped executable for 64-bit Windows (XP and higher)
- `praatXXXX_win32.zip`: zipped executable for 32-bit Windows (XP and higher)
- `praatconXXXX_win64.zip`: zipped executable for 64-bit Windows, console edition
- `praatconXXXX_win32.zip`: zipped executable for 32-bit Windows, console edition
- `praatconXXXX_win32sit.exe`: self-extracting StuffIt archive with executable for 32-bit Windows, console edition
- `praatXXXX_win98.zip`: zipped executable for Windows 98
- `praatXXXX_win98sit.exe`: self-extracting StuffIt archive with executable for Windows 98
### 2.2. Mac binaries
- `praatXXXX_mac64.dmg`: disk image with executable for 64-bit Intel Macs (Cocoa)
- `praatXXXX_xcodeproj64.zip`: zipped Xcode project file for the 64-bit edition (Cocoa)
- `praatXXXX_mac32.dmg`: disk image with executable for 32-bit Intel Macs (Carbon)
- `praatXXXX_xcodeproj32.zip`: zipped Xcode project file for the 32-bit edition (Carbon)
- `praatXXXX_macU.dmg`: disk image with universal executable for (32-bit) PPC and Intel Macs (Carbon)
- `praatXXXX_macU.sit`: StuffIt archive with universal executable for (32-bit) PPC and Intel Macs (Carbon)
- `praatXXXX_macU.zip`: zipped universal executable for (32-bit) PPC and Intel Macs (Carbon)
- `praatXXXX_macX.zip`: zipped executable for MacOS X (PPC)
- `praatXXXX_mac9.sit`: StuffIt archive with executable for MacOS 9
- `praatXXXX_mac9.zip`: zipped executable for MacOS 9
- `praatXXXX_mac7.sit`: StuffIt archive with executable for MacOS 7
### 2.3. Unix binaries
- `praatXXXX_linux64.tar.gz`: gzipped tarred executable for 64-bit Linux (GTK)
- `praatXXXX_linux32.tar.gz`: gzipped tarred executable for 32-bit Linux (GTK)
- `praatXXXX_linux_motif64.tar.gz`: gzipped tarred executable for 64-bit Linux (Motif)
- `praatXXXX_linux_motif32.tar.gz`: gzipped tarred executable for 32-bit Linux (Motif)
- `praatXXXX_solaris.tar.gz`: gzipped tarred executable for Solaris
praat-6.0.23/artsynth/ 0000775 0000000 0000000 00000000000 13023464014 0014562 5 ustar 00root root 0000000 0000000 praat-6.0.23/artsynth/Art_Speaker.cpp 0000664 0000000 0000000 00000036165 13023464014 0017501 0 ustar 00root root 0000000 0000000 /* Art_Speaker.cpp
*
* Copyright (C) 1992-2012,2014,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Art_Speaker.h"
#define DLIP 5e-3
void Art_Speaker_toVocalTract (Art _art, Speaker speaker,
double intX [], double intY [], double extX [], double extY [],
double *bodyX, double *bodyY)
{
double *art = _art -> art;
double f = speaker -> relativeSize * 1e-3;
struct { double x, y, da; } jaw;
struct { double dx, dy; } hyoid;
struct { double x, y, r, radius; } body;
struct { double x, y, r, a; } teeth;
struct { double a; } blade;
struct { double x, y, a; } tip;
struct { double dx, dy; } lowerLip, upperLip;
double HBody_x, HBody_y, HC, Sp, p, a, b;
/* Determine the position of the hyoid bone (Mermelstein's H). */
/* The rest position is a characteristic of the speaker. */
/* The stylohyoid muscle pulls the hyoid bone up. */
/* The sternohyoid muscle pulls the hyoid bone down. */
/* The sphincter muscle pulls the hyoid bone backwards. */
hyoid.dx = -5 * f * art [kArt_muscle_SPHINCTER];
hyoid.dy = 20 * f * (art [kArt_muscle_STYLOHYOID]
- art [kArt_muscle_STERNOHYOID]);
/* The larynx moves up and down with the hyoid bone. */
/* Only the lowest point (Mermelstein's K) */
/* does not follow completely the horizontal movements. */
/* Anterior larynx. */
intX [1] = -14 * f + 0.5 * hyoid.dx; intY [1] = -53 * f + hyoid.dy;
/* Top of larynx. */
intX [2] = -20 * f + hyoid.dx; intY [2] = -33 * f + hyoid.dy;
/* Epiglottis. */
intX [3] = -20 * f + hyoid.dx; intY [3] = -26 * f + hyoid.dy;
/* Hyoid bone. */
intX [4] = -16 * f + hyoid.dx; intY [4] = -26 * f + hyoid.dy;
/* Posterior larynx. */
extX [1] = -22 * f + hyoid.dx; extY [1] = -53 * f + hyoid.dy;
/* Esophagus. */
extX [2] = -26 * f + hyoid.dx; extY [2] = -40 * f + hyoid.dy;
/* The lower pharynx moves up and down with the hyoid bone. */
/* The lower constrictor muscle pulls the rear pharyngeal wall forwards. */
extX [3] = -34 * f + art [kArt_muscle_SPHINCTER] * 5 * f; extY [3] = extY [2];
/* The upper pharynx is fixed at the height of the velum. */
/* The upper constrictor muscle pulls the rear pharyngeal wall forwards. */
extX [5] = -34 * f + art [kArt_muscle_SPHINCTER] * 5 * f;
extY [5] = speaker -> velum.y;
/* The height of the middle pharynx is in between the lower and upper pharynx. */
/* The middle constrictor muscle pulls the rear pharyngeal wall forwards. */
extX [4] = -34 * f + art [kArt_muscle_SPHINCTER] * 5 * f;
extY [4] = 0.5 * (extY [3] + extY [5]);
/* Tongue root. */
jaw.x = -75 * f, jaw.y = 53 * f; /* Position of the condyle. */
jaw.da = art [kArt_muscle_MASSETER] * 0.15
- art [kArt_muscle_MYLOHYOID] * 0.20;
body.x = jaw.x + 81 * f * cos (-0.60 + jaw.da)
- art [kArt_muscle_STYLOGLOSSUS] * 10 * f
+ art [kArt_muscle_GENIOGLOSSUS] * 10 * f;
body.y = jaw.y + 81 * f * sin (-0.60 + jaw.da)
- art [kArt_muscle_HYOGLOSSUS] * 10 * f
+ art [kArt_muscle_STYLOGLOSSUS] * 5 * f;
*bodyX = body.x;
*bodyY = body.y;
body.r = sqrt ((jaw.x - body.x) * (jaw.x - body.x)
+ (jaw.y - body.y) * (jaw.y - body.y));
body.radius = 20 * f;
HBody_x = body.x - intX [4];
HBody_y = body.y - intY [4];
HC = sqrt (HBody_x * HBody_x + HBody_y * HBody_y);
if (HC <= body.radius) {
HC = body.radius;
Sp = 0.0; // prevent rounding errors in sqrt (can occur on processors with e.g. 80-bit registers)
} else {
Sp = sqrt (HC * HC - body.radius * body.radius);
}
a = atan2 (HBody_y, HBody_x);
b = asin (body.radius / HC);
p = 0.57 * (34.8 * f - Sp);
intX [5] = intX [4] + 0.5 * Sp * cos (a + b) - p * sin (a + b);
intY [5] = intY [4] + 0.5 * Sp * sin (a + b) + p * cos (a + b);
HBody_x = body.x - intX [5];
HBody_y = body.y - intY [5];
HC = sqrt (HBody_x * HBody_x + HBody_y * HBody_y);
if (HC <= body.radius) { HC = body.radius; Sp = 0.0; } else Sp = sqrt (HC * HC - body.radius * body.radius);
a = atan2 (HBody_y, HBody_x);
b = asin (body.radius / HC);
intX [6] = intX [5] + Sp * cos (a + b);
intY [6] = intY [5] + Sp * sin (a + b);
/* Posterior blade. */
teeth.a = speaker -> lowerTeeth.a + jaw.da;
intX [7] = body.x + body.radius * cos (1.73 + teeth.a);
intY [7] = body.y + body.radius * sin (1.73 + teeth.a);
/* Tip. */
tip.a = (art [kArt_muscle_UPPER_TONGUE]
- art [kArt_muscle_LOWER_TONGUE]) * 1.0;
blade.a = teeth.a
+ 0.004 * (body.r - speaker -> neutralBodyDistance) + tip.a;
intX [8] = intX [7] + speaker -> tip.length * cos (blade.a);
intY [8] = intY [7] + speaker -> tip.length * sin (blade.a);
/* Jaw. */
teeth.r = speaker -> lowerTeeth.r;
teeth.x = jaw.x + teeth.r * cos (teeth.a);
teeth.y = jaw.y + teeth.r * sin (teeth.a);
intX [9] = teeth.x + speaker -> teethCavity.dx1;
intY [9] = teeth.y + speaker -> teethCavity.dy;
intX [10] = teeth.x + speaker -> teethCavity.dx2;
intY [10] = intY [9];
intX [11] = teeth.x;
intY [11] = teeth.y;
/* Lower lip. */
lowerLip.dx = speaker -> lowerLip.dx + art [kArt_muscle_ORBICULARIS_ORIS] * 0.02 - 5e-3;
lowerLip.dy = speaker -> lowerLip.dy + art [kArt_muscle_ORBICULARIS_ORIS] * 0.01;
intX [12] = teeth.x;
intY [12] = teeth.y + lowerLip.dy;
intX [13] = teeth.x + lowerLip.dx;
intY [13] = intY [12];
/* Velum. */
extX [6] = speaker -> velum.x;
extY [6] = speaker -> velum.y;
/* Palate. */
extX [7] = speaker -> alveoli.x;
extY [7] = speaker -> alveoli.y;
extX [8] = speaker -> upperTeeth.x;
extY [8] = speaker -> upperTeeth.y;
/* Upper lip. */
upperLip.dx = speaker -> upperLip.dx + art [kArt_muscle_ORBICULARIS_ORIS] * 0.02 - 5e-3;
upperLip.dy = speaker -> upperLip.dy - art [kArt_muscle_ORBICULARIS_ORIS] * 0.01;
extX [9] = extX [8];
extY [9] = extY [8] + upperLip.dy;
extX [10] = extX [9] + upperLip.dx;
extY [10] = extY [9];
extX [11] = extX [10] + 5e-3;
extY [11] = extY [10] + DLIP;
/* Chin. */
intX [14] = intX [13] + 5e-3;
intY [14] = intY [13] - DLIP;
intX [15] = intX [11] + 0.5e-2;
intY [15] = intY [11] - 3.0e-2;
intX [16] = intX [1];
intY [16] = intY [1];
}
void Art_Speaker_draw (Art art, Speaker speaker, Graphics g) {
double f = speaker -> relativeSize * 1e-3;
double intX [1 + 16], intY [1 + 16], extX [1 + 11], extY [1 + 11];
double bodyX, bodyY;
int i;
Graphics_Viewport previous;
Art_Speaker_toVocalTract (art, speaker, intX, intY, extX, extY, & bodyX, & bodyY);
previous = Graphics_insetViewport (g, 0.1, 0.9, 0.1, 0.9);
Graphics_setWindow (g, -0.05, 0.05, -0.05, 0.05);
/* Draw inner contour. */
for (i = 1; i <= 5; i ++)
Graphics_line (g, intX [i], intY [i], intX [i + 1], intY [i + 1]);
Graphics_arc (g, bodyX, bodyY, 20 * f,
atan2 (intY [7] - bodyY, intX [7] - bodyX) * 180 / NUMpi,
atan2 (intY [6] - bodyY, intX [6] - bodyX) * 180 / NUMpi);
for (i = 7; i <= 15; i ++)
Graphics_line (g, intX [i], intY [i], intX [i + 1], intY [i + 1]);
/* Draw outer contour. */
for (i = 1; i <= 5; i ++)
Graphics_line (g, extX [i], extY [i], extX [i + 1], extY [i + 1]);
Graphics_arc (g, 0, 0, speaker -> palate.radius,
speaker -> alveoli.a * 180 / NUMpi,
speaker -> velum.a * 180 / NUMpi);
for (i = 7; i <= 10; i ++)
Graphics_line (g, extX [i], extY [i], extX [i + 1], extY [i + 1]);
Graphics_resetViewport (g, previous);
}
void Art_Speaker_fillInnerContour (Art art, Speaker speaker, Graphics g) {
double f = speaker -> relativeSize * 1e-3;
double intX [1 + 16], intY [1 + 16], extX [1 + 11], extY [1 + 11];
double x [1 + 16], y [1 + 16];
double bodyX, bodyY;
int i;
Graphics_Viewport previous;
Art_Speaker_toVocalTract (art, speaker, intX, intY, extX, extY, & bodyX, & bodyY);
previous = Graphics_insetViewport (g, 0.1, 0.9, 0.1, 0.9);
Graphics_setWindow (g, -0.05, 0.05, -0.05, 0.05);
for (i = 1; i <= 16; i ++) { x [i] = intX [i]; y [i] = intY [i]; }
Graphics_setGrey (g, 0.8);
Graphics_fillArea (g, 16, & x [1], & y [1]);
Graphics_fillCircle (g, bodyX, bodyY, 20 * f);
Graphics_setGrey (g, 0.0);
Graphics_resetViewport (g, previous);
}
static double arcLength (double from, double to) {
double result = to - from;
while (result > 0.0) result -= 2 * NUMpi;
while (result < 0.0) result += 2 * NUMpi;
return result;
}
static int Art_Speaker_meshCount = 27;
static double bodyX, bodyY, bodyRadius;
static double toLine (double x, double y, const double intX [], const double intY [], int i) {
int nearby;
if (i == 6) {
double a7 = atan2 (intY [7] - bodyY, intX [7] - bodyX);
double a6 = atan2 (intY [6] - bodyY, intX [6] - bodyX);
double a = atan2 (y - bodyY, x - bodyX);
double da6 = arcLength (a7, a6);
double da = arcLength (a7, a);
if (da <= da6)
return fabs (sqrt ((bodyX - x) * (bodyX - x) + (bodyY - y) * (bodyY - y)) - bodyRadius);
else
nearby = arcLength (a7 + 0.5 * da6, a) < NUMpi ? 6 : 7;
} else if ((x - intX [i]) * (intX [i + 1] - intX [i]) +
(y - intY [i]) * (intY [i + 1] - intY [i]) < 0) {
nearby = i;
} else if ((x - intX [i + 1]) * (intX [i] - intX [i + 1]) +
(y - intY [i + 1]) * (intY [i] - intY [i + 1]) < 0) {
nearby = i + 1;
} else {
double boundaryDistance =
sqrt ((intX [i + 1] - intX [i]) * (intX [i + 1] - intX [i]) +
(intY [i + 1] - intY [i]) * (intY [i + 1] - intY [i]));
double outerProduct = (intX [i] - x) * (intY [i + 1] - intY [i]) - (intY [i] - y) * (intX [i + 1] - intX [i]);
return fabs (outerProduct) / boundaryDistance;
}
return sqrt ((intX [nearby] - x) * (intX [nearby] - x) + (intY [nearby] - y) * (intY [nearby] - y));
}
static int inside (double x, double y,
const double intX [], const double intY [])
{
int i, up = 0;
for (i = 1; i <= 16 - 1; i ++)
if ((y > intY [i]) != (y > intY [i + 1])) {
double slope = (intX [i + 1] - intX [i]) / (intY [i + 1] - intY [i]);
if (x > intX [i] + (y - intY [i]) * slope)
up += ( y > intY [i] ? 1 : -1 );
}
return up != 0 || bodyRadius * bodyRadius >
(x - bodyX) * (x - bodyX) + (y - bodyY) * (y - bodyY);
}
void Art_Speaker_meshVocalTract (Art art, Speaker speaker,
double xi [], double yi [], double xe [], double ye [],
double xmm [], double ymm [], int closed [])
{
double f = speaker -> relativeSize * 1e-3;
double intX [1 + 16], intY [1 + 16], extX [1 + 11], extY [1 + 11], d_angle;
double xm [40], ym [40];
int i;
Art_Speaker_toVocalTract (art, speaker, intX, intY, extX, extY, & bodyX, & bodyY);
bodyRadius = 20 * f;
xe [1] = extX [1]; /* Eq. 5.45 */
ye [1] = extY [1];
xe [2] = 0.2 * extX [2] + 0.8 * extX [1];
ye [2] = 0.2 * extY [2] + 0.8 * extY [1];
xe [3] = 0.6 * extX [2] + 0.4 * extX [1];
ye [3] = 0.6 * extY [2] + 0.4 * extY [1];
xe [4] = 0.9 * extX [3] + 0.1 * extX [4]; /* Eq. 5.46 */
ye [4] = 0.9 * extY [3] + 0.1 * extY [4];
xe [5] = 0.7 * extX [3] + 0.3 * extX [4];
ye [5] = 0.7 * extY [3] + 0.3 * extY [4];
xe [6] = 0.5 * extX [3] + 0.5 * extX [4];
ye [6] = 0.5 * extY [3] + 0.5 * extY [4];
xe [7] = 0.3 * extX [3] + 0.7 * extX [4];
ye [7] = 0.3 * extY [3] + 0.7 * extY [4];
xe [8] = 0.1 * extX [3] + 0.9 * extX [4];
ye [8] = 0.1 * extY [3] + 0.9 * extY [4];
xe [9] = 0.9 * extX [4] + 0.1 * extX [5];
ye [9] = 0.9 * extY [4] + 0.1 * extY [5];
xe [10] = 0.7 * extX [4] + 0.3 * extX [5];
ye [10] = 0.7 * extY [4] + 0.3 * extY [5];
xe [11] = 0.5 * extX [4] + 0.5 * extX [5];
ye [11] = 0.5 * extY [4] + 0.5 * extY [5];
xe [12] = 0.3 * extX [4] + 0.7 * extX [5];
ye [12] = 0.3 * extY [4] + 0.7 * extY [5];
xe [13] = 0.1 * extX [4] + 0.9 * extX [5];
ye [13] = 0.1 * extY [4] + 0.9 * extY [5];
d_angle = (atan2 (ye [13], xe [13]) - 0.5 * NUMpi) / 6; /* Eq. 5.47 */
for (i = 14; i <= 18; i ++) {
double a = 0.5 * NUMpi + (19 - i) * d_angle;
xe [i] = speaker -> palate.radius * cos (a);
ye [i] = speaker -> palate.radius * sin (a);
}
xe [19] = 0;
ye [19] = speaker -> palate.radius;
xe [20] = 0.25 * extX [7];
xe [21] = 0.50 * extX [7];
xe [22] = 0.75 * extX [7];
for (i = 20; i <= 22; i ++) {
ye [i] = speaker -> palate.radius * sqrt (1.0 - xe [i] * xe [i] /
(speaker -> palate.radius * speaker -> palate.radius));
}
xe [23] = extX [7];
ye [23] = extY [7];
xe [24] = 0.5 * (extX [7] + extX [8]);
ye [24] = 0.5 * (extY [7] + extY [8]);
xe [25] = extX [8];
ye [25] = extY [8];
xe [26] = 0.25 * extX [11] + 0.75 * extX [9];
xe [27] = 0.75 * extX [11] + 0.25 * extX [9];
ye [26] = extY [10];
ye [27] = 0.5 * (extY [10] + extY [11]);
for (i = 1; i <= 27; i ++) { /* Every mesh point. */
double minimum = 100000;
int j;
for (j = 1; j <= 15 - 1; j ++) { /* Every internal segment. */
double d = toLine (xe [i], ye [i], intX, intY, j);
if (d < minimum) minimum = d;
}
if ((closed [i] = inside (xe [i], ye [i], intX, intY)) != 0)
minimum = - minimum;
if (xe [i] >= 0.0) { /* Vertical line pieces. */
xi [i] = xe [i];
yi [i] = ye [i] - minimum;
} else if (ye [i] <= 0.0) { /* Horizontal line pieces. */
xi [i] = xe [i] + minimum;
yi [i] = ye [i];
} else { /* Radial line pieces, centre = centre of palate arc. */
double angle = atan2 (ye [i], xe [i]);
xi [i] = xe [i] - minimum * cos (angle);
yi [i] = ye [i] - minimum * sin (angle);
}
}
for (i = 1; i <= Art_Speaker_meshCount; i ++) {
xm [i] = 0.5 * (xe [i] + xi [i]);
ym [i] = 0.5 * (ye [i] + yi [i]);
}
for (i = 2; i <= Art_Speaker_meshCount; i ++) {
xmm [i] = 0.5 * (xm [i - 1] + xm [i]);
ymm [i] = 0.5 * (ym [i - 1] + ym [i]);
}
xmm [1] = 2 * xm [1] - xmm [2];
ymm [1] = 2 * ym [1] - ymm [2];
xmm [Art_Speaker_meshCount + 1] = 2 * xm [Art_Speaker_meshCount]
- xmm [Art_Speaker_meshCount];
ymm [Art_Speaker_meshCount + 1] = 2 * ym [Art_Speaker_meshCount]
- ymm [Art_Speaker_meshCount];
}
void Art_Speaker_drawMesh (Art art, Speaker speaker, Graphics graphics) {
double xi [40], yi [40], xe [40], ye [40], xmm [40], ymm [40];
int closed [40];
int i;
Graphics_Viewport previous;
int oldLineType = Graphics_inqLineType (graphics);
Art_Speaker_meshVocalTract (art, speaker, xi, yi, xe, ye, xmm, ymm, closed);
previous = Graphics_insetViewport (graphics, 0.1, 0.9, 0.1, 0.9); /* Must be square. */
Graphics_setWindow (graphics, -0.05, 0.05, -0.05, 0.05);
/* Mesh lines. */
for (i = 1; i <= Art_Speaker_meshCount; i ++)
Graphics_line (graphics, xi [i], yi [i], xe [i], ye [i]);
/* Radii. */
Graphics_setLineType (graphics, Graphics_DOTTED);
for (i = 1; i <= Art_Speaker_meshCount; i ++)
if (xe [i] <= 0.0 && ye [i] >= 0.0)
Graphics_line (graphics, 0.0, 0.0, 0.9 * xi [i], 0.9 * yi [i]);
Graphics_setLineType (graphics, oldLineType);
/* Lengths. */
for (i = 1; i <= Art_Speaker_meshCount; i ++)
Graphics_line (graphics, xmm [i], ymm [i], xmm [i + 1], ymm [i + 1]);
for (i = 1; i <= Art_Speaker_meshCount + 1; i ++)
Graphics_speckle (graphics, xmm [i], ymm [i]);
Graphics_setTextAlignment (graphics, Graphics_LEFT, Graphics_HALF);
Graphics_text (graphics, 0.0, 0.0, U"O"); // origin
Graphics_resetViewport (graphics, previous);
}
/* End of file Art_Speaker.cpp */
praat-6.0.23/artsynth/Art_Speaker.h 0000664 0000000 0000000 00000003466 13023464014 0017144 0 ustar 00root root 0000000 0000000 /* Art_Speaker.h
*
* Copyright (C) 1992-2011 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Articulation.h"
#include "Speaker.h"
#include "Graphics.h"
void Art_Speaker_toVocalTract (Art art, Speaker speaker,
double intX [], double intY [], double extX [], double extY [],
double *bodyX, double *bodyY);
/*
Function:
compute key places of the supralaryngeal vocal tract.
Preconditions:
index intX [1..13];
index intY [1..13];
index extX [1..9];
index extY [1..9];
Postconditions:
int [1..6] is anterior larynx, hyoid, and tongue root.
int [6..7] is the arc of the tongue body.
int [7..13] is tongue blade, lower teeth, and lower lip.
ext [1..5] is posterior larynx, back pharynx wall, and velic.
ext [5..6] is the arc of the velum and palate.
ext [6..9] is the gums, upper teeth and upper lip.
*/
void Art_Speaker_draw (Art art, Speaker speaker, Graphics g);
void Art_Speaker_fillInnerContour (Art art, Speaker speaker, Graphics g);
void Art_Speaker_meshVocalTract (Art art, Speaker speaker,
double xi [], double yi [], double xe [], double ye [],
double xmm [], double ymm [], int closed []);
void Art_Speaker_drawMesh (Art art, Speaker speaker, Graphics g);
/* End of file Art_Speaker.h */
praat-6.0.23/artsynth/Art_Speaker_Delta.cpp 0000664 0000000 0000000 00000006524 13023464014 0020606 0 ustar 00root root 0000000 0000000 /* Art_Speaker_Delta.cpp
*
* Copyright (C) 1992-2011 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Art_Speaker_Delta.h"
#include "Art_Speaker.h"
void Art_Speaker_intoDelta (Art art, Speaker speaker, Delta delta)
{
double f = speaker -> relativeSize * 1e-3;
double xe [30], ye [30], xi [30], yi [30], xmm [30], ymm [30], dx, dy;
int closed [40];
int itube;
/* Lungs. */
for (itube = 7; itube <= 18; itube ++)
delta -> tube [itube]. Dyeq = 120 * f * (1 + art -> art [kArt_muscle_LUNGS]);
/* Glottis. */
{
Delta_Tube t = delta -> tube + 36;
t -> Dyeq = f * (5 - 10 * art -> art [kArt_muscle_INTERARYTENOID]
+ 3 * art -> art [kArt_muscle_POSTERIOR_CRICOARYTENOID]
- 3 * art -> art [kArt_muscle_LATERAL_CRICOARYTENOID]); /* 4.38 */
t -> k1 = speaker -> lowerCord.k1 * (1 + art -> art [kArt_muscle_CRICOTHYROID]);
t -> k3 = t -> k1 * (20 / t -> Dz) * (20 / t -> Dz);
}
if (speaker -> cord.numberOfMasses >= 2) {
Delta_Tube t = delta -> tube + 37;
t -> Dyeq = delta -> tube [36]. Dyeq;
t -> k1 = speaker -> upperCord.k1 * (1 + art -> art [kArt_muscle_CRICOTHYROID]);
t -> k3 = t -> k1 * (20 / t -> Dz) * (20 / t -> Dz);
}
if (speaker -> cord.numberOfMasses >= 10) {
delta -> tube [84]. Dyeq = 0.75 * 1 * f + 0.25 * delta -> tube [36]. Dyeq;
delta -> tube [85]. Dyeq = 0.50 * 1 * f + 0.50 * delta -> tube [36]. Dyeq;
delta -> tube [86]. Dyeq = 0.25 * 1 * f + 0.75 * delta -> tube [36]. Dyeq;
delta -> tube [84]. k1 = 0.75 * 160 + 0.25 * delta -> tube [36]. k1;
delta -> tube [85]. k1 = 0.50 * 160 + 0.50 * delta -> tube [36]. k1;
delta -> tube [86]. k1 = 0.25 * 160 + 0.75 * delta -> tube [36]. k1;
for (itube = 84; itube <= 86; itube ++)
delta -> tube [itube]. k3 = delta -> tube [itube]. k1 *
(20 / delta -> tube [itube]. Dz) * (20 / delta -> tube [itube]. Dz);
}
/* Vocal tract. */
Art_Speaker_meshVocalTract (art, speaker, xi, yi, xe, ye, xmm, ymm, closed);
for (itube = 38; itube <= 64; itube ++) {
Delta_Tube t = delta -> tube + itube;
int i = itube - 37;
t -> Dxeq = sqrt (( dx = xmm [i] - xmm [i + 1], dx * dx ) + ( dy = ymm [i] - ymm [i + 1], dy * dy ));
t -> Dyeq = sqrt (( dx = xe [i] - xi [i], dx * dx ) + ( dy = ye [i] - yi [i], dy * dy ));
if (closed [i]) t -> Dyeq = - t -> Dyeq;
}
delta -> tube [65]. Dxeq = delta -> tube [51]. Dxeq = delta -> tube [50]. Dxeq;
/* Voor [r]: thy tube [60]. Brel = 0.1; thy tube [60]. k1 = 3; */
/* Nasopharyngeal port. */
delta -> tube [65]. Dyeq = f * (18 - 25 * art -> art [kArt_muscle_LEVATOR_PALATINI]); /* 4.40 */
for (itube = 1; itube <= delta -> numberOfTubes; itube ++) {
Delta_Tube t = delta -> tube + itube;
t -> s1 = 5e6 * t -> Dxeq * t -> Dzeq;
t -> s3 = t -> s1 / (0.9e-3 * 0.9e-3);
}
}
/* End of file Art_Speaker_Delta.cpp */
praat-6.0.23/artsynth/Art_Speaker_Delta.h 0000664 0000000 0000000 00000001563 13023464014 0020251 0 ustar 00root root 0000000 0000000 /* Art_Speaker_Delta.h
*
* Copyright (C) 1992-2011 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Articulation.h"
#include "Speaker.h"
#include "Delta.h"
void Art_Speaker_intoDelta (Art art, Speaker speaker, Delta delta);
/* End of file Art_Speaker_Delta.h */
praat-6.0.23/artsynth/Art_Speaker_to_VocalTract.cpp 0000664 0000000 0000000 00000003301 13023464014 0022307 0 ustar 00root root 0000000 0000000 /* Art_Speaker_to_VocalTract.cpp
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Delta.h"
#include "Speaker_to_Delta.h"
#include "Art_Speaker_Delta.h"
#include "Art_Speaker_to_VocalTract.h"
autoVocalTract Art_Speaker_to_VocalTract (Art art, Speaker speaker) {
autoDelta delta = Speaker_to_Delta (speaker);
Art_Speaker_intoDelta (art, speaker, delta.get());
double area [300];
constexpr double sectionLength = 0.001; // one millimetre
int numberOfSections = 0;
for (long isection = 1; isection <= 27; isection ++) {
Delta_Tube tube = delta -> tube + 37 + isection;
int numberOfConstantSections = lround (tube -> Dxeq / sectionLength);
double constantArea = tube -> Dyeq * tube -> Dzeq;
for (int jsection = 1; jsection <= numberOfConstantSections; jsection ++)
area [++ numberOfSections] = constantArea;
}
autoVocalTract thee = VocalTract_create (numberOfSections, sectionLength);
for (long isection = 1; isection <= numberOfSections; isection ++)
thy z [1] [isection] = area [isection];
return thee;
}
/* End of file Art_Speaker_to_VocalTract.cpp */
praat-6.0.23/artsynth/Art_Speaker_to_VocalTract.h 0000664 0000000 0000000 00000001616 13023464014 0021763 0 ustar 00root root 0000000 0000000 /* Art_Speaker_to_VocalTract.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Articulation.h"
#include "Speaker.h"
#include "VocalTract.h"
autoVocalTract Art_Speaker_to_VocalTract (Art art, Speaker speaker);
/* End of file Art_Speaker_to_VocalTract.h */
praat-6.0.23/artsynth/Articulation.cpp 0000664 0000000 0000000 00000002725 13023464014 0017732 0 ustar 00root root 0000000 0000000 /* Articulation.cpp
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Articulation.h"
#include "oo_DESTROY.h"
#include "Articulation_def.h"
#include "oo_COPY.h"
#include "Articulation_def.h"
#include "oo_EQUAL.h"
#include "Articulation_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "Articulation_def.h"
#include "oo_WRITE_TEXT.h"
#include "Articulation_def.h"
#include "oo_WRITE_BINARY.h"
#include "Articulation_def.h"
#include "oo_READ_TEXT.h"
#include "Articulation_def.h"
#include "oo_READ_BINARY.h"
#include "Articulation_def.h"
#include "oo_DESCRIPTION.h"
#include "Articulation_def.h"
#include "enums_getText.h"
#include "Articulation_enums.h"
#include "enums_getValue.h"
#include "Articulation_enums.h"
Thing_implement (Art, Daata, 0);
autoArt Art_create () {
return Thing_new (Art);
}
/* End of file Articulation.cpp */
praat-6.0.23/artsynth/Articulation.h 0000664 0000000 0000000 00000002353 13023464014 0017374 0 ustar 00root root 0000000 0000000 #ifndef _Articulation_h_
#define _Articulation_h_
/* Articulation.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/* Art = Articulation */
/* Members represent muscle activities for speech production. */
/* All members have values from 0 (no activity) to 1 (maximum activity). */
#include "Data.h"
#include "Articulation_enums.h"
#include "Articulation_def.h"
autoArt Art_create ();
/*
Return value:
an array of double, with indices from enum Art.
Postconditions:
result -> art [kArt_muscle_LUNGS] == 0.0;
...
result -> art [kArt_muscle_BUCCINATOR] = 0.0;
*/
/* End of file Articulation.h */
#endif
praat-6.0.23/artsynth/Articulation_def.h 0000664 0000000 0000000 00000001552 13023464014 0020212 0 ustar 00root root 0000000 0000000 /* Articulation_def.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT Art
oo_DEFINE_CLASS (Art, Daata)
oo_DOUBLE_SET (art, kArt_muscle)
oo_END_CLASS (Art)
#undef ooSTRUCT
/* End of file Articulation_def.h */
praat-6.0.23/artsynth/Articulation_enums.h 0000664 0000000 0000000 00000006515 13023464014 0020607 0 ustar 00root root 0000000 0000000 /* Articulation_enums.h
*
* Copyright (C) 1992-2009,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
enums_begin (kArt_muscle, 0)
enums_add (kArt_muscle, 0, _, U"_")
enums_add (kArt_muscle, 1, LUNGS, U"Lungs")
enums_add (kArt_muscle, 2, INTERARYTENOID, U"Interarytenoid") // constriction of larynx; 0 = breathing, 1 = constricted glottis
enums_add (kArt_muscle, 3, CRICOTHYROID, U"Cricothyroid") // vocal-cord tension
enums_add (kArt_muscle, 4, VOCALIS, U"Vocalis") // vocal-cord tension
enums_add (kArt_muscle, 5, THYROARYTENOID, U"Thyroarytenoid")
enums_add (kArt_muscle, 6, POSTERIOR_CRICOARYTENOID, U"PosteriorCricoarytenoid") // opening of glottis
enums_add (kArt_muscle, 7, LATERAL_CRICOARYTENOID, U"LateralCricoarytenoid") // opening of glottis
enums_add (kArt_muscle, 8, STYLOHYOID, U"Stylohyoid") // up movement of hyoid bone
enums_add (kArt_muscle, 9, STERNOHYOID, U"Sternohyoid") // down movement of hyoid bone
enums_add (kArt_muscle, 10, THYROPHARYNGEUS, U"Thyropharyngeus") // constriction of ventricular folds
enums_add (kArt_muscle, 11, LOWER_CONSTRICTOR, U"LowerConstrictor")
enums_add (kArt_muscle, 12, MIDDLE_CONSTRICTOR, U"MiddleConstrictor")
enums_add (kArt_muscle, 13, UPPER_CONSTRICTOR, U"UpperConstrictor")
enums_add (kArt_muscle, 14, SPHINCTER, U"Sphincter") // constriction of pharynx
enums_add (kArt_muscle, 15, HYOGLOSSUS, U"Hyoglossus") // down movement of tongue body
enums_add (kArt_muscle, 16, STYLOGLOSSUS, U"Styloglossus") // up movement of tongue body
enums_add (kArt_muscle, 17, GENIOGLOSSUS, U"Genioglossus") // forward movement of tongue body
enums_add (kArt_muscle, 18, UPPER_TONGUE, U"UpperTongue") // up curling of the tongue tip
enums_add (kArt_muscle, 19, LOWER_TONGUE, U"LowerTongue") // down curling of the tongue
enums_add (kArt_muscle, 20, TRANSVERSE_TONGUE, U"TransverseTongue") // thickening of tongue
enums_add (kArt_muscle, 21, VERTICAL_TONGUE, U"VerticalTongue") // thinning of tongue
enums_add (kArt_muscle, 22, RISORIUS, U"Risorius") // spreading of lips
enums_add (kArt_muscle, 23, ORBICULARIS_ORIS, U"OrbicularisOris") // rounding of lips
enums_add (kArt_muscle, 24, LEVATOR_PALATINI, U"LevatorPalatini") // closing of velo-pharyngeal port; 0 = open ("nasal"), 1 = closed ("oral")
enums_add (kArt_muscle, 25, TENSOR_PALATINI, U"TensorPalatini")
enums_add (kArt_muscle, 26, MASSETER, U"Masseter") // closing of jaw; 0 = open, 1 = closed
enums_add (kArt_muscle, 27, MYLOHYOID, U"Mylohyoid") // opening of jaw
enums_add (kArt_muscle, 28, LATERAL_PTERYGOID, U"LateralPterygoid") // horizontal jaw position
enums_add (kArt_muscle, 29, BUCCINATOR, U"Buccinator") // oral wall tension
enums_end (kArt_muscle, 29, LUNGS)
/* End of file Articulation.enums */
praat-6.0.23/artsynth/Artword.cpp 0000664 0000000 0000000 00000011634 13023464014 0016715 0 ustar 00root root 0000000 0000000 /* Artword.cpp
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Artword.h"
#include "oo_DESTROY.h"
#include "Artword_def.h"
#include "oo_COPY.h"
#include "Artword_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "Artword_def.h"
#include "oo_EQUAL.h"
#include "Artword_def.h"
#include "oo_WRITE_TEXT.h"
#include "Artword_def.h"
#include "oo_READ_TEXT.h"
#include "Artword_def.h"
#include "oo_WRITE_BINARY.h"
#include "Artword_def.h"
#include "oo_READ_BINARY.h"
#include "Artword_def.h"
#include "oo_DESCRIPTION.h"
#include "Artword_def.h"
Thing_implement (Artword, Daata, 0);
autoArtword Artword_create (double totalTime) {
autoArtword me = Thing_new (Artword);
my totalTime = totalTime;
for (int i = 1; i <= kArt_muscle_MAX; i ++)
Artword_setDefault (me.get(), i);
return me;
}
void Artword_setDefault (Artword me, int feature) {
ArtwordData f = & my data [feature];
NUMvector_free (f -> times, 1);
NUMvector_free (f -> targets, 1);
f -> times = NUMvector (1, 2);
f -> targets = NUMvector (1, 2);
f -> numberOfTargets = 2;
f -> times [1] = 0.0;
f -> targets [1] = 0.0;
f -> times [2] = my totalTime;
f -> targets [2] = 0.0;
f -> _iTarget = 1;
}
void Artword_setTarget (Artword me, int feature, double time, double target) {
try {
Melder_assert (feature >= 1);
Melder_assert (feature <= kArt_muscle_MAX);
ArtwordData f = & my data [feature];
Melder_assert (f -> numberOfTargets >= 2);
int insert = 1;
if (time < 0.0) time = 0.0;
if (time > my totalTime) time = my totalTime;
while (insert <= f -> numberOfTargets && f -> times [insert] < time)
insert ++;
Melder_assert (insert <= f -> numberOfTargets); // can never insert past totalTime
if (f -> times [insert] != time) {
long numberOfTargets = f -> numberOfTargets;
NUMvector_insert (& f -> times, 1, & numberOfTargets, insert);
numberOfTargets = f -> numberOfTargets;
NUMvector_insert (& f -> targets, 1, & numberOfTargets, insert);
f -> numberOfTargets ++;
}
f -> targets [insert] = target;
f -> times [insert] = time;
} catch (MelderError) {
Melder_throw (me, U": target not set.");
}
}
double Artword_getTarget (Artword me, int feature, double time) {
ArtwordData f = & my data [feature];
double *times = f -> times, *targets = f -> targets;
int iTarget = f -> _iTarget;
if (! iTarget) iTarget = 1;
while (time > times [iTarget + 1] && iTarget < f -> numberOfTargets - 1)
iTarget ++;
while (time < times [iTarget] && iTarget > 1)
iTarget --;
f -> _iTarget = iTarget;
Melder_assert (iTarget > 0 && iTarget < f -> numberOfTargets);
return targets [iTarget] + (time - times [iTarget]) *
(targets [iTarget + 1] - targets [iTarget]) /
(times [iTarget + 1] - times [iTarget]);
}
void Artword_removeTarget (Artword me, int feature, int iTarget) {
ArtwordData f = & my data [feature];
Melder_assert (iTarget >= 1);
Melder_assert (iTarget <= f -> numberOfTargets);
if (iTarget == 1)
f -> targets [iTarget] = 0.0;
else if (iTarget == f -> numberOfTargets)
f -> targets [f -> numberOfTargets] = 0.0;
else {
for (int i = iTarget; i < f -> numberOfTargets; i ++) {
f -> times [i] = f -> times [i + 1];
f -> targets [i] = f -> targets [i + 1];
}
f -> numberOfTargets --;
}
f -> _iTarget = 1;
}
void Artword_intoArt (Artword me, Art art, double time) {
for (int feature = 1; feature <= kArt_muscle_MAX; feature ++) {
art -> art [feature] = Artword_getTarget (me, feature, time);
}
}
void Artword_draw (Artword me, Graphics g, int feature, bool garnish) {
long numberOfTargets = my data [feature]. numberOfTargets;
if (numberOfTargets > 0) {
autoNUMvector x (1, numberOfTargets);
autoNUMvector y (1, numberOfTargets);
Graphics_setInner (g);
Graphics_setWindow (g, 0, my totalTime, -1.0, 1.0);
for (int i = 1; i <= numberOfTargets; i ++) {
x [i] = my data [feature]. times [i];
y [i] = my data [feature]. targets [i];
}
Graphics_polyline (g, numberOfTargets, & x [1], & y [1]);
Graphics_unsetInner (g);
}
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksBottom (g, 2, true, true, false);
Graphics_marksLeft (g, 3, true, true, true);
Graphics_textTop (g, false, kArt_muscle_getText (feature));
Graphics_textBottom (g, true, U"Time (s)");
}
}
/* End of file Artword.cpp */
praat-6.0.23/artsynth/Artword.h 0000664 0000000 0000000 00000005001 13023464014 0016351 0 ustar 00root root 0000000 0000000 #ifndef _Artword_h_
#define _Artword_h_
/* Artword.h
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Articulation.h"
#include "Graphics.h"
#include "Artword_def.h"
autoArtword Artword_create (double totalTime);
void Artword_setDefault (Artword me, int feature);
/*
Postconditions:
my data [feature]. numberOfTargets == 2;
my data [feature]. times [1] == 0.0;
my data [feature]. times [2] == self -> totalTime;
my data [feature]. targets [1] == 0.0;
my data [feature]. targets [2] == 0.0;
rest unchanged;
*/
void Artword_setTarget (Artword me, int feature, double tim, double value);
double Artword_getTarget (Artword me, int feature, double tim);
void Artword_removeTarget (Artword me, int feature, int iTarget);
/*
Function:
remove one target from the target list of "feature".
If "iTarget" is the first or the last target in the list,
only set the target to zero (begin and end targets remain).
Preconditions:
self != nullptr;
feature in enum Art_MUSCLE;
iTarget >= 1;
iTarget <= self -> data [feature]. numberOfTargets;
Postconditions:
if (iTarget == 1)
self -> data [feature]. targets [1] == 0.0;
else if (iTarget == self -> data [feature]. numberOfTargets)
self -> data [feature]. targets [iTarget] == 0.0;
else
self -> data [feature]. numberOfTargets == old self -> data [feature]. numberOfTargets - 1;
for (i == iTarget..self -> data [feature]. numberOfTargets)
self -> data [feature]. times [i] == old self -> data [feature]. times [i + 1];
self -> data [feature]. targets [i] == old self -> data [feature]. targets [i + 1];
*/
void Artword_intoArt (Artword me, Art art, double tim);
/*
Function:
Linear interpolation between targets, into an existing Art.
Preconditions:
me != nullptr;
art != nullptr;
*/
void Artword_draw (Artword me, Graphics graphics, int feature, bool garnish);
/* End of file Artword.h */
#endif
praat-6.0.23/artsynth/ArtwordEditor.cpp 0000664 0000000 0000000 00000014171 13023464014 0020063 0 ustar 00root root 0000000 0000000 /* ArtwordEditor.cpp
*
* Copyright (C) 1992-2011,2013,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "ArtwordEditor.h"
#include "machine.h"
Thing_implement (ArtwordEditor, Editor, 0);
void structArtwordEditor :: v_destroy () noexcept {
ArtwordEditor_Parent :: v_destroy ();
}
static void updateList (ArtwordEditor me) {
Artword artword = (Artword) my data;
ArtwordData a = & artword -> data [my feature];
GuiList_deleteAllItems (my list);
for (int i = 1; i <= a -> numberOfTargets; i ++) {
GuiList_insertItem (my list,
Melder_cat (Melder_single (a -> times [i]), U" ", Melder_single (a -> targets [i])),
i);
}
Graphics_updateWs (my graphics.get());
}
static void gui_button_cb_removeTarget (ArtwordEditor me, GuiButtonEvent /* event */) {
Artword artword = (Artword) my data;
long numberOfSelectedPositions;
long *selectedPositions = GuiList_getSelectedPositions (my list, & numberOfSelectedPositions); // BUG memory
if (selectedPositions) {
for (long ipos = numberOfSelectedPositions; ipos > 0; ipos --)
Artword_removeTarget (artword, my feature, selectedPositions [ipos]);
}
NUMvector_free (selectedPositions, 1);
updateList (me);
Editor_broadcastDataChanged (me);
}
static void gui_button_cb_addTarget (ArtwordEditor me, GuiButtonEvent /* event */) {
Artword artword = (Artword) my data;
char32 *timeText = GuiText_getString (my time);
double tim = Melder_atof (timeText);
char32 *valueText = GuiText_getString (my value);
double value = Melder_atof (valueText);
ArtwordData a = & artword -> data [my feature];
int i = 1, oldCount = a -> numberOfTargets;
Melder_free (timeText);
Melder_free (valueText);
Artword_setTarget (artword, my feature, tim, value);
/* Optimization instead of "updateList (me)". */
if (tim < 0) tim = 0;
if (tim > artword -> totalTime) tim = artword -> totalTime;
while (tim != a -> times [i]) {
i ++;
Melder_assert (i <= a -> numberOfTargets); // can fail if tim is in an extended precision register
}
const char32 *itemText = Melder_cat (Melder_single (tim), U" ", Melder_single (value));
if (a -> numberOfTargets == oldCount) {
GuiList_replaceItem (my list, itemText, i);
} else {
GuiList_insertItem (my list, itemText, i);
}
Graphics_updateWs (my graphics.get());
Editor_broadcastDataChanged (me);
}
static void gui_radiobutton_cb_toggle (ArtwordEditor me, GuiRadioButtonEvent event) {
my feature = event -> position;
Melder_assert (my feature > 0);
Melder_assert (my feature <= kArt_muscle_MAX);
updateList (me);
}
static void gui_drawingarea_cb_expose (ArtwordEditor me, GuiDrawingArea_ExposeEvent /* event */) {
if (! my graphics) return;
Artword artword = (Artword) my data;
Graphics_clearWs (my graphics.get());
Artword_draw (artword, my graphics.get(), my feature, true);
}
static void gui_drawingarea_cb_click (ArtwordEditor me, GuiDrawingArea_ClickEvent event) {
if (! my graphics) return;
Artword artword = (Artword) my data;
Graphics_setWindow (my graphics.get(), 0, artword -> totalTime, -1.0, 1.0);
Graphics_setInner (my graphics.get());
double xWC, yWC;
Graphics_DCtoWC (my graphics.get(), event -> x, event -> y, & xWC, & yWC);
Graphics_unsetInner (my graphics.get());
GuiText_setString (my time, Melder_fixed (xWC, 6));
GuiText_setString (my value, Melder_fixed (yWC, 6));
}
void structArtwordEditor :: v_dataChanged () {
updateList (this);
Graphics_updateWs (graphics.get());
}
void structArtwordEditor :: v_createChildren () {
int dy = Machine_getMenuBarHeight ();
GuiLabel_createShown (d_windowForm, 40, 100, dy + 3, dy + 3 + Gui_LABEL_HEIGHT, U"Targets:", 0);
GuiLabel_createShown (d_windowForm, 5, 65, dy + 20, dy + 20 + Gui_LABEL_HEIGHT, U"Times:", 0);
GuiLabel_createShown (d_windowForm, 80, 140, dy + 20, dy + 20 + Gui_LABEL_HEIGHT, U"Values:", 0);
list = GuiList_createShown (d_windowForm, 0, 140, dy + 40, dy + 340, true, nullptr);
GuiButton_createShown (d_windowForm, 10, 130, dy + 410, dy + 410 + Gui_PUSHBUTTON_HEIGHT, U"Remove target", gui_button_cb_removeTarget, this, 0);
drawingArea = GuiDrawingArea_createShown (d_windowForm, 170, 470, dy + 10, dy + 310,
gui_drawingarea_cb_expose, gui_drawingarea_cb_click, nullptr, nullptr, this, 0);
GuiLabel_createShown (d_windowForm, 220, 270, dy + 340, dy + 340 + Gui_LABEL_HEIGHT, U"Time:", 0);
time = GuiText_createShown (d_windowForm, 270, 370, dy + 340, dy + 340 + Gui_TEXTFIELD_HEIGHT, 0);
GuiLabel_createShown (d_windowForm, 220, 270, dy + 370, dy + 370 + Gui_LABEL_HEIGHT, U"Value:", 0);
value = GuiText_createShown (d_windowForm, 270, 370, dy + 370, dy + 370 + Gui_TEXTFIELD_HEIGHT, 0);
GuiButton_createShown (d_windowForm, 240, 360, dy + 410, dy + 410 + Gui_PUSHBUTTON_HEIGHT, U"Add target", gui_button_cb_addTarget, this, GuiButton_DEFAULT);
dy = Machine_getMenuBarHeight ();
GuiRadioGroup_begin ();
for (int i = 1; i <= kArt_muscle_MAX; i ++) {
button [i] = GuiRadioButton_createShown (d_windowForm,
480, 0, dy, dy + Gui_RADIOBUTTON_HEIGHT,
kArt_muscle_getText (i), gui_radiobutton_cb_toggle, this, 0);
dy += Gui_RADIOBUTTON_HEIGHT + Gui_RADIOBUTTON_SPACING - 2;
}
GuiRadioGroup_end ();
feature = 1;
GuiRadioButton_set (button [feature]);
}
autoArtwordEditor ArtwordEditor_create (const char32 *title, Artword data) {
try {
autoArtwordEditor me = Thing_new (ArtwordEditor);
Editor_init (me.get(), 20, 40, 650, 600, title, data);
//XtUnmanageChild (my menuBar);
my graphics = Graphics_create_xmdrawingarea (my drawingArea);
updateList (me.get());
return me;
} catch (MelderError) {
Melder_throw (U"Artword window not created.");
}
}
/* End of file ArtwordEditor.cpp */
praat-6.0.23/artsynth/ArtwordEditor.h 0000664 0000000 0000000 00000002315 13023464014 0017525 0 ustar 00root root 0000000 0000000 #ifndef _ArtwordEditor_h_
#define _ArtwordEditor_h_
/* ArtwordEditor.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Editor.h"
#include "Artword.h"
Thing_define (ArtwordEditor, Editor) {
autoGraphics graphics;
int feature;
GuiList list;
GuiDrawingArea drawingArea;
GuiText time, value;
GuiRadioButton button [1 + kArt_muscle_MAX];
void v_destroy () noexcept
override;
void v_createChildren ()
override;
void v_dataChanged ()
override;
};
autoArtwordEditor ArtwordEditor_create (const char32 *title, Artword data);
/* End of file ArtwordEditor.h */
#endif
praat-6.0.23/artsynth/Artword_Speaker.cpp 0000664 0000000 0000000 00000003266 13023464014 0020371 0 ustar 00root root 0000000 0000000 /* Artword_Speaker.cpp
*
* Copyright (C) 1992-2011,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Art_Speaker.h"
#include "Artword_Speaker.h"
void Artword_Speaker_draw (Artword artword, Speaker speaker, Graphics g, int numberOfSteps) {
double oldLineWidth = Graphics_inqLineWidth (g);
autoArt art = Art_create ();
for (int i = 0; i <= numberOfSteps; i ++) {
Artword_intoArt (artword, art.get(), i * artword -> totalTime / numberOfSteps);
Graphics_setLineWidth (g, 2 + i + i);
Art_Speaker_draw (art.get(), speaker, g);
}
Graphics_setLineWidth (g, oldLineWidth);
}
void Artword_Speaker_movie (Artword artword, Speaker speaker, Graphics graphics) {
constexpr double timeStep = 0.03;
autoArt art = Art_create ();
for (double tim = 0.0; tim < artword -> totalTime; tim += timeStep) {
Artword_intoArt (artword, art.get(), tim);
Graphics_beginMovieFrame (graphics, & Graphics_WHITE);
Graphics_setWindow (graphics, 0.0, 1.0, 0.0, 1.0);
Art_Speaker_draw (art.get(), speaker, graphics);
Graphics_endMovieFrame (graphics, timeStep);
}
}
/* End of file Artword_Speaker.cpp */
praat-6.0.23/artsynth/Artword_Speaker.h 0000664 0000000 0000000 00000001722 13023464014 0020031 0 ustar 00root root 0000000 0000000 /* Artword_Speaker.h
*
* Copyright (C) 1992-2011 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Artword.h"
#include "Speaker.h"
#include "Graphics.h"
void Artword_Speaker_draw (Artword artword, Speaker speaker, Graphics g, int numberOfSteps);
void Artword_Speaker_movie (Artword artword, Speaker speaker, Graphics g);
/* End of file Artword_Speaker.h */
praat-6.0.23/artsynth/Artword_Speaker_Sound.cpp 0000664 0000000 0000000 00000004107 13023464014 0021534 0 ustar 00root root 0000000 0000000 /* Artword_Speaker_Sound.cpp
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Artword_Speaker_Sound.h"
#include "Artword_Speaker.h"
#include "Art_Speaker.h"
Thing_define (Artword_Speaker_Sound_PlayInfo, Thing) {
Artword artword;
Speaker speaker;
Graphics graphics;
};
Thing_implement (Artword_Speaker_Sound_PlayInfo, Thing, 0);
static int playCallback (Artword_Speaker_Sound_PlayInfo me, int /* phase */, double /* tmin */, double /* tmax */, double t) {
static autoArt art;
if (! art)
art = Art_create ();
Artword_intoArt (my artword, art.get(), t);
Graphics_beginMovieFrame (my graphics, & Graphics_WHITE);
Graphics_setWindow (my graphics, 0.0, 1.0, 0.0, 1.0);
Art_Speaker_draw (art.get(), my speaker, my graphics);
Graphics_endMovieFrame (my graphics, 0.0);
return 1;
}
void Artword_Speaker_Sound_movie (Artword artword, Speaker speaker, Sound sound, Graphics graphics) {
try {
static autoArtword_Speaker_Sound_PlayInfo info;
if (! info)
info = Thing_new (Artword_Speaker_Sound_PlayInfo);
info -> artword = artword;
info -> speaker = speaker;
info -> graphics = graphics;
if (sound) {
Sound_play (sound, playCallback, info.get());
} else {
autoSound silence = Sound_createSimple (1, artword -> totalTime, 44100.0);
Sound_play (silence.get(), playCallback, info.get());
}
} catch (MelderError) {
Melder_throw (artword, U" & ", speaker, U": movie not played.");
}
}
/* End of file Artword_Speaker_Sound.cpp */
praat-6.0.23/artsynth/Artword_Speaker_Sound.h 0000664 0000000 0000000 00000001630 13023464014 0021177 0 ustar 00root root 0000000 0000000 /* Artword_Speaker_Sound.h
*
* Copyright (C) 1992-2011 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Artword.h"
#include "Speaker.h"
#include "Sound.h"
void Artword_Speaker_Sound_movie
(Artword artword, Speaker speaker, Sound sound, Graphics graphics);
/* End of file Artword_Speaker_Sound.h */
praat-6.0.23/artsynth/Artword_Speaker_to_Sound.cpp 0000664 0000000 0000000 00000045732 13023464014 0022247 0 ustar 00root root 0000000 0000000 /* Artword_Speaker_to_Sound.cpp
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Speaker_to_Delta.h"
#include "Art_Speaker_Delta.h"
#include "Artword_Speaker_to_Sound.h"
#define Dymin 0.00001
#define criticalVelocity 10.0
#define noiseFactor 0.1
#define MONITOR_SAMPLES 100
/* While debugging, some of these can be 1; otherwise, they are all 0: */
#define EQUAL_TUBE_WIDTHS 0
#define CONSTANT_TUBE_LENGTHS 1
#define NO_MOVING_WALLS 0
#define NO_TURBULENCE 0
#define NO_RADIATION_DAMPING 0
#define NO_BERNOULLI_EFFECT 0
#define MASS_LEAPFROG 0
#define B91 0
autoSound Artword_Speaker_to_Sound (Artword artword, Speaker speaker,
double fsamp, int oversampling,
autoSound *out_w1, int iw1, autoSound *out_w2, int iw2, autoSound *out_w3, int iw3,
autoSound *out_p1, int ip1, autoSound *out_p2, int ip2, autoSound *out_p3, int ip3,
autoSound *out_v1, int iv1, autoSound *out_v2, int iv2, autoSound *out_v3, int iv3)
{
try {
autoSound result = Sound_createSimple (1, artword -> totalTime, fsamp);
long numberOfSamples = result -> nx;
double minTract [1+78], maxTract [1+78]; // for drawing
double Dt = 1.0 / fsamp / oversampling,
rho0 = 1.14,
c = 353.0,
onebyc2 = 1.0 / (c * c),
rho0c2 = rho0 * c * c,
halfDt = 0.5 * Dt,
twoDt = 2.0 * Dt,
halfc2Dt = 0.5 * c * c * Dt,
twoc2Dt = 2.0 * c * c * Dt,
onebytworho0 = 1.0 / (2.0 * rho0),
Dtbytworho0 = Dt / (2.0 * rho0);
double tension, rrad, onebygrad, totalVolume;
autoArt art = Art_create ();
autoDelta delta = Speaker_to_Delta (speaker);
autoMelderMonitor monitor (U"Articulatory synthesis");
Artword_intoArt (artword, art.get(), 0.0);
Art_Speaker_intoDelta (art.get(), speaker, delta.get());
int M = delta -> numberOfTubes;
autoSound w1, w2, w3, p1, p2, p3, v1, v2, v3;
if (iw1 > 0 && iw1 <= M) w1 = Sound_createSimple (1, artword -> totalTime, fsamp); else iw1 = 0;
if (iw2 > 0 && iw2 <= M) w2 = Sound_createSimple (1, artword -> totalTime, fsamp); else iw2 = 0;
if (iw3 > 0 && iw3 <= M) w3 = Sound_createSimple (1, artword -> totalTime, fsamp); else iw3 = 0;
if (ip1 > 0 && ip1 <= M) p1 = Sound_createSimple (1, artword -> totalTime, fsamp); else ip1 = 0;
if (ip2 > 0 && ip2 <= M) p2 = Sound_createSimple (1, artword -> totalTime, fsamp); else ip2 = 0;
if (ip3 > 0 && ip3 <= M) p3 = Sound_createSimple (1, artword -> totalTime, fsamp); else ip3 = 0;
if (iv1 > 0 && iv1 <= M) v1 = Sound_createSimple (1, artword -> totalTime, fsamp); else iv1 = 0;
if (iv2 > 0 && iv2 <= M) v2 = Sound_createSimple (1, artword -> totalTime, fsamp); else iv2 = 0;
if (iv3 > 0 && iv3 <= M) v3 = Sound_createSimple (1, artword -> totalTime, fsamp); else iv3 = 0;
/* Initialize drawing. */
for (int i = 1; i <= 78; i ++) {
minTract [i] = 100.0;
maxTract [i] = -100.0;
}
totalVolume = 0.0;
for (int m = 1; m <= M; m ++) {
Delta_Tube t = delta->tube + m;
if (! t -> left1 && ! t -> right1) continue;
t->Dx = t->Dxeq; t->dDxdt = 0.0; // 5.113 (numbers refer to equations in Boersma (1998)
t->Dy = t->Dyeq; t->dDydt = 0.0; // 5.113
t->Dz = t->Dzeq; // 5.113
t->A = t->Dz * ( t->Dy >= t->dy ? t->Dy + Dymin :
t->Dy <= - t->dy ? Dymin :
(t->dy + t->Dy) * (t->dy + t->Dy) / (4.0 * t->dy) + Dymin ); // 4.4, 4.5
#if EQUAL_TUBE_WIDTHS
t->A = 0.0001;
#endif
t->Jleft = t->Jright = 0.0; // 5.113
t->Qleft = t->Qright = rho0c2; // 5.113
t->pleft = t->pright = 0.0; // 5.114
t->Kleft = t->Kright = 0.0; // 5.114
t->V = t->A * t->Dx; // 5.114
totalVolume += t->V;
}
//Melder_casual (U"Starting volume: ", totalVolume * 1000, U" litres.");
for (long sample = 1; sample <= numberOfSamples; sample ++) {
double time = (sample - 1) / fsamp;
Artword_intoArt (artword, art.get(), time);
Art_Speaker_intoDelta (art.get(), speaker, delta.get());
if (sample % MONITOR_SAMPLES == 0 && monitor.graphics()) { // because we can be in batch
Graphics graphics = monitor.graphics();
double area [1+78];
for (int i = 1; i <= 78; i ++) {
area [i] = delta -> tube [i]. A;
if (area [i] < minTract [i]) minTract [i] = area [i];
if (area [i] > maxTract [i]) maxTract [i] = area [i];
}
Graphics_beginMovieFrame (graphics, & Graphics_WHITE);
Graphics_Viewport vp = Graphics_insetViewport (monitor.graphics(), 0.0, 0.5, 0.5, 1.0);
Graphics_setWindow (graphics, 0.0, 1.0, 0.0, 0.05);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 1, 35, 0.0, 0.9);
Graphics_function (graphics, maxTract, 1, 35, 0.0, 0.9);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 1, 35, 0.0, 0.9);
Graphics_setLineType (graphics, Graphics_DOTTED);
Graphics_line (graphics, 0.0, 0.0, 1.0, 0.0);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
vp = Graphics_insetViewport (graphics, 0, 0.5, 0, 0.5);
Graphics_setWindow (graphics, 0.0, 1.0, -0.000003, 0.00001);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 36, 37, 0.2, 0.8);
Graphics_function (graphics, maxTract, 36, 37, 0.2, 0.8);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 36, 37, 0.2, 0.8);
Graphics_setLineType (graphics, Graphics_DOTTED);
Graphics_line (graphics, 0.0, 0.0, 1.0, 0.0);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
vp = Graphics_insetViewport (graphics, 0.5, 1.0, 0.5, 1.0);
Graphics_setWindow (graphics, 0.0, 1.0, 0.0, 0.001);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 38, 64, 0.0, 1.0);
Graphics_function (graphics, maxTract, 38, 64, 0.0, 1.0);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 38, 64, 0.0, 1.0);
Graphics_setLineType (graphics, Graphics_DOTTED);
Graphics_line (graphics, 0.0, 0.0, 1.0, 0.0);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
vp = Graphics_insetViewport (graphics, 0.5, 1.0, 0.0, 0.5);
Graphics_setWindow (graphics, 0.0, 1.0, 0.001, 0.0);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 65, 78, 0.5, 1.0);
Graphics_function (graphics, maxTract, 65, 78, 0.5, 1.0);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 65, 78, 0.5, 1.0);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
Graphics_endMovieFrame (graphics, 0.0);
Melder_monitor ((double) sample / numberOfSamples, U"Articulatory synthesis: ", Melder_half (time), U" seconds");
}
for (int n = 1; n <= oversampling; n ++) {
for (int m = 1; m <= M; m ++) {
Delta_Tube t = delta -> tube + m;
if (! t -> left1 && ! t -> right1) continue;
/* New geometry. */
#if CONSTANT_TUBE_LENGTHS
t->Dxnew = t->Dx;
#else
t->dDxdtnew = (t->dDxdt + Dt * 10000.0 * (t->Dxeq - t->Dx)) /
(1.0 + 200.0 * Dt); // critical damping, 10 ms
t->Dxnew = t->Dx + t->dDxdtnew * Dt;
#endif
/* 3-way: equal lengths. */
/* This requires left tubes to be processed before right tubes. */
if (t->left1 && t->left1->right2) t->Dxnew = t->left1->Dxnew;
t->Dz = t->Dzeq; /* immediate... */
t->eleft = (t->Qleft - t->Kleft) * t->V; // 5.115
t->eright = (t->Qright - t->Kright) * t->V; // 5.115
t->e = 0.5 * (t->eleft + t->eright); // 5.116
t->p = 0.5 * (t->pleft + t->pright); // 5.116
t->DeltaP = t->e / t->V - rho0c2; // 5.117
t->v = t->p / (rho0 + onebyc2 * t->DeltaP); // 5.118
{
double dDy = t->Dyeq - t->Dy;
double cubic = t->k3 * dDy * dDy;
Delta_Tube l1 = t->left1, l2 = t->left2, r1 = t->right1, r2 = t->right2;
tension = dDy * (t->k1 + cubic);
t->B = 2.0 * t->Brel * sqrt (t->mass * (t->k1 + 3.0 * cubic));
if (t->k1left1 != 0.0 && l1)
tension += t->k1left1 * t->k1 * (dDy - (l1->Dyeq - l1->Dy));
if (t->k1left2 != 0.0 && l2)
tension += t->k1left2 * t->k1 * (dDy - (l2->Dyeq - l2->Dy));
if (t->k1right1 != 0.0 && r1)
tension += t->k1right1 * t->k1 * (dDy - (r1->Dyeq - r1->Dy));
if (t->k1right2 != 0.0 && r2)
tension += t->k1right2 * t->k1 * (dDy - (r2->Dyeq - r2->Dy));
}
if (t->Dy < t->dy) {
if (t->Dy >= - t->dy) {
double dDy = t->dy - t->Dy, dDy2 = dDy * dDy;
tension += dDy2 / (4.0 * t->dy) * (t->s1 + 0.5 * t->s3 * dDy2);
t->B += 2.0 * dDy / (2.0 * t->dy) *
sqrt (t->mass * (t->s1 + t->s3 * dDy2));
} else {
tension -= t->Dy * (t->s1 + t->s3 * (t->Dy * t->Dy + t->dy * t->dy));
t->B += 2.0 * sqrt (t->mass * (t->s1 + t->s3 * (3.0 * t->Dy * t->Dy + t->dy * t->dy)));
}
}
t->dDydtnew = (t->dDydt + Dt / t->mass * (tension + 2.0 * t->DeltaP * t->Dz * t->Dx)) /
(1.0 + t->B * Dt / t->mass); // 5.119
t->Dynew = t->Dy + t->dDydtnew * Dt; // 5.119
#if NO_MOVING_WALLS
t->Dynew = t->Dy;
#endif
t->Anew = t->Dz * ( t->Dynew >= t->dy ? t->Dynew + Dymin :
t->Dynew <= - t->dy ? Dymin :
(t->dy + t->Dynew) * (t->dy + t->Dynew) / (4.0 * t->dy) + Dymin ); // 4.4, 4.5
#if EQUAL_TUBE_WIDTHS
t->Anew = 0.0001;
#endif
t->Ahalf = 0.5 * (t->A + t->Anew); // 5.120
t->Dxhalf = 0.5 * (t->Dxnew + t->Dx); // 5.121
t->Vnew = t->Anew * t->Dxnew; // 5.128
{ double oneByDyav = t->Dz / t->A;
/*t->R = 12.0 * 1.86e-5 * t->parallel * t->parallel * oneByDyav * oneByDyav;*/
if (t->Dy < 0.0)
t->R = 12.0 * 1.86e-5 / (Dymin * Dymin + t->dy * t->dy);
else
t->R = 12.0 * 1.86e-5 * t->parallel * t->parallel /
((t->Dy + Dymin) * (t->Dy + Dymin) + t->dy * t->dy);
t->R += 0.3 * t->parallel * oneByDyav; /* 5.23 */ }
t->r = (1.0 + t->R * Dt / rho0) * t->Dxhalf / t->Anew; // 5.122
t->ehalf = t->e + halfc2Dt * (t->Jleft - t->Jright); // 5.123
t->phalf = (t->p + halfDt * (t->Qleft - t->Qright) / t->Dx) / (1.0 + Dtbytworho0 * t->R); // 5.123
#if MASS_LEAPFROG
t->ehalf = t->ehalfold + 2.0 * halfc2Dt * (t->Jleft - t->Jright);
#endif
t->Jhalf = t->phalf * t->Ahalf; // 5.124
t->Qhalf = t->ehalf / (t->Ahalf * t->Dxhalf) + onebytworho0 * t->phalf * t->phalf; // 5.124
#if NO_BERNOULLI_EFFECT
t->Qhalf = t->ehalf / (t->Ahalf * t->Dxhalf);
#endif
}
for (int m = 1; m <= M; m ++) { // compute Jleftnew and Qleftnew
Delta_Tube l = delta->tube + m, r1 = l -> right1, r2 = l -> right2, r = r1;
Delta_Tube l1 = l, l2 = r ? r -> left2 : nullptr;
if (! l->left1) { // closed boundary at the left side (diaphragm)?
if (! r) continue; // tube not connected at all
l->Jleftnew = 0; // 5.132
l->Qleftnew = (l->eleft - twoc2Dt * l->Jhalf) / l->Vnew; // 5.132
}
else // left boundary open to another tube will be handled...
(void) 0; // ...together with the right boundary of the tube to the left
if (! r) { // open boundary at the right side (lips, nostrils)?
rrad = 1.0 - c * Dt / 0.02; // radiation resistance, 5.135
onebygrad = 1.0 / (1.0 + c * Dt / 0.02); // radiation conductance, 5.135
#if NO_RADIATION_DAMPING
rrad = 0;
onebygrad = 0;
#endif
l->prightnew = ((l->Dxhalf / Dt + c * onebygrad) * l->pright +
2.0 * ((l->Qhalf - rho0c2) - (l->Qright - rho0c2) * onebygrad)) /
(l->r * l->Anew / Dt + c * onebygrad); // 5.136
l->Jrightnew = l->prightnew * l->Anew; // 5.136
l->Qrightnew = (rrad * (l->Qright - rho0c2) +
c * (l->prightnew - l->pright)) * onebygrad + rho0c2; // 5.136
} else if (! l2 && ! r2) { // two-way boundary
if (l->v > criticalVelocity && l->A < r->A) {
l->Pturbrightnew = -0.5 * rho0 * (l->v - criticalVelocity) *
(1.0 - l->A / r->A) * (1.0 - l->A / r->A) * l->v;
if (l->Pturbrightnew != 0.0)
l->Pturbrightnew *= NUMrandomGauss (1.0, noiseFactor) /* * l->A */;
}
if (r->v < - criticalVelocity && r->A < l->A) {
l->Pturbrightnew = 0.5 * rho0 * (r->v + criticalVelocity) *
(1.0 - r->A / l->A) * (1.0 - r->A / l->A) * r->v;
if (l->Pturbrightnew != 0.0)
l->Pturbrightnew *= NUMrandomGauss (1.0, noiseFactor) /* * r->A */;
}
#if NO_TURBULENCE
l->Pturbrightnew = 0.0;
#endif
l->Jrightnew = r->Jleftnew =
(l->Dxhalf * l->pright + r->Dxhalf * r->pleft +
twoDt * (l->Qhalf - r->Qhalf + l->Pturbright)) /
(l->r + r->r); // 5.127
#if B91
l->Jrightnew = r->Jleftnew =
(l->pright + r->pleft +
2.0 * twoDt * (l->Qhalf - r->Qhalf + l->Pturbright) / (l->Dxhalf + r->Dxhalf)) /
(l->r / l->Dxhalf + r->r / r->Dxhalf);
#endif
l->prightnew = l->Jrightnew / l->Anew; // 5.128
r->pleftnew = r->Jleftnew / r->Anew; // 5.128
l->Krightnew = onebytworho0 * l->prightnew * l->prightnew; // 5.128
r->Kleftnew = onebytworho0 * r->pleftnew * r->pleftnew; // 5.128
#if NO_BERNOULLI_EFFECT
l->Krightnew = r->Kleftnew = 0.0;
#endif
l->Qrightnew =
(l->eright + r->eleft + twoc2Dt * (l->Jhalf - r->Jhalf)
+ l->Krightnew * l->Vnew + (r->Kleftnew - l->Pturbrightnew) * r->Vnew) /
(l->Vnew + r->Vnew); // 5.131
r->Qleftnew = l->Qrightnew + l->Pturbrightnew; // 5.131
} else if (r2) { // two adjacent tubes at the right side (velic)
r1->Jleftnew =
(r1->Jleft * r1->Dxhalf * (1.0 / (l->A + r2->A) + 1.0 / r1->A) +
twoDt * ((l->Ahalf * l->Qhalf + r2->Ahalf * r2->Qhalf ) / (l->Ahalf + r2->Ahalf) - r1->Qhalf)) /
(1.0 / (1.0 / l->r + 1.0 / r2->r) + r1->r); // 5.138
r2->Jleftnew =
(r2->Jleft * r2->Dxhalf * (1.0 / (l->A + r1->A) + 1.0 / r2->A) +
twoDt * ((l->Ahalf * l->Qhalf + r1->Ahalf * r1->Qhalf ) / (l->Ahalf + r1->Ahalf) - r2->Qhalf)) /
(1.0 / (1.0 / l->r + 1.0 / r1->r) + r2->r); // 5.138
l->Jrightnew = r1->Jleftnew + r2->Jleftnew; // 5.139
l->prightnew = l->Jrightnew / l->Anew; // 5.128
r1->pleftnew = r1->Jleftnew / r1->Anew; // 5.128
r2->pleftnew = r2->Jleftnew / r2->Anew; // 5.128
l->Krightnew = onebytworho0 * l->prightnew * l->prightnew; // 5.128
r1->Kleftnew = onebytworho0 * r1->pleftnew * r1->pleftnew; // 5.128
r2->Kleftnew = onebytworho0 * r2->pleftnew * r2->pleftnew; // 5.128
#if NO_BERNOULLI_EFFECT
l->Krightnew = r1->Kleftnew = r2->Kleftnew = 0;
#endif
l->Qrightnew = r1->Qleftnew = r2->Qleftnew =
(l->eright + r1->eleft + r2->eleft + twoc2Dt * (l->Jhalf - r1->Jhalf - r2->Jhalf) +
l->Krightnew * l->Vnew + r1->Kleftnew * r1->Vnew + r2->Kleftnew * r2->Vnew) /
(l->Vnew + r1->Vnew + r2->Vnew); // 5.137
} else {
Melder_assert (l2 != nullptr);
l1->Jrightnew =
(l1->Jright * l1->Dxhalf * (1.0 / (r->A + l2->A) + 1.0 / l1->A) -
twoDt * ((r->Ahalf * r->Qhalf + l2->Ahalf * l2->Qhalf ) / (r->Ahalf + l2->Ahalf) - l1->Qhalf)) /
(1.0 / (1.0 / r->r + 1.0 / l2->r) + l1->r); // 5.138
l2->Jrightnew =
(l2->Jright * l2->Dxhalf * (1.0 / (r->A + l1->A) + 1.0 / l2->A) -
twoDt * ((r->Ahalf * r->Qhalf + l1->Ahalf * l1->Qhalf ) / (r->Ahalf + l1->Ahalf) - l2->Qhalf)) /
(1.0 / (1.0 / r->r + 1.0 / l1->r) + l2->r); // 5.138
r->Jleftnew = l1->Jrightnew + l2->Jrightnew; // 5.139
r->pleftnew = r->Jleftnew / r->Anew; // 5.128
l1->prightnew = l1->Jrightnew / l1->Anew; // 5.128
l2->prightnew = l2->Jrightnew / l2->Anew; // 5.128
r->Kleftnew = onebytworho0 * r->pleftnew * r->pleftnew; // 5.128
l1->Krightnew = onebytworho0 * l1->prightnew * l1->prightnew; // 5.128
l2->Krightnew = onebytworho0 * l2->prightnew * l2->prightnew; // 5.128
#if NO_BERNOULLI_EFFECT
r->Kleftnew = l1->Krightnew = l2->Krightnew = 0.0;
#endif
r->Qleftnew = l1->Qrightnew = l2->Qrightnew =
(r->eleft + l1->eright + l2->eright + twoc2Dt * (l1->Jhalf + l2->Jhalf - r->Jhalf) +
r->Kleftnew * r->Vnew + l1->Krightnew * l1->Vnew + l2->Krightnew * l2->Vnew) /
(r->Vnew + l1->Vnew + l2->Vnew); // 5.137
}
}
/* Save some results. */
if (n == (oversampling + 1) / 2) {
double out = 0.0;
for (int m = 1; m <= M; m ++) {
Delta_Tube t = delta->tube + m;
out += rho0 * t->Dx * t->Dz * t->dDydt * Dt * 1000.0; // radiation of wall movement, 5.140
if (! t->right1)
out += t->Jrightnew - t->Jright; // radiation of open tube end
}
result -> z [1] [sample] = out /= 4.0 * NUMpi * 0.4 * Dt; // at 0.4 metres
if (iw1) w1 -> z [1] [sample] = delta->tube[iw1].Dy;
if (iw2) w2 -> z [1] [sample] = delta->tube[iw2].Dy;
if (iw3) w3 -> z [1] [sample] = delta->tube[iw3].Dy;
if (ip1) p1 -> z [1] [sample] = delta->tube[ip1].DeltaP;
if (ip2) p2 -> z [1] [sample] = delta->tube[ip2].DeltaP;
if (ip3) p3 -> z [1] [sample] = delta->tube[ip3].DeltaP;
if (iv1) v1 -> z [1] [sample] = delta->tube[iv1].v;
if (iv2) v2 -> z [1] [sample] = delta->tube[iv2].v;
if (iv3) v3 -> z [1] [sample] = delta->tube[iv3].v;
}
for (int m = 1; m <= M; m ++) {
Delta_Tube t = delta->tube + m;
t->Jleft = t->Jleftnew;
t->Jright = t->Jrightnew;
t->Qleft = t->Qleftnew;
t->Qright = t->Qrightnew;
t->Dy = t->Dynew;
t->dDydt = t->dDydtnew;
t->A = t->Anew;
t->Dx = t->Dxnew;
t->dDxdt = t->dDxdtnew;
t->eleft = t->eleftnew;
t->eright = t->erightnew;
#if MASS_LEAPFROG
t->ehalfold = t->ehalf;
#endif
t->pleft = t->pleftnew;
t->pright = t->prightnew;
t->Kleft = t->Kleftnew;
t->Kright = t->Krightnew;
t->V = t->Vnew;
t->Pturbright = t->Pturbrightnew;
}
}
}
totalVolume = 0.0;
for (int m = 1; m <= M; m ++)
totalVolume += delta->tube [m]. V;
//Melder_casual (U"Ending volume: ", totalVolume * 1000, U" litres.");
if (out_w1) *out_w1 = w1.move();
if (out_w2) *out_w2 = w2.move();
if (out_w3) *out_w3 = w3.move();
if (out_p1) *out_p1 = p1.move();
if (out_p2) *out_p2 = p2.move();
if (out_p3) *out_p3 = p3.move();
if (out_v1) *out_v1 = v1.move();
if (out_v2) *out_v2 = v2.move();
if (out_v3) *out_v3 = v3.move();
return result;
} catch (MelderError) {
Melder_throw (artword, U" & ", speaker, U": articulatory synthesis not performed.");
}
}
/* End of file Artword_Speaker_to_Sound.cpp */
praat-6.0.23/artsynth/Artword_Speaker_to_Sound.h 0000664 0000000 0000000 00000002224 13023464014 0021701 0 ustar 00root root 0000000 0000000 /* Artword_Speaker_to_Sound.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Artword.h"
#include "Speaker.h"
#include "Sound.h"
autoSound Artword_Speaker_to_Sound (Artword artword, Speaker speaker,
double samplingFrequency, int oversampling,
autoSound *w1, int iw1, autoSound *w2, int iw2, autoSound *w3, int iw3,
autoSound *p1, int ip1, autoSound *p2, int ip2, autoSound *p3, int ip3,
autoSound *v1, int iv1, autoSound *v2, int iv2, autoSound *v3, int iv3);
/* End of file Artword_Speaker_to_Sound.h */
praat-6.0.23/artsynth/Artword_def.h 0000664 0000000 0000000 00000002236 13023464014 0017176 0 ustar 00root root 0000000 0000000 /* Artword_def.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT ArtwordData
oo_DEFINE_STRUCT (ArtwordData)
oo_INT (numberOfTargets)
oo_DOUBLE_VECTOR (targets, numberOfTargets)
oo_DOUBLE_VECTOR (times, numberOfTargets)
#if oo_DECLARING
oo_INT (_iTarget)
#endif
oo_END_STRUCT (ArtwordData)
#undef ooSTRUCT
#define ooSTRUCT Artword
oo_DEFINE_CLASS (Artword, Daata)
oo_DOUBLE (totalTime)
oo_STRUCT_SET (ArtwordData, data, kArt_muscle)
oo_END_CLASS (Artword)
#undef ooSTRUCT
/* End of file Artword_def.h */
praat-6.0.23/artsynth/Artword_to_Art.cpp 0000664 0000000 0000000 00000001772 13023464014 0020227 0 ustar 00root root 0000000 0000000 /* Artword_to_Art.cpp
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Artword_to_Art.h"
autoArt Artword_to_Art (Artword me, double tim) {
try {
autoArt thee = Art_create ();
Artword_intoArt (me, thee.get(), tim);
return thee;
} catch (MelderError) {
Melder_throw (me, U": not converted to Articulation.");
}
}
/* End of file Artword_to_Art.cpp */
praat-6.0.23/artsynth/Artword_to_Art.h 0000664 0000000 0000000 00000001555 13023464014 0017673 0 ustar 00root root 0000000 0000000 /* Artword_to_Art.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Artword.h"
autoArt Artword_to_Art (Artword me, double time);
/*
Function:
linear interpolation between targets.
*/
/* End of file Artword_to_Art.h */
praat-6.0.23/artsynth/Delta.cpp 0000664 0000000 0000000 00000002511 13023464014 0016316 0 ustar 00root root 0000000 0000000 /* Delta.cpp
*
* Copyright (C) 1992-2011,2012,2013,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Delta.h"
Thing_implement (Delta, Thing, 0);
void structDelta :: v_destroy () noexcept {
NUMvector_free (our tube, 1);
Delta_Parent :: v_destroy ();
}
void Delta_init (Delta me, int numberOfTubes) {
Melder_assert (numberOfTubes >= 1);
my numberOfTubes = numberOfTubes;
my tube = NUMvector (1, numberOfTubes);
for (int itube = 1; itube <= numberOfTubes; itube ++) {
Delta_Tube t = & my tube [itube];
t -> parallel = 1;
}
}
autoDelta Delta_create (int numberOfTubes) {
autoDelta me = Thing_new (Delta);
Delta_init (me.get(), numberOfTubes);
return me;
}
/* End of file Delta.cpp */
praat-6.0.23/artsynth/Delta.h 0000664 0000000 0000000 00000004576 13023464014 0016000 0 ustar 00root root 0000000 0000000 #ifndef _Delta_h_
#define _Delta_h_
/* Delta.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Thing.h"
typedef struct structDelta_Tube *Delta_Tube;
struct structDelta_Tube
{
/* Structure: static. */
Delta_Tube left1; /* If null: closed at left edge. */
Delta_Tube left2; /* If not null: two merging streams. */
Delta_Tube right1; /* If null: radiation at right edge. */
Delta_Tube right2; /* If not null: a stream splitting into two. */
long parallel; /* Parallel subdivision. */
/* Controlled by articulation: quasistatic. */
double Dxeq, Dyeq, Dzeq;
double mass, k1, k3, Brel, s1, s3, dy;
double k1left1, k1left2, k1right1, k1right2; /* Linear coupling factors. */
double k3left1, k3left2, k3right1, k3right2; /* Cubic coupling factors. */
/* Dynamic. */
double Jhalf, Jleft, Jleftnew, Jright, Jrightnew;
double Qhalf, Qleft, Qleftnew, Qright, Qrightnew;
double Dx, Dxnew, dDxdt, dDxdtnew, Dxhalf;
double Dy, Dynew, dDydt, dDydtnew;
double Dz;
double A, Ahalf, Anew, V, Vnew;
double e, ehalf, eleft, eleftnew, eright, erightnew, ehalfold;
double p, phalf, pleft, pleftnew, pright, prightnew;
double Kleft, Kleftnew, Kright, Krightnew, Pturbright, Pturbrightnew;
double B, r, R, DeltaP, v;
};
Thing_define (Delta, Thing) {
int numberOfTubes; // >= 1
struct structDelta_Tube *tube; // tube [1..numberOfTubes]
void v_destroy () noexcept
override;
};
void Delta_init (Delta me, int numberOfTubes);
autoDelta Delta_create (int numberOfTubes);
/*
Function:
return a new Delta.
Preconditions:
numberOfTubes >= 1;
Postconditions:
result -> numberOfTubes = numberOfTubes;
all members of result -> tube [1..numberOfTubes] are zero or null,
except 'parallel', which is 1.
*/
/* End of file Delta.h */
#endif
praat-6.0.23/artsynth/Makefile 0000664 0000000 0000000 00000001324 13023464014 0016222 0 ustar 00root root 0000000 0000000 # Makefile of the library "artsynth"
# Paul Boersma, 24 August 2013
include ../makefile.defs
CPPFLAGS = -I ../num -I ../sys -I ../fon -I ../stat
OBJECTS = Speaker.o Articulation.o Artword.o \
Art_Speaker.o Art_Speaker_to_VocalTract.o Artword_Speaker.o Artword_Speaker_Sound.o \
Artword_Speaker_to_Sound.o Artword_to_Art.o \
Delta.o Speaker_to_Delta.o Art_Speaker_Delta.o \
ArtwordEditor.o praat_Artsynth.o manual_Artsynth.o
.PHONY: all clean
all: libartsynth.a
clean:
$(RM) $(OBJECTS)
$(RM) libartsynth.a
libartsynth.a: $(OBJECTS)
touch libartsynth.a
rm libartsynth.a
$(AR) cq libartsynth.a $(OBJECTS)
$(RANLIB) libartsynth.a
$(OBJECTS): *.h ../num/NUM.h ../sys/*.h ../fon/*.h ../stat/*.h
praat-6.0.23/artsynth/Speaker.cpp 0000664 0000000 0000000 00000010672 13023464014 0016666 0 ustar 00root root 0000000 0000000 /* Speaker.cpp
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Speaker.h"
#include "oo_DESTROY.h"
#include "Speaker_def.h"
#include "oo_COPY.h"
#include "Speaker_def.h"
#include "oo_EQUAL.h"
#include "Speaker_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "Speaker_def.h"
#include "oo_WRITE_TEXT.h"
#include "Speaker_def.h"
#include "oo_READ_TEXT.h"
#include "Speaker_def.h"
#include "oo_WRITE_BINARY.h"
#include "Speaker_def.h"
#include "oo_READ_BINARY.h"
#include "Speaker_def.h"
#include "oo_DESCRIPTION.h"
#include "Speaker_def.h"
Thing_implement (Speaker, Daata, 0);
autoSpeaker Speaker_create (const char32 *kindOfSpeaker, int numberOfVocalCordMasses) {
autoSpeaker me = Thing_new (Speaker);
/* Supralaryngeal dimensions are taken from P. Mermelstein (1973): */
/* "Articulatory model for the study of speech production", */
/* Journal of the Acoustical Society of America 53,1070 - 1082. */
/* That was a male speaker, so we need scaling for other speakers: */
double scaling;
if (str32equ (kindOfSpeaker, U"Male")) my relativeSize = 1.1;
else if (str32equ (kindOfSpeaker, U"Child")) my relativeSize = 0.7;
else my relativeSize = 1.0;
scaling = my relativeSize;
/* Laryngeal system. Data for male speaker from Ishizaka and Flanagan. */
if (str32equ (kindOfSpeaker, U"Female")) {
my lowerCord.thickness = 1.4e-3; // dx, in metres
my upperCord.thickness = 0.7e-3;
my cord.length = 10e-3;
my lowerCord.mass = 0.02e-3; // kilograms
my upperCord.mass = 0.01e-3;
my lowerCord.k1 = 10; // Newtons per metre
my upperCord.k1 = 4;
} else if (str32equ (kindOfSpeaker, U"Male")) {
my lowerCord.thickness = 2.0e-3; // dx, in metres
my upperCord.thickness = 1.0e-3;
my cord.length = 18e-3;
my lowerCord.mass = 0.1e-3; // kilograms
my upperCord.mass = 0.05e-3;
my lowerCord.k1 = 12; // Newtons per metre
my upperCord.k1 = 4;
} else /* "Child" */ {
my lowerCord.thickness = 0.7e-3; // dx, in metres
my upperCord.thickness = 0.3e-3;
my cord.length = 6e-3;
my lowerCord.mass = 0.003e-3; // kilograms
my upperCord.mass = 0.002e-3;
my lowerCord.k1 = 6; // Newtons per metre
my upperCord.k1 = 2;
}
my cord.numberOfMasses = numberOfVocalCordMasses;
if (numberOfVocalCordMasses == 1) {
my lowerCord.thickness += my upperCord.thickness;
my lowerCord.mass += my upperCord.mass;
my lowerCord.k1 += my upperCord.k1;
}
/* Supralaryngeal system. Data from Mermelstein. */
my velum.x = -0.031 * scaling;
my velum.y = 0.023 * scaling;
my velum.a = atan2 (my velum.y, my velum.x);
my palate.radius = sqrt (my velum.x * my velum.x + my velum.y * my velum.y);
my tip.length = 0.034 * scaling;
my neutralBodyDistance = 0.086 * scaling;
my alveoli.x = 0.024 * scaling;
my alveoli.y = 0.0302 * scaling;
my alveoli.a = atan2 (my alveoli.y, my alveoli.x);
my teethCavity.dx1 = -0.009 * scaling;
my teethCavity.dx2 = -0.004 * scaling;
my teethCavity.dy = -0.011 * scaling;
my lowerTeeth.a = -0.30; // radians
my lowerTeeth.r = 0.113 * scaling; // metres
my upperTeeth.x = 0.036 * scaling;
my upperTeeth.y = 0.026 * scaling;
my lowerLip.dx = 0.010 * scaling;
my lowerLip.dy = -0.004 * scaling;
my upperLip.dx = 0.010 * scaling;
my upperLip.dy = 0.004 * scaling;
my nose.Dx = 0.007 * scaling;
my nose.Dz = 0.014 * scaling;
my nose.weq [0] = 0.018 * scaling;
my nose.weq [1] = 0.016 * scaling;
my nose.weq [2] = 0.014 * scaling;
my nose.weq [3] = 0.020 * scaling;
my nose.weq [4] = 0.023 * scaling;
my nose.weq [5] = 0.020 * scaling;
my nose.weq [6] = 0.035 * scaling;
my nose.weq [7] = 0.035 * scaling;
my nose.weq [8] = 0.030 * scaling;
my nose.weq [9] = 0.022 * scaling;
my nose.weq [10] = 0.016 * scaling;
my nose.weq [11] = 0.010 * scaling;
my nose.weq [12] = 0.012 * scaling;
my nose.weq [13] = 0.013 * scaling;
return me;
}
/* End of file Speaker.cpp */
praat-6.0.23/artsynth/Speaker.h 0000664 0000000 0000000 00000002103 13023464014 0016321 0 ustar 00root root 0000000 0000000 #ifndef _Speaker_h_
#define _Speaker_h_
/* Speaker.h
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Data.h"
#include "Speaker_def.h"
autoSpeaker Speaker_create (const char32 *kindOfSpeaker, int numberOfVocalCordMasses);
/* Preconditions: */
/* 1 <= numberOfVocalCordMasses <= 2; */
/* Failures: */
/* Kind of speaker is not one of "Female", "Male", or "Child". */
/* End of file Speaker.h */
#endif
praat-6.0.23/artsynth/Speaker_def.h 0000664 0000000 0000000 00000006757 13023464014 0017162 0 ustar 00root root 0000000 0000000 /* Speaker_def.h
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT Speaker_CordDimensions
oo_DEFINE_STRUCT (Speaker_CordDimensions)
oo_INT (numberOfMasses)
oo_DOUBLE (length)
oo_END_STRUCT (Speaker_CordDimensions)
#undef ooSTRUCT
#define ooSTRUCT Speaker_CordSpring
oo_DEFINE_STRUCT (Speaker_CordSpring)
oo_DOUBLE (thickness)
oo_DOUBLE (mass)
oo_DOUBLE (k1)
oo_END_STRUCT (Speaker_CordSpring)
#undef ooSTRUCT
#define ooSTRUCT Speaker_GlottalShunt
oo_DEFINE_STRUCT (Speaker_GlottalShunt)
oo_DOUBLE (Dx)
oo_DOUBLE (Dy)
oo_DOUBLE (Dz)
oo_END_STRUCT (Speaker_GlottalShunt)
#undef ooSTRUCT
#define ooSTRUCT Speaker_Velum
oo_DEFINE_STRUCT (Speaker_Velum) // V
oo_DOUBLE (x)
oo_DOUBLE (y)
oo_DOUBLE (a)
oo_END_STRUCT (Speaker_Velum)
#undef ooSTRUCT
#define ooSTRUCT Speaker_Palate
oo_DEFINE_STRUCT (Speaker_Palate) // OM
oo_DOUBLE (radius)
oo_END_STRUCT (Speaker_Palate)
#undef ooSTRUCT
#define ooSTRUCT Speaker_Tip
oo_DEFINE_STRUCT (Speaker_Tip)
oo_DOUBLE (length)
oo_END_STRUCT (Speaker_Tip)
#undef ooSTRUCT
#define ooSTRUCT Speaker_Alveoli
oo_DEFINE_STRUCT (Speaker_Alveoli)
oo_DOUBLE (x)
oo_DOUBLE (y)
oo_DOUBLE (a)
oo_END_STRUCT (Speaker_Alveoli)
#undef ooSTRUCT
#define ooSTRUCT Speaker_TeethCavity
oo_DEFINE_STRUCT (Speaker_TeethCavity)
oo_DOUBLE (dx1)
oo_DOUBLE (dx2)
oo_DOUBLE (dy)
oo_END_STRUCT (Speaker_TeethCavity)
#undef ooSTRUCT
#define ooSTRUCT Speaker_LowerTeeth
oo_DEFINE_STRUCT (Speaker_LowerTeeth) // rest position of J
oo_DOUBLE (r)
oo_DOUBLE (a)
oo_END_STRUCT (Speaker_LowerTeeth)
#undef ooSTRUCT
#define ooSTRUCT Speaker_UpperTeeth
oo_DEFINE_STRUCT (Speaker_UpperTeeth) // U
oo_DOUBLE (x)
oo_DOUBLE (y)
oo_END_STRUCT (Speaker_UpperTeeth)
#undef ooSTRUCT
#define ooSTRUCT Speaker_Lip
oo_DEFINE_STRUCT (Speaker_Lip)
oo_DOUBLE (dx)
oo_DOUBLE (dy)
oo_END_STRUCT (Speaker_Lip)
#undef ooSTRUCT
#define ooSTRUCT Speaker_Nose
oo_DEFINE_STRUCT (Speaker_Nose)
oo_DOUBLE (Dx)
oo_DOUBLE (Dz)
oo_DOUBLE_ARRAY (weq, 14, 14)
oo_END_STRUCT (Speaker_Nose)
#undef ooSTRUCT
#define ooSTRUCT Speaker
oo_DEFINE_CLASS (Speaker, Daata)
oo_DOUBLE (relativeSize) // different for female, male, child
/* In the larynx. */
oo_STRUCT (Speaker_CordDimensions, cord)
oo_STRUCT (Speaker_CordSpring, lowerCord)
oo_STRUCT (Speaker_CordSpring, upperCord)
oo_STRUCT (Speaker_GlottalShunt, shunt)
/* Above the larynx. */
oo_STRUCT (Speaker_Velum, velum)
oo_STRUCT (Speaker_Palate, palate)
oo_STRUCT (Speaker_Tip, tip)
oo_DOUBLE (neutralBodyDistance)
oo_STRUCT (Speaker_Alveoli, alveoli)
oo_STRUCT (Speaker_TeethCavity, teethCavity)
oo_STRUCT (Speaker_LowerTeeth, lowerTeeth)
oo_STRUCT (Speaker_UpperTeeth, upperTeeth)
oo_STRUCT (Speaker_Lip, lowerLip)
oo_STRUCT (Speaker_Lip, upperLip)
/* In the nasal cavity. */
oo_STRUCT (Speaker_Nose, nose)
oo_END_CLASS (Speaker)
#undef ooSTRUCT
/* End of file Speaker_def.h */
praat-6.0.23/artsynth/Speaker_to_Delta.cpp 0000664 0000000 0000000 00000032552 13023464014 0020502 0 ustar 00root root 0000000 0000000 /* Speaker_to_Delta.cpp
*
* Copyright (C) 1992-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Art_Speaker.h"
#include "Speaker_to_Delta.h"
#define SMOOTH_LUNGS true
#define FIRST_TUBE 7
autoDelta Speaker_to_Delta (Speaker me) {
double f = my relativeSize * 1e-3; // we shall use millimetres and grams
double xe [30], ye [30], xi [30], yi [30], xmm [30], ymm [30], dx, dy;
int closed [40];
int itube;
autoDelta thee = Delta_create (89);
Melder_assert (my cord.numberOfMasses == 1 || my cord.numberOfMasses == 2 || my cord.numberOfMasses == 10);
/* Lungs: tubes 1..23. */
for (itube = 1; itube <= 23; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dx = t -> Dxeq = 10.0 * f;
t -> Dy = t -> Dyeq = 100.0 * f;
t -> Dz = t -> Dzeq = 230.0 * f;
t -> mass = 10.0 * my relativeSize * t -> Dx * t -> Dz; // 80 * f; 35 * Dx * Dz
t -> k1 = 200.0; // 90000 * Dx * Dz; Newtons per metre
t -> k3 = 0.0;
t -> Brel = 0.8;
t -> parallel = 1000;
}
/* Bronchi: tubes 24..29. */
for (itube = 24; itube <= 29; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dx = t -> Dxeq = 10.0 * f;
t -> Dy = t -> Dyeq = 15.0 * f;
t -> Dz = t -> Dzeq = 30.0 * f;
t -> mass = 10.0 * f;
t -> k1 = 40.0; // 125000 * Dx * Dz; Newtons per metre
t -> k3 = 0.0;
t -> Brel = 0.8;
}
/* Trachea: tubes 30..35; four of these may be replaced by conus elasticus (see below). */
for (itube = 30; itube <= 35; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dx = t -> Dxeq = 10.0 * f;
t -> Dy = t -> Dyeq = 15.0 * f;
t -> Dz = t -> Dzeq = 16.0 * f;
t -> mass = 5.0 * f;
t -> k1 = 160.0; // 100000 * Dx * Dz; Newtons per metre
t -> k3 = 0.0;
t -> Brel = 0.8;
}
if (SMOOTH_LUNGS) {
struct { int itube; double Dy, Dz, parallel; } data [] = {
{ 7, 120.0, 240.0, 5000.0 }, { 8, 120.0, 240.0, 5000.0 }, { 9, 120.0, 240.0, 5000.0 },
{ 10, 120.0, 240.0, 5000.0 }, { 11, 120.0, 240.0, 5000.0 }, { 12, 120.0, 240.0, 5000.0 },
{ 13, 120.0, 240.0, 2500.0 }, { 14, 120.0, 240.0, 1250.0 }, { 15, 120.0, 240.0, 640.0 },
{ 16, 120.0, 240.0, 320.0 }, { 17, 120.0, 240.0, 160.0 }, { 18, 120.0, 140.0, 80.0 },
{ 19, 70.0, 70.0, 40.0 }, { 20, 35.0, 35.0, 20.0 }, { 21, 18.0, 18.0, 10.0 },
{ 22, 12.0, 12.0, 5.0 }, { 23, 12.0, 12.0, 3.0 }, { 24, 18.0, 9.0, 2.0 },
{ 25, 18.0, 19.0, 2.0 }, { 0 } };
int i;
for (i = 0; data [i]. itube; i ++) {
Delta_Tube t = thy tube + data [i]. itube;
t -> Dy = t -> Dyeq = data [i]. Dy * f;
t -> Dz = t -> Dzeq = data [i]. Dz * f;
t -> parallel = data [i]. parallel;
}
for (itube = 26; itube <= 35; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dy = t -> Dyeq = 11.0 * f;
t -> Dz = t -> Dzeq = 14.0 * f;
t -> parallel = 1;
}
for (itube = FIRST_TUBE; itube <= 18; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dx = t -> Dxeq = 10.0 * f;
t -> mass = 10.0 * my relativeSize * t -> Dx * t -> Dz; // 10 mm
t -> k1 = 1e5 * t -> Dx * t -> Dz; // elastic tissue: 1 mbar/mm
t -> k3 = 0.0;
t -> Brel = 1.0;
}
for (itube = 19; itube <= 35; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dx = t -> Dxeq = 10.0 * f;
t -> mass = 3.0 * my relativeSize * t -> Dx * t -> Dz; // 3 mm
t -> k1 = 10e5 * t -> Dx * t -> Dz; // cartilage: 10 mbar/mm
t -> k3 = 0.0;
t -> Brel = 1.0;
}
}
/* Glottis: tubes 36 and 37; the last one may be disconnected (see below). */
{
Delta_Tube t = thy tube + 36;
t -> Dx = t -> Dxeq = my lowerCord.thickness;
t -> Dy = t -> Dyeq = 0.0;
t -> Dz = t -> Dzeq = my cord.length;
t -> mass = my lowerCord.mass;
t -> k1 = my lowerCord.k1;
t -> k3 = t -> k1 * (20.0 / t -> Dz) * (20.0 / t -> Dz);
t -> Brel = 0.2;
}
/*
* Fill in the values for the upper part of the glottis (tube 37) only if there is no one-mass model.
*/
if (my cord.numberOfMasses >= 2) {
Delta_Tube t = thy tube + 37;
t -> Dx = t -> Dxeq = my upperCord.thickness;
t -> Dy = t -> Dyeq = 0.0;
t -> Dz = t -> Dzeq = my cord.length;
t -> mass = my upperCord.mass;
t -> k1 = my upperCord.k1;
t -> k3 = t -> k1 * (20.0 / t -> Dz) * (20.0 / t -> Dz);
t -> Brel = 0.2;
/* Couple spring with lower cord. */
t -> k1left1 = thy tube [36]. k1right1 = 1.0;
}
/*
* Fill in the values for the conus elasticus (tubes 79..86) only if we want to model it.
*/
if (my cord.numberOfMasses == 10) {
thy tube [79]. Dx = thy tube [79]. Dxeq = 8.0 * f;
thy tube [80]. Dx = thy tube [80]. Dxeq = 7.0 * f;
thy tube [81]. Dx = thy tube [81]. Dxeq = 6.0 * f;
thy tube [82]. Dx = thy tube [82]. Dxeq = 5.0 * f;
thy tube [83]. Dx = thy tube [83]. Dxeq = 4.0 * f;
thy tube [84]. Dx = thy tube [84]. Dxeq = 0.75 * 4.0 * f + 0.25 * my lowerCord.thickness;
thy tube [85]. Dx = thy tube [85]. Dxeq = 0.50 * 4.0 * f + 0.50 * my lowerCord.thickness;
thy tube [86]. Dx = thy tube [86]. Dxeq = 0.25 * 4.0 * f + 0.75 * my lowerCord.thickness;
thy tube [79]. Dy = thy tube [79]. Dyeq = 11.0 * f;
thy tube [80]. Dy = thy tube [80]. Dyeq = 7.0 * f;
thy tube [81]. Dy = thy tube [81]. Dyeq = 4.0 * f;
thy tube [82]. Dy = thy tube [82]. Dyeq = 2.0 * f;
thy tube [83]. Dy = thy tube [83]. Dyeq = 1.0 * f;
thy tube [84]. Dy = thy tube [84]. Dyeq = 0.75 * f;
thy tube [85]. Dy = thy tube [85]. Dyeq = 0.50 * f;
thy tube [86]. Dy = thy tube [86]. Dyeq = 0.25 * f;
thy tube [79]. Dz = thy tube [79]. Dzeq = 16.0 * f;
thy tube [80]. Dz = thy tube [80]. Dzeq = 16.0 * f;
thy tube [81]. Dz = thy tube [81]. Dzeq = 16.0 * f;
thy tube [82]. Dz = thy tube [82]. Dzeq = 16.0 * f;
thy tube [83]. Dz = thy tube [83]. Dzeq = 16.0 * f;
thy tube [84]. Dz = thy tube [84]. Dzeq = 0.75 * 16.0 * f + 0.25 * my cord.length;
thy tube [85]. Dz = thy tube [85]. Dzeq = 0.50 * 16.0 * f + 0.50 * my cord.length;
thy tube [86]. Dz = thy tube [86]. Dzeq = 0.25 * 16.0 * f + 0.75 * my cord.length;
thy tube [79]. k1 = 160.0;
thy tube [80]. k1 = 160.0;
thy tube [81]. k1 = 160.0;
thy tube [82]. k1 = 160.0;
thy tube [83]. k1 = 160.0;
thy tube [84]. k1 = 0.75 * 160.0 * f + 0.25 * my lowerCord.k1;
thy tube [85]. k1 = 0.50 * 160.0 * f + 0.50 * my lowerCord.k1;
thy tube [86]. k1 = 0.25 * 160.0 * f + 0.75 * my lowerCord.k1;
thy tube [79]. Brel = 0.7;
thy tube [80]. Brel = 0.6;
thy tube [81]. Brel = 0.5;
thy tube [82]. Brel = 0.4;
thy tube [83]. Brel = 0.3;
thy tube [84]. Brel = 0.2;
thy tube [85]. Brel = 0.2;
thy tube [86]. Brel = 0.2;
for (itube = 79; itube <= 86; itube ++) {
Delta_Tube t = thy tube + itube;
t -> mass = t -> Dx * t -> Dz / (30.0 * f);
t -> k3 = t -> k1 * (20.0 / t -> Dz) * (20.0 / t -> Dz);
t -> k1left1 = t -> k1right1 = 1.0;
}
thy tube [79]. k1left1 = 0.0;
thy tube [36]. k1left1 = 1.0; // the essence: couple spring with lower vocal cords
}
/*
* Fill in the values of the glottal shunt only if we want to model it.
*/
if (my shunt.Dx != 0.0) {
for (itube = 87; itube <= 89; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dx = t -> Dxeq = my shunt.Dx;
t -> Dy = t -> Dyeq = my shunt.Dy;
t -> Dz = t -> Dzeq = my shunt.Dz;
t -> mass = 3.0 * my upperCord.mass; // heavy...
t -> k1 = 3.0 * my upperCord.k1; // ...and stiff...
t -> k3 = t -> k1 * (20.0 / t -> Dz) * (20.0 / t -> Dz);
t -> Brel = 3.0; // ...and inelastic, so that the walls will not vibrate
}
}
/* Vocal tract from neutral articulation. */
{
autoArt art = Art_create ();
Art_Speaker_meshVocalTract (art.get(), me, xi, yi, xe, ye, xmm, ymm, closed);
}
/* Pharynx and mouth: tubes 38..64. */
for (itube = 38; itube <= 64; itube ++) {
Delta_Tube t = thy tube + itube;
int i = itube - 37;
t -> Dx = t -> Dxeq = sqrt (( dx = xmm [i] - xmm [i + 1], dx * dx ) + ( dy = ymm [i] - ymm [i + 1], dy * dy ));
t -> Dyeq = sqrt (( dx = xe [i] - xi [i], dx * dx ) + ( dy = ye [i] - yi [i], dy * dy ));
if (closed [i]) t -> Dyeq = - t -> Dyeq;
t -> Dy = t -> Dyeq;
t -> Dz = t -> Dzeq = 0.015;
t -> mass = 0.006;
t -> k1 = 30.0;
t -> k3 = 0.0;
t -> Brel = 1.0;
}
/* For tongue-tip vibration [r]: thy tube [60]. Brel = 0.1; thy tube [60]. k1 = 3; */
/* Nose: tubes 65..78. */
for (itube = 65; itube <= 78; itube ++) {
Delta_Tube t = thy tube + itube;
t -> Dx = t -> Dxeq = my nose.Dx;
t -> Dy = t -> Dyeq = my nose.weq [itube - 65];
t -> Dz = t -> Dzeq = my nose.Dz;
t -> mass = 0.006;
t -> k1 = 100.0;
t -> k3 = 0.0;
t -> Brel = 1.0;
}
thy tube [65]. Dy = thy tube [65]. Dyeq = 0.0; // override: nasopharyngeal port closed
/* The default structure:
* every tube is connected on the left to the previous tube (index one lower).
* This corresponds to a two-mass model of the vocal cords without shunt.
*/
for (itube = SMOOTH_LUNGS ? FIRST_TUBE : 1; itube <= thy numberOfTubes; itube ++) {
Delta_Tube t = thy tube + itube;
t -> s1 = 5e6 * t -> Dx * t -> Dz;
t -> s3 = t -> s1 / (0.9e-3 * 0.9e-3);
t -> dy = 1e-5;
t -> left1 = t - 1; // connect to the previous tube on the left
t -> right1 = t + 1; // connect to the next tube on the right
}
/***** Connections: boundaries and interfaces. *****/
/* The leftmost boundary: the diaphragm (tube 1).
* Disconnect on the left.
*/
thy tube [SMOOTH_LUNGS ? FIRST_TUBE : 1]. left1 = nullptr; // closed at diaphragm
/* Optional one-mass model of the vocal cords.
* Short-circuit over tube 37 (upper glottis).
*/
if (my cord.numberOfMasses == 1) {
/* Connect the right side of tube 36 to the left side of tube 38. */
thy tube [36]. right1 = thy tube + 38;
thy tube [38]. left1 = thy tube + 36;
/* Disconnect tube 37 on both sides. */
thy tube [37]. left1 = thy tube [37]. right1 = nullptr;
}
/* Optionally couple vocal cords with conus elasticus.
* Replace tubes 32..35 (upper trachea) by tubes 79..86 (conus elasticus).
*/
if (my cord.numberOfMasses == 10) {
/* Connect the right side of tube 31 to the left side of tube 79. */
thy tube [31]. right1 = thy tube + 79;
thy tube [79]. left1 = thy tube + 31;
/* Connect the right side of tube 86 to the left side of tube 36. */
thy tube [86]. right1 = thy tube + 36;
thy tube [36]. left1 = thy tube + 86;
/* Disconnect tubes 32..35 on both sides. */
thy tube [32]. left1 = thy tube [32]. right1 = nullptr;
thy tube [33]. left1 = thy tube [33]. right1 = nullptr;
thy tube [34]. left1 = thy tube [34]. right1 = nullptr;
thy tube [35]. left1 = thy tube [35]. right1 = nullptr;
} else {
/* Disconnect tubes 79..86 on both sides. */
for (itube = 79; itube <= 86; itube ++)
thy tube [itube]. left1 = thy tube [itube]. right1 = nullptr;
}
/* Optionally add a shunt parallel to the glottis.
* Create a side branch from tube 34/35 (or 85/86) to tube 38/39 with tubes 87..89.
*/
if (my shunt.Dx != 0.0) {
int topOfTrachea = ( my cord.numberOfMasses == 10 ? 86 : 35 );
/* Create a three-way interface below the shunt.
* Connect lowest shunt tube (87) with top of trachea (34/35 or 85/86).
*/
thy tube [topOfTrachea - 1]. right2 = thy tube + 87; // trachea to shunt
thy tube [87]. left1 = thy tube + topOfTrachea - 1; // shunt to trachea
thy tube [87]. Dxeq = thy tube [topOfTrachea - 1]. Dxeq = thy tube [topOfTrachea]. Dxeq; // equal length
thy tube [87]. Dx = thy tube [topOfTrachea - 1]. Dx = thy tube [topOfTrachea]. Dx;
/* Create a three-way interface above the shunt.
* Connect highest shunt tube (89) with bottom of pharynx (38/39).
*/
thy tube [89]. right1 = thy tube + 39; // shunt to pharynx
thy tube [39]. left2 = thy tube + 89; // pharynx to shunt
thy tube [89]. Dxeq = thy tube [39]. Dxeq = thy tube [38]. Dxeq; // all three of equal length
thy tube [89]. Dx = thy tube [39]. Dx = thy tube [38]. Dx;
} else {
/* Disconnect tubes 87..89 on both sides. */
for (itube = 87; itube <= 89; itube ++)
thy tube [itube]. left1 = thy tube [itube]. right1 = nullptr;
}
/* Create a three-way interface at the nasopharyngeal port.
* Connect tubes 50 (pharynx), 51 (mouth), and 65 (nose).
*/
thy tube [50]. right2 = thy tube + 65; // pharynx to nose
thy tube [65]. left1 = thy tube + 50; // nose to pharynx
thy tube [65]. Dxeq = thy tube [51]. Dxeq = thy tube [50]. Dxeq; // all three must be of equal length
thy tube [65]. Dx = thy tube [51]. Dx = thy tube [50]. Dx;
/* The rightmost boundaries: the lips (tube 64) and the nostrils (tube 78).
* Disconnect on the right.
*/
thy tube [64]. right1 = nullptr; // radiation at the lips
thy tube [78]. right1 = nullptr; // radiation at the nostrils
for (itube = 1; itube <= thy numberOfTubes; itube ++) {
Delta_Tube t = thy tube + itube;
Melder_assert (! t->left1 || t->left1->right1 == t || t->left1->right2 == t);
Melder_assert (! t->left2 || t->left2->right1 == t);
Melder_assert (! t->right1 || t->right1->left1 == t || t->right1->left2 == t);
Melder_assert (! t->right2 || t->right2->left1 == t);
}
return thee;
}
/* End of file Speaker_to_Delta.cpp */
praat-6.0.23/artsynth/Speaker_to_Delta.h 0000664 0000000 0000000 00000001474 13023464014 0020146 0 ustar 00root root 0000000 0000000 /* Speaker_to_Delta.h
*
* Copyright (C) 1992-2011 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Speaker.h"
#include "Delta.h"
autoDelta Speaker_to_Delta (Speaker me);
/* End of file Speaker_to_Delta.h */
praat-6.0.23/artsynth/manual_Artsynth.cpp 0000664 0000000 0000000 00000024670 13023464014 0020450 0 ustar 00root root 0000000 0000000 /* manual_Artsynth.cpp
*
* Copyright (C) 1992-2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "ManPagesM.h"
void manual_Artsynth_init (ManPages me);
void manual_Artsynth_init (ManPages me) {
MAN_BEGIN (U"Articulatory synthesis", U"ppgb", 201101028)
INTRO (U"This is a description of the articulatory synthesis package in Praat. "
"For a detailed description of the physics and mathematics behind the model, "
"see @@Boersma (1998)@, chapters 2 and 3. "
"For examples of how to synthesize utterances, consult http://www.fon.hum.uva.nl/paul/diss/ch5/.")
ENTRY (U"How to start (after reading the @Intro)")
NORMAL (U"We are going to have the synthesizer say [əpə]. We need a @Speaker and an @Artword object.")
NORMAL (U"1. Create a speaker with @@Create Speaker...@ from the @@New menu@.")
NORMAL (U"2. Create an articulation word of 0.5 seconds with @@Create Artword...@.")
NORMAL (U"3. Edit the Artword by selecting it and clicking ##View & Edit#.")
NORMAL (U"4. To set the glottis to a position suitable for phonation, use the ArtwordEditor to "
"set the %Interarytenoid activity to 0.5 throughout the utterance. You set two targets: "
"0.5 at a time of 0 seconds, and 0.5 at a time of 0.5 seconds.")
NORMAL (U"5. To prevent air escaping from the nose, close the nasopharyngeal port "
"by setting the %LevatorPalatini activity to 1.0 throughout the utterance.")
NORMAL (U"6. To generate the lung pressure needed for phonation, you set the %Lungs activity at 0 seconds to 0.2, "
"and at 0.1 seconds to 0.")
NORMAL (U"7. To force a jaw movement that closes the lips, set the %Masseter activity at 0.25 seconds to 0.7, "
"and the %OrbicularisOris activity at 0.25 seconds to 0.2.")
NORMAL (U"8. Select the Speaker and the Artword and click #Movie; "
"you will see a closing-and-opening gesture of the mouth.")
NORMAL (U"9. Select the Speaker and the Artword and click ##To Sound...# "
"(see @@Artword & Speaker: To Sound...@).")
NORMAL (U"10. Just click #OK; the synthesis starts.")
NORMAL (U"11. If you are sitting at a 1997 computer, this will last for 5 minutes or so; at a 2010 computer, 6 seconds. "
"If this is too slow for you, click #Interrupt. "
"Otherwise, you can watch the vibrating vocal cords "
"and the changing vocal-tract shape.")
NORMAL (U"12. You can play, view, and analyse the resulting @Sound as you would any other. "
"You can see and hear a sound movie if you select the Speaker, "
"the Artword, and the Sound, and click #Play.")
MAN_END
MAN_BEGIN (U"Artword", U"ppgb", 20030316)
INTRO (U"One of the @@types of objects@ in Praat. See @@Articulatory synthesis@.")
NORMAL (U"An object of class Artword object represents the activities of several speech muscles as functions of time.")
ENTRY (U"Artword commands")
LIST_ITEM (U"• @@Create Artword...@: creates an Artword with relaxed muscles")
LIST_ITEM (U"• @@Artword & Speaker: To Sound...@: articulatory synthesis")
MAN_END
MAN_BEGIN (U"Artword & Speaker: To Sound...", U"ppgb", 20040331)
INTRO (U"A command to synthesize a @Sound object from the selected @Speaker and the selected @Artword.")
NORMAL (U"This is the command that performs the actual articulatory synthesis. "
"See @@Articulatory synthesis@.")
ENTRY (U"Settings")
TAG (U"##Sampling frequency (Hz)")
DEFINITION (U"the number of times per second that the equilibrium widths and lengths and the tensions of the muscles "
"are recomputed from the Artword. This will also be the sampling frequency of the resulting sound and "
"of the optional resulting tube widths, air pressures, and air velocities. The standard value is 22050 Hz.")
TAG (U"##Oversampling")
DEFINITION (U"the number of times that the aerodynamic quantities and the state of the tube walls "
"will be recomputed during each sample period. The standard value is 25.")
TAG (U"##Width 1#, ##Width 2#, ##Width 3#")
DEFINITION (U"the numbers (see below) of the tubes whose widths you want to monitor. "
"E.g., if ##Width 1# is 36, the synthesizer will create a Sound object named $$width36$, "
"which contains the width of tube 36 (the lower glottis) as a function of time, expressed in metres. "
"To prevent the creation of a $$width$ object, specify $$0$ (the standard value).")
TAG (U"##Pressure 1#, ##Pressure 2#, ##Pressure 3#")
DEFINITION (U"the numbers (see below) of the tubes whose air pressures you want to monitor. "
"E.g., if ##Pressure 3# is 37, the synthesizer will create a Sound object named $$pressure37$, "
"which contains the air pressure of tube 37 (the upper glottis) as a function of time, expressed in Pascal. "
"To prevent the creation of a $$pressure$ object, specify $$0$ (the standard value).")
TAG (U"##Velocity 1#, ##Velocity 2#, ##Velocity 3")
DEFINITION (U"the numbers (see below) of the tubes whose air velocities you want to monitor. "
"E.g., if ##Velocity 1# is 60, the synthesizer will create a Sound object named $velocity60, "
"which contains the air velocity of tube 60 (in the mouth) as a function of time, expressed in metres per second. "
"To prevent the creation of a $velocity object, specify $0 (the standard value).")
ENTRY (U"Stability")
NORMAL (U"The internal sampling frequency for the aerodynamics is the specified ##Sampling frequency#, "
"multiplied by the specified #Oversampling. With the standard settings, this is 22050 times 25 = 550750 Hz.")
NORMAL (U"To ensure the stability of the synthesis, this internal sampling frequency should not be less than the "
"velocity of sound (353 m/s) divided by the length of the shortest tube. For the standard #Female, "
"#Male, and #Child speakers, the shortest tube is the upper glottis, which has a length "
"of 0.7, 1.0, and 0.3 millimetres, respectively. The minimum internal sampling frequencies, therefore, "
"are 504286, 353000, and 1176667 hertz, respectively.")
ENTRY (U"Time resolution")
NORMAL (U"To capture the microscopic pressure changes in the glottis, you will want maximum time resolution. "
"For a female speaker, you could set ##Sampling frequency# to 550750 Hz, and #Oversampling to 1.")
ENTRY (U"Tube numbers")
NORMAL (U"Here are the tube numbers that you can use for the #Width, #Pressure, and #Velocity settings:")
LIST_ITEM (U"1..23: lungs (from bottom to top)")
LIST_ITEM (U"24..29: bronchi (from bottom to top)")
LIST_ITEM (U"30..35: trachea (from bottom to top)")
LIST_ITEM (U"36: lower glottis")
LIST_ITEM (U"37: upper glottis (not for a one-mass model)")
LIST_ITEM (U"38..49: pharynx (from bottom to top)")
LIST_ITEM (U"50..51: nasopharyngeal branching")
LIST_ITEM (U"52..64: mouth (from back to front)")
LIST_ITEM (U"65..78: nose (from back to front)")
LIST_ITEM (U"79..86: conus elasticus (only for a 10-mass model)")
LIST_ITEM (U"87..89: glottal shunt between the arytenoids (from bottom to top)")
NORMAL (U"Some structural properties:")
LIST_ITEM (U"• Tube 1 is closed at the bottom.")
LIST_ITEM (U"• Tubes 64 (lips) and 78 (nostrils) radiate into the air.")
LIST_ITEM (U"• The nasopharyngeal branch is at tubes 50, 51, and 65. They are constrained to have equal lengths.")
LIST_ITEM (U"• For a one-mass model of the vocal cords, tube 36 is connected to 38.")
LIST_ITEM (U"• For a 10-mass model, tubes 32..35 are replaced with 79..86, so that "
"tube 31 is connected to 79, and 86 is connected to 36.")
LIST_ITEM (U"• A glottal shunt will be implemented if the speaker's $$shunt.Dx$ attribute is not zero. "
"A branch is then made from tubes 34 and 35 (or 85 and 86) to 87, "
"and from tube 89 to 38 and 39.")
MAN_END
MAN_BEGIN (U"Create Artword...", U"ppgb", 20101212)
INTRO (U"A command to create an @Artword object with all muscle activities set to zero. "
"See @@Articulatory synthesis@.")
ENTRY (U"Settings")
TAG (U"##Name")
DEFINITION (U"the name that you give to the created object. The standard name is $$hallo$, "
"but you should give it a more sensible name, possibly something that represents the utterance "
"that it is supposed to generate.")
TAG (U"##Duration (seconds)")
DEFINITION (U"the duration of the resulting Artword. Should be as long as the utterance that "
"you want to generate with it. The standard value is 1 second.")
MAN_END
MAN_BEGIN (U"Create Speaker...", U"ppgb", 20101212)
INTRO (U"A command to create a @Speaker object. See @@Articulatory synthesis@.")
ENTRY (U"Settings")
TAG (U"##Name")
DEFINITION (U"the name that you give to the created object. The standard name is \"speaker\", "
"but if you work with multiple Speaker objects, give them sensible names to reduce confusion.")
TAG (U"##Kind of speaker")
DEFINITION (U"Choose from #Female, #Male, or #Child. The only difference is a relative size.")
TAG (U"##Number of tubes in glottis")
DEFINITION (U"Choose from #1, #2, or #10. See @@Artword & Speaker: To Sound...@ for details.")
MAN_END
MAN_BEGIN (U"Create Vocal Tract from phone...", U"ppgb", 19960908)
INTRO (U"A way to create a @VocalTract object.")
ENTRY (U"Purpose")
NORMAL (U"to translate a phone symbol like [a], [u], etc., into a vocal-tract area function.")
ENTRY (U"Behaviour")
NORMAL (U"The resulting VocalTract will appear in the list of objects, "
"with the same name as the phone.")
ENTRY (U"Algorithm")
NORMAL (U"The area function of the resulting VocalTract is taken from the Russian speaker from @@Fant (1960)@.")
MAN_END
MAN_BEGIN (U"Speaker", U"ppgb", 19980201)
INTRO (U"One of the @@types of objects@ in Praat. See @@Articulatory synthesis@.")
ENTRY (U"Speaker commands")
LIST_ITEM (U"• @@Create Speaker...")
LIST_ITEM (U"• @@Artword & Speaker: To Sound...@: articulatory synthesis")
MAN_END
MAN_BEGIN (U"VocalTract", U"ppgb", 20030316)
INTRO (U"One of the @@types of objects@ in Praat.")
NORMAL (U"A VocalTract object represents the area function of the vocal tract, expressed in m^2, "
"running from the glottis to the lips.")
MAN_END
MAN_BEGIN (U"VocalTract: Formula...", U"ppgb", 20021206)
INTRO (U"A command for changing the data in all selected @VocalTract objects.")
NORMAL (U"See the @Formulas tutorial for examples and explanations.")
MAN_END
}
/* End of file manual_Artsynth.cpp */
praat-6.0.23/artsynth/praat_Artsynth.cpp 0000664 0000000 0000000 00000033002 13023464014 0020267 0 ustar 00root root 0000000 0000000 /* praat_Artsynth.cpp
*
* Copyright (C) 1992-2012,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Art_Speaker.h"
#include "Artword_Speaker.h"
#include "Art_Speaker_to_VocalTract.h"
#include "Artword_Speaker_Sound.h"
#include "Artword_Speaker_to_Sound.h"
#include "Artword_to_Art.h"
#include "ArtwordEditor.h"
#include "VocalTract_to_Spectrum.h"
#include "praat_Matrix.h"
// MARK: - ART
FORM (NEW1_Art_create, U"Create a default Articulation", U"Articulatory synthesis") {
WORDVAR (name, U"Name", U"articulation")
OK
DO
CREATE_ONE
autoArt result = Art_create ();
CREATE_ONE_END (name);
}
FORM (WINDOW_Art_viewAndEdit, U"View & Edit Articulation", nullptr) {
for (int i = 1; i <= kArt_muscle_MAX; i ++)
REAL (kArt_muscle_getText (i), U"0.0")
OK
FIND_ONE (Art)
for (int i = 1; i <= kArt_muscle_MAX; i ++)
SET_REAL (kArt_muscle_getText (i), my art [i]);
DO
FIND_ONE (Art)
if (theCurrentPraatApplication -> batch)
Melder_throw (U"Cannot edit an Art from batch.");
for (int i = 1; i <= kArt_muscle_MAX; i ++)
my art [i] = GET_REAL (kArt_muscle_getText (i));
END
}
// MARK: - ARTWORD
FORM (NEW1_Artword_create, U"Create an empty Artword", U"Create Artword...") {
WORDVAR (name, U"Name", U"hallo")
POSITIVEVAR (duration, U"Duration (seconds)", U"1.0")
OK
DO
CREATE_ONE
autoArtword result = Artword_create (duration);
CREATE_ONE_END (name)
}
FORM (GRAPHICS_Artword_draw, U"Draw one Artword tier", nullptr) {
OPTIONMENUVAR (muscle, U"Muscle", kArt_muscle_LUNGS)
for (int ienum = 1; ienum <= kArt_muscle_MAX; ienum ++)
OPTION (kArt_muscle_getText (ienum))
BOOLEANVAR (garnish, U"Garnish", true)
OK
DO
GRAPHICS_EACH (Artword)
Artword_draw (me, GRAPHICS, muscle, garnish);
GRAPHICS_EACH_END
}
DIRECT (WINDOW_Artword_viewAndEdit) {
if (theCurrentPraatApplication -> batch) Melder_throw (U"Cannot view or edit an Artword from batch.");
WHERE (SELECTED) {
iam_LOOP (Artword);
autoArtwordEditor editor = ArtwordEditor_create (ID_AND_FULL_NAME, me);
praat_installEditor (editor.get(), IOBJECT);
editor.releaseToUser();
}
END }
FORM (REAL_Artword_getTarget, U"Get one Artword target", nullptr) {
REALVAR (time, U"Time (seconds)", U"0.0")
OPTIONMENUVAR (muscle, U"Muscle", kArt_muscle_LUNGS)
for (int ienum = 1; ienum <= kArt_muscle_MAX; ienum ++)
OPTION (kArt_muscle_getText (ienum))
OK
DO
NUMBER_ONE (Artword)
double result = Artword_getTarget (me, muscle, time);
NUMBER_ONE_END (U"")
}
DIRECT (HELP_Artword_help) {
HELP (U"Artword")
}
FORM (MODIFY_Artword_setTarget, U"Set one Artword target", nullptr) {
REALVAR (time, U"Time (seconds)", U"0.0")
REALVAR (targetValue, U"Target value (0-1)", U"0.0")
OPTIONMENUVAR (muscle, U"Muscle", kArt_muscle_LUNGS)
for (int ienum = 1; ienum <= kArt_muscle_MAX; ienum ++)
OPTION (kArt_muscle_getText (ienum))
OK
DO
if (time < 0.0) Melder_throw (U"The specified time should not be less than 0.");
MODIFY_EACH (Artword)
Artword_setTarget (me, muscle, time, targetValue);
MODIFY_EACH_END
}
FORM (NEW_Artword_to_Art, U"From Artword to Art", nullptr) {
REALVAR (time, U"Time (seconds)", U"0.0")
OK
DO
CONVERT_EACH (Artword)
autoArt result = Artword_to_Art (me, time);
CONVERT_EACH_END (my name)
}
// MARK: - ART & SPEAKER
DIRECT (GRAPHICS_Art_Speaker_draw) {
GRAPHICS_TWO (Art, Speaker)
Art_Speaker_draw (me, you, GRAPHICS);
GRAPHICS_TWO_END
}
DIRECT (GRAPHICS_Art_Speaker_fillInnerContour) {
GRAPHICS_TWO (Art, Speaker)
Art_Speaker_fillInnerContour (me, you, GRAPHICS);
GRAPHICS_TWO_END
}
DIRECT (GRAPHICS_Art_Speaker_drawMesh) {
GRAPHICS_TWO (Art, Speaker)
Art_Speaker_drawMesh (me, you, GRAPHICS);
GRAPHICS_TWO_END
}
DIRECT (NEW1_Art_Speaker_to_VocalTract) {
CONVERT_TWO (Art, Speaker)
autoVocalTract result = Art_Speaker_to_VocalTract (me, you);
CONVERT_TWO_END (my name, U"_", your name)
}
// MARK: - ARTWORD & SPEAKER
FORM (GRAPHICS_Artword_Speaker_draw, U"Draw Artword & Speaker", nullptr) {
NATURALVAR (numberOfSteps, U"Number of steps", U"5")
OK
DO
GRAPHICS_TWO (Artword, Speaker)
Artword_Speaker_draw (me, you, GRAPHICS, numberOfSteps);
GRAPHICS_TWO_END
}
FORM (NEW1_Artword_Speaker_to_Sound, U"Articulatory synthesizer", U"Artword & Speaker: To Sound...") {
POSITIVEVAR (samplingFrequency, U"Sampling frequency (Hz)", U"22050.0")
NATURALVAR (oversamplingFactor, U"Oversampling factor", U"25")
INTEGERVAR (width1, U"Width 1", U"0")
INTEGERVAR (width2, U"Width 2", U"0")
INTEGERVAR (width3, U"Width 3", U"0")
INTEGERVAR (pressure1, U"Pressure 1", U"0")
INTEGERVAR (pressure2, U"Pressure 2", U"0")
INTEGERVAR (pressure3, U"Pressure 3", U"0")
INTEGERVAR (velocity1, U"Velocity 1", U"0")
INTEGERVAR (velocity2, U"Velocity 2", U"0")
INTEGERVAR (velocity3, U"Velocity 3", U"0")
OK
DO
FIND_TWO (Artword, Speaker)
autoSound w1, w2, w3, p1, p2, p3, v1, v2, v3;
autoSound result = Artword_Speaker_to_Sound (me, you,
samplingFrequency, oversamplingFactor,
& w1, width1, & w2, width2, & w3, width3,
& p1, pressure1, & p2, pressure2, & p3, pressure3,
& v1, velocity1, & v2, velocity2, & v3, velocity3);
praat_new (result.move(), my name, U"_", your name);
if (width1) praat_new (w1.move(), U"width", width1);
if (width2) praat_new (w2.move(), U"width", width2);
if (width3) praat_new (w3.move(), U"width", width3);
if (pressure1) praat_new (p1.move(), U"pressure", pressure1);
if (pressure2) praat_new (p2.move(), U"pressure", pressure2);
if (pressure3) praat_new (p3.move(), U"pressure", pressure3);
if (velocity1) praat_new (v1.move(), U"velocity", velocity1);
if (velocity2) praat_new (v2.move(), U"velocity", velocity2);
if (velocity3) praat_new (v3.move(), U"velocity", velocity3);
END
}
DIRECT (MOVIE_Artword_Speaker_movie) {
MOVIE_TWO (Artword, Speaker, U"Artword & Speaker movie", 300, 300)
Artword_Speaker_movie (me, you, graphics);
MOVIE_TWO_END
}
// MARK: - ARTWORD & SPEAKER & SOUND
DIRECT (MOVIE_Artword_Speaker_Sound_movie) {
MOVIE_THREE (Artword, Speaker, Sound, U"Artword & Speaker & Sound movie", 300, 300)
Artword_Speaker_Sound_movie (me, you, him, graphics);
MOVIE_THREE_END
}
// MARK: - SPEAKER
FORM (NEW1_Speaker_create, U"Create a Speaker", U"Create Speaker...") {
WORDVAR (name, U"Name", U"speaker")
OPTIONMENUSTRVAR (kindOfSpeaker, U"Kind of speaker", 1)
OPTION (U"Female")
OPTION (U"Male")
OPTION (U"Child")
OPTIONMENUSTRVAR (numberOfTubesInGlottis, U"Number of tubes in glottis", 2)
OPTION (U"1")
OPTION (U"2")
OPTION (U"10")
OK
DO
CREATE_ONE
autoSpeaker result = Speaker_create (kindOfSpeaker, Melder_atoi (numberOfTubesInGlottis));
CREATE_ONE_END (name)
}
DIRECT (HELP_Speaker_help) {
HELP (U"Speaker")
}
// MARK: - VOCALTRACT
FORM (NEW1_VocalTract_createFromPhone, U"Create Vocal Tract from phone", U"Create Vocal Tract from phone...") {
OPTIONMENUSTRVAR (phone, U"Phone", 1)
OPTION (U"a")
OPTION (U"e")
OPTION (U"i")
OPTION (U"o")
OPTION (U"u")
OPTION (U"y1")
OPTION (U"y2")
OPTION (U"y3")
OPTION (U"jery")
OPTION (U"p")
OPTION (U"t")
OPTION (U"k")
OPTION (U"x")
OPTION (U"pa")
OPTION (U"ta")
OPTION (U"ka")
OPTION (U"pi")
OPTION (U"ti")
OPTION (U"ki")
OPTION (U"pu")
OPTION (U"tu")
OPTION (U"ku")
OK
DO
CREATE_ONE
autoVocalTract result = VocalTract_createFromPhone (phone);
CREATE_ONE_END (phone)
}
DIRECT (GRAPHICS_VocalTract_draw) {
GRAPHICS_EACH (VocalTract)
VocalTract_draw (me, GRAPHICS);
GRAPHICS_EACH_END
}
FORM (MODIFY_VocalTract_formula, U"VocalTract Formula", U"Matrix: Formula...") {
LABEL (U"label", U"`x' is the distance form the glottis in metres, `col' is the section number, `self' is in m\u00B2")
LABEL (U"label", U"x := x1; for col := 1 to ncol do { self [col] := `formula' ; x := x + dx }")
TEXTVAR (formula, U"formula", U"0")
OK
DO
MODIFY_EACH_WEAK (VocalTract)
Matrix_formula (me, formula, interpreter, nullptr);
MODIFY_EACH_WEAK_END
}
DIRECT (HELP_VocalTract_help) {
HELP (U"VocalTract")
}
DIRECT (NEW_VocalTract_to_Matrix) {
CONVERT_EACH (VocalTract)
autoMatrix result = VocalTract_to_Matrix (me);
CONVERT_EACH_END (my name)
}
FORM (NEW_VocalTract_to_Spectrum, U"From Vocal Tract to Spectrum", nullptr) {
LABEL (U"", U"Compute transfer function")
NATURALVAR (numberOfFequencies, U"Number of frequencies", U"4097")
POSITIVEVAR (maximumFrequency, U"Maximum frequency (Hz)", U"5000.0")
REALVAR (glottalDamping, U"Glottal damping", U"0.1")
BOOLEANVAR (radiationDamping, U"Radiation damping", true)
BOOLEANVAR (internalDamping, U"Internal damping", true)
OK
DO
CONVERT_EACH (VocalTract)
autoSpectrum result = VocalTract_to_Spectrum (me, numberOfFequencies,
maximumFrequency, glottalDamping, radiationDamping, internalDamping);
CONVERT_EACH_END (my name)
}
DIRECT (HELP_ArticulatorySynthesisTutorial) {
HELP (U"Articulatory synthesis")
}
void manual_Artsynth_init (ManPages me);
// MARK: - buttons
void praat_uvafon_Artsynth_init ();
void praat_uvafon_Artsynth_init () {
Thing_recognizeClassesByName (classArt, classArtword, classSpeaker, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Articulatory synthesis", nullptr, 0, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Articulatory synthesis tutorial", nullptr, praat_DEPTH_1, HELP_ArticulatorySynthesisTutorial);
praat_addMenuCommand (U"Objects", U"New", U"-- new articulatory synthesis -- ", nullptr, 1, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Create Articulation...", nullptr, 1, NEW1_Art_create);
praat_addMenuCommand (U"Objects", U"New", U"Create Speaker...", nullptr, 1, NEW1_Speaker_create);
praat_addMenuCommand (U"Objects", U"New", U"Create Artword...", nullptr, 1, NEW1_Artword_create);
praat_addMenuCommand (U"Objects", U"New", U"-- new vocal tract --", nullptr, 1, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Create Vocal Tract from phone...", nullptr, 1, NEW1_VocalTract_createFromPhone);
praat_addAction1 (classArt, 1, U"View & Edit", nullptr, praat_ATTRACTIVE, WINDOW_Art_viewAndEdit);
praat_addAction1 (classArt, 1, U"Edit", U"*View & Edit", praat_DEPRECATED_2011, WINDOW_Art_viewAndEdit);
praat_addAction1 (classArtword, 0, U"Artword help", nullptr, 0, HELP_Artword_help);
praat_addAction1 (classArtword, 1, U"View & Edit", nullptr, praat_ATTRACTIVE, WINDOW_Artword_viewAndEdit);
praat_addAction1 (classArtword, 1, U"Edit", U"*View & Edit", praat_DEPRECATED_2011, WINDOW_Artword_viewAndEdit);
praat_addAction1 (classArtword, 0, U"Info", nullptr, 0, nullptr);
praat_addAction1 (classArtword, 1, U"Get target...", nullptr, 0, REAL_Artword_getTarget);
praat_addAction1 (classArtword, 0, U"Draw", nullptr, 0, nullptr);
praat_addAction1 (classArtword, 0, U"Draw...", nullptr, 0, GRAPHICS_Artword_draw);
praat_addAction1 (classArtword, 0, U"Modify", nullptr, 0, nullptr);
praat_addAction1 (classArtword, 1, U"Set target...", nullptr, 0, MODIFY_Artword_setTarget);
praat_addAction1 (classArtword, 0, U"Analyse", nullptr, 0, nullptr);
praat_addAction1 (classArtword, 0, U"To Art (slice)...", nullptr, 0, NEW_Artword_to_Art);
praat_addAction2 (classArt, 1, classSpeaker, 1, U"Draw", nullptr, 0, nullptr);
praat_addAction2 (classArt, 1, classSpeaker, 1, U"Draw", nullptr, 0, GRAPHICS_Art_Speaker_draw);
praat_addAction2 (classArt, 1, classSpeaker, 1, U"Fill inner contour", nullptr, 0, GRAPHICS_Art_Speaker_fillInnerContour);
praat_addAction2 (classArt, 1, classSpeaker, 1, U"Draw mesh", nullptr, 0, GRAPHICS_Art_Speaker_drawMesh);
praat_addAction2 (classArt, 1, classSpeaker, 1, U"Synthesize", nullptr, 0, nullptr);
praat_addAction2 (classArt, 1, classSpeaker, 1, U"To VocalTract", nullptr, 0, NEW1_Art_Speaker_to_VocalTract);
praat_addAction2 (classArtword, 1, classSpeaker, 1, U"Movie", nullptr, 0, MOVIE_Artword_Speaker_movie);
praat_addAction2 (classArtword, 1, classSpeaker, 1, U"Draw", nullptr, 0, nullptr);
praat_addAction2 (classArtword, 1, classSpeaker, 1, U"Draw...", nullptr, 0, GRAPHICS_Artword_Speaker_draw);
praat_addAction2 (classArtword, 1, classSpeaker, 1, U"Synthesize", nullptr, 0, nullptr);
praat_addAction2 (classArtword, 1, classSpeaker, 1, U"To Sound...", nullptr, 0, NEW1_Artword_Speaker_to_Sound);
praat_addAction3 (classArtword, 1, classSpeaker, 1, classSound, 1, U"Movie", nullptr, 0, MOVIE_Artword_Speaker_Sound_movie);
praat_addAction1 (classSpeaker, 0, U"Speaker help", nullptr, 0, HELP_Speaker_help);
praat_addAction1 (classVocalTract, 0, U"VocalTract help", nullptr, 0, HELP_VocalTract_help);
praat_addAction1 (classVocalTract, 0, U"Draw", nullptr, 0, nullptr);
praat_addAction1 (classVocalTract, 0, U"Draw", nullptr, 0, GRAPHICS_VocalTract_draw);
praat_addAction1 (classVocalTract, 0, U"Analyse", nullptr, 0, nullptr);
praat_addAction1 (classVocalTract, 0, U"To Spectrum...", nullptr, 0, NEW_VocalTract_to_Spectrum);
praat_addAction1 (classVocalTract, 0, U"Modify", nullptr, 0, nullptr);
praat_addAction1 (classVocalTract, 0, U"Formula...", nullptr, 0, MODIFY_VocalTract_formula);
praat_addAction1 (classVocalTract, 0, U"Hack", nullptr, 0, nullptr);
praat_addAction1 (classVocalTract, 0, U"To Matrix", nullptr, 0, NEW_VocalTract_to_Matrix);
manual_Artsynth_init (theCurrentPraatApplication -> manPages);
}
/* End of file praat_Artsynth.cpp */
praat-6.0.23/contrib/ 0000775 0000000 0000000 00000000000 13023464014 0014346 5 ustar 00root root 0000000 0000000 praat-6.0.23/contrib/ola/ 0000775 0000000 0000000 00000000000 13023464014 0015121 5 ustar 00root root 0000000 0000000 praat-6.0.23/contrib/ola/BUGS.txt 0000664 0000000 0000000 00000000063 13023464014 0016421 0 ustar 00root root 0000000 0000000 Known bugs:
CPrune: progress indicators are borken
praat-6.0.23/contrib/ola/ChangeLog.txt 0000664 0000000 0000000 00000002113 13023464014 0017506 0 ustar 00root root 0000000 0000000 --------------------
libOla.a - ChangeLog
--------------------
2008-05-29 * Initial release
2008-08-10 * Bugfixes
* Merging with the upstream version of Praat
2008-10-01 * Bugfix: C-Pruner now rejects instance bases of sizes <= 1
* Multithreaded kNN-classification implemented (Linux only)
2009-01-23 * Bugfix: KNN_learn(...) MUX:ing removed; broke scripting
* Bugfix: KNN serialization fixed (using the proper version ID)
* Removed redundant information from the manual
* The TableOfReal output of the KNN classifier now mimics the
format of the corresponding output of the FFNet classifier.
2009-01-31 * kNN-classifier no longer executes in a thread of its own
* on single-CPU machines
2009-07-02 * Threading disabled on all plattforms
* Bugfix: The k-means clustering routine no longer attempts to create
clusters when k > number of patterns by means of reseeding.
* Bugfix: Inadequate checking of input data in the C-Pruner routine
resulting in rare crashes fixed.
praat-6.0.23/contrib/ola/FeatureWeights.cpp 0000664 0000000 0000000 00000035744 13023464014 0020570 0 ustar 00root root 0000000 0000000 /* FeatureWeights.cpp
*
* Copyright (C) 2007-2008 Ola So"der, 2010-2012,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 2007/05/29 Initial release
* pb 2010/06/06 removed some array-creations-on-the-stack
* pb 2011/03/08 tried to repair some of the header file chaos (several procedures here should be in KNN.c instead)
* pb 2011/04/12 C++
*/
#include "FeatureWeights.h"
#include "KNN.h" // BUG
#include "oo_DESTROY.h"
#include "FeatureWeights_def.h"
#include "oo_COPY.h"
#include "FeatureWeights_def.h"
#include "oo_EQUAL.h"
#include "FeatureWeights_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "FeatureWeights_def.h"
#include "oo_WRITE_TEXT.h"
#include "FeatureWeights_def.h"
#include "oo_WRITE_BINARY.h"
#include "FeatureWeights_def.h"
#include "oo_READ_TEXT.h"
#include "FeatureWeights_def.h"
#include "oo_READ_BINARY.h"
#include "FeatureWeights_def.h"
#include "oo_DESCRIPTION.h"
#include "FeatureWeights_def.h"
void structFeatureWeights :: v_info ()
{
our structDaata :: v_info ();
MelderInfo_writeLine (U"Number of weights: ", our fweights -> numberOfColumns);
}
Thing_implement (FeatureWeights, Daata, 0);
/////////////////////////////////////////////////////////////////////////////////////////////
// Creation... //
/////////////////////////////////////////////////////////////////////////////////////////////
autoFeatureWeights FeatureWeights_create
(
///////////////////////////////
// Parameters //
///////////////////////////////
long nweights // number of weights
)
{
try {
autoFeatureWeights me = Thing_new (FeatureWeights);
my fweights = TableOfReal_create (1, nweights);
for (long i = 1; i <= nweights; i ++) {
my fweights -> data [1] [i] = 1;
}
return me;
} catch (MelderError) {
Melder_throw (U"FeatureWeights not created.");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Compute prior probabilities //
/////////////////////////////////////////////////////////////////////////////////////////////
long FeatureWeights_computePriors
(
///////////////////////////////
// Parameters //
///////////////////////////////
Categories c, // source categories
//
long * indices, // Out: instances indices ..
//
double * priors // Out: .. and their prior probabilities
//
)
{
long nc = 0;
for (long y = 1; y <= c->size; y ++)
{
long ifriend = -1;
for (long sc = 0; sc < nc; sc ++)
if (FeatureWeights_areFriends (c->at [y], c->at [indices [sc]])) ifriend = sc;
if (ifriend < 0)
{
indices [nc] = y;
priors [nc] = 1;
nc ++;
}
else
{
priors [ifriend] ++;
}
}
for (long q = 0; q < nc; q++) priors [q] /= c->size;
return nc;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Compute feature weights //
/////////////////////////////////////////////////////////////////////////////////////////////
autoFeatureWeights FeatureWeights_compute // Obsolete
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList pp, // Source pattern
//
Categories c, // Source categories
//
long k // k(!)
)
{
return FeatureWeights_computeRELIEF (pp, c, k);
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Compute feature weights (wrapper), evaluate using folding //
/////////////////////////////////////////////////////////////////////////////////////////////
autoFeatureWeights FeatureWeights_computeWrapperInt
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // Classifier
//
long k, // k(!)
//
int d, // distance weighting
//
long nseeds, // the number of seeds
//
double alfa, // shrinkage factor
//
double stop, // stop at
//
int mode, // mode (co/serial)
//
int emode // evaluation mode (10-fold/L1O)
//
)
{
if (! me) return autoFeatureWeights();
try {
double pivot = 0.5;
double range = 0.5;
autoNUMvector results (0L, nseeds);
autoThingVector cs (0L, nseeds);
for (long y = 0; y <= nseeds; y++) {
cs [y] = FeatureWeights_create (my input -> nx);
}
for (long x = 1; x <= my input -> nx; x ++)
cs [nseeds] -> fweights -> data [1] [x] = pivot;
results [nseeds] = KNN_evaluate (me, cs [nseeds].get(), k, d, emode);
while (range > 0 && results [nseeds] < stop)
{
long best = nseeds;
if (mode == 2)
{
for (long x = 1; x <= (my input)->nx; x ++)
{
for (long y = 0; y < nseeds; y ++)
{
cs[y]->fweights->data[1][x] = NUMrandomUniform(OlaMAX(0, cs[nseeds]->fweights->data[1][x] - range),
OlaMIN(1, cs[nseeds]->fweights->data[1][x] + range));
results[y] = KNN_evaluate (me, cs [y].get(), k, d, emode);
}
for (long q = 0; q < nseeds; q++)
if (results[q] > results[best]) best = q;
if (results[best] > results[nseeds])
{
for (long x = 1; x <= (my input)->nx; x++) // HELP FIXME the same index for an inner and an outer loop!!!
cs[nseeds]->fweights->data[1][x] = cs[best]->fweights->data[1][x];
results[nseeds] = results[best];
}
}
}
else
{
for (long y = 0; y < nseeds; y++)
{
for (long x = 1; x <= (my input)->nx; x++)
{
cs[y]->fweights->data[1][x] = NUMrandomUniform(OlaMAX(0, cs[nseeds]->fweights->data[1][x] - range),
OlaMIN(1, cs[nseeds]->fweights->data[1][x] + range));
}
results[y] = KNN_evaluate (me, cs [y].get(), k, d, emode);
}
for (long q = 0; q < nseeds; q++)
if (results[q] > results[best]) best = q;
if (results[best] > results[nseeds])
{
for (long x = 1; x <= (my input)->nx; x++)
cs[nseeds]->fweights->data[1][x] = cs[best]->fweights->data[1][x];
results[nseeds] = results[best];
}
}
range -= alfa;
}
autoFeatureWeights result = cs [nseeds].move();
return result;
} catch (MelderError) {
Melder_throw (U"FeatureWeights: wrapper not computed.");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Compute feature weights (wrapper), evaluate using separate test set //
/////////////////////////////////////////////////////////////////////////////////////////////
autoFeatureWeights FeatureWeights_computeWrapperExt
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN nn, // Classifier
//
PatternList pp, // test pattern
//
Categories c, // test categories
//
long k, // k(!)
//
int d, // distance weighting
//
long nseeds, // the number of seeds
//
double alfa, // shrinkage factor
//
double stop, // stop at
//
int mode // mode (co/serial)
//
)
{
if (! nn) return autoFeatureWeights();
try {
double pivot = 0.5;
double range = 0.5;
autoNUMvector results (0L, nseeds);
autoThingVector cs (0L, nseeds);
for (long y = 0; y <= nseeds; y++) {
cs [y] = FeatureWeights_create (pp -> nx);
}
for (long x = 1; x <= pp -> nx; x ++)
cs [nseeds] -> fweights -> data [1] [x] = pivot;
results [nseeds] = FeatureWeights_evaluate (cs [nseeds].get(), nn, pp, c, k, d);
while (range > 0 && results [nseeds] < stop)
{
long best = nseeds;
if (mode == 2)
{
for (long x = 1; x <= pp->nx; x++)
{
for (long y = 0; y < nseeds; y++)
{
cs[y]->fweights->data[1][x] = NUMrandomUniform(OlaMAX(0, (cs[nseeds]->fweights)->data[1][x] - range),
OlaMIN(1, cs[nseeds]->fweights->data[1][x] + range));
results[y] = FeatureWeights_evaluate (cs[y].get(), nn, pp, c, k, d);
}
for (long q = 0; q < nseeds; q++)
if (results[q] > results[best]) best = q;
if (results[best] > results[nseeds])
{
for (long x = 1; x <= pp->nx; x++) // BUG: a loop over x inside a loop over x; just hope mode is never 2
cs[nseeds]->fweights->data[1][x] = cs[best]->fweights->data[1][x];
results[nseeds] = results[best];
}
}
}
else
{
for (long y = 0; y < nseeds; y++)
{
for (long x = 1; x <= pp->nx; x++)
{
cs[y]->fweights->data[1][x] = NUMrandomUniform(OlaMAX(0, cs[nseeds]->fweights->data[1][x] - range),
OlaMIN(1, cs[nseeds]->fweights->data[1][x] + range));
}
results[y] = FeatureWeights_evaluate (cs [y].get(), nn, pp, c, k, d);
}
for (long q = 0; q < nseeds; q++)
if (results[q] > results[best]) best = q;
if (results[best] > results[nseeds])
{
for (long x = 1; x <= pp->nx; x++)
cs[nseeds]->fweights->data[1][x] = cs[best]->fweights->data[1][x];
results[nseeds] = results[best];
}
}
range -= alfa;
}
autoFeatureWeights result = cs [nseeds].move();
return result;
} catch (MelderError) {
Melder_throw (U"FeatureWeights: wrapper not computed.");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Evaluate feature weights, wrapper aux. //
/////////////////////////////////////////////////////////////////////////////////////////////
double FeatureWeights_evaluate // Obsolete - use *_EvaluateWithTestSet
// instead
(
///////////////////////////////
// Parameters //
///////////////////////////////
FeatureWeights fws, // Weights to evaluate
//
KNN nn, // Classifier
//
PatternList pp, // test pattern
//
Categories c, // test categories
//
long k, // k(!)
//
int d // distance weighting
//
)
{
try {
autoCategories o = KNN_classifyToCategories (nn, pp, fws, k, d);
double hits = 0.0;
for (long y = 1; y <= o->size; y ++)
if (FeatureWeights_areFriends (o->at [y], c->at [y])) hits ++;
hits /= o->size;
return hits;
} catch (MelderError) {
throw;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Compute feature weights according to the RELIEF-F algorithm //
/////////////////////////////////////////////////////////////////////////////////////////////
autoFeatureWeights FeatureWeights_computeRELIEF
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList pp, // source pattern
//
Categories c, // source categories
//
long k // k(!)
//
)
{
autoPatternList p = Data_copy (pp);
autoFeatureWeights me = FeatureWeights_create (p -> nx);
/////////////////////////////////
// Initial weights <- 0 //
/////////////////////////////////
for (long i = 1; i <= p->nx; i++) {
my fweights -> data [1] [i] = 0.0;
}
/////////////////////////////////
// Normalization //
/////////////////////////////////
autoNUMvector min (0L, p->nx - 1);
autoNUMvector max (0L, p->nx - 1);
for (long x = 1; x <= p -> nx; x ++) {
max [x] = p -> z [1] [x]; // BUG: this will just crash because of array index out of bounds
min [x] = max [x];
}
for (long y = 1; y <= p -> ny; y ++) {
for (long x = 1; x <= p->nx; x++) {
if (p->z[y][x] > max[x]) max[x] = p->z[y][x];
if (p->z[y][x] < min[x]) min[x] = p->z[y][x];
}
}
autoNUMvector alfa (0L, p -> nx - 1);
for (long x = 1; x <= p -> nx; x ++) {
alfa [x] = max [x] - min [x]; // BUG: this will just crash because of array index out of bounds
}
for (long y = 1; y <= p->ny; y++) {
for (long x = 1; x <= p->nx; x++) {
if (alfa [x] != 0.0) {
p->z[y][x] = (p->z[y][x] - min[x]) / alfa[x];
} else {
p->z[y][x] = 0.0;
}
}
}
/////////////////////////////////
// Computing prior class probs //
/////////////////////////////////
autoNUMvector priors (0L, c->size - 1); // worst-case allocations
autoNUMvector classes (0L, c->size - 1);//
autoNUMvector enemies (0L, c->size - 1);//
autoNUMvector friends (0L, c->size - 1);//
long nclasses = FeatureWeights_computePriors (c, classes.peek(), priors.peek());
Melder_assert (nclasses >= 2);
/////////////////////////////////
// Updating the w.vector //
/////////////////////////////////
for (long y = 1; y <= p -> ny; y ++) {
long nfriends = KNN_kFriends (p.get(), p.get(), c, y, k, friends.peek());
long nenemies = KNN_kUniqueEnemies (p.get(), p.get(), c, y, nclasses - 1, enemies.peek());
if (nfriends && nenemies) {
autoNUMvector classps (0L, nenemies - 1);
for (long eq = 0; eq < nenemies; eq ++) {
for (long iq = 0; iq < nclasses; iq ++) {
if (FeatureWeights_areFriends (c->at [enemies [eq]], c->at [classes [iq]])) {
classps [eq] = priors [iq];
break;
}
}
}
for (long x = 1; x <= p -> nx; x ++) {
double p1 = 0.0;
double p2 = 0.0;
for (long ec = 0; ec < nfriends; ec ++) {
p1 += fabs (p -> z [y] [x] - p -> z [friends [ec]] [x]) / (p -> ny * nfriends);
}
for (long ec = 0; ec < nenemies; ec++) {
p2 += (fabs (p->z[y][x] - p->z[enemies[ec]][x]) * classps[ec]) / p->ny;
}
my fweights -> data [1] [x] = my fweights -> data [1] [x] - p1 + p2;
}
}
}
return me;
}
/* End of file FeatureWeights.cpp */
praat-6.0.23/contrib/ola/FeatureWeights.h 0000664 0000000 0000000 00000005333 13023464014 0020224 0 ustar 00root root 0000000 0000000 #ifndef _FeatureWeights_h_
#define _FeatureWeights_h_
/* FeatureWeights.h
*
* Copyright (C) 2007-2008 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20080529 Initial release
* pb 2011/03/08
*/
/////////////////////////////////////////////////////
// Praat datatypes //
/////////////////////////////////////////////////////
#include "Data.h"
#include "TableOfReal.h"
#include "PatternList.h"
#include "Categories.h"
/////////////////////////////////////////////////////
// Miscs //
/////////////////////////////////////////////////////
#include "OlaP.h"
/////////////////////////////////////////////////////
// Praat specifics //
/////////////////////////////////////////////////////
#include "FeatureWeights_def.h"
/////////////////////////////////////////////////////
// Private definitions and macros //
/////////////////////////////////////////////////////
#define FeatureWeights_areFriends(x,y) ! SimpleString_compare (x,y)
#define FeatureWeights_areEnemies(x,y) SimpleString_compare (x,y)
/////////////////////////////////////////////////////
// Prototypes //
/////////////////////////////////////////////////////
// Create
autoFeatureWeights FeatureWeights_create
(
long nweights // number of weights
);
// Compute prior probabilities
long FeatureWeights_computePriors
(
Categories c, // source categories
long * indices, // Out: instances indices ..
double * priors // Out: .. and their prior probabilities
);
// Compute feature weights (obsolete)
autoFeatureWeights FeatureWeights_compute
(
PatternList pp, // Source pattern
Categories c, // Source categories
long k // k(!)
);
// Compute feature weights according to the RELIEF-F algorithm
autoFeatureWeights FeatureWeights_computeRELIEF
(
PatternList pp, // source pattern
Categories c, // source categories
long k // k(!)
);
/* End of file FeatureWeights.h */
#endif
praat-6.0.23/contrib/ola/FeatureWeights_def.h 0000664 0000000 0000000 00000001736 13023464014 0021045 0 ustar 00root root 0000000 0000000 /* FeatureWeights_def.h
*
* Copyright (C) 2007-2009 Ola Söder, 2011 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT FeatureWeights
oo_DEFINE_CLASS (FeatureWeights, Daata)
oo_AUTO_OBJECT (TableOfReal, 0, fweights)
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS (FeatureWeights)
#undef ooSTRUCT
/* End of file FeatureWeights_def.h */
praat-6.0.23/contrib/ola/KNN.cpp 0000664 0000000 0000000 00000156063 13023464014 0016266 0 ustar 00root root 0000000 0000000 /* KNN.cpp
*
* Copyright (C) 2008 Ola So"der, 2010-2012,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 2008/05/29 initial release
* pb 2010/06/06 removed some array-creations-on-the-stack
* pb 2011/04/12 C++
* pb 2011/04/13 removed several memory leaks
* pb 2011/07/07 some exception safety
*/
#include "KNN.h"
#include "KNN_threads.h"
#include "OlaP.h"
#include "oo_DESTROY.h"
#include "KNN_def.h"
#include "oo_COPY.h"
#include "KNN_def.h"
#include "oo_EQUAL.h"
#include "KNN_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "KNN_def.h"
#include "oo_WRITE_TEXT.h"
#include "KNN_def.h"
#include "oo_WRITE_BINARY.h"
#include "KNN_def.h"
#include "oo_READ_TEXT.h"
#include "KNN_def.h"
#include "oo_READ_BINARY.h"
#include "KNN_def.h"
#include "oo_DESCRIPTION.h"
#include "KNN_def.h"
Thing_implement (KNN, Daata, 0);
/////////////////////////////////////////////////////////////////////////////////////////////
// Praat specifics //
/////////////////////////////////////////////////////////////////////////////////////////////
void structKNN :: v_info ()
{
structDaata :: v_info ();
MelderInfo_writeLine (U"Size of instancebase: ", nInstances);
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Creation //
/////////////////////////////////////////////////////////////////////////////////////////////
autoKNN KNN_create ()
{
try {
autoKNN me = Thing_new (KNN);
my nInstances = 0;
return me;
} catch (MelderError) {
Melder_throw (U"KNN classifier not created.");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Learning //
/////////////////////////////////////////////////////////////////////////////////////////////
int KNN_learn
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier to be trained
//
PatternList p, // source pattern
//
Categories c, // target categories
//
int method, // method <- REPLACE or APPEND
//
int ordering // ordering <- SHUFFLE?
)
{
if (c->size == p->ny) // the number of input vectors must
{ // equal the number of categories.
switch (method)
{
case kOla_REPLACE: // in REPLACE mode simply
// dispose of the current
my input = Data_copy (p); // LEAK
my output = Data_copy (c);
my nInstances = c->size;
break;
case kOla_APPEND: // in APPEND mode a new
// instance base is formed
// by merging the new and
// the old.
//
if (p->nx == (my input)->nx) // the number of features
// of the old and new
// instance base must
// match; otherwise merging
// won't be possible.
{
/*
* Create without change.
*/
autoMatrix matrix = Matrix_appendRows (my input.get(), p, classPatternList);
autoPatternList tinput = matrix.static_cast_move ();
autoCategories toutput = Data_copy (my output.get());
toutput -> merge (c);
/*
* Change without error.
*/
my input = tinput.move();
my output = toutput.move();
my nInstances += p->ny;
}
else // fail
{
return kOla_DIMENSIONALITY_MISMATCH;
}
break;
}
if (ordering == kOla_SHUFFLE) // shuffle the instance base
{
KNN_shuffleInstances(me);
}
}
else // fail
{
return kOla_PATTERN_CATEGORIES_MISMATCH;
}
return kOla_SUCCESS; // success
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Classification - To Categories //
/////////////////////////////////////////////////////////////////////////////////////////////
typedef struct
{
KNN me;
PatternList ps;
long * output;
FeatureWeights fws;
long k;
int dist;
long istart;
long istop;
} KNN_input_ToCategories_t;
autoCategories KNN_classifyToCategories
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier being used
//
PatternList ps, // the pattern to classify
//
FeatureWeights fws, // feature weights
//
long k, // the number of sought after neighbours
//
int dist // distance weighting
)
{
int nthreads = KNN_getNumberOfCPUs();
long *outputindices = NUMvector (0, ps->ny);
long chunksize = ps->ny / nthreads;
Melder_assert(nthreads > 0);
Melder_assert(k > 0 && k <= my nInstances);
if(chunksize < 1)
{
chunksize = 1;
nthreads = ps->ny;
}
long istart = 1;
long istop = chunksize;
autoCategories output = Categories_create ();
KNN_input_ToCategories_t ** input = (KNN_input_ToCategories_t **) malloc(nthreads * sizeof(KNN_input_ToCategories_t *));
if (!input)
return autoCategories();
for (int i = 0; i < nthreads; i ++)
{
input [i] = (KNN_input_ToCategories_t *) malloc(sizeof(KNN_input_ToCategories_t));
if (! input [i])
{
while (input [i --])
free (input [i]);
free (input);
return autoCategories();
}
}
for (int i = 0; i < nthreads; i ++)
{
input[i]->me = me;
input[i]->ps = ps;
input[i]->output = outputindices;
input[i]->fws = fws;
input[i]->k = k;
input[i]->dist = dist;
input[i]->istart = istart;
if (istop + chunksize > ps->ny)
{
input[i]->istop = ps->ny;
break;
}
else
{
input[i]->istop = istop;
istart = istop + 1;
istop += chunksize;
}
}
enum KNN_thread_status * error = (enum KNN_thread_status *) KNN_threadDistribution(KNN_classifyToCategoriesAux, (void **) input, nthreads);
//void *error = KNN_classifyToCategoriesAux (input [0]);
for (int i = 0; i < nthreads; i ++)
free (input [i]);
free (input);
if (error) // Something went very wrong, you ought to inform the user!
{
free (error);
return autoCategories();
}
for (long i = 1; i <= ps -> ny; i ++) {
output -> addItem_move (Data_copy (my output->at [outputindices [i]]));
}
NUMvector_free (outputindices, 0);
return output;
}
void * KNN_classifyToCategoriesAux
(
///////////////////////////////
// Parameters //
///////////////////////////////
void * input
)
{
Melder_assert(((KNN_input_ToCategories_t *) input)->istart > 0 &&
((KNN_input_ToCategories_t *) input)->istop > 0 &&
((KNN_input_ToCategories_t *) input)->istart <= ((KNN_input_ToCategories_t *) input)->ps->ny &&
((KNN_input_ToCategories_t *) input)->istop <= ((KNN_input_ToCategories_t *) input)->ps->ny &&
((KNN_input_ToCategories_t *) input)->istart <= ((KNN_input_ToCategories_t *) input)->istop);
long ncollected;
long ncategories;
long *indices = NUMvector (0, ((KNN_input_ToCategories_t *) input)->k);
long *freqindices = NUMvector (0, ((KNN_input_ToCategories_t *) input)->k);
double *distances = NUMvector (0, ((KNN_input_ToCategories_t *) input)->k);
double *freqs = NUMvector (0, ((KNN_input_ToCategories_t *) input)->k);
for (long y = ((KNN_input_ToCategories_t *) input)->istart; y <= ((KNN_input_ToCategories_t *) input)->istop; ++y)
{
/////////////////////////////////////////
// Localizing the k nearest neighbours //
/////////////////////////////////////////
ncollected = KNN_kNeighbours
(
((KNN_input_ToCategories_t *) input)->ps,
((KNN_input_ToCategories_t *) input)->me->input.get(),
((KNN_input_ToCategories_t *) input)->fws, y,
((KNN_input_ToCategories_t *) input)->k, indices, distances
);
/////////////////////////////////////////////////
// Computing frequencies and average distances //
/////////////////////////////////////////////////
ncategories = KNN_kIndicesToFrequenciesAndDistances
(
((KNN_input_ToCategories_t *) input)->me->output.get(),
((KNN_input_ToCategories_t *) input)->k,
indices, distances, freqs, freqindices
);
////////////////////////
// Distance weighting //
////////////////////////
switch(((KNN_input_ToCategories_t *) input)->dist)
{
case kOla_DISTANCE_WEIGHTED_VOTING:
for (long c = 0; c < ncategories; ++c)
freqs[c] *= 1 / OlaMAX(distances[c], kOla_MINFLOAT);
break;
case kOla_SQUARED_DISTANCE_WEIGHTED_VOTING:
for (long c = 0; c < ncategories; ++c)
freqs[c] *= 1 / OlaMAX(OlaSQUARE(distances[c]), kOla_MINFLOAT);
}
KNN_normalizeFloatArray(freqs, ncategories);
((KNN_input_ToCategories_t *) input)->output[y] = freqindices[KNN_max(freqs, ncategories)];
}
NUMvector_free (indices, 0);
NUMvector_free (freqindices, 0);
NUMvector_free (distances, 0);
NUMvector_free (freqs, 0);
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Classification - To TableOfReal //
/////////////////////////////////////////////////////////////////////////////////////////////
typedef struct {
KNN me;
PatternList ps;
Categories uniqueCategories;
TableOfReal output;
FeatureWeights fws;
long k;
int dist;
long istart;
long istop;
} KNN_input_ToTableOfReal_t;
autoTableOfReal KNN_classifyToTableOfReal
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier being used
//
PatternList ps, // source PatternList
//
FeatureWeights fws, // feature weights
//
long k, // the number of sought after neighbours
//
int dist // distance weighting
)
{
int nthreads = KNN_getNumberOfCPUs();
long chunksize = ps->ny / nthreads;
autoCategories uniqueCategories = Categories_selectUniqueItems (my output.get());
long ncategories = Categories_getSize (uniqueCategories.get());
Melder_assert (nthreads > 0);
Melder_assert (ncategories > 0);
Melder_assert (k > 0 && k <= my nInstances);
if (! ncategories)
return autoTableOfReal();
if (chunksize < 1)
{
chunksize = 1;
nthreads = ps->ny;
}
long istart = 1;
long istop = chunksize;
KNN_input_ToTableOfReal_t ** input = (KNN_input_ToTableOfReal_t **) malloc (nthreads * sizeof (KNN_input_ToTableOfReal_t *));
if(! input)
return autoTableOfReal();
autoTableOfReal output = TableOfReal_create(ps->ny, ncategories);
for (long i = 1; i <= ncategories; i ++)
TableOfReal_setColumnLabel (output.get(), i, SimpleString_c (uniqueCategories->at [i]));
for (int i = 0; i < nthreads; i ++)
{
input [i] = (KNN_input_ToTableOfReal_t *) malloc (sizeof (KNN_input_ToTableOfReal_t));
if (! input [i])
{
while (input [i --]) // ppgb FIXME: is always false
free (input [i]); // ppgb FIXME: the stopping condition is incorrect
free (input);
return autoTableOfReal();
}
}
for (int i = 0; i < nthreads; i ++)
{
input[i]->me = me;
input[i]->ps = ps;
input[i]->output = output.get(); // YUCK: reference copy
input[i]->uniqueCategories = uniqueCategories.releaseToAmbiguousOwner();
input[i]->fws = fws;
input[i]->k = k;
input[i]->dist = dist;
input[i]->istart = istart;
if(istop + chunksize > ps->ny)
{
input[i]->istop = ps->ny;
break;
}
else
{
input[i]->istop = istop;
istart = istop + 1;
istop += chunksize;
}
}
enum KNN_thread_status * error = (enum KNN_thread_status *) KNN_threadDistribution(KNN_classifyToTableOfRealAux, (void **) input, nthreads);
for (int i = 0; i < nthreads; i ++)
free (input [i]);
free (input);
if (error) // Something went very wrong, you ought to inform the user!
{
free (error);
return autoTableOfReal();
}
return output;
}
void * KNN_classifyToTableOfRealAux
(
///////////////////////////////
// Parameters //
///////////////////////////////
void * input
)
{
long ncategories = Categories_getSize (((KNN_input_ToTableOfReal_t *) input)->uniqueCategories);
autoNUMvector indices (0L, ((KNN_input_ToTableOfReal_t *) input)->k);
autoNUMvector distances (0L, ((KNN_input_ToTableOfReal_t *) input)->k);
for (long y = ((KNN_input_ToTableOfReal_t *) input)->istart; y <= ((KNN_input_ToTableOfReal_t *) input)->istop; ++y)
{
KNN_kNeighbours(((KNN_input_ToTableOfReal_t *) input)->ps,
((KNN_input_ToTableOfReal_t *) input)->me->input.get(),
((KNN_input_ToTableOfReal_t *) input)->fws, y,
((KNN_input_ToTableOfReal_t *) input)->k, indices.peek(), distances.peek());
for(long i = 0; i < ((KNN_input_ToTableOfReal_t *) input)->k; ++i)
{
for(long j = 1; j <= ncategories; ++j) {
if (FeatureWeights_areFriends (((KNN_input_ToTableOfReal_t *) input) -> me -> output->at [indices [i]],
((KNN_input_ToTableOfReal_t *) input) -> uniqueCategories->at [j]))
{
++((KNN_input_ToTableOfReal_t *) input) -> output -> data [y] [j];
}
}
}
}
switch (((KNN_input_ToTableOfReal_t *) input)->dist)
{
case kOla_DISTANCE_WEIGHTED_VOTING:
for (long y = ((KNN_input_ToTableOfReal_t *) input) -> istart; y <= ((KNN_input_ToTableOfReal_t *) input) -> istop; y ++)
{
double sum = 0;
for(long c = 1; c <= ncategories; ++c)
{
((KNN_input_ToTableOfReal_t *) input)->output->data[y][c] *= 1 / OlaMAX(distances[c], kOla_MINFLOAT);
sum += ((KNN_input_ToTableOfReal_t *) input)->output->data[y][c];
}
for(long c = 1; c <= ncategories; ++c)
((KNN_input_ToTableOfReal_t *) input)->output->data[y][c] /= sum;
}
break;
case kOla_SQUARED_DISTANCE_WEIGHTED_VOTING:
for (long y = ((KNN_input_ToTableOfReal_t *) input)->istart; y <= ((KNN_input_ToTableOfReal_t *) input)->istop; ++y)
{
double sum = 0;
for(long c = 1; c <= ncategories; ++c)
{
((KNN_input_ToTableOfReal_t *) input)->output->data[y][c] *= 1 / OlaMAX(OlaSQUARE(distances[c]), kOla_MINFLOAT);
sum += ((KNN_input_ToTableOfReal_t *) input)->output->data[y][c];
}
for(long c = 1; c <= ncategories; ++c)
((KNN_input_ToTableOfReal_t *) input)->output->data[y][c] /= sum;
}
break;
case kOla_FLAT_VOTING:
for (long y = ((KNN_input_ToTableOfReal_t *) input)->istart; y <= ((KNN_input_ToTableOfReal_t *) input)->istop; ++y)
{
double sum = 0;
for(long c = 1; c <= ncategories; ++c)
sum += ((KNN_input_ToTableOfReal_t *) input)->output->data[y][c];
for(long c = 1; c <= ncategories; ++c)
((KNN_input_ToTableOfReal_t *) input)->output->data[y][c] /= sum;
}
}
return nullptr;
}
//////////////////////////////////////////////////////////////////////////////////////////////
// Classification - Folding //
/////////////////////////////////////////////////////////////////////////////////////////////
autoCategories KNN_classifyFold
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier being used
//
PatternList ps, // source PatternList
//
FeatureWeights fws, // feature weights
//
long k, // the number of sought after neighbours
//
int dist, // distance weighting
//
long begin, // fold start, inclusive [...
//
long end // fold end, inclusive ...]
//
)
{
Melder_assert(k > 0 && k <= ps->ny);
Melder_assert(end > 0 && end <= ps->ny);
Melder_assert(begin > 0 && begin <= ps->ny);
if (begin > end)
OlaSWAP(long, begin, end);
if (k > my nInstances - (end - begin))
k = my nInstances - (end - begin);
long ncollected;
long ncategories;
autoNUMvector indices (0L, k);
autoNUMvector freqindices (0L, k);
autoNUMvector distances (0L, k);
autoNUMvector freqs (0L, k);
autoNUMvector outputindices (0L, ps->ny);
long noutputindices = 0;
for (long y = begin; y <= end; ++y)
{
/////////////////////////////////////////
// Localizing the k nearest neighbours //
/////////////////////////////////////////
ncollected = KNN_kNeighboursSkipRange (ps, my input.get(), fws, y, k, indices.peek(), distances.peek(), begin, end);
/////////////////////////////////////////////////
// Computing frequencies and average distances //
/////////////////////////////////////////////////
ncategories = KNN_kIndicesToFrequenciesAndDistances (my output.get(), k, indices.peek(), distances.peek(), freqs.peek(), freqindices.peek());
////////////////////////
// Distance weighting //
////////////////////////
switch (dist)
{
case kOla_DISTANCE_WEIGHTED_VOTING:
for (long c = 0; c < ncategories; c ++)
freqs [c] *= 1.0 / OlaMAX (distances [c], kOla_MINFLOAT);
break;
case kOla_SQUARED_DISTANCE_WEIGHTED_VOTING:
for (long c = 0; c < ncategories; c ++)
freqs [c] *= 1.0 / OlaMAX (OlaSQUARE (distances [c]), kOla_MINFLOAT);
}
KNN_normalizeFloatArray (freqs.peek(), ncategories);
outputindices [noutputindices++] = freqindices [KNN_max (freqs.peek(), ncategories)];
}
autoCategories output = Categories_create ();
for (long o = 0; o < noutputindices; o ++) {
output -> addItem_move (Data_copy (my output->at [outputindices [o]]));
}
return output;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Evaluation //
/////////////////////////////////////////////////////////////////////////////////////////////
double KNN_evaluate
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier being used
//
FeatureWeights fws, // feature weights
//
long k, // the number of sought after neighbours
//
int dist, // distance weighting
//
int mode // kOla_TEN_FOLD_CROSS_VALIDATION / kOla_LEAVE_ONE_OUT
//
)
{
double correct = 0.0;
long adder;
switch(mode)
{
case kOla_TEN_FOLD_CROSS_VALIDATION:
adder = my nInstances / 10;
break;
case kOla_LEAVE_ONE_OUT:
if (my nInstances > 1)
adder = 1;
else
adder = 0;
break;
default:
adder = 0;
}
if (adder == 0)
return -1;
for (long begin = 1; begin <= my nInstances; begin += adder)
{
autoCategories c = KNN_classifyFold (me, my input.get(), fws, k, dist, begin, OlaMIN (begin + adder - 1, my nInstances));
for (long y = 1; y <= c->size; y ++)
if (FeatureWeights_areFriends (c->at [y], my output->at [begin + y - 1]))
correct += 1.0;
}
correct /= (double) my nInstances;
return correct;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Evaluation using a separate test set //
/////////////////////////////////////////////////////////////////////////////////////////////
double KNN_evaluateWithTestSet
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier being used
//
PatternList p, // The vectors of the test set
//
Categories c, // The categories of the test set
//
FeatureWeights fws, // feature weights
//
long k, // the number of sought after neighbours
//
int dist // distance weighting
//
)
{
double correct = 0.0;
autoCategories t = KNN_classifyToCategories (me, p, fws, k, dist);
for (long y = 1; y <= t->size; y ++)
if (FeatureWeights_areFriends (t->at [y], c->at [y])) correct += 1.0;
return correct / c->size;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Model search //
/////////////////////////////////////////////////////////////////////////////////////////////
typedef struct structsoil
{
double performance;
long dist;
long k;
} soil;
double KNN_modelSearch
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier being used
//
FeatureWeights fws, // feature weights
//
long * k, // valid long *, to hold the output value of k
//
int * dist, // valid int *, to hold the output value dist_weight
//
int mode, // evaluation mode
//
double rate, // learning rate
//
long nseeds // the number of seeds to be used
//
)
{
try {
int dists[] =
{
kOla_SQUARED_DISTANCE_WEIGHTED_VOTING,
kOla_DISTANCE_WEIGHTED_VOTING,
kOla_FLAT_VOTING
};
long max = *k;
double range = (double) max / 2.0;
double pivot = range;
double dpivot = 1.0;
double drange = 1.0;
double drate = rate / range;
soil best = {0, lround(dpivot), lround(dpivot)};
autoNUMvector field (0L, nseeds - 1);
while (range > 0)
{
for (long n = 0; n < nseeds; n++)
{
field[n].k = lround (NUMrandomUniform (OlaMAX (pivot - range, 1), OlaMIN (pivot + range, max)));
field[n].dist = lround (NUMrandomUniform (OlaMAX (dpivot - drange, 0), OlaMIN (dpivot + drange, 2)));
field[n].performance = KNN_evaluate (me, fws, field[n].k, dists[field[n].dist], mode);
}
long maxindex = 0;
for (long n = 1; n < nseeds; n++)
if (field[n].performance > field[maxindex].performance) maxindex = n;
if (field[maxindex].performance > best.performance)
{
pivot = field[maxindex].k;
dpivot = field[maxindex].dist;
best.performance = field[maxindex].performance;
best.dist = field[maxindex].dist;
best.k = field[maxindex].k;
}
range -= rate;
drange -= drate;
}
*k = best.k;
*dist = dists[best.dist];
return best.performance;
} catch (MelderError) {
Melder_throw (me, U" & ", fws, U": model search not performed.");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Euclidean distance //
/////////////////////////////////////////////////////////////////////////////////////////////
double KNN_distanceEuclidean
(
PatternList ps, // PatternList 1
//
PatternList pt, // PatternList 2
//
FeatureWeights fws, // Feature weights
//
long rows, // Vector index of pattern 1
//
long rowt // Vector index of pattern 2
)
{
double distance = 0.0;
for (long x = 1; x <= ps->nx; ++x)
distance += OlaSQUARE ((ps->z[rows][x] - pt->z[rowt][x]) * fws->fweights->data[1][x]);
return sqrt (distance);
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Manhattan distance //
/////////////////////////////////////////////////////////////////////////////////////////////
double KNN_distanceManhattan
(
PatternList ps, // PatternList 1
//
PatternList pt, // PatternList 2
//
long rows, // Vector index of pattern 1
//
long rowt // Vector index of pattern 2
//
)
{
double distance = 0.0;
for (long x = 1; x <= ps->nx; ++x)
distance += fabs (ps->z[rows][x] - pt->z[rowt][x]);
return distance;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Find longest distance //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_max
(
double * distances, // an array of distances containing ...
//
long ndistances // ndistances distances
//
)
{
long maxndx = 0;
for (long maxc = 1; maxc < ndistances; ++maxc)
if (distances[maxc] > distances[maxndx])
maxndx = maxc;
return maxndx;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Locate k neighbours, skip one + disposal of distance //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_kNeighboursSkip
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList j, // source pattern
//
PatternList p, // target pattern (where neighbours are sought for)
//
FeatureWeights fws, // feature weights
//
long jy, // source instance index
//
long k, // the number of sought after neighbours
//
long * indices, // memory space to contain the indices of
// the k neighbours
//
long skipper // the index of the instance to be skipped
//
)
{
long maxi;
long dc = 0;
long py = 1;
autoNUMvector distances (0L, k - 1);
Melder_assert (jy > 0 && jy <= j->ny);
Melder_assert (k > 0 && k <= p->ny);
Melder_assert (skipper <= p->ny);
while (dc < k && py <= p -> ny)
{
if (py != jy && py != skipper)
{
distances [dc] = KNN_distanceEuclidean (j, p, fws, jy, py);
indices [dc] = py;
++ dc;
}
++ py;
}
maxi = KNN_max (distances.peek(), k);
while (py <= p->ny)
{
if (py != jy && py != skipper)
{
double d = KNN_distanceEuclidean (j, p, fws, jy, py);
if (d < distances [maxi])
{
distances [maxi] = d;
indices [maxi] = py;
maxi = KNN_max (distances.peek(), k);
}
}
++ py;
}
return OlaMIN (k, dc);
}
//////////////////////////////////////////////////////////////////////////////////
// Locate the k nearest neighbours, exclude instances within the range defined //
// by [begin ... end] //
//////////////////////////////////////////////////////////////////////////////////
long KNN_kNeighboursSkipRange
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList j, // source-pattern (where the unknown is located)
//
PatternList p, // target pattern (where neighbours are sought for)
//
FeatureWeights fws, // feature weights
//
long jy, // the index of the unknown instance in the source pattern
//
long k, // the number of sought after neighbours
//
long * indices, // a pointer to a memory-space big enough for k longs
// representing indices to the k neighbours in the
// target pattern
//
double * distances, // a pointer to a memory-space big enough for k
// doubles representing the distances to the k
// neighbours
//
long begin, // an index indicating the first instance in the
// target pattern to be excluded from the search
//
long end // an index indicating the last instance in the
// range of excluded instances in the target
// pattern
)
{
///////////////////////////////
// Private variables //
///////////////////////////////
long maxi; // index indicating the most distant neighbour
// among the k nearest
//
long dc = 0; // fetch counter
//
long py = 0; //
Melder_assert (jy > 0 && jy <= j->ny);
Melder_assert (k > 0 && k <= p->ny);
Melder_assert (end > 0 && end <= j->ny);
Melder_assert (begin > 0 && begin <= j->ny);
while (dc < k && (end + py) % p->ny + 1 != begin) // the first k neighbours are the nearest found
{ // sofar
if ((end + py) % p->ny + 1 != jy) // no instance is its own neighbour
{
distances [dc] = KNN_distanceEuclidean (j, p, fws, jy, (end + py) % p->ny + 1);
indices [dc] = (end + py) % p->ny + 1;
++dc;
}
++py;
}
maxi = KNN_max(distances, k); // accept only those instances less distant
while ((end + py) % p->ny + 1 != begin) // than the least near one found this far
{
if ((end + py) % p->ny + 1 != jy)
{
double d = KNN_distanceEuclidean(j, p, fws, jy, (end + py) % p->ny + 1);
if (d < distances[maxi])
{
distances [maxi] = d;
indices [maxi] = (end + py) % p->ny + 1;
maxi = KNN_max (distances, k);
}
}
++py;
}
return OlaMIN (k, dc); // return the number of found neighbours
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Locate k neighbours //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_kNeighbours
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList j, // source-pattern (where the unknown is located)
//
PatternList p, // target pattern (where neighbours are sought for)
//
FeatureWeights fws, // feature weights
//
long jy, // the index of the unknown instance in the source pattern
//
long k, // the number of sought after neighbours
//
long * indices, // a pointer to a memory-space big enough for k longs
// representing indices to the k neighbours in the
// target pattern
double * distances // a pointer to a memory-space big enough for k
// doubles representing the distances to the k
// neighbours
//
)
{
long maxi;
long dc = 0;
long py = 1;
Melder_assert (jy > 0 && jy <= j->ny);
Melder_assert (k > 0 && k <= p->ny);
Melder_assert (indices);
Melder_assert (distances);
while (dc < k && py <= p->ny)
{
if (py != jy)
{
distances[dc] = KNN_distanceEuclidean (j, p, fws, jy, py);
indices[dc] = py;
++dc;
}
++py;
}
maxi = KNN_max(distances, k);
while (py <= p->ny)
{
if (py != jy)
{
double d = KNN_distanceEuclidean (j, p, fws, jy, py);
if (d < distances [maxi])
{
distances [maxi] = d;
indices [maxi] = py;
maxi = KNN_max (distances, k);
}
}
++py;
}
long ret = OlaMIN (k, dc);
if (ret < 1)
{
indices [0] = jy;
return 0;
}
else
return ret;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Locating k (nearest) friends //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_kFriends
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList j, // source-pattern
//
PatternList p, // target pattern (where friends are sought for)
//
Categories c, // categories
//
long jy, // the index of the source instance
//
long k, // the number of sought after friends
//
long * indices // a pointer to a memory-space big enough for k longs
// representing indices to the k friends in the
// target pattern
)
{
long maxi;
long dc = 0;
long py = 1;
autoNUMvector distances (0L, k - 1);
Melder_assert (jy <= j->ny && k <= p->ny && k > 0);
Melder_assert (indices);
while (dc < k && py < p->ny)
{
if (jy != py && FeatureWeights_areFriends (c->at [jy], c->at [py]))
{
distances[dc] = KNN_distanceManhattan (j, p, jy, py);
indices[dc] = py;
dc++;
}
++py;
}
maxi = KNN_max (distances.peek(), k);
while (py <= p->ny)
{
if (jy != py && FeatureWeights_areFriends (c->at [jy], c->at [py]))
{
double d = KNN_distanceManhattan (j, p, jy, py);
if (d < distances [maxi])
{
distances [maxi] = d;
indices [maxi] = py;
maxi = KNN_max (distances.peek(), k);
}
}
++py;
}
return OlaMIN (k, dc);
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Computing the distance to the nearest enemy //
/////////////////////////////////////////////////////////////////////////////////////////////
double KNN_nearestEnemy
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList j, // source-pattern
//
PatternList p, // target pattern (where friends are sought for)
//
Categories c, // categories
//
long jy // the index of the source instance
//
)
{
double distance = KNN_distanceManhattan(j, p, jy, 1);
Melder_assert(jy > 0 && jy <= j->ny );
for (long y = 2; y <= p->ny; y++)
{
if (FeatureWeights_areEnemies (c->at [jy], c->at [y]))
{
double newdist = KNN_distanceManhattan(j, p, jy, y);
if (newdist > distance) distance = newdist;
}
}
return distance;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Computing the number of friends among k neighbours //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_friendsAmongkNeighbours
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList j, // source-pattern
//
PatternList p, // target pattern (where friends are sought for)
//
Categories c, // categories
//
long jy, // the index of the source instance
//
long k // k (!)
//
)
{
autoNUMvector distances (0L, k - 1);
autoNUMvector indices (0L, k - 1);
long friends = 0;
Melder_assert (jy > 0 && jy <= j->ny && k <= p->ny && k > 0);
autoFeatureWeights fws = FeatureWeights_create (p -> nx);
long ncollected = KNN_kNeighbours (j, p, fws.get(), jy, k, indices.peek(), distances.peek());
while (ncollected--)
if (FeatureWeights_areFriends (c->at [jy], c->at [indices [ncollected]])) friends ++;
return friends;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Locating k unique (nearest) enemies //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_kUniqueEnemies
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList j, // source-pattern
//
PatternList p, // target pattern (where friends are sought for)
//
Categories c, // categories
//
long jy, // the index of the source instance
//
long k, // k (!)
//
long * indices // a memory space to hold the indices of the
// located enemies
//
)
{
long maxi;
long dc = 0;
long py = 1;
double *distances = NUMvector (0, k - 1);
Melder_assert (jy <= j->ny);
Melder_assert (k <= p->ny);
Melder_assert (k > 0);
Melder_assert (indices);
while (dc < k && py <= p->ny)
{
if (FeatureWeights_areEnemies (c->at [jy], c->at [py]))
{
int hasfriend = 0;
for (long sc = 0; sc < dc; ++sc)
if (FeatureWeights_areFriends (c->at [py], c->at [indices [sc]])) hasfriend = 1;
if (!hasfriend)
{
distances[dc] = KNN_distanceManhattan(j, p, jy, py);
indices[dc] = py;
++dc;
}
}
++py;
}
maxi = KNN_max(distances, k);
while (py <= p->ny)
{
if (FeatureWeights_areEnemies (c->at [jy], c->at [py]))
{
int hasfriend = 0;
for (long sc = 0; sc < dc; ++sc)
if (FeatureWeights_areFriends (c->at [py], c->at [indices[sc]])) hasfriend = 1;
if (!hasfriend)
{
double d = KNN_distanceManhattan(j, p, jy, py);
if (d < distances[maxi] && FeatureWeights_areFriends (c->at [jy], c->at [py]))
{
distances[maxi] = d;
indices[maxi] = py;
maxi = KNN_max(distances, k);
}
}
}
++py;
}
NUMvector_free (distances, 0);
return OlaMIN (k, dc);
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Compute dissimilarity matrix //
/////////////////////////////////////////////////////////////////////////////////////////////
autoDissimilarity KNN_patternToDissimilarity
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList p, // PatternList
//
FeatureWeights fws // Feature weights
//
)
{
autoDissimilarity output = Dissimilarity_create (p -> ny);
for (long y = 1; y <= p -> ny; ++ y)
for (long x = 1; x <= p -> ny; ++ x)
output -> data [y] [x] = KNN_distanceEuclidean (p, p, fws, y, x);
return output;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Compute frequencies //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_kIndicesToFrequenciesAndDistances
(
///////////////////////////////
// Parameters //
///////////////////////////////
Categories c, // Source categories
//
long k, // k (!)
//
long * indices, // In: indices
//
double * distances, // Out: distances
//
double * freqs, // Out: and frequencies (double, sic!)
//
long *freqindices // Out: and indices -> freqs.
)
{
long ncategories = 0;
Melder_assert (k <= c->size && k > 0);
Melder_assert (distances && indices && freqs && freqindices);
for (long y = 0; y < k; ++y)
{
int hasfriend = 0;
long ifriend = 0;
while (ifriend < ncategories)
{
if (FeatureWeights_areFriends (c->at [indices [y]], c->at [freqindices [ifriend]]))
{
hasfriend = 1;
break;
}
++ifriend;
}
if (!hasfriend)
{
freqindices[ncategories] = indices[y];
freqs[ncategories] = 1;
distances[ncategories] = distances[y];
ncategories++;
}
else
{
++freqs[ifriend];
distances[ifriend] += (distances[y] - distances[ifriend]) / (ncategories + 1);
}
}
return(ncategories);
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Normalize array //
/////////////////////////////////////////////////////////////////////////////////////////////
void KNN_normalizeFloatArray
(
///////////////////////////////
// Parameters //
///////////////////////////////
double * array, // Array to be normalized
//
long n // The number of elements
// in the array
)
{
long c = 0;
double sum = 0;
while(c < n)
sum += array[c++];
while(c--)
array[c] /= sum;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Remove instance //
/////////////////////////////////////////////////////////////////////////////////////////////
void KNN_removeInstance
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // Classifier
//
long y // Index of the instance to be purged
//
)
{
if (y == 1 && my nInstances == 1) {
my nInstances = 0;
my input.reset();
my output.reset();
return;
}
Melder_assert (y > 0 && y <= my nInstances);
autoPatternList newPattern = PatternList_create (my nInstances - 1, my input -> nx);
long yt = 1;
for (long cy = 1; cy <= my nInstances; cy ++) {
if (cy != y) {
for (long cx = 1; cx <= my input -> nx; cx ++)
newPattern -> z [yt] [cx] = my input -> z [cy] [cx];
yt ++;
}
}
my input = newPattern.move();
my output -> removeItem (y);
my nInstances--;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Shuffle instances //
/////////////////////////////////////////////////////////////////////////////////////////////
void KNN_shuffleInstances
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me // Classifier whose instance
// base is to be shuffled
)
{
if (my nInstances < 2)
return; // it takes at least two to tango
autoPatternList new_input = PatternList_create (my nInstances, my input -> nx);
autoCategories new_output = Categories_create ();
long y = 1;
while (my nInstances)
{
long pick = NUMrandomInteger (1, my nInstances);
new_output -> addItem_move (Data_copy (my output->at [pick]));
for (long x = 1; x <= my input -> nx; x ++)
new_input -> z [y] [x] = my input -> z [pick] [x];
KNN_removeInstance (me, pick);
y ++;
}
my nInstances = new_output->size;
my input = new_input.move();
my output = new_output.move();
}
/////////////////////////////////////////////////////////////////////////////////////////////
// KNN to Permutation (experimental) //
/////////////////////////////////////////////////////////////////////////////////////////////
autoPermutation KNN_SA_ToPermutation
(
///////////////////////////////
// Parameters //
///////////////////////////////
KNN me, // the classifier being used
//
long tries, //
//
long iterations, //
//
double step_size, //
//
double boltzmann_c, //
//
double temp_start, //
//
double damping_f, //
//
double temp_stop //
//
)
{
gsl_rng * r;
const gsl_rng_type * T;
KNN_SA_t * istruct = KNN_SA_t_create (my input.get());
autoPermutation result = Permutation_create (my nInstances);
gsl_siman_params_t params = { (int) tries, (int) iterations, step_size, boltzmann_c, temp_start, damping_f, temp_stop};
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
gsl_siman_solve(r,
istruct,
KNN_SA_t_energy,
KNN_SA_t_step,
KNN_SA_t_metric,
nullptr, // KNN_SA_t_print
KNN_SA_t_copy,
KNN_SA_t_copy_construct,
KNN_SA_t_destroy,
0,
params);
for (long i = 1; i <= my nInstances; ++i)
result->p[i] = istruct->indices[i];
KNN_SA_t_destroy(istruct);
return result;
}
double KNN_SA_t_energy
(
///////////////////////////////
// Parameters //
///////////////////////////////
void * istruct
)
{
if(((KNN_SA_t *) istruct)->p->ny < 2)
return(0);
double eCost = 0;
for(long i = 1; i <= ((KNN_SA_t *) istruct)->p->ny; ++i)
{
/* fast and sloppy version */
double jDist = 0;
double kDist = 0;
long j = i - 1 > 0 ? i - 1 : ((KNN_SA_t *) istruct)->p->ny;
long k = i + 1 <= ((KNN_SA_t *) istruct)->p->ny ? i + 1 : 1;
for (long x = 1; x <= ((KNN_SA_t *) istruct)->p->nx; ++x)
{
jDist += OlaSQUARE(((KNN_SA_t *) istruct)->p->z[((KNN_SA_t *) istruct)->indices[i]][x] -
((KNN_SA_t *) istruct)->p->z[((KNN_SA_t *) istruct)->indices[j]][x]);
kDist += OlaSQUARE(((KNN_SA_t *) istruct)->p->z[((KNN_SA_t *) istruct)->indices[i]][x] -
((KNN_SA_t *) istruct)->p->z[((KNN_SA_t *) istruct)->indices[k]][x]);
}
eCost += ((sqrt(jDist) + sqrt(kDist)) / 2 - eCost) / i;
}
return(eCost);
}
double KNN_SA_t_metric
(
void * istruct1,
void * istruct2
)
{
double result = 0;
for(long i = ((KNN_SA_t *) istruct1)->p->ny; i >= 1; --i)
if(((KNN_SA_t *) istruct1)->indices[i] != ((KNN_SA_t *) istruct2)->indices[i])
++result;
return(result);
}
void KNN_SA_t_print (void * istruct) {
Melder_casual (U"\n");
for (long i = 1; i <= ((KNN_SA_t *) istruct) -> p -> ny; i ++)
Melder_casual (((KNN_SA_t *) istruct) -> indices [i]);
Melder_casual (U"\n");
}
void KNN_SA_t_step
(
const gsl_rng * r,
void * istruct,
double step_size
)
{
long i1 = lround ((((KNN_SA_t *) istruct) -> p -> ny - 1) * gsl_rng_uniform (r)) + 1;
long i2 = (i1 + lround (step_size * gsl_rng_uniform (r))) % ((KNN_SA_t *) istruct) -> p -> ny + 1;
if (i1 == i2)
return;
if (i1 > i2)
OlaSWAP (long, i1, i2);
long partitions[i2 - i1 + 1];
KNN_SA_partition(((KNN_SA_t *) istruct)->p, i1, i2, partitions);
for (long r, l = 1, stop = i2 - i1 + 1; l < stop; l ++)
{
while (l < stop && partitions [l] == 1)
l ++;
r = l + 1;
while (r <= stop && partitions [r] == 2)
r ++;
if (r == stop)
break;
OlaSWAP (long, ((KNN_SA_t *) istruct) -> indices [i1], ((KNN_SA_t *) istruct) -> indices [i2]);
}
}
void KNN_SA_t_copy
(
void * istruct_src,
void * istruct_dest
)
{
((KNN_SA_t *) istruct_dest)->p = ((KNN_SA_t *) istruct_src)->p;
for(long i = 1; i <= ((KNN_SA_t *) istruct_dest)->p->ny; ++i)
((KNN_SA_t *) istruct_dest)->indices[i] = ((KNN_SA_t *) istruct_src)->indices[i];
}
void * KNN_SA_t_copy_construct
(
void * istruct
)
{
KNN_SA_t * result = (KNN_SA_t *) malloc(sizeof(KNN_SA_t));
result->p = ((KNN_SA_t *) istruct)->p;
result->indices = (long *) malloc(sizeof(long) * (result->p->ny + 1));
for(long i = 1; i <= result->p->ny; ++i)
result->indices[i] = ((KNN_SA_t *) istruct)->indices[i];
return((void *) result);
}
KNN_SA_t * KNN_SA_t_create
(
PatternList p
)
{
KNN_SA_t * result = (KNN_SA_t *) malloc(sizeof(KNN_SA_t));
result->p = p;
result->indices = (long *) malloc(sizeof(long) * (p->ny + 1));
for(long i = 1; i <= p->ny; ++i)
result->indices[i] = i;
return(result);
}
void KNN_SA_t_destroy
(
void * istruct
)
{
free(((KNN_SA_t *) istruct)->indices);
free((KNN_SA_t *) istruct);
}
void KNN_SA_partition
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList p, //
//
long i1, // i1 < i2
//
long i2, //
//
long * result // [0] anv. ej
//
)
{
long c1 = (long) lround(NUMrandomUniform(i1, i2));
long c2 = (long) lround(NUMrandomUniform(i1, i2));
double *p1 = NUMvector (1, p->nx);
double *p2 = NUMvector (1, p->nx);
for(long x = 1; x <= p->nx; ++x)
{
p1[x] = p->z[c1][x];
p2[x] = p->z[c2][x];
}
for (bool converging = true; converging; )
{
double d1, d2;
converging = false;
for(long i = i1, j = 1; i <= i2; ++i)
{
d1 = 0;
d2 = 0;
for (long x = 1; x <= p->nx; ++x)
{
d1 += OlaSQUARE(p->z[i][x] - p1[x]);
d2 += OlaSQUARE(p->z[i][x] - p2[x]);
}
d1 = sqrt(d1);
d2 = sqrt(d2);
if(d1 < d2)
{
if(result[j] != 1)
{
converging = true;
result[j] = 1;
}
}
else
{
if(result[j] != 2)
{
converging = true;
result[j] = 2;
}
}
++j;
}
for (long x = 1; x <= p -> nx; x ++)
{
p1[x] = 0;
p2[x] = 0;
}
for (long i = i1, j = 1, j1 = 1, j2 = 1; i <= i2; i ++)
{
if (result [j] == 1)
{
for (long x = 1; x <= p->nx; x ++)
p1[x] += (p->z[i][x] - p1[x]) / j1;
++j1;
}
else
{
for (long x = 1; x <= p -> nx; x ++)
p2[x] += (p->z[i][x] - p2[x]) / j2;
++j2;
}
++j;
}
}
NUMvector_free (p1, 1);
NUMvector_free (p2, 1);
}
/* End of file KNN.cpp */
praat-6.0.23/contrib/ola/KNN.h 0000664 0000000 0000000 00000026654 13023464014 0015735 0 ustar 00root root 0000000 0000000 #ifndef _KNN_h_
#define _KNN_h_
/* KNN.h
*
* Copyright (C) 2007-2008 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20080529 Initial release
* pb 2011/03/08 C++
*/
/////////////////////////////////////////////////////
// Praat datatypes //
/////////////////////////////////////////////////////
#include "Data.h"
#include "PatternList.h"
#include "Categories.h"
#include "TableOfReal.h"
#include "Permutation.h"
#include "MDS.h"
/////////////////////////////////////////////////////
// KNN miscs //
/////////////////////////////////////////////////////
#include "OlaP.h"
#include "FeatureWeights.h"
#include "gsl_siman.h"
/////////////////////////////////////////////////////
// Praat specifics //
/////////////////////////////////////////////////////
#include "KNN_def.h"
/////////////////////////////////////////////////////
// Private definitions and macros //
/////////////////////////////////////////////////////
#define kOla_TEN_FOLD_CROSS_VALIDATION 1
#define kOla_LEAVE_ONE_OUT 2
#define kOla_TO_TABLEOFREAL 1
#define kOla_TO_TABLEOFREAL_ALL 2
#define kOla_TO_CATEGORIES 4
#define kOla_SQUARED_DISTANCE_WEIGHTED_VOTING 8
#define kOla_DISTANCE_WEIGHTED_VOTING 16
#define kOla_FLAT_VOTING 32
#define kOla_ERROR 0
#define kOla_SUCCESS 303
#define kOla_APPEND 1
#define kOla_REPLACE 2
#define kOla_SHUFFLE 1
#define kOla_SEQUENTIAL 2
#define kOla_PATTERN_CATEGORIES_MISMATCH 111
#define kOla_DIMENSIONALITY_MISMATCH 222
#define kOla_FWEIGHTS_MISMATCH 333
/////////////////////////////////////////////////////
// Prototypes //
/////////////////////////////////////////////////////
// a near-dummy function
autoKNN KNN_create ();
// Learning
int KNN_learn
(
KNN me, // the classifier to be trained
PatternList p, // source pattern
Categories c, // target categories
int method, // method <- REPLACE or APPEND
int ordering // ordering <- SHUFFLE?
);
// Classification - To Categories
autoCategories KNN_classifyToCategories
(
KNN me, // the classifier being used
PatternList ps, // target pattern (where neighbours are sought for)
FeatureWeights fws, // feature weights
long k, // the number of sought after neighbours
int dist // distance weighting
);
// Classification - To Categories, threading aux
void * KNN_classifyToCategoriesAux
(
void * input
);
// Classification - To TableOfReal
autoTableOfReal KNN_classifyToTableOfReal
(
KNN me, PatternList ps, FeatureWeights fws, long int k, int dist
);
// Classification - To TableOfReal, threading aux
void * KNN_classifyToTableOfRealAux
(
void * input
);
// Classification - To TableOfReal, all candidates
autoTableOfReal KNN_classifyToTableOfRealAll
(
KNN me, // the classifier being used
PatternList ps, // target pattern (where neighbours are sought for)
FeatureWeights fws, // feature weights
long k, // the number of sought after neighbours
int dist // distance weighting
);
// Classification - Folding
autoCategories KNN_classifyFold
(
KNN me, // the classifier being used
PatternList ps, // target pattern (where neighbours are sought for)
FeatureWeights fws, // feature weights
long k, // the number of sought after neighbours
int dist, // distance weighting
long begin, // fold start, inclusive [...
long end // fold end, inclusive ...]
);
// Evaluation
double KNN_evaluate
(
KNN me, // the classifier being used
FeatureWeights fws, // feature weights
long k, // the number of sought after neighbours
int dist, // distance weighting
int mode // TEN_FOLD_CROSS_VALIDATION / LEAVE_ONE_OUT
);
// Evaluation using a separate test set
double KNN_evaluateWithTestSet
(
KNN me, // the classifier being used
PatternList p, // The vectors of the test set
Categories c, // The categories of the test set
FeatureWeights fws, // feature weights
long k, // the number of sought after neighbours
int dist // distance weighting
);
// Model search
double KNN_modelSearch
(
KNN me, // the classifier being used
FeatureWeights fws, // feature weights
long * k, // valid long *, to hold the output value of k
int * dist, // valid int *, to hold the output value dist_weight
int mode, // evaluation mode
double rate, // learning rate
long nseeds // the number of seeds to be used
);
// Euclidean distance
double KNN_distanceEuclidean
(
PatternList ps, PatternList pt, FeatureWeights fws, long int rows, long int rowt
);
// Manhattan distance
double KNN_distanceManhattan
(
PatternList ps, PatternList pt, long int rows, long int rowt
);
// Find longest distance
long KNN_max
(
double * distances, // an array of distances containing ...
long ndistances // ndistances distances
);
// Locate k neighbours, skip one + disposal of distance
long KNN_kNeighboursSkip
(
PatternList j, PatternList p, FeatureWeights fws, long int jy, long int k, long int* indices, long int skipper
);
// Locate the k nearest neighbours, exclude instances within the range defined
// by [begin ... end]
long KNN_kNeighboursSkipRange
(
PatternList j, PatternList p, FeatureWeights fws, long int jy, long int k, long int* indices, double* distances, long int begin, long int end
// range of excluded instances in the target
// pattern
);
// Locate k neighbours
long KNN_kNeighbours
(
PatternList j, // source-pattern (where the unknown is located)
PatternList p, // target pattern (where neighbours are sought for)
FeatureWeights fws, // feature weights
long jy, // the index of the unknown instance in the source pattern
long k, // the number of sought after neighbours
long * indices, // a pointer to a memory-space big enough for k longs
// representing indices to the k neighbours in the
// target pattern
double * distances // a pointer to a memory-space big enough for k
// doubles representing the distances to the k
// neighbours
);
// Locating k (nearest) friends
long KNN_kFriends
(
PatternList j, PatternList p, Categories c, long int jy, long int k, long int* indices
// representing indices to the k friends in the
// target pattern
);
// Computing the distance to the nearest enemy
double KNN_nearestEnemy
(
PatternList j, PatternList p, Categories c, long int jy
);
// Computing the number of friends among k neighbours
long KNN_friendsAmongkNeighbours
(
PatternList j, PatternList p, Categories c, long int jy, long int k
);
// Locating k unique (nearest) enemies
long KNN_kUniqueEnemies
(
PatternList j, PatternList p, Categories c, long int jy, long int k, long int* indices
// located enemies
);
// Compute dissimilarity matrix
autoDissimilarity KNN_patternToDissimilarity
(
PatternList p, // PatternList
FeatureWeights fws // Feature weights
);
// Compute frequencies
long KNN_kIndicesToFrequenciesAndDistances
(
Categories c, // Source categories
long k, // k (!)
long * indices, // In: indices
double * distances, // Out: distances
double * freqs, // Out: and frequencies (double, sic!)
long *freqindices // Out: and indices -> freqs.
);
// Normalize array
void KNN_normalizeFloatArray
(
double * array, // Array to be normalized
long n // The number of elements
// in the array
);
// Remove instance
void KNN_removeInstance
(
KNN me, // Classifier
long y // Index of the instance to be purged
//
);
// Shuffle instances
void KNN_shuffleInstances
(
KNN me // Classifier whose instance
// base is to be shuffled
);
// Experimental code
autoPermutation KNN_SA_ToPermutation
(
KNN me, // the classifier being used
long tries, //
long iterations, //
double step_size, //
double boltzmann_c, //
double temp_start, //
double damping_f, //
double temp_stop //
//
);
// Experimental code
typedef struct
{
PatternList p;
long * indices;
} KNN_SA_t;
// Experimental code
double KNN_SA_t_energy
(
void * istruct
);
// Experimental code
double KNN_SA_t_metric
(
void * istruct1,
void * istruct2
);
// Experimental code
void KNN_SA_t_print
(
void * istruct
);
// Experimental code
void KNN_SA_t_step
(
const gsl_rng * r,
void * istruct,
double step_size
);
// Experimental code
void KNN_SA_t_copy
(
void * istruct_src,
void * istruct_dest
);
// Experimental code
void * KNN_SA_t_copy_construct
(
void * istruct
);
// Experimental code
KNN_SA_t * KNN_SA_t_create
(
PatternList p
);
// Experimental code
void KNN_SA_t_destroy
(
void * istruct
);
// Experimental code
void KNN_SA_partition
(
PatternList p,
long i1,
long i2,
long * result
);
// Compute feature weights (wrapper), evaluate using folding
autoFeatureWeights FeatureWeights_computeWrapperInt
(
KNN me, // Classifier
long k, // k(!)
int d, // distance weighting
long nseeds, // the number of seeds
double alfa, // shrinkage factor
double stop, // stop at
int mode, // mode (co/serial)
int emode // evaluation mode (10-fold/L1O)
);
// Compute feature weights (wrapper), evaluate using separate test set
autoFeatureWeights FeatureWeights_computeWrapperExt
(
KNN nn, // Classifier
PatternList pp, // test pattern
Categories c, // test categories
long k, // k(!)
int d, // distance weighting
long nseeds, // the number of seeds
double alfa, // shrinkage factor
double stop, // stop at
int mode // mode (co/serial)
);
// Evaluate feature weights, wrapper aux.
double FeatureWeights_evaluate
(
FeatureWeights fws, // Weights to evaluate
KNN nn, // Classifier
PatternList pp, // test pattern
Categories c, // test categories
long k, // k(!)
int d // distance weighting
);
/* End of file KNN.h */
#endif
praat-6.0.23/contrib/ola/KNN_def.h 0000664 0000000 0000000 00000001747 13023464014 0016547 0 ustar 00root root 0000000 0000000 /* KNN_def.h
*
* Copyright (C) 2007-2009 Ola Söder, 2011,2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT KNN
oo_DEFINE_CLASS (KNN, Daata)
oo_LONG (nInstances)
oo_AUTO_OBJECT (PatternList, 2, input)
oo_AUTO_OBJECT (Categories, 0, output)
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS (KNN)
#undef ooSTRUCT
/* End of file KNN_def.h */
praat-6.0.23/contrib/ola/KNN_prune.cpp 0000664 0000000 0000000 00000017641 13023464014 0017475 0 ustar 00root root 0000000 0000000 /* KNN_prune.cpp
*
* Copyright (C) 2007-2008 Ola So"der, 2010-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 2007/05/29 Initial release
* os 2009/01/23 Bugfix: Rejects classifiers containing 0 or 1 instances
* pb 2010/06/06 removed some array-creations-on-the-stack
* pb 2011/04/14 C++
* pb 2011/04/16 removed memory leaks
*/
#include "KNN_prune.h"
/////////////////////////////////////////////////////////////////////////////////////////////
// Prune //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_prune_prune
(
KNN me, // the classifier to be pruned
double n, // pruning degree: noise, 0 <= n <= 1
double r, // pruning redundancy: noise, 0 <= n <= 1
long k // k(!)
)
{
autoCategories uniqueCategories = Categories_selectUniqueItems (my output.get());
if (Categories_getSize (uniqueCategories.get()) == my nInstances)
return 0;
long removals = 0;
long ncandidates = 0;
autoNUMvector candidates (0L, my nInstances - 1);
if (my nInstances <= 1)
return 0;
for (long y = 1; y <= my nInstances; y ++) {
if (KNN_prune_noisy (my input.get(), my output.get(), y, k)) {
if (n == 1 || NUMrandomUniform (0, 1) <= n) {
KNN_removeInstance (me, y);
++ removals;
}
}
}
for (long y = 1; y <= my nInstances; ++ y) {
if (KNN_prune_superfluous (my input.get(), my output.get(), y, k, 0) && ! KNN_prune_critical (my input.get(), my output.get(), y, k))
candidates [ncandidates ++] = y;
}
KNN_prune_sort (my input.get(), my output.get(), k, candidates.peek(), ncandidates);
for (long y = 0; y < ncandidates; ++ y) {
if (KNN_prune_superfluous (my input.get(), my output.get(), candidates [y], k, 0) && ! KNN_prune_critical (my input.get(), my output.get(), candidates [y], k)) {
if (r == 1.0 || NUMrandomUniform (0.0, 1.0) <= r) {
KNN_removeInstance (me, candidates[y]);
for (long i = y + 1; i < ncandidates; ++ i) {
if(candidates[i] > candidates[y])
-- candidates[i];
}
++ removals;
}
}
}
return removals;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// sort indices according to pruning order defined by rule 2 //
/////////////////////////////////////////////////////////////////////////////////////////////
void KNN_prune_sort
(
PatternList p, // source
Categories c, // source
long k, // k(!)
long * indices, // indices of instances to be sorted
long nindices // the number of instances to be sorted
)
{
long n = nindices;
autoNUMvector h (0L, nindices - 1);
for (long cc = 0; cc < nindices; ++ cc)
h [cc] = KNN_friendsAmongkNeighbours (p, p, c, indices [cc], k);
while (-- n) { // insertion-sort, is heap-sort worth the effort?
for (long m = n; m < nindices - 1; m ++) {
if (h [m - 1] > h[m])
break;
if (h [m - 1] < h[m]) {
OlaSWAP (long, indices [m - 1], indices [m]);
} else {
if (KNN_nearestEnemy (p, p, c, indices [m - 1]) < KNN_nearestEnemy (p, p, c, indices [m])) {
OlaSWAP (long, indices [m - 1], indices [m]);
} else {
if (NUMrandomUniform (0, 1) > 0.5) {
OlaSWAP (long, indices [m - 1], indices [m]);
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// k-coverage //
/////////////////////////////////////////////////////////////////////////////////////////////
long KNN_prune_kCoverage
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k, // k(!)
long * indices // Out: kCoverage set
)
{
Melder_assert (y <= p->ny);
Melder_assert (k > 0 && k <= p->ny);
long cc = 0;
autoFeatureWeights fws = FeatureWeights_create (p -> nx);
autoNUMvector tempindices (0L, p -> ny - 1);
for (long yy = 1; yy <= p -> ny; yy ++) {
if (y != yy && FeatureWeights_areFriends (c->at [y], c->at [yy])) {
long n = KNN_kNeighboursSkip (p, p, fws.get(), yy, k, tempindices.peek(), y);
while (n) {
Melder_assert (n <= p -> ny);
if (tempindices [-- n] == y) {
indices [cc ++] = yy;
break;
}
}
}
}
return cc;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// testing for superfluousness //
/////////////////////////////////////////////////////////////////////////////////////////////
int KNN_prune_superfluous
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k, // k(!)
long skipper // Skipping instance skipper
)
{
if (y > p -> ny) y = p -> ny; // safety belt
if (k > p -> ny) k = p -> ny;
autoFeatureWeights fws = FeatureWeights_create (p -> nx);
autoNUMvector indices (0L, k - 1);
autoNUMvector freqindices (0L, k - 1);
autoNUMvector distances (0L, k - 1);
autoNUMvector freqs (0L, k - 1);
if (! KNN_kNeighboursSkip (p, p, fws.get(), y, k, indices.peek(), skipper)) return 0;
long ncategories = KNN_kIndicesToFrequenciesAndDistances (c, k, indices.peek(), distances.peek(), freqs.peek(), freqindices.peek());
int result = FeatureWeights_areFriends (c->at [y], c->at [freqindices [KNN_max (freqs.peek(), ncategories)]]);
if (result)
return 1;
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// testing for criticalness //
/////////////////////////////////////////////////////////////////////////////////////////////
int KNN_prune_critical
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k // k(!)
)
{
if (y > p -> ny) y = p -> ny; // safety belt
if (k > p -> ny) k = p -> ny;
autoFeatureWeights fws = FeatureWeights_create (p -> nx);
autoNUMvector indices (0L, k - 1);
long ncollected = KNN_kNeighboursSkip (p, p, fws.get(), y, k, indices.peek(), y);
for (long ic = 0; ic < ncollected; ic ++) {
if (! KNN_prune_superfluous (p, c, indices [ic], k, 0) || ! KNN_prune_superfluous (p, c, indices [ic], k, y)) {
return 1;
}
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////
// testing for noisyness //
/////////////////////////////////////////////////////////////////////////////////////////////
int KNN_prune_noisy
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k // k(!)
)
{
if (y > p -> ny) y = p -> ny; // safety belt
if (k > p -> ny) k = p -> ny;
autoFeatureWeights fws = FeatureWeights_create (p -> nx);
autoNUMvector indices (0L, p->ny - 1); // the coverage is not bounded by k but by n
long reachability = KNN_kNeighboursSkip (p, p, fws.get(), y, k, indices.peek(), y);
long coverage = KNN_prune_kCoverage (p, c, y, k, indices.peek());
if (! KNN_prune_superfluous (p, c, y, k, 0) && reachability > coverage)
return 1;
return 0;
}
/* End of file KNN_prune.cpp */
praat-6.0.23/contrib/ola/KNN_prune.h 0000664 0000000 0000000 00000005246 13023464014 0017140 0 ustar 00root root 0000000 0000000 #ifndef _KNN_prune_h_
#define _KNN_prune_h_
/* KNN_prune.h
*
* Copyright (C) 2007-2008 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20080529 Initial release
* pb 2011/03/08 C++
*/
/////////////////////////////////////////////////////
// Prune auxs //
/////////////////////////////////////////////////////
#include "KNN.h"
#include "FeatureWeights.h"
#include "OlaP.h"
/////////////////////////////////////////////////////
// Prototypes //
/////////////////////////////////////////////////////
// Prune
long KNN_prune_prune
(
KNN me, // the classifier to be pruned
double n, // pruning degree: noise, 0 <= n <= 1
double r, // pruning redundancy: noise, 0 <= n <= 1
long k // k(!)
);
// sort indices according to pruning order defined by rule 2
void KNN_prune_sort
(
PatternList p, // source
Categories c, // source
long k, // k(!)
long * indices, // indices of instances to be sorted
long nindices // the number of instances to be sorted
);
// k-coverage
long KNN_prune_kCoverage
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k, // k(!)
long * indices // Out: kCoverage set
);
// testing for superfluousness
int KNN_prune_superfluous
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k, // k(!)
long skipper // Skipping instance skipper
);
// testing for criticalness
int KNN_prune_critical
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k // k(!)
);
// testing for noisyness
int KNN_prune_noisy
(
PatternList p, // source
Categories c, // source
long y, // source instance index
long k // k(!)
);
/* End of file KNN_prune.h */
#endif
praat-6.0.23/contrib/ola/KNN_threads.cpp 0000664 0000000 0000000 00000012505 13023464014 0017770 0 ustar 00root root 0000000 0000000 /* KNN_threads.cpp
*
* Copyright (C) 2009 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20090123 First version
*/
/////////////////////////////////////////////////////
// //
/////////////////////////////////////////////////////
#include
#include "KNN.h"
#include "KNN_threads.h"
#include "OlaP.h"
// Threading disabled
/*
// Linux...
#if defined (__linux__)
#define __USE_GNU
#include
// BSD-style OSes
#elif defined (__APPLE__)
#include
#include
#endif
// Non-pthreaders, Windows
#ifdef _WIN32
#include
// The rest of the pack
#else
#include
#endif
*/
/////////////////////////////////////////////////////
// KNN_getNumberOfCPUs //
/////////////////////////////////////////////////////
int KNN_getNumberOfCPUs ()
{
return(1);
// Threading disabled
/*
int ncpus = 0;
// Linux...
#if defined (__linux__)
cpu_set_t * cpuset = (cpu_set_t *) malloc(sizeof(cpu_set_t));
if(cpuset)
{
sched_getaffinity(0, sizeof(cpu_set_t), cpuset);
for(int cpu = 0; cpu <= CPU_SETSIZE; ++cpu)
if(CPU_ISSET(cpu, cpuset))
++ncpus;
free(cpuset);
}
Melder_assert(ncpus >= 1);
// BSD-style OSes
#elif defined (__APPLE__)
int mib[2];
size_t len = sizeof(ncpus);
mib[0] = CTL_HW;
mib[1] = HW_NCPU;
sysctl(mib, 2, &ncpus, &len, 0, 0);
// Non-pthreaders, Windows
#elif defined (_WIN32)
typedef BOOL (WINAPI *LPFN_GLPI)
(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD);
BOOL done, rc;
DWORD returnLength, byteOffset;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer, ptr;
LPFN_GLPI Glpi;
Glpi = (LPFN_GLPI) GetProcAddress(GetModuleHandle(TEXT("kernel32")), "GetLogicalProcessorInformation");
if(!Glpi)
return(1);
done = false;
buffer = nullptr;
returnLength = 0;
while(!done)
{
rc = Glpi(buffer, &returnLength);
if(!rc)
{
if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
if(buffer)
free(buffer);
return (1);
}
else done = true;
}
byteOffset = 0;
ptr=buffer;
while (byteOffset < returnLength)
{
switch (ptr->Relationship)
{
case RelationProcessorCore:
++ncpus;
default:
}
byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
++ptr;
}
}
free(buffer);
ncpus = 1;
// Unknown OS
#else
ncpus = 1;
#endif
Melder_assert(ncpus >= 1);
return(ncpus);
*/
}
/////////////////////////////////////////////////////
// KNN_threadDistribution //
/////////////////////////////////////////////////////
void * KNN_threadDistribution
(
void * (* function) (void *),
void ** input,
int nthreads
)
{
Melder_assert(function && input && nthreads > 0);
if(!(function && input && nthreads > 0))
{
KNN_thread_status * error = (KNN_thread_status *) malloc(sizeof(enum KNN_thread_status));
if(error)
*error = KNN_THREAD_ERROR;
return((void *) error);
}
if(nthreads > 1)
{
#ifdef _WIN32
// Threading disabled
/*
HANDLE hHandle[nthreads];
for(int i = 0; i < nthreds; ++)
hHandle[i] = CreateThread(nullptr, 0, function, input[i], 0, nullptr);
while(nthreads--)
WaitForSingleObject(hHandle[nthreds], INFINITE);
*/
#else
// Threading disabled
/*
pthread_t thread_ids[nthreads];
for(int i = 0; i < nthreads; ++i)
pthread_create(&thread_ids[i], nullptr, function, input[i]);
while(nthreads--)
pthread_join(thread_ids[nthreads], nullptr);
return nullptr;
*/
#endif
}
void *result = function (input [0]);
return result;
}
/////////////////////////////////////////////////////
// KNN_threadTest //
/////////////////////////////////////////////////////
void KNN_threadTest ()
{
void * dummy[KNN_getNumberOfCPUs()];
KNN_threadDistribution(KNN_threadTestAux, (void **) &dummy, KNN_getNumberOfCPUs());
}
/////////////////////////////////////////////////////
// KNN_threadTestAux //
/////////////////////////////////////////////////////
void * KNN_threadTestAux (void * dummy)
{
dummy = nullptr; // dummy assignment to avoid compiler warnings;
for(int i = 0; i < 50000; ++i)
for(int i = 0; i < 50000; ++i) ;
return nullptr;
}
praat-6.0.23/contrib/ola/KNN_threads.h 0000664 0000000 0000000 00000002672 13023464014 0017441 0 ustar 00root root 0000000 0000000 #ifndef _KNN_threads_h_
#define _KNN_threads_h_
/* KNN_threads.h
*
* Copyright (C) 2009 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20090123 First version
* pb 2011/03/08 C++
*/
/////////////////////////////////////////////////////
// //
/////////////////////////////////////////////////////
// Error codes
enum KNN_thread_status
{
KNN_THREAD_OK,
KNN_THREAD_ERROR
};
// Query the number of available CPUs
int KNN_getNumberOfCPUs ();
// Distribute the work specified by
// (*function) and input over nthreads
// threads
void * KNN_threadDistribution
(
void * (* function) (void *),
void ** input,
int nthreads
);
// Test threading
void KNN_threadTest ();
// Test threading aux
void * KNN_threadTestAux
(
void * dummy
);
/* End of file KNN_threads.h */
#endif
praat-6.0.23/contrib/ola/Makefile 0000664 0000000 0000000 00000001352 13023464014 0016562 0 ustar 00root root 0000000 0000000 # Makefile of the library "contrib/ola"
# Ola So"der 19 January 2008
# Paul Boersma, 22 October 2016
include ../../makefile.defs
CPPFLAGS = -I ../../sys -I ../../FFNet -I ../../dwtools -I ../../fon -I ../../dwsys -I ../../stat -I ../../num -I ../../external/gsl -D_DEBUG -D_REENTRANT
OBJECTS = KNN.o \
KNN_threads.o Pattern_to_Categories_cluster.o KNN_prune.o FeatureWeights.o praat_contrib_Ola_KNN.o manual_KNN.o
.PHONY: all clean
all: libOla.a
clean:
$(RM) $(OBJECTS)
$(RM) libOla.a
libOla.a: $(OBJECTS)
touch libOla.a
rm libOla.a
$(AR) cq libOla.a $(OBJECTS)
$(RANLIB) libOla.a
$(OBJECTS): *.h ../../sys/*.h ../../FFNet/*.h ../../dwtools/*.h ../../fon/*.h ../../dwsys/*.h ../../stat/*.h ../../num/*.h ../../external/gsl/*.h
praat-6.0.23/contrib/ola/OlaP.h 0000664 0000000 0000000 00000002600 13023464014 0016123 0 ustar 00root root 0000000 0000000 #ifndef _OlaP_h_
#define _OlaP_h_
/* OlaP.h
*
* Copyright (C) 2007-2008 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20080529 Initial release
*/
/////////////////////////////////////////
// Macros //
/////////////////////////////////////////
#define OlaSWAP(TYPE, X, Y) {TYPE temp = X; X = Y; Y = temp;}
#define OlaMAX(x,y) ((x) > (y) ? (x) : (y))
#define OlaMIN(x,y) ((x) < (y) ? (x) : (y))
#define OlaSQUARE(x) ((x) * (x))
/////////////////////////////////////////
// DEBUG //
/////////////////////////////////////////
/////////////////////////////////////////
// Misc defines //
/////////////////////////////////////////
#define kOla_MINFLOAT 0.0000000000000000000001
#endif /* _Misc_h_ */
praat-6.0.23/contrib/ola/Pattern_to_Categories_cluster.cpp 0000664 0000000 0000000 00000011476 13023464014 0023663 0 ustar 00root root 0000000 0000000 /* Pattern_to_Categories_cluster.cpp
*
* Copyright (C) 2007-2008 Ola So"der, 2010-2011,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20070529 initial release
* pb 20100606 removed some array-creations-on-the-stack
* pb 20100606 corrected some arrary-index-out-of-bounds errors
* pb 20100606 corrected some memory leaks
* pb 2011/03/08 tried to repair some of the header file chaos (several procedures here should be in KNN.c instead)
* pb 2011/04/13 C++
*/
#include "Pattern_to_Categories_cluster.h"
#include "KNN.h" // BUG
/////////////////////////////////////////////////////////////////////////////////////////////
// Pattern_to_Categories_cluster //
/////////////////////////////////////////////////////////////////////////////////////////////
autoCategories PatternList_to_Categories_cluster
(
///////////////////////////////
// Parameters //
///////////////////////////////
PatternList p, // source
//
FeatureWeights fws, // feature weights
//
long k, // k(!)
//
double s, // clustersize constraint 0 < s <= 1
//
long m // reseed maximum
//
)
{
autoCategories categories = Categories_createWithSequentialNumbers (k);
if (k == p->ny)
return categories;
autoKNN knn = KNN_create();
if (p -> ny % k)
if (s > (double) (p -> ny / k) / (double) (p -> ny / k + 1)) // FIXME check whether integer division is correct
s = (double) (p -> ny / k) / (double) (p -> ny / k + 1);
double progress = m;
autoNUMvector sizes (0L, k);
autoNUMvector seeds (0L, k);
autoPatternList centroids = PatternList_create (k, p -> nx);
autoNUMvector beta (0L, centroids -> nx);
do
{
double delta;
long nfriends = 0;
Melder_progress (1 - (progress - m) / progress, U"");
for (long y = 1; y <= centroids->ny; y++)
{
int ifriend = 1;
long ys = (long) lround(NUMrandomUniform(1, p->ny));
if (nfriends)
{
while (ifriend)
{
ys = (long) lround(NUMrandomUniform(1, p->ny));
for (long fc = 0; fc < nfriends; fc++)
{
ifriend = 0;
Melder_assert (fc < k);
if (seeds [fc] == ys)
{
ifriend = 1;
break;
}
}
}
}
Melder_assert (nfriends <= k);
seeds [nfriends++] = ys;
for (long x = 1; x <= centroids->nx; x++)
centroids->z[y][x] = p->z[ys][x];
}
do
{
delta = 0;
KNN_learn (knn.get(), centroids.get(), categories.get(), kOla_REPLACE, kOla_SEQUENTIAL);
autoCategories interim = KNN_classifyToCategories (knn.get(), p, fws, 1, kOla_FLAT_VOTING);
for (long x = 1; x <= k; x ++)
sizes [x] = 0;
for (long yp = 1; yp <= categories->size; yp ++)
{
double alfa = 1;
Melder_assert (yp <= centroids -> ny);
for (long x = 1; x <= centroids -> nx; x ++)
{
beta [x] = centroids -> z [yp] [x];
}
for (long ys = 1; ys <= interim->size; ys ++)
{
if (FeatureWeights_areFriends (categories->at [yp], interim->at [ys]))
{
for (long x = 1; x <= p -> nx; x ++)
{
Melder_assert (ys <= p -> ny);
if (alfa == 1)
{
centroids -> z [yp] [x] = p -> z [ys] [x];
}
else
{
centroids -> z [yp] [x] += (p -> z [ys] [x] - centroids -> z [yp] [x]) / alfa;
}
}
Melder_assert (yp <= k);
sizes [yp] ++;
alfa ++;
}
}
for (long x = 1; x <= centroids -> nx; x ++)
{
delta += fabs (beta [x] - centroids -> z [yp] [x]);
}
}
}
while (delta != 0.0);
double smax = sizes [1];
double smin = sizes [1];
for (long x = 1; x <= k; x++)
{
if (smax < sizes [x]) smax = sizes [x];
if (smin > sizes [x]) smin = sizes [x];
}
sizes [0] = smin / smax;
-- m;
}
while (sizes[0] < s && m > 0);
autoCategories output = KNN_classifyToCategories (knn.get(), p, fws, 1, kOla_FLAT_VOTING);
return output;
}
/* End of file Pattern_to_Categories_cluster.cpp */
praat-6.0.23/contrib/ola/Pattern_to_Categories_cluster.h 0000664 0000000 0000000 00000003715 13023464014 0023325 0 ustar 00root root 0000000 0000000 /* Pattern_to_Categories_cluster.h
*
* Copyright (C) 2007-2008 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 20070529 Initial release
* pb 2011/03/08 C++
*/
/////////////////////////////////////////////////////
// DEBUG //
/////////////////////////////////////////////////////
//#define CLUSTERING_DEBUG
/////////////////////////////////////////////////////
// Praat datatypes //
/////////////////////////////////////////////////////
#include "PatternList.h"
#include "Categories.h"
/////////////////////////////////////////////////////
// Miscs //
/////////////////////////////////////////////////////
#include "FeatureWeights.h"
/////////////////////////////////////////////////////
// Prototypes //
/////////////////////////////////////////////////////
// PatternList_to_Categories_cluster
autoCategories PatternList_to_Categories_cluster
(
PatternList p, // source
FeatureWeights fws, // feature weights
long k, // k(!)
double s, // clustersize constraint 0 < s <= 1
long m // reseed maximum
);
/* End of file PatternList_to_Categories_cluster.h */
praat-6.0.23/contrib/ola/TODO.txt 0000664 0000000 0000000 00000000066 13023464014 0016431 0 ustar 00root root 0000000 0000000 Multithreading on Windows.
Approx n. search?
kD-tree?
praat-6.0.23/contrib/ola/manual_KNN.cpp 0000664 0000000 0000000 00000127336 13023464014 0017624 0 ustar 00root root 0000000 0000000 /* manual_KNN.c
*
* Copyright (C) 2007-2008 Ola Söder
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 2008/05/29 Initial release
* os 2009/01/23 Removed irrelevant information
* pb 2010/12/28 lay-out, spelling
*/
#include "ManPagesM.h"
#include "KNN.h"
void manual_KNN_init (ManPages me);
void manual_KNN_init (ManPages me)
{
MAN_BEGIN (U"kNN classifiers", U"Ola Söder", 20080529)
INTRO (U"This tutorial describes the use of kNN classifiers in Praat.")
NORMAL (U"@@kNN classifiers 1. What is a kNN classifier?|1. What is a kNN classifier?@")
NORMAL (U"@@kNN classifiers 1.1. Improving classification accuracy|1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting|1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1.1. Filter-based feature weighting|1.1.1.1. Filter-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1.2. Wrapper-based feature weighting|1.1.1.2. Wrapper-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.2. Model selection|1.1.2. Model selection@")
NORMAL (U"@@kNN classifiers 1.2. Improving resource efficiency|1.2. Improving resource efficiency@")
LIST_ITEM (U"@@kNN classifiers 1.2.1. Pruning|1.2.1. Pruning@")
NORMAL (U"@@kNN classifiers 2. Quick start|2. Quick start@")
NORMAL (U"@@kNN classifiers 3. Command overview|3. Command overview@")
MAN_END
MAN_BEGIN (U"KNN", U"Ola Söder", 20080529)
INTRO (U"One of the @@types of objects@ in Praat.")
NORMAL (U"A #KNN classifier can %learn associations between its %input and its %output. "
"The @@kNN classifiers@ tutorial gives you an introduction to the usage of %%k%NN learners in Praat.")
MAN_END
MAN_BEGIN (U"FeatureWeights", U"Ola Söder", 20080729)
INTRO (U"One of the @@types of objects@ in Praat.")
NORMAL (U"A @FeatureWeights object is a %d-dimensional vector containing weight values used to transform a %d-dimensional space. Feature weighting can be used to improve the classifcation accuracy of @KNN classifiers. It can also be used to generate a @Dissimilarity matrix from a @PatternList object. @Dissimilarity matrices in conjunction with @@Multidimensional scaling|MDS-analysis@ can aid the visualization of high-dimensional data.")
MAN_END
MAN_BEGIN (U"kNN classifiers 1. What is a kNN classifier?", U"Ola Söder", 20080529)
NORMAL (U"%%Instance-based% classifiers such as the %%k%NN classifier operate on the premises that classification of unknown instances "
"can be done by relating the unknown to the known according to some @@Euclidean distance|distance/similarity function@. "
"The intuition is that two instances far apart in the %%instance space% defined by the appropriate %%distance function% are less likely "
"than two closely situated instances to belong to the same class.")
ENTRY (U"The learning process")
NORMAL (U"Unlike many artificial learners, %%instance-based% learners do not abstract any information from the training data during the learning phase. "
"Learning is merely a question of encapsulating the training data. The process of %generalization is postponed until it is absolutely unavoidable, "
"that is, at the time of %classification. This property has lead to the referring to %%instance-based% learners as %lazy learners, "
"whereas classifiers such as @@Feedforward neural networks 1. What is a feedforward neural network?|feedforward neural networks@, "
"where proper %abstraction is done during the learning phase, often are entitled %eager learners.")
ENTRY (U"Classification")
NORMAL (U"Classification (%generalization) using an %%instance-based% classifier can be a simple matter of locating the nearest neighbour in %%instance space% "
"and labelling the unknown instance with the same class label as that of the located (known) neighbour. "
"This approach is often referred to as a %%nearest neighbour classifier%. "
"The downside of this simple approach is the lack of robustness that characterize the resulting classifiers. "
"The high degree of local sensitivity makes %%nearest neighbour classifiers% highly susceptible to noise in the training data.")
NORMAL (U"More robust models can be achieved by locating %k, where %k > 1, neighbours and letting the majority vote decide the outcome of the class labelling. "
"A higher value of %k results in a smoother, less locally sensitive, function. "
"The %%nearest neighbour classifier% can be regarded as a special case of the more general %%k-nearest neighbours classifier%, "
"hereafter referred to as a %%k%NN classifier. The drawback of increasing the value of %k is of course that as %k approaches %n, "
"where %n is the size of the %%instance base%, the performance of the classifier will approach that of the most straightforward %%statistical baseline%, "
"the assumption that all unknown instances belong to the class most most frequently represented in the training data.")
NORMAL (U"This problem can be avoided by limiting the influence of distant instances. "
"One way of doing so is to assign a weight to each vote, where the weight is a function of the distance between the unknown and the known instance. "
"By letting each weight be defined by the inversed squared distance between the known and unknown instances votes cast by distant instances "
"will have very little influence on the decision process compared to instances in the near neighbourhood. "
"%%Distance weighted voting% usually serves as a good middle ground as far as local sensitivity is concerned.")
MAN_END
MAN_BEGIN (U"kNN classifiers 1.1. Improving classification accuracy", U"Ola Söder", 20080529)
NORMAL (U"This tutorial describes possible ways of improving the classification accuracy of a %%k%NN classifier.")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting|1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.2. Model selection|1.1.2. Model selection@")
MAN_END
MAN_BEGIN (U"kNN classifiers 1.1.1. Feature weighting", U"Ola Söder", 20080529)
NORMAL (U"A %%k%NN classifier in its most basic form operates under the implicit assumption that all features are of equal value as far as the classification problem at hand is concerned. When irrelevant and noisy features influence the neighbourhood search to the same degree as highly relevant features, the accuracy of the model is likely to deteriorate. %%Feature weighting% is a technique used to approximate the optimal degree of influence of individual features using a training set. When successfully applied relevant features are attributed a high weight value, whereas irrelevant features are given a weight value close to zero. %%Feature weighting% can be used not only to improve classification accuracy but also to discard features with weights below a certain threshold value and thereby increase the resource efficiency of the classifier.")
NORMAL (U"Two fundamentally different approaches to this optimization problem can be identified, the %%filter-based% and the %%wrapper-based%. The class of %%filter-based% methods contains algorithms that use no input other than the training data itself to calculate the %%feature weights%, whereas %%wrapper-based% algorithms use feedback from a classifier to guide the search. %%Wrapper-based% algorithms are inherently more powerful than their filter-based counterpart as they implicitly take the %%inductive bias% of the classifier into account. This power comes at a price however; the usage of %%wrapper-based% algorithms increases the risk of %%overfitting% the training data.")
NORMAL (U"In @@kNN classifiers 1.1.1.1. Filter-based feature weighting|section 1.1.1.1.@ the %%filter-based% feature weighting algorithm implemented in Praat is presented. @@kNN classifiers 1.1.1.2. Wrapper-based feature weighting|Section 1.1.1.2.@ contains an account of the implemented %%wrapper-based% feature weighting algorithm.")
MAN_END
MAN_BEGIN (U"kNN classifiers 1.1.1.1. Filter-based feature weighting", U"Ola Söder", 20080529)
NORMAL (U"The %%filter-based% %%feature weighting% algorithm implemented in Praat is an extended version of the well known R\\s{ELIEF} algorithm, R\\s{ELIEF-F}, such as it is presented (with one minor exception, see below) in @@Igor Kononenko (1994)|Kononenko (1994)@. Unlike the original R\\s{ELIEF} algorithm, the R\\s{ELIEF-F} algorithm copes with multi class (as in more than 2 classes) data sets. The simple intuition behind the R\\s{ELIEF-F} algorithm is that a good feature is a feature with little within class variance and generous amounts of between-class variance. A bad feature is characterized by within-class and between-class variances of magnitudes roughly equal.")
NORMAL (U"The computation of the weight vector is done in an iterative fashion, with all weights initially set to 0. All features in the training set are normalized (all values are set within the range [0 ... 1]) and thereafter used to update the weight vector as follows: On each iteration a random instance is chosen. The nearest hit is located, where hit is an instance of the same class as that of the randomly chosen instance. The nearest misses of all the classes but that of the randomly chosen instance are located, where a miss is an instance of a class different from that of the randomly chosen instance. Each weight is updated by subtracting the difference between the given attribute of the randomly chosen instance and that of the nearest hit and adding the corresponding difference between the chosen instance and all the nearest misses weighted by the prior probabilities of their classes. If the distance between the attribute of the randomly chosen instance and the nearest hit equals the corresponding value for the nearest miss(es) then the weight value will not change, it will thus remain 0 given that the current iteration is the first one. If the difference between the attribute of the chosen instance and the nearest hit is lower than the corresponding value for the miss(es) then the weight value will be increased. On average highly significant attributes will result in absolute values distinct from 0, leading to an absolute increase of the weight, and insignificant attributes will on average result in values near 0, retaining the pessimistic view that all features are of no value as predictors.")
NORMAL (U"The implementation of R\\s{ELIEF-F} found in Praat differs slightly from the algorithm described. Instances are not randomly chosen, instead all instances are used to update the weight vector. This simplification is of no concern unless massive data sets are used, in which case the Praat approach would be no less precise, but needlessly slow.")
MAN_END
MAN_BEGIN (U"kNN classifiers 1.1.1.2. Wrapper-based feature weighting", U"Ola Söder", 20090123)
NORMAL (U"The %%wrapper-based% %%feature weighting% algorithm implemented in Praat attempts to find the globally optimal feature weights by means of a greedy local search. The local neighbourhood is defined by a number of random seeds centered around a pivot seed. For each iteration of the algorithm the best performing seed is chosen to be the pivot of the next iteration. At the same time the maximum allowed distance between a seed and the pivot is decreased by a constant factor. Given a sufficient number of seeds and a small shrinkage factor the algorithm will on average home in on a good approximation of the global maximum.")
NORMAL (U"Given reasonable parameter settings, the search algorithm on average gives good results without huge memory and CPU requirements. The strong point of the method, the ability to efficiently do a rather thorough search of the weight space, can, as mentioned in @@kNN classifiers 1.1.1. Feature weighting|section 1.1.1.@, lead to overfitting. One way of minimizing this problem is to constrain the algorithm by means of %%early stopping%. In Praat this is done in a very naive fashion, by simply not allowing the algorithm to explore weights achieving an accuracy higher than a specified threshold value.")
MAN_END
MAN_BEGIN (U"kNN classifiers 1.1.2. Model selection", U"Ola Söder", 20080529)
NORMAL (U"%%Model selection% is the process of choosing classifier parameters suitable for the classification task at hand. In most cases this is done manually in an experimental fashion.")
NORMAL (U"The search for the optimal model can also be automated. In Praat this is done by means of the same @@kNN classifiers 1.1.1.2. Wrapper-based feature weighting|greedy local search algorithm@ used to search the weight space for feature weights. The %%model selection% search implementation in Praat lets the user limit the search space with respect to the parameter %k. By setting a maximum allowed value of %k the search space can be shrunk considerably.")
NORMAL (U"Due to its discrete (%k) and nominal (vote weighting) nature, the size of the search space is normally of no concern, making an experimental/manual search tractable. The %%model selection% feature of Praat becomes an essential tool only when applied to huge instance bases where the expected optimal value of %k is high. In most cases however, manual experimenting will suffice.")
MAN_END
MAN_BEGIN (U"kNN classifiers 1.2. Improving resource efficiency", U"Ola Söder", 20080529)
NORMAL (U"%%Instance-based% learners such as the %%k%NN classifier implemented in Praat are fairly inefficient as far as CPU and memory usage is concerned. The performance can be improved upon by making sure that only those instances that are vital for the accuracy of the classifier are stored and that non-vital instances are disposed of. Praat does give the user the possibility to prune non-vital or harmful instances, making the resulting classifier less memory and CPU hungry and in some cases more accurate even though that is not the primary objective of the pruning algorithm.")
MAN_END
MAN_BEGIN (U"kNN classifiers 1.2.1. Pruning", U"Ola Söder", 20080529)
NORMAL (U"Pruning is the process of discarding instances that do not improve upon the classification accuracy of the classifier. This group of instances includes noisy instances that, at best, make no difference as far as model accuracy is concerned, at worst, induces classification errors. It also includes instances that are redundant; instances that are implied by the defined neighbourhood.")
ENTRY (U"The C-Pruner algorithm")
NORMAL (U"The C-Pruner algorithm such as it is presented in @@Ke-Ping Zhao et al. (2003)|Zhao et al. (2003)@ identifies pruning candidates and computes the order in which these candidates shall be removed. The ordering is of vital importance since the removal of one candidate might disqualify other candidates, making them non-prunable. In order to understand how the C-Pruner algorithm operates a few definitions are necessary:")
LIST_ITEM (U"\\bu The %k-reachability set of an instance %p consists of the %k nearest neighbours of %p")
LIST_ITEM (U"\\bu The %k-coverage set of an instance %p consists of those instances of the same class as that of %p having %p as one of their %k nearest neighbours.")
LIST_ITEM (U"\\bu An instance %p is superfluous if it is implied by %k-reachability, that is, if it can be correctly classified using %k-reachability as instance base.")
LIST_ITEM (U"\\bu An instance %p is critical if at least one instance in the %k-coverage set of %p is not implied by the %k-reachability set of %p or, after %p is deleted, atleast one instance in the %k-coverage set of %p is not implied by the %k-reachability set of %p.")
LIST_ITEM (U"\\bu An instance %p is noisy if %p isn't superfluous and the %k-reachability set of %p is bigger than the %k-coverage set of %p.")
NORMAL (U"Given these definitions, an instance is tagged for pruning if one of the following conditions hold: It is noisy, or it is superfluous but not critical. This translates to the discarding of instances that are bad class predictors (noise) and of instances that are highly typical of their class and thus are located close to the center of the cluster defining the given class. Instances located close to the class center are very likely implied by the surrounding border instances and thus redundant. In order to avoid destructive domino effects it is important that the pruning starts close to the center of the cluster and works its way out and not the other way around. To impose this ordering the C-Pruner algorithm uses the following heuristics to determine the order of removal of two superfluous instances %p__i_ and %p__j_:")
LIST_ITEM (U"\\bu If the %k-reachability set of %p__i_ contains more instances of the same class as that of %p__i_ than the corresponding value for %p__j_ then %p__i_ should be removed before %p__j_.")
LIST_ITEM (U"\\bu If the %k-reachability set of %p__i_ contains the same number of instances of the same class as that of %p__i_ as the corresponding value for %p__j_ and the distance between %p__i_ and the closest instance of a class different from the class of %p__i_ is greater than the corresponding value for %p__j_ then %p__i_ should be removed before %p__j_.")
LIST_ITEM (U"\\bu If the %k-reachability set of %p__i_ contains the same number of instances of the same class as that of %p__i_ as the corresponding value for %p__j_ and the distance between %p__i_ and the closest instance of a class different from the class of %p__i_ equals the corresponding value for %p__j_ then the order of removal is decided randomly.")
NORMAL (U"In order to gain control of the degree of pruning the Praat implementation of the C-Pruner algorithm decides whether to prune or not prune a given instance tagged for pruning on a probabilistic basis. This makes it possible for the user to specify the hardness of the pruning process (e.g. 100 percent (exp.) noise, 50 percent (exp.) redundancy) to be able to find a good compromise between model accuracy and resource requirements.")
MAN_END
MAN_BEGIN (U"kNN classifiers 2. Quick start", U"Ola Söder", 20080809)
ENTRY (U"An example: Learning the Iris data set")
NORMAL (U"In the @@Feedforward neural networks|the feedforward neural networks tutorial@ a description of how the @FFNet classifier in Praat can be applied to @@iris data set|the Iris data set@ can be found.")
NORMAL (U"The same data can be used to test the %%k%NN feature of Praat. To do so create an example data set using the @@Create iris example...@ command found in the ##Feedforward neural networks# submenu. The form prompting for network topology settings can be ignored by selecting OK. Select the newly created @PatternList and @Categories objects and click ##To KNN Classifier...#. A form prompting for a name of the classifier to be created will be shown. The ordering in which instances are to be inserted into the instance base can also be specified, make sure that #Random is selected and thereafter close the form by selecting OK. The newly created and trained classifier will be shown in the list of objects.")
NORMAL (U"To estimate how well the classifier can be expected to classify new samples of Irises select ##Query -# \\=> ##Get accuracy estimate...#. A form prompting for %%k%NN parameter settings and evaluation method will be shown. Experiment with the parameter settings until satisfactory results are achieved. If everything worked out the estimate will likely end up somewhere in the range of 94-98 percent.")
NORMAL (U"An alternative to manually experimenting with model parameters is to let the computer do the job. This is done be choosing the @KNN object and thereafter selecting ##Query -# \\=> ##Get optimized parameters...#. The form shown prompts for a selection of parameters controlling the search. The default values will in most cases, including this, be appropriate.")
NORMAL (U"Another way of improving classification accuracy is to transform the instance space in which the individual instances, in this case Irises, are stored as to maximize the distance between instances of different classes and minimize the distance between instances of the same class. This can be done by means of feature weighting. To do so select the @KNN object and choose ##To FeatureWeights...#. Adjust the %%k%NN settings according to the ones found by the model search algorithm and let the remaining options retain the default values. Click OK. A @FeatureWeights object will be added to the objects list. The feature weights contained within the newly created object can be used by selecting named object in conjunction with the @KNN classifier and thereafter choosing the desired action.")
MAN_END
MAN_BEGIN (U"k-means clustering", U"Ola Söder", 20080529)
INTRO (U"This tutorial describes the use of %%k%-means clustering in Praat. ")
NORMAL (U"@@k-means clustering 1. How does k-means clustering work?|1. How does k-means clustering work?@")
NORMAL (U"@@k-means clustering 2. Quick start|2. Quick start@")
MAN_END
MAN_BEGIN (U"k-means clustering 1. How does k-means clustering work?", U"Ola Söder", 20080529)
NORMAL (U"The %%k%-means clustering algorithm attempts to split a given anonymous data set (a set containing no information as to class identity) into a fixed number (%k) of clusters.")
NORMAL (U"Initially %k number of so called %centroids are chosen. A %centroid is a data point (imaginary or real) at the center of a cluster. In Praat each centroid is an existing data point in the given input data set, picked at random, such that all %centroids are unique (that is, for all %centroids %c__%i_ and %c__%j_, %c__%i_ \\=/ %c__%j_). These %centroids are used to train a @@kNN classifiers 1. What is a kNN classifier?|kNN classifier@. The resulting classifier is used to classify (using %k = 1) the data and thereby produce an initial randomized set of clusters. Each %centroid is thereafter set to the arithmetic mean of the cluster it defines. The process of classification and %centroid adjustment is repeated until the values of the %centroids stabilize. The final %centroids will be used to produce the final classification/clustering of the input data, effectively turning the set of initially anonymous data points into a set of data points, each with a class identity.")
MAN_END
MAN_BEGIN (U"k-means clustering 2. Quick start", U"Ola Söder", 20080529)
NORMAL (U"Clustering using the %%k%-means clustering algorithm in Praat is done by selecting a @PatternList and choosing ##To Categories...#. In the appearing requester the number of sought after clusters (unique categories) can be specified. The cluster size ratio constraint (%z) imposes a constraint on the output such that %cluster size(%x) / %cluster size(%y) > %z for all clusters %x and %y in the resulting set of clusters. Valid values of %z are 0 < %z <= 1 where values near 0 imposes practically no constraints on the cluster sizes and a value of 1 tells the algorithm to attempt to create clusters of equal size. The size ratio constraint is enforced in a very naive fashion, by random reseeding. Since this can be a rather time consuming process it is possible to set an upper bound on the number of reseeds done by the algorithm. This upper bound is defined by the parameter ##Maximum number of reseeds#. It should be noted however that normally there's no need to use the size ratio constraint, selecting the desired number of clusters will, on average, result in clusters of roughly equal size, given well distributed data.")
MAN_END
MAN_BEGIN (U"PatternList to Dissimilarity", U"Ola Söder", 20080529)
NORMAL (U"A @Dissimilarity matrix can be used in conjunction with @@Multidimensional scaling|Multidimensional scaling@ to aid visualization of high-dimensional data. A @Dissimilarity object is a matrix of the distances, according to the chosen @@Euclidean distance|distance function@, between all the data points in the @PatternList object.")
NORMAL (U"A @Dissimilarity object can be created by selecting a @PatternList object and choosing ##To Dissimilarity#. The dissimilarity matrix can also be computed using feature weights. This is done by selecting a @PatternList object, an @FeatureWeights object and choosing ##To Dissimilarity#.")
MAN_END
MAN_BEGIN (U"Euclidean distance", U"Ola Söder", 20080529)
NORMAL (U"The Euclidean distance between the %n-dimensional vectors %a and %b can be calculated as follows:")
FORMULA (U"\\De__Euclidean_(%x,%y) = \\Vr(\\su__%i=1..%n_(%a__%i_ - %b__%I_)^2)")
MAN_END
MAN_BEGIN (U"kNN classifiers 3. Command overview", U"Ola Söder", 20080809 )
INTRO (U"KNN commands")
ENTRY (U"Creation:")
LIST_ITEM (U"\\bu @@PatternList & Categories: To KNN classifier...@")
LIST_ITEM (U"\\bu @@Create KNN...@")
ENTRY (U"Learning:")
LIST_ITEM (U"\\bu @@KNN & PatternList & Categories: Learn...@")
ENTRY (U"Classification:")
LIST_ITEM (U"\\bu @@KNN & PatternList: To Categories...@")
LIST_ITEM (U"\\bu @@KNN & PatternList: To TabelOfReal...@")
LIST_ITEM (U"\\bu @@KNN & PatternList & FeatureWeights: To Categories...@")
LIST_ITEM (U"\\bu @@KNN & PatternList & FeatureWeights: To TableOfReal...@")
ENTRY (U"Evaluation:")
LIST_ITEM (U"\\bu @@KNN & PatternList & Categories: Evaluate...@")
LIST_ITEM (U"\\bu @@KNN & PatternList & Categories & FeatureWeights: Evaluate...@")
ENTRY (U"Queries")
LIST_ITEM (U"\\bu @@KNN: Get optimized parameters...@")
LIST_ITEM (U"\\bu @@KNN: Get accuracy estimate...@")
LIST_ITEM (U"\\bu @@KNN & FeatureWeights: Get accuracy estimate...@")
LIST_ITEM (U"\\bu @@KNN: Get size of instance base@")
ENTRY (U"Extractions")
LIST_ITEM (U"\\bu @@KNN: Extract input Pattern@")
LIST_ITEM (U"\\bu @@KNN: Extract output Categories@")
ENTRY (U"Modification:")
LIST_ITEM (U"\\bu @@KNN: Shuffle@")
LIST_ITEM (U"\\bu @@KNN: Prune...@")
LIST_ITEM (U"\\bu @@KNN: Reset...@")
ENTRY (U"Miscellaneous:")
LIST_ITEM (U"\\bu @@KNN: To FeatureWeights...@")
LIST_ITEM (U"\\bu @@KNN & PatternList & Categories: To FeatureWeights...@")
LIST_ITEM (U"\\bu @@PatternList & Categories: To FeatureWeights...@")
ENTRY (U"Pre/post processing:")
LIST_ITEM (U"\\bu @@PatternList: To Categories...@")
LIST_ITEM (U"\\bu @@PatternList & FeatureWeights: To Categories...@")
LIST_ITEM (U"\\bu @@PatternList: To Dissimilarity...@")
LIST_ITEM (U"\\bu @@PatternList & FeatureWeights: To Dissimilarity...@")
MAN_END
MAN_BEGIN (U"PatternList & Categories: To KNN classifier...", U"Ola Söder", 20080726 )
INTRO (U"Create and train a @KNN classifier using the selected @PatternList and @Categories objects as training data.")
ENTRY (U"Settings")
TAG (U"##Name")\
DEFINITION (U"The name of the @KNN classifier.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
MAN_END
MAN_BEGIN (U"Create KNN...", U"Ola Söder", 20080718 )
INTRO (U"Create a new @KNN classifier.")
ENTRY (U"Settings")
TAG (U"##Name")
DEFINITION (U"The name of the classifier.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN & PatternList & Categories: Learn...", U"Ola Söder", 20080726 )
INTRO (U"Train the selected @KNN classifier using the chosen @PatternList and @Categories objects as training data.")
ENTRY (U"Settings")
TAG (U"##Name")
DEFINITION (U"The name of the classifier.")
TAG (U"##Ordering")
DEFINITION (U"The order in which the training instances are to be inserted into the instance base.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
MAN_END
MAN_BEGIN (U"KNN & PatternList: To Categories...", U"Ola Söder", 20080726 )
INTRO (U"Use the selected @KNN classifier to classify the chosen @PatternList. A @Categories object containing the result will be created.")
ENTRY (U"Settings")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
MAN_END
MAN_BEGIN (U"KNN & PatternList: To TabelOfReal...", U"Ola Söder", 20080718 )
INTRO (U"Use the selected @KNN classifier to classify the chosen @PatternList. A @TableOfReal object containing verbose information on the decision process will be created.")
ENTRY (U"Settings")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
TAG (U"##Output")
DEFINITION (U"Specifies the degree of verbosity, where %%winners only% generates a @TableOfReal containing information on the instances of the winning category only whereas %%All candidates% results in a @TableOfReal with verbose information on all unique categories in the neighbourhood defined by the parameter %k.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
MAN_END
MAN_BEGIN (U"KNN & PatternList & FeatureWeights: To Categories...", U"Ola Söder", 20080726 )
INTRO (U"Use the selected @KNN classifier and @FeatureWeights object to classify the chosen @PatternList. A @Categories object containing the result will be created.")
ENTRY (U"Settings")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1.1. Filter-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1.2. Wrapper-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN & PatternList & FeatureWeights: To TableOfReal...", U"Ola Söder", 20080718 )
INTRO (U"Use the selected @KNN classifier and the feature weights, @FeatureWeights, to classify the chosen @PatternList. A @TableOfReal object containing verbose information on the decision process will be created.")
ENTRY (U"Settings")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
TAG (U"##Output")
DEFINITION (U"Specifies the degree of verbosity, where %%winners only% generates a @TableOfReal containing information on the instances of the winning category only whereas %%All candidates% results in a @TableOfReal with verbose information on all unique categories in the neighbourhood defined by the parameter %k.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1.1. Filter-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1.2. Wrapper-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Get optimized parameters...", U"Ola Söder", 20080718 )
INTRO (U"Perform an automated search for the optimal @KNN parameter settings.")
ENTRY (U"Settings")
TAG (U"##Evaluation method")
DEFINITION (U"The method to be used for estimating the classification accuracy, which in turn is used to guide the model search. "
"Supported methods are 10-fold cross-validation and leave-one-out.")
TAG (U"##k max")
DEFINITION (U"The maximum value of the parameter %k.")
TAG (U"##Number of seeds")
DEFINITION (U"The size of the parameter neighbourhood to be searched.")
TAG (U"##Learning rate")
DEFINITION (U"The rate at which the parameter neighbourhood is shrunk (per iteration).")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers 1.1.2. Model selection@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Get accuracy estimate...", U"Ola Söder", 20080718 )
INTRO (U"Estimate the classification accuracy of the selected @KNN classifier.")
ENTRY (U"Settings")
TAG (U"##Evaluation method")
DEFINITION (U"The method to be used for estimating the classification accuracy. Supported methods are 10-fold cross-validation and leave-one-out.")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@KNN & FeatureWeights: Get accuracy estimate...@")
LIST_ITEM (U"@@KNN & PatternList & Categories: Evaluate...@")
LIST_ITEM (U"@@KNN & PatternList & Categories & FeatureWeights: Evaluate...@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.2. Model selection@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN & FeatureWeights: Get accuracy estimate...", U"Ola Söder", 20080809)
INTRO (U"Estimate the classification accuracy of the @KNN classifier using the chosen @FeatureWeights.")
ENTRY (U"Settings")
TAG (U"##Evaluation method")
DEFINITION (U"The method to be used for estimating the classification accuracy. "
"Supported methods are 10-fold cross-validation and leave-one-out.")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@KNN & PatternList & Categories: Evaluate...@")
LIST_ITEM (U"@@KNN & PatternList & Categories & FeatureWeights: Evaluate...@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.2. Model selection@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN & PatternList & Categories: Evaluate...", U"Ola Söder", 20080718)
INTRO (U"Estimate the classification accuracy of the chosen @KNN classifier using the selected @PatternList and @Categories objects as test set.")
ENTRY (U"Settings")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@KNN & PatternList & Categories & FeatureWeights: Evaluate...@")
LIST_ITEM (U"@@KNN: Get accuracy estimate...@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.2. Model selection@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN & PatternList & Categories & FeatureWeights: Evaluate...", U"Ola Söder", 20080718)
INTRO (U"Estimate the classification accuracy of the chosen @KNN classifier using the selected @PatternList and @Categories objects as test set. The selected @FeatureWeights object will be used in the classification process.")
ENTRY (U"Settings")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@KNN & PatternList & Categories: Evaluate...@")
LIST_ITEM (U"@@KNN: Get accuracy estimate...@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.2. Model selection@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Get size of instance base", U"Ola Söder", 20080718)
INTRO (U"Queries the selected @KNN for the number of instances in the instance base. ")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Extract input Pattern", U"Ola Söder", 20080726)
INTRO (U"Create a new @PatternList object identical to the one in the instance base of the selected @KNN classifier.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Extract output Categories", U"Ola Söder", 20080726)
INTRO (U"Create a new @Categories object identical to the one in the instance base of the selected @KNN classifier.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Shuffle", U"Ola Söder", 20080718)
INTRO (U"Shuffle the instance base of the selected classifier.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Prune...", U"Ola Söder", 20080718)
INTRO (U"Prune the instance base of the selected classifier.")
ENTRY (U"Settings")
TAG (U"##Noise pruning degree")
DEFINITION (U"A value in the range [0 ... 1] specifying the probability that instances tagged as noisy by @@kNN classifiers 1.2.1. Pruning|the C-Pruner algorithm@ will be pruned.")
TAG (U"##Redundancy pruning degree")
DEFINITION (U"The probability that instances tagged as redundant by @@kNN classifiers 1.2.1. Pruning|the C-Pruner algorithm@ will be pruned.")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers 1.2.1. Pruning@")
LIST_ITEM (U"@@kNN classifiers 1.2. Improving resource efficiency@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: Reset...", U"Ola Söder", 20080718)
INTRO (U"Empty the instance base of the selected classifier.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN: To FeatureWeights...", U"Ola Söder", 20080728)
INTRO (U"Wrap the selected @KNN and use its feedback to guide the search for the optimal feature weights. A @FeatureWeights object will be created.")
ENTRY (U"Settings")
TAG (U"##Learning rate")
DEFINITION (U"The rate at which the maximum distance between the pivot and a random seed is decremented.")
TAG (U"##Number of seeds")
DEFINITION (U"The size of the feature weight neighbourhood.")
TAG (U"##Stop at")
DEFINITION (U"A value specifying a stopping criterion. When feature weights yielding accuracy estimates higher than the specified value the search will stop. A value of 1 imposes no constraints whereas a value of 0.5 will result in the termination of the search algorithm once feature weights resulting in an classification accuracy of 50 percent or better are found.")
TAG (U"##Optimization")
DEFINITION (U"Specifies whether to search for all features simultaneously or one at a time.")
TAG (U"##Evaluation method")
DEFINITION (U"The method to be used for estimating the classification accuracy. Supported methods are 10-fold cross-validation and leave-one-out.")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood used for feedback classification.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers 1.1.1.2. Wrapper-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@KNN & PatternList & Categories & FeatureWeights: Evaluate...@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"KNN & PatternList & Categories: To FeatureWeights...", U"Ola Söder", 20080809)
INTRO (U"Wrap the selected @KNN and use its classification accuracy on the test set constituted by the @PatternList and @Categories objects as feedback to guide the search for the optimal feature weights. A @FeatureWeights object will be created.")
ENTRY (U"Settings")
TAG (U"##Learning rate")
DEFINITION (U"The rate at which the maximum distance between the pivot and a random seed is decremented.")
TAG (U"##Number of seeds")
DEFINITION (U"The size of the feature weight neighbourhood.")
TAG (U"##Stop at")
DEFINITION (U"A value specifying a stopping criterion. When feature weights yielding accuracy estimates higher than the specified value the search will stop. A value of 1 imposes no constraints whereas a value of 0.5 will result in the termination of the search algorithm once feature weights resulting in an classification accuracy of 50 percent or better are found.")
TAG (U"##Optimization")
DEFINITION (U"Specifies whether to search for all features simultaneously or one at a time.")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood used for feedback classification.")
TAG (U"##Vote weighting")
DEFINITION (U"The type of vote weighting to be used.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers 1.1.1.2. Wrapper-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1. Improving classification accuracy@")
LIST_ITEM (U"@@KNN & PatternList & Categories & FeatureWeights: Evaluate...@")
LIST_ITEM (U"@@kNN classifiers 1. What is a kNN classifier?@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"PatternList & Categories: To FeatureWeights...", U"Ola Söder", 20080809)
INTRO (U"Compute an estimate of the optimal feature weights using the @@kNN classifiers 1.1.1.1. Filter-based feature weighting|RELIEF-F algorithm@.")
ENTRY (U"Setting")
TAG (U"##k neighbours")
DEFINITION (U"The size of the neighbourhood.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers 1.1.1.1. Filter-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers 1.1.1.2. Wrapper-based feature weighting@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"PatternList: To Categories...", U"Ola Söder", 20080728)
INTRO (U"Split the given @PatternList into a fixed number of clusters using the @@k-means clustering|%%k%-means clustering algorithm@. A @Categories object containing numbered categories corresponding to the generated clusters will be created.")
ENTRY (U"Settings")
TAG (U"##k clusters")
DEFINITION (U"The number of clusters to be generated.")
TAG (U"##Cluster size ratio constraint")
DEFINITION (U"The minimum allowed ratio between the smallest and the biggest cluster.")
TAG (U"##Maximum number of reseeds")
DEFINITION (U"The maximum allowed number of reseeds used to enforce the cluster size ratio constraint.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"PatternList & FeatureWeights: To Categories...", U"Ola Söder", 20080728)
INTRO (U"Split the given @PatternList into a fixed number of clusters using the @@k-means clustering|%%k%-means clustering algorithm@ and the feature weights contained within the selected @FeatureWeights object. A @Categories object containing numbered categories corresponding to the generated clusters will be created.")
ENTRY (U"Settings")
TAG (U"##k clusters")
DEFINITION (U"The number of clusters to be generated.")
TAG (U"##Cluster size ratio constraint")
DEFINITION (U"The minimum allowed ratio between the smallest and the biggest cluster.")
TAG (U"##Maximum number of reseeds")
DEFINITION (U"The maximum allowed number of reseeds used to enforce the cluster size ratio constraint.")
ENTRY (U"See also:")
LIST_ITEM (U"@@kNN classifiers@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
MAN_END
MAN_BEGIN (U"PatternList: To Dissimilarity...", U"Ola Söder", 20080718)
INTRO (U"Generate a @Dissimilarity matrix from the selected @PatternList. Dissimilarities are computed using the @@Euclidean distance@")
ENTRY (U"See also:")
LIST_ITEM (U"@@Multidimensional scaling@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"PatternList & FeatureWeights: To Dissimilarity...", U"Ola Söder", 20080718)
INTRO (U"Generate a @Dissimilarity matrix from the selected @PatternList using the feature weights contained within the selected @FeatureWeights object. Dissimilarities are computed using the @@Euclidean distance@.")
ENTRY (U"See also:")
LIST_ITEM (U"@@Multidimensional scaling@")
LIST_ITEM (U"@@kNN classifiers 1.1.1. Feature weighting@")
LIST_ITEM (U"@@kNN classifiers@")
MAN_END
MAN_BEGIN (U"Ke-Ping Zhao et al. (2003)", U"Ola Söder", 20080718)
NORMAL (U"Ke-Ping Zhao et al. (2003): \"C-Pruner: An improved instance pruning algorithm.\" "
"In %%Proceedings of the Second International Conference on Machine Learning and Cybernetics%, November 2003, 94\\--99.")
MAN_END
MAN_BEGIN (U"Igor Kononenko (1994)", U"Ola Söder", 20080718)
NORMAL (U"Igor Kononenko (1994): \"Estimating attributes: Analysis and extensions of relief.\" "
"In %%ECML-94: Proceedings of the European Conference on Machine Learning%, Secaucus, NJ, USA, 171\\--182. "
"New York: Springer.")
MAN_END
}
/* End of file manual_KNN.c */
praat-6.0.23/contrib/ola/praat_contrib_Ola_KNN.cpp 0000664 0000000 0000000 00000111605 13023464014 0021761 0 ustar 00root root 0000000 0000000 /* praat_contrib_Ola_KNN.cpp
*
* Copyright (C) 2007-2009 Ola Söder, 2010-2011,2015,2016 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
* os 2007/05/29 Initial release?
* os 2009/01/23 Bugfix: Removed MUX:ing (KNN_learn) incompatible with the scripting engine. Thanks to Paul Boersma for spotting this problem.
* pb 2010/12/28 in messages: typos, English, interpunction
* pb 2011/07/12 C++ and removed several errors
* pb 2011/09/18 made a start with handling dataChanged at all
* pb 2016/10/19 loops, dataChanged, Praat idiom for names, English
*/
#include "KNN.h"
#include "KNN_threads.h"
#include "KNN_prune.h"
#include "Pattern_to_Categories_cluster.h"
#include "FeatureWeights.h"
#include "praat_FFNet.h"
#undef iam
#define iam iam_LOOP
static const char32 *QUERY_BUTTON = U"Query -";
static const char32 *MODIFY_BUTTON = U"Modify -";
static const char32 *EXTRACT_BUTTON = U"Extract -";
/////////////////////////////////////////////////////////////////////////////////////////
// KNN creations //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (NEW1_KNN_create, U"Create kNN Classifier", U"kNN classifiers 1. What is a kNN classifier?") {
WORD (U"Name", U"Classifier")
OK
DO
autoKNN knn = KNN_create ();
praat_new (knn.move(), GET_STRING (U"Name"));
END }
FORM (NEW1_PatternList_Categories_to_KNN, U"Create kNN classifier", U"kNN classifiers 1. What is a kNN classifier?") {
WORD (U"Name", U"Classifier")
RADIO (U"Ordering", 1)
RADIOBUTTON (U"Random")
RADIOBUTTON (U"Sequential")
OK
DO
FIND_TWO (PatternList, Categories)
int ordering = GET_INTEGER (U"Ordering");
autoKNN knn = KNN_create ();
switch (ordering) {
case 1:
ordering = kOla_SHUFFLE;
break;
case 2:
ordering = kOla_SEQUENTIAL;
}
int result = KNN_learn (knn.get(), me, you, kOla_REPLACE, ordering);
switch (result) {
case kOla_PATTERN_CATEGORIES_MISMATCH:
Melder_throw (U"The number of Categories should be equal to the number of rows in PatternList.");
case kOla_DIMENSIONALITY_MISMATCH:
Melder_throw (U"The dimensionality of PatternList should be equal to that of the instance base.");
default:
praat_new (knn.move(), GET_STRING (U"Name"));
}
END
}
/////////////////////////////////////////////////////////////////////////////////////////
// KNN extractions, queries and modifications //
/////////////////////////////////////////////////////////////////////////////////////////
DIRECT (INTEGER_KNN_getNumberOfInstances) {
NUMBER_ONE (KNN)
long result = my nInstances;
NUMBER_ONE_END (U" units")
}
FORM (INTEGER_KNN_getOptimumModel, U"kNN model selection", U"kNN classifiers 1.1.2. Model selection") {
RADIO (U"Evaluation method", 1)
RADIOBUTTON (U"Leave one out")
RADIOBUTTON (U"10-fold cross-validation")
INTEGER (U"k max", U"50")
INTEGER (U"Number of seeds", U"10")
POSITIVE (U"Learning rate", U"0.2")
OK
DO
FIND_ONE (KNN)
long k = GET_INTEGER (U"k max");
double lrate = GET_REAL (U"Learning rate");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k max such that 0 < k max < ", my nInstances + 1, U".");
long nseeds = GET_INTEGER (U"Number of seeds");
if (nseeds < 1)
Melder_throw (U"The number of seeds should exceed 1.");
int mode = GET_INTEGER (U"Evaluation method");
switch (mode) {
case 1:
mode = kOla_LEAVE_ONE_OUT;
break;
case 2:
mode = kOla_TEN_FOLD_CROSS_VALIDATION;
break;
}
autoFeatureWeights fws = FeatureWeights_create (my input -> nx);
int dist;
KNN_modelSearch (me, fws.get(), & k, & dist, mode, lrate, nseeds);
switch (dist) {
case kOla_SQUARED_DISTANCE_WEIGHTED_VOTING:
Melder_information (k, U" (vote weighting: inversed squared distance)");
break;
case kOla_DISTANCE_WEIGHTED_VOTING:
Melder_information (k, U" (vote weighting: inversed distance)");
break;
case kOla_FLAT_VOTING:
Melder_information (k, U" (vote weighting: flat)");
break;
}
END
}
FORM (REAL_KNN_evaluate, U"Evaluation", U"KNN: Get accuracy estimate...") {
RADIO (U"Evaluation method", 1)
RADIOBUTTON (U"Leave one out")
RADIOBUTTON (U"10-fold cross-validation")
INTEGER (U"k neighbours", U"1")
RADIO (U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_ONE (KNN)
if (my nInstances < 1)
Melder_throw (U"Instance base is empty.");
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
int vt = GET_INTEGER (U"Vote weighting");
switch (vt) {
case 1:
vt = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
vt = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
vt = kOla_FLAT_VOTING;
break;
}
int mode = GET_INTEGER (U"Evaluation method");
switch (mode) {
case 2:
mode = kOla_TEN_FOLD_CROSS_VALIDATION;
break;
case 1:
mode = kOla_LEAVE_ONE_OUT;
break;
}
autoFeatureWeights fws = FeatureWeights_create (my input -> nx);
double result = KNN_evaluate (me, fws.get(), k, vt, mode);
if (lround (result) == kOla_FWEIGHTS_MISMATCH)
Melder_throw (U"The number of feature weights should be equal to the dimensionality of the PatternList.");
Melder_information (100 * result, U" percent of the instances correctly classified."); // BUG: use Melder_percent
END
}
FORM (REAL_KNN_FeatureWeights_evaluate, U"Evaluation", U"KNN & FeatureWeights: Get accuracy estimate...") {
RADIO (U"Evaluation method", 1)
RADIOBUTTON (U"Leave one out")
RADIOBUTTON (U"10-fold cross-validation")
INTEGER (U"k neighbours", U"1")
RADIO (U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_TWO (KNN, FeatureWeights)
if (my nInstances < 1)
Melder_throw (U"Instance base is empty");
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
int vt = GET_INTEGER (U"Vote weighting");
switch (vt) {
case 1:
vt = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
vt = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
vt = kOla_FLAT_VOTING;
break;
}
int mode = GET_INTEGER (U"Evaluation method");
switch (mode) {
case 2:
mode = kOla_TEN_FOLD_CROSS_VALIDATION;
break;
case 1:
mode = kOla_LEAVE_ONE_OUT;
break;
}
double result = KNN_evaluate (me, you, k, vt, mode);
if (lround (result) == kOla_FWEIGHTS_MISMATCH)
Melder_throw (U"The number of feature weights should be equal to the dimensionality of the PatternList.");
Melder_information (100 * result, U" percent of the instances correctly classified."); // BUG: never report a percentage; always report a fraction
END
}
DIRECT (NEW_KNN_extractInputPatterns) {
LOOP {
iam (KNN);
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
autoPatternList input = Data_copy (my input.get());
praat_new (input.move(), my name, U"_input");
}
END }
DIRECT (NEW_KNN_extractOutputCategories) {
LOOP {
iam (KNN);
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
autoCategories output = Data_copy (my output.get());
praat_new (output.move(), my name, U"_output");
}
END }
FORM (MODIFY_KNN_reset, U"Reset", U"KNN: Reset...") {
LABEL (U"", U"Warning: this command destroys all previous learning.")
OK
DO
LOOP {
iam (KNN);
my input.reset();
my output.reset();
my nInstances = 0;
praat_dataChanged (me); // BUG: this should be inserted much more often
}
END }
DIRECT (MODIFY_KNN_shuffle) {
LOOP {
iam (KNN);
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
KNN_shuffleInstances (me);
praat_dataChanged (me);
}
END }
FORM (INFO_MODIFY_KNN_prune, U"Pruning", U"KNN: Prune...") {
POSITIVE (U"Noise pruning degree", U"1")
POSITIVE (U"Redundancy pruning degree", U"1")
INTEGER (U"k neighbours", U"1")
OK
DO
FIND_ONE (KNN)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
long oldn = my nInstances; // save before it changes!
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
double n = GET_REAL (U"Noise pruning degree");
double r = GET_REAL (U"Redundancy pruning degree");
if (n <= 0 || n > 1 || r <= 0 || r > 1)
Melder_throw (U"Please select a pruning degree d such that 0 < d <= 1.");
long npruned = KNN_prune_prune (me, n, r, k);
Melder_information (npruned, U" instances discarded. \n", U"Size of new instance base: ", oldn - npruned);
END
}
/////////////////////////////////////////////////////////////////////////////////////////
// Learning //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (MODIFY_KNN_PatternList_Categories_learn, U"Learning", U"kNN classifiers 1. What is a kNN classifier?") {
RADIO (U"Learning method", 1)
RADIOBUTTON (U"Append new information")
RADIOBUTTON (U"Replace current instance base")
RADIO (U"Ordering", 1)
RADIOBUTTON (U"Random")
RADIOBUTTON (U"Sequential")
OK
DO
FIND_THREE (KNN, PatternList, Categories)
int ordering = GET_INTEGER (U"Ordering");
switch (ordering) {
case 1:
ordering = kOla_SHUFFLE;
break;
case 2:
ordering = kOla_SEQUENTIAL;
}
int method = GET_INTEGER (U"Learning method");
int result = kOla_ERROR;
switch (method) {
case 1:
result = KNN_learn (me, you, him, my nInstances == 0 ? kOla_REPLACE : kOla_APPEND, ordering);
break;
case 2:
result = KNN_learn (me, you, him, kOla_REPLACE, ordering);
break;
}
switch (result) {
case kOla_PATTERN_CATEGORIES_MISMATCH:
Melder_throw (U"The number of Categories should be equal to the number of rows in PatternList.");
case kOla_DIMENSIONALITY_MISMATCH:
Melder_throw (U"The dimensionality of PatternList should be equal to that of the instance base.");
}
END
}
/////////////////////////////////////////////////////////////////////////////////////////
// Evaluation //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (BUG_KNN_evaluateWithTestSet, U"Evaluation", U"KNN & PatternList & Categories: Evaluate...") {
INTEGER (U"k neighbours", U"1")
RADIO (U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_THREE (KNN, PatternList, Categories)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty");
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
int vt = GET_INTEGER (U"Vote weighting");
switch (vt) {
case 1:
vt = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
vt = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
vt = kOla_FLAT_VOTING;
break;
}
if (your ny != his size)
Melder_throw (U"The number of Categories should be equal to the number of rows in PatternList.");
if (your nx != my input -> nx)
Melder_throw (U"The dimensionality of PatternList should be equal to that of the instance base.");
autoFeatureWeights fws = FeatureWeights_create (your nx);
double result = KNN_evaluateWithTestSet (me, you, him, fws.get(), k, vt);
Melder_information (100 * result, U" percent of the instances correctly classified.");
END
}
FORM (BUG_KNN_evaluateWithTestSetAndFeatureWeights, U"Evaluation", U"KNN & PatternList & Categories & FeatureWeights: Evaluate...") {
INTEGER4 (kNeighbours, U"k neighbours", U"1")
RADIO4 (voteWeighting, U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_FOUR (KNN, PatternList, Categories, FeatureWeights)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty");
if (kNeighbours < 1 || kNeighbours > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
switch (voteWeighting) {
case 1:
voteWeighting = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
voteWeighting = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
voteWeighting = kOla_FLAT_VOTING;
break;
}
if (your ny != his size)
Melder_throw (U"The number of Categories should be equal to the number of rows in PatternList.");
if (your nx != my input -> nx)
Melder_throw (U"The dimensionality of PatternList should be equal to that of the instance base.");
if (your nx != her fweights -> numberOfColumns)
Melder_throw (U"The number of feature weights should be equal to the dimensionality of the PatternList.");
double result = KNN_evaluateWithTestSet (me, you, him, she, kNeighbours, voteWeighting);
Melder_information (100 * result, U" percent of the instances correctly classified.");
END
}
/////////////////////////////////////////////////////////////////////////////////////////
// Classification //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (NEW1_KNN_PatternList_to_Categories, U"Classification", U"KNN & PatternList: To Categories...") {
INTEGER (U"k neighbours", U"1")
RADIO (U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_TWO (KNN, PatternList)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
int vt = GET_INTEGER (U"Vote weighting");
switch (vt) {
case 1:
vt = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
vt = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
vt = kOla_FLAT_VOTING;
break;
}
if (your nx != my input -> nx)
Melder_throw (U"The dimensionality of PatternList should match that of the instance base.");
autoFeatureWeights fws = FeatureWeights_create (your nx);
autoCategories result = KNN_classifyToCategories (me, you, fws.get(), k, vt);
praat_new (result.move(), my name, U"_", your name);
END
}
FORM (NEW1_KNN_PatternList_to_TableOfReal, U"Classification", U"KNN & PatternList: To TabelOfReal...") {
INTEGER (U"k neighbours", U"1")
RADIO (U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_TWO (KNN, PatternList)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
autoFeatureWeights fws = FeatureWeights_create (your nx);
int vt = GET_INTEGER (U"Vote weighting");
switch (vt) {
case 1:
vt = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
vt = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
vt = kOla_FLAT_VOTING;
break;
}
if (your nx != my input -> nx)
Melder_throw (U"The dimensionality of PatternList should match that of the instance base.");
autoTableOfReal result = KNN_classifyToTableOfReal (me, you, fws.get(), k, vt);
praat_new (result.move(), U"Output");
END
}
FORM (NEW1_KNN_PatternList_FeatureWeights_to_Categories, U"Classification", U"KNN & PatternList & FeatureWeights: To Categories...") {
INTEGER (U"k neighbours", U"KNN & PatternList & FeatureWeights: To Categories...")
RADIO (U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_THREE (KNN, PatternList, FeatureWeights)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
int vt = GET_INTEGER (U"Vote weighting");
switch (vt) {
case 1:
vt = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
vt = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
vt = kOla_FLAT_VOTING;
break;
}
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
if (your nx != my input -> nx)
Melder_throw (U"The dimensionality of PatternList should be equal to that of the instance base.");
if (your nx != his fweights -> numberOfColumns)
Melder_throw (U"The number of feature weights should be equal to the dimensionality of the PatternList.");
autoCategories result = KNN_classifyToCategories (me, you, him, k, vt);
praat_new (result.move(), U"Output");
END
}
FORM (NEW1_KNN_PatternList_FeatureWeights_to_TableOfReal, U"Classification", U"KNN & PatternList & FeatureWeights: To TableOfReal...") {
INTEGER (U"k neighbours", U"1")
RADIO (U"Vote weighting", 1)
RADIOBUTTON (U"Inverse squared distance")
RADIOBUTTON (U"Inverse distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_THREE (KNN, PatternList, FeatureWeights)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty.");
long k = GET_INTEGER (U"k neighbours");
int vt = GET_INTEGER (U"Vote weighting");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U"\n");
if (your nx != his fweights -> numberOfColumns)
Melder_throw (U"The number of features and the number of feature weights should be equal.");
switch (vt) {
case 1:
vt = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
vt = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
vt = kOla_FLAT_VOTING;
break;
}
autoTableOfReal result = KNN_classifyToTableOfReal (me, you, him, k, vt);
praat_new (result.move(), U"Output");
END
}
/////////////////////////////////////////////////////////////////////////////////////////
// Clustering //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (NEW_PatternList_to_Categories_cluster, U"k-means clustering", U"PatternList: To Categories...") {
INTEGER (U"k clusters", U"1")
POSITIVE (U"Cluster size ratio constraint", U"1e-7");
INTEGER (U"Maximum number of reseeds", U"1000")
OK
DO
LOOP {
iam (PatternList);
if (my nx > 0 && my ny > 0) {
long k = GET_INTEGER (U"k clusters");
if (k < 1 || k > my ny)
Melder_throw (U"Please select a value of k such that 0 < k <= ", my ny, U".");
long rs = GET_INTEGER (U"Maximum number of reseeds");
if (rs < 0)
Melder_throw (U"The maximum number of reseeds should not be negative.");
double rc = GET_REAL (U"Cluster size ratio constraint");
if (rc > 1 || rc <= 0)
Melder_throw (U"Please select a value of the cluster size ratio constraint c such that 0 < c <= 1.");
autoFeatureWeights fws = FeatureWeights_create (my nx);
autoCategories result = PatternList_to_Categories_cluster (me, fws.get(), k, rc, rs);
praat_new (result.move(), U"Output");
} else {
Melder_throw (U"PatternList is empty.");
}
}
END }
FORM (NEW1_PatternList_FeatureWeights_to_Categories_cluster, U"k-means clustering", U"PatternList & FeatureWeights: To Categories...") {
INTEGER (U"k clusters", U"1")
POSITIVE (U"Cluster size ratio constraint", U"1e-7");
INTEGER (U"Maximum number of reseeds", U"1000")
OK
DO
FIND_TWO (PatternList, FeatureWeights)
if (my nx <= 0 || my ny <= 0)
Melder_throw (U"PatternList is empty.");
if (my nx != your fweights -> numberOfColumns)
Melder_throw (U"The number of features and the number of feature weights should be equal.");
long k = GET_INTEGER (U"k clusters");
if (k < 1 || k > my ny)
Melder_throw (U"Please select a value of k such that 0 < k <= ", my ny, U".");
long rs = GET_INTEGER (U"Maximum number of reseeds");
if (rs < 0)
Melder_throw (U"The maximum number of reseeds should not be negative.");
double rc = GET_REAL (U"Cluster size ratio constraint");
if (rc > 1 || rc <= 0)
Melder_throw (U"Please select a value of the cluster size ratio constraint c such that 0 < c <= 1.");
autoCategories result = PatternList_to_Categories_cluster (me, you, k, rc, rs);
praat_new (result.move(), U"Output");
END
}
/////////////////////////////////////////////////////////////////////////////////////////
// Dissimilarity computations //
/////////////////////////////////////////////////////////////////////////////////////////
DIRECT (NEW_PatternList_to_Dissimilarity) {
LOOP {
iam (PatternList);
autoFeatureWeights fws = FeatureWeights_create (my nx);
autoDissimilarity result = KNN_patternToDissimilarity (me, fws.get());
praat_new (result.move(), my name);
}
END }
DIRECT (NEW1_PatternList_FeatureWeights_to_Dissimilarity) {
FIND_TWO (PatternList, FeatureWeights)
if (my nx != your fweights -> numberOfColumns)
Melder_throw (U"The number of features and the number of feature weights should be equal.");
autoDissimilarity result = KNN_patternToDissimilarity (me, you);
praat_new (result.move(), U"Output");
END
}
/////////////////////////////////////////////////////////////////////////////////////////
// Computation of permutation //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (NEW_KNN_to_Permutation_annealing, U"KNN: To Permutation", U"PatternList & Categories: To FeatureWeights...") {
NATURAL (U"Tries per step", U"200")
NATURAL (U"Iterations", U"10")
POSITIVE (U"Step size", U"10")
POSITIVE (U"Boltzmann constant", U"1.0")
POSITIVE (U"Initial temperature", U"0.002")
POSITIVE (U"Damping factor", U"1.005")
POSITIVE (U"Final temperature", U"0.000002")
OK
DO
LOOP {
iam (KNN);
long tries = GET_INTEGER (U"Tries per step");
long iterations = GET_INTEGER (U"Iterations");
double step_size = GET_REAL (U"Step size");
double bolzmann_c = GET_REAL (U"Boltzmann constant");
double temp_start = GET_REAL (U"Initial temperature");
double temp_damp = GET_REAL (U"Damping factor");
double temp_stop = GET_REAL (U"Final temperature");
autoPermutation result = KNN_SA_ToPermutation (me, tries, iterations, step_size, bolzmann_c, temp_start, temp_damp, temp_stop);
praat_new (result.move(), my name);
}
END }
/////////////////////////////////////////////////////////////////////////////////////////
// Computation of feature weights //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (NEW1_PatternList_Categories_to_FeatureWeights_relief, U"Feature weights", U"PatternList & Categories: To FeatureWeights...") {
INTEGER (U"Number of neighbours", U"1")
OK
DO
FIND_TWO (PatternList, Categories)
if (my ny < 2)
Melder_throw (U"The PatternList object should contain at least two rows.");
if (my ny != your size)
Melder_throw (U"The number of rows in the PatternList object should equal the number of categories in the Categories object.");
autoFeatureWeights result = FeatureWeights_compute (me, you, GET_INTEGER (U"Number of neighbours"));
praat_new (result.move(), U"Output");
END
}
FORM (NEW1_KNN_PatternList_Categories_to_FeatureWeights_wrapperExt, U"Feature weights", U"KNN & PatternList & Categories: To FeatureWeights..") {
POSITIVE (U"Learning rate", U"0.02")
NATURAL (U"Number of seeds", U"20")
POSITIVE (U"Stop at", U"1")
RADIO (U"Optimization", 1)
RADIOBUTTON (U"Co-optimization")
RADIOBUTTON (U"Single feature")
NATURAL (U"k neighbours", U"1")
RADIO (U"Vote weighting", 3)
RADIOBUTTON (U"Inversed squared distance")
RADIOBUTTON (U"Inversed distance")
RADIOBUTTON (U"Flat")
OK
DO
FIND_THREE (KNN, PatternList, Categories)
if (my nInstances <= 0)
Melder_throw (U"Instance base is empty");
int mode = GET_INTEGER (U"Vote weighting");
switch (mode) {
case 1:
mode = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
mode = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
mode = kOla_FLAT_VOTING;
break;
}
long k = GET_INTEGER (U"k neighbours");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
if (your nx != my input -> nx)
Melder_throw (U"The dimensionality of PatternList should be equal to that of the instance base.");
autoFeatureWeights result = FeatureWeights_computeWrapperExt (me, you, him, k, mode, GET_INTEGER (U"Number of seeds"),
GET_REAL (U"Learning rate"), GET_REAL (U"Stop at"), (int) GET_INTEGER (U"Optimization"));
praat_new (result.move(), U"Output");
END
}
FORM (NEW_KNN_to_FeatureWeights_wrapperInt, U"Feature weights", U"KNN: To FeatureWeights...") {
POSITIVE (U"Learning rate", U"0.02")
NATURAL (U"Number of seeds", U"10")
POSITIVE (U"Stop at", U"1")
RADIO (U"Optimization", 1)
RADIOBUTTON (U"Co-optimization")
RADIOBUTTON (U"Single feature")
RADIO (U"Evaluation method", 1)
RADIOBUTTON (U"Leave one out")
RADIOBUTTON (U"10-fold cross-validation")
NATURAL (U"k neighbours", U"1")
RADIO (U"Vote weighting", 3)
RADIOBUTTON (U"Inversed squared distance")
RADIOBUTTON (U"Inversed distance")
RADIOBUTTON (U"Flat")
OK
DO
int emode = GET_INTEGER (U"Evaluation method");
switch (emode) {
case 1:
emode = kOla_LEAVE_ONE_OUT;
break;
case 2:
emode = kOla_TEN_FOLD_CROSS_VALIDATION;
break;
}
int mode = GET_INTEGER (U"Vote weighting");
switch (mode) {
case 1:
mode = kOla_SQUARED_DISTANCE_WEIGHTED_VOTING;
break;
case 2:
mode = kOla_DISTANCE_WEIGHTED_VOTING;
break;
case 3:
mode = kOla_FLAT_VOTING;
break;
}
long k = GET_INTEGER (U"k neighbours");
LOOP {
iam (KNN);
if (my nInstances < 1)
Melder_throw (U"Instance base is empty");
if (k < 1 || k > my nInstances)
Melder_throw (U"Please select a value of k such that 0 < k < ", my nInstances + 1, U".");
autoFeatureWeights result = FeatureWeights_computeWrapperInt (me, k, mode, GET_INTEGER (U"Number of seeds"), GET_REAL (U"Learning rate"),
GET_REAL (U"Stop at"), (int) GET_INTEGER (U"Optimization"), emode);
praat_new (result.move(), my name, U"_output");
}
END }
/////////////////////////////////////////////////////////////////////////////////////////
// Creation and processing of auxiliary datatypes //
/////////////////////////////////////////////////////////////////////////////////////////
FORM (NEW1_FeatureWeights_create, U"Create FeatureWeights", nullptr) {
WORD (U"Name", U"empty")
NATURAL (U"Number of weights", U"1")
OK
DO
autoFeatureWeights result = FeatureWeights_create (GET_INTEGER (U"Number of weights"));
praat_new (result.move(), GET_STRING (U"Name"));
END }
/////////////////////////////////////////////////////////////////////////////////////////
// DEBUG //
/////////////////////////////////////////////////////////////////////////////////////////
// Disabled
/*
#ifdef _DEBUG
DIRECT (KNN_debug_KNN_SA_partition) {
FIND_ONE (PatternList)
autoPatternList output = PatternList_create (my ny, my nx);
autoNUMvector result (0, my ny);
KNN_SA_partition (me, 1, my ny, result);
for (long k = 1, c = 1; k <= output -> ny; k ++, c ++)
for (long i = 1; i <= my ny && k <= output -> ny; i ++)
if (result [i] == c) {
for(long j = 1; j <= output -> nx; ++j)
output -> z [k] [j] = my z [i] [j];
k ++;
}
praat_new (output.move(), U"Output");
END
}
DIRECT (KNN_debug_KNN_getNumberOfCPUs) {
Melder_information (KNN_getNumberOfCPUs(), U" CPUs available");
END }
DIRECT (KNN_debug_KNN_threadTest) {
KNN_threadTest();
END }
#endif
*/
/////////////////////////////////////////////////////////////////////////////////////////
// Help //
/////////////////////////////////////////////////////////////////////////////////////////
DIRECT (HELP_KNN_help) {
Melder_help (U"KNN classifiers");
END }
DIRECT (HINT_KNN_and_FeatureWeights_evaluate) {
Melder_information (U"The accuracy of a KNN can be estimated by selecting a KNN and a FeatureWeights object and choosing \"Evaluate...\".");
END }
DIRECT (HINT_KNN_and_Pattern_classify) {
Melder_information (U"You can use the KNN as a classifier by selecting a KNN and a PatternList and choosing \"To Categories...\" or \"To TableOfReal...\".");
END }
DIRECT (HINT_KNN_and_Pattern_and_FeatureWeights_classify) {
Melder_information (U"You can use the KNN as a classifier by selecting a KNN, a PatternList and an FeatureWeights object and choosing \"To Categories...\" or \"To TableOfReal...\".");
END }
DIRECT (HINT_KNN_and_Pattern_and_Categories_learn) {
Melder_information (U"You can train a KNN by selecting a KNN, a PatternList and a Categories object together and choosing \"Learn...\".");
END }
DIRECT (HINT_KNN_and_Pattern_and_Categories_evaluate) {
Melder_information (U"The accuracy of a KNN can be estimated by selecting a KNN, a test PatternList and the corresponding Categories object and choosing \"Evaluate...\".");
END }
DIRECT (HINT_KNN_and_Pattern_and_Categories_and_FeatureWeights_evaluate) {
Melder_information (U"The accuracy of a KNN can be estimated by selecting a KNN, a test PatternList, an FeatureWeights object, and the corresponding Categories object and choosing \"Evaluate...\".");
END }
DIRECT (HINT_Pattern_and_FeatureWeights_to_Categories) {
Melder_information (U"A PatternList object and a FeatureWeights object can be used to compute a fixed number of clusters using the k-means clustering clustering algorithm.");
END }
DIRECT (HINT_Pattern_and_FeatureWeights_to_Dissimilarity) {
Melder_information (U"A Dissimilarity matrix can be generated from a PatternList and a FeatureWeights object.");
END }
/////////////////////////////////////////////////////////////////////////////////////////
// Setting callbacks //
/////////////////////////////////////////////////////////////////////////////////////////
void praat_contrib_Ola_KNN_init ();
void praat_contrib_Ola_KNN_init ()
{
Thing_recognizeClassesByName (classKNN, classFeatureWeights, nullptr);
//////////
// Menu //
//////////
praat_addMenuCommand (U"Objects", U"New", U"kNN classifiers", nullptr, 0, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"kNN classifiers", nullptr, praat_DEPTH_1, HELP_KNN_help);
praat_addMenuCommand (U"Objects", U"New", U"-- KNN --", nullptr, 1, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Create kNN classifier...", nullptr, 1, NEW1_KNN_create);
praat_addMenuCommand (U"Objects", U"New", U"Advanced", nullptr, 1, nullptr);
praat_addMenuCommand (U"Objects", U"New", U"Create PatternList...", nullptr, 2, NEW1_PatternList_create);
praat_addMenuCommand (U"Objects", U"New", U"Create Categories...", nullptr, 2, NEW1_Categories_create);
praat_addMenuCommand (U"Objects", U"New", U"Create FeatureWeights...", nullptr, 2, NEW1_FeatureWeights_create);
/////////////
// Actions //
/////////////
praat_addAction1 (classKNN, 0, U"kNN help", nullptr, 0, HELP_KNN_help);
praat_addAction1 (classKNN, 0, QUERY_BUTTON, nullptr, 0, nullptr);
praat_addAction1 (classKNN, 1, U"Get optimized parameters...", nullptr, 2, INTEGER_KNN_getOptimumModel);
praat_addAction1 (classKNN, 1, U"Get accuracy estimate...", nullptr, 2, REAL_KNN_evaluate);
praat_addAction1 (classKNN, 1, U"Get size of instancebase", nullptr, 2, INTEGER_KNN_getNumberOfInstances);
praat_addAction1 (classKNN, 0, MODIFY_BUTTON, nullptr, 0, nullptr);
praat_addAction1 (classKNN, 0, U"Shuffle", nullptr, 1, MODIFY_KNN_shuffle);
praat_addAction1 (classKNN, 1, U"Prune...", nullptr, 1, INFO_MODIFY_KNN_prune);
praat_addAction1 (classKNN, 0, U"Reset...", nullptr, 1, MODIFY_KNN_reset);
praat_addAction1 (classKNN, 0, EXTRACT_BUTTON, nullptr, 0, nullptr);
praat_addAction1 (classKNN, 0, U"Extract input Patterns", nullptr, 1, NEW_KNN_extractInputPatterns);
praat_addAction1 (classKNN, 0, U"Extract output Categories", nullptr, 1, NEW_KNN_extractOutputCategories);
praat_addAction1 (classKNN, 0, U"To FeatureWeights...", nullptr, 0, NEW_KNN_to_FeatureWeights_wrapperInt);
// praat_addAction1 (classKNN, 0, U"To Permutation (annealing)...", nullptr, 0, NEW_KNN_to_Permutation_annealing);
// praat_addAction2 (classKNN, 1, classFeatureWeights, 1, U"To Permutation...", nullptr, 0, NEW1_KNN_FeatureWeights_to_Permutation);
praat_addAction3 (classKNN, 1, classPatternList, 1, classCategories, 1, U"Learn...", nullptr, 0, MODIFY_KNN_PatternList_Categories_learn);
praat_addAction2 (classKNN, 1, classFeatureWeights, 1, U"Evaluate...", nullptr, 0, REAL_KNN_FeatureWeights_evaluate);
praat_addAction3 (classKNN, 1, classPatternList, 1, classCategories, 1, U"Evaluate...", nullptr, 0, BUG_KNN_evaluateWithTestSet);
praat_addAction4 (classKNN, 1, classPatternList, 1, classCategories, 1, classFeatureWeights, 1, U"Evaluate...", nullptr, 0, BUG_KNN_evaluateWithTestSetAndFeatureWeights);
praat_addAction3 (classKNN, 1, classPatternList, 1, classCategories, 1, U"To FeatureWeights...", nullptr, 0,
NEW1_KNN_PatternList_Categories_to_FeatureWeights_wrapperExt);
praat_addAction2 (classKNN, 1, classPatternList, 1, U"To Categories...", nullptr, 0, NEW1_KNN_PatternList_to_Categories);
praat_addAction2 (classKNN, 1, classPatternList, 1, U"To TableOfReal...", nullptr, 0, NEW1_KNN_PatternList_to_TableOfReal);
praat_addAction3 (classKNN, 1, classPatternList, 1, classFeatureWeights, 1, U"To Categories...", nullptr, 0,
NEW1_KNN_PatternList_FeatureWeights_to_Categories);
praat_addAction3 (classKNN, 1, classPatternList, 1, classFeatureWeights, 1, U"To TableOfReal...", nullptr, 0,
NEW1_KNN_PatternList_FeatureWeights_to_TableOfReal);
praat_addAction1 (classPatternList, 0, U"To Dissimilarity", nullptr, 1, NEW_PatternList_to_Dissimilarity);
praat_addAction1 (classPatternList, 0, U"To Categories (cluster)...", nullptr, 1, NEW_PatternList_to_Categories_cluster);
praat_addAction2 (classPatternList, 1, classFeatureWeights, 1, U"To Dissimilarity", nullptr, 0, NEW1_PatternList_FeatureWeights_to_Dissimilarity);
praat_addAction2 (classPatternList, 1, classFeatureWeights, 1, U"To Categories (cluster)...", nullptr, 0, NEW1_PatternList_FeatureWeights_to_Categories_cluster);
praat_addAction2 (classPatternList, 1, classCategories, 1, U"To FeatureWeights (relief)...", nullptr, 0, NEW1_PatternList_Categories_to_FeatureWeights_relief);
praat_addAction2 (classPatternList, 1, classCategories, 1, U"To KNN Classifier...", nullptr, 0, NEW1_PatternList_Categories_to_KNN);
///////////
// DEBUG //
///////////
/*
#ifdef _DEBUG
praat_addAction1 (classKNN, 0, U"_DEBUG: KNN_getNumberOfCPUs", 0, 0, DO_KNN_debug_KNN_getNumberOfCPUs);
praat_addAction1 (classKNN, 0, U"_DEBUG: KNN_threadTest", 0, 0, DO_KNN_debug_KNN_threadTest);
praat_addAction1 (classPattern, 1, U"_DEBUG: KNN_SA_partition", 0, 1, DO_KNN_debug_KNN_SA_partition);
#endif
*/
///////////
// Hints //
///////////
praat_addAction1 (classPatternList, 0, U"& FeatureWeights: To Categories?", nullptr, 0, HINT_Pattern_and_FeatureWeights_to_Categories);
praat_addAction1 (classPatternList, 0, U"& FeatureWeights: To Dissimilarity?", nullptr, 0, HINT_Pattern_and_FeatureWeights_to_Dissimilarity);
praat_addAction1 (classKNN, 0, U"& FeatureWeights: Evaluate?", nullptr, 0, HINT_KNN_and_FeatureWeights_evaluate);
// praat_addAction1 (classKNN, 0, U"& FeatureWeights: To Permutation?", nullptr, 0, HINT_Pattern_and_FeatureWeights_to_Dissimilarity);
praat_addAction1 (classKNN, 0, U"& Pattern: Classify?", nullptr, 0, HINT_KNN_and_Pattern_classify);
praat_addAction1 (classKNN, 0, U"& Pattern & FeatureWeights: Classify?", nullptr, 0, HINT_KNN_and_Pattern_and_FeatureWeights_classify);
praat_addAction1 (classKNN, 0, U"& Pattern & Categories: Learn?", nullptr, 0, HINT_KNN_and_Pattern_and_Categories_learn);
praat_addAction1 (classKNN, 0, U"& Pattern & Categories: Evaluate?", nullptr, 0, HINT_KNN_and_Pattern_and_Categories_evaluate);
praat_addAction1 (classKNN, 0, U"& Pattern & Categories & FeatureWeights: Evaluate?", nullptr, 0, HINT_KNN_and_Pattern_and_Categories_and_FeatureWeights_evaluate);
INCLUDE_MANPAGES (manual_KNN_init)
}
/* End of file praat_contrib_Ola_KNN.cpp */
praat-6.0.23/dwsys/ 0000775 0000000 0000000 00000000000 13023464014 0014057 5 ustar 00root root 0000000 0000000 praat-6.0.23/dwsys/Collection_extensions.cpp 0000664 0000000 0000000 00000020144 13023464014 0021136 0 ustar 00root root 0000000 0000000 /* Collection_extensions.cpp
*
* Copyright (C) 1994-2011, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020812 GPL header
djmw 20040420 Fraction in OrderedOfString_difference must be double.
djmw 20050511 Skip printing unique labels in OrderedOfString
djmw 20061214
djmw 20061214 Changed info to Melder_writeLine format.
djmw 20110304 Thing_new
*/
#include "Collection_extensions.h"
#include "Simple_extensions.h"
#include "NUM2.h"
autoCollection Collection_and_Permutation_permuteItems (Collection me, Permutation him) {
try {
if (my size != his numberOfElements) {
Melder_throw (me, U"The number of elements are not equal.");
}
autoNUMvector pos (1, my size);
autoCollection thee = Data_copy (me);
for (long i = 1; i <= my size; i ++) {
pos [i] = i;
}
/* Dual meaning of array pos: */
/* k < i : position of item 'k' */
/* k >= i : the item at position 'k' */
for (long i = 1; i <= my size; i++) {
long ti = pos [i], which = Permutation_getValueAtIndex (him, i);
long where = pos [which]; // where >= i
Daata tmp = static_cast (thy at [i]);
if (i == where) {
continue;
}
thy at [i] = thy at [where];
thy at [where] = tmp;
/* order is important !! */
pos [ti] = where;
pos [where] = ti;
pos [which] = ( which <= i ? i : ti );
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": not permuted.");
}
}
autoCollection Collection_permuteItems (Collection me) {
try {
autoPermutation p = Permutation_create (my size);
Permutation_permuteRandomly_inline (p.get(), 0, 0);
autoCollection thee = Collection_and_Permutation_permuteItems (me, p.get());
return thee;
} catch (MelderError) {
Melder_throw (me, U": items not permuted.");
}
}
/****************** class OrderedOfString ******************/
void structOrderedOfString :: v_info () {
structDaata :: v_info ();
MelderInfo_writeLine (U"Number of strings: ", our size);
autoOrderedOfString uStrings = OrderedOfString_selectUniqueItems (this);
MelderInfo_writeLine (U"Number of unique categories: ", uStrings->size); // FIXME: "categories"?, and why mention a Set property?
}
Thing_implement (OrderedOfString, Ordered, 0);
int OrderedOfString_append (OrderedOfString me, const char32 *append) {
try {
if (! append) {
return 1; // BUG: lege string appenden??
}
autoSimpleString item = SimpleString_create (append);
my addItem_move (item.move());
return 1;
} catch (MelderError) {
Melder_throw (me, U": text not appended.");
}
}
autoOrderedOfString OrderedOfString_joinItems (OrderedOfString me, OrderedOfString thee) {
try {
if (my size != thy size) {
Melder_throw (U"sizes must be equal.");
}
autoOrderedOfString him = Data_copy (me);
for (long i = 1; i <= my size; i ++) {
SimpleString_append (his at [i], thy at [i]);
}
return him;
} catch (MelderError) {
Melder_throw (U"Items not joinmed.");
}
}
autoOrderedOfString OrderedOfString_selectUniqueItems (OrderedOfString me) {
try {
autoStringSet thee = StringSet_create ();
for (long i = 1; i <= my size; i ++) {
if (! thy hasItem (my at [i])) { // FIXME: first sort, then unicize
autoSimpleString item = Data_copy (my at [i]);
thy addItem_move (item.move());
}
}
autoOrderedOfString him = OrderedOfString_create ();
for (long i = 1; i <= thy size; i ++) {
autoSimpleString item = Data_copy (thy at [i]);
his addItem_move (item.move());
}
return him;
} catch (MelderError) {
Melder_throw (me, U": unique items not selected.");
}
}
void OrderedOfString_frequency (OrderedOfString me, OrderedOfString thee, long *count) {
for (long i = 1; i <= my size; i ++) {
for (long j = 1; j <= thy size; j ++) {
if (Data_equal (my at [i], thy at [j])) {
count[j]++;
break;
}
}
}
}
long OrderedOfString_getNumberOfDifferences (OrderedOfString me, OrderedOfString thee) {
long numberOfDifferences = 0;
if (my size != thy size) {
return -1;
}
for (long i = 1; i <= my size; i ++) {
if (! Data_equal (my at [i], thy at [i])) {
numberOfDifferences++;
}
}
return numberOfDifferences;
}
double OrderedOfString_getFractionDifferent (OrderedOfString me, OrderedOfString thee) {
long numberOfDifferences = OrderedOfString_getNumberOfDifferences (me, thee);
if (numberOfDifferences < 0) {
return NUMundefined;
}
return my size == 0 ? 0.0 : (0.0 + numberOfDifferences) / my size;
}
int OrderedOfString_difference (OrderedOfString me, OrderedOfString thee, long *ndif, double *fraction) {
*ndif = 0;
*fraction = 1.0;
if (my size != thy size) {
Melder_flushError (U"OrderedOfString_difference: the numbers of items differ");
return 0;
}
for (long i = 1; i <= my size; i ++) {
if (! Data_equal (my at [i], thy at [i])) {
(*ndif) ++;
}
}
*fraction = *ndif;
*fraction /= my size;
return 1;
}
long OrderedOfString_indexOfItem_c (OrderedOfString me, const char32 *str) {
long index = 0;
autoSimpleString s = SimpleString_create (str);
for (long i = 1; i <= my size; i ++) {
if (Data_equal (my at [i], s.get())) {
index = i;
break;
}
}
return index;
}
const char32 *OrderedOfString_itemAtIndex_c (OrderedOfString me, long index) {
return index > 0 && index <= my size ? SimpleString_c (my at [index]) : nullptr;
}
void OrderedOfString_initWithSequentialNumbers (OrderedOfString me, long n) {
for (long i = 1; i <= n; i ++) {
my addItem_move (SimpleString_create (Melder_integer (i)));
}
}
void OrderedOfString_changeStrings (OrderedOfString me, char32 *search, char32 *replace, int maximumNumberOfReplaces, long *nmatches, long *nstringmatches, int use_regexp) {
regexp *compiled_search = nullptr;
try {
if (! search) {
Melder_throw (U"Missing search string.");
}
if (! replace) {
Melder_throw (U"Missing replace string.");
}
if (use_regexp) {
compiled_search = CompileRE_throwable (search, 0);
}
for (long i = 1; i <= my size; i ++) {
SimpleString ss = my at [i];
long nmatches_sub;
char32 *r = use_regexp ? str_replace_regexp (ss -> string, compiled_search, replace, maximumNumberOfReplaces, &nmatches_sub) : str_replace_literal (ss -> string, search, replace, maximumNumberOfReplaces, &nmatches_sub);
// Change without error:
Melder_free (ss -> string);
ss -> string = r;
if (nmatches_sub > 0) {
*nmatches += nmatches_sub;
(*nstringmatches) ++;
}
}
if (use_regexp) {
free (compiled_search);
}
} catch (MelderError) {
if (use_regexp) {
free (compiled_search);
}
Melder_throw (U"Replace not completed.");
}
}
long OrderedOfString_isSubsetOf (OrderedOfString me, OrderedOfString thee, long *translation) { // ?? test and give number
long nStrings = 0;
for (long i = 1; i <= my size; i ++) {
if (translation) {
translation [i] = 0;
}
for (long j = 1; j <= thy size; j ++)
if (Data_equal (my at [i], thy at [j])) {
if (translation) {
translation[i] = j;
}
nStrings++; break;
}
}
return nStrings;
}
void OrderedOfString_drawItem (OrderedOfString me, Graphics g, long index, double xWC, double yWC) {
if (index > 0 && index <= my size) {
SimpleString_draw (my at [index], g, xWC, yWC);
}
}
long OrderedOfString_getSize (OrderedOfString me) {
return my size;
}
void OrderedOfString_removeOccurrences (OrderedOfString me, const char32 *search, int use_regexp) {
if (! search) {
return;
}
for (long i = my size; i >= 1; i --) {
SimpleString ss = my at [i];
if ( (use_regexp && strstr_regexp (ss -> string, search)) ||
(!use_regexp && str32str (ss -> string, search))) {
my removeItem (i);
}
}
}
/* End of file Collection_extensions.cpp */
praat-6.0.23/dwsys/Collection_extensions.h 0000664 0000000 0000000 00000006317 13023464014 0020611 0 ustar 00root root 0000000 0000000 #ifndef _Collection_extensions_h_
#define _Collection_extensions_h_
/* Collection_extensions.h
*
* Copyright (C) 1994-2002,2015 David Weenink, 2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Collection.h"
#include "Graphics.h"
#include "Permutation.h"
autoCollection Collection_and_Permutation_permuteItems (Collection me, Permutation him);
autoCollection Collection_permuteItems (Collection me);
/* permute the order of my items */
/****************** class OrderedOfString ******************/
Collection_define (OrderedOfString, OrderedOf, SimpleString) {
void v_info ()
override;
};
int OrderedOfString_append (OrderedOfString me, const char32 *append);
autoOrderedOfString OrderedOfString_joinItems (OrderedOfString me, OrderedOfString thee);
/* Join each item */
autoOrderedOfString OrderedOfString_selectUniqueItems (OrderedOfString me);
/* Postcondition: thy size <= my size */
void OrderedOfString_frequency (OrderedOfString me, OrderedOfString thee, long *count);
/* count how often the items in 'thee' occur in 'me' */
/* Precondition: count[1..thy size] exists */
/* To be removed Praat 4.2.4 2004040427 */
int OrderedOfString_difference (OrderedOfString me, OrderedOfString thee, long *ndif, double *fraction);
double OrderedOfString_getFractionDifferent (OrderedOfString me, OrderedOfString thee);
long OrderedOfString_getNumberOfDifferences (OrderedOfString me, OrderedOfString thee);
const char32 *OrderedOfString_itemAtIndex_c (OrderedOfString me, long index);
long OrderedOfString_indexOfItem_c (OrderedOfString me, const char32 *str);
void OrderedOfString_drawItem (OrderedOfString me, Graphics g, long index, double xWC, double yWC);
void OrderedOfString_initWithSequentialNumbers (OrderedOfString me, long n);
void OrderedOfString_removeOccurrences (OrderedOfString me, const char32 *search, int user_regexp);
void OrderedOfString_changeStrings (OrderedOfString me, char32 *search, char32 *replace,
int maximumNumberOfReplaces, long *nmatches, long *nstringmatches, int use_regexp);
long OrderedOfString_isSubsetOf (OrderedOfString me, OrderedOfString thee, long *translation);
/* Check whether my items are (a subset of)|(in) thy items.
* Preconditions:
* if (translation) translation[1..my size] exists.
* Postconditions:
* Return: the number of my labels that are in thee.
* if (translation) the returned translation table has the following property:
* if (translation[i] > 0) my label[i] = thy label[ translation[i] ];
* else if (translation[i] == 0) my label[i] not in thy labels.
*/
long OrderedOfString_getSize (OrderedOfString me);
/* return my size */
#endif /* _Collection_extensions_h_ */
praat-6.0.23/dwsys/Command.cpp 0000664 0000000 0000000 00000004324 13023464014 0016144 0 ustar 00root root 0000000 0000000 /* Command.cpp
*
* Copyright (C) 1994-2011, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Command.h"
#pragma mark - class Command
Thing_implement (Command, Thing, 0);
void Command_init (Command me, const char32 *name, Thing boss, Command_Callback execute, Command_Callback undo) {
Melder_assert (execute && undo);
Thing_setName (me, name);
my boss = boss;
my execute = execute;
my undo = undo;
}
int Command_do (Command me) {
return my execute (me);
}
int Command_undo (Command me) {
return my undo (me);
}
#pragma mark - class CommandHistory
Thing_implement (CommandHistory, Ordered, 0);
void CommandHistory_forth (CommandHistory me) {
my current ++;
}
void CommandHistory_back (CommandHistory me) {
my current --;
}
Command CommandHistory_getItem (CommandHistory me) {
Melder_assert (my current > 0 && my current <= my size);
return my at [my current];
}
void CommandHistory_insertItem_move (CommandHistory me, autoCommand command) {
for (long i = my size; i >= my current + 1; i --) {
my removeItem (i);
}
my addItem_move (command.move());
while (my size > 20) {
my removeItem (1);
}
my current = my size;
}
int CommandHistory_empty (CommandHistory me) {
return my size == 0;
}
int CommandHistory_offleft (CommandHistory me) {
return my current == 0;
}
int CommandHistory_offright (CommandHistory me) {
return my size == 0 || my current == my size + 1;
}
char32 *CommandHistory_commandName (CommandHistory me, long offsetFromCurrent) {
long pos = my current + offsetFromCurrent;
return pos >= 1 && pos <= my size ? Thing_getName (my at [pos]) : nullptr;
}
/* End of file Command.cpp */
praat-6.0.23/dwsys/Command.h 0000664 0000000 0000000 00000004637 13023464014 0015620 0 ustar 00root root 0000000 0000000 #ifndef _Command_h_
#define _Command_h_
/* Command.h
*
* Copyright (C) 1994-2011,2015 David Weenink, 2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Thing.h"
#include "Collection.h"
#pragma mark - class Command
Thing_declare (Command);
typedef MelderCallback Command_Callback;
Thing_define (Command, Thing) {
Thing boss;
Command_Callback execute;
Command_Callback undo;
};
void Command_init (Command me, const char32 *name, Thing boss, Command_Callback execute, Command_Callback undo);
int Command_do (Command me);
int Command_undo (Command me);
#pragma mark - class CommandHistory
Collection_define (CommandHistory, OrderedOf, Command) {
long current;
};
/* Active data structure. 'current' is position of the cursor in the list */
/* Queries and insertions are at the current position */
/* Invariants: */
/* 0 <= current <= size + 1; */
void CommandHistory_forth (CommandHistory me);
/* Precondition: ! offright */
/* my current++; */
void CommandHistory_back (CommandHistory me);
/* Precondition: ! offleft */
/* my current--; */
Command CommandHistory_getItem (CommandHistory me);
/* return (pointer to) my item[my current]; */
void CommandHistory_insertItem_move (CommandHistory me, autoCommand command);
/* 1. forget about item[ current+1..size ] */
/* 2. insert item after current. */
/* 3. current = size */
int CommandHistory_empty (CommandHistory me);
/* return my size == 0; */
int CommandHistory_offleft (CommandHistory me);
/* return my current == 0; */
int CommandHistory_offright (CommandHistory me);
/* return my size == 0 || my current == my size + 1; */
char32 *CommandHistory_commandName (CommandHistory me, long offsetFromCurrent);
/* offsetFromCurrent may be zero, positive or negative. */
/* References outside the list will return nullptr. */
#endif /* _Command_h_ */
praat-6.0.23/dwsys/DoublyLinkedList.cpp 0000664 0000000 0000000 00000012607 13023464014 0020012 0 ustar 00root root 0000000 0000000 /* DoublyLinkedList.cpp
*
* Copyright (C) 2011-2013, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "DoublyLinkedList.h"
Thing_implement (DoublyLinkedNode, Daata, 0);
void structDoublyLinkedNode :: v_destroy () noexcept {
DoublyLinkedNode_Parent :: v_destroy ();
}
void structDoublyLinkedNode :: v_copy (Daata thee_Daata) {
DoublyLinkedNode thee = static_cast (thee_Daata);
thy data = Data_copy (our data.get());
}
Thing_implement (DoublyLinkedList, Thing, 0);
void structDoublyLinkedList :: v_destroy () noexcept {
DoublyLinkedNode v = front;
while (v) {
DoublyLinkedNode cur = v;
v = v -> next;
forget (cur);
}
DoublyLinkedList_Parent :: v_destroy ();
}
int structDoublyLinkedList :: s_compareHook (Daata /* node1 */, Daata /* node2 */) noexcept {
return 0;
}
autoDoublyLinkedNode DoublyLinkedNode_create (autoDaata data) {
autoDoublyLinkedNode me = Thing_new (DoublyLinkedNode);
my data = data.move();
return me;
}
void DoublyLinkedList_init (DoublyLinkedList) {
}
autoDoublyLinkedList DoublyLinkedList_create() {
try {
autoDoublyLinkedList me = Thing_new (DoublyLinkedList);
DoublyLinkedList_init (me.get());
return me;
} catch (MelderError) {
Melder_throw (U"DoublyLinkedList not created.");
}
}
void DoublyLinkedList_addFront (DoublyLinkedList me, DoublyLinkedNode node) {
if (my front) {
DoublyLinkedList_addBefore (me, my front, node);
} else { // empty list
my front = node;
my back = node;
node -> next = nullptr;
node -> prev = nullptr;
my numberOfNodes++;
}
}
void DoublyLinkedList_addBack (DoublyLinkedList me, DoublyLinkedNode node) {
if (my back) {
DoublyLinkedList_addAfter (me, my back, node);
} else {
DoublyLinkedList_addFront (me, node); // empty list
}
}
void DoublyLinkedList_addBefore (DoublyLinkedList me, DoublyLinkedNode pos, DoublyLinkedNode node) {
node -> prev = pos -> prev;
node -> next = pos;
if (pos -> prev == nullptr) {
my front = node;
} else {
pos -> prev -> next = node;
}
pos -> prev = node;
my numberOfNodes++;
}
void DoublyLinkedList_addAfter (DoublyLinkedList me, DoublyLinkedNode pos, DoublyLinkedNode node) {
node -> prev = pos;
node -> next = pos -> next;
if (pos -> next == nullptr) {
my back = node;
} else {
pos -> next -> prev = node;
}
pos -> next = node;
my numberOfNodes++;
}
void DoublyLinkedList_remove (DoublyLinkedList me, DoublyLinkedNode node) {
if (my numberOfNodes == 0) {
return;
}
if (node == my front) {
my front = my front -> next;
my front -> prev = nullptr;
} else if (node == my back) {
my back = my back -> prev;
my back -> next = nullptr;
} else {
node -> prev -> next = node -> next;
node -> next -> prev = node -> prev;
}
forget (node);
my numberOfNodes++;
}
// Preconditions:
// from and to must be part of the list
// from must occur before to
void DoublyLinkedList_sortPart (DoublyLinkedList me, DoublyLinkedNode from, DoublyLinkedNode to) {
// Save data
if (from == to) {
return; // nothing to do
}
DoublyLinkedNode from_prev = from -> prev;
DoublyLinkedNode to_next = to -> next;
DoublyLinkedNode my_front = my front;
DoublyLinkedNode my_back = my back;
from -> prev = to -> next = nullptr;
my front = from;
my back = to;
DoublyLinkedList_sort (me);
// restore complete list
my front -> prev = from_prev;
if (from_prev) {
from_prev -> next = my front;
}
my back -> next = to_next;
if (to_next) {
to_next -> prev = my back;
}
if (my_front != from) {
my front = my_front;
}
if (my_back != to) {
my back = my_back;
}
}
void DoublyLinkedList_sort (DoublyLinkedList me) {
Data_CompareHook::FunctionType compare = my v_getCompareHook ().get();
long increment = 1;
DoublyLinkedNode front = my front, back;
for (;;) {
DoublyLinkedNode node1 = front;
front = nullptr;
back = nullptr;
long numberOfMerges = 0;
while (node1) {
DoublyLinkedNode node2 = node1, node;
long node1size = 0;
numberOfMerges++;
for (long i = 1; i <= increment; i++) {
node1size++;
node2 = node2 -> next;
if (! node2) {
break;
}
}
long node2size = increment;
while (node1size > 0 || (node2size > 0 && node2)) { // merge node1 and node2
if (node1size == 0) {
node2size--; node = node2; node2 = node2 -> next;
} else if (node2size == 0 || ! node2) {
node1size--; node = node1; node1 = node1 -> next;
} else if (compare (node1, node2) <= 0) {
node1size--; node = node1; node1 = node1 -> next;
} else {
node2size--; node = node2; node2 = node2 -> next;
}
if (back) {
back -> next = node;
} else {
front = node;
}
node -> prev = back;
back = node;
}
node1 = node2;
}
back -> next = nullptr;
if (numberOfMerges <= 1) {
break;
}
increment *= 2;
}
//
my front = front;
my back = back;
}
// end of file DoublyLinkedList.cpp
praat-6.0.23/dwsys/DoublyLinkedList.h 0000664 0000000 0000000 00000003757 13023464014 0017465 0 ustar 00root root 0000000 0000000 #ifndef _DoublyLinkedList_h_
#define _DoublyLinkedList_h_
/* DoublyLinkedList.h
*
* Copyright (C) 2011, 2015 David Weenink, 2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Data.h"
Thing_define (DoublyLinkedNode, Daata) {
DoublyLinkedNode next, prev;
autoDaata data;
void v_destroy () noexcept
override;
void v_copy (Daata data_to)
override;
};
Thing_define (DoublyLinkedList, Thing) {
long numberOfNodes;
DoublyLinkedNode front, back;
void v_destroy () noexcept
override;
static int s_compareHook (Daata /* data1 */, Daata /* data2 */) noexcept;
virtual Data_CompareHook v_getCompareHook () { return s_compareHook; }
};
autoDoublyLinkedNode DoublyLinkedNode_create (autoDaata data);
void DoublyLinkedList_init (DoublyLinkedList me);
autoDoublyLinkedList DoublyLinkedList_create ();
void DoublyLinkedList_addFront (DoublyLinkedList me, DoublyLinkedNode n);
void DoublyLinkedList_addBack (DoublyLinkedList me, DoublyLinkedNode n);
void DoublyLinkedList_addBefore (DoublyLinkedList me, DoublyLinkedNode pos, DoublyLinkedNode n);
void DoublyLinkedList_addAfter (DoublyLinkedList me, DoublyLinkedNode pos, DoublyLinkedNode n);
void DoublyLinkedList_remove (DoublyLinkedList me, DoublyLinkedNode n);
void DoublyLinkedList_sort (DoublyLinkedList me);
void DoublyLinkedList_sortPart (DoublyLinkedList me, DoublyLinkedNode from, DoublyLinkedNode to);
#endif // _DoublyLinkedList_h_
praat-6.0.23/dwsys/Eigen.cpp 0000664 0000000 0000000 00000041051 13023464014 0015613 0 ustar 00root root 0000000 0000000 /* Eigen.cpp
*
* Copyright (C) 1993-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20010719
djmw 20020402 GPL header.
djmw 20030701 Modified sorting in Eigen_initFromSquareRootPair.
djmw 20030703 Added Eigens_alignEigenvectors.
djmw 20030708 Corrected syntax error in Eigens_alignEigenvectors.
djmw 20030812 Corrected memory bug in Eigen_initFromSymmetricMatrix.
djmw 20030825 Removed praat_USE_LAPACK external variable.
djmw 20031101 Documentation
djmw 20031107 Moved NUMdmatrix_transpose to NUM2.c
djmw 20031210 Added rowLabels to Eigen_drawEigenvector and Eigen_and_Strings_drawEigenvector
djmw 20030322 Extra test in Eigen_initFromSquareRootPair.
djmw 20040329 Added fractionOfTotal and cumulative parameters in Eigen_drawEigenvalues_scree.
djmw 20040622 Less horizontal labels in Eigen_drawEigenvector.
djmw 20050706 Shortened horizontal offsets in Eigen_drawEigenvalues from 1 to 0.5
djmw 20051204 Eigen_initFromSquareRoot adapted for nrows < ncols
djmw 20071012 Added: o_CAN_WRITE_AS_ENCODING.h
djmw 20110304 Thing_new
*/
#include "Eigen.h"
#include "NUMmachar.h"
#include "NUMlapack.h"
#include "NUMclapack.h"
#include "NUM2.h"
#include "SVD.h"
#include "oo_DESTROY.h"
#include "Eigen_def.h"
#include "oo_COPY.h"
#include "Eigen_def.h"
#include "oo_EQUAL.h"
#include "Eigen_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "Eigen_def.h"
#include "oo_WRITE_TEXT.h"
#include "Eigen_def.h"
#include "oo_READ_TEXT.h"
#include "Eigen_def.h"
#include "oo_WRITE_BINARY.h"
#include "Eigen_def.h"
#include "oo_READ_BINARY.h"
#include "Eigen_def.h"
#include "oo_DESCRIPTION.h"
#include "Eigen_def.h"
Thing_implement (Eigen, Daata, 0);
#define MAX(m,n) ((m) > (n) ? (m) : (n))
#define MIN(m,n) ((m) < (n) ? (m) : (n))
#define SWAP(a,b) {temp=(a);(a)=(b);(b)=temp;}
static void Graphics_ticks (Graphics g, double min, double max, bool hasNumber, bool hasTick, bool hasDottedLine, bool integers) {
double range = max - min, scale = 1.0, tick = min, dtick = 1.0;
if (range == 0.0) {
return;
} else if (range > 1.0) {
while (range / scale > 10.0) {
scale *= 10.0;
}
range /= scale;
} else {
while (range / scale < 10.0) {
scale /= 10.0;
}
range *= scale;
}
if (range < 3.0) {
dtick = 0.5;
}
dtick *= scale;
tick = dtick * floor (min / dtick);
if (tick < min) {
tick += dtick;
}
while (tick <= max) {
double num = integers ? round (tick) : tick;
Graphics_markBottom (g, num, hasNumber, hasTick, hasDottedLine, nullptr);
tick += dtick;
}
}
void Eigen_init (Eigen me, long numberOfEigenvalues, long dimension) {
my numberOfEigenvalues = numberOfEigenvalues;
my dimension = dimension;
my eigenvalues = NUMvector (1, numberOfEigenvalues);
my eigenvectors = NUMmatrix (1, numberOfEigenvalues, 1, dimension);
}
/*
Solve: (A'A - lambda)x = 0 for eigenvalues lambda and eigenvectors x.
svd(A) = UDV' => A'A = (UDV')'(UDV') = VD^2V'
(VD^2V'-lambda)x = 0 => (D^2 - lambda)V'x = 0 => solution V'x = I => x = V
Eigenvectors: the columns of the matrix V
Eigenvalues: D_i^2
*/
void Eigen_initFromSquareRoot (Eigen me, double **a, long numberOfRows, long numberOfColumns) {
long numberOfZeroed, numberOfEigenvalues;
long nsv = MIN (numberOfRows, numberOfColumns);
my dimension = numberOfColumns;
autoSVD svd = SVD_create_d (a, numberOfRows, numberOfColumns);
/*
Make sv's that are too small zero. These values occur automatically
when the rank of A'A < numberOfColumns. This could occur when for
example numberOfRows <= numberOfColumns.
(n points in an n-dimensional space define maximally an n-1
dimensional surface for which we maximally need an n-1 dimensional
basis.)
*/
numberOfZeroed = SVD_zeroSmallSingularValues (svd.get(), 0.0);
numberOfEigenvalues = nsv - numberOfZeroed;
Eigen_init (me, numberOfEigenvalues, numberOfColumns);
long k = 0;
for (long i = 1; i <= nsv; i++) {
double t = svd -> d[i];
if (t > 0.0) {
my eigenvalues[++k] = t * t;
for (long j = 1; j <= numberOfColumns; j++) {
my eigenvectors[k][j] = svd -> v[j][i];
}
}
}
Eigen_sort (me);
}
void Eigen_initFromSquareRootPair (Eigen me, double **a, long numberOfRows, long numberOfColumns, double **b, long numberOfRows_b) {
double *u = nullptr, *v = nullptr, maxsv2 = -10.0;
char jobu = 'N', jobv = 'N', jobq = 'Q';
long k, ll, m = numberOfRows, n = numberOfColumns, p = numberOfRows_b;
long lda = m, ldb = p, ldu = lda, ldv = ldb, ldq = n;
long lwork = MAX (MAX (3 * n, m), p) + n, info;
/* Melder_assert (numberOfRows >= numberOfColumns || numberOfRows_b >= numberOfColumns);*/
my dimension = numberOfColumns;
autoNUMvector alpha (1, n);
autoNUMvector beta (1, n);
autoNUMvector work (1, lwork);
autoNUMvector iwork (1, n);
autoNUMmatrix q (1, n, 1, n);
autoNUMmatrix ac (NUMmatrix_transpose (a, numberOfRows, numberOfColumns), 1, 1);
autoNUMmatrix bc (NUMmatrix_transpose (b, numberOfRows_b, numberOfColumns), 1, 1);
(void) NUMlapack_dggsvd (&jobu, &jobv, &jobq, &m, &n, &p, &k, &ll,
&ac[1][1], &lda, &bc[1][1], &ldb, &alpha[1], &beta[1], u, &ldu,
v, &ldv, &q[1][1], &ldq, &work[1], &iwork[1], &info);
if (info != 0) {
Melder_throw (U"dggsvd fails.");
}
// Calculate the eigenvalues (alpha[i]/beta[i])^2 and store in alpha[i].
maxsv2 = -1.0;
for (long i = k + 1; i <= k + ll; i++) {
double t = alpha[i] / beta[i];
alpha[i] = t * t;
if (alpha[i] > maxsv2) {
maxsv2 = alpha[i];
}
}
// Deselect the eigenvalues < eps * max_eigenvalue.
n = 0;
for (long i = k + 1; i <= k + ll; i++) {
if (alpha[i] < NUMfpp -> eps * maxsv2) {
n++; alpha[i] = -1.0;
}
}
if (ll - n < 1) {
Melder_throw (U"No eigenvectors can be found. Matrix too singular.");
}
Eigen_init (me, ll - n, numberOfColumns);
long ii = 0;
for (long i = k + 1; i <= k + ll; i++) {
if (alpha[i] == -1.0) {
continue;
}
my eigenvalues[++ii] = alpha[i];
for (long j = 1; j <= numberOfColumns; j++) {
my eigenvectors[ii][j] = q[i][j];
}
}
Eigen_sort (me);
NUMnormalizeRows (my eigenvectors, my numberOfEigenvalues, numberOfColumns, 1);
}
void Eigen_initFromSymmetricMatrix (Eigen me, double **a, long n) {
double wt[1], temp;
char jobz = 'V', uplo = 'U';
long lwork = -1, info;
my dimension = my numberOfEigenvalues = n;
if (! my eigenvectors) {
Eigen_init (me, n, n);
}
NUMmatrix_copyElements (a, my eigenvectors, 1, n, 1, n);
// Get size of work array
(void) NUMlapack_dsyev (&jobz, &uplo, &n, &my eigenvectors[1][1], &n,
&my eigenvalues[1], wt, &lwork, &info);
if (info != 0) {
Melder_throw (U"dsyev initialization fails");
}
lwork = (long) floor (wt[0]);
autoNUMvector work (0L, lwork);
(void) NUMlapack_dsyev (&jobz, &uplo, &n, &my eigenvectors[1][1], &n, &my eigenvalues[1], work.peek(), &lwork, &info);
if (info != 0) {
Melder_throw (U"dsyev fails");
}
// We want descending order instead of ascending.
for (long i = 1; i <= n / 2; i++) {
long ilast = n - i + 1;
SWAP (my eigenvalues[i], my eigenvalues[ilast])
for (long j = 1; j <= n; j++) {
SWAP (my eigenvectors[i][j], my eigenvectors[ilast][j])
}
}
}
autoEigen Eigen_create (long numberOfEigenvalues, long dimension) {
try {
autoEigen me = Thing_new (Eigen);
Eigen_init (me.get(), numberOfEigenvalues, dimension);
return me;
} catch (MelderError) {
Melder_throw (U"Eigen not created.");
}
}
long Eigen_getNumberOfEigenvectors (Eigen me) {
return my numberOfEigenvalues;
}
double Eigen_getEigenvectorElement (Eigen me, long ivec, long element) {
if (ivec > my numberOfEigenvalues || element < 1 || element > my dimension) {
return NUMundefined;
}
return my eigenvectors[ivec][element];
}
long Eigen_getDimensionOfComponents (Eigen me) {
return my dimension;
}
double Eigen_getSumOfEigenvalues (Eigen me, long from, long to) {
if (from < 1) {
from = 1;
}
if (to < 1) {
to = my numberOfEigenvalues;
}
if (to > my numberOfEigenvalues || from > to) {
return NUMundefined;
}
double sum = 0.0;
for (long i = from; i <= to; i++) {
sum += my eigenvalues[i];
}
return sum;
}
double Eigen_getCumulativeContributionOfComponents (Eigen me, long from, long to) {
double partial = 0.0, sum = 0.0;
if (to == 0) {
to = my numberOfEigenvalues;
}
if (from > 0 && to <= my numberOfEigenvalues && from <= to) {
for (long i = 1; i <= my numberOfEigenvalues; i++) {
sum += my eigenvalues[i];
if (i >= from && i <= to) {
partial += my eigenvalues[i];
}
}
}
return sum > 0.0 ? partial / sum : 0.0;
}
long Eigen_getDimensionOfFraction (Eigen me, double fraction) {
double sum = Eigen_getSumOfEigenvalues (me, 0, 0);
if (sum == 0.0) {
return 1;
}
long n = 1;
double p = my eigenvalues[1];
while (p / sum < fraction && n < my numberOfEigenvalues) {
p += my eigenvalues[++n];
}
return n;
}
void Eigen_sort (Eigen me) {
double temp, *e = my eigenvalues, **v = my eigenvectors;
for (long i = 1; i < my numberOfEigenvalues; i++) {
long k;
double emax = e[k = i];
for (long j = i + 1; j <= my numberOfEigenvalues; j++) {
if (e[j] > emax) {
emax = e[k = j];
}
}
if (k != i) {
// Swap eigenvalues and eigenvectors
SWAP (e[i], e[k])
for (long j = 1; j <= my dimension; j++) {
SWAP (v[i][j], v[k][j])
}
}
}
}
void Eigen_invertEigenvector (Eigen me, long ivec) {
if (ivec < 1 || ivec > my numberOfEigenvalues) {
return;
}
for (long j = 1; j <= my dimension; j++) {
my eigenvectors[ivec][j] = - my eigenvectors[ivec][j];
}
}
void Eigen_drawEigenvalues (Eigen me, Graphics g, long first, long last, double ymin, double ymax, bool fractionOfTotal, bool cumulative, double size_mm, const char32 *mark, bool garnish) {
double xmin = first, xmax = last, scale = 1.0, sumOfEigenvalues = 0.0;
if (first < 1) {
first = 1;
}
if (last < 1 || last > my numberOfEigenvalues) {
last = my numberOfEigenvalues;
}
if (last <= first) {
first = 1; last = my numberOfEigenvalues;
}
xmin = first - 0.5; xmax = last + 0.5;
if (fractionOfTotal || cumulative) {
sumOfEigenvalues = Eigen_getSumOfEigenvalues (me, 0, 0);
if (sumOfEigenvalues <= 0.0) {
sumOfEigenvalues = 1.0;
}
scale = sumOfEigenvalues;
}
if (ymax <= ymin) {
ymax = Eigen_getSumOfEigenvalues (me, ( cumulative ? 1 : first ), first) / scale;
ymin = Eigen_getSumOfEigenvalues (me, ( cumulative ? 1 : last ), last) / scale;
if (ymin > ymax) {
double tmp = ymin; ymin = ymax; ymax = tmp;
}
if (ymin == ymax) { // only one eigenvalue
ymin -= 0.1 * ymin; ymax = ymax += 0.1 * ymax;
}
}
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
for (long i = first; i <= last; i ++) {
double accu = Eigen_getSumOfEigenvalues (me, (cumulative ? 1 : i), i);
Graphics_mark (g, i, accu / scale, size_mm, mark);
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textLeft (g, true, ( fractionOfTotal ? ( cumulative ? U"Cumulative fractional eigenvalue" : U"Fractional eigenvalue" ) :
( cumulative ? U"Cumulative eigenvalue" : U"Eigenvalue" ) ));
Graphics_ticks (g, first, last, true, true, false, true);
Graphics_marksLeft (g, 2, true, true, false);
Graphics_textBottom (g, true, U"Index");
}
}
void Eigen_drawEigenvector (Eigen me, Graphics g, long ivec, long first, long last, double ymin, double ymax, bool weigh, double size_mm, const char32 *mark, bool connect, char32 **rowLabels, bool garnish) {
double xmin = first, xmax = last;
if (ivec < 1 || ivec > my numberOfEigenvalues) {
return;
}
if (last <= first) {
first = 1; last = my dimension;
xmin = 0.5; xmax = last + 0.5;
}
double *vec = my eigenvectors[ivec];
double w = weigh ? sqrt (my eigenvalues[ivec]) : 1.0;
// If ymax < ymin the eigenvector will automatically be drawn inverted.
if (ymax == ymin) {
NUMvector_extrema (vec, first, last, &ymin, &ymax);
ymax *= w; ymin *= w;
}
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
for (long i = first; i <= last; i++) {
Graphics_mark (g, i, w * vec[i], size_mm, mark);
if (connect && i > first) {
Graphics_line (g, i - 1.0, w * vec[i - 1], i, w * vec[i]);
}
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_markBottom (g, first, false, true, false, rowLabels ? rowLabels[first] : Melder_integer (first));
Graphics_markBottom (g, last, false, true, false, rowLabels ? rowLabels[last] : Melder_integer (last));
Graphics_drawInnerBox (g);
if (ymin * ymax < 0.0) {
Graphics_markLeft (g, 0.0, true, true, true, nullptr);
}
Graphics_marksLeft (g, 2, true, true, false);
if (! rowLabels) {
Graphics_textBottom (g, true, U"Element number");
}
}
}
void Eigens_alignEigenvectors (OrderedOf* me) {
if (my size < 2) {
return;
}
Eigen e1 = my at [1];
double **evec1 = e1 -> eigenvectors;
long nev1 = e1 -> numberOfEigenvalues;
long dimension = e1 -> dimension;
for (long i = 2; i <= my size; i ++) {
Eigen e2 = my at [i];
if (e2 -> dimension != dimension) {
Melder_throw (U"The dimension of the eigenvectors must be equal (offending object is ", i, U").");
}
}
/*
Correlate eigenvectors.
If r < 0 then mirror the eigenvector.
*/
for (long i = 2; i <= my size; i ++) {
Eigen e2 = my at [i];
double **evec2 = e2 -> eigenvectors;
for (long j = 1; j <= MIN (nev1, e2 -> numberOfEigenvalues); j ++) {
double ip = 0.0;
for (long k = 1; k <= dimension; k ++) {
ip += evec1 [j] [k] * evec2 [j] [k];
}
if (ip < 0.0) {
for (long k = 1; k <= dimension; k ++) {
evec2 [j] [k] = - evec2 [j] [k];
}
}
}
}
}
static void Eigens_getAnglesBetweenSubspaces (Eigen me, Eigen thee, long ivec_from, long ivec_to, double *angles_degrees) {
long nvectors = ivec_to - ivec_from + 1;
for (long i = 1; i <= nvectors; i++) {
angles_degrees[i] = NUMundefined;
}
long nmin = my numberOfEigenvalues < thy numberOfEigenvalues ? my numberOfEigenvalues : thy numberOfEigenvalues;
if (my dimension != thy dimension) {
Melder_throw (U"The eigenvectors must have the same dimension.");
}
if (ivec_from > ivec_to || ivec_from < 1 || ivec_to > nmin) {
Melder_throw (U"Eigenvector range too large.");
}
autoNUMmatrix c (1, nvectors, 1, nvectors);
/*
Algorithm 12.4.3 Golub & van Loan
Because we deal with eigenvectors we don't have to do the QR-decomposition,
the columns in the Q's are the eigenvectors.
Compute C.
*/
for (long i = 1; i <= nvectors; i++) {
for (long j = 1; j <= nvectors; j++) {
for (long k = 1; k <= my dimension; k++) {
c[i][j] += my eigenvectors[ivec_from + i - 1][k] * thy eigenvectors[ivec_from + j - 1][k];
}
}
}
autoSVD svd = SVD_create_d (c.peek(), nvectors, nvectors);
for (long i = 1; i <= nvectors; i++) {
angles_degrees[i] = acos (svd -> d[i]) * 180.0 / NUMpi;
}
}
double Eigens_getAngleBetweenEigenplanes_degrees (Eigen me, Eigen thee) {
double angles_degrees[3];
Eigens_getAnglesBetweenSubspaces (me, thee, 1, 2, angles_degrees);
return angles_degrees[2];
}
/* Very low level */
void Eigen_and_matrix_into_matrix_principalComponents (Eigen me, double **from, long numberOfRows, long from_colbegin, double **to, long numberOfDimensionsToKeep, long to_colbegin) {
/*
* Preconditions:
*
* from[numberOfRows, from_colbegin - 1 + my dimension] exists
* to [numberOfRows, to_colbegin - 1 + numberOfDimensionsToKeep] exists
*
* Project/rotate the vectors in matrix 'from' along the 'numberOfDimensionsToKeep' eigenvectors into the matrix 'to'.
*/
from_colbegin = from_colbegin <= 0 ? 1 : from_colbegin;
to_colbegin = to_colbegin <= 0 ? 1 : to_colbegin;
if (numberOfDimensionsToKeep > my numberOfEigenvalues) {
Melder_throw (U"The number of dimensions to keep must not be larger than the number of eigenvalues.");
}
for (long irow = 1; irow <= numberOfRows; irow ++) {
for (long icol = 1; icol <= numberOfDimensionsToKeep; icol ++) {
double r = 0.0;
for (long k = 1; k <= my dimension; k ++) {
// eigenvector[icol] is in row[icol] of my eigenvectors
r += my eigenvectors [icol] [k] * from [irow] [from_colbegin + k - 1];
}
to [irow] [to_colbegin + icol - 1] = r;
}
}
}
#undef MAX
#undef MIN
#undef SWAP
/* End of file Eigen.cpp */
praat-6.0.23/dwsys/Eigen.h 0000664 0000000 0000000 00000006621 13023464014 0015264 0 ustar 00root root 0000000 0000000 #ifndef _Eigen_h_
#define _Eigen_h_
/* Eigen.h
*
* Copyright (C) 1993-2012, 2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Collection.h"
#include "Graphics.h"
#include "Strings_.h"
#include "Eigen_def.h"
autoEigen Eigen_create (long numberOfEigenvalues, long dimension);
void Eigen_init (Eigen me, long numberOfEigenvalues, long dimension);
void Eigen_initFromSymmetricMatrix (Eigen me, double **a, long n);
void Eigen_initFromSquareRoot (Eigen me, double **a, long numberOfRows, long numberOfColumns);
/*
Calculate eigenstructure for symmetric matrix A'A (e.g. covariance matrix),
when only A is given.
Precondition: numberOfRows > 1
Method: SVD.
*/
void Eigen_initFromSquareRootPair (Eigen me, double **a, long numberOfRows, long numberOfColumns, double **b, long numberOfRows_b);
/*
Calculate eigenstructure for A'Ax - lambda B'Bx = 0
Preconditions: numberOfRows >= numberOfColumns &&
numberOfRows_b >= numberOfColumns
Method: Generalized SVD.
*/
long Eigen_getNumberOfEigenvectors (Eigen me);
long Eigen_getDimensionOfComponents (Eigen me);
double Eigen_getCumulativeContributionOfComponents (Eigen me, long from, long to);
long Eigen_getDimensionOfFraction (Eigen me, double fraction);
double Eigen_getEigenvectorElement (Eigen me, long ivec, long element);
double Eigen_getSumOfEigenvalues (Eigen me, long from, long to);
void Eigen_sort (Eigen me);
/*
Sort eigenvalues and corresponding eigenvectors in decreasing order.
*/
void Eigen_invertEigenvector (Eigen me, long ivec);
void Eigen_drawEigenvalues (Eigen me, Graphics g, long first, long last, double ymin, double ymax,
bool fractionOfTotal, bool cumulative, double size_mm, const char32 *mark, bool garnish);
void Eigen_drawEigenvector (Eigen me, Graphics g, long ivec, long first, long last, double minimum, double maximum, bool weigh,
double size_mm, const char32 *mark, bool connect, char32 **rowLabels, bool garnish);
/*
Draw eigenvector. When rowLabels != nullptr, draw row text labels on bottom axis.
*/
/**
Adapt the sign of each eigenvector except the first
in such a way that it correlates positively with the first eigenvector.
*/
void Eigens_alignEigenvectors (OrderedOf* me);
double Eigens_getAngleBetweenEigenplanes_degrees (Eigen me, Eigen thee);
/*
Get angle between the eigenplanes, spanned by the first two eigenvectors, .
*/
void Eigen_and_matrix_into_matrix_principalComponents (Eigen me, double **from, long numberOfRows, long from_colbegin, double **to, long numberOfDimensionsToKeep, long to_colbegin);
/*
* Preconditions:
*
* from[numberOfRows, from_colbegin - 1 + my dimension] exists
* to [numberOfRows, to_colbegin - 1 + numberOfDimensionsToKeep] exists
*
* Project the vectors in matrix 'from' along the 'numberOfDimensionsToKeep' eigenvectors into the matrix 'to'.
*/
#endif /* _Eigen_h_ */
praat-6.0.23/dwsys/Eigen_def.h 0000664 0000000 0000000 00000001745 13023464014 0016104 0 ustar 00root root 0000000 0000000 /* Eigen_def.h
*
* Copyright (C) 1993-2008 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#define ooSTRUCT Eigen
oo_DEFINE_CLASS (Eigen, Daata)
oo_LONG (numberOfEigenvalues)
oo_LONG (dimension)
oo_DOUBLE_VECTOR (eigenvalues, numberOfEigenvalues)
oo_DOUBLE_MATRIX (eigenvectors, numberOfEigenvalues, dimension)
oo_END_CLASS (Eigen)
#undef ooSTRUCT
/* End of file Eigen_def.h */
praat-6.0.23/dwsys/FileInMemory.cpp 0000664 0000000 0000000 00000021216 13023464014 0017124 0 ustar 00root root 0000000 0000000 /* FileInMemory.cpp
*
* Copyright (C) 2012-2013, 2015-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "FileInMemory.h"
#include "Strings_.h"
Thing_implement (FileInMemory, Daata, 0);
void structFileInMemory :: v_copy (Daata thee_Daata) {
FileInMemory thee = static_cast (thee_Daata);
our FileInMemory_Parent :: v_copy (thee);
thy d_path = Melder_dup (our d_path);
thy d_id = Melder_dup (our d_id);
thy d_numberOfBytes = our d_numberOfBytes;
thy ownData = our ownData;
thy d_data = NUMvector (0, our d_numberOfBytes);
memcpy (thy d_data, our d_data, our d_numberOfBytes + 1);
}
void structFileInMemory :: v_destroy () noexcept {
Melder_free (our d_path);
Melder_free (our d_id);
if (our ownData)
NUMvector_free (our d_data, 0);
our FileInMemory_Parent :: v_destroy ();
}
void structFileInMemory :: v_info () {
our structDaata :: v_info ();
MelderInfo_writeLine (U"File name: ", our d_path);
MelderInfo_writeLine (U"Id: ", our d_id);
MelderInfo_writeLine (U"Number of bytes: ", our d_numberOfBytes);
}
autoFileInMemory FileInMemory_create (MelderFile file) {
try {
if (! MelderFile_readable (file)) {
Melder_throw (U"File not readable.");
}
long length = MelderFile_length (file);
if (length <= 0) {
Melder_throw (U"File is empty.");
}
autoFileInMemory me = Thing_new (FileInMemory);
my d_path = Melder_dup (file -> path);
my d_id = Melder_dup (MelderFile_name (file));
my d_numberOfBytes = length;
my ownData = true;
my d_data = NUMvector (0, my d_numberOfBytes); // includes room for a final null byte in case the file happens to contain text
MelderFile_open (file);
for (long i = 0; i < my d_numberOfBytes; i++) {
unsigned int number = bingetu1 (file -> filePointer);
my d_data[i] = number;
}
my d_data[my d_numberOfBytes] = 0; // one extra
MelderFile_close (file);
return me;
} catch (MelderError) {
Melder_throw (U"FileInMemory not created from \"", Melder_fileToPath (file), U"\".");
}
}
autoFileInMemory FileInMemory_createWithData (long numberOfBytes, const char *data, const char32 *path, const char32 *id) {
try {
autoFileInMemory me = Thing_new (FileInMemory);
my d_path = Melder_dup (path);
my d_id = Melder_dup (id);
my d_numberOfBytes = numberOfBytes;
my ownData = false;
my d_data = const_cast (data); // copy pointer to data only
return me;
} catch (MelderError) {
Melder_throw (U"FileInMemory not create from data.");
}
}
void FileInMemory_setId (FileInMemory me, const char32 *newId) {
Melder_free (my d_id);
my d_id = Melder_dup (newId);
}
void FileInMemory_showAsCode (FileInMemory me, const char32 *name, long numberOfBytesPerLine)
{
if (numberOfBytesPerLine <= 0) {
numberOfBytesPerLine = 20;
}
// autoNUMvector data (0, my d_numberOfBytes); ????
MelderInfo_writeLine (U"\t\tstatic unsigned char ", name, U"_data[", my d_numberOfBytes+1, U"] = {");
for (long i = 0; i < my d_numberOfBytes; i++) {
unsigned char number = my d_data[i];
MelderInfo_write ((i % numberOfBytesPerLine == 0 ? U"\t\t\t" : U""), number, U",",
((i % numberOfBytesPerLine == (numberOfBytesPerLine - 1)) ? U"\n" : U" "));
}
MelderInfo_writeLine ((my d_numberOfBytes - 1) % numberOfBytesPerLine == (numberOfBytesPerLine - 1) ? U"\t\t\t0};" : U"0};");
MelderInfo_write (U"\t\tautoFileInMemory ", name, U" = FileInMemory_createWithData (");
MelderInfo_writeLine (my d_numberOfBytes, U", reinterpret_cast (&", name, U"_data), \n\t\t\tU\"", my d_path, U"\", \n\t\t\tU\"", my d_id, U"\");");
}
Thing_implement (FileInMemorySet, SortedSet, 0);
int structFileInMemorySet :: s_compare_name (FileInMemory me, FileInMemory thee) {
return Melder_cmp (my d_path, thy d_path);
}
int structFileInMemorySet :: s_compare_id (FileInMemory me, FileInMemory thee) {
return Melder_cmp (my d_id, thy d_id);
}
autoFileInMemorySet FileInMemorySet_createFromDirectoryContents (const char32 *dirpath, const char32 *fileGlobber) {
try {
structMelderDir parent { { 0 } };
Melder_pathToDir (dirpath, &parent);
autoStrings thee = Strings_createAsFileList (Melder_cat (dirpath, U"/", fileGlobber));
if (thy numberOfStrings < 1) {
Melder_throw (U"No files found.");
}
autoFileInMemorySet me = FileInMemorySet_create ();
for (long i = 1; i <= thy numberOfStrings; i ++) {
structMelderFile file { 0 };
MelderDir_getFile (& parent, thy strings [i], & file);
autoFileInMemory fim = FileInMemory_create (& file);
my addItem_move (fim.move());
}
return me;
} catch (MelderError) {
Melder_throw (U"FileInMemorySet not created from directory \"", dirpath, U"\" for files that match \"", fileGlobber, U"\".");
}
}
void FileInMemorySet_showAsCode (FileInMemorySet me, const char32 *name, long numberOfBytesPerLine) {
autoMelderString one_fim;
MelderInfo_writeLine (U"#include \"Collection.h\"");
MelderInfo_writeLine (U"#include \"FileInMemory.h\"");
MelderInfo_writeLine (U"#include \"melder.h\"\n");
MelderInfo_writeLine (U"autoFileInMemorySet create_", name, U" () {");
MelderInfo_writeLine (U"\ttry {");
MelderInfo_writeLine (U"\t\tautoFileInMemorySet me = FileInMemorySet_create ();");
for (long ifile = 1; ifile <= my size; ifile ++) {
FileInMemory fim = my at [ifile];
MelderString_copy (& one_fim, name, ifile);
FileInMemory_showAsCode (fim, one_fim.string, numberOfBytesPerLine);
MelderInfo_writeLine (U"\t\tCollection_addItem_move (me.get(), ", one_fim.string, U".move());\n");
}
MelderInfo_writeLine (U"\t\treturn me;");
MelderInfo_writeLine (U"\t} catch (MelderError) {");
MelderInfo_writeLine (U"\t\tMelder_throw (U\"FileInMemorySet not created.\");");
MelderInfo_writeLine (U"\t}");
MelderInfo_writeLine (U"}\n\n");
}
void FileInMemorySet_showOneFileAsCode (FileInMemorySet me, long index, const char32 *name, long numberOfBytesPerLine)
{
if (index < 1 || index > my size) return;
MelderInfo_writeLine (U"#include \"FileInMemory.h\"");
MelderInfo_writeLine (U"#include \"melder.h\"\n");
MelderInfo_writeLine (U"static autoFileInMemory create_new_object () {");
MelderInfo_writeLine (U"\ttry {");
autoMelderString one_fim;
FileInMemory fim = my at [index];
MelderString_append (& one_fim, name, index);
FileInMemory_showAsCode (fim, U"me", numberOfBytesPerLine);
MelderInfo_writeLine (U"\t\treturn me;");
MelderInfo_writeLine (U"\t} catch (MelderError) {");
MelderInfo_writeLine (U"\t\tMelder_throw (U\"FileInMemory not created.\");");
MelderInfo_writeLine (U"\t}");
MelderInfo_writeLine (U"}\n\n");
MelderInfo_writeLine (U"autoFileInMemory ", name, U" = create_new_object ();");
}
long FileInMemorySet_getIndexFromId (FileInMemorySet me, const char32 *id) {
long index = 0;
for (long i = 1; i <= my size; i ++) {
FileInMemory fim = my at [i];
if (Melder_equ (id, fim -> d_id)) {
index = i;
break;
}
}
return index;
}
autoStrings FileInMemorySet_to_Strings_id (FileInMemorySet me) {
try {
autoStrings thee = Thing_new (Strings);
thy strings = NUMvector (1, my size);
thy numberOfStrings = 0;
for (long ifile = 1; ifile <= my size; ifile ++) {
FileInMemory fim = my at [ifile];
thy strings [ifile] = Melder_dup_f (fim -> d_id);
thy numberOfStrings ++;
}
return thee;
} catch (MelderError) {
Melder_throw (U"No Strings created from FilesinMemory.");
}
}
char * FileInMemorySet_getCopyOfData (FileInMemorySet me, const char32 *id, long *numberOfBytes) {
*numberOfBytes = 0;
long index = FileInMemorySet_getIndexFromId (me, id);
if (index == 0) {
return nullptr;
}
FileInMemory fim = my at [index];
char *data = (char *) _Melder_malloc (fim -> d_numberOfBytes);
if (! data || ! memcpy (data, fim -> d_data, fim -> d_numberOfBytes)) {
//Melder_appendError (U"No memory for dictionary.");
return nullptr;
}
*numberOfBytes = fim -> d_numberOfBytes;
return data;
}
const char * FileInMemorySet_getData (FileInMemorySet me, const char32 *id, long *numberOfBytes) {
*numberOfBytes = 0;
long index = FileInMemorySet_getIndexFromId (me, id);
if (index == 0) {
return nullptr;
}
FileInMemory fim = my at [index];
*numberOfBytes = fim -> d_numberOfBytes;
return fim -> d_data;
}
/* End of file FileInMemory.cpp */
praat-6.0.23/dwsys/FileInMemory.h 0000664 0000000 0000000 00000004660 13023464014 0016575 0 ustar 00root root 0000000 0000000 #ifndef _FileInMemory_h_
#define _FileInMemory_h_
/* FileInMemory.h
*
* Copyright (C) 2011-2012,2015 David Weenink, 2015 Paul Boersma
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Collection.h"
#include "Strings_.h"
Thing_define (FileInMemory, Daata) {
char32 *d_path;
char32 *d_id;
long d_numberOfBytes;
char *d_data;
bool ownData;
void v_copy (Daata data_to)
override;
void v_destroy () noexcept
override;
void v_info ()
override;
};
autoFileInMemory FileInMemory_create (MelderFile file);
autoFileInMemory FileInMemory_createWithData (long numberOfBytes, const char *data, const char32 *path, const char32 *id);
void FileInMemory_dontOwnData (FileInMemory me);
void FileInMemory_setId (FileInMemory me, const char32 *newId);
void FileInMemory_showAsCode (FileInMemory me, const char32 *name, long numberOfBytesPerLine);
Collection_define (FileInMemorySet, SortedSetOf, FileInMemory) {
int d_sortKey;
static int s_compare_name (FileInMemory data1, FileInMemory data2);
static int s_compare_id (FileInMemory data1, FileInMemory data2);
CompareHook v_getCompareHook ()
override { return d_sortKey == 0 ? s_compare_name : s_compare_id; }
};
autoFileInMemorySet FileInMemorySet_createFromDirectoryContents (const char32 *dirpath, const char32 *file);
void FileInMemorySet_showAsCode (FileInMemorySet me, const char32 *name, long numberOfBytesPerLine);
void FileInMemorySet_showOneFileAsCode (FileInMemorySet me, long index, const char32 *name, long numberOfBytesPerLine);
long FileInMemorySet_getIndexFromId (FileInMemorySet me, const char32 *id);
autoStrings FileInMemorySet_to_Strings_id (FileInMemorySet me);
char * FileInMemorySet_getCopyOfData (FileInMemorySet me, const char32 *id, long *numberOfBytes);
const char * FileInMemorySet_getData (FileInMemorySet me, const char32 *id, long *numberOfBytes);
#endif // _FileInMemory_h_
praat-6.0.23/dwsys/Graphics_extensions.cpp 0000664 0000000 0000000 00000021221 13023464014 0020600 0 ustar 00root root 0000000 0000000 /* Graphics_extensions.cpp
*
* Copyright (C) 2012-2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20120727 latest modification
*/
#include "Graphics_extensions.h"
#include "NUM2.h"
#include "Permutation.h"
/*
Draw a box plot of data[1..ndata]. The vertical center line of the plot
is at position 'x'. The rectangle box is 2*w wide, the whisker 2*r.
All drawing outside [ymin, ymax] is clipped.
*/
void Graphics_boxAndWhiskerPlot (Graphics g, double data[], long ndata, double x, double r, double w, double ymin, double ymax) {
int lineType = Graphics_inqLineType (g);
Melder_assert (r > 0.0 && w > 0.0);
if (ndata < 3) {
return;
}
/*
Sort the data (ascending: data[1] <= ... <= data[ndata]).
Get the median (q50) and the upper and lower quartile points
(q25 and q75).
Now q25 and q75 are the lower and upper hinges, respectively.
The fances can be calcultaed from q25 and q75.
The spread is defined as the interquartile range or midrange
|q75 - q25|.
The fences are defined as:
(lower/upper) innerfence = (lower/upper) hinge +/- 1.5 hspread
(lower/upper) outerfence = (lower/upper) hinge +/- 3.0 hspread
*/
NUMsort_d (ndata, data);
if (ymax <= ymin) {
ymin = data[1]; ymax = data[ndata];
}
if (data[1] > ymax || data[ndata] < ymin) {
return;
}
double mean = 0.0;
for (long i = 1; i <= ndata; i++) {
mean += data[i];
}
mean /= ndata;
double q25 = NUMquantile (ndata, data, 0.25);
double q50 = NUMquantile (ndata, data, 0.5);
double q75 = NUMquantile (ndata, data, 0.75);
double hspread = fabs (q75 - q25);
double lowerOuterFence = q25 - 3.0 * hspread;
double lowerInnerFence = q25 - 1.5 * hspread;
double upperInnerFence = q75 + 1.5 * hspread;
double upperOuterFence = q75 + 3.0 * hspread;
/*
Decide whether there are outliers that have to be drawn.
First process data from below (data are sorted).
*/
long i = 1, ie = ndata;
while (i <= ie && data[i] < ymin) {
i++;
}
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
while (i <= ie && data[i] < lowerOuterFence) {
Graphics_text (g, x, data[i], U"o"); i++;
}
while (i <= ie && data[i] < lowerInnerFence) {
Graphics_text (g, x, data[i], U"*"); i++;
}
double lowerWhisker = data[i] < q25 ? data[i] : lowerInnerFence;
if (lowerWhisker > ymax) {
return;
}
// Next process data from above.
i = ndata; ie = i;
while (i >= ie && data[i] > ymax) {
i--;
}
while (i >= ie && data[i] > upperOuterFence) {
Graphics_text (g, x, data[i], U"o"); i--;
}
while (i >= ie && data[i] > upperInnerFence) {
Graphics_text (g, x, data[i], U"*"); i--;
}
double upperWhisker = data[i] > q75 ? data[i] : upperInnerFence;
if (upperWhisker < ymin) {
return;
}
/*
Determine what parts of the "box" have to be drawn within the
range [ymin, ymax].
Horizontal lines first.
*/
double y1 = lowerWhisker;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - r, y1, x + r, y1);
}
y1 = q25;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = q50;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = q75;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = upperWhisker;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - r, y1, x + r, y1);
}
// Extension: draw the mean too.
y1 = mean;
if (ymax > y1 && ymin < y1) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, x - w, y1, x + w, y1);
Graphics_setLineType (g, lineType);
}
// Now process the vertical lines.
y1 = lowerWhisker;
double y2 = q25;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x, y1, x, y2);
}
y1 = q25; y2 = q75;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x - w, y1, x - w, y2);
Graphics_line (g, x + w, y1, x + w, y2);
}
y1 = q75; y2 = upperWhisker;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x, y1, x, y2);
}
}
void Graphics_quantileQuantilePlot (Graphics g, long numberOfQuantiles, double xdata[], long xnumberOfData, double ydata[], long ynumberOfData, double xmin, double xmax, double ymin, double ymax, int labelSize, const char32 *plotLabel) {
int fontSize = Graphics_inqFontSize (g);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (g, labelSize);
autoNUMvector xsorted (NUMvector_copy (xdata, 1, xnumberOfData), 1);
autoNUMvector ysorted (NUMvector_copy (ydata, 1, ynumberOfData), 1);
NUMsort_d (xnumberOfData, xsorted.peek());
NUMsort_d (ynumberOfData, ysorted.peek());
long numberOfData = xnumberOfData < ynumberOfData ? xnumberOfData : ynumberOfData;
numberOfQuantiles = numberOfData < numberOfQuantiles ? numberOfData : numberOfQuantiles;
double un = pow (0.5, 1.0 / numberOfQuantiles);
double u1 = 1.0 - un;
if (xmin == xmax) {
xmin = NUMquantile (xnumberOfData, xsorted.peek(), u1);
xmax = NUMquantile (xnumberOfData, xsorted.peek(), un);
}
if (ymin == ymax) {
ymin = NUMquantile (ynumberOfData, ysorted.peek(), u1);
ymax = NUMquantile (ynumberOfData, ysorted.peek(), un);
}
for (long i = 1; i <= numberOfQuantiles; i++) {
double ui = i == 1 ? u1 : (i == numberOfQuantiles ? un : (i - 0.3175) / (numberOfQuantiles + 0.365));
double qx = NUMquantile (xnumberOfData, xsorted.peek(), ui);
double qy = NUMquantile (ynumberOfData, ysorted.peek(), ui);
if (qx < xmin || qx > xmax || qy < ymin || qy > ymax) continue; // outside area
Graphics_text (g, qx, qy, plotLabel);
}
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, xmin, ymin, xmax, ymax);
Graphics_setLineType (g, Graphics_DRAWN);
Graphics_setFontSize (g, fontSize);
}
void Graphics_matrixAsSquares (Graphics g, double **matrix, long numberOfRows, long numberOfColumns, double zmin, double zmax, double cellSizeFactor, int randomFillOrder) {
long numberOfCells = numberOfRows * numberOfColumns;
autoPermutation p = Permutation_create (numberOfCells);
if (randomFillOrder) {
Permutation_permuteRandomly_inline (p.get(), 1, numberOfCells);
}
double zAbsMax = fabs (zmax) > fabs (zmin) ? fabs (zmax) : fabs (zmin);
Graphics_Colour colour = Graphics_inqColour (g);
double x1WC, x2WC, y1WC, y2WC;
Graphics_inqWindow (g, &x1WC, &x2WC, &y1WC, &y2WC);
double dx = fabs (x2WC - x1WC) / numberOfColumns;
double dy = fabs (y2WC - y1WC) / numberOfRows;
for (long i = 1; i <= numberOfCells; i++) {
long index = Permutation_getValueAtIndex (p.get(), i);
long irow = (index - 1) / numberOfColumns + 1;
long icol = (index - 1) % numberOfColumns + 1;
double z = matrix[irow][icol];
z = z < zmin ? zmin : z;
z = z > zmax ? zmax : z;
double zweight = sqrt (fabs (z) / zAbsMax); // Area length^2)
double xcenter = (icol - 0.5) * dx;
double ycenter = (irow - 0.5) * dy;
double x1 = x1WC + xcenter - zweight * 0.5 * dx * cellSizeFactor;
x1 = x1 < x1WC ? x1WC : x1;
double x2 = x1WC + xcenter + zweight * 0.5 * dx * cellSizeFactor;
x2 = x2 > x2WC ? x2WC : x2;
double y1 = y1WC + ycenter - zweight * 0.5 * dy * cellSizeFactor;
y1 = y1 < y1WC ? y1WC : y1;
double y2 = y1WC + ycenter + zweight * 0.5 * dy * cellSizeFactor;
y2 = y2 > y2WC ? y2WC : y2;
if (z > 0.0) {
Graphics_setColour (g, Graphics_WHITE);
}
Graphics_fillRectangle (g, x1, x2, y1, y2);
Graphics_setColour (g, colour);
Graphics_rectangle (g, x1, x2 , y1, y2);
}
}
void Graphics_lagPlot (Graphics g, double data[], long numberOfData, double xmin, double xmax, long lag, int labelSize, const char32 *plotLabel) {
if (lag < 0 || lag >= numberOfData) {
return;
}
int fontSize = Graphics_inqFontSize (g);
Graphics_setFontSize (g, labelSize);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
// plot x[i] vertically and x[i-lag] horizontally
for (long i = 1; i <= numberOfData - lag; i++) {
double x = data[i + lag], y = data[i];
if (x >= xmin && x <= xmax && y >= xmin && y <= xmax) {
Graphics_text (g, x, y, plotLabel);
}
}
Graphics_setLineType (g, Graphics_DRAWN);
Graphics_setFontSize (g, fontSize);
}
/* End of file Graphics_extensions.cpp */
praat-6.0.23/dwsys/Graphics_extensions.h 0000664 0000000 0000000 00000003265 13023464014 0020255 0 ustar 00root root 0000000 0000000 #ifndef _Graphics_extensions_h_
#define _Graphics_extensions_h_
/* Graphics_extensions.h
*
* Copyright (C) 2012-2014 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Graphics.h"
/**
Draw a box plot of data[1..ndata]. The vertical center line of the plot
is at position 'x'. The rectangle box is 2*w wide, the whisker 2*r.
All drawing outside [ymin, ymax] is clipped.
*/
void Graphics_boxAndWhiskerPlot (Graphics g, double data[], long ndata, double x, double r, double w, double ymin, double ymax);
void Graphics_quantileQuantilePlot (Graphics g, long numberOfQuantiles, double xdata[], long xnumberOfData, double ydata[], long ynumberOfData, double xmin, double xmax, double ymin, double ymax, int labelSize, const char32 *plotLabel);
void Graphics_matrixAsSquares (Graphics g, double **matrix, long numberOfRows, long numberOfColumns, double zmin, double zmax, double cellSizeFactor, int randomFillOrder);
void Graphics_lagPlot (Graphics g, double x[], long numberOfData, double xmin, double xmax, long lag, int labelSize, const char32 *plotLabel);
#endif /* _Graphics_extensions_h_ */
praat-6.0.23/dwsys/Index.cpp 0000664 0000000 0000000 00000007765 13023464014 0015651 0 ustar 00root root 0000000 0000000 /* Index.cpp
*
* Copyright (C) 2005-2011,2015,2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20050724
djmw 20061212 Changed info to Melder_writeLine format.
djmw 20070102
djmw 20071012 Added: o_CAN_WRITE_AS_ENCODING.h
djmw 20110304 Thing_new
*/
#include
#include "Index.h"
#include "NUM2.h"
#include "oo_DESTROY.h"
#include "Index_def.h"
#include "oo_COPY.h"
#include "Index_def.h"
#include "oo_EQUAL.h"
#include "Index_def.h"
#include "oo_CAN_WRITE_AS_ENCODING.h"
#include "Index_def.h"
#include "oo_WRITE_TEXT.h"
#include "Index_def.h"
#include "oo_WRITE_BINARY.h"
#include "Index_def.h"
#include "oo_READ_TEXT.h"
#include "Index_def.h"
#include "oo_READ_BINARY.h"
#include "Index_def.h"
#include "oo_DESCRIPTION.h"
#include "Index_def.h"
const char32 *undefinedClassLabel = U"";
Thing_implement (Index, Daata, 0);
void structIndex :: v_info () {
structDaata :: v_info ();
MelderInfo_writeLine (U"Number of items: ", our numberOfItems);
}
void Index_init (Index me, long numberOfItems) {
if (numberOfItems < 1) {
Melder_throw (U"Cannot create index without items.");
}
my classes = Ordered_create ();
my numberOfItems = numberOfItems;
my classIndex = NUMvector (1, numberOfItems);
}
autoIndex Index_extractPart (Index me, long from, long to) {
try {
if (from == 0) {
from = 1;
}
if (to == 0) {
to = my numberOfItems;
}
if (to < from || from < 1 || to > my numberOfItems) {
Melder_throw (U"Range should be in interval [1,", my numberOfItems, U"].");
}
autoIndex thee = Data_copy (me);
thy numberOfItems = to - from + 1;
for (long i = 1; i <= thy numberOfItems; i ++) {
thy classIndex [i] = my classIndex [from + i - 1];
}
return thee;
} catch (MelderError) {
Melder_throw (me, U": part not extracted.");
}
}
Thing_implement (StringsIndex, Index, 0);
autoStringsIndex StringsIndex_create (long numberOfItems) {
try {
autoStringsIndex me = Thing_new (StringsIndex);
Index_init (me.get(), numberOfItems);
return me;
} catch (MelderError) {
Melder_throw (U"StringsIndex not created.");
}
}
long Index_getClassIndexFromItemIndex (Index me, long itemIndex) {
long result = 0;
if (itemIndex >= 0 && itemIndex <= my numberOfItems) {
result = my classIndex [itemIndex];
}
return result;
}
int StringsIndex_getClassIndexFromClassLabel (StringsIndex me, char32 *klasLabel) {
for (long i = 1; i <= my classes->size; i ++) {
SimpleString ss = (SimpleString) my classes->at [i]; // FIXME cast
if (Melder_equ (ss -> string, klasLabel)) {
return i;
}
}
return 0;
}
const char32 *StringsIndex_getClassLabelFromClassIndex (StringsIndex me, long klasIndex) {
const char32 *result = undefinedClassLabel;
if (klasIndex > 0 && klasIndex <= my classes -> size) {
SimpleString ss = (SimpleString) my classes->at [klasIndex]; // FIXME cast
result = ss -> string;
}
return result;
}
const char32 *StringsIndex_getItemLabelFromItemIndex (StringsIndex me, long itemNumber) {
const char32 *result = undefinedClassLabel;
if (itemNumber > 0 && itemNumber <= my numberOfItems) {
long klas = my classIndex [itemNumber];
SimpleString ss = (SimpleString) my classes->at [klas]; // FIXME cast
result = ss -> string;
}
return result;
}
long StringsIndex_countItems (StringsIndex me, int iclass) {
long sum = 0;
for (long i = 1; i <= my numberOfItems; i ++) {
if (my classIndex [i] == iclass) {
sum ++;
}
}
return sum;
}
/* End of Index.cpp */
praat-6.0.23/dwsys/Index.h 0000664 0000000 0000000 00000003463 13023464014 0015305 0 ustar 00root root 0000000 0000000 #ifndef _Index_h_
#define _Index_h_
/* Index.h
*
* Copyright (C) 2005-2011, 2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
#include "Collection.h"
#include "Index_def.h"
/*
* An Index is a summary of an array of strings.
* It has two parts:
* 1 an OrderedSet of the different strings that occur
* 2 an item array with indexes in this OrderedSet
* Example:
* Suppose we have a Strings with 7 elements/items "u", "o", "a", "u", "u", "o", "a"
* The Index derived from this Strings will have 3 elements in its sorted set "a", "o" and "u"
* The item array with indices will have the following content: 3, 2, 1, 3, 3, 2, 1
*/
void Index_init (Index me, long numberOfElements);
autoIndex Index_extractPart (Index me, long from, long to);
long Index_getClassIndexFromItemIndex (Index me, long itemIndex);
autoStringsIndex StringsIndex_create (long numberOfItems);
int StringsIndex_getClassIndexFromClassLabel (StringsIndex me, char32 *classLabel);
const char32 *StringsIndex_getClassLabelFromClassIndex (StringsIndex me, long classNumber);
const char32 *StringsIndex_getItemLabelFromItemIndex (StringsIndex me, long itemNumber);
long StringsIndex_countItems (StringsIndex me, int iclas);
#endif /* _Index_h_ */
praat-6.0.23/dwsys/Index_def.h 0000664 0000000 0000000 00000002233 13023464014 0016115 0 ustar 00root root 0000000 0000000 /* Index_def.h
*
* Copyright (C) 2005-2006,2015 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20050724
djmw 20060529 Added object version numbers.
*/
#define ooSTRUCT Index
oo_DEFINE_CLASS (Index, Daata)
oo_AUTO_OBJECT (Ordered, 0, classes)
oo_LONG (numberOfItems)
oo_LONG_VECTOR (classIndex, numberOfItems)
#if oo_DECLARING
void v_info ()
override;
#endif
oo_END_CLASS(Index)
#undef ooSTRUCT
#define ooSTRUCT StringsIndex
oo_DEFINE_CLASS (StringsIndex, Index)
oo_END_CLASS(StringsIndex)
#undef ooSTRUCT
/* End of file Index_def.h */
praat-6.0.23/dwsys/Makefile 0000664 0000000 0000000 00000001472 13023464014 0015523 0 ustar 00root root 0000000 0000000 # makefile for library "dwsys".
# David Weenink 20130826
include ../makefile.defs
CPPFLAGS = -I ../stat -I ../num -I ../sys -I ../external/gsl -I ../kar
all: libdwsys.a
OBJECTS = Collection_extensions.o Command.o \
DoublyLinkedList.o Eigen.o FileInMemory.o Graphics_extensions.o Index.o \
NUM2.o NUMhuber.o NUMlapack.o NUMmachar.o \
NUMf2c.o NUMcblas.o NUMclapack.o NUMfft_d.o NUMsort2.o \
NUMmathlib.o NUMstring.o \
Permutation.o Permutation_and_Index.o \
regularExp.o SimpleVector.o Simple_extensions.o \
SVD.o
.PHONY: all clean
all: libdwsys.a
clean:
$(RM) $(OBJECTS)
$(RM) libdwsys.a
libdwsys.a: $(OBJECTS) NUMmachar.o
touch libdwsys.a
rm libdwsys.a
$(AR) cq libdwsys.a $(OBJECTS)
$(RANLIB) libdwsys.a
$(OBJECTS): *.h ../stat/*.h ../num/NUM.h ../sys/*.h ../external/gsl/*.h ../dwsys/*.h ../kar/*.h
praat-6.0.23/dwsys/NUM2.cpp 0000664 0000000 0000000 00000237043 13023464014 0015315 0 ustar 00root root 0000000 0000000 /* NUM2.cpp
*
* Copyright (C) 1993-2016 David Weenink
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This code is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this work. If not, see .
*/
/*
djmw 20020819 GPL header
djmw 20020819 Split nonGLP part off.
djmw 20001109 Changed stop criteria in NUMsvdcmp and NUMtqli.
djmw 20020819 Split into GPL and nonGPL part.
djmw 20021008 Removed SVD_sort.
djmw 20030619 Removed calls to NRC svd-routines.
djmw 20030623 Removed tqli en tred calls.
djmw 20030703 Replaced NUMincompleteBeta with gsl_sf_beta_inc.
djmw 20030710 NUMminimize_brent now also returns the minimum function value.
djmw 20030731 NUMridders: better approximation for small d.
NUMinvFisherQ better approximation for p < 0.5
djmw 20030813 Added NUMmad and NUMstatistics_huber.
djmw 20030825 Replaced gsl_sf_beta_inc with NUMincompleteBeta
pb 20030828 Improvements for invFisherQ, ridders, studentP, studentQ,
invStudentQ, invChiSquareQ: modifications for 'undefined' return values.
djmw 20030830 Corrected a bug in NUMtriangularfilter_amplitude
djmw 20031111 Added NUMdmatrix_transpose, NUMdmatrix_printMatlabForm
djmw 20040105 Added NUMmahalanobisDistance_chi
djmw 20040211 Modified NUMstrings_copyElements: if (form[i]==NULL) then {to[i]= NULL}.
djmw 20040303 Added NUMstring_containsPrintableCharacter.
djmw 20050406 NUMprocrutus->NUMprocrustes
djmw 20060319 NUMinverse_cholesky: calculation of determinant is made optional
djmw 20060517 Added NUMregexp_compile
djmw 20060518 Treat NULL string as empty string in strs_replace_regexp/literal. Don't accept empty search in str_replace_regexp
djmw 20060626 Extra NULL argument for ExecRE.
djmw 20061021 printf expects %ld for 'long int' for 64-bit systems
djmw 20070302 NUMclipLineWithinRectangle
djmw 20070614 updated to version 1.30 of regular expressions.
djmw 20071022 Removed function NUMfvector_moment2.
djmw 20071201 Melder_warning
djmw 20080107 Changed assertion to "npoints > 0" in NUMcosinesTable
djmw 20080110 Corrected some bugs in str_replace_regexp
djmw 20080122 Bug in str_replace_regexp
djmw 20080317 +NUMsinc
pb 20080410 FisherQ from gsl
djmw 20090630 NUMlogNormalP/Q from gsl
djmw 20090707 Rename NUMinverse_cholesky to NUMlowerCholeskyInverse,
+NUMcovarianceFromColumnCentredMatrix, +NUMmultivariateKurtosis
djmw 20100311 +NUMsolveQuadraticEquation
djmw 20100426 replace wcstok by Melder_wcstok
djmw 20101209 removed NUMwcscmp is Melder_wcscmp now
djmw 20110304 Thing_new
djmw 20111110 use autostringvector
djmw 20140318 NUMvector_avevar now returns variance instead of sigma^2
*/
#include
#include "SVD.h"
#include "Eigen.h"
#include "NUMclapack.h"
#ifndef _NUM_h_
#include "NUM.h"
#endif
#include "NUM2.h"
#include "NUMmachar.h"
#include "melder.h"
#include "gsl_randist.h"
#include "gsl_errno.h"
#include "gsl_sf_bessel.h"
#include "gsl_sf_gamma.h"
#include "gsl_sf_erf.h"
#include "gsl_sf_trig.h"
#include "gsl_poly.h"
#include "gsl_cdf.h"
#define my me ->
#undef MAX
#undef MIN
#define MAX(m,n) ((m) > (n) ? (m) : (n))
#define MIN(m,n) ((m) < (n) ? (m) : (n))
#define SIGN(a,b) ((b < 0) ? -fabs(a) : fabs(a))
using namespace std;
struct pdf1_struct {
double p;
double df;
};
struct pdf2_struct {
double p;
double df1;
double df2;
};
void NUMdmatrix_printMatlabForm (double **m, long nr, long nc, const char32 *name) {
long npc = 5;
ldiv_t n = ldiv (nc, npc);
MelderInfo_open ();
MelderInfo_write (name, U"=[");
for (long i = 1; i <= nr; i++) {
for (long j = 1; j <= n.quot; j++) {
for (long k = 1; k <= npc; k++) {
MelderInfo_write (m[i][ (j - 1) *npc + k], (k < npc ? U", " : U""));
}
MelderInfo_write (j < n.quot ? U",\n" : U"");
}
for (long k = 1; k <= n.rem; k++) {
MelderInfo_write (m[i][n.quot * npc + k], (k < n.rem ? U", " : U""));
}
MelderInfo_write (i < nr ? U";\n" : U"];\n");
}
MelderInfo_close ();
}
void NUMcentreRows (double **a, long rb, long re, long cb, long ce) {
for (long i = rb; i <= re; i++) {
double rowmean = 0.0;
for (long j = cb; j <= ce; j++) {
rowmean += a[i][j];
}
rowmean /= (ce - cb + 1);
for (long j = cb; j <= ce; j++) {
a[i][j] -= rowmean;
}
}
}
void NUMcentreColumns (double **a, long rb, long re, long cb, long ce, double *centres) {
for (long j = cb; j <= ce; j++) {
double colmean = 0.0;
for (long i = rb; i <= re; i++) {
colmean += a[i][j];
}
colmean /= (re - rb + 1);
for (long i = rb; i <= re; i++) {
a[i][j] -= colmean;
}
if (centres) {
centres[j - cb + 1] = colmean;
}
}
}
void NUMdoubleCentre (double **a, long rb, long re, long cb, long ce) {
NUMcentreRows (a, rb, re, cb, ce);
NUMcentreColumns (a, rb, re, cb, ce, NULL);
}
void NUMnormalizeColumns (double **a, long nr, long nc, double norm) {
Melder_assert (norm > 0);
for (long j = 1; j <= nc; j++) {
double s = 0.0;
for (long i = 1; i <= nr; i++) {
s += a[i][j] * a[i][j];
}
if (s <= 0.0) {
continue;
}
s = sqrt (norm / s);
for (long i = 1; i <= nr; i++) {
a[i][j] *= s;
}
}
}
void NUMnormalizeRows (double **a, long nr, long nc, double norm) {
Melder_assert (norm > 0);
for (long i = 1; i <= nr; i++) {
double s = 0.0;
for (long j = 1; j <= nc; j++) {
s += a[i][j] * a[i][j];
}
if (s <= 0.0) {
continue;
}
s = sqrt (norm / s);
for (long j = 1; j <= nc; j++) {
a[i][j] *= s;
}
}
}
void NUMnormalize (double **a, long nr, long nc, double norm) {
Melder_assert (norm > 0);
double sq = 0.0;
for (long i = 1; i <= nr; i++) {
for (long j = 1; j <= nc; j++) {
sq += a[i][j] * a[i][j];
}
}
if (sq <= 0.0) {
return;
}
norm = sqrt (norm / sq);
for (long i = 1; i <= nr; i++) {
for (long j = 1; j <= nc; j++) {
a[i][j] *= norm;
}
}
}
void NUMstandardizeColumns (double **a, long rb, long re, long cb, long ce) {
long n = re - rb + 1;
if (n < 2) {
return;
}
for (long j = cb; j <= ce; j++) {
double ep = 0.0, s = 0.0, sdev, var = 0.0;
for (long i = rb; i <= re; i++) {
s += a[i][j];
}
double ave = s / n;
for (long i = rb; i <= re; i++) {
s = a[i][j] - ave;
ep += s;
var += s * s;
}
if (ave != 0.0) {
for (long i = rb; i <= re; i++) {
a[i][j] -= ave;
}
}
if (var > 0.0) {
var = (var - ep * ep / n) / (n - 1);
sdev = sqrt (var);
for (long i = rb; i <= re; i++) {
a[i][j] /= sdev;
}
}
}
}
void NUMstandardizeRows (double **a, long rb, long re, long cb, long ce) {
long n = ce - cb + 1;
if (n < 2) {
return;
}
for (long i = rb; i <= re; i++) {
double ep = 0.0, s = 0.0, sdev, var = 0.0;
for (long j = cb; j <= ce; j++) {
s += a[i][j];
}
double ave = s / n;
for (long j = cb; j <= ce; j++) {
s = a[i][j] - ave;
ep += s;
var += s * s;
}
if (ave != 0.0) {
for (long j = cb; j <= ce; j++) {
a[i][j] -= ave;
}
}
if (var > 0.0) {
var = (var - ep * ep / n) / (n - 1);
sdev = sqrt (var);
for (long j = cb; j <= ce; j++) {
a[i][j] /= sdev;
}
}
}
}
void NUMaverageColumns (double **a, long rb, long re, long cb, long ce) {
long n = re - rb + 1;
if (n < 2) {
return;
}
for (long j = cb; j <= ce; j++) {
double ave = 0.0;
for (long i = rb; i <= re; i++) {
ave += a[i][j];
}
ave /= n;
for (long i = rb; i <= re; i++) {
a[i][j] = ave;
}
}
}
void NUMvector_avevar (double *a, long n, double *p_mean, double *p_var) {
double mean = 0.0;
for (long i = 1; i <= n; i++) {
mean += a[i];
}
mean /= n;
if (p_mean) {
*p_mean = mean;
}
if (p_var) {
double eps = 0.0, var = 0.0;
if (n > 1) {
for (long i = 1; i <= n; i++) {
double s = a[i] - mean;
eps += s;
var += s * s;
}
var = (var - eps * eps / n);
} else {
var = NUMundefined;
}
*p_var = var;
}
}
void NUMcolumn_avevar (double **a, long nr, long nc, long icol, double *p_mean, double *p_var) {
Melder_assert (nr > 0 && nc > 0 && icol > 0 && icol <= nc);
double mean = 0.0;
for (long i = 1; i <= nr; i++) {
mean += a[i][icol];
}
mean /= nr;
if (p_mean) {
*p_mean = mean;
}
if (p_var) {
double eps = 0.0, var = 0.0;
if (nr > 1) {
for (long i = 1; i <= nr; i++) {
double s = a[i][icol] - mean;
eps += s;
var += s * s;
}
var = (var - eps * eps / nr);
} else {
var = NUMundefined;
}
*p_var = var;
}
}
void NUMcolumn2_avevar (double **a, long nr, long nc, long icol1, long icol2, double *p_mean1, double *p_var1, double *p_mean2, double *p_var2, double *p_covar) {
Melder_assert (icol1 > 0 && icol1 <= nc && icol2 > 0 && icol2 <= nc);
double mean1 = 0.0, mean2 = 0.0;
for (long i = 1; i <= nr; i++) {
mean1 += a[i][icol1];
mean2 += a[i][icol2];
}
mean1 /= nr;
mean2 /= nr;
if (p_mean1) {
*p_mean1 = mean1;
}
if (p_mean2) {
*p_mean2 = mean2;
}
if (p_var1 || p_var2 || p_covar) {
double eps1 = 0.0, eps2 = 0.0, var1 = 0.0, var2 = 0.0, covar = 0.0;
if (nr > 1) {
for (long i = 1; i <= nr; i++) {
double s1 = a[i][icol1] - mean1;
double s2 = a[i][icol2] - mean2;
eps1 += s1;
eps2 += s2;
var1 += s1 * s1;
var2 += s2 * s2;
covar += s1 * s2;
}
var1 = (var1 - eps1 * eps1 / nr);
var2 = (var2 - eps2 * eps2 / nr);;
} else {
var1 = NUMundefined;
var2 = NUMundefined;
covar = NUMundefined;
}
if (p_var1) {
*p_var1 = var1;
}
if (p_var2) {
*p_var2 = var2;
}
if (icol1 == icol2) {
covar = var1;
}
if (p_covar) {
*p_covar = covar;
}
}
}
void NUMvector_smoothByMovingAverage (double *xin, long n, long nwindow, double *xout) {
// simple averaging, out of bound values are zero
for (long i = 1; i <= n; i++) {
long jfrom = i - nwindow / 2, jto = i + nwindow / 2;
if ((nwindow % 2) == 0) {
jto--;
}
jfrom = jfrom < 1 ? 1 : jfrom;
jto = jto > n ? n : jto;
xout[i] = 0;
for (long j = jfrom; j <= jto; j++) {
xout[i] += xin[j];
}
xout[i] /= jto - jfrom + 1;
}
}
void NUMcovarianceFromColumnCentredMatrix (double **x, long nrows, long ncols, long ndf, double **covar) {
if (ndf < 0 || nrows - ndf < 1 || covar == 0) {
Melder_throw (U"Invalid arguments.");
}
for (long i = 1; i <= ncols; i++) {
for (long j = i; j <= ncols; j++) {
double sum = 0.0;
for (long k = 1; k <= nrows; k++) {
sum += x[k][i] * x[k][j];
}
covar[i][j] = covar[j][i] = sum / (nrows - ndf);
}
}
}
double NUMmultivariateKurtosis (double **x, long nrows, long ncols, int method) {
double kurt = NUMundefined;
if (nrows < 5) {
return kurt;
}
autoNUMvector mean (1, ncols);
autoNUMmatrix covar (1, ncols, 1, ncols);
NUMcentreColumns (x, 1, nrows, 1, ncols, mean.peek());
NUMcovarianceFromColumnCentredMatrix (x, nrows, ncols, 1, covar.peek());
if (method == 1) { // Schott (2001, page 33)
kurt = 0.0;
for (long l = 1; l <= ncols; l++) {
double zl = 0.0, wl, sll2 = covar[l][l] * covar[l][l];
for (long j = 1; j <= nrows; j++) {
double d = x[j][l] - mean[l], d2 = d * d;
zl += d2 * d2;
}
zl = (zl - 6.0 * sll2) / (nrows - 4);
wl = (sll2 - zl / nrows) * nrows / (nrows - 1);
kurt += zl / wl;
}
kurt = kurt / (3 * ncols) - 1.0;
}
return kurt;
}
void eigenSort (double d[], double **v, long n, int sort) {
if (sort == 0) {
return;
}
for (long i = 1; i < n; i++) {
long k;
double temp = d[k = i];
if (sort > 0) {
for (long j = i + 1; j <= n; j++) {
if (d[j] > temp) {
temp = d[k = j];
}
}
} else {
for (long j = i + 1; j <= n; j++) {
if (d[j] < temp) {
temp = d[k = j];
}
}
}
if (k != i) {
d[k] = d[i];
d[i] = temp;
if (v) {
for (long j = 1; j <= n; j++) {
temp = v[j][i];
v[j][i] = v[j][k];
v[j][k] = temp;
}
}
}
}
}
int NUMstrcmp (const char *s1, const char *s2) {
if (! s1 || s1[0] == '\0') {
if (s2 && s2[0] != '\0') {
return -1;
} else {
return 0;
}
} else {
if (! s2) {
return +1;
} else {
return strcmp (s1, s2);
}
}
}
void NUMlocate_f (float *xx, long n, float x, long *index) {
long ju = n + 1, jm, jl = 0;
int ascend = xx[n] >= xx[1];
while (ju - jl > 1) {
jm = (ju + jl) / 2;
if ( (x >= xx[jm]) == ascend) {
jl = jm;
} else {
ju = jm;
}
}
if (x == xx[1]) {
*index = 1;
} else if (x == xx[n]) {
*index = n - 1;
} else {
*index = jl;
}
}
void NUMlocate (double *xx, long n, double x, long *index) {
long ju = n + 1, jm, jl = 0;
int ascend = xx[n] >= xx[1];
while (ju - jl > 1) {
jm = (ju + jl) / 2;
if ( (x >= xx[jm]) == ascend) {
jl = jm;
} else {
ju = jm;
}
}
if (x == xx[1]) {
*index = 1;
} else if (x == xx[n]) {
*index = n - 1;
} else {
*index = jl;
}
}
/*
The following algorithm for monotone regession is on the average
3.5 times faster than
Kruskal's algorithm for monotone regression (and much simpler).
Regression is ascending
*/
void NUMmonotoneRegression (const double x[], long n, double xs[]) {
double xt = NUMundefined; // Only to stop gcc complaining "may be used unitialized"
for (long i = 1; i <= n; i++) {
xs[i] = x[i];
}
for (long i = 2; i <= n; i++) {
if (xs[i] >= xs[i - 1]) {
continue;
}
double sum = xs[i];
long nt = 1;
for (long j = 1; j <= i - 1; j++) {
sum += xs[i - j]; nt++;
xt = sum / nt; // i >= 2 -> xt always gets a value
if (j < i - 1 && xt >= xs[i - j - 1]) {
break;
}
}
for (long j = i - nt + 1; j <= i; j++) {
xs[j] = xt;
}
}
}
double NUMvector_getNorm1 (const double v[], long n) {
double norm = 0;
for (long i = 1; i <= n; i++) {
norm += fabs (v[i]);
}
return norm;
}
double NUMvector_getNorm2 (const double v[], long n) {
double norm = 0.0;
for (long i = 1; i <= n; i++) {
norm += v[i] * v[i];
}
return sqrt (norm);
}
double NUMvector_normalize1 (double v[], long n) {
double norm = 0.0;
for (long i = 1; i <= n; i++) {
norm += fabs (v[i]);
}
if (norm > 0.0) {
for (long i = 1; i <= n; i++) {
v[i] /= norm;
}
}
return norm;
}
double NUMvector_normalize2 (double v[], long n) {
double norm = 0;
for (long i = 1; i <= n; i++) {
norm += v[i] * v[i];
}
norm = sqrt (norm);
if (norm > 0) {
for (long i = 1; i <= n; i++) {
v[i] /= norm;
}
}
return norm;
}
#undef TINY
void NUMcholeskySolve (double **a, long n, double d[], double b[], double x[]) {
for (long i = 1; i <= n; i++) { /* Solve L.y=b */
double sum = b[i];
for (long k = i - 1; k >= 1; k--) {
sum -= a[i][k] * x[k];
}
x[i] = sum / d[i];
}
for (long i = n; i >= 1; i--) { /* Solve L^T.x=y */
double sum = x[i];
for (long k = i + 1; k <= n; k++) {
sum -= a[k][i] * x[k];
}
x[i] = sum / d[i];
}
}
void NUMdeterminant_cholesky (double **a, long n, double *p_lnd) {
// Save the diagonal
autoNUMvector d (1, n);
for (long i = 1; i <= n; i++) {
d[i] = a[i][i];
}
// Cholesky decomposition in lower, leave upper intact
char uplo = 'U';
long lda = n, info;
NUMlapack_dpotf2 (&uplo, &n, &a[1][1], &lda, &info);
if (info != 0) {
Melder_throw (U"Cannot determine Cholesky decomposition.");
}
// Determinant from diagonal, restore diagonal
double lnd = 0.0;
for (long i = 1; i <= n; i++) {
lnd += log (a[i][i]);
a[i][i] = d[i];
}
lnd *= 2.0; // because A = L . L' TODO
// Restore lower from upper */
for (long i = 1; i < n; i++) {
for (long j = i + 1; j <= n; j++) {
a[j][i] = a[i][j];
}
}
if (p_lnd) {
*p_lnd = lnd;
}
}
void NUMlowerCholeskyInverse (double **a, long n, double *lnd) {
char uplo = 'U', diag = 'N';
long info;
// Cholesky decomposition in lower, leave upper intact
// Fortran storage -> use uplo='U' to get 'L'.
(void) NUMlapack_dpotf2 (&uplo, &n, &a[1][1], &n, &info);
if (info != 0) {
Melder_throw (U"dpotf2 fails.");
}
// Determinant from diagonal, diagonal is now sqrt (a[i][i]) !
if (lnd) {
*lnd = 0.0;
for (long i = 1; i <= n; i++) {
*lnd += log (a[i][i]);
}
*lnd *= 2.0; /* because A = L . L' */
}
// Get the inverse */
(void) NUMlapack_dtrtri (&uplo, &diag, &n, &a[1][1], &n, &info);
if (info != 0) {
Melder_throw (U"dtrtri fails.");
}
}
double **NUMinverseFromLowerCholesky (double **m, long n) {
autoNUMmatrix r (1, n, 1, n);
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= i; j++) {
double sum = 0;
for (long k = i; k <= n; k++) {
sum += m[k][i] * m[k][j];
}
r[i][j] = r[j][i] = sum;
}
}
return r.transfer();
}
double NUMmahalanobisDistance_chi (double **linv, double *v, double *m, long nr, long n) {
double chisq = 0;
if (nr == 1) { // 1xn matrix
for (long j = 1; j <= n; j++) {
double t = linv[1][j] * (v[j] - m[j]);
chisq += t * t;
}
} else { // nxn matrix
for (long i = n; i > 0; i--) {
double t = 0.0;
for (long j = 1; j <= i; j++) {
t += linv[i][j] * (v[j] - m[j]);
}
chisq += t * t;
}
}
return chisq;
}
double NUMtrace (double **a, long n) {
double trace = 0.0;
for (long i = 1; i <= n; i++) {
trace += a[i][i];
}
return trace;
}
double NUMtrace2 (double **a1, double **a2, long n) {
double trace = 0.0;
for (long i = 1; i <= n; i++) {
for (long k = 1; k <= n; k++) {
trace += a1[i][k] * a2[k][i];
}
}
return trace;
}
void NUMeigensystem (double **a, long n, double **evec, double eval[]) {
autoEigen me = Thing_new (Eigen);
Eigen_initFromSymmetricMatrix (me.get(), a, n);
if (evec) {
NUMmatrix_copyElements (my eigenvectors, evec, 1, n, 1, n);
}
if (eval) {
NUMvector_copyElements (my eigenvalues, eval, 1, n);
}
}
void NUMdominantEigenvector (double **mns, long n, double *q, double *p_lambda, double tolerance) {
autoNUMvector z (1, n);
double lambda0, lambda = 0.0;
for (long k = 1; k <= n; k++) {
for (long l = 1; l <= n; l++) {
lambda += q[k] * mns[k][l] * q[l];
}
}
if (lambda == 0.0) {
Melder_throw (U"Zero matrices ??");
}
long iter = 0;
do {
double znorm2 = 0.0;
for (long l = 1; l <= n; l++) {
z[l] = 0.0;
for (long k = 1; k <= n; k++) {
z[l] += mns[l][k] * q[k];
}
}
for (long k = 1; k <= n; k++) {
znorm2 += z[k] * z[k];
}
znorm2 = sqrt (znorm2);
for (long k = 1; k <= n; k++) {
q[k] = z[k] / znorm2;
}
lambda0 = lambda;
lambda = 0.0;
for (long k = 1; k <= n; k++) {
for (long l = 1; l <= n; l++) {
lambda += q[k] * mns[k][l] * q[l];
}
}
} while (fabs (lambda - lambda0) > tolerance || ++iter < 30);
if (p_lambda) {
*p_lambda = lambda;
}
}
void NUMprincipalComponents (double **a, long n, long nComponents, double **pc) {
autoNUMmatrix evec (1, n, 1, n);
NUMeigensystem (a, n, evec.peek(), NULL);
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= nComponents; j++) {
double s = 0.0;
for (long k = 1; k <= n; k++) {
s += a[k][i] * evec[k][j]; /* times sqrt(eigenvalue) ?? */
}
pc[i][j] = s;
}
}
}
void NUMdmatrix_projectRowsOnEigenspace (double **data, long numberOfRows, long from_col, double **eigenvectors, long numberOfEigenvectors, long dimension, double **projection, long to_col) {
/* Input:
* data[numberOfRows, from_col - 1 + my dimension]
* contains the 'numberOfRows' vectors to be projected on the eigenspace.
* eigenvectors [numberOfEigenvectors][dimension]
* the eigenvectors stored as rows
* Input/Output
* projection [numberOfRows, to_colbegin - 1 + numberOfEigenvectors]
* the projected vectors from 'data'
*
* Project (part of) the vectors in matrix 'data' along the 'numberOfEigenvectors' eigenvectors into the matrix 'projection'.
*/
from_col = from_col <= 0 ? 1 : from_col;
to_col = to_col <= 0 ? 1 : to_col;
for (long irow = 1; irow <= numberOfRows; irow ++) {
for (long icol = 1; icol <= numberOfEigenvectors; icol ++) {
double r = 0.0;
for (long k = 1; k <= dimension; k ++) {
r += eigenvectors [icol] [k] * data [irow] [from_col + k - 1];
}
projection [irow] [to_col + icol - 1] = r;
}
}
}
void NUMdmatrix_projectColumnsOnEigenspace (double **data, long numberOfColumns, double **eigenvectors, long numberOfEigenvectors, long dimension, double **projection) {
/* Input:
* data[dimension, numberOfColumns]
* contains the column vectors to be projected on the eigenspace.
* eigenvectors [numberOfEigenvectors][dimension]
* the eigenvectors stored as rows
* Input/Output
* projection [numberOfEigenvectors, numberOfColumns]
* the projected vectors from 'data'
*
* Project the columnvectors in matrix 'data' along the 'numberOfEigenvectors' eigenvectors into the matrix 'projection'.
*/
for (long icol = 1; icol <= numberOfColumns; icol++) {
for (long irow = 1; irow <= numberOfEigenvectors; irow++) {
double r = 0.0;
for (long k = 1; k <= dimension; k ++) {
r += eigenvectors [irow] [k] * data [k] [icol];
}
projection [irow][icol] = r;
}
}
}
void NUMdmatrix_into_principalComponents (double **m, long nrows, long ncols, long numberOfComponents, double **pc) {
Melder_assert (numberOfComponents > 0 && numberOfComponents <= ncols);
autoNUMmatrix mc (NUMmatrix_copy (m, 1, nrows, 1, ncols), 1, 1);
/*NUMcentreColumns (mc, nrows, ncols);*/
autoSVD svd = SVD_create_d (mc.peek(), nrows, ncols);
for (long i = 1; i <= nrows; i++) {
for (long j = 1; j <= numberOfComponents; j++) {
pc[i][j] = 0.0;
for (long k = 1; k <= ncols; k++) {
pc[i][j] += svd -> v[k][j] * m[i][k];
}
}
}
}
void NUMpseudoInverse (double **y, long nr, long nc, double **yinv, double tolerance) {
autoSVD me = SVD_create_d (y, nr, nc);
(void) SVD_zeroSmallSingularValues (me.get(), tolerance);
for (long i = 1; i <= nc; i++) {
for (long j = 1; j <= nr; j++) {
double s = 0.0;
for (long k = 1; k <= nc; k++) {
if (my d[k] != 0.0) {
s += my v[i][k] * my u[j][k] / my d[k];
}
}
yinv[i][j] = s;
}
}
}
long NUMsolveQuadraticEquation (double a, double b, double c, double *x1, double *x2) {
return gsl_poly_solve_quadratic (a, b, c, x1, x2);
}
void NUMsolveEquation (double **a, long nr, long nc, double *b, double tolerance, double *result) {
double tol = tolerance > 0 ? tolerance : NUMfpp -> eps * nr;
if (nr <= 0 || nc <= 0) {
Melder_throw (U"Negative dimensions");
}
autoSVD me = SVD_create_d (a, nr, nc);
SVD_zeroSmallSingularValues (me.get(), tol);
SVD_solve (me.get(), b, result);
}
void NUMsolveEquations (double **a, long nr, long nc, double **b, long ncb, double tolerance, double **x) {
double tol = tolerance > 0 ? tolerance : NUMfpp -> eps * nr;
if (nr <= 0 || nc <= 0) {
Melder_throw (U"Negative dimensions");
}
autoSVD me = SVD_create_d (a, nr, nc);
autoNUMvector bt (1, nr + nc);
double *xt = & bt[nr];
SVD_zeroSmallSingularValues (me.get(), tol);
for (long k = 1; k <= ncb; k++) {
for (long j = 1; j <= nr; j++) {
bt[j] = b[j][k];
}
SVD_solve (me.get(), bt.peek(), xt);
for (long j = 1; j <= nc; j++) {
x[j][k] = xt[j];
}
}
}
void NUMsolveNonNegativeLeastSquaresRegression (double **m, long nr, long nc, double *d, double tol, long itermax, double *b) {
double difsq, difsqp = 0.0;
for (long iter = 1; iter <= itermax; iter++) {
// Fix all weights except b[j]
for (long j = 1; j <= nc; j++) {
double mjr = 0.0, mjmj = 0.0;
for (long i = 1; i <= nr; i++) {
double ri = d[i], mij = m[i][j];
for (long l = 1; l <= nc; l++) {
if (l != j) {
ri -= b[l] * m[i][l];
}
}
mjr += mij * ri;
mjmj += mij * mij;
}
b[j] = mjr / mjmj;
if (b[j] < 0.0) {
b[j] = 0.0;
}
}
// Calculate t(b) and compare with previous result.
difsq = 0.0;
for (long i = 1; i <= nr; i++) {
double dmb = d[i];
for (long j = 1; j <= nc; j++) {
dmb -= m[i][j] * b[j];
}
difsq += dmb * dmb;
}
if (fabs (difsq - difsqp) / difsq < tol) {
break;
}
difsqp = difsq;
}
}
struct nr_struct {
double *y, *delta;
};
/*
f (lambda) = sum (y[i]^2 delta[i] / (delta[i]-lambda)^2, i=1..3)
f'(lambda) = 2 * sum (y[i]^2 delta[i] / (delta[i]-lambda)^3, i=1..3)
*/
static void nr_func (double x, double *f, double *df, void *data) {
struct nr_struct *me = (struct nr_struct *) data;
*f = *df = 0.0;
for (long i = 1; i <= 3; i++) {
double t1 = (my delta[i] - x);
double t2 = my y[i] / t1;
double t3 = t2 * t2 * my delta[i];
*f += t3;
*df += t3 * 2 / t1;
}
}
void NUMsolveConstrainedLSQuadraticRegression (double **o, const double d[], long n, double *alpha, double *gamma) {
long n3 = 3, info;
double eps = 1e-5, t1, t2, t3;
autoNUMmatrix ftinv (1, n3, 1, n3);
autoNUMmatrix b (1, n3, 1, n3);
autoNUMmatrix g (1, n3, 1, n3);
autoNUMmatrix p (1, n3, 1, n3);
autoNUMvector delta (1, n3);
autoNUMmatrix ftinvp (1, n3, 1, n3);
autoNUMmatrix ptfinv (1, n3, 1, n3);
autoNUMvector otd (1, n3);
autoNUMmatrix ptfinvc (1, n3, 1, n3);
autoNUMvector y (1, n3);
autoNUMvector w (1, n3);
autoNUMvector chi (1, n3);
autoNUMvector diag (1, n3);
// Construct O'.O [1..3][1..3].
for (long i = 1; i <= n3; i++) {
for (long j = 1; j <= n3; j++) {
for (long k = 1; k <= n; k++) {
ftinv[i][j] += o[k][i] * o[k][j];
}
}
}
// Get lower triangular decomposition from O'.O and
// get F'^-1 from it (eq. (2)) (F^-1 not done ????)
char uplo = 'U';
(void) NUMlapack_dpotf2 (&uplo, &n3, &ftinv[1][1], &n3, &info);
if (info != 0) {
Melder_throw (U"dpotf2 fails.");
}
ftinv[1][2] = ftinv[1][3] = ftinv[2][3] = 0.0;
// Construct G and its eigen-decomposition (eq. (4,5))
// Sort eigenvalues (& eigenvectors) ascending.
b[3][1] = b[1][3] = -0.5; b[2][2] = 1.0;
// G = F^-1 B (F')^-1 (eq. 4)
for (long i = 1; i <= 3; i++) {
for (long j = 1; j <= 3; j++) {
for (long k = 1; k <= 3; k++) {
if (ftinv[k][i] != 0.0) {
for (long l = 1; l <= 3; l++) {
g[i][j] += ftinv[k][i] * b[k][l] * ftinv[l][j];
}
}
}
}
}
// G's eigen-decomposition with eigenvalues (assumed ascending). (eq. 5)
NUMeigensystem (g.peek(), 3, p.peek(), delta.peek());
NUMsort_d (3, delta.peek()); /* ascending */
// Construct y = P'.F'.O'.d ==> Solve (F')^-1 . P .y = (O'.d) (page 632)
// Get P'F^-1 from the transpose of (F')^-1 . P
for (long i = 1; i <= 3; i++) {
for (long j = 1; j <= 3; j++) {
if (ftinv[i][j] != 0.0) {
for (long k = 1; k <= 3; k++) {
ftinvp[i][k] += ftinv[i][j] * p[3 + 1 - j][k]; /* is sorted desc. */
}
}
}
for (long k = 1; k <= n; k++) {
otd[i] += o[k][i] * d[k];
}
}
for (long i = 1; i <= 3; i++) {
for (long j = 1; j <= 3; j++) {
ptfinvc[j][i] = ptfinv[j][i] = ftinvp[i][j];
}
}
NUMsolveEquation (ftinvp.peek(), 3, 3, otd.peek(), 1e-6, y.peek());
// The solution (3 cases)
if (fabs (y[1]) < eps) {
// Case 1: page 633
t2 = y[2] / (delta[2] - delta[1]);
t3 = y[3] / (delta[3] - delta[1]);
/* +- */
w[1] = sqrt (- delta[1] * (t2 * t2 * delta[2] + t3 * t3 * delta[3]));
w[2] = t2 * delta[2];
w[3] = t3 * delta[3];
NUMsolveEquation (ptfinv.peek(), 3, 3, w.peek(), 1e-6, chi.peek());
w[1] = -w[1];
if (fabs (chi[3] / chi[1]) < eps) {
NUMsolveEquation (ptfinvc.peek(), 3, 3, w.peek(), 1e-6, chi.peek());
}
} else if (fabs (y[2]) < eps) {
// Case 2: page 633
t1 = y[1] / (delta[1] - delta[2]);
t3 = y[3] / (delta[3] - delta[2]);
w[1] = t1 * delta[1];
if ( (delta[2] < delta[3] && (t2 = (t1 * t1 * delta[1] + t3 * t3 * delta[3])) < eps)) {
w[2] = sqrt (- delta[2] * t2); /* +- */
w[3] = t3 * delta[3];
NUMsolveEquation (ptfinv.peek(), 3, 3, w.peek(), 1e-6, chi.peek());
w[2] = -w[2];
if (fabs (chi[3] / chi[1]) < eps) {
NUMsolveEquation (ptfinvc.peek(), 3, 3, w.peek(), 1e-6, chi.peek());
}
} else if (((delta[2] < delta[3] + eps) || (delta[2] > delta[3] - eps)) && fabs (y[3]) < eps) {
// choose one value for w[2] from an infinite number
w[2] = w[1];
w[3] = sqrt (- t1 * t1 * delta[1] * delta[2] - w[2] * w[2]);
NUMsolveEquation (ptfinv.peek(), 3, 3, w.peek(), 1e-6, chi.peek());
}
} else {
// Case 3: page 634 use Newton-Raphson root finder
struct nr_struct me;
double xlambda, eps2 = (delta[2] - delta[1]) * 1e-6;
me.y = y.peek(); me.delta = delta.peek();
NUMnrbis (nr_func, delta[1] + eps, delta[2] - eps2, & me, & xlambda);
for (long i = 1; i <= 3; i++) {
w[i] = y[i] / (1 - xlambda / delta[i]);
}
NUMsolveEquation (ptfinv.peek(), 3, 3, w.peek(), 1e-6, chi.peek());
}
*alpha = chi[1]; *gamma = chi[3];
}
/*
f (b) = delta - b / (2 alpha) - sum (x[i]^2 / (c[i] - b)^2, i=1..n)
f'(b) = - 1 / (2 alpha) + 2 * sum (x[i]^2 / (c[i] - b)^3, i=1..n)
*/
struct nr2_struct {
long m;
double delta, alpha, *x, *c;
};
static void nr2_func (double b, double *f, double *df, void *data) {
struct nr2_struct *me = (struct nr2_struct *) data;
*df = - 0.5 / my alpha;
*f = my delta + *df * b;
for (long i = 1; i <= my m; i++) {
double c1 = (my c[i] - b);
double c2 = my x[i] / c1;
double c2sq = c2 * c2;
*f -= c2sq; *df += 2 * c2sq / c1;
}
}
void NUMsolveWeaklyConstrainedLinearRegression (double **f, long n, long m, double phi[], double alpha, double delta, double t[]) {
autoNUMmatrix u (1, m, 1, m);
autoNUMvector c (1, m);
autoNUMvector x (1, n);
autoNUMvector indx (1, m);
for (long j = 1; j <= m; j++) {
t[j] = 0.0;
}
autoSVD svd = SVD_create_d (f, n, m);
if (alpha == 0.0) {
SVD_solve (svd.get(), phi, t); // standard least squares
}
// Step 1: Compute U and C from the eigendecomposition F'F = UCU'
// Evaluate q, the multiplicity of the smallest eigenvalue in C
double *sqrtc = svd -> d;
double **ut = svd -> v;
NUMindexx (sqrtc, m, indx.peek());
for (long j = m; j > 0; j--) {
double tmp = sqrtc [indx[j]];
c[m - j + 1] = tmp * tmp;
for (long k = 1; k <= m; k++) {
u[m - j + 1][k] = ut [indx[j]] [k];
}
}
long q = 1;
double tol = 1e-6;
while (q < m && (c[m - q] - c[m]) < tol) {
q++;
}
// step 2: x = U'F'phi
for (long i = 1; i <= m; i++) {
for (long j = 1; j <= m; j++) {
for (long k = 1; k <= n; k++) {
x[i] += u[j][i] * f[k][j] * phi[k];
}
}
}
// step 3:
struct nr2_struct me;
me.m = m;
me.delta = delta;
me.alpha = alpha;
me.x = x.peek();
me.c = c.peek();
double xqsq = 0.0;
for (long j = m - q + 1; j <= m; j++) {
xqsq += x[j] * x[j];
}
long r = m;
if (xqsq < tol) { /* xqsq == 0 */
double fm, df;
r = m - q;
me.m = r;
nr2_func (c[m], &fm, &df, & me);
if (fm >= 0.0) { /* step 3.b1 */
x[r + 1] = sqrt (fm);
for (long j = 1; j <= r; j++) {
x[j] /= c[j] - c[m];
}
for (long j = 1; j <= r + 1; j++) {
for (long k = 1; k <= r + 1; k++) {
t[j] += u[j][k] * x[k];
}
}
return;
}
// else continue with r = m - q
}
// step 3a & 3b2, determine interval lower bound for Newton-Raphson root finder
double xCx = 0.0;
for (long j = 1; j <= r; j++) {
xCx += x[j] * x[j] / c[j];
}
double b0, bmin = delta > 0.0 ? - xCx / delta : -2.0 * sqrt (alpha * xCx);
double eps = (c[m] - bmin) * tol;
// find the root of d(psi(b)/db in interval (bmin, c[m])
NUMnrbis (nr2_func, bmin + eps, c[m] - eps, & me, & b0);
for (long j = 1; j <= r; j++) {
for (long k = 1; k <= r; k++) {
t[j] += u[j][k] * x[k] / (c[k] - b0);
}
}
}
void NUMProcrustes (double **x, double **y, long nPoints, long nDimensions, double **t, double v[], double *s) {
bool orthogonal = ! v || ! s; // else similarity transform
autoNUMmatrix c (1, nDimensions, 1, nDimensions);
autoNUMmatrix yc (1, nPoints, 1, nDimensions);
NUMmatrix_copyElements (y, yc.peek(), 1, nPoints, 1, nDimensions);
/*
Reference: Borg & Groenen (1997), Modern multidimensional scaling,
Springer
1. Calculate C = X'JY (page 346) for similarity transform
else X'Y for othogonal (page 341)
JY amounts to centering the columns of Y.
*/
if (! orthogonal) {
NUMcentreColumns (yc.peek(), 1, nPoints, 1, nDimensions, NULL);
}
for (long i = 1; i <= nDimensions; i++) {
for (long j = 1; j <= nDimensions; j++) {
for (long k = 1; k <= nPoints; k++) {
c[i][j] += x[k][i] * yc[k][j];
}
}
}
// 2. Decompose C by SVD: C = PDQ' (SVD attribute is Q instead of Q'!)
autoSVD svd = SVD_create_d (c.peek(), nDimensions, nDimensions);
double trace = 0.0;
for (long i = 1; i <= nDimensions; i++) {
trace += svd -> d[i];
}
if (trace == 0.0) {
Melder_throw (U"NUMProcrustes: degenerate configuration(s).");
}
// 3. T = QP'
for (long i = 1; i <= nDimensions; i++) {
for (long j = 1; j <= nDimensions; j++) {
t[i][j] = 0.0;
for (long k = 1; k <= nDimensions; k++) {
t[i][j] += svd -> v[i][k] * svd -> u[j][k];
}
}
}
if (! orthogonal) {
autoNUMmatrix xc (1, nPoints, 1, nDimensions);
NUMmatrix_copyElements (x, xc.peek(), 1, nPoints, 1, nDimensions);
autoNUMmatrix yt (1, nPoints, 1, nDimensions);
// 4. Dilation factor s = (tr X'JYT) / (tr Y'JY)
// First we need YT.
for (long i = 1; i <= nPoints; i++) {
for (long j = 1; j <= nDimensions; j++) {
for (long k = 1; k <= nDimensions; k++) {
yt[i][j] += y[i][k] * t[k][j];
}
}
}
// X'J amount to centering the columns of X
NUMcentreColumns (xc.peek(), 1, nPoints, 1, nDimensions, NULL);
// tr X'J YT == tr xc' yt
double traceXtJYT = 0.0;
for (long i = 1; i <= nDimensions; i++) {
for (long j = 1; j <= nPoints; j++) {
traceXtJYT += xc[j][i] * yt[j][i];
}
}
double traceYtJY = 0.0;
for (long i = 1; i <= nDimensions; i++) {
for (long j = 1; j <= nPoints; j++) {
traceYtJY += y[j][i] * yc[j][i];
}
}
*s = traceXtJYT / traceYtJY;
// 5. Translation vector tr = (X - sYT)'1 / nPoints
for (long i = 1; i <= nDimensions; i++) {
for (long j = 1; j <= nPoints; j++) {
v[i] += x[j][i] - *s * yt[j][i];
}
v[i] /= nPoints;
}
}
}
void NUMmspline (double knot[], long nKnots, long order, long i, double x, double *y) {
long jj, nSplines = nKnots - order;
if (nSplines <= 0) {
Melder_throw (U"No splines.");
}
// Find the interval where x is located.
// M-splines of order k have degree k-1.
// M-splines are zero outside interval [ knot[i], knot[i+order] ).
// First and last 'order' knots are equal, i.e.,
// knot[1] = ... = knot[order] && knot[nKnots-order+1] = ... knot[nKnots].
*y = 0.0;
if (i > nSplines || order < 1) {
Melder_throw (U"Combination of order and index not correct.");
}
for (jj = order; jj <= nKnots - order + 1; jj++) {
if (x < knot[jj]) {
break;
}
}
if (jj < i || (jj > i + order) || jj == order || jj > (nKnots - order + 1)) {
return;
}
// Calculate M[i](x|1,t) according to eq.2.
long ito = i + order - 1;
autoNUMvector m (i, ito);
for (long j = i; j <= ito; j++) {
if (x >= knot[j] && x < knot[j + 1]) {
m[j] = 1 / (knot[j + 1] - knot[j]);
}
}
// Iterate to get M[i](x|k,t)
for (long k = 2; k <= order; k++) {
for (long j = i; j <= i + order - k; j++) {
double kj = knot[j], kjpk = knot[j + k];
if (kjpk > kj) {
m[j] = k * ((x - kj) * m[j] + (kjpk - x) * m[j + 1]) / ((k - 1) * (kjpk - kj));
}
}
}
*y = m[i];
}
void NUMispline (double aknot[], long nKnots, long order, long i, double x, double *y) {
long j, orderp1 = order + 1;
*y = 0.0;
for (j = orderp1; j <= nKnots - order; j++) {
if (x < aknot[j]) {
break;
}
}
j--;
if (j < i) {
return;
}
if (j > i + order || (j == nKnots - order && x == aknot[j])) {
*y = 1.0; return;
}
// Equation 5 in Ramsay's article contains some errors!!!
// 1. the interval selection must be 'j-k <= i <= j' instead of
// 'j-k+1 <= i <= j'
// 2. the summation index m starts at 'i+1' instead of 'i'
for (long m = i + 1; m <= j; m++) {
double r;
NUMmspline (aknot, nKnots, orderp1, m, x, &r);
*y += (aknot[m + orderp1] - aknot[m]) * r;
}
*y /= orderp1;
}
double NUMwilksLambda (double *lambda, long from, long to) {
double result = 1.0;
for (long i = from; i <= to; i++) {
result /= (1.0 + lambda[i]);
}
return result;
}
double NUMfactln (int n) {
static double table[101];
if (n < 0) {
return NUMundefined;
}
if (n <= 1) {
return 0;
}
return n > 100 ? NUMlnGamma (n + 1.0) : table[n] != 0.0 ? table[n] :
(table[n] = NUMlnGamma (n + 1.0));
}
void NUMnrbis (void (*f) (double x, double *fx, double *dfx, void *closure), double xmin, double xmax, void *closure, double *root) {
double df, fx, fh, fl, tmp, xh, xl, tol;
long itermax = 60;
(*f) (xmin, &fl, &df, closure);
if (fl == 0.0) {
*root = xmin;
return;
}
(*f) (xmax, &fh, &df, closure);
if (fh == 0.0) {
*root = xmax;
return;
}
if ((fl > 0.0 && fh > 0.0) || (fl < 0.0 && fh < 0.0)) {
*root = NUMundefined;
return;
}
if (fl < 0.0) {
xl = xmin;
xh = xmax;
} else {
xh = xmin;
xl = xmax;
}
double dxold = fabs (xmax - xmin);
double dx = dxold;
*root = 0.5 * (xmin + xmax);
(*f) (*root, &fx, &df, closure);
for (long iter = 1; iter <= itermax; iter++) {
if ((((*root - xh) * df - fx) * ((*root - xl) * df - fx) >= 0.0) || (fabs (2.0 * fx) > fabs (dxold * df))) {
dxold = dx;
dx = 0.5 * (xh - xl);
*root = xl + dx;
if (xl == *root) {
return;
}
} else {
dxold = dx;
dx = fx / df;
tmp = *root;
*root -= dx;
if (tmp == *root) {
return;
}
}
tol = NUMfpp -> eps * (*root == 0.0 ? 1.0 : fabs (*root));
if (fabs (dx) < tol) {
return;
}
(*f) (*root, &fx, &df, closure);
if (fx < 0.0) {
xl = *root;
} else {
xh = *root;
}
}
Melder_warning (U"NUMnrbis: maximum number of iterations (", itermax, U") exceeded.");
}
double NUMridders (double (*f) (double x, void *closure), double x1, double x2, void *closure) {
/* There is still a problem with this implementation:
tol may be zero;
*/
double x3, x4, d, root = NUMundefined, tol;
long itermax = 100;
double f1 = f (x1, closure);
if (f1 == 0.0) {
return x1;
}
if (f1 == NUMundefined) {
return NUMundefined;
}
double f2 = f (x2, closure);
if (f2 == 0.0) {
return x2;
}
if (f2 == NUMundefined) {
return NUMundefined;
}
if ( (f1 < 0.0 && f2 < 0.0) || (f1 > 0.0 && f2 > 0.0)) {
return NUMundefined;
}
for (long iter = 1; iter <= itermax; iter++) {
x3 = 0.5 * (x1 + x2);
double f3 = f (x3, closure);
if (f3 == 0.0) {
return x3;
}
if (f3 == NUMundefined) {
return NUMundefined;
}
// New guess: x4 = x3 + (x3 - x1) * sign(f1 - f2) * f3 / sqrt(f3^2 - f1*f2)
d = f3 * f3 - f1 * f2;
if (d < 0.0) {
Melder_warning (U"d < 0 in ridders (iter = ", iter, U").");
return NUMundefined;
}
if (d == 0.0) {
// pb test added because f1 f2 f3 may be 1e-170 or so
tol = NUMfpp -> eps * (x3 == 0.0 ? 1.0 : fabs (x3));
if (iter > 1 && fabs (x3 - root) < tol) {
return root;
}
root = x3;
// Perform bisection.
if (f1 > 0.0) {
// falling curve: f1 > 0, f2 < 0
if (f3 > 0.0) {
x1 = x3; f1 = f3; // retain invariant: f1 > 0, f2 < 0
} else {
// f3 <= 0.0
x2 = x3; f2 = f3; // retain invariant: f1 > 0, f2 < 0
}
} else {
// rising curve: f1 < 0, f2 > 0
if (f3 > 0.0) {
x2 = x3; f2 = f3; // retain invariant: f1 < 0, f2 > 0
} else {
// f3 < 0.0
x1 = x3; f1 = f3; // retain invariant: f1 < 0, f2 > 0
}
}
} else {
d = sqrt (d);
if (isnan (d)) {
// pb: square root of denormalized small number fails on some computers
tol = NUMfpp -> eps * (x3 == 0.0 ? 1.0 : fabs (x3));
if (iter > 1 && fabs (x3 - root) < tol) {
return root;
}
root = x3;
// Perform bisection.
if (f1 > 0.0) {
// falling curve: f1 > 0, f2 < 0
if (f3 > 0.0) {
x1 = x3; f1 = f3; // retain invariant: f1 > 0, f2 < 0
} else {
// f3 <= 0.0
x2 = x3; f2 = f3; // retain invariant: f1 > 0, f2 < 0
}
} else {
// rising curve: f1 < 0, f2 > 0
if (f3 > 0.0) {
x2 = x3; f2 = f3; // retain invariant: f1 < 0, f2 > 0
} else {
// f3 < 0.0
x1 = x3; f1 = f3; // retain invariant: f1 < 0, f2 > 0 */
}
}
} else {
d = (x3 - x1) * f3 / d;
x4 = f1 - f2 < 0 ? x3 - d : x3 + d;
tol = NUMfpp -> eps * (x4 == 0.0 ? 1.0 : fabs (x4));
if (iter > 1 && fabs (x4 - root) < tol) {
return root;
}
root = x4;
double f4 = f (x4, closure);
if (f4 == 0.0) {
return root;
}
if (f4 == NUMundefined) {
return NUMundefined;
}
if ((f1 > f2) == (d > 0.0) /* pb: instead of x3 < x4 */) {
if (SIGN (f3, f4) != f3) {
x1 = x3; f1 = f3;
x2 = x4; f2 = f4;
} else {
x1 = x4; f1 = f4;
}
} else {
if (SIGN (f3, f4) != f3) {
x1 = x4; f1 = f4;
x2 = x3; f2 = f3;
} else {
x2 = x4; f2 = f4;
}
}
}
}
if (fabs (x1 - x2) < tol) {
return root;
}
}
{
static long nwarnings = 0;
nwarnings++;
Melder_warning (U"NUMridders: maximum number of iterations (", itermax, U") exceeded.");
}
return root;
}
double NUMlogNormalP (double x, double zeta, double sigma) {
return gsl_cdf_lognormal_P (x, zeta, sigma);
}
double NUMlogNormalQ (double x, double zeta, double sigma) {
return gsl_cdf_lognormal_Q (x, zeta, sigma);
}
double NUMstudentP (double t, double df) {
if (df < 1.0) {
return NUMundefined;
}
double ib = NUMincompleteBeta (0.5 * df, 0.5, df / (df + t * t));
if (ib == NUMundefined) {
return NUMundefined;
}
ib *= 0.5;
return t < 0.0 ? ib : 1.0 - ib;
}
double NUMstudentQ (double t, double df) {
if (df < 1) {
return NUMundefined;
}
double ib = NUMincompleteBeta (0.5 * df, 0.5, df / (df + t * t));
if (ib == NUMundefined) {
return NUMundefined;
}
ib *= 0.5;
return t > 0.0 ? ib : 1.0 - ib;
}
double NUMfisherP (double f, double df1, double df2) {
if (f < 0.0 || df1 < 1.0 || df2 < 1.0) {
return NUMundefined;
}
double ib = NUMincompleteBeta (0.5 * df2, 0.5 * df1, df2 / (df2 + f * df1));
if (ib == NUMundefined) {
return NUMundefined;
}
return 1.0 - ib;
}
double NUMfisherQ (double f, double df1, double df2) {
if (f < 0.0 || df1 < 1.0 || df2 < 1.0) {
return NUMundefined;
}
if (Melder_debug == 28) {
return NUMincompleteBeta (0.5 * df2, 0.5 * df1, df2 / (df2 + f * df1));
} else {
double result = gsl_cdf_fdist_Q (f, df1, df2);
if (isnan (result)) {
return NUMundefined;
}
return result;
}
}
double NUMinvGaussQ (double p) {
double pc = p;
if (p <= 0.0 || p >= 1.0) {
return NUMundefined;
}
if (p > 0.5) {
pc = 1.0 - p;
}
double t = sqrt (- 2.0 * log (pc));
t -= (2.515517 + (0.802853 + 0.010328 * t) * t) /
(1.0 + (1.432788 + (0.189269 + 0.001308 * t) * t) * t);
return p > 0.5 ? -t : t;
}
static double studentQ_func (double x, void *voidParams) {
struct pdf1_struct *params = (struct pdf1_struct *) voidParams;
double q = NUMstudentQ (x, params -> df);
return q == NUMundefined ? NUMundefined : q - params -> p;
}
double NUMinvStudentQ (double p, double df) {
struct pdf1_struct params;
double pc = p > 0.5 ? 1.0 - p : p, xmin, xmax = 1.0, x;
if (p < 0.0 || p >= 1.0) {
return NUMundefined;
}
// Bracket the function f(x) = NUMstudentQ (x, df) - p.
for (;;) {
double q = NUMstudentQ (xmax, df);
if (q == NUMundefined) {
return NUMundefined;
}
if (q < pc) {
break;
}
xmax *= 2.0;
}
xmin = xmax > 1.0 ? xmax / 2.0 : 0.0;
// Find zero of f(x) with Ridders' method.
params. df = df;
params. p = pc;
x = NUMridders (studentQ_func, xmin, xmax, & params);
if (x == NUMundefined) {
return NUMundefined;
}
return p > 0.5 ? -x : x;
}
static double chiSquareQ_func (double x, void *voidParams) {
struct pdf1_struct *params = (struct pdf1_struct *) voidParams;
double q = NUMchiSquareQ (x, params -> df);
return q == NUMundefined ? NUMundefined : q - params -> p;
}
double NUMinvChiSquareQ (double p, double df) {
struct pdf1_struct params;
double xmin, xmax = 1;
if (p < 0.0 || p >= 1.0) {
return NUMundefined;
}
// Bracket the function f(x) = NUMchiSquareQ (x, df) - p.
for (;;) {
double q = NUMchiSquareQ (xmax, df);
if (q == NUMundefined) {
return NUMundefined;
}
if (q < p) {
break;
}
xmax *= 2.0;
}
xmin = xmax > 1.0 ? xmax / 2.0 : 0.0;
// Find zero of f(x) with Ridders' method.
params. df = df;
params. p = p;
return NUMridders (chiSquareQ_func, xmin, xmax, & params);
}
static double fisherQ_func (double x, void *voidParams) {
struct pdf2_struct *params = (struct pdf2_struct *) voidParams;
double q = NUMfisherQ (x, params -> df1, params -> df2);
return q == NUMundefined ? NUMundefined : q - params -> p;
}
double NUMinvFisherQ (double p, double df1, double df2) {
if (p <= 0.0 || p > 1.0 || df1 < 1.0 || df2 < 1.0) {
return NUMundefined;
}
if (Melder_debug == 29) {
//if (p == 1.0) return 0.0;
return gsl_cdf_fdist_Qinv (p, df1, df2);
} else {
struct pdf2_struct params;
double top = 1000.0;
if (p == 1.0) {
return 0.0;
}
params. p = p;
params. df1 = df1;
params. df2 = df2;
for (;;) {
double q = NUMfisherQ (top, df1, df2);
if (q == NUMundefined) {
return NUMundefined;
}
if (q < p) {
break;
}
if (top > 0.9e300) {
return NUMundefined;
}
top *= 1e9;
}
return NUMridders (fisherQ_func, 0.0, p > 0.5 ? 2.2 : top, & params);
}
}
double NUMbeta2 (double z, double w) {
gsl_sf_result result;
int status = gsl_sf_beta_e (z, w, &result);
return status == GSL_SUCCESS ? result.val : NUMundefined;
}
double NUMlnBeta (double a, double b) {
gsl_sf_result result;
int status = gsl_sf_lnbeta_e (a, b, &result);
return status == GSL_SUCCESS ? result.val : NUMundefined;
}
double NUMnormalityTest_HenzeZirkler (double **data, long n, long p, double *beta, double *tnb, double *lnmu, double *lnvar) {
if (*beta <= 0) {
*beta = (1.0 / sqrt (2.0)) * pow ((1.0 + 2 * p) / 4.0, 1.0 / (p + 4)) * pow (n, 1.0 / (p + 4));
}
double p2 = p / 2.0;
double beta2 = *beta * *beta, beta4 = beta2 * beta2, beta8 = beta4 * beta4;
double gamma = 1.0 + 2.0 * beta2, gamma2 = gamma * gamma, gamma4 = gamma2 * gamma2;
double delta = 1.0 + beta2 * (4.0 + 3.0 * beta2), delta2 = delta * delta;
double prob = NUMundefined;
*tnb = *lnmu = *lnvar = NUMundefined;
if (n < 2 || p < 1) {
return prob;
}
autoNUMvector zero (1, p);
autoNUMmatrix