void Player::changeTier(const QString &newtier)
{
if (tier() == newtier)
return;
if (battling()) {
sendMessage(tr("You can't change tiers while battling."));
return;
}
if (!TierMachine::obj()->exists(newtier)) {
sendMessage(tr("The tier %1 doesn't exist!").arg(newtier));
return;
}
if (!TierMachine::obj()->isValid(team(), newtier)) {
Tier *tier = &TierMachine::obj()->tier(newtier);
if (!tier->allowGen(team().gen)) {
sendMessage(tr("The generation of your team is invalid for that tier."));
return;
}
QList<int> indexList;
for(int i = 0; i < 6; i++) {
if (tier->isBanned(team().poke(i))) {
indexList.append(i);
}
}
if (indexList.size() > 0) {
foreach(int i, indexList) {
sendMessage(tr("The Pokemon '%1' is banned on tier '%2' for the following reasons: %3").arg(PokemonInfo::Name(team().poke(i).num()), newtier, tier->bannedReason(team().poke(i))));
}
void TextGrids_append_inline (TextGrid me, TextGrid thee, bool preserveTimes)
{
try {
if (my tiers -> size != thy tiers -> size) {
Melder_throw (U"The number of tiers must be equal.");
}
if (preserveTimes && thy xmin < my xmax) {
Melder_throw (U"The start time of the second TextGrid can't be earlier than the end time of the first one if you want to preserve times.");
}
TextGrid_checkStartAndEndTimesOfTiers (me); // all tiers must have the same start/end time as textgrid
TextGrid_checkStartAndEndTimesOfTiers (thee);
// last intervals must have the same end time
double xmax = preserveTimes ? thy xmax : my xmax + (thy xmax - thy xmin);
for (long itier = 1; itier <= my tiers -> size; itier++) {
Function myTier = my tier (itier), thyTier = thy tier (itier);
if (myTier -> classInfo == classIntervalTier && thyTier -> classInfo == classIntervalTier) {
IntervalTier myIntervalTier = static_cast <IntervalTier> (myTier);
IntervalTier thyIntervalTier = static_cast <IntervalTier> (thyTier);
IntervalTiers_append_inline (myIntervalTier, thyIntervalTier, preserveTimes);
// make sure last interval has correct end time
TextInterval lastInterval = myIntervalTier -> interval (myIntervalTier -> numberOfIntervals());
lastInterval -> xmax = xmax;
Melder_assert (lastInterval -> xmax > lastInterval -> xmin);
} else if (myTier -> classInfo == classTextTier && thyTier -> classInfo == classTextTier) {
TextTier myTextTier = static_cast <TextTier> (myTier);
TextTier thyTextTier = static_cast <TextTier> (thyTier);
TextTiers_append_inline (myTextTier, thyTextTier, preserveTimes);
myTextTier -> xmax = xmax;
} else {
Melder_throw (U"Tier ", itier, U" in the second TextGrid is of a different type "
"than tier ", itier, U" in the first TextGrid.");
}
}
my xmax = xmax;
} catch (MelderError) {
Melder_throw (U"TextGrids not appended.");
}
}
void
promote::TierScheduler<TASK>::run(std::size_t const maxTasks,
bool const repeats)
{
TASK* task(0);
// Flush _addedTasks queue
while( (task = Scheduler<TASK>::getAddedTask()) ) {
insertTask(task);
}
if( _numTasks == 0 ) return;
std::size_t const tierCount(_tiers.size());
for(std::size_t processed = 0; processed < maxTasks; ) {
std::size_t const count(++_counter);
std::size_t tier(0);
do {
// Process tasks in current tier
Queue<TASK*,false,false>* const tierTasks(_tiers[tier]);
if( tierTasks ) {
std::size_t const tierTaskCount(tierTasks->size());
for(std::size_t jj = 0; jj != tierTaskCount; ++jj) {
tierTasks->read(task);
task->process();
++processed;
if( task->completed() ) {
Scheduler<TASK>::releaseTask(task);
--_numTasks;
if( _numTasks == 0 ) {
return;
}
} else if( task->tier() == tier ) { // tier hasn't changed
tierTasks->write(task);
} else {
insertTask(task);
}
}
}
++tier;
} while( (count & ((1 << tier) - 1)) == 0 and (tier < tierCount) );
}
}
QString TeamHolder::tier() const
{
return tier(currentTeam());
}
void TextGrid_Sound_draw (TextGrid me, Sound sound, Graphics g, double tmin, double tmax,
bool showBoundaries, bool useTextStyles, bool garnish) // STEREO BUG
{
long numberOfTiers = my numberOfTiers ();
/*
* Automatic windowing:
*/
if (tmax <= tmin) tmin = my xmin, tmax = my xmax;
Graphics_setInner (g);
Graphics_setWindow (g, tmin, tmax, -1.0 - 0.5 * numberOfTiers, 1.0);
/*
* Draw sound in upper part.
*/
long first, last;
if (sound && Sampled_getWindowSamples (sound, tmin, tmax, & first, & last) > 1) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, tmin, 0.0, tmax, 0.0);
Graphics_setLineType (g, Graphics_DRAWN);
Graphics_function (g, sound -> z [1], first, last,
Sampled_indexToX (sound, first), Sampled_indexToX (sound, last));
}
/*
* Draw labels in lower part.
*/
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setPercentSignIsItalic (g, useTextStyles);
Graphics_setNumberSignIsBold (g, useTextStyles);
Graphics_setCircumflexIsSuperscript (g, useTextStyles);
Graphics_setUnderscoreIsSubscript (g, useTextStyles);
for (long itier = 1; itier <= numberOfTiers; itier ++) {
Function anyTier = my tier (itier);
double ymin = -1.0 - 0.5 * itier, ymax = ymin + 0.5;
Graphics_rectangle (g, tmin, tmax, ymin, ymax);
if (anyTier -> classInfo == classIntervalTier) {
IntervalTier tier = static_cast <IntervalTier> (anyTier);
long ninterval = tier -> numberOfIntervals ();
for (long iinterval = 1; iinterval <= ninterval; iinterval ++) {
TextInterval interval = tier -> interval (iinterval);
double intmin = interval -> xmin, intmax = interval -> xmax;
if (intmin < tmin) intmin = tmin;
if (intmax > tmax) intmax = tmax;
if (intmin >= intmax) continue;
if (showBoundaries && intmin > tmin && intmin < tmax) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, intmin, -1.0, intmin, 1.0); /* In sound part. */
Graphics_setLineType (g, Graphics_DRAWN);
}
/* Draw left boundary. */
if (intmin > tmin && intmin < tmax) Graphics_line (g, intmin, ymin, intmin, ymax);
/* Draw label text. */
if (interval -> text && intmax >= tmin && intmin <= tmax) {
double t1 = tmin > intmin ? tmin : intmin;
double t2 = tmax < intmax ? tmax : intmax;
Graphics_text (g, 0.5 * (t1 + t2), 0.5 * (ymin + ymax), interval -> text);
}
}
} else {
TextTier tier = static_cast <TextTier> (anyTier);
long numberOfPoints = tier -> numberOfPoints ();
for (long ipoint = 1; ipoint <= numberOfPoints; ipoint ++) {
TextPoint point = tier -> point (ipoint);
double t = point -> number;
if (t > tmin && t < tmax) {
if (showBoundaries) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, t, -1.0, t, 1.0); /* In sound part. */
Graphics_setLineType (g, Graphics_DRAWN);
}
Graphics_line (g, t, ymin, t, 0.8 * ymin + 0.2 * ymax);
Graphics_line (g, t, 0.2 * ymin + 0.8 * ymax, t, ymax);
if (point -> mark)
Graphics_text (g, t, 0.5 * (ymin + ymax), point -> mark);
}
}
}
}
Graphics_setPercentSignIsItalic (g, TRUE);
Graphics_setNumberSignIsBold (g, TRUE);
Graphics_setCircumflexIsSuperscript (g, TRUE);
Graphics_setUnderscoreIsSubscript (g, TRUE);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, 1, L"Time (s)");
Graphics_marksBottom (g, 2, 1, 1, 1);
}
}
void TextGrid_anySound_alignInterval (TextGrid me, Function anySound, long tierNumber, long intervalNumber, const wchar_t *languageName, bool includeWords, bool includePhonemes) {
try {
IntervalTier headTier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
if (intervalNumber < 1 || intervalNumber > headTier -> numberOfIntervals ())
Melder_throw ("Interval ", intervalNumber, " does not exist.");
TextInterval interval = headTier -> interval (intervalNumber);
if (! includeWords && ! includePhonemes)
Melder_throw ("Nothing to be done, because you asked neither for word alignment nor for phoneme alignment.");
if (wcsstr (headTier -> name, L"/") )
Melder_throw ("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, L"default");
double silenceThreshold = -35, minSilenceDuration = 0.1, minSoundingDuration = 0.1;
autoTextGrid analysis = NULL;
if (! Melder_wcsequ (interval -> text, L"")) {
try {
analysis.reset (SpeechSynthesizer_and_Sound_and_TextInterval_align
(synthesizer.peek(), part.peek(), interval, silenceThreshold, minSilenceDuration, minSoundingDuration));
} catch (MelderError) {
Melder_clearError (); // ignore all error messages from DTW and the like
}
}
if (analysis.peek()) {
/*
* Clean up the analysis.
*/
Melder_assert (analysis -> xmin == interval -> xmin);
Melder_assert (analysis -> xmax == interval -> xmax);
Melder_assert (analysis -> numberOfTiers () == 4);
Thing_cast (IntervalTier, analysisWordTier, analysis -> tier (3));
if (! IntervalTier_check (analysisWordTier))
Melder_throw (L"Analysis word tier out of order.");
IntervalTier_removeEmptyIntervals (analysisWordTier, NULL);
Melder_assert (analysisWordTier -> xmax == analysis -> xmax);
Melder_assert (analysisWordTier -> numberOfIntervals () >= 1);
TextInterval firstInterval = analysisWordTier -> interval (1);
TextInterval lastInterval = analysisWordTier -> interval (analysisWordTier -> numberOfIntervals ());
firstInterval -> xmin = analysis -> xmin;
lastInterval -> xmax = analysis -> xmax;
if (lastInterval -> xmax != analysis -> xmax)
Melder_fatal ("analysis ends at %ls, but last interval at %ls seconds",
Melder_double (analysis -> xmax), Melder_double (lastInterval -> xmax));
if (! IntervalTier_check (analysisWordTier))
Melder_throw (L"Analysis word tier out of order (2).");
Thing_cast (IntervalTier, analysisPhonemeTier, analysis -> tier (4));
if (! IntervalTier_check (analysisPhonemeTier))
Melder_throw (L"Analysis phoneme tier out of order.");
IntervalTier_removeEmptyIntervals (analysisPhonemeTier, analysisWordTier);
Melder_assert (analysisPhonemeTier -> xmax == analysis -> xmax);
Melder_assert (analysisPhonemeTier -> numberOfIntervals () >= 1);
firstInterval = analysisPhonemeTier -> interval (1);
lastInterval = analysisPhonemeTier -> interval (analysisPhonemeTier -> numberOfIntervals ());
firstInterval -> xmin = analysis -> xmin;
lastInterval -> xmax = analysis -> xmax;
Melder_assert (lastInterval -> xmax == analysis -> xmax);
if (! IntervalTier_check (analysisPhonemeTier))
Melder_throw (L"Analysis phoneme tier out of order (2).");
}
long wordTierNumber = 0, phonemeTierNumber = 0;
IntervalTier wordTier = NULL, phonemeTier = NULL;
/*
* Include a word tier.
*/
if (includeWords) {
/*
* Make sure that the word tier exists.
*/
autoMelderString newWordTierName;
MelderString_copy (& newWordTierName, headTier -> name);
MelderString_append (& newWordTierName, L"/word");
for (long itier = 1; itier <= my numberOfTiers (); itier ++) {
IntervalTier tier = static_cast <IntervalTier> (my tier (itier));
if (Melder_wcsequ (newWordTierName.string, tier -> name)) {
if (tier -> classInfo != classIntervalTier)
Melder_throw ("A tier with the prospective word tier name (", tier -> name, ") already exists, but it is not an interval tier."
"\nPlease change its name or remove it.");
wordTierNumber = itier;
break;
}
}
if (! wordTierNumber) {
autoIntervalTier newWordTier = IntervalTier_create (my xmin, my xmax);
Thing_setName (newWordTier.peek(), newWordTierName.string);
Ordered_addItemPos (my tiers, newWordTier.transfer(), wordTierNumber = tierNumber + 1);
}
Melder_assert (wordTierNumber >= 1 && wordTierNumber <= my tiers -> size);
wordTier = static_cast <IntervalTier> (my tier (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.peek()) {
Thing_cast (IntervalTier, analysisWordTier, analysis -> tier (3));
if (! IntervalTier_check (analysisWordTier))
Melder_throw (L"Analysis word tier out of order (3).");
if (! IntervalTier_check (wordTier))
Melder_throw (L"Word tier out of order (3).");
for (long ianalysisInterval = 1; ianalysisInterval <= analysisWordTier -> numberOfIntervals (); ianalysisInterval ++) {
TextInterval analysisInterval = analysisWordTier -> interval (ianalysisInterval);
TextInterval wordInterval = NULL;
double tmin = analysisInterval -> xmin, tmax = analysisInterval -> xmax;
if (tmax == analysis -> xmax) {
wordInterval = wordTier -> interval (wordIntervalNumber);
TextInterval_setText (wordInterval, analysisInterval -> text);
} else {
wordInterval = wordTier -> interval (wordIntervalNumber);
autoTextInterval newInterval = TextInterval_create (tmin, tmax, analysisInterval -> text);
wordInterval -> xmin = tmax;
Collection_addItem (wordTier -> intervals, newInterval.transfer());
wordIntervalNumber ++;
}
}
if (! IntervalTier_check (analysisWordTier))
Melder_throw (L"Analysis word tier out of order (4).");
if (! IntervalTier_check (wordTier))
Melder_throw (L"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);
MelderString_append (& newPhonemeTierName, L"/phon");
for (long itier = 1; itier <= my numberOfTiers (); itier ++) {
IntervalTier tier = static_cast <IntervalTier> (my tier (itier));
if (Melder_wcsequ (newPhonemeTierName.string, tier -> name)) {
if (tier -> classInfo != classIntervalTier)
Melder_throw ("A tier with the prospective phoneme tier name (", tier -> name, ") already exists, but it is not an interval tier."
"\nPlease change its name or remove it.");
phonemeTierNumber = itier;
break;
}
}
if (! phonemeTierNumber) {
autoIntervalTier newPhonemeTier = IntervalTier_create (my xmin, my xmax);
Thing_setName (newPhonemeTier.peek(), newPhonemeTierName.string);
Ordered_addItemPos (my tiers, newPhonemeTier.transfer(), phonemeTierNumber = wordTierNumber ? wordTierNumber + 1 : tierNumber + 1);
}
Melder_assert (phonemeTierNumber >= 1 && phonemeTierNumber <= my tiers -> size);
phonemeTier = static_cast <IntervalTier> (my tiers -> item [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.peek()) {
Thing_cast (IntervalTier, analysisPhonemeTier, analysis -> tiers -> item [4]);
for (long ianalysisInterval = 1; ianalysisInterval <= analysisPhonemeTier -> numberOfIntervals (); ianalysisInterval ++) {
TextInterval analysisInterval = analysisPhonemeTier -> interval (ianalysisInterval);
TextInterval phonemeInterval = NULL;
double tmin = analysisInterval -> xmin, tmax = analysisInterval -> xmax;
if (tmax == analysis -> xmax) {
phonemeInterval = phonemeTier -> interval (phonemeIntervalNumber);
TextInterval_setText (phonemeInterval, analysisInterval -> text);
} else {
phonemeInterval = phonemeTier -> interval (phonemeIntervalNumber);
autoTextInterval newInterval = TextInterval_create (tmin, tmax, analysisInterval -> text);
phonemeInterval -> xmin = tmax;
Collection_addItem (phonemeTier -> intervals, newInterval.transfer());
phonemeIntervalNumber ++;
}
}
}
if (includeWords) {
/*
* Synchronize the boundaries between the word tier and the phoneme tier.
*/
//for (long iinterval = 1; iinterval <=
}
}
} catch (MelderError) {
Melder_throw (me, " & ", anySound, ": interval not aligned.");
}
}