• Small Javascript to reset to "zero" the rotate value of a placed item.

Hi @dimitri_cas, you are already well on your way to a solution, but I just remembered that I did a similar thing in a previous script I wrote. Maybe you could look at it and see if it sheds any light on the problem.

- Mark

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