std::string GCode::change_layer(const Layer &layer) { this->layer = &layer; this->layer_index++; this->first_layer = (layer.id() == 0); // avoid computing islands and overhangs if they're not needed if (this->config.avoid_crossing_perimeters) { ExPolygons islands; union_(layer.slices, &islands, true); this->avoid_crossing_perimeters.init_layer_mp(islands); } std::string gcode; if (this->layer_count > 0) { gcode += this->writer.update_progress(this->layer_index, this->layer_count); } coordf_t z = layer.print_z + this->config.z_offset.value; // in unscaled coordinates if (EXTRUDER_CONFIG(retract_layer_change) && this->writer.will_move_z(z)) { gcode += this->retract(); } { std::ostringstream comment; comment << "move to next layer (" << this->layer_index << ")"; gcode += this->writer.travel_to_z(z, comment.str()); } // forget last wiping path as wiping after raising Z is pointless this->wipe.reset_path(); return gcode; }
std::string GCode::retract(bool toolchange) { std::string gcode; if (this->writer.extruder() == NULL) return gcode; // wipe (if it's enabled for this extruder and we have a stored wipe path) if (EXTRUDER_CONFIG(wipe) && this->wipe.has_path()) { gcode += this->wipe.wipe(*this, toolchange); } /* The parent class will decide whether we need to perform an actual retraction (the extruder might be already retracted fully or partially). We call these methods even if we performed wipe, since this will ensure the entire retraction length is honored in case wipe path was too short. */ gcode += toolchange ? this->writer.retract_for_toolchange() : this->writer.retract(); gcode += this->writer.reset_e(); if (this->writer.extruder()->retract_length() > 0 || this->config.use_firmware_retraction) gcode += this->writer.lift(); return gcode; }
// convert a model-space scaled point into G-code coordinates Pointf GCode::point_to_gcode(const Point &point) { Pointf extruder_offset = EXTRUDER_CONFIG(extruder_offset); return Pointf( unscale(point.x) + this->origin.x - extruder_offset.x, unscale(point.y) + this->origin.y - extruder_offset.y ); }
bool GCode::needs_retraction(const Polyline &travel, ExtrusionRole role) { if (travel.length() < scale_(EXTRUDER_CONFIG(retract_before_travel))) { // skip retraction if the move is shorter than the configured threshold return false; } if (role == erSupportMaterial) { const SupportLayer* support_layer = dynamic_cast<const SupportLayer*>(this->layer); if (support_layer != NULL && support_layer->support_islands.contains(travel)) { // skip retraction if this is a travel move inside a support material island return false; } } if (this->config.only_retract_when_crossing_perimeters && this->layer != NULL) { if (this->config.fill_density.value > 0 && this->layer->any_internal_region_slice_contains(travel)) { /* skip retraction if travel is contained in an internal slice *and* internal infill is enabled (so that stringing is entirely not visible) */ return false; } else if (this->layer->any_bottom_region_slice_contains(travel) && this->layer->upper_layer != NULL && this->layer->upper_layer->slices.contains(travel) && (this->config.bottom_solid_layers.value >= 2 || this->config.fill_density.value > 0)) { /* skip retraction if travel is contained in an *infilled* bottom slice but only if it's also covered by an *infilled* upper layer's slice so that it's not visible from above (a bottom surface might not have an upper slice in case of a thin membrane) */ return false; } } // retract if only_retract_when_crossing_perimeters is disabled or doesn't apply return true; }
std::string GCode::extrude(ExtrusionLoop loop, std::string description, double speed) { // get a copy; don't modify the orientation of the original loop object otherwise // next copies (if any) would not detect the correct orientation // extrude all loops ccw bool was_clockwise = loop.make_counter_clockwise(); // find the point of the loop that is closest to the current extruder position // or randomize if requested Point last_pos = this->last_pos(); if (this->config.spiral_vase) { loop.split_at(last_pos); } else if (this->config.seam_position == spNearest || this->config.seam_position == spAligned) { Polygon polygon = loop.polygon(); // simplify polygon in order to skip false positives in concave/convex detection // (loop is always ccw as polygon.simplify() only works on ccw polygons) Polygons simplified = polygon.simplify(scale_(EXTRUDER_CONFIG(nozzle_diameter))/2); // restore original winding order so that concave and convex detection always happens // on the right/outer side of the polygon if (was_clockwise) { for (Polygons::iterator p = simplified.begin(); p != simplified.end(); ++p) p->reverse(); } // concave vertices have priority Points candidates; for (Polygons::const_iterator p = simplified.begin(); p != simplified.end(); ++p) { Points concave = p->concave_points(PI*4/3); candidates.insert(candidates.end(), concave.begin(), concave.end()); } // if no concave points were found, look for convex vertices if (candidates.empty()) { for (Polygons::const_iterator p = simplified.begin(); p != simplified.end(); ++p) { Points convex = p->convex_points(PI*2/3); candidates.insert(candidates.end(), convex.begin(), convex.end()); } } // retrieve the last start position for this object if (this->layer != NULL && this->_seam_position.count(this->layer->object()) > 0) { last_pos = this->_seam_position[this->layer->object()]; } Point point; if (this->config.seam_position == spNearest) { if (candidates.empty()) candidates = polygon.points; last_pos.nearest_point(candidates, &point); // On 32-bit Linux, Clipper will change some point coordinates by 1 unit // while performing simplify_polygons(), thus split_at_vertex() won't // find them anymore. if (!loop.split_at_vertex(point)) loop.split_at(point); } else if (!candidates.empty()) { Points non_overhang; for (Points::const_iterator p = candidates.begin(); p != candidates.end(); ++p) { if (!loop.has_overhang_point(*p)) non_overhang.push_back(*p); } if (!non_overhang.empty()) candidates = non_overhang; last_pos.nearest_point(candidates, &point); if (!loop.split_at_vertex(point)) loop.split_at(point); // see note above } else { if (this->config.seam_position == spAlwaysHideSeam){ if (loop.role == elrContourInternalPerimeter) { Polygon polygon = loop.polygon(); Point centroid = polygon.centroid(); point = Point(polygon.bounding_box().max.x, centroid.y); point.rotate(rand() % 2*PI, centroid); } } } else{
std::string GCode::extrude(ExtrusionLoop loop, std::string description, double speed) { // get a copy; don't modify the orientation of the original loop object otherwise // next copies (if any) would not detect the correct orientation // extrude all loops ccw bool was_clockwise = loop.make_counter_clockwise(); SeamPosition seam_position = this->config.seam_position; if (loop.role == elrSkirt) seam_position = spNearest; // find the point of the loop that is closest to the current extruder position // or randomize if requested Point last_pos = this->last_pos(); if (this->config.spiral_vase) { loop.split_at(last_pos); } else if (seam_position == spNearest || seam_position == spAligned) { const Polygon polygon = loop.polygon(); // simplify polygon in order to skip false positives in concave/convex detection // (loop is always ccw as polygon.simplify() only works on ccw polygons) Polygons simplified = polygon.simplify(scale_(EXTRUDER_CONFIG(nozzle_diameter))/2); // restore original winding order so that concave and convex detection always happens // on the right/outer side of the polygon if (was_clockwise) { for (Polygons::iterator p = simplified.begin(); p != simplified.end(); ++p) p->reverse(); } // concave vertices have priority Points candidates; for (Polygons::const_iterator p = simplified.begin(); p != simplified.end(); ++p) { Points concave = p->concave_points(PI*4/3); candidates.insert(candidates.end(), concave.begin(), concave.end()); } // if no concave points were found, look for convex vertices if (candidates.empty()) { for (Polygons::const_iterator p = simplified.begin(); p != simplified.end(); ++p) { Points convex = p->convex_points(PI*2/3); candidates.insert(candidates.end(), convex.begin(), convex.end()); } } // retrieve the last start position for this object if (this->layer != NULL && this->_seam_position.count(this->layer->object()) > 0) { last_pos = this->_seam_position[this->layer->object()]; } Point point; if (seam_position == spNearest) { if (candidates.empty()) candidates = polygon.points; last_pos.nearest_point(candidates, &point); // On 32-bit Linux, Clipper will change some point coordinates by 1 unit // while performing simplify_polygons(), thus split_at_vertex() won't // find them anymore. if (!loop.split_at_vertex(point)) loop.split_at(point); } else if (!candidates.empty()) { Points non_overhang; for (Points::const_iterator p = candidates.begin(); p != candidates.end(); ++p) { if (!loop.has_overhang_point(*p)) non_overhang.push_back(*p); } if (!non_overhang.empty()) candidates = non_overhang; last_pos.nearest_point(candidates, &point); if (!loop.split_at_vertex(point)) loop.split_at(point); // see note above } else { point = last_pos.projection_onto(polygon); loop.split_at(point); } if (this->layer != NULL) this->_seam_position[this->layer->object()] = point; } else if (seam_position == spRandom) { if (loop.role == elrContourInternalPerimeter) { Polygon polygon = loop.polygon(); Point centroid = polygon.centroid(); last_pos = Point(polygon.bounding_box().max.x, centroid.y); last_pos.rotate(fmod((float)rand()/16.0, 2.0*PI), centroid); } loop.split_at(last_pos); } // clip the path to avoid the extruder to get exactly on the first point of the loop; // if polyline was shorter than the clipping distance we'd get a null polyline, so // we discard it in that case double clip_length = this->enable_loop_clipping ? scale_(EXTRUDER_CONFIG(nozzle_diameter)) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER : 0; // get paths ExtrusionPaths paths; loop.clip_end(clip_length, &paths); if (paths.empty()) return ""; // apply the small perimeter speed if (paths.front().is_perimeter() && loop.length() <= SMALL_PERIMETER_LENGTH) { if (speed == -1) speed = this->config.get_abs_value("small_perimeter_speed"); } // extrude along the path std::string gcode; for (ExtrusionPaths::const_iterator path = paths.begin(); path != paths.end(); ++path) gcode += this->_extrude(*path, description, speed); // reset acceleration gcode += this->writer.set_acceleration(this->config.default_acceleration.value); if (this->wipe.enable) this->wipe.path = paths.front().polyline; // TODO: don't limit wipe to last path // make a little move inwards before leaving loop if (paths.back().role == erExternalPerimeter && this->layer != NULL && this->config.perimeters > 1) { // detect angle between last and first segment // the side depends on the original winding order of the polygon (left for contours, right for holes) Point a = paths.front().polyline.points[1]; // second point Point b = *(paths.back().polyline.points.end()-3); // second to last point if (was_clockwise) { // swap points Point c = a; a = b; b = c; } double angle = paths.front().first_point().ccw_angle(a, b) / 3; // turn left if contour, turn right if hole if (was_clockwise) angle *= -1; // create the destination point along the first segment and rotate it // we make sure we don't exceed the segment length because we don't know // the rotation of the second segment so we might cross the object boundary Line first_segment( paths.front().polyline.points[0], paths.front().polyline.points[1] ); double distance = std::min( scale_(EXTRUDER_CONFIG(nozzle_diameter)), first_segment.length() ); Point point = first_segment.point_at(distance); point.rotate(angle, first_segment.a); // generate the travel move gcode += this->writer.travel_to_xy(this->point_to_gcode(point), "move inwards before travel"); } return gcode; }