WIP: Moved sources int src/, separated most of the source code from Perl.

The XS was left only for the unit / integration tests, and it links
libslic3r only. No wxWidgets are allowed to be used from Perl starting
from now.

src/libslic3r/Rasterizer/Rasterizer.cpp

@@ -0,0 +1,214 @@
+#include "Rasterizer.hpp"
+#include <ExPolygon.hpp>
+
+#include <cstdint>
+
+// For rasterizing
+#include <agg/agg_basics.h>
+#include <agg/agg_rendering_buffer.h>
+#include <agg/agg_pixfmt_gray.h>
+#include <agg/agg_pixfmt_rgb.h>
+#include <agg/agg_renderer_base.h>
+#include <agg/agg_renderer_scanline.h>
+
+#include <agg/agg_scanline_p.h>
+#include <agg/agg_rasterizer_scanline_aa.h>
+#include <agg/agg_path_storage.h>
+
+// For png compression
+#include <png/writer.hpp>
+
+namespace Slic3r {
+
+class Raster::Impl {
+public:
+    using TPixelRenderer = agg::pixfmt_gray8; // agg::pixfmt_rgb24;
+    using TRawRenderer = agg::renderer_base<TPixelRenderer>;
+    using TPixel = TPixelRenderer::color_type;
+    using TRawBuffer = agg::rendering_buffer;
+
+    using TBuffer = std::vector<TPixelRenderer::pixel_type>;
+
+    using TRendererAA = agg::renderer_scanline_aa_solid<TRawRenderer>;
+
+    static const TPixel ColorWhite;
+    static const TPixel ColorBlack;
+
+    using Origin = Raster::Origin;
+
+private:
+    Raster::Resolution resolution_;
+    Raster::PixelDim pxdim_;
+    TBuffer buf_;
+    TRawBuffer rbuf_;
+    TPixelRenderer pixfmt_;
+    TRawRenderer raw_renderer_;
+    TRendererAA renderer_;
+    Origin o_;
+    std::function<void(agg::path_storage&)> flipy_ = [](agg::path_storage&) {};
+public:
+    inline Impl(const Raster::Resolution& res, const Raster::PixelDim &pd,
+                Origin o):
+        resolution_(res), pxdim_(pd),
+        buf_(res.pixels()),
+        rbuf_(reinterpret_cast<TPixelRenderer::value_type*>(buf_.data()),
+              res.width_px, res.height_px,
+              res.width_px*TPixelRenderer::num_components),
+        pixfmt_(rbuf_),
+        raw_renderer_(pixfmt_),
+        renderer_(raw_renderer_),
+        o_(o)
+    {
+        renderer_.color(ColorWhite);
+
+        // If we would like to play around with gamma
+        // ras.gamma(agg::gamma_power(1.0));
+
+        clear();
+
+        if(o_ == Origin::TOP_LEFT) flipy_ = [this](agg::path_storage& path) {
+            path.flip_y(0, resolution_.height_px);
+        };
+    }
+
+    void draw(const ExPolygon &poly) {
+        agg::rasterizer_scanline_aa<> ras;
+        agg::scanline_p8 scanlines;
+
+        auto&& path = to_path(poly.contour);
+        flipy_(path);
+        ras.add_path(path);
+
+        for(auto h : poly.holes) {
+            auto&& holepath = to_path(h);
+            flipy_(holepath);
+            ras.add_path(holepath);
+        }
+
+        agg::render_scanlines(ras, scanlines, renderer_);
+    }
+
+    inline void clear() {
+        raw_renderer_.clear(ColorBlack);
+    }
+
+    inline TBuffer& buffer()  { return buf_; }
+
+    inline const Raster::Resolution resolution() { return resolution_; }
+
+    inline Origin origin() const /*noexcept*/ { return o_; }
+
+private:
+    double getPx(const Point& p) {
+        return p(0) * SCALING_FACTOR/pxdim_.w_mm;
+    }
+
+    double getPy(const Point& p) {
+        return p(1) * SCALING_FACTOR/pxdim_.h_mm;
+    }
+
+    agg::path_storage to_path(const Polygon& poly) {
+        agg::path_storage path;
+        auto it = poly.points.begin();
+        path.move_to(getPx(*it), getPy(*it));
+        while(++it != poly.points.end())
+            path.line_to(getPx(*it), getPy(*it));
+
+        path.line_to(getPx(poly.points.front()), getPy(poly.points.front()));
+        return path;
+    }
+
+};
+
+const Raster::Impl::TPixel Raster::Impl::ColorWhite = Raster::Impl::TPixel(255);
+const Raster::Impl::TPixel Raster::Impl::ColorBlack = Raster::Impl::TPixel(0);
+
+Raster::Raster(const Resolution &r, const PixelDim &pd, Origin o):
+    impl_(new Impl(r, pd, o)) {}
+
+Raster::Raster() {}
+
+Raster::~Raster() {}
+
+Raster::Raster(Raster &&m):
+    impl_(std::move(m.impl_)) {}
+
+void Raster::reset(const Raster::Resolution &r, const Raster::PixelDim &pd)
+{
+    // Free up the unnecessary memory and make sure it stays clear after
+    // an exception
+    auto o = impl_? impl_->origin() : Origin::TOP_LEFT;
+    reset(r, pd, o);
+}
+
+void Raster::reset(const Raster::Resolution &r, const Raster::PixelDim &pd,
+                   Raster::Origin o)
+{
+    impl_.reset();
+    impl_.reset(new Impl(r, pd, o));
+}
+
+void Raster::reset()
+{
+    impl_.reset();
+}
+
+Raster::Resolution Raster::resolution() const
+{
+    if(impl_) return impl_->resolution();
+
+    return Resolution(0, 0);
+}
+
+void Raster::clear()
+{
+    assert(impl_);
+    impl_->clear();
+}
+
+void Raster::draw(const ExPolygon &poly)
+{
+    assert(impl_);
+    impl_->draw(poly);
+}
+
+void Raster::save(std::ostream& stream, Compression comp)
+{
+    assert(impl_);
+    switch(comp) {
+    case Compression::PNG: {
+
+        png::writer<std::ostream> wr(stream);
+
+        wr.set_bit_depth(8);
+        wr.set_color_type(png::color_type_gray);
+        wr.set_width(resolution().width_px);
+        wr.set_height(resolution().height_px);
+        wr.set_compression_type(png::compression_type_default);
+
+        wr.write_info();
+
+        auto& b = impl_->buffer();
+        auto ptr = reinterpret_cast<png::byte*>( b.data() );
+        unsigned stride =
+                sizeof(Impl::TBuffer::value_type) *  resolution().width_px;
+
+        for(unsigned r = 0; r < resolution().height_px; r++, ptr+=stride) {
+            wr.write_row(ptr);
+        }
+
+        break;
+    }
+    case Compression::RAW: {
+        stream << "P5 "
+               << impl_->resolution().width_px << " "
+               << impl_->resolution().height_px << " "
+               << "255 ";
+
+        stream.write(reinterpret_cast<const char*>(impl_->buffer().data()),
+                     impl_->buffer().size()*sizeof(Impl::TBuffer::value_type));
+    }
+    }
+}
+
+}

src/libslic3r/Rasterizer/Rasterizer.hpp

@@ -0,0 +1,86 @@
+#ifndef RASTERIZER_HPP
+#define RASTERIZER_HPP
+
+#include <ostream>
+#include <memory>
+
+namespace Slic3r {
+
+class ExPolygon;
+
+/**
+ * @brief Raster captures an anti-aliased monochrome canvas where vectorial
+ * polygons can be rasterized. Fill color is always white and the background is
+ * black. Contours are anti-aliased.
+ *
+ * It also supports saving the raster data into a standard output stream in raw
+ * or PNG format.
+ */
+class Raster {
+    class Impl;
+    std::unique_ptr<Impl> impl_;
+public:
+
+    /// Supported compression types
+    enum class Compression {
+        RAW,    //!> Uncompressed pixel data
+        PNG     //!> PNG compression
+    };
+
+    enum class Origin {
+        TOP_LEFT,
+        BOTTOM_LEFT
+    };
+
+    /// Type that represents a resolution in pixels.
+    struct Resolution {
+        unsigned width_px;
+        unsigned height_px;
+        inline Resolution(unsigned w, unsigned h): width_px(w), height_px(h) {}
+        inline unsigned pixels() const /*noexcept*/ {
+            return width_px * height_px;
+        }
+    };
+
+    /// Types that represents the dimension of a pixel in millimeters.
+    struct PixelDim {
+        double w_mm;
+        double h_mm;
+        inline PixelDim(double px_width_mm, double px_height_mm ):
+            w_mm(px_width_mm), h_mm(px_height_mm) {}
+    };
+
+    /// Constructor taking the resolution and the pixel dimension.
+    explicit Raster(const Resolution& r, const PixelDim& pd,
+                    Origin o = Origin::BOTTOM_LEFT );
+    Raster();
+    Raster(const Raster& cpy) = delete;
+    Raster& operator=(const Raster& cpy) = delete;
+    Raster(Raster&& m);
+    ~Raster();
+
+    /// Reallocated everything for the given resolution and pixel dimension.
+    void reset(const Resolution& r, const PixelDim& pd);
+    void reset(const Resolution& r, const PixelDim& pd, Origin o);
+
+    /**
+     * Release the allocated resources. Drawing in this state ends in
+     * unspecified behaviour.
+     */
+    void reset();
+
+    /// Get the resolution of the raster.
+    Resolution resolution() const;
+
+    /// Clear the raster with black color.
+    void clear();
+
+    /// Draw a polygon with holes.
+    void draw(const ExPolygon& poly);
+
+    /// Save the raster on the specified stream.
+    void save(std::ostream& stream, Compression comp = Compression::RAW);
+};
+
+}
+#endif // RASTERIZER_HPP