from tensorflow import keras
from . import model

def train(filename):

def train(monitor, filename):

    print(source.seed())

    training_data = model.training_data(source)
    monitor.target.fit(x=training_data[0], y=training_data[1], batch_size=100, epochs=250, callbacks=monitor)

    bg_thread = threading.Thread(target=train, args=(sys.argv[1],), kwargs={})

    m = model.model()
    m.compile(
            optimizer=keras.optimizers.RMSprop(),
            loss=keras.losses.MeanSquaredError()
            )
    monitor = model.Monitor(m)
    bg_thread = threading.Thread(target=train, args=(monitor, sys.argv[1]), kwargs={})

    drawmap.run()

    drawmap.run(monitor)

def run():

def run(monitor):

  test_tensor = tf.math.scalar_mul(255, tf.keras.activations.sigmoid(inputs_equirectangular(1024, 512)))
  image = tensor_to_surface(test_tensor)
  sdl2.SDL_BlitSurface(image, None, windowsurface, None)

  inputs = tf.reshape(inputs_equirectangular(1024, 512), (1024 * 512, 3))

  sdl2.SDL_FreeSurface(image)

      outputs = monitor.snapshot()(inputs)
      outputs = tf.math.multiply(255, tf.reshape(outputs, (512, 1024, outputs.shape[1])))
      image = tensor_to_surface(outputs)
      sdl2.SDL_BlitSurface(image, None, windowsurface, None)

      sdl2.SDL_FreeSurface(image)

    return helpers.render_tensor(ctypes.c_void_p(tf.cast(source, tf.uint8).numpy().ctypes.data), ctypes.c_int(shape[1]), ctypes.c_int(shape[0]), ctypes.c_int(shape[2]))

    source = tf.cast(source, tf.uint8).numpy()
    return helpers.render_tensor(ctypes.c_void_p(source.ctypes.data), ctypes.c_int(shape[1]), ctypes.c_int(shape[0]), ctypes.c_int(shape[2]))

import tensorflow as tf
from tensorflow import keras
import threading
def model():
    inputs = keras.Input(shape=(3,))
    layer = keras.layers.Dense(9, activation=tf.math.asinh)(inputs)
    layer = keras.layers.Dense(24, activation=tf.math.asinh)(layer)
    layer = keras.layers.Dense(240, activation=tf.math.asinh)(layer)
    layer = keras.layers.Dense(240, activation=tf.math.asinh)(layer)
    layer = keras.layers.Dense(24, activation=tf.math.asinh)(layer)
    outputs = keras.layers.Dense(1, activation=keras.activations.sigmoid)(layer)
    return keras.Model(inputs=inputs, outputs=outputs, name="geology_model")
def training_data(simresult):
    return (simresult.vertices, tf.math.multiply(1/700000000, simresult.crust_layers['total']))
def clone_my_model(source):
    custom_objects = {"asinh": tf.math.asinh}
    with keras.utils.custom_object_scope(custom_objects):
        return keras.models.clone_model(source)
class Monitor(keras.callbacks.Callback):
    def __init__(self, target):
        self.lock = threading.Lock()
        self.target = target
        self.stable = clone_my_model(target)
    def on_epoch_end(self, epoch, logs=None):
        self.lock.acquire()
        self.stable.set_weights(self.target.get_weights())
        self.lock.release()
    def snapshot(self):
        self.lock.acquire()
        result = self.stable
        self.lock.release()
        return result