Ridurre al minimo il numero di pagine dinamiche per mappare punti sparsi usando ArcGIS Desktop?

Di tanto in tanto devo produrre un mapbook per mostrare i punti di interesse. Primo passo per creare pagine, usando la mesh regolare:

Non mi piace la soluzione perché a) ci sono alcune pagine con punti singoli (es. Pagina 25) seduti sul bordo eb) troppe pagine.

Il primo problema è facile da risolvere usando il codice, - sposta il rettangolo dell'estensione della pagina al centro dell'estensione dei punti rilevanti:

Non mi piace ancora, sembra molto affollato perché il numero di pagine rimane lo stesso. Ricorda, finiscono per essere pagine di carta A3 reali in più copie del rapporto!

Quindi ho preparato un codice che riduce il numero di pagine. In questo esempio da 45 a 34.

Non sono sicuro che questo sia il miglior risultato che si possa ottenere,

Qual è la migliore strategia (pseudo codice, pubblicazione, libreria Python) per mescolare i punti al fine di ridurre al minimo il numero di rettangoli di dimensioni specifiche per acquisire tutti i punti? Sicuramente qualcuno l'ha scoperto nella teoria dei giochi, nell'arte militare o nell'industria della pesca

Questo è l'aggiornamento alla domanda originale:

Ciò mostra l'estensione reale e le dimensioni della pagina richieste:

Zoom più vicino che mostra 10 pagine su 164:

Classe caratteristica punto campione

Le dimensioni del rettangolo possono cambiare non appena rimangono entro i limiti, vale a dire che più piccolo va bene.

Questa non è la risposta, ho pensato di pubblicare la soluzione Python per coloro che erano interessati:

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

recentemente applicato per la pianificazione del sondaggio:

AGGIORNARE:

Sembra che per alcuni schemi che si occupano prima di tutto di punti "vaganti" sia la strada da percorrere. Ho usato la buccia 'scafo convesso' per identificarli, idea di whuber, non riesco a trovare posta, scusa.

Questa sembra una versione geometrica del problema di copertura massima che è strettamente correlata al problema di copertura dell'insieme e quei due sono NP-completi.

Quindi, per risolverlo, si potrebbe usare l'approssimazione. Vorrei provare il seguente algoritmo e sembra funzionare perfettamente. Sebbene a causa della complessità del problema, non possiamo trovare la risposta migliore.

1. Ogni punto foreach genera N = 10 rettangoli a distanze casuali; solo per assicurarsi che il rettangolo copra il punto (ogni rettangolo ha almeno un punto ad esso e ogni punto appartiene ad almeno un rettangolo)
2. Ripeti fino a quando tutti i punti sono coperti: ottieni un rettangolo che copre il numero massimo di punti scoperti. Segna i punti come coperti.

un'implementazione di questo algoritmo, solo per Circle, è qui: http://jsfiddle.net/nwvao72r/3/