Minimierung der Anzahl dynamischer Seiten zum Zuordnen verstreuter Punkte mit ArcGIS Desktop?

Von Zeit zu Zeit muss ich ein Kartenbuch erstellen, um Sehenswürdigkeiten zu zeigen. Erster Schritt zum Erstellen von Seiten mit regulären Maschen:

Die Lösung gefällt mir nicht, weil a) einige Seiten mit einzelnen Punkten (z. B. Seite 25) am Rand sitzen und b) zu viele Seiten.

Das erste Problem lässt sich einfach mit Code beheben. - Verschieben Sie das Rechteck der Seitenausdehnung in die Mitte der relevanten Punktausdehnung:

Ich mag es immer noch nicht, es sieht sehr voll aus, weil die Anzahl der Seiten gleich bleibt. Denken Sie daran, dass es sich bei allen um tatsächliche A3-Papierseiten in mehreren Kopien des Berichts handelt!

Also habe ich einen Code gekocht, der die Anzahl der Seiten reduziert. In diesem Beispiel von 45 bis 34.

Ich bin mir nicht sicher, ob dies das beste Ergebnis ist, das erzielt werden kann.

Was ist die beste Strategie (Pseudocode, Veröffentlichung, Python-Bibliothek), um durch Punkte zu mischen, um die Anzahl der Rechtecke mit der angegebenen Größe zu minimieren und alle Punkte zu erfassen? Sicherlich hat es jemand in der Spieltheorie, der Militärkunst oder der Fischereiindustrie entdeckt

Dies ist eine Aktualisierung der ursprünglichen Frage:

Dies zeigt den tatsächlichen Umfang und die erforderliche Seitengröße:

Näherer Zoom mit 10 von 164 Seiten:

Beispielpunkt-Feature-Class

Die Rechteckgröße kann sich ändern, sobald sie innerhalb der Grenzen bleibt, dh kleiner ist in Ordnung.

Dies ist nicht die Antwort, ich dachte nur, ich poste eine Python-Lösung für diejenigen, die interessiert sind:

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

hat es kürzlich für die Umfrageplanung angewendet:

AKTUALISIEREN:

Es scheint, dass für einige Muster, die sich zuerst mit Streupunkten befassen, der richtige Weg ist. Ich habe 'Convex Hull'-Peeling verwendet, um sie zu identifizieren, Idee von Whuber, kann keinen Beitrag finden, sorry.

Dies sieht aus wie eine geometrische Version des Problems der maximalen Abdeckung, die eng mit dem Problem der festgelegten Abdeckung zusammenhängt , und diese beiden sind NP-vollständig.

Um es zu lösen, könnte man eine Annäherung verwenden. Ich würde den folgenden Algorithmus ausprobieren und er scheint perfekt zu funktionieren. Obwohl wir aufgrund der Komplexität des Problems nicht die beste Antwort finden können.

1. Für jeden Punkt werden N = 10 Rechtecke in zufälligen Abständen erzeugt. Nur um sicherzustellen, dass das Rechteck den Punkt abdeckt (jedes Rechteck hat mindestens einen Punkt und jeder Punkt gehört mindestens einem Rechteck).
2. Wiederholen, bis alle Punkte abgedeckt sind: Holen Sie sich ein Rechteck, das die maximale Anzahl nicht abgedeckter Punkte abdeckt. Punkte als abgedeckt markieren.

Eine Implementierung dieses Algorithmus nur für Circle finden Sie hier: http://jsfiddle.net/nwvao72r/3/