Changeset 288

Timestamp:

12/30/07 20:56:37 (12 months ago)

Author:

tom

Message:

added canvas.layer_pixels() and pixels.set_pixel()

Location:

libraries/coreimage

Files:

• __init__.py (modified) (15 diffs)
• coreimage-example5.py (modified) (4 diffs)
• coreimage-example6.py (modified) (3 diffs)

libraries/coreimage/__init__.py

@@ -5 +5 @@
 
 __author__    = "Tom De Smedt"
-__version__   = "1.9.1"
+__version__   = "1.9.2"
 __copyright__ = "Copyright (c) 2007 Tom De Smedt"
 __license__   = "MIT"
@@ -37 +37 @@
 LAYER_LAYERS          = "layers"
 LAYER_PATH            = "path"
+LAYER_PIXELS          = "pixels"
 LAYER_CIIMAGEOBJECT   = "CIImageobject"
 LAYER_NSIMAGEDATA     = "NSImageData"
@@ -321 +322 @@
         except: pass
         
+        # Pixels
+        # A one-dimensional list of color objects.
+        try:
+            clr, w, h = data[0][0], data[1], data[2]
+            r, g, b, a = clr.r, clr.g, clr.b, clr.a
+            type = LAYER_PIXELS
+            return _add_layer(data, type, x, y, w, h)
+        except: pass
+        
         # Core Image CIImage object.
         try:
@@ -420 +430 @@
         
         return self.layer((path, background, foreground, stroke, strokewidth), LAYER_PATH, x, y, w, h, name)
+
+    def layer_pixels(self, colors, w, h,
+                     x=None, y=None, name=""):
+        
+        """ Adds a new layer from a list of pixel colors.
+        """
+        
+        return self.layer((colors, w, h), LAYER_PIXELS, x, y, w, h, name)
     
     def layer_bytes(self, data, 
@@ -427 +445 @@
         
         Creates an NSImage from the data.
-        This method is should go somewhere because it references Cocoa.
+        This method should go somewhere else because it references Cocoa.
         
         """
@@ -580 +598 @@
     def is_file(self)            : return (self.type == LAYER_FILE)
     def is_fill(self)            : return (self.type == LAYER_FILL)    
-    def is_gradient(self)        : return (self.type == LAYER_LINEAR_GRADIENT)    
+    def is_gradient(self)        : return (self.type == LAYER_LINEAR_GRADIENT or
+                                           self.type == LAYER_RADIAL_GRADIENT)    
     def is_linear_gradient(self) : return (self.type == LAYER_RADIAL_GRADIENT)
     def is_radial_gradient(self) : return (self.type == LAYER_LINEAR_GRADIENT)    
     def is_path(self)            : return (self.type == LAYER_PATH)
+    def is_pixels(self)          : return (self.type == LAYER_PIXELS)
+    def is_group(self)           : return (self.type == LAYER_LAYERS)
     def has_layers(self)         : return (self.type == LAYER_LAYERS)
     def is_mask(self)            : return (self.canvas._parent != None and 
@@ -661 +682 @@
         if self.type == LAYER_PATH:
             data = (self.data[0].copy(), Color(self.data[1]), Color(self.data[2]), Color(self.data[3]), self.data[4])
+        if self.type == LAYER_PIXELS:
+            data = self.data
         if self.type == LAYER_CIIMAGEOBJECT:
             data = self.data
@@ -1418 +1441 @@
                 path.stroke()            
             img.unlockFocus()
+            img = img.TIFFRepresentation()
+            img = CIImage.alloc().initWithData_(img)
+        
+        if type == LAYER_PIXELS:
+            
+            # The layer's source is a list of pixel colors.
+            # Duane Bailey, http://nodebox.net/code/index.php/shared_2007-12-28-23-34-57
+            # If there is more width*height than there are pixels,
+            # the bitmap will be completed with transparent pixels.
+            
+            p, w, h = data
+            import Numeric
+            raw = Numeric.array([0] * w*h*4, typecode='c')
+            for i in range(len(p)):
+                raw[i*4+0] = p[i].r * 255
+                raw[i*4+1] = p[i].g * 255
+                raw[i*4+2] = p[i].b * 255
+                raw[i*4+3] = p[i].a * 255
+            raw = (raw, None, None, None, None)
+            img = NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
+                raw, w, h, 8, 4, True, False, NSDeviceRGBColorSpace, w * 4, 32
+            )
             img = img.TIFFRepresentation()
             img = CIImage.alloc().initWithData_(img)
@@ -2416 +2461 @@
         self._img = self._img.TIFFRepresentation()
         self._img = NSBitmapImageRep.imageRepWithData_(self._img)
-        
-        raw = self._img.bitmapData()
-        a = Numeric.fromstring(raw, Numeric.UnsignedInt8)
-        
+
         self.channels = self._img.samplesPerPixel()
-        self.pixels = Numeric.reshape(a, (self.w*self.h, self.channels))
-        
-        if self.is_rgb():
-            self.r = self.pixels[:,0] 
-            self.g = self.pixels[:,1]
-            self.b = self.pixels[:,2]
-            self.a = None
-            if self.has_alpha(): self.a = self. pixels[:,3]
-    
+
     def is_rgb(self):
         
@@ -2440 +2474 @@
     def get_pixel(self, x, y):
         
-        """ Returns color values for the pixel at x, y.
-        """
-        
-        if 0 <= x < self.w and 0 <= y < self.h:
-            return list(self.pixels[x+y*self.w])
-        else:
-            return None
-    
-    def min(self, transparency=False, treshold=0):
+        """ Returns color for the pixel at x, y.
+        """
+        
+        return _ctx.color(self._img.colorAtX_y_(x, y))
+        
+    def set_pixel(self, x, y, clr):
+        
+        """ Sets the pixel at x, y with the given color.
+        """
+        
+        self._img.setColor_atX_y_(clr._rgb, x, y)
+
+    def update(self):
+        
+        """ Updates the layer with the changes from set_pixel().
+        """
+        
+        self.layer.data = self._img.TIFFRepresentation()
+        self.layer.type = LAYER_NSIMAGEDATA
+
+    def _array(self, int=8):
+        
+        """ All the pixel color values as a lists of integers.
+        """
+        
+        bytes = self._img.bitmapData()
+        a = Numeric.fromstring(bytes, Numeric.UnsignedInt8)
+        a = Numeric.reshape(a, (self.w*self.h, self.channels))
+        if int == 32:
+            a = a.astype(Numeric.UnsignedInt32)
+        
+        return a
+    
+    def min(self, transparency=False, threshold=0):
         
         """ Returns the lowest color values in the image.
         
         By default, transparent pixels (alpha=0) are
-        not searched. The treshold defines the cutoff,
-        for example treshold=100 means that all pixels with alpha
-        less than 100 are not taken into account.
-        
-        """
-
-        a = self.pixels.astype(Numeric.UnsignedInt32)
+        not searched. The threshold defines the cutoff,
+        for example threshold=0.1 means that all pixels with alpha
+        less than 10% are not taken into account.
+        
+        """
+
+        if isinstance(threshold, int): 
+            threshold /= 255.0
+            
+        a = self._array(int=32)
         if transparency == False and self.has_alpha():
-            i = Numeric.nonzero(Numeric.greater(self.a, treshold))
+            i = Numeric.nonzero(Numeric.greater(self.a, threshold))
             a = Numeric.take(a, i)
         
@@ -2468 +2530 @@
         for j in range(self.channels):
             v.append(a[i[j]][j])
-        return v
-    
-    def max(self, transparency=False, treshold=0):
+        
+        # Return a color object:
+        clr = _ctx.color(0)
+        clr.r, clr.g, clr.b = v[0]/255.0, v[1]/255.0, v[2]/255.0
+        if self.has_alpha(): 
+            clr.a = v[3]/255.0
+        return clr
+    
+    def max(self, transparency=False, threshold=0):
 
         """ Returns the highest color values in the image.
         """
 
-        a = self.pixels.astype(Numeric.UnsignedInt32)
+        if isinstance(threshold, int): 
+            threshold /= 255.0
+        
+        a = self._array(int=32)
         if transparency == False and self.has_alpha():
-            i = Numeric.nonzero(Numeric.greater(self.a, treshold))
+            i = Numeric.nonzero(Numeric.greater(self.a, threshold))
             a = Numeric.take(a, i)
         
@@ -2484 +2555 @@
         for j in range(self.channels):
             v.append(a[i[j]][j])
-        return v
-        
-    def average(self, transparency=False, treshold=0):
+        
+        # Return a color object:
+        clr = _ctx.color(0)
+        clr.r, clr.g, clr.b = v[0]/255.0, v[1]/255.0, v[2]/255.0
+        if self.has_alpha(): 
+            clr.a = v[3]/255.0
+        return clr
+        
+    def average(self, transparency=False, threshold=0):
         
         """ Returns the average color values in the image.
         """
         
-        a = self.pixels.astype(Numeric.UnsignedInt32)
-        n = len(self.pixels)
-        
+        a = self._array(int=32)
+        n = len(a)
+        
+        if isinstance(threshold, int): 
+            threshold /= 255.0
         if transparency == False and self.has_alpha():
-            i = Numeric.nonzero(Numeric.greater(self.a, treshold))
+            i = Numeric.nonzero(Numeric.greater(self.a, threshold))
             a = Numeric.take(a, i)
             n = len(i)
@@ -2504 +2583 @@
         for i in range(self.channels):
             v.append(int(a[i]))
-        return v
+        
+        # Return a color object:
+        clr = _ctx.color(0)
+        clr.r, clr.g, clr.b = v[0]/255.0, v[1]/255.0, v[2]/255.0
+        if self.has_alpha(): 
+            clr.a = v[3]/255.0
+        return clr
         
     def histogram(self, channel=None, helper=False):
@@ -2517 +2602 @@
         """
         
+        a = self._array()
+        
         bins = Numeric.arange(1, 255, 1)
         v = []
         for i in range(self.channels):
-            p = self.pixels[:,i]
+            p = a[:,i]
         
             # From the NumPy searchsorted() documentation.
@@ -2903 +2990 @@
     c.draw()
 
+# 1.9.2
+# Added layers_pixels() to Canvas.
+# Added set_pixel() to CoreImagePixels.
+# All of the CoreImagePixels methods, except histogram(),
+# now use color() objects instead of lists of R,G,B values.
+
 # 1.9.0
 # Layers from bytes (e.g. download stream) can be created with Canvas.layer_bytes().

libraries/coreimage/coreimage-example5.py

@@ -1 @@
-size(500, 500)
+# Coffee dynamics.
 
 try: 
@@ -7 +7 @@
     reload(coreimage)
 
+size(500, 500)
 speed(30)
 def setup():
@@ -24 +25 @@
     
     # The bottom layer is a brownish fill color.
-    l = canvas.layer_fill(color(0.2,0.15,0))
+    l = canvas.layer_fill(color(0.07,0.05,0))
 
     if not copy:
@@ -30 +31 @@
         # construct a layer from an outlined text path.
         fontsize(100)
-        p = textpath("SMOKE", 0, 50)
-        copy = canvas.layer_path(p, foreground=color(1))
+        p = textpath("COFFEE", 0, 50)
+        copy = canvas.layer_path(p, foreground=color(1,1,0.95))
     else:
         # During the next frames of the animation,

libraries/coreimage/coreimage-example6.py

@@ -50 +50 @@
 c.draw()
 
-"""
+
 # Some fun converting pixels to curves.
 # Uncomment the code below to grow grass on a sphere.
-
+"""
 l.adjust_contrast(1.1)
 
 p = l.pixels()
 
-colormode(RGB, 255)
 nofill()
 strokewidth(0.25)
@@ -73 +72 @@
         # more requires to much processing and clogs the image.
         if random() > 0.5:
-            r,g,b,a = p.get_pixel(i,j)
+            clr = p.get_pixel(i,j)
             
             # We don't draw curves on black pixels.
-            if not (r == g == b == 0):
+            if not (clr.r == clr.g == clr.b == 0):
                 
                 # The actual location of the curve
@@ -88 +87 @@
                 dy = y-l.y
                 dh = 20
-                
-                c = color(r, g, b)
-                c.b += random(1.5)
-                stroke(c)
-                
+
+                stroke(clr)
                 beginpath(x, y)
                 curveto(x+random(dh),