Slic3r::anonymous_namespace{PrintConfig.cpp} Namespace Reference

Functions
static void	normalize_stride2_floats (ConfigOptionFloats &opt, size_t expected_size)
static void	log_normalize_legacy_vector_size (const char *fn, const std::string &key, int stride, size_t src_size, size_t dest_size, size_t expected_size, size_t restore_n, int cur_variant_count, int target_variant_count, size_t cur_ids, size_t target_ids, const ConfigOption *opt_src, const ConfigOption *opt_target)
static bool	looks_like_bed_exclusion_volume_syntax (const std::string &value)
static bool	parse_double_token (const std::string &text, double &out)
static bool	parse_z_range_token (const std::string &token_in, const double printable_height, double &z_min, double &z_max, bool &has_z)
static std::optional< Polygon >	parse_exclude_polygon_points (const std::string &points_str)
static void	append_legacy_bed_exclude_regions (std::vector< BedExcludeRegion > &out, const Pointfs &legacy_points, const double printable_height)
static void	append_bed_exclusion_volume_regions (std::vector< BedExcludeRegion > &out, const std::string &region_specs_raw, const double printable_height)
static bool	has_nonempty_string (const std::string &value)
static bool	collision_volumes_configured (const std::string &shared_specs, const BedExcludeVolumeMode mode, const std::vector< std::string > &per_extruder_specs)
static std::vector< BedExcludeRegion >	parse_master_bed_excluded_regions (const Pointfs &legacy_points, const std::string &shared_specs, const bool use_collision_volumes, const BedExcludeVolumeMode mode, const double printable_height)
static void	project_bed_material_keepouts (std::vector< BedExcludeRegion > &regions, const ConfigBase &cfg)
static std::vector< BedExcludeRegion >	resolve_bed_excluded_regions (const std::vector< BedExcludeRegion > &master_regions, const BedExcludeVolumeMode mode, const std::vector< std::string > &per_extruder_specs, const std::vector< Vec2d > &extruder_offsets, const size_t reference_extruder, const size_t extruder_id, const double printable_height)
static size_t	bed_exclusion_extruder_count (const size_t nozzle_count, const size_t offset_count, const size_t per_extruder_count)
static std::vector< BedExcludeRegion >	flatten_bed_excluded_regions (const BedExcludeVolumeMode mode, std::vector< std::vector< BedExcludeRegion > > regions_by_extruder)

Function Documentation

append_bed_exclusion_volume_regions()

void Slic3r::anonymous_namespace{PrintConfig.cpp}::append_bed_exclusion_volume_regions ( std::vector< BedExcludeRegion > & out, const std::string & region_specs_raw, const double printable_height )

static

{
    std::vector<std::string> region_specs;
    boost::split(region_specs, region_specs_raw, boost::is_any_of("|\n"));
 
    for (const std::string &spec_raw : region_specs) {
        std::string spec = spec_raw;
        boost::trim(spec);
        if (spec.empty())
            continue;
 
        std::vector<std::string> fields;
        boost::split(fields, spec, boost::is_any_of(";"));
 
        double z_min = 0.0;
        double z_max = printable_height;
        bool has_z_range = false;
        std::string points_field;
        bool invalid_z = false;
 
        for (std::string field : fields) {
            boost::trim(field);
            if (field.empty())
                continue;
 
            bool parsed_z_range = parse_z_range_token(field, printable_height, z_min, z_max, has_z_range);
            if (parsed_z_range)
                continue;
 
            if (field.find("..") != std::string::npos && field.find('x') == std::string::npos) {
                invalid_z = true;
                break;
            }
 
            if (boost::algorithm::istarts_with(field, "points="))
                field = field.substr(std::string("points=").size());
            else if (boost::algorithm::istarts_with(field, "polygon="))
                field = field.substr(std::string("polygon=").size());
 
            points_field = field;
        }
 
        if (invalid_z)
            continue;
 
        if (! has_z_range) {
            z_min = 0.0;
            z_max = printable_height;
        }
 
        if (z_min >= z_max)
            continue;
 
        std::optional<Polygon> polygon = parse_exclude_polygon_points(points_field);
        if (! polygon)
            continue;
 
        out.push_back({ std::move(*polygon), z_min, z_max,
                        BedExcludeRegion::Purpose::CollisionVolume, has_z_range });
    }
}

References append_bed_exclusion_volume_regions(), Slic3r::BedExcludeRegion::CollisionVolume, parse_exclude_polygon_points(), parse_z_range_token(), and Slic3r::printable_height().

Referenced by append_bed_exclusion_volume_regions(), parse_master_bed_excluded_regions(), and resolve_bed_excluded_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

append_legacy_bed_exclude_regions()

void Slic3r::anonymous_namespace{PrintConfig.cpp}::append_legacy_bed_exclude_regions ( std::vector< BedExcludeRegion > & out, const Pointfs & legacy_points, const double printable_height )

static

{
    if (legacy_points.size() < 3)
        return;
 
    Polygon polygon;
    polygon.points.reserve(legacy_points.size());
    for (const Vec2d &pt : legacy_points)
        polygon.points.emplace_back(scale_(pt.x()), scale_(pt.y()));
    polygon.make_counter_clockwise();
 
    out.push_back({ std::move(polygon), 0.0, printable_height,
                    BedExcludeRegion::Purpose::MaterialKeepout, false });
}

References append_legacy_bed_exclude_regions(), Slic3r::Polygon::make_counter_clockwise(), Slic3r::BedExcludeRegion::MaterialKeepout, Slic3r::MultiPoint::points, Slic3r::printable_height(), and scale_.

Referenced by append_legacy_bed_exclude_regions(), and parse_master_bed_excluded_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

bed_exclusion_extruder_count()

size_t Slic3r::anonymous_namespace{PrintConfig.cpp}::bed_exclusion_extruder_count ( const size_t nozzle_count, const size_t offset_count, const size_t per_extruder_count )

static

{
    return std::max<size_t>(1, std::max({ nozzle_count, offset_count, per_extruder_count }));
}

References bed_exclusion_extruder_count().

Referenced by bed_exclusion_extruder_count().

Here is the call graph for this function:

Here is the caller graph for this function:

collision_volumes_configured()

bool Slic3r::anonymous_namespace{PrintConfig.cpp}::collision_volumes_configured ( const std::string & shared_specs, const BedExcludeVolumeMode mode, const std::vector< std::string > & per_extruder_specs )

static

{
    if (mode == BedExcludeVolumeMode::PerExtruder)
        return std::any_of(per_extruder_specs.begin(), per_extruder_specs.end(), has_nonempty_string);
    return has_nonempty_string(shared_specs);
}

References collision_volumes_configured(), has_nonempty_string(), and Slic3r::PerExtruder.

Referenced by collision_volumes_configured().

Here is the call graph for this function:

Here is the caller graph for this function:

flatten_bed_excluded_regions()

std::vector< BedExcludeRegion > Slic3r::anonymous_namespace{PrintConfig.cpp}::flatten_bed_excluded_regions ( const BedExcludeVolumeMode mode, std::vector< std::vector< BedExcludeRegion > > regions_by_extruder )

static

{
    if (regions_by_extruder.empty())
        return {};
    if (mode == BedExcludeVolumeMode::Shared)
        return std::move(regions_by_extruder.front());
 
    std::vector<BedExcludeRegion> flattened;
    // A shared legacy area is present in every resolved nozzle group so object
    // validation sees it for every tool. Flatten it only once, while retaining
    // every nozzle-specific collision volume.
    bool material_keepout_added = false;
    for (std::vector<BedExcludeRegion> &regions : regions_by_extruder) {
        for (BedExcludeRegion &region : regions) {
            if (!region.is_collision_volume()) {
                if (material_keepout_added)
                    continue;
                material_keepout_added = true;
            }
            flattened.emplace_back(std::move(region));
        }
    }
    return flattened;
}

References flatten_bed_excluded_regions(), and Slic3r::Shared.

Referenced by flatten_bed_excluded_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

has_nonempty_string()

bool Slic3r::anonymous_namespace{PrintConfig.cpp}::has_nonempty_string ( const std::string & value )

static

{
    return std::any_of(value.begin(), value.end(), [](const char c) { return !std::isspace(static_cast<unsigned char>(c)); });
}

References has_nonempty_string().

Referenced by collision_volumes_configured(), and has_nonempty_string().

Here is the call graph for this function:

Here is the caller graph for this function:

log_normalize_legacy_vector_size()

void Slic3r::anonymous_namespace{PrintConfig.cpp}::log_normalize_legacy_vector_size ( const char * fn, const std::string & key, int stride, size_t src_size, size_t dest_size, size_t expected_size, size_t restore_n, int cur_variant_count, int target_variant_count, size_t cur_ids, size_t target_ids, const ConfigOption * opt_src, const ConfigOption * opt_target )

static

{
    BOOST_LOG_TRIVIAL(debug) << fn << ": normalizing legacy vector size for key '" << key << "'"
                             << " stride=" << stride << " src_size=" << src_size << " dest_size=" << dest_size << " expected=" << expected_size
                             << " restore_index.size=" << restore_n << " cur_variants=" << cur_variant_count << " target_variants=" << target_variant_count
                             << " cur_ids=" << cur_ids << " target_ids=" << target_ids << " cur_value=" << opt_src->serialize()
                             << " target_value=" << opt_target->serialize();
}

References log_normalize_legacy_vector_size(), and Slic3r::ConfigOption::serialize().

Referenced by log_normalize_legacy_vector_size().

Here is the call graph for this function:

Here is the caller graph for this function:

looks_like_bed_exclusion_volume_syntax()

bool Slic3r::anonymous_namespace{PrintConfig.cpp}::looks_like_bed_exclusion_volume_syntax ( const std::string & value )

static

{
    return value.find('|') != std::string::npos || (value.find("..") != std::string::npos && value.find(';') != std::string::npos);
}

References looks_like_bed_exclusion_volume_syntax().

Referenced by looks_like_bed_exclusion_volume_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_stride2_floats()

void Slic3r::anonymous_namespace{PrintConfig.cpp}::normalize_stride2_floats ( ConfigOptionFloats & opt, size_t expected_size )

static

{
    auto &v = opt.values;
    if (expected_size == 0) {
        v.clear();
        return;
    }
    if (v.empty()) {
        // Fallback: keep behavior predictable instead of crashing. This should be rare.
        v.resize(expected_size, 0.0);
        return;
    }
 
    const double first  = v[0];
    const double second = (v.size() >= 2) ? v[1] : first;
 
    // Ensure we have at least one (normal,silent) pair to replicate.
    if (v.size() < 2) {
        v.resize(2, first);
        v[1] = second;
    }
    // Keep pair alignment if some legacy preset produced odd length.
    if (v.size() % 2 != 0)
        v.push_back(second);
 
    if (v.size() > expected_size) {
        v.resize(expected_size);
        return;
    }
 
    const size_t have_variants = v.size() / 2;
    const size_t want_variants = expected_size / 2;
    v.resize(expected_size);
    for (size_t vi = have_variants; vi < want_variants; ++vi) {
        v[vi * 2] = first;
        if (vi * 2 + 1 < v.size())
            v[vi * 2 + 1] = second;
    }
}

References normalize_stride2_floats().

Referenced by normalize_stride2_floats().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_double_token()

bool Slic3r::anonymous_namespace{PrintConfig.cpp}::parse_double_token ( const std::string & text, double & out )

static

{
    std::string token = text;
    boost::trim(token);
    if (token.empty())
        return false;
 
    size_t parsed = 0;
    out = string_to_double_decimal_point(token, &parsed);
    return parsed == token.size() && std::isfinite(out);
}

References parse_double_token(), and Slic3r::string_to_double_decimal_point().

Referenced by parse_double_token(), parse_exclude_polygon_points(), and parse_z_range_token().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_exclude_polygon_points()

std::optional< Polygon > Slic3r::anonymous_namespace{PrintConfig.cpp}::parse_exclude_polygon_points ( const std::string & points_str )

static

{
    Pointfs points;
    std::vector<std::string> point_tokens;
    boost::split(point_tokens, points_str, boost::is_any_of(","));
    points.reserve(point_tokens.size());
    for (std::string point_token : point_tokens) {
        boost::trim(point_token);
        const size_t separator = point_token.find('x');
        if (separator == std::string::npos || point_token.find('x', separator + 1) != std::string::npos)
            return std::nullopt;
 
        double x = 0.0;
        double y = 0.0;
        if (!parse_double_token(point_token.substr(0, separator), x) ||
            !parse_double_token(point_token.substr(separator + 1), y) ||
            !std::isfinite(x) || !std::isfinite(y))
            return std::nullopt;
        points.emplace_back(x, y);
    }
    if (points.size() < 3)
        return std::nullopt;
 
    Polygon polygon;
    polygon.points.reserve(points.size());
    for (const Vec2d &pt : points)
        polygon.points.emplace_back(scale_(pt.x()), scale_(pt.y()));
    if (polygon.area() == 0.0)
        return std::nullopt;
    polygon.make_counter_clockwise();
    return polygon;
}

References Slic3r::Polygon::area(), Slic3r::Polygon::make_counter_clockwise(), parse_double_token(), parse_exclude_polygon_points(), Slic3r::MultiPoint::points, and scale_.

Referenced by append_bed_exclusion_volume_regions(), and parse_exclude_polygon_points().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_master_bed_excluded_regions()

std::vector< BedExcludeRegion > Slic3r::anonymous_namespace{PrintConfig.cpp}::parse_master_bed_excluded_regions ( const Pointfs & legacy_points, const std::string & shared_specs, const bool use_collision_volumes, const BedExcludeVolumeMode mode, const double printable_height )

static

{
    std::vector<BedExcludeRegion> regions;
    const double height = std::max(0.0, printable_height);
    // Legacy excluded areas remain a shared material/placement keep-out even
    // when collision volumes are configured. Collision volumes add constraints;
    // they do not silently remove the printer profile's established area.
    append_legacy_bed_exclude_regions(regions, legacy_points, height);
    if (use_collision_volumes && mode != BedExcludeVolumeMode::PerExtruder)
        append_bed_exclusion_volume_regions(regions, shared_specs, height);
    return regions;
}

References append_bed_exclusion_volume_regions(), append_legacy_bed_exclude_regions(), parse_master_bed_excluded_regions(), Slic3r::PerExtruder, and Slic3r::printable_height().

Referenced by parse_master_bed_excluded_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_z_range_token()

bool Slic3r::anonymous_namespace{PrintConfig.cpp}::parse_z_range_token ( const std::string & token_in, const double printable_height, double & z_min, double & z_max, bool & has_z )

static

{
    std::string token = token_in;
    boost::trim(token);
    if (token.empty())
        return false;
 
    size_t range_pos = token.find("..");
    if (range_pos == std::string::npos)
        return false;
 
    std::string min_token = token.substr(0, range_pos);
    std::string max_token = token.substr(range_pos + 2);
    boost::trim(min_token);
    boost::trim(max_token);
 
    double parsed_min = 0.0;
    double parsed_max = printable_height;
    if (! min_token.empty() && ! parse_double_token(min_token, parsed_min))
        return false;
    if (! max_token.empty() && ! parse_double_token(max_token, parsed_max))
        return false;
 
    z_min = std::clamp(parsed_min, 0.0, printable_height);
    z_max = std::clamp(parsed_max, 0.0, printable_height);
    has_z = true;
    // A range wholly outside the printable height clamps to a plane, which is
    // not a volume and must not participate in conservative unknown-Z checks.
    return z_min < z_max;
}

References parse_double_token(), parse_z_range_token(), and Slic3r::printable_height().

Referenced by append_bed_exclusion_volume_regions(), and parse_z_range_token().

Here is the call graph for this function:

Here is the caller graph for this function:

project_bed_material_keepouts()

void Slic3r::anonymous_namespace{PrintConfig.cpp}::project_bed_material_keepouts ( std::vector< BedExcludeRegion > & regions, const ConfigBase & cfg )

static

{
    const auto *belt = cfg.option<ConfigOptionBool>("belt_printer");
    if (belt == nullptr || !belt->value)
        return;
 
    const auto *axis = cfg.option<ConfigOptionEnum<BeltRotationAxis>>("belt_slice_rotation");
    const auto *angle = cfg.option<ConfigOptionFloat>("belt_slice_rotation_angle");
    if (axis == nullptr || angle == nullptr)
        return;
 
    const auto tilt = BeltTransformPipeline::physical_tilt(axis->value, angle->value);
    const double cos_x = std::cos(Geometry::deg2rad(tilt.tilt_x_deg));
    const double cos_y = std::cos(Geometry::deg2rad(tilt.tilt_y_deg));
    // Resolve bed-surface coordinates once, before any placement or tower
    // consumer sees them. Collision volumes already use model coordinates.
    for (BedExcludeRegion &region : regions)
        if (!region.is_collision_volume())
            for (Point &point : region.polygon.points)
                point = Point(scale_(unscale<double>(point.x()) * cos_y), scale_(unscale<double>(point.y()) * cos_x));
}

References Slic3r::angle(), Slic3r::Geometry::deg2rad(), Slic3r::ConfigBase::option(), Slic3r::BeltTransformPipeline::physical_tilt(), project_bed_material_keepouts(), scale_, and Slic3r::unscale().

Referenced by project_bed_material_keepouts().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_bed_excluded_regions()

std::vector< BedExcludeRegion > Slic3r::anonymous_namespace{PrintConfig.cpp}::resolve_bed_excluded_regions ( const std::vector< BedExcludeRegion > & master_regions, const BedExcludeVolumeMode mode, const std::vector< std::string > & per_extruder_specs, const std::vector< Vec2d > & extruder_offsets, const size_t reference_extruder, const size_t extruder_id, const double printable_height )

static

{
    if (mode == BedExcludeVolumeMode::Shared)
        return master_regions;
 
    if (mode == BedExcludeVolumeMode::PerExtruder) {
        std::vector<BedExcludeRegion> regions = master_regions;
        if (extruder_id < per_extruder_specs.size())
            append_bed_exclusion_volume_regions(
                regions, per_extruder_specs[extruder_id], std::max(0.0, printable_height));
        return regions;
    }
 
    std::vector<BedExcludeRegion> regions = master_regions;
    if (extruder_id >= extruder_offsets.size() || extruder_offsets.empty())
        return regions;
 
    const size_t clamped_reference = std::min(reference_extruder, extruder_offsets.size() - 1);
    // A model-space point is emitted as model_position - extruder_offset. Therefore a
    // carriage/toolhead obstacle described through the reference nozzle appears in another
    // nozzle's model space translated by (other_offset - reference_offset).
    const Vec2d delta = extruder_offsets[extruder_id] - extruder_offsets[clamped_reference];
    const Point translation(scale_(delta.x()), scale_(delta.y()));
    for (BedExcludeRegion &region : regions) {
        // Toolhead-relative offsets apply only to opt-in collision volumes.
        // A legacy material keep-out is bed-fixed and shared by every nozzle.
        if (region.is_collision_volume())
            region.polygon.translate(translation);
    }
    return regions;
}

References append_bed_exclusion_volume_regions(), Slic3r::PerExtruder, Slic3r::printable_height(), resolve_bed_excluded_regions(), scale_, and Slic3r::Shared.

Referenced by resolve_bed_excluded_regions().

Here is the call graph for this function:

Here is the caller graph for this function: