Model centered when exporting to png. Added some comments to the rasterization.

xs/src/libslic3r/Print.cpp

@@ -15,10 +15,6 @@
 // For png export of the sliced model
 #include <fstream>
 #include <sstream>
-//#include <wx/dcmemory.h>
-//#include <wx/bitmap.h>
-//#include <wx/image.h>
-//#include <wx/graphics.h>
 
 #include "Rasterizer/Rasterizer.hpp"
 #include "tbb/parallel_for.h"
@@ -1254,22 +1250,57 @@ void Print::set_status(int percent, const std::string &message)
     printf("Print::status %d => %s\n", percent, message.c_str());
 }
 
+/*
+ * Interface for a file printer of the slices. Implementation can be an SVG
+ * or PNG printer or any other format.
+ *
+ * The format argument spefies the output format of the printer and it enables
+ * different implementations of this class template for each supported format.
+ *
+ */
 template<Print::FilePrinterFormat format>
 class FilePrinter {
 public:
+
+    // Draw an ExPolygon which is a polygon inside a slice on the specified layer.
     void drawPolygon(const ExPolygon& p, unsigned lyr);
+
+    // Tell the printer how many layers should it consider.
     void layers(unsigned layernum);
+
+    // Get the number of layers in the print.
     unsigned layers() const;
+
+    /* Switch the a particular layer. If there where less layers then the
+     * specified layer number than an appripriate number of layers will be
+     * allocated in the printer.
+     */
     void beginLayer(unsigned layer);
+
+    // Allocate a new layer on top of the last and switch to it.
     void beginLayer();
+
+    /*
+     * Finish the selected layer. It means that no drawing is allowed on that
+     * layer anymore. This fact can be used to prepare the file system output
+     * data like png conmprimation and so on.
+     */
     void finishLayer(unsigned layer);
+
+    // Finish the top layer.
     void finishLayer();
+
+    // Save all the layers into the file (or dir) specified in the path argument
     void save(const std::string& path);
+
+    // Save only the selected layer to the file specified in path argument.
     void saveLayer(unsigned lyr, const std::string& path);
 };
 
-template<>
+template<> // Implementation for PNG raster output
 class FilePrinter<Print::FilePrinterFormat::PNG> {
+    // We will save the compressed PNG data into stringstreams which can be done
+    // in parallel. Later we can write every layer to the disk sequentially.
     std::vector<std::pair<Raster, std::stringstream>> layers_rst_;
     Raster::Resolution res_;
     Raster::PixelDim pxdim_;
@@ -1341,70 +1372,24 @@ public:
         std::fstream out(loc, std::fstream::out | std::fstream::binary);
         if(out.good()) {
             layers_rst_[i].first.save(out, Raster::Compression::PNG);
-        }
+        } /*else {
+          some logging should be done here...
+        }*/
         out.close();
         layers_rst_[i].first.reset();
     }
 };
 
-//template<>
-//class FilePrinter<Print::FilePrinterFormat::PNG> {
-//    wxBitmap bitmap_;
-//    std::unique_ptr<wxMemoryDC> dc_;
-//    std::unique_ptr<wxGraphicsContext> gc_;
-//    double pxw_;
-//    double pxh_;
-//public:
-//    inline FilePrinter(unsigned width_px, unsigned height_px,
-//                       double width_mm, double height_mm):
-//        bitmap_(width_px, height_px),
-//        dc_(new wxMemoryDC(bitmap_)),
-//        gc_(wxGraphicsContext::Create(*dc_)),
-//        pxw_(width_mm/width_px),
-//        pxh_(height_mm/width_px)
-//    {
-//        gc_->SetAntialiasMode(wxANTIALIAS_DEFAULT);
-//    }
-
-//    FilePrinter(const FilePrinter& ) = delete;
-//    FilePrinter(FilePrinter&& m):
-//        bitmap_(std::move(m.bitmap_)), dc_(std::move(m.dc_)),
-//        gc_(std::move(m.gc_)), pxw_(m.pxw_), pxh_(m.pxh_) {}
-
-//    void drawPolygon(const Polygon& p) {
-
-//        gc_->SetPen(*wxWHITE_PEN);
-//        std::vector<wxPoint2DDouble> points;
-//        points.reserve(p.points.size());
-
-//        for(auto pp : p.points) {
-//            points.emplace_back(
-//                    std::round(pp.x * SCALING_FACTOR/pxw_),
-//                    std::round(pp.y * SCALING_FACTOR/pxh_)
-//                        );
-//        }
-
-//        gc_->DrawLines(points.size(), points.data());
-//    }
-
-//    void finish() {
-
-//    }
-
-//    void save(const std::string& path) {
-//        if(!bitmap_.SaveFile(path, wxBITMAP_TYPE_PNG)) {
-//            std::cout << "fail for " << path << std::endl;
-//        }
-//    }
-//};
-
 template<Print::FilePrinterFormat format, class...Args>
-void Print::print_to(std::string dirpath, Args...args)
+void Print::print_to(std::string dirpath,
+                     double width_mm,
+                     double height_mm,
+                     Args...args)
 {
 
     std::string dir = dirpath;
 
-#ifdef WIN32
+#ifdef WIN32 // Making dirpath end with a directory separator on all platforms
     if(dir.back() != '\\') dir.push_back('\\');
 #else
     if(dir.back() != '/') dir.push_back('/');
@@ -1412,34 +1397,50 @@ void Print::print_to(std::string dirpath, Args...args)
 
     LayerPtrs layers;
 
+    // Merge the sliced layers wit hthe support layers
     std::for_each(objects.begin(), objects.end(), [&layers](PrintObject *o){
         layers.insert(layers.end(), o->layers.begin(), o->layers.end());
         layers.insert(layers.end(), o->support_layers.begin(),
                       o->support_layers.end());
     });
 
+    // Sort layers by z coord
     std::sort(layers.begin(), layers.end(), [](Layer *l1, Layer *l2){
         return l1->print_z < l2->print_z;
     });
 
     auto print_bb = bounding_box();
 
-    FilePrinter<format> printer(std::forward<Args>(args)...);
+    // If the print does not fit into the print area we should cry about it.
-    printer.layers(layers.size());
+    assert(unscale(print_bb.size().x) <= width_mm ||
+            unscale(print_bb.size().y) <= height_mm);
 
-    auto process_layer = [&layers, &printer, print_bb, dir] (unsigned layer_id) {
+    // Offset for centering the print onto the print area
+    auto cx = scale_(width_mm)/2 - (print_bb.center().x - print_bb.min.x);
+    auto cy = scale_(height_mm)/2 - (print_bb.center().y - print_bb.min.y);
+
+    // Create the actual printer, forward any additional arguments to it.
+    FilePrinter<format> printer(std::forward<Args>(args)...);
+    printer.layers(layers.size());  // Allocate space for all the layers
+
+    // Method that prints one layer
+    auto process_layer = [this, &layers, &printer, print_bb, dir, cx, cy]
+            (unsigned layer_id)
+    {
         Layer& l = *(layers[layer_id]);
 
-        ExPolygonCollection slices = l.slices;
+        ExPolygonCollection slices = l.slices; // Copy the layer slices
-        using Sl = ExPolygons::value_type;
+
+        // Sort the polygons in the layer
         std::sort(slices.expolygons.begin(),
                   slices.expolygons.end(),
-                  [](Sl a, Sl b){
+                  [](const ExPolygon& a, const ExPolygon& b){
             return a.contains(b.contour.first_point()) ? false : true;
         });
 
-        printer.beginLayer(layer_id);
+        printer.beginLayer(layer_id);   // Switch to the appropriate layer
 
+        // Draw all the polygons in the slice to the actual layer.
         std::for_each(l.object()->_shifted_copies.begin(),
                       l.object()->_shifted_copies.end(),
                       [&] (Point d)
@@ -1449,25 +1450,34 @@ void Print::print_to(std::string dirpath, Args...args)
                           [&] (ExPolygon slice)
             {
                 slice.translate(d.x, d.y);
-                slice.translate(-print_bb.min.x, -print_bb.min.y);
+                slice.translate(-print_bb.min.x + cx, -print_bb.min.y + cy);
 
                 printer.drawPolygon(slice, layer_id);
             });
         });
 
-        printer.finishLayer(layer_id);
+        if(has_support_material() && layer_id > 0) {
-//        printer.saveLayer(layer_id, dir);
+            std::cout << "support layer " << layer_id << "\n";
+        }
+
+        printer.finishLayer(layer_id);  // Finish the layer for later saving it.
+        // printer.saveLayer(layer_id, dir); We could save the layer immediately
 
     };
 
-    tbb::parallel_for<size_t, decltype(process_layer)>(0, layers.size(), process_layer);
+    // Print all the layers in parallel
+    tbb::parallel_for<size_t, decltype(process_layer)>(0,
+                                                       layers.size(),
+                                                       process_layer);
 
+    // Save the print into the file system.
     printer.save(dir);
 }
 
 void Print::print_to_png(std::string dirpath, long width_px, long height_px,
                          double width_mm, double height_mm) {
-    print_to<FilePrinterFormat::PNG>(dirpath, width_px, height_px,
+    print_to<FilePrinterFormat::PNG>(dirpath, width_mm, height_mm,
+                                     width_px, height_px,
                                      width_mm, height_mm);
 }
 

xs/src/libslic3r/Print.hpp

@@ -316,14 +316,17 @@ public:
     };
 
     template<FilePrinterFormat format, class...Args>
-    void print_to(std::string dirpath, Args...args);
+    void print_to(std::string dirpath,
+                  double width_mm,
+                  double height_mm,
+                  Args...args);
 
     void print_to_png(std::string dirpath, long width_px, long height_px,
                       double width_mm, double height_mm);
 
     void print_to_png(std::string dirpath) {
-        // Where should this be specified?
+        // Will need some GUI dialogue perhaps for these to be specified.
-        print_to_png(dirpath, 1440, 2560, 40.0, 72.0);
+        print_to_png(dirpath, 1440, 2560, 68.0, 120.0);
     }
 
 private:

xs/src/libslic3r/Rasterizer/Rasterizer.cpp

@@ -1,4 +1,6 @@
 #include "Rasterizer.hpp"
+#include <ExPolygon.hpp>
+
 #include <cstdint>
 
 // For rasterizing
@@ -14,7 +16,7 @@
 #include <agg/agg_rasterizer_scanline_aa.h>
 #include <agg/agg_path_storage.h>
 
-// For compression
+// For png compression
 #ifdef WIN32
 inline char *strerror_r(int errnum, char *buf, size_t buflen) {
     strerror_s(buf, buflen, errnum);
@@ -70,9 +72,12 @@ public:
         agg::rasterizer_scanline_aa<> ras;
         agg::scanline_p8 scanlines;
 
-        ras.add_path(to_path(poly.contour));
+        auto&& path = to_path(poly.contour);
+        ras.add_path(path);
+
         for(auto h : poly.holes) {
-            ras.add_path(to_path(h));
+            auto&& holepath = to_path(h);
+            ras.add_path(holepath);
         }
 
         agg::render_scanlines(ras, scanlines, renderer_);

xs/src/libslic3r/Rasterizer/Rasterizer.hpp

@@ -2,20 +2,32 @@
 #define RASTERIZER_HPP
 
 #include <ostream>
-#include <ExPolygon.hpp>
+#include <memory>
 
 namespace Slic3r {
 
+class ExPolygon;
+
+/**
+ * @brief Raster captures an antialiased monochrome canvas where vectorial
+ * polygons can be rasterized. Fill color is always white and the background is
+ * black. Countours are antialiased.
+ *
+ * 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,
+        RAW,    //!> Uncompressed pixel data
-        PNG
+        PNG     //!> PNG compression
     };
 
+    /// Type that represents a resolution in pixels.
     struct Resolution {
         unsigned width_px;
         unsigned height_px;
@@ -25,6 +37,7 @@ public:
         }
     };
 
+    /// Types that represents the dimension of a pixel in millimeters.
     struct PixelDim {
         double w_mm;
         double h_mm;
@@ -32,22 +45,32 @@ public:
             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 );
     Raster();
-    ~Raster();
     Raster(const Raster& cpy);
     Raster(Raster&& m);
+    ~Raster();
 
+    /// Reallocated everything for the given resolution and pixel dimension.
     void reset(const Resolution& r, const PixelDim& pd);
 
+    /**
+     * 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);
 };