Examples of jm.music.data.Note

jm.music.data.Note
The Note class is representative of notes in standard western music notation. It contains data relavent to music note information such as time, duration and pitch. Notes get contained in Phrase objects. Like in tradtional music notation (CPN) notes get played one after the other in the order in which they are added to the Phrase.
!IMPORTANT: notes with a pitch of the minimum integer are rests, those between 0 <> 127 are exactly the same as normal sounding notes numbered like the MIDI specification. Notes with a pitch specified as a double value, e.g., 440.0, are frequency values for the note pitch. In general, note pitch refers to the chromatic key number (as per MIDI) as an int and the note frequency refer to the value in hertz as a double value.
Notes can be added to a phrase like this...
```
 Phrase phrase = new Phrase(0.0); Note note = new Note(C4, CROTCHET, MF); phrase.addNote(note); 
```
The note also has the option to create notes with reasonable default values. This allows a user who is not interested in any performance details to work with notes solely using pitch value and rythmValue like this....
```
 Note note = new Note(C4, CROTCHET); 
```
The final option for building a note also includes the dynamic parameter for minimal performace information.
```
 Note note = new Note(C4, CROTCHET, F); 
```
Comments about the offset parameter: The intention of offset was to allow for 'feel' in score playback. For example, a snare drum might be played slightly ahead or behind the beat, or a sound with a slow attack might need to be triggered early in order to sound in time with other parts.
With this in mind, offset should have no influence on rhythmValue or duration calculations within the jMusic data structure, only when translated to another format (eg MIDI). In your example (offset 0.1, duration 0.8, and rv 1.0) the rendering (MIDI or other that does not support the offset concept) should consider the start time of the note 0.1 bpm later than 'normal' but the duration of the note will be 0.8 bpm from that offset start time. The next note should start 1.0 bpm after the 'normal' startTime (ignoring offset). This allows for offset to be used in cases where performance of music varies from beat to beat, eg., the downbeat is anticipated slightly. In extreme cases this could cause overlapping notes in MIDI translation which need to be 'handled' but we consider this a weakness of the MIDI data specification rather than a problem for jMusic : )
In short, think of offset as "A displacement from the normal start time of a note that allows performance interpretation without distorting the score for compositional or analysis purposes." --------------- @author Andrew Sorensen @version 1.0, Sun Feb 25 18:43:31 2001 @see Phrase

                // shuffle every time, so that we don't always get the same chord for a given note
                Collections.shuffle(scaleChords, random);
                Collections.shuffle(scaleSeventhChords, random);
                Collections.shuffle(scaleOtherChords, random);


                Note currentNote = notes[i];
                if (currentNote.getRhythmValue() == 0) {
                    continue; // rhythm value is 0 for the first notes of a (main-part) chord. So progress to the next
                }
                // inter-measure chords only for even-numbered, compound metres
                if (canHaveInterMeasureChords && currentMeasureSize == 0) {
                    interMeasureChord = Chance.test(18);
                }
                double chordLength = interMeasureChord ? normalizedMeasureSize / 2 : normalizedMeasureSize;
                boolean isHalfMeasure = currentMeasureSize == normalizedMeasureSize / 2;


                if (currentNote.getPitch() == 0) {
                    logger.warn("Pitch is 0 in main part.");
                    continue;
                }
                if (!currentNote.isRest() && (currentMeasureSize == 0 || (interMeasureChord && isHalfMeasure))) {
                    boolean preferStable = ToneResolver.needsContrastingChord(firstToneTypes, ToneGroups.UNSTABLE);
                    boolean preferUnstable = ToneResolver.needsContrastingChord(firstToneTypes, ToneGroups.STABLE);
                    Chord previous = chord;
                    chord = ChordUtils.getChord(ctx, currentNote.getPitch(), previous, scaleChords, scaleSeventhChords, scaleOtherChords, preferStable, preferUnstable);
                    if (chord != null && Chance.test(90)) {
                        if (Chance.test(20)) { // change the special note type
                            if (Chance.test(60)) { // to a new value
                                specialNoteType = SpecialNoteType.values()[random.nextInt(SpecialNoteType.values().length)];
                            } else { // reset
                                specialNoteType = null;
                            }
                        }
                        firstToneTypes.add(chord.getFirstToneType());
                        int[] chordPitches = chord.getPitches();
                        logger.debug(Arrays.toString(chordPitches) + " : " + currentNote.getPitch());


                        postProcessPitches(accompanimentPart, chordPitches);


                        int dynamics = InstrumentGroups.getInstrumentSpecificDynamics(65 + random.nextInt(20), accompanimentPart.getInstrument());
                        // in some cases repeat the chord
                        if (Chance.test(82)) {
                            if (Chance.test(75)) { //full chord
                                addChord(chordPitches, chordLength, dynamics, accompanimentPhrase,
                                        specialNoteType, preferChordNotesOffset, measureOffset);
                            } else { //partial chord + rest
                                // make the filling rest between 1/16 and 1/4
                                double restLength = 0.125 * Math.pow(2, random.nextInt(4));
                                if (restLength >= chordLength) {
                                    restLength = chordLength / 2;
                                }
                                addChord(chordPitches, chordLength - restLength, dynamics,
                                        accompanimentPhrase, specialNoteType, preferChordNotesOffset,
                                        measureOffset);
                                accompanimentPhrase.addRest(new Rest(restLength));
                            }
                        } else {
                            addChord(chordPitches, chordLength / 2, dynamics, accompanimentPhrase,
                                    specialNoteType, preferChordNotesOffset, measureOffset);
                            addChord(chordPitches, chordLength / 2, dynamics, accompanimentPhrase,
                                    specialNoteType, preferChordNotesOffset, measureOffset);
                        }
                    } else {
                        accompanimentPhrase.addRest(new Rest(chordLength));
                    }


                    measureChordLength += chordLength;
                }


                if (currentNote.isRest() && (currentMeasureSize == 0 || (interMeasureChord && isHalfMeasure))) {
                    accompanimentPhrase.addRest(new Rest(chordLength));
                    measureChordLength += chordLength;
                }


                currentMeasureSize += currentNote.getRhythmValue();
                if (currentMeasureSize >= normalizedMeasureSize) {
                    // when there's a long note and so no inter-measure chord is possible, fill the measure with a rest
                    if (measureChordLength != currentMeasureSize) {
                        double fillingSize = normalizedMeasureSize - measureChordLength;
                        accompanimentPhrase.addRest(new Rest(fillingSize));

View Full Code Here

        // in some cases add each subsequent note with a slight offset
        double offset = preferOffset && Chance.test(30) || Chance.test(5) ? 0.1 + random.nextInt(20) / 100d : 0;


        // all but the first note are set with length = 0, so that they all sound as a chord
        for (int i = 1; i < chordPitches.length; ++i) {
            Note localNote = NoteFactory.createNote(chordPitches[i], 0.0d);
            localNote.setOffset(measureOffset + i * offset);
            if (noteType == null) {
                localNote.setDuration(chordLength * 0.9d);
            } else {
                localNote.setDuration(chordLength * noteType.getValue());
            }
            localNote.setDynamic(dynamics);
            phrase.addNote(localNote);
        }
        // the first note is added with the right length
        Note note = NoteFactory.createNote(chordPitches[0], chordLength);
        note.setDynamic(dynamics);
        note.setOffset(measureOffset);
        phrase.addNote(note);


        // Add a supplementary octave chord in a lower octave
        if (Chance.test(10)) {
            Note startNote = NoteFactory.createNote(chordPitches[0] - 12, 0.0D);
            startNote.setDuration(chordLength * 0.9D);
            phrase.addNote(startNote);
            phrase.addNote(chordPitches[0] - 24, chordLength);
        }
    }

View Full Code Here

        timpaniPart.add(phrase);
    }


    private Note getNote(ScoreContext ctx, ToneType tone) {
        int pitch = Pitches.C3 + ctx.getScale().getDefinition()[tone.getDegree()];
        Note note = NoteFactory.createNote(pitch, ctx.getNormalizedMeasureSize() / 4);
        note.setDynamic(52 + random.nextInt(10));
        note.setDuration(1.2);
        return note;
    }

View Full Code Here


    @Test
    public void retrogradeTest() {
        MainPartGenerator gen = new MainPartGenerator();
        List<Note> list = new ArrayList<>();
        list.add(new Note(Pitches.C4, RhythmValues.EIGHTH_NOTE));
        list.add(new Note(Pitches.C5, RhythmValues.QUARTER_NOTE));
        list.add(new Note(Pitches.C6, RhythmValues.HALF_NOTE));
        gen.retrograde(list);
        Assert.assertEquals(RhythmValues.EIGHTH_NOTE, list.get(0).getRhythmValue(), 0);
        Assert.assertEquals(RhythmValues.QUARTER_NOTE, list.get(1).getRhythmValue(), 0);
        Assert.assertEquals(RhythmValues.HALF_NOTE, list.get(2).getRhythmValue(), 0);

View Full Code Here


            if (usePause) {
                lCtx.getCurrentPhrase().addRest(new Rest(length));
                structureItem.append("-R-");
            } else {
                Note note = createNote(lCtx, downBeat, length);


                if (lCtx.isAllowOrnaments() && Chance.test(6)) {
                    addOrnamentedNote(lCtx, length, note);
                } else {
                    lCtx.getCurrentPhrase().addNote(note);
                }


                structureItem.append("-" + note.getPitch() + "-");
            }
        }


        // add the cadences to the final phrase, if the above loop has been interrupted due to the end of the piece
        if (lCtx.getCurrentPhrase() != null) {

View Full Code Here

            }
        }
    }


    private Note createNote(MainPartContext lCtx, boolean downBeat, double length) {
        Note note = NoteFactory.createNote(lCtx.getNotePitch(), length);
        note.setDynamic(getNextNoteDynamics(lCtx, downBeat));


        if (lCtx.getSpecialNoteType() != null) {
            note.setDuration(note.getRhythmValue() * lCtx.getSpecialNoteType().getValue());
        } else if (Chance.test(8)) { // in 8% of the cases, choose this note to be special by its own
            note.setDuration(note.getRhythmValue() * SpecialNoteType.values()[random.nextInt(SpecialNoteType.values().length)].getValue());
        } else if (lCtx.getDominantSpecialNoteType() != null) {
            note.setDuration(note.getRhythmValue() * lCtx.getDominantSpecialNoteType().getValue());
        }
        return note;
    }

View Full Code Here

        if (length >= JMC.QUARTER_NOTE && Chance.test(60)) { // trill or tremolo
            boolean tremolo = Chance.test(40); // vary the velocity of the sound
            boolean mordents = Chance.test(20); // trill alternates 2 notes, mordents is alternation of 3 notes
            boolean changePitch = Chance.test(85);
            for (int i = 0; i < count; i++) {
                Note ornamentNote = cloneNote(note);
                ornamentNote.setLength(JMC.THIRTYSECOND_NOTE);
                if (i % 2 == 1) {
                    if (changePitch) {
                        ornamentNote.setPitch(ornamentNote.getPitch() + pitchChange);
                    }
                    if (tremolo) {
                        ornamentNote.setDynamic(ornamentNote.getDynamic() - 20);
                    }


                }
                if (mordents && i % 3 == 1 && changePitch) {
                    ornamentNote.setPitch(ornamentNote.getPitch() + pitchChange);
                } else if (mordents && changePitch && i % 3 == 2) {
                    ornamentNote.setPitch(ornamentNote.getPitch() + secondPitchChange);
                }


                lCtx.getCurrentPhrase().addNote(ornamentNote);
            }
        } else { //appoggiatura
            Note ornament = cloneNote(note);
            note.setLength(note.getRhythmValue() - JMC.THIRTYSECOND_NOTE);
            ornament.setLength(JMC.THIRTYSECOND_NOTE);
            lCtx.getCurrentPhrase().addNote(ornament);
            lCtx.getCurrentPhrase().addNote(note);
        }


        //TODO "turn"

View Full Code Here


    private void addInitialMeasures(MainPartContext lCtx, Part part) {
        if (Chance.test(43)) {
            int pitch = Pitches.C4 + lCtx.getScoreContext().getKeyNote();
            // initial note is needed, so that accompaniment can "hook" to it.
            Note note = NoteFactory.createNote(pitch, JMC.QUARTER_NOTE);
            double restLength = lCtx.getScoreContext().getNormalizedMeasureSize() - JMC.QUARTER_NOTE;
            ExtendedPhrase phrase = new ExtendedPhrase();
            phrase.setScale(lCtx.getScoreContext().getScale());
            phrase.setMeasures(2 + random.nextInt(3));
            phrase.add(note);

View Full Code Here


    private static double getVariationPerNote(Phrase phrase) {
        double variation = 0;
        int noteCount = 0;
        Note[] notes = phrase.getNoteArray();
        Note previousNote = null;
        for (Note note : notes) {
            if (note.isRest()) {
                continue;
            }
            if (previousNote != null) {
                variation += Math.abs(note.getPitch() - previousNote.getPitch());
            }
            previousNote = note;
            noteCount++;
        }
        if (noteCount == 0) {

View Full Code Here

            }
        }
    }


    private Note cloneNote(Note note) {
        Note newNote = NoteFactory.createNote(note.getPitch(), note.getRhythmValue(), note.getDynamic());
        newNote.setDuration(note.getDuration());
        return newNote;
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of jm.music.data.Note

com.music.AccompanimentPartGenerator

com.music.Arpeggiator

com.music.BassPartGenerator

com.music.DroneGenerator

com.music.EffectsGenerator

com.music.LengthTest

com.music.MainPartGenerator

com.music.MusicXmlRenderer

com.music.PadsGenerator

com.music.PercussionGenerator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.