indesign-script - scatterPath.jsx (Pfade aufrauen)

Verschiebt die einzelnen Pfadpunkte gewählter Pfadobjekte per Zufall innerhalb vom User wählbaren Grenzen. Gut zum anecken und aufrauen von Pfaden.

Es komplementiert folgende Pfade-Skripte, die sich alle prima im Mix und in Verbindung mit addPoints.jsx anwenden lassen:

reducePath.jsx - entfernen überflüssiger Pfadpunkte unter Beibehaltung der generelle Form = Pfad vereinfachen.
smoothPath.jsx - berechnen von "Bezier-Handles" für die Pfadpunkte, sodass die Kurve weich durch ihre Punkte fließt.
scatterPath.jsx - Pfade aufrauhen, verzerren.
planePath.jsx - Mittelwert zwischen den Pfadpunkten berechnen und so Extremwerte abmildern. Hobelt Ecken rund.
(addPoints.jsx - von Adobe mitgeliefert. Fügt zwischen jede zwei Pfadpunkte einen Pfadpunkt in der Mitte ein.)

// ScatterPath.jsx   v.0.1
// An InDesign CS4 JavaScript

// Randomizes the position of the points of selected path objects. The bezier handles are not touched. (Too much math for my head).
// Best used with small values. Use "addPoints.jsx" from the Adobe example scripts to play around.

#target indesign

main();
function main(){
	//Make certain that user interaction (display of dialogs, etc.) is turned on.
	app.scriptPreferences.userInteractionLevel = UserInteractionLevels.interactWithAll;
	var myObjectList = new Array;
	if (app.documents.length != 0){
		if (app.selection.length != 0){

for(var myCounter = 0;myCounter < app.selection.length; myCounter++){
				switch (app.selection[myCounter].constructor.name){
					case "TextFrame":
					case "Rectangle":
					case "Oval":
					case "Polygon":
					case "GraphicLine":
						myObjectList.push(app.selection[myCounter]);
						break;
				}
			}
			if (myObjectList.length != 0){
				myDisplayDialog(myObjectList);
			}
			else{
				alert ("Please select a rectangle, oval, polygon, or graphic line and try again.");
			}
		}
		else{
			alert ("Please select an object and try again.");
		}
	}
	else{
		alert ("Please open a document, select an object, and try again.");
	}
}

function getUnit(mu) {
	var str = new String;
	switch (mu) {
		case MeasurementUnits.AGATES: str = "ag"; break;
		case MeasurementUnits.CENTIMETERS: str = "cm"; break;
		case MeasurementUnits.CICEROS: str = "ci"; break;
		case MeasurementUnits.CUSTOM: str = "cstm"; break;
		case MeasurementUnits.INCHES: str = "in"; break;
		case MeasurementUnits.INCHES_DECIMAL: str = "in"; break;
		case MeasurementUnits.MILLIMETERS: str = "mm"; break;
		case MeasurementUnits.PICAS: str = "pc"; break;
		case MeasurementUnits.POINTS: str = "pt"; break;
	}
	return str;
}

function myPathEffect(myObjectList, myTransX, myTransY){
	var myPathPoint, myAnchor, myX, myY, myX1, myY1, myRX1, myRY1, myLX1, myLY1, myRndTransX, myRndTransY, myPoint, myPathPoint, myPointArray
	for (var myObjectCounter = 0; myObjectCounter < myObjectList.length; myObjectCounter++){
		var myObject = myObjectList[myObjectCounter];
		var myBounds = myObject.geometricBounds;
		var myXCenter = myBounds[1] + ((myBounds[3] - myBounds[1]) / 2);
		var myYCenter = myBounds[0] + ((myBounds[2] - myBounds[0]) / 2);

for(var myPathCounter = 0; myPathCounter < myObject.paths.length; myPathCounter ++){
			var myPath = myObject.paths.item(myPathCounter);
			var myPointArray = new Array(myPath.pathPoints.length);
			for (var myPathPointCounter = 0; myPathPointCounter < myPath.pathPoints.length; myPathPointCounter ++){
				myPathPoint = myPath.pathPoints.item(myPathPointCounter);
				
				myAnchor = myPathPoint.anchor;
				myRightDirection = myPathPoint.rightDirection;
				myLeftDirection = myPathPoint.leftDirection;
				
				myX1 = myAnchor[0];
				myY1 = myAnchor[1];
				myRX1 = myRightDirection[0];
				myRY1 = myRightDirection[1];
				myLX1 = myLeftDirection[0];
				myLY1 = myLeftDirection[1];
				
				myRndTransX = 2*((Math.random()*myTransX)-0.5*myTransX);
				myRndTransY = 2*((Math.random()*myTransY)-0.5*myTransY);
				
				myX =  myRndTransX + myX1;
				myY =  myRndTransY + myY1;

myRX = myRndTransX + myRX1;
				myRY = myRndTransY + myRY1;
				myLX = myRndTransX+ myLX1;
				myLY = myRndTransY + myLY1;
	
				myPoint = [[myLX, myLY], [myX, myY], [myRX, myRY]];

myPointArray[myPathPointCounter] = myPoint;
			}
			myPath.entirePath = myPointArray;
		}
	}
}