get layer bounds incorrect with layer.bounds

After some time thinking, I figure out a way to get the accurate bounds of the vector layer. using path point.

as the api layer.bounds would rounding the x,y coordinate, which make the result unexpected, but path point contains double value, like this:

197.228464419476,197.021301498127

287.228464419476,197.021301498127

292.228464419476,202.021301498127

292.228464419476,292.021301498127

287.228464419476,297.021301498127

197.228464419476,297.021301498127

192.228464419476,292.021301498127

192.228464419476,202.021301498127

So all I need is to find the min x, max x, min y and max y through these path points, here is my solution code:

first check if the snap option uncheck or not

Document.prototype.snapToPixelGridEnabled = function()
{
    var ref = new ActionReference();
    ref.putProperty(charIDToTypeID('Prpr'), charIDToTypeID('GnrP'));
    ref.putEnumerated(charIDToTypeID('capp'), charIDToTypeID('Ordn'), charIDToTypeID('Trgt'));
    var desc = executeActionGet(ref);
    var gnrp = desc.getObjectValue(charIDToTypeID('GnrP'));
    return gnrp.getBoolean(stringIDToTypeID('transformsSnapToPixels'));
};

and parse the path point of the vector layer:

Layer.prototype.getVectorBound = function()
{
    if (!this.isSolidFill()) {
        console_debug("is not solid fill layer");
        return -1;
    }
    var name = this.getName();
    try {
        var doc = app.activeDocument;
        var pathItem = null;
        for (var i= 0, len = doc.pathItems.length; i < len; i++) {
            var p = doc.pathItems;

            if (p.name.indexOf(name) > -1) {
                pathItem = p;
                break;
            }
        }
        if (pathItem != null && pathItem.subPathItems.length > 0) {
            var subItem = pathItem.subPathItems[0];
            if (subItem.closed && subItem.pathPoints.length > 0) {
                return getBounds(subItem.pathPoints);
            }
        }

        return Rect.zeroRect();
    } catch (e) {
        console_debug("err: " + e.toString());
        return Rect.zeroRect();
    }

    function getBounds(points) {
        var left = right = points[0].anchor[0];
        var top = bottom = points[0].anchor[1];
        for (var i=1; i<points.length; i++) {
            var x = points.anchor[0];

            var y = points.anchor[1];

            if (x < left) { left = x; }
            if (x > right) { right = x; }
            if (y < top) { top = y; }
            if (y > bottom) { bottom = y; }
        }
        console_debug(left + "," + right + "," + top + "," + bottom);
        return new Rect(left, top, Math.round(right - left), Math.round(bottom - top));
    }
};

at last I got what I want.

It may be rounding. It may also be that when Photoshop files that shape with pixels it may do some anti-aliasing. I just tride a shapr the had a inner 1 px stroke. Snap to on with center guide lines.

// enable double-clicking from Mac Finder or Windows Explorer

#target photoshop // this command only works in Photoshop CS2 and higher

// bring application forward for double-click events

app.bringToFront();

// Save the current preferences

var startRulerUnits = app.preferences.rulerUnits;

// Set Photoshop to use pixels

app.preferences.rulerUnits = Units.PIXELS;

var LB = activeDocument.activeLayer.bounds;

var LWidth = (LB[2].value) - (LB[0].value);

var LHeight = (LB[3].value) - (LB[1].value);

alert("'" + activeDocument.activeLayer.name + "' Layer Bounds\nTop Left " +  LB[0].value + "X," +  LB[1].value + "Y   Bottom Right "  +  LB[2].value + "X," +  LB[3].value

  + "Y\nWidth " +  LWidth + "px   Height " + LHeight +"px"

  + "\nLayer center relative to canvas " + (LB[0].value + LWidth/2) + "X," +  (LB[1].value + LHeight/2) +"Y" );

// Return the app preferences

app.preferences.rulerUnits = startRulerUnits;