removed globals, they were an irritation for to long

Author: Robert van der Tuuk

Ledart/MatrixSim/Interfaces/PygameInterface.py

@@ -14,7 +14,7 @@ def __init__(self, width, height, blocksize, fullscreen=False):
             self.flags |= pygame.FULLSCREEN
         self.window = pygame.display.set_mode((self.width, self.height),
                                               self.flags)
-        if blocksize < 4:
+        if blocksize < 7:
             self.pixelsurface = pygame.Surface((blocksize, blocksize))
         else:
             self.pixelsurface = pygame.Surface((blocksize - 2, blocksize - 2))

Ledart/Patterns/MetaBalls.py

@@ -1,103 +1,9 @@
 from Ledart import Graphics, BLACK, BLUE, RED, WHITE
 from Ledart import translate
-from colorsys import hsv_to_rgb
-import operator
-import random
-import math
-
-class Vector(object):
-    def __init__(self, **axes):
-        super(Vector, self).__setattr__('axes', axes)
-
-    def magnitude(self):
-        """ for every N square it, sum list. take square root. """
-        magnitude = sum([(self.axes[axis] * self.axes[axis]) for axis in self.axes]) ** 0.5
-        return magnitude
-
-    def set_mag(self, mag):
-        self = self.normalize()
-        self *= mag
-
-    def dist(self, other):
-        deltas = [(self.axes[axis] - other.axes[axis]) ** 2 for axis in self.axes]
-        return abs(sum(deltas)) ** 0.5
-
-    def normalize(self):
-        return self.__div__(self.magnitude())
-
-    def limit(self, lim):
-        pass
-
-    def heading(self):
-        pass
-
-    def rotate(self):
-        pass
-
-    def lerp(self):
-        pass
-
-    def angleBetween(self):
-        pass
-
-    def dot(self):
-        pass
-
-    def cross(self):
-        pass
-
-    def randomVec(self):
-        pass
-
-    def __operation__(self, op, val):
-        result = {}
-        if isinstance(val, (int, float)):
-            for axis in self.axes:
-                result[axis] = op(self.axes[axis], val)
-        elif isinstance(val, Vector):
-            for axis in self.axes:
-                result[axis] = op(self.axes[axis], val.axes[axis])
-        else:
-            raise TypeError
-        return Vector(**result)
-
-    def __add__(self, val):
-        return self.__operation__(operator.add, val)
-
-    def __sub__(self, val):
-        return self.__operation__(operator.sub, val)
-
-    def __mul__(self, val):
-        return self.__operation__(operator.mul, val)
-
-    def __div__(self, val):
-        return self.__operation__(operator.div, val)
-
-    def __len__(self):
-        return self.mag()
-
-    def __getattr__(self, attr):
-        if attr in self.axes:
-            return self.axes[attr]
-        elif attr == 'mag':
-            return self.magnitude()
-        else:
-            raise AttributeError
-
-    def __setattr__(self, attr, value):
-        if attr in self.axes:
-            self.axes[attr] = value
-        elif attr == 'mag':
-            self.set_mag(value)
-        else:
-            raise KeyError
-
-    def __str__(self):
-        values = {}
-        values.update(self.axes)
-        values['mag'] = self.mag
-        return str(values)
 
+from colorsys import *
+from Ledart import Vector
+import random
 
 class Ball(object):
     def __init__(self, g=None, x=0, y=0, size=1):
@@ -106,11 +12,12 @@ def __init__(self, g=None, x=0, y=0, size=1):
         self.pos = Vector(x=x, y=y)
         self.size = size
         self.g = g
-        self.mass = self.size
+        self.mass = self.size ** 6 / 2
         self.max_speed = 0
 
     def update(self):
         self.speed += self.accel
+        self.speed *= 0.998
         self.pos += self.speed
         self.accel *= 0
 
@@ -129,7 +36,7 @@ def handle_collision(self):
             self.speed.y *= -1
 
     def draw(self):
-        self.g.draw_circle(self.pos.x, self.pos.y, self.size, BLUE)
+        self.g.draw_circle(self.pos.x, self.pos.y, self.size, BLACK)
 
 
 class MetaBalls(Graphics):
@@ -144,6 +51,9 @@ def __init__(self, **kwargs):
             # ball.speed += random.randint(20, 80) / 100.
             self.balls.append(ball)
         self.max = 0
+        self.totalballsize = 0
+        for ball in self.balls:
+            self.totalballsize += ball.size
 
     def generate(self):
         self.fill(BLACK)
@@ -156,19 +66,22 @@ def generate(self):
                 distance = (ball.pos.dist(Vector(x=x, y=y)) + 1)
                 sumc += ball.size / distance
 
-            color = min(sumc * 80, 0xff) / 0xff
-            self[point] = [int(c * 0xff) for c in hsv_to_rgb(color, 1, 1)]
+            # color = min(sumc * 80, 0xff) / 0xff
+            # print(sumc)
+            colorfunc = hsv_to_rgb
+            color = min(sumc * (0x80 - self.totalballsize), 0xff) / 0xff
+            self[point] = [int(c * 0xff) for c in colorfunc(1 - color, 1, 1)]
+
 
         for ball in self.balls:
             ball.update()
-            ball.draw()
+            # ball.draw()
             for otherball in self.balls:
-                if ball != otherball:
+                if ball != otherball: #and ball.pos.dist(otherball.pos) < self.width / 4:
                     force = ball.pos - otherball.pos
                     dist = max(force.mag, ball.size)
                     force = force.normalize()
-                    G = 0.01
+                    G = 6.67191*(10**-11)
                     strength = (G * ball.mass * otherball.mass) / (dist ** 2)
                     force *= strength
                     ball.accel -= force
-            # print(ball.speed)

Ledart/Tools/Vector.py

@@ -0,0 +1,103 @@
+import operator
+import math
+
+
+class Vector(object):
+    def __init__(self, **axes):
+        super(Vector, self).__setattr__('axes', axes)
+
+    def magnitude(self):
+        """ for every N square it, sum list. take square root. """
+        magnitude = sum([(self.axes[axis] * self.axes[axis]) for axis in self.axes]) ** 0.5
+        return magnitude
+
+    def set_mag(self, mag):
+        self = self.normalize()
+        self *= mag
+
+    def dist(self, other):
+        deltas = [(self.axes[axis] - other.axes[axis]) ** 2 for axis in self.axes]
+        return abs(sum(deltas)) ** 0.5
+
+    def normalize(self):
+        m = self.magnitude()
+        if m:
+            return self / m
+
+        return self * 0
+
+    def limit(self, lim):
+        if self.mag > lim:
+            self = self.normalize()
+            self *= lim
+        return Vector(**self.axes)
+
+    def heading(self):
+        pass
+
+    def rotate(self):
+        pass
+
+    def lerp(self):
+        pass
+
+    def angleBetween(self):
+        pass
+
+    def dot(self):
+        pass
+
+    def cross(self):
+        pass
+
+    def randomVec(self):
+        pass
+
+    def __operation__(self, op, val):
+        result = {}
+        if isinstance(val, (int, float)):
+            for axis in self.axes:
+                result[axis] = op(self.axes[axis], val)
+        elif isinstance(val, Vector):
+            for axis in self.axes:
+                result[axis] = op(self.axes[axis], val.axes[axis])
+        else:
+            raise TypeError
+        return Vector(**result)
+
+    def __add__(self, val):
+        return self.__operation__(operator.add, val)
+
+    def __sub__(self, val):
+        return self.__operation__(operator.sub, val)
+
+    def __mul__(self, val):
+        return self.__operation__(operator.mul, val)
+
+    def __div__(self, val):
+        return self.__operation__(operator.div, val)
+
+    def __len__(self):
+        return self.mag
+
+    def __getattr__(self, attr):
+        if attr in self.axes:
+            return self.axes[attr]
+        elif attr == 'mag':
+            return self.magnitude()
+        else:
+            raise AttributeError
+
+    def __setattr__(self, attr, value):
+        if attr in self.axes:
+            self.axes[attr] = value
+        elif attr == 'mag':
+            self.set_mag(value)
+        else:
+            raise KeyError
+
+    def __str__(self):
+        values = {}
+        values.update(self.axes)
+        values['mag'] = self.mag
+        return str(values)

Ledart/Tools/__init__.py

@@ -3,4 +3,4 @@
 from Ledart.Tools.NumberSegmentBitMap import *
 from Ledart.Tools.Palet import *
 from Ledart.Tools.Timing import *
-
+from Ledart.Tools.Vector import *

Ledart/configs/pattern_conf.py

@@ -24,7 +24,7 @@
 # protocol = LegacyLmcp(dispmode=rgb24)
 
 matrixsim = MatrixScreen(dims=dims,
-                         pixelsize=1,
+                         pixelsize=4,
                          fullscreen=False,
                          interface=interface_opts["pygame"])
 
@@ -49,7 +49,7 @@
     # dest: DisplayImage(dims=dims, fname='/home/duality/Pictures/System-Shock-2.jpg'),
     # dest: VideoPlay(dims=dims, fname='/home/duality/Videos/bad-noshadow.mp4'),
     # dest: VideoPlay(dims=dims, fname='/home/duality/Videos/bad.mkv'),
-    dest: CamCapture(dims=dims),
+    # dest: CamCapture(dims=dims),
     # dest: Water(dims=dims),
     # dest: AliasedWPlasma(dims=dims),
     # dest: AliasedFire(dims=dims),
@@ -72,7 +72,7 @@
     # dest: GraphicsPixelTest(dims=dims),
     # dest: GraphicsDotTest(dims=dims),
     # dest: SpiroGraph(dims=dims),
-    # dest: MetaBalls(dims=dims),
+    dest: MetaBalls(dims=dims),
     # dest: VUmeter(dims=dims)
 
     # dest: Fft(dims=dims, mode=1),

Ledart/runPatternJob.py

@@ -19,7 +19,6 @@
 from utils import matrix
 
 basepath = os.path.dirname(os.path.realpath(__file__))
-protocol, matrixscreen, targets = None, None, None
 
 
 def tst_patterns(directory, showpass=False):
@@ -56,7 +55,7 @@ def listpatterns():
         print(pattern)
 
 
-def sendout(args, targets, protocol):
+def sendout(args, targets, protocol, matrixsim):
     # sendout function that sends out data to the networked devices and
     # also to the matrix screen simulator if enabled.
     # or only to the matrix simulator if no pattern is selected.
@@ -65,9 +64,9 @@ def sendout(args, targets, protocol):
             pattern = targets[t]
             # generate the next set of images to send.
             pattern.generate()
-            if matrixscreen:
-                matrixscreen.handleinput()
-                matrixscreen.process(pattern)
+            if matrixsim:
+                matrixsim.handleinput()
+                matrixsim.process(pattern)
             if args.sendOnChange:
                 changed = (Surface(pattern) != Surface(sendout.previous))
                 sendout.previous = Surface(pattern)
@@ -121,10 +120,7 @@ def main():
         cleanup(4)
     else:
         # load config
-        global targets
-        global protocol
-        global matrixscreen
-        targets, protocol, matrixscreen = load_targets(args.config)
+        targets, protocol, matrixsim = load_targets(args.config)
 
         # check if there is anything configured.
         if not len(targets):
@@ -160,9 +156,9 @@ def main():
                 sys.stdout.write(fmtstr % fmt)
                 sys.stdout.flush()
             if args.fps > 0:
-                sendout(args, targets, protocol)
+                sendout(args, targets, protocol, matrixsim)
                 time.sleep(abs(fps))
             # else send everything out as fast as possible
             else:
-                sendout(args, targets, protocol)
+                sendout(args, targets, protocol, matrixsim)
             previousTime = currentTime

Ledart/utils.py

@@ -135,14 +135,14 @@ def load_targets(configfile):
 
     targets = variables.get('targets', None)
     protocol = variables.get('protocol', None)
-    matrix_sim = variables.get('matrixsim', None)
+    matrixsim = variables.get('matrixsim', None)
 
     # print("configfile: %s" % configfile)
     # print("protocol: %s" % protocol)
     # print("matrixsim: %s" % matrix_sim)
     # print("targets: %s" % (str(targets)))
 
-    return (targets, protocol, matrix_sim)
+    return (targets, protocol, matrixsim)
 
 def checkList(first, second):
     for item1, item2 in zip(first, second):