zum InDesign-Forum

Skriptfeed abonnieren

Login für Autoren

planePath.jsx (Pfadecken mildern per gleitendem Mittelwert)

von Stephan Möbius am 4.06.10 1:21 in Grafisches

planePath.jsx

Link zur Ursprungsdiskussion im Forum

Berechnet den (-->wikipedia) "Gleitenden Mittelwert" auf Pfadobjekte. Jeder Pfadpunkt wird auf den Mittelwert aus sich und seinen jeweiligen zwei Nachbarpunkten gesetzt. Das mildert Extremwerte in Pfaden und hobelt Ecken rund.

Beispielbilder siehe Ursprungsdiskussion.

Es komplementiert folgende Pfade-Scripte, 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.)

//***************************************************************************
// planePath.jsx   v.0.1
// Doing a 3rd order "running average" transformation on the selected path objects 
// Each pathpoint is moved to the average position of itself, its predecessor and successor point. Exception: First and Last Point in open paths cannot be calculated since they are missing predecessor or successor.

// An InDesign CS4 JavaScript
// Stephan Möbius, May 2010, contact [moebius@anymotion.de]

//***************************************************************************

// Can be used to smoothen a path, especially in combination with 
// "add_points.jsx" [adding new point inbetween each two given points]
// by running "planePath.jsx" and "add_points.jsx" several times. Experiment.

// Also good for creative use in combination with:
// "reducePath.jsx" [removing unnescessary vertices], 
// "scatterPath.jsx" [chaotically roughen a path by moving vertices up to a given random max amount]
// "smoothPath.jsx" [calculating smoother bezier handles to curve a path smoothly]

#target indesign
const planeAmount = 1.0;  // 0.1 = almost no shaving off; 1 = full averaging of points

main();

function PlanePath(myPath) {
	var myPathClosed = (myPath.pathType == PathType.CLOSED_PATH ? true : false);
	var myPathLength = myPath.pathPoints.length;
	var myPointArray = new Array();
	var myPoint, myPnLast, myPnLastX, myPnLastY, myPnNext, myPnNextX, myPnNextY, myNewPnX, myNewPnY, myPnDeltaX, myPnDeltaY, myNewPnRX, myNewPnRY, myNewPnLX, myNewPnLY;
	
	if (myPathClosed) {
		/* check for simple case */
		if ( myPathLength <= 3 ) 
			return(myPath.entirePath);    /* one or two points */
		for (var n = 0; n <= myPathLength-1; n ++){
			with (myPath.pathPoints.item(n)) {;			
				// left and right bezier handle of anchorpoints will _not_ be changed/smoothed. We do need them to move with their anchor point, so we need to move them the same amount as the anchor.
				// in fact i have no idea what to do with the bezier handles in order to get smooth correct results. Run a "smoothPath.jsx" aftterwards.
				switch(n) {
					case 0: 
						myPnLast = myPath.pathPoints.item(myPathLength-1);
						myPnNext = myPath.pathPoints.item(1);
						break;
					case myPathLength-1:
						myPnLast = myPath.pathPoints.item(myPathLength-2);
						myPnNext = myPath.pathPoints.item(0);
						break;
					default: 
						myPnLast = myPath.pathPoints.item(n-1); // the point before the current one		
						myPnNext = myPath.pathPoints.item(n+1); // the point after the current one
				}	
				myPnLastX = myPnLast.anchor[0];
				myPnLastY = myPnLast.anchor[1];		
				myPnNextX = myPnNext.anchor[0];
				myPnNextY = myPnNext.anchor[1];
				myNewPnX = (myPnLastX +  anchor[0] + myPnNextX)/3;  // we use a running average of 3rd order, so we calculate the center of 3 consecutive points
				myNewPnY = (myPnLastY + anchor[1] + myPnNextY)/3;		
				myPnDeltaX = anchor[0] - myNewPnX; // calculating the distance between old and new position - needed to move the bezier handles
				myPnDeltaY = anchor[1] - myNewPnY;
				
				myNewPnX += (1-planeAmount)*myPnDeltaX;
				myNewPnY += (1-planeAmount)*myPnDeltaY;
				
				myNewPnRX = rightDirection[0] - myPnDeltaX +  (1-planeAmount)*myPnDeltaX; // new left bezier handle position
				myNewPnRY = rightDirection[1] - myPnDeltaY +(1-planeAmount)*myPnDeltaY;
				myNewPnLX = leftDirection[0] - myPnDeltaX + (1-planeAmount)*myPnDeltaX;  // new right bezier handle position
				myNewPnLY = leftDirection[1] - myPnDeltaY+ (1-planeAmount)*myPnDeltaY;
				myPoint = [[myNewPnLX, myNewPnLY], [myNewPnX, myNewPnY], [myNewPnRX, myNewPnRY]];
			} // end with
			myPointArray.push(myPoint); // this point-array will be returned and given to "myPath.entirePath" in main
		} // end for
	}
	else {
		/* check for simple case */
		if ( myPathLength < 3 ) 
			return(myPath.entirePath);    /* one or two points */
		for (var n = 0; n <= myPathLength-1; n ++){
			with (myPath.pathPoints.item(n)) {;			
				if (n == 0 || n == myPathLength-1) {
					myPoint = [[leftDirection[0], leftDirection[1]], [anchor[0],  anchor[1]], [rightDirection[0], rightDirection[1]]];
				}
				else {
					myPnLast = myPath.pathPoints.item(n-1); // the point before the current one		
					myPnLastX = myPnLast.anchor[0];
					myPnLastY = myPnLast.anchor[1];		
					myPnNext = myPath.pathPoints.item(n+1); // the point after the current one		
					myPnNextX = myPnNext.anchor[0];
					myPnNextY = myPnNext.anchor[1];
					myNewPnX = (myPnLastX +  anchor[0] + myPnNextX)/3;  // we use a running average of 3rd order, so we calculate the center of 3 consecutive points
					myNewPnY = (myPnLastY + anchor[1] + myPnNextY)/3;		
					myPnDeltaX = anchor[0] - myNewPnX; // calculating the distance between old and new position - needed to move the bezier handles
					myPnDeltaY = anchor[1] - myNewPnY;
					myNewPnRX = rightDirection[0] - myPnDeltaX; // new left bezier handle position
					myNewPnRY = rightDirection[1] - myPnDeltaY;
					myNewPnLX = leftDirection[0] - myPnDeltaX;  // new right bezier handle position
					myNewPnLY = leftDirection[1] - myPnDeltaY;
					myPoint = [[myNewPnLX, myNewPnLY], [myNewPnX, myNewPnY], [myNewPnRX, myNewPnRY]];
				} // end if...else
			} // end with
			myPointArray.push(myPoint); // this point-array will be returned and given to "myPath.entirePath" in main
		} // end for
	} // end if else path closed
	return myPointArray;
}  // function PlanePath

function main(){
	//Make certain that user interaction (display of dialogs, etc.) is turned on.
	app.scriptPreferences.userInteractionLevel = UserInteractionLevels.interactWithAll;
	if (app.documents.length != 0){
		if (app.selection.length != 0){
			for(var n = 0; n < app.selection.length; n++){
				switch (app.selection[n].constructor.name){
					case "TextFrame":
					case "Rectangle":
					case "Oval":
					case "Polygon":
					case "GraphicLine":
						var myPaths = app.selection[n].paths
						for (var m = 0; m < myPaths.length; m++) { // for each of the paths in one selected object DO...
							var myPath = myPaths[m];
							myPath.entirePath = PlanePath(myPath);
						}
						break;
					default: alert ("Please select a rectangle, oval, polygon, or graphic line and try again.");
				} // end switch
			} // end for
		} else alert ("Please select an object and try again.");
	} else alert ("Please open a document, select an object, and try again.");
}

Skript ist lauffähig in:
InDesign Version CS4

Suche

Skriptkategorien

Letzte Skripte

Inhaltsverzeichnis