marchsq Namespace Reference

Namespaces
namespace	__impl

Classes
struct	AdaptiveTpmsField
struct	_RasterTraits< AdaptiveTpmsField >
struct	AdaptiveLevelField
struct	_RasterTraits< AdaptiveLevelField >
struct	GyroidField
struct	_RasterTraits< GyroidField >
struct	ScalarField
struct	_RasterTraits< ScalarField >
struct	_RasterTraits< Slic3r::png::ImageGreyscale >
struct	Coord
struct	_RasterTraits
struct	_Loop
struct	_Loop< Slic3r::ExecutionTBB >
struct	_RasterTraits< Slic3r::sla::RasterGrayscaleAA >

Typedefs
using	coordr_t = long
using	Pointf = Vec2d
using	Ring = std::vector<Coord>

Functions
Polylines	get_gyroid_polylines (const GyroidField &sf, const double tolerance=SCALED_EPSILON)
Polylines	get_polylines (const ScalarField &sf, const double tolerance=SCALED_EPSILON)
std::ostream &	operator<< (std::ostream &os, const Coord &o)
std::ostream &	operator<< (std::ostream &os, const Ring &r)
template<class Raster, class ExecutionPolicy>
std::vector< marchsq::Ring >	execute_with_policy (ExecutionPolicy &&policy, const Raster &raster, TRasterValue< Raster > isoval, Coord windowsize={})
template<class Raster>
std::vector< marchsq::Ring >	execute (const Raster &raster, TRasterValue< Raster > isoval, Coord windowsize={})

Typedef Documentation

coordr_t

using marchsq::coordr_t = long

Pointf

using marchsq::Pointf = Vec2d

Ring

using marchsq::Ring = std::vector<Coord>

Function Documentation

execute()

template<class Raster>

std::vector< marchsq::Ring > marchsq::__impl::execute	(	const Raster &	raster,
		TRasterValue< Raster >	isoval,
		Coord	windowsize = {} )

                                                                                                                            {})
{
    return execute_with_policy(nullptr, raster, isoval, windowsize);
}

Referenced by Slic3r::anonymous_namespace{SL1.cpp}::extract_slices_from_sla_archive(), and Slic3r::sla::raster_to_polygons().

Here is the caller graph for this function:

execute_with_policy()

template<class Raster, class ExecutionPolicy>

std::vector< marchsq::Ring > marchsq::__impl::execute_with_policy	(	ExecutionPolicy &&	policy,
		const Raster &	raster,
		TRasterValue< Raster >	isoval,
		Coord	windowsize = {} )

                                                                                 {})
{
    if (!rows(raster) || !cols(raster))
        return {};
 
    size_t ratio = cols(raster) / rows(raster);
 
    if (!windowsize.r)
        windowsize.r = 2;
    if (!windowsize.c)
        windowsize.c = std::max(2l, long(windowsize.r * ratio));
 
    Grid<Raster> grid{raster, windowsize};
 
    grid.tag_grid(std::forward<ExecutionPolicy>(policy), isoval);
    std::vector<marchsq::Ring> rings = grid.scan_rings();
    grid.interpolate_rings(std::forward<ExecutionPolicy>(policy), rings, isoval);
 
    return rings;
}

Referenced by get_gyroid_polylines(), get_polylines(), Slic3r::make_adaptive_infill_shells(), and Slic3r::make_adaptive_tpms().

Here is the caller graph for this function:

get_gyroid_polylines()

Polylines marchsq::get_gyroid_polylines ( const GyroidField & sf, const double tolerance = SCALED_EPSILON )

inline

{
    std::vector<Ring> rings = execute_with_policy(ex_tbb, sf, sf.isoval, {sf.gsize, sf.gsize});
    Polylines polys;
    polys.reserve(rings.size());
    for (const Ring& ring : rings) {
        Polyline poly;
        Points&  pts = poly.points;
        pts.reserve(ring.size() + 1);
        for (const Coord& crd : ring)
            pts.emplace_back(sf.to_Point(crd));
        pts.push_back(pts.front());
        if (tolerance >= 0.0)
            poly.simplify(tolerance);
        polys.emplace_back(poly);
    }
    return polys;
}

References Slic3r::ex_tbb, execute_with_policy(), marchsq::GyroidField::isoval, SCALED_EPSILON, and marchsq::GyroidField::to_Point().

Referenced by Slic3r::FillGyroid::_fill_surface_single().

Here is the call graph for this function:

Here is the caller graph for this function:

get_polylines()

Polylines marchsq::get_polylines	(	const ScalarField &	sf,
		const double	tolerance = SCALED_EPSILON )

{
    std::vector<Ring> rings = execute_with_policy(ex_tbb, sf, sf.isoval, {sf.gsize, sf.gsize});
 
    Polylines polys;
    polys.reserve(rings.size());
    // size_t old_pts = 0, new_pts = 0;
 
    for (const Ring& ring : rings) {
        Polyline poly;
        Points&  pts = poly.points;
        pts.reserve(ring.size() + 1);
        for (const Coord& crd : ring)
            pts.emplace_back(sf.to_Point(crd));
        // MarchingSquare's rings are polygons, so add the first point to the end to make it a PolyLine.
        pts.push_back(pts.front());
        // old_pts += poly.points.size();
        //  Simplify within specified tolerance to reduce points.
        if (tolerance >= 0.0)
            poly.simplify(tolerance);
        // new_pts += poly.points.size();
        polys.emplace_back(poly);
    }
    // std::cerr << "MarchingSquares: poly.simplify(" << tolerance << ") reduced points from" <<
    //     old_pts << " to " << new_pts << " (" << 100*new_pts/old_pts << "%)\n";
    return polys;
}

References Slic3r::ex_tbb, execute_with_policy(), marchsq::ScalarField::isoval, SCALED_EPSILON, and marchsq::ScalarField::to_Point().

Referenced by Slic3r::FillTpmsFK::_fill_surface_single().

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [1/2]

std::ostream & marchsq::operator<< ( std::ostream & os, const Coord & o )

inline

{ return os << "(r=" << o.r << ",c=" << o.c << ")"; }

References marchsq::Coord::c, and marchsq::Coord::r.

operator<<() [2/2]

std::ostream & marchsq::operator<< ( std::ostream & os, const Ring & r )

inline

{
    os << "[" << r.size() << "]:";
    for (Coord c : r)
        os << " " << c;
    return os << "\n";
}