3500 lines
201 KiB
Python
3500 lines
201 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# We will use the inkex module with the predefined Effect base class.
|
|
import inkex
|
|
# The simplestyle module provides functions for style parsing.
|
|
|
|
import simplestyle
|
|
import math
|
|
from th_inkscape_path import *
|
|
from lxml import etree
|
|
|
|
#Constants defined here
|
|
WoodHingeSize = 3 #To be multiplied by thickness
|
|
WoodHingeInternalCircle = 2 #To be multiplied by thickness
|
|
WoodHingeRect = 1.5 #To be multiplied by thickness
|
|
|
|
SteelHingeSpacing = 0.3
|
|
RadiusSteelHingeAxis = 1.3 #Use axis about 2.6mm diameter, I use nails 2.3mmx70mm. The actual hole will be larger
|
|
RadiusSteelHingeAxisChange = 0.25 #Factor the the larger hole, multiplied by thickness
|
|
MinMove = 1e-2 #Minimum distance betwwen two points (0.01 mm !)
|
|
|
|
SlidingLidSpaceZ = 1.3 #Space to allow easy move of the sliding lid (z or thickness). To be multiplied by thickness
|
|
SlidingLidSpaceX = 1.0 #Space to allow easy move in X direction/
|
|
|
|
|
|
#Global variables used for the whole program
|
|
thickness = 0
|
|
burn = 0
|
|
fDebug = None
|
|
|
|
def distance2Points(x0, y0, x1, y1):
|
|
return math.sqrt((x1-x0)**2 + (y1-y0)**2)
|
|
|
|
def DebugMsg(s):
|
|
'''
|
|
Print a debug message into debug file if debug file is defined
|
|
'''
|
|
if fDebug:
|
|
fDebug.write(s)
|
|
|
|
def OpenDebugFile():
|
|
global fDebug
|
|
try:
|
|
fDebug = open( 'DebugGenericBox.txt', 'w')
|
|
except IOError:
|
|
pass
|
|
DebugMsg("Start processing\n")
|
|
|
|
def CloseDebugFile():
|
|
global fDebug
|
|
if fDebug:
|
|
fDebug.close()
|
|
fDebug = None
|
|
|
|
def drawHole(path, x0, y0, dx, dy, burn):
|
|
'''
|
|
Add a rectangle starting at x0,y0 and with a length dx and width dy to the current path
|
|
burn is the burn factor, so actual coordinates are modified by burn/2
|
|
'''
|
|
path.MoveTo(x0+burn/2, y0+burn/2)
|
|
path.LineToVRel(dy-burn)
|
|
path.LineToHRel(dx-burn)
|
|
path.LineToVRel(-dy+burn)
|
|
path.LineToHRel(-dx+burn)
|
|
|
|
# Generate vertical lines for flex
|
|
# Parameters : StartX, StartY, size, nunmber of lines and +1 if lines goes up and -1 down
|
|
def GenLinesFlex(StartX, StartY, Size, nLine, UpDown, path):
|
|
DebugMsg("Enter GenLinesFlex, Pos="+str((StartX, StartY))+" nSegment="+str(nLine)+" Size Segment="+str(Size)+" UpDown="+str(UpDown)+" End="+str((StartX, StartY+nLine*(Size+2)-2))+'\n')
|
|
for i in range(nLine):
|
|
path.Line(StartX, StartY, StartX, StartY + UpDown*Size)
|
|
DebugMsg("GenLinesFlex from "+str((StartX, StartY))+" to "+str((StartX, StartY + UpDown*Size))+'\n')
|
|
StartY += UpDown*(Size+2)
|
|
|
|
|
|
class Ellipse:
|
|
'''
|
|
This class defines some functions that will be used with the coffin style lid
|
|
'''
|
|
def __init__(self, a, b):
|
|
'''
|
|
a and b are the ellipse parameters
|
|
'''
|
|
self.a = a
|
|
self.b = b
|
|
self.Start = 0
|
|
|
|
def length(self):
|
|
'''
|
|
Compute a rather good approwimation of the ellipse length.
|
|
Use the formula Ramanujan 2
|
|
'''
|
|
h = (self.a - self.b)*(self.a - self.b)/((self.a + self.b)*(self.a + self.b))
|
|
|
|
l = math.pi*(self.a+self.b)*(1.0 + 3*h/(10.0+math.sqrt(4.0-3*h)))
|
|
return l
|
|
|
|
def length2Angle(self, l):
|
|
'''
|
|
Compute the angle which gives the given length on the ellipse.
|
|
The ellipse perimeter couldn't be computed from known functions, so we use a discrete integral computation
|
|
In order to save time, this function should be called with increasing value of l, i.e. it doesn't recompute values less than previous parameter l
|
|
'''
|
|
CurDistance = PrevDistance = self.LastDistance
|
|
index = self.CurPoint
|
|
while CurDistance < l and index < self.nPoints:
|
|
PrevDistance = CurDistance
|
|
Alpha = (index +0.5)* self.StepAngle + self.Start
|
|
CurDistance += self.StepAngle*math.sqrt((self.a*math.sin(Alpha))**2 + (self.b*math.cos(Alpha))**2)
|
|
index += 1
|
|
#Will stop here, record values
|
|
self.LastDistance = CurDistance
|
|
self.CurPoint = index
|
|
#Interpolate between the last points to increase precision
|
|
if CurDistance > PrevDistance:
|
|
Delta = (l - PrevDistance)/(CurDistance - PrevDistance)*self.StepAngle
|
|
return (index-1)*self.StepAngle + Delta + self.Start
|
|
else:
|
|
return index*self.StepAngle + self.Start
|
|
|
|
def Compute_Ellipse_Params(self, Start, End):
|
|
self.length_ellipse = self.length() * (End - Start)/math.pi/2.0
|
|
self.Start = Start
|
|
self.End = End
|
|
#Compute length between notches, each notch is about 2mm wide, total length is 2*( l_between_notches + 1)
|
|
if self.length_ellipse < 80:
|
|
self.l_between_notches = 1
|
|
elif self.length_ellipse < 150:
|
|
self.l_between_notches = 2
|
|
elif self.length_ellipse < 250:
|
|
self.l_between_notches = 3
|
|
else:
|
|
self.l_between_notches = 4
|
|
self.nb_Ellipse_Notch = int(round(self.length_ellipse / (2*( self.l_between_notches + 1) + 2),0)) #Add a notch at the end
|
|
self.size_Ellipse_Notch = self.length_ellipse / (self.nb_Ellipse_Notch *( self.l_between_notches + 1) + 1)
|
|
self.Size_betweenNotches = self.l_between_notches*self.size_Ellipse_Notch
|
|
self.nb_point_between_notches = int(round(self.Size_betweenNotches))
|
|
self.SizeBetweenPoints = self.Size_betweenNotches / self.nb_point_between_notches
|
|
DebugMsg("Ellipse length ="+str(self.length_ellipse)+" nb_Ellipse_Notch="+str(self.nb_Ellipse_Notch)
|
|
+" size_Ellipse_Notch="+str(self.size_Ellipse_Notch)+" Distance between notches="+str((self.l_between_notches+1)*self.size_Ellipse_Notch)
|
|
+"mm, Nb point_between nocthes="+str(self.nb_point_between_notches)
|
|
+" Total Size Notch ="+str(self.size_Ellipse_Notch*self.nb_Ellipse_Notch*(self.l_between_notches+1)+self.size_Ellipse_Notch)+'\n')
|
|
#Compute the number of points used to compute the integration, and init values to be used by length2Angle
|
|
if self.length_ellipse < 500:
|
|
self.nPoints = 20000 #Error will be less than 0.01mm
|
|
elif self.length_ellipse < 2000:
|
|
self.nPoints = 100000
|
|
else:
|
|
self.nPoints = 500000 #Beware compute time will be higher.
|
|
|
|
def drawNotchedEllipse(self, path, Start, End, Offset):
|
|
'''
|
|
draw the notched ellipse from Start Angle to End Angle using path path
|
|
'''
|
|
self.Compute_Ellipse_Params(Start, End)
|
|
#Compute offset to be added to coordinates such as the start point matches with start angle
|
|
xOffset = -self.a*math.cos(Start) + Offset[0]
|
|
yOffset = -self.a*math.sin(Start) + Offset[1]
|
|
self.StepAngle = (End - Start)/self.nPoints
|
|
self.CurPoint = 0
|
|
self.LastDistance = 0.0 #At the start point
|
|
DebugMsg("nPoints ="+str(self.nPoints)+" StepAngle="+str(self.StepAngle)+"\n")
|
|
DebugMsg("Offset Ellipse="+str((xOffset, yOffset))+'\n')
|
|
'''
|
|
#TEST
|
|
a1 = self.length2Angle(1.0)
|
|
DebugMsg("length2Angle(1.0) --> "+str(a1*180/math.pi)+'\n')
|
|
a2 = self.length2Angle(2.0)
|
|
DebugMsg("length2Angle(2.0) --> "+str(a2*180/math.pi)+'\n')
|
|
a3 = self.length2Angle(5.0)
|
|
DebugMsg("length2Angle(5.0) --> "+str(a3*180/math.pi)+'\n')
|
|
a4 = self.length2Angle(10.0)
|
|
DebugMsg("length2Angle(10.0) --> "+str(a4*180/math.pi)+'\n')
|
|
a5 = self.length2Angle(self.length_ellipse/2.0)
|
|
DebugMsg("length2Angle(length/2) --> "+str(a5*180/math.pi)+'\n')
|
|
a6 = self.length2Angle(3*self.length_ellipse/4.0)
|
|
DebugMsg("length2Angle(length*0.75) --> "+str(a6*180/math.pi)+'\n')
|
|
a7 = self.length2Angle(self.length_ellipse-2.0)
|
|
DebugMsg("length2Angle(length-2) --> "+str(a7*180/math.pi)+'\n')
|
|
a8 = self.length2Angle(self.length_ellipse-1.0)
|
|
DebugMsg("length2Angle(length-1) --> "+str(a8*180/math.pi)+'\n')
|
|
a9 = self.length2Angle(self.length_ellipse)
|
|
DebugMsg("length2Angle(length) --> "+str(a9*180/math.pi)+'\n')
|
|
self.StepAngle = (End - Start)/self.nPoints
|
|
self.CurPoint = 0
|
|
self.LastDistance = 0.0 #At the start point
|
|
a9 = self.length2Angle(self.length_ellipse)
|
|
DebugMsg("length2Angle(length), fresh start --> "+str(a9*180/math.pi)+'\n')
|
|
self.CurPoint = 0
|
|
self.LastDistance = 0.0 #At the start point
|
|
#End TEST
|
|
'''
|
|
#The side face is "internal", that is the notches are towards the exterior.
|
|
DeltaAngleNotches = -math.pi/2 #Angle from the tangeant
|
|
CurAngle = Start #Starting point
|
|
CurDistance = 0 #Distance on ellipse
|
|
#Now for all notches but the last one
|
|
for i in range(self.nb_Ellipse_Notch):
|
|
#Start with the notch itself, but first compute the tangeant at the current point
|
|
theta = math.atan2(self.b*math.cos(CurAngle), -self.a*math.sin(CurAngle))
|
|
AngleNotch = theta + DeltaAngleNotches
|
|
#Draw notch , start position on ellipse + Notch itself
|
|
x = self.a * math.cos(CurAngle) + thickness * math.cos(AngleNotch) + xOffset
|
|
y = self.b * math.sin(CurAngle) + thickness * math.sin(AngleNotch) + yOffset
|
|
DebugMsg("Notch, Pos without offset="+str((self.a * math.cos(CurAngle) + thickness * math.cos(AngleNotch), self.b * math.sin(CurAngle) + thickness * math.sin(AngleNotch) ))+" WithOffset"+str((x,y))+'\n')
|
|
path.LineTo(x, y)
|
|
#Now the side parralel to the ellipse
|
|
x += self.size_Ellipse_Notch * math.cos(theta)
|
|
y += self.size_Ellipse_Notch * math.sin(theta)
|
|
path.LineTo(x, y)
|
|
#Now back to the ellipse, do not use the angle to come back to the ellipse but compute the position on ellipse.
|
|
#This will give a better approximation of the ellipse. As ellipse is convex, the interior of the notch will be shorter than the exterior
|
|
CurDistance += self.size_Ellipse_Notch
|
|
CurAngle = self.length2Angle(CurDistance)
|
|
x = self.a * math.cos(CurAngle) + xOffset
|
|
y = self.b * math.sin(CurAngle) + yOffset
|
|
path.LineTo(x, y)
|
|
#Now draw the interior line, but mm by mm to have a good approximation of the ellipse
|
|
for j in range(self.nb_point_between_notches):
|
|
CurDistance += self.SizeBetweenPoints
|
|
CurAngle = self.length2Angle(CurDistance)
|
|
x = self.a * math.cos(CurAngle) + xOffset
|
|
y = self.b * math.sin(CurAngle) + yOffset
|
|
path.LineTo(x, y)
|
|
#We are now ready to draw the next notch
|
|
#Now draw the last notch, but draw it "backward" to have a symetric view.
|
|
theta = math.atan2(self.b*math.cos(End), -self.a*math.sin(End))
|
|
AngleNotch = theta + DeltaAngleNotches
|
|
#Draw notch , start position on ellipse + Notch itself
|
|
x_end_notch = self.a * math.cos(End) + thickness * math.cos(AngleNotch) + xOffset
|
|
y_end_notch = self.b * math.sin(End) + thickness * math.sin(AngleNotch) + yOffset
|
|
#Now the side parralel to the ellipse
|
|
x_start_notch = x_end_notch - self.size_Ellipse_Notch * math.cos(theta)
|
|
y_start_notch = y_end_notch - self.size_Ellipse_Notch * math.sin(theta)
|
|
path.LineTo(x_start_notch, y_start_notch)
|
|
path.LineTo(x_end_notch, y_end_notch)
|
|
#For the last point, we will use the End Parameter
|
|
x = self.a * math.cos(End) + xOffset
|
|
y = self.b * math.sin(End) + yOffset
|
|
path.LineTo(x,y)
|
|
#We should be arrived at the last point now !
|
|
|
|
|
|
def drawFlexEllipse(self, path, height, SkipFlex, Position):
|
|
'''
|
|
draw the flex lines for the ellipse
|
|
After this path will be at the right/bottom corner of the flex line.
|
|
'''
|
|
xpos = Position[0]
|
|
ypos = Position[1]
|
|
#First compute angles of each notch in order to skip unnecessary flex lines
|
|
|
|
self.StepAngle = (self.End - self.Start)/self.nPoints
|
|
self.CurPoint = 0
|
|
self.LastDistance = 0.0 #At the start point
|
|
CurAngle = self.Start #Starting point
|
|
CurDistance = 0 #Distance on ellipse
|
|
DeltaNotch = (self.l_between_notches+1)*self.size_Ellipse_Notch
|
|
ListDistance = []
|
|
#Now for all notches but the last one
|
|
for i in range(self.nb_Ellipse_Notch):
|
|
#Start with the notch itself, but first compute the tangeant at the current point (x0,y0)
|
|
LastAngle = CurAngle
|
|
# with the line equation in the form alpha*x + beta*y + gamma = 0
|
|
alpha = self.b * math.cos(CurAngle)
|
|
beta = self.a * math.sin(CurAngle)
|
|
gamma = -(self.a*self.b)
|
|
CurDistance += DeltaNotch
|
|
CurAngle = self.length2Angle(CurDistance)
|
|
#Now compute distance between tangeant and next point.
|
|
x1 = self.a * math.cos(CurAngle)
|
|
y1 = self.b * math.sin(CurAngle)
|
|
#Distance betwwen line and point is (alpha * pt.x + beta * pt.y + gamma)*(alpha * pt.x + beta * pt.y + gamme)/sqrt(alpha*alpha + beta*beta)
|
|
distance = abs(alpha * x1 + beta * y1 + gamma)/math.sqrt(alpha*alpha + beta*beta)
|
|
ListDistance.append(distance)
|
|
DebugMsg("LastAngle ="+str(round(180*LastAngle/math.pi,2))+" CurAngle="+str(round(180*CurAngle/math.pi,2))+" NewPoint="+str((x1,y1))+" distance="+str(distance)+'\n')
|
|
#and for the last one, repeat the previous
|
|
ListDistance.append(distance)
|
|
|
|
'''
|
|
Now, this is the real flex line drawing
|
|
'''
|
|
#Compute number of vertical lines. Each long mark should be at most 50mm long to avoid failures
|
|
TotalHeight = height+2*thickness
|
|
nMark = int( TotalHeight / 50) + 1 #Compute number of lines
|
|
nMark = max(nMark, 2) # At least 2 marks
|
|
#Sizes of short and long lines to make flex
|
|
LongMark = (TotalHeight / nMark) - 2.0 #Long Mark equally divide the height
|
|
ShortMark = LongMark/2 # And short mark should lay at center of long marks
|
|
DebugMsg("\ndrawFlexEllipse, Pos="+str(Position)+" TotalHeight="+str(TotalHeight)+" nMark="+str(nMark)+" LongMark="+str(LongMark)+" ShortMark="+str(ShortMark)+'\n')
|
|
for i in range(self.nb_Ellipse_Notch):
|
|
'''
|
|
For each set notch + interval between notches, always start with a notch, and we are external in this case
|
|
The path is designed as it will lead to "optimal" move of the laser beam.
|
|
|
|
First draw the nocth and the line inside the notch
|
|
First edge of the notch, start with a short line, then nMark-1 long lines then a short one. This will cover the entire height+2*thickness
|
|
The the second edge of the notch, the same but drawn backwards (bottom to top)
|
|
and at last the line inside the notch, drawn from top to bottom
|
|
'''
|
|
DebugMsg("Notch("+str(i)+"), SkipFlex="+str(SkipFlex)+" ListDistance[i]="+str(ListDistance[i])+'\n')
|
|
#Draw the edge line from Top to Bottom
|
|
GenLinesFlex(xpos, ypos, ShortMark, 1, 1, path)
|
|
#Then nMark-1 long Lines
|
|
GenLinesFlex(xpos, ypos+ShortMark+2, LongMark, nMark-1, 1, path)
|
|
#And the last short line
|
|
GenLinesFlex(xpos, ypos+TotalHeight-ShortMark, ShortMark, 1, 1, path)
|
|
#Now we are at the bottom of the Flex face, draw the bottom notch
|
|
path.Line(xpos, ypos+height+thickness, xpos+self.size_Ellipse_Notch, ypos+height+thickness)
|
|
#Then draw the same pattern for the other side of the notch, but bottom to top
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch, ypos+TotalHeight, ShortMark, 1, -1, path)
|
|
#Then nMark-1 long Lines
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch, ypos+TotalHeight-ShortMark-2, LongMark, nMark-1, -1, path)
|
|
#And the last short line that will reach the top external edge
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch, ypos+ShortMark, ShortMark, 1, -1, path)
|
|
#then the top notch
|
|
path.Line(xpos+self.size_Ellipse_Notch, ypos + thickness, xpos, ypos+thickness)
|
|
#Then draw the long lines inside the notch, first and last will be shorter by thickness
|
|
#This line is drawn from top to bottom, and start at 1mm from the interior of the notch
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch/2, ypos+thickness+1, LongMark-thickness, 1, 1, path)
|
|
#Then the remaining inside if any
|
|
if nMark > 2:
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch/2, ypos+3+LongMark, LongMark, nMark-2, 1, path)
|
|
#Then the last one, shorter also, will reach internal bottom + 1mm
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch/2, ypos+TotalHeight-LongMark-1, LongMark-thickness, 1, 1, path)
|
|
'''
|
|
At this point we are near the bottom line.
|
|
First draw the external line up to the next notch
|
|
'''
|
|
xpos += self.size_Ellipse_Notch #xpos is the other side of the notch
|
|
path.Line(xpos, ypos+TotalHeight, xpos+self.Size_betweenNotches, ypos+TotalHeight)
|
|
|
|
'''
|
|
Then draw the lines between external top and bottom, but only if needed when SkipFlex is true
|
|
They are 2*l_between_notches - 1 lines, so the number is always odd
|
|
Even indexes are made of long lines only and drawn Bottom to Top.
|
|
Odd indexes are made of one short line, nMark-2 long lines then a short line and rawn top to bottom
|
|
As total number is odd, wa always end with long lines drawn from bottom to top, so the last position will be near the top line
|
|
'''
|
|
#If the ellipse is not very round at this point, in order to save laser time, draw only lines inside the notch and the line just before the notch
|
|
drawAllLines = False
|
|
if SkipFlex == False or ListDistance[i] > 0.5:
|
|
drawAllLines = True
|
|
for j in range(2*self.l_between_notches-1):
|
|
if j == 2*self.l_between_notches-2 or drawAllLines:
|
|
if (j % 2)==0:
|
|
#even, draw long lines bottom to top
|
|
GenLinesFlex(xpos+(j+1)*self.size_Ellipse_Notch/2, ypos+TotalHeight-1, LongMark, nMark, -1, path)
|
|
else:
|
|
#Odd, draw short line, nMark-2 long lines then a short line, top to bottom
|
|
GenLinesFlex(xpos+(j+1)*self.size_Ellipse_Notch/2, ypos+1, ShortMark-1, 1, 1, path)
|
|
#Then nMark-1 long Lines
|
|
GenLinesFlex(xpos+(j+1)*self.size_Ellipse_Notch/2, ypos+ShortMark+2, LongMark, nMark-1, 1, path)
|
|
#And the last short line
|
|
GenLinesFlex(xpos+(j+1)*self.size_Ellipse_Notch/2, ypos+TotalHeight-ShortMark, ShortMark-1, 1, 1, path)
|
|
#Now we are near the top line, draw the line up to the next notch
|
|
path.Line(xpos, ypos, xpos+self.Size_betweenNotches, ypos)
|
|
#And we are ready to draw the next flex pattern
|
|
xpos += self.Size_betweenNotches
|
|
|
|
'''
|
|
Now draw the pattern for the last notch
|
|
'''
|
|
#Draw the edge line from Top to Bottom
|
|
GenLinesFlex(xpos, ypos, ShortMark, 1, 1, path)
|
|
#Then nMark-1 long Lines
|
|
GenLinesFlex(xpos, ypos+ShortMark+2, LongMark, nMark-1, 1, path)
|
|
#And the last short line
|
|
GenLinesFlex(xpos, ypos+TotalHeight-ShortMark, ShortMark, 1, 1, path)
|
|
#Now we are at the bottom of the Flex face, draw the bottom notch
|
|
path.Line(xpos, ypos+height+thickness, xpos+self.size_Ellipse_Notch, ypos+height+thickness)
|
|
#Then draw the same pattern for the other side of the notch, but bottom to top
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch, ypos+TotalHeight, ShortMark, 1, -1, path)
|
|
#Then nMark-1 long Lines
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch, ypos+TotalHeight-ShortMark-2, LongMark, nMark-1, -1, path)
|
|
#And the last short line that will reach the top external edge
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch, ypos+ShortMark, ShortMark, 1, -1, path)
|
|
#then the top notch
|
|
path.Line(xpos+self.size_Ellipse_Notch, ypos + thickness, xpos, ypos+thickness)
|
|
#Then draw the long lines inside the notch, first and last will be shorter by thickness
|
|
#This line is drawn from top to bottom, and start at 1mm from the interior of the notch
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch/2, ypos+thickness+1, LongMark-thickness, 1, 1, path)
|
|
#Then the remaining inside if any
|
|
if nMark > 2:
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch/2, ypos+3+LongMark, LongMark, nMark-2, 1, path)
|
|
#Then the last one, shorter also, will reach internal bottom + 1mm
|
|
GenLinesFlex(xpos+self.size_Ellipse_Notch/2, ypos+TotalHeight-LongMark-1, LongMark-thickness, 1, 1, path)
|
|
xpos += self.size_Ellipse_Notch #xpos is the other side of the notch
|
|
path.MoveTo(xpos, ypos+TotalHeight) #Path will be at the end of flex line on the BOTTOM edge.
|
|
DebugMsg("Path pos ="+str((xpos, ypos+TotalHeight))+'\n')
|
|
|
|
class CornerPoint:
|
|
'''
|
|
This class stores data about corners, to be used later to draw the faces of the box
|
|
position is a tuple giving the position of the corner
|
|
'''
|
|
def __init__(self, position, radius, x_internal, y_internal, WoodHingeCorner = False):
|
|
self.x_internal = x_internal
|
|
self.y_internal = y_internal
|
|
self.WoodHingeCorner = WoodHingeCorner
|
|
if radius > 0:
|
|
self.radius = radius
|
|
else:
|
|
self.radius = 0
|
|
#Compute position of circle center and corner according to corner quadrant and internal / external flags
|
|
if position[0] <= thickness:
|
|
#Left corner
|
|
if x_internal:
|
|
self.xc = position[0] + self.radius
|
|
self.x_corner = position[0]
|
|
else:
|
|
self.xc = position[0] + self.radius - thickness
|
|
self.x_corner = position[0] - thickness
|
|
else:
|
|
#Right corner
|
|
if x_internal:
|
|
self.xc = position[0] - self.radius
|
|
self.x_corner = position[0]
|
|
else:
|
|
self.xc = position[0] - self.radius + thickness
|
|
self.x_corner = position[0] + thickness
|
|
if position[1] <= thickness:
|
|
#Top corner
|
|
if y_internal:
|
|
self.yc = position[1] + self.radius
|
|
self.y_corner = position[1]
|
|
else:
|
|
self.yc = position[1] + self.radius - thickness
|
|
self.y_corner = position[1] - thickness
|
|
else:
|
|
#Bottom corner
|
|
if y_internal:
|
|
self.yc = position[1] - self.radius
|
|
self.y_corner = position[1]
|
|
else:
|
|
self.yc = position[1] - self.radius + thickness
|
|
self.y_corner = position[1] + thickness
|
|
|
|
#Compute position of line of finger joints
|
|
if position[0] <= thickness and position[1] <= thickness:
|
|
#Top left corner, compute positions of start/end of corners
|
|
self.quadrant = 0
|
|
self.x_start_joint = position[0] + self.radius #X direction, do not take into account Internal/External
|
|
self.y_start_joint = self.y_corner
|
|
self.x_end_joint = self.x_corner
|
|
self.y_end_joint = position[1] + self.radius #Y Direction, do not take into account Internal/External
|
|
elif position[1] <= thickness:
|
|
#Top right corner
|
|
self.quadrant = 1
|
|
self.x_start_joint = self.x_corner
|
|
self.y_start_joint = position[1] + self.radius
|
|
self.x_end_joint = position[0] - self.radius
|
|
self.y_end_joint = self.y_corner
|
|
elif position[0] <= thickness:
|
|
#Bottom left corner
|
|
self.quadrant = 3
|
|
self.x_start_joint = self.x_corner
|
|
self.y_start_joint = position[1] - self.radius
|
|
self.x_end_joint = position[0] + self.radius
|
|
self.y_end_joint = self.y_corner
|
|
else:
|
|
#Bottom right corner
|
|
self.quadrant = 2
|
|
self.x_start_joint = position[0] - self.radius
|
|
self.y_start_joint = self.y_corner
|
|
self.x_end_joint = self.x_corner
|
|
self.y_end_joint = position[1] - self.radius
|
|
#Specific case for WoodHingeCorner, "corner" is 3/4 of the circle out of the corner
|
|
if WoodHingeCorner:
|
|
if self.quadrant == 0:
|
|
self.y_end_joint = self.y_corner + WoodHingeSize*thickness
|
|
self.x_start_joint = self.x_corner + WoodHingeSize*thickness
|
|
elif self.quadrant == 1:
|
|
self.x_end_joint = self.x_corner - WoodHingeSize*thickness
|
|
self.y_start_joint = self.y_corner + WoodHingeSize*thickness
|
|
DebugMsg("End CornerPoint init. Corner="+str((self.x_corner, self.y_corner))+" Circle="+str((self.xc, self.yc, self.radius))+" StartJoint="+str((self.x_start_joint, self.y_start_joint))+" EndJoint="+str((self.x_end_joint, self.y_end_joint))+" WoodHingeCorner="+str(self.WoodHingeCorner)+'\n')
|
|
|
|
def drawCorner(self, path):
|
|
'''
|
|
Draw the lines around the corner using path
|
|
Start position of the path should be (x_end_joint, y_end_joint), not checked nor enforced
|
|
End Position is (x_start_joint, y_start_joint)
|
|
'''
|
|
DebugMsg("Start drawCorner PathPos ="+str((path.x_noff, path.y_noff))+'\n')
|
|
if self.WoodHingeCorner:
|
|
#Specific case, draw 3/4 of a circle of radius WoodHingeSize*thickness + plus a small segment of size thickness
|
|
if self.quadrant == 0: #Left corner
|
|
DebugMsg("drawCorner_WoodHinge Left: StartPoint="+str((self.x_end_joint, self.y_end_joint))+" Circle="+str((self.xc, self.yc))+ " EndPoint="+str((self.x_start_joint, self.y_start_joint))+'\n')
|
|
path.LineToHRel(-thickness)
|
|
path.drawQuarterCircle(self.x_corner-thickness, self.y_corner, WoodHingeSize*thickness, 3) #Start Lower Left
|
|
path.drawQuarterCircle(self.x_corner-thickness, self.y_corner, WoodHingeSize*thickness, 0) #Start Upper Left
|
|
path.drawQuarterCircle(self.x_corner-thickness, self.y_corner, WoodHingeSize*thickness, 1) #Start Upper Right
|
|
elif self.quadrant == 1: #Right corner
|
|
DebugMsg("drawCorner_WoodHinge Right: StartPoint="+str((self.x_end_joint, self.y_end_joint))+" Circle="+str((self.xc, self.yc))+ " EndPoint="+str((self.x_start_joint, self.y_start_joint))+'\n')
|
|
path.LineToHRel(thickness)
|
|
path.drawQuarterCircle(self.x_corner+thickness, self.y_corner, WoodHingeSize*thickness, 0) #Start Upper Left
|
|
path.drawQuarterCircle(self.x_corner+thickness, self.y_corner, WoodHingeSize*thickness, 1) #Start Upper Right
|
|
path.drawQuarterCircle(self.x_corner+thickness, self.y_corner, WoodHingeSize*thickness, 2) #Start Lower Right
|
|
path.LineToHRel(-thickness)
|
|
elif self.radius > 0:
|
|
nxc = self.xc
|
|
nyc = self.yc
|
|
if self.quadrant == 0:
|
|
#if needed, draw vertical line to cope with external corner
|
|
if self.y_internal == 0:
|
|
path.LineToVRel(-thickness)
|
|
DebugMsg("drawCorner, move dY="+str(-thickness)+"\n")
|
|
elif self.quadrant == 1:
|
|
#if needed, draw horizontal line to cope with external corner
|
|
if self.x_internal == 0:
|
|
path.LineToHRel(thickness)
|
|
DebugMsg("drawCorner, move dX="+str(thickness)+"\n")
|
|
elif self.quadrant == 2:
|
|
#if needed, draw vertical line to cope with external corner
|
|
if self.y_internal == 0:
|
|
path.LineToVRel(thickness)
|
|
DebugMsg("drawCorner, move dY="+str(thickness)+"\n")
|
|
elif self.quadrant == 3:
|
|
#if needed, draw horizontal line to cope with external corner
|
|
if self.x_internal == 0:
|
|
path.LineToHRel(-thickness)
|
|
DebugMsg("drawCorner, move dX="+str(-thickness)+"\n")
|
|
DebugMsg("drawCorner before circle PathPos ="+str((path.x_noff, path.y_noff))+'\n')
|
|
DebugMsg("drawCorner radius Center"+str((nxc, nyc))+" Radius="+str(self.radius)+ " quadrant="+str(self.quadrant)+'\n')
|
|
path.drawQuarterCircle(nxc, nyc, self.radius, self.quadrant)
|
|
DebugMsg("drawCorner after circle PathPos ="+str((path.x_noff, path.y_noff))+'\n')
|
|
if self.quadrant == 0:
|
|
#if needed, draw H line to cope with external corner
|
|
if self.x_internal == 0:
|
|
path.LineToHRel(thickness)
|
|
DebugMsg("drawCorner, move dX="+str(thickness)+"\n")
|
|
elif self.quadrant == 1:
|
|
#if needed, draw V line to cope with external corner
|
|
if self.y_internal == 0:
|
|
path.LineToVRel(thickness)
|
|
DebugMsg("drawCorner, move dY="+str(thickness)+"\n")
|
|
elif self.quadrant == 2:
|
|
#if needed, draw H line to cope with external corner
|
|
if self.x_internal == 0:
|
|
path.LineToHRel(-thickness)
|
|
DebugMsg("drawCorner, move dX="+str(-thickness)+"\n")
|
|
elif self.quadrant == 3:
|
|
#if needed, draw V line to cope with external corner
|
|
if self.y_internal == 0:
|
|
path.LineToVRel(-thickness)
|
|
DebugMsg("drawCorner, move dY="+str(-thickness)+"\n")
|
|
else:
|
|
DebugMsg("drawCorner: StartPoint="+str((self.x_end_joint, self.y_end_joint))+" Corner="+str((self.x_corner, self.y_corner))+ " EndPoint="+str((self.x_start_joint, self.y_start_joint))+'\n')
|
|
if distance2Points(self.x_end_joint, self.y_end_joint, self.x_corner, self.y_corner) > MinMove:
|
|
#Draw line up to real corner
|
|
path.LineTo(self.x_corner, self.y_corner)
|
|
if distance2Points(self.x_start_joint, self.y_start_joint, self.x_corner, self.y_corner) > MinMove:
|
|
#Draw line between corner and start of joints
|
|
path.LineTo(self.x_start_joint, self.y_start_joint)
|
|
DebugMsg("End drawCorner PathPos ="+str((path.x_noff, path.y_noff))+'\n')
|
|
|
|
|
|
|
|
class NotchLine:
|
|
'''
|
|
This class deals with straight lines with or without finger joints
|
|
start and end parameters are actually tuples giving position (x,y) and internal/external status of each point
|
|
The angle give the direction, it couldn't be easily computed from start and ending point because of internal/external status
|
|
If parameter DrawHalf is < 0, only first half of line will be drawn, if > 0 only second half.
|
|
When DrawHalf is null both parts will be drawn
|
|
Beware, DrawHalf could be < 0 or > 0 only when Status (Internal/External) are indentical.
|
|
'''
|
|
def __init__(self, start, end, angle, finger_joint_size, DrawHalf=0):
|
|
self.StartX = start[0]
|
|
self.StartY = start[1]
|
|
self.EndX = end[0]
|
|
self.EndY = end[1]
|
|
self.StartStatus = start[2]
|
|
self.EndStatus = end[2]
|
|
self.JointSize = finger_joint_size
|
|
self.Angle = angle
|
|
self.size_line_joint = 0
|
|
self.start_line_joint_x = self.StartX
|
|
self.start_line_joint_y = self.StartY
|
|
self.end_line_joint_x = self.EndX
|
|
self.end_line_joint_y = self.EndY
|
|
self.DrawHalf = DrawHalf
|
|
DebugMsg("NotchLine_init, StartPoint="+str(start)+" EndPoint="+str(end)+" Joint_size="+str(finger_joint_size)+" DrawHalf="+str(DrawHalf)+'\n')
|
|
# Compute size of all finger joints
|
|
# Compute size as a distance to deal with every direction.
|
|
size = math.sqrt((self.EndX - self.StartX)*(self.EndX - self.StartX) + (self.EndY - self.StartY)*(self.EndY - self.StartY))
|
|
# Round size to avoid float errors
|
|
size = round(size, 3)
|
|
# Compute number of joints
|
|
if finger_joint_size == 0: # No finger joint
|
|
self.nb_finger_joint = 0
|
|
if DrawHalf != 0: #Draw only half of line (specific case for rounded flex)
|
|
self.EndX = (self.StartX + self.EndX) / 2
|
|
self.EndY = (self.StartY + self.EndY) / 2
|
|
self.end_line_joint_x = self.EndX
|
|
self.end_line_joint_y = self.EndY
|
|
elif start[2] == end[2]:
|
|
# Same status, internal/external, the number of notches should be odd (at least 3)
|
|
if size < 3 * finger_joint_size:
|
|
self.nb_finger_joint = 0
|
|
else:
|
|
self.nb_finger_joint = 2*int((size-finger_joint_size) / (2*finger_joint_size)) + 1
|
|
self.size_line_joint = self.nb_finger_joint * finger_joint_size
|
|
# compute start and stop of finger joint line, centered on edge
|
|
delta_pos = (size - self.size_line_joint)/2
|
|
self.start_line_joint_x = self.StartX + delta_pos*math.cos(angle)
|
|
self.start_line_joint_y = self.StartY + delta_pos*math.sin(angle)
|
|
self.end_line_joint_x = self.EndX - delta_pos*math.cos(angle)
|
|
self.end_line_joint_y = self.EndY - delta_pos*math.sin(angle)
|
|
if DrawHalf < 0:
|
|
#Draw only first half of notch line,i.e. end will be at the middle of segment
|
|
self.EndX = (self.StartX + self.EndX) / 2
|
|
self.EndY = (self.StartY + self.EndY) / 2
|
|
self.nb_finger_joint = (self.nb_finger_joint // 2 ) + 1 #Previous number was odd (2n+1), new notch count = n + 1, as last one will be half notch
|
|
self.end_line_joint_x = self.start_line_joint_x + ((self.nb_finger_joint-0.5)*finger_joint_size)*math.cos(angle) #Quit line at end of last notch
|
|
self.end_line_joint_y = self.start_line_joint_y + ((self.nb_finger_joint-0.5)*finger_joint_size)*math.sin(angle) #Quit line at end of last notch
|
|
if (self.nb_finger_joint%2) == 0 and self.StartStatus:
|
|
#Now nb joint is even, so Internal/External status is changed so end is external
|
|
self.end_line_joint_x += thickness * math.cos(angle-math.pi/2)
|
|
self.end_line_joint_y += thickness * math.sin(angle-math.pi/2)
|
|
self.EndX = self.end_line_joint_x
|
|
self.EndY = self.end_line_joint_y
|
|
elif (self.nb_finger_joint%2) == 0 and self.StartStatus == 0:
|
|
#Now nb joint is even, so Internal/External status is changed so end is internal
|
|
self.end_line_joint_x += thickness * math.cos(angle+math.pi/2)
|
|
self.end_line_joint_y += thickness * math.sin(angle+math.pi/2)
|
|
self.EndX = self.end_line_joint_x
|
|
self.EndY = self.end_line_joint_y
|
|
elif DrawHalf > 0:
|
|
#Draw only second half of notch line,i.e. Start will be at the middle of segment
|
|
self.StartX = (self.StartX + self.EndX) / 2
|
|
self.StartY = (self.StartY + self.EndY) / 2
|
|
self.nb_finger_joint = (self.nb_finger_joint // 2 ) + 1 #Previous number was odd (2n+1), new notch count = n+1 , as first one with half notch for the first one
|
|
#Draw the first half notch as a shift from start position
|
|
self.start_line_joint_x = self.StartX - 0.5*finger_joint_size*math.cos(angle)
|
|
self.start_line_joint_y = self.StartY - 0.5*finger_joint_size*math.sin(angle)
|
|
DebugMsg("NotchLine Init, DrawHalf=1, start_line_joint = "+str((self.start_line_joint_x, self.start_line_joint_y))+" nb_joint="+str(self.nb_finger_joint)+" EndStatus="+str(self.EndStatus)+'\n')
|
|
if (self.nb_finger_joint%2) == 0:
|
|
if self.EndStatus:
|
|
#Now number of joints is even, so switch StartStatus to have different status (Start and End), and keep End Status
|
|
#In this case, Start is now External
|
|
self.StartStatus = 0
|
|
#Move Start point
|
|
self.start_line_joint_x += thickness * math.cos(angle-math.pi/2)
|
|
self.start_line_joint_y += thickness * math.sin(angle-math.pi/2)
|
|
else:
|
|
#Now number of joints is even, so switch StartStatus to have different status (Start and End), and keep End Status
|
|
#In this case, Start is now Internal
|
|
self.StartStatus = 1
|
|
#Move Start point
|
|
self.start_line_joint_x += thickness * math.cos(angle+math.pi/2)
|
|
self.start_line_joint_y += thickness * math.sin(angle+math.pi/2)
|
|
else: #Start and end have different internal/external status. Number of notches should be even
|
|
if size < 2 * finger_joint_size:
|
|
self.nb_finger_joint = 0
|
|
else:
|
|
self.nb_finger_joint = 2*int(size / (2*finger_joint_size))
|
|
self.size_line_joint = self.nb_finger_joint * finger_joint_size
|
|
# compute start and stop of finger joint line, centered on edge
|
|
delta_pos = (size - self.size_line_joint)/2
|
|
self.start_line_joint_x = self.StartX + delta_pos*math.cos(angle)
|
|
self.start_line_joint_y = self.StartY + delta_pos*math.sin(angle)
|
|
self.end_line_joint_x = self.EndX - delta_pos*math.cos(angle)
|
|
self.end_line_joint_y = self.EndY - delta_pos*math.sin(angle)
|
|
DebugMsg("NotchLine_init, size of line joints = "+str(size)+" Nb_Joint="+str(self.nb_finger_joint)+" size_line_joint="+str(self.size_line_joint)+" start_line_joint"+str(( self.start_line_joint_x, self.start_line_joint_y))+" end_line_joint="+str((self.end_line_joint_x, self.end_line_joint_y))+'\n')
|
|
|
|
def ModifyNotchLine(self, SizeCut, CutOnStart):
|
|
'''
|
|
This function modify a vertical notch line to take into account cuts needed by WoodHinge
|
|
Beware, only safe to call with vertical lines, unexpected results in other cases
|
|
SizeCut is the Size of cut, last notch will be at last 1.5 thickness far from this cut
|
|
CutOnStart is True when the cut is at the start of the line. Beware could be top or bottom if angle is 90 or 270°
|
|
'''
|
|
DebugMsg("Enter ModifyNotchLine, CutOnStart="+str(CutOnStart)+" angle="+str(self.Angle)+" Start ="+str(self.StartY)+" End="+str(self.EndY)+" nb_finger_joint="+str(self.nb_finger_joint)+" SizeJoint="+str(self.JointSize)+" start_line_joint_y="+str(self.start_line_joint_y)+" end_line_joint_y="+str(self.end_line_joint_y)+'\n')
|
|
Dir = 0 #Bottom to Top if Dir = 0
|
|
SizeCut -= thickness #In all cases, reduce sizecut because top and bottom lines are always external in Y
|
|
|
|
if abs(self.Angle - math.pi/2) < 1e-6:
|
|
Dir = 1 # Top to Bottom
|
|
if Dir == 1 and CutOnStart:
|
|
#Change line, shorten of SizeCut at the start, in this case start at end of line
|
|
nbNotch = 1
|
|
ypos = self.end_line_joint_y
|
|
Limit = SizeCut + self.StartY + 1.5*thickness
|
|
DebugMsg("WHC_init_1 : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+" Limit="+str(Limit)+" NewSizeCut="+str(SizeCut)+"\n")
|
|
while ypos > Limit:
|
|
ypos -= 2*self.JointSize
|
|
nbNotch += 2
|
|
DebugMsg("WHC : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+"\n")
|
|
#Now change the line
|
|
if nbNotch > 3:
|
|
nbNotch -= 2 #Sub last step which was too far
|
|
self.start_line_joint_y = self.end_line_joint_y - nbNotch*self.JointSize
|
|
self.nb_finger_joint = nbNotch
|
|
self.StartY += SizeCut
|
|
else:
|
|
self.nb_finger_joint = 0 #No more notch
|
|
self.StartY += SizeCut
|
|
elif Dir==1 and CutOnStart == False:
|
|
#Change line, shorten of SizeCut at the end, in this case start at start of line
|
|
nbNotch = 1
|
|
ypos = self.start_line_joint_y
|
|
Limit = self.EndY - SizeCut - 1.5*thickness
|
|
DebugMsg("WHC_init_2 : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+" Limit="+str(Limit)+" NewSizeCut="+str(SizeCut)+"\n")
|
|
while ypos < Limit:
|
|
ypos += 2*self.JointSize
|
|
nbNotch += 2
|
|
DebugMsg("WHC : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+"\n")
|
|
#Now change the line
|
|
if nbNotch > 3:
|
|
nbNotch -= 2 #Sub last step which was too far
|
|
#Cut on end, so change EndY and end_line_joint_y
|
|
self.end_line_joint_y = self.start_line_joint_y + nbNotch*self.JointSize
|
|
self.nb_finger_joint = nbNotch
|
|
self.EndY -= SizeCut
|
|
else:
|
|
self.nb_finger_joint = 0 #No more notch
|
|
self.EndY -= SizeCut
|
|
if self.EndY < self.end_line_joint_y: #Limit send_line_joint_y to be lower or equal than EndY
|
|
self.end_line_joint_y = self.EndY
|
|
elif Dir==0 and CutOnStart:
|
|
#Change line, shorten of SizeCut at the start, in this case this the bottom of line because Angle is 270°
|
|
nbNotch = 1
|
|
ypos = self.end_line_joint_y
|
|
Limit = self.StartY - SizeCut - 1.5*thickness
|
|
DebugMsg("WHC_init_3 : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+" Limit="+str(Limit)+" NewSizeCut="+str(SizeCut)+"\n")
|
|
while ypos < Limit:
|
|
ypos += 2*self.JointSize
|
|
nbNotch += 2
|
|
DebugMsg("WHC : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+"\n")
|
|
#Now change the line
|
|
if nbNotch > 3:
|
|
nbNotch -= 2 #Sub last step which was too far
|
|
#Change at start of line
|
|
self.start_line_joint_y = self.end_line_joint_y + nbNotch*self.JointSize
|
|
self.nb_finger_joint = nbNotch
|
|
self.StartY -= SizeCut
|
|
else:
|
|
self.nb_finger_joint = 0 #No more notch
|
|
self.StartY -= SizeCut
|
|
elif Dir==0 and CutOnStart == 0:
|
|
#Change line, shorten of SizeCut at the end, in this case this the top of line because Angle is 270°
|
|
nbNotch = 1
|
|
ypos = self.start_line_joint_y
|
|
Limit = self.EndY + SizeCut + 1.5*thickness
|
|
DebugMsg("WHC_init_4 : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+" Limit="+str(Limit)+" NewSizeCut="+str(SizeCut)+"\n")
|
|
while ypos > Limit:
|
|
ypos -= 2*self.JointSize
|
|
nbNotch += 2
|
|
DebugMsg("WHC : ypos ="+str(ypos)+" nbNotch ="+str(nbNotch)+"\n")
|
|
#Now change the line
|
|
if nbNotch > 3:
|
|
nbNotch -= 2 #Sub last step which was too far
|
|
self.end_line_joint_y = self.start_line_joint_y - nbNotch*self.JointSize
|
|
self.nb_finger_joint = nbNotch
|
|
self.EndY += SizeCut #New EndY is below the previous one
|
|
else:
|
|
self.nb_finger_joint = 0 #No more notch
|
|
self.EndY += SizeCut
|
|
if self.EndY < self.end_line_joint_y:
|
|
self.end_line_joint_y = self.EndY
|
|
DebugMsg("Exit ModifyNotchLine, angle="+str(self.Angle)+" Start ="+str(self.StartY)+" End="+str(self.EndY)+" nb_finger_joint="+str(self.nb_finger_joint)+" SizeJoint="+str(self.JointSize)+" start_line_joint_y="+str(self.start_line_joint_y)+" end_line_joint_y="+str(self.end_line_joint_y)+'\n')
|
|
|
|
def drawNotchLine(self, path):
|
|
'''
|
|
Draw the actual line, starting at current position of path.
|
|
The position should be StartX, StartY, this is not checked or enforced to avoid unwanted moves
|
|
Each finger joint is JointSize long but there is a correction to take into account the burn factor (thickness of the cutting line).
|
|
So each external joint is actually JointSize+2*burn long and Internal joints are JointSize-2*burn
|
|
'''
|
|
if self.nb_finger_joint == 0:
|
|
#Easy case, no finger joint, draw a straight line
|
|
path.LineTo(self.EndX, self.EndY)
|
|
return
|
|
#Normal case, there are finger joint(s)
|
|
#First compute angles.
|
|
#AngleJoint is the angle for drawing the first part of the finger joint
|
|
#If start point is internal, AngleJoint should be Angle - pi/2, else it should be Angle + pi/2
|
|
if self.StartStatus: #internal
|
|
AngleJoint = self.Angle - math.pi/2
|
|
DeltaBurn = -burn
|
|
else:
|
|
AngleJoint = self.Angle + math.pi/2
|
|
DeltaBurn = burn
|
|
DebugMsg("drawNotchLine, Angle ="+str(round(self.Angle*180/math.pi))+" AngleJoint="+str(round(AngleJoint*180/math.pi))+'\n')
|
|
DebugMsg("start_line_joint="+str((self.start_line_joint_x, self.start_line_joint_y))+" JointSize="+str(self.JointSize)+" DeltaBurn="+str(DeltaBurn)+'\n')
|
|
#First go up to start of notch line + first joint + burn correction
|
|
DebugMsg("Position before drawNotchLine : "+str((path.x_noff, path.y_noff))+'\n')
|
|
xcur = self.start_line_joint_x + (self.JointSize+DeltaBurn)*math.cos(self.Angle)
|
|
ycur = self.start_line_joint_y + (self.JointSize+DeltaBurn)*math.sin(self.Angle)
|
|
path.LineTo(xcur, ycur)
|
|
DebugMsg("First Point="+str((xcur, ycur))+'\n')
|
|
i = self.nb_finger_joint - 1
|
|
while i > 0:
|
|
#The start drawing finger joint
|
|
path.LineToRel(thickness*math.cos(AngleJoint), thickness*math.sin(AngleJoint))
|
|
#Compute next AngleJoint for return move if necessary
|
|
AngleJoint = AngleJoint + math.pi
|
|
if AngleJoint > 2*math.pi:
|
|
AngleJoint -= 2*math.pi #Keep angle between 0 and 2*pi
|
|
#idem for burn factor
|
|
DeltaBurn = -DeltaBurn
|
|
#Then line which is JointSize long and take into account the burn factor, draw half finger joint when last of first half
|
|
if self.DrawHalf < 0 and i == 1:
|
|
path.LineToRel((self.JointSize/2+DeltaBurn)*math.cos(self.Angle), (self.JointSize/2+DeltaBurn)*math.sin(self.Angle))
|
|
elif i > 1: #Do not draw last segment, not necessary, will be completed by next path.LIneTo
|
|
path.LineToRel((self.JointSize+DeltaBurn)*math.cos(self.Angle), (self.JointSize+DeltaBurn)*math.sin(self.Angle))
|
|
i -= 1
|
|
#Then draw last part, up to end point
|
|
#Do not check if necessary because of burn factor, last position is not the real end of notch line.
|
|
path.LineTo(self.EndX, self.EndY)
|
|
DebugMsg("Last LineTo End ="+str((self.EndX, self.EndY))+'\n')
|
|
|
|
class FlexLines:
|
|
'''
|
|
This class deals and draw set of flex lines to round a corner
|
|
'''
|
|
def drawFlexLines(self, Position, Height, Radius, path):
|
|
'''
|
|
First compute how many segment per line. Segment length should be kept short, < 50mm or so, so high boxes means number of lines
|
|
Also compute distance between lines, which depend on radius. Shorter radius means smaller distance between lines
|
|
But keep min distance at about 1mm minimum and 1.5mm max, after this value flex is quite hard to bend !
|
|
'''
|
|
if Height+2*thickness < 30:
|
|
nSegmentFlex = 1
|
|
elif Height+2*thickness < 80:
|
|
nSegmentFlex = 2
|
|
elif Height+2*thickness < 150:
|
|
nSegmentFlex = 3
|
|
else:
|
|
nSegmentFlex = Height+2*thickness // 50
|
|
#Then compute distance between flex lines. The basic idea is to have a minimum of 15 lines per corner, with lines distant at least of 1mm
|
|
#But also ensure that distance between lines is at most at 2mm
|
|
round_distance = Radius*math.pi/2
|
|
flex_line_spacing = round_distance / 14
|
|
flex_line_spacing = max(flex_line_spacing, 1.0)
|
|
flex_line_spacing = min(flex_line_spacing, 1.5)
|
|
nb_flex_lines = int(round(round_distance / flex_line_spacing,0))
|
|
DebugMsg("sizeround ="+str(round_distance)+" flex_line_spacing="+str(flex_line_spacing)+" nb_flex_lines="+str(nb_flex_lines)+" size="+str(nb_flex_lines*flex_line_spacing)+"\n")
|
|
#nb_flex_lines should be odd
|
|
nb_flex_lines |= 1
|
|
flex_line_spacing = round_distance / (nb_flex_lines-1) #Real distance between lines
|
|
length_flex_segment_case1 = (Height+2*thickness - 2*nSegmentFlex) / nSegmentFlex #Case 1, 1/2 segment starting at top, n-1 segments and 1/2 segment up to bottom
|
|
length_flex_segment_case2 = (Height+2*thickness - 2*(nSegmentFlex+1)) / nSegmentFlex #Case 2, n segments equally spaced (2mm) from top to bottom
|
|
DebugMsg("nSegmentFlex="+str(nSegmentFlex)+" sizeround ="+str(round_distance)+" flex_line_spacing="+str(flex_line_spacing)+" nb_flex_lines="+str(nb_flex_lines)+" size="+str(nb_flex_lines*flex_line_spacing)+"\n")
|
|
#Now draw set of flex lines
|
|
for i in range(nb_flex_lines):
|
|
if i % 2:
|
|
#In this case draw nSegmentFlex segments which are identical. First segment start at 2 mm above bottom line, segments are 2mm spaced
|
|
for j in range(nSegmentFlex):
|
|
path.MoveTo(Position + i * flex_line_spacing, Height+thickness-2-j * (length_flex_segment_case2+2) )
|
|
path.LineToVRel(-length_flex_segment_case2)
|
|
else:
|
|
#In this case draw a first segment starting at -thickness (top), segment is length_flex_segment_even/2 long
|
|
path.MoveTo(Position + i * flex_line_spacing, -thickness )
|
|
path.LineToVRel(length_flex_segment_case1/2) #One half segment
|
|
#Then nSegmentFlex-1 which are
|
|
for j in range(nSegmentFlex-1):
|
|
path.MoveTo(Position + i * flex_line_spacing, j*(length_flex_segment_case1+2) + length_flex_segment_case1/2 + 2 - thickness )
|
|
path.LineToVRel(length_flex_segment_case1)
|
|
path.MoveTo(Position + i * flex_line_spacing, Height+thickness - length_flex_segment_case1/2)
|
|
path.LineTo(Position + i * flex_line_spacing, Height+thickness )
|
|
|
|
|
|
class FlexFace:
|
|
'''
|
|
This class deal with flex faces, which are used as vertical faces when rounded corners are used.
|
|
'''
|
|
def __init__(self, FlexBandList, isLid, zbox, z_joint, InkscapeGroup, PositionInPage):
|
|
'''
|
|
The list FlexBandList contains all elements to be used on top and bottom line of the flex face.
|
|
Each element is in a tuple
|
|
item 0 is the path id
|
|
item 1 is Start_Internal
|
|
item 2 is End Internal
|
|
item 3..n are tuple with ( size, size_joints top, radius rounded corner, size_joints bottom, [hasCircle])
|
|
Last item is always with radius = 0
|
|
'''
|
|
self.FlexBandList = FlexBandList
|
|
self.z_joint = z_joint
|
|
self.height = zbox
|
|
self.isLid = isLid
|
|
#Update PositionInPage to take into account finger joints (only OK if it is a simple shape with finger joints).
|
|
PositionInPage[0] -= thickness
|
|
PositionInPage[1] -= thickness
|
|
|
|
FlexElt = FlexBandList[3]
|
|
if len(FlexElt) == 5 and FlexElt[4] and self.isLid == False:
|
|
#Change path offset to take into account the circle...
|
|
PositionInPage[0] -= WoodHingeSize*thickness
|
|
PositionInPage[1] -= WoodHingeSize*thickness
|
|
elif len(FlexBandList) > 4:
|
|
FlexElt = FlexBandList[len(FlexBandList)-1]
|
|
if len(FlexElt) == 5 and FlexElt[4] and self.isLid == False:
|
|
#Change path offset to take into account the circle... but only on y here
|
|
PositionInPage[1] -= WoodHingeSize*thickness
|
|
|
|
|
|
self.BoundingBox = (-PositionInPage[0], -PositionInPage[1], -PositionInPage[0], -PositionInPage[1])
|
|
|
|
#If needed, create path which will be used to draw the face
|
|
#The path will be in the group InkscapeGroup
|
|
name = FlexBandList[0]
|
|
if isLid:
|
|
name = 'Lid_'+name
|
|
self.path = th_inkscape_path(PositionInPage, InkscapeGroup, name)
|
|
#Remember these 2 parameters for Side Notch lines
|
|
self.InkscapeGroup = InkscapeGroup
|
|
self.BaseName = FlexBandList[0]
|
|
|
|
def Close(self):
|
|
'''
|
|
Close and write the path after drawing is done
|
|
'''
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
def drawClip(self, size_clip, UpDown):
|
|
''' Draw a single clip pattern
|
|
The clip is vertical, with length size_clip and width size_clip/4
|
|
Add clip to current path, use LineTo
|
|
New path position will be end of clip
|
|
If draw up, UpDown should be 1
|
|
'''
|
|
if UpDown != 1:
|
|
UpDown=-1 #Will draw negative
|
|
#First draw vertical line which is .31*size
|
|
self.path.LineToVRel(size_clip*0.3075*UpDown)
|
|
#Then small bezier curve
|
|
self.path.BezierRel(0, size_clip*0.036241333*UpDown, size_clip*0.045356111, size_clip*0.052734333*UpDown, size_clip*0.0685556, size_clip*0.025*UpDown)
|
|
#then line
|
|
self.path.LineToRel(size_clip*0.132166667, size_clip*-0.157555556*UpDown)
|
|
#then bezier
|
|
self.path.BezierRel(size_clip*0.016710556, size_clip*-0.02*UpDown, size_clip*0.05, size_clip*-0.008*UpDown, size_clip*0.05, size_clip*0.017795167*UpDown)
|
|
#Then vertical line
|
|
self.path.LineToVRel(size_clip*0.615*UpDown)
|
|
#then bezier
|
|
self.path.BezierRel(0, size_clip*0.026*UpDown, size_clip*-0.032335, size_clip*0.037760389*UpDown, size_clip*-0.05, size_clip*0.017795167*UpDown)
|
|
#Then line
|
|
self.path.LineToRel(size_clip*-0.132166667, size_clip*-0.157555556*UpDown)
|
|
#then last bezier
|
|
#c -0.42188,0.5 -1.23438,0.203125 -1.23438,-0.449219
|
|
self.path.BezierRel(size_clip*-0.023437778, size_clip*-0.027777778*UpDown, size_clip*-0.068576667, size_clip*-0.011284722*UpDown, size_clip*-0.068576667, size_clip*0.025*UpDown)
|
|
#then last line
|
|
self.path.LineToVRel(size_clip*0.3075*UpDown)
|
|
|
|
def drawFlexFace(self, ClosePath):
|
|
'''
|
|
Draw the flex face into its path, close path if argument is true after drawing
|
|
This method is only valid when the corners are straight.
|
|
When all corners are rounded, drawRoundedFlexFace should be used.
|
|
'''
|
|
ListFlexLines = []
|
|
#Build Top line
|
|
xpos = 0
|
|
if self.isLid:
|
|
TopJointOff = 3
|
|
BotJointOff = 1
|
|
else:
|
|
TopJointOff = 1
|
|
BotJointOff = 3
|
|
leftCircle = False
|
|
leftCircleCut = False
|
|
leftCirclePos = 0
|
|
rightCircle = False
|
|
rightCircleCut = False
|
|
rightCirclePos = 0
|
|
LastRadius = 0 #Always start with straight corner
|
|
DebugMsg("\nEnter drawFlexFace, isLid="+str(self.isLid)+" Number of elements in list="+str(len(self.FlexBandList))+"Height="+str(self.height)+"\n")
|
|
#Now read all elements (3..N)
|
|
for i in range(3, len(self.FlexBandList)):
|
|
FlexElement = self.FlexBandList[i]
|
|
DebugMsg("Top line, i="+str(i)+" FlexElement="+str(FlexElement)+'\n')
|
|
if i == 3 and len(FlexElement) == 5 and FlexElement[4] and self.isLid == False:
|
|
#Specific case of left wood hinge face, draw circle on top
|
|
leftCircle = True
|
|
leftCirclePos = -thickness #Remember circle position
|
|
#In this case start position is 0, (WoodHingeSize-1)*thickness
|
|
self.path.MoveTo(0, (WoodHingeSize-1)*thickness)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.drawQuarterCircle(-thickness, -thickness, WoodHingeSize*thickness, 3) #Start Lower Left
|
|
self.path.drawQuarterCircle(-thickness, -thickness, WoodHingeSize*thickness, 0) #Start Upper Left
|
|
self.path.drawQuarterCircle(-thickness, -thickness, WoodHingeSize*thickness, 1) #Start Upper Right
|
|
#After this position should be WoodHingeSize*thickness-thickness, -thickness
|
|
self.path.LineTo(FlexElement[0] - FlexElement[2], -thickness)
|
|
xpos += FlexElement[0] - LastRadius - FlexElement[2]
|
|
elif i == 3 and len(FlexElement) == 5 and FlexElement[4] and self.isLid == True:
|
|
leftCircleCut = True
|
|
if i == 3:
|
|
#Draw path start
|
|
if self.FlexBandList[1]: #First item : Start point if internal
|
|
self.path.MoveTo(0, -thickness) # Start position (0, -thickness) because flex band is always external in Y direction
|
|
else:
|
|
self.path.MoveTo(-thickness, -thickness) # Start position (-thickness, -thickness) because x external and flex band is always external in Y direction
|
|
self.path.LineTo(0, -thickness)
|
|
DebugMsg("Element "+str(i)+": xpos="+str(xpos)+' Size ='+str(FlexElement[0])+' radius ='+str(FlexElement[2])+' --> '+str(FlexElement[2]*math.pi/2)+'\n')
|
|
#First Notch Line, with length SizeEdge - SizeOfRoundedCorners
|
|
hLine = NotchLine((xpos, -thickness, 0), (xpos+FlexElement[0]-(LastRadius+FlexElement[2]), -thickness, 0), 0.0, FlexElement[TopJointOff])
|
|
hLine.drawNotchLine(self.path)
|
|
xpos += FlexElement[0] - LastRadius - FlexElement[2]
|
|
elif i == len(self.FlexBandList) - 1 and len(FlexElement) == 5 and FlexElement[4] and self.isLid == False:
|
|
#Specific case of right wood hinge face, draw circle on top
|
|
rightCircle = True
|
|
rightCirclePos = xpos #Remember circle position
|
|
#In this case start position is 0, (WoodHingeSize-1)*thickness
|
|
self.path.LineTo( xpos + FlexElement[0] - LastRadius - (WoodHingeSize-1)*thickness, -thickness)
|
|
xpos += FlexElement[0] - LastRadius
|
|
rightCirclePos = xpos + thickness #Remember circle position
|
|
self.path.drawQuarterCircle(rightCirclePos, -thickness, WoodHingeSize*thickness, 0) #Start Upper Left
|
|
self.path.drawQuarterCircle(rightCirclePos, -thickness, WoodHingeSize*thickness, 1) #Start Upper Right
|
|
self.path.drawQuarterCircle(rightCirclePos, -thickness, WoodHingeSize*thickness, 2) #Start Lower Right
|
|
self.path.LineToHRel(-thickness)
|
|
elif i == len(self.FlexBandList) - 1 and len(FlexElement) == 5 and FlexElement[4] and self.isLid == True:
|
|
rightCircleCut = True
|
|
DebugMsg("Element "+str(i)+": xpos="+str(xpos)+' Size ='+str(FlexElement[0])+' radius ='+str(FlexElement[2])+' --> '+str(FlexElement[2]*math.pi/2)+'\n')
|
|
#First Notch Line, with length SizeEdge - SizeOfRoundedCorners
|
|
hLine = NotchLine((xpos, -thickness, 0), (xpos+FlexElement[0]-(LastRadius+FlexElement[2]), -thickness, 0), 0.0, FlexElement[TopJointOff])
|
|
hLine.drawNotchLine(self.path)
|
|
xpos += FlexElement[0] - LastRadius - FlexElement[2]
|
|
else:
|
|
if i == 3:
|
|
#Draw path start
|
|
if self.FlexBandList[1]: #First item : Start point if internal
|
|
self.path.MoveTo(0, -thickness) # Start position (0, -thickness) because flex band is always external in Y direction
|
|
else:
|
|
self.path.MoveTo(-thickness, -thickness) # Start position (-thickness, -thickness) because x external and flex band is always external in Y direction
|
|
self.path.LineTo(0, -thickness)
|
|
DebugMsg("Element "+str(i)+": xpos="+str(xpos)+' Size ='+str(FlexElement[0])+' radius ='+str(FlexElement[2])+' --> '+str(FlexElement[2]*math.pi/2)+'\n')
|
|
#First Notch Line, with length SizeEdge - SizeOfRoundedCorners
|
|
hLine = NotchLine((xpos, -thickness, 0), (xpos+FlexElement[0]-(LastRadius+FlexElement[2]), -thickness, 0), 0.0, FlexElement[TopJointOff])
|
|
hLine.drawNotchLine(self.path)
|
|
xpos += FlexElement[0] - LastRadius - FlexElement[2]
|
|
#Then the line corresponding to rounded corner, also add coordinates for Flex lines
|
|
if FlexElement[2] > 0:
|
|
self.path.LineTo(xpos + FlexElement[2]*math.pi/2, -thickness)
|
|
ListFlexLines.append((xpos, FlexElement[2]))
|
|
xpos += FlexElement[2]*math.pi/2
|
|
LastRadius = FlexElement[2] #For the next edge
|
|
if rightCircle == 0:
|
|
if self.FlexBandList[2] == 0: #External end ?
|
|
self.path.LineTo(xpos + thickness, -thickness)
|
|
xpos += thickness
|
|
self.path.LineTo(xpos, 0)
|
|
DebugMsg('Vertical Line 1, xpos='+str(xpos)+'\n')
|
|
#Then Vertical notch line,
|
|
vLine = NotchLine((xpos, 0, self.FlexBandList[2]), (xpos, self.height, self.FlexBandList[2]), math.pi/2, self.z_joint)
|
|
if rightCircle:
|
|
#In this case modify the line just created
|
|
#Specific case, shorten Right line of notches to take into account the wood hinge circle. Delete some notches on top
|
|
SizeCut = WoodHingeSize*thickness
|
|
vLine.ModifyNotchLine(SizeCut, True) #Last parameter, CutOnStart = True
|
|
elif rightCircleCut:
|
|
#In this case modify the line just created
|
|
#Specific case, shorten Right line of notches to take into account the wood hinge circle cut. Delete some notches on bottom
|
|
SizeCut = WoodHingeSize*thickness
|
|
vLine.ModifyNotchLine(SizeCut, False) #Last parameter, CutOnStart = False
|
|
vLine.drawNotchLine(self.path) #Draw the line of notches
|
|
if rightCircleCut:
|
|
#Then the cut. Choose 0.95*SizeCut because the actual circle is NOT centered of this vertical edge but shifted by thickness
|
|
self.path.LineTo(xpos, self.height+thickness-SizeCut*0.95)
|
|
#Then the rounded cut, almost a quarter of circle, radius SizeCut
|
|
self.path.Bezier(xpos-SizeCut*0.23, self.height+thickness-SizeCut*0.90,
|
|
xpos-SizeCut+thickness, self.height+thickness-SizeCut*0.551916,
|
|
xpos-SizeCut+thickness, self.height+thickness)
|
|
else:
|
|
self.path.LineTo(xpos, self.height+thickness)
|
|
DebugMsg("Start bottom line, reverse\n")
|
|
#Then Bottom line (reverse from top line)
|
|
if self.FlexBandList[2] == 0: #External end ?
|
|
self.path.LineTo(xpos - thickness, self.height+thickness)
|
|
xpos -= thickness
|
|
for i in range(len(self.FlexBandList)-1, 2, -1): #Start at end up to third element
|
|
#For reverse drawing, should have the radius of the next corner
|
|
if i > 3:
|
|
NextRadius = self.FlexBandList[i-1][2]
|
|
else:
|
|
NextRadius = 0
|
|
FlexElement = self.FlexBandList[i]
|
|
DebugMsg("Element "+str(i)+": xpos="+str(xpos)+' Size ='+str(FlexElement[0])+' radius ='+str(FlexElement[2])+' --> '+str(FlexElement[2]*math.pi/2)+' Next Radius='+str(NextRadius)+'\n')
|
|
#First the line corresponding to rounded corner (reverse from previous)
|
|
DebugMsg("Draw line for rounded corner, size ="+str(FlexElement[2]*math.pi/2)+" New xpos="+str(xpos - FlexElement[2]*math.pi/2)+'\n')
|
|
if FlexElement[2] > 0:
|
|
self.path.LineTo(xpos - FlexElement[2]*math.pi/2, self.height+thickness)
|
|
xpos -= FlexElement[2]*math.pi/2
|
|
#Then Notch Line
|
|
if i == 3 and leftCircleCut:
|
|
#specific case, draw up to start of cut
|
|
self.path.LineTo(SizeCut - thickness , self.height+thickness)
|
|
xpos = 0 #Not true yet, but needed to place the vertical line at the right position
|
|
DebugMsg("leftCircleCut True, pathto "+str((SizeCut - thickness , self.height+thickness))+" xpos ="+str(xpos)+"\n")
|
|
else:
|
|
hLine = NotchLine((xpos, self.height+thickness, 0), (xpos-(FlexElement[0]-FlexElement[2]-NextRadius), self.height+thickness, 0), math.pi, FlexElement[BotJointOff])
|
|
hLine.drawNotchLine(self.path)
|
|
xpos -= FlexElement[0] - NextRadius - FlexElement[2]
|
|
if leftCircleCut == False:
|
|
if self.FlexBandList[1] == 0: #External Start ?
|
|
self.path.LineTo(xpos - thickness, self.height+thickness)
|
|
xpos -= thickness
|
|
self.path.LineTo(xpos, self.height)
|
|
#Then Vertical notch line for left edge
|
|
vLine = NotchLine((xpos, self.height, self.FlexBandList[1]), (xpos, 0, self.FlexBandList[1]), -math.pi/2, self.z_joint)
|
|
if leftCircle:
|
|
SizeCut = WoodHingeSize*thickness
|
|
vLine.ModifyNotchLine(SizeCut, False) #Last parameter, CutOnStart = False, because we start at bottom
|
|
elif leftCircleCut:
|
|
#In this case, shorten the notch line on bottom because of the circle cut
|
|
SizeCut = WoodHingeSize*thickness
|
|
vLine.ModifyNotchLine(SizeCut, True) #Last parameter, CutOnStart = True, because we start at bottom
|
|
#Draw the rounded cut, almost a quarter of circle, radius ExtRadius
|
|
self.path.Bezier(SizeCut-thickness, self.height+thickness-SizeCut*0.551916
|
|
, SizeCut*0.23, self.height+thickness-SizeCut*0.90
|
|
, 0, self.height+thickness-SizeCut*0.95)
|
|
|
|
|
|
vLine.drawNotchLine(self.path)
|
|
DebugMsg('Vertical Line 2, xpos='+str(xpos)+'\n')
|
|
|
|
#Draw up to -thickness because external in Y direction
|
|
if leftCircle:
|
|
self.path.LineTo(xpos, SizeCut - thickness)
|
|
else:
|
|
self.path.LineTo(xpos, -thickness)
|
|
|
|
# If circle, draw interior and rectangles
|
|
#Case with WoodHingeCorner, draw circle and rectangle
|
|
if leftCircle:
|
|
#Draw the circle internal to the hinge, radius is 2*thickness mm
|
|
CircleRadius = WoodHingeInternalCircle*thickness
|
|
self.path.drawCircle(leftCirclePos, -thickness, CircleRadius)
|
|
#Then the internal rectangle, rectangle height is 1.5*thickness
|
|
RectHeight = WoodHingeRect*thickness
|
|
self.path.MoveTo(leftCirclePos, -thickness) #Starting point Ext/Bottom
|
|
self.path.LineToVRel(-RectHeight) #Ext/Top
|
|
self.path.LineToHRel(thickness) #Int/Top
|
|
self.path.LineToVRel(RectHeight) #Int Bottom
|
|
self.path.LineToHRel(-thickness) #Return to start
|
|
if rightCircle:
|
|
#Draw the circle internal to the hinge, radius is 2*thickness mm
|
|
CircleRadius = WoodHingeInternalCircle*thickness
|
|
self.path.drawCircle(rightCirclePos, -thickness, CircleRadius)
|
|
#Then the internal rectangle, rectangle height is 1.5*thickness
|
|
RectHeight = WoodHingeRect*thickness
|
|
self.path.MoveTo(rightCirclePos, -thickness) #Starting point Ext/Bottom
|
|
self.path.LineToVRel(-RectHeight) #Ext/Top
|
|
self.path.LineToHRel(-thickness) #Int/Top
|
|
self.path.LineToVRel(RectHeight) #Int Bottom
|
|
self.path.LineToHRel(thickness) #Return to start
|
|
|
|
|
|
#Now draw flex lines
|
|
|
|
for FlexLinePos in ListFlexLines:
|
|
Flex = FlexLines()
|
|
Flex.drawFlexLines(FlexLinePos[0], self.height, FlexLinePos[1], self.path)
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
def drawRoundedFlexFace(self, ClosePath):
|
|
'''
|
|
Draw a Flex band when all corners are rounded. This is a specific case because there are clips at the center of back face
|
|
Back face should be the first in list
|
|
'''
|
|
|
|
#Compute clips number and position, zone with clips will be between thickness and zbox - thickness
|
|
zoneclips = self.height - 2*thickness
|
|
#Size of clips is dependant to size of zoneclips
|
|
if zoneclips < 50:
|
|
sizeclips = 10
|
|
else:
|
|
sizeclips = 18
|
|
nbclips = int(zoneclips // sizeclips)
|
|
if nbclips == 0:
|
|
inkex.errormsg('Box is not high enough, no room for clips')
|
|
CloseDebugFile()
|
|
return
|
|
DebugMsg("\ndrawRoundedFlexFace, sizeclips="+str(sizeclips)+" nbclips="+str(nbclips)+'\n')
|
|
ListFlexLines = []
|
|
LastRadius = self.FlexBandList[6][2] # Radius of left back corner
|
|
xpos = 0
|
|
FlexElement = self.FlexBandList[3]
|
|
DebugMsg("First Half notch line, size ="+str(FlexElement[0])+" Size Round BackLeft="+str(LastRadius)+" Size Round BackRight="+str(FlexElement[2])+'\n')
|
|
#The notch line will be centered on xpos (0), so should start at -(SizeNotchLine-SizeRadius_BackLeft-SizeRadius_BackRight)/2
|
|
First_hLine = NotchLine((-(FlexElement[0]-FlexElement[2] - LastRadius)/2, -thickness, 0), ((FlexElement[0]-FlexElement[2] - LastRadius)/2, -thickness, 0), 0.0, FlexElement[1], 1) #Draw only second half
|
|
if First_hLine.StartStatus == 0:
|
|
self.path.MoveTo(0, -thickness) # Start position (0, -thickness) because flex band is external in Y direction, and this side start internal in X
|
|
DebugMsg("Start Point is "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
else:
|
|
self.path.MoveTo(0, 0) # Start position (0, 0) because flex band is internal in Y direction, and this side start internal in X
|
|
DebugMsg("Start Point is "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
First_hLine.drawNotchLine(self.path)
|
|
xpos = (FlexElement[0]-FlexElement[2]-LastRadius)/2
|
|
DebugMsg("After drawing first half of notch line, pos ="+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
ListFlexLines.append((xpos, FlexElement[2])) #Add this position to draw flex lines.
|
|
#Then the line corresponding to rounded corner
|
|
if FlexElement[2] > 0:
|
|
self.path.LineTo(xpos + FlexElement[2]*math.pi/2, -thickness)
|
|
xpos += FlexElement[2]*math.pi/2
|
|
DebugMsg("Line corresponding to back right corner, l="+str(FlexElement[2]*math.pi/2)+" xpos="+str(xpos)+'\n')
|
|
LastRadius = FlexElement[2]
|
|
#Now read all elements (4..N-1) --> 4..6 here
|
|
for i in range(4, 7):
|
|
FlexElement = self.FlexBandList[i]
|
|
DebugMsg("Element "+str(i)+": xpos="+str(xpos)+' Size ='+str(FlexElement[0])+' radius ='+str(FlexElement[2])+" LastRadius="+str(LastRadius)+"--> "+str(FlexElement[0] - LastRadius - FlexElement[2]) +'\n')
|
|
#First Notch Line
|
|
hLine = NotchLine((xpos, -thickness, 0), (xpos+FlexElement[0] - LastRadius - FlexElement[2] , -thickness, 0), 0.0, FlexElement[1], 0)
|
|
hLine.drawNotchLine(self.path)
|
|
xpos += FlexElement[0] - LastRadius - FlexElement[2]
|
|
#Then the line corresponding to rounded corner
|
|
if FlexElement[2] > 0:
|
|
self.path.LineTo(xpos + FlexElement[2]*math.pi/2, -thickness)
|
|
ListFlexLines.append((xpos, FlexElement[2]))
|
|
xpos += FlexElement[2]*math.pi/2
|
|
LastRadius = FlexElement[2]
|
|
DebugMsg("After drawing line for rounded corner, xpos="+str(xpos)+'\n')
|
|
|
|
#Last element
|
|
FlexElement = self.FlexBandList[7]
|
|
DebugMsg("Last Element (7): xpos="+str(xpos)+' Size ='+str(FlexElement[0])+' radius ='+str(FlexElement[2])+" LastRadius="+str(LastRadius)+"--> "+str(FlexElement[0] - LastRadius - FlexElement[2]) +'\n')
|
|
#Last Notch Line, at last half of it ! First half indeed.
|
|
hLine = NotchLine((xpos, -thickness, 0), (xpos+FlexElement[0] - LastRadius - FlexElement[2], -thickness, 0), 0.0, FlexElement[1], -1)
|
|
hLine.drawNotchLine(self.path)
|
|
xpos += (FlexElement[0] - LastRadius - FlexElement[2])/2
|
|
|
|
self.path.LineTo(xpos, thickness)
|
|
DebugMsg('Clip Line 1, xpos='+str(xpos)+'\n')
|
|
#Then Vertical clip line
|
|
self.path.LineToVRel((zoneclips - nbclips*sizeclips)/2)
|
|
for i in range(nbclips):
|
|
self.drawClip(sizeclips, 1)
|
|
|
|
DebugMsg("Bottom line, reverse, start at xpos="+str((xpos, self.height+thickness))+'\n')
|
|
#Then Bottom line (reverse from top line)
|
|
FlexElement = self.FlexBandList[7]
|
|
#Element 7 is the last one, with radius of Back Right corner
|
|
NextRadius = self.FlexBandList[6][2] #This is the radius of the left right corner
|
|
DebugMsg("Element 7: xpos="+str(xpos)+' Size ='+str(FlexElement[0])+' radius ='+str(FlexElement[2])+' --> '+str(FlexElement[0]-FlexElement[2]-NextRadius)+'\n')
|
|
#Last Notch Line, half line. Center line on xpos
|
|
hLine = NotchLine((xpos + (FlexElement[0] - NextRadius - FlexElement[2])/2, self.height+thickness, 0), (xpos-(FlexElement[0] - NextRadius - FlexElement[2])/2, self.height+thickness, 0), math.pi, FlexElement[3], 1)
|
|
if hLine.StartStatus == 0:
|
|
self.path.LineTo(xpos, self.height+thickness)
|
|
else:
|
|
self.path.LineTo(xpos, self.height)
|
|
hLine.drawNotchLine(self.path)
|
|
xpos -= (FlexElement[0] - NextRadius - FlexElement[2])/2
|
|
for i in range(6, 3, -1): #Start at end up to third element
|
|
FlexElement = self.FlexBandList[i]
|
|
NextRadius = self.FlexBandList[i-1][2]
|
|
DebugMsg("Element "+str(i)+": xpos="+str(xpos)+' Size ='+str(FlexElement[0])+" radius ="+str(FlexElement[2])+" NextRadius="+str(NextRadius)+' --> '+str(FlexElement[0] - FlexElement[2] - NextRadius)+'\n')
|
|
#First the line corresponding to rounded corner (reverse from previous)
|
|
if FlexElement[2] > 0:
|
|
self.path.LineTo(xpos - FlexElement[2]*math.pi/2, self.height+thickness)
|
|
xpos -= FlexElement[2]*math.pi/2
|
|
DebugMsg("After line for rounded corner, l="+str(FlexElement[2]*math.pi/2)+" Pos="+str((xpos, self.height+thickness))+'\n')
|
|
#Then Notch Line
|
|
hLine = NotchLine((xpos, self.height+thickness, 0), (xpos-(FlexElement[0] - FlexElement[2] - NextRadius), self.height+thickness, 0), math.pi, FlexElement[3], 0)
|
|
hLine.drawNotchLine(self.path)
|
|
xpos -= FlexElement[0] - FlexElement[2] - NextRadius
|
|
|
|
NextRadius = self.FlexBandList[7][2]
|
|
FlexElement = self.FlexBandList[3]
|
|
DebugMsg("First Element (3): xpos="+str(xpos)+' Size ='+str(FlexElement[0])+" radius ="+str(FlexElement[2])+" NextRadius="+str(NextRadius)+' --> '+str(FlexElement[0] - FlexElement[2] - NextRadius)+'\n')
|
|
#Then Last round corner
|
|
self.path.LineTo(xpos - FlexElement[2]*math.pi/2, self.height+thickness)
|
|
xpos -= FlexElement[2]*math.pi/2
|
|
DebugMsg("Last Round corner, l="+str(FlexElement[2]*math.pi/2)+" new pos="+str((xpos, self.height+thickness))+'\n')
|
|
#Then Notch Line, half of it
|
|
hLine = NotchLine((xpos, self.height+thickness, 0), (xpos-(FlexElement[0]-FlexElement[2]-LastRadius), self.height+thickness, 0), math.pi, FlexElement[3], -1) #Draw only first half
|
|
hLine.drawNotchLine(self.path)
|
|
xpos -= (FlexElement[0]-FlexElement[2] - LastRadius)/2
|
|
self.path.LineTo(xpos, self.height)
|
|
#Then Vertical clip line
|
|
DebugMsg('Vertical Clip 2, pos='+str((xpos, self.height))+'\n')
|
|
#and vertical trip (reverse)
|
|
self.path.LineToVRel(-1.0*((zoneclips - nbclips*sizeclips)/2) - thickness)
|
|
for i in range(nbclips):
|
|
self.drawClip(sizeclips, -1)
|
|
if First_hLine.StartStatus == 0: #If StartStatus is external, move to (0,-Thickness)
|
|
self.path.LineTo(0, -thickness)
|
|
else:
|
|
self.path.LineTo(0, 0)
|
|
|
|
#Now draw flex lines
|
|
|
|
for FlexLinePos in ListFlexLines:
|
|
Flex = FlexLines()
|
|
Flex.drawFlexLines(FlexLinePos[0], self.height, FlexLinePos[1], self.path)
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
def drawSideLineNotches(self):
|
|
'''
|
|
Draw the side line notches used with sliding lid. These lines are on left and right (if flex) lines
|
|
These lines are created whenever the top notches are not null
|
|
'''
|
|
n_side_line = 0
|
|
ypos = -self.BoundingBox[1]
|
|
LastRadius = 0
|
|
for i in range(3, len(self.FlexBandList)):
|
|
FlexElement = self.FlexBandList[i]
|
|
if FlexElement[1] > 0: #Notches are present, draw SideLine with notches
|
|
n_side_line += 1
|
|
DebugMsg("\nDraw "+self.BaseName+'LidJoint'+str(n_side_line)+" Radius="+str(FlexElement[2])+" LastRadius="+str(LastRadius)+" Size ="+str(FlexElement[0] - FlexElement[2] - LastRadius)+'\n')
|
|
Line = BoxFace(self.BaseName+'LidJoint'+str(n_side_line),
|
|
CornerPoint((0,0), 0, 1, 1), 0, #Start point, no notch
|
|
CornerPoint((FlexElement[0] - FlexElement[2] - LastRadius,0), 0, 1, 1), 0, #Size is up to rounded corner, no notch for the small side
|
|
CornerPoint((FlexElement[0] - FlexElement[2] - LastRadius,thickness), 0, 1, 1), FlexElement[1], #Same x, height = 2*thickness, joints up to next
|
|
CornerPoint((0, thickness), 0, 1, 1), 0,
|
|
self.InkscapeGroup, [-self.BoundingBox[2]-2, ypos])
|
|
ypos -= 2*thickness + 2
|
|
Line.drawSimpleFace(True)
|
|
LastRadius = FlexElement[2]
|
|
|
|
|
|
class BoxFace:
|
|
'''
|
|
This class deals with faces
|
|
Each face is defined with 4 corners and the size of the finger joints between the corners
|
|
finger joint size = 0 means no finger joints (straight line)
|
|
The InkscapeGroup parameter is used to bind the path in this group
|
|
The PositionInPage parameter is used to fix the path within the inkscape document
|
|
'''
|
|
def __init__(self, name, top_left, top_finger_joint, top_right, right_finger_joint, bottom_right, bottom_finger_joint, bottom_left, left_finger_joint, InkscapeGroup, PositionInPage, Path=None):
|
|
#First set up the corners
|
|
self.top_left_corner = top_left
|
|
self.top_right_corner = top_right
|
|
self.bottom_right_corner = bottom_right
|
|
self.bottom_left_corner = bottom_left
|
|
#then the lines between the corners
|
|
self.TopLine = NotchLine((top_left.x_start_joint, top_left.y_start_joint, top_left.y_internal), (top_right.x_end_joint, top_right.y_end_joint, top_right.y_internal), 0, top_finger_joint)
|
|
|
|
self.RightLine = NotchLine((top_right.x_start_joint, top_right.y_start_joint, top_right.x_internal), (bottom_right.x_end_joint, bottom_right.y_end_joint, bottom_right.x_internal), math.pi/2, right_finger_joint)
|
|
|
|
self.BottomLine = NotchLine((bottom_right.x_start_joint, bottom_right.y_start_joint, bottom_right.y_internal), (bottom_left.x_end_joint, bottom_left.y_end_joint, bottom_left.y_internal), math.pi, bottom_finger_joint)
|
|
|
|
self.LeftLine = NotchLine((bottom_left.x_start_joint, bottom_left.y_start_joint, bottom_left.x_internal), (top_left.x_end_joint, top_left.y_end_joint, top_left.x_internal), -math.pi/2, left_finger_joint)
|
|
|
|
#Update PositionInPage to take into account external corners or notches
|
|
if self.top_left_corner.WoodHingeCorner:
|
|
PositionInPage[0] -= (WoodHingeSize+1)*thickness
|
|
PositionInPage[1] -= WoodHingeSize*thickness
|
|
elif self.top_right_corner.WoodHingeCorner:
|
|
PositionInPage[1] -= WoodHingeSize*thickness
|
|
PositionInPage[0] -= thickness
|
|
elif self.top_left_corner.x_internal == 0 or self.bottom_left_corner.x_internal == 0 or self.LeftLine.nb_finger_joint > 0:
|
|
PositionInPage[0] -= thickness
|
|
if self.top_left_corner.y_internal == 0 or self.top_right_corner.y_internal == 0 or self.TopLine.nb_finger_joint > 0:
|
|
PositionInPage[1] -= thickness
|
|
self.BoundingBox = (-PositionInPage[0], -PositionInPage[1], -PositionInPage[0], -PositionInPage[1])
|
|
self.name = name
|
|
self.InkscapeGroup = InkscapeGroup
|
|
#If needed, create path which will be used to draw the face
|
|
#The path will be in the group InkscapeGroup
|
|
if Path == None:
|
|
self.path = th_inkscape_path(PositionInPage, InkscapeGroup, name)
|
|
DebugMsg("Creating path("+name+") Position ="+str(PositionInPage)+'\n')
|
|
else:
|
|
self.path = Path
|
|
#DebugMsg("Create path "+str(name)+ " PositionInPage="+str(PositionInPage)+'\n')
|
|
|
|
def Close(self):
|
|
'''
|
|
Close and write the path after drawing is done
|
|
'''
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
|
|
def drawSimpleFace(self, ClosePath):
|
|
'''
|
|
Draw the face, when there are no other elements in the perimeter
|
|
If ClosePath is true the path is closed
|
|
'''
|
|
if self.top_left_corner.WoodHingeCorner:
|
|
#Specific case, shorten Left line of notches to take into account the wood hinge circle
|
|
#But first copy values from right edge, because WoodHingeCorner has modified the notch line
|
|
self.LeftLine.start_line_joint_y = self.RightLine.end_line_joint_y
|
|
self.LeftLine.JointSize = self.RightLine.JointSize
|
|
self.LeftLine.nb_finger_joint = self.RightLine.nb_finger_joint
|
|
self.LeftLine.EndY = self.RightLine.StartY
|
|
SizeCut = WoodHingeSize * thickness
|
|
#Start from bottom (because reverse on left line) up to sizecut
|
|
self.LeftLine.ModifyNotchLine(SizeCut, False) #Last parameter, CutOnStart = False, because we start at bottom
|
|
if self.top_right_corner.WoodHingeCorner:
|
|
#Specific case, shorten Right line of notches to take into account the wood hinge circle
|
|
#But first copy values from Left edge, because WoodHingeCorner has modified the notch line
|
|
self.RightLine.start_line_joint_y = self.LeftLine.end_line_joint_y
|
|
self.RightLine.end_line_joint_y = self.LeftLine.start_line_joint_y
|
|
self.RightLine.JointSize = self.LeftLine.JointSize
|
|
self.RightLine.nb_finger_joint = self.LeftLine.nb_finger_joint
|
|
self.RightLine.StartY = self.LeftLine.EndY
|
|
SizeCut = WoodHingeSize * thickness
|
|
self.RightLine.ModifyNotchLine(SizeCut, True) #Last parameter, CutOnStart = False, because we start at Top
|
|
# Go To starting point
|
|
self.path.MoveTo(self.top_left_corner.x_end_joint, self.top_left_corner.y_end_joint)
|
|
#DebugMsg("StartPoint, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#first (top left) corner
|
|
self.top_left_corner.drawCorner(self.path)
|
|
#DebugMsg("TopLeft, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#then top edge
|
|
self.TopLine.drawNotchLine(self.path)
|
|
#DebugMsg("Top Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Top right corner
|
|
self.top_right_corner.drawCorner(self.path)
|
|
#DebugMsg("Top Right corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Right edge
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#DebugMsg("Right Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom right corner
|
|
self.bottom_right_corner.drawCorner(self.path)
|
|
#DebugMsg("Bottom Right corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom edge
|
|
self.BottomLine.drawNotchLine(self.path)
|
|
#DebugMsg("Bottom Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom left corner
|
|
self.bottom_left_corner.drawCorner(self.path)
|
|
DebugMsg("Bottom Left corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
#DebugMsg("Left Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#The position is now (top_left_corner.x_end_joint, top_left_corner.y_end_joint), it is the starting point
|
|
|
|
#Case with WoodHingeCorner, draw circle and rectangle
|
|
if self.top_left_corner.WoodHingeCorner:
|
|
#Draw the circle internal to the hinge, radius is 2*thickness mm
|
|
CircleRadius = WoodHingeInternalCircle*thickness
|
|
self.path.drawCircle(-thickness, -thickness, CircleRadius)
|
|
#Then the internal rectangle, rectangle height is 1.5*thickness
|
|
RectHeight = WoodHingeRect*thickness
|
|
self.path.MoveTo(-thickness, -thickness) #Starting point Ext/Bottom
|
|
self.path.LineToVRel(-RectHeight) #Ext/Top
|
|
self.path.LineToHRel(thickness) #Int/Top
|
|
self.path.LineToVRel(RectHeight) #Int Bottom
|
|
self.path.LineToHRel(-thickness) #Return to start
|
|
if self.top_right_corner.WoodHingeCorner:
|
|
#Draw the circle internal to the hinge, radius is 2*thickness mm
|
|
CircleRadius = WoodHingeInternalCircle*thickness
|
|
self.path.drawCircle(self.top_right_corner.x_corner+thickness, -thickness, CircleRadius)
|
|
#Then the internal rectangle, rectangle height is 1.5*thickness
|
|
RectHeight = WoodHingeRect*thickness
|
|
self.path.MoveTo(self.top_right_corner.x_corner+thickness, -thickness) #Starting point Ext/Bottom
|
|
self.path.LineToVRel(-RectHeight) #Ext/Top
|
|
self.path.LineToHRel(-thickness) #Int/Top
|
|
self.path.LineToVRel(RectHeight) #Int Bottom
|
|
self.path.LineToHRel(thickness) #Return to start
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
def drawSimpleFaceHinge(self, HingeList, ClosePath):
|
|
'''
|
|
Draw the face, and the cut for the hinge
|
|
If ClosePath is true the path is closed
|
|
'''
|
|
# Go To starting point
|
|
self.path.MoveTo(self.top_left_corner.x_end_joint, self.top_left_corner.y_end_joint)
|
|
#DebugMsg("StartPoint, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#first (top left) corner
|
|
self.top_left_corner.drawCorner(self.path)
|
|
#DebugMsg("TopLeft, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#then top edge, no notch in this case, but cut for the hinge(s)
|
|
for Hinge in HingeList:
|
|
HingePos = Hinge[2] - 1
|
|
self.path.LineTo(HingePos, 0)
|
|
#Then cut for the Hinge
|
|
self.path.LineToVRel(4.5*thickness+1)
|
|
self.path.LineToHRel(5*thickness + 2.5*SteelHingeSpacing + 2)
|
|
self.path.LineToVRel(-4.5*thickness-1)
|
|
#Then line up to length
|
|
self.path.LineTo(self.top_right_corner.x_corner, 0) #Up to end of top line
|
|
#Top right corner
|
|
self.top_right_corner.drawCorner(self.path)
|
|
#DebugMsg("Top Right corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Right edge
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#DebugMsg("Right Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom right corner
|
|
self.bottom_right_corner.drawCorner(self.path)
|
|
#DebugMsg("Bottom Right corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom edge
|
|
self.BottomLine.drawNotchLine(self.path)
|
|
#DebugMsg("Bottom Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom left corner
|
|
self.bottom_left_corner.drawCorner(self.path)
|
|
#DebugMsg("Bottom Left corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
#DebugMsg("Left Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#The position is now (top_left_corner.x_end_joint, top_left_corner.y_end_joint), it is the starting point
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
def drawFaceWithHoles(self, n_slot, slot_size, DeltaHolePosition, z_joint_size, Height_percentage, ClosePath, HingeList = None):
|
|
'''
|
|
Draw a face with holes (for internal walls)
|
|
The holes positions are given in a list (see CalcNotchPos), and an offset will be added if necessary (shorten face)
|
|
n_slot : number of slots
|
|
slot_size
|
|
DeltaHolePosition : Offset for holes
|
|
z_joint_size
|
|
Height_percentage : Actual interior will be height*percentage, so dig holes only for useful part
|
|
ClosePath :
|
|
HingeList :
|
|
'''
|
|
if HingeList == None:
|
|
#No cut for hinge, call regular function to draw face
|
|
self.drawSimpleFace(False) #First draw the face itself, without closing path
|
|
else:
|
|
self.drawSimpleFaceHinge(HingeList, False) #First draw the face itself, without closing path
|
|
#now the holes used to fix the walls
|
|
#This line will be used to draw the holes
|
|
InteriorHeight = self.bottom_right_corner.y_end_joint * Height_percentage / 100.0
|
|
l_NotchLine = NotchLine((0, 0, 1), (InteriorHeight, 0, 1), math.pi/2, z_joint_size)
|
|
|
|
StartHole = l_NotchLine.start_line_joint_y + l_NotchLine.JointSize
|
|
Spacing = 2*l_NotchLine.JointSize
|
|
DebugMsg("drawFaceWithHoles, Hole Start ="+str(StartHole)+" Spacing="+str(Spacing)+" n_holes"+str(l_NotchLine.nb_finger_joint//2)
|
|
+' n_slot='+str(n_slot)+' slot_size='+str(slot_size)+" Delta_Pos="+str(DeltaHolePosition)+'\n')
|
|
for i in range(1, n_slot):
|
|
#For each wall, draw holes corresponding at each notch on zbox
|
|
for j in range((l_NotchLine.nb_finger_joint)//2):
|
|
drawHole(self.path, i*(slot_size+thickness) - DeltaHolePosition -thickness, StartHole + j*Spacing, thickness, l_NotchLine.JointSize, burn)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
def drawFaceInternalSlidingLeft(self, ClosePath):
|
|
'''
|
|
Draw specific pattern helping the sliding of the lid inside the box
|
|
'''
|
|
radius_back = self.top_left_corner.radius
|
|
# Go To starting point (top left)
|
|
self.path.MoveTo(self.top_left_corner.x_corner, self.top_left_corner.y_corner+thickness)
|
|
DebugMsg("drawFaceInternalSlidingLeft, top left start in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then draw the small quarter of circle
|
|
self.path.LineToVRel(radius_back)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
self.path.drawQuarterCircle(self.top_left_corner.x_corner+radius_back, self.top_left_corner.y_corner+radius_back+thickness, radius_back, 0)
|
|
DebugMsg("drawFaceInternalSlidingLeft, after circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
self.path.LineToHRel(-radius_back)
|
|
DebugMsg("drawFaceInternalSlidingLeft, End of top left circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
|
|
|
|
#Then restart path at bottom right
|
|
self.path.MoveTo(self.bottom_right_corner.x_end_joint, self.bottom_right_corner.y_end_joint)
|
|
DebugMsg("drawFaceInternalSlidingLeft, start in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Draw the horizontal line towards left corner
|
|
self.path.LineTo(self.bottom_left_corner.x_end_joint+SlidingLidSpaceZ*thickness, self.bottom_left_corner.y_end_joint)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Draw the vertical left line towards rounded back
|
|
#Change left line
|
|
x = self.path.x_noff
|
|
self.LeftLine = NotchLine((x, self.bottom_left_corner.y_start_joint, 0), (x, self.top_left_corner.y_end_joint+SlidingLidSpaceZ*thickness, 0), -math.pi/2, self.LeftLine.JointSize)
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
x = self.top_left_corner.x_end_joint+SlidingLidSpaceZ*thickness
|
|
y = self.top_left_corner.y_end_joint+SlidingLidSpaceZ*thickness
|
|
DebugMsg("drawFaceInternalSlidingLeft, after notches in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
self.path.LineTo(x, y)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Draw the quarter circle (quadrant 0)
|
|
self.path.drawQuarterCircle(x+radius_back, y, radius_back, 0)
|
|
DebugMsg("drawFaceInternalSlidingLeft, after first circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then the horizontal line towards the large circle
|
|
x = self.top_right_corner.x_end_joint - (SlidingLidSpaceZ+1)*thickness
|
|
y = self.path.y_noff
|
|
self.path.LineTo(x, y)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#then large circle (Quadrant 1)
|
|
radius = self.top_right_corner.radius
|
|
y_end = min(self.top_right_corner.y_start_joint, self.bottom_right_corner.y_end_joint - thickness)
|
|
self.path.Bezier(x+radius*0.551916, y, x + radius, y+radius*(1-0.551916), x+radius, y_end)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then V Line up to bottom
|
|
self.path.LineTo(self.bottom_right_corner.x_end_joint- (SlidingLidSpaceZ+1)*thickness, self.bottom_right_corner.y_end_joint - thickness)
|
|
DebugMsg("drawFaceInternalSlidingLeft, After V Line now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then H line
|
|
x = self.bottom_right_corner.x_end_joint - thickness
|
|
y = self.bottom_right_corner.y_end_joint - thickness
|
|
self.path.LineTo(x, y)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then V Line
|
|
self.path.LineTo(x, y_end)
|
|
#Then large circle, first quadrant but reverse drawing
|
|
self.path.Bezier(x, y_end - radius*0.551916, x - radius*0.551916, y_end-radius, x-radius+thickness, y_end-radius) # upper right quarter
|
|
DebugMsg("drawFaceInternalSlidingLeft, After circle 2 in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then V line
|
|
self.path.LineToVRel(-thickness)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#And last large circle
|
|
x = self.path.x_noff
|
|
y = self.path.y_noff
|
|
self.path.Bezier(x+radius*0.551916, y, self.bottom_right_corner.x_end_joint, y+radius*(1-0.551916), self.bottom_right_corner.x_end_joint, self.top_right_corner.y_start_joint-thickness)
|
|
DebugMsg("drawFaceInternalSlidingLeft, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
def drawFaceInternalSlidingRight(self, ClosePath):
|
|
'''
|
|
Draw specific pattern helping the sliding of the lid inside the box
|
|
'''
|
|
radius_back = self.top_right_corner.radius
|
|
# Go To starting point (top Right)
|
|
self.path.MoveTo(self.top_right_corner.x_corner, self.top_right_corner.y_corner+thickness)
|
|
DebugMsg("drawFaceInternalSlidingRight, top right start in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then draw the small quarter of circle
|
|
self.path.LineToHRel(-radius_back)
|
|
DebugMsg("drawFaceInternalSlidingRight, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
self.path.drawQuarterCircle(self.top_right_corner.x_corner-radius_back, self.top_right_corner.y_corner+radius_back+thickness, radius_back, 1)
|
|
DebugMsg("drawFaceInternalSlidingRight, after circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
self.path.LineToVRel(-radius_back)
|
|
DebugMsg("drawFaceInternalSlidingRight, End of top right circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
|
|
|
|
#Then restart path at bottom left
|
|
self.path.MoveTo(self.bottom_left_corner.x_end_joint, self.bottom_left_corner.y_end_joint)
|
|
DebugMsg("drawFaceInternalSlidingRight, start in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Draw the horizontal line towards right corner
|
|
self.path.LineTo(self.bottom_right_corner.x_end_joint-SlidingLidSpaceZ*thickness, self.bottom_right_corner.y_end_joint)
|
|
DebugMsg("drawFaceInternalSlidingRight, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Draw the vertical Right line towards rounded back
|
|
#Change right line
|
|
x = self.path.x_noff
|
|
self.RightLine = NotchLine((x, self.bottom_right_corner.y_start_joint, 1), (x, self.top_right_corner.y_start_joint+SlidingLidSpaceZ*thickness, 1), -math.pi/2, self.RightLine.JointSize)
|
|
self.RightLine.drawNotchLine(self.path)
|
|
DebugMsg("drawFaceInternalSlidingRight, after notches in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
y = self.top_right_corner.y_start_joint+SlidingLidSpaceZ*thickness
|
|
self.path.LineTo(x, y)
|
|
DebugMsg("drawFaceInternalSlidingRight, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Draw the quarter circle, use bezier instead of drawCircle because reverse draw
|
|
self.path.Bezier(x, y - radius_back*0.551916, x - radius_back*(1-0.551916), y-radius_back, x-radius_back, y-radius_back)
|
|
DebugMsg("drawFaceInternalSlidingRight, after first circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then the horizontal line towards the large circle
|
|
x = self.top_left_corner.x_start_joint + (SlidingLidSpaceZ+1)*thickness
|
|
y = self.path.y_noff
|
|
self.path.LineTo(x, y)
|
|
DebugMsg("drawFaceInternalSlidingRight, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#then large circle (Quadrant 0)
|
|
radius = self.top_left_corner.radius
|
|
y_end = min(self.top_left_corner.y_end_joint, self.bottom_left_corner.y_end_joint - thickness)
|
|
self.path.Bezier(x-radius*0.551916, y, x - radius, y+radius*(1-0.551916), x-radius, y_end)
|
|
x = x-radius
|
|
DebugMsg("drawFaceInternalSlidingRight, after circle 1 in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then V Line up to bottom
|
|
self.path.LineTo(x, self.bottom_left_corner.y_end_joint - thickness)
|
|
DebugMsg("drawFaceInternalSlidingLeft, After V Line now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then H line
|
|
x = self.bottom_left_corner.x_end_joint + thickness
|
|
y = self.bottom_left_corner.y_end_joint - thickness
|
|
self.path.LineTo(x, y)
|
|
DebugMsg("drawFaceInternalSlidingRight, now in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then Up yo y_end
|
|
self.path.LineTo(x, y_end)
|
|
#Then large circle, first quadrant
|
|
self.path.Bezier(x, y_end - radius*0.551916, x + radius*0.551916, y_end-radius, x+radius-thickness, y_end-radius)
|
|
DebugMsg("drawFaceInternalSlidingRight, Circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then V line
|
|
self.path.LineToVRel(-thickness)
|
|
DebugMsg("drawFaceInternalSlidingRight, VLine in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#And last large circle
|
|
x = self.path.x_noff
|
|
y = self.path.y_noff
|
|
self.path.Bezier(x-radius*0.551916, y, self.bottom_left_corner.x_end_joint, y+radius*(1-0.551916), self.bottom_left_corner.x_end_joint, self.top_left_corner.y_end_joint-thickness)
|
|
DebugMsg("drawFaceInternalSlidingRight, Circle in "+str((self.path.x_noff, self.path.y_noff))+'\n')
|
|
#Then Last line
|
|
self.path.LineTo(self.bottom_left_corner.x_end_joint, self.bottom_left_corner.y_end_joint)
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
|
|
def drawSideLineNotches(self, xpos, ypos):
|
|
'''
|
|
Draw the side line notches used with sliding lid. These lines are on left and right lines
|
|
These lines are created whenever the top notches are not null
|
|
'''
|
|
n_side_line = 0
|
|
Line = BoxFace(self.name+'LidJoint',
|
|
CornerPoint((0,0), 0, 1, 1), 0, #Start point, no notch
|
|
CornerPoint((self.top_right_corner.xc - self.top_left_corner.xc,0), 0, 1, 1), 0, #Size is up to rounded corner, no notch for the small side
|
|
CornerPoint((self.top_right_corner.xc - self.top_left_corner.xc,thickness), 0, 1, 1), self.TopLine.JointSize, #Same x, height = 2*thickness, joints up to next
|
|
CornerPoint((0, thickness), 0, 1, 1), 0,
|
|
self.InkscapeGroup, [xpos, ypos])
|
|
Line.drawSimpleFace(True)
|
|
|
|
|
|
def drawExternalBackSlidingLid(self, ClosePath):
|
|
'''
|
|
Draw the face, specific case for sliding lid back face
|
|
If ClosePath is true the path is closed
|
|
'''
|
|
# Go To starting point
|
|
self.path.MoveTo(self.top_left_corner.x_end_joint, self.top_left_corner.y_end_joint)
|
|
#first (top left) corner
|
|
self.top_left_corner.drawCorner(self.path)
|
|
#DebugMsg("TopLeft, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Then draw below thickness
|
|
self.path.LineToVRel(thickness)
|
|
#then top edge, without notches
|
|
self.path.LineToHRel(self.top_right_corner.x_end_joint)
|
|
#Then Up thickness
|
|
self.path.LineToVRel(-thickness)
|
|
#Top right corner
|
|
self.top_right_corner.drawCorner(self.path)
|
|
#DebugMsg("Top Right corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Right edge
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#DebugMsg("Right Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom right corner
|
|
self.bottom_right_corner.drawCorner(self.path)
|
|
#DebugMsg("Bottom Right corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom edge
|
|
self.BottomLine.drawNotchLine(self.path)
|
|
#DebugMsg("Bottom Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Bottom left corner
|
|
self.bottom_left_corner.drawCorner(self.path)
|
|
#DebugMsg("Bottom Left corner, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
#DebugMsg("Left Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#The position is now (top_left_corner.x_end_joint, top_left_corner.y_end_joint), it is the starting point
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
def drawExternalBackWoodHingeLid(self, ClosePath):
|
|
'''
|
|
Draw the face, specific case for wood hinge lid back face
|
|
This face will use a specific vertical notch lines, which are shorter by the circle of the hinge
|
|
If ClosePath is true the path is closed
|
|
'''
|
|
DebugMsg("\n enter drawExternalBackWoodHingeLid\n")
|
|
#Size of wood hinge cut
|
|
SizeCut = WoodHingeSize*thickness + 2*burn
|
|
#Modify right line to accomodate this cut
|
|
self.RightLine.ModifyNotchLine(SizeCut, True)
|
|
#Do the same for left line, but reverse
|
|
self.LeftLine.ModifyNotchLine(SizeCut, False)
|
|
# Go To starting point
|
|
self.path.MoveTo(0, -thickness)
|
|
self.path.LineTo(self.top_right_corner.x_end_joint, -thickness) #Space for cut
|
|
#Then go to cut
|
|
self.path.LineToVRel(SizeCut)
|
|
self.path.LineToHRel(thickness)
|
|
#Right edge
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#Bottom right corner
|
|
self.bottom_right_corner.drawCorner(self.path)
|
|
#Bottom edge
|
|
self.BottomLine.drawNotchLine(self.path)
|
|
#Bottom left corner
|
|
self.bottom_left_corner.drawCorner(self.path)
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
#Then cut
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineTo(0, -thickness)
|
|
#The position is now (top_left_corner.x_end_joint, top_left_corner.y_end_joint), it is the starting point
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
def drawLidBackWoodHinge(self, ClosePath):
|
|
'''
|
|
Draw the lid back when Wood hinge is chosen, specific case for wood hinge lid back face
|
|
This face will use a specific vertical notch lines, which are shorter by the circle of the hinge
|
|
If ClosePath is true the path is closed
|
|
'''
|
|
#Size of wood hinge cut
|
|
SizeCut = WoodHingeSize*thickness + 2*burn
|
|
DebugMsg("\n enter drawLidBackWoodHinge, SizeCut = "+str(SizeCut)+"\n")
|
|
DebugMsg("Joint size ="+str(self.RightLine.JointSize)+" Top_Right="+str((self.top_right_corner.x_corner, self.top_right_corner.y_corner))+" Bottom Right="+str((self.bottom_right_corner.x_corner, self.bottom_right_corner.y_corner))+"\n")
|
|
#Change right line, from top to bottom RightLine
|
|
self.RightLine.ModifyNotchLine(SizeCut, False) #Last Parameter false because we start on Top and cut is on bottom
|
|
#The left line will be the same but reverse
|
|
self.LeftLine.ModifyNotchLine(SizeCut, True) #Last Parameter false because we start on Bottom and cut is on bottom
|
|
# Go To starting point
|
|
self.path.MoveTo(self.top_left_corner.x_end_joint, self.top_left_corner.y_end_joint)
|
|
#DebugMsg("StartPoint, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#first (top left) corner
|
|
self.top_left_corner.drawCorner(self.path)
|
|
#DebugMsg("TopLeft, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#then top edge
|
|
self.TopLine.drawNotchLine(self.path)
|
|
#DebugMsg("Top Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Top right corner
|
|
self.top_right_corner.drawCorner(self.path)
|
|
#Right edge
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#Then the cut with the notch for the circle
|
|
StartNotchCircle = 1.5 * thickness
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineTo(self.bottom_right_corner.x_end_joint - thickness, self.bottom_right_corner.y_corner - StartNotchCircle)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(StartNotchCircle)
|
|
self.path.LineTo(self.bottom_right_corner.x_end_joint - thickness, self.bottom_right_corner.y_corner)
|
|
#Bottom edge
|
|
self.path.LineTo(-thickness, self.bottom_left_corner.y_corner)
|
|
#Then Cut
|
|
self.path.LineToVRel(-StartNotchCircle)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineTo(0, self.bottom_left_corner.y_corner - SizeCut)
|
|
self.path.LineToHRel(-thickness)
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
self.path.LineTo(-thickness, -thickness)
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
def drawExternalBackSteelHingeLid(self, HingeList, ClosePath):
|
|
'''
|
|
Draw the face, specific case for lid with 'steel hinge' back face
|
|
This face will have cuts to place the real hinge elements
|
|
HingeList is a list of Hinge position
|
|
If ClosePath is true the path is closed
|
|
'''
|
|
DebugMsg("\n enter drawExternalBackSteelHingeLid\n")
|
|
# Go To starting point
|
|
self.path.MoveTo(-thickness, -thickness)
|
|
#The top line will have cut for the hinge
|
|
for Hinge in HingeList:
|
|
HingePos = Hinge[2]
|
|
self.path.LineTo(HingePos + thickness, -thickness) #add thickness in x because hinge pos is internal, and sub thickness in y because always external
|
|
#Then Hinge
|
|
self.path.LineToVRel(2.5*thickness)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-thickness + 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(thickness + SteelHingeSpacing)
|
|
self.path.LineToVRel(thickness - 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-thickness + 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(thickness + SteelHingeSpacing)
|
|
self.path.LineToVRel(thickness - 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-2.5*thickness)
|
|
#Then line up to length
|
|
self.path.LineTo(self.top_right_corner.x_corner, -thickness) #Up to end of top line
|
|
|
|
#Right edge
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#Bottom right corner
|
|
self.bottom_right_corner.drawCorner(self.path)
|
|
#Bottom edge
|
|
self.BottomLine.drawNotchLine(self.path)
|
|
#Bottom left corner
|
|
self.bottom_left_corner.drawCorner(self.path)
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
#Then return to Start
|
|
self.path.LineTo(-thickness, -thickness)
|
|
|
|
#Now draw holes for the hinge(s)
|
|
for Hinge in HingeList:
|
|
self.path.MoveTo(Hinge[2]+thickness, 3.5*thickness)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-thickness)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineToVRel(thickness)
|
|
self.path.MoveTo(Hinge[2] + 3*thickness + SteelHingeSpacing, 3.5*thickness)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-thickness)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineToVRel(thickness)
|
|
self.path.MoveTo(Hinge[2] + 5*thickness + 2*SteelHingeSpacing, 3.5*thickness)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-thickness)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineToVRel(thickness)
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
|
|
def drawLidBackSteelHinge(self, HingeList, ClosePath):
|
|
'''
|
|
Draw the lid back, specific case for lid with 'steel hinge' back face
|
|
This face will have cuts to place the real hinge elements
|
|
HingeList is a list of Hinge position
|
|
If ClosePath is true the path is closed
|
|
'''
|
|
DebugMsg("\n enter drawLidBackSteelHinge\n")
|
|
# Go To starting point
|
|
self.path.MoveTo(self.top_left_corner.x_end_joint, self.top_left_corner.y_end_joint)
|
|
#DebugMsg("StartPoint, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#first (top left) corner
|
|
self.top_left_corner.drawCorner(self.path)
|
|
#DebugMsg("TopLeft, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#then top edge
|
|
self.TopLine.drawNotchLine(self.path)
|
|
#DebugMsg("Top Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Top right corner
|
|
self.top_right_corner.drawCorner(self.path)
|
|
#Right edge
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#Bottom right corner
|
|
self.bottom_right_corner.drawCorner(self.path)
|
|
#Bottom edge, this one has cut for the hinge(s).
|
|
z = self.bottom_right_corner.y_corner
|
|
#Now draw holes for the hinge(s), reverse because draw from right to left
|
|
for Hinge in reversed(HingeList):
|
|
HingePos = Hinge[2] + thickness
|
|
#First H line up to end of 2nd hinge
|
|
self.path.LineTo(HingePos + 5*thickness + 2.5*SteelHingeSpacing, z)
|
|
#Then Hinge
|
|
self.path.LineToVRel(-1.5*thickness - 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(-thickness - SteelHingeSpacing)
|
|
self.path.LineToVRel(-thickness + 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineToVRel(thickness - 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(-thickness - SteelHingeSpacing)
|
|
self.path.LineToVRel(-thickness + 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineToVRel(thickness - 0.5*SteelHingeSpacing)
|
|
self.path.LineToHRel(-thickness - SteelHingeSpacing)
|
|
self.path.LineToVRel(1.5*thickness + 0.5*SteelHingeSpacing)
|
|
#Then draw up to corner
|
|
self.path.LineTo(self.bottom_left_corner.x_end_joint, self.bottom_left_corner.y_end_joint)
|
|
#Bottom left corner
|
|
self.bottom_left_corner.drawCorner(self.path)
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
#Then return to Start
|
|
self.path.LineTo(-thickness, -thickness)
|
|
|
|
#Then draw holes for the hinge(s)
|
|
for Hinge in HingeList:
|
|
HingePos = Hinge[2] + 2*thickness
|
|
self.path.MoveTo(HingePos + 0.5*SteelHingeSpacing, z - 3.5*thickness)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-thickness)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineToVRel(thickness)
|
|
self.path.MoveTo(HingePos + 2*thickness + 1.5*SteelHingeSpacing, z - 3.5*thickness)
|
|
self.path.LineToHRel(thickness)
|
|
self.path.LineToVRel(-thickness)
|
|
self.path.LineToHRel(-thickness)
|
|
self.path.LineToVRel(thickness)
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
def drawLidSideWoodHinge(self, FlagRight, ClosePath):
|
|
'''
|
|
Generate lid side with integrated hinge. This is a rectangle with a rounded cut for the hinge and notches on 3 edges
|
|
No notch on the bottom edge
|
|
'''
|
|
SizeCut = WoodHingeSize*thickness + 2*burn
|
|
DebugMsg("\n enter drawLidSideWoodHinge, SizeCut="+str(SizeCut)+" FlagRight ="+str(FlagRight)+"\n")
|
|
#Because of the cut on the lid, we have to change either the right of left line of notches
|
|
if FlagRight > 0:
|
|
self.RightLine.ModifyNotchLine(SizeCut, False)
|
|
else:
|
|
self.LeftLine.ModifyNotchLine(SizeCut, True)
|
|
# Go To starting point
|
|
self.path.MoveTo(self.top_left_corner.x_end_joint, self.top_left_corner.y_end_joint)
|
|
#DebugMsg("StartPoint, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#first (top left) corner
|
|
self.top_left_corner.drawCorner(self.path)
|
|
#DebugMsg("TopLeft, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#then top edge
|
|
self.TopLine.drawNotchLine(self.path)
|
|
#DebugMsg("Top Edge, PathPos ="+str((self.path.x, self.path.y))+" Bounding Box="+str(self.path.GetBoundingBox())+'\n')
|
|
#Top right corner
|
|
self.top_right_corner.drawCorner(self.path)
|
|
#Right edge, first start with normal notch line
|
|
self.RightLine.drawNotchLine(self.path)
|
|
#If right side, special case. Start with notches, but then switch to a circle
|
|
if FlagRight > 0:
|
|
#Then the cut. Choose 0.95*SizeCut because the actual circle is NOT centered of this vertical edge but shifted by thickness
|
|
self.path.LineTo(self.top_right_corner.x_corner, self.bottom_right_corner.y_corner-SizeCut*0.95)
|
|
#Then the rounded cut, almost a quarter of circle, radius SizeCut
|
|
self.path.Bezier(self.top_right_corner.x_corner-SizeCut*0.23, self.bottom_right_corner.y_corner-SizeCut*0.90,
|
|
self.top_right_corner.x_corner-SizeCut+thickness, self.bottom_right_corner.y_corner-SizeCut*0.551916,
|
|
self.top_right_corner.x_corner-SizeCut+thickness, self.bottom_right_corner.y_corner)
|
|
#No notches on bottom line, just go to next corner
|
|
self.path.LineTo(0, self.bottom_left_corner.y_corner)
|
|
else:
|
|
self.path.LineTo(self.top_right_corner.x_corner, self.bottom_right_corner.y_corner) #Up to corner
|
|
self.path.LineTo(SizeCut-thickness, self.bottom_left_corner.y_corner) #Bottom line up to circle cut
|
|
#Draw the rounded cut, almost a quarter of circle, radius ExtRadius
|
|
self.path.Bezier(SizeCut-thickness, self.bottom_left_corner.y_corner-SizeCut*0.551916
|
|
, SizeCut*0.23, self.bottom_left_corner.y_corner-SizeCut*0.90
|
|
, 0, self.bottom_left_corner.y_corner-SizeCut*0.95)
|
|
#Left edge
|
|
self.LeftLine.drawNotchLine(self.path)
|
|
self.path.LineTo(0, -thickness) #Up to starting point
|
|
|
|
#Get bounding box of path
|
|
self.BoundingBox = (self.path.xmin, self.path.ymin, self.path.xmax, self.path.ymax)
|
|
|
|
#Close the path if asked
|
|
if ClosePath:
|
|
self.path.Close()
|
|
self.path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
|
|
|
|
|
|
class GenericBox(inkex.Effect):
|
|
"""
|
|
Creates a new layer with the drawings for a parametrically generated box.
|
|
"""
|
|
def __init__(self):
|
|
'''
|
|
init for all parameters
|
|
'''
|
|
inkex.Effect.__init__(self)
|
|
self.knownUnits = ['in', 'pt', 'px', 'mm', 'cm', 'm', 'km', 'pc', 'yd', 'ft']
|
|
|
|
self.arg_parser.add_argument('--unit', action = 'store',
|
|
type = str, dest = 'unit', default = 'mm',
|
|
help = 'Unit, should be one of ')
|
|
|
|
self.arg_parser.add_argument('--thickness', action = 'store',
|
|
type = float, dest = 'thickness', default = '3.0',
|
|
help = 'Material thickness')
|
|
|
|
self.arg_parser.add_argument('--lid_type', action = 'store',
|
|
type = str, dest = 'lid_type', default = 'Simple',
|
|
help = 'Box lid style ')
|
|
|
|
self.arg_parser.add_argument('--n_slot_x', action = 'store',
|
|
type = int, dest = 'n_slot_x', default = '2',
|
|
help = 'Number of columns of slots')
|
|
|
|
self.arg_parser.add_argument('--n_slot_y', action = 'store',
|
|
type = int, dest = 'n_slot_y', default = '2',
|
|
help = 'Number of rows of slots')
|
|
|
|
self.arg_parser.add_argument('--h_slot', action = 'store',
|
|
type = int, dest = 'h_slot', default = '100',
|
|
help = 'Height of slots (%)')
|
|
|
|
self.arg_parser.add_argument('--z', action = 'store',
|
|
type = float, dest = 'z', default = '40.0',
|
|
help = "box height")
|
|
|
|
self.arg_parser.add_argument('--y', action = 'store',
|
|
type = float, dest = 'y', default = '60.0',
|
|
help = "box depth")
|
|
|
|
self.arg_parser.add_argument('--x', action = 'store',
|
|
type = float, dest = 'x', default = '40.0',
|
|
help = "box width")
|
|
|
|
self.arg_parser.add_argument('--z_lid', action = 'store',
|
|
type = float, dest = 'z_lid', default = '20.0',
|
|
help = 'lid height')
|
|
|
|
self.arg_parser.add_argument('--z_dome_lid', action = 'store',
|
|
type = float, dest = 'z_dome_lid', default = '20.0',
|
|
help = 'dome lid height')
|
|
|
|
self.arg_parser.add_argument('--SkipFlexLines', action = 'store',
|
|
type = inkex.Boolean, dest = 'SkipFlexLines', default = 'true',
|
|
help = 'Skip flex lines when possible')
|
|
|
|
self.arg_parser.add_argument('--radius_lid', action = 'store',
|
|
type = float, dest = 'radius_lid', default = '50.0',
|
|
help = 'Radius of rounded lid')
|
|
|
|
self.arg_parser.add_argument('--burn', action = 'store',
|
|
type = float, dest = 'burn', default = '0.1',
|
|
help = 'laser burn size')
|
|
|
|
self.arg_parser.add_argument('--StraigthCorners', action = 'store',
|
|
type = inkex.Boolean, dest = 'StraigthCorners', default = 'true',
|
|
help = 'Straight corners')
|
|
|
|
self.arg_parser.add_argument('--back_left_radius', action = 'store',
|
|
type = float, dest = 'back_left_radius', default = '10.0',
|
|
help = 'Radius of top left rounded corner')
|
|
|
|
self.arg_parser.add_argument('--back_right_radius', action = 'store',
|
|
type = float, dest = 'back_right_radius', default = '10.0',
|
|
help = 'Radius of top right rounded corner')
|
|
|
|
self.arg_parser.add_argument('--front_left_radius', action = 'store',
|
|
type = float, dest = 'front_left_radius', default = '10.0',
|
|
help = 'Radius of bottom left rounded corner')
|
|
|
|
self.arg_parser.add_argument('--front_right_radius', action = 'store',
|
|
type = float, dest = 'front_right_radius', default = '10.0',
|
|
help = 'Radius of bottom right rounded corner')
|
|
|
|
self.arg_parser.add_argument('--AutoSize', action = 'store',
|
|
type = inkex.Boolean, dest = 'AutoSizeJoints', default = 'true',
|
|
help = 'Size of finger joints computed from box dimlensions')
|
|
|
|
self.arg_parser.add_argument('--x_joint', action = 'store',
|
|
type = float, dest = 'x_joint', default = '10.0',
|
|
help = 'Size of finger joints in X direction')
|
|
|
|
self.arg_parser.add_argument('--y_joint', action = 'store',
|
|
type = float, dest = 'y_joint', default = '10.0',
|
|
help = 'Size of finger joints in Y direction')
|
|
|
|
self.arg_parser.add_argument('--z_joint', action = 'store',
|
|
type = float, dest = 'z_joint', default = '10.0',
|
|
help = 'Size of finger joints in Z direction')
|
|
|
|
self.arg_parser.add_argument('--Topic', action = 'store',
|
|
type = str, dest = 'TopicPage',
|
|
help = 'Size of finger joints in Z direction')
|
|
|
|
|
|
self.BoundingBox = [0, 0, 0, 0]
|
|
self.HingeList = []
|
|
|
|
try:
|
|
inkex.Effect.unittouu # unitouu has moved since Inkscape 0.91
|
|
except AttributeError:
|
|
try:
|
|
def unittouu(self, unit):
|
|
return inkex.unittouu(unit)
|
|
except AttributeError:
|
|
pass
|
|
|
|
def UpdateBoundingBox(self, Face):
|
|
if Face.BoundingBox[0] < self.BoundingBox[0]:
|
|
self.BoundingBox[0] = Face.BoundingBox[0]
|
|
if Face.BoundingBox[1] < self.BoundingBox[1]:
|
|
self.BoundingBox[1] = Face.BoundingBox[1]
|
|
if Face.BoundingBox[2] > self.BoundingBox[2] - 2:
|
|
self.BoundingBox[2] = Face.BoundingBox[2] + 2
|
|
if Face.BoundingBox[3] > self.BoundingBox[3] - 2:
|
|
self.BoundingBox[3] = Face.BoundingBox[3] + 2
|
|
|
|
def CalcNotchPos(self, n_slot, size_slot):
|
|
'''
|
|
Compute the position of notches for a vertical or horizontal line
|
|
No offset, i.e. position is relative to internal side
|
|
Return a list of positions, each position is a tuple with 3 elements, giving start, size of notch and group number
|
|
These positions are NOT sensitive to burn factor. The burn factor should be added later if needed
|
|
'''
|
|
NPos = []
|
|
if size_slot < 25:
|
|
#Small size, only one notch
|
|
i_notch_number = 1
|
|
notch_size = size_slot / 3 # Notch is center aligned
|
|
elif size_slot < 50:
|
|
#Medium size, draw 5mm notches
|
|
notch_number = size_slot / 5
|
|
if (notch_number % 2) == 0:
|
|
notch_number -= 1 #should be odd
|
|
notch_size = size_slot / notch_number
|
|
i_notch_number = int(notch_number // 2)
|
|
elif size_slot < 120:
|
|
#Medium high size, draw 10mm notches
|
|
notch_number = size_slot / 10
|
|
if (notch_number % 2) == 0:
|
|
notch_number -= 1 #should be odd
|
|
notch_size = size_slot / notch_number
|
|
i_notch_number = int(notch_number // 2)
|
|
elif size_slot < 200:
|
|
#Medium high size, draw 20mm notches
|
|
notch_number = size_slot / 20
|
|
if (notch_number % 2) == 0:
|
|
notch_number -= 1 #should be odd
|
|
notch_size = size_slot / notch_number
|
|
i_notch_number = int(notch_number // 2)
|
|
else:
|
|
#Large size, draw 30mm notches
|
|
notch_number = size_slot / 30
|
|
if (notch_number % 2) == 0:
|
|
notch_number -= 1 #should be odd
|
|
notch_size = size_slot / notch_number
|
|
i_notch_number = int(notch_number // 2)
|
|
for j in range(n_slot):
|
|
#For each slot
|
|
for i in range(i_notch_number):
|
|
NPos.append((j*(size_slot+thickness)+notch_size+2*i*notch_size, notch_size, j)) #Add a tuple with 3 elements for start, size of notch and group number
|
|
return NPos
|
|
|
|
def ComputeJointSize(self, xbox, ybox, zbox, back_left_radius, back_right_radius, front_right_radius, front_left_radius):
|
|
'''
|
|
This function compute finger joint size
|
|
It will try to have identical finger joint, but if not possible we will have different joint sizes
|
|
Basic joint size : if l < 100, size = 5mm, when l > 100 --> size = 0.5*sqrt(l)
|
|
'''
|
|
#First take into account radius
|
|
x = min(xbox - back_left_radius - back_right_radius, xbox - front_right_radius - front_left_radius)
|
|
if x < 18:
|
|
inkex.errormsg('Error: box length too small, should be at least 18mm + round radius')
|
|
CloseDebugFile()
|
|
exit()
|
|
y = min(ybox - back_left_radius - front_left_radius, ybox - front_right_radius - back_right_radius)
|
|
if y < 18:
|
|
inkex.errormsg('Error: box depth too small, should be at least 18mm + round radius')
|
|
CloseDebugFile()
|
|
exit()
|
|
if x <= 100:
|
|
basic_size_x = 5.0
|
|
else:
|
|
basic_size_x = 5.0*math.pow(x/100,0.8)
|
|
if y <= 100:
|
|
basic_size_y = 5.0
|
|
else:
|
|
basic_size_y = 5.0*math.pow(y/100,0.8)
|
|
if zbox <= 100:
|
|
basic_size_z = 5.0
|
|
else:
|
|
basic_size_z = 5.0*math.pow(zbox/100,0.8)
|
|
#DebugMsg("Basic joint sizes (1) :"+str((basic_size_x, basic_size_y, basic_size_z))+' \n')
|
|
#Now try to converge towards a single size
|
|
# First with x and y
|
|
if basic_size_x > basic_size_y and y >= 3.0*basic_size_x + 1:
|
|
#x is greater, but at least 3 joints in y direction (one notch)
|
|
basic_size_y = basic_size_x
|
|
if basic_size_y > basic_size_x and x >= 3.0*basic_size_y + 1:
|
|
#y is greater, but at least 3 joints in x direction (one notch)
|
|
basic_size_x = basic_size_y
|
|
# For z direction, should have at least 3 joint size (one notch)
|
|
if basic_size_x > basic_size_y:
|
|
if zbox > 3*basic_size_x + 1:
|
|
basic_size_z = basic_size_x
|
|
else:
|
|
basic_size_z = (zbox-1) / 3 #If not possible, set max finger size
|
|
else:
|
|
if zbox > 3*basic_size_y + 1:
|
|
basic_size_z = basic_size_y
|
|
else:
|
|
basic_size_z = (zbox-1) / 3 #If not possible, set max finger size
|
|
return(basic_size_x, basic_size_y, basic_size_z)
|
|
|
|
def drawSteelHingeElement(self, idx, thickness, xOffset, yOffset, parent):
|
|
StartOffset = (xOffset, yOffset)
|
|
xOffset -= 2*thickness
|
|
|
|
path = th_inkscape_path((xOffset, yOffset), parent, 'HingeElt_'+str(idx))
|
|
path.MoveTo(0, 0)
|
|
#Start at upper right
|
|
path.LineToVRel(thickness)
|
|
path.LineToHRel(-thickness)
|
|
path.LineToVRel(thickness)
|
|
path.LineToHRel(thickness)
|
|
path.LineToVRel(thickness)
|
|
#Now draw half circle (radius is 1.5*thickness)
|
|
#Position is now 0,3*thickness
|
|
path.Bezier(1.5*thickness*0.551916, 3*thickness, 1.5*thickness, 3*thickness+1.5*thickness*0.551916, 1.5*thickness, 4.5*thickness)
|
|
path.Bezier(1.5*thickness, 4.5*thickness+1.5*thickness*0.551916, 1.5*thickness*(1-0.551916), 6*thickness, 0, 6*thickness)
|
|
#Second part of circle has a radius of 2*thickness
|
|
path.Bezier(-2*thickness*0.551916, 6*thickness, -2*thickness, 6*thickness-2*thickness*0.551916, -2*thickness, 4*thickness)
|
|
path.LineTo(-2*thickness, thickness)
|
|
path.Bezier(-2*thickness, thickness*(1-0.551916), thickness*-1.551916, 0, -thickness, 0)
|
|
path.LineTo(0,0)
|
|
#and last the circle at center for this axis, radius is RadiusSteelHingeAxis mm
|
|
#Change the diameter to allow some space
|
|
locRadiusSteelHingeAxis = RadiusSteelHingeAxis + thickness * RadiusSteelHingeAxisChange
|
|
path.drawCircle(0, 4.5*thickness, locRadiusSteelHingeAxis)
|
|
path.Close()
|
|
path.GenPath()
|
|
if path.xmin < self.BoundingBox[0]:
|
|
self.BoundingBox[0] = path.xmin
|
|
if path.ymin < self.BoundingBox[1]:
|
|
self.BoundingBox[1] = path.ymin
|
|
if path.xmax > self.BoundingBox[2] - 2:
|
|
self.BoundingBox[2] = path.xmax + 2
|
|
if path.ymax > self.BoundingBox[3] - 2:
|
|
self.BoundingBox[3] = path.ymax + 2
|
|
|
|
def BuildTop(self, xbox, ybox, back_left_radius, back_right_radius, front_right_radius, front_left_radius):
|
|
'''
|
|
Draw the top of the box. It depends on the lid style
|
|
'''
|
|
if self.options.lid_type == 'Without' or self.options.lid_type == 'Coffin':
|
|
return # Nothing in this case
|
|
if self.options.lid_type == 'Sliding':
|
|
#Specific case, top is a rectangle which is xbox long and ybox wide with finger joints on top
|
|
#Not compatible with rounded corners on back, so radius is set to 0
|
|
#On top, corner are internal on x and external on y
|
|
#Position is set at 0,0 (first element)
|
|
#There is also a line of finger joints which is xbox long and thickness wide, begin with this one
|
|
TopLineBottomRight = CornerPoint((xbox+2*thickness,thickness), 0, 1, 1)
|
|
TopLineBottomLeft = CornerPoint((0,thickness), 0, 1, 1)
|
|
#Modify Bottom right corner to change start of line
|
|
TopLineBottomRight.x_start_joint -= thickness
|
|
#idem for bottom left
|
|
TopLineBottomLeft.x_end_joint += thickness
|
|
TopLine = BoxFace('Lid_Joints', CornerPoint((0,0), 0, 1, 1),
|
|
0, CornerPoint((xbox+2*thickness,0), 0, 1, 1),
|
|
0, TopLineBottomRight,
|
|
self.x_joint, TopLineBottomLeft,
|
|
0, self.group, [0.0,0.0])
|
|
TopLine.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(TopLine)
|
|
Top = BoxFace('Lid_Top', CornerPoint((0,0), back_left_radius, 1, 0),
|
|
self.x_joint, CornerPoint((xbox,0), back_right_radius, 1, 0),
|
|
0, CornerPoint((xbox,ybox), front_right_radius, 1, 1),
|
|
0, CornerPoint((0,ybox), front_left_radius, 1, 1),
|
|
0, self.group, [-thickness,-self.BoundingBox[3]])
|
|
Top.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(Top)
|
|
return
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
#Specific case, top is a rectangle which is xbox long and ytop_sliding_rounded wide with finger joints on 3 edges
|
|
#The rectangle is a little bit bigger than thickness to allow easy handling.
|
|
TopLine = BoxFace('Lid_Joints', CornerPoint((thickness,0), 0, 1, 1),
|
|
0, CornerPoint((xbox-thickness-SlidingLidSpaceX,0), 0, 1, 1),
|
|
0, CornerPoint((xbox-thickness-SlidingLidSpaceX,thickness*1.5), 0, 1, 1),
|
|
self.x_joint, CornerPoint((thickness,thickness*1.5), 0, 1, 1),
|
|
0, self.group, [0.0,0.0])
|
|
TopLine.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(TopLine)
|
|
Top = BoxFace('Top', CornerPoint((0,0), 0, 1, 1),
|
|
self.x_joint, CornerPoint((xbox,0), 0, 1, 1),
|
|
self.y_joint, CornerPoint((xbox, self.ytop_sliding_rounded), 0, 1, 1),
|
|
0, CornerPoint((0, self.ytop_sliding_rounded), 0, 1, 1),
|
|
self.y_joint, self.group, [-thickness,-self.BoundingBox[3]])
|
|
Top.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(Top)
|
|
return
|
|
|
|
#For all cases except coffin, draw a rounded rectangle with internal corners
|
|
Top = BoxFace('Lid_Top', CornerPoint((0,0), back_left_radius, 1, 1),
|
|
self.x_joint, CornerPoint((xbox,0), back_right_radius, 1, 1),
|
|
self.y_joint, CornerPoint((xbox,ybox), front_right_radius, 1, 1),
|
|
self.x_joint, CornerPoint((0,ybox), front_left_radius, 1, 1),
|
|
self.y_joint, self.group, [0.0, 0.0])
|
|
Top.drawSimpleFace(False)
|
|
if self.options.lid_type == 'Simple':
|
|
#Add a hole in the top, which the same rounded rectangle, but with thickness less in each direction
|
|
TopHole = BoxFace('Lid_Int', CornerPoint((thickness,thickness), back_left_radius-thickness, 1, 1),
|
|
0, CornerPoint((xbox-thickness,thickness), back_right_radius-thickness, 1, 1),
|
|
0, CornerPoint((xbox-thickness,ybox-thickness), front_right_radius-thickness, 1, 1),
|
|
0, CornerPoint((thickness,ybox-thickness), front_left_radius-thickness, 1, 1),
|
|
0, self.group, [0.0, 0.0], Top.path)
|
|
TopHole.drawSimpleFace(False)
|
|
Top.Close() #Close and generate path (both if simple lid)
|
|
self.UpdateBoundingBox(Top)
|
|
if self.options.lid_type == 'Simple':
|
|
#In this case, draw a simple face without notches, external at all corners in both directions
|
|
Top = BoxFace('Lid', CornerPoint((0,0), back_left_radius, 0, 0),
|
|
0, CornerPoint((xbox,0), back_right_radius, 0, 0),
|
|
0, CornerPoint((xbox,ybox), front_right_radius, 0, 0),
|
|
0, CornerPoint((0,ybox), front_left_radius, 0, 0),
|
|
0, self.group, [-self.BoundingBox[2]-thickness-2, 0.0])
|
|
Top.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(Top)
|
|
|
|
return
|
|
|
|
def BuildBottom(self, xbox, ybox, back_left_radius, back_right_radius, front_right_radius, front_left_radius):
|
|
'''
|
|
Draw the bottom of the box. It is a rounded rectangle
|
|
Also draw the holes used to secure the internal walls
|
|
Should exchange left and right from top to draw the external face
|
|
'''
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
Bottom = BoxFace('Bottom', CornerPoint((0,0), back_right_radius, 1, 1),
|
|
self.x_joint, CornerPoint((xbox,0), back_left_radius, 1, 1),
|
|
self.y_joint, CornerPoint((xbox,ybox), front_left_radius, 1, 1),
|
|
0, CornerPoint((0,ybox), front_right_radius, 1, 1),
|
|
self.y_joint, self.group, [-self.BoundingBox[2], 0.0]) #Draw it right of top, same Y
|
|
|
|
else:
|
|
Bottom = BoxFace('Bottom', CornerPoint((0,0), back_right_radius, 1, 1),
|
|
self.x_joint, CornerPoint((xbox,0), back_left_radius, 1, 1),
|
|
self.y_joint, CornerPoint((xbox,ybox), front_left_radius, 1, 1),
|
|
self.x_joint, CornerPoint((0,ybox), front_right_radius, 1, 1),
|
|
self.y_joint, self.group, [-self.BoundingBox[2], 0.0]) #Draw it right of top, same Y
|
|
Bottom.drawSimpleFace(False)
|
|
#now the holes used to fix the walls
|
|
#Start with columns, compute holes position
|
|
self.ListNotchColumns = self.CalcNotchPos(self.n_slot_y, self.y_slot_size)
|
|
DebugMsg("List Column Notches:"+str( self.ListNotchColumns)+'\n')
|
|
for i in range(1, self.n_slot_x):
|
|
#For each wall, draw holes corresponding at each notch_y
|
|
for notch in self.ListNotchColumns:
|
|
drawHole(Bottom.path, i*(self.x_slot_size+thickness), notch[0] + thickness, thickness, notch[1], burn)
|
|
|
|
#Then rows
|
|
self.ListNotchRows = self.CalcNotchPos(self.n_slot_x, self.x_slot_size)
|
|
DebugMsg("List Row Notches:"+str( self.ListNotchRows)+'\n')
|
|
|
|
for i in range(1, self.n_slot_y):
|
|
#For each wall, draw holes corresponding at each notch_y
|
|
for notch in self.ListNotchRows:
|
|
drawHole(Bottom.path, notch[0] + thickness, i*(self.y_slot_size+thickness), notch[1], thickness, burn)
|
|
|
|
Bottom.Close()
|
|
self.UpdateBoundingBox(Bottom)
|
|
return
|
|
|
|
def drawColumWall(self, index, n_slot_y, y_slot_size, ListNotchPos, length, zbox, height_percentage, xOffset, yOffset, parent):
|
|
'''
|
|
Draw the face, specific case for columns walls
|
|
This is a specific face with cuts for row walls on top
|
|
'''
|
|
DebugMsg("\nDrawColumWall, index="+str(index)+" n_Slot="+str(n_slot_y)+" Slot_Size="+str(y_slot_size)+" Length="+str(length)+" Height="+str(zbox)+" Percentage="+str(height_percentage)+" Offset="+str((xOffset, yOffset))+'\n')
|
|
path = th_inkscape_path((xOffset-thickness, yOffset), parent, 'COL_WALL_'+str(index+1))
|
|
|
|
actual_height = zbox * height_percentage / 100.0
|
|
VNotchLine1 = NotchLine((length,0,1), (length, actual_height, 1), math.pi/2, self.z_joint ) #Vertical Notch line
|
|
VNotchLine2 = NotchLine((0,actual_height,1), (0, 0, 1), -math.pi/2, self.z_joint ) #Vertical Notch line, reverse
|
|
|
|
|
|
path.MoveTo(0,0)
|
|
#first H line with cut to accomodate with row walls
|
|
for i in range(1, n_slot_y):
|
|
path.LineToHRel(y_slot_size)
|
|
path.LineToVRel(actual_height/2)
|
|
path.LineToHRel(thickness)
|
|
path.LineToVRel(-actual_height/2)
|
|
path.LineTo(length, 0)
|
|
|
|
#Second line (V), this is a notch line
|
|
path.LineTo(length, thickness)
|
|
VNotchLine1.drawNotchLine(path)
|
|
path.LineTo(length, actual_height)
|
|
#Third line (H) with notches, but at specific positions. Use reversed because, draw from right to left
|
|
for Notch in reversed(ListNotchPos):
|
|
path.LineTo(Notch[0]+Notch[1], actual_height)
|
|
path.LineToVRel(thickness)
|
|
path.LineToHRel(-Notch[1])
|
|
path.LineToVRel(-thickness)
|
|
path.LineTo(0, actual_height)
|
|
#and last one
|
|
path.LineTo(0, actual_height-thickness)
|
|
VNotchLine2.drawNotchLine(path)
|
|
path.LineTo(0, 0)
|
|
|
|
#Apply bounding box of path
|
|
DebugMsg("Path Bounding box="+str(((path.xmin, path.ymin), (path.xmax, path.ymax)))+'\n')
|
|
if path.xmin < self.BoundingBox[0]:
|
|
self.BoundingBox[0] = path.xmin
|
|
if path.ymin < self.BoundingBox[1]:
|
|
self.BoundingBox[1] = path.ymin
|
|
if path.xmax > self.BoundingBox[2] - 2:
|
|
self.BoundingBox[2] = path.xmax + 2
|
|
if path.ymax > self.BoundingBox[3] - 2:
|
|
self.BoundingBox[3] = path.ymax + 2
|
|
|
|
#Close the path
|
|
path.Close()
|
|
path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
|
|
def drawRowWall(self, index, n_slot_x, x_slot_size, ListNotchPos, length, zbox, height_percentage, xOffset, yOffset, parent):
|
|
'''
|
|
Draw the face, specific case for row walls
|
|
This is a specific face with cuts for columns walls on bottom
|
|
index : index of Row wall (0..nSlot-1)
|
|
n_slot_x : number of slots (columns) to draw specific cuts for the column wall
|
|
x_slot_size
|
|
ListNotchPos : Position of notches
|
|
'''
|
|
DebugMsg("\nDrawRowWall, index="+str(index)+" n_Slot="+str(n_slot_x)+" Slot_Size="+str(x_slot_size)+" Length="+str(length)+" Height="+str(zbox)+" Offset="+str((xOffset, yOffset))+'\n')
|
|
path = th_inkscape_path((xOffset-thickness, yOffset), parent, 'ROW_WALL_'+str(index+1))
|
|
actual_height = zbox * height_percentage / 100.0
|
|
|
|
VNotchLine1 = NotchLine((length,0,1), (length, actual_height, 1), math.pi/2, self.z_joint ) #Vertical Notch line
|
|
VNotchLine2 = NotchLine((0,actual_height,1), (0, 0, 1), -math.pi/2, self.z_joint ) #Vertical Notch line, reverse
|
|
|
|
|
|
path.MoveTo(0,0)
|
|
|
|
#first H line (top) without cut, so up to length
|
|
path.LineTo(length, 0)
|
|
|
|
#Second line (V), this is a notch line
|
|
path.LineTo(length, thickness)
|
|
VNotchLine1.drawNotchLine(path)
|
|
path.LineTo(length, actual_height)
|
|
#Third line (bottom H) with notches, but at specific positions. Use reversed because, draw from right to left, also cut openings for columns
|
|
# At each change of group, draw a cut
|
|
group_num = n_slot_x - 1
|
|
for Notch in reversed(ListNotchPos):
|
|
if group_num != Notch[2]: # Change of group, draw cut (up to half of the piece)
|
|
path.LineTo(group_num * (x_slot_size + thickness) , actual_height)
|
|
path.LineToVRel(-actual_height/2)
|
|
path.LineToHRel(-thickness)
|
|
path.LineToVRel(actual_height/2)
|
|
group_num = Notch[2] #Change group for next pass
|
|
path.LineTo(Notch[0]+Notch[1], actual_height)
|
|
path.LineToVRel(thickness)
|
|
path.LineToHRel(-Notch[1])
|
|
path.LineToVRel(-thickness)
|
|
path.LineTo(0, actual_height)
|
|
#and last one
|
|
path.LineTo(0, actual_height-thickness)
|
|
VNotchLine2.drawNotchLine(path)
|
|
path.LineTo(0, 0)
|
|
|
|
#Apply bounding box of path
|
|
DebugMsg("Path Bounding box="+str(((path.xmin, path.ymin), (path.xmax, path.ymax)))+'\n')
|
|
if path.xmin < self.BoundingBox[0]:
|
|
self.BoundingBox[0] = path.xmin
|
|
if path.ymin < self.BoundingBox[1]:
|
|
self.BoundingBox[1] = path.ymin
|
|
if path.xmax > self.BoundingBox[2] - 2:
|
|
self.BoundingBox[2] = path.xmax + 2
|
|
if path.ymax > self.BoundingBox[3] - 2:
|
|
self.BoundingBox[3] = path.ymax + 2
|
|
|
|
#Close the path
|
|
path.Close()
|
|
path.GenPath()
|
|
#DebugMsg("Closing path, BoundingBox="+str(self.BoundingBox)+'\n')
|
|
|
|
def drawCoffinSide(self, FlagRight, ybox, zlid, z_dome_lid, xOffset, yOffset, parent):
|
|
'''
|
|
Draw the sides of the coffin style lid.
|
|
This is a rectangle ybox x zlid with an ellipse (ybox, z_dome_lid) on top of the rectangle
|
|
There a "normal notches on the rectangle, then small notches on the ellipse, because the "front/top/Back" part will be flex
|
|
'''
|
|
DebugMsg("\ndrawCoffinSide, FlagRight="+str(FlagRight)+" ybox="+str(ybox)+" zlid="+str(zlid)+" z_dome_lid="+str(z_dome_lid)+'\n')
|
|
name = 'Lid_Left'
|
|
if FlagRight=='Right':
|
|
name = 'Lid_Right'
|
|
#Change offset in y direction because this one will be drawn from bottom left.
|
|
path = th_inkscape_path((xOffset-thickness, yOffset-zlid - z_dome_lid-thickness), parent, name)
|
|
#First build the notch lines for the rectangle
|
|
VNotchLine1 = NotchLine((0,0,1), (0, -zlid, 1), -math.pi/2, self.z_joint ) #Vertical Notch line (left side)
|
|
VNotchLine2 = NotchLine((ybox,-zlid,1), (ybox, 0, 1), math.pi/2, self.z_joint ) #Vertical Notch line, right side
|
|
|
|
#First point on (0,0) : bottom/left of the lid
|
|
path.MoveTo(0, 0)
|
|
#The draw left notch line
|
|
VNotchLine1.drawNotchLine(path)
|
|
#The draw the notched ellipse, this ellipse has parameters ybox/2 and z_dome_lid
|
|
TopLid = Ellipse(ybox/2.0, z_dome_lid)
|
|
TopLid.drawNotchedEllipse(path, math.pi, 2*math.pi, (0, -zlid))
|
|
#Now the second Notch line
|
|
VNotchLine2.drawNotchLine(path)
|
|
#And end with bottom line (straight)
|
|
path.LineTo(0,0)
|
|
#Apply bounding box of path
|
|
DebugMsg("Path Bounding box="+str(((path.xmin, path.ymin), (path.xmax, path.ymax)))+'\n')
|
|
if path.xmin < self.BoundingBox[0]:
|
|
self.BoundingBox[0] = path.xmin
|
|
if path.ymin < self.BoundingBox[1]:
|
|
self.BoundingBox[1] = path.ymin
|
|
if path.xmax > self.BoundingBox[2] - 2:
|
|
self.BoundingBox[2] = path.xmax + 2
|
|
if path.ymax > self.BoundingBox[3] - 2:
|
|
self.BoundingBox[3] = path.ymax + 2
|
|
|
|
path.Close()
|
|
path.GenPath()
|
|
|
|
def drawCoffinTop(self, xbox, ybox, zlid, z_dome_lid, xOffset, yOffset, parent):
|
|
'''
|
|
Draw the top of the coffin style lid.
|
|
This is 2 rectangle xbox x zlid separated by a flex pattern which has the length half of the ellipse (ybox, z_dome_lid), flex height is xbox
|
|
'''
|
|
DebugMsg("\ndrawCoffinTop, xbox="+str(xbox)+" ybox="+str(ybox)+" zlid="+str(zlid)+" z_dome_lid="+str(z_dome_lid)+'\n')
|
|
#Change offset in y direction because this one will be drawn from bottom left.
|
|
path = th_inkscape_path((xOffset, yOffset - thickness), parent, 'Coffin_Top')
|
|
DebugMsg("Offset ="+str((xOffset, yOffset))+" Path_Offset="+str((path.offsetX, path.offsetY))+'\n')
|
|
#Create the ellipse object used to draw the flex
|
|
FlexBand = Ellipse(ybox/2.0, z_dome_lid)
|
|
FlexBand.Compute_Ellipse_Params(math.pi, 2*math.pi)
|
|
l = FlexBand.length_ellipse
|
|
#First build the notch lines for the rectangle
|
|
HNotchLine1 = NotchLine((zlid, xbox+thickness, 0), (0, xbox+thickness, 0), math.pi, self.z_joint ) #Horizontal Notch line, bottom left
|
|
HNotchLine2 = NotchLine((0,-thickness,0), (zlid, -thickness, 0), 0, self.z_joint ) #Horizontal Notch line, top left
|
|
HNotchLine3 = NotchLine((zlid+l, xbox+thickness, 1), (2*zlid+l, xbox+thickness, 1), 0, self.z_joint ) #Horizontal Notch line, bottom right
|
|
HNotchLine4 = NotchLine((2*zlid+l, -thickness, 1), (zlid+l, -thickness, 1), math.pi, self.z_joint ) #Horizontal Notch line, bottom left
|
|
|
|
#In order to minimize move effects, draw the holes for the hinge first
|
|
#Draw holes for the hinge(s)
|
|
for Hinge in self.HingeList:
|
|
HingePos = Hinge[2] + 2*thickness
|
|
path.MoveTo(3.5*thickness, HingePos + 0.5*SteelHingeSpacing)
|
|
path.LineToVRel(thickness)
|
|
path.LineToHRel(thickness)
|
|
path.LineToVRel(-thickness)
|
|
path.LineToHRel(-thickness)
|
|
path.MoveTo(3.5*thickness, HingePos + 2*thickness + 1.5*SteelHingeSpacing)
|
|
path.LineToVRel(thickness)
|
|
path.LineToHRel(thickness)
|
|
path.LineToVRel(-thickness)
|
|
path.LineToHRel(-thickness)
|
|
|
|
#First point on (zlid,0) : bottom/left of the lid
|
|
path.MoveTo(zlid, xbox+thickness)
|
|
#The draw left notch line
|
|
HNotchLine1.drawNotchLine(path)
|
|
#The draw the bottom line with cuts for the hinge(s)
|
|
#Now draw holes for the hinge(s), reverse because draw from right to left
|
|
for Hinge in reversed(self.HingeList):
|
|
HingePos = Hinge[2] + thickness
|
|
#First H line up to end of 2nd hinge
|
|
path.LineTo(0, HingePos + 5*thickness + 2.5*SteelHingeSpacing)
|
|
#Then Hinge
|
|
path.LineToHRel(1.5*thickness + 0.5*SteelHingeSpacing)
|
|
path.LineToVRel(-thickness - SteelHingeSpacing)
|
|
path.LineToHRel(thickness - 0.5*SteelHingeSpacing)
|
|
path.LineToVRel(-thickness)
|
|
path.LineToHRel(-thickness + 0.5*SteelHingeSpacing)
|
|
path.LineToVRel(-thickness - SteelHingeSpacing)
|
|
path.LineToHRel(thickness - 0.5*SteelHingeSpacing)
|
|
path.LineToVRel(-thickness)
|
|
path.LineToHRel(-thickness + 0.5*SteelHingeSpacing)
|
|
path.LineToVRel(-thickness - SteelHingeSpacing)
|
|
path.LineToHRel(-1.5*thickness - 0.5*SteelHingeSpacing)
|
|
#Then draw up to corner
|
|
path.LineTo(0, -thickness)
|
|
#Now the second Notch line
|
|
HNotchLine2.drawNotchLine(path)
|
|
#Then the flex band
|
|
FlexBand.drawFlexEllipse(path, xbox, self.options.SkipFlexLines, (zlid, -thickness))
|
|
#Then the third notch line
|
|
HNotchLine3.drawNotchLine(path)
|
|
#Then the straight line up to the next corner (top right)
|
|
path.LineTo(2*zlid+l, -thickness)
|
|
#And the last line
|
|
HNotchLine4.drawNotchLine(path)
|
|
#Apply bounding box of path
|
|
DebugMsg("Path Bounding box="+str(((path.xmin, path.ymin), (path.xmax, path.ymax)))+'\n')
|
|
if path.xmin < self.BoundingBox[0]:
|
|
self.BoundingBox[0] = path.xmin
|
|
if path.ymin < self.BoundingBox[1]:
|
|
self.BoundingBox[1] = path.ymin
|
|
if path.xmax > self.BoundingBox[2] - 2:
|
|
self.BoundingBox[2] = path.xmax + 2
|
|
if path.ymax > self.BoundingBox[3] - 2:
|
|
self.BoundingBox[3] = path.ymax + 2
|
|
path.GenPath()
|
|
|
|
def drawRoundedSlidindLid(self, w_lid, l_lid, xOffset, yOffset, parent):
|
|
'''
|
|
Draw the rounded sliding lid.
|
|
This is a rectangle made of flex which is w_lid wide and l_lid long.
|
|
There are notches on one width long edge, but not on the other edges
|
|
'''
|
|
DebugMsg("\ndrawRoundedSlidindLid, w_lid="+str(w_lid)+" l_lid="+str(l_lid)+'\n')
|
|
#Change offset in y direction because this one will be drawn from bottom left.
|
|
path = th_inkscape_path((xOffset, yOffset - thickness), parent, 'Sliding_Top')
|
|
DebugMsg("Offset ="+str((xOffset, yOffset))+" Path_Offset="+str((path.offsetX, path.offsetY))+'\n')
|
|
|
|
#First build the notch line for the rectangle
|
|
NotchLine1 = NotchLine((0, w_lid-thickness, 0), (0, thickness, 0), -math.pi/2, self.z_joint ) #Vertical Notch line, left edge, external
|
|
#Then draw the rectangle
|
|
path.MoveTo(0, w_lid-thickness)
|
|
NotchLine1.drawNotchLine(path)
|
|
DebugMsg("After Notches pos="+str((path.x_noff, path.y_noff))+'\n')
|
|
path.LineToHRel(thickness)
|
|
path.LineToVRel(-thickness)
|
|
#Then the top H Line
|
|
path.LineTo(l_lid, 0)
|
|
#Then V Line
|
|
path.LineToVRel(w_lid)
|
|
#Then last H line
|
|
path.LineTo(thickness, w_lid)
|
|
path.LineToVRel(-thickness)
|
|
path.LineTo(0, w_lid-thickness)
|
|
|
|
#Now draw flex lines, first compute flex parameters
|
|
nLines = int(l_lid - thickness) - 1 #One mm free at each end
|
|
delta_x = (l_lid - thickness - 1)/nLines
|
|
TotalHeight = w_lid
|
|
nMark = int( TotalHeight / 50) + 1 #Compute number of lines
|
|
nMark = max(nMark, 2) # At least 2 marks
|
|
#Sizes of short and long lines to make flex
|
|
LongMark = (TotalHeight / nMark) - 2.0 #Long Mark equally divide the height
|
|
ShortMark = LongMark/2 # And short mark should lay at center of long marks
|
|
DebugMsg("\ndrawRoundedSlidindLid, nLines="+str(nLines)+" TotalHeight="+str(TotalHeight)+" nMark="+str(nMark)+" LongMark="+str(LongMark)+" ShortMark="+str(ShortMark)+'\n')
|
|
xpos = thickness + 1
|
|
ypos = 0
|
|
for i in range(nLines):
|
|
if i % 2 == 0:
|
|
#Even number, start with short mark and draw from top to bottom
|
|
GenLinesFlex(xpos, 0, ShortMark, 1, 1, path)
|
|
#Then nMark-1 long Lines
|
|
GenLinesFlex(xpos, ShortMark+2, LongMark, nMark-1, 1, path)
|
|
#And the last short line
|
|
GenLinesFlex(xpos, TotalHeight-ShortMark, ShortMark, 1, 1, path)
|
|
else:
|
|
#odd number draw long lines only, at 1mm from edge
|
|
GenLinesFlex(xpos, w_lid-1, LongMark, nMark, -1, path)
|
|
xpos += delta_x
|
|
|
|
|
|
|
|
#Apply bounding box of path
|
|
DebugMsg("Path Bounding box="+str(((path.xmin, path.ymin), (path.xmax, path.ymax)))+'\n')
|
|
if path.xmin < self.BoundingBox[0]:
|
|
self.BoundingBox[0] = path.xmin
|
|
if path.ymin < self.BoundingBox[1]:
|
|
self.BoundingBox[1] = path.ymin
|
|
if path.xmax > self.BoundingBox[2] - 2:
|
|
self.BoundingBox[2] = path.xmax + 2
|
|
if path.ymax > self.BoundingBox[3] - 2:
|
|
self.BoundingBox[3] = path.ymax + 2
|
|
path.GenPath()
|
|
|
|
|
|
|
|
def effect(self):
|
|
"""
|
|
Draws a card box box, based on provided parameters
|
|
"""
|
|
global burn, thickness
|
|
|
|
# input sanity check
|
|
error = False
|
|
if self.options.thickness < 1 or self.options.thickness > 10:
|
|
inkex.errormsg('Error: thickness should be at least 1mm and less than 10mm')
|
|
error = True
|
|
|
|
if error:
|
|
exit()
|
|
|
|
self.n_slot_x = self.options.n_slot_x
|
|
self.n_slot_y = self.options.n_slot_y
|
|
|
|
|
|
# convert units
|
|
unit = self.options.unit
|
|
|
|
xbox = self.svg.unittouu(str(self.options.x) + unit)
|
|
ybox = self.svg.unittouu(str(self.options.y) + unit)
|
|
zbox = self.svg.unittouu(str(self.options.z) + unit)
|
|
zlid = self.svg.unittouu(str(self.options.z_lid) + unit)
|
|
z_dome_lid = self.svg.unittouu(str(self.options.z_dome_lid) + unit)
|
|
radius_lid = self.svg.unittouu(str(self.options.radius_lid) + unit)
|
|
|
|
if self.options.StraigthCorners:
|
|
back_left_radius = 0
|
|
back_right_radius = 0
|
|
front_right_radius = 0
|
|
front_left_radius = 0
|
|
else:
|
|
back_left_radius = self.svg.unittouu(str(self.options.back_left_radius) + unit)
|
|
back_right_radius = self.svg.unittouu(str(self.options.back_right_radius) + unit)
|
|
front_right_radius = self.svg.unittouu(str(self.options.front_right_radius) + unit)
|
|
front_left_radius = self.svg.unittouu(str(self.options.front_left_radius) + unit)
|
|
|
|
max_radius = max(back_left_radius, back_right_radius, front_right_radius, front_left_radius)
|
|
thickness = self.svg.unittouu(str(self.options.thickness) + unit)
|
|
burn = self.svg.unittouu(str(self.options.burn) + unit)
|
|
|
|
self.x_joint = self.svg.unittouu(str(self.options.x_joint) + unit)
|
|
self.y_joint = self.svg.unittouu(str(self.options.y_joint) + unit)
|
|
self.z_joint = self.svg.unittouu(str(self.options.z_joint) + unit)
|
|
|
|
self.x_slot_size = (xbox - (1+self.n_slot_x)*thickness)/self.n_slot_x
|
|
self.y_slot_size = (ybox - (1+self.n_slot_y)*thickness)/self.n_slot_y
|
|
|
|
|
|
|
|
if self.x_slot_size < 18 or self.y_slot_size < 18:
|
|
inkex.errormsg('Error: each slot should be at least 18mm large, here x_slot_size='+str(self.x_slot_size)+ ' y_slot_size='+str(self.y_slot_size))
|
|
CloseDebugFile()
|
|
exit()
|
|
if self.x_slot_size < max_radius or self.y_slot_size < max_radius:
|
|
inkex.errormsg('Error: slot size should be greater than rounded corner radius, here x_slot_size='+str(self.x_slot_size)+ ' y_slot_size='+str(self.y_slot_size))
|
|
CloseDebugFile()
|
|
exit()
|
|
|
|
|
|
svg = self.document.getroot()
|
|
docWidth = self.svg.unittouu(svg.get('width'))
|
|
docHeigh = self.svg.unittouu(svg.attrib['height'])
|
|
|
|
layer = etree.SubElement(svg, 'g')
|
|
layer.set(inkex.addNS('label', 'inkscape'), 'Generic Box')
|
|
layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')
|
|
self.group = etree.SubElement(layer, 'g')
|
|
OpenDebugFile()
|
|
|
|
HasLid = False
|
|
HasNormalLid = False
|
|
#Compute joint size if auto is chosen
|
|
if self.options.AutoSizeJoints:
|
|
self.x_joint, self.y_joint, self.z_joint = self.ComputeJointSize(xbox, ybox, zbox, back_left_radius, back_right_radius, front_right_radius, front_left_radius)
|
|
#Default case, for the top lines, front and back joints are x_joint in size, left and right joints are y_joint in size
|
|
self.front_joint = self.x_joint
|
|
self.back_joint = self.x_joint
|
|
self.right_joint = self.y_joint
|
|
self.left_joint = self.y_joint
|
|
|
|
DebugMsg("Joints size ="+str((self.x_joint, self.y_joint, self.z_joint))+'\n')
|
|
DebugMsg("Slots X N="+str(self.n_slot_x)+" size="+str(self.x_slot_size)+'\n')
|
|
DebugMsg("Slots Y N="+str(self.n_slot_y)+" size="+str(self.y_slot_size)+'\n')
|
|
|
|
#Now, check if internal walls should be drawn
|
|
self.InternalWalls_LR = False
|
|
self.InternalWalls_FB = False
|
|
zbox_internal_walls = zbox #Height of internal walls
|
|
|
|
#If there are slots inside the box, also draw internal walls
|
|
if self.n_slot_x > 1:
|
|
self.InternalWalls_FB = True
|
|
if self.n_slot_y > 1:
|
|
self.InternalWalls_LR = True
|
|
|
|
# If lid is sliding, there are always internal walls left and right
|
|
if self.options.lid_type == 'Sliding':
|
|
self.InternalWalls_LR = True
|
|
zbox += thickness #Also increase box height to take into account the sliding top, but NOT internal walls height
|
|
zbox_internal_walls -= 0.2 #Indeed, reduce internal wall height to ease sliding
|
|
if back_left_radius > 0 or back_right_radius > 0:
|
|
inkex.errormsg('Error: Sliding lid is incompatible with rounded corners on back')
|
|
CloseDebugFile()
|
|
exit()
|
|
self.front_joint = 0 #No joint on front top
|
|
|
|
# If lid is rounded sliding, there are always internal walls left and right
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
if radius_lid > zbox or radius_lid > ybox:
|
|
inkex.errormsg('Error: incorrect radius for sliding lid, should be lower than width and height ')
|
|
CloseDebugFile()
|
|
exit()
|
|
self.InternalWalls_LR = True
|
|
zbox += thickness #Also increase box height to take into account the sliding top, but NOT internal walls height
|
|
zbox_internal_walls -= 0.2 #Indeed, reduce internal wall height to ease sliding
|
|
if back_left_radius > 0 or back_right_radius > 0 or front_left_radius > 0 or front_right_radius:
|
|
inkex.errormsg('Error: Sliding lid is incompatible with rounded corners')
|
|
CloseDebugFile()
|
|
exit()
|
|
self.front_joint = 0 #No joint on front top
|
|
#Check that the dimensions are OK. y_box should be greater than radius_lid*pi/2
|
|
self.radius_back_lid = thickness * 6
|
|
self.ytop_sliding_rounded = ybox - radius_lid
|
|
self.length_sliding_rounded = zbox + radius_lid*(math.pi/2 - 1)
|
|
DebugMsg("Rounded sliding, radius_lid="+str(radius_lid)+", radius_back_lid="+str(self.radius_back_lid)+" ytop_sliding_rounded="+str(self.ytop_sliding_rounded)+" length_sliding_rounded="+str(self.length_sliding_rounded)+"\n")
|
|
if self.length_sliding_rounded > zbox + self.radius_back_lid*(math.pi/2 - 2) + self.ytop_sliding_rounded - 2 * thickness:
|
|
inkex.errormsg('Error: no room for sliding lid, please increase width, should be at least '+str( (radius_lid - self.radius_back_lid)*(math.pi/2 - 1) + 2 * thickness + radius_lid + self.radius_back_lid ))
|
|
CloseDebugFile()
|
|
exit()
|
|
|
|
# If there is no lid, no notches on top
|
|
if self.options.lid_type == 'Without':
|
|
self.front_joint = 0 #No joint on front top
|
|
self.back_joint = 0 #No joint on back top
|
|
self.right_joint = 0 #No joint on right top
|
|
self.left_joint = 0 #No joint on left top
|
|
#As top edges are external, but without notches, just decrease height by thickness
|
|
zbox -= thickness
|
|
|
|
# If this is a real lid, no round corners allowed on back
|
|
if self.options.lid_type == 'WoodHinge' or self.options.lid_type == 'SteelHinge' or self.options.lid_type == 'Coffin':
|
|
if back_left_radius > 0 or back_right_radius > 0:
|
|
inkex.errormsg('Error: real lid option is incompatible with rounded corners on back')
|
|
exit()
|
|
self.front_joint = 0 #No joint on front top
|
|
self.back_joint = 0 #No joint on back top
|
|
self.right_joint = 0 #No joint on right top
|
|
self.left_joint = 0 #No joint on left top
|
|
#As top edges are external, but without notches, just decrease height by thickness
|
|
zbox -= thickness
|
|
zlid -= thickness
|
|
if self.options.lid_type == 'Coffin':
|
|
if front_left_radius > 0 or front_right_radius > 0:
|
|
inkex.errormsg('Error: coffin lid option is incompatible with rounded corners')
|
|
exit()
|
|
HasCoffinlid = True
|
|
HasLid = False
|
|
else:
|
|
HasCoffinlid = False
|
|
HasLid = True
|
|
|
|
if self.options.lid_type == 'SteelHinge' or self.options.lid_type == 'Coffin':
|
|
#Compute placement of hinges
|
|
#First compute hinge width. Each hinge has 5 elements with thickness width whiche should be slighly spaced for the main box elements (3)
|
|
hingeWidth = 5*thickness + 3*SteelHingeSpacing
|
|
if ( hingeWidth > self.x_slot_size - 3 ):
|
|
inkex.errormsg('Error: no space for hinge within slots, slots should be at least '+str(hingeWidth+3)+'mm wide')
|
|
CloseDebugFile()
|
|
exit(1)
|
|
#if the box is small with only one slot in x direction try with only one hinge
|
|
if self.n_slot_x == 1 and self.x_slot_size < 2 * hingeWidth + 30:
|
|
HingePos = (self.x_slot_size - hingeWidth)/2.0
|
|
self.HingeList.append((0, HingePos, HingePos)) # One hinge, starting at the middle of slot 0 (the only one)
|
|
elif self.n_slot_x == 1:
|
|
#One slot, but a large one. 2 hinges about 1/4 - 3/4 of the edge
|
|
HingePos = max(self.x_slot_size/4 - hingeWidth/2, 2)
|
|
if HingePos < 10:
|
|
HingePos = 10
|
|
self.HingeList.append((0, HingePos, HingePos))
|
|
self.HingeList.append((0, self.x_slot_size - HingePos, (self.x_slot_size - HingePos - hingeWidth) ))
|
|
elif self.n_slot_x == 2:
|
|
#in this case place hinge in first and last slot.
|
|
# Exact position depend on slot width, try to place hinge at about 1/3 of the slot
|
|
HingePos = max(self.x_slot_size/3 - hingeWidth/2, 2)
|
|
if HingePos < 8:
|
|
HingePos = max(self.x_slot_size/2.5 - hingeWidth/2, 2) #1/3 is very close from start, so change to 1/2.5
|
|
self.HingeList.append((0, HingePos, HingePos))
|
|
self.HingeList.append((self.n_slot_x-1, self.x_slot_size - HingePos, (self.n_slot_x-1)*(self.x_slot_size+thickness) + (self.x_slot_size - HingePos - hingeWidth) ))
|
|
elif self.n_slot_x <= 6:
|
|
#in this case place hinge in first and last slot.
|
|
# Exact position depend on slot width, try to place hinge at about 1/2 of the slot
|
|
HingePos = (self.x_slot_size - hingeWidth)/2.0
|
|
self.HingeList.append((0, HingePos, HingePos))
|
|
self.HingeList.append((self.n_slot_x-1, self.x_slot_size - HingePos, (self.n_slot_x-1)*(self.x_slot_size+thickness) + (self.x_slot_size - HingePos - hingeWidth) ))
|
|
else:
|
|
#a lot of slots, place hinge in second and before last slot, at center of slots
|
|
HingePos = (self.x_slot_size - hingeWidth)/2.0
|
|
self.HingeList.append((1, HingePos, self.x_slot_size + thickness + HingePos ))
|
|
self.HingeList.append((self.n_slot_x-2, HingePos, (self.n_slot_x-2)*(self.x_slot_size+thickness) + (self.x_slot_size - HingePos - hingeWidth)))
|
|
DebugMsg("Lid with steel hinge\n")
|
|
DebugMsg("Hinge width="+str(hingeWidth)+", Number of hinges="+str(len(self.HingeList))+", Hinge pos="+str(self.HingeList)+"\n")
|
|
|
|
|
|
#Draw external faces which are planes, begin with top (no top for rounded sliding or open or coffin)
|
|
|
|
DebugMsg("\n\nBuild TOP\n")
|
|
self.BuildTop(xbox, ybox, back_left_radius, back_right_radius, front_right_radius, front_left_radius)
|
|
|
|
DebugMsg("\n\nBuild Bottom\n")
|
|
self.BuildBottom(xbox, ybox, back_left_radius, back_right_radius, front_right_radius, front_left_radius)
|
|
|
|
''' Draw sides, which could be rounded (with flex)
|
|
For boxes with lid, draw also the lid, just above the side.
|
|
There are 16 cases
|
|
TL TR BR BL Flex Straight
|
|
0 0 0 0 NO ALL OK
|
|
0 0 0 1 Left → Front Back, Right OK
|
|
0 0 1 0 Front → Right Back, Left OK
|
|
0 0 1 1 Left → Front → Right Back OK
|
|
0 1 0 0 Right → Back Front, Left OK
|
|
0 1 0 1 Right → Back, Left → Front No OK
|
|
0 1 1 0 Front --> Right --> Back Left OK
|
|
0 1 1 1 Left → Front → Right → Back No OK
|
|
1 0 0 0 Back → Left Right, Front OK
|
|
1 0 0 1 Back → Left → Front Right OK
|
|
1 0 1 0 Back → Left, Front → Right No OK
|
|
1 0 1 1 Back → Left → Front → Right No OK
|
|
1 1 0 0 Right → Back → Left Front OK
|
|
1 1 0 1 Right → Back → Left → Front No OK
|
|
1 1 1 0 Front → Right → Back → Left No OK
|
|
1 1 1 1 All Flex No
|
|
'''
|
|
FlexBandList = [] #empty list at init
|
|
RightFace = None
|
|
LeftFace = None
|
|
ypos = -self.BoundingBox[3]
|
|
yposface = ypos
|
|
xpos = 0.0
|
|
LidFace = None
|
|
if front_left_radius == 0 and front_right_radius == 0:
|
|
if HasLid:
|
|
DebugMsg("Draw front lid\n")
|
|
LidFace = BoxFace('Lid_Front', CornerPoint((0,0), 0, 0, 0),
|
|
self.x_joint, CornerPoint((xbox,0), 0, 0, 0),
|
|
self.z_joint, CornerPoint((xbox,zlid), 0, 0, 0),
|
|
self.front_joint, CornerPoint((0,zlid), 0, 0, 0),
|
|
self.z_joint, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
LidFace.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(LidFace) #Now update bounding box, to place back face just below
|
|
yposface = -self.BoundingBox[3]
|
|
if self.options.lid_type != 'SlidingRounded':
|
|
DebugMsg("\nStraight face for front\n")
|
|
#No round, front is straight
|
|
#Front is xbox * zbox, all corners are external in each direction
|
|
Face = BoxFace('Front', CornerPoint((0,0), 0, 0, 0),
|
|
self.front_joint, CornerPoint((xbox,0), 0, 0, 0),
|
|
self.z_joint, CornerPoint((xbox,zbox), 0, 0, 0),
|
|
self.x_joint, CornerPoint((0,zbox), 0, 0, 0),
|
|
self.z_joint, self.group, [xpos, yposface]) #Draw face just below previous drawings
|
|
Face.drawSimpleFace(True)
|
|
xpos = -Face.BoundingBox[2]-2
|
|
self.UpdateBoundingBox(Face) #Now update bounding box
|
|
elif front_left_radius == 0:
|
|
#Rounded corner on Front right
|
|
#Straight corner on Front/left, there is a flex band starting on front left
|
|
if back_right_radius == 0:
|
|
#Straight corner on Front / right, Flex on front --> right, BL to TR
|
|
DebugMsg("\nFlex on front --> Right\n")
|
|
FlexBand = ('Flex_Front_Right', 0, 1, #Draw Front then Right so first element is external and last internal
|
|
(xbox, self.front_joint, front_right_radius, self.x_joint), #Then Front Notch Line and round corner r= front_right_radius
|
|
#Then Right notch line withount rounded corner, the last parameter is used when WoodHinge to draw the top circle
|
|
(ybox, self.right_joint, 0, self.y_joint, self.options.lid_type == 'WoodHinge'))
|
|
FlexBandList.append(FlexBand)
|
|
elif back_left_radius == 0:
|
|
#Straight corner on back left, flex band is front + right + back
|
|
DebugMsg("\nFlex on front --> right --> back\n")
|
|
FlexBand = ('Flex_Front_Right_Back', 0, 0, #Draw Front then Right and Back so first element is external and last external
|
|
(xbox, self.front_joint, front_right_radius, self.x_joint), #Then Front Notch Line and round corner r= front_right_radius
|
|
(ybox, self.right_joint, back_right_radius, self.y_joint), #Then Right notch line and Back/Right rounded corner
|
|
(xbox, self.back_joint, 0, self.x_joint)) #Then Back notch line withount rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
else:
|
|
#flex band is front + right + back + left
|
|
DebugMsg("\nFlex on front --> right --> back --> left\n")
|
|
FlexBand = ('Flex_Front_Right_Back_Left', 0, 1, #Draw Front then Right, Back and left so first element is external and last internal
|
|
(xbox, self.front_joint, front_right_radius, self.x_joint), #Then Front Notch Line and round corner r= front_right_radius
|
|
(ybox, self.right_joint, back_right_radius, self.y_joint), #Then Right notch line and Back/Right rounded corner
|
|
(xbox, self.back_joint, back_left_radius, self.x_joint), #Then Back notch line with Back/Left rounded corner
|
|
(ybox, self.left_joint, 0)) #At last, Left line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
|
|
if back_left_radius == 0 and back_right_radius == 0:
|
|
if HasLid:
|
|
DebugMsg("Draw back lid\n")
|
|
LidFace = BoxFace('Lid_Back', CornerPoint((0,0), 0, 0, 0),
|
|
self.x_joint, CornerPoint((xbox,0), 0, 0, 0),
|
|
self.z_joint, CornerPoint((xbox,zlid), 0, 0, 0),
|
|
self.back_joint, CornerPoint((0,zlid), 0, 0, 0),
|
|
self.z_joint, self.group, [xpos, ypos]) #Draw face just right previous drawings
|
|
if self.options.lid_type == 'WoodHinge':
|
|
LidFace.drawLidBackWoodHinge(True)
|
|
else: #This is SteelHinge or Coffin
|
|
LidFace.drawLidBackSteelHinge(self.HingeList, True)
|
|
if yposface == ypos:
|
|
self.UpdateBoundingBox(LidFace) #Now update bounding box, if not already done, to place back face just below
|
|
yposface = -self.BoundingBox[3]
|
|
|
|
#Back is xbox * zbox, all corners are external in each direction
|
|
DebugMsg("\nStraight face for Back\n")
|
|
if self.options.lid_type == 'Sliding':
|
|
#In this case, not a simple face, so we use a specific function. Also, top line is internal in y and external in x
|
|
Face = BoxFace('Back', CornerPoint((0,0), 0, 0, 1),
|
|
self.back_joint, CornerPoint((xbox,0), 0, 0, 1),
|
|
self.z_joint, CornerPoint((xbox,zbox), 0, 0, 0),
|
|
self.x_joint, CornerPoint((0,zbox), 0, 0, 0),
|
|
self.z_joint, self.group, [xpos, yposface]) #Draw face just right from previous one
|
|
Face.drawExternalBackSlidingLid(True)
|
|
elif self.options.lid_type == 'WoodHinge':
|
|
#In this case, not a simple face, so we use a specific function.
|
|
Face = BoxFace('Back', CornerPoint((0,0), 0, 0, 0),
|
|
0, CornerPoint((xbox,0), 0, 0, 0), #No joint here !
|
|
self.z_joint, CornerPoint((xbox,zbox), 0, 0, 0),
|
|
self.x_joint, CornerPoint((0,zbox), 0, 0, 0),
|
|
self.z_joint, self.group, [xpos, yposface]) #Draw face just right from previous one
|
|
Face.drawExternalBackWoodHingeLid(True)
|
|
elif self.options.lid_type == 'SteelHinge' or self.options.lid_type == 'Coffin':
|
|
#In this case, not a simple face, so we use a specific function.
|
|
Face = BoxFace('Back', CornerPoint((0,0), 0, 0, 0),
|
|
0, CornerPoint((xbox,0), 0, 0, 0), #No joint here !
|
|
self.z_joint, CornerPoint((xbox,zbox), 0, 0, 0),
|
|
self.x_joint, CornerPoint((0,zbox), 0, 0, 0),
|
|
self.z_joint, self.group, [xpos, yposface]) #Draw face just right from previous one
|
|
Face.drawExternalBackSteelHingeLid(self.HingeList, True)
|
|
else:
|
|
Face = BoxFace('Back', CornerPoint((0,0), 0, 0, 0),
|
|
self.back_joint, CornerPoint((xbox,0), 0, 0, 0),
|
|
self.z_joint, CornerPoint((xbox,zbox), 0, 0, 0),
|
|
self.x_joint, CornerPoint((0,zbox), 0, 0, 0),
|
|
self.z_joint, self.group, [xpos, yposface]) #Draw face just right from previous one
|
|
Face.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(Face) #Now update bounding box
|
|
xpos = -Face.BoundingBox[2]-2
|
|
elif back_right_radius == 0:
|
|
#Rounded corner on Back left
|
|
#Straight corner on Back/right, there is a flex band starting on back right
|
|
if front_left_radius == 0:
|
|
#Straight corner on front / left, flex band is back + left
|
|
DebugMsg("\nFlex on back --> left\n")
|
|
FlexBand = ('Flex_Back_Left', 0, 1, #Draw Back then Left so first element is external and last internal
|
|
(xbox, self.back_joint, back_left_radius, self.x_joint), #Back Notch Line and round corner r= front_right_radius
|
|
(ybox, self.left_joint, 0, self.y_joint)) #Then Left notch line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
|
|
elif front_right_radius == 0:
|
|
#Straight corner on bottom right, flex band is back + left + front
|
|
DebugMsg("\nFlex on back --> left --> front\n")
|
|
FlexBand = ('Flex_Back_Left_Front', 0, 0, #Draw Back then Left then Front so first element is external and last External
|
|
(xbox, self.back_joint, back_left_radius, self.x_joint), #Back Notch Line and round corner r= front_right_radius
|
|
(ybox, self.left_joint, front_left_radius, self.y_joint), #Then Left notch line and Front/Left rounded corner
|
|
(xbox, self.front_joint, 0, self.x_joint)) #At last, Front line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
else:
|
|
#flex band is back + left + front + right
|
|
DebugMsg("\nFlex on back --> left --> front --> right\n")
|
|
FlexBand = ('Flex_Back_Left_Front_Right', 0, 1, #Draw Back then Left then Front Then Right so first element is external and last Inetrnal
|
|
(xbox, self.back_joint, back_left_radius, self.x_joint), #Back Notch Line and round corner r= front_right_radius
|
|
(ybox, self.left_joint, front_left_radius, self.y_joint), #Then Left notch line and Front/Left rounded corner
|
|
(xbox, self.front_joint, front_right_radius, self.x_joint), #Then Front line with Front/Right rounded corner
|
|
(ybox, self.right_joint, 0, self.y_joint)) #At last Right line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
|
|
|
|
if back_left_radius == 0 and front_left_radius == 0:
|
|
if HasLid:
|
|
DebugMsg("Draw left lid\n")
|
|
LidFace = BoxFace('Lid_Left', CornerPoint((0,0), 0, 1, 0),
|
|
self.y_joint, CornerPoint((ybox,0), 0, 1, 0),
|
|
self.z_joint, CornerPoint((ybox,zlid), 0, 1, 0),
|
|
self.left_joint, CornerPoint((0,zlid), 0, 1, 0),
|
|
self.z_joint, self.group, [xpos, ypos]) #Draw face just right previous drawings
|
|
if self.options.lid_type == 'WoodHinge':
|
|
LidFace.drawLidSideWoodHinge(0, True)
|
|
elif self.options.lid_type == 'SteelHinge': #This is SteelHinge
|
|
LidFace.drawSimpleFace(True)
|
|
# No round for left face
|
|
# Left is ybox * zbox, corners are external in y but internal in x
|
|
DebugMsg("\nStraight face for Left\n")
|
|
if self.options.lid_type == 'Sliding' or self.options.lid_type == 'SlidingRounded' :
|
|
delta_yposface = 2*thickness + 2
|
|
else:
|
|
delta_yposface = 0
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
LeftFace = BoxFace('Left', CornerPoint((0,0), 0, 1, 0, 0),
|
|
self.y_joint, CornerPoint((ybox,0), radius_lid, 1, 0),
|
|
0, CornerPoint((ybox,zbox), 0, 1, 0),
|
|
self.y_joint, CornerPoint((0,zbox), 0, 1, 0),
|
|
self.z_joint, self.group, [xpos, yposface-delta_yposface]) #Draw face just right from previous drawings
|
|
else:
|
|
LeftFace = BoxFace('Left', CornerPoint((0,0), 0, 1, 0, self.options.lid_type == 'WoodHinge'),
|
|
self.left_joint, CornerPoint((ybox,0), 0, 1, 0),
|
|
self.z_joint, CornerPoint((ybox,zbox), 0, 1, 0),
|
|
self.y_joint, CornerPoint((0,zbox), 0, 1, 0),
|
|
self.z_joint, self.group, [xpos, yposface-delta_yposface]) #Draw face just right from previous drawings
|
|
LeftFace.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(LeftFace) #Now update bounding box
|
|
if self.options.lid_type == 'Sliding':
|
|
LeftFace.drawSideLineNotches(xpos, yposface) #Left face is straight
|
|
xpos = -LeftFace.BoundingBox[2]-2
|
|
elif back_left_radius == 0:
|
|
#Rounded corner on Front left
|
|
#Straight corner on Back/left, there is a flex band starting on Back left
|
|
if front_right_radius == 0:
|
|
#Straight corner on Front / Right, flex band is Left + Front
|
|
DebugMsg("\nFlex on Left --> Front\n")
|
|
FlexBand = ('Flex_Left_Front', 1, 0, #Draw Left then Front so first element is internal and last external
|
|
#Left Notch Line and round corner r= front_left_radius, last parameter used when WoodHing to draw top circles
|
|
(ybox, self.left_joint, front_left_radius, self.y_joint, self.options.lid_type == 'WoodHinge'),
|
|
(xbox, self.front_joint, 0, self.x_joint)) #Then Front notch line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
elif back_right_radius == 0:
|
|
#Straight corner on Back right, flex band is Left + Back + Right
|
|
DebugMsg("\nFlex on Left --> Front --> Right\n")
|
|
FlexBand = ('Flex_Left_Front_Right', 1, 1, #Draw Left then Front and Right so first element is internal and last internal
|
|
#Left Notch Line and round corner r= front_left_radius, last parameter used when WoodHing to draw top circles
|
|
(ybox, self.left_joint, front_left_radius, self.y_joint, self.options.lid_type == 'WoodHinge'),
|
|
(xbox, self.front_joint, front_right_radius, self.x_joint), #Then Front notch line with Front/Right rounded corner
|
|
(ybox, self.right_joint, 0, self.y_joint, self.options.lid_type == 'WoodHinge')) #And Right notch line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
else:
|
|
#flex band on Left --> front --> right --> Back
|
|
DebugMsg("\nFlex on Left --> front --> right --> Back\n")
|
|
FlexBand = ('Flex_Left_Front_Right_Back', 1, 0, #Draw Left then Front, Right and Back so first element is internal and last external
|
|
(ybox, self.left_joint, front_left_radius, self.y_joint), #Left Notch Line and round corner r= front_left_radius
|
|
(xbox, self.front_joint, front_right_radius, self.x_joint), #Then Front notch line with Front/Right rounded corner
|
|
(ybox, self.right_joint, back_right_radius, self.y_joint), #And Right notch line with Back/Right rounded corner
|
|
(xbox, self.back_joint, 0, self.x_joint))
|
|
FlexBandList.append(FlexBand)
|
|
|
|
|
|
if back_right_radius == 0 and front_right_radius == 0:
|
|
#Right is the same
|
|
if HasLid:
|
|
DebugMsg("Draw Right lid\n")
|
|
LidFace = BoxFace('Lid_Right', CornerPoint((0,0), 0, 1, 0),
|
|
self.y_joint, CornerPoint((ybox,0), 0, 1, 0),
|
|
self.z_joint, CornerPoint((ybox,zlid), 0, 1, 0),
|
|
self.right_joint, CornerPoint((0,zlid), 0, 1, 0),
|
|
self.z_joint, self.group, [xpos, ypos]) #Draw face just right previous drawings
|
|
if self.options.lid_type == 'WoodHinge':
|
|
LidFace.drawLidSideWoodHinge(1, True)
|
|
elif self.options.lid_type == 'SteelHinge': #This is SteelHinge
|
|
LidFace.drawSimpleFace(True)
|
|
|
|
# Right is ybox * zbox, corners are external in y but internal in x
|
|
DebugMsg("\nStraight face for Right\n")
|
|
if self.options.lid_type == 'Sliding' or self.options.lid_type == 'SlidingRounded':
|
|
delta_yposface = 2*thickness + 2
|
|
else:
|
|
delta_yposface = 0
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
RightFace = BoxFace('Right', CornerPoint((0,0), radius_lid, 1, 0),
|
|
self.y_joint, CornerPoint((ybox,0), 0, 1, 0),
|
|
self.z_joint, CornerPoint((ybox,zbox), 0, 1, 0),
|
|
self.y_joint, CornerPoint((0,zbox), 0, 1, 0),
|
|
0, self.group, [xpos, yposface-delta_yposface]) #Draw face just right from previous drawings
|
|
else:
|
|
RightFace = BoxFace('Right', CornerPoint((0,0), 0, 1, 0),
|
|
self.right_joint, CornerPoint((ybox,0), 0, 1, 0, self.options.lid_type == 'WoodHinge'),
|
|
self.z_joint, CornerPoint((ybox,zbox), 0, 1, 0),
|
|
self.y_joint, CornerPoint((0,zbox), 0, 1, 0),
|
|
self.z_joint, self.group, [xpos, yposface-delta_yposface]) #Draw face just below previous drawings
|
|
RightFace.drawSimpleFace(True)
|
|
if self.options.lid_type == 'Sliding':
|
|
RightFace.drawSideLineNotches(xpos, yposface) #Right face is straight
|
|
self.UpdateBoundingBox(RightFace) #Now update bounding box
|
|
xpos = -RightFace.BoundingBox[2]-2
|
|
elif front_right_radius == 0:
|
|
#Rounded corner on Back right
|
|
#Straight corner on Front right
|
|
if back_left_radius == 0:
|
|
#Straight corner on top / left, flex band is Left + Back
|
|
DebugMsg("\nFlex on Right --> Back\n")
|
|
FlexBand = ( 'Flex_Right_Back', 1, 0, #Draw Right then Back so first element is internal and last external
|
|
(ybox, self.right_joint, back_right_radius, self.y_joint), #Left Notch Line and round corner r= back_right_radius
|
|
(xbox, self.back_joint, 0, self.x_joint)) #Then Back notch line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
elif front_left_radius == 0:
|
|
#Straight corner on Front left, flex band is Right --> Back --> Left
|
|
DebugMsg("\nFlex on Right --> Back --> Left\n")
|
|
FlexBand = ('Flex_Right_Back_Left', 1, 1, #Draw Right then Back and left so first element is internal and last internal
|
|
(ybox, self.right_joint, back_right_radius, self.y_joint), #Left Notch Line and round corner r= back_right_radius
|
|
(xbox, self.back_joint, back_left_radius, self.x_joint), #Then Back notch line with Back/Left rounded corner
|
|
(ybox, self.left_joint, 0, self.y_joint)) #And left Notch line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
else:
|
|
#flex band on Left --> front --> right --> Back --> Front
|
|
DebugMsg("\nFlex on Right --> Back --> Left --> Front\n")
|
|
FlexBand = ('Flex_Right_Back_Left_Front', 1, 1, #Draw Right then Back and left so first element is internal and last internal
|
|
(ybox, self.right_joint, back_right_radius, self.y_joint), #Left Notch Line and round corner r= back_right_radius
|
|
(xbox, self.back_joint, back_left_radius, self.x_joint), #Then Back notch line with Back/Left rounded corner
|
|
(ybox, self.left_joint, front_left_radius, self.y_joint), #Then left Notch line with Front/Left rounded corner
|
|
(xbox, self.front_joint, 0, self.x_joint)) #And Front notch line without rounded corner
|
|
FlexBandList.append(FlexBand)
|
|
|
|
if front_right_radius > 0 and back_right_radius > 0 and back_left_radius > 0 and front_left_radius > 0:
|
|
#Specific case, all corners are rounded
|
|
DebugMsg("\n\nFlex on all faces\n")
|
|
FlexBand = ('Flex_All', 1, 1, #Draw flex all around the box with clips
|
|
(xbox, self.back_joint, back_right_radius, self.x_joint), #(Half) Back Notch Line and round corner r= back_right_radius
|
|
(ybox, self.right_joint, front_right_radius, self.y_joint), #Then Right notch line with Front/Right rounded corner
|
|
(xbox, self.front_joint, front_left_radius, self.x_joint), #Then front notch line with Front/Left rounded corner
|
|
(ybox, self.left_joint, back_left_radius, self.y_joint), #Then Laft notch line with Back/Left rounded corner
|
|
(xbox, self.back_joint, back_right_radius, self.x_joint)) #And another back line, (half)
|
|
Face = FlexFace(FlexBand, 0, zbox, self.z_joint, self.group, [xpos, ypos])
|
|
Face.drawRoundedFlexFace(True)
|
|
self.UpdateBoundingBox(Face) #Now update bounding box
|
|
else:
|
|
for FlexBand in FlexBandList:
|
|
if HasLid:
|
|
FaceLid = FlexFace(FlexBand, 1, zlid, self.z_joint, self.group, [xpos, ypos])
|
|
FaceLid.drawFlexFace(True)
|
|
if yposface == ypos:
|
|
yposface = ypos - FaceLid.BoundingBox[3] - 2
|
|
Face = FlexFace(FlexBand, 0, zbox, self.z_joint, self.group, [xpos, yposface])
|
|
Face.drawFlexFace(True)
|
|
xpos -= Face.BoundingBox[2] + 2
|
|
|
|
#if sliding top, generate specific elements to let the lid slide
|
|
if self.options.lid_type == 'Sliding':
|
|
if len(FlexBandList) > 0:
|
|
#Case with flex
|
|
#This code works because with sliding top, there is AT MOST one flex band.
|
|
Face.drawSideLineNotches()
|
|
self.UpdateBoundingBox(Face) #Now update bounding box
|
|
|
|
ypos = -self.BoundingBox[3]
|
|
xpos = 0.0
|
|
|
|
# If coffin draw the lid here
|
|
if self.options.lid_type == 'Coffin':
|
|
self.drawCoffinSide('Left', ybox, zlid+thickness, z_dome_lid, xpos, ypos, self.group)
|
|
xpos -= ybox + 2*thickness + 2
|
|
self.drawCoffinSide('Right', ybox, zlid+thickness, z_dome_lid, xpos, ypos, self.group)
|
|
xpos -= ybox + 2*thickness + 2
|
|
self.drawCoffinTop(xbox, ybox, zlid+thickness, z_dome_lid, xpos, ypos, self.group)
|
|
|
|
ypos = -self.BoundingBox[3]
|
|
xpos = 0.0
|
|
# Then draw internal walls
|
|
# First Back and front
|
|
# Rectangle with joints on sides, not on top and bottom
|
|
#
|
|
if self.InternalWalls_FB:
|
|
DebugMsg("\nDrawing Internal Back\n")
|
|
if self.InternalWalls_LR:
|
|
left_joint = self.z_joint
|
|
else:
|
|
left_joint = 0 #Only draw joints if there is a left side !
|
|
#If rounded corner, shorten size by radius, if not by thickness
|
|
if back_left_radius > 0:
|
|
left_joint = 0
|
|
d1 = back_left_radius
|
|
else:
|
|
d1 = thickness
|
|
if self.InternalWalls_LR:
|
|
right_joint = self.z_joint
|
|
else:
|
|
right_joint = 0 #Only draw joints if there is a right side !
|
|
#If rounded corner, shorten size by radius, if not by thickness
|
|
if back_right_radius > 0:
|
|
right_joint = 0
|
|
d2 = back_right_radius
|
|
else:
|
|
d2 = thickness
|
|
|
|
InternalBack = BoxFace('Int_Back', CornerPoint((0,0), 0, 0, 1), #First corner, external on X, internal on Y sides
|
|
0, CornerPoint((xbox-d1-d2,0), 0, 0, 1),
|
|
right_joint, CornerPoint((xbox-d1-d2, zbox_internal_walls), 0, 0, 1),
|
|
0, CornerPoint((0,zbox_internal_walls), 0, 0, 1),
|
|
left_joint, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
if self.options.lid_type == 'SteelHinge' or self.options.lid_type == 'Coffin':
|
|
#Special case, should cut some spce for the hinge in the back, so add the last parameter
|
|
InternalBack.drawFaceWithHoles(self.n_slot_x, self.x_slot_size, d1 - thickness, self.z_joint, self.options.h_slot, True, self.HingeList)
|
|
else:
|
|
InternalBack.drawFaceWithHoles(self.n_slot_x, self.x_slot_size, d1 - thickness, self.z_joint, self.options.h_slot, True)
|
|
xpos = -InternalBack.BoundingBox[2]-2
|
|
|
|
|
|
if self.InternalWalls_LR:
|
|
left_joint = self.z_joint
|
|
else:
|
|
left_joint = 0 #Only draw joints if there is a left side !
|
|
if front_left_radius > 0:
|
|
left_joint = 0
|
|
d1 = front_left_radius
|
|
else:
|
|
d1 = thickness
|
|
if self.InternalWalls_LR:
|
|
right_joint = self.z_joint
|
|
else:
|
|
right_joint = 0 #Only draw joints if there is a right side !
|
|
if front_right_radius > 0:
|
|
right_joint = 0
|
|
d2 = front_right_radius
|
|
else:
|
|
d2 = thickness
|
|
DebugMsg("\nDrawing Internal Front\n")
|
|
InternalFront = BoxFace('Int_Front', CornerPoint((0,0), 0, 0, 1), #First corner, external on X, internal on Y sides
|
|
0, CornerPoint((xbox-d1-d2,0), 0, 0, 1),
|
|
right_joint, CornerPoint((xbox-d1-d2, zbox_internal_walls), 0, 0, 1),
|
|
0, CornerPoint((0,zbox_internal_walls), 0, 0, 1),
|
|
left_joint, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
InternalFront.drawFaceWithHoles(self.n_slot_x, self.x_slot_size, d1 - thickness, self.z_joint, self.options.h_slot, True)
|
|
xpos = -InternalFront.BoundingBox[2]-2
|
|
|
|
# Then Left and right internal walls if needed.
|
|
if self.InternalWalls_LR:
|
|
DebugMsg("\nDrawing Internal Left\n")
|
|
if self.InternalWalls_FB:
|
|
left_joint = self.z_joint
|
|
else:
|
|
left_joint = 0 #Only draw joints if there is a left side !
|
|
if back_left_radius > 0:
|
|
left_joint = 0
|
|
d1 = back_left_radius
|
|
else:
|
|
d1 = thickness
|
|
if self.InternalWalls_FB:
|
|
right_joint = self.z_joint
|
|
else:
|
|
right_joint = 0 #Only draw joints if there is a right side !
|
|
if front_left_radius > 0:
|
|
right_joint = 0
|
|
d2 = front_left_radius
|
|
else:
|
|
d2 = thickness
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
InternalLeft = BoxFace('Int_Left', CornerPoint((0,0), self.radius_back_lid, 1, 0), #First corner, internal x, external y
|
|
0, CornerPoint((ybox,0), radius_lid, 1, 0),
|
|
0, CornerPoint((ybox, zbox), 0, 1, 1), #internal both directions
|
|
0, CornerPoint((0,zbox), 0, 1, 1),
|
|
self.z_joint, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
InternalLeft.drawFaceInternalSlidingLeft(True) #Left side
|
|
else:
|
|
InternalLeft = BoxFace('Int_Left', CornerPoint((0,0), 0, 1, 1), #First corner, internal on both sides
|
|
0, CornerPoint((ybox-d1-d2,0), 0, 1, 1),
|
|
right_joint, CornerPoint((ybox-d1-d2, zbox_internal_walls), 0, 1, 1),
|
|
0, CornerPoint((0,zbox_internal_walls), 0, 1, 1),
|
|
left_joint, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
InternalLeft.drawFaceWithHoles(self.n_slot_y, self.y_slot_size, d1 - thickness, self.z_joint, self.options.h_slot, True)
|
|
xpos = -InternalLeft.BoundingBox[2]-2
|
|
|
|
|
|
if self.InternalWalls_FB:
|
|
left_joint = self.z_joint
|
|
else:
|
|
left_joint = 0 #Only draw joints if there is a left side !
|
|
if front_right_radius > 0:
|
|
left_joint = 0
|
|
d1 = front_right_radius
|
|
else:
|
|
d1 = thickness
|
|
if self.InternalWalls_FB:
|
|
right_joint = self.z_joint
|
|
else:
|
|
right_joint = 0 #Only draw joints if there is a right side !
|
|
if back_right_radius > 0:
|
|
right_joint = 0
|
|
d2 = back_right_radius
|
|
else:
|
|
d2 = thickness
|
|
DebugMsg("\nDrawing Internal Right\n")
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
InternalRight = BoxFace('Int_Right', CornerPoint((0,0), radius_lid, 1, 0), #First corner, internal x, external y
|
|
0, CornerPoint((ybox,0), self.radius_back_lid, 1, 0),
|
|
self.z_joint, CornerPoint((ybox, zbox), 0, 1, 1), #internal both directions
|
|
0, CornerPoint((0,zbox), 0, 1, 1),
|
|
0, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
InternalRight.drawFaceInternalSlidingRight(True) #Right side
|
|
else:
|
|
InternalRight = BoxFace('Int_Right', CornerPoint((0,0), 0, 1, 1), #First corner, internal on both sides
|
|
0, CornerPoint((ybox-d1-d2,0), 0, 1, 1),
|
|
right_joint, CornerPoint((ybox-d1-d2, zbox_internal_walls), 0, 1, 1),
|
|
0, CornerPoint((0,zbox_internal_walls), 0, 1, 1),
|
|
left_joint, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
InternalRight.drawFaceWithHoles(self.n_slot_y, self.y_slot_size, d1 - thickness, self.z_joint, self.options.h_slot, True)
|
|
|
|
xpos = -InternalRight.BoundingBox[2]-2
|
|
self.UpdateBoundingBox(InternalRight) #Now update bounding box
|
|
elif self.InternalWalls_FB:
|
|
#Udate bounding box with front and back value
|
|
self.UpdateBoundingBox(InternalFront) #Now update bounding box
|
|
|
|
if self.options.lid_type == 'SlidingRounded':
|
|
#Draw the internal wall at the back used to "protect" the sliding lid inside the box
|
|
InternalProtection = BoxFace('Int_Back', CornerPoint((0,0), 0, 1, 1), #First corner, internal x, internal y
|
|
0, CornerPoint((xbox-2*thickness,0), 0, 1, 1),
|
|
self.z_joint, CornerPoint((xbox-2*thickness, zbox-self.radius_back_lid-thickness), 0, 1, 1), #internal both directions
|
|
0, CornerPoint((0,zbox-self.radius_back_lid-thickness), 0, 1, 1),
|
|
self.z_joint, self.group, [xpos, ypos]) #Draw face just below previous drawings
|
|
InternalProtection.drawSimpleFace(True)
|
|
self.UpdateBoundingBox(InternalProtection) #Now update bounding box
|
|
ypos = -self.BoundingBox[3]
|
|
xpos = 0.0
|
|
#And draw the sliding lid
|
|
self.drawRoundedSlidindLid(xbox-SlidingLidSpaceX, self.length_sliding_rounded, xpos, ypos, self.group)
|
|
|
|
#Then internal walls
|
|
#Columns first
|
|
xpos = 0
|
|
ypos = -self.BoundingBox[3]
|
|
|
|
for i in range(self.n_slot_x-1):
|
|
self.drawColumWall(i, self.n_slot_y, self.y_slot_size, self.ListNotchColumns, ybox-2*thickness, zbox_internal_walls, self.options.h_slot, xpos, ypos, self.group)
|
|
xpos -= ybox + 2 #Next position for drawing
|
|
|
|
#Then rows, nearly the same, but opening at the bottom edge
|
|
|
|
xpos = 0
|
|
ypos -= zbox_internal_walls + thickness + 2
|
|
for i in range(self.n_slot_y-1):
|
|
self.drawRowWall(i, self.n_slot_x, self.x_slot_size, self.ListNotchRows, xbox-2*thickness, zbox_internal_walls, self.options.h_slot, xpos, ypos, self.group)
|
|
xpos -= xbox + 2 #Next position for drawing
|
|
|
|
#
|
|
if self.options.lid_type == 'SteelHinge' or self.options.lid_type == 'Coffin':
|
|
#the elements of the hinge
|
|
HingeNum = 0
|
|
ypos = -self.BoundingBox[3] - 2
|
|
xpos = -2
|
|
for Hinge in self.HingeList:
|
|
for i in range(5):
|
|
self.drawSteelHingeElement(HingeNum*5+i, thickness, xpos, ypos, self.group)
|
|
xpos -= 3.5*thickness + 2
|
|
HingeNum += 1
|
|
xpos -= 3
|
|
|
|
|
|
CloseDebugFile()
|
|
|
|
|
|
# Create effect instance and apply it.
|
|
effect = GenericBox()
|
|
effect.run()
|