ich habe eine Look-Up-Table geschrieben, die Positionen mit Informationen versieht, die ein Roboter theoretisch anfahren kann. Der Roboter kann sich 6-dimensional im Raum bewegen (3 translatorsche Freiheitsgrade X,Y,Z und drei rotatorische Xe, Ye, Ze). Es handelt sich aslo um ein 6 dimensionales Array. Die Informationen können sein: gültige Position (="0") oder ungegültige Postion (eine Zahl<32678, die aus addierten Binärzahlen besteht, die codiert die Gründe für das Nicht-Erreichen dieser Position wiedergeben.
Da die Datenmenge der look-up-table möglichst gering sein soll, habe ich beschlossen, Bereiche und nicht genaue Positionen mit Werten zu versehen.
Der unten stehende Code funktioniert fehlerfrei, nur ist er extrem unprofessionel, und ich möchte euch bitten mir zu helfen ihn effizienter und professioner zu gestalten.
Der Code soll die Lookuptable auslesen und sagen, ob die Input-Position gültig oder ungültig ist.
Die Look-up-table besteht aus zwei Teilen: der rough_matrix und der detailed_matrix. Die rough_matrix beschreibt Bereiche, die man sich als 6-dimensionale Würfel mit einer Kantenlänge von 8 Einheiten vorstellen kann. Jeder dieser Würfel ist entweder komplett mit Gültigen Positionen im Inneren versehen(Eintrag "0"), ungültig("addierte Binärzahl<32768) oder liegt im Grenzbereich und hat also im Inneren gültige und ungültige Positionen. Wenn, dass der fall ist, wird dieser Würfel mit einer Adresse deklariert (Eine Zahl>=32768), die auf eine Stelle in der detailed_matrix verweist. Die detailed_matrix ist ein 7-dimensionales array, da sie noch eine Spalte für die Adresse benötigt. Unter jeder Adresse wird der 8er Würfel in 64 kleiner Würfel aufgeteilt, die eine Kantenlänge von 4 Einheiten haben, die wiederrum gültig/ungültig oder im grenzbereich liegen. 4er Würfel im Grenzbereich werden wiederum mit Adressen deklariert, die auf eine Stelle in der detailed_matrix verweisen, die den 4er Würfel in 64 kleiner Wüfel mit 2 Einheiten kantenlänge unterteilen und die neue deklarieren.
Das klingt alles sehr abstrakt, ich weiß. Hoffe ihr könnt mir trotzdem weiterhelfen. Danke!
Code: Alles auswählen
import vtk
def check_position():
xs = x.get()
ys = y.get()
zs = z.get()
xes = xe.get()
yes = ye.get()
zes = ze.get()
input = (float(xs), float(ys), float(zs), float(xes), float(yes), float(zes))
#definierte Bereiche (von, bis)
X = (-16, 17)
Y = (-8, 57)
Z = (-16, 17)
Xe = (-64, 65)
Ye = (-16, 17)
Ze = (-16, 49)
#python listen statt numpy arrays, damit index() funktioniert
x_array = numpy.arange(X[0], X[1], 8)
x_list = x_array.tolist()
y_array = numpy.arange(Y[0], Y[1], 8)
y_list = y_array.tolist()
z_array = numpy.arange(Z[0], Z[1], 8)
z_list = z_array.tolist()
xe_array = numpy.arange (Xe[0], Xe[1], 8)
xe_list = xe_array.tolist()
ye_array = numpy.arange(Ye[0], Ye[1], 8)
ye_list = ye_array.tolist()
ze_array = numpy.arange(Ze[0], Ze[1], 8)
ze_list = ze_array.tolist()
#inputzahlen auf durch 8 teilbare zahl abrunden, da diese 8er Wuerfel deklarieren
input_floored_8 = []
for i in range(0, len(input)):
input_floored_8.append(8 * math.floor (input[i] / 8))
print input_floored_8
#index in listen suchen
xindex = x_list.index(input_floored_8[0])
yindex = y_list.index(input_floored_8[1])
zindex = z_list.index(input_floored_8[2])
xeindex = xe_list.index(input_floored_8[3])
yeindex = ye_list.index(input_floored_8[4])
zeindex = ze_list.index(input_floored_8[5])
if rough_matrix[xindex][yindex][zindex][xeindex][yeindex][zeindex] < 32768:
if rough_matrix[xindex][yindex][zindex][xeindex][yeindex][zeindex] == 0:
print input, "is reachable"
else:
print input, "is not reachable, Reason: ", rough_matrix[xindex][yindex][zindex][xeindex][yeindex][zeindex]
else:
print "4mm/4degree solution necessary"
address = int(rough_matrix[xindex][yindex][zindex][xeindex][yeindex][zeindex] - 32768)
input_floored_4 = []
for i in range(0, len(input)):
input_floored_4.append(4 * math.floor (input[i] / 4))
print "4mm/4degree coordinates: ", input_floored_4
if input_floored_4[0] == input_floored_8[0]:
x0 = 0
else:
x0 = 1
if input_floored_4[1] == input_floored_8[1]:
y0 = 0
else:
y0 = 1
if input_floored_4[2] == input_floored_8[2]:
z0 = 0
else:
z0 = 1
if input_floored_4[3] == input_floored_8[3]:
xe0 = 0
else:
xe0 = 1
if input_floored_4[4] == input_floored_8[4]:
ye0 = 0
else:
ye0 = 1
if input_floored_4[5] == input_floored_8[5]:
ze0 = 0
else:
ze0 = 1
if detailed_matrix[address][x0][y0][z0][xe0][ye0][ze0] < 32768:
if detailed_matrix[address][x0][y0][z0][xe0][ye0][ze0] == 0:
print input, "is reachable"
else:
print input, "is not reachable, Reason: ", detailed_matrix[address][x0][y0][z0][xe0][ye0][ze0]
else:
print "2mm/2degree solution necessary!"
address = int(detailed_matrix[address][x0][y0][z0][xe0][ye0][ze0] - 32768)
input_floored_2 = []
for i in range(0, len(input)):
input_floored_2.append(2 * math.floor (input[i] / 2))
print "2mm/2degree cube-coordinates: ", input_floored_2
if input_floored_2[0] == input_floored_4[0]:
x0 = 0
else:
x0 = 1
if input_floored_2[1] == input_floored_4[1]:
y0 = 0
else:
y0 = 1
if input_floored_2[2] == input_floored_4[2]:
z0 = 0
else:
z0 = 1
if input_floored_2[3] == input_floored_4[3]:
xe0 = 0
else:
xe0 = 1
if input_floored_2[4] == input_floored_4[4]:
ye0 = 0
else:
ye0 = 1
if input_floored_2[5] == input_floored_4[5]:
ze0 = 0
else:
ze0 = 1
if detailed_matrix[address][x0][y0][z0][xe0][ye0][ze0] == 0:
print input, "is reachable"
else:
print input, "is not reachable, Reason: ", detailed_matrix[address][x0][y0][z0][xe0][ye0][ze0]
print "_____________________________________"
) und die possible_ranges wären in meinen Augen Konstanten die ich man durch GROSSBUCHSTABEN bei der Namensgebung kennzeichnet. Da könnte man dann schauen ob man diese Konstanten nicht lieber an einer Zentralen Stelle definiert. "input" ist keine gute Idee für eine Variable, weil damit die interne Funktion input() überschrieben wird und die meisten Programmierer wohl mit einer Eingabe an dieser Stelle rechnen.
, abgerundet(0,0), was den Indexen [2,2] entspricht. Also steht wegen des Grenzbereichs in der rough_matrix an Stelle [2][2] zum Beispiel "32786" , eine Adresse. Ich gehe also in die detailed_matrix an der Stelle 32786-32786=0, wo 4 Würfel mit Kantenlänge 4 definiert sind. (Bei 6 Dimensionen wären es 64 Würfel). Die detailed_matrix ist so aufgebaut [adresse-32768][x][y] wobei x und y nur die Werte 0 oder 1 annehmen können. Die Position liegt hier bei [0][1][0] und im grenzbereich, also gibt es für die Position auch eine 2mm Auflösung und eine neue Adresse steht an dieser Stelle in der detailed_matrix( detailed_matrix[0][1][0]=32787). Dann suche ich an dieser Stelle der detailedmatrix nach dem richtigen x,y (hier (0,0) und erhalte die Information, dass die Eingabeposition nicht erreichbar ist.