Graphic frame bounding box

Hi all,

In terms of bounding boxes the question could first be addressed as follows. To ensure that the parent container does not extend beyond the image area, it is sufficient to check that the parent inner box is contained within the image inner box. Which is satisfied if and only if each corner point of the parent box belongs to the child box. That specific problem can be solved very quickly using (u,v) coordinates of the respective boxes, without any transformation or Pathfinder operations.

However, the figure below shows that the condition, although sufficient, is not necessary:

Here we have a configuration where the child box does not contain the parent box (blue regions overlap) while the actual parent shape still entirely stands inside the child box. What would be great for addressing any possibility would be to handle the “in-child” box of the parent, that is, the visible bounding box of the parent framed in the perspective of the child coordinate space. Unfortunately, the DOM does not provide simple access to “in-child” boxes! One can access the in-parent box of the child, but not the in-child box of the parent :-(

Note. — At first you may think that checking the state of the in-parent box of the child relative to the parent inner box could be an indirect way of addressing the original problem. But this is definitely wrong. The figure below clearly shows that the in-parent box of the child can entirely contain the parent box while the polygonal shape extends beyond the image area.

So we need a workaround for really testing the parent shape bounding box seen in the perspective of the image space. (And, by the way, we need the visible box rather than the geometric box of the parent, in case rounded corners would be applied.)

Fortunately we have two interesting properties at hand. First, the fact of “extending beyond the image area” is invariant by any transformation. That is, if we transform the container in some way this doesn't change the state of the problem. Secondly, the whole image area by nature coincides with its inner box, which is a parallelogram in the perspective of the pasteboard. Therefore we can find a transformation T that, being applied to the parent, will change the image box into a rectangle in the pasteboard space. Then, we can consider the visible “in-board” box of the parent, that is, the rectangle that encloses the parent in the perspective of the pasteboard space. We know have two comparable rectangles Rchild and Rparent and the problem reduces to checking whether Rchild entirely contains Rparent.

The figure below summarizes the trick:

As usual, the implementation requires a “machine epsilon” (see my EPSILON constant) in order to prevent floating-point approximation errors which frequently occur in InDesign coordinate system. Here is the code I suggest:

const CS_BOARD = +CoordinateSpaces.pasteboardCoordinates,
      BB_VISIBLE = +BoundingBoxLimits.outerStrokeBounds,
      BB_PATH = +BoundingBoxLimits.geometricPathBounds;
const EPSILON = 1e-6;
var image = app.selection[0], // target image
    parent = image.parent;
// Temporarily transform the container so that its image (inner) box
// be a rectangle in the perspective of the pasteboard.
// ---
var origin = image.resolve([[.5,.5],BB_PATH],CS_BOARD)[0],
    mx = image.transformValuesOf(CS_BOARD)[0],
    T = app.transformationMatrices.add(1,1,-mx.clockwiseShearAngle,-mx.counterclockwiseRotationAngle);
parent.transform(CS_BOARD,origin,T);
// Retrieve image corners in board coord space.
// ---
var iTL = image.resolve([[0,0],BB_PATH],CS_BOARD)[0],
    iBR = image.resolve([[1,1],BB_PATH],CS_BOARD)[0];
// Retrieve parent *inboard box* corners in board coord space.
// ---
var pTL = parent.resolve([[0,0],BB_VISIBLE,CS_BOARD],CS_BOARD)[0],
    pBR = parent.resolve([[1,1],BB_VISIBLE,CS_BOARD],CS_BOARD)[0];
// Revert the transformation.
// ---
parent.transform(CS_BOARD,origin,T.invertMatrix());
// Check whether the rectangle <pTL,pBR> is included in <iTL,iBR>
// ---
var r = pTL[0] >= iTL[0]-EPSILON && pTL[1] >= iTL[1]-EPSILON
     && pBR[0] <= iBR[0]+EPSILON && pBR[1] <= iBR[1]+EPSILON;
alert( r ? 'OK' : 'KO' );

And a few test screenshots:

@+

Marc

See Check if two line segments intersect · GitHub

and Calculating the intersection of two lines. - JSFiddle

If the brown inner frame is bigger than the blue outer frame and the lines don't intersect then there's no empty space.

If they intersect only on a non extreme point like the corner of the blue frame or the tops etc. and the browns bigger that it encapsulates the blue one then there's no empty space

if the 2 frames don't intersect and are on different parts of the screen then there's a lot of empty space

Here's a start

javascript - Check if polygon is inside a polygon - Stack Overflow

HTH

Trevor