Raster am besten speichern!

[capgeti]

Hallo.

Ich habe eine Liste.
Jedes Element daraus ist wieder eine Liste. Sozusagen ein 2d Array.

Das Gute ist ich kann so drauf zu greifen:

Code: Alles auswählen

obj = raster[x][y]

In dieser form und mit zwei schleifen kann ich auch die 8 nachbarfelder dieses feldes hohlen.

Code: Alles auswählen

for x in range(-1,2):
    for y in range(-1,2):
        obj = range[x][y]

Jetzt weis ich aber nicht wie performant das ganze ist. Da es mir aber sehr darauf ankommt ist jetzt meine frage ob es nicht vielleicht doch besser ist ein Objekt mit rekursion zu benutzen.

Code: Alles auswählen

class RasterField:
    def __init__(self, lo, o, ro, l, r, lu, u, ru)
        self.lo = lo
        self.o = o
        ....

So hab ich ein Feld und alle Nachbarfelder. Das dumme ist, das ich nicht mehr an ein einzelnes rankomme.

Habt ihr eine Idee was das beste ist um solch eine Struktur zu speichern, wo man aber auch noch schnell zugreifen kann?

lg

[lutz.horn]

Schau Dir mal http://numpy.scipy.org/ an, da findest Du auch Matrix-Operationen.

[capgeti]

mhm.-... ob es wirklicht schneller ist?

Oder ist es vllt noch besser die ganze brechnung in c auszulagern?

edit: das ist ja cool
http://www.scipy.org/PerformancePython

[lutz.horn]

Hast Du NumPy mal angeschaut?

[Rebecca]

Hint: Die "Getting Started"-Seite sagt ein paar interessante Dinge ueber NumPy, Geschwindigkeit und C...

[capgeti]

Ja, scheint wirklich schneller zu sein =)
Mal sehen wie es sich bei mir verhält.
Ich werd das heut abend mal ausprobieren und mich dann wieder melden.

Danke für eure schnelle hilfe.

[sma]

Ob's schnell genug ist oder nicht, kann nur ein Benchmark im konkreten Anwendungsfall sagen, niemals eine allgemeine Beschreibung. Bevor ich mir eine Extrabibliothek als Abhängigkeit an's Bein binde, würde ich's erst mal mit Bordmitteln versuchen.

Hier ist ein Beispiel:

Code: Alles auswählen

class Field:
    def __init__(self, width, height):
        self.width, self.height = width, height
        self.values = [[None] * width for x in range(height)]
    
    def __getitem__(self, x, y):
        self._check(x, y)
        return self.values[x + self.width * y]

    def neighbors(self, x, y):
        self._check(x, y)
        for yy in range(max(0, y - 1), min(self.height, y + 2)):
            for xx in range(max(0, x - 1), min(self.width, x + 2)):
                yield self[x, y]
    
    def _check(self, x, y):
        if x < 0 or x >= self.width: raise IndexError("x")
        if y < 0 or y >= self.height: raise IndexError("y")

Dann geht:

Code: Alles auswählen

field = Field(10, 10)
for f in field.neighbors(3, 4):
    print f

Direkte Referenzen auf die 8 Nachbarfelder würde ich nicht speichern, da es die Initialisierung so aufwendig macht. Wenn man jedoch nicht extra immer über das 2D-Array gehen möchte, sondern wenn es für den Anwendungsfall besser scheint, eine verkettete Topologie aus Einzelzellen aufzubauen, dann kann das eine Lösung sein.

Stefan