[enh] adds clitools

clitools/generators/dummy.py

@@ -0,0 +1,51 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+# -*- mode: Python -*-
+
+
+'''
+
+This is the most basic generator you can imagine: straight up static!
+v0.1.0
+
+Use it to test your filters and outputs
+
+LICENCE : CC
+
+by cocoa 
+
+'''
+
+from __future__ import print_function
+import time
+import argparse
+import sys
+name="generator::dummy"
+
+
+def debug(*args, **kwargs):
+    if( verbose == False ):
+        return
+    print(*args, file=sys.stderr, **kwargs)
+
+
+argsparser = argparse.ArgumentParser(description="Dummy generator")
+argsparser.add_argument("-f","--fps",help="Frame Per Second",default=30,type=int)
+argsparser.add_argument("-v","--verbose",action="store_true",help="Verbose output")
+args = argsparser.parse_args()
+
+fps=args.fps
+verbose=args.verbose
+optimal_looptime = 1 / fps
+debug(name+" optimal looptime "+str(optimal_looptime))
+
+while True:
+  start = time.time()
+  #print("[(100.0, 100.0, 65280), (100.0, 500.0, 65280), (500.0, 500.0, 65280), (500.0, 100.0, 65280), (100.0, 100.0, 65280)]", flush=True);
+  print("[(100.0, 100.0, 65280), (110.0, 500.0, 65280), (510.0, 500.0, 65280), (510.0, 100.0, 65280), (100.0, 110.0, 65280)]", flush=True);
+  looptime = time.time() - start
+  if( looptime < optimal_looptime ):
+    time.sleep( optimal_looptime - looptime)
+    debug(name+" micro sleep:"+str( optimal_looptime - looptime))
+  
+

clitools/generators/example.py

@@ -0,0 +1,182 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+# -*- mode: Python -*-
+
+
+'''
+
+example, based on custom
+v0.1.0
+
+A copy of square.py you can modify to code your plugin.
+custom1 has necessary hooks in LJ.conf, webui and so on.
+
+
+LICENCE : CC
+
+by Sam Neurohack
+
+
+'''
+import sys
+import os
+ljpath = r'%s' % os.getcwd().replace('\\','/')
+
+# import from shell
+sys.path.append(ljpath +'/../../libs/')
+
+#import from LJ
+sys.path.append(ljpath +'/libs/')
+print(ljpath+'/../libs/')
+
+import lj23layers as lj
+
+sys.path.append('../libs')
+import math
+import time
+import argparse
+
+
+print ("")
+print ("Arguments parsing if needed...")
+argsparser = argparse.ArgumentParser(description="Custom1 example for LJ")
+argsparser.add_argument("-v","--verbose",help="Verbosity level (0 by default)",default=0,type=int)
+args = argsparser.parse_args()
+
+# 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)
+
+width = 800
+height = 600
+centerX = width / 2
+centerY = height / 2
+
+# 3D to 2D projection parameters
+fov = 256
+viewer_distance = 2.2
+
+# Anaglyph computation parameters for right and left eyes.
+# algorythm come from anaglyph geo maps 
+eye_spacing = 100
+nadir = 0.5
+observer_altitude = 30000
+map_layerane_altitude = 0.0
+
+# square coordinates : vertices that compose each of the square.
+vertices = [
+        (- 1.0, 1.0,- 1.0),
+        ( 1.0, 1.0,- 1.0),
+        ( 1.0,- 1.0,- 1.0),
+        (- 1.0,- 1.0,- 1.0)
+        ]
+
+face = [0,1,2,3]
+
+#
+# LJ inits
+# 
+
+layer = 0
+
+# Define properties for each drawn "element" : name, intensity, active, xy, color, red, green, blue, layer , closed
+Leftsquare = lj.FixedObject('Leftsquare', True, 255, [], red, 255, 0, 0, layer , True)
+Rightsquare = lj.FixedObject('Rightsquare', True, 255, [], green, 0, 255, 0, layer , True)
+
+# 'Destination' for given layer : name, number, active, layer , scene, laser
+Dest0 = lj.DestObject('0', 0, True, 0 , 0, 0) 	# Dest0 will send layer 0 points to scene 0, laser 0 
+
+
+#
+# Anaglyph computation : different X coordinate for each eye
+#
+
+def LeftShift(elevation):
+
+    diff = elevation - map_layerane_altitude
+                        return nadir * eye_spacing *  diff / (observer_altitude - elevation)
+
+def RightShift(elevation):
+
+    diff = map_layerane_altitude - elevation
+                        return (1 - nadir) * eye_spacing * diff / (observer_altitude - elevation)
+
+
+def Proj(x,y,z,angleX,angleY,angleZ):
+
+    rad = angleX * math.pi / 180
+                cosa = math.cos(rad)
+                sina = math.sin(rad)
+                y2 = y
+                y = y2 * cosa - z * sina
+                z = y2 * sina + z * cosa
+
+                rad = angleY * math.pi / 180
+                cosa = math.cos(rad)
+                sina = math.sin(rad)
+                z2 = z
+                z = z2 * cosa - x * sina
+                x = z2 * sina + x * cosa
+
+                rad = angleZ * math.pi / 180
+                cosa = math.cos(rad)
+                sina = math.sin(rad)
+                x2 = x
+                x = x2 * cosa - y * sina
+                y = x2 * sina + y * cosa
+
+
+                """ Transforms this 3D point to 2D using a perspective projection. """
+                factor = fov / (viewer_distance + z)
+                x = x * factor + centerX
+                y = - y * factor + centerY
+                return (x,y)
+
+
+#
+# Main 
+#
+
+def Run():
+    Left = []
+    Right = []
+    counter =0
+    try:
+      while True: 
+        Left = []
+        Right = []
+        x = vertices[0][0]
+        y = vertices[0][1]
+        z = vertices[0][2]
+
+        # lj tracers will "move" the laser to this first point in black, then move to the next with second point color.
+        # for more accuracy in dac emulator, repeat this first point.
+
+        # generate all points in square.
+        for point in face:
+            x = vertices[point][0]
+                y = vertices[point][1]
+                z = vertices[point][2]
+                left.append(proj(x+leftshift(z*25),y,z,0,counter,0))
+                right.append(proj(x+rightshift(z*25),y,z,0,counter,0))	
+
+
+        lj.polylineonecolor(left, c = leftsquare.color , layer = leftsquare.layer, closed = leftsquare.closed)
+        lj.polylineonecolor(right, c = rightsquare.color , layer = rightsquare.layer, closed = rightsquare.closed)
+        lj.drawdests()
+        time.sleep(0.1)
+        counter += 1
+        if counter > 360:
+            counter = 0
+
+    except KeyboardInterrupt:
+        pass
+
+    # Gently stop on CTRL C
+    finally:
+        lj.ClosePlugin()
+
+
+Run()