indesign-script - smoothPath.jsx (weiche Bezier-Punkte berechnen)

Berechnet "weiche" Bezier-Handles für die Pfadpunkte der gewählten Pfadobjekte. Die Weichheit ist einstellbar und die Kurve fliesst mehr oder minder weich durch alle Punkte.

Weichheit 0 entfernt alle Bezier-Handles, macht den Pfad eckig. Der Algorithmus ist jedoch keine Cubic Spline Interpolation und die Ergebnisse in vielen Fällen nicht so weich wie erwartet.

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.)

// smoothPath.jsx - 0.0.1
// Smoothes the vertices by giving them smooth bezier control handles. Note: it's _not_ a true quadratic or cubic  spline interpolation.

#target indesign
var  smooth = prompt ("Smooth value of 1 gives smoothest results. Smooth 1.05 on a square gives a circle. Smooth value of 0 retracts all bezier handles:" , 1 , "smoothPath 0.0.1" );

// Smoothing algorithm taken from here: http://www.antigrain.com/research/bezier_interpolation/index.html
// Smooth value of 1 gives smoothest results. Smooth 1.05 on a square gives a circle. Smooth value of 0 retracts all bezier handles.

// Often you will need to reduce the paths beforehand and remove superflous vertices - use "reducePath.jsx"
// If you'd like a user interface to enter values, with the added ability to reduce the paths, preview the smoothing,  and undo smoothing  try "smoothPathUI.jsx"
// This script works here in Adobe InDesign CS4 6.0.4 (german)(windows XP) - I can't test it anywhere else.

// KNOWN ISSUES
// - doesn't work with any groups selected, because i am too lazy
// - will not smooth the last vertex in open paths

// kind regards,
// Stephan Möbius

for (var n = 0; n < app.selection.length; n++) { // for each selected object DO...
	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 = smoothPath(myPath, smooth);
	} 
}

function smoothPath(myPath, smooth_value) {
	var myPathClosed = (myPath.pathType == PathType.CLOSED_PATH ? true : false);
	var myPointArray = new Array;
	var myLast, myThis, myNext, mySecondNext = new Number; 
	
	// put all PathPoints of this path into an array to work with
	for (var i = 0; i < myPath.pathPoints.length; i ++){ 
		with (myPath.pathPoints[i])
			myPointArray.push([[leftDirection[0], leftDirection[1]], [anchor[0], anchor[1]], [rightDirection[0], rightDirection[1]]]);
	}
	for (var i = 0; i < myPointArray.length; i++) { 
		myThis = i;
		myLast = (i-1) % myPointArray.length + (i-1>=0 ? 0 : myPointArray.length); // for negative results of modulo, add 1*length to be in the positive range
		myNext = (i+1) % myPointArray.length;
		mySecondNext = (i+2) % myPointArray.length;
		
		xc1 = (myPointArray[myLast][1][0] + myPointArray[myThis][1][0]) / 2.0;
		yc1 = (myPointArray[myLast][1][1] + myPointArray[myThis][1][1]) / 2.0;
		xc2 = (myPointArray[myThis][1][0] + myPointArray[myNext][1][0]) / 2.0;
		yc2 = (myPointArray[myThis][1][1] + myPointArray[myNext][1][1]) / 2.0;
		xc3 = (myPointArray[myNext][1][0] + myPointArray[mySecondNext][1][0]) / 2.0;
		yc3 = (myPointArray[myNext][1][1] + myPointArray[mySecondNext][1][1]) / 2.0;

len1 = Math.sqrt((myPointArray[myThis][1][0]-myPointArray[myLast][1][0]) * (myPointArray[myThis][1][0]-myPointArray[myLast][1][0]) + (myPointArray[myThis][1][1]-myPointArray[myLast][1][1]) * (myPointArray[myThis][1][1]-myPointArray[myLast][1][1]));
		len2 = Math.sqrt((myPointArray[myNext][1][0]-myPointArray[myThis][1][0]) * (myPointArray[myNext][1][0]-myPointArray[myThis][1][0]) + (myPointArray[myNext][1][1]-myPointArray[myThis][1][1]) * (myPointArray[myNext][1][1]-myPointArray[myThis][1][1]));
		len3 = Math.sqrt((myPointArray[mySecondNext][1][0]-myPointArray[myNext][1][0]) * (myPointArray[mySecondNext][1][0]-myPointArray[myNext][1][0]) + (myPointArray[mySecondNext][1][1]-myPointArray[myNext][1][1]) * (myPointArray[mySecondNext][1][1]-myPointArray[myNext][1][1]));

k1 = len1 / (len1 + len2);
		k2 = len2 / (len2 + len3);

xm1 = xc1 + (xc2 - xc1) * k1;
		ym1 = yc1 + (yc2 - yc1) * k1;
		xm2 = xc2 + (xc3 - xc2) * k2;
		ym2 = yc2 + (yc3 - yc2) * k2;

ctrl1_x = xm1 + (xc2 - xm1) * smooth_value + myPointArray[myThis][1][0] - xm1;
		ctrl1_y = ym1 + (yc2 - ym1) * smooth_value + myPointArray[myThis][1][1] - ym1;
		ctrl2_x = xm2 + (xc2 - xm2) * smooth_value + myPointArray[myNext][1][0] - xm2;
		ctrl2_y = ym2 + (yc2 - ym2) * smooth_value + myPointArray[myNext][1][1] - ym2;

if (myPathClosed) {
			myPointArray[myThis][2][0] = ctrl1_x;
			myPointArray[myThis][2][1] = ctrl1_y;
			myPointArray[myNext][0][0] = ctrl2_x;
			myPointArray[myNext][0][1] = ctrl2_y;
		}
		else { // if path is open then don't give the start and endpoints any beziercontrols they don't have already
			if (myThis != 0 && myThis != myPointArray.length-1) {
				myPointArray[myThis][2][0] = ctrl1_x;
				myPointArray[myThis][2][1] = ctrl1_y;
			}
			if (myThis != myPointArray.length-1 && myThis != myPointArray.length-2) {
				myPointArray[myNext][0][0] = ctrl2_x;
				myPointArray[myNext][0][1] = ctrl2_y;
			}
		}
	} // end of FOR each point in path
	return myPointArray;
}