def effect(self):
"""Main entry point for Inkscape plugins.
"""
# Create a log file for debugging
if self.options.log_create_log and self.options.log_filename:
log_path = os.path.abspath(os.path.expanduser(self.options.log_filename))
log_level = getattr(logging, self.options.log_level, DEFAULT_LOG_LEVEL)
logging.basicConfig(filename=log_path, filemode='w', level=log_level)
self.process_options()
geom.set_epsilon(self.options.epsilon)
# Create a transform to flip the coordinates
# from cartesian to SVG (flip Y axis from lower left to upper left).
page_height = self.get_document_size()[1]
#page_width = float(self.docroot.get('width'))
flip_transform_attr = 'translate(0, %f) scale(1, -1)' % page_height
flip_transform = simpletransform.parseTransform(flip_transform_attr)
# Clear out any previous preview and debug layers if any
self.clear_layer(PREVIEW_LAYER_NAME)
self.clear_layer(DEBUG_LAYER_NAME)
# Create a new layer that will contain the G code preview
self.preview_layer = self.create_layer(PREVIEW_LAYER_NAME)
self.preview_layer.set('transform', flip_transform_attr)
self.current_layer = self.preview_layer
if self.options.debug_layer:
debug_layer = self.create_layer(DEBUG_LAYER_NAME)
debug_layer.set('transform', flip_transform_attr)
# setup geom module for debug output
geom.DEBUG_EFFECT = self
geom.DEBUG_LAYER = debug_layer
# Get selected SVG elements if any
rootnodes = self.selected.values()
if rootnodes:
# Get the parent layer transform for the
# selected elements in order to get them in the right place
shapelist = []
for node in rootnodes:
parent_layer = self.get_parent_layer(node)
matrix = geom.IdentityTransform2D
if parent_layer is not None:
parent_transform = parent_layer.get('transform')
matrix = simpletransform.parseTransform(parent_transform)
shapelist.extend(supereffect.flatten_nodetree((node,), mtransform=matrix,
ignored_layers=IGNORED_LAYERS))
else:
# Use entire document if nothing is selected
rootnodes = self.document.getroot()
shapelist = supereffect.flatten_nodetree(rootnodes,
ignored_layers=IGNORED_LAYERS)
# Process the SVG shape/path elements
cutpath_list = self.process_shapes(shapelist, flip_transform)
# self.trystuff(cutpath_list)
# return
preview_plotter=SVGPreviewPlotter(self.document.getroot(),
self.preview_layer)
cam = self.generate_gcode(cutpath_list, preview_plotter)
# try:
# # Generate and export G code
# cam = self.generate_gcode(cutpath_list)
# except Exception, e:
# inkex.errormsg(str(e))
# return
try:
cam.export(self.options.filename, self.options.directory,
append_suffix=self.options.append_suffix)
except IOError, e:
inkex.errormsg(str(e))
def effect(self):
"""Main entry point for Inkscape plugins.
"""
if self.options.log_create_log and self.options.log_filename:
log_path = os.path.expanduser(self.options.log_filename)
log_path = os.path.abspath(log_path)
log_level = getattr(logging, self.options.log_level,
DEFAULT_LOG_LEVEL)
logging.basicConfig(filename=log_path, filemode='w', level=log_level)
# logger.debug('scale: %f' % self.options.scale)
# logger.debug('fillon: %s' % self.options.fillon)
# logger.debug('zfill: %s' % self.options.zfill)
# logger.debug('flip: %s' % self.options.flip)
# logger.debug('symmetry: %d' % self.options.symmetry)
# logger.debug('maxmax: %d' % self.options.numlines)
logger.debug('midon0: %d' % int(self.options.mid_skinny))
logger.debug('midon1: %d' % int(self.options.mid_fat))
# logger.debug('polygon-stroke: %s' % self.options.polygon_stroke)
# logger.debug('segment-stroke: %s' % self.options.segment_stroke)
units = self.get_document_units()
unit_scale = inkex.uuconv[units]
# Perform any necessary unit conversion on plugin options
self.convert_option_units(default_unit_scale=unit_scale)
geom.set_epsilon(self.options.epsilon)
# logger.debug('EPSILON= %f' % geom.EPSILON)
self.scale = self.options.scale * self._SCALE_SCALE
self.offset = geom.P(self.view_center) + geom.P(self.options.offset_x,
self.options.offset_y)
mrot = geom.matrix_rotate_2d(self.options.rotate)
self.transform = geom.matrix_scale_translate_2d(self.scale, self.scale,
self.offset.x, self.offset.y)
self.transform = geom.compose_transform(self.transform, mrot)
doc_size = geom.P(self.get_document_size())
self.doc_center = doc_size / 2
plotter = SVGQuasiPlotter()
# if DEFAULT_LOG_LEVEL == logging.DEBUG:
# geom.DEBUG_EFFECT = self
# geom.DEBUG_LAYER = self.create_layer('debug')
# plotter.debug_layer = geom.DEBUG_LAYER
# Set up document and margin clipping regions
mBL = geom.P(self.options.margin_left, self.options.margin_bottom)
mTR = doc_size - geom.P(self.options.margin_right,
self.options.margin_top)
margin_clip_rect = geom.Box(mBL, mTR)
if self.options.clip_to_circle:
r = min(doc_size.x, doc_size.y) / 2.0
plotter.doc_clip_region = geom.Circle(self.doc_center, r)
r = min(margin_clip_rect.width(), margin_clip_rect.height()) / 2.0
plotter.margin_clip_region = geom.Circle(self.doc_center, r)
else:
if self.options.clip_to_doc:
plotter.doc_clip_region = geom.Box(geom.P(0,0), doc_size)
if self.options.clip_to_margins:
plotter.margin_clip_region = margin_clip_rect
plotter.doc_center = self.doc_center
plotter.blowup_scale = self.options.blowup_scale
# plotter.clip_to_doc = self.options.clip_to_doc
# plotter.clip_polygons_to_margins = self.options.clip_poly
# plotter.clip_segments_to_margins = self.options.clip_segments
if self.options.project_sphere:
self.projector = SphericalProjector(self.doc_center,
self.options.project_radius,
invert=self.options.project_invert)
if self.projector is None:
self.projector = IdentityProjector()
plotter.projector = self.projector
if self.options.polygon_mult == 1:
plotter.polygon_layers.append(self.create_layer('quasink polygons'))
else:
for n in range(self.options.polygon_mult):
layer = self.create_layer('quasink polygons %02d' % (n+1))
plotter.polygon_layers.append(layer)
if self.options.segment_draw:
plotter.segment_layer = self.create_layer('quasink segments')
plotter.scale = self.scale
plotter.offset = self.offset
plotter.transform = self.transform
# plotter.offsetx = self.offset[0]
# plotter.offsety = self.offset[1]
plotter.fill_polygons = bool(self.options.polygon_fill)
plotter.use_color = bool(self.options.polygon_colorfill)
plotter.polygon_stroke = self.options.polygon_stroke
plotter.segment_stroke = self.options.segment_stroke
plotter.polygon_stroke_width = self.options.polygon_stroke_width
plotter.segment_stroke_width = self.options.segment_stroke_width
plotter.polygon_mult = self.options.polygon_mult
plotter.polygon_mult_spacing = self.options.polygon_mult_spacing
q = quasi.Quasi()
q.offset_salt_x = self.options.salt_x
q.offset_salt_y = self.options.salt_y
q.skinnyfat_ratio = self.options.skinnyfat_ratio
q.segment_ratio = self.options.segment_ratio
q.segtype_skinny = self.options.mid_skinny
q.segtype_fat = self.options.mid_fat
q.symmetry = self.options.symmetry
q.numlines = self.options.numlines
q.plotter = plotter
q.quasi()
def segsort_key(seg):
# mp = seg.midpoint() - self.doc_center
# return mp.angle()
return seg.midpoint().distance(self.doc_center)
if self.options.polyseg_draw:
polyseg_layer = self.create_layer('quasink_polygon_segments')
color = self.parse_color(self.options.polyseg_stroke)
style = self.styles['polyseg'] % (self.options.polyseg_stroke_width,
color,)
for segment in plotter.poly_segments:
self.draw_segment(segment, polyseg_layer, style)
if self.options.polysegpath_draw:
polysegpath_layer = self.create_layer('quasink_polygon_segment_paths')
segtable = SegmentChainer2()
# seglist = sorted(plotter.poly_segments, key=segsort_key)
segpath_list = segtable.create_chains(plotter.poly_segments)
# Sort segment paths so that the largest are at the bottom of the Z-order
# segpath_list.sort(key=SegmentPath.bounding_box_area, reverse=True)
segpath_list.sort(key=len, reverse=True)
style = self.styles['polysegpath'] % (self.options.polysegpath_stroke_width,
self.parse_color(self.options.polysegpath_stroke),)
for segpath in segpath_list:
plotter.plot_segpath(polysegpath_layer, segpath, style)
# for p in plotter.poly_segments.nodes.keys():
# plotter.debug_plot_point(p)
if self.options.convex_hull_draw:
hull_layer = self.create_layer('quasink_convex_hull')
plotter.polygon_layers[0] = hull_layer
hull = plotter.poly_segments.convex_hull()
plotter.polygon_stroke = "#f08080"
plotter.plot_polygon(hull, nofill=True, draw_only=True)
if self.options.hull_draw or self.options.voronoi_draw:
polygon_hulls = plotter.poly_segments.boundary_polygons(
peel_hulls=self.options.hull_inner_draw)
if self.options.hull_draw:
hull_layer = self.create_layer('quasink_polygon_hulls')
plotter.polygon_layers[0] = hull_layer
for hull in polygon_hulls:
plotter.polygon_stroke = self.options.hull_stroke
plotter.polygon_stroke_width = self.options.hull_stroke_width
plotter.plot_polygon(hull, nofill=True, draw_only=True)
if self.options.segpath_draw:
segpath_layer = self.create_layer('quasink_segment_paths')
segtable = SegmentChainer2()
segpath_list = segtable.create_chains(plotter.path_segments)
style = self.styles['segpath'] % (self.options.segpath_stroke_width,
self.parse_color(self.options.segpath_stroke),)
for segpath in segpath_list:
plotter.plot_segpath(segpath_layer, segpath, style)
if self.options.voronoi_draw:
voronoi_layer = self.create_layer('quasink_voronoi')
# voronoi_path_layer = self.create_layer('quasink_voronoi_paths')
style = self.styles['voronoi'] % (self.options.voronoi_stroke_width,
self.parse_color(self.options.voronoi_stroke),)
# points = []
# for p in plotter.poly_segments.nodes.keys():
# pt = self.projector.project(p * self.scale + self.offset)
# points.append(pt)
points = plotter.poly_segments.nodes.keys()
voronoi_segments = self.voronoi(points)
phull = []
for p in polygon_hulls[0]:
phull.append(self.projector.project(p * self.scale + self.offset))
for segment in voronoi_segments:
p1 = self.projector.project(segment.p1 * self.scale + self.offset)
p2 = self.projector.project(segment.p2 * self.scale + self.offset)
line = geom.Line(p1, p2)
line = margin_clip_rect.clip_line(line)
if line and polygon.point_inside(phull, line.p1) and \
polygon.point_inside(phull, line.p2):
attrs = {'d': 'M %5f %5f L %5f %5f' % \
(line.p1.x, line.p1.y, line.p2.x, line.p2.y),
'style': style}
inkex.etree.SubElement(voronoi_layer, inkex.addNS('path', 'svg'), attrs)
