Pas de blabla : Télécharger le script / Download the script
(Non-French users : the script auto-toggles to EN-language interface according to application locale)

---

(MàJ du 28.06.07)      Claquos ! version 1.2 est téléchargeable et désormais compatible avec InDesign CS, CS2 et CS3. Quelques améliorations mineures lui ont été apportées. Ne laissez pas couler votre ancienne version, faites illico la mise à jour !

---

(Note du 11.05.06)      Un bug stupide a trompé momentanément notre vigilance : Claquos ! fonctionnait sur la page 1 du document de travail mais pas sur les autres pages ! Dysfonctionnement tout à fait logique puisque le code attachait les méthodes de création à l’objet Document et non pas à l’objet Page. Une erreur de débutant !... heureusement corrigée dans la version 1.0b.

---

L’infographiste adore les nouveaux défis mais déteste réinventer la roue. Donc, quand il a besoin d’intégrer des graphiques dans sa mise en page InDesign, il bascule vers un logiciel idoine, produit son petit camembert 3D, l’exporte en EPS voire en TIF, l’importe dans InDi, ajuste les dimensions, recadre, résout les conflits colorimétriques — ah ! la pollution des nuanciers importés ! — retourne vers le logiciel source si les données changent (et elles changent, bien sûr), puis réactualise, recommence... Le temps qu’on perd à gagner du temps mériterait une étude statistique.

En fait, InDesign est presque un logiciel de dessin vectoriel (tracés, pathfinder, etc.), sauf que c’est avant tout un logiciel pour maquettistes ! Alors se posent et s’endurcissent les frontières tribales entre PAOistes et illustrateurs, d’où l’inhibition machiavélique des organes vectoriels d’InDesign.

Mon propos n’est évidemment pas de jeter Illustrator ou Freehand aux orties. Il y a un milliard de choses graphiquement infaisables sous InDesign — puisqu’on vous dit que ce n’est pas un logiciel de dessin ! — mais franchement, un générateur de graphiques sectoriels, est-ce demander la lune à Adobe ?

« Claquos ! » est un script tout bête dans un emballage fleurant bon le prolétariat : il permet de fabriquer en deux clics des diagrammes camembert dans et avec InDesign, versions CS, CS2 ou CS3.

Une fois le fichier téléchargé et rangé dans votre dossier de scripts magiques (v. infra), vous n’aurez plus qu’à lancer notre générateur fromager depuis la palette de scripts, ce qui donne d’abord ceci :

...puis cela :

Les nombres saisis sont convertis en parts proportionnelles ; on peut donc entrer aussi bien des pourcentages que des valeurs en vrac, « Claquos » s’occupe de calculer le ratio par rapport à la somme. Le graphique consiste en un groupe de quartiers à chacun duquel est attribuée une nuance présente dans le document actif. Vous pourrez bien sûr modifier cette distribution après coup par sélection directe et réaffectation de couleur.

Si vous avez créé un jeu de nuances suffisant avant le lancement du script, chaque quartier possédera une couleur de remplissage distincte. « Claquos » propose aussi (case à cocher dans sa boîte de dialogue) d’utiliser un nuancier de gris (qu’il crée lui-même, le cas échéant).

Le camembert obtenu est redimensionnable à loisir. On peut sans mal y intégrer des effets d’ombre, modifier la bordure intérieure (blanche par défaut), éclater des parts pour les mettre en évidence, etc.

Une prochaine version du script intégrera sans doute la création d’étiquettes de texte indiquant les valeurs ou les pourcentages correspondant, mais je m’en suis tenu dans ce premier jet aux aspects strictement graphiques.

À première vue, « scripter » dans InDesign la production complète de ces tranches de camembert semble très ambitieux, car leur construction manuelle représente déjà en soi un vrai défi. En effet, InDesign n’offre ni arcs ni secteurs dans sa caisse à outils polygonaux.

Si l’on devait procéder à la mano, il faudrait découper très laborieusement un disque élémentaire obtenu par l’outil Ellipse (L) selon des tracés angulaires attentivement calculés et exécutés, à grand renforts de sinus et de cosinus ! C’est pratiquement inimaginable... et c’est pourtant exactement ce que va faire notre script, mais en vous épargnant de rouvrir vos cahiers de trigo !

Pour l’amour de la pédagogie, supposons créé un disque de base et suivons pas à pas la création d’un tracé de découpe correspondant à un angle a de 70°.

La figure 4 montre le théâtre des opérations. Un disque de 50 unités de rayon a été centré sur l’origine du système et soigneusement balisé de repères magnétiques (cf. script AutoRepères). On effectue la découpe à la plume en partant d’un point légèrement extérieur au disque sur l’axe horizontal, on place ensuite le sommet de l’angle au centre du cercle...

La position du troisième point pourrait être déterminée par le biais d’une mesure d’angle associée à la palette Informations. Cependant, la précision optimale s’obtiendra en calculant le cosinus et le sinus de l’angle qui, multipliés par la longueur du segment (un chouia de plus que le rayon), fournissent respectivement l’abscisse et l’ordonnée du point. On saisit donc ces valeurs dans la palette Transformation après un placement approximatif du point. Au passage, n’oublions pas que le système de coordonnées d’InDesign est dirigé vers le bas sur l’axe vertical : on prend donc l’opposé du sinus pour déterminer l’ordonnée du point.

Bien entendu, ces calculs idiots seront entièrement pris en charge par le script, mais il est utile d’en bien saisir la démarche. Comme le quartier de disque sera extrait par l’opération Intersection du Pathfinder, il est important de fermer le tracé polygonal. Tant que l’angle est aigu, cette clôture est facile. La méthode la plus rationnelle consiste à placer un quatrième point aux coordonnées (R, –R) [c’est-à-dire (50, –50) dans notre exemple], puis à boucler la boucle :

À l’extrême inverse, pour un angle situé au-delà de 270°, la fermeture du polygone nécessite davantage de points intermédiaires, comme l’illustre la figure 6 :

On voit donc que le tracé de la découpe par programmation nécessite un petit algorithme ciselé. C’est l’objet de la méthode Document::createSecteur(...) intégrée dans le script. Elle prend en arguments la position de l’origine, le rayon et l’angle à délimiter, et enfin la rotation à appliquer au secteur par rapport à l’origine afin de pouvoir extraire la tranche du camembert à n’importe quel endroit. Ce module constitue le cœur du programme, il renvoie à l’appelant le tracé polygonal fraîchement constitué.

Page.prototype.createSecteur = function
      (origin, radius, angle, rotation)
//--------------------------------------------------------------------
// Cree un secteur "delimite" selon origin[x,y], radius (rayon),
// angle et rotation -- NB: angle est en degres
// v. 1.0b
{
// demarrage avec un GraphicLine
var secteur = this.graphicLines.add();
var path = secteur.paths[0];
var pts = path.pathPoints;
 
var dx = origin[0];
var dy = origin[1];
var r = radius;
var a = (angle*Math.PI)/180; // conversion en radians
 
pts[0].anchor = [dx+r,dy]; // pt initial en (r,0)
pts[1].anchor = [dx,dy]; // centre du secteur
 
var X = r * Math.cos(a);
var Y = -r * Math.sin(a);
pts.add({anchor:[dx+X,dy+Y]}); // + pt en r[cos(a),sin(a)]
 
// fermeture du polygone
if ( angle > 270 ) pts.add({anchor:[dx+r,dy+r]});
if ( angle > 180 ) pts.add({anchor:[dx-r,dy+r]});
if ( angle > 90 ) pts.add({anchor:[dx-r,dy-r]});
pts.add({anchor:[dx+r,dy-r]});
path.pathType = PathType.closedPath;
 
// applique la rotation centree en [dx,dy]
secteur.rotate(rotation, [dx,dy]);
 
return(secteur);
}

J’ai choisi de créer le tracé en partant d’un objet GraphicLine, c’est-à-dire un simple segment. Les tracés d’un composant graphique sont incarnés par la collection paths. Le tracé unique d’un composant simple réside donc dans paths[0], qui est un objet de type Path. Un path (« tracé ») n’est pas autre chose qu’une suite de points, éléments de type PathPoint qui, outre quelques propriétés décrivant les tangentes, recueillent leurs coordonnées dans PathPoint::anchor. Lorsque l’on dessine un tracé polygonal angulaire, c’est la seule propriété que l’on manipule : anchor est un vulgaire tableau [x,y] contenant l’abscisse et l’ordonnée du point dans l’unité courante de l’interface utilisateur.

Concernant la problématique des conversions d’unités, je vous renvoie à la présentation du script Equalizer, section « Unités de mesure ».

Pour ajouter un point au tracé monPath, il suffit d’appeler monPath.pathPoints.add() — et le nec plus ultra consiste à y glisser directement les coordonnées du point à créer :
monPath.pathPoints.add({anchor:[x,y]}). Et voilà !

La méthode Document::createSecteur(...) découle alors des observations que nous avons faites durant l’atelier préliminaire. Seul piège à connaître : les fontions natives Math::cos() et Math::sin() prennent en arguments des angles en radians, d’où cette petite formule de conversion :
aRadians = (aDegres*Math.PI)/180 ;

Comme d’habitude, je présente seulement ici quelques éclairages ponctuels sur le code. Je laisse aux passionnés de javascript InDesign le plaisir de creuser les aspects qui les intéressent par l’examen détaillé du script.

Avec notre usine à fabriquer des secteurs polygonaux, nous allons aisément orchestrer la construction de chaque quartier. Il suffit de créer un cercle (Oval) et de l’intersecter avec un secteur dont le rayon sera légèrement surdimensionné (radius + 5). La méthode Document::createQuartier(...) met cela en œuvre tout en prenant en argument supplémentaire un objet Swatch (« nuance ») appliqué en couleur de fond.

Page.prototype.createQuartier = function
      (origin, radius, angle, rotation, swatch)
//--------------------------------------------------------------------
// Cree un quartier (intersection d'un disque et d'un secteur)
// v. 1.0b
{
var secteur = this.createSecteur(origin, radius+5,angle,rotation);
var quartier = this.ovals.add();
 
// place et dimensionne le cercle
quartier.geometricBounds =
      [
      origin[1]-radius,
      origin[0]-radius,
      origin[1]+radius,
      origin[0]+radius
      ];
 
// intersection
quartier = quartier.intersectPath(secteur);
 
// couleurs
quartier.fillColor = swatch;
quartier.strokeColor = app.activeDocument.swatches.item("Paper");
 
return(quartier);
}

Il reste alors à créer une boucle décrivant tous les quartiers. Les valeurs sont saisies par l’utilisateur dans une boîte de dialogue — v. fonction showDialog(). Les paramètres sont analysés dans parseDialogParams(), qui transforme notamment la séquence saisie en un tableau de nombres :

tableau = chaine.replace(/,/ , ".").split(/[^\.0-9]+/) ;

Le replace() transforme les éventuelles virgules décimales en points, puis le split() interprète tout ce qui n’est ni point ni chiffre comme séparateur de nombre.

Si vous utilisez cette formule dans un autre programme, pensez à réintégrer le signe moins numérique (trait d’union) dans l’expression régulière pour accepter les nombres négatifs. Dans notre cas, les nombres négatifs sont exclus.

Une méthode accessoire, que j’ai baptisée Array::toAngularRatios(), se charge de convertir un tableau de nombres « absolus » en ratios angulaires. Un ratio angulaire est l’équivalent d’un pourcentage (on utilise la somme des nombres comme valeur totale), à ceci près qu’il est rapporté à 360 (au lieu de 100). Cela correspond donc à l’angle, en degrés, représentant la tranche considérée.

La boucle principale de « Claquos !» — v. Document::createClaquos(...) — transmet successivement le ratio angulaire de chaque élément à Document::createQuartier(...), tout en incrémentant d’autant l’angle de rotation du quartier (à partir de zéro). Les tranches du camembert sont donc construites dans le sens trigonométrique (anti-horaire) à partir de l’angle nul.

Quelques modules complémentaires s’occupent de gérer les unités et le jeu de nuances. Une option permet notamment de produire un système de nuances de gris par pas de 10 % plutôt que d’utiliser les nuances du document actif.

Le camembert est positionné au centre de la page active et ses différents quartiers sont groupés par l’instruction :
app.activeWindow.activeSpread.groups.add(claquos) ;

Dorénavant, InDesign vous servira le fromage à la coupe !

Les instructions d’installation de « Claquos !» sont données en entête dans le script lui-même, Claquos.js, inclus dans ce fichier zip téléchargeable.

Ce programme est bien sûr en libre usage, mais n’oubliez pas d’indiquer la source et l’auteur si vous le mentionnez ou le réexploitez. Merci de signaler tout bug éventuel à l’adresse du rédacteur en chef.

Télécharger le script