Speed-up von Koordinaten Suche
Verfasst: Samstag 6. Juni 2020, 10:41
Hallo,
ich habe einen Code geschrieben, der bei größeren Datenmengen zu langsam ist und bräuchte Anregungen wie ich diesen schneller machen kann.
Zu dem Code:
Ich trenne mit OpenCv dunkle von hellen Pixeln und schreibe die x-y-Koordinaten der dunklen Pixel in eine Liste. Diese Liste importiere ich dann in meinen "Problem Code". In diesem Teil soll die Liste so sortiert werden, dass die Liste möglichst meanderförmig von unten nach oben abgefahren werden. Das funktioniert für kleine Bilder (also kurze Listen) auch sehr gut. Bei größeren Bildern (also langen Listen) funktioniert das ebenfalls, dauert aber zu lange. Ich hoffe man kann sich das Problem vorstellen, würde gerne ein Bild der turtle Simulation hochladen, das geht aber nicht.
Die CPU Auslastung befindet sich aber die ganze Zeit bei ca. 25%. D.h. der Code läuft nur über einen von 4 Kerne des Prozessors (?)
Mein Idee wären:
1.) numpy zu verwenden, weil das schneller sein soll als Python Listen (stimmt das?)
2.) Multiprocessoring zu verwenden. Da weiß ich allerdings nicht welche Programmteile ich parallel laufen lassen könnte.
Über ein paar Anregungen wäre ich dankbar.
Hier der Code:
ich habe einen Code geschrieben, der bei größeren Datenmengen zu langsam ist und bräuchte Anregungen wie ich diesen schneller machen kann.
Zu dem Code:
Ich trenne mit OpenCv dunkle von hellen Pixeln und schreibe die x-y-Koordinaten der dunklen Pixel in eine Liste. Diese Liste importiere ich dann in meinen "Problem Code". In diesem Teil soll die Liste so sortiert werden, dass die Liste möglichst meanderförmig von unten nach oben abgefahren werden. Das funktioniert für kleine Bilder (also kurze Listen) auch sehr gut. Bei größeren Bildern (also langen Listen) funktioniert das ebenfalls, dauert aber zu lange. Ich hoffe man kann sich das Problem vorstellen, würde gerne ein Bild der turtle Simulation hochladen, das geht aber nicht.
Die CPU Auslastung befindet sich aber die ganze Zeit bei ca. 25%. D.h. der Code läuft nur über einen von 4 Kerne des Prozessors (?)
Mein Idee wären:
1.) numpy zu verwenden, weil das schneller sein soll als Python Listen (stimmt das?)
2.) Multiprocessoring zu verwenden. Da weiß ich allerdings nicht welche Programmteile ich parallel laufen lassen könnte.
Über ein paar Anregungen wäre ich dankbar.
Hier der Code:
Code: Alles auswählen
from pixelfinder_v_iii import koo_list, height, width
import time
start = time.perf_counter()
def find_neigbors(koo_list):
potential_neighbors = []
neighbors_work = []
for j in range(len(koo_list)):
x_coordinate = koo_list[j][0]
y_coordinate = koo_list[j][1]
potential_neighbors.append((x_coordinate + 1, y_coordinate))
potential_neighbors.append((x_coordinate - 1, y_coordinate))
potential_neighbors.append((x_coordinate, y_coordinate + 1))
#potentail_neighbors.append((x_coordinate+1, y_coordinate + 1))
#potential_neighbors.append((x_coordinate -1, y_coordinate + 1))
for i in range(len(potential_neighbors)):
if potential_neighbors[i] in koo_list:
neighbors_work.append(koo_list.index((potential_neighbors[i])))
neighbors.append(tuple(neighbors_work))
neighbors_work.clear()
potential_neighbors.clear()
return neighbors
def startpoints(coordinates_work_list, height, width):
kleinste_y = height
potential_startpoints = []
for i in range(len(coordinates_work_list)):
aktuelle_y = coordinates_work_list[i][1]
if aktuelle_y < kleinste_y:
kleinste_y = aktuelle_y
potential_startpoints.clear()
potential_startpoints.append(coordinates_work_list[i])
elif aktuelle_y == kleinste_y:
potential_startpoints.append(coordinates_work_list[i])
kleinste_x = width
for i in range(len(potential_startpoints)):
aktuelle_x = potential_startpoints[i][0]
if aktuelle_x < kleinste_x:
kleinste_x = aktuelle_x
return ((kleinste_x,kleinste_y))
def search_for_neighbor(neigbors, used_coordinates):
for i in range(len(neigbors)):
if neigbors[i] not in used_coordinates:
return neigbors[i]
pass;
print("Ab hier beginnt der pathfinder")
neighbors = []
neighbors = find_neigbors(koo_list)
used_coordinates = []
path_work = []
path = []
coordinates_work_list = koo_list
while len(used_coordinates) < len(koo_list):
startpunkt = (startpoints(coordinates_work_list, height, width))
path_work.append(koo_list.index(startpunkt))
used_coordinates.append(koo_list.index(startpunkt))
while True:
next_point = (search_for_neighbor(neighbors[used_coordinates[-1]], used_coordinates))
if next_point != None:
used_coordinates.append(next_point)
path_work.append(next_point)
else:
break;
path.append(tuple(path_work))
coordinates_work_list = []
for j in range((len(koo_list))):
if j not in used_coordinates:
coordinates_work_list.append(koo_list[j])
path_work.clear()
print(path)
finish = time.perf_counter()
print(f"abgeschlossen in {round(finish-start,2)} Sekunden")