Minimizar o número de páginas dinâmicas para mapear pontos dispersos usando o ArcGIS Desktop?

De tempos em tempos eu tenho que produzir um livro de mapas para mostrar pontos de interesse. Primeiro passo para criar páginas, usando malha regular:

Não gosto da solução porque: a) há algumas páginas com pontos únicos (por exemplo, página 25) na borda eb) muitas páginas.

É fácil corrigir o primeiro problema usando o código, - mova o retângulo da extensão da página para o centro da extensão dos pontos relevantes:

Ainda não gosto, parece muito lotado porque o número de páginas permanece o mesmo. Lembre-se, todos eles acabam sendo páginas em papel A3 reais em várias cópias do relatório!

Então, eu criei um código que reduz o número de páginas. Neste exemplo, de 45 a 34.

Não tenho certeza se esse é o melhor resultado que pode ser alcançado,

Qual é a melhor estratégia (pseudo-código, publicação, biblioteca Python) para embaralhar os pontos, a fim de minimizar o número de retângulos de determinado tamanho e capturar todos os pontos? Certamente, alguém o descobriu na teoria dos jogos, arte militar ou indústria pesqueira

Esta é a atualização para a pergunta original:

Isso mostra a extensão real e o tamanho da página necessários:

Zoom mais próximo mostrando 10 de 164 páginas:

Classe de recurso de ponto de amostra

O tamanho do retângulo pode mudar assim que permanecer dentro dos limites, ou seja, menor é bom.

Esta não é a resposta, eu apenas pensei em postar uma solução Python para quem se interessasse:

# ---------------------------------------------------------------------------
# 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()

aplicou-o recentemente para o planejamento de pesquisas:

ATUALIZAR:

Parece que, para alguns padrões, lidar primeiro com pontos "perdidos" é o caminho a percorrer. Eu usei a casca 'casco convexo' para identificá-los, ideia de whuber, não consigo encontrar post, desculpe.

Parece uma versão geométrica do problema de cobertura máxima, que está intimamente relacionada ao problema de cobertura de conjunto , e esses dois são NP-Complete.

Então, para resolvê-lo, pode-se usar aproximação. Eu tentaria o seguinte algoritmo e parece funcionar perfeitamente. Embora, devido à complexidade do problema, não possamos encontrar a melhor resposta.

1. O ponto Foreach gera N = 10 retângulos em distâncias aleatórias; apenas para garantir que o retângulo cubra o ponto (cada retângulo possui pelo menos um ponto e pertence a pelo menos um retângulo)
2. Repita até que todos os pontos estejam cobertos: obtenha um retângulo cobrindo o número máximo de pontos descobertos. Marque os pontos como cobertos.

uma implementação desse algoritmo, apenas para circle, está aqui: http://jsfiddle.net/nwvao72r/3/