Living Code

Yesterday I wrote about how to extend NSImage so it can save to a file. Today we’ll tackle NSBezierPath. NSBezierPath is pretty cool for drawing, but it doesn’t support arbitrary regular polygons, just rects and ovals (and lines and arcs). And there’s not an easy way to extract the points that make up a path. And if you could extract the points, there isn’t a way to draw dots for the points instead of stroking or filling the path. OK, enough already, let’s look at some code.

First thing in the code, we’ll define some basic trigonometry routines to calculate the points for a polygon. Then we’ll create the class itself.

from objc import Category

from AppKit import NSBezierPath

import math

def poly_point(center, r, degrees):

    x = r * math.cos(degrees) + center[0]

    y = r * math.sin(degrees) + center[1]

    return x,y

def polypoints(center, r, numPoints, degreesRotation=0):

    if numPoints < 3:

        raise ValueError, 'Must have at least 3 points in a polygon'

    rotation = math.radians(degreesRotation)

    theta = (math.pi * 2) / numPoints

    return [poly_point(center, r, i*theta+rotation)

        for i in range(numPoints)]

class NSBezierPath(Category(NSBezierPath)):

    def points(self):

        points = []

        for i in range(self.elementCount()):

        elem, pts = self.elementAtIndex_associatedPoints_(i)

        points += pts

        return points

def appendBezierPathWithPolygonWithCenter_radius_numberOfPoints_(self, center, radius, numberOfPoints):

	''' Creates a regular polygon '''

	pts = polypoints(center, radius, numberOfPoints) self.moveToPoint_(pts[0])

	for pt in pts[1:]:

		self.lineToPoint_(pt)

	self.closePath()

    def dot(self):

        '''

        Similar to stroke: and fill:, but draws dots for each point in the

        path. Dot size is based on linewidth. Not as efficient, because it

        creates a separate NSBezierPath each time it is called.

        '''

        tmp_path = NSBezierPath.alloc().init()

        width = self.lineWidth()

        offset = width / 2

        for point in self.points():

            rect = (point[0] - offset, point[1] - offset),(width, width)

            tmp_path.appendBezierPathWithOvalInRect_(rect)

        tmp_path.fill()

OK, hopefully the above is reasonably clear. You can follow along with any calls which are unfamiliar by firing up AppKiDo or the Apple documentation for NSBezierPath. If you’re going to use the dot: method a lot you might want to cache the path so you’re not creating a new NSBezierPath every time, it depends on what you need.

Here’s a short script you can run on the command line to create a hexagon and demonstrate fill:, stroke: and dot:

from AppKit import NSApplication, NSBezierPath, NSColor, NSImage

from Foundation import NSInsetRect, NSMakeRect

import image_ext, bezier_path_ext

app = NSApplication.sharedApplication()

image = NSImage.alloc().initWithSize_((64,64))

image.fillWithColor_(NSColor.clearColor())

image.lockFocus()

hex = NSBezierPath.alloc().init()

hex.appendBezierPathWithPolygonWithCenter_radius_numberOfPoints_((32,32), 26, 6)

NSColor.greenColor().set()

hex.fill()

hex.setLineWidth_(2)

NSColor.blueColor().set()

hex.stroke()

hex.setLineWidth_(8)

NSColor.redColor().set()

hex.dot()

image.unlockFocus()

image.writeToFilePath_('hex.png')

Which results in this: 

Why am I so interested in points and dots? Well, they let me visualize control points for arcs for one thing. Perhaps tomorrow we can explore more along those lines.