Suche Elemente in zwei Arrays im angegebenen Bereich mit numpy.where()

Question

Ich arbeite mit großen Arrays von geophysikalischen Daten. Ich habe zwei numpy Arrays, die Größen 320 x 340 haben: erste XLAT enthält die Breite von jedem Punkt im Raster, die zweite XLON enthält die Länge von jedem Punkt im Raster. So beschreibt jeder i, j den Punkt auf dem Boden mit Breitengrad XLAT[i][j] und Längengrad XLON[i][j].

Ich habe Punkt mit Koordinaten P_LAT und P_LON und ich muss den nächsten 4 Punkt zum gegebenen Punkt finden.

Zuerst schrieb ich einfache Funktion, die durch alle Punkte auf X-Achse und Y-Achse laufen, aber es macht 320 * 340 = 108 800 Iterationen und funktioniert sehr sehr langsam (~ 0,5 Sekunden für jeden Punkt):

for i in range(0, lat-1): 
      for j in range(0, lon-1): 

        if ST_LON >= XLON[i][j] and \ 
          ST_LON < XLON[i][j + 1] and \ 
          ST_LAT >= XLAT[i][j] and \ 
          ST_LAT < XLAT[i + 1][j]: 
          return (True, i, i + 1, j, j + 1) 

Dann fand ich einige Informationen über numpy.where() und schrieb diesen Code:

for i in range(0, lat): 
      rows = numpy.where((XLON[i] >= ST_LON - 0.5) & (XLON[i] <= ST_LON + 0.5)) 

     for j in rows[0]: 
      if ST_LON >= XLON[i][j] and \ 
          ST_LON < XLON[i][j + 1] and \ 
          ST_LAT >= XLAT[i][j] and \ 
          ST_LAT < XLAT[i + 1][j]: 
       return (True, i, i + 1, j, j + 1) 

Diese Funktion ist viel schneller (~ 0,015 sec für jeden Punkt), aber ich glaube nicht, es ist das Recht und schöne Lösung.

So ist meine letzte Frage, wie kann ich die Elemente in beiden Feldern finden, die die Bedingungen erfüllen:

XLON[i] <= ST_LON <= XLON[i][j+1] und XLAT[i][j] <= ST_LAT <= XLAT[i+1][j]

und dies sollte schnell arbeiten?

Answer 1

Ich bin über die Programmieraufgabe nicht sicher, mich in meinen eigenen Worten wiederholen lassen:

Sie haben zwei 2dim Arrays XLAT und XLON. Sie sind eine Art von Übersetzungsanordnungen, um die Breite/Länge von einem Gitter zu erhalten.

aus dem Code Beispiele, die ich schließen: XLON [i] [j] == XLON [h] [j] ist gültig für alle i, h in Bereich (0, lat)?! (Vielleicht gibt es einen guten Grund, um das Objekt zu haben, aber es sieht nicht sehr performant)

So ist die einfachste Lösung sollte es sein, nur separat bieten Dimensionen zu behandeln:

for i in range(0, lat-1): 
    if (XLON[i][0] >= ST_LON - 0.5) & (XLON[i][0] <= ST_LON + 0.5): 
     break 
for j in range(0, lon-1): 
    if (XLAT[0][j] >= ST_LAT - 0.5) & (XLAT[0][j] <= ST_LAT + 0.5)): 
     break 
return (True, i, i + 1, j, j + 1) 

Sie können auch Ersetzen Sie die if-break-Anweisung durch np.where.

Ich bin mir nicht sicher, ob ich dich richtig verstanden habe. Wenn meine Antwort nicht hilft, wäre es sehr nützlich, uns einen kleinen funktionierenden Beispiel-Python-Code mit XLON, XLAT zu geben, der auf etwa 5x4 Dimensionen reduziert ist.

Answer 2

Dank für alle Antworten, fand ich eine schnelle Lösung numpy.where() mit großem Zustand verwendet wird, aber es ist ein bisschen nicht schön und nicht ästhetisch :)

#Calculate the step 
    dLAT = numpy.abs(self.XLON[0][1] - self.XLON[0][0]) * 3 
    dLON = numpy.abs(self.XLAT[1][0] - self.XLAT[0][0]) * 3 

    #Get the rows and cells satisfying the condition 
    rows, cells = numpy.where(((self.XLON >= ST_LON - dLON) & (self.XLON <= ST_LON + dLON)) & ((self.XLAT >= ST_LAT - dLAT) & (self.XLAT <= ST_LAT + dLAT))) 

    #Loop through all the values 
    for i in range(0, len(rows)): 

     #Get the indexes 
     current_lat = rows[i] 
     next_lat = rows[i] + 1 
     current_lon = cells[i] 
     next_lon = cells[i] + 1 

     #Check the point 
     if ST_LON >= self.XLON[current_lat][current_lon] and ST_LON < self.XLON[current_lat][next_lon] and \ 
      ST_LAT >= self.XLAT[current_lat][current_lon] and ST_LAT < self.XLAT[next_lat][current_lon]: 

      return(True, current_lat, next_lat, current_lon, next_lon) 

    return (False, 0, 0, 0, 0)