Minimiser le nombre de pages dynamiques pour cartographier les points dispersés à l'aide d'ArcGIS Desktop?

De temps en temps, je dois produire un cartographe pour montrer les points d'intérêt. Première étape pour créer des pages, en utilisant un maillage régulier:

Je n'aime pas la solution car a) il y a des pages avec des points uniques (par exemple la page 25) assis sur le bord et b) trop de pages.

Le premier problème est facile à résoudre en utilisant du code, - déplacez le rectangle de l'étendue de la page au centre de l'étendue des points pertinents:

Je n'aime toujours pas ça, ça a l'air très encombré car le nombre de pages reste le même. N'oubliez pas, ils finissent tous par être de véritables pages papier A3 en plusieurs exemplaires du rapport!.

J'ai donc préparé un code qui réduit le nombre de pages. Dans cet exemple de 45 à 34.

Je ne sais pas si c'est le meilleur résultat qui puisse être obtenu,

Quelle est la meilleure stratégie (pseudo-code, publication, bibliothèque Python) pour parcourir les points afin de minimiser le nombre de rectangles de taille donnée pour capturer tous les points? Certes, quelqu'un l'a découvert dans la théorie des jeux, l'art militaire ou l'industrie de la pêche

Ceci est une mise à jour de la question d'origine:

Cela montre l'étendue réelle et la taille de page requises:

Zoom rapproché affichant 10 pages sur 164:

Exemple de classe d'entités ponctuelles

La taille du rectangle peut changer dès qu'il reste dans les limites, c'est-à-dire que plus petit est bien.

Ce n'est pas la réponse, je pensais juste publier une solution Python pour ceux qui seraient intéressés:

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

l'a appliqué récemment pour la planification de l'enquête:

METTRE À JOUR:

Il semble que pour certains modèles traitant des points «errants», la première voie à suivre. J'ai utilisé le pelage de la coque convexe pour les identifier, idée de whuber, impossible de trouver le message, désolé.

Cela ressemble à une version géométrique du problème de couverture maximale qui est étroitement liée au problème de couverture définie , et ces deux sont NP-Complete.

Donc, pour le résoudre, on pourrait utiliser l'approximation. J'essaierais l'algorithme suivant et il semble fonctionner parfaitement. Bien qu'en raison de la complexité du problème, nous ne pouvons pas trouver la meilleure réponse.

1. Chaque point génère N = 10 rectangles à des distances aléatoires; juste pour s'assurer que le rectangle couvre le point (chaque rectangle a au moins un point lui appartient et chaque point appartient à au moins un rectangle)
2. Répétez jusqu'à ce que tous les points soient couverts: obtenez un rectangle couvrant le nombre maximum de points non couverts. Marquez les points comme couverts.

une implémentation de cet algorithme, uniquement pour le cercle, est ici: http://jsfiddle.net/nwvao72r/3/