public override void Run()
{
if (group == null)
{
group = workspace.PickRandomGroupByRecency();
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
// Check out the # of subcomponents of this group, and if it's a good number (2,3, or 4), add a group reason to the group.
int num = group.GroupElements.Count;
if (num < 2 || num > 4)
{
return;
}
double strength = 100.0 - (num - 2) * 33.3;
group.AddGroupReason(new GroupReasonNumberOfSubelements(group, strength));
}
public override void Run()
{
if (group == null)
{
group = workspace.PickRandomGroupByRecency();
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
// Add to attention history.
workspace.RecordCodeletAttentionHistory(this, group.MinLocation);
workspace.RecordCodeletAttentionHistory(this, group.MaxLocation);
// Check the Larson expectedness vector.
// Score is high when expectation was relatively high.
double score;
Key key = workspace.Key;
Alphabet alphabet = group.Alphabet;
if (alphabet == null)
{
alphabet = Alphabet.GetScaleAlphabet(key);
}
List <float> expectedness = group.GetNoteExpectednessLarson(key, alphabet);
int num = expectedness.Count;
if (num < 2)
{
return;
}
if (expectedness[num - 1] > expectedness[num - 2])
{
score = Math.Min(100, 100 * (expectedness[num - 1] / Constants.MAX_LARSON_EXPECTEDNESS));
if (score > 25)
{
group.AddGroupReason(new GroupReasonEndMusicalForcesClosure(group, score));
}
}
}
public Group MakeRealGroup()
{
Group g = new Group(workspace);
foreach (GroupElement ge in groupElements)
{
g.AddGroupElement(ge); //// NOW, add affects ge.parentGroup, for a non-temp group.
}
foreach (GroupReason r in reasons)
{
r.ReplaceGroup(g);
g.AddGroupReason(r);
}
return(g);
}
public override void Run()
{
if (group == null)
{
group = workspace.PickRandomGroupByRecency();
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
// Add to attention history.
workspace.RecordCodeletAttentionHistory(this, group.MinLocation, group.MaxLocation);
// Compute the similarity of each pair of subcomponents, left to right, and average.
// Similarity determined by measure links, for measures, or analogies, for groups.
double score = ComputeSimilarity();
if (score < 50)
{
return; // not good enough
}
// Record the grouping reason.
GroupReason reason;
if (score > 99.99)
{
reason = new GroupReasonComponentsIdentical(group);
}
else
{
reason = new GroupReasonComponentsSimilar(group, score);
}
group.AddGroupReason(reason);
}
public override void Run()
{
if (group == null)
{
group = workspace.PickRandomGroupByRecency();
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
// Add to attention history.
workspace.RecordCodeletAttentionHistory(this, group.MinLocation);
workspace.RecordCodeletAttentionHistory(this, group.MaxLocation);
// Let's see if we are slowing down at the end of the group.
// Compare the final measure to the prev measure.
// Find fastest rhythm in each region.
// Final measure
int startMeasure = group.MaxLocation;
int startBeat = 0;
int endMeasure = startMeasure;
int endBeat = workspace.measures[endMeasure].MeasureDuration - 1;
int fastestFinalMeasure = GetFastestRhythmInRegion(startMeasure, startBeat, endMeasure, endBeat);
// Second to last measure
float slowDownRatio = -1;
if (group.LengthInMeasures > 1)
{
startMeasure = group.MaxLocation - 1;
startBeat = 0;
endMeasure = startMeasure;
endBeat = workspace.measures[endMeasure].MeasureDuration - 1;
int fastestPrevMeasure = GetFastestRhythmInRegion(startMeasure, startBeat, endMeasure, endBeat);
slowDownRatio = ((float)fastestFinalMeasure) / fastestPrevMeasure;
}
// Compare the final half-measure to the previous half measure.
startMeasure = group.MaxLocation;
startBeat = workspace.measures[endMeasure].MeasureDuration / 2;
endMeasure = startMeasure;
endBeat = workspace.measures[endMeasure].MeasureDuration - 1;
int fastestLastHalfMeasure = GetFastestRhythmInRegion(startMeasure, startBeat, endMeasure, endBeat);
startBeat = 0;
endBeat = workspace.measures[endMeasure].MeasureDuration / 2 - 1;
int fastestPrevHalfMeasure = GetFastestRhythmInRegion(startMeasure, startBeat, endMeasure, endBeat);
float slowDownRatioHalfMeasure = ((float)fastestLastHalfMeasure) / fastestPrevHalfMeasure;
float score = 0;
if (slowDownRatio > 1)
{
score += slowDownRatio * 25;;
}
if (slowDownRatioHalfMeasure > 1)
{
score += slowDownRatioHalfMeasure * 10;
}
if (score > 100)
{
score = 100;
}
if (score > 25)
{
group.AddGroupReason(new GroupReasonSlowingEnd(group, score));
}
}
public override void Run()
{
if (group == null)
{
// Pick a random analogy and post codelets to work on it.
analogy = workspace.PickRandomAnalogyByRecency();
if (analogy == null)
{
return;
}
foreach (Group g in analogy.GetAllSubGroups())
{
GroupReasonAnalogyComponentCodelet gcc = new GroupReasonAnalogyComponentCodelet((int)this.rawUrgency * 2, this, coderack, workspace, slipnet, g);
coderack.AddCodelet(gcc);
}
// If the analogy has a parent group containing the two sides (and nothing else) add it.
Group parent = analogy.GetParent();
if (parent != null)
{
GroupReasonAnalogyComponentCodelet gcc = new GroupReasonAnalogyComponentCodelet(100, this, coderack, workspace, slipnet, parent, analogy);
coderack.AddCodelet(gcc);
}
return;
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
if (!workspace.analogies.Contains(analogy))
{
return;
}
if (analogy == null)
{
// Find the enclosing analogy.
List <Analogy> enclosingAnalogies = workspace.FindAllEnclosingAnalogies(group);
analogy = Utilities.PickItem <Analogy>(enclosingAnalogies);
}
if (analogy == null)
{
return;
}
// Add to attention history.
workspace.RecordCodeletAttentionHistory(this, group.MinLocation, group.MaxLocation);
// Add the reason, with strength == analogy strength.
group.AddGroupReason(new GroupReasonAnalogySupport(group, analogy.Strength, analogy));
}
public override void Run()
{
if (group == null)
{
group = workspace.PickRandomGroupByRecency();
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
// Add to attention history.
workspace.RecordCodeletAttentionHistory(this, group.MinLocation);
workspace.RecordCodeletAttentionHistory(this, group.MaxLocation);
// Check the start and end of the group and compute rhythmic gap scores.
// Gap scores are based on rhythmic patterns before the first measure or after the last measure.
float startGapScore, endGapScore;
int m1index = group.MinLocation;
// 1st measure automatically has a huge gap score.
int startMaxGapScore;
if (m1index < 1)
{
startMaxGapScore = workspace.measures[m1index].MeasureDuration;
startGapScore = startMaxGapScore;
}
else
{
startMaxGapScore = workspace.measures[m1index - 1].MeasureDuration;
startGapScore = ComputeGapScoreBefore(m1index);
}
int m2index = group.MaxLocation;
// last measure automatically has a huge gap score.
int lastInputMeasureIdx = workspace.measuresInput.Count - 1;
int lastMeasureIdx = workspace.measures.Count - 1;
int endMaxGapScore;
if (m2index > lastInputMeasureIdx - 1)
{
endMaxGapScore = workspace.measures[m2index].MeasureDuration;
endGapScore = endMaxGapScore;
}
else if (m2index > lastMeasureIdx - 1)
{
endGapScore = 0;
endMaxGapScore = 1;
}
else
{
endGapScore = ComputeGapScoreBefore(m2index + 1);
endMaxGapScore = workspace.measures[m2index].MeasureDuration;
}
double strengthStart = Math.Min(100.0 * startGapScore / startMaxGapScore, 100);
double strengthEnd = Math.Min(100.0 * endGapScore / endMaxGapScore, 100);
if (strengthStart > 25)
{
group.AddGroupReason(new GroupReasonStartAfterGap(group, strengthStart));
}
if (strengthEnd > 25)
{
group.AddGroupReason(new GroupReasonEndBeforeGap(group, strengthEnd));
}
}
public override void Run()
{
if (group == null)
{
group = workspace.PickRandomGroupByRecency();
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
// Add to attention history.
workspace.RecordCodeletAttentionHistory(this, group.MinLocation);
workspace.RecordCodeletAttentionHistory(this, group.MaxLocation);
// Check the final note of the rhythm.
// Score based on the duration and tonic/dominantness of the pitch.
Measure m = group.Measures[group.Measures.Count - 1];
Note n = m.rhythm.notes[m.rhythm.notes.Count - 1];
if (n.midiInfo == null)
{
return;
}
ScaleDegree degree = n.midiInfo.GetScaleDegree(new Key()); // assume C major.
int dur = n.duartionIncludingTiesAfter;
double score = 0;
// check for minor/chromatic.
if (degree == null)
{
// maybe its minor (TODO: crude)
degree = n.midiInfo.GetScaleDegree(new Key()); // assume C minor.
}
// maybe it's chromatic
if (degree == null)
{
return;
}
else
{
switch (degree.Number)
{
case 1: // tonic
score = 100;
break;
case 5: // dominant
score = 100;
break;
case 2: // supertonic
score = 30;
break;
default:
return;
}
}
// Now average in harmonic context of pitch, if available.
double str1 = group.AlphabetStrength;
double str2 = m.AlphabetStrength;
Alphabet alphabet = null;
if (str1 >= str2)
{
alphabet = group.Alphabet;
}
else
{
alphabet = m.Alphabet;
}
if (alphabet != null)
{
// Average in 0 or 100 points depending on stability
if (alphabet.isStable(degree))
{
score = (score + 100) / 2;
}
else
{
score = (score + 0) / 2;
}
}
// Duration
if (dur < 8)
{
score = score * (dur / 8.0);
}
if (score > 25)
{
if (degree.Number == 1)
{
group.AddGroupReason(new GroupReasonEndTonic(group, score));
}
else
{
group.AddGroupReason(new GroupReasonEndDominant(group, score));
}
}
}
public override void Run()
{
if (group == null)
{
group = workspace.PickRandomGroupByRecency();
}
if (group == null)
{
return;
}
if (!workspace.groups.Contains(group))
{
return;
}
if (workspace.barlines.Count < 1)
{
return;
}
// Add to attention history.
workspace.RecordCodeletAttentionHistory(this, group.MinLocation, group.MaxLocation);
// Check if this group ends at a hierarchy border that is good..
// Find min of the hierarchy strenghts of start and end.
int endHierarchy = workspace.barlines[0];
if (workspace.barlines.Count > group.MaxLocation + 1)
{
endHierarchy = workspace.barlines[group.MaxLocation + 1];
}
// Look for the maximal hierarhcy level inside group (excluding endpoints)
int max = -1;
for (int i = group.MinLocation + 1; i <= group.MaxLocation && i < workspace.barlines.Count; i++)
{
if (workspace.barlines[i] > max)
{
max = workspace.barlines[i];
}
}
// This one has a hierarchy crossing. No bonus.
if (max >= endHierarchy)
{
return;
}
//int diff = endHierarchy - max;
// compute bonus.
// TODO!!!! maybe need to check for relatinoship between group level and absolute
// hiearachy end barline, not just diff from max.................
//double strength = Math.Min(40 * diff, 100);
double strength = Math.Min(40 * (endHierarchy - group.Level), 100);
if (strength > 25)
{
group.AddGroupReason(new GroupReasonHierarchyEnd(group, strength));
}
}