p5-python 0.5.5__tar.gz → 0.6.29__tar.gz

{p5-python-0.5.5 → p5-python-0.6.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: p5-python
-Version: 0.5.5
+Version: 0.6.29
 Summary: A package wrapping pygame functionality in p5.js calling conventions.
 Home-page: https://github.com/gromko/p5-python
 Author: Grygoriy Gromko

{p5-python-0.5.5 → p5-python-0.6.29}/p5/__init__.py

@@ -1,10 +1,10 @@
 import os
 os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
 
-from p5.corefunctions import (run, createCanvas, saveCanvas, angleMode,
-                              line, ellipse, circle, rect, quad, arc, triangle,
-                              point, beginShape, vertex, curveVertex,
-                              endShape, cursor, strokeWeight, noStroke, 
+from p5.corefunctions import (run, createCanvas, saveCanvas, angleMode, rectMode, ellipseMode,
+                              line, ellipse, circle, rect, quad, arc, triangle, bezier,
+                              point, beginShape, vertex, curveVertex, curve, bezierVertex,
+                              endShape, cursor, strokeWeight, noStroke, loadPixels, updatePixels, 
                               loadImage, image, keyIsDown, frameRate, loop, noLoop,  
                               background,text,textFont, textSize, textStyle, textAlign)
 
@@ -24,26 +24,25 @@ from p5.color import (fill,noFill, stroke, red, green, blue, brightness, hue, li
 
 from p5.timedata import (hour, minute, second, day, month, year, milli_sec,  millis)
 
-from p5.drawcurve import (bezier,spline)
-
 from p5.transform import (scale, rotate, translate,  push, pop, resetMatrix)
 
-__all__ = ["run", "createCanvas", "translate", "background", "fill", "noFill", "line", "ellipse", "circle", "rect", "triangle", "quad", "arc",
+
+__all__ = ["run", "createCanvas", "translate", "background", "fill", "noFill", "line", "ellipse", "circle", "rect", "triangle", "quad", "arc", 
     "push", "pop", "cursor", "TWO_PI", "HALF_PI", "PI", "QUARTER_PI", "TAU", "CURSOR_ARROW", "CURSOR_DIAMOND", "CURSOR_BROKEN_X", "CURSOR_TRI_LEFT",
     "CURSOR_TRI_RIGHT", "BOLD", "ITALIC", "BOLDITALIC", "NORMAL", "strokeWeight", "stroke", "noStroke", "loadImage", "image", "point", "CORNER", "CORNERS", "RADIUS",
      "frameRate", "random", "constrain", "floor", "ceil", "dist", "exp", "lerp", "log", "log10", "log2", "logb", "mag", "textAlign", "CHORD", "PIE", "OPEN", "ARC",
     "rerange", "norm", "sq", "sqrt", "frac", "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "degrees",    "radians", "loop", "noLoop", "integral",
-    "text","textFont", "textSize", "textStyle","beginShape", "vertex", "endShape", "keyIsDown", "saveCanvas", "scale", "rotate", "translate",
+    "text","textFont", "textSize", "textStyle","beginShape", "vertex", "endShape", "keyIsDown", "saveCanvas", "scale", "rotate", "translate", "rectMode", "ellipseMode",
     "BACKSPACE","TAB","RETURN","ENTER","PAUSE","ESCAPE","SPACE","DELETE","EXCLAIM","QUOTEDBL","HASH","DOLLAR","AMPERSAND","QUOTE","LEFTPAREN","RIGHTPAREN",
     "ASTERISK","PLUS","COMMA","MINUS","PERIOD","SLASH","COLON","SEMICOLON","LESS","EQUALS","GREATER","QUESTION","AT","LEFTBRACKET","RIGHTBRACKET","CARET",
     "UNDERSCORE","BACKQUOTE","UP","DOWN","RIGHT","LEFT","UP_ARROW","DOWN_ARROW","LEFT_ARROW","RIGHT_ARROW","INSERT","HOME","END","PAGEUP","PAGEDOWN","PGUP",
     "PGDN","KP0","KP1","KP2","KP3","KP4","KP5","KP6","KP7","KP8","KP9","KP_PERIOD","KP_DIVIDE","KP_MULTIPLY","KP_MINUS","KP_PLUS","F1","F2","F3","F4","F5",
     "F6","F7","F8","F9","F10","F11","F12","NUMLOCK","CAPSLOCK","SCROLLOCK","RSHIFT","LSHIFT","RCTRL","LCTRL","RALT","LALT","RMETA","LMETA","CONTEXTMENU",
-    "PRINT","SYSREQ","BREAK","MENU","CENTER","CLOSE", "pow", "map", "angleMode", "curveVertex", "randomSeed", "resetMatrix",
-    "hour", "minute", "second", "day", "month", "year", "milli_sec", "millis", "bezier", "spline"
+    "PRINT","SYSREQ","BREAK","MENU","CENTER","CLOSE", "RADIANS","DEGREES", "pow", "map", "angleMode", "curveVertex", "randomSeed", "resetMatrix", 
+    "hour", "minute", "second", "day", "month", "year", "milli_sec", "millis", "curve", "bezierVertex", "bezier", "loadPixels", "updatePixels"
 ]
 
-__version__ = "0.5.5"
+__version__ = "0.5.84"
 
 print("Thank you for using p5\n")
 

{p5-python-0.5.5 → p5-python-0.6.29}/p5/color.py

@@ -10,6 +10,8 @@ def get_Color(c, a=255):
         color = Color(int(c), int(c), int(c))
     elif (type(c) == str):
         color = Color(c)
+        if c=="green":
+            color =  Color(int(0), int(128), int(0)) # p5.js green color 
     elif (type(c) == tuple):
         color = Color(c)
     else:
@@ -35,9 +37,6 @@ def fill(*args): # set fill color
 
 def noFill():
     settings["no_fill"] = True
-    fill_color = settings["fill_color"]
-    fill_color[3] = 0
-    settings["fill_color"] = fill_color
     settings["text_color"] = settings["fill_color"]
     pass
 

{p5-python-0.5.5 → p5-python-0.6.29}/p5/corefunctions.py

@@ -9,7 +9,6 @@ import builtins
 from typing import Callable, Optional
 from p5.constants import *
 from p5.timedata import *
-from p5.drawcurve import *
 from p5.settings import *
 from p5.color import *
 from p5.transform import *
@@ -156,20 +155,6 @@ def ctxy(c):    # transform tuple x,y coordinate
     return tmp  
 
 
-def ellipse_array(x, y, width, height,thickness,scale):
-    rx = (width/2  + thickness)*scale
-    ry = (height/2 + thickness) * scale
-
-    cx = x * scale
-    cy = y * scale
-    
-    pts =[]
-    # Get points on ellipse
-    for n in range(0,360):
-        xx = cx + int(rx*math.cos(n*math.pi/180))
-        yy = cy + int(ry*math.sin(n*math.pi/180))
-        pts.append((xx, yy))
-    return pts
 
 # ---- 2D PRIMITIVES ----
 def arc(x, y, w, h, start, stop, mode = ARC):              
@@ -208,12 +193,20 @@ def ellipse(x, y, w, h=None):
 
 def circle(x, y, d):
     emode = builtins.ellipse_mode
+    w = d
     if emode == RADIUS:
         d = 2 * d
     if emode == CORNER:
         x = x + d/2
-        y = y + d/2    
-    draw_circle(CAIRO_SURFACE, x, y, d/2)   
+        y = y + d/2
+    if emode == CORNERS:
+        x1 = d
+        y1 = d
+        w = abs(x - x1)
+        h = abs(y - y1)
+        x = x1 + w/2
+        y = y1 + h/2     
+    draw_circle(CAIRO_SURFACE, x, y, w/2)   
     pass
 
 def line(x1, y1, x2, y2):  
@@ -275,6 +268,14 @@ def curveVertex(x,y):
     if shape:
         curvevertices.append((x,y))
     pass    
+
+def bezierVertex(*args):
+    global shape, beziervertices
+    if shape:
+        if len(args) == 6:
+            beziervertices.append(args)   
+    pass  
+
     
 def endShape(*args): # draw polygon/lines or spline curve
     global shape, vertices,curvevertices
@@ -283,16 +284,44 @@ def endShape(*args): # draw polygon/lines or spline curve
             if len(vertices) > 0:
                 draw_polygon(CAIRO_SURFACE, vertices)
             if len(curvevertices) > 0:            
-                spline(CAIRO_SURFACE, settings["stroke_color"], True, curvevertices,100, 0,0,0, settings["stroke_weight"])    
+                draw_spline(CAIRO_SURFACE, curvevertices,True)
+            if len(beziervertices) > 0:
+                if len(vertices) == 1:              
+                    draw_bezier(CAIRO_SURFACE, vertices[0], beziervertices, True)
     else:
         if len(vertices) > 0:            
                 draw_lines(CAIRO_SURFACE, vertices)
         if len(curvevertices) > 0:            
-                spline(CAIRO_SURFACE, settings["stroke_color"], False, curvevertices,100, 0,0,0, settings["stroke_weight"])
+                draw_spline(CAIRO_SURFACE, curvevertices,False)
+        if len(beziervertices) > 0:
+            if len(vertices) == 1:              
+                draw_bezier(CAIRO_SURFACE, vertices[0][0], vertices[0][1], beziervertices, False)
     shape = None
     vertices.clear()
     curvevertices.clear()
+    beziervertices.clear()
     pass   
+
+def curve(*args):
+    curvvert =[]
+    if len(args) > 0:
+        for i in range(0,len(args)-1,2):
+            curvvert.append((args[i],args[i+1]))
+        curvevertices.append(curvvert[0])
+        for i in range(len(curvvert)):
+            curvevertices.append(curvvert[i])
+        curvevertices.append(curvvert[len(curvvert)-1])
+        if len(curvevertices) > 0:            
+                    draw_spline(CAIRO_SURFACE, curvevertices,False)      
+        curvevertices.clear()
+
+def bezier(*args):
+    bz = []
+    if len(args) == 8:
+        for i in range(2,8):
+            bz.append(args[i])
+        draw_bezier(CAIRO_SURFACE, args[0], args[1], [bz], False)
+        
     
 # ---- TYPOGRAPHY ---
 
@@ -335,21 +364,44 @@ def textAlign(align):
         raise ValueError("textAlign() was expecting LEFT|CENTER|RIGHT")
       
 # ---- IMAGE AND PIXEL ----
-
-def loadImage(path):
-    return pygame.image.load(path)
-
-def image(img, x, y):
-    pg_Screen.blit(img, (x, y))
-        
+def bgra_surf_to_rgba_string(surface):
+    # convert raw data from BGRA to RGBA
+    img = surface.get_data()
+    rgba= img
+    for i in range(0,len(rgba),4):
+               rgba[i],rgba[i+2]=rgba[i+2],rgba[i]
+    return rgba
+    
+def loadImage(path): # load image to IMAGE_SURFACE
+    img_surface = cairo.ImageSurface.create_from_png(path)
+    rgba= bgra_surf_to_rgba_string(img_surface)
+    return img_surface
+
+def image(image, x, y):
+    ctx = cairo.Context(CAIRO_SURFACE)
+    ctx.set_source_surface(image, x, y)    
+    ctx.paint()
+     
 def saveCanvas(filename):        
     pygame.image.save(pg_Screen, filename)
 
-def loadPixels(image):
-    return pygame.PixelArray(image)
-
-def updatePixels(pixels):
-    pixels.close()
+def loadPixels():
+    surface = CAIRO_SURFACE
+    img = surface.get_data()
+    rgba= img
+    for i in range(0,len(rgba),4):
+               rgba[i],rgba[i+2]=rgba[i+2],rgba[i]
+    builtins.pixels = list(rgba)
+   
+def updatePixels():
+    rgba= builtins.pixels
+    for i in range(0,len(rgba),4):
+               rgba[i],rgba[i+2]=rgba[i+2],rgba[i]
+    img = bytearray(rgba)
+    img_surface = cairo.ImageSurface.create_for_data(img, cairo.FORMAT_ARGB32, builtins.width, builtins.height)
+    ctx = cairo.Context(CAIRO_SURFACE)
+    ctx.set_source_surface(img_surface, 0, 0)    
+    ctx.paint()
 
 # ---- ----
 def createCanvas(w=100, h=100):
@@ -374,18 +426,10 @@ def background(*args): # clear and set background color
 def strokeWeight(weight):
     settings["stroke_weight"] = weight
     settings["no_stroke"]     = False
-    stroke_color = settings["stroke_color"]
-    stroke_color[3] = 255
-    settings["stroke_color"]  = stroke_color
-    settings["text_outline"]  = stroke_color
     pass
 
 def noStroke():
     settings["no_stroke"] = True
-    stroke_color = settings["stroke_color"]
-    stroke_color[3] = 0
-    settings["stroke_color"] = stroke_color
-    settings["text_outline"] = stroke_color
     pass
 
 def ellipseMode(mode):

{p5-python-0.5.5 → p5-python-0.6.29}/p5/renderer.py

@@ -18,9 +18,9 @@ def a_radians(a):
     if builtins.ANGLEMODE == DEGREES:
         return a * math.pi/180
     else:
-        return a  
-def clear_background(surface, width, height, color):
-    
+        return a
+        
+def clear_background(surface, width, height, color):    
     ctx = cairo.Context(surface)
     ctx.set_source_rgba(*bgra(color))
     ctx.rectangle(0, 0, width, height)
@@ -29,6 +29,7 @@ def clear_background(surface, width, height, color):
 def draw_line(surface, x1, y1, x2, y2):
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["stroke_color"] 
@@ -36,16 +37,19 @@ def draw_line(surface, x1, y1, x2, y2):
     fill_color   = settings["fill_color"]
     ctx = cairo.Context(surface)
     ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
     ctx.rotate(rotate_angle)
     ctx.set_line_width(thickness)
     ctx.move_to(x1, y1)
     ctx.line_to(x2, y2)
-    ctx.set_source_rgba(*bgra(stroke_color))
-    ctx.stroke()
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()
 
 def draw_rect(surface, x, y, width, height):
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1 
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["stroke_color"] 
@@ -53,17 +57,21 @@ def draw_rect(surface, x, y, width, height):
     fill_color   = settings["fill_color"]
     ctx = cairo.Context(surface)
     ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
     ctx.rotate(rotate_angle)
     ctx.rectangle(x, y, width, height)
     ctx.set_line_width(thickness)
-    ctx.set_source_rgba(*bgra(fill_color))
-    ctx.fill_preserve() 
-    ctx.set_source_rgba(*bgra(stroke_color))
-    ctx.stroke()
+    if not(settings["no_fill"]):
+        ctx.set_source_rgba(*bgra(fill_color))
+        ctx.fill_preserve() 
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()
 
 def draw_polygon(surface, vertices):
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["stroke_color"] 
@@ -71,37 +79,44 @@ def draw_polygon(surface, vertices):
     fill_color   = settings["fill_color"]
     ctx = cairo.Context(surface)
     ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
     ctx.rotate(rotate_angle)
     ctx.move_to(*vertices[0])
     for n in range(1,len(vertices)):
         ctx.line_to(*vertices[n])    
     ctx.close_path() 
     ctx.set_line_width(thickness)
-    ctx.set_source_rgba(*bgra(fill_color))
-    ctx.fill_preserve() 
-    ctx.set_source_rgba(*bgra(stroke_color))
-    ctx.stroke()
+    if not(settings["no_fill"]):
+        ctx.set_source_rgba(*bgra(fill_color))
+        ctx.fill_preserve()
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()
 
 def draw_lines(surface, vertices):
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["stroke_color"] 
     thickness    = settings["stroke_weight"]
     ctx = cairo.Context(surface)
     ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
     ctx.rotate(rotate_angle)
     ctx.move_to(*vertices[0])
     for n in range(1,len(vertices)):
         ctx.line_to(*vertices[n])
     ctx.set_line_width(thickness)
-    ctx.set_source_rgba(*bgra(stroke_color))
-    ctx.stroke()
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()
     
 def draw_circle(surface, x, y, radius):
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["stroke_color"] 
@@ -110,16 +125,20 @@ def draw_circle(surface, x, y, radius):
     ctx = cairo.Context(surface)    
     ctx.translate(origin_x, origin_y)
     ctx.rotate(rotate_angle)
+    ctx.scale(scale_xy, scale_xy)
     ctx.arc(x, y, radius, 0, 2.0 * math.pi)
     ctx.set_line_width(thickness)
-    ctx.set_source_rgba(*bgra(fill_color))
-    ctx.fill_preserve() 
-    ctx.set_source_rgba(*bgra(stroke_color))
-    ctx.stroke()
+    if not(settings["no_fill"]):
+        ctx.set_source_rgba(*bgra(fill_color))
+        ctx.fill_preserve() 
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()
 
 def draw_ellipse(surface, x, y, width, height):
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["stroke_color"] 
@@ -127,21 +146,27 @@ def draw_ellipse(surface, x, y, width, height):
     fill_color   = settings["fill_color"]
     ctx = cairo.Context(surface)
     ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
     ctx.rotate(rotate_angle)   
     radius = width/2
     scale_x = 1.0
     scale_y = height / width
+    ctx.save()
     ctx.scale(scale_x, scale_y)
     ctx.arc(x, y/scale_y, radius, 0, 2.0 * math.pi)
     ctx.set_line_width(thickness)
-    ctx.set_source_rgba(*bgra(fill_color))
-    ctx.fill_preserve() 
-    ctx.set_source_rgba(*bgra(stroke_color))
-    ctx.stroke()    
+    if not(settings["no_fill"]):
+        ctx.set_source_rgba(*bgra(fill_color))
+        ctx.fill_preserve() 
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()    
+    ctx.restore()
     
 def draw_arc(surface, x, y, width, height, angle1, angle2, mode):           
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["stroke_color"] 
@@ -149,25 +174,31 @@ def draw_arc(surface, x, y, width, height, angle1, angle2, mode):
     fill_color   = settings["fill_color"]
     ctx = cairo.Context(surface)
     ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
     ctx.rotate(rotate_angle)   
     if mode == "pie":
         ctx.move_to(x, y)
     radius = width/2
     scale_x = 1.0
     scale_y = height / width
+    ctx.save()
     ctx.scale(scale_x, scale_y)        
     ctx.arc(x, y/scale_y, radius, angle1, angle2)
     if (mode == "chord") or (mode == "pie"):
         ctx.close_path()
     if (mode == "chord") or (mode == "pie") or (mode == "open"):
-        ctx.set_source_rgba(*bgra(fill_color))
-        ctx.fill_preserve()
-    ctx.set_source_rgba(*bgra(stroke_color))
-    ctx.stroke()
-
+        if not(settings["no_fill"]):
+            ctx.set_source_rgba(*bgra(fill_color))
+            ctx.fill_preserve()
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()
+    ctx.restore()
+    
 def draw_text(surface, txt, x, y, style):
     rotate_angle = a_radians(settings["rotate_amnt"])
     scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
     origin_x     = settings["real_ox"]
     origin_y     = settings["real_oy"]
     stroke_color = settings["text_outline"] 
@@ -177,6 +208,7 @@ def draw_text(surface, txt, x, y, style):
     font_size    = settings["text_size"]
     ctx = cairo.Context(surface)
     ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
     ctx.rotate(rotate_angle)    
     font_options = cairo.FontOptions()
     font_options.set_antialias(cairo.ANTIALIAS_DEFAULT)
@@ -196,26 +228,113 @@ def draw_text(surface, txt, x, y, style):
     if settings["text_align"] == CENTER:
         x = x - width/2    
     # Render outline
-    ctx.set_source_rgba(*bgra(stroke_color))
-    for i in range(-thickness, thickness+1):
-        for j in range(-thickness, thickness+1):
-            ctx.move_to(x + i, y + j)
-            ctx.show_text(txt)
-    
-    ctx.set_source_rgba(*bgra(fill_color))
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        i = -thickness
+        while i < thickness-0.3 :
+            j =-thickness
+            while j < thickness-0.3 :
+                ctx.move_to(x + i, y + j)
+                ctx.show_text(txt)
+                j = j + 0.2
+            i = i + 0.2            
+    if not(settings["no_fill"]):
+        ctx.set_source_rgba(*bgra(fill_color))
+        ctx.fill_preserve()
     ctx.move_to(x, y)
     ctx.show_text(txt)
-    ctx.stroke()   
-'''    
-def draw_curve(surface,color):    
-    x, y = 100, 50
-    x1, y1 = 140, 50
-    x2, y2 = 60, 100
-    x3, y3 = 190, 150
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color))
+        ctx.stroke()  
+
+def draw_spline(surface, curvevertices, mode):
+    vertices =[]
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["text_outline"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["text_color"]
+    font_name    = settings["text_font"] 
+    font_size    = settings["text_size"]
     ctx = cairo.Context(surface)
-    ctx.move_to(x, y)
-    ctx.curve_to(x1, y1, x2, y2, x3, y3)
-    ctx.set_source_rgba(*bgra(color))
+    ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
+    ctx.rotate(rotate_angle)
+    ctx.set_line_width(thickness)  
+    vertices = list(curvevertices)
+    ctx.move_to(vertices[0][0],vertices[0][1] )
+    vertices_length = len(vertices)
+    cached_vertices = []
+    curTightness = 0
+    if vertices_length >  0:
+      # closeShape = mode 
+      # if the shape is closed, the first element is also the last element
+        if mode:
+            vertices.append(vertices[0])
+        # curveVertex -> bezierVertex
+        if  vertices_length > 3 :
+            b = [None,None,None,None]
+            s = 1 - curTightness;
+            '''
+            Matrix to convert from Catmull-Rom to cubic Bezier
+            where t = curTightness
+            |0         1          0         0       |
+            |(t-1)/6   1          (1-t)/6   0       |
+            |0         (1-t)/6    1         (t-1)/6 |
+            |0         0          0         0       |
+            '''
+            i = 1
+            while (i+2 < vertices_length):          
+                cached_vertices = vertices[i]
+                b[0] = [cached_vertices[0], cached_vertices[1]]
+                b[1] = [cached_vertices[0] + (s * vertices[i+1][0] - s * vertices[i-1][0]) / 6, \
+                       cached_vertices[1] + (s * vertices[i+1][1] - s * vertices[i-1][1]) / 6]
+                b[2] = [vertices[i+1][0] + (s * vertices[i][0] - s * vertices[i+2][0]) / 6, \
+                       vertices[i+1][1] + (s * vertices[i][1] - s * vertices[i+2][1]) / 6]
+                b[3] = [vertices[i+1][0], vertices[i+1][1]]
+                i = i + 1
+                ctx.curve_to(b[1][0], b[1][1], b[2][0], b[2][1], b[3][0], b[3][1]) # draw bezier curve
+    if mode:
+        ctx.line_to(vertices[0][0],vertices[0][1])
+    
+    if not(settings["no_fill"]):
+        ctx.set_source_rgba(*bgra(fill_color))
+        #ctx.fill_preserve() 
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color)) 
     ctx.stroke()
-'''    
     
+    pass
+# end of draw_spline
+
+def draw_bezier(surface, x, y, bezier_vertices, mode):
+  
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    if scale_xy == 0: scale_xy = 1
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["fill_color"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.scale(scale_xy, scale_xy)
+    ctx.rotate(rotate_angle)
+    ctx.set_line_width(thickness)
+    ctx.move_to(x, y)
+    for i in range(len(bezier_vertices)):
+        b = bezier_vertices[i]        
+        ctx.curve_to(*b) # draw bezier curve
+        
+    if mode:
+        ctx.line_to(x, y)
+    if not(settings["no_fill"]):
+        ctx.set_source_rgba(*bgra(fill_color))
+        ctx.fill_preserve() 
+    if not(settings["no_stroke"]):
+        ctx.set_source_rgba(*bgra(stroke_color)) 
+        ctx.stroke()

{p5-python-0.5.5 → p5-python-0.6.29}/p5/settings.py

@@ -1,9 +1,6 @@
 import builtins
 from p5.constants import *
 
-pg_Screen = None
-clock = None
-
 builtins.mouseX         = 0
 builtins.mouseY         = 0
 builtins.pmouseX        = None
@@ -26,10 +23,14 @@ builtins.MILLIS         = 0
 builtins.frameCount     = 0
 builtins.ellipse_mode   = CENTER
 builtins.rect_mode      = CORNER
+builtins.pixels         = [] # store for pixels
+
+pg_Screen = None
+clock     = None
+# ----
 
+stack  = [] # store for settings
 
-# variables
-stack = [] # store for settings
 settings = {
     "fill_color"    : [255,255,255,255],
     "no_fill"       : False,
@@ -37,7 +38,7 @@ settings = {
     "stroke_weight" : 1,
     "stroke_color"  : [0,0,0,255],
     "rotate_amnt"   : 0,
-    "scale_amnt"    : 1,
+    "scale_amnt"    : 0,
     "text_size"     : 12,
     "text_font"     : "Arial",
     "text_bold"     : False,
@@ -54,5 +55,6 @@ settings = {
 
 vertices      = []
 curvevertices = []
+beziervertices= []
 shape         = None
 

{p5-python-0.5.5 → p5-python-0.6.29}/p5/transform.py

@@ -1,11 +1,12 @@
 # TRANSFORM
 from p5.settings import *
 import math
+import builtins
 
 def transform_canvas_reset(): # Transformations are reset at the beginning of the draw loop.
     global settings
     settings["rotate_amnt"] = 0
-    settings["scale_amnt"]  = 1
+    settings["scale_amnt"]  = 0
     settings["origin_x"]    = 0
     settings["origin_y"]    = 0
     settings["real_ox"]     = 0
@@ -18,15 +19,16 @@ def resetMatrix():
 def rotate(angle):
     current_angle = settings["rotate_amnt"]
     current_angle += angle
-    if current_angle < 0:
-        current_angle = 360 + current_angle
-    if current_angle > 359:
-        current_angle = current_angle % 360
-    settings["rotate_amnt"] = current_angle          
+    if builtins.ANGLEMODE == DEGREES:
+        if current_angle < 0:
+            current_angle = 360 + current_angle
+        if current_angle > 359:
+            current_angle = current_angle % 360
+        settings["rotate_amnt"] = current_angle          
     pass
 
 def scale(amnt):
-    settings["scale_amnt"] = amnt
+    settings["scale_amnt"] = settings["scale_amnt"] + amnt
     pass    
 
 def real_oxy(xx,yy):   # calulate real x,y coordinate    

{p5-python-0.5.5 → p5-python-0.6.29}/p5_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: p5-python
-Version: 0.5.5
+Version: 0.6.29
 Summary: A package wrapping pygame functionality in p5.js calling conventions.
 Home-page: https://github.com/gromko/p5-python
 Author: Grygoriy Gromko

{p5-python-0.5.5 → p5-python-0.6.29}/p5_python.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ p5/__main__.py
 p5/color.py
 p5/constants.py
 p5/corefunctions.py
-p5/drawcurve.py
 p5/mathfunctions.py
 p5/p5-python.png
 p5/renderer.py

{p5-python-0.5.5 → p5-python-0.6.29}/p5_python.egg-info/requires.txt

@@ -1 +1,2 @@
+pycairo>=1.20.0
 pygame<3.0.0,>=2.1.2

{p5-python-0.5.5 → p5-python-0.6.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "p5"
-version = "0.5.5"
+version = "0.6.29"
 readme = "README.md"
 license = "MIT"
 homepage = "https://github.com/gromko/p5-python"
@@ -14,6 +14,7 @@ include = [
 [tool.poetry.dependencies]
 python = ">=3.8.0"
 pygame = "^2.1.2"
+pycairo = "^1.20.0"
 
 [tool.poetry.dev-dependencies]
 

{p5-python-0.5.5 → p5-python-0.6.29}/setup.py

@@ -8,11 +8,11 @@ package_data = \
 {'': ['*']}
 
 install_requires = \
-['pygame>=2.1.2,<3.0.0']
+['pygame>=2.1.2,<3.0.0','pycairo>=1.20.0']
 
 setup_kwargs = {
     'name': 'p5-python',
-    'version': '0.5.5',
+    'version': '0.6.29',
     'description': 'A package wrapping pygame functionality in p5.js calling conventions.',
     'long_description': '#p5 is a friendly tool for learning to code and make art. It is a free and open-source Python library built by an inclusive, nurturing community. p5 is a Python library that provides high level drawing functionality to help you quickly create simulations and interactive art using Python.',
     'author': 'Grygoriy Gromko',

p5-python-0.5.5/p5/drawcurve.py

@@ -1,146 +0,0 @@
-# Splines/Curves from PAdLib - Ian Mallett - 2013
-
-from math import *
-import pygame
-from p5.renderer import *
-
-# math helper
-def rndint(num): return int(num+0.5)
-def clamp(num, low,high):
-    if num <  low: return  low
-    if num > high: return high
-    return num
-
-def vec_add(v1,v2):
-    return [v1[i]+v2[i] for i in range(len(v1))]
-def vec_sub(v1,v2):
-    return [v1[i]-v2[i] for i in range(len(v1))]
-def vec_dot(v1,v2):
-    return sum([v1[i]*v2[i] for i in range(len(v1))])
-def vec_scale(sc,v):
-    return [sc*v[i] for i in range(len(v))]
-def vec_negate(v):
-    return [-v[i] for i in range(len(v))]
-
-def vec_length_sq(vec):
-    return vec_dot(vec,vec)
-def vec_length(vec):
-    return vec_dot(vec,vec) ** 0.5
-def vec_norm(vec):
-    return vec_scale(1.0/vec_length(vec),vec)
-
-def vec_reflect(vec, norm):
-    v_dot_n = vec_dot(vec,norm)
-    sc = 2 * v_dot_n
-    return [sc*norm[i]-vec[i] for i in range(len(vec))]
-
-def point_project_line(p, l1,l2):
-    #Adapted from http://www.gamedev.net/topic/444154-closest-point-on-a-line/
-    p_l1 = vec_sub(p,l1)
-    l2_l1 = vec_sub(l2,l1)
-
-    t = vec_dot(p_l1,l2_l1) / vec_dot(l2_l1,l2_l1)
-
-    return vec_add(l1,vec_scale(t,l2_l1))
-
-# draw bezier curve
-def _draw_bezier(surface, color, controlpointslist, steps, aa, width, blend):
-    #Algorithm derived from geometric animations on
-    #http://en.wikipedia.org/wiki/B[e]zier_curve
-    #The "[e]" is actually an e with an inflection
-    #over it; removed for this file's portability.
-    
-    points = []
-    
-    def draw_curve(controlpointslist):
-        l = len(controlpointslist)
-        
-        def lerp(p1,p2):
-            return vec_add(
-                vec_scale(1.0-t,p1),
-                vec_scale(    t,p2)
-            )
-        if l == 2:
-            points.append(lerp(*controlpointslist))
-        else:
-            controlpointslist2 = []
-            for i in range(l-1):
-                controlpointslist2.append(lerp(
-                    controlpointslist[i],
-                    controlpointslist[i+1]
-                ))
-            draw_curve(controlpointslist2)
-                
-    for i in range(steps):
-        t = float(i) / float(steps-1)
-        draw_curve(controlpointslist)
-
-    points = [list(map(rndint,p)) for p in points]
-    draw_lines(surface,points)
-
-#draw spline curve
-def _draw_spline(surface, color, closed, pointslist, steps, t,b,c, aa, width, blend):
-    #Kochanek-Bartels spline implementation, written long ago and updated.
-    t_inc = 1.0/float(steps)
-
-    #This allows us to draw through all visible control points (normal Kochanek-Bartels
-    #splines do not draw through their last endpoints).
-    if closed:
-        pointslist = [pointslist[-2],pointslist[-1]] + pointslist + [pointslist[0],pointslist[1]]
-    else:
-        pointslist = [pointslist[0]] + pointslist + [pointslist[-1]]
-
-    cona = (1-t)*(1+b)*(1-c)*0.5
-    conb = (1-t)*(1-b)*(1+c)*0.5
-    conc = (1-t)*(1+b)*(1+c)*0.5
-    cond = (1-t)*(1-b)*(1-c)*0.5
-
-    tans = []
-    tand = []
-    for x in range(len(pointslist)-2):
-        tans.append([])
-        tand.append([])
-    i = 1
-    while i < len(pointslist)-1:
-        pa = pointslist[i-1]
-        pb = pointslist[i  ]
-        pc = pointslist[i+1]
-        x1 = pb[0] - pa[0]
-        y1 = pb[1] - pa[1]
-        x2 = pc[0] - pb[0]
-        y2 = pc[1] - pb[1]
-        tans[i-1] = (cona*x1+conb*x2, cona*y1+conb*y2)
-        tand[i-1] = (conc*x1+cond*x2, conc*y1+cond*y2)
-        i += 1
-
-    for i in range(1,len(pointslist)-2,1):
-        p0 = pointslist[i  ]
-        p1 = pointslist[i+1]
-        m0 = tand[i-1]
-        m1 = tans[i  ]
-        
-        #draw curve from p0 to p1
-        points = [(p0[0],p0[1])]
-        t_iter = t_inc
-        while t_iter < 1.0:
-            h00 = ( 2*(t_iter*t_iter*t_iter)) - ( 3*(t_iter*t_iter)) + 1
-            h10 = ( 1*(t_iter*t_iter*t_iter)) - ( 2*(t_iter*t_iter)) + t_iter
-            h01 = (-2*(t_iter*t_iter*t_iter)) + ( 3*(t_iter*t_iter))
-            h11 = ( 1*(t_iter*t_iter*t_iter)) - ( 1*(t_iter*t_iter))
-            px = h00*p0[0] + h10*m0[0] + h01*p1[0] + h11*m1[0]
-            py = h00*p0[1] + h10*m0[1] + h01*p1[1] + h11*m1[1]
-            points.append((px,py))
-            t_iter += t_inc
-        points.append((p1[0],p1[1]))
-        
-        points = [list(map(rndint,p)) for p in points]
-        draw_lines(surface,points)
-
-
-def bezier(surface, color, controlpointslist, steps, width=1):
-    _draw_bezier(surface, color, controlpointslist, steps, False, width, False)
-
-
-def spline(surface, color, closed, pointslist, steps, t=0.0,b=0.0,c=0.0, width=1):
-    _draw_spline(surface, color, closed, pointslist, steps, t,b,c, False, width, False)
-