#! /usr/bin/python
# -*- coding: utf-8 -*-
"""
This file is part of librelight.
librelight is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 2 of the License.
librelight is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with librelight. If not, see <http://www.gnu.org/licenses/>.
(c) 2012 micha@librelight.de
"""
import math, random
import time,json
class Sequence(object):
def __init__(self):
pass
def go(self,ID,RANGE,ATTRIBUT):
pass
class Stack(object):
"List of Presets"
def __init__(self):
self.__stacks = show.load_stacks(self.__show["NAME"],self.__stacks)
def save(self):
show.save_stacks(self.__show["NAME"],self.__stacks)
def __str__(self):
pass
def go(self,ID):
pass
def pause(self,ID):
pass
def set(self,optinon,value):
pass
def next(self,FIX,ATTR):
pass
class Effect(object):
"""Effect sinus, cosinus, linear"""
def __init__(self,TYPE="sinus",size=10,speed=100,offset=0,egroup=None,DIR=1):
self.__type=TYPE
self.__msize=255
self.__mspeed=255
self.__moffset=1
self.__dir=DIR
self.__mdir=1
self.__size=size
self.__speed=speed
self.__base = None
self.__offset = offset
self.__vmax = -1000000
self.__vmaxt = 0
self.__vmin = 1000000
self.__vmint = 0
if self.__offset:
self.__step = float(self.__offset*self.__moffset)
else:
self.__step = 0
#self.__step = 0
self.__old_step = 0#self.__step
self.__old_rand = 0
self.__egroup = egroup
print(self)
def __str__(self):
return self.__repr__()
def __repr__(self):
return '<%(klass)s type:%(TYPE)s size:%(size)s base:%(base)s speed:%(speed)s offset:%(offset)s egroup:%(egroup)s msize:%(msize)s mspeed:%(mspeed)s moffset:%(moffset)s mdir:%(mdir)s _dir:%(_dir)s>' % dict(
klass = self.__class__.__name__,
TYPE = self.__type,
size = self.__size,
base = self.__base,
speed = self.__speed,
offset = self.__offset,
egroup = self.__egroup,
msize = self.__msize,
mspeed = self.__mspeed,
moffset = self.__moffset,
mdir = self.__mdir,
_dir = self.__dir
)
def __sinus(self,current_value):
out = current_value + math.sin(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
if self.__mdir:
if self.__dir:
DIR = 0
else:
DIR = 1
else:
if self.__dir:
DIR = 1
else:
DIR = 0
#print(DIR)
if DIR:
self.__step += (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
else:
#out = current_value + math.cos(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
self.__step -= (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
if int(out) > self.__vmax:
self.__vmaxt = time.time()
self.__vmax = int(out)
#print("max schrittbreite ",self.__vmaxt - self.__vmint,"sec \t",self)
if int(out) < self.__vmin:
self.__vmint = time.time()
self.__vmin = int(out)
#print("min schrittbreite ",self.__vmaxt - self.__vmint,"sec \t",self)
if out > 255:
out = 255
elif out < 0:
out = 0
#print(self)
return out
def __cosinus(self,current_value):
out = current_value + math.cos(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
if self.__mdir:
if self.__dir:
DIR = 0
else:
DIR = 1
else:
if self.__dir:
DIR = 1
else:
DIR = 0
#if self.__mdir + self.__dir == 1:
if DIR:
#out = current_value + math.cos(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
self.__step += (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
else:
#out = current_value + math.sin(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
self.__step -= (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
if out > 255:
out = 255
elif out < 0:
out = 0
return out
def __linear(self,current_value):
pass
def __rand(self,current_value):
#self.__step += int(self.__speed/10000)
#print(self.__old_step-int(self.__speed/1000.) , time.time())
if self.__old_step < time.time():
self.__old_rand = random.randint(0,int(self.__size*self.__msize/255) )
self.__old_step = time.time() + ( 10- ( ( self.__speed/100. ) *self.__mspeed/255 ) / 30000. )
print("NEW SPEED :" ,self.__old_step, time.time() - self.__old_step)
print("NEW RAND :" ,self.__old_rand)
return self.__old_rand
def get_egroup(self):
return self.__egroup
def set_mdir(self, mdir):
if type(mdir) is int:
if mdir != 0:
mdir = 1
self.__mdir=mdir
else:
print(self, "mdir not an int")
#print(self.__mdir * self.__dir)
def set_msize(self,msize):
if type(msize) is int:
self.__msize=msize
else:
print(self, "msize not an int")
def set_mspeed(self,mspeed):
if type(mspeed) is int:
self.__mspeed=mspeed
else:
print(self, "mspeed not an int")
def set_moffset(self,moffset):
# set Master Offset
if type(moffset) is int:
if moffset != self.__moffset:
val = self.__offset*self.__moffset
self.__step -= float(val)
#print("old offset ",val)
self.__moffset = moffset
val = self.__offset*self.__moffset
self.__step += float(val)
#print("new offset ",val)
#self.__offset = float(val) self.__moffset=moffset
#print("set moffset",moffset, self.__offset*self.__moffset/10)
else:
print(self, "moffset not an int")
def set_size(self,val):
self.__size = val
def set_speed(self,val):
self.__speed = val
def set_type(self,val):
self.__type = val
def set_offset(self,val):
self.__step -= float(self.__offset)
self.__step += float(val)
self.__offset = float(val)
def next(self,current_value):
self.__base = current_value
if self.__type == "sinus":
return self.__sinus(current_value)
elif self.__type == "cosinus":
return self.__cosinus(current_value)
elif self.__type == "linear":
return 0
pass
elif self.__type == "rand":
return self.__rand(current_value)
else:
print("effect type \""+str(self.__type) +"\" unknown")
return 0
class FadeFast(object):
"""Fade 16bit mode as FLOAT
Berechnet Schritte in "on the fly"
"""
def __init__(self,start,target,fadetime=None,start_time=None):
self.INIT = 0
if target > 255.999:
target = 255.999
elif target < 0:
target = 0
if start_time:
self.__start_time = start_time
else:
self.__start_time = time.time()
self.fakt = 1. #1000.
#feine aufloesung
start = int(start*self.fakt)
target = int(target*self.fakt)
if not fadetime:
start = target
self.__start = start
self.value = start
self.old_ret = start
self.__current = start
self.__target = target
self.__fadetime = fadetime
self.__dist = target - start
self.fine = 0
#print(self.__class__.__name__,"(", self.__start/self.fakt, self.__target/self.fakt, self.__dist/self.fakt, self.__fadetime , ") NEW FADE OBJ")
if self.__dist != 0:
self.__step_time = fadetime / (self.__dist * 1.0)
else:
self.__step_time = 0
if self.__step_time < 0:
self.__step_time = self.__step_time *-1
#print(self.__step_time)
#print(self)
def __dict__(self):
return None
def __str__(self):
return self.__repr__()
def __repr__(self):
#return {"non":None}
return '<%(klass)s start:%(start)s target:%(target)s fadetime:%(fadetime)ssec start_time:%(start_time)ssec>' % dict(
klass = self.__class__.__name__,
start = self.__start/self.fakt,
target = self.__target/self.fakt,
fadetime = self.__fadetime,
start_time = self.__start_time
)
def next(self):
jetzt = time.time()
if self.fine:
return 0
if jetzt >= self.__fadetime + self.__start_time or not self.__step_time :
if not self.INIT:
#print(self.__fadetime,jetzt - self.__start_time)
#print("end")
self.INIT = 1
self.value = self.__target/self.fakt
self.fine = 1
return 1
elif jetzt < self.__start_time:
self.value = self.__start
return 0
#return self.__start
if self.__step_time :
step = (jetzt - self.__start_time) / self.__step_time
else:
step = 0
#print(self.__class__.__name__,"fade",self.__fadetime,"jetzt",jetzt,"start_t", self.__start_time,"start",self.__start,"step", step,"step_t",self.__step_time)
if self.__start < self.__target:
ret = int(self.__start + step)/self.fakt
else:
ret = int(self.__start - step)/self.fakt
self.value = ret
if self.old_ret != ret:
self.old_ret = ret
return 1
#return ret
return 0
class Fade(object):
"""altes fade objekt
Speicher fresser und initialisierung dauert
alle einzelschritte werden bei der initialisierung erzeugt
"""
def __init__(self,start,target,fadetime=None,start_time=None):
self.INIT = 0
if target > 255:
target = 255
if start_time:
self.__time = start_time
else:
self.__time = time.time()
#feine aufloesung
start = int(start*100.)
target = int(target*100.)
if not fadetime:
start = target
self.__start = start
self.__current = start
self.__target = target
self.__fadetime = fadetime
self.__dist = target - start
print(self.__class__.__name__,"(", self.__start/100., self.__target/100., self.__dist/100, self.__fadetime , ") NEW FADE OBJ")
if self.__dist != 0:
self.__step_time = fadetime / (self.__dist * 1.0)
else:
self.__step_time = 0
self.__steps = []
if self.__dist < 0:
for i in range(self.__dist*-1):
self.__steps.append([self.__start,0])
elif self.__dist > 0:
for i in range(self.__dist):
self.__steps.append([self.__start,0])
else:
self.__steps.append([self.__target,time.time()])
#print("DIST == 0")
if self.__step_time < 0:
self.__step_time = self.__step_time *-1
i = 0
#print(self#.__dist, self.__start ,self.__step_time)
#erstelle alle schritte mit absolutem zeitstempel
while self.__dist != 0:
if self.__dist > 0:
self.__current += 1
self.__dist -= 1
else:
self.__current -= 1
self.__dist += 1
self.__time += self.__step_time
self.__steps[i][0] = self.__current
self.__steps[i][1] = self.__time
i += 1
#print(i,self.__steps, self.__dist, self.__start )
def __str__(self):
return self.__repr__()
def __repr__(self):
return '<%(klass)s start:%(start)s target:%(target)s fadetime:%(fadetime)s sec>' % dict(
klass = self.__class__.__name__,
start = self.__start/100.,
target = self.__target/100.,
fadetime = self.__fadetime,
)
def next(self):
out = self.__start
jetzt = time.time()
#print(self.__start,self.__steps[-1])
if jetzt < self.__steps[-1][1]:
for i in self.__steps:
if jetzt >= i[1]:
out = i[0]
#print(i, jetzt ,jetzt >= i[1])
return out /100.
else:
return self.__steps[-1][0]/100.