def effect(self):
if not len(self.selected) == 1:
inkex.errormsg("You must select exactly 1 element.")
return
# Get script's values
sensor_distance = self.options.sensor_distance #defines where the lines are cut out
arrow_size = self.options.line_thickness + 10
self.gap = self.options.gap
line_thickness = self.options.line_thickness
# Get access to main SVG document element and get its dimensions.
svg = self.document.getroot()
# Create a new layer.
layer = inkex.etree.SubElement(svg, 'g')
layer.set(inkex.addNS('label', 'inkscape'), 'CurveLayer')
layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')
converter = Converter()
# from Inkscape svg to Path
userInputObject = self.selected.values()[0]
pathMask = Path(userInputObject)
degree = pathMask.getNumNodes()
nodes = []
points = []
for i in range(0, degree):
#Get the nodes from the control graph
nodes.append(pathMask.getNodeXY(i))
curve = Bezier(nodes)
i = (100-sensor_distance) /1000.0
for t in arange(0, 1+i, i):
point = curve.point(t)
points.append(point)
#draw the bezier curve
i = 0.005
p0 = curve.point(0)
for t in arange(0, 1, i):
point = curve.point(t+i)
self.draw_line(line_thickness, (p0[0], p0[1]), (point[0], point[1]), layer)
p0 = curve.point(t)
#cut out the sensors
z = points[0]
for p in points[1:]:
self.calculatePoint(z[0],z[1],p[0],p[1],arrow_size,45, layer)
z = p
""" remove the line which describes the curve """
for selected_element in self.selected.itervalues():
self.remove(selected_element)
def drawLine(self,p1x,p1y,p2x,p2y, layer,color='#000000'):
'''
draw the white line in order to separate the sensors
'''
path = Path()
path.addNodeAtEnd(p1x,p1y)
path.addNodeAtEnd(p2x,p2y)
style = {'stroke' : str(color), 'stroke-width': self.gap, 'fill': 'none'}
svgPath = inkex.etree.SubElement(layer, inkex.addNS('path','svg'), {'style': simplestyle.formatStyle(style)})
path.toSVG(svgPath)
def _polygonToPath(self, polygon):
"""
Internal convertion of a Shapely Polygon
into a Path object.
"""
coords = polygon.exterior.coords.xy
coordsX = coords[0]
coordsY = coords[1]
path = Path()
for i in range(len(coordsX)):
path.addNodeAtEnd(coordsX[i], coordsY[i])
return path
def effect(self):
if not len(self.selected) == 1:
inkex.errormsg("You must select exactly 1 element.")
return
converter = Converter()
svg = self.document.getroot()
# Create a new layer.
layer = inkex.etree.SubElement(svg, 'g')
layer.set(inkex.addNS('label', 'inkscape'), 'SensorLayer')
layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')
sensorWidth = self.options.sensors_x
sensorHeight = self.options.sensors_y
padding = self.options.padding
curve_type = self.options.curve_type
#curve_number = self.options.curve_number
# Users might create invalid masks that the Path object can not handle.
if (not Path.isValid(self.selected.values()[0])):
inkex.errormsg("The selected mask is invalid and can not be handled by the Path object.")
return
# From Inkscape svg to Path
pathMask = Path(self.selected.values()[0])
polyMask = converter.pathToPolygon(pathMask)
'''if (curve_type != 'path'):
polyMask = converter.curveToBezier(pathMask)
else:
polyMask = converter.pathToPolygon(pathMask)'''
# for point in list(polyMask.exterior.coords):
# self.draw_SVG_square((5,5), (point[0],point[1]), layer)
#inkex.errormsg("valid polygon: "+str(polyMask.is_valid))
#inkex.errormsg("object: %s"%polyMask.exterior.type)
#inkex.errormsg("valid linearRing: "+str(polyMask.exterior.is_valid))
# Bounding box of the mask is upper size limit for grid
minx, miny, maxx, maxy = polyMask.bounds
maskWidth = maxx - minx
maskHeight = maxy - miny
#inkex.errormsg("width: %d"%maskWidth+", height: %d"%maskHeight)
sensorNumX = int((maskWidth + padding)/(sensorWidth + padding)) + 1
sensorNumY = int((maskHeight + padding)/(sensorHeight + padding)) + 1
# Create grid
pathGrid = util.createSensorGrid(sensorNumX, sensorNumY, sensorWidth, sensorHeight, padding, minx, miny)
# Convert Path objects in Grid to Shapely Polygons
polyGrid = [converter.pathToPolygon(path) for path in pathGrid]
# Apply mask on each element of the grid
pathMaskedGrid = []
for poly in polyGrid:
polyMasked = poly.intersection(polyMask)
pathMasked = converter.polygonsToPath([polyMasked])
if isinstance(pathMasked, list):#multiple polygons created e.g. sensor cut into parts by mask
pathMaskedGrid.extend(pathMasked)
elif len(pathMasked) != 0: #one polygon, not empty
pathMaskedGrid.append(pathMasked)
# Convert cut out Path objects into SVG paths and add to layer.
for rectMasked in pathMaskedGrid:
style = {'stroke' : 'none', 'stroke-width': '1', 'fill': '#000000'}
attribs = {'style': simplestyle.formatStyle(style)}
svgRectPath = inkex.etree.Element(inkex.addNS('path','svg'),attribs)
rectMasked.toSVG(svgRectPath)
layer.append(svgRectPath)
def effect(self):
if not len(self.selected) == 1:
inkex.errormsg("You must select exactly 1 element.")
return
# Get script's values
number_sensors = self.options.number_sensors
sensor_size = self.options.sensor_size
sensor_distance = self.options.sensor_distance
bezier_type = self.options.bezier_type
# Get access to main SVG document element and get its dimensions.
svg = self.document.getroot()
# Create a new layer.
layer = inkex.etree.SubElement(svg, 'g')
layer.set(inkex.addNS('label', 'inkscape'), 'CurveLayer')
layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')
userInputObject = self.selected.values()[0]
# from Inkscape svg to Path
pathMask = Path(userInputObject)
degree = pathMask.getNumNodes()
if (bezier_type == 'cubic' and degree != 4) or (bezier_type == 'quatratic' and degree != 3):
inkex.errormsg("The path is invalid. Either 3 or 4 points are allowed.")
nodes = []
points = []
for i in range(0, degree):
#Get the nodes from the control graph
nodes.append(pathMask.getNodeXY(i))
#Create Cubic/Quadratic Bezier with the control points
if (bezier_type == 'cubic'):
if (degree < 4):
inkex.errormsg("The path is invalid. You need 4 points.")
curve = CubicBezier(nodes[0], nodes[1], nodes[2], nodes[3])
else:
curve = QuadraticBezier(nodes[0], nodes[1], nodes[2])
# triangle
p1 = [0 , 0]
p2 = [0 , sensor_size/2]
p3 = [sensor_size , sensor_size/4]
pts = ar([p3, p2, p1])
#rotation point
pr = [sensor_size/4, sensor_size/4]
length = curve.length()
offset = sensor_size * 0.25
number_sensors = math.ceil(length / (sensor_size + offset))
i = sensor_distance/1000.0
tri0 = [[0, 0], [0, 1], [0.5, 0.5]]
for j in np.arange(0, 1+i, i):
#Calculation of slope and angle for rotation
slope = curve.derivation(j)
angle = angle_between(slope)
if slope[1] < 0:
angle = 2*pi - angle
point = curve.point(j)
#DEBUGGING:draw squares without rotation to compare
#self.draw_SVG_square((5,5), (point[0],point[1]), layer)
points.append(point)
ots = Rotate(pts,ar(pr),angle)
#draw a triangle
tri = [[point[0]+ots[0][0], point[1]+ots[0][1]] ,\
[point[0]+ots[1][0], point[1]+ots[1][1]] ,\
[point[0]+ots[2][0], point[1]+ots[2][1]] ]
self.draw_triangle(tri, layer)
