// Sets probabilities of note types into an array from a polylist
  private int[] setProb(Polylist probs) {

    int chord, color, random, scale;
    chord = Integer.parseInt((String) probs.first().toString());
    color = Integer.parseInt((String) probs.second().toString());
    random = Integer.parseInt((String) probs.third().toString());
    scale = Integer.parseInt((String) probs.fourth().toString());

    int[] result = new int[4];
    result[0] = chord;
    result[1] = color;
    result[2] = random;
    result[3] = scale;
    return result;
  }
Esempio n. 2
0
 /**
  * toRoadmapSave is used to create a Polylist for saving to a RoadMap This is NOT the same as the
  * Polylist usedd to save in the dictionary. Returns a Polylist representation of a Brick.
  *
  * @return a Polylist containing the Brick's contents
  */
 @Override
 public Polylist toRoadmapSave() {
   PolylistBuffer buffer = new PolylistBuffer();
   buffer.append(BRICK_KEYWORD);
   buffer.append(Polylist.list("name", dashed(name)));
   buffer.append(Polylist.list("variant", variant));
   buffer.append(Polylist.list("type", type));
   buffer.append(Polylist.list("key", BrickLibrary.keyNumToName(key)));
   buffer.append(Polylist.list("mode", mode));
   buffer.append(Polylist.list("duration", duration));
   buffer.append(Polylist.list("overlap", overlap));
   buffer.append(Polylist.list("end", endValue));
   buffer.append(subBlocksToRoadmapSave());
   return buffer.toPolylist();
 }
Esempio n. 3
0
  /**
   * toBrickDefinition Returns a Polylist formatted specifically to replicate the Brick's original
   * definition format
   *
   * @return a Polylist containing the Brick's definition information
   */
  public Polylist toBrickDefinition() {
    PolylistBuffer buffer = new PolylistBuffer();

    for (Block b : getSubBlocks()) {
      buffer.append(b.toPolylist());
    }
    if (!variant.equals("")) {
      return Polylist.list(
              BrickLibrary.DEF_BRICK,
              dashed(name) + "(" + variant + ")",
              mode,
              dashed(type),
              BrickLibrary.keyNumToName(key))
          .append(buffer.toPolylist());
    } else {
      return Polylist.list(
              BrickLibrary.DEF_BRICK,
              dashed(name),
              mode,
              dashed(type),
              BrickLibrary.keyNumToName(key))
          .append(buffer.toPolylist());
    }
  }
Esempio n. 4
0
  /**
   * Gets the closest match Note to a given pitchName, from a polylist of NoteSymbols
   *
   * @param pitch
   * @param tonesPL
   * @return Note an instance of the 'closest' note in list from the pitchName
   */
  public static Note getClosestMatch(int pitch, Polylist tonesPL) {
    int originalPitch = pitch;
    // System.out.println("getClosestMatch to " + pitchName + " " + tonesPL);

    if (!tonesPL.nonEmpty()) {
      ErrorLog.log(ErrorLog.WARNING, "*** Error: No tones list to match against.");
    }

    Polylist list = tonesPL;
    int[] tones = new int[list.length()];

    /* Make an array of pitches of all acceptable tones to match to */
    for (int i = 0; list.nonEmpty(); i++) {
      try {
        tones[i] = ((NoteSymbol) list.first()).getMIDI() % OCTAVE;
        list = list.rest();
      } catch (Exception ep) {
        // ep.printStackTrace();
      }
    }

    /* Search incrementally within the tones list for the 'closest'
     * acceptable pitchName.  This will fit our contour best.
     */
    int stepSearch = 0;
    int indexMatch;

    while ((indexMatch = arrayContains((pitch % OCTAVE), tones)) == OUT_OF_BOUNDS) {
      stepSearch++;
      if (stepSearch % 2 == 0) {
        pitch -= stepSearch;
      } else {
        pitch += stepSearch;
      }
    }

    Note note = ((NoteSymbol) tonesPL.nth(indexMatch)).toNote();
    note.setPitch(pitch);
    /*
    if( pitchName != originalPitch )
    {
        System.out.println("closest match to " + new Note(originalPitch).toLeadsheet() + " is " + note.toLeadsheet() + " among " + tonesPL);
    }
     */
    return note;
  }
Esempio n. 5
0
  /**
   * Gets the closest match Note at or above a given pitchName, from a polylist of NoteSymbols
   *
   * @param pitch
   * @param tonesPL
   * @param upward
   * @return Note an instance of the 'closest' note in list from the pitchName
   */
  public static Note getClosestMatchDirectional(int pitch, Polylist tonesPL, boolean upward) {
    // System.out.println("getClosestMatchDirectional to " + pitchName + " " + tonesPL);
    if (!tonesPL.nonEmpty()) {
      ErrorLog.log(ErrorLog.WARNING, "*** Error: No tones list to match against.");
    }

    Polylist list = tonesPL;
    int[] tones = new int[tonesPL.length()];

    /* Make an array of pitches of all acceptable tones to match to */
    for (int i = 0; i < tones.length; i++) {
      try {
        tones[i] = ((NoteSymbol) tonesPL.first()).getMIDI() % OCTAVE;
        tonesPL = tonesPL.rest();
      } catch (Exception ep) {
        // ep.printStackTrace();
      }
    }

    /* Search incrementally within the tones list for the 'closest'
     * acceptable pitchName.  This will fit our contour best.
     */

    int indexMatch;

    if (upward) {
      pitch++;
    } else {
      pitch--;
    }
    while ((indexMatch = arrayContains((pitch % OCTAVE), tones)) == OUT_OF_BOUNDS) {
      if (upward) {
        pitch++;
      } else {
        pitch--;
      }
    }

    Note note = ((NoteSymbol) list.nth(indexMatch)).toNote();
    note.setPitch(pitch);
    return note;
  }
  public NoteChooser(boolean noOctaveSwitch) {

    // if this is true, never transpose pitch an octave if out of bounds
    doNotSwitchOctave = noOctaveSwitch;

    /* The first number in each line represents which type of note we are
     * looking for - 0 for chord, 1 for color, 2 for random, 3 for scale
     * The next three numbers represent which notes are present of chord,
     * color, and then random
     * The last 4 numbers are probabilities for which will be chosen:
     * in order - chord, color, random, scale
     */
    String probString =
        "( (0 1 1 1 100 0 0 0) "
            + // looking for chord, have chord, color, random
            "(0 1 1 0 100 0 0 0) "
            + // looking for chord, have chord, color
            "(0 1 0 1 100 0 0 0) "
            + // looking for chord, have chord, random
            "(0 1 0 0 100 0 0 0) "
            + // looking for chord, have chord
            "(0 0 1 1 0 100 0 0) "
            + // looking for chord, have color, random
            "(0 0 1 0 0 100 0 0) "
            + // looking for chord, have color
            "(0 0 0 1 0 0 100 0) "
            + // looking for chord, have random
            "(1 1 1 1 0 100 0 0) "
            + // looking for color, have chord, color, random
            "(1 1 1 0 10 90 0 0) "
            + // looking for color, have chord, color
            "(1 1 0 1 85 0 15 0) "
            + // looking for color, have chord, random
            "(1 1 0 0 100 0 0 0) "
            + // looking for color, have chord
            "(1 0 1 1 0 100 0 0) "
            + // looking for color, have color, random
            "(1 0 1 0 0 100 0 0) "
            + // looking for color, have color
            "(1 0 0 1 0 0 100 0) "
            + // looking for color, have random
            "(3 1 1 1 0 0 0 100) "
            + // looking for scale, have chord, color, random
            "(3 1 1 0 0 0 0 100) "
            + // looking for scale, have chord, color
            "(3 1 0 1 0 0 0 100) "
            + // looking for scale, have chord, random
            "(3 1 0 0 0 0 0 100) "
            + // looking for scale, have chord
            "(3 0 1 1 0 0 0 100) "
            + // looking for scale, have color, random
            "(3 0 1 0 0 0 0 100) "
            + // looking for scale, have color
            "(3 0 0 1 0 0 100 0) "
            + // looking for scale, have random
            "(2 1 1 1 50 25 25 0) "
            + // looking for random, have chord, color, random
            "(2 1 1 0 80 20 0 0) "
            + // looking for random, have chord, color
            "(2 1 0 1 50 0 50 0) "
            + // looking for random, have chord, random
            "(2 1 0 0 100 0 0 0) "
            + // looking for random, have chord
            "(2 0 1 1 0 50 50 0) "
            + // looking for random, have color, random
            "(2 0 1 0 0 100 0 0) "
            + // looking for random, have color
            "(2 0 0 1 0 0 100 0) )"; // looking for random, have random

    probabilities = (Polylist) (Polylist.PolylistFromString(probString)).first();
  }
  /* Called from chooseNote in Lickgen
   * Given an interval, the desired type of note,
   * the types of notes in the interval, and the occurences of each type of note,
   * looks up the probabilities for what type of note to choose in a table
   * and returns a note chosen based on the probabilities
   * attempts is a counter for the number of times we have tried to get all pitches within range
   */
  public int getNote(
      int minPitch,
      int maxPitch,
      int low,
      int high,
      int type,
      int[] numTypes,
      int[] noteTypes,
      int attempts) {

    if (type == CHORD) type = 0;
    if (type == COLOR) type = 1;
    if (type == RANDOM) type = 2;
    if (type == SCALE) type = 3;

    Polylist prob = new Polylist();

    // integers representing whether a certain type is present
    int haveChord, haveColor, haveRandom;
    if (numTypes[0] != 0) haveChord = 1;
    else haveChord = 0;
    if (numTypes[1] != 0) haveColor = 1;
    else haveColor = 0;
    if (numTypes[2] != 0) haveRandom = 1;
    else haveRandom = 0;

    // special case for chord tones - they are more important than staying
    // in the interval
    // if(type == 0 && haveChord == 0) {
    //   for(int i = low - 4; i <= low + 4; i++) {
    //
    //   }
    // }

    Polylist identifier = Polylist.list(type, haveChord, haveColor, haveRandom);

    // look for match
    for (Polylist L = probabilities; L.nonEmpty(); L = L.rest()) {
      // get first list in probabilities
      Polylist tempProb = (Polylist) L.first();
      // chop off the probabilities so we just have the identifier
      Polylist tempIdentifier = tempProb.prefix(4);
      if (identifier.equals(tempIdentifier)) {
        prob = tempProb.coprefix(4);
      }
    }

    // put the matched probabilities into an array
    int[] probs = setProb(prob);

    Random rand = new Random();

    // generate note type from probabilities
    int randNum = rand.nextInt(100) + 1;
    int newType = 0; // -1;
    for (int i = 0; i < probs.length; i++) {
      randNum = randNum - probs[i];
      if (randNum <= 0) {
        newType = i;
        i = probs.length;
      }
    }

    // get note pitch
    randNum = rand.nextInt(numTypes[newType]) + 1;
    int pitchdiff = 0;
    for (int i = 0; i < noteTypes.length; i++) {
      if (noteTypes[i] == typeMap[newType]
          || (newType == 3 && (noteTypes[i] == CHORD || noteTypes[i] == COLOR))) {
        randNum--;
      }
      if (randNum <= 0) {
        pitchdiff = i;
        i = noteTypes.length;
      }
    }
    int finalPitch = low + pitchdiff;

    if (attempts >= LickGen.MELODY_GEN_LIMIT - 1 && doNotSwitchOctave == false) {
      // raise or lower by an octave if outside bounds
      while (finalPitch > maxPitch) {
        finalPitch -= 12;
      }
      while (finalPitch < minPitch) {
        finalPitch += 12;
      }
    }
    return finalPitch;
  }
Esempio n. 8
0
 /**
  * toPolylist Returns a Polylist representation of a Brick.
  *
  * @return a Polylist containing the Brick's contents
  */
 @Override
 public Polylist toPolylist() {
   return Polylist.list(BRICK_KEYWORD, dashed(name), BrickLibrary.keyNumToName(key), duration);
 }
Esempio n. 9
0
  /**
   * addSubBlocks / 3 Constructs the subblocks of a brick by reading in a PolyList and using a
   * BrickLibrary to convert it to bricks with appropriate subbricks.
   *
   * @param contents, a PolyList of subbricks
   * @param bricks, a BrickLibrary
   */
  private void addSubBlocks(
      Polylist contents, BrickLibrary bricks, LinkedHashMap<String, LinkedList<Polylist>> polymap) {

    List<Block> subBlockList = new ArrayList<Block>();

    while (contents.nonEmpty()) {
      Object obj = contents.first();
      contents = contents.rest();
      if (obj instanceof Polylist) {
        Polylist pList = (Polylist) obj;
        String blockType = pList.first().toString();
        pList = pList.rest();

        // If a subblock is a brick, split it into components and then
        // look up the corresponding brick in the library to construct
        // the necessary new brick.
        if (blockType.equals(BRICK_KEYWORD) && (pList.length() == 3 || pList.length() == 4)) {
          // determine the information about the name, variant, etc.
          String subBrickName = BrickLibrary.dashless(pList.first().toString());
          pList = pList.rest();

          String subBrickVariant = "";
          if (pList.first() instanceof Polylist) {
            subBrickVariant = ((Polylist) pList.first()).toStringSansParens();
            pList = pList.rest();
          }

          String subBrickKeyString = pList.first().toString();
          pList = pList.rest();

          // Workaround added by RK for error reporting
          // in case of missing duration in sub-brick

          Object durObj = DEFAULT_SUBRICK_DURATION;

          if (pList.isEmpty()) {
            ErrorLog.log(
                ErrorLog.WARNING, "Missing Sub-Brick Duration in " + subBrickName + ", using 1");
          } else {
            durObj = pList.first();
            // pList = pList.rest();
          }

          // when all data members are initialized, find the correct
          // brick scaled appropriately
          boolean starFlag = isStar(durObj);
          if (durObj instanceof Long || starFlag) {
            int dur = starFlag ? 0 : Arith.long2int((Long) durObj);
            long subBrickKeyNum = BrickLibrary.keyNameToNum(subBrickKeyString);
            Brick subBrick = null;

            // if the subbrick already exists in the dictionary
            if (bricks.hasBrick(subBrickName)) {
              if (!subBrickVariant.equals("")) {
                subBrick = bricks.getBrick(subBrickName, subBrickVariant, subBrickKeyNum, dur);
              } else {
                subBrick = bricks.getBrick(subBrickName, subBrickKeyNum, dur);
              }
            }

            // if the subbrick has yet to be initialized in the
            // dictionary, make one to use for now
            else if (polymap.containsKey(subBrickName)) {

              // find the appropriate definition to use to assemble
              // the subbrick
              LinkedList<Polylist> tokenList = polymap.get(subBrickName);
              Polylist tokens = null;
              if (subBrickVariant.equals("")) {
                tokens = tokenList.getFirst();
              } else {
                for (Polylist p : tokenList) {
                  Object variant = p.rest().rest().first();
                  if (variant instanceof Polylist
                      && ((Polylist) variant).toStringSansParens().equals(subBrickVariant)) {
                    tokens = p;
                    break;
                  }
                }
                if (tokens == null) {
                  ErrorLog.log(
                      ErrorLog.SEVERE,
                      "Dictionary does not contain " + subBrickName + subBrickVariant);
                }
              }

              // find the elements of the subbrick
              String brickName = BrickLibrary.dashless(subBrickName);
              tokens = tokens.rest();
              tokens = tokens.rest();

              String brickVariant = "";
              if (tokens.first() instanceof Polylist) {
                brickVariant = ((Polylist) tokens.first()).toStringSansParens();
                tokens = tokens.rest();
              }
              String brickMode = tokens.first().toString();
              tokens = tokens.rest();
              String brickType = tokens.first().toString();
              tokens = tokens.rest();
              String brickKeyString = tokens.first().toString();
              tokens = tokens.rest();
              long brickKeyNum = BrickLibrary.keyNameToNum(brickKeyString);

              // construct the subbrick
              subBrick =
                  new Brick(
                      brickName,
                      brickVariant,
                      brickKeyNum,
                      brickType,
                      tokens,
                      bricks,
                      brickMode,
                      polymap);
              subBrick.transpose(Arith.long2int(subBrickKeyNum - brickKeyNum));
              subBrick.setDuration(dur);
            } else {
              ErrorLog.log(
                  ErrorLog.SEVERE, "Dictionary does " + "not contain " + subBrickName, true);
            }

            subBlockList.add(subBrick);
          } else {
            ErrorLog.log(
                ErrorLog.FATAL, subBrickName + ": " + "Duration not of type long: " + obj, true);
          }
        }

        // If a subblock is a chord, make an appropriate Chord object
        else if (blockType.equals(CHORD_KEYWORD) && pList.length() == 2) {
          String chordName = pList.first().toString();
          pList = pList.rest();
          Object durObj = pList.first();
          // pList = pList.rest();
          boolean starFlag = isStar(durObj);
          if (durObj instanceof Long || starFlag) {
            int dur = starFlag ? 0 : Arith.long2int((Long) durObj);
            ChordBlock subBlockChord = new ChordBlock(chordName, dur);
            subBlockList.add(subBlockChord);
          } else {
            ErrorLog.log(
                ErrorLog.FATAL, chordName + ": " + "Duration not of type long: " + durObj, true);
          }
        } else {
          ErrorLog.log(
              ErrorLog.WARNING,
              "Incorrect subblock of "
                  + name
                  + ": "
                  + blockType
                  + " "
                  + pList.toStringSansParens());
        }
      }
    }

    subBlocks.addAll(subBlockList);
  }
Esempio n. 10
0
  /**
   * addSubBlocks / 2 Constructs the subblocks of a brick by reading in a PolyList and using a
   * BrickLibrary to convert it to bricks with appropriate subbricks.
   *
   * @param contents, a PolyList of subbricks
   * @param bricks, a BrickLibrary
   */
  private void addSubBlocks(Polylist contents, BrickLibrary bricks) {

    List<Block> subBlockList = new ArrayList<Block>();

    while (contents.nonEmpty()) {
      Object obj = contents.first();
      contents = contents.rest();
      if (obj instanceof Polylist) {
        Polylist pList = (Polylist) obj;
        String blockType = pList.first().toString();
        pList = pList.rest();

        // If a subblock is a brick, split it into components and then
        // look up the corresponding brick in the library to construct
        // the necessary new brick.
        if (blockType.equals(BRICK_KEYWORD)) {
          String brickName = BrickLibrary.dashless(pList.first().toString());
          pList = pList.rest();
          String brickVariant = "";
          if (pList.first() instanceof Polylist) {
            brickVariant = ((Polylist) pList.first()).toStringSansParens();
            pList = pList.rest();
          }
          String brickKeyString = pList.first().toString();
          pList = pList.rest();
          Object durObj = pList.first();
          // pList = pList.rest();
          boolean starFlag = isStar(durObj);
          if (durObj instanceof Long || starFlag) {
            int dur = starFlag ? 0 : Arith.long2int((Long) durObj);
            long brickKeyNum = BrickLibrary.keyNameToNum(brickKeyString);
            Brick subBrick;
            if (brickVariant.equals("")) {
              subBrick =
                  bricks.getBrick(
                      brickName, brickVariant,
                      brickKeyNum, dur);
            } else {
              subBrick = bricks.getBrick(brickName, brickKeyNum, dur);
            }
            subBlockList.add(subBrick);
          } else {
            ErrorLog.log(
                ErrorLog.FATAL, brickName + ": " + "Duration not of type long: " + obj, true);
          }
        }

        // If a subblock is a chord, make an appropriate Chord object
        else if (blockType.equals(CHORD_KEYWORD)) {
          String chordName = pList.first().toString();
          pList = pList.rest();
          Object durObj = pList.first();
          boolean starFlag = isStar(durObj);
          if (durObj instanceof Long || starFlag) {
            int dur = starFlag ? 0 : Arith.long2int((Long) durObj);
            ChordBlock subBlockChord = new ChordBlock(chordName, dur);
            subBlockList.add(subBlockChord);
          } else {
            ErrorLog.log(
                ErrorLog.FATAL, chordName + ": " + "Duration not of type long: " + obj, true);
          }
        }
      }
    }

    subBlocks.addAll(subBlockList);
  }
Esempio n. 11
0
  /**
   * Make a Brick from a Polylist in the external representation of a RoadMap
   *
   * @param blockPolylist
   * @return
   */
  public static Block fromPolylist(Polylist blockPolylist) {
    // Need to populate sub-blocks before calling constructor!
    Polylist temp;
    temp = blockPolylist.assoc("name");

    String name = (String) temp.second();
    temp = blockPolylist.assoc("variant");
    String variant = temp.rest().nonEmpty() ? (String) temp.second() : DEFAULT_VARIANT;

    temp = blockPolylist.assoc("type");
    String type = (String) temp.second();

    temp = blockPolylist.assoc("key");
    String key = (String) temp.second();

    temp = blockPolylist.assoc("duration");
    int duration = ((Number) temp.second()).intValue();

    temp = blockPolylist.assoc("overlap");
    boolean overlap = temp.second().equals("true");

    temp = blockPolylist.assoc("end");
    int endValue = ((Number) temp.second()).intValue();

    temp = blockPolylist.assoc("mode");
    String mode = (String) temp.second();

    temp = blockPolylist.assoc("blocks");
    ArrayList<Block> blocks = new ArrayList<Block>();

    Polylist polyBlocks = temp.rest();
    while (polyBlocks.nonEmpty()) {
      Polylist polyBlock = (Polylist) polyBlocks.first();
      Block block = Block.fromPolylist(polyBlock);
      blocks.add(block);
      polyBlocks = polyBlocks.rest();
    }

    Brick brick = new Brick(name, variant, BrickLibrary.keyNameToNum(key), type, blocks, mode);
    brick.setOverlap(overlap);
    brick.setSectionEnd(endValue);
    // Above, we are targeting this constructor:
    //
    //   public Brick(String brickName,
    //                 long brickKey,
    //                 String type,
    //                 List<Block> brickList)

    return brick;
  }
Esempio n. 12
0
  // Determine whether '#' or 'b' is visible in the lick triage utility, based on
  // whatever the current chord is.
  public boolean[] getCurrentEnharmonics(int index, Polylist tones) {
    boolean[] enh = new boolean[5];

    // We set the default visible accidental to '#' if we're in a sharp key; otherwise, set
    // the default to 'b'.
    if (keySig >= 0) {
      enh[CSHARP] = true;
      enh[DSHARP] = true;
      enh[FSHARP] = true;
      enh[GSHARP] = true;
      enh[ASHARP] = true;
    } else {
      enh[CSHARP] = false;
      enh[DSHARP] = false;
      enh[FSHARP] = false;
      enh[GSHARP] = false;
      enh[ASHARP] = false;
    }

    // Get the current chord if there is one.
    Chord current = chordProg.getCurrentChord(index);

    if (current == null || current.getName().equals(NOCHORD)) {
      return enh;
    }

    if (tones == null || tones.isEmpty()) {
      return enh;
    }

    // Look at all the chord tones in the list and determine whether we need to change
    // any accidental labels from '#' to 'b'
    while (tones.nonEmpty()) {
      NoteSymbol first = (NoteSymbol) tones.first();
      tones = tones.rest();

      if (first.getPitchString().length() > 1) {
        switch (first.getPitchString().charAt(0)) {
          case 'c':
            if (first.getPitchString().charAt(1) == '#') {
              enh[CSHARP] = true;
            }
            break;
          case 'd':
            if (first.getPitchString().charAt(1) == 'b') {
              enh[CSHARP] = false;
            } else if (first.getPitchString().charAt(1) == '#') {
              enh[DSHARP] = true;
            }
            break;
          case 'e':
            if (first.getPitchString().charAt(1) == 'b') {
              enh[DSHARP] = false;
            }
            break;
          case 'f':
            if (first.getPitchString().charAt(1) == '#') {
              enh[FSHARP] = true;
            }
          case 'g':
            if (first.getPitchString().charAt(1) == 'b') {
              enh[FSHARP] = false;
            } else if (first.getPitchString().charAt(1) == '#') {
              enh[GSHARP] = true;
            }
            break;
          case 'a':
            if (first.getPitchString().charAt(1) == 'b') {
              enh[GSHARP] = false;
            } else if (first.getPitchString().charAt(1) == '#') {
              enh[ASHARP] = true;
            }
            break;
          case 'b':
            if (first.getPitchString().charAt(1) == 'b') {
              enh[ASHARP] = false;
            }
            break;
        }
      }
    }
    return enh;
  }
Esempio n. 13
0
 public void setDefaultLayout() {
   this.layout = Polylist.list(DEFAULT_BARS_PER_LINE);
 }