LJ/plugins/aurora/aurora.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# -*- mode: Python -*-

'''

Aurora interactive installation

Quoi pour debut fin ?
Dependre du tempo gstt.currentbpm 

LICENCE : CC
Sam Neurohack



CCs Aurora Style

#              0         1         2          3        4       5           6           7
encoders = ['steps', 'stepmax','lineSize','radius','Xcoord','Ycoord', 'Xrotdirec','Zrotdirec']

    layer = int(args[0])
    number = int(args[1])
    value = int(args[2])

    ccs[layer][number] = value


Xcoord = 114    # /translator/X/amt 
Ycoord = 118    # /translator/Y/amt 
Zcoord = 122    # /translator/Z/amt 
        
scandots = 138  # /points/number 
scale= 98       # /scaler/scale is Artnet 98
        
Xrotdirec = 102 # /rotator/X/direct
Yrotdirec = 106 # /rotator/Y/direct
Zrotdirec = 110 # /rotator/Z/direct
        
rotspeed = 100  # /rotator/X/speed 
        
color
run
    
step
steps
stepmax
stepvals
        
lineSize
radius
intensity = 92 # /intensity/freq

# /aurora/transpeed layernumber axe transpeed

# /aurora/transamt layernumber axe maxposition



 LINK

  - bpm 

  - beatnumber -> Event
 

 MIDI  

 - cc : channel = layer / ccnumber = steps / ccvalue = stepmax -> /aurora/cc channel ccnumber ccvalue
 
 - notes

 if midi.sync :

 - midix.bpm
 
 - start -> /aurora/start
 
 - stop  -> /aurora/stop
 
 - clock -> /aurora/clock


 OSC 

 - /aurora/scim layernumber
 
 - /aurora/amp  layer side axe amp

 - /aurora/cc layer steps stepmax

 - /aurora/color/layername colorname

 - /aurora/fx/layernumber fxname ("ScanH", "ScanV", "Wave", "Circle", "Dot00", "Zero", "Maxwell", "Starfield", "Trckr", "Word")

 - /aurora/intensity layernumber intensity

 - /aurora/linesize layer value

 - /aurora/noteoff layer note

                    33 (B0) ScanH / 35 (B0) ScanV / 24 (C0) Wave / 26 (D0) Circle
 - /aurora/noteon layer note velocity

 - /aurora/part partname

 - /aurora/radius layernumber value

 - /aurora/rawcc layer encoder value (to change given encoder parameter ie 0 = steps)

                        X 102 Y 106 Z 110
 - /aurora/rotdirec layernumber axe rotdirec
                          X 100 Y 104 Z 108
 - /aurora/rotspeed layernumber axe speed

                        Scale 98
 - /aurora/scale layer value

                        X 114 Y 118 Z 122
 - /aurora/transamt layernumber axe maxposition 

 - /aurora/transpeed layernumber axe transpeed

 - /aurora/trckr/frame layernumber framenumber points

 - /aurora/x/layernumber coord (0-1)
 - /aurora/xcoord layernumber coord

 - /aurora/y/layernumber coord (0-1)
 - /aurora/ycoord layernumber coord

 - /aurora/word/layernumber word

mode ALIGN

mode LIVE

mode SONG

'''

import math
import numpy as np
import pdb
from datetime import datetime
from random import randrange
import redis
import sys
import ast
import os
import time,traceback
import midix
import log

ljpath = r'%s' % os.getcwd().replace('\\','/')

# import from shell
sys.path.append(ljpath +'/../../libs3/')
sys.path.append(ljpath +'/../libs3/')

#import from LJ
sys.path.append(ljpath +'/libs3/')

sys.path.append('../libs3')
sys.path.append(ljpath +'/../../libs3')

import gstt

is_py2 = sys.version[0] == '2'
if is_py2:
    from OSC import OSCServer, OSCClient, OSCMessage
else:
    from OSC3 import OSCServer, OSCClient, OSCMessage

import lj23layers as lj
import argparse

print()
log.infog("Aurora v0.1b")

OSCinPort = 8090
ljscene = 0

StartFXs = ["anim.Starfield","anim.Starfield","anim.Starfield", "anim.Word"]

# Useful variables init.
white = lj.rgb2int(255,255,255)
red = lj.rgb2int(255,0,0)
blue = lj.rgb2int(0,0,255)
green = lj.rgb2int(0,255,0)
cyan = lj.rgb2int(255,0,255)
yellow = lj.rgb2int(255,255,0)

StartColors = [white, white,white, white]

screen_size = [700,700]
xy_center = [screen_size[0]/2,screen_size[1]/2]

width = 800
height = 600
centerX = width / 2
centerY = height / 2

# 3D to 2D projection parameters
fov = 256
viewer_distance = 2.2

inv = math.pi/2

ccmidi =[0]*15

print()
log.info('Startup...')
# print("Arguments parsing if needed...")
argsparser = argparse.ArgumentParser(description="Aurora for LJ")
argsparser.add_argument("-r","--redisIP",help="IP of the Redis server used by LJ (127.0.0.1 by default) ",type=str)
argsparser.add_argument("-m","--myIP",help="IP to bind (0.0.0.0 by default) ",type=str)
argsparser.add_argument("-s","--scene",help="LJ scene number (1 by default)",type=int)
argsparser.add_argument("-v","--verbose",help="Verbosity level (0 by default)",type=int)
argsparser.add_argument("-L","--Lasers",help="Number of lasers connected (1 by default).",type=int)
argsparser.add_argument('-song',help="Run according to external (LIVE is default)", dest='song', action='store_true')
argsparser.set_defaults(song=False)
argsparser.add_argument('-link',help="Enable Ableton Link (disabled by default)", dest='link', action='store_true')
argsparser.set_defaults(link=False)
args = argsparser.parse_args()


if args.verbose:
    debug = args.verbose
else:
    debug = 0

if args.scene:
    ljscene = args.scene
else:
    ljscene = 1

# Redis Computer IP
if args.redisIP  != None:
    redisIP  = args.redisIP
else:
    redisIP = '127.0.0.1'

# myIP
if args.myIP  != None:
    gstt.myIP  = args.myIP
else:
    gstt.myIP = '0.0.0.0'

# Lasers = number of laser connected
if args.Lasers  != None:
    lasernumber = args.Lasers
else:
    lasernumber = 1

# with Ableton Link
if args.link  == True:
    import alink

    alink.Start()
    linked = True
else:
    print("Link DISABLED")
    linked = False

# Mode song 
if args.song  == True:
    print("Mode SONG")
    mode = "song"
else:
    print("Mode LIVE")
    mode = "live"


lj.Config(redisIP, ljscene, "aurora")

import anim, user

ccs =[[0] * 140] *4

# Layer FXs
FXs = ["ScanH", "ScanV", "Wave", "Circle", "Dot00", "Zero", "Maxwell", "Starfield", "Trckr", "Word"]
AllFXDisplay = [True, True, True, True]


# Animation parameters for each layer
Layer = [] *lasernumber
Stars = []    
currentlayer = 0

for l in range(lasernumber):

    Layer.append({'number': 0, 'FX': "user.User4",
        'Xcoord': 300, 'Ycoord': 300, 'Zcoord': 0,
        'scandots': 64, 'scale': 45, 'color': white,  "run": False, 
        'intensity': 255, 'closed': False,
        'lineSize': 64, 'radius': 45, 'wavefreq': 3,
        'word': "SonoptiK",
        'step': 0, 'steps': 60, 'stepmax': 60, 'stepvals': [], 
        'Xtransamt': 0, 'Ytransamt': 0, 'Ztransamt': 0, 
        'Xtranspeed': 0, 'Ytranspeed': 0, 'Ztranspeed': 0,
        'Xrotdirec': 0, 'Yrotdirec': 0, 'Zrotdirec': 0, 
        'Xrotspeed': 0, 'Yrotspeed': 0, 'Zrotspeed': 0,
        'rotspeed': 0
        })

    Layer[l]['number']= l
    Layer[l]['FX'] = StartFXs[l]
    Layer[l]['color'] = StartColors[l]

multi = {"radius": 300 }



#
# Destination :           name, number, active, layer , scene, laser)
#

Dest000 = lj.DestObject('FX0', 0, True, 0 , 0, 0)

if lasernumber >1:
    Dest101 = lj.DestObject('FX1', 1, True, 1 , 0, 1)

if lasernumber >2:
    Dest202 = lj.DestObject('FX2', 2, True, 2 , 0, 2)

if lasernumber >3:
    Dest303 = lj.DestObject('FX3', 3, True, 3 , 0, 3)

'''
# RelativeObject              name, active, intensity, xy, color, red, green, blue, layer , closed, xpos , ypos , scale , rotx , roty , rotz
FX0Form = lj.RelativeObject('FX0', True, 255, [], Layer[0]['color'], 255, 0, 0, 0 , False, 250 , 250, 1 , 0 , 0 , 0)
FX1Form = lj.RelativeObject('FX1', True, 255, [], Layer[1]['color'], 255, 0, 0, 1 , False, 250 , 250, 1 , 0 , 0 , 0)
FX2Form = lj.RelativeObject('FX2', True, 255, [], Layer[2]['color'], 255, 0, 0, 2 , False, 250 , 250, 1 , 0 , 0 , 0)
FX3Form = lj.RelativeObject('FX3', True, 255, [], Layer[3]['color'], 255, 0, 0, 3 , False, 250 , 250, 1 , 0 , 0 , 0)
'''

#
# OSC
#

oscserver = OSCServer( (gstt.myIP, OSCinPort) )
oscserver.timeout = 0
#oscrun = True

# this method of reporting timeouts only works by convention
# that before calling handle_request() field .timed_out is 
# set to False
def handle_timeout(self):
    self.timed_out = True


# funny python's way to add a method to an instance of a class
import types
oscserver.handle_timeout = types.MethodType(handle_timeout, oscserver)


# /aurora/ljscene
def OSCljscene(path, tags, args, source):

    log.info("Aurora OSC : got /aurora/ljscene with value" + str(args[0]))
    lj.WebStatus("aurora to virtual "+ str(args[0]))
    ljscene = args[0]
    lj.ljscene(ljscene)

# default handler
def OSChandler(path, tags, args, source):
    global TrckrPts

    oscaddress = ''.join(path.split("/"))
    #print()
    print("Aurora default OSC Handler : " + str(path) + " from Client : " + str(source[0]))
    #print(args)

    if len(args) > 0:
        pass

    #Convert from TouchOSC full text OSC style (no args) 
    if path.find(" ") != -1:

        prevargs = []
        if len(args) > 0:
            prevargs = args
            print(prevargs)
        newargs = path.split(" ")
        args=[]
        #print(newargs, len(newargs))
        for arg in range(len(newargs)-1):
            args.append(newargs[arg+1])

        args.append(prevargs[0])
        
        print("correction", path, args)
        #log.info("with args " + str(args))

    # /aurora/fx/layernumber FXname
    if path.find('/aurora/fx') == 0:

        #print("path", path, 'args', args)
        #print("layer", path[11:12])
        layer = int(path[11:12])

        if layer <= lasernumber-1:
            fx = args[0]
            if fx in FXs:
    
                Layer[layer]['FX']  = "anim."+fx
                print("Aurora default OSC got FX generator for layer", layer,":", Layer[layer]['FX'] )
                lj.SendLJ("/line1",[fx])
                midix.SendUI('/status', [fx])
            else:
                print("unknwon FX.")
        else:
            print("NOT POSSIBLE : only", lasernumber,"laser requested at startup")
            lj.SendLJ("/line1",str(lasernumber)+ " Laser")
            

    # /aurora/color/layernumber colorname
    if path.find('/aurora/color') == 0:

        #if args[1] =='1':
        layer = int(path[14:15])
        if layer <= lasernumber-1:
            color = args[0]
            Layer[layer]['color'] = eval(color)
            print("Aurora default OSc for Layer", layer,Layer[layer]['FX'], "Got color change to", color)
        else:
            print("NOT POSSIBLE : only", lasernumber,"laser requested at startup")
            lj.SendLJ("/line1",str(lasernumber)+ " Laser")

    #                      [0,1] or [0,127]
    # /aurora/x/layernumber coord
    if path.find('/aurora/x') == 0:

        layer = int(path[10:11])
        value = float(args[0])
        if value >1:
            value = value /127
        #print("xdefault layer", layer, "value", value)
        Layer[layer]['Xcoord'] = value * screen_size[0]
        print("Aurora default OSC got X coord for layer", layer,":", Layer[layer]['Xcoord'])
        midix.SendUI('/status', ["X : "+str(value * screen_size[0])])
    #                      [0,1] or [0,127]
    # /aurora/y/layernumber coord
    if path.find('/aurora/y') == 0:

        layer = int(path[10:11])
        value = float(args[0])
        if value >1:
            value = value /127
        #print("ydefault layer", layer, "value", value)
        Layer[layer]['Ycoord'] = value * screen_size[1]
        print("Aurora default OSC got Y coord for layer", layer,":", Layer[layer]['Ycoord'])
        midix.SendUI('/status', ["Y : "+str(value * screen_size[0])])
    
    # /aurora/trckr/frame layernumber framenumber points
    if path.find('aurora/trckr/frame') == 0:

       if debug != 0: 
         print("Aurora default OSC got trckr frame", args[1], "for layer", args[0], "with path", path)
         print(len(args),"args", args)
           
       counter =0

       '''
       TrckrPts = []
       for dot in range(2,len(args)-1,2):

         TrckrPts.append([float(args[dot]), float(args[dot+1])])
       '''

       TrckrPts[int(args[0])] = []
       for dot in range(2,len(args)-1,2):

         TrckrPts[int(args[0])].append([float(args[dot]), float(args[dot+1])])


    # /aurora/word/layer word
    if path.find('/aurora/word') == 0:

        layer = int(path[13:14])
        value = args[0]
        Layer[layer]['word'] = value
        print("Aurora default OSC got word", args[0], "for layer", layer)
        midix.SendUI('/status', ["Word : "+str(value * screen_size[0])])

    # /aurora/word/layer word
    if path.find('/aurora/rawcc') == 0:

        layer = int(args[0])
        number = int(args[1])
        value = int(args[2])
        midix.SendUI('/beatstep/'+ "m" +str(layer+1)+ str(number+1) + '/value', [format(value, "03d")])
        #ccs[layer][number] = value
    
        print(encoders[number],": value", value, "steps", Layer[layer]['steps'],"stepmax", Layer[layer]['stepmax'], "lineSize", Layer[layer]['lineSize'])
        print("Aurora Default OSC Got rawCC for layer", layer, "encoder", encoders[number], "value", value)
        #print(value, Layer[layer]['stepmax'])
        if value * 2 < Layer[layer]['stepmax']:
    
            Layer[layer][encoders[number]] = value * 5
            Layer[layer]['stepvals'] = anim.sbilinear(Layer[layer]['steps'], 0, Layer[layer]['stepmax'])

    # /aurora/scim
    if path.find('/aurora/scim') == 0:

        print("OSC default got /scim",int(args[0]))
        #lj.SendLJ("/scim", [int(args[0])+24])

'''
# /aurora/color/layernumber color
def OSCcolor(path, tags, args, source):

    print("Aurora OSC : color got", path, args)
    
    if args[1] == '1':
        layer = int(path[14:15])
        color = args[0]

        Layer[layer]["color"] = eval(color)
        print("Aurora OSC :", color ,"for layer", layer)
'''

# /aurora/scim layernumber
'''
def OSCim(path, tags, args, source):

    newarg = path.split(" ")
    newlaser = args[0]+24
    print("OSim sending to LJ /scim",str(newlaser))
    lj.SendLJ("/scim", [newlaser])
    print("sending knobs value for new layer")
    UpdateKnobs(newlaser)
    midix.SendUI('/status', ["Sim : "+newlaser])
'''

# /aurora/scim layernumber
def OSCim(path, tags, args, source):
    global currentlayer

    newarg = path.split(" ")
    currentlayer = int(args[0])
    print("OSim got /scim",str(currentlayer))
    print("new layer :", currentlayer)
    #lj.SendLJ("/scim", [newlaser])
    #print("sending knobs value for new layer")
    #UpdateKnobs(newlaser)
    #midix.SendUI('/status', ["Sim : "+newlaser])



def Resampler(laser,lsteps):

    #                   shortstep          longsteps    
    # lsteps is  like : [ 1.0, 8,     0.25, 3, 0.75, 3, 1.0, 10]
    print("Resampler change for laser ", laser)
    lj.SendLJ("/resampler/"+str(laser), [lsteps])


# /aurora/start
def OSCstart(path, tags, args, source):

    print("Aurora OSC Got MIDI start")
    for l in range(3):
        Layer[l]['run'] = True
    midix.SendUI('/status', ["Start"])


# /aurora/stop layer
def OSCstop(path, tags, args, source):

    print("Aurora OSC Got MIDI stop for layer", int(args[0]))
    Layer[int(args[0])]['run'] = False
    #for l in range(3):
    #    Layer[l]['run'] = not Layer[l]['run']
    midix.SendUI('/status', ["Stop"])


# 33 (B0) ScanH / 35 (B0) ScanV / 24 (C0) Wave / 26 (D0) Circle
# fxs = ["anim.ScanH", "anim.ScanV", "anim.Wave", "anim.Circle"]
# /aurora/noteon layer note velocity
def OSCnoteon(path, tags, args, source):

    print("Aurora OSC Got MIDI noteon")
    l = int(args[0])
    note = int(args[1])
    velocity = int(args[2])

    # first led raw : FX change

    # A0 / Scan H
    if note == 33:
        Layer[l]['FX'] = beatstepfxs[0]
    # B0
    if note == 35: 
        Layer[l]['FX'] = beatstepfxs[1]
    # C0
    if note == 24:  
        Layer[l]['FX'] = beatstepfxs[2]
    # D0
    if note == 26:
        Layer[l]['FX'] = beatstepfxs[3]

    # E0
    if note == 28:
        Layer[l]['FX'] = beatstepfxs[4]
    # F0
    if note == 29: 
        Layer[l]['FX'] = beatstepfxs[5]
    # G0
    if note == 31:  
        Layer[l]['FX'] = beatstepfxs[6]
    # G#0
    if note == 21:
        Layer[l]['FX'] = beatstepfxs[7]

    if 21 < note < 35:
        midix.SendUI('/status', [Layer[l]['FX']])
    # Second led raw : Color change

    # A1
    if note == 45:
        Layer[l]['color'] = eval(beatstepcols[0])
    # B1
    if note == 47: 
        Layer[l]['color'] = eval(beatstepcols[1])
    # C1
    if note == 36:  
        Layer[l]['color'] = eval(beatstepcols[2])
    # D1
    if note == 38:
        Layer[l]['color'] = eval(beatstepcols[3])

    # E1
    if note == 40:
        Layer[l]['color'] = eval(beatstepcols[4])
    # F1
    if note == 41: 
        Layer[l]['color'] = eval(beatstepcols[5])
    # G1
    if note == 43:  
        Layer[l]['color'] = eval(beatstepcols[6])
    # G#1
    if note == 44:
        Layer[l]['color'] = eval(beatstepcols[7])

    if 36 < note < 47:
        midix.SendUI('/status', [Layer[l]['color']])


    print ("Aurora OSC Got new MIDI FX/color for layer", l, ":", Layer[l]['FX'],"/",(Layer[l]['color']) )


# /aurora/noteoff layer notenumber
def OSCnoteoff(path, tags, args, source):

    print("Aurora OSC Got MIDI noteoff")
    l = int(args[0])
    note = int(args[1])


# /aurora/fx layer FXname
def OSCfx(path, tags, args, source):

    layer = int(args[0])
    fx = args[1]
    print(layer, fx)
    if fx in FXs:
        Layer[layer]['FX'] = "anim."+fx
        print("Aurora OSC Got new WS FX generator for layer", layer, ":", Layer[layer]['FX'])
    else:
        print("unknwon FX.")

#                   
# /aurora/xcoord layer value
def OSCXcoord(path, tags, args, source):

    #Layer[layer]['run'] = False 
    layer = int(args[0])
    value = float(args[1])
    if value >0:
       value = value /127
    #print("xdefault layer", layer, "value", value)
    Layer[layer]['Xcoord'] = value * screen_size[0]
    print("Aurora OSC got X coord for layer", layer,":", Layer[layer]['Xcoord'])



# /aurora/ycoord layer value
def OSCYcoord(path, tags, args, source):

    layer = int(args[0])
    value = float(args[1])
    if value >0:
       value = value /127
    #print("xdefault layer", layer, "value", value)
    Layer[layer]['Ycoord'] = value * screen_size[0]
    print("Aurora OSC got Y coord for layer", layer,":", Layer[layer]['Ycoord'])

# [0-1] ?
# /aurora/scale layer value
def OSCale(path, tags, args, source):

    layer = int(args[0])
    value = float(args[1])
    #if value >1:
    #    value = value /127
    print("New scale", value, "for layer", layer)
    Layer[int(args[0])]['scale'] = value*3
    ccs[layer][98] = value * 127


# /aurora/scandots layernumber value
def OSCandots(path, tags, args, source):

    if int(args[1]) > 2:
      Layer[int(args[0])]['scandots'] = int(args[1])
    else:
      lj.WebStatus("2 dots minimum")

    # ccs[layer][98] = value       2/11


# /aurora/radius layernumber radius [0-1] 
def OSCradius(path, tags, args, source):

    layer = int(args[0])
    value = float(args[1])
    if value >1:
        value = value /127
    print("aurora OSC got radius", value, (value * multi["radius"]), "layer", layer)
    Layer[layer]['radius'] = value * multi["radius"]
    midix.SendUI('/status', ["Radius : ", value * multi["radius"]])


# /aurora/amp  layer side axe type
def OSCamp(path, tags, args, source):
    pass

# /aurora/linesize layer value
def OSClinesize(path, tags, args, source):

    #Layer[layer]['run'] = False 

    layer = int(args[0])
    value = float(args[1])
    if value >1:
        value = value /127
    Layer[layer]['lineSize'] = value*400
    midix.SendUI('/status', ["linesize : ", value*400])


# /aurora/steps layer value
def OSCsteps(path, tags, args, source):

    layer = int(args[0])
    value = float(args[1])
    print("aurora OSC got steps", value, (value * 5), "layer", layer)
    
    if value * 2 < Layer[layer]['stepmax']:

        Layer[layer]['step']   = 0
        Layer[layer]['steps'] = round(value * 5)
        Layer[layer]['stepvals'] = anim.sbilinear(Layer[layer]['steps'], 0, Layer[layer]['stepmax'])


# /aurora/stepmax layer value
def OSCstepmax(path, tags, args, source):

    layer = int(args[0])
    value = float(args[1])
    print("aurora OSC got stepmax", value, (value * 5), "layer", layer)

    if value * 2 < Layer[layer]['stepmax']:

        Layer[layer]['step']   = 0
        Layer[layer]['stepmax'] = value * 5
        Layer[layer]['stepvals'] = anim.sbilinear(Layer[layer]['steps'], 0, Layer[layer]['stepmax'])


# /aurora/rotdirec layer axe direc
def OSCrotdirec(path, tags, args, source):

    layer = int(args[0])
    axe = args[1]
    direc = int(args[2])

    #print(layer, axe, direc)
    if axe =="X":
        Layer[layer]['Xrotdirec'] = ccs[layer][102] = direc
    if axe =="Y":
        Layer[layer]['Yrotdirec'] = ccs[layer][106] = direc 
    if axe =="Z":
        Layer[layer]['Zrotdirec'] = ccs[layer][110] = direc


# /aurora/rotspeed layernumber axe speed
def OSCrotspeed(path, tags, args, source):

    print("Aurora OSC : rotspeed got", path, args)
    layer = int(args[0])
    axe = args[1]
    speed = int(args[2])

    if axe =="X":
        Layer[layer]['Xrotspeed'] =  ccs[layer][100] = speed
    if axe =="Y":
        Layer[layer]['Yrotspeed'] =  ccs[layer][104] = speed
    if axe =="Z":
        Layer[layer]['Zrotspeed'] =  ccs[layer][108] = speed


# /aurora/transamt layernumber axe maxposition
def OSCtransamt(path, tags, args, source):
    
    print("Aurora OSC : transamt got", path, args)
    layer = int(args[0])
    axe = args[1]
    maxpos = int(args[2])

    if axe =="X":
        Layer[layer]['Xtransamt'] = ccs[layer][114] = maxpos
    if axe =="Y":
        Layer[layer]['Ytransamt'] = ccs[layer][118] = maxpos
    if axe =="Z":
        Layer[layer]['Ztransamt'] = ccs[layer][122] = maxpos



# /aurora/transpeed layernumber axe transpeed
def OSCtranspeed(path, tags, args, source):

    print("Aurora OSC : transspeed got", path, args)
    layer = int(args[0])
    axe = args[1]
    speed = int(args[2])

    if axe =="X":
        Layer[layer]['Xtranspeed'] = ccs[layer][112] = speed
    if axe =="Y":
        Layer[layer]['Ytranspeed'] = ccs[layer][116] =  speed
    if axe =="Z":
        Layer[layer]['Ztranspeed'] = ccs[layer][120] =  speed


# /aurora/part partname
def OSCpart(path, tags, args, source):

    print("aurora part got", path, args)
    gstt.aurorapart = args[0]


# /aurora/bpm set current bpm
def OSCbpm(path, tags, args, source):

    pass
    #gstt.currentbpm = int(args[0])
    #print("Aurora OSC New BPM :", int(args[0]))


#/aurora/clock
def OSClock(path, tags, args, source):

    pass
    #print("Aurora OSC Got MIDI clock")

# /aurora/trckr/frame
def OSCtrckr(path, tags, args, source):
    global TrckrPts


    #print("trckr got frame", args[0])
    if debug != 0: 
      print("trckr got frame", args[1], "for layer", layer)
      print(len(args),"args", args)
    counter =0
    TrckrPts[args[0]] = []

    for dot in range(2,len(args)-2,2):

      TrckrPts[args[0]].append([float(args[dot]), float(args[dot+1])])


# /aurora/rawcc layer encoder value (Aurora style)
encoders = ['Xcoord','Ycoord', 'resize', 'scandots', 'Xrotdirec', 'Yrotdirec', 'Zrotdirec', 'radius','steps', 'stepmax','lineSize','radius','radius','radius','radius','radius']
def OSCrawcc(path, tags, args, source):

    if path.find(" ") != -1:
        newargs = path.split(" ")
        args=[]
        #print(newargs, len(newargs))
        for arg in range(len(newargs)-1):
            args.append(newargs[arg+1])
        print(path, args)

    layer = int(args[0])
    number = int(args[1])
    value = int(args[2])

    #print("OSC rawcc")
    midix.SendUI('/beatstep/'+ "m" +str(layer+1)+ str(number+1) + '/value', [format(value, "03d")])
    #print('/beatstep/'+ "m" +str(layer+1)+ str(number+1) + '/value', [format(value, "03d")])
    #ccs[layer][number] = value

    print(encoders[number],": value", value, "steps", Layer[layer]['steps'],"stepmax", Layer[layer]['stepmax'], "lineSize", Layer[layer]['lineSize'])
    #print("Aurora OSC Got rawCC for layer", layer, "encoder", encoders[number], "value", value)
    #print(value, Layer[layer]['stepmax'])
    if value * 2 < Layer[layer]['stepmax']:

        Layer[layer][encoders[number]] = value * 5
        Layer[layer]['stepvals'] = anim.sbilinear(Layer[layer]['steps'], 0, Layer[layer]['stepmax'])


# /aurora/cc channel CC value
# /aurora/cc layer steps stepmax
def OSCcc(path, tags, args, source):

    print("Aurora OSC Got CC")
    channel = int(args[0])
    ccnumber = int(args[1])
    ccvalue = int(args[2])

    Layer[channel]['step']    = 0
    Layer[channel]['steps']   = ccnumber * 5
    Layer[channel]['stepmax'] = ccvalue  * 5
    Layer[channel]['stepvals'] = anim.sbilinear(Layer[channel]['steps'], 0, Layer[channel]['stepmax'])


# /aurora/intensity layernumber intensity
def OSCintensity(path, tags, args, source):
    
    print("Aurora OSC : intensity got", path, args)
    layer = int(args[0])
    Layer[layer]['intensity'] = int(args[1])
    lj.SendIntensity(layer, int(args[1]))


# /aurora/kpps layernumber kpps
def OSCkpps(path, tags, args, source):
    
    print("Aurora OSC : kpps got", path, args)
    layer = int(args[0])
    lj.Sendkpps(layer, int(args[1]))
    


#
# OSC Audio
# 

# /aurora/audioR value
def OSCaudioR(path, tags, args, source):
    global audioR

    audioR = abs(float(args[0])* audiosize)
    #print("Aurora OSC Got audioR value", audioR )


# /aurora/audioL value
def OSCaudioL(path, tags, args, source):
    global audioL

    audioL = abs(float(args[0]) * audiosize)
    #print("Aurora OSC Got audioR value", audioL )




#
# OSC Beatstep
#

beatstepfxs = ["anim.ScanH", "anim.ScanV", "anim.Wave", "anim.Circle", "anim.Starfield", "anim.Word", "anim.Trckr", "anim.ScanH"]
beatstepcols = ["red", "yellow", "green", "blue", "cyan", "white", "white", "white"]
def beatstepUI():

    midix.SendUI('/beatstep', [1])
    midix.SendUI('/beatstep/on', [1])
    midix.SendUI('/status', ["Aurora"])
    if linked:
        midix.SendUI('/bpm', alink.bpm)

    for l in range(4):
        
        # First encoder line
        midix.SendUI('/beatstep/'+ "m1" + str(l+1) + '/line1', '')
        midix.SendUI('/beatstep/'+ "m1" + str(l+1) + '/line2', encoders[l])
        midix.SendUI('/beatstep/'+ "m1" + str(l+1) + '/value', [format(0, "03d")])
        midix.SendUI('/beatstep/'+ "m1" + str(4+l+1) + '/line1', '')
        midix.SendUI('/beatstep/'+ "m1" + str(4+l+1) + '/line2', encoders[l])
        midix.SendUI('/beatstep/'+ "m1" + str(4+l+1) + '/value', [format(0, "03d")])

        # First pad line
        fxname = beatstepfxs[l].split('.')
        print(fxname)
        midix.SendUI('/beatstep/'+ "m3" + str(l+1) + '/line1', fxname[0])
        midix.SendUI('/beatstep/'+ "m3" + str(l+1) + '/line2', fxname[1])
        midix.SendUI('/beatstep/'+ "m3" + str(4+l+1) + '/line1', fxname[0])
        midix.SendUI('/beatstep/'+ "m3" + str(4+l+1) + '/line2', fxname[1])


# 
# Color functions
#

# input hexcode = '0xff00ff'
def hex2rgb(hexcode):

    hexcode = hexcode[2:]
    return tuple(int(hexcode[i:i+2], 16) for i in (0, 2, 4))
    #return tuple(map(ord,hexcode[1:].decode('hex')))

# input rgb=(255,0,255) output '0xff00ff'
def rgb2hex(rgb):
    return '0x%02x%02x%02x' % tuple(rgb)

#def rgb2hex(r, g, b):
#    return hex((r << 16) + (g << 8) + b)


def rgb2int(rgb):
    return int('0x%02x%02x%02x' % tuple(rgb),0)

#def rgb2int(r,g,b):
#    return int('0x%02x%02x%02x' % (r,g,b),0)

def int2rgb(intcode):
    #hexcode = '0x{0:06X}'.format(intcode)
    hexcode = '{0:06X}'.format(intcode)
    return tuple(int(hexcode[i:i+2], 16) for i in (0, 2, 4))

#
# Compute animations speed
#

def animSpeeds():

    print("Compute animations speed for", lasernumber, "lasers...")
    
    for l in range(lasernumber):
        Layer[l]['stepvals'] = anim.sbilinear(Layer[l]['steps'], 0, Layer[l]['stepmax'])

#
# Starfields
# 

StarFields = []

# Init Starfields
def prepareStarfield():

    print("Init starfields...")
    lj.WebStatus("Init starfields...")

    for field in range(lasernumber):

        StarFields.append({'stars': [], 'starfieldcount': 0, 'starspeed': 0.05, 'displayedstars': 5, 'num_stars': 50, 'max_depth': 20})
        for i in range(StarFields[field]['num_stars']):

            # A star is represented as a list with this format: [X,Y,Z]
            star = [randrange(-25,25), randrange(-25,25), randrange(1, StarFields[field]['max_depth'])]
            StarFields[field]['stars'].append(star)

#
# faces tracker
# 


TrckrPts =[[],[],[],[]] 
#print(TrckrPts)

def prepareTrckr():

  for l in range(lasernumber):
    #print()
    TrckrPts[l] = [[159.39, 137.68], [155.12, 159.31], [155.56, 180.13], [159.81, 201.6], [170.48, 220.51], [187.46, 234.81], [208.4, 244.68], [229.46, 248.21], [246.44, 244.91], [259.69, 234.83], [270.95, 221.51], [278.54, 204.66], [283.53, 185.63], [286.27, 165.79], [284.72, 144.84], [280.06, 125.01], [274.35, 118.7], [260.71, 117.23], [249.52, 118.86], [182.04, 121.5], [193.63, 114.79], [210.24, 114.77], [222.35, 117.57], [190.6, 137.49], [203.59, 132.42], [214.75, 137.58], [203.04, 140.46], [203.32, 136.53], [272.45, 141.57], [263.33, 135.42], [250.31, 138.89], [262.15, 143.27], [261.99, 139.37], [235.82, 131.74], [221.87, 156.09], [213.66, 165.88], [219.28, 173.53], [236.3, 175.25], [249.02, 174.4], [254.22, 167.81], [248.83, 157.39], [237.94, 147.51], [227.01, 168.39], [245.68, 170.02], [204.94, 197.32], [217.56, 192.77], [228.27, 190.55], [234.66, 192.19], [240.47, 191.09], [247.96, 193.87], [254.52, 199.19], [249.35, 204.25], [242.74, 207.16], [233.2, 207.87], [222.13, 206.52], [212.44, 203.09], [220.34, 198.74], [233.31, 200.04], [244.0, 199.6], [244.27, 197.8], [233.81, 197.44], [220.88, 196.99], [239.57, 162.69], [196.52, 133.86], [210.2, 133.98], [209.43, 139.41], [196.59, 139.47], [268.99, 137.59], [256.36, 136.02], [255.95, 141.5], [267.9, 142.85]]
    #print(l, ":",TrckrPts[l])
 
#
# ALl FXs points generation
#

def AllFX():
  global step, shapestep 

  for l in range(lasernumber):
    if AllFXDisplay[l]: #and 0 <= x0 < screen_size[0] - 2 and 0 <= y0 < screen_size[1] - 2:
              
       LAY = Layer[l]     
       dots = []
       ##log.err(str(l) + " "+ str(LAY))
       # Generators sending directly their points.
       if LAY['FX'] == "anim.Starfield":
           anim.Onefield(LAY, StarFields[l], hori=0, verti=0)

       elif LAY['FX'] == "anim.Trckr":
           anim.Trckr(LAY, TrckrPts[l])

       elif LAY['FX'] == "anim.Word":
           anim.Word(LAY)

       elif LAY['FX'] == "anim.User1":
           user.User1(LAY)

       elif LAY['FX'] == "anim.User2":
           user.User2(LAY)

       elif LAY['FX'] == "anim.User3":
           dots = user.User3(LAY)

       elif LAY['FX'] == "anim.User4":

           dots = user.User4(LAY)
           if LAY['FX'] != "Zero" or lent(dots) != 0:
               #print(dots, LAY['color'])
               lj.rPolyLineOneColor(dots, c = LAY['color'], layer = l, closed = LAY['closed'], xpos = LAY['Xcoord'] + LAY['stepvals'][LAY['step']] - (LAY['lineSize']/2), ypos = Layer[l]['Ycoord'], resize = LAY['scale'] * audioR, rotx = LAY['Xrotdirec'], roty = LAY['Yrotdirec'], rotz = LAY['Zrotdirec'])


       elif LAY['FX'] == "anim.Butterfly":
           anim.Butterfly(LAY)
       
       # Generic generators : return dots list 
       else:

           dots = eval(LAY['FX']+"(LAY)")
           if LAY['FX'] != "Zero" or lent(dots) != 0:
                #print(dots, LAY['color'])
                #for cc in range(15):
                #    ccmidi[cc] = int(lj.fromKey("/midi/cc/1/"+str(cc)))
                #    #print(ccmidi)
                lj.rPolyLineOneColor(dots, c = LAY['color'], layer = l, closed = LAY['closed'], xpos = LAY['Xcoord'] + LAY['stepvals'][LAY['step']] - (LAY['lineSize']/2), ypos = Layer[l]['Ycoord'], resize = LAY['scale'] * audioR, rotx = LAY['Xrotdirec'], roty = LAY['Yrotdirec'], rotz = LAY['Zrotdirec'])
                #lj.rPolyLineOneColor(dots, c = LAY['color'], layer = l, closed = LAY['closed'], xpos = LAY['Xcoord'] - (ccmidi[0]-64)*4 - (LAY['lineSize']/2), ypos = Layer[l]['Ycoord'] + (ccmidi[1]-64)*4, resize = LAY['scale'] * audioR * (ccmidi[2])/50, rotx = LAY['Xrotdirec']+(ccmidi[3]*3), roty = LAY['Yrotdirec']+(ccmidi[3]*3), rotz = LAY['Zrotdirec']+(ccmidi[3]*3))
           else:
                lj.rPolyLineOneColor((0,0,0), c = 0, layer = l, closed = LAY['closed'], xpos = LAY['Xcoord'] + LAY['stepvals'][LAY['step']] - (LAY['lineSize']/2), ypos = Layer[l]['Ycoord'], resize = LAY['scale'] * audioR, rotx = LAY['Xrotdirec'], roty = LAY['Yrotdirec'], rotz = LAY['Zrotdirec'])
           # OSC cc Audio reactive audioR -> size
           
           # Animation
           if LAY['run']:

               lsteps = [ (1.0, 8),   (0.25, 3), (0.75, 3), (1.0, 10)]
               #Resampler(l,lsteps)

               if LAY['step'] < LAY['steps']-1:
                   LAY['step'] +=1
               else:
                   LAY['step'] = 0
               # print("stepmax", LAY['stepmax'], 'step', LAY['step'])

           if shapestep < shapesteps-1:
             shapestep +=1
           else:
             shapestep =0
           '''
           # morphing
               gstt.patchnumber[layer] = number
               for ccnumber in range(len(maxwell['ccs'])):
                   gstt.morphCCinc[ccnumber] = (getPatchValue(gstt.patchnumber[layer], ccnumber) - gstt.ccs[layer][ccnumber]) / gstt.morphsteps
                   gstt.morphCC[ccnumber] = gstt.ccs[layer][ccnumber]
                   print("CC", ccnumber, "was", gstt.ccs[layer][ccnumber],"will be", getPatchValue(gstt.patchnumber[layer], ccnumber), "so inced is", gstt.morphCCinc[ccnumber])
               gstt.morphing = 0
           '''
# Update Pose webUI
def UpdateAuroraUI():

    lj.WebStatus("Aurora Connected")


def UpdateKnobs(layernumber):

    LAY = Layer[layernumber]     

    lj.SendLJ("/forwardui", "aurora/word " + LAY['word'])

    lj.SendLJ("/forwardui", "aurora/Xcoord " + str(LAY['Xcoord']))
    lj.SendLJ("/forwardui", "aurora/Ycoord " + str(LAY['Ycoord']))
    lj.SendLJ("/forwardui", "aurora/scale "  + str(LAY['scale']))
    lj.SendLJ("/forwardui", "aurora/scandots " + str(LAY['scandots']))
    lj.SendLJ("/forwardui", "aurora/rotdirec X " + str(LAY['Xrotdirec']))
    lj.SendLJ("/forwardui", "aurora/rotdirec Y " + str(LAY['Yrotdirec']))
    lj.SendLJ("/forwardui", "aurora/rotdirec Z " + str(LAY['Zrotdirec']))

    lj.SendLJ("/forwardui", "aurora/steps " + str(LAY['steps']))
    lj.SendLJ("/forwardui", "aurora/stepmax " + str(LAY['stepmax']))
    lj.SendLJ("/forwardui", "aurora/linesize " + str(LAY['lineSize']))
    lj.SendLJ("/forwardui", "aurora/radius " + str(LAY['radius']))


prepareStarfield()
prepareTrckr()

log.info("Starting OSC server at " + str(gstt.myIP)+ " port "+ str(OSCinPort)+ " ...")
#print("TouchOSC", gstt.TouchOSCIP)
oscserver.addMsgHandler("/aurora/ljscene", OSCljscene)

oscserver.addMsgHandler("/aurora/noteon", OSCnoteon)
oscserver.addMsgHandler("/aurora/fx", OSCfx)
oscserver.addMsgHandler("/aurora/noteoff", OSCnoteoff)
#oscserver.addMsgHandler("/aurora/color", OSColor)
oscserver.addMsgHandler("/aurora/bpm",  OSCbpm)
oscserver.addMsgHandler("/aurora/clock", OSClock)
oscserver.addMsgHandler("/aurora/start", OSCstart)
oscserver.addMsgHandler("/aurora/stop", OSCstop)
oscserver.addMsgHandler("/aurora/part", OSCpart)

oscserver.addMsgHandler("/aurora/steps", OSCsteps)
oscserver.addMsgHandler("/aurora/stepmax", OSCstepmax)


oscserver.addMsgHandler("/aurora/rawcc", OSCrawcc)
oscserver.addMsgHandler("/aurora/cc", OSCcc)

oscserver.addMsgHandler("/aurora/audioR", OSCaudioR)
oscserver.addMsgHandler("/aurora/autioL", OSCaudioL)

oscserver.addMsgHandler("/aurora/Xcoord", OSCXcoord)
oscserver.addMsgHandler("/aurora/Ycoord", OSCYcoord)
oscserver.addMsgHandler("/aurora/linesize", OSClinesize)
oscserver.addMsgHandler("/aurora/scale", OSCale)
oscserver.addMsgHandler("/aurora/radius", OSCradius)
oscserver.addMsgHandler("/aurora/scandots", OSCandots)
oscserver.addMsgHandler("/aurora/scim", OSCim)

oscserver.addMsgHandler("/aurora/intensity", OSCintensity)
oscserver.addMsgHandler("/aurora/rotspeed", OSCrotspeed)
oscserver.addMsgHandler("/aurora/transamt", OSCtransamt)
oscserver.addMsgHandler("/aurora/rotdirec", OSCrotdirec)
oscserver.addMsgHandler("/aurora/trckr/frame", OSCtrckr)
# Add OSC generic layerugins commands : 'default", /ping, /quit, /pluginame/obj, /pluginame/var, /pluginame/adddest, /pluginame/deldest
lj.addOSCdefaults(oscserver)
oscserver.addMsgHandler( "default", OSChandler )
#anim.prepareSTARFIELD()

beatstepUI()

#beatstep.UpdatePatch(beatstep.patchnumber)

print("Updating Aurora UI...")
UpdateAuroraUI()

midix.check()

animSpeeds()

audioR = 1
audioL = 1
audiosize = 1.1

'''
steps = 500
step = 0
stepmax = 200
stepvals = anim.sbilinear(steps, 0, stepmax)
'''

shapesteps = 50
shapestep = 0
shapemax = 2
shapevals = anim.ssquare(shapesteps, 1, 0, shapemax)

#Layer[1]['FX']="anim.StarField"
#Layer[0]['FX']="anim.Maxwell"

#lsteps = [ (1.0, 3), (0.25, 3), (0.75, 3), (1.0, 10)]
#Resampler(l,lsteps)
print(anim.randlinear2(8,0,100))

def Run():
    
    log.infog("Running...")
    try:
        while lj.oscrun:

            # If you want an idea 
            # t0 = time.time()
            lj.OSCframe()
            if linked:
                alink.BeatEvent()

            AllFX()

            time.sleep(0.002)

            #t1 = time.time()
            # looptime = t1 - t0
            # 25 frames/sec -> 1 frame is 0.04 sec long
            # if looptime is 0.01 sec
            # 0.04/0.01 = 4 loops with the same anim
            # so speedanim is 1 / 4 = 0.25
            # speedanim = 1 / (0.04 / looptime)

            lj.DrawDests()
            #print("Took %f" % (t1 - t0, ))

    #except KeyboardInterrupt:
    #    pass
    except Exception:
        log.err("Exception")
        traceback.print_exc()

    # Gently stop on CTRL C
    finally:

        lj.WebStatus("Aurora Disconnected")
        log.info("Stopping OSC...")
        lj.OSCstop()

        log.infog("Aurora Stopped.")

Run()