¿Minimizar el número de páginas dinámicas para mapear puntos dispersos usando ArcGIS Desktop?

De vez en cuando tengo que producir un libro de mapas para mostrar puntos de interés. Primer paso para crear páginas, utilizando mallas regulares:

No me gusta la solución porque a) hay algunas páginas con puntos únicos (por ejemplo, la página 25) en el borde yb) demasiadas páginas.

El primer problema es fácil de solucionar usando código; mueva el rectángulo de la extensión de la página al centro de la extensión de los puntos relevantes:

Todavía no me gusta, parece muy concurrido porque el número de páginas sigue siendo el mismo. ¡Recuerde, todos terminan siendo páginas de papel A3 reales en múltiples copias del informe!

Así que he cocinado un código que reduce el número de páginas. En este ejemplo de 45 a 34.

No estoy seguro de si este es el mejor resultado que se puede lograr,

¿Cuál es la mejor estrategia (pseudocódigo, publicación, biblioteca de Python) para barajar los puntos a fin de minimizar el número de rectángulos de tamaño dado para capturar todos los puntos? Seguramente, alguien lo descubrió en teoría de juegos, arte militar o industria pesquera

Esta es la actualización de la pregunta original:

Esto muestra la extensión real y el tamaño de página requerido:

Zoom más cercano que muestra 10 de 164 páginas:

Clase de entidad de punto de muestra

El tamaño del rectángulo puede cambiar tan pronto como se mantenga dentro de los límites, es decir, más pequeño está bien.

Esta no es la respuesta, solo pensé en publicar la solución Python para aquellos interesados:

# ---------------------------------------------------------------------------
# PAGE MAKER
# 
# ---------------------------------------------------------------------------
# Import arcpy module
import arcpy, traceback, os, sys
from arcpy import env

width=650
height=500

try:
    def showPyMessage():
            arcpy.AddMessage(str(time.ctime()) + " - " + message)
    mxd = arcpy.mapping.MapDocument("CURRENT")
    points = arcpy.mapping.ListLayers(mxd,"points")[0]
    pgons = arcpy.mapping.ListLayers(mxd,"pages")[0]

    g=arcpy.Geometry()
    geometryList=arcpy.CopyFeatures_management(points,g)
    geometryList=[p.firstPoint for p in geometryList]
    curT = arcpy.da.InsertCursor(pgons,"SHAPE@")
    while True:
        nPoints=len(geometryList)
        small=[geometryList.pop(0)]
        for p in geometryList:
            small.append(p)
            mPoint=arcpy.Multipoint(arcpy.Array(small))
            ext=mPoint.extent
            cHeight=ext.height
            cWidth=ext.width
            if cHeight>height or cWidth>width:
                small.remove(p)
        mPoint=arcpy.Multipoint(arcpy.Array(small))
        ext=mPoint.extent
        xC=(ext.XMin+ext.XMax)/2
        yC=(ext.YMin+ext.YMax)/2
        LL=arcpy.Point (xC-width/2,yC-height/2)
        UL=arcpy.Point (xC-width/2,yC+height/2)
        UR=arcpy.Point (xC+width/2,yC+height/2)
        LR=arcpy.Point (xC+width/2,yC-height/2)
        pgon=arcpy.Polygon(arcpy.Array([LL,UL,UR,LR]))
        curT.insertRow((pgon,))
        short=filter(lambda x: x not in small,geometryList)
        arcpy.AddMessage('Grabbed %i points, %i to go' %(len(small),len(short)))
        if len(short)==0: break
        geometryList=short[:]
    del mxd
except:
    message = "\n*** PYTHON ERRORS *** "; showPyMessage()
    message = "Python Traceback Info: " + traceback.format_tb(sys.exc_info()[2])[0]; showPyMessage()
    message = "Python Error Info: " +  str(sys.exc_type)+ ": " + str(sys.exc_value) + "\n"; showPyMessage()

lo aplicó últimamente para la planificación de encuestas:

ACTUALIZAR:

Parece que para algunos patrones tratar con puntos 'extraviados' primero es el camino a seguir. He utilizado la cáscara 'casco convexo' para identificarlos, idea de whuber, no puedo encontrar la publicación, lo siento.

Esto parece una versión geométrica del problema de cobertura máxima que está estrechamente relacionado con el problema de cobertura de conjunto , y esos dos son NP-Complete.

Entonces, para resolverlo, uno podría usar la aproximación. Intentaría el siguiente algoritmo y parece funcionar perfectamente. Aunque debido a la complejidad del problema, no podemos encontrar la mejor respuesta.

1. Cada punto genera N = 10 rectángulos en distancias aleatorias; solo para asegurarse de que el rectángulo cubra el punto (cada rectángulo tiene al menos un punto que le pertenece y cada punto pertenece al menos a un rectángulo)
2. Repita hasta que todos los puntos estén cubiertos: obtenga un rectángulo que cubra el número máximo de puntos descubiertos. Marque los puntos como cubiertos.

Una implementación de este algoritmo, solo para círculo, está aquí: http://jsfiddle.net/nwvao72r/3/