#!/usr/bin/python3 # Copyright (C) 2013-2014 Florian Festi # # 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 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import cairo import math import argparse from argparse import ArgumentParser import re from functools import wraps from boxes import edges def dist(dx, dy): """ Return distance :param dx: delta x :param dy: delat y """ return (dx*dx+dy*dy)**0.5 def restore(func): """ Wrapper: Restore coordiantes after function :param func: function to wrap """ @wraps(func) def f(self, *args, **kw): self.ctx.save() pt = self.ctx.get_current_point() func(self, *args, **kw) self.ctx.restore() self.ctx.move_to(*pt) return f ############################################################################# ### Building blocks ############################################################################# class NutHole: """Draw a hex nut""" sizes = { "M1.6" : (3.2, 1.3), "M2" : (4, 1.6), "M2.5" : (5, 2.0), "M3" : (5.5, 2.4), "M4" : (7, 3.2), "M5" : (8, 4.7), "M6" : (10, 5.2), "M8" : (13, 6.8), "M10" : (16, 8.4), "M12" : (18, 10.8), "M14" : (21, 12.8), "M16" : (24, 14.8), "M20" : (30, 18.0), "M24" : (36, 21.5), "M30" : (46, 25.6), "M36" : (55, 31), "M42" : (65, 34), "M48" : (75, 38), "M56" : (85, 45), "M64" : (95, 51), } def __init__(self, boxes, settings): self.boxes = boxes self.ctx = boxes.ctx self.settings = settings @restore def __call__(self, size, x=0, y=0, angle=0): size = self.sizes.get(size, (size,))[0] side = size / 3**0.5 self.boxes.moveTo(x, y, angle) self.boxes.moveTo(-0.5*side, 0.5*size, angle) for i in range(6): self.boxes.edge(side) self.boxes.corner(-60) def argparseSections(s): """ Parse sections parameter :param s: string to parse """ m = re.match(r"(\d+(\.\d+)?)/(\d+)", s) if m: n = int(m.group(3)) print([ float(m.group(1)) ] * n) return [ float(m.group(1))/n ] * n m = re.match(r"(\d+(\.\d+)?)\*(\d+)", s) if m: n = int(m.group(3)) return [ float(m.group(1)) ] * n try: return [float(part) for part in s.split(":")] except ValueError: raise argparse.ArgumentTypeError("Don't understand sections string") class Boxes: """Main class -- Generator should sub class this """ def __init__(self): self.argparser = ArgumentParser(description=self.__doc__) self.argparser.add_argument( "--thickness", action="store", type=float, default=4.0, help="thickness of the material") self.argparser.add_argument( "--output", action="store", type=str, default="box.svg", help="name of resulting file") self.argparser.add_argument( "--debug", action="store_true", default=False, help="print surrounding boxes for some structures") self.argparser.add_argument( "--burn", action="store", type=float, default=0.05, help="burn correction in mm") def open(self, width, height): """ Prepare for rendering Call this function from your .render() method :param width: width of canvas in mm :param height: height of canvas in mm """ self.spacing = 2*self.burn + 0.5 * self.thickness self.fingerHoleEdgeWidth = 1.0 # multitudes of self.thickness self.bedBoltSettings = (3, 5.5, 2, 20, 15) #d, d_nut, h_nut, l, l1 self.hexHolesSettings = (5, 3, 'circle') # r, dist, style self._init_surface(width, height) self._buildObjects() def buildArgParser(self, *l): """ Add commonly used commandf line parameters :param \*l: parameter names """ for arg in l: if arg == "x": self.argparser.add_argument( "--x", action="store", type=float, default=100.0, help="inner width in mm") elif arg == "y": self.argparser.add_argument( "--y", action="store", type=float, default=100.0, help="inner depth in mm") elif arg == "sx": self.argparser.add_argument( "--sx", action="store", type=argparseSections, default="50*3", help="""sections left to right in mm. Possible formats: overallwidth/numberof sections e.g. "250/5"; sectionwith*numberofsections e.g. "50*5"; section widths separated by ":" e.g. "30:25.5:70" """) elif arg == "sy": self.argparser.add_argument( "--sy", action="store", type=argparseSections, default="50*3", help="""sections back to front in mm. See --sx for format""") elif arg == "h": self.argparser.add_argument( "--h", action="store", type=float, default=100.0, help="inner height in mm") elif arg == "hi": self.argparser.add_argument( "--hi", action="store", type=float, default=0.0, help="inner height of inner walls in mm (leave to zero for same as outer walls)") else: raise ValueError("No default for argument", arg) def parseArgs(self, args=None): """ Parse command line parameters :param args: (Default value = None) parameters, None for using sys.argv """ self.argparser.parse_args(args=args, namespace=self) def addPart(self, part, name=None): """ Add Edge or other part instance to this one and add it as attribute :param part: Callable :param name: (Default value = None) attribute name (__name__ as default) """ if name is None: name = part.__class__.__name__ name = name[0].lower() + name[1:] #if not hasattr(self, name): setattr(self, name, part) if isinstance(part, edges.Edge): self.edges[part.char] = part def _buildObjects(self): """Add default edges and parts """ self.edges = {} self.addPart(edges.Edge(self, None)) self.addPart(edges.OutSetEdge(self, None)) # Share settings object s = edges.FingerJointSettings(self.thickness) self.addPart(edges.FingerJointEdge(self, s)) self.addPart(edges.FingerJointEdgeCounterPart(self, s)) self.addPart(edges.FingerHoleEdge(self, s)) self.addPart(edges.FingerHoles(self, s)) s = edges.DoveTailSettings(self.thickness) self.addPart(edges.DoveTailJoint(self, s)) self.addPart(edges.DoveTailJointCounterPart(self, s)) s = edges.FlexSettings(self.thickness) self.addPart(edges.FlexEdge(self, s)) self.addPart(NutHole(self, None)) def _init_surface(self, width, height): """ Initialize cairo canvas :param width: canvas size :param height: canvas height """ #mm2pt = 90 / 25.4 / 1.25 mm2pt = 1 #width *= mm2pt #height *= mm2pt #3.543307 self.surface = cairo.SVGSurface(self.output, width, height) self.ctx = ctx = cairo.Context(self.surface) ctx.translate(0, height) ctx.scale(mm2pt, -mm2pt) #ctx.set_source_rgb(1.0, 1.0, 1.0) #ctx.rectangle(0, 0, width, height) #ctx.fill() ctx.set_source_rgb(0.0, 0.0, 0.0) ctx.set_line_width(2*self.burn) def render(self): """Implement this method in your sub class. You will typically need to call .parseArgs() before calling this one""" self.open(100, 100) # Change settings and creat new Edges and part classes here raise NotImplemented self.close() def cc(self, callback, number, x=0.0, y=None): """Call callback from edge of a part :param callback: callback (callable or list of callables) :param number: number of the callback :param x: (Default value = 0.0) x position to be call on :param y: (Default value = None) y position to be called on (default does burn correction) """ if y is None: y = self.burn self.ctx.save() self.moveTo(x, y) if callable(callback): callback(number) elif hasattr(callback, '__getitem__'): try: callback = callback[number] if callable(callback): callback() except (KeyError, IndexError): pass except: self.ctx.restore() raise self.ctx.restore() def getEntry(self, param, idx): """ Get entry from list or items itself :param param: list or item :param idx: index in list """ if isinstance(param, list): if len(param)>idx: return param[idx] else: return None else: return param def close(self): """Finish rendering Call at the end of your .render() method""" self.ctx.stroke() self.surface.flush() self.surface.finish() f = open(self.output, "r+") s = f.read(1024) pos = s.find('pt"') if pos > 0: f.seek(pos) f.write("mm") else: print("Could not replace pt with mm") pos = s.find('pt"', pos+3) if pos > 0: f.seek(pos) f.write("mm") else: print("Could not replace pt with mm") ############################################################ ### Turtle graphics commands ############################################################ def corner(self, degrees, radius=0): """ Draw a corner This is what does the burn corrections :param degrees: angle :param radius: (Default value = 0) """ rad = degrees*math.pi/180 if degrees > 0: self.ctx.arc(0, radius+self.burn, radius+self.burn, -0.5*math.pi, rad - 0.5*math.pi) elif radius > self.burn: self.ctx.arc_negative(0, -(radius-self.burn), radius-self.burn, 0.5*math.pi, rad + 0.5*math.pi) else: # not rounded inner corner self.ctx.arc_negative(0, self.burn-radius, self.burn-radius, -0.5*math.pi, -0.5*math.pi+rad) self.continueDirection(rad) def edge(self, length): """ Simple line :param length: length in mm """ self.ctx.move_to(0,0) self.ctx.line_to(length, 0) self.ctx.translate(*self.ctx.get_current_point()) def curveTo(self, x1, y1, x2, y2, x3, y3): """control point 1, control point 2, end point :param x1: :param y1: :param x2: :param y2: :param x3: :param y3: """ self.ctx.curve_to(x1, y1, x2, y2, x3, y3) dx = x3-x2 dy = y3-y2 rad = math.atan2(dy, dx) self.continueDirection(rad) def polyline(self, *args): """ Draw multiple connected lines :param \*args: Alternating length in mm and angle """ for i, arg in enumerate(args): if i % 2: self.corner(arg) else: self.edge(arg) def bedBoltHole(self, length, bedBoltSettings=None): """ Draw an edge with slot for a bed bolt :param length: length of the edge in mm :param bedBoltSettings: (Default value = None) Dimmensions of the slot """ d, d_nut, h_nut, l, l1 = bedBoltSettings or self.bedBoltSettings self.edge((length-d)/2.0) self.corner(90) self.edge(l1) self.corner(90) self.edge((d_nut-d)/2.0) self.corner(-90) self.edge(h_nut) self.corner(-90) self.edge((d_nut-d)/2.0) self.corner(90) self.edge(l-l1-h_nut) self.corner(-90) self.edge(d) self.corner(-90) self.edge(l-l1-h_nut) self.corner(90) self.edge((d_nut-d)/2.0) self.corner(-90) self.edge(h_nut) self.corner(-90) self.edge((d_nut-d)/2.0) self.corner(90) self.edge(l1) self.corner(90) self.edge((length-d)/2.0) def grip(self, length, depth): """Corrugated edge useful as an gipping area :param length: length :param depth: depth of the grooves """ grooves = int(length // (depth*2.0)) + 1 depth = length / grooves / 4.0 for groove in range(grooves): self.corner(90, depth) self.corner(-180, depth) self.corner(90, depth) def _latchHole(self, length): """ :param length: """ self.edge(1.1*self.thickness) self.corner(-90) self.edge(length/2.0+0.2*self.thickness) self.corner(-90) self.edge(1.1*self.thickness) def _latchGrip(self, length): """ :param length: """ self.corner(90, self.thickness/4.0) self.grip(length/2.0-self.thickness/2.0-0.2*self.thickness, self.thickness/2.0) self.corner(90, self.thickness/4.0) def latch(self, length, positive=True, reverse=False): """Latch to fix a flex box door to the box :param length: length in mm :param positive: (Default value = True) False: Door side; True: Box side :param reverse: (Default value = False) True when running away from the latch """ if positive: if reverse: self.edge(length/2.0-self.burn) self.corner(-90) self.edge(self.thickness) self.corner(90) self.edge(length/2.0) self.corner(90) self.edge(self.thickness) self.corner(-90) if not reverse: self.edge(length/2.0-self.burn) else: if reverse: self._latchGrip(length) else: self.corner(90) self._latchHole(length) if not reverse: self._latchGrip(length) else: self.corner(90) def handle(self, x, h, hl, r=30): """Creates an Edge with a handle :param x: width in mm :param h: height in mm :param hl: height if th grip hole :param r: (Default value = 30) radius of the corners """ d = (x-hl-2*r)/2.0 if d < 0: print("Handle too wide") self.ctx.save() # Hole self.moveTo(d+2*r, 0) self.edge(hl-2*r) self.corner(-90, r) self.edge(h-3*r) self.corner(-90, r) self.edge(hl-2*r) self.corner(-90, r) self.edge(h-3*r) self.corner(-90, r) self.ctx.restore() self.moveTo(0,0) self.curveTo(d, 0, d, 0, d, -h+r) self.curveTo(r, 0, r, 0, r, r) self.edge(hl) self.curveTo(r, 0, r, 0, r, r) self.curveTo(h-r, 0, h-r, 0, h-r, -d) ### Navigation def moveTo(self, x, y=0.0, degrees=0): """ Move coordinate system to given point :param x: :param y: (Default value = 0.0) :param degrees: (Default value = 0) """ self.ctx.move_to(0, 0) self.ctx.translate(x, y) self.ctx.rotate(degrees*math.pi/180.0) self.ctx.move_to(0, 0) def continueDirection(self, angle=0): """ Set coordinate system to current position (end point) :param angle: (Default value = 0) heading """ self.ctx.translate(*self.ctx.get_current_point()) self.ctx.rotate(angle) def move(self, x, y, where, before=False): """Intended to be used by parts where can be combinations of "up", "down", "left", "right" and "only" when "only" is included the move is only done when before is True The function returns whether actual drawing of the part should be omited. :param x: width of part :param y: height of part :param where: which direction to move :param before: (Default value = False) called before or after part being drawn """ if not where: return False terms = where.split() dontdraw = before and "only" in terms moves = { "up": (0, y, False), "down" : (0, -y, True), "left" : (-x, 0, True), "right" : (x, 0, False), "only" : (0, 0, None), } for term in terms: if not term in moves: raise ValueError("Unknown direction: '%s'" % term) x, y, movebeforeprint = moves[term] if movebeforeprint and before: self.moveTo(x, y) elif (not movebeforeprint and not before) or dontdraw: self.moveTo(x, y) return dontdraw # Building blocks def fingerHolesAt(self, x, y, length, angle=90, bedBolts=None, bedBoltSettings=None): """ Draw holes for a matching finger joint edge :param x: position :param y: position :param length: length of matching edge :param angle: (Default value = 90) :param bedBolts: (Default value = None) :param bedBoltSettings: (Default value = None) """ self.ctx.save() self.moveTo(x, y, angle) self.fingerHoles(length, bedBolts, bedBoltSettings) self.ctx.restore() @restore def hole(self, x, y, r): """ Draw a round hole :param x: position :param y: postion :param r: radius """ radius -= self.burn if radius < 0: radius = 1E-9 self.moveTo(x+r, y) self.ctx.arc(-r, 0, r, 0, 2*math.pi) @restore def rectangularHole(self, x, y, dx, dy, r=0): """ Draw an rectangulat hole :param x: position :param y: position :param dx: width :param dy: height :param r: (Default value = 0) radius of the corners """ self.moveTo(x+r-dx/2.0, y-dy/2.0, 180) for d in (dy, dx, dy, dx): self.corner(-90, r) self.edge(d-2*r) @restore def text(self, text, x=0, y=0, angle=0, align=""): """ Draw text :param text: text to render :param x: (Default value = 0) :param y: (Default value = 0) :param angle: (Default value = 0) :param align: (Default value = "") string with combinations of (top|middle|bottom) and (left|center|right) separated by a space """ self.moveTo(x, y, angle) (tx, ty, width, height, dx, dy) = self.ctx.text_extents(text) align = align.split() moves = { "top" : (0, -height), "middle" : (0, -0.5*height), "bottom" : (0, 0), "left" : (0, 0), "center" : (-0.5*width, 0), "right" : (-width, 0), } for a in align: if a in moves: self.moveTo(*moves[a]) else: raise ValueError("Unknown alignment: %s" % align) self.ctx.scale(1, -1) self.ctx.show_text(text) @restore def NEMA(self, size, x=0, y=0, angle=0): """Draw holes for mounting a NEMA stepper motor :param size: Nominal size in tenths of inches :param x: (Default value = 0) :param y: (Default value = 0) :param angle: (Default value = 0) """ nema = { # motor,flange, holes, screws 8 : (20.3, 16, 15.4, 3), 11 : (28.2, 22, 23, 4), 14 : (35.2, 22, 26, 4), 16 : (39.2, 22, 31, 4), 17 : (42.2, 22, 31, 4), 23 : (56.4, 38.1, 47.1, 5.2), 24 : (60, 36, 49.8, 5.1), 34 : (86.3, 73, 69.8, 6.6), 42 : (110, 55.5, 89, 8.5), } width, flange, holedistance, diameter = nema[size] self.moveTo(x, y, angle) if self.debug: self.rectangularHole(0, 0, width, width) self.hole(0,0, 0.5*flange) for x in (-1, 1): for y in (-1, 1): self.hole(x*0.5*holedistance, y*0.5*holedistance, 0.5*diameter) # hexHoles def hexHolesRectangle(self, x, y, settings=None, skip=None): """Fills a rectangle with holes in a hex pattern. Settings have: r : radius of holes b : space between holes style : what types of holes (not yet implemented) :param x: width :param y: heigth :param settings: (Default value = None) :param skip: (Default value = None) function to check if hole should be present gets x, y, r, b, posx, posy """ if settings is None: settings = self.hexHolesSettings r, b, style = settings w = r+b/2.0 dist = w * math.cos(math.pi/6.0) # how many half circles do fit cx = int((x-2*r) // (w)) + 2 cy = int((y-2*r) // (dist)) + 2 # what's left on the sides lx = (x - (2*r+(cx-2)*w))/2.0 ly = (y - (2*r+((cy//2)*2)*dist-2*dist))/2.0 for i in range(cy//2): for j in range((cx-(i%2))//2): px = 2*j*w + r + lx py = i*2*dist + r + ly if i % 2: px += w if skip and skip(x, y, r, b, px, py): continue self.hole(px, py, r) def __skipcircle(self, x, y, r, b, posx, posy): cx, cy = x/2.0, y/2.0 return (dist(posx-cx, posy-cy) > (cx-r)) def hexHolesCircle(self, d, settings=None): """ Fill circle with holes in a hex pattern :param d: diameter of the circle :param settings: (Default value = None) """ d2 = d/2.0 self.hexHolesRectangle(d, d, settings=settings, skip=self.__skipcircle) def hexHolesPlate(self, x, y, rc, settings=None): """ Fill a plate with holes in a hex pattern :param x: width :param y: height :param rc: radius of the corners :param settings: (Default value = None) """ def skip(x, y, r, b, posx, posy): """ :param x: :param y: :param r: :param b: :param posx: :param posy: """ posx = abs(posx-(x/2.0)) posy = abs(posy-(y/2.0)) wx = 0.5*x-rc-r wy = 0.5*y-rc-r if (posx <= wx) or (posy <= wx): return 0 return dist(posx-wx, posy-wy) > rc self.hexHolesRectangle(x, y, settings, skip=skip) def hexHolesHex(self, h, settings=None, grow=None): """ Fill a hexagon with holes in a hex pattern :param h: height :param settings: (Default value = None) :param grow: (Default value = None) """ if settings is None: settings = self.hexHolesSettings r, b, style = settings self.ctx.rectangle(0, 0, h, h) w = r+b/2.0 dist = w * math.cos(math.pi/6.0) cy = 2 * int((h-4*dist)// (4*w)) + 1 leftover = h-2*r-(cy-1)*2*r if grow=='space ': b += leftover / (cy-1) / 2 # recalulate with adjusted values w = r+b/2.0 dist = w * math.cos(math.pi/6.0) self.moveTo(h/2.0-(cy//2)*2*w, h/2.0) for j in range(cy): self.hole(2*j*w, 0, r) for i in range(1, cy/2+1): for j in range(cy-i): self.hole(j*2*w+i*w, i*2*dist, r) self.hole(j*2*w+i*w, -i*2*dist, r) ################################################## ### parts ################################################## def roundedPlate(self, x, y, r, callback=None, holesMargin=None, holesSettings=None, bedBolts=None, bedBoltSettings=None, move=None): """Plate with rounded corner fitting to .surroundingWall() First edge is split to have a joint in the middle of the side callback is called at the beginning of the straight edges 0, 1 for the two part of the first edge, 2, 3, 4 for the others :param x: width :param y: hight :param r: radius of the corners :param callback: (Default value = None) :param holesMargin: (Default value = None) set to get hex holes :param holesSettings: (Default value = None) :param bedBolts: (Default value = None) :param bedBoltSettings: (Default value = None) :param move: (Default value = None) """ overallwidth = x+2*self.fingerJointEdge.spacing() overallheight = y+2*self.fingerJointEdge.spacing() if self.move(overallwidth, overallheight, move, before=True): return self.ctx.save() self.moveTo(self.fingerJointEdge.margin(), self.fingerJointEdge.margin()) self.moveTo(r, 0) self.cc(callback, 0) self.fingerJointEdge(x/2.0-r, bedBolts=self.getEntry(bedBolts, 0), bedBoltSettings=self.getEntry(bedBoltSettings, 0)) self.cc(callback, 1) self.fingerJointEdge(x/2.0-r, bedBolts=self.getEntry(bedBolts, 1), bedBoltSettings=self.getEntry(bedBoltSettings, 1)) for i, l in zip(range(3), (y, x, y)): self.corner(90, r) self.cc(callback, i+2) self.fingerJointEdge(l-2*r, bedBolts=self.getEntry(bedBolts, i+2), bedBoltSettings=self.getEntry(bedBoltSettings, i+2)) self.corner(90, r) self.ctx.restore() self.ctx.save() self.moveTo(self.fingerJointEdge.margin(), self.fingerJointEdge.margin()) if holesMargin is not None: self.moveTo(holesMargin, holesMargin) if r > holesMargin: r -= holesMargin else: r = 0 self.hexHolesPlate(x-2*holesMargin, y-2*holesMargin, r, settings=holesSettings) self.ctx.restore() self.ctx.stroke() self.move(overallwidth, overallheight, move) def surroundingWall(self, x, y, r, h, bottom='e', top='e', callback=None, move=None): """h : inner height, not counting the joints callback is called a beginn of the flat sides with * 0 for right half of first x side; * 1 and 3 for y sides; * 2 for second x side * 4 for second half of the first x side :param x: width of matching roundedPlate :param y: height of matching roundedPlate :param r: corner radius of matching roundedPlate :param h: height of the wall :param bottom: (Default value = 'e') Edge type :param top: (Default value = 'e') Edge type :param callback: (Default value = None) :param move: (Default value = None) """ c4 = (r+self.burn)*math.pi*0.5 # circumference of quarter circle c4 = 0.9 * c4 # stretch flex 10% top = self.edges.get(top, top) bottom = self.edges.get(bottom, bottom) topwidth = top.width() bottomwidth = bottom.width() overallwidth = 2*x + 2*y - 8*r + 4*c4 + \ self.edges["d"].spacing() + self.edges["D"].spacing() overallheight = h + top.spacing() + bottom.spacing() if self.move(overallwidth, overallheight, move, before=True): return self.ctx.save() self.moveTo(self.edges["D"].margin(), bottom.margin()) self.cc(callback, 0, y=bottomwidth+self.burn) bottom(x/2.0-r) if (y-2*r) < 1E-3: self.flexEdge(2*c4, h+topwidth+bottomwidth) self.cc(callback, 2, y=bottomwidth+self.burn) bottom(x-2*r) self.flexEdge(2*c4, h+topwidth+bottomwidth) else: for i, l in zip(range(4), (y, x, y, 0)): self.flexEdge(c4, h+topwidth+bottomwidth) self.cc(callback, i+1, y=bottomwidth+self.burn) if i < 3: bottom(l-2*r) bottom(x/2.0-r) self.corner(90) self.edge(bottomwidth) self.doveTailJoint(h) self.edge(topwidth) self.corner(90) top(x/2.0-r) for i, l in zip(range(4), (y, x, y, 0)): self.edge(c4) if i < 3: top(l - 2*r) top(x/2.0-r) self.corner(90) self.edge(topwidth) self.doveTailJointCounterPart(h) self.edge(bottomwidth) self.corner(90) self.ctx.restore() self.ctx.stroke() self.move(overallwidth, overallheight, move) def rectangularWall(self, x, y, edges="eeee", holesMargin=None, holesSettings=None, bedBolts=None, bedBoltSettings=None, callback=None, move=None): """ Rectangular wall for all kind of box like objects :param x: width :param y: height :param edges: (Default value = "eeee") bottom, right, top, left :param holesMargin: (Default value = None) :param holesSettings: (Default value = None) :param bedBolts: (Default value = None) :param bedBoltSettings: (Default value = None) :param callback: (Default value = None) :param move: (Default value = None) """ if len(edges) != 4: raise ValueError("four edges required") edges = [self.edges.get(e, e) for e in edges] edges += edges # append for wrapping around overallwidth = x + edges[-1].spacing() + edges[1].spacing() overallheight = y + edges[0].spacing() + edges[2].spacing() if self.move(overallwidth, overallheight, move, before=True): return self.ctx.save() self.moveTo(edges[-1].margin(), edges[0].margin()) for i, l in enumerate((x, y, x, y)): self.edge(edges[i-1].width()) self.cc(callback, i, y=edges[i].width()+self.burn) edges[i](l, bedBolts=self.getEntry(bedBolts, i), bedBoltSettings=self.getEntry(bedBoltSettings, i)) self.edge(edges[i+1].width()) self.corner(90-edges[i].endAngle()-edges[i+1].startAngle()) if holesMargin is not None: self.moveTo(holesMargin+edges[-1].width(), holesMargin+edges[0].width()) self.hexHolesRectangle(x-2*holesMargin, y-2*holesMargin) self.ctx.restore() self.ctx.stroke() self.move(overallwidth, overallheight, move) ################################################## ### main ################################################## class DemoBox(Boxes): """A simple fully enclosed box showcasing different finger joints""" def __init__(self): Boxes.__init__(self) self.buildArgParser("x", "y", "h") def render(self): """ """ x, y, h, t = self.x, self.y, self.h, self.thickness self.open(2*x+10*self.thickness, y+2*h+20*self.thickness) self.ctx.save() self.moveTo(t, t) self.rectangularWall(x, y, "ffff") self.moveTo(x+4*t, 0) self.rectangularWall(x, y, "FFFF") self.ctx.restore() self.moveTo(t, y+4*t) for i in range(2): for l in (x, y): self.rectangularWall(l, h, "hffF") self.moveTo(l+4*t, 0) self.moveTo(-x-y-8*t, h+4*t) self.close() if __name__ == '__main__': b = DemoBox() b.parseArgs() b.render()