Accuracy of rotating images in Photoshop

Here's something that might be fun. I modified a script that I use to place shapes. it measures the angle between two reference dots. So to use this script, you need to create a group with the name "Orig" - capitalize the "O." in this group, create two round shape layers - best to draw one then copy it. Shape layers won't degrade if you keep changing image size. Move one of the shape dots while holding the shift key, just to keep them aligned. if you want, you can draw a line between the two dots, just for ease of viewing, but the line has to be on the bottom of the layer stack in the group. Now duplicate the group, and leave the name as "Orig copy." Rotate the copy group with transform, then run the script. It should alert you to how much the one group was moved. The results do vary depending on the size of the file, and are slightly off from what scriptlistener says the rotation was. Here's a screen shot of my setup:

Here's the script:

#target photoshop
var doc = activeDocument;

var origGp = doc.layers.getByName('Orig');
var moveGp = doc.layers.getByName('Orig copy');
var origPt1 = getRefPoints(origGp.layers[0]);
var origPt2 = getRefPoints(origGp.layers[1]);
var movePt1 = getRefPoints(moveGp.layers[0]);
var movePt2 = getRefPoints(moveGp.layers[1]);

var ang1 = getAng (movePt1[0], movePt1[1], movePt2[0], movePt2[1])+270
var ang2 = getAng (origPt1[0], origPt1[1], origPt2[0], origPt2[1])+270
alert (ang2-ang1)


function getRefPoints(ref){
    var x = (ref.bounds[0].value + ref.bounds[2].value)/2
    var y = (ref.bounds[1].value + ref.bounds[3].value)/2
    var pt = new Array(x,y)
    return pt
    }

 function getAng(x1,y1,x2,y2){
     
     var deltaX = x2-x1
     var deltaY = y2-y1
     //var theta = Math.atan2 (deltaY, deltaX)
     var angGA = (Math.atan2 (deltaY, deltaX))*-180 /Math.PI

     return angGA
     }

That's right. The accuracy obviously depends on the resolution. The more pixels, the more accurate, as Lumigraphics' 4x4 example clearly demonstrates.

It depends on the size of the image. Rotate a 4x4 pixel image 10 degrees and let me know how that works out for you.

If you know how to do geometry and trig, you can easily calculate how far a given pixel moves for a specific rotation. I bet Mathematica could give you an accuracy level based on image size. Also remember that you don't have to use square pixels.

desc9.putUnitDouble (idAngl, idAng, 10.000001)

then you will see that the result is different (use the difference mode enhanced by leves to see the result).

So it turns quite accurately.
A third-party program may rotate according to a different algorithm, therefore, it believes that the original image is rotated to a slightly different angle.

Here is an example of using ScriptListener to read the rotation angle. I used Transform to capture the info. The angle measurement is the 4th line from the bottom.

// =======================================================
var idTrnf = charIDToTypeID( "Trnf" );
    var desc9 = new ActionDescriptor();
    var idnull = charIDToTypeID( "null" );
        var ref1 = new ActionReference();
        var idPath = charIDToTypeID( "Path" );
        var idOrdn = charIDToTypeID( "Ordn" );
        var idTrgt = charIDToTypeID( "Trgt" );
        ref1.putEnumerated( idPath, idOrdn, idTrgt );
    desc9.putReference( idnull, ref1 );
    var idFTcs = charIDToTypeID( "FTcs" );
    var idQCSt = charIDToTypeID( "QCSt" );
    var idQcsa = charIDToTypeID( "Qcsa" );
    desc9.putEnumerated( idFTcs, idQCSt, idQcsa );
    var idOfst = charIDToTypeID( "Ofst" );
        var desc10 = new ActionDescriptor();
        var idHrzn = charIDToTypeID( "Hrzn" );
        var idPxl = charIDToTypeID( "#Pxl" );
        desc10.putUnitDouble( idHrzn, idPxl, 0.000000 );
        var idVrtc = charIDToTypeID( "Vrtc" );
        var idPxl = charIDToTypeID( "#Pxl" );
        desc10.putUnitDouble( idVrtc, idPxl, 0.000000 );
    var idOfst = charIDToTypeID( "Ofst" );
    desc9.putObject( idOfst, idOfst, desc10 );
    var idAngl = charIDToTypeID( "Angl" );
    var idAng = charIDToTypeID( "#Ang" );
    desc9.putUnitDouble( idAngl, idAng, 23.008041 );
    var idLnkd = charIDToTypeID( "Lnkd" );
    desc9.putBoolean( idLnkd, true );
executeAction( idTrnf, desc9, DialogModes.NO );

That is quite a few places.  Interpolation play a big part.  Nearest neighbor is crude so it will demonstrate well. Here I created  small image and zoomed in then rotate 4 degrees them added . with every decimal value I entered the image interpolation changed Photoshop precision is good. The interpretation method used does not try to anti-alas or smooth in any way.

ScriptListener plugin records your rotation

example

d.putUnitDouble(stringIDToTypeID("angle"), stringIDToTypeID("angleUnit"), 7.25380180288289);

How good the rotation will be I believe would be more  a matter of how many pixels you for your for the image lots of pixels foe a high resolution print and the interpretation method you use for the image's content. In the transform you can move the rotation point and the angle you enter can be to several decimals places.  Your rotating square pixels and the resulting image will have square pixels that are squared to the canvas the images has to be interpolated. Image content will rotate off  canvas and some  areas of the canvas will not have image content.