# Copyright (C) 2013-2019 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 <http://www.gnu.org/licenses/>.
from boxes import *
from boxes.walledges import _WallMountedBox
class PinEdge(edges.BaseEdge):
def __call__(self, length, **kw):
w2 = self.settings.pinwidth/2
l = self.settings.pinlength
s = self.settings.pinspacing
inc = self.settings.pinspacing_increment
t = self.settings.thickness
pin = [0, -90, l+t-w2, (180, w2), l+t-w2, -90]
self.edge(s/2-w2)
s += inc/2
for i in range(self.pins-1):
self.polyline(*pin, s-2*w2)
s+=inc
self.polyline(*pin, s/2-w2-inc/4)
def margin(self) -> float:
return self.settings.thickness+self.settings.pinlength
[docs]
class WallPinRow(_WallMountedBox):
"""Outset and angled plate to mount stuff to"""
def __init__(self) -> None:
super().__init__()
self.argparser.add_argument(
"--pins", action="store", type=int, default=8,
help="number of pins")
self.argparser.add_argument(
"--pinlength", action="store", type=float, default=35,
help="length of pins (in mm)")
self.argparser.add_argument(
"--pinwidth", action="store", type=float, default=10,
help="width of pins (in mm)")
self.argparser.add_argument(
"--pinspacing", action="store", type=float, default=35,
help="space from middle to middle of pins (in mm)")
self.argparser.add_argument(
"--pinspacing_increment", action="store", type=float, default=0.0,
help="increase spacing from left to right (in mm)")
self.argparser.add_argument(
"--angle", action="store", type=float, default=20.0,
help="angle of the pins pointing up (in degrees)")
self.argparser.add_argument(
"--hooks", action="store", type=int, default=3,
help="number of hooks into the wall")
self.argparser.add_argument(
"--h", action="store", type=float, default=50.0,
help="height of the front plate (in mm) - needs to be at least 7 time the thickness")
def frontCB(self):
s = self.pinspacing
inc = self.pinspacing_increment
t = self.thickness
pos = s/2
s += 0.5*inc
for i in range(self.pins):
self.rectangularHole(pos, 2*t, self.pinwidth, t)
pos += s
s+=inc
for i in range(1, self.hooks-1):
self.fingerHolesAt(i*self.x/(self.hooks-1), self.h/2, self.h/2)
def backCB(self):
t = self.thickness
self.fingerHolesAt(0, 2*t, self.x, 0)
if self.angle < 0.001:
return
for i in range(1, self.hooks-1):
self.fingerHolesAt(i*self.x/(self.hooks-1), 3*t, self.h/2-3*t)
def sideWall(self, move=None):
a = self.angle
ar = math.radians(a)
h = self.h
t = self.thickness
sh = math.sin(ar)*6*t + math.cos(ar)*h
tw = self.edges["a"].margin() + math.sin(ar)*h + math.cos(ar)*6*t
th = sh + 6
if self.move(tw, th, move, True):
return
self.moveTo(self.edges["a"].margin())
self.polyline(math.sin(ar)*h, a, 4*t)
self.fingerHolesAt(-3.5*t, 0, h/2, 90)
self.edgeCorner("e", "h")
self.edges["h"](h)
self.polyline(0, 90-a, math.cos(ar)*6*t, 90)
self.edges["a"](sh)
self.corner(90)
self.move(tw, th, move)
def supportWall(self, move=None):
a = self.angle
ar = math.radians(a)
h = self.h
t = self.thickness
sh = math.sin(ar)*6*t + math.cos(ar)*h
tw = self.edges["a"].margin() + max(
math.sin(ar)*h/2 + math.cos(ar)*5*t,
math.sin(ar)*h)
th = sh + 6
if self.move(tw, th, move, True):
return
self.moveTo(self.edges["a"].margin())
if a > 0.001:
self.polyline(math.sin(ar)*h, a+90, 3*t)
self.edges["f"](h/2-3*t)
self.polyline(0, -90)
self.polyline(4*t, 90)
self.edges["f"](h/2)
self.polyline(math.sin(ar)*2*t, 90-a,
math.cos(ar)*4*t - math.sin(ar)**2*2*t, 90)
if a > 0.001:
self.edges["a"](sh)
else:
self.edges["a"](h/2)
self.corner(90)
self.move(tw, th, move)
def render(self):
self.generateWallEdges()
p = PinEdge(self, self)
n = self.pins
t = self.thickness
if self.h < 7*t:
self.h = 7*t
self.x = x = n*self.pinspacing + (n)*(n-1)/2 *self.pinspacing_increment
self.rectangularWall(x, 3*t, [p, "e", "f", "e"], move="up")
self.rectangularWall(x, self.h, "efef", callback=[self.frontCB],
move="up")
self.rectangularWall(x, self.h/2, "efef", callback=[self.backCB],
move="up")
self.sideWall(move="right")
for i in range(self.hooks-2):
self.supportWall(move="right")
self.sideWall(move="right")
