def step_with_redraw():
    smoother = graph.mesh_smoothing_tool(zero_points, [400, 20, 7, 2])
    for i in range(50):
        single_step(trace_engine,
                    2e-6,
                    2e-6,
                    .9,
                    lens.parameters,
                    optimizer,
                    None,
                    grad_clip=1e-3)
def training_routine():
    parameter_history = []
    print("starting training routine.")
    start_time = time.time()

    def save_history():
        parameter_history.append((lens.surfaces[0].parameters.numpy(),
                                  lens.surfaces[1].parameters.numpy()))

    smoother = graph.mesh_smoothing_tool(zero_points, [300, 50, 20, 10, 5])
    for i in range(75):
        single_step(trace_engine,
                    5e-7,
                    5e-7,
                    .8,
                    lens.parameters,
                    optimizer,
                    accumulator,
                    grad_clip=1e-3)
        smooth(lens.surfaces[0], smoother)
        smooth(lens.surfaces[1], smoother)
        if i % 10 == 0:
            simple_trace_redraw()
            save_history()
        first_drawer.draw()

    smoother = graph.mesh_smoothing_tool(zero_points, [400, 40, 15, 5, 2])
    for i in range(50):
        single_step(trace_engine,
                    1e-5,
                    1e-5,
                    .9,
                    lens.parameters,
                    optimizer,
                    None,
                    grad_clip=1e-3)
        smooth(lens.surfaces[0], smoother)
        smooth(lens.surfaces[1], smoother)
        if i % 10 == 0:
            simple_trace_redraw()
            save_history()
        first_drawer.draw()

    for i in range(50):
        single_step(trace_engine,
                    2e-6,
                    2e-6,
                    .95,
                    lens.parameters,
                    optimizer,
                    None,
                    grad_clip=1e-3)
        if i % 10 == 0:
            simple_trace_redraw()
            save_history()
        first_drawer.draw()

    with open("./stl/saved_parameters.dat", 'wb') as outFile:
        pickle.dump(parameter_history, outFile, pickle.HIGHEST_PROTOCOL)

    end_time = time.time()
    print(f"Completed training routine.  Took {end_time-start_time} seconds.")
    """
    set_momentum(momentum)
    grads, error = process_gradient(engine, lr1, lr2, parameters, grad_clip,
                                    accumulator)
    print(f"step {optimizer.iterations.numpy()} error: {error.numpy()}")
    optimizer.apply_gradients([(grads[0], parameters[0]),
                               (grads[1], parameters[1])])


optimizer = tf.optimizers.SGD(learning_rate=1.0,
                              momentum=momentum.get_value(),
                              nesterov=True)

# draw the rays
drawer = drawing.RayDrawer3D(plot)
smoother = graph.mesh_smoothing_tool(zero_points, [300, 50, 20, 10, 5])


def step_with_redraw():
    smoother = graph.mesh_smoothing_tool(zero_points, [400, 20, 7, 2])
    for i in range(50):
        single_step(trace_engine,
                    2e-6,
                    2e-6,
                    .9,
                    lens.parameters,
                    optimizer,
                    None,
                    grad_clip=1e-3)
        #smooth(lens.surfaces[0], smoother)
        #smooth(lens.surfaces[1], smoother)