Hi @dimitri_cas, here is one approach—get the rotation from the placed item's matrix, then rotate it by that negative amount:
(function () {
var doc = app.activeDocument,
placedItem = doc.selection[0];
if (!placedItem)
return alert('Please select a placed item and try again.');
var sr = getLinkScaleAndRotation(placedItem),
scale = [sr[0], sr[1]],
rotation = sr[2];
placedItem.rotate(-rotation);
})();
/**
* Return the scale, rotation and size
* of a PlacedItem or RasterItem.
* @author m1b
* @version 2023-03-09
* @param {PlacedItem|RasterItem} item - an Illustrator item.
* @param {Boolean} round - whether to round numbers to nearest integer.
* @returns {Array} [scaleX%, scaleY%, rotation°, width, height]
*/
function getLinkScaleAndRotation(item, round) {
if (item == undefined)
return;
var m = item.matrix,
rotatedAmount,
unrotatedMatrix,
scaledAmount;
var flipPlacedItem = (item.typename == 'PlacedItem') ? 1 : -1;
try {
rotatedAmount = item.tags.getByName('BBAccumRotation').value * 180 / Math.PI;
} catch (error) {
rotatedAmount = 0;
}
unrotatedMatrix = app.concatenateRotationMatrix(m, rotatedAmount * flipPlacedItem);
if (
unrotatedMatrix.mValueA == 0
&& unrotatedMatrix.mValueB !== 0
&& unrotatedMatrix.mValueC !== 0
&& unrotatedMatrix.mValueD == 0
)
scaledAmount = [unrotatedMatrix.mValueB * 100, unrotatedMatrix.mValueC * -100 * flipPlacedItem];
else
scaledAmount = [unrotatedMatrix.mValueA * 100, unrotatedMatrix.mValueD * -100 * flipPlacedItem];
if (scaledAmount[0] == 0 || scaledAmount[1] == 0)
return;
if (round)
return [round(scaledAmount[0]), round(scaledAmount[1]), round(rotatedAmount)];
else
return [scaledAmount[0], scaledAmount[1], rotatedAmount];
};
There are other ways, eg. read the rotation value from a tag:
rotatedAmount = item.tags.getByName('BBAccumRotation').value * 180 / Math.PI;
I also wrote a function that derives the rotation value by minimizing the area of the rectangular bounds of the item:
/**
* Returns the rotation amount in degrees
* that the item needs to be rotated such
* that it has a minimal bounding box area.
* Assuming that `item` is a rectangular
* object, such as a PlacedItem, RasterItem
* or a rectangular path item, the resulting
* rotation will rotate it so that the sides
* of the rectangle align to a factor of 90°.
* In other words, it will return the value
* required to "unrotate" the item.
* @author m1b
* @version 2023-08-25
* @param {PageItem} item - an Illustrator page item.
* @returns {Number}
*/
function findRotationByMinimalBounds(item) {
// we will rotate a copy and leave the original
var workingItem = item.duplicate(),
convergenceThreshold = 0.001,
inc = 45, // the starting rotation increment
rotationAmount = 0,
prevArea = area(workingItem);
while (Math.abs(inc) >= convergenceThreshold) {
workingItem.rotate(inc);
var newArea = area(workingItem);
if (newArea < prevArea) {
prevArea = newArea;
rotationAmount -= inc;
inc *= 0.5;
}
else {
workingItem.rotate(-inc); // Undo the last rotation
inc *= -0.5;
}
}
// clean up
workingItem.remove();
return round(rotationAmount, 2);
/**
* Returns area of bounding box of `item`.
* @param {PageItem} item
* @returns {Number}
*/
function area(item) {
return item.width * item.height;
};
};
/**
* Rounds `n` to `places` decimal places.
* @param {Number} n - the number to round
* @param {Number} places - number of decimal places, can be negative
* @returns {Number}
*/
function round(n, places) {
var m = Math.pow(10, places != undefined ? places : 3);
return Math.round(n * m) / m;
};
Each method has pros and cons. I suggest you try the first approach first and see how you go. It only works with an unskewed matrix. The second approach only works if the tag exists, and no rotations have been performed without updating it. The third option is probably the most robust but is a bit slower.
- Mark
1 Correct answer
22
Replies
AdChoices