le-violon.org

Je sais pas si quelqu'un a déjà eu l'idée... imaginez un logiciel, vous injectez votre partition (au format qui va bien) et il vous sort les doigtés (voire plusieurs variantes)

est ce que ça tente les scientifiques du forum de réfléchir la dessus
il peut en effet s'agir d'un problème d'optimisation fort intéressant, minimisation de l'utilisation du 4ème doigt, minimisation du nombre de changements de position, etc...

ça risque d'être dur, car on va non seulement choisir le doigté en fonction du niveau, mais surtout en fonction du son que l'on veut obtenir, et il risque d'être dur de programmer des algo capables de discerner le son à obtenir suivant les passages et d'ainsi attribuer un doigté...

puis d'autre part, s'il doigte toutes les notes, la partition risque d'être méchamment chargée voir illisible...

après pourquoi pas, on pourrait toujours essayer

après on fait afficher uniquement les doigtés de changement de position et/ou de cordes,

pour les préférences, on peut à loisir affecter au cahier des charges des coefficients de pondération pour chaque doigt, un coefficient d'adversité au changement de position ou de corde, etc...

oui mais vu que ça dépend de chaque partition, on risque de passer plus de temps à programmer le log qu'a les mettre soit-même non ?

après le seul moyen est d'essayer...

on risque de passer plus de temps

certes je n'ai pas besoin de logiciel pour choisir mes doigtés, d'ailleurs j'ai horreur de les noter, et j'en change fréquemment, c'est donc un projet purement altruiste, qui part du principe qu'il est sans doute possible de déterminer une méthode rationnelle de choix des doigtés

au niveau de l'utilité, c'est un constat, de nombreux débutants galèrent avec leurs doigtés et ne savent pas comment jouer certains passages.. un tel outil leur serait assurément particulièrement utile et ne devrait pas être d'une complexité effroyable à mettre en œuvre.

toto a écrit :[...] qui part du principe qu'il est sans doute possible de déterminer une méthode rationnelle de choix des doigtés [...]

Mmmh, ça me paraît fortement discutable... Faut aussi tenir compte des préférences de chacun. Par exemple, ayant des petits doigts, je sais que j'ai systématiquement tendance à privilégier un changement de position plutôt que de tenter une extension qui a une chance sur deux de foirer, surtout dans les basses positions.

Et puis on l'a dit, comment tu intègres la notion de sonorité dans ton algorithme ? Tu n'as pas de règle générale du genre "privilégier toujours les cordes les plus basses", c'est à voir au cas par cas. Et à partir du moment où celui qui utilise l'algorithme a compris ça, il en a plus vraiment besoin...

De toute façon, si tu réfléchis bien, pour faire une même note, t'as toujours plusieurs possibilités, jusque 16 pour les notes au delà disons du la 4. Comment tu choisirais la bonne façon de la faire ? Où tu places les changements de position ?

A mon avis, c'est faisable, mais ça demanderait un boulot pharaonique d'inventaire et de formalisation des "règles" qu'on applique inconsciemment en doigtant soi-même sa partition. D'où finalement un intérêt assez limité...

Sans compter que faut lui rentrer la partition note par note, ou alors utiliser un logiciel qui convertit les images en partition utilisable et éditable...

et bien il ne faut pas chercher la perfection dans un projet informatique, un algorithme de base qui tient compte uniquement des changements de position et d'utilisation du 4ème doigt avec une pondération reflétant la préférence utilisateur

un boulot pharaonique

tu y vas un peu fort quand même, c'est pas bien méchant

jusque 16 pour les notes au delà disons du la 4

du si 4 tu veux dire

ton idée (brillante) me paraît être le bon point de départ... pour chaque note tu regarde le nombre de possibilité qui existent, donc une note basse aura moins de possibilités que de note aiguës déjà... et puis ensuite tu peux enlever toutes les solutions irréalistes, en tenant compte de la note précédente et de la note suivante..
le but n'étant pas de fournir une solution unique ad hoc mais de suggérer un certain nombre de possibilités acceptables, en gros tu peux voir ça comme un programme d'élimination de doigtés bidons dans un premier temps

Je suppose que tu as eu le réflexe de regarder ce qui existait déjà dans le domaine sur internet, et que tu connais donc ces articles:
Pour piano
Pour guitare
Générique pour les instruments à corde

Sans compter les références bibliographiques, celle-ci par exemple.

Y'a de quoi faire là déjà.

Non je n'ai pas eu ce réflexe, j'espère que tu ne m'en tiendras pas rigueur... c'est juste une idée qui m'a traversé l'esprit comme ça. Je suis tout à fait heureux de savoir que cela existe déjà.

Donc comme un tel type de programme existe déjà pour le violon (comme quoi il n'y a rien d'irréalisable dedans), on peut alors se poser la question de "comment ça marche" ?

intéressant ce concept! ouais mais alors c'est vrai, comment ça marche?

A l'électricité

Idée interessants, je verrai un gros fichier avec tous les doigtés déjà existants pour toutes les partitions pour violon, le tout répertorié et noté, et donc on aurait la possibilité, en cliquant sur un bouton "suivant" de voir les doigtés qui nous vont le mieux. Bon c'est vrai que pour ça, il faudrait que quelqu'un rentre tout pour toutes les partitions existantes mais bon, il faut de l'acharnemant pour tout (on en connait quelque chose)

!

Voici une ébauche en francais. L'algo ne prend pas en compte le niveau et les préférences de chacun, ne fonctionne que sur les Ière et IIIème positions.

La liste obtenue en résultat doit encore être travaillée pour un affichage à l'écran, ainsi que la saisie de données

Il reste encore beaucoupr de boulot pour prendre en compte toutes les notes, toutes les préférences de chacun, les harmoniques...
Mais je ne vais pas m'y aventurer, des programmes font déja ca très bien. c'est juste pour avoir un ordre d'idée de la complexité des choses.

Code : Tout sélectionner

Algorithme : tablature violon
: liste_notes : liste de x listes --liste qui contient les notes entrées par l’utilisateur, [(note1, octave1), (note2, octave2), ...]
: liste_result : liste de x listes --liste qui contiendra les positions finales {[(case1, corde1), position1], [(case2, corde2), position2], ...}
longueur_liste : entier -- variable qui contient la longueur de la liste à analyser
: a : entier --la position en cours d’analyse
: n : entier --curseur
: note_actu : liste de deux chaînes de caractères --la note en cours d’analyse (note, octave)
: coo : liste deux entiers --les coordonnées trouvées
:
: DEBUT
: liste_notes <-  [(note1, octave1), (note2, octave2), ...]
: longueur_liste <- longueur(liste_notes)
: A <- 1
:
: Pour n allant de 1 à longueur_liste –On refait la boucle autant de fois qu’il y a de notes à analyser
: 	note_actu <- liste_notes(n)
:	coo <- po(a, note_actu) –On appelle la fonction po avec la position et la note et elle retourne (case, corde) ou (0, 0) si rien n’est trouvé dans la position donnée
:	Si coo = (0, 0) alors –Si po n’a rien trouvé, on change de position puis on relance po
:		Si a = 1 alors
:			a <- 3
:		Sinon
:			a <- 1
:		Fin Si
:		coo <- po(a, note_actu)
:	Fin Si
:	liste_result(n) <- (coo, a) –Pour finir on enregistre le résultat [(case, corde), position] dans la liste résultat
: Fin Pour
: FIN
:
: Fonction po(position : entier, note : liste de deux chaînes de caractères) –po est une fonction à deux paramètres : la position étudiée et la note à analyser
: e : liste de deux entiers –e, variable locale qui contiendra la coordonnée trouvée
: c, i : curseurs --curseurs
:
: DEBUT
: Si position = 1 alors –si on essaye en première position
:	Pour c allant de 1 à 4 –les quatre cordes
:		Pour i allant de 0 à 6 –les sept possibilités par corde
:			Si T1[i, c] = note alors –si la note du tableau 1 correspond à la note analysée
:				e <- (i, c) –on enregistre les coordonnées dans e
:				retourner e –et po renvoie e
:			Fin Si
:		Fin Pour
:	Fin Pour
:	retourner e
: Sinon –même opération si on est en troisième position
:	Pour c allant de 1 à 4
:		Pour i allant de 1 à 7 –mais sans le 0, il n’y a plus les cordes à vide, et en ajoutant le 7, le quatrième doigt 
:			Si T3[i, c] = note alors –dans le tableau 3 cette fois-ci
:				e <- (i, c)
:				retourner e
:			Fin Si
:		Fin Pour
:	Fin Pour
:	retourner e
: Fin Si
: FIN

Et T1 est le tableau de listes :
___0_____1_____2_____3___4____5____6
1 (Sol,3) (S#,3) (La,3) (L#,3) (Si,3) (Do,4) (D#,4)
2 (Ré,4) (R#,4) (Mi,4) (Fa,4) (F#,4) (Sol,4) (S#, 4)
3 (La,4) (L#,4) (Si,4) (Do,5) (D#,5) (Ré,5) (R#,5)
4 (Mi,5) (Fa,5) (F#,5) (Sol,5) (S#,5) (La,5) (L#,5)
Et T3 est le tableau de listes :
___1_____2_____3____4____5____6____7
1 (Do,4) (D#,4) (Ré,4) (R#,4) (Mi,4) (Fa,4) (F#4)
2 (Sol,4) (S#,4) (La,4) (L#,4) (Si,4) (Do,5) (D#,5)
3 (Ré,5) (R#,5) (Mi,5) (Fa,5) (F#,5) (Sol,5) (S#,5)
4 (La,5) (L#,5) (Si,5) (Do,6) (D#6) (Ré,6) (Ré#6)

Exemple :
L’utilisateur entre [(Do,5), (Mi,5), (Do,6), (Do,5), (Sol,3)]
L’algorithme retourne {[(3, 3),1], [(0, 4), 1], [(4, 4), 3], [(6, 2), 3], [(0, 1), 1]}

aaaah mais ça me fait super plaisir que tu te sois penché sur la question

, les réactions à mon topic ayant été froides, j'avais lâché l'affaire, je vais regarder ton bout de code

merci en tout cas, c'est l'intention qui compte

le-violon.org

Algorithme de doigté

Algorithme de doigté