FAMAS Index du Forum

FAMAS
Faction armée des makers assoiffés de sang

 FAQFAQ   RechercherRechercher   MembresMembres   GroupesGroupes   S’enregistrerS’enregistrer 
 ProfilProfil   Se connecter pour vérifier ses messages privésSe connecter pour vérifier ses messages privés   ConnexionConnexion 

Créations diverses
Aller à la page: <  1, 2, 318, 19, 20101, 102, 103  >
 
Poster un nouveau sujet   Répondre au sujet    FAMAS Index du Forum -> Section Corvées -> Laboratoire de recherche & développement
Sujet précédent :: Sujet suivant  
Auteur Message
trotter



Inscrit le: 26 Juil 2011
Messages: 6 872

MessagePosté le: Dim 25 Nov - 00:51 (2012)    Sujet du message: Créations diverses Répondre en citant

PublicitéSupprimer les publicités ?
Revue du message précédent :

Elle bronze avec un Facekini.
Revenir en haut
Roi of the Suisse
Vétéran


Inscrit le: 27 Juil 2011
Messages: 8 140

MessagePosté le: Dim 25 Nov - 01:11 (2012)    Sujet du message: Créations diverses Répondre en citant

Alors moi j'ai commencé un programme java qui compose de la musique tout seul.
Vous pouvez le lancer (à condition d'avoir des fichiers "C:\\Users\\Pierre\\Documents\\ia\\do.wav" pour chacune des 12 notes), il ne joue pour l'instant que des bases harmoniques de 4 mesures de long.
Code:
package musique;

import java.io.File;
import java.io.IOException;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.FloatControl;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;

public class Musique extends Thread {

    private String filename;
    private Position curPosition;
    private final int EXTERNAL_BUFFER_SIZE = 524288; // 128Kb
    enum Position {LEFT, RIGHT, NORMAL};

    public Musique(String wavfile) {
        filename = wavfile;
        curPosition = Position.NORMAL;
    }

    public void run() {
        File soundFile = new File(filename);
        if (!soundFile.exists()) {
            System.err.println("Wave file not found: " + filename);
            return;
        }

        AudioInputStream audioInputStream = null;
        try {
            audioInputStream = AudioSystem.getAudioInputStream(soundFile);
        } catch (UnsupportedAudioFileException e1) {
            e1.printStackTrace();
            return;
        } catch (IOException e1) {
            e1.printStackTrace();
            return;
        }

        AudioFormat format = audioInputStream.getFormat();
        SourceDataLine auline = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);

        try {
            auline = (SourceDataLine) AudioSystem.getLine(info);
            auline.open(format);
        } catch (LineUnavailableException e) {
            e.printStackTrace();
            return;
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }

        if (auline.isControlSupported(FloatControl.Type.PAN)) {
            FloatControl pan = (FloatControl) auline.getControl(FloatControl.Type.PAN);
            if (curPosition == Position.RIGHT) {
                pan.setValue(1.0f);
            } else if (curPosition == Position.LEFT) {
                pan.setValue(-1.0f);
            }
        }

        auline.start();
        int nBytesRead = 0;
        byte[] abData = new byte[EXTERNAL_BUFFER_SIZE];

        try {
            while (nBytesRead != -1) {
                nBytesRead = audioInputStream.read(abData, 0, abData.length);
                if (nBytesRead >= 0) {
                    auline.write(abData, 0, nBytesRead);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            return;
        } finally {
            auline.drain();
            auline.close();
        }
    }

   
   
   
    public static int choisirHumeurInitiale(){
        return (int) (Math.random() * 3) + 1; // 1 == melancolique ; 2 == elegiaque ; 3 == instable ;
    }
   
    public static int choisirFormat(int vitesse, int humeur){
        // nombre de temps par mesure
        int format =1;
        if (vitesse == 3){ // en vitesse rapide pas de formats courts
            if (humeur == 1){ //humeur melancolique donc plutot une fluide (2) qu'une rigoureuse (1)
                if (resultatProbabilite(0.618)){
                    format = 6;
                }
                else{
                    format = 4;
                }
            }
            if (humeur == 2){ //humeur elegiaque donc plutot une rigoureuse (1) qu'une fluide (2)
                if (resultatProbabilite(0.707)){
                    format = 4;
                }
                else{
                    format = 6;
                }
            }
            if (humeur == 3){ // instable don peu importe
                while (format != 5){
                    format = (int) (Math.random() * 5) + 2;
                }
            }
           
        }
        else{ // vitesse lente ou moyenne
            if (humeur ==1){
                if (resultatProbabilite(0.618)){
                    format = 6; //fluide
                }
                else{
                    if (resultatProbabilite(0.5)){
                        format = 4; //rigoureuse
                    }
                    else{
                        if (resultatProbabilite(0.7)){
                            format = 2; //naine
                        }
                        else{
                            format = 3; //valse
                        }
                    }
                }
            }
            if (humeur ==2){
                if (resultatProbabilite(0.3)){
                    format = 6; //fluide
                }
                else{
                    if (resultatProbabilite(0.7)){
                        format = 4; //rigoureuse
                    }
                    else{
                        if (resultatProbabilite(0.3)){
                            format = 2; //naine
                        }
                        else{
                            format = 3; //valse
                        }
                    }
                }
            }
            if (humeur ==3){
                if (resultatProbabilite(0.5)){
                    format = 6; //fluide
                }
                else{
                    if (resultatProbabilite(0.7)){
                        format = 4; //rigoureuse
                    }
                    else{
                        if (resultatProbabilite(0.5)){
                            format = 2; //naine
                        }
                        else{
                            format = 3; //valse
                        }
                    }
                }
            }
        }
        return format;
    }
   
    public static int choisirVitesseInitiale(){
        int lower = 1;
        int higher = 2;
        // 1 == lent ; 2 == moyen ; 3 == rapide ;
        higher++;
        return (int) (Math.random() * (higher-lower)) + lower;
    }
   
    public static int choisirTempoInitial(int vitesse){
            int lower=120;
            int higher=120;
           
        vitesse = 2; // à enlever quand gestion des notes courtes !!!       
       
        if (vitesse == 1) { // lent
            lower = 70;
            higher = 100;
        }
        if (vitesse == 2) { // moyen
            lower = 100;
            higher = 142;
        }
        if (vitesse == 3) { // moyen
            lower = 142;
            higher = 168;
        }
       
        higher++;
        return (int)(Math.random() * (higher-lower)) + lower;
    }
   
    public static void wait (int k){
        long time0, time1;
        time0 = System.currentTimeMillis();
        time1 = System.currentTimeMillis();
        while ( (time1 - time0) < k ){
            time1 = System.currentTimeMillis();
        }
    }
   
    public static void jouerNote(int note){
        int nott = note % 12;
        while(nott < 0){
            nott = nott+12;
        }
        while (nott >= 12){
            nott = nott - 12;
        }
       
        switch(nott){
            case 0:
                Thread playWave0=new Musique("C:\\Users\\Pierre\\Documents\\ia\\la.wav");
                playWave0.start();
                break;
            case 1:
                Thread playWave1=new Musique("C:\\Users\\Pierre\\Documents\\ia\\sib.wav");
                playWave1.start();
                break;
            case 2:
                Thread playWave2=new Musique("C:\\Users\\Pierre\\Documents\\ia\\si.wav");
                playWave2.start();
                break;
            case 3:
                Thread playWave3=new Musique("C:\\Users\\Pierre\\Documents\\ia\\do.wav");
                playWave3.start();
                break;
            case 4:
                Thread playWave4=new Musique("C:\\Users\\Pierre\\Documents\\ia\\dod.wav");
                playWave4.start();
                break;
            case 5:
                Thread playWave5=new Musique("C:\\Users\\Pierre\\Documents\\ia\\re.wav");
                playWave5.start();
                break;
            case 6:
                Thread playWave6=new Musique("C:\\Users\\Pierre\\Documents\\ia\\mib.wav");
                playWave6.start();
                break;
            case 7:
                Thread playWave7=new Musique("C:\\Users\\Pierre\\Documents\\ia\\mi.wav");
                playWave7.start();
                break;
            case 8:
                Thread playWave8=new Musique("C:\\Users\\Pierre\\Documents\\ia\\fa.wav");
                playWave8.start();
                break;
            case 9:
                Thread playWave9=new Musique("C:\\Users\\Pierre\\Documents\\ia\\fad.wav");
                playWave9.start();
                break;
            case 10:
                Thread playWave10=new Musique("C:\\Users\\Pierre\\Documents\\ia\\sol.wav");
                playWave10.start();
                break;
            case 11:
                Thread playWave11=new Musique("C:\\Users\\Pierre\\Documents\\ia\\sold.wav");
                playWave11.start();
                break;
        }
    }
     
    public static void jouerPremierePartition(int tempo, int format, int humeur, double ecrasement,int profondeurMaximale, int gamme, int tailleMelodie){
        int[][] base = choisirBaseHarmonique(format,humeur,ecrasement,profondeurMaximale, gamme);
       
        ajouterMelodie(base,format,humeur,ecrasement,profondeurMaximale,gamme,tailleMelodie);
       
        System.out.println("ecrasement : " + ecrasement);
        afficherPartition(base, format);
        playPartitionRythme(base,tempo,format);
        playPartitionRythme(base,tempo,format);
    }
   
    public static void ajouterMelodie(int[][] base, int format, int humeur, double ecrasement, int profondeurMaximale, int gamme, int tailleMelodie){
        for(int i=0 ; i<4*format*36 ; i++){
            if (base[i][0] != 13){
                base[i][1] = 12;
            }
        }
       
        int[] mesureRythmeMelodie = new int[2*format*36];
        mesureRythmeMelodie = inventerMesureRythmeMelodie(base,format,humeur,ecrasement,profondeurMaximale,tailleMelodie);
       
    }
   
    public static int[] inventerMesureRythmeMelodie(int[][] base,int format,int humeur,double ecrasement, int profondeurMaximale, int tailleMelodie){
        int[] mesureRythme = new int[sizeMelodie*format*36];
        for (int i=0 ; i<format*36 ; i++){
            mesureRythme[i]=0;
        }
       
        for (int j=0 ; j<(4/tailleMelodie) ; j++){
            for (int i=0 ; i<format*36 ; i++){
                if (base[i+j*36*format][1]==12){
                    mesureRythme[i]=mesureRythme[i]+importanceMesure(j);
                }
            }
        }
       
        mesureRythme = trouverRythmeMelodie(mesureRythme,format,tailleMelodie,ecrasement,profondeurMaximale,humeur);
       
        return mesureRythme;
    }
   
    public static int importanceMesure(int j){
        if (j==0){
            return 4;
        }
        else{
            if (j==2){
                return 3;
            }
            else{
                if (j==1){
                    return 2;
                }
                else{
                    return 1;
                }
            }
        }
    }
   
    public static int[] trouverRythmeMelodie(int[] mesureRythme,int format, int tailleMelodie,double ecrasement,int profondeurMaximale, int humeur){
        mesureRythme = regulariserRythme(mesureRythme,format,tailleMelodie);
        int[/* taille */][/* numero 1 ou 2 */][/* rythme*/] tableauDeChoixDeRythmes = choixDesRythmes(format,humeur,ecrasement,profondeurMaximale);
        mesureRythme = broderRythme(mesureRythme,format,tailleMelodie,tableauDeChoixDeRythmes);
       
        return mesureRythme;
    }
   
    public static int[][][] choixDesRythmes(int format, int humeur, double ecrasement,int profondeurMaximale){
               
        int[] rythmeVide = {0,0,0,0,0,0,0,0,0,0,0,0};
        int[][][] tableDeRythmes = new int[12][10][12];
        for (int i=0; i<12;i++){ //différentes tailles de rythmes
            for (int n=0; n<10; n++){
                tableDeRythmes[i][n]=rythmeVide;
            }
        }
       
        int[] coefficientsVides = {0,0,0,0,0,0,0}; //un coefficient se compose des coefficients de format et d'humeur
        int[][][] tableDeCoefficients = new int[12][10][7];
        for (int i=0; i<12;i++){ //différentes tailles de rythmes
            for (int n=0; n<10;n++){
                tableDeCoefficients[i][n]=coefficientsVides;
            }
        }
       
       
        int[] rythme1_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[1-1][0]=rythme1_0;
        int[] coeff1_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[1-1][0]=coeff1_0;
       
        int[] rythme2_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[2-1][0]=rythme2_0;
        int[] coeff2_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[2-1][0]=coeff2_0;
        int[] rythme2_1 = {1,1,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[2-1][1]=rythme2_1;
        int[] coeff2_1 ={0,1,0,1,0,1,0}; tableDeCoefficients[2-1][1]=coeff2_1;
       
        int[] rythme3_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[3-1][0]=rythme3_0;
        int[] coeff3_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[3-1][0]=coeff3_0;
        int[] rythme3_1 = {1,0,1,0,0,0,0,0,0,0,0,0}; tableDeRythmes[3-1][1]=rythme3_1;
        int[] coeff3_1 ={0,1,0,1,1,1,1}; tableDeCoefficients[3-1][1]=coeff3_1;
        int[] rythme3_2 = {1,1,1,0,0,0,0,0,0,0,0,0}; tableDeRythmes[3-1][2]=rythme3_2;
        int[] coeff3_2 ={0,1,0,1,1,1,0}; tableDeCoefficients[3-1][2]=coeff3_2;
       
        int[] rythme4_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[4-1][0]=rythme4_0;
        int[] coeff4_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[4-1][0]=coeff4_0;
        int[] rythme4_1 = {1,0,1,0,0,0,0,0,0,0,0,0}; tableDeRythmes[4-1][1]=rythme4_1;
        int[] coeff4_1 ={1,0,1,0,1,1,1}; tableDeCoefficients[4-1][1]=coeff4_1;
        int[] rythme4_2 = {1,0,0,1,0,0,0,0,0,0,0,0}; tableDeRythmes[4-1][2]=rythme4_2;
        int[] coeff4_2 ={1,1,1,1,1,1,1}; tableDeCoefficients[4-1][2]=coeff4_2;
        int[] rythme4_3 = {1,0,1,1,0,0,0,0,0,0,0,0}; tableDeRythmes[4-1][3]=rythme4_3;
        int[] coeff4_3 ={1,0,1,1,1,0,1}; tableDeCoefficients[4-1][3]=coeff4_3;
        int[] rythme4_4 = {1,1,1,0,0,0,0,0,0,0,0,0}; tableDeRythmes[4-1][4]=rythme4_4;
        int[] coeff4_4 ={1,1,1,1,1,0,0}; tableDeCoefficients[4-1][4]=coeff4_4;
        int[] rythme4_5 = {1,1,1,1,0,0,0,0,0,0,0,0}; tableDeRythmes[4-1][5]=rythme4_5;
        int[] coeff4_5 ={1,1,1,1,1,1,0}; tableDeCoefficients[4-1][5]=coeff4_5;
       
        int[] rythme5_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[5-1][0]=rythme5_0;
        int[] coeff5_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[5-1][0]=coeff5_0;
        int[] rythme5_1 = {1,0,0,0,1,0,0,0,0,0,0,0}; tableDeRythmes[5-1][1]=rythme5_1;
        int[] coeff5_1 ={1,1,1,1,0,1,0}; tableDeCoefficients[5-1][1]=coeff5_1;
        int[] rythme5_2 = {1,0,0,1,1,0,0,0,0,0,0,0}; tableDeRythmes[5-1][2]=rythme5_2;
        int[] coeff5_2 ={1,1,1,1,1,0,0}; tableDeCoefficients[5-1][2]=coeff5_2;
        int[] rythme5_3 = {1,0,1,1,1,0,0,0,0,0,0,0}; tableDeRythmes[5-1][3]=rythme5_3;
        int[] coeff5_3 ={0,1,0,1,1,1,0}; tableDeCoefficients[5-1][3]=coeff5_3;
        int[] rythme5_4 = {1,1,1,1,1,0,0,0,0,0,0,0}; tableDeRythmes[5-1][4]=rythme5_4;
        int[] coeff5_5 ={0,0,1,1,1,1,0}; tableDeCoefficients[5-1][5]=coeff5_5;
       
        int[] rythme6_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[6-1][0]=rythme6_0;
        int[] coeff6_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[6-1][0]=coeff6_0;
        int[] rythme6_1 = {1,0,0,1,0,0,0,0,0,0,0,0}; tableDeRythmes[6-1][1]=rythme6_1;
        int[] coeff6_1 ={1,1,1,1,1,1,1}; tableDeCoefficients[6-1][1]=coeff6_1;
        int[] rythme6_2 = {1,0,0,0,0,1,0,0,0,0,0,0}; tableDeRythmes[6-1][2]=rythme6_2;
        int[] coeff6_2 ={1,1,0,1,0,1,1}; tableDeCoefficients[6-1][2]=coeff6_2;
        int[] rythme6_3 = {1,0,1,0,1,0,0,0,0,0,0,0}; tableDeRythmes[6-1][3]=rythme6_3;
        int[] coeff6_3 ={1,1,1,1,1,1,1}; tableDeCoefficients[6-1][3]=coeff6_3;
        int[] rythme6_4 = {1,0,0,1,1,1,0,0,0,0,0,0}; tableDeRythmes[6-1][4]=rythme6_4;
        int[] coeff6_4 ={0,1,0,1,1,1,0}; tableDeCoefficients[6-1][4]=coeff6_4;
        int[] rythme6_5 = {1,1,1,1,1,1,0,0,0,0,0,0}; tableDeRythmes[6-1][5]=rythme6_5;
        int[] coeff6_5 ={0,0,1,1,1,1,0}; tableDeCoefficients[6-1][5]=coeff6_5;
       
        int[] rythme7_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[7-1][0]=rythme7_0;
        int[] coeff7_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[7-1][0]=coeff7_0;
        int[] rythme7_1 = {1,0,0,0,0,1,0,0,0,0,0,0}; tableDeRythmes[7-1][1]=rythme7_1;
        int[] coeff7_1 ={0,1,0,1,0,1,1}; tableDeCoefficients[7-1][1]=coeff7_1;
        int[] rythme7_2 = {1,0,0,0,1,0,0,0,0,0,0,0}; tableDeRythmes[7-1][2]=rythme7_2;
        int[] coeff7_2 ={1,1,1,1,1,1,1}; tableDeCoefficients[7-1][2]=coeff7_2;
               
        int[] rythme8_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[8-1][0]=rythme8_0;
        int[] coeff8_0 ={2,2,2,2,6,2,2}; tableDeCoefficients[8-1][0]=coeff8_0;
        int[] rythme8_1 = {1,0,0,0,1,0,0,0,0,0,0,0}; tableDeRythmes[8-1][1]=rythme8_1;
        int[] coeff8_1 ={2,1,2,1,2,1,1}; tableDeCoefficients[8-1][1]=coeff8_1;
        int[] rythme8_2 = {1,0,0,0,0,0,0,1,0,0,0,0}; tableDeRythmes[8-1][2]=rythme8_2;
        int[] coeff8_2 ={1,2,1,2,1,2,0}; tableDeCoefficients[8-1][2]=coeff8_2;
        int[] rythme8_3 = {1,0,0,0,1,0,1,0,0,0,0,0}; tableDeRythmes[8-1][3]=rythme8_3;
        int[] coeff8_3 ={2,1,2,1,2,1,2}; tableDeCoefficients[8-1][3]=coeff8_3;
        int[] rythme8_4 = {1,0,0,0,0,0,1,1,0,0,0,0}; tableDeRythmes[8-1][4]=rythme8_4;
        int[] coeff8_4 ={1,1,1,1,1,1,0}; tableDeCoefficients[8-1][4]=coeff8_4;
        int[] rythme8_5 = {1,0,0,0,1,0,1,1,0,0,0,0}; tableDeRythmes[8-1][5]=rythme8_5;
        int[] coeff8_5 ={1,0,2,0,1,0,1}; tableDeCoefficients[8-1][5]=coeff8_5;
        int[] rythme8_6 = {1,0,1,0,1,0,1,0,0,0,0,0}; tableDeRythmes[8-1][6]=rythme8_6;
        int[] coeff8_6 ={1,0,1,0,2,0,1}; tableDeCoefficients[8-1][6]=coeff8_6;
        int[] rythme8_7 = {1,0,1,0,1,0,1,1,0,0,0,0}; tableDeRythmes[8-1][7]=rythme8_7;
        int[] coeff8_7 ={0,0,1,0,1,0,1}; tableDeCoefficients[8-1][7]=coeff8_7;
        int[] rythme8_8 = {1,0,1,1,1,0,1,1,0,0,0,0}; tableDeRythmes[8-1][8]=rythme8_8;
        int[] coeff8_8 ={1,2,1,2,2,1,0}; tableDeCoefficients[8-1][8]=coeff8_8;
        int[] rythme8_9 = {1,1,1,1,1,1,1,1,0,0,0,0}; tableDeRythmes[8-1][9]=rythme8_9;
        int[] coeff8_9 ={0,0,1,0,1,1,0}; tableDeCoefficients[8-1][9]=coeff8_9;
       
        int[] rythme9_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[9-1][0]=rythme9_0;
        int[] coeff9_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[9-1][0]=coeff9_0;
        int[] rythme9_1 = {1,0,0,0,0,0,1,0,0,0,0,0}; tableDeRythmes[9-1][1]=rythme9_1;
        int[] coeff9_1 ={1,2,1,2,1,2,1}; tableDeCoefficients[9-1][1]=coeff9_1;
        int[] rythme9_2 = {1,0,0,0,0,0,0,0,1,0,0,0}; tableDeRythmes[9-1][2]=rythme9_2;
        int[] coeff9_2 ={1,2,0,2,0,1,0}; tableDeCoefficients[9-1][2]=coeff9_2;
        int[] rythme9_3 = {1,0,0,1,0,0,1,0,0,0,0,0}; tableDeRythmes[9-1][3]=rythme9_3;
        int[] coeff9_3 ={0,2,0,1,2,1,0}; tableDeCoefficients[9-1][3]=coeff9_3;
        int[] rythme9_4 = {1,0,0,0,0,0,1,1,1,0,0,0}; tableDeRythmes[9-1][4]=rythme9_4;
        int[] coeff9_4 ={0,2,0,2,0,2,0}; tableDeCoefficients[9-1][4]=coeff9_4;
        int[] rythme9_5 = {1,0,0,1,0,0,1,1,1,0,0,0}; tableDeRythmes[9-1][5]=rythme9_5;
        int[] coeff9_5 ={0,1,0,1,1,2,0}; tableDeCoefficients[9-1][5]=coeff9_5;
        int[] rythme9_6 = {1,0,1,1,0,1,1,0,1,0,0,0}; tableDeRythmes[9-1][6]=rythme9_6;
        int[] coeff9_6 ={1,2,2,1,2,2,1}; tableDeCoefficients[9-1][6]=coeff9_6;
       
        int[] rythme10_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[10-1][0]=rythme10_0;
        int[] coeff10_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[10-1][0]=coeff10_0;
        int[] rythme10_1 = {1,0,0,0,0,0,0,0,1,0,0,0}; tableDeRythmes[10-1][1]=rythme10_1;
        int[] coeff10_1 ={0,1,0,1,0,1,0}; tableDeCoefficients[10-1][1]=coeff10_1;
        int[] rythme10_2 = {1,0,0,0,0,0,0,1,0,0,0,0}; tableDeRythmes[10-1][2]=rythme10_2;
        int[] coeff10_2 ={1,2,1,2,1,2,2}; tableDeCoefficients[10-1][2]=coeff10_2;
        int[] rythme10_3 = {1,0,0,0,0,0,1,0,1,0,0,0}; tableDeRythmes[10-1][3]=rythme10_3;
        int[] coeff10_3 ={1,0,2,0,2,1,1}; tableDeCoefficients[10-1][3]=coeff10_3;
        int[] rythme10_4 = {1,0,0,0,0,0,0,0,1,1,0,0}; tableDeRythmes[10-1][4]=rythme10_4;
        int[] coeff10_4 ={1,1,1,1,1,1,0}; tableDeCoefficients[10-1][4]=coeff10_4;
        int[] rythme10_5 = {1,0,0,0,0,0,0,1,1,1,0,0}; tableDeRythmes[10-1][5]=rythme10_5;
        int[] coeff10_5 ={2,1,2,1,1,2,0}; tableDeCoefficients[10-1][5]=coeff10_5;
       
        int[] rythme11_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[11-1][0]=rythme11_0;
        int[] coeff11_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[11-1][0]=coeff11_0;
        int[] rythme11_1 = {1,0,0,0,0,0,0,0,0,0,1,0}; tableDeRythmes[11-1][1]=rythme11_1;
        int[] coeff11_1 ={0,1,0,1,0,1,0}; tableDeCoefficients[11-1][1]=coeff11_1;
        int[] rythme11_2 = {1,0,0,0,0,0,0,0,0,1,0,0}; tableDeRythmes[11-1][2]=rythme11_2;
        int[] coeff11_2 ={1,0,1,0,2,1,1}; tableDeCoefficients[11-1][2]=coeff11_2;
       
        int[] rythme12_0 = {1,0,0,0,0,0,0,0,0,0,0,0}; tableDeRythmes[12-1][0]=rythme12_0;
        int[] coeff12_0 ={1,1,1,1,1,1,1}; tableDeCoefficients[12-1][0]=coeff12_0;
        int[] rythme12_1 = {1,0,0,0,0,0,0,0,0,0,1,0}; tableDeRythmes[12-1][1]=rythme12_1;
        int[] coeff12_1 ={1,0,1,0,2,1,1}; tableDeCoefficients[12-1][1]=coeff12_1;
        int[] rythme12_2 = {1,0,0,0,0,0,0,0,0,1,0,0}; tableDeRythmes[12-1][2]=rythme12_2;
        int[] coeff12_2 ={0,1,0,2,1,1,1}; tableDeCoefficients[12-1][2]=coeff12_2;
        int[] rythme12_3 = {1,0,0,0,0,0,0,0,1,0,1,0}; tableDeRythmes[12-1][3]=rythme12_3;
        int[] coeff12_3 ={1,0,1,0,2,0,1}; tableDeCoefficients[12-1][3]=coeff12_3;
        int[] rythme12_4 = {1,0,0,0,0,0,1,0,0,0,1,1}; tableDeRythmes[12-1][4]=rythme12_4;
        int[] coeff12_4 ={0,1,0,1,1,1,0}; tableDeCoefficients[12-1][4]=coeff12_4;
        int[] rythme12_5 = {1,0,0,0,0,0,1,0,0,1,0,0}; tableDeRythmes[12-1][5]=rythme12_5;
        int[] coeff12_5 ={0,1,0,1,2,2,1}; tableDeCoefficients[12-1][5]=coeff12_5;
        int[] rythme12_6 = {1,0,0,1,0,0,1,0,0,1,0,0}; tableDeRythmes[12-1][6]=rythme12_6;
        int[] coeff12_6 ={0,1,0,1,2,1,1}; tableDeCoefficients[12-1][6]=coeff12_6;
        int[] rythme12_7 = {1,0,0,0,0,0,1,0,1,0,1,0}; tableDeRythmes[12-1][7]=rythme12_7;
        int[] coeff12_7 ={1,0,1,0,2,1,1}; tableDeCoefficients[12-1][7]=coeff12_7;
        int[] rythme12_8 = {1,0,0,0,1,0,1,0,1,0,1,0}; tableDeRythmes[12-1][8]=rythme12_8;
        int[] coeff12_8 ={1,0,1,0,1,0,0}; tableDeCoefficients[12-1][8]=coeff12_8;
        int[] rythme12_9 = {1,0,1,0,1,0,1,0,1,0,1,0}; tableDeRythmes[12-1][9]=rythme12_9;
        int[] coeff12_9 ={1,0,1,0,1,0,1}; tableDeCoefficients[12-1][0]=coeff12_9;
       
        int[][] tableSommeCoefficientsFormat = new int[12][10];
        int[][] tableSommeCoefficientsHumeur = new int[12][10];
        double[][] tableSommeCoefficientsTotal = new double[12][10];
        double[][] tableSommeCoefficientsTauxRemplissage = new double[12][10];
        int[][] tableSommeCoefficientsProfondeur = new int[12][10];
       
        for(int tailleDuRythme=1;tailleDuRythme<12;tailleDuRythme++){
            for (int numero=0;numero<=9;numero++){
                tableSommeCoefficientsFormat[sizeDuRythme][numero] =0;
                tableSommeCoefficientsHumeur[sizeDuRythme][numero] =0;
                tableSommeCoefficientsTotal[sizeDuRythme][numero] =0;
                tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero]=0;
               
               
                // est-ce que le rythme est trop rempli par rapport à l'écrasement fixé ?
                for (int i=0;i<12;i++){
                    tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero]=tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero]+tableDeRythmes[sizeDuRythme][numero][i];
                }
                tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero]=((double) tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero])/((double) tailleDuRythme);
                if (tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero]>ecrasement*ecrasement*ecrasement){
                    tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero] = 0;
                }
                else{
                    tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero] = 1;
                }
               
                // est-ce que le rythme possède des notes trop courtes par rapport à la taille limite ?
                boolean profondeurPasRespectee=false;
                int sautDeFormat=1;
                if ((format ==2) || (format ==4)){
                    sautDeFormat=2;
                }
                if ((format ==3) || (format ==6)){
                    sautDeFormat=3;
                }
                for (int i=1; i<12;i=i+sautDeFormat){
                    if (tableDeRythmes[sizeDuRythme][numero][i]==1){
                        profondeurPasRespectee=true;
                    }
                }
                if ((profondeurPasRespectee)&&(profondeurMaximale>=6)){
                    tableSommeCoefficientsProfondeur[sizeDuRythme][numero]=0;
                }
                else{
                    tableSommeCoefficientsProfondeur[sizeDuRythme][numero]=1;
                }
               
                // est-ce que le rythme correspond au format fixé ?
                if (format ==2){
                    tableSommeCoefficientsFormat[sizeDuRythme][numero] = tableSommeCoefficientsFormat[sizeDuRythme][numero]+tableDeCoefficients[sizeDuRythme][numero][0];
                }
                if (format ==3){
                    tableSommeCoefficientsFormat[sizeDuRythme][numero] = tableSommeCoefficientsFormat[sizeDuRythme][numero]+tableDeCoefficients[sizeDuRythme][numero][1];
                }
                if (format ==4){
                    tableSommeCoefficientsFormat[sizeDuRythme][numero] = tableSommeCoefficientsFormat[sizeDuRythme][numero]+tableDeCoefficients[sizeDuRythme][numero][2];
                }
                if (format ==6){
                    tableSommeCoefficientsFormat[sizeDuRythme][numero] = tableSommeCoefficientsFormat[sizeDuRythme][numero]+tableDeCoefficients[sizeDuRythme][numero][3];
                }
               
                // est-ce que le rythme correspond à l'humeur voulue ?
               
                if (humeur ==1){
                    tableSommeCoefficientsHumeur[sizeDuRythme][numero] = tableSommeCoefficientsFormat[sizeDuRythme][numero]+tableDeCoefficients[sizeDuRythme][numero][4];
                }
                if (humeur ==2){
                    tableSommeCoefficientsHumeur[sizeDuRythme][numero] = tableSommeCoefficientsFormat[sizeDuRythme][numero]+tableDeCoefficients[sizeDuRythme][numero][5];
                }
                if (humeur ==3){
                    tableSommeCoefficientsHumeur[sizeDuRythme][numero] = tableSommeCoefficientsFormat[sizeDuRythme][numero]+tableDeCoefficients[sizeDuRythme][numero][6];
                }
               
                tableSommeCoefficientsTotal[sizeDuRythme][numero] = tableSommeCoefficientsHumeur[sizeDuRythme][numero]*tableSommeCoefficientsFormat[sizeDuRythme][numero]*tableSommeCoefficientsProfondeur[sizeDuRythme][numero]*tableSommeCoefficientsTauxRemplissage[sizeDuRythme][numero];
            }
        }
       
        int[] premiereListeDeNumerosDeRythmes = new int[12];
        int[] deuxiemeListeDeNumerosDeRythmes = new int[12];
        for(int i=0;i<12;i++){
            premiereListeDeNumerosDeRythmes[i]=resultatTableauProba(tableSommeCoefficientsTotal[i],10);
        }
        for(int i=0;i<12;i++){
            deuxiemeListeDeNumerosDeRythmes[i]=resultatTableauProba(tableSommeCoefficientsTotal[i],10);
        }

        int[][] premiereListeDeRythmes = new int[12][12];
        int[][] deuxiemeListeDeRythmes = new int[12][12];
        for(int i=0;i<12;i++){
            premiereListeDeRythmes[i]=tableDeRythmes[i][premiereListeDeNumerosDeRythmes[i]];
        }
        for(int i=0;i<12;i++){
            deuxiemeListeDeRythmes[i]=tableDeRythmes[i][deuxiemeListeDeNumerosDeRythmes[i]];
        }
        // on a à présent pour chaque taille deux rythmes utilisables
       
        int[][][] tableauQuiProposeDeuxRythmesPourChaqueTaille = new int[12][2][12];
        for (int taille =0; taille<12;taille++){
            for (int numero1ou2 = 0; numero1ou2<=1;numero1ou2++){
                for (int i=0 ; i<12;i++){
                    if (numero1ou2==0){
                        tableauQuiProposeDeuxRythmesPourChaqueTaille[size][numero1ou2][i]=premiereListeDeRythmes[size][i];
                    }
                    else{
                        tableauQuiProposeDeuxRythmesPourChaqueTaille[size][numero1ou2][i]=deuxiemeListeDeRythmes[size][i];
                    }
                   
                }
            }
        }
        return tableauQuiProposeDeuxRythmesPourChaqueTaille;
    }
   
    public static int[] broderRythme(int[] mesureRythme, int format, int tailleMelodie, int[][][] tableauDeChoixDeRythmes){
        // mettre les rythmes du tableau de choix dans les trous
       
        return null;
       
        int[] emplacementDesNotes = new int[sizeMelodie*format*36];
        int nombreDeNotesRencontrees=0;
        for (int i=0; i<tailleMelodie*format*36; i++){
            if (mesureRythme[i]==12){
                emplacementDesNotes[nombreDeNotesRencontrees]=i;
                nombreDeNotesRencontrees=nombreDeNotesRencontrees+1;
            }
        }
        // on sait à présent combien de notes on a rencontré, et dans le tableau c'est écrit où elles se trouvent
        caca
        // on doit pourtant transformer ce tableau pour ne pas que les mélodies exigés soient supérieurs à 12
        // en format 6, il y a 54 trous à remplir, donc à couper en 6 temps de 9 trous
        // en format 4, il y a 16 trous à remplir, donc à couper en 4 temps de 4 trous ou 2 blanches de 8 trous
        // en fait on va retrancher à un trou trop gros le plus gros rythmes de la liste et ainsi de suite
        emplacementDesNotes[nombreDeNotesRencontrees]=tailleMelodie*format*36-1;
        int tailleZoneCreuse = 0;
        int numero1ou2=0;
        for (int i=0;i<nombreDeNotesRencontrees;i++){ //tronçons à remplir par des Rythmes
            tailleZoneCreuse = emplacementDesNotes[i+1]-emplacementDesNotes[i];
            for (int j=0;j<tailleZoneCreuse;j++){
                //attention, j peut dépasser 12 => segmenter les creux intelligemment
                numero1ou2= (int)(Math.random()*2);
                mesureRythme[emplacementDesNotes[i]+j]=tableauDeChoixDeRythmes[sizeZoneCreuse][numero1ou2][j];
            }
        }
       
        caca
       
       
        return mesureRythme;
    }
   
    public static int[] regulariserRythme(int[] mesureRythme, int format, int tailleMelodie){
        int[] mesure = new int[sizeMelodie*format*36];
        for (int i=0 ; i<tailleMelodie*format*36; i++){
            if (mesureRythme[i]>=6/tailleMelodie){
                mesure[i]=12;
            }
            else{
                mesure[i]=13;
            }
        }
       
        return mesure;
    }
   
    public static void playPartitionRythme(int[][] base, int tempo, int format){
        for (int i = 0 ; i < 4*format*36 ; i++){
            if (base[i][0]!=13){
                jouerNote(base[i][0]);
            }
           
            wait((int) ((250.0 * 120.0) /(tempo*36.0)));
           
        }
    }
   
    public static void afficherPartition(int[][] partition, int format){
        int a;
        for (int j = 0 ; j < 8 ; j++){
           
            if (format%3!=0){
                for (int i=0 ; i < 4*format*36 ; i++){
                    if (i == (4*format*36)-1){
                            System.out.println("||");
                    }
                    else{
                        if (i % 9 == 0){
                            if (i % (format*36) == 0){
                                System.out.print("|");
                            }

                            if(partition[i][j]==13) { //vide
                                System.out.print("  ");
                            }
                            else {
                                a = partition[i][j];
                                if (a < 10){
                                    System.out.print(a+" ");
                                }
                                else{
                                    System.out.print(a);
                                }
                            }
                        }
                    }
                       
                }
            }
            else{
                for (int i=0 ; i < 4*format*36 ; i++){
                    if (i == (4*format*36)-1){
                        System.out.println("||");
                    }
                   
                    if (i % 4 == 0){
                        if (i % (format*36) ==0){
                            System.out.print("|");
                        }
                        if(partition[i][j]==13) { //vide
                            System.out.print("  ");
                        }
                        else {
                            a = partition[i][j];
                            if (a < 10){
                                System.out.print(a+" ");
                            }
                            else{
                                System.out.print(a);
                            }
                           
                        }
                    }
   
                }
            }           
        }
    }
   
    public static int[][] choisirBaseHarmonique(int format, int humeur, double ecrasement, int profondeurMaximale, int gamme){
        int[][] base = partitionVide(format);
        base = rythmerBase(base,humeur,format,ecrasement, profondeurMaximale);
        base = remplirBase(base,humeur,format, gamme, ecrasement, profondeurMaximale);
        return base;
    }
   
    public static int[][] partitionVide(int format){
        int[][] base = new int[4*format*36][8];
        for(int i = 0 ; i<4*format*36 ; i++){
            for (int j = 0 ; j<8 ; j++){
                base[i][j] = 13;
            }
        }
        return base;
    }
   
    public static int[][] rythmerBase(int[][] base, int humeur, int format, double ecrasement, int profondeurMaximale){
        return inventerRythmeMesure(humeur, format, ecrasement, profondeurMaximale);
    }
   
   
    public static int[][] inventerRythmeMesure(int humeur, int format, double ecrasement, int profondeurMaximale){
        int[][] mesureRythme = new int[4*format*36][8];
        mesureRythme = partitionVide(format);
        if (format == 4){ //rigoureuse
            for (int i =0 ; i < 4*format*36 ; i=i+9){
                mesureRythme[i][0] = remplirMesure(i,humeur, format, ecrasement,profondeurMaximale);
            }
        }
        if (format == 6){ //fluide
            for (int i =0 ; i < 4*format*36 ; i=i+4){
                mesureRythme[i][0] = remplirMesure(i,humeur, format, ecrasement,profondeurMaximale);
            }
        }
        if (format == 2){ //naine
            for (int i =0 ; i < 4*format*36 ; i=i+9){
                mesureRythme[i][0] = remplirMesure(i,humeur, format, ecrasement,profondeurMaximale);
            }
        }
        if (format == 3){ //valse
            for (int i =0 ; i < 4*format*36 ; i=i+4){
                mesureRythme[i][0] = remplirMesure(i,humeur, format, ecrasement,profondeurMaximale);
            }
        }
       
        return mesureRythme;
    }
   
    public static int remplirMesure(int i, int humeur, int format, double ecrasement,int profondeurMaximale){
       
        if (resultatProbabilite(probabilitePresenceNote(i,humeur,format,ecrasement,profondeurMaximale))){
            return 12; // 12 vaut une note inconnue
        }
        else{
            return 13; // 13 vaut le vide
        }
       
        /* return (int) (10* probabilitePresenceNote(i,humeur,format,ecrasement,profondeurMaximale)   ); */
       
    }
   
    public static double probabilitePresenceNote(int i, int humeur, int format, double ecrasement, int profondeurMaximale){
        double temp = puissance( importancePosition(i,format,0,ecrasement,profondeurMaximale) , exposantHumeur(humeur) );
        if ((temp < ecrasement ) && (temp > 2*(1-ecrasement))){
            temp = temp + coefficientFin(i, format, ecrasement);
        }
       
        if ((temp >= 1.0)|| i % (format*36) == 0){
            temp = 1.0;
        }
             
        /* temp = racineCarree(temp); */
        temp = temp*temp;
       
        return  temp ;
    }
   
    public static double racineCarree(double x){
        return 2 * (1 - 1/(1+x));
    }
   
    public static double coefficientFin(int i, int format, double ecrasement){
        double placeDansLaMesure = i % (36*format);
        double coeffDeRapprochementDeFinDeMesure =  placeDansLaMesure/(36*format);
       
        double placeDansLaDoubleMesure = i % (2*36*format);
        double coeffDeRapprochementDeFinDeDoubleMesure = placeDansLaDoubleMesure/(2*36*format);
       
        double placeDansLaQuadrupleMesure = i % (4*36*format);
        double coeffDeRapprochementDeFinDeQuadrupleMesure = placeDansLaQuadrupleMesure/(4*36*format);
               
        return coeffDeRapprochementDeFinDeMesure*(coeffDeRapprochementDeFinDeMesure*coeffDeRapprochementDeFinDeDoubleMesure*coeffDeRapprochementDeFinDeQuadrupleMesure+coeffDeRapprochementDeFinDeDoubleMesure*coeffDeRapprochementDeFinDeQuadrupleMesure+coeffDeRapprochementDeFinDeQuadrupleMesure)*ecrasement*ecrasement;
    }
   
    public static double puissance(double x, int n){
        double puissance = 1;
        for(int i=0 ; i<n ; i++){
            puissance = puissance * x;
        }
        return puissance;
    }
   
    public static double importancePosition(int i,int format, int profondeur, double ecrasement, int profondeurMaximale){
       
        if (profondeur >= profondeurMaximale){
            return 0.2*ecrasement;
        }
        if (((int) (i % ((4*format*36)/puissance(2,profondeur+1)))) == 0){
            return 1;
        }
       
        if ((profondeur >= 2) && (format % 3 ==0)){
            return ecrasement*importancePosition( (int) (i % ((format*36)/puissance(3,profondeur-1))), format, profondeur+1, ecrasement, profondeurMaximale);
        }
        else{
            return ecrasement*importancePosition( (int) (i % ((4*format*36)/puissance(2,profondeur+1))), format, profondeur+1, ecrasement, profondeurMaximale);
        }
       
        /*
        if (((format == 4)||(format == 2))||(profondeur<3)){
            if (i % (4*format*36/ puissance(2,profondeur) ) == 0){
                return 1.0;
            }
            return ecrasement * importancePosition( (int) (i % (4*format*36 / puissance(2,profondeur))), format, profondeur+1,ecrasement,profondeurMaximale);

        }
        else{
            if (i % (4*format*36/ puissance(3,profondeur) ) == 0){
                return 1.0;
            }
            return ecrasement * importancePosition( (int) (i % (4*format*36 / (4*puissance(3,profondeur-2)))), format, profondeur+1,ecrasement,profondeurMaximale);
        } */
       
    }
   
    public static int exposantHumeur(int humeur){
        int resultat =0;
        if (humeur == 1){
            resultat = (int) (Math.random()*2+1);
        }
        if (humeur == 2){
            resultat = (int) (Math.random()*3+1);
        }
        if (humeur == 3){
            resultat = (int) (Math.random()*3+1);
        }
        return resultat;
    }
   
    public static boolean resultatProbabilite(double probabilite){
        if ( (Math.random()*1000) <= probabilite*1000){
            return true;
        }
        else{
            return false;
        } 
    }
   
    public static int[][] remplirBase(int[][] base, int humeur, int format, int gamme, double ecrasement, int profondeurMaximale){
        int[][] lol = partitionVide(format);
       
        if(base[0][0]==12){
            lol[0][0] = gamme;
        }
       
        int precedent = base[0][0];
        for(int i=1; i<4*format*36;i++){
            if (base[i][0] != 13){// si non vide
                precedent=inventerSuite(precedent, humeur, gamme, importancePosition(i, format, 0,ecrasement, profondeurMaximale),ecrasement );
                lol[i][0]=precedent;
            }
           
        }
        return lol;
    }
   
    public static int inventerSuite(int precedent, int humeur, int gamme, double importancePosition, double ecrasement){
        double[] tableauDeProbabilites = new double[12];
       
        for(int noteEssai=0;noteEssai<12;noteEssai++){
            tableauDeProbabilites[noteEssai] = passage(precedent, noteEssai, humeur,gamme,importancePosition,ecrasement)*passage(precedent, noteEssai, humeur, gamme,importancePosition,ecrasement)*presence(noteEssai, gamme, humeur);
        }
       
        return resultatTableauProba(tableauDeProbabilites,12);
    }
   
    public static int resultatTableauProba(double[] tableau,int tailleTableau){
        int resultat = 0;
        double sommeTotale = 0;
        for(int i = 0 ; i<tailleTableau ; i++){
            sommeTotale = sommeTotale + tableau[i];
        }
        double discriminant = (Math.random()*sommeTotale);
        double sommePartielle=tableau[0];
        boolean trouve = false;
        int idRecherche=0;
        while( ! trouve){
            if (discriminant <= sommePartielle){
                resultat = idRecherche;
                trouve = true;
            }
            else{
                idRecherche++;
                idRecherche = idRecherche % 24;
                sommePartielle = sommePartielle + tableau[idRecherche];
            }
        }
       
        return resultat;
    }
   
   
    public static int passage(int note1, int note2, int humeur, int gamme, double importancePosition, double ecrasement){
        int copieNote1=note1;
        int copieNote2=note2;
       
        //              en haut les notes de sortie
       
        //              lasibsidod#rembmifaf#soso#
        int[] ligne0 =  {2,0,2,1,2,3,0,4,3,1,2,0}; //la
        int[] ligne1 =  {1,0,0,1,1,2,1,0,1,0,2,0}; //sib
        int[] ligne2 =  {4,0,3,2,3,3,0,2,0,2,0,3}; //si
        int[] ligne3 =  {3,0,1,3,0,3,0,3,4,0,4,1}; //do
        int[] ligne4 =  {3,1,3,0,3,0,1,4,1,2,0,2}; //do#
        int[] ligne5 =  {4,2,1,3,0,3,0,2,2,0,2,0}; //re          de ce côté les notes d'entrée
        int[] ligne6 =  {0,2,3,1,2,0,2,1,2,1,2,0}; //mib
        int[] ligne7 =  {1,0,3,1,3,2,0,3,1,1,2,0}; //mi
        int[] ligne8 =  {3,3,0,3,2,3,1,1,3,0,2,1}; //fa
        int[] ligne9 =  {3,1,3,0,2,2,0,4,1,2,2,4}; //fa#
        int[] ligne10 = {4,1,3,3,0,2,0,4,3,0,3,1}; //sol
        int[] ligne11 = {9,1,2,2,2,0,1,2,2,1,0,2}; //sol#
       
        if (humeur>=2){
            ligne0[3]=2; ligne0[4]=0;
            ligne1[3]=1; ligne1[4]=0;
            ligne2[3]=3; ligne2[4]=0;
            ligne6[3]=2; ligne6[4]=1;
            ligne7[3]=3; ligne7[4]=1;
           
            ligne0[11]=2; ligne0[10]=0;
            ligne1[11]=2; ligne4[10]=0;
            ligne2[11]=3; ligne2[10]=0;
            ligne6[11]=2; ligne6[10]=0;
            ligne7[11]=3; ligne7[10]=0;
        }
       
        if (humeur<3){
            ligne5[8]=1; ligne5[9]=3;
            ligne8[10]=1;
        }
       
        if((humeur<3)&&(((note1 - note2) %12 == 4)||((note1 - note2) %12 == -8))){ //de ré vers sib  bof pas terrible
            return 1;
        }
       
        if((humeur<3)&&(((note1 - note2) %12 == 6)||((note1 - note2) %12 == -6))){ //de ré vers sib  bof pas terrible
            return 0;
        }
       
        int[][] tableDePassage = {ligne0,ligne1,ligne2,ligne3,ligne4,ligne5,ligne6,ligne7,ligne8,ligne9,ligne10,ligne11};
       
        if ((note1==note2)&&(importancePosition>=ecrasement*ecrasement)){
            return 0;
        }
        if ((note1==note2)&&(importancePosition>=ecrasement*ecrasement*ecrasement)){
            return 1;
        }
               
        copieNote1 = note1-gamme;
        while(copieNote1 < 0){
            copieNote1 = copieNote1 + 12;
        }
        while (copieNote1 >= 12){
            copieNote1 = copieNote1 - 12;
        }
       
        copieNote2 = note2-gamme;
        while(copieNote2 < 0){
            copieNote2 = copieNote2 + 12;
        }
        while (copieNote2 >= 12){
            copieNote2 = copieNote2 - 12;
        }
       
        return tableDePassage[copieNote1][copieNote2];
    }
   
    public static int consonnance(int note1, int note2, int humeur){
        int[] tableDeConsonnance = {4,0,1,3,3,4,0,4,3,3,1,0};
       
        int ecart = note1-note2;
        while(ecart < 0){
            ecart = ecart+12;
        }
        while (ecart >= 12){
            ecart = ecart - 12;
        }
               
        return tableDeConsonnance[ecart];
    }
   
    public static int presence(int note, int gamme, int humeur){
        int[] tableDePresence = {4,0,2,3,2,3,0,4,3,1,3,1};
        if (humeur == 3){
            tableDePresence[1]=1;
            tableDePresence[3]=3;
            tableDePresence[4]=1;
            tableDePresence[10]=2;
            tableDePresence[11]=2;
        }
        if (humeur == 2){
            tableDePresence[1]=0;
            tableDePresence[3]=2;
            tableDePresence[4]=3;
            tableDePresence[10]=4;
            tableDePresence[11]=0;
        }
        int ecart = note - gamme;
        while(ecart<0){
            ecart = ecart + 12;
        }
        while(ecart>=12){
            ecart = ecart - 12;
        }
        return tableDePresence[ecart];
    }
   
    public static int choisirTailleMelodie(int format, int vitesse, int humeur){
        int taille=1;
        double probabiliteMelodieCourte;
       
        if (format <=3){
            probabiliteMelodieCourte = 0.4;
        }
        else{
            probabiliteMelodieCourte = 0.6;
        }
       
        if (vitesse ==1){ //si c'est lent, mélodie courte pas génante
            probabiliteMelodieCourte = probabiliteMelodieCourte+0.2;
        }
        if (vitesse ==2){ //si c'est rapide, mélodie courte génante
            probabiliteMelodieCourte = probabiliteMelodieCourte-0.2;
        }
       
        if (humeur ==1){ //si élégiaque, mélodie courte pas génante
            probabiliteMelodieCourte = probabiliteMelodieCourte+0.1;
        }
        if (humeur ==2){ //si melancolique, mélodie longue préférable
            probabiliteMelodieCourte = probabiliteMelodieCourte-0.1;
        }
       
        if (resultatProbabilite(probabiliteMelodieCourte)){
            taille=1;
        }
        else{
            taille=2;
        }
       
        return taille;
    }
   
   
    public static void main(String[] args) {
        int tempo, vitesse, format, humeur;
        double ecrasement;
        int gammeInitiale = (int) (Math.random()*12);
        int tailleMelodie;
       
        vitesse = choisirVitesseInitiale();
        tempo = choisirTempoInitial(vitesse); // on le rendra plus tard égal à la moyenne de lui-même et d'un nouveau tempo aléatoire de son groupe de vitesse
        humeur = choisirHumeurInitiale(); // 1 == melancolique ; 2 == elegiaque ; 3 == instable ;
        System.out.println("humeur : "+humeur);
        System.out.println("gamme : "+gammeInitiale);
        format = choisirFormat(vitesse,humeur); // nombre de temps par mesure
        tailleMelodie = choisirTailleMelodie(format,vitesse,humeur);
        ecrasement = (Math.random()*20+60)/100;
        int profondeurMaximale = (int) (Math.random()*4+3);
        /* importancePosition(int i,int format, int profondeur, double ecrasement, int profondeurMaximale) */
        if (format ==2){ //la base harmonique est trop remplie sinon
            ecrasement = ecrasement*ecrasement;
        }
       
        jouerPremierePartition(tempo,format,humeur,ecrasement,profondeurMaximale,gammeInitiale,tailleMelodie);
       
       
    }
   


Dès que j'ai fini je crée un bot intelligent qui discute par l'apprentissage, joue aux échecs, et résout des équations, pour mettre trotter au chômage.
Revenir en haut
Visiter le site web du posteur
Roi of the Suisse
Vétéran


Inscrit le: 27 Juil 2011
Messages: 8 140

MessagePosté le: Dim 25 Nov - 01:25 (2012)    Sujet du message: Créations diverses Répondre en citant

Des exemples :

http://www.rpg-maker.fr/index.php?page=forum&id=17774&deb=71&an…
Revenir en haut
Visiter le site web du posteur
trotter
Vétéran


Inscrit le: 26 Juil 2011
Messages: 6 872

MessagePosté le: Dim 25 Nov - 03:30 (2012)    Sujet du message: Créations diverses Répondre en citant

Mort de rire ton code, bien joué.
Tu peux pas lui faire générer du midi plutôt ? C'est sûr qu'en lisant un wav tu te casses moins les couilles mais tu vas vite être limité.
Tu devrais peut être t'y mettre tant que ton code est pas trop avancé.
Revenir en haut
trotter
Vétéran


Inscrit le: 26 Juil 2011
Messages: 6 872

MessagePosté le: Dim 25 Nov - 03:52 (2012)    Sujet du message: Créations diverses Répondre en citant

http://faydoc.tripod.com/formats/mid.htm
http://www.sonicspot.com/guide/midifiles.html
http://sander.vanzoest.com/talks/2002/audio_and_apache/midispec.html
Revenir en haut
Roi of the Suisse
Vétéran


Inscrit le: 27 Juil 2011
Messages: 8 140

MessagePosté le: Dim 25 Nov - 12:00 (2012)    Sujet du message: Créations diverses Répondre en citant

Ouais avant je comptais le faire en midi mais la gestion du midi était 100 fois plus compliquée que la gestion du wav, on voit que les inventeurs de langages ne pensent pas du tout aux compositeurs et qu'à la fin ils sont obligés de bidouiller des interfaces merdiques à l'arrache.
Je ne vois pas en quoi je vais être limité, mon programme imprime des partitions (voir les fonctions du genre "afficher partition"), et je peux enregistrer la carte son quand le programme joue.

Si je décide de le passer en midi la seule chose que changera ce sera le début du code jusqu'à la fonction jouer(note). Je peux refaire une fonction jouer(note) en midi sans changer son nom et le reste du programme ne change pas.
Revenir en haut
Visiter le site web du posteur
trotter
Vétéran


Inscrit le: 26 Juil 2011
Messages: 6 872

MessagePosté le: Dim 25 Nov - 12:28 (2012)    Sujet du message: Créations diverses Répondre en citant

Hmm, limité au niveau des notes, un seul instrument, une seule gamme (sauf si tu vas changer le pitch), une seule durée de note j'ai l'impression.
Enfin, c'est sûr que c'est plus pratique et plus rapide de se baser sur des .wav, c'est juste que ça ressemble à une solution de prototypage. Si tu veux être plus ambitieux plus tard... Sinon c'est cool, décortiquer le code est un bon tuto pour composer.


Si tu veux générer des partitions tu pourrais utiliser le format .nwctxt - NoteWorthy Composer Text, tu connais ? Ca sera peut être plus simple que le midi.
Normalement tu fous ça dans un fichier texte et tu l'importes avec Noteworthy et ça devrait te sortir une partition :
http://my.noteworthysoftware.com/?topic=6094.0

Code:
# This is a sample NWC Text file. As you can see, any text starting with
# a '#' character is treated as a comment.
#
# ------------------------------------------------------------------------------
# This first non-comment line of the file should be the !NoteWorthyComposer
# header line. This indicates that this file contains NoteWorthy Composer Text.
# This sample targets version 2.0 (newer files use version 2.5).
#
!NoteWorthyComposer(2.0)

# Blank lines can appear anywhere in the file after the
# initial !NoteWorthyComposer header

# ------------------------------------------------------------------------------
# The SongInfo, PgSetup, PgMargins, and Font lines can appear anywhere in
# the file, but it is good form to have them at the top, prior to adding
# any staff data.

# It is fine to use multiple SongInfo, PgSetup, and PgMargins in a file.
# If a field is specified more than once, the last one overrides any
# previous assignment.
|SongInfo|Title:"<FileTitle>"|Author:"<Author>"|Lyricist:"<Lyricist>"
|SongInfo|Copyright1:"<Copyright1>"
|SongInfo||Copyright2:"<Copyright2>"
|SongInfo|Comments:"<Comments>"

|PgSetup|StaffSize:16|NtnTypeface:NWC2SwingDings|Zoom:4
|PgSetup|TitlePage:Y|JustifyVertically:Y|ExtendLastSystem:Y
|PgSetup|DurationPadding:Y|PageNumbers:3|StaffLabels:First System
|PgSetup|BarNumbers:Circled|StartingBar:20|AllowLayering:Y

# Margins are specified in Centimeters. You can convert to
# inches by dividing these values by 2.54.
|PgMargins|Left:1.27|Top:1.27|Right:1.27|Bottom:1.27
|PgMargins|Mirror:Y

# Unlike the other top level instructions, each Font instruction should
# be defined on a single line. Each Font instruction must include the
# Style option, which identifies which named font is being defined on
# the line. The Size is in points. The CharSet comes from Script field
# in the Font dialog.
|Font|Style:Staff Italic|Typeface:"Times New Roman"|Size:10|Bold:Y|Italic:Y|CharSet:0
|Font|Style:Staff Bold|Typeface:"Times New Roman"|Size:8|Bold:Y|Italic:N|CharSet:0
|Font|Style:Staff Lyric|Typeface:"Times New Roman"|Size:7|Bold:N|Italic:N|CharSet:0
|Font|Style:Page Title Text|Typeface:"Times New Roman"|Size:24|Bold:Y|Italic:N|CharSet:0
|Font|Style:Page Text|Typeface:"Times New Roman"|Size:12|Bold:N|Italic:N|CharSet:0
|Font|Style:Page Small Text|Typeface:"Times New Roman"|Size:8|Bold:N|Italic:N|CharSet:0

# If a particular User font is not used in the file, then it might
# not appear in the file.  When scanning an existing nwctxt file,
# you cannot assume that any particular fields or instructions
# will exist in the file.
|Font|Style:User 1|Typeface:"Times New Roman"|Size:8|Bold:N|Italic:N|CharSet:0
|Font|Style:User 2|Typeface:"Times New Roman"|Size:8|Bold:N|Italic:N|CharSet:0
|Font|Style:User 3|Typeface:"Times New Roman"|Size:8|Bold:N|Italic:N|CharSet:0
|Font|Style:User 4|Typeface:"Times New Roman"|Size:8|Bold:N|Italic:N|CharSet:0
|Font|Style:User 5|Typeface:"Times New Roman"|Size:8|Bold:N|Italic:N|CharSet:0
|Font|Style:User 6|Typeface:"Times New Roman"|Size:8|Bold:N|Italic:N|CharSet:0

# ------------------------------------------------------------------------------
# The first AddStaff line is optional, although it is required if you want to name,
# label, or group a staff
|AddStaff|Name:"<Staff1Name>"|Label:"<StaffLabel>"|Group:"Vocal"

# The various StaffProperties can be assigned using multiple instances of
# the instruction.
|StaffProperties|EndingBar:Section Close|Visible:Y
|StaffProperties|BoundaryTop:14|BoundaryBottom:12
|StaffProperties|Lines:5|Style:Standard|Layer:N|Color:Default
|StaffProperties|Muted:N|Volume:127|StereoPan:64|Device:0|Channel:2

# The StaffInstrument uses the same syntax as the Instrument instruction
# used in NWC clip text
|StaffInstrument|Name:"Lead 6 (voice)"|Patch:85|Trans:0|DynVel:10,30,45,60,75,92,108,127

# Lyrics can be defined anywhere after the AddStaff line, but it is good form
# to place them before the notation for the staff
|Lyrics|Placement:Bottom|Align:Standard Rules|Offset:0|UnderscoreAsSpace:N
|Lyric1|Text:"Aaaaaaaah________\r\n"

# The notation contained in the staff uses the same format as NWC2 Clip
# Text from the NWC2 User Tool and clipboard mechanisms
|Clef|Type:Treble
|Note|Dur:Whole|Pos:1^
|Bar
|TempoVariance|Style:Fermata|Pos:9
|Note|Dur:Whole|Pos:1

# ------------------------------------------------------------------------------
# Whenever an AddStaff is encountered, a new staff is created. The new
# staff then becomes the target for the instructions that follow it, until
# another AddStaff is encountered.
|AddStaff|Name:"<Staff2Name>"|Label:"<PianoStaffLabel>"|Group:"Piano"
|StaffProperties|EndingBar:Section Close|Visible:Y|BoundaryTop:10|BoundaryBottom:18|Lines:5|Style:Upper Grand Staff|Layer:N|Color:Default
|StaffProperties|Muted:N|Volume:127|StereoPan:64|Device:0|Channel:1
|StaffInstrument|Trans:0|DynVel:10,30,45,60,75,92,108,127
|Lyrics|Placement:Bottom|Align:Start of Accidental/Note|Offset:2
|Lyric1|Text:"1_1 1_2 1_3 1_4\r\n1_5 1_6 1_7 1_8\r\n"
|Lyric2|Text:"2_1 2_2 2_3 2_4\r\n2_5 2_6 2_7 2_8\r\n"
|Clef|Type:Treble
|Note|Dur:4th|Pos:-4
|Note|Dur:4th|Pos:-3
|Note|Dur:4th|Pos:-2
|Note|Dur:4th|Pos:-1
|Bar
|Note|Dur:4th|Pos:0
|Note|Dur:4th|Pos:1
|Note|Dur:4th|Pos:2
|TempoVariance|Style:Fermata|Pause:5|Pos:9
|Chord|Dur:4th|Pos:1,3,5

# ------------------------------------------------------------------------------
|AddStaff|Name:"<Staff3Name>"|Group:"Piano"
|StaffProperties|EndingBar:Section Close|Visible:Y|BoundaryTop:15|BoundaryBottom:14|Lines:5|Style:Lower Grand Staff|Layer:N|Color:Default
|StaffProperties|Muted:N|Volume:127|StereoPan:64|Device:0|Channel:1
|StaffInstrument|Trans:0|DynVel:10,30,45,60,75,92,108,127
|Lyrics|Placement:Top|Align:Standard Rules|Offset:-2|UnderscoreAsSpace:N
|Lyric1|Text:"1_1 1_2 1_3 1_4\r\n1_5 1_6 1_7 1_8\r\n"
|Lyric2|Text:"2_1 2_2 2_3 2_4\r\n2_5 2_6 2_7 2_8\r\n"
|Clef|Type:Bass
|Note|Dur:4th|Pos:-1
|Note|Dur:4th|Pos:0
|Note|Dur:4th|Pos:1
|Note|Dur:4th|Pos:2
|Bar
|Note|Dur:4th|Pos:3
|Note|Dur:4th|Pos:4
|Note|Dur:4th|Pos:5
|TempoVariance|Style:Fermata|Pause:0|Pos:-7
|Note|Dur:4th|Pos:6
!NoteWorthyComposer-End
Revenir en haut
Roi of the Suisse
Vétéran


Inscrit le: 27 Juil 2011
Messages: 8 140

MessagePosté le: Dim 25 Nov - 17:55 (2012)    Sujet du message: Créations diverses Répondre en citant

L'export en NWC pourrait m'intéresser un jour.

Un seul instrument : ce sera le piano donc un orchestre à lui tout seul (dixit Chopin).
Une seule gamme : non, il y aura les 128 notes.
Une seule durée de note : non, les 128 notes seront disponibles en courtes et en longues.
Tuto pour composer : pour l'instant le coeur du code est là :
Code:
        //              en haut les notes de sortie
       
        //              lasibsidod#rembmifaf#soso#
        int[] ligne0 =  {2,0,2,1,2,3,0,4,3,1,2,0}; //la
        int[] ligne1 =  {1,0,0,1,1,2,1,0,1,0,2,0}; //sib
        int[] ligne2 =  {4,0,3,2,3,3,0,2,0,2,0,3}; //si
        int[] ligne3 =  {3,0,1,3,0,3,0,3,4,0,4,1}; //do
        int[] ligne4 =  {3,1,3,0,3,0,1,4,1,2,0,2}; //do#
        int[] ligne5 =  {4,2,1,3,0,3,0,2,2,0,2,0}; //re          de ce côté les notes d'entrée
        int[] ligne6 =  {0,2,3,1,2,0,2,1,2,1,2,0}; //mib
        int[] ligne7 =  {1,0,3,1,3,2,0,3,1,1,2,0}; //mi
        int[] ligne8 =  {3,3,0,3,2,3,1,1,3,0,2,1}; //fa
        int[] ligne9 =  {3,1,3,0,2,2,0,4,1,2,2,4}; //fa#
        int[] ligne10 = {4,1,3,3,0,2,0,4,3,0,3,1}; //sol
        int[] ligne11 = {9,1,2,2,2,0,1,2,2,1,0,2}; //sol#

Et même pour le brodage de mélodie et l'ajout de basses il y aura appel à cette matrice.
Revenir en haut
Visiter le site web du posteur
sriden
Administrateur


Inscrit le: 22 Juil 2011
Messages: 14 912

MessagePosté le: Dim 25 Nov - 18:33 (2012)    Sujet du message: Créations diverses Répondre en citant

Tu fais un truc qui compose des morceaux automatiquement ? zulu Je vais me plaindre au syndicat de la Sacem que tu nous voles le pain de notre bouche tel un ignoble charles à taon capitaliste.
Revenir en haut
Saka
Vétéran


Inscrit le: 16 Oct 2011
Messages: 750

MessagePosté le: Sam 1 Déc - 16:37 (2012)    Sujet du message: Créations diverses Répondre en citant

C'est moi qui l'a fé
Revenir en haut
sriden
Administrateur


Inscrit le: 22 Juil 2011
Messages: 14 912

MessagePosté le: Sam 1 Déc - 16:50 (2012)    Sujet du message: Créations diverses Répondre en citant

C'est le héros de Kujira après 30 ans passé dans la baleine à faire des énigmes de zutre ? zulu
Revenir en haut
Roi of the Suisse
Vétéran


Inscrit le: 27 Juil 2011
Messages: 8 140

MessagePosté le: Sam 1 Déc - 20:46 (2012)    Sujet du message: Créations diverses Répondre en citant

Lulz il y a une ressemblance oui (ça doit être le fait de dessiner maladroitement à la souris).
Si tu progresses encore tu feras mes charas pour le chapitre 4, les charas c'est ce qui me démotive.
Revenir en haut
Visiter le site web du posteur
Criket
Vétéran


Inscrit le: 12 Déc 2011
Messages: 1 878

MessagePosté le: Sam 1 Déc - 21:36 (2012)    Sujet du message: Créations diverses Répondre en citant

C bien.
Rajoute des ombres pour qu'on puisse triquiter le pillow-shading. :8X


Dernière édition par Criket le Dim 2 Déc - 15:29 (2012); édité 1 fois
Revenir en haut
Saka
Vétéran


Inscrit le: 16 Oct 2011
Messages: 750

MessagePosté le: Sam 1 Déc - 23:17 (2012)    Sujet du message: Créations diverses Répondre en citant

Mais y'a des ombres MÂÂÂDAME.
Regarde bien les jambes.
Elles sont pas réalistes, c'est ça?... :(

Je mets un screenchiotteshot pour pas poster dans le vide:



Ouais c'est pas tout à fait comme celui que j'ai mis sur oniro, j'ai un peu arrangé entre temps.
Revenir en haut
Anonyme
Vétéran


Inscrit le: 30 Juil 2011
Messages: 1 028

MessagePosté le: Sam 1 Déc - 23:55 (2012)    Sujet du message: Créations diverses Répondre en citant

C'est un jeu sur Nonor ?
Revenir en haut
Roi of the Suisse
Vétéran


Inscrit le: 27 Juil 2011
Messages: 8 140

MessagePosté le: Dim 2 Déc - 00:28 (2012)    Sujet du message: Créations diverses Répondre en citant

Lulz à gauche on dirait Einstein :--
Revenir en haut
Visiter le site web du posteur
Contenu Sponsorisé






MessagePosté le: Aujourd’hui à 08:03 (2017)    Sujet du message: Créations diverses

Revenir en haut
Montrer les messages depuis:   
Poster un nouveau sujet   Répondre au sujet    FAMAS Index du Forum -> Section Corvées -> Laboratoire de recherche & développement Toutes les heures sont au format GMT + 2 Heures
Aller à la page: <  1, 2, 318, 19, 20101, 102, 103  >
Page 19 sur 103

 
Sauter vers:  

Index | creer un forum gratuit | Forum gratuit d’entraide | Annuaire des forums gratuits | Signaler une violation | Conditions générales d'utilisation
Powered by phpBB © 2001, 2005 phpBB Group
Traduction par : phpBB-fr.com