Lançons-nous dans le scripting !

i m back

J'ai modifié le script pour créer les moyennes toujours dans le même suivi et en les nommants avec le nom du suivi qui est moyenné

Code:

{
var myComp = app.project.activeItem;
if (!myComp || !(myComp instanceof CompItem))
    alert("Il n’y a pas de composition active");
else {
    if (myComp.selectedLayers.length != 1)
        alert("Le calque contenant le suivi n'est pas sélectionné.");
    else {
        var myLayer = myComp.selectedLayers[0];
        var myTrackerGroup = myLayer.property("Motion Trackers");
        var selectedTracker = null;
        for (var i = 1; i <= myTrackerGroup.numProperties; i++) {
            var theTracker = myTrackerGroup.property(i);
            if(theTracker.selected == true) {
                selectedTracker = theTracker;
                break;
                }
            }
        if (selectedTracker == null)
            alert("Vous devez sélectionner un Suvi.");
        else {
            var nbPoints = selectedTracker.numProperties;
            if (nbPoints < 2)
                alert ("Votre Suivi doit contenir au moins deux Point de suivi.");
            else {
                var trackPoints = new Array();
                for (var i = 1; i <= nbPoints; i++) {
                    trackPoints[i] = selectedTracker.property(i).property(1);
                    }
                var theAttach = new Array();
                for (var t = 0; t <= myComp.duration; t += myComp.frameDuration) {
                    var totalAttach = [0,0];
                    for (i = 1; i <= nbPoints; i++) {
                        totalAttach += trackPoints[i].valueAtTime(t, true);
                        }
                    theAttach[t] = totalAttach / nbPoints;
                    }
                app.beginUndoGroup("pataTrack");
                var myTracker = myTrackerGroup.property("----moyenne----");
                if (myTracker == null) {
                    myTracker = myTrackerGroup.addProperty("ADBE MTracker");
                    myTracker.name = "----moyenne----";
                    }
                var newTrackPoint = myTracker.addProperty("ADBE MTracker Pt");
                newTrackPoint.name = "moyenne de "+selectedTracker.name;
                for (var t = 0; t <= myComp.duration; t += myComp.frameDuration) {
                    newTrackPoint.property(1).setValueAtTime(t , theAttach[t]);
                    newTrackPoint.property(6).setValueAtTime(t , theAttach[t]);
                    }
                app.endUndoGroup();
                }
            }
        }
    }
}

.

petite question dans valueAtTime(t, true), à quoi sert true ?

 

Cela indique s'il faut prendre la valeur de la propriété avant évaluation d'expression (true), ou en tenant compte de l'expression (false).

Il y a une petite erreur dans ton script....fait afficher ton tableau "trackPoints", tu vas voir que le premier élément du tableau est vide (pas vraiment conseillé). L'index du premier élément d'un tableau est 0 (ici pour le remplir tu fais ta boucle avec un "i" qui commence à 1).

 

Pour la petit erreur, je trouvais ça plus pratique de faire comma ça, puisque les propriétés commence à 1. Comme ça j'ai un index du tableau qui correspond au rang de la propriété.

Pour continuer à m'entraîner je voudrais faire autre chose et je vais essayer de comprendre ce qui tu expliquais plus haut pour contrôler le nombre d’image clé.
Car je voudrais faire une moyenne par Points de suivi de toutes les clés de Degrè de confiance. Ensuite je renommerai le Point de suivi avec cette valeur, ce qui permettra d’avoir un apperçu rapide de la qualité des différents tracks.

Et ça me fera deux outils pour le tracking, d’où un peu plus d’intérêt pour faire ça dans une palette.

 

oui j avais bien compris ce que tu avais en tête et je te deconseille de faire comme ca

si tu veux garder ton i de 1 à nbPoints pour correspondre avec l index des propriétés, utilise la technique montrée en page 1 pour remplir un tableau:

Code:

var trackPoints = new Array();
for (var i = 1; i <= nbPoints; i++) {
      trackPoints[trackPoints.length] = selectedTracker.property(i).property(1);
}

Pour récuperer les infos sur l'instant des clés, tu as "keyTime()" qui te renvoie l instant (en seconde) de la clé que tu lui passes en parametre. (ex: myProp.keyTime(10) donne l instant de la 10e image clé de "myProp"). Meme principe qu'avec les expressions mais noté différemment.

Avec la palette et tout ...tu vas te faire un bon script au finish là

 

Est-ce que finalement tu as d'autres infos sur l'intérêt de l'ExtendScript Toolkit ?

 

A y est :voilà mon script qui renomme les Point de suivi sélectionné avec la moyenne de leur Degré de confiance.

Code:

{
var myComp = app.project.activeItem;
if (!myComp || !(myComp instanceof CompItem))
	alert("Il n’y a pas de composition active");
else {
	if (myComp.selectedLayers.length != 1)
		alert("Le calque contenant le suivi n'est pas sélectionné");
	else {
		var myLayer = myComp.selectedLayers[0];
		var myTrackerGroup = myLayer.property("Motion Trackers");
		var selectedTrack = 0;
		app.beginUndoGroup("testTrack");
		for (var i = 1; i <= myTrackerGroup.numProperties; i++) {
			var theTracker = myTrackerGroup.property(i);
			for (var j = 1; j <= theTracker.numProperties; j++) {
				var theTrackPoint = theTracker.property(j);
				var nbKeys = theTrackPoint.property(5).numKeys;
				if (theTrackPoint.selected == true & nbKeys > 0) {
					var totalConfidence = 0;
					for (var k = 1; k <= nbKeys; k++) {
						totalConfidence += theTrackPoint.property(5).keyValue(k);
						}
					theTrackPoint.name = Math.round(totalConfidence/nbKeys);
					selectedTrack++;
					}
				}
			}
		if (selectedTrack == 0)
			alert ("Vous devez sélectionner des Points de suivi avec des images clé en Degré de confiance.")
		app.endUndoGroup();
		}
	}
}

 

Impeccable !
va falloir que tu mettes tout ca en boîte maintenant

ps1: on met normalement deux signes "&" pour designer le "et" logique dans la condition
ps2: pour l'ESTK, je ne l'ai jamais utilisé...à part avoir la possibilité de mettre des "Points d'arret" dans ton programme pour éventuellement aider dans le débogage (faire du pas à pas), et le fait de ne pas à avoir un éditeur externe, je dirais qu'il ne serait à rien.

 

1-

c'est quoi justement cette différence entre les && "logique" et les & "au niveau du bit"

 

& est l'opérateur "et" bit à bit donc si on utilise cet opérateur dans un if, l'opération "et" va être effectuée et c'est seulement si le résultat est différent de 0 que la condition est validée.

&& est l'opérateur "et" pour les conditions, c'est dire que si tu fais if (A && B) et que A est faux, il ne va pas plus loin, la condition n'est pas validée.

(enfin, c'est comme ça dans plusieurs langages dont le javascript donc je suppose que c'est pareil pour AE)

-> donc il vaut mieux utiliser && comme l'a dit nab

 

oui c'est ce qu'a dit Sylv...

qqes precisions...
"&" est utilisé pour comparer bit à bit (au sens du "et" logique) deux variables.
Cela analyse donc la représentation des variables (representees en binaire..par des bits 0 ou 1), si deux bits se trouve à 1 ("vrai") le résultat pour ce bit sera 1, si l'un des deux est 0 ce sera 0... le calcul se fait pour tous les bits representant les variables.
par exemple: 15 & 9 te donne 1111 & 1001 = 1001 (i.e. 9 donc different de 0)

dans nos scripts on n'aura pas besoin de cet operateur...nous on veut un operateur qui teste si la premiere condition est vraie et si c est le cas va aller tester la deuxieme; tout cela en terme de "vrai/faux" (succes au test ou echec)...et celui-ci s écrit "&&"

va falloir perdre tes bonnes vieilles habitudes désolé

 

L'opérateur & est généralement utilisé pour faire du bit masking. Par exemple, si tu veux récupérer les bytes d'un mot de 32 bits, tu peux faire quelque chose comme ça, en pseudo language (en binaire, 0xF vaut 1111):

Code:

byte a = mot & 0xFF;
mot = mot >> 8;
byte b = mot & 0xFF;
mot = mot >> 8;
byte c = mot & 0xFF;
byte d = mot >> 8;

Ce qui donne en assembleur quelque chose comme:

Code:

lw $t0, 0($v0) # t0 = dddddddd'cccccccc'bbbbbbbb'aaaaaaaa
addi $t1, $t0, 0xFF # t1 = 00000000'00000000'00000000'aaaaaaaa
sru $t0, $t0, 8 # t0 = 00000000'dddddddd'cccccccc'bbbbbbbb
addi $t2, $t0, 0xFF # t2 = 00000000'00000000'00000000'bbbbbbbb
sru $t0, $t0, 8 # t0 = 00000000'00000000'dddddddd'cccccccc
addi $t3, $t0, 0xFF # t3 = 00000000'00000000'00000000'cccccccc
sru $t4, $t0, 8 # t4 = 00000000'00000000'00000000'dddddddd

Normalement, tu n'auras jamais besoin d'utiliser des opérations logiques, à moins que tu désires faire des opérations bas niveau. Il faut cependant faire attention aux types. L'opérateur & retourne un entier, et pas un booléen. Si tu peux le mettre dans une condition en javascript, c'est que le langage considère que 0 vaut false et que les autres nombres valent true. Pas tout les langages font cette conversion.

 

Ok merci pour toutes ces infos !

J'ai une autre question:
Comment procéder pour classer une série de nombre dans un ordre croissant (ou décroissant) ?

 

pour trier soit tu le fais toi-même, soit tu utilises la methode javascript "sort()".
elle peut prendre en parametre une fonction, ce sera cette fonction qui determinera l'ordre dans lequel seront triés les éléments (par defaut sinon cela transforme chaque élément en chaine de caracteres et les classe par ordre lexico..).
elle fonctionne un peu bizarrement ..en fait le signe (+ -) du resultat de ta fonction indique si l element vient se ranger avant(-) ou apres(+), qd (=) ils sont consecutifs dans le tableau...) lorsque cette fonction compare tour à tour les paires d'éléments;
le plus simple est que je te file un exemple avec la fonction "croissant" et "decroissant", tu n'as plus qu'a ajouter celle que tu veux dans ton script.

Code:

function croissant(i,j) { 
	return i - j;
}
function decroissant(i,j) { 
	return j - i;
}

var tab = [25,17,32,3,35,14,3,1]; 
alert(tab.sort(croissant));
alert(tab.sort(decroissant));

ps: pour plus d'infos check sur le net avec "Array.sort" ou "sort(compareFunction)"

 

Et si tu veux le faire toi-même: http://fr.wikipedia.org/wiki/Tri

 

Je préfère que sort() le fasse pour moi

Mais je ne comprends pas comment sort utilise la fonction.
Comment sont introduits les paramètres i et j ?

Par exemple si je veux classer 1 et 20
[2,10].sort() ok ça donne l'ordre lexico 2,10.
Mais faut mettre quoi dans les parenthèses pour choisir l'ordre ?