Matplotlib: Geschwindigkeitsproblem

[locutus]

Das mit dem Vorberechnen hatte ich mir auch gedacht, daher habe ich es so umgebaut:

Code: Alles auswählen

##### vorher alles gleich

def init():

    joint.set_data([], [])

    return [joint]


def animate(i):

    print i

    joint.set_data(array_out[i][0], array_out[i][1])
    if array_out[i][2] == 1:
        joint.set_color('g')
    elif array_out[i][2] == 2:
        joint.set_color('r')
    else:
        joint.set_color('w')

    return [joint]

array_out = []

#####

for i in range(t+2206, len(arm1[5, :])):

    array1 = np.amax(abs(arm1[:, i] - arm1[:, i - t]))
    array2 = np.amax(abs(arm2[:, i] - arm2[:, i - t]))

    if array1 > array2:
        ind = np.argmax(abs(arm1[:, i] - arm1[:, i - t]))
        joints_on = joint1
    else:
        ind = np.argmax(abs(arm2[:, i] - arm2[:, i - t]))
        joints_on = joint2

    if abs(arm1[ind, i] - arm1[ind, i - t]) >= mv1[ind] and abs(arm2[ind, i] - arm2[ind, i - t]) >= mv2[ind]:

        if (arm1[ind, i] - arm1[ind, i - t]) and (arm2[ind, i] - arm2[ind, i - t]) > 0:
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [1]

        elif (arm1[ind, i] - arm1[ind, i - t]) and (arm2[ind, i] - arm2[ind, i - t]) < 0:
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [1]

        elif (arm1[ind, i] - arm1[ind, i - t]) > 0 > (arm2[ind, i] - arm2[ind, i - t]):
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [1]

        else:
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [1]

    elif abs(arm1[ind, i] - arm1[ind, i - t]) >= mv1[ind]:

        if (arm1[ind, i] - arm1[ind, i - t]) > 0:
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [1]
        else:
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [2]

    elif abs(arm2[ind, i] - arm2[ind, i - t]) >= mv2[ind]:

        if (arm2[ind, i] - arm2[ind, i - t]) > 0:
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [1]
        else:
            array_out += [joints_on[ind][0]], [joints_on[ind][1]], [2]

    else:

        array_out += [joints_on[ind][0]], [joints_on[ind][1]], [0]

#####

array_out = np.reshape(array_out,(len(array_out)/3,3))

ani = animation.FuncAnimation(fig, animate, blit=True, init_func=init)

plt.show()

Mit zusätzlicher Funktion "vor = grün, zurück = rot", der Array ist auch schnell in 1-2 Sekunden fertig, die Frames der Animation sind aber ähnlich langsam wie vorher :-/
25 pro Sekunde wären schon klasse^^

[MagBen]

Mit Vorberechnet meinte ich eher sowas:

Code: Alles auswählen

def animate(i):
    return [joints[i]]

D.h. Du veränderst nicht die Line2D Objekte während der Animation, sonderst Du hast für jedes Frame ein eigenes Line2D Objekt.

[locutus]

ah, ok, verstehe, aber wie initialisiert man ein line2D object so, dass man darüber iterieren kann?
So allein kommt ja verständlicher Weise dann: "TypeError: 'Line2D' object does not support indexing"

Update: Also es liegt eigentlich nur an plt.show(), was das ganze langsam macht. Lasse ich es ungesehen durchrechnen, geht es ganz gut und die gespeicherte animation klappt dann auch.
Wenigstens das