void Minimizer_minimizeManyTimes (Minimizer me, long numberOfTimes, long maxIterationsPerTime, double tolerance) {
double fopt = my minimum;
int monitorSingle = numberOfTimes == 1;
autoNUMvector<double> popt (NUMvector_copy<double> (my p, 1, my nParameters), 1);
if (! monitorSingle) {
Melder_progress (0.0, L"Minimize many times");
}
/* on first iteration start with current parameters 27/11/97 */
for (long i = 1; i <= numberOfTimes; i++) {
Minimizer_minimize (me, maxIterationsPerTime, tolerance, monitorSingle);
Melder_casual ("Current %ld: minimum = %.17g", i, my minimum);
if (my minimum < fopt) {
NUMvector_copyElements (my p, popt.peek(), 1, my nParameters);
fopt = my minimum;
}
Minimizer_reset (me, 0);
if (! monitorSingle) {
try {
Melder_progress ( (double) i / numberOfTimes, Melder_integer (i), L" from ",
Melder_integer (numberOfTimes)); therror
} catch (MelderError) {
Melder_clearError (); // interrurpt, no error
break;
}
}
}
if (! monitorSingle) {
Melder_progress (1.0, 0);
}
Minimizer_reset (me, popt.peek());
}
void structSteepestDescentMinimizer :: v_minimize () {
autoNUMvector<double> dp (1, nParameters);
autoNUMvector<double> dpp (1, nParameters);
double fret = func (object, p);
while (iteration < maxNumOfIterations) {
dfunc (object, p, dp.peek());
for (long i = 1; i <= nParameters; i++) {
dpp[i] = - eta * dp[i] + momentum * dpp[i];
p[i] += dpp[i];
}
history[++iteration] = minimum = func (object, p);
success = 2.0 * fabs (fret - minimum) < tolerance * (fabs (fret) + fabs (minimum));
if (after) {
try {
after (this, aclosure);
} catch (MelderError) {
Melder_casual ("Interrupted after %ld iterations.", iteration);
Melder_clearError ();
break;
}
}
if (success) {
break;
}
fret = minimum;
}
}
void Minimizer_minimize (Minimizer me, long maxNumOfIterations, double tolerance, int monitor) {
try {
my tolerance = tolerance;
if (maxNumOfIterations <= 0) {
return;
}
if (my iteration + maxNumOfIterations > my maxNumOfIterations) {
my maxNumOfIterations += maxNumOfIterations;
if (my history) { // clumsy because vector must have been allocated before one can append
NUMvector_append<double> (& my history, 1, & my maxNumOfIterations);
} else {
my history = NUMvector<double> (1, my maxNumOfIterations);
}
}
if (monitor) {
my gmonitor = (Graphics) Melder_monitor (0.0, U"Starting...");
}
my start = 1; /* for my after() */
my v_minimize ();
if (monitor) {
monitor_off (me);
}
if (my success) Melder_casual (U"Minimizer_minimize:", U" minimum ", my minimum, U" reached \nafter ", my iteration,
U" iterations and ", my funcCalls, U" function calls.");
} catch (MelderError) {
if (monitor) {
monitor_off (me); // temporarily until better monitor facilities
}
Melder_clearError(); // memory error in history mechanism is not fatal
}
}
void structSoundEditor :: v_prepareDraw () {
if (d_longSound.data) {
try {
LongSound_haveWindow (d_longSound.data, d_startWindow, d_endWindow);
} catch (MelderError) {
Melder_clearError ();
}
}
}
void Melder_flushError () {
/*
"errors" has to be cleared *before* the message is put on the screen.
This is because on some platforms the message dialog is synchronous
(Melder_flushError will wait until the message dialog is closed),
and some operating systems may force an immediate redraw event as soon as
the message dialog is closed. We want "errors" to be empty when redrawing!
*/
static char32 temp [2000+1];
str32cpy (temp, errors);
Melder_clearError ();
theError (temp);
}
static void LongSound_init (LongSound me, MelderFile file) {
MelderFile_copy (file, & my file);
MelderFile_open (file); // BUG: should be auto, but that requires an implemented .transfer()
my f = file -> filePointer;
my audioFileType = MelderFile_checkSoundFile (file, & my numberOfChannels, & my encoding, & my sampleRate, & my startOfData, & my nx);
if (my audioFileType == 0)
Melder_throw (U"File not recognized (LongSound only supports AIFF, AIFC, WAV, NeXT/Sun, NIST and FLAC).");
if (my encoding == Melder_SHORTEN || my encoding == Melder_POLYPHONE)
Melder_throw (U"LongSound does not support sound files compressed with \"shorten\".");
if (my nx < 1)
Melder_throw (U"Audio file contains 0 samples.");
my xmin = 0.0;
my dx = 1 / my sampleRate;
my xmax = my nx * my dx;
my x1 = 0.5 * my dx;
my numberOfBytesPerSamplePoint = Melder_bytesPerSamplePoint (my encoding);
my bufferLength = prefs_bufferLength;
for (;;) {
my nmax = my bufferLength * my numberOfChannels * my sampleRate * (1 + 3 * MARGIN);
try {
my buffer = NUMvector <int16> (0, my nmax * my numberOfChannels);
break;
} catch (MelderError) {
my bufferLength *= 0.5; // try 30, 15, or 7.5 seconds
if (my bufferLength < 5.0) // too short to be good
throw;
Melder_clearError (); // delete out-of-memory message
}
}
my imin = 1;
my imax = 0;
my flacDecoder = nullptr;
if (my audioFileType == Melder_FLAC) {
my flacDecoder = FLAC__stream_decoder_new ();
FLAC__stream_decoder_init_FILE (my flacDecoder, my f, _LongSound_FLAC_write, nullptr, _LongSound_FLAC_error, me);
}
my mp3f = nullptr;
if (my audioFileType == Melder_MP3) {
my mp3f = mp3f_new ();
mp3f_set_file (my mp3f, my f);
mp3f_set_callback (my mp3f, _LongSound_MP3_convert, me);
if (! mp3f_analyze (my mp3f))
Melder_throw (U"Unable to analyze MP3 file.");
Melder_warning (U"Time measurements in MP3 files can be off by several tens of milliseconds. "
U"Please convert to WAV file if you need time precision or annotation.");
}
}
Formant 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 ("We cannot find the roots of a polynomial of order > 99.");
}
if (margin >= samplingFrequency / 4) {
Melder_throw ("Margin must be smaller than ", samplingFrequency / 4, ".");
}
autoFormant thee = Formant_create (my xmin, my xmax, my nx, my dx, my x1, (nmax + 1) / 2);
autoMelderProgress progress (L"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, L"LPC to Formant: frame ", Melder_integer (i),
L" out of ", Melder_integer (my nx), L".");
}
}
Formant_sort (thee.peek());
if (err > 0) {
Melder_warning (Melder_integer (err), L" formant frames out of ", Melder_integer (my nx), L" suspect.");
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": no Formant created.");
}
}
void LongSound_getWindowExtrema (LongSound me, double tmin, double tmax, int channel, double *minimum, double *maximum) {
long imin, imax;
(void) Sampled_getWindowSamples (me, tmin, tmax, & imin, & imax);
*minimum = 1.0;
*maximum = -1.0;
try {
LongSound_haveWindow (me, tmin, tmax);
} catch (MelderError) {
Melder_clearError ();
return;
}
long minimum_int = 32767, maximum_int = -32768;
for (long i = imin; i <= imax; i ++) {
long value = my buffer [(i - my imin) * my numberOfChannels + channel - 1];
if (value < minimum_int) minimum_int = value;
if (value > maximum_int) maximum_int = value;
}
*minimum = minimum_int / 32768.0;
*maximum = maximum_int / 32768.0;
}
void Minimizer_minimize (Minimizer me, long maxNumOfIterations, double tolerance, int monitor) {
try {
my tolerance = tolerance;
if (maxNumOfIterations <= 0) {
return;
}
if (my iteration + maxNumOfIterations > my maxNumOfIterations) {
double *history;
my maxNumOfIterations += maxNumOfIterations;
if (my history) {
my history++; /* arrays start at 1 !! */
}
history = (double *) Melder_realloc (my history, my maxNumOfIterations *
sizeof (double));
my history = --history; /* arrays start at 1 !! */
}
if (monitor) {
my gmonitor = (Graphics) Melder_monitor (0.0, L"Starting...");
}
my start = 1; /* for my after() */
my v_minimize ();
if (monitor) {
monitor_off (me);
}
if (my success) Melder_casual ("Minimizer_minimize: minimum %f reached \n"
"after %ld iterations and %ld function calls.", my minimum,
my iteration, my funcCalls);
} catch (MelderError) {
if (monitor) {
monitor_off (me); // temporarily until better monitor facilities
}
Melder_clearError(); // memory error in history mechanism is not fatal
}
}
void structVDSmagtMinimizer :: v_minimize () {
int decrease_direction_found = 1;
int l_iteration = 1; // David, dat is gevaarlijk: een locale variabele met dezelfde naam als een member; daarom hernoemd, maar is het correct? yes, we can iterate in steps, therefore local and global counter
double rtemp, rtemp2;
// df is estimate of function reduction obtainable during line search
// restart = 2 => line search in direction of steepest descent
// restart = 1 => line search with Powell-restart.
// flag = 1 => no decrease in function value during previous line search;
// flag = 2 => line search did not decrease gradient
// OK; must restart
if (restart_flag) {
minimum = func (object, p);
dfunc (object, p, dp);
df = minimum;
restart = 2;
one_up = flag = 0;
gcg0 = gopt_sq = 0.0;
}
restart_flag = 1;
while (++ this -> iteration <= maxNumOfIterations) {
if (flag & 1) {
if (one_up) {
decrease_direction_found = 0;
this -> iteration --;
break;
} else {
one_up = 1;
}
} else {
one_up = 0;
}
if (flag & 2) {
restart = 2; /* flag & 1 ??? */
} else if (fabs ( (double) gcg0) > 0.2 * gopt_sq) {
restart = 1;
}
if (restart == 0) {
rtemp = rtemp2 = 0.0;
for (long i = 1; i <= nParameters; i++) {
rtemp += gc[i] * grst[i];
rtemp2 += gc[i] * srst[i];
}
gamma = rtemp / gamma_in;
if (fabs (beta * gropt - gamma * rtemp2) > 0.2 * gopt_sq) {
restart = 1;
} else {
for (long i = 1; i <= nParameters; i++) {
s[i] = beta * s[i] + gamma * srst[i] - gc[i];
}
}
}
if (restart == 2) {
for (long i = 1; i <= nParameters; i++) {
s[i] = - dp[i];
}
restart = 1;
} else if (restart == 1) {
gamma_in = gropt - gr0;
for (long i = 1; i <= nParameters; i++) {
srst[i] = s[i];
s[i] = beta * s[i] - gc[i];
grst[i] = gc[i] - g0[i];
}
restart = 0;
}
// Begin line search
// lineSearch_iteration = #iterations during current line search
flag = 0;
lineSearch_iteration = 0;
rtemp = 0.0;
for (long i = 1; i <= nParameters; i++) {
rtemp += dp[i] * s[i];
g0[i] = dp[i];
}
gr0 = gropt = rtemp;
if (l_iteration == 1) {
alphamin = fabs (df / gropt);
}
if (gr0 > 0) {
flag = 1;
restart = 2;
continue;
}
f0 = minimum;
// alpha = length of step along line;
// dalpha = change in alpha
// alphamin = position of min along line
alplim = -1;
again = -1;
rtemp = fabs (df / gropt);
dalpha = alphamin < rtemp ? alphamin : rtemp;
alphamin = 0;
do {
do {
if (lineSearch_iteration) {
if (! (fch == 0)) {
gr2s += (temp + temp) / dalpha;
}
if (alplim < -0.5) {
dalpha = 9.0 * alphamin;
} else {
dalpha = 0.5 * (alplim - alphamin);
}
grs = gropt + dalpha * gr2s;
if (gropt * grs < 0) {
dalpha *= gropt / (gropt - grs);
}
}
alpha = alphamin + dalpha;
for (long i = 1; i <= nParameters; i++) {
pc[i] = p[i] + dalpha * s[i];
}
fc = func (object, pc);
dfunc (object, pc, gc);
l_iteration ++;
lineSearch_iteration++;
gsq = grc = 0.0;
for (long i = 1; i <= nParameters; i++) {
gsq += gc[i] * gc[i];
grc += gc[i] * s[i];
}
fch = fc - minimum;
gr2s = (grc - gropt) / dalpha;
temp = (fch + fch) / dalpha - grc - gropt;
if ( (fc < minimum) ||
( (fc == minimum) && (grc / gropt > -1))) {
double *tmp;
gopt_sq = gsq;
history [this ->iteration] = minimum = fc;
tmp = p; p = pc; pc = tmp;
tmp = dp; dp = gc; gc = tmp;
if (grc *gropt <= 0) {
alplim = alphamin;
}
alphamin = alpha;
gropt = grc;
dalpha = - dalpha;
success = gsq < tolerance;
if (after) {
try {
after (this, aclosure);
} catch (MelderError) {
Melder_casual ("Interrupted after %ld iterations.", this -> iteration);
Melder_clearError ();
break;
}
}
if (success) {
return;
}
if (fabs (gropt / gr0) < lineSearchGradient) {
break;
}
} else {
alplim = alpha;
}
} while (lineSearch_iteration
<= lineSearchMaxNumOfIterations);
fc = history [this -> iteration] = minimum;
rtemp = 0.0;
for (long i = 1; i <= nParameters; i++) {
pc[i] = p[i];
gc[i] = dp[i];
rtemp += gc[i] * g0[i];
}
gcg0 = rtemp;
if (fabs (gropt - gr0) > tolerance) {
beta = (gopt_sq - gcg0) / (gropt - gr0);
if (fabs (beta * gropt) < 0.2 * gopt_sq) {
break;
}
}
again++;
if (again > 0) {
flag += 2;
}
} while (flag < 1);
if (f0 <= minimum) {
flag += 1;
}
df = gr0 * alphamin;
}
if (this -> iteration > maxNumOfIterations) {
this -> iteration = maxNumOfIterations;
}
if (decrease_direction_found) {
restart_flag = 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 <double> physicalMinimum (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0';
physicalMinimum [ichannel] = atof (buffer);
}
autoNUMvector <double> physicalMaximum (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0';
physicalMaximum [ichannel] = atof (buffer);
}
autoNUMvector <double> digitalMinimum (1, numberOfChannels);
for (long ichannel = 1; ichannel <= numberOfChannels; ichannel ++) {
fread (buffer, 1, 8, f); buffer [8] = '\0';
digitalMinimum [ichannel] = atof (buffer);
}
autoNUMvector <double> 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 <unsigned char> 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.peek())) 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.peek(), 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.peek(), 2, time, & letters. string [8]);
} catch (MelderError) {
Melder_clearError ();
trace (U"Duplicate trigger at ", time, U" seconds: ", & letters. string [8]);
}
} else {
TextGrid_insertPoint (thee.peek(), 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.peek(), 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 -> item [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.peek(), bit, time);
if ((thisValue & bitValue) != 0)
TextGrid_setIntervalText (thee.peek(), 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.peek()) == 32) {
EEG_setChannelName (him.peek(), 1, U"Fp1");
EEG_setChannelName (him.peek(), 2, U"AF3");
EEG_setChannelName (him.peek(), 3, U"F7");
EEG_setChannelName (him.peek(), 4, U"F3");
EEG_setChannelName (him.peek(), 5, U"FC1");
EEG_setChannelName (him.peek(), 6, U"FC5");
EEG_setChannelName (him.peek(), 7, U"T7");
EEG_setChannelName (him.peek(), 8, U"C3");
EEG_setChannelName (him.peek(), 9, U"CP1");
EEG_setChannelName (him.peek(), 10, U"CP5");
EEG_setChannelName (him.peek(), 11, U"P7");
EEG_setChannelName (him.peek(), 12, U"P3");
EEG_setChannelName (him.peek(), 13, U"Pz");
EEG_setChannelName (him.peek(), 14, U"PO3");
EEG_setChannelName (him.peek(), 15, U"O1");
EEG_setChannelName (him.peek(), 16, U"Oz");
EEG_setChannelName (him.peek(), 17, U"O2");
EEG_setChannelName (him.peek(), 18, U"PO4");
EEG_setChannelName (him.peek(), 19, U"P4");
EEG_setChannelName (him.peek(), 20, U"P8");
EEG_setChannelName (him.peek(), 21, U"CP6");
EEG_setChannelName (him.peek(), 22, U"CP2");
EEG_setChannelName (him.peek(), 23, U"C4");
EEG_setChannelName (him.peek(), 24, U"T8");
EEG_setChannelName (him.peek(), 25, U"FC6");
EEG_setChannelName (him.peek(), 26, U"FC2");
EEG_setChannelName (him.peek(), 27, U"F4");
EEG_setChannelName (him.peek(), 28, U"F8");
EEG_setChannelName (him.peek(), 29, U"AF4");
EEG_setChannelName (him.peek(), 30, U"Fp2");
EEG_setChannelName (him.peek(), 31, U"Fz");
EEG_setChannelName (him.peek(), 32, U"Cz");
} else if (EEG_getNumberOfCapElectrodes (him.peek()) == 64) {
EEG_setChannelName (him.peek(), 1, U"Fp1");
EEG_setChannelName (him.peek(), 2, U"AF7");
EEG_setChannelName (him.peek(), 3, U"AF3");
EEG_setChannelName (him.peek(), 4, U"F1");
EEG_setChannelName (him.peek(), 5, U"F3");
EEG_setChannelName (him.peek(), 6, U"F5");
EEG_setChannelName (him.peek(), 7, U"F7");
EEG_setChannelName (him.peek(), 8, U"FT7");
EEG_setChannelName (him.peek(), 9, U"FC5");
EEG_setChannelName (him.peek(), 10, U"FC3");
EEG_setChannelName (him.peek(), 11, U"FC1");
EEG_setChannelName (him.peek(), 12, U"C1");
EEG_setChannelName (him.peek(), 13, U"C3");
EEG_setChannelName (him.peek(), 14, U"C5");
EEG_setChannelName (him.peek(), 15, U"T7");
EEG_setChannelName (him.peek(), 16, U"TP7");
EEG_setChannelName (him.peek(), 17, U"CP5");
EEG_setChannelName (him.peek(), 18, U"CP3");
EEG_setChannelName (him.peek(), 19, U"CP1");
EEG_setChannelName (him.peek(), 20, U"P1");
EEG_setChannelName (him.peek(), 21, U"P3");
EEG_setChannelName (him.peek(), 22, U"P5");
EEG_setChannelName (him.peek(), 23, U"P7");
EEG_setChannelName (him.peek(), 24, U"P9");
EEG_setChannelName (him.peek(), 25, U"PO7");
EEG_setChannelName (him.peek(), 26, U"PO3");
EEG_setChannelName (him.peek(), 27, U"O1");
EEG_setChannelName (him.peek(), 28, U"Iz");
EEG_setChannelName (him.peek(), 29, U"Oz");
EEG_setChannelName (him.peek(), 30, U"POz");
EEG_setChannelName (him.peek(), 31, U"Pz");
EEG_setChannelName (him.peek(), 32, U"CPz");
EEG_setChannelName (him.peek(), 33, U"Fpz");
EEG_setChannelName (him.peek(), 34, U"Fp2");
EEG_setChannelName (him.peek(), 35, U"AF8");
EEG_setChannelName (him.peek(), 36, U"AF4");
EEG_setChannelName (him.peek(), 37, U"AFz");
EEG_setChannelName (him.peek(), 38, U"Fz");
EEG_setChannelName (him.peek(), 39, U"F2");
EEG_setChannelName (him.peek(), 40, U"F4");
EEG_setChannelName (him.peek(), 41, U"F6");
EEG_setChannelName (him.peek(), 42, U"F8");
EEG_setChannelName (him.peek(), 43, U"FT8");
EEG_setChannelName (him.peek(), 44, U"FC6");
EEG_setChannelName (him.peek(), 45, U"FC4");
EEG_setChannelName (him.peek(), 46, U"FC2");
EEG_setChannelName (him.peek(), 47, U"FCz");
EEG_setChannelName (him.peek(), 48, U"Cz");
EEG_setChannelName (him.peek(), 49, U"C2");
EEG_setChannelName (him.peek(), 50, U"C4");
EEG_setChannelName (him.peek(), 51, U"C6");
EEG_setChannelName (him.peek(), 52, U"T8");
EEG_setChannelName (him.peek(), 53, U"TP8");
EEG_setChannelName (him.peek(), 54, U"CP6");
EEG_setChannelName (him.peek(), 55, U"CP4");
EEG_setChannelName (him.peek(), 56, U"CP2");
EEG_setChannelName (him.peek(), 57, U"P2");
EEG_setChannelName (him.peek(), 58, U"P4");
EEG_setChannelName (him.peek(), 59, U"P6");
EEG_setChannelName (him.peek(), 60, U"P8");
EEG_setChannelName (him.peek(), 61, U"P10");
EEG_setChannelName (him.peek(), 62, U"PO8");
EEG_setChannelName (him.peek(), 63, U"PO4");
EEG_setChannelName (him.peek(), 64, U"O2");
}
return him;
} catch (MelderError) {
static autoFormant Sound_to_Formant_any_inline (Sound me, double dt_in, int numberOfPoles,
double halfdt_window, int which, double preemphasisFrequency, double safetyMargin)
{
double dt = dt_in > 0.0 ? dt_in : halfdt_window / 4.0;
double duration = my nx * my dx, t1;
double dt_window = 2.0 * halfdt_window;
long nFrames = 1 + (long) floor ((duration - dt_window) / dt);
long nsamp_window = (long) floor (dt_window / my dx), halfnsamp_window = nsamp_window / 2;
if (nsamp_window < numberOfPoles + 1)
Melder_throw (U"Window too short.");
t1 = my x1 + 0.5 * (duration - my dx - (nFrames - 1) * dt); // centre of first frame
if (nFrames < 1) {
nFrames = 1;
t1 = my x1 + 0.5 * duration;
dt_window = duration;
nsamp_window = my nx;
}
autoFormant thee = Formant_create (my xmin, my xmax, nFrames, dt, t1, (numberOfPoles + 1) / 2); // e.g. 11 poles -> maximally 6 formants
autoNUMvector <double> window (1, nsamp_window);
autoNUMvector <double> frame (1, nsamp_window);
autoNUMvector <double> cof (1, numberOfPoles); // superfluous if which==2, but nobody uses that anyway
autoMelderProgress progress (U"Formant analysis...");
/* Pre-emphasis. */
Sound_preEmphasis (me, preemphasisFrequency);
/* Gaussian window. */
for (long i = 1; i <= nsamp_window; i ++) {
double imid = 0.5 * (nsamp_window + 1), edge = exp (-12.0);
window [i] = (exp (-48.0 * (i - imid) * (i - imid) / (nsamp_window + 1) / (nsamp_window + 1)) - edge) / (1.0 - edge);
}
for (long iframe = 1; iframe <= nFrames; iframe ++) {
double t = Sampled_indexToX (thee.peek(), iframe);
long leftSample = Sampled_xToLowIndex (me, t);
long rightSample = leftSample + 1;
long startSample = rightSample - halfnsamp_window;
long endSample = leftSample + halfnsamp_window;
double maximumIntensity = 0.0;
if (startSample < 1) startSample = 1;
if (endSample > my nx) endSample = my nx;
for (long i = startSample; i <= endSample; i ++) {
double value = Sampled_getValueAtSample (me, i, Sound_LEVEL_MONO, 0);
if (value * value > maximumIntensity) {
maximumIntensity = value * value;
}
}
if (maximumIntensity == HUGE_VAL)
Melder_throw (U"Sound contains infinities.");
thy d_frames [iframe]. intensity = maximumIntensity;
if (maximumIntensity == 0.0) continue; // Burg cannot stand all zeroes
/* Copy a pre-emphasized window to a frame. */
for (long j = 1, i = startSample; j <= nsamp_window; j ++)
frame [j] = Sampled_getValueAtSample (me, i ++, Sound_LEVEL_MONO, 0) * window [j];
if (which == 1) {
burg (frame.peek(), endSample - startSample + 1, cof.peek(), numberOfPoles, & thy d_frames [iframe], 0.5 / my dx, safetyMargin);
} else if (which == 2) {
if (! splitLevinson (frame.peek(), endSample - startSample + 1, numberOfPoles, & thy d_frames [iframe], 0.5 / my dx)) {
Melder_clearError ();
Melder_casual (U"(Sound_to_Formant:)"
U" Analysis results of frame ", iframe,
U" will be wrong."
);
}
}
Melder_progress ((double) iframe / (double) nFrames, U"Formant analysis: frame ", iframe);
}
Formant_sort (thee.peek());
return thee;
}
ClassificationTable Discriminant_and_TableOfReal_to_ClassificationTable (Discriminant me, TableOfReal thee,
int poolCovarianceMatrices, int useAprioriProbabilities) {
try {
long g = Discriminant_getNumberOfGroups (me);
long p = Eigen_getDimensionOfComponents (me);
long m = thy numberOfRows;
if (p != thy numberOfColumns) Melder_throw
(U"The number of columns does not agree with the dimension of the discriminant.");
autoNUMvector<double> log_p (1, g);
autoNUMvector<double> log_apriori (1, g);
autoNUMvector<double> ln_determinant (1, g);
autoNUMvector<double> buf (1, p);
autoNUMvector<SSCP> sscpvec (1, g);
autoSSCP pool = SSCPs_to_SSCP_pool (my groups);
autoClassificationTable him = ClassificationTable_create (m, g);
NUMstrings_copyElements (thy rowLabels, his rowLabels, 1, m);
// Scale the sscp to become a covariance matrix.
for (long i = 1; i <= p; i++) {
for (long k = i; k <= p; k++) {
pool -> data[k][i] = (pool -> data[i][k] /= (pool -> numberOfObservations - g));
}
}
double lnd;
autoSSCPs agroups = 0; SSCPs groups;
if (poolCovarianceMatrices) {
/*
Covariance matrix S can be decomposed as S = L.L'. Calculate L^-1.
L^-1 will be used later in the Mahalanobis distance calculation:
v'.S^-1.v == v'.L^-1'.L^-1.v == (L^-1.v)'.(L^-1.v).
*/
NUMlowerCholeskyInverse (pool -> data, p, &lnd);
for (long j = 1; j <= g; j++) {
ln_determinant[j] = lnd;
sscpvec[j] = pool.peek();
}
groups = (SSCPs) my groups;
} else {
// Calculate the inverses of all group covariance matrices.
// In case of a singular matrix, substitute inverse of pooled.
agroups.reset (Data_copy ( (SSCPs) my groups)); groups = agroups.peek();
long npool = 0;
for (long j = 1; j <= g; j++) {
SSCP t = (SSCP) groups -> item[j];
long no = (long) floor (SSCP_getNumberOfObservations (t));
for (long i = 1; i <= p; i++) {
for (long k = i; k <= p; k++) {
t -> data[k][i] = (t -> data[i][k] /= (no - 1));
}
}
sscpvec[j] = (SSCP) groups -> item[j];
try {
NUMlowerCholeskyInverse (t -> data, p, &ln_determinant[j]);
} catch (MelderError) {
// Try the alternative: the pooled covariance matrix.
// Clear the error.
Melder_clearError ();
if (npool == 0) {
NUMlowerCholeskyInverse (pool -> data, p, &lnd);
}
npool++;
sscpvec[j] = pool.peek();
ln_determinant[j] = lnd;
}
}
if (npool > 0) {
Melder_warning (npool, U" groups use pooled covariance matrix.");
}
}
// Labels for columns in ClassificationTable
for (long j = 1; j <= g; j++) {
const char32 *name = Thing_getName ( (Thing) my groups -> item[j]);
if (! name) {
name = U"?";
}
TableOfReal_setColumnLabel (him.peek(), j, name);
}
// Normalize the sum of the apriori probabilities to 1.
// Next take ln (p) because otherwise probabilities might be too small to represent.
NUMvector_normalize1 (my aprioriProbabilities, g);
double logg = log (g);
for (long j = 1; j <= g; j++) {
log_apriori[j] = useAprioriProbabilities ? log (my aprioriProbabilities[j]) : - logg;
}
// Generalized squared distance function:
// D^2(x) = (x - mu)' S^-1 (x - mu) + ln (determinant(S)) - 2 ln (apriori)
for (long i = 1; i <= m; i++) {
double norm = 0, pt_max = -1e38;
for (long j = 1; j <= g; j++) {
SSCP t = (SSCP) groups -> item[j];
double md = mahalanobisDistanceSq (sscpvec[j] -> data, p, thy data[i], t -> centroid, buf.peek());
double pt = log_apriori[j] - 0.5 * (ln_determinant[j] + md);
if (pt > pt_max) {
pt_max = pt;
}
log_p[j] = pt;
}
for (long j = 1; j <= g; j++) {
norm += (log_p[j] = exp (log_p[j] - pt_max));
}
for (long j = 1; j <= g; j++) {
his data[i][j] = log_p[j] / norm;
}
}
return him.transfer();
} catch (MelderError) {
Melder_throw (U"ClassificationTable from Discriminant & TableOfReal not created.");
}
}
void TextGrid_anySound_alignInterval (TextGrid me, Function anySound, long tierNumber, long intervalNumber, const char32 *languageName, bool includeWords, bool includePhonemes) {
try {
IntervalTier headTier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
if (intervalNumber < 1 || intervalNumber > headTier -> intervals.size)
Melder_throw (U"Interval ", intervalNumber, U" does not exist.");
TextInterval interval = headTier -> intervals.at [intervalNumber];
if (! includeWords && ! includePhonemes)
Melder_throw (U"Nothing to be done, because you asked neither for word alignment nor for phoneme alignment.");
if (str32str (headTier -> name, U"/") )
Melder_throw (U"The current tier already has a slash (\"/\") in its name. Cannot create a word or phoneme tier from it.");
autoSound part =
anySound -> classInfo == classLongSound ?
LongSound_extractPart (static_cast <LongSound> (anySound), interval -> xmin, interval -> xmax, true) :
Sound_extractPart (static_cast <Sound> (anySound), interval -> xmin, interval -> xmax, kSound_windowShape_RECTANGULAR, 1.0, true);
autoSpeechSynthesizer synthesizer = SpeechSynthesizer_create (languageName, U"default");
double silenceThreshold = -35, minSilenceDuration = 0.1, minSoundingDuration = 0.1;
autoTextGrid analysis;
if (! Melder_equ (interval -> text, U"")) {
try {
analysis = SpeechSynthesizer_and_Sound_and_TextInterval_align
(synthesizer.get(), part.get(), interval, silenceThreshold, minSilenceDuration, minSoundingDuration);
} catch (MelderError) {
Melder_clearError (); // ignore all error messages from DTW and the like
}
}
if (analysis) {
/*
* Clean up the analysis.
*/
Melder_assert (analysis -> xmin == interval -> xmin);
Melder_assert (analysis -> xmax == interval -> xmax);
Melder_assert (analysis -> tiers->size == 4);
Thing_cast (IntervalTier, analysisWordTier, analysis -> tiers->at [3]);
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order.");
IntervalTier_removeEmptyIntervals (analysisWordTier, nullptr);
Melder_assert (analysisWordTier -> xmax == analysis -> xmax);
Melder_assert (analysisWordTier -> intervals.size >= 1);
TextInterval firstInterval = analysisWordTier -> intervals.at [1];
TextInterval lastInterval = analysisWordTier -> intervals.at [analysisWordTier -> intervals.size];
firstInterval -> xmin = analysis -> xmin;
lastInterval -> xmax = analysis -> xmax;
if (lastInterval -> xmax != analysis -> xmax)
Melder_fatal (U"analysis ends at ", analysis -> xmax, U", but last interval at ", lastInterval -> xmax, U" seconds");
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order (2).");
Thing_cast (IntervalTier, analysisPhonemeTier, analysis -> tiers->at [4]);
if (! IntervalTier_check (analysisPhonemeTier))
Melder_throw (U"Analysis phoneme tier out of order.");
IntervalTier_removeEmptyIntervals (analysisPhonemeTier, analysisWordTier);
Melder_assert (analysisPhonemeTier -> xmax == analysis -> xmax);
Melder_assert (analysisPhonemeTier -> intervals.size >= 1);
firstInterval = analysisPhonemeTier -> intervals.at [1];
lastInterval = analysisPhonemeTier -> intervals.at [analysisPhonemeTier -> intervals.size];
firstInterval -> xmin = analysis -> xmin;
lastInterval -> xmax = analysis -> xmax;
Melder_assert (lastInterval -> xmax == analysis -> xmax);
if (! IntervalTier_check (analysisPhonemeTier))
Melder_throw (U"Analysis phoneme tier out of order (2).");
}
long wordTierNumber = 0, phonemeTierNumber = 0;
IntervalTier wordTier = nullptr, phonemeTier = nullptr;
/*
* Include a word tier.
*/
if (includeWords) {
/*
* Make sure that the word tier exists.
*/
autoMelderString newWordTierName;
MelderString_copy (& newWordTierName, headTier -> name, U"/word");
for (long itier = 1; itier <= my tiers->size; itier ++) {
IntervalTier tier = static_cast <IntervalTier> (my tiers->at [itier]);
if (Melder_equ (newWordTierName.string, tier -> name)) {
if (tier -> classInfo != classIntervalTier)
Melder_throw (U"A tier with the prospective word tier name (", tier -> name, U") already exists, but it is not an interval tier."
U"\nPlease change its name or remove it.");
wordTierNumber = itier;
break;
}
}
if (! wordTierNumber) {
autoIntervalTier newWordTier = IntervalTier_create (my xmin, my xmax);
Thing_setName (newWordTier.get(), newWordTierName.string);
my tiers -> addItemAtPosition_move (newWordTier.move(), wordTierNumber = tierNumber + 1);
}
Melder_assert (wordTierNumber >= 1 && wordTierNumber <= my tiers->size);
wordTier = static_cast <IntervalTier> (my tiers->at [wordTierNumber]);
/*
* Make sure that the word tier has boundaries at the edges of the interval.
*/
IntervalTier_insertIntervalDestructively (wordTier, interval -> xmin, interval -> xmax);
/*
* Copy the contents of the word analysis into the interval in the word tier.
*/
long wordIntervalNumber = IntervalTier_hasTime (wordTier, interval -> xmin);
Melder_assert (wordIntervalNumber != 0);
if (analysis) {
Thing_cast (IntervalTier, analysisWordTier, analysis -> tiers->at [3]);
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order (3).");
if (! IntervalTier_check (wordTier))
Melder_throw (U"Word tier out of order (3).");
for (long ianalysisInterval = 1; ianalysisInterval <= analysisWordTier -> intervals.size; ianalysisInterval ++) {
TextInterval analysisInterval = analysisWordTier -> intervals.at [ianalysisInterval];
TextInterval wordInterval = nullptr;
double tmin = analysisInterval -> xmin, tmax = analysisInterval -> xmax;
if (tmax == analysis -> xmax) {
wordInterval = wordTier -> intervals.at [wordIntervalNumber];
TextInterval_setText (wordInterval, analysisInterval -> text);
} else {
wordInterval = wordTier -> intervals.at [wordIntervalNumber];
autoTextInterval newInterval = TextInterval_create (tmin, tmax, analysisInterval -> text);
wordInterval -> xmin = tmax;
wordTier -> intervals. addItem_move (newInterval.move());
wordIntervalNumber ++;
}
}
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order (4).");
if (! IntervalTier_check (wordTier))
Melder_throw (U"Word tier out of order (4).");
}
}
/*
* Include a phoneme tier.
*/
if (includePhonemes) {
/*
* Make sure that the phoneme tier exists.
*/
autoMelderString newPhonemeTierName;
MelderString_copy (& newPhonemeTierName, headTier -> name, U"/phon");
for (long itier = 1; itier <= my tiers->size; itier ++) {
IntervalTier tier = (IntervalTier) my tiers->at [itier];
if (Melder_equ (newPhonemeTierName.string, tier -> name)) {
if (tier -> classInfo != classIntervalTier)
Melder_throw (U"A tier with the prospective phoneme tier name (", tier -> name, U") already exists, but it is not an interval tier."
U"\nPlease change its name or remove it.");
phonemeTierNumber = itier;
break;
}
}
if (! phonemeTierNumber) {
autoIntervalTier newPhonemeTier = IntervalTier_create (my xmin, my xmax);
Thing_setName (newPhonemeTier.get(), newPhonemeTierName.string);
my tiers -> addItemAtPosition_move (newPhonemeTier.move(),
phonemeTierNumber = wordTierNumber ? wordTierNumber + 1 : tierNumber + 1);
}
Melder_assert (phonemeTierNumber >= 1 && phonemeTierNumber <= my tiers->size);
phonemeTier = static_cast <IntervalTier> (my tiers->at [phonemeTierNumber]);
/*
* Make sure that the phoneme tier has boundaries at the edges of the interval.
*/
IntervalTier_insertIntervalDestructively (phonemeTier, interval -> xmin, interval -> xmax);
/*
* Copy the contents of the phoneme analysis into the interval in the phoneme tier.
*/
long phonemeIntervalNumber = IntervalTier_hasTime (phonemeTier, interval -> xmin);
Melder_assert (phonemeIntervalNumber != 0);
if (analysis.get()) {
Thing_cast (IntervalTier, analysisPhonemeTier, analysis -> tiers->at [4]);
for (long ianalysisInterval = 1; ianalysisInterval <= analysisPhonemeTier -> intervals.size; ianalysisInterval ++) {
TextInterval analysisInterval = analysisPhonemeTier -> intervals.at [ianalysisInterval];
TextInterval phonemeInterval = nullptr;
double tmin = analysisInterval -> xmin, tmax = analysisInterval -> xmax;
if (tmax == analysis -> xmax) {
phonemeInterval = phonemeTier -> intervals.at [phonemeIntervalNumber];
TextInterval_setText (phonemeInterval, analysisInterval -> text);
} else {
phonemeInterval = phonemeTier -> intervals.at [phonemeIntervalNumber];
autoTextInterval newInterval = TextInterval_create (tmin, tmax, analysisInterval -> text);
phonemeInterval -> xmin = tmax;
phonemeTier -> intervals. addItem_move (newInterval.move());
phonemeIntervalNumber ++;
}
}
}
if (includeWords) {
/*
* Synchronize the boundaries between the word tier and the phoneme tier.
*/
//for (long iinterval = 1; iinterval <=
}
}
} catch (MelderError) {
Melder_throw (me, U" & ", anySound, U": interval not aligned.");
}
}
static void _GraphicsScreen_cellArrayOrImage (GraphicsScreen me, double **z_float, double_rgbt **z_rgbt, unsigned char **z_byte,
long ix1, long ix2, long x1DC, long x2DC,
long iy1, long iy2, long y1DC, long y2DC,
double minimum, double maximum,
long clipx1, long clipx2, long clipy1, long clipy2, int interpolate)
{
/*long t=clock();*/
long nx = ix2 - ix1 + 1; /* The number of cells along the horizontal axis. */
long ny = iy2 - iy1 + 1; /* The number of cells along the vertical axis. */
double dx = (double) (x2DC - x1DC) / (double) nx; /* Horizontal pixels per cell. Positive. */
double dy = (double) (y2DC - y1DC) / (double) ny; /* Vertical pixels per cell. Negative. */
double scale = 255.0 / (maximum - minimum), offset = 255.0 + minimum * scale;
if (x2DC <= x1DC || y1DC <= y2DC) return;
trace ("scale %f", scale);
/* Clip by the intersection of the world window and the outline of the cells. */
//Melder_casual ("clipy1 %ld clipy2 %ld", clipy1, clipy2);
if (clipx1 < x1DC) clipx1 = x1DC;
if (clipx2 > x2DC) clipx2 = x2DC;
if (clipy1 > y1DC) clipy1 = y1DC;
if (clipy2 < y2DC) clipy2 = y2DC;
/*
* The first decision is whether we are going to use the standard rectangle drawing
* (cellArray only), or whether we are going to write into a bitmap.
* The standard drawing is best for small numbers of cells,
* provided that some cells are larger than a pixel.
*/
if (! interpolate && nx * ny < 3000 && (dx > 1.0 || dy < -1.0)) {
try {
/*unsigned int cellWidth = (unsigned int) dx + 1;*/
unsigned int cellHeight = (unsigned int) (- (int) dy) + 1;
long ix, iy;
#if cairo
cairo_pattern_t *grey [256];
for (int igrey = 0; igrey < sizeof (grey) / sizeof (*grey); igrey ++) {
double v = igrey / ((double) (sizeof (grey) / sizeof (*grey)) - 1.0);
grey [igrey] = cairo_pattern_create_rgb (v, v, v);
}
#elif win
static HBRUSH greyBrush [256];
RECT rect;
if (! greyBrush [0])
for (int igrey = 0; igrey <= 255; igrey ++)
greyBrush [igrey] = CreateSolidBrush (RGB (igrey, igrey, igrey)); // once
#elif mac
GraphicsQuartz_initDraw (me);
CGContextSetAlpha (my d_macGraphicsContext, 1.0);
CGContextSetBlendMode (my d_macGraphicsContext, kCGBlendModeNormal);
#endif
autoNUMvector <long> lefts (ix1, ix2 + 1);
for (ix = ix1; ix <= ix2 + 1; ix ++)
lefts [ix] = x1DC + (long) ((ix - ix1) * dx);
for (iy = iy1; iy <= iy2; iy ++) {
long bottom = y1DC + (long) ((iy - iy1) * dy), top = bottom - cellHeight;
if (top > clipy1 || bottom < clipy2) continue;
if (top < clipy2) top = clipy2;
if (bottom > clipy1) bottom = clipy1;
#if win
rect. bottom = bottom; rect. top = top;
#endif
for (ix = ix1; ix <= ix2; ix ++) {
long left = lefts [ix], right = lefts [ix + 1];
if (right < clipx1 || left > clipx2) continue;
if (left < clipx1) left = clipx1;
if (right > clipx2) right = clipx2;
if (z_rgbt) {
#if cairo
// NYI
#elif win
// NYI
#elif mac
double red = z_rgbt [iy] [ix]. red;
double green = z_rgbt [iy] [ix]. green;
double blue = z_rgbt [iy] [ix]. blue;
double transparency = z_rgbt [iy] [ix]. transparency;
red = ( red <= 0.0 ? 0.0 : red >= 1.0 ? 1.0 : red );
green = ( green <= 0.0 ? 0.0 : green >= 1.0 ? 1.0 : green );
blue = ( blue <= 0.0 ? 0.0 : blue >= 1.0 ? 1.0 : blue );
CGContextSetRGBFillColor (my d_macGraphicsContext, red, green, blue, 1.0 - transparency);
CGContextFillRect (my d_macGraphicsContext, CGRectMake (left, top, right - left, bottom - top));
#endif
} else {
#if cairo
long value = offset - scale * ( z_float ? z_float [iy] [ix] : z_byte [iy] [ix] );
cairo_set_source (my d_cairoGraphicsContext, grey [value <= 0 ? 0 : value >= sizeof (grey) / sizeof (*grey) ? sizeof (grey) / sizeof (*grey) : value]);
cairo_rectangle (my d_cairoGraphicsContext, left, top, right - left, bottom - top);
cairo_fill (my d_cairoGraphicsContext);
#elif win
long value = offset - scale * ( z_float ? z_float [iy] [ix] : z_byte [iy] [ix] );
rect. left = left; rect. right = right;
FillRect (my d_gdiGraphicsContext, & rect, greyBrush [value <= 0 ? 0 : value >= 255 ? 255 : value]);
#elif mac
double value = offset - scale * ( z_float ? z_float [iy] [ix] : z_byte [iy] [ix] );
double igrey = ( value <= 0 ? 0 : value >= 255 ? 255 : value ) / 255.0;
CGContextSetRGBFillColor (my d_macGraphicsContext, igrey, igrey, igrey, 1.0);
CGContextFillRect (my d_macGraphicsContext, CGRectMake (left, top, right - left, bottom - top));
#endif
}
}
}
#if cairo
for (int igrey = 0; igrey < sizeof (grey) / sizeof (*grey); igrey ++)
cairo_pattern_destroy (grey [igrey]);
#elif mac
CGContextSetRGBFillColor (my d_macGraphicsContext, 0.0, 0.0, 0.0, 1.0);
GraphicsQuartz_exitDraw (me);
#endif
} catch (MelderError) { }
} else {
long xDC, yDC;
long undersampling = 1;
/*
* Prepare for off-screen bitmap drawing.
*/
#if cairo
long arrayWidth = clipx2 - clipx1;
long arrayHeight = clipy1 - clipy2;
trace ("arrayWidth %f, arrayHeight %f", (double) arrayWidth, (double) arrayHeight);
cairo_surface_t *sfc = cairo_image_surface_create (CAIRO_FORMAT_RGB24, arrayWidth, arrayHeight);
unsigned char *bits = cairo_image_surface_get_data (sfc);
int scanLineLength = cairo_image_surface_get_stride (sfc);
unsigned char grey [256];
trace ("image surface address %p, bits address %p, scanLineLength %d, numberOfGreys %d", sfc, bits, scanLineLength, sizeof(grey)/sizeof(*grey));
for (int igrey = 0; igrey < sizeof (grey) / sizeof (*grey); igrey++)
grey [igrey] = 255 - (unsigned char) (igrey * 255.0 / (sizeof (grey) / sizeof (*grey) - 1));
#elif win
long bitmapWidth = clipx2 - clipx1, bitmapHeight = clipy1 - clipy2;
int igrey;
/*
* Create a device-independent bitmap, 32 bits deep.
*/
struct { BITMAPINFOHEADER header; } bitmapInfo;
long scanLineLength = bitmapWidth * 4; // for 24 bits: (bitmapWidth * 3 + 3) & ~3L;
HBITMAP bitmap;
unsigned char *bits; // a pointer to memory allocated by VirtualAlloc or by CreateDIBSection ()
bitmapInfo. header.biSize = sizeof (BITMAPINFOHEADER);
bitmapInfo. header.biWidth = bitmapWidth; // scanLineLength;
bitmapInfo. header.biHeight = bitmapHeight;
bitmapInfo. header.biPlanes = 1;
bitmapInfo. header.biBitCount = 32;
bitmapInfo. header.biCompression = 0;
bitmapInfo. header.biSizeImage = 0;
bitmapInfo. header.biXPelsPerMeter = 0;
bitmapInfo. header.biYPelsPerMeter = 0;
bitmapInfo. header.biClrUsed = 0;
bitmapInfo. header.biClrImportant = 0;
bitmap = CreateDIBSection (my d_gdiGraphicsContext /* ignored */, (CONST BITMAPINFO *) & bitmapInfo,
DIB_RGB_COLORS, (VOID **) & bits, NULL, 0);
#elif mac
long bytesPerRow = (clipx2 - clipx1) * 4;
Melder_assert (bytesPerRow > 0);
long numberOfRows = clipy1 - clipy2;
Melder_assert (numberOfRows > 0);
unsigned char *imageData = Melder_malloc_f (unsigned char, bytesPerRow * numberOfRows);
#endif
/*
* Draw into the bitmap.
*/
#if cairo
#define ROW_START_ADDRESS (bits + (clipy1 - 1 - yDC) * scanLineLength)
#define PUT_PIXEL \
if (1) { \
unsigned char kar = value <= 0 ? 0 : value >= 255 ? 255 : (int) value; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = 0; \
}
#elif win
#define ROW_START_ADDRESS (bits + (clipy1 - 1 - yDC) * scanLineLength)
#define PUT_PIXEL \
if (1) { \
unsigned char kar = value <= 0 ? 0 : value >= 255 ? 255 : (int) value; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = 0; \
}
#elif mac
#define ROW_START_ADDRESS (imageData + (clipy1 - 1 - yDC) * bytesPerRow)
#define PUT_PIXEL \
if (my colourScale == kGraphics_colourScale_GREY) { \
unsigned char kar = value <= 0 ? 0 : value >= 255 ? 255 : (int) value; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = kar; \
*pixelAddress ++ = 0; \
} else if (my colourScale == kGraphics_colourScale_BLUE_TO_RED) { \
if (value < 0.0) { \
*pixelAddress ++ = 0; \
*pixelAddress ++ = 0; \
*pixelAddress ++ = 63; \
*pixelAddress ++ = 0; \
} else if (value < 64.0) { \
*pixelAddress ++ = 0; \
*pixelAddress ++ = 0; \
*pixelAddress ++ = (int) (value * 3 + 63.999); \
*pixelAddress ++ = 0; \
} else if (value < 128.0) { \
*pixelAddress ++ = (int) (value * 4 - 256.0); \
*pixelAddress ++ = (int) (value * 4 - 256.0); \
*pixelAddress ++ = 255; \
*pixelAddress ++ = 0; \
} else if (value < 192.0) { \
*pixelAddress ++ = 255; \
*pixelAddress ++ = (int) ((256.0 - value) * 4 - 256.0); \
*pixelAddress ++ = (int) ((256.0 - value) * 4 - 256.0); \
*pixelAddress ++ = 0; \
} else if (value < 256.0) { \
*pixelAddress ++ = (int) ((256.0 - value) * 3 + 63.999); \
*pixelAddress ++ = 0; \
*pixelAddress ++ = 0; \
*pixelAddress ++ = 0; \
} else { \
*pixelAddress ++ = 63; \
*pixelAddress ++ = 0; \
*pixelAddress ++ = 0; \
*pixelAddress ++ = 0; \
} \
}
#else
#define ROW_START_ADDRESS NULL
#define PUT_PIXEL
#endif
if (interpolate) {
try {
autoNUMvector <long> ileft (clipx1, clipx2);
autoNUMvector <long> iright (clipx1, clipx2);
autoNUMvector <double> rightWeight (clipx1, clipx2);
autoNUMvector <double> leftWeight (clipx1, clipx2);
for (xDC = clipx1; xDC < clipx2; xDC += undersampling) {
double ix_real = ix1 - 0.5 + ((double) nx * (xDC - x1DC)) / (x2DC - x1DC);
ileft [xDC] = floor (ix_real), iright [xDC] = ileft [xDC] + 1;
rightWeight [xDC] = ix_real - ileft [xDC], leftWeight [xDC] = 1.0 - rightWeight [xDC];
if (ileft [xDC] < ix1) ileft [xDC] = ix1;
if (iright [xDC] > ix2) iright [xDC] = ix2;
}
for (yDC = clipy2; yDC < clipy1; yDC += undersampling) {
double iy_real = iy2 + 0.5 - ((double) ny * (yDC - y2DC)) / (y1DC - y2DC);
long itop = ceil (iy_real), ibottom = itop - 1;
double bottomWeight = itop - iy_real, topWeight = 1.0 - bottomWeight;
unsigned char *pixelAddress = ROW_START_ADDRESS;
if (itop > iy2) itop = iy2;
if (ibottom < iy1) ibottom = iy1;
if (z_float) {
double *ztop = z_float [itop], *zbottom = z_float [ibottom];
for (xDC = clipx1; xDC < clipx2; xDC += undersampling) {
double interpol =
rightWeight [xDC] *
(topWeight * ztop [iright [xDC]] + bottomWeight * zbottom [iright [xDC]]) +
leftWeight [xDC] *
(topWeight * ztop [ileft [xDC]] + bottomWeight * zbottom [ileft [xDC]]);
double value = offset - scale * interpol;
PUT_PIXEL
}
} else if (z_rgbt) {
double_rgbt *ztop = z_rgbt [itop], *zbottom = z_rgbt [ibottom];
for (xDC = clipx1; xDC < clipx2; xDC += undersampling) {
double red =
rightWeight [xDC] * (topWeight * ztop [iright [xDC]]. red + bottomWeight * zbottom [iright [xDC]]. red) +
leftWeight [xDC] * (topWeight * ztop [ileft [xDC]]. red + bottomWeight * zbottom [ileft [xDC]]. red);
double green =
rightWeight [xDC] * (topWeight * ztop [iright [xDC]]. green + bottomWeight * zbottom [iright [xDC]]. green) +
leftWeight [xDC] * (topWeight * ztop [ileft [xDC]]. green + bottomWeight * zbottom [ileft [xDC]]. green);
double blue =
rightWeight [xDC] * (topWeight * ztop [iright [xDC]]. blue + bottomWeight * zbottom [iright [xDC]]. blue) +
leftWeight [xDC] * (topWeight * ztop [ileft [xDC]]. blue + bottomWeight * zbottom [ileft [xDC]]. blue);
double transparency =
rightWeight [xDC] * (topWeight * ztop [iright [xDC]]. transparency + bottomWeight * zbottom [iright [xDC]]. transparency) +
leftWeight [xDC] * (topWeight * ztop [ileft [xDC]]. transparency + bottomWeight * zbottom [ileft [xDC]]. transparency);
if (red < 0.0) red = 0.0; else if (red > 1.0) red = 1.0;
if (green < 0.0) green = 0.0; else if (green > 1.0) green = 1.0;
if (blue < 0.0) blue = 0.0; else if (blue > 1.0) blue = 1.0;
if (transparency < 0.0) transparency = 0.0; else if (transparency > 1.0) transparency = 1.0;
#if win
*pixelAddress ++ = blue * 255.0;
*pixelAddress ++ = green * 255.0;
*pixelAddress ++ = red * 255.0;
*pixelAddress ++ = 0;
#elif mac
*pixelAddress ++ = red * 255.0;
*pixelAddress ++ = green * 255.0;
*pixelAddress ++ = blue * 255.0;
*pixelAddress ++ = transparency * 255.0;
#elif cairo
*pixelAddress ++ = blue * 255.0;
*pixelAddress ++ = green * 255.0;
*pixelAddress ++ = red * 255.0;
*pixelAddress ++ = transparency * 255.0;
#endif
}
} else {
unsigned char *ztop = z_byte [itop], *zbottom = z_byte [ibottom];
for (xDC = clipx1; xDC < clipx2; xDC += undersampling) {
double interpol =
rightWeight [xDC] *
(topWeight * ztop [iright [xDC]] + bottomWeight * zbottom [iright [xDC]]) +
leftWeight [xDC] *
(topWeight * ztop [ileft [xDC]] + bottomWeight * zbottom [ileft [xDC]]);
double value = offset - scale * interpol;
PUT_PIXEL
}
}
}
} catch (MelderError) { Melder_clearError (); }
} else {
try {
autoNUMvector <long> ix (clipx1, clipx2);
for (xDC = clipx1; xDC < clipx2; xDC += undersampling)
ix [xDC] = floor (ix1 + (nx * (xDC - x1DC)) / (x2DC - x1DC));
for (yDC = clipy2; yDC < clipy1; yDC += undersampling) {
long iy = ceil (iy2 - (ny * (yDC - y2DC)) / (y1DC - y2DC));
unsigned char *pixelAddress = ROW_START_ADDRESS;
Melder_assert (iy >= iy1 && iy <= iy2);
if (z_float) {
double *ziy = z_float [iy];
for (xDC = clipx1; xDC < clipx2; xDC += undersampling) {
double value = offset - scale * ziy [ix [xDC]];
PUT_PIXEL
}
} else {
unsigned char *ziy = z_byte [iy];
for (xDC = clipx1; xDC < clipx2; xDC += undersampling) {
double value = offset - scale * ziy [ix [xDC]];
PUT_PIXEL
}
}
}
} catch (MelderError) { Melder_clearError (); }
}
/*
* Copy the bitmap to the screen.
*/
#if cairo
cairo_matrix_t clip_trans;
cairo_matrix_init_identity (& clip_trans);
cairo_matrix_scale (& clip_trans, 1, -1); // we painted in the reverse y-direction
cairo_matrix_translate (& clip_trans, - clipx1, - clipy1);
cairo_pattern_t *bitmap_pattern = cairo_pattern_create_for_surface (sfc);
trace ("bitmap pattern %p", bitmap_pattern);
if (cairo_status_t status = cairo_pattern_status (bitmap_pattern)) {
Melder_casual ("bitmap pattern status: %s", cairo_status_to_string (status));
} else {
cairo_pattern_set_matrix (bitmap_pattern, & clip_trans);
cairo_save (my d_cairoGraphicsContext);
cairo_set_source (my d_cairoGraphicsContext, bitmap_pattern);
cairo_paint (my d_cairoGraphicsContext);
cairo_restore (my d_cairoGraphicsContext);
}
cairo_pattern_destroy (bitmap_pattern);
#elif win
SetDIBitsToDevice (my d_gdiGraphicsContext, clipx1, clipy2, bitmapWidth, bitmapHeight, 0, 0, 0, bitmapHeight,
bits, (CONST BITMAPINFO *) & bitmapInfo, DIB_RGB_COLORS);
//StretchDIBits (my d_gdiGraphicsContext, clipx1, clipy2, bitmapWidth, bitmapHeight, 0, 0, 0, bitmapHeight,
// bits, (CONST BITMAPINFO *) & bitmapInfo, DIB_RGB_COLORS, SRCCOPY);
#elif mac
CGImageRef image;
static CGColorSpaceRef colourSpace = NULL;
if (colourSpace == NULL) {
colourSpace = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB); // used to be kCGColorSpaceUserRGB
Melder_assert (colourSpace != NULL);
}
if (1) {
CGDataProviderRef dataProvider = CGDataProviderCreateWithData (NULL,
imageData,
bytesPerRow * numberOfRows,
_mac_releaseDataCallback // we need this because we cannot release the image data immediately after drawing,
// because in PDF files the imageData has to stay available through EndPage
);
Melder_assert (dataProvider != NULL);
image = CGImageCreate (clipx2 - clipx1, numberOfRows,
8, 32, bytesPerRow, colourSpace, kCGImageAlphaNone, dataProvider, NULL, false, kCGRenderingIntentDefault);
CGDataProviderRelease (dataProvider);
} else if (0) {
Melder_assert (CGBitmapContextCreate != NULL);
CGContextRef bitmaptest = CGBitmapContextCreate (imageData, 100, 100,
8, 800, colourSpace, 0);
Melder_assert (bitmaptest != NULL);
CGContextRef bitmap = CGBitmapContextCreate (NULL/*imageData*/, clipx2 - clipx1, numberOfRows,
8, bytesPerRow, colourSpace, kCGImageAlphaLast);
Melder_assert (bitmap != NULL);
image = CGBitmapContextCreateImage (bitmap);
// release bitmap?
}
Melder_assert (image != NULL);
GraphicsQuartz_initDraw (me);
CGContextDrawImage (my d_macGraphicsContext, CGRectMake (clipx1, clipy2, clipx2 - clipx1, clipy1 - clipy2), image);
GraphicsQuartz_exitDraw (me);
//CGColorSpaceRelease (colourSpace);
CGImageRelease (image);
#endif
/*
* Clean up.
*/
#if cairo
cairo_surface_destroy (sfc);
#elif win
DeleteBitmap (bitmap);
#endif
}
char32 *str_replace_regexp (const char32 *string, regexp *compiledSearchRE,
const char32 *replaceRE, long maximumNumberOfReplaces, long *nmatches) {
int buf_nchar = 0; /* # characters in 'buf' */
int gap_copied = 0;
int nchar, reverse = 0;
int errorType;
char32 prev_char = '\0';
const char32 *pos; /* current position in 'string' / start of current match */
const char32 *posp; /* end of previous match */
autostring32 buf;
*nmatches = 0;
if (string == 0 || compiledSearchRE == 0 || replaceRE == 0) {
return 0;
}
int string_length = str32len (string);
//int replace_length = str32len (replaceRE);
if (string_length == 0) {
maximumNumberOfReplaces = 1;
}
long i = maximumNumberOfReplaces > 0 ? 0 : - string_length;
/*
We do not know the size of the replaced string in advance,
therefor, we allocate a replace buffer twice the size of the
original string. After all replaces have taken place we do a
final realloc to the then exactly known size.
If during the replace, the size of the buffer happens to be too
small (this is signalled by the replaceRE function),
we double its size and restart the replace.
*/
int buf_size = 2 * string_length;
buf_size = buf_size < 100 ? 100 : buf_size;
buf.resize (buf_size);
pos = posp = string;
while (ExecRE (compiledSearchRE, 0, pos, 0, reverse, prev_char, '\0', 0, 0, 0) && i++ < maximumNumberOfReplaces) {
/*
Copy gap between the end of the previous match and the start
of the current match.
Check buffer overflow. pos == posp ? '\0' : pos[-1],
*/
pos = compiledSearchRE -> startp[0];
nchar = pos - posp;
if (nchar > 0 && ! gap_copied) {
if (buf_nchar + nchar + 1 > buf_size) {
buf_size *= 2;
buf.resize (buf_size);
}
str32ncpy (buf.peek() + buf_nchar, posp, nchar);
buf_nchar += nchar;
}
gap_copied = 1;
/*
Do the substitution. We can only check afterwards for buffer
overflow. SubstituteRE puts null byte at last replaced position and signals when overflow.
*/
if ( (SubstituteRE (compiledSearchRE, replaceRE, buf.peek() + buf_nchar, buf_size - buf_nchar, &errorType)) == false) {
if (errorType == 1) { // not enough memory
buf_size *= 2;
buf.resize (buf_size);
Melder_clearError ();
i--; // retry
continue;
}
Melder_throw (U"Error during substitution.");
}
// Buffer is not full, get number of characters added;
nchar = str32len (buf.peek() + buf_nchar);
buf_nchar += nchar;
// Update next start position in search string.
posp = pos;
pos = (char32 *) compiledSearchRE -> endp[0];
if (pos != posp) {
prev_char = pos[-1];
}
gap_copied = 0;
posp = pos; //pb 20080121
(*nmatches) ++;
// at end of string?
// we need this because .* matches at end of a string
if (pos - string == string_length) {
break;
}
}
// Copy last part of string to destination string
nchar = (string + string_length) - pos;
buf_size = buf_nchar + nchar + 1;
buf.resize (buf_size);
str32ncpy (buf.peek() + buf_nchar, pos, nchar);
buf[buf_size - 1] = '\0';
return buf.transfer();
}
void TimeSoundEditor_drawSound (TimeSoundEditor me, double globalMinimum, double globalMaximum) {
Sound sound = my d_sound.data;
LongSound longSound = my d_longSound.data;
Melder_assert (!! sound != !! longSound);
int nchan = sound ? sound -> ny : longSound -> numberOfChannels;
bool cursorVisible = my d_startSelection == my d_endSelection && my d_startSelection >= my d_startWindow && my d_startSelection <= my d_endWindow;
Graphics_setColour (my d_graphics, Graphics_BLACK);
bool fits;
try {
fits = sound ? true : LongSound_haveWindow (longSound, my d_startWindow, my d_endWindow);
} catch (MelderError) {
bool outOfMemory = !! str32str (Melder_getError (), U"memory");
if (Melder_debug == 9) Melder_flushError (); else Melder_clearError ();
Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0);
Graphics_setTextAlignment (my d_graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_text (my d_graphics, 0.5, 0.5, outOfMemory ? U"(out of memory)" : U"(cannot read sound file)");
return;
}
if (! fits) {
Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0);
Graphics_setTextAlignment (my d_graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_text (my d_graphics, 0.5, 0.5, U"(window too large; zoom in to see the data)");
return;
}
long first, last;
if (Sampled_getWindowSamples (sound ? (Sampled) sound : (Sampled) longSound, my d_startWindow, my d_endWindow, & first, & last) <= 1) {
Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0);
Graphics_setTextAlignment (my d_graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_text (my d_graphics, 0.5, 0.5, U"(zoom out to see the data)");
return;
}
const int numberOfVisibleChannels = nchan > 8 ? 8 : nchan;
const int firstVisibleChannel = my d_sound.channelOffset + 1;
int lastVisibleChannel = my d_sound.channelOffset + numberOfVisibleChannels;
if (lastVisibleChannel > nchan) lastVisibleChannel = nchan;
double maximumExtent = 0.0, visibleMinimum = 0.0, visibleMaximum = 0.0;
if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW) {
if (longSound)
LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, firstVisibleChannel, & visibleMinimum, & visibleMaximum);
else
Matrix_getWindowExtrema (sound, first, last, firstVisibleChannel, firstVisibleChannel, & visibleMinimum, & visibleMaximum);
for (int ichan = firstVisibleChannel + 1; ichan <= lastVisibleChannel; ichan ++) {
double visibleChannelMinimum, visibleChannelMaximum;
if (longSound)
LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & visibleChannelMinimum, & visibleChannelMaximum);
else
Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & visibleChannelMinimum, & visibleChannelMaximum);
if (visibleChannelMinimum < visibleMinimum)
visibleMinimum = visibleChannelMinimum;
if (visibleChannelMaximum > visibleMaximum)
visibleMaximum = visibleChannelMaximum;
}
maximumExtent = visibleMaximum - visibleMinimum;
}
for (int ichan = firstVisibleChannel; ichan <= lastVisibleChannel; ichan ++) {
double cursorFunctionValue = longSound ? 0.0 :
Vector_getValueAtX (sound, 0.5 * (my d_startSelection + my d_endSelection), ichan, 70);
/*
* BUG: this will only work for mono or stereo, until Graphics_function16 handles quadro.
*/
double ymin = (double) (numberOfVisibleChannels - ichan + my d_sound.channelOffset) / numberOfVisibleChannels;
double ymax = (double) (numberOfVisibleChannels + 1 - ichan + my d_sound.channelOffset) / numberOfVisibleChannels;
Graphics_Viewport vp = Graphics_insetViewport (my d_graphics, 0, 1, ymin, ymax);
bool horizontal = false;
double minimum = sound ? globalMinimum : -1.0, maximum = sound ? globalMaximum : 1.0;
if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW) {
if (nchan > 2) {
if (longSound) {
LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & minimum, & maximum);
} else {
Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & minimum, & maximum);
}
if (maximumExtent > 0.0) {
double middle = 0.5 * (minimum + maximum);
minimum = middle - 0.5 * maximumExtent;
maximum = middle + 0.5 * maximumExtent;
}
} else {
minimum = visibleMinimum;
maximum = visibleMaximum;
}
} else if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW_AND_CHANNEL) {
if (longSound) {
LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & minimum, & maximum);
} else {
Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & minimum, & maximum);
}
} else if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_HEIGHT) {
if (longSound) {
LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & minimum, & maximum);
} else {
Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & minimum, & maximum);
}
double channelExtent = my p_sound_scaling_height;
double middle = 0.5 * (minimum + maximum);
minimum = middle - 0.5 * channelExtent;
maximum = middle + 0.5 * channelExtent;
} else if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_RANGE) {
minimum = my p_sound_scaling_minimum;
maximum = my p_sound_scaling_maximum;
}
if (minimum == maximum) { horizontal = true; minimum -= 1.0; maximum += 1.0;}
Graphics_setWindow (my d_graphics, my d_startWindow, my d_endWindow, minimum, maximum);
if (horizontal) {
Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_HALF);
double mid = 0.5 * (minimum + maximum);
Graphics_text (my d_graphics, my d_startWindow, mid, Melder_float (Melder_half (mid)));
} else {
if (! cursorVisible || ! NUMdefined (cursorFunctionValue) || Graphics_dyWCtoMM (my d_graphics, cursorFunctionValue - minimum) > 5.0) {
Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_BOTTOM);
Graphics_text (my d_graphics, my d_startWindow, minimum, Melder_float (Melder_half (minimum)));
}
if (! cursorVisible || ! NUMdefined (cursorFunctionValue) || Graphics_dyWCtoMM (my d_graphics, maximum - cursorFunctionValue) > 5.0) {
Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_TOP);
Graphics_text (my d_graphics, my d_startWindow, maximum, Melder_float (Melder_half (maximum)));
}
}
if (minimum < 0 && maximum > 0 && ! horizontal) {
Graphics_setWindow (my d_graphics, 0, 1, minimum, maximum);
if (! cursorVisible || ! NUMdefined (cursorFunctionValue) || fabs (Graphics_dyWCtoMM (my d_graphics, cursorFunctionValue - 0.0)) > 3.0) {
Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_HALF);
Graphics_text (my d_graphics, 0, 0, U"0");
}
Graphics_setColour (my d_graphics, Graphics_CYAN);
Graphics_setLineType (my d_graphics, Graphics_DOTTED);
Graphics_line (my d_graphics, 0, 0, 1, 0);
Graphics_setLineType (my d_graphics, Graphics_DRAWN);
}
/*
* Garnish the drawing area of each channel.
*/
Graphics_setWindow (my d_graphics, 0, 1, 0, 1);
Graphics_setColour (my d_graphics, Graphics_CYAN);
Graphics_innerRectangle (my d_graphics, 0, 1, 0, 1);
Graphics_setColour (my d_graphics, Graphics_BLACK);
if (nchan > 1) {
Graphics_setTextAlignment (my d_graphics, Graphics_LEFT, Graphics_HALF);
const char32 *channelName = my v_getChannelName (ichan);
static MelderString channelLabel;
MelderString_copy (& channelLabel, ( channelName ? U"ch" : U"Channel " ), ichan);
if (channelName)
MelderString_append (& channelLabel, U": ", channelName);
if (ichan > 8 && ichan - my d_sound.channelOffset == 1) {
MelderString_append (& channelLabel, U" " UNITEXT_UPWARDS_ARROW);
} else if (ichan >= 8 && ichan - my d_sound.channelOffset == 8 && ichan < nchan) {
MelderString_append (& channelLabel, U" " UNITEXT_DOWNWARDS_ARROW);
}
Graphics_text (my d_graphics, 1, 0.5, channelLabel.string);
}
/*
* Draw a very thin separator line underneath.
*/
if (ichan < nchan) {
/*Graphics_setColour (d_graphics, Graphics_BLACK);*/
Graphics_line (my d_graphics, 0, 0, 1, 0);
}
/*
* Draw the samples.
*/
/*if (ichan == 1) FunctionEditor_SoundAnalysis_drawPulses (this);*/
if (sound) {
Graphics_setWindow (my d_graphics, my d_startWindow, my d_endWindow, minimum, maximum);
if (cursorVisible && NUMdefined (cursorFunctionValue))
FunctionEditor_drawCursorFunctionValue (me, cursorFunctionValue, Melder_float (Melder_half (cursorFunctionValue)), U"");
Graphics_setColour (my d_graphics, Graphics_BLACK);
Graphics_function (my d_graphics, sound -> z [ichan], first, last,
Sampled_indexToX (sound, first), Sampled_indexToX (sound, last));
} else {
Graphics_setWindow (my d_graphics, my d_startWindow, my d_endWindow, minimum * 32768, maximum * 32768);
Graphics_function16 (my d_graphics,
longSound -> buffer - longSound -> imin * nchan + (ichan - 1), nchan - 1, first, last,
Sampled_indexToX (longSound, first), Sampled_indexToX (longSound, last));
}
Graphics_resetViewport (my d_graphics, vp);
}
Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0);
Graphics_rectangle (my d_graphics, 0.0, 1.0, 0.0, 1.0);
}
void Sampled_drawInside (Sampled me, Graphics g, double xmin, double xmax, double ymin, double ymax,
double speckle_mm, long ilevel, int unit)
{
try {
if (speckle_mm != 0.0) {
Sampled_speckleInside (me, g, xmin, xmax, ymin, ymax, speckle_mm, ilevel, unit);
return;
}
Function_unidirectionalAutowindow (me, & xmin, & xmax);
long ixmin, ixmax, startOfDefinedStretch = -1;
Sampled_getWindowSamples (me, xmin, xmax, & ixmin, & ixmax);
if (Function_isUnitLogarithmic (me, ilevel, unit)) {
ymin = Function_convertStandardToSpecialUnit (me, ymin, ilevel, unit);
ymax = Function_convertStandardToSpecialUnit (me, ymax, ilevel, unit);
}
if (ymax <= ymin) return;
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
autoNUMvector <double> xarray (ixmin - 1, ixmax + 1);
autoNUMvector <double> yarray (ixmin - 1, ixmax + 1);
double previousValue = Sampled_getValueAtSample (me, ixmin - 1, ilevel, unit);
if (NUMdefined (previousValue)) {
startOfDefinedStretch = ixmin - 1;
xarray [ixmin - 1] = Sampled_indexToX (me, ixmin - 1);
yarray [ixmin - 1] = previousValue;
}
for (long ix = ixmin; ix <= ixmax; ix ++) {
double x = Sampled_indexToX (me, ix), value = Sampled_getValueAtSample (me, ix, ilevel, unit);
if (NUMdefined (value)) {
if (NUMdefined (previousValue)) {
xarray [ix] = x;
yarray [ix] = value;
} else {
startOfDefinedStretch = ix - 1;
xarray [ix - 1] = x - 0.5 * my dx;
yarray [ix - 1] = value;
xarray [ix] = x;
yarray [ix] = value;
}
} else if (NUMdefined (previousValue)) {
Melder_assert (startOfDefinedStretch >= ixmin - 1);
if (ix > ixmin) {
xarray [ix] = x - 0.5 * my dx;
yarray [ix] = previousValue;
if (xarray [startOfDefinedStretch] < xmin) {
double phase = (xmin - xarray [startOfDefinedStretch]) / my dx;
xarray [startOfDefinedStretch] = xmin;
yarray [startOfDefinedStretch] = phase * yarray [startOfDefinedStretch + 1] + (1.0 - phase) * yarray [startOfDefinedStretch];
}
Graphics_polyline (g, ix + 1 - startOfDefinedStretch, & xarray [startOfDefinedStretch], & yarray [startOfDefinedStretch]);
}
startOfDefinedStretch = -1;
}
previousValue = value;
}
if (startOfDefinedStretch > -1) {
double x = Sampled_indexToX (me, ixmax + 1), value = Sampled_getValueAtSample (me, ixmax + 1, ilevel, unit);
Melder_assert (NUMdefined (previousValue));
if (NUMdefined (value)) {
xarray [ixmax + 1] = x;
yarray [ixmax + 1] = value;
} else {
xarray [ixmax + 1] = x - 0.5 * my dx;
yarray [ixmax + 1] = previousValue;
}
if (xarray [startOfDefinedStretch] < xmin) {
double phase = (xmin - xarray [startOfDefinedStretch]) / my dx;
xarray [startOfDefinedStretch] = xmin;
yarray [startOfDefinedStretch] = phase * yarray [startOfDefinedStretch + 1] + (1.0 - phase) * yarray [startOfDefinedStretch];
}
if (xarray [ixmax + 1] > xmax) {
double phase = (xarray [ixmax + 1] - xmax) / my dx;
xarray [ixmax + 1] = xmax;
yarray [ixmax + 1] = phase * yarray [ixmax] + (1.0 - phase) * yarray [ixmax + 1];
}
Graphics_polyline (g, ixmax + 2 - startOfDefinedStretch, & xarray [startOfDefinedStretch], & yarray [startOfDefinedStretch]);
}
} catch (MelderError) {
Melder_clearError ();
}
}
void SoundEditor::prepareDraw () {
if (_longSound.data) {
LongSound_haveWindow (_longSound.data, _startWindow, _endWindow);
Melder_clearError ();
}
}
int HyperPage_script (I, double width_inches, double height_inches, const wchar_t *script) {
iam (HyperPage);
wchar_t *text = Melder_wcsdup_f (script);
Interpreter interpreter = Interpreter_createFromEnvironment (NULL);
double topSpacing = 0.1, bottomSpacing = 0.1, minFooterDistance = 0.0;
kGraphics_font font = my font;
int size = my fontSize;
double true_width_inches = width_inches * ( width_inches < 0.0 ? -1.0 : size / 12.0 );
double true_height_inches = height_inches * ( height_inches < 0.0 ? -1.0 : size / 12.0 );
if (! my printing) {
my d_y -= ( my previousBottomSpacing > topSpacing ? my previousBottomSpacing : topSpacing ) * size / 12.0;
if (my d_y > PAGE_HEIGHT + true_height_inches || my d_y < PAGE_HEIGHT - SCREEN_HEIGHT) {
my d_y -= true_height_inches;
} else {
my d_y -= true_height_inches;
Graphics_setFont (my g, font);
Graphics_setFontStyle (my g, 0);
Graphics_setFontSize (my g, size);
my d_x = true_width_inches > my rightMargin ? 0 : 0.5 * (my rightMargin - true_width_inches);
Graphics_setWrapWidth (my g, 0);
long x1DCold, x2DCold, y1DCold, y2DCold;
Graphics_inqWsViewport (my g, & x1DCold, & x2DCold, & y1DCold, & y2DCold);
double x1NDCold, x2NDCold, y1NDCold, y2NDCold;
Graphics_inqWsWindow (my g, & x1NDCold, & x2NDCold, & y1NDCold, & y2NDCold);
{
if (my praatApplication == NULL) my praatApplication = Melder_calloc_f (structPraatApplication, 1);
if (my praatObjects == NULL) my praatObjects = Melder_calloc_f (structPraatObjects, 1);
if (my praatPicture == NULL) my praatPicture = Melder_calloc_f (structPraatPicture, 1);
theCurrentPraatApplication = (PraatApplication) my praatApplication;
theCurrentPraatApplication -> batch = true; // prevent creation of editor windows
theCurrentPraatApplication -> topShell = theForegroundPraatApplication. topShell; // needed for UiForm_create () in dialogs
theCurrentPraatObjects = (PraatObjects) my praatObjects;
theCurrentPraatPicture = (PraatPicture) my praatPicture;
theCurrentPraatPicture -> graphics = my g; // has to draw into HyperPage rather than Picture window
theCurrentPraatPicture -> font = font;
theCurrentPraatPicture -> fontSize = size;
theCurrentPraatPicture -> lineType = Graphics_DRAWN;
theCurrentPraatPicture -> colour = Graphics_BLACK;
theCurrentPraatPicture -> lineWidth = 1.0;
theCurrentPraatPicture -> arrowSize = 1.0;
theCurrentPraatPicture -> x1NDC = my d_x;
theCurrentPraatPicture -> x2NDC = my d_x + true_width_inches;
theCurrentPraatPicture -> y1NDC = my d_y;
theCurrentPraatPicture -> y2NDC = my d_y + true_height_inches;
Graphics_setViewport (my g, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
Graphics_setWindow (my g, 0.0, 1.0, 0.0, 1.0);
long x1DC, y1DC, x2DC, y2DC;
Graphics_WCtoDC (my g, 0.0, 0.0, & x1DC, & y2DC);
Graphics_WCtoDC (my g, 1.0, 1.0, & x2DC, & y1DC);
Graphics_resetWsViewport (my g, x1DC, x2DC, y1DC, y2DC);
Graphics_setWsWindow (my g, 0, width_inches, 0, height_inches);
theCurrentPraatPicture -> x1NDC = 0;
theCurrentPraatPicture -> x2NDC = width_inches;
theCurrentPraatPicture -> y1NDC = 0;
theCurrentPraatPicture -> y2NDC = height_inches;
Graphics_setViewport (my g, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
{ // scope
autoMelderProgressOff progress;
autoMelderWarningOff warning;
autoMelderSaveDefaultDir saveDir;
if (! MelderDir_isNull (& my rootDirectory)) {
Melder_setDefaultDir (& my rootDirectory);
}
try {
Interpreter_run (interpreter, text);
} catch (MelderError) {
if (my scriptErrorHasBeenNotified) {
Melder_clearError ();
} else {
Melder_flushError (NULL);
my scriptErrorHasBeenNotified = true;
}
}
}
Graphics_setLineType (my g, Graphics_DRAWN);
Graphics_setLineWidth (my g, 1.0);
Graphics_setArrowSize (my g, 1.0);
Graphics_setColour (my g, Graphics_BLACK);
/*Graphics_Link *paragraphLinks;
long numberOfParagraphLinks = Graphics_getLinks (& paragraphLinks);
if (my links) for (long ilink = 1; ilink <= numberOfParagraphLinks; ilink ++) {
HyperLink link = HyperLink_create (paragraphLinks [ilink]. name,
paragraphLinks [ilink]. x1, paragraphLinks [ilink]. x2,
paragraphLinks [ilink]. y1, paragraphLinks [ilink]. y2);
Collection_addItem (my links, link);
}*/
theCurrentPraatApplication = & theForegroundPraatApplication;
theCurrentPraatObjects = & theForegroundPraatObjects;
theCurrentPraatPicture = & theForegroundPraatPicture;
}
Graphics_resetWsViewport (my g, x1DCold, x2DCold, y1DCold, y2DCold);
Graphics_setWsWindow (my g, x1NDCold, x2NDCold, y1NDCold, y2NDCold);
Graphics_setViewport (my g, 0, 1, 0, 1);
Graphics_setWindow (my g, 0, 1, 0, 1);
Graphics_setTextAlignment (my g, Graphics_LEFT, Graphics_BOTTOM);
}
} else {
Graphics_setFont (my ps, font);
Graphics_setFontStyle (my ps, 0);
Graphics_setFontSize (my ps, size);
my d_y -= my d_y == PAPER_TOP - TOP_MARGIN ? 0 : ( my previousBottomSpacing > topSpacing ? my previousBottomSpacing : topSpacing ) * size / 12.0;
my d_y -= true_height_inches;
if (my d_y < PAPER_BOTTOM + BOTTOM_MARGIN + minFooterDistance) {
Graphics_nextSheetOfPaper (my ps);
if (my d_printingPageNumber) my d_printingPageNumber ++;
HyperPage_initSheetOfPaper (me);
Graphics_setFont (my ps, font);
Graphics_setFontSize (my ps, size);
my d_y -= true_height_inches;
}
my d_x = 3.7 - 0.5 * true_width_inches;
if (my d_x < 0) my d_x = 0;
Graphics_setWrapWidth (my ps, 0);
long x1DCold, x2DCold, y1DCold, y2DCold;
Graphics_inqWsViewport (my ps, & x1DCold, & x2DCold, & y1DCold, & y2DCold);
double x1NDCold, x2NDCold, y1NDCold, y2NDCold;
Graphics_inqWsWindow (my ps, & x1NDCold, & x2NDCold, & y1NDCold, & y2NDCold);
{
if (my praatApplication == NULL) my praatApplication = Melder_calloc_f (structPraatApplication, 1);
if (my praatObjects == NULL) my praatObjects = Melder_calloc_f (structPraatObjects, 1);
if (my praatPicture == NULL) my praatPicture = Melder_calloc_f (structPraatPicture, 1);
theCurrentPraatApplication = (PraatApplication) my praatApplication;
theCurrentPraatApplication -> batch = true;
theCurrentPraatApplication -> topShell = theForegroundPraatApplication. topShell; // needed for UiForm_create () in dialogs
theCurrentPraatObjects = (PraatObjects) my praatObjects;
theCurrentPraatPicture = (PraatPicture) my praatPicture;
theCurrentPraatPicture -> graphics = my ps;
theCurrentPraatPicture -> font = font;
theCurrentPraatPicture -> fontSize = size;
theCurrentPraatPicture -> lineType = Graphics_DRAWN;
theCurrentPraatPicture -> colour = Graphics_BLACK;
theCurrentPraatPicture -> lineWidth = 1.0;
theCurrentPraatPicture -> arrowSize = 1.0;
theCurrentPraatPicture -> x1NDC = my d_x;
theCurrentPraatPicture -> x2NDC = my d_x + true_width_inches;
theCurrentPraatPicture -> y1NDC = my d_y;
theCurrentPraatPicture -> y2NDC = my d_y + true_height_inches;
Graphics_setViewport (my ps, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
Graphics_setWindow (my ps, 0.0, 1.0, 0.0, 1.0);
long x1DC, y1DC, x2DC, y2DC;
Graphics_WCtoDC (my ps, 0.0, 0.0, & x1DC, & y2DC);
Graphics_WCtoDC (my ps, 1.0, 1.0, & x2DC, & y1DC);
long shift = (long) (Graphics_getResolution (my ps) * true_height_inches) + (y1DCold - y2DCold);
Graphics_resetWsViewport (my ps, x1DC, x2DC, y1DC + shift, y2DC + shift);
Graphics_setWsWindow (my ps, 0, width_inches, 0, height_inches);
theCurrentPraatPicture -> x1NDC = 0;
theCurrentPraatPicture -> x2NDC = width_inches;
theCurrentPraatPicture -> y1NDC = 0;
theCurrentPraatPicture -> y2NDC = height_inches;
Graphics_setViewport (my ps, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
{ // scope
autoMelderProgressOff progress;
autoMelderWarningOff warning;
autoMelderSaveDefaultDir saveDir;
if (! MelderDir_isNull (& my rootDirectory)) {
Melder_setDefaultDir (& my rootDirectory);
}
try {
Interpreter_run (interpreter, text);
} catch (MelderError) {
Melder_clearError ();
}
}
Graphics_setLineType (my ps, Graphics_DRAWN);
Graphics_setLineWidth (my ps, 1.0);
Graphics_setArrowSize (my ps, 1.0);
Graphics_setColour (my ps, Graphics_BLACK);
theCurrentPraatApplication = & theForegroundPraatApplication;
theCurrentPraatObjects = & theForegroundPraatObjects;
theCurrentPraatPicture = & theForegroundPraatPicture;
}
Graphics_resetWsViewport (my ps, x1DCold, x2DCold, y1DCold, y2DCold);
Graphics_setWsWindow (my ps, x1NDCold, x2NDCold, y1NDCold, y2NDCold);
Graphics_setViewport (my ps, 0, 1, 0, 1);
Graphics_setWindow (my ps, 0, 1, 0, 1);
Graphics_setTextAlignment (my ps, Graphics_LEFT, Graphics_BOTTOM);
}
my previousBottomSpacing = bottomSpacing;
forget (interpreter);
Melder_free (text);
return 1;
}
/*
This routine is modeled after qdiag.m from Andreas Ziehe, Pavel Laskov, Guido Nolte, Klaus-Robert Müller,
A Fast Algorithm for Joint Diagonalization with Non-orthogonal Transformations and its Application to
Blind Source Separation, Journal of Machine Learning Research 5 (2004), 777–800.
*/
static void Diagonalizer_and_CrossCorrelationTables_ffdiag (Diagonalizer me, CrossCorrelationTables thee, long maxNumberOfIterations, double delta) {
try {
long iter = 0, dimension = my numberOfRows;
double **v = my data;
autoCrossCorrelationTables ccts = CrossCorrelationTables_and_Diagonalizer_diagonalize (thee, me);
autoNUMmatrix<double> w (1, dimension, 1, dimension);
autoNUMmatrix<double> vnew (1, dimension, 1, dimension);
autoNUMmatrix<double> cc (1, dimension, 1, dimension);
for (long i = 1; i <= dimension; i++) {
w[i][i] = 1;
}
autoMelderProgress progress (U"Simultaneous diagonalization of many CrossCorrelationTables...");
double dm_new = CrossCorrelationTables_getDiagonalityMeasure (ccts.peek(), nullptr, 0, 0);
try {
double dm_old, theta = 1, dm_start = dm_new;
do {
dm_old = dm_new;
for (long i = 1; i <= dimension; i++) {
for (long j = i + 1; j <= dimension; j++) {
double zii = 0, zij = 0, zjj = 0, yij = 0, yji = 0; // zij = zji
for (long k = 1; k <= ccts -> size; k++) {
CrossCorrelationTable ct = (CrossCorrelationTable) ccts -> item [k];
zii += ct -> data[i][i] * ct -> data[i][i];
zij += ct -> data[i][i] * ct -> data[j][j];
zjj += ct -> data[j][j] * ct -> data[j][j];
yij += ct -> data[j][j] * ct -> data[i][j];
yji += ct -> data[i][i] * ct -> data[i][j];
}
double denom = zjj * zii - zij * zij;
if (denom != 0) {
w[i][j] = (zij * yji - zii * yij) / denom;
w[j][i] = (zij * yij - zjj * yji) / denom;
}
}
}
double norma = 0;
for (long i = 1; i <= dimension; i++) {
double normai = 0;
for (long j = 1; j <= dimension; j++) {
if (i != j) {
normai += fabs (w[i][j]);
}
}
if (normai > norma) {
norma = normai;
}
}
// evaluate the norm
if (norma > theta) {
double normf = 0;
for (long i = 1; i <= dimension; i++)
for (long j = 1; j <= dimension; j++)
if (i != j) {
normf += w[i][j] * w[i][j];
}
double scalef = theta / sqrt (normf);
for (long i = 1; i <= dimension; i++) {
for (long j = 1; j <= dimension; j++) {
if (i != j) {
w[i][j] *= scalef;
}
}
}
}
// update V
NUMmatrix_copyElements (v, vnew.peek(), 1, dimension, 1, dimension);
NUMdmatrices_multiply_VC (v, w.peek(), dimension, dimension, vnew.peek(), dimension);
for (long k = 1; k <= ccts -> size; k++) {
CrossCorrelationTable ct = (CrossCorrelationTable) ccts -> item[k];
NUMmatrix_copyElements (ct -> data, cc.peek(), 1, dimension, 1, dimension);
NUMdmatrices_multiply_VCVp (ct -> data, w.peek(), dimension, dimension, cc.peek(), 1);
}
dm_new = CrossCorrelationTables_getDiagonalityMeasure (ccts.peek(), 0, 0, 0);
iter++;
Melder_progress ((double) iter / (double) maxNumberOfIterations, U"Iteration: ", iter, U", measure: ", dm_new, U"\n fractional measure: ", dm_new / dm_start);
} while (fabs ((dm_old - dm_new) / dm_new) > delta && iter < maxNumberOfIterations);
} catch (MelderError) {
Melder_clearError ();
}
} catch (MelderError) {
Melder_throw (me, U" & ", thee, U": no joint diagonalization (ffdiag).");
}
}
static void _GraphicsScreen_imageFromFile (GraphicsScreen me, const wchar_t *relativeFileName, double x1, double x2, double y1, double y2) {
long x1DC = wdx (x1), x2DC = wdx (x2), y1DC = wdy (y1), y2DC = wdy (y2);
long width = x2DC - x1DC, height = my yIsZeroAtTheTop ? y1DC - y2DC : y2DC - y1DC;
#if 0
structMelderFile file = { 0 };
Melder_relativePathToFile (relativeFileName, & file);
try {
autoPhoto photo = Photo_readFromImageFile (& file);
if (x1 == x2 && y1 == y2) {
width = photo -> nx, x1DC -= width / 2, x2DC = x1DC + width;
height = photo -> ny, y2DC -= height / 2, y1DC = y2DC + height;
} else if (x1 == x2) {
width = height * (double) photo -> nx / (double) photo -> ny;
x1DC -= width / 2, x2DC = x1DC + width;
} else if (y1 == y2) {
height = width * (double) photo -> ny / (double) photo -> nx;
y2DC -= height / 2, y1DC = y2DC + height;
}
autoNUMmatrix <double_rgbt> z (1, photo -> ny, 1, photo -> nx);
for (long iy = 1; iy <= photo -> ny; iy ++) {
for (long ix = 1; ix <= photo -> nx; ix ++) {
z [iy] [ix]. red = photo -> d_red -> z [iy] [ix];
z [iy] [ix]. green = photo -> d_green -> z [iy] [ix];
z [iy] [ix]. blue = photo -> d_blue -> z [iy] [ix];
z [iy] [ix]. transparency = photo -> d_transparency -> z [iy] [ix];
}
}
_cellArrayOrImage (me, NULL, z.peek(), NULL,
1, photo -> nx, x1DC, x2DC, 1, photo -> ny, y1DC, y2DC,
0.0, 1.0,
//wdx (my d_x1WC), wdx (my d_x2WC), wdy (my d_y1WC), wdy (my d_y2WC), // in case of clipping
LONG_MIN, LONG_MAX, LONG_MAX, LONG_MIN, // in case of no clipping
true);
} catch (MelderError) {
Melder_clearError ();
}
#elif win
if (my d_useGdiplus) {
structMelderFile file = { 0 };
Melder_relativePathToFile (relativeFileName, & file);
Gdiplus::Bitmap image (file. path);
if (x1 == x2 && y1 == y2) {
width = image. GetWidth (), x1DC -= width / 2, x2DC = x1DC + width;
height = image. GetHeight (), y2DC -= height / 2, y1DC = y2DC + height;
} else if (x1 == x2) {
width = height * (double) image. GetWidth () / (double) image. GetHeight ();
x1DC -= width / 2, x2DC = x1DC + width;
} else if (y1 == y2) {
height = width * (double) image. GetHeight () / (double) image. GetWidth ();
y2DC -= height / 2, y1DC = y2DC + height;
}
Gdiplus::Graphics dcplus (my d_gdiGraphicsContext);
Gdiplus::Rect rect (x1DC, y2DC, width, height);
dcplus. DrawImage (& image, rect);
} else {
}
#elif mac
structMelderFile file = { 0 };
Melder_relativePathToFile (relativeFileName, & file);
char utf8 [500];
Melder_wcsTo8bitFileRepresentation_inline (file. path, utf8);
CFStringRef path = CFStringCreateWithCString (NULL, utf8, kCFStringEncodingUTF8);
CFURLRef url = CFURLCreateWithFileSystemPath (NULL, path, kCFURLPOSIXPathStyle, false);
CFRelease (path);
CGImageSourceRef imageSource = CGImageSourceCreateWithURL (url, NULL);
CFRelease (url);
if (imageSource != NULL) {
CGImageRef image = CGImageSourceCreateImageAtIndex (imageSource, 0, NULL);
CFRelease (imageSource);
if (image != NULL) {
if (x1 == x2 && y1 == y2) {
width = CGImageGetWidth (image), x1DC -= width / 2, x2DC = x1DC + width;
height = CGImageGetHeight (image), y2DC -= height / 2, y1DC = y2DC + height;
} else if (x1 == x2) {
width = height * (double) CGImageGetWidth (image) / (double) CGImageGetHeight (image);
x1DC -= width / 2, x2DC = x1DC + width;
} else if (y1 == y2) {
height = width * (double) CGImageGetHeight (image) / (double) CGImageGetWidth (image);
y2DC -= height / 2, y1DC = y2DC + height;
}
GraphicsQuartz_initDraw (me);
CGContextSaveGState (my d_macGraphicsContext);
NSCAssert(my d_macGraphicsContext, @"nil context");
CGContextTranslateCTM (my d_macGraphicsContext, 0, y1DC);
CGContextScaleCTM (my d_macGraphicsContext, 1.0, -1.0);
CGContextDrawImage (my d_macGraphicsContext, CGRectMake (x1DC, 0, width, height), image);
CGContextRestoreGState (my d_macGraphicsContext);
GraphicsQuartz_exitDraw (me);
CGImageRelease (image);
}
}
#endif
}
static void Diagonalizer_and_CrossCorrelationTable_qdiag (Diagonalizer me, CrossCorrelationTables thee, double *cweights, long maxNumberOfIterations, double delta) {
try {
CrossCorrelationTable c0 = (CrossCorrelationTable) thy item[1];
double **w = my data;
long dimension = c0 -> numberOfColumns;
autoEigen eigen = Thing_new (Eigen);
autoCrossCorrelationTables ccts = Data_copy (thee);
autoNUMmatrix<double> pinv (1, dimension, 1, dimension);
autoNUMmatrix<double> d (1, dimension, 1, dimension);
autoNUMmatrix<double> p (1, dimension, 1, dimension);
autoNUMmatrix<double> m1 (1, dimension, 1, dimension);
autoNUMmatrix<double> wc (1, dimension, 1, dimension);
autoNUMvector<double> wvec (1, dimension);
autoNUMvector<double> wnew (1, dimension);
autoNUMvector<double> mvec (1, dimension);
for (long i = 1; i <= dimension; i++) // Transpose W
for (long j = 1; j <= dimension; j++) {
wc[i][j] = w[j][i];
}
// d = diag(diag(W'*C0*W));
// W = W*d^(-1/2);
NUMdmatrix_normalizeColumnVectors (wc.peek(), dimension, dimension, c0 -> data);
// scale eigenvectors for sphering
// [vb,db] = eig(C0);
// P = db^(-1/2)*vb';
Eigen_initFromSymmetricMatrix (eigen.peek(), c0 -> data, dimension);
for (long i = 1; i <= dimension; i++) {
if (eigen -> eigenvalues[i] < 0) {
Melder_throw (U"Covariance matrix not positive definite, eigenvalue[", i, U"] is negative.");
}
double scalef = 1 / sqrt (eigen -> eigenvalues[i]);
for (long j = 1; j <= dimension; j++) {
p[dimension - i + 1][j] = scalef * eigen -> eigenvectors[i][j];
}
}
// P*C[i]*P'
for (long ic = 1; ic <= thy size; ic++) {
CrossCorrelationTable cov1 = (CrossCorrelationTable) thy item[ic];
CrossCorrelationTable cov2 = (CrossCorrelationTable) ccts -> item[ic];
NUMdmatrices_multiply_VCVp (cov2 -> data, p.peek(), dimension, dimension, cov1 -> data, 1);
}
// W = P'\W == inv(P') * W
NUMpseudoInverse (p.peek(), dimension, dimension, pinv.peek(), 0);
NUMdmatrices_multiply_VpC (w, pinv.peek(), dimension, dimension, wc.peek(), dimension);
// initialisation for order KN^3
for (long ic = 2; ic <= thy size; ic++) {
CrossCorrelationTable cov = (CrossCorrelationTable) ccts -> item[ic];
// C * W
NUMdmatrices_multiply_VC (m1.peek(), cov -> data, dimension, dimension, w, dimension);
// D += scalef * M1*M1'
NUMdmatrices_multiplyScaleAdd (d.peek(), m1.peek(), dimension, dimension, 2 * cweights[ic]);
}
long iter = 0;
double delta_w;
autoMelderProgress progress (U"Simultaneous diagonalization of many CrossCorrelationTables...");
try {
do {
// the standard diagonality measure is rather expensive to calculate so we compare the norms of
// differences of eigenvectors.
delta_w = 0;
for (long kol = 1; kol <= dimension; kol++) {
for (long i = 1; i <= dimension; i++) {
wvec[i] = w[i][kol];
}
update_one_column (ccts.peek(), d.peek(), cweights, wvec.peek(), -1, mvec.peek());
Eigen_initFromSymmetricMatrix (eigen.peek(), d.peek(), dimension);
// Eigenvalues already sorted; get eigenvector of smallest !
for (long i = 1; i <= dimension; i++) {
wnew[i] = eigen -> eigenvectors[dimension][i];
}
update_one_column (ccts.peek(), d.peek(), cweights, wnew.peek(), 1, mvec.peek());
for (long i = 1; i <= dimension; i++) {
w[i][kol] = wnew[i];
}
// compare norms of eigenvectors. We have to compare ||wvec +/- w_new|| because eigenvectors
// may change sign.
double normp = 0, normm = 0;
for (long j = 1; j <= dimension; j++) {
double dm = wvec[j] - wnew[j], dp = wvec[j] + wnew[j];
normp += dm * dm; normm += dp * dp;
}
normp = normp < normm ? normp : normm;
normp = sqrt (normp);
delta_w = normp > delta_w ? normp : delta_w;
}
iter++;
Melder_progress ((double) iter / (double) (maxNumberOfIterations + 1), U"Iteration: ", iter, U", norm: ", delta_w);
} while (delta_w > delta && iter < maxNumberOfIterations);
} catch (MelderError) {
Melder_clearError ();
}
// Revert the sphering W = P'*W;
// Take transpose to make W*C[i]W' diagonal instead of W'*C[i]*W => (P'*W)'=W'*P
NUMmatrix_copyElements (w, wc.peek(), 1, dimension, 1, dimension);
NUMdmatrices_multiply_VpC (w, wc.peek(), dimension, dimension, p.peek(), dimension); // W = W'*P: final result
// Calculate the "real" diagonality measure
// double dm = CrossCorrelationTables_and_Diagonalizer_getDiagonalityMeasure (thee, me, cweights, 1, thy size);
} catch (MelderError) {
Melder_throw (me, U" & ", thee, U": no joint diagonalization (qdiag).");
}
}
autoClassificationTable Discriminant_and_TableOfReal_to_ClassificationTable_dw (Discriminant me, TableOfReal thee, int poolCovarianceMatrices, int useAprioriProbabilities, double alpha, double minProb, autoTableOfReal *displacements) {
try {
long g = Discriminant_getNumberOfGroups (me);
long p = Eigen_getDimensionOfComponents (my eigen.get());
long m = thy numberOfRows;
if (p != thy numberOfColumns) Melder_throw
(U"The number of columns does not agree with the dimension of the discriminant.");
autoNUMvector<double> log_p (1, g);
autoNUMvector<double> log_apriori (1, g);
autoNUMvector<double> ln_determinant (1, g);
autoNUMvector<double> buf (1, p);
autoNUMvector<double> displacement (1, p);
autoNUMvector<double> x (1, p);
autoNUMvector<SSCP> sscpvec (1, g);
autoSSCP pool = SSCPList_to_SSCP_pool (my groups.get());
autoClassificationTable him = ClassificationTable_create (m, g);
NUMstrings_copyElements (thy rowLabels, his rowLabels, 1, m);
autoTableOfReal adisplacements = Data_copy (thee);
// Scale the sscp to become a covariance matrix.
for (long i = 1; i <= p; i ++) {
for (long k = i; k <= p; k ++) {
pool -> data [k] [i] = pool -> data [i] [k] /= pool -> numberOfObservations - g;
}
}
double lnd;
autoSSCPList agroups;
SSCPList groups;
if (poolCovarianceMatrices) {
// Covariance matrix S can be decomposed as S = L.L'. Calculate L^-1.
// L^-1 will be used later in the Mahalanobis distance calculation:
// v'.S^-1.v == v'.L^-1'.L^-1.v == (L^-1.v)'.(L^-1.v).
NUMlowerCholeskyInverse (pool -> data, p, & lnd);
for (long j = 1; j <= g; j ++) {
ln_determinant [j] = lnd;
sscpvec [j] = pool.get();
}
groups = my groups.get();
} else {
//Calculate the inverses of all group covariance matrices.
// In case of a singular matrix, substitute inverse of pooled.
agroups = Data_copy (my groups.get());
groups = agroups.get();
long npool = 0;
for (long j = 1; j <= g; j ++) {
SSCP t = groups->at [j];
long no = (long) floor (SSCP_getNumberOfObservations (t));
for (long i = 1; i <= p; i ++) {
for (long k = i; k <= p; k ++) {
t -> data [k] [i] = t -> data [i] [k] /= no - 1;
}
}
sscpvec [j] = groups->at [j];
try {
NUMlowerCholeskyInverse (t -> data, p, & ln_determinant [j]);
} catch (MelderError) {
// Try the alternative: the pooled covariance matrix.
// Clear the error.
Melder_clearError ();
if (npool == 0) {
NUMlowerCholeskyInverse (pool -> data, p, & lnd);
}
npool ++;
sscpvec [j] = pool.get();
ln_determinant [j] = lnd;
}
}
if (npool > 0) {
Melder_warning (npool, U" groups use pooled covariance matrix.");
}
}
// Labels for columns in ClassificationTable
for (long j = 1; j <= g; j ++) {
const char32 *name = Thing_getName (my groups->at [j]);
if (! name) {
name = U"?";
}
TableOfReal_setColumnLabel (him.get(), j, name);
}
// Normalize the sum of the apriori probabilities to 1.
// Next take ln (p) because otherwise probabilities might be too small to represent.
double logg = log (g);
NUMvector_normalize1 (my aprioriProbabilities, g);
for (long j = 1; j <= g; j ++) {
log_apriori[j] = ( useAprioriProbabilities ? log (my aprioriProbabilities[j]) : - logg );
}
// Generalized squared distance function:
// D^2(x) = (x - mu)' S^-1 (x - mu) + ln (determinant(S)) - 2 ln (apriori)
for (long i = 1; i <= m; i ++) {
SSCP winner;
double norm = 0, pt_max = -1e308;
long iwinner = 1;
for (long k = 1; k <= p; k ++) {
x [k] = thy data [i] [k] + displacement [k];
}
for (long j = 1; j <= g; j ++) {
SSCP t = groups->at [j];
double md = mahalanobisDistanceSq (sscpvec [j] -> data, p, x.peek(), t -> centroid, buf.peek());
double pt = log_apriori [j] - 0.5 * (ln_determinant [j] + md);
if (pt > pt_max) {
pt_max = pt;
iwinner = j;
}
log_p [j] = pt;
}
for (long j = 1; j <= g; j ++) {
norm += log_p [j] = exp (log_p [j] - pt_max);
}
for (long j = 1; j <= g; j ++) {
his data [i] [j] = log_p [j] / norm;
}
// Save old displacement, calculate new displacement
winner = groups->at [iwinner];
for (long k = 1; k <= p; k ++) {
adisplacements -> data [i] [k] = displacement [k];
if (his data [i] [iwinner] > minProb) {
double delta_k = winner -> centroid [k] - x [k];
displacement [k] += alpha * delta_k;
}
}
}
*displacements = adisplacements.move();
return him;
} catch (MelderError) {
Melder_throw (U"ClassificationTable for Weenink procedure not created.");
}
}
