Subversion Repositories phr

#!/usr/bin/env python
#
# img2mod - A script to convert an image file into a PCB module file for Kicad.
# Version 1.02 - June 19, 2013
# Now works with the new .kicad_mod s-expression file format
#
# Written by Matthew Beckler for Wayne and Layne, LLC
# Copyright (c) 2011, Wayne and Layne, LLC
# http://img2mod.wayneandlayne.com/ - wayneandlayne at wayneandlayne dot com
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
 
 
from PIL import Image, ImageOps
 
# Text for the file header, the parameter is the name of the module, ex "LOGO".
header = """(module %(name)s
  (layer F.Cu)
  (at 0 0)
  (fp_text reference "VAL***" (at 0 10) (layer F.SilkS) hide
    (effects (font (thickness 0.3)))
  )
  (fp_text reference "%(name)s" (at 0 5) (layer F.SilkS) hide
    (effects (font (thickness 0.3)))
  )
"""
 
# Text for the file footer, the only parameter is the name of the module
footer = """)
"""
 
# Places a pixel with (x, y) at the upper-left corner
# Size is in units of mm
def make_pixel(x, y, px_size):
    return """  (fp_poly
    (pts
      (xy %(0)s %(1)s)
      (xy %(2)s %(1)s)
      (xy %(2)s %(3)s)
      (xy %(0)s %(3)s)
      (xy %(0)s %(1)s)
    )
    (layer F.SilkS)
    (width 0.01)
  )
""" % {"0": x, "1": y, "2": x + px_size, "3": y + px_size}
 
def conv_image_to_module(image, module_name, scale_factor):
    """ Returns the text for the module, and the size: (x, y) in mm. """
    w, h = image.size
    #print "Original image dimensions: {0} x {1}".format(w, h)
    #print "Writing module file to \"{0}\"".format(output_filename)
    module = header % {"name": module_name}
    for y in range(h):
        for x in range(w):
            #print image.getpixel((x,y))
            if image.getpixel((x, y)) == 0:
                module += make_pixel(scale_factor * x, scale_factor * y, scale_factor)
    module += footer % {"name": module_name}
    return module, (scale_factor * w, scale_factor * h)
 
 
def main():
    import sys
 
    if len(sys.argv) < 5:
        print "Usage: %s input_image output_filename module_name scale_factor" % sys.argv[0]
        print "  input_image is the filename of the input image"
        print "  output_filename is the name of the output module file"
        print "  module_name is the name to use for the module, traditionally LOGO"
        print "  scale_factor is the size of each output pixel, in units of mm\""
        sys.exit(1)
 
    input_image = sys.argv[1]
    output_filename = sys.argv[2]
    module_name = sys.argv[3]
    scale_factor = int(sys.argv[4])
 
    print "Reading image from \"%s\"" % input_image
 
    # If we .convert("1") it makes a binary image with a 127 threshold
    # Keeping it at greyscale allows us to make the threshold configurable
    image = Image.open(input_image).convert("L")
    # The above conversion will assume a black background for removing transparency.
    # If we want to use a different background color, use this:
    #white = Image.new("RGB", image.size, (255,255,255))
    #r,g,b,a = image.split()
    #image = Image.composite(image, white, a)
 
    # If you want to invert the image:
    #image = ImageOps.invert(image)
 
    # If you want to do non-127 thresholding, change the 127 below
    image = image.point(lambda i: 0 if i < 127 else 255)
 
    module, size = conv_image_to_module(image, module_name, scale_factor)
    print "Output image size: %f x %f mm" % (size[0], size[1])
 
    fid = open(output_filename, "w")
    fid.write(module)
    fid.close()
 
if __name__ == "__main__":
    main()