NUI Paint - Python

from __future__ import with_statement

from pymt import *

from pyglet.gl import *

from numpy import *

import string

class Canvas(MTScatterWidget):

    def __init__(self, **kwargs):

        super(Canvas, self).__init__(**kwargs)

        self.width = 500

        self.height = 400

        self.fbo = Fbo(size=(self.width, self.height), with_depthbuffer=False)

        self.color = (0,1,0,1.0)

        set_brush('brushes/brush_particle.png')

        self.layer_clear()

        self.touch_positions = {}

        self.mode = "zoom"

        set_brush_size(25)

        self.brush_color=(0,0,0,1)

    def layer_clear(self):

        self.fbo.bind()

        glClearColor(0,0,0,0)

        glClear(GL_COLOR_BUFFER_BIT)

        self.fbo.release()

    def on_touch_down(self, touches, touchID, x, y):

        if self.collide_point(x,y): 

            self.touch_positions[touchID] = self.to_local(x,y)            

            if self.mode == "draw":

                self.fbo.bind()

                set_color(*self.brush_color)

                set_brush('brushes/brush_particle.png')

                set_brush_size(25)

                drawCircle(pos=self.to_local(x,y), radius=1)            

                self.fbo.release()

            elif self.mode == "zoom":

                super(Canvas, self).on_touch_down(touches, touchID, x, y)

            elif self.mode == "smudge":

                self.do_smudge(self.touch_positions[touchID][0],self.touch_positions[touchID][1])

            return True

    def on_touch_move(self, touches, touchID, x, y):

        if self.touch_positions.has_key(touchID):

            if self.mode == "zoom":

                super(Canvas, self).on_touch_move(touches, touchID, x, y)

            elif self.mode == "draw":

                cur_pos = self.to_local(x,y)

                ox,oy = self.touch_positions[touchID]

                self.fbo.bind()

                set_color(*self.brush_color)

                set_brush('brushes/brush_particle.png')

                set_brush_size(25)

                paintLine((ox,oy,cur_pos[0],cur_pos[1]))

                self.fbo.release()

                self.touch_positions[touchID] = self.to_local(x,y)

            return True

    def draw(self):

        with gx_matrix:

            glColor4f(1,1,1,1)

            drawRectangle((-6,-6),(self.width+12,self.height+12))

            glScaled(float(self.width)/500, float(self.height)/400, 2.0)            

            with gx_blending:

                drawTexturedRectangle(self.fbo.texture, (-6,-6),(self.width+12,self.height+12))

    def set_mode(self,mode):

        self.mode = mode

    def set_brush_color(self,color):

        self.brush_color = color

    def do_smudge(self, x, y):

        # First, extract region from texture

        region = self.fbo.texture.get_region(int(x) - 16, int(y) - 16, 32, 32)

        data = region.get_image_data()

        # Extract pixels                

        format = 'RGB'

        pitch = 32 * len(format)       

        pixel_data = data.get_data(format, pitch)

        pixels_list = map(ord, list(pixel_data))

        pixels = zeros((32,32,3), float)

        z = 0

        for i in range(0,31):

            for j in range(0,31):

                for k in range(0,2):

                    pixels[i,j,k] = pixels_list[z]

                    z += 1				

        #work

        state=zeros((32,32,3), float)

        rate = 0.5

        #i = 32 * 32;

        for i in range (32*32,0,-1) :

            iy = i >> 5

            ix = i & 0x1f

            # is it not on the circle of radius sqrt(120) at location 16,16?

            if (ix - 16) * (ix - 16) + (iy - 16) * (iy - 16) > 120 :

                continue

            # it is on the circle, so grab it

            # Get color

            r = float(pixels[ix,iy,0])/float(255)

            g = float(pixels[ix,iy,1])/float(255)

            b = float(pixels[ix,iy,02])/float(255)

            #print r,g,b

            state[ix,iy,0] = rate * state[ix,iy,0] + (1.0 - rate) * r

            state[ix,iy,1] = rate * state[ix,iy,1] + (1.0 - rate) * g

            state[ix,iy,2] = rate * state[ix,iy,2] + (1.0 - rate) * b

        #put back pixel

        z = 0

        for i in range(0,31):

            for j in range(0,31):

                for k in range(0,2):

                    pixels_list[z] = pixels[i,j,k]

                    z += 1

        data.set_data(format, pitch, ''.join(map(chr, pixels_list)))

        texture = data.get_texture()

        # Draw texture on Fbo

        with self.fbo:

            drawTexturedRectangle(texture, pos=(x - 16, y - 16), size=(32, 32))    

from layermanager import *

        self.canvas_area = MTStencilContainer(pos=(20,20),size=(self.width-40,self.height-40))

        self.add_widget(self.canvas_area)

        self.layer_manager = LayerManager(pos=(20,20),canvas=self,size=(self.width-40,self.height-40))

        self.canvas_area.add_widget(self.layer_manager)

            glColor4f(0,0,0,1)

            drawRectangle((0,0),(self.width,self.height))

        self.layer_manager.set_mode(mode)

    def create_layer(self,pos=(0,0),size=(200,200),color=(0,0,0,0.5)):

        self.layer_manager.create_layer(pos=pos,size=size,color=color)

    def save_image(self):

        with self.fbo:

            self.layer_manager.background.dispatch_event('on_draw')

            for layer in self.layer_manager.layer_list :

                layer.dispatch_event('on_draw')

		data = (self.fbo.texture).get_image_data()

        data.save(file='test.png')

        self.layer_manager.set_brush_color(color)

    def set_brush(self,sprite,size):

        self.layer_manager.set_brush(sprite,size)

    def collide_point(self, x,y):

        local_coords = self.to_local(x,y)

        if local_coords[0] > 0 and local_coords[0] < self.width \

           and local_coords[1] > 0 and local_coords[1] < self.height:

            return True

        else:

            return False

if __name__ == '__main__':

    w = MTWindow()

    canvas = Canvas(size=(540,440),pos=(w.width/2-260,w.height/2-120))

    w.add_widget(canvas)

    draw_but = MTButton(label="Painting")

    w.add_widget(draw_but)

    @draw_but.event    

    def on_press(touchID, x, y):

        canvas.set_mode(mode='draw')

    zoom_but = MTButton(label="Layering",pos=(draw_but.width+5,0))

    w.add_widget(zoom_but)

    @zoom_but.event    

    def on_press(touchID, x, y):

        canvas.set_mode(mode='zoom')

    add_but = MTButton(label="Save",pos=(draw_but.width+zoom_but.width+10,0))

    @add_but.event    

    def on_press(touchID, x, y):

        canvas.save_image()

    w.add_widget(add_but)

    canvas.create_layer(pos=(100,100),size=(200,200),color=(1,0,0,0.8))

    canvas.create_layer(size=(300,200),color=(0,1,0,0.8))

    canvas.create_layer(size=(250,150),color=(0,0,1,0.8))

    runTouchApp()

        self.color = kwargs.get('color')        

                    set_color(*self.layer_manager.brush_color)

                    set_brush(self.layer_manager.brush_sprite,self.layer_manager.brush_size)

                    set_color(*self.layer_manager.brush_color)

                    set_brush(self.layer_manager.brush_sprite,self.layer_manager.brush_size)

                drawTexturedRectangle(self.fbo.texture, (0,0),(self.width,self.height))

        #self.size = self.canvas.size

        self.brush_color = (0,0,0,1)

        self.brush_sprite = "brushes/brush_particle.png"

        self.brush_size = 25

        self.background = NormalLayer(size=self.size,color=(1,1,1,1),moveable=False,layer_manager=self)

    def set_brush_color(self,color):

        self.brush_color = color

    def set_brush(self,sprite,size):

        self.brush_sprite = sprite

        self.brush_size = size

from math import cos,sin,radians,pi

from glob import glob

class MTCircularItem(MTButton):

    def __init__(self, **kwargs):

        kwargs.setdefault('scale', 1.0)

        kwargs.setdefault('filename', None)

        if kwargs.get('filename') is None:

            raise Exception('No filename given to Item')

        super(MTCircularItem, self).__init__(**kwargs)

        self.action_handler = kwargs.get('handler')

        self.action_value = kwargs.get('value')

        self.filename		= kwargs.get('filename')

        self.scale          = kwargs.get('scale')

        self.image.scale    = self.scale

        self.size           = (self.image.width, self.image.height)

        self.x = self.x-self.width/2

        self.y = self.y-self.height/2

        self.image.x        = self.x

        self.image.y        = self.y

    def collide_point(self, x, y):

        if( x > self.x-self.width/2  and x < self.x+self.width/2 and

           y > self.y-self.height/2 and y < self.y+self.height/2  ):

            return True

    def on_press(self, touchID, x, y):

        self.action_handler(sprite=self.action_value,size=25)

    def _get_filename(self):

        return self._filename

    def _set_filename(self, filename):

        self._filename = filename

        img            = pyglet.image.load(filename)

        self.image     = pyglet.sprite.Sprite(img)

    filename = property(_get_filename, _set_filename)

    def on_draw(self):

        self.image.x        = self.x-self.width/2

        self.image.y        = self.y-self.height/2

        self.image.scale    = self.scale

        self.size           = (self.image.width, self.image.height)

        self.image.draw()

class MTCircularMenu_Manager(MTWidget):

        super(MTCircularMenu_Manager, self).__init__(**kwargs)

        self.canvas = kwargs.get('canvas')

        self.pos = kwargs.get('pos')

        self.radius = kwargs.get('radius')

        kt = MTKinetic(velstop=5.0)

        self.circular_menu = MTCircularMenu(pos=self.pos,radius=self.radius)

        kt.add_widget(self.circular_menu)

        self.add_widget(kt)

        brush_list = []

        #by default generate a brushes list in circular menu        

        for brush in glob('brushes/*.png'):

            brush_list.append([brush,self.canvas.set_brush,brush])

        self.set_list(list=brush_list)

    def set_list(self,list):

        for item in list:

            im = MTCircularItem(filename=item[0],handler=item[1],value=item[2])

            self.circular_menu.add_widget(im)

class MTCircularMenu(MTScatterWidget):

    def __init__(self, **kwargs):

        kwargs.setdefault('do_scale', False)

        kwargs.setdefault('do_rotation', True)

        kwargs.setdefault('do_translation', False)

        self.radius = kwargs.get('radius')

        self.size = (self.radius*2,self.radius*2)

        self.pos = kwargs.get('pos')

        super(MTCircularMenu, self).init_transform(self.pos, 0, 1)

    def add_widget(self, widget, do_layout=True):

        super(MTCircularMenu, self).add_widget(widget)

        self.need_layout = True

        if do_layout:

            self.do_layout()

    def do_layout(self):

        x = int((self.radius-40)*cos(radians(20*(len(self.children)-1))))

        y = int((self.radius-40)*sin(radians(20*(len(self.children)-1))))

        self.children[len(self.children)-1].x = x

        self.children[len(self.children)-1].y = y

    def rotate_zoom_move(self, touchID, x, y):

        # we definitly have one point

        p1_start = Vector(*self.touches[touchID])

        p1_now   = Vector(x, y)

        # if we have a second point, do the scale/rotate/move thing

        # find intersection between lines...the point around which to rotate

        intersect = Vector(self.pos)

        # compute rotation angle

        old_line = p1_start - intersect

        new_line = p1_now - intersect

        rotation = -1.0 * old_line.angle(new_line)

        scale = 1.0

        # just comnpute a translation component if we only have one point

        trans = p1_now - p1_start

        # apply to our transformation matrix

        self.apply_angle_scale_trans(rotation, scale, trans, intersect)

        # save new position of the current touch

        self.touches[touchID] = Vector(x,y)

    def draw(self):

        #set_color(0,1,0,1)

        #drawCircle((0,0), 10)

        set_color(*self.style.get('bg-color'))

        #drawRectangle((0,0),self.size)

        drawCircle((0,0), self.radius)

        #drawCircle(self.pos, self.radius-64)

        #drawTriangle(self.pos, w=40, h=100)

    cm = MTCircularMenu_Manager(pos=(0,0))

    w.add_widget(cm)  

    cv = Canvas(size=(540,440),pos=(w.width/2-260,w.height/2-120))

    w.add_widget(cv) 

    #cv.create_layer(pos=(100,100),size=(200,200),color=(1,0,0,0.2))

    #cv.create_layer(size=(300,200),color=(0,1,0,0.2))

    #cv.create_layer(size=(250,150),color=(0,0,1,0.2))    

    w.add_widget(tb)    

    cm = MTCircularMenu_Manager(pos=(-225,-225),radius=225,canvas=cv)

    w.add_widget(cm)