Best way to get a bounding polygon of all features in a file .gdb

Question

I have an arcpy script that dynamically creates a filegeodatabase and its featureclasses from uploaded spatial data, currently point and line features and possibly polygons in the future. I am interested in what is the best way to go about creating a polygon around the entire contents of the gdb.

Ideally, it would be perfect if I there was a way to do minimum boudning geometry on a set of feature classes, or an entire geodatabase, and maybe that is a thing somewhere that I am not seeing.

I have had success just calling that and creating polygons for each feature class, and then take the union of all the polygons for the geodatabase, however as the datasets get large that seems like it wouldn't be a very efficient way of handling it.

Another way I'm looking at right now is getting a list of all the points and doing a bounding geometry algorithm on them, furthermore just getting the min/max xy of each polygon and run it against a list of those.
It just seems like there is a tool or something that I'm not aware of that does this and would be a better way of solving the problem.

Answer 1

You could loop through all the feature classes in the gdb and use the minimum bounding geometry gp tool to create convex hull polys in memory and then run a final minimum bounding geometry process on all these polys. This is untested, but something like this may work:

import os, arcpy
def iter_ws(workspace, dataType='Any', ftype='ANY', wildcard='*'):
    '''Iterates through a workspace using arcpy.da.Walk

    valid data types can be found @:
        http://resources.arcgis.com/en/help/main/10.1/index.html#//018w00000023000000

    Required:
    workspace -- workspace to check for features

    Optional:
    dataType -- type of data to search for
    ftype -- feature and raster data types can be further filtered by this parameter
    wildcard -- wildcard for feature names
    '''

    # find top level features and rasters
    for dirpath, dirnames, filenames in arcpy.da.Walk(workspace,
                                                      datatype=dataType,
                                                      type=ftype):
        for name in filenames:
            feature = os.path.join(dirpath, name)
            if wildcard != '*':
                if fnmatch.fnmatch(feature, os.path.join(dirpath, wildcard)):
                    yield feature
            else:
                yield feature

def gdb_bb(gdb, output_polygon):
    polys = []
    for fc in iter_ws(gdb):
        tmp = r'in_memory\{0}_poly'.format(os.path.basename(fc))
        arcpy.MinimumBoundingGeometry_management(fc, tmp, "CONVEX_HULL", "ALL")
        polys.append(tmp)

    # merge polys
    merged = r'in_memory\merged'
    arcpy.Merge_management(polys, merged)

    # run convex hull again to create output
    arcpy.MinimumBoundingGeometry_management(merged, output_polygon, "CONVEX_HULL", "ALL")
    return output_polygon

if __name__ == '__main__':
    gdb = r'path\to\your.gdb'
    final = r'path\to\your.gdb\convex_hull'
    gdb_bb(gdb, final)

Answer 2

For a full geodatabase, a quick solution is to create a bounding polygon based on the extents of each feature class. Of course, I assume that all your feature classes are in the same coordinate system.

you can loop on the feature classes of the geodatabase, request the extent and store the min, max values in X and Y. something like below (same for Y)

minX = 1000000000
maxX = 0

for featureClass in featureClasses:
    if (minX > arcpy.describe(featureClass).extent.XMin):
        minX = arcpy.describe(featureClass).extent.XMin
    if (maxX < arcpy.describe(featureClass).extent.XMax):
        maxX = arcpy.describe(featureClass).extent.XMax