cyclone-pcb-factory/Software/Replath/pyRepRap/build/lib.linux-x86_64-2.7/reprap/shapeplotter.py

304 lines
10 KiB
Python

"""
This module plots many shapes a polygon objects containing a series of lines
The Polygon object can be found in reprap.toolpath
"""
# Python module properties
__author__ = "Stefan Blanke (greenarrow) (greenarrow@users.sourceforge.net)"
__license__ = "GPL 3.0"
__credits__ = "Author of potrace"
__licence__ = """
pyRepRap is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
pyRepRap is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with pyRepRap. If not, see <http://www.gnu.org/licenses/>.
"""
import math, os
import toolpath
# Fill modes
FILL_LOCUS = 1
FILL_LINES = 2
debug = False
def line(line):
"""Returns polygon for line (x1, y2, x2, y2) as a Polygon object"""
poly = toolpath.Polygon()
x1, y1, x2, y2 = line
poly.addPoint( toolpath.Point(x1, y1) )
poly.addPoint( toolpath.Point(x2, y2) )
return poly
def point(point):
"""Returns polygon for point (x, y) as a Polygon Object"""
poly = toolpath.Polygon()
x, y = point
poly.addPoint( toolpath.Point(x, y) )
return poly
def arc(x, y, radius, startAngle, endAngle, resolution):
"""Returns polygon an arc with x, y, radius, start angle (radians), end engle (radians) and resolution (lines per mm) a Polygon object"""
# This function works in degrees but takes parameters in radians
poly = toolpath.Polygon()
if debug: print "Plotting arc at", x, y, "from", startAngle, "(", math.degrees(startAngle), ") to", endAngle, "(", math.degrees(endAngle), ")"
startAngle, endAngle = math.degrees(startAngle), math.degrees(endAngle)
circumference = float(2) * math.pi * float(radius)
angleDiv = ( float(360) / float( circumference * resolution ) )# + ( 360 % int( circumference * resolution ) )
lastX, lastY = _calcCircle( startAngle, radius )
# compensate for arc going beyond 360 deg
if startAngle > endAngle:
endAngle += 360
# make detail proportional to radius to always give good resolution
for theta in _frange( startAngle, endAngle + angleDiv, angleDiv ):
cx, cy = _calcCircle(theta, radius)
poly.addPoint( toolpath.Point(x + cx, y + cy) )
return poly
def circle(x, y, radius, resolution, fillDensity = False):
"""Returns polygon for a filled circle with x, y, radius, resolution (lines per mm) and fill density (lines per mm) as a Polygon object"""
poly = toolpath.Polygon()
if fillDensity:
numFills = int( float(fillDensity) * float(radius) )
else:
numFills = 1
for d in range( 1, numFills + 1 ):
r = ( float(d) / float(numFills) ) * float(radius)
if debug: print "using r", r, "mm"
poly.addPolygon( arc( x, y, r, math.radians(0), math.radians(360), resolution ) )
return poly
def ellipse(x, y, a, b, resolution, fillDensity = False):
"""Returns polygon for a filled ellipse with x, y, a, b, resolution (lines per mm) and fill density (lines per mm) as a Polygon object"""
poly = toolpath.Polygon()
if not resolution:
resolution = self.circleResolution
if fillDensity:
if a > b:
largerDimension = a
else:
largerDimension = b
numFills = int( float(fillDensity) * float(largerDimension) )
else:
numFills = 1
startAngle, endAngle = 0, 360
# Not really cicumference but will do?
circumference = float(2) * math.pi * float( float( a + b ) / 2 )
angleDiv = ( float(360) / float( circumference * resolution ) ) # + ( 360 % int( circumference * resolution ) )
lastX, lastY = _calcEllipse( startAngle, a, b )
# Compensate for arc going beyond 360 deg
if startAngle > endAngle:
endAngle += 360
for d in range( 1, numFills + 1 ):
ra = ( float(d) / float(numFills) ) * float(a)
rb = ( float(d) / float(numFills) ) * float(b)
for theta in _frange( startAngle, endAngle + angleDiv, angleDiv ):
newX, newY = _calcEllipse( theta, ra, rb )
aLine = poly.addPoint( toolpath.Point(newX + x , newY + y) )
if debug: print "aLine", aLine
return poly
# Return polygon for a filled rectangle
def rectangle(x, y, width, height, fillDensity = False):
"""Returns polygon for line x, y, width, height and fill density (lines per mm) as a Polygon object"""
poly = toolpath.Polygon()
numFillsY = int( float(fillDensity) * float(height) )
cornerX, cornerY = x - ( width / 2 ), y - ( height / 2 )
invert = False
for dy in range( 0, numFillsY + 1 ):
ry = ( float(dy) / float(numFillsY) ) * float(height)
line1 = (cornerX, cornerY + ry, cornerX + width, cornerY + ry )
line2 = (cornerX, cornerY + ry, cornerX + width, cornerY - ry )
if invert:
line1 = _reverseLine(line1)
invert = not invert
x1, y1, x2, y2 = line1
poly.addPoint( toolpath.Point(x1, y1) )
poly.addPoint( toolpath.Point(x2, y2) )
poly.addPoint( toolpath.Point(cornerX, cornerY) )
poly.addPoint( toolpath.Point(cornerX, cornerY + height) )
poly.addPoint( toolpath.Point(cornerX + width, cornerY) )
poly.addPoint( toolpath.Point(cornerX + width, cornerY + height) )
return poly
def circleStroke(x1, y1, x2, y2, radius, resolution, fillDensity = False ):
"""Returns polygon for a photoplotter moving stroke using a circular aperture with x, y, radius, resolution (lines per mm) and fill density (lines per mm) as a Polygon object"""
poly = toolpath.Polygon()
deltaY = y2 - y1
deltaX = x2 - x1
if x1 == x2 and y1 == y2:
#print "this is not a move, this is why software like eagle that uses drm on your own files....is crap"
poly.addPolygon( circle( x1, y1, radius, resolution = resolution, fillDensity = fillDensity ) )
else:
if debug: print "PMWC, fill density", fillDensity
#Plot central line
poly.addPoint( toolpath.Point(x1, y1) )
poly.addPoint( toolpath.Point(x2, y2) )
# For each locus
numFills = int( float(fillDensity) * float(radius) )
for d in range( 1, numFills + 1 ):
r = ( float(d) / float(numFills) ) * float(radius)
if debug: print "using r", r, "mm"
theta = _angleFromDeltas( deltaX, deltaY )
rsintheta = r * math.sin( theta )
rcostheta = r * math.cos( theta )
# Makes sure angle is in correct quadrant
if deltaX > 0:
startOffset = math.radians(90)
endOffset = math.radians(-90)
else:
startOffset = math.radians(-90)
endOffset = math.radians(90)
if deltaY < 0:
startOffset = -startOffset
endOffset = -endOffset
# Plot side lines and end arcs (simi-circles) of locus
# reversing these point lets locus be drawn in one continual motion
poly.addPoint( toolpath.Point(x2 - rsintheta, y2 + rcostheta) )
poly.addPoint( toolpath.Point(x1 - rsintheta, y1 + rcostheta) )
poly.addPolygon( arc(x1, y1, r, theta + startOffset, theta + endOffset, resolution, fillDensity = False) )
poly.addPoint( toolpath.Point(x1 + rsintheta, y1 - rcostheta) )
poly.addPoint( toolpath.Point(x2 + rsintheta, y2 - rcostheta) )
poly.addPolygon( arc(x2, y2, r, theta - startOffset, theta - endOffset, resolution, fillDensity = False) )
return poly
def fill(polygon, fillDensity):
pass
def raster(fileName, originalWidth, originalHeight, svg = False):
"""Returns polygon for a vectorised raster as a Polygon object.
Uses external potrace program to convert raster file into polygon(s)
"""
poly = toolpath.Polygon()
if svg:
os.system("potrace --svg --output " + fileName[ :-3 ] + "svg " + fileName)
os.system("potrace --alphamax 0 --turdsize 5 --backend gimppath --output " + fileName[ :-3 ] + "gimppath " + fileName)
os.system("rm " + fileName)
f = open(fileName[ :-3 ] + "gimppath")
pathLines = f.readlines()
f.close()
os.system("rm " + fileName[ :-3 ] + "gimppath")
scale = 0.005 # temp - competely arbitary
# 1 / 200, i.e 1 / (resolution = 20 * 100 for some reason)
for l in pathLines:
parts = l.split(' ')
isPoint = False
for i, p in enumerate(parts):
if p == 'TYPE:':
ptype = int(parts[i + 1])
isPoint = True
elif p == 'X:':
x = float(parts[i + 1]) * scale
elif p == 'Y:':
y = float(parts[i + 1]) * scale
if isPoint:
poly.addPoint( toolpath.Point(x, y) )
#print "NEW POINT", x, y, ptype
# This should not be assumed?
poly.closed = True
"""
#this needs to be done on all paths at same time
maxX, maxY = 0, 0
for p in points:
x, y, t = p
maxX = max(maxX, x)
maxY = max(maxY, y)
print "max", maxX, maxY
#print "read", len(points), "points"
scaleX = originalWidth / maxX
scaleY = originalHeight / maxY
print "scales", scaleX, scaleY
for i in range(len(points)):
x, y, y = points[i]
x = x * scaleX
y = y * scaleY
points[i] = x, y, t
"""
#should make this return a list of all found polygons
return poly
############# General Maths Functions #############
# Return the coordinates of a point on a circle at theta (rad) with radius.
def _calcCircle(theta, radius):
x = math.cos( math.radians(theta) ) * radius
y = math.sin( math.radians(theta) ) * radius
return x, y
# Return the coordinates of a point on an ellipse at theta (rad) with a and b.
def _calcEllipse(theta, a, b):
x = math.cos( math.radians(theta) ) * a
y = math.sin( math.radians(theta) ) * b
return x, y
# Reverse line (swap x1, y1 and x2, y2)
def _reverseLine( line ):
x1, y1, x2, y2 = line
return x2, y2, x1, y1
# Return the angle between the line between two points (2D coordinates) and vetical?
def _angleFromDeltas( dx, dy ):
radius = math.sqrt( ( dx * dx ) + ( dy * dy ) )
#if radius != 0:
dx, dy = dx / radius, dy / radius
if dx > 0:
if dy > 0:
return math.asin(dx)
elif dy < 0:
return math.acos(dx) + math.radians(90)
else:
#print "moo1"
return 0
elif dx < 0:
if dy > 0:
return math.asin(dy) + math.radians(270)
elif dy < 0:
return math.radians(180) - math.asin(dx)
else:
#print "moo2"
return 0
else:
return math.radians(-90) # i think this should really be 90, it just makes thae program work wen its -90 :)
#else:
# print "Radius cannot be zero!, returning 0 (_angleFromDeltas, shapeplotter.py)"
# Range function accepting floats (by Dinu Gherman)
def _frange(start, end=None, inc=None):
if end == None:
end = start + 0.0
start = 0.0
if inc == None:
inc = 1.0
L = []
while 1:
next = start + len(L) * inc
if inc > 0 and next >= end:
break
elif inc < 0 and next <= end:
break
L.append(next)
return L
# Return length of vector
def _calcVectorLength(line):
x1, y1, x2, y2 = line
deltaX = max(x1, x2) - min(x1, x2)
deltaY = max(y1, y2) - min(y1, y2)
return math.sqrt( math.pow(deltaX, 2) + math.pow(deltaY, 2) )