Does arcpy have a way to determine if a data frame overlaps a page extent?

Question

I'm in the process of writing a script that will iterate through multiple MXDs and extract the data from layers that are turned on and only data that is within the data frame extent.

Some of the MXDs may have data frames that are not visible on the page. I don't want to extract the data from these data frames. So, I want to write a function that will test whether a data frame is within the page extent.

My first thought was to access the dimensions of the page layout using the page size property of the Map Document. Then I would iterate through each data frame and test the X and Y position and compare them to the page dimensions. In theory, this seemed like a good idea. However, I noticed that the positions change when the anchor point is changed.

Take the following example of an A4 page with four data frames. Two on the page and two off the page:

Focusing on the data frame on the left, I can see that it's off the page. When I look at the X position of the data frame, I can see that it is negative which seems to tell me that it is off the page.

Changing the anchor point, changes the X position:

and

I thought about adding the X position to the width. In the first example, when the anchor is set to bottom left, the X position plus the width is still negative, which would tell me that the data frame is off the page. However, if the anchor point is in the middle, or right, the sum of X position and width is positive, which would falsely indicate that the data frame is on the page.

This gets further complicated when the dataframe is partially overlapping the page. I also haven't gotten into the dataframe on the right or testing Y position, though the logic would be similar.

So, my question is, does there exist a method in arcpy to test if a data frame is on or overlaps a page extent?

I'm using ArcGIS Desktop 10.4.1 Basic.

Answer 1

The following script will a) detect if a data frame is definitely on the page, and b) detect if a data frame might be on the page, based on a page width + data frame width calculation.

import arcpy
mxd = arcpy.mapping.MapDocument("CURRENT")
dfs = arcpy.mapping.ListDataFrames(mxd)
pagewidth = round(mxd.pageSize.width, 2)
pageheight = round(mxd.pageSize.height, 2)

for df in dfs:
    if df.name != 'Layers':
        apx = df.elementPositionX
        apy = df.elementPositionY
        w = df.elementWidth
        h = df.elementHeight
        maxheightbuffer = pageheight + h
        minheightbuffer = 0 - h
        maxwidthbuffer = pagewidth + w
        minwidthbuffer = 0 - w
        i = 0
        if (apx > 0 and apx < pagewidth) or (apy > 0 and apy < pageheight):
            arcpy.AddWarning("Data frame {0} is on the page!!".format(df.name))
        else:
            if apx > minwidthbuffer and apx < maxwidthbuffer:
                i += 1
            if apy > minheightbuffer and apy < maxheightbuffer:
                i += 1
            if i == 2:
                arcpy.AddMessage("Data frame {0} is within page buffer".format(df.name))
            else:
                arcpy.AddMessage("Data frame {0} is OK".format(df.name))

It does this by adding a width buffer and a height buffer to the actual page size, and determining if the data frame element could be within that those buffers based on the anchor point position and width/height of the element.

It can determine whether the anchor point is definitely on the page (if elementPositionX or elementPositionY is between 0 and the page width or height then it's on the page), so will give a Warning message. If the anchor point isn't on the page, then it applies the buffer to determine whether it's possible that some part of the frame might be on the page.

• DF 'One' has anchor point bottom-left
• DF 'Two' bottom-right
• DF 'Three' bottom-left
• DF 'Four' bottom-right

Basically, to be sure you'd need each element to be at least the buffer width from the page. The script could be modified to enforce this fairly easily, but this example at least tells you of the possibility.