Merge branch 'master' into pa_reprap_g10_temperature_support

src/libslic3r/GCode/Analyzer.cpp

@@ -12,6 +12,8 @@
 #include "Analyzer.hpp"
 #include "PreviewData.hpp"
 
+#if !ENABLE_GCODE_VIEWER
+
 static const std::string AXIS_STR = "XYZE";
 static const float MMMIN_TO_MMSEC = 1.0f / 60.0f;
 static const float INCHES_TO_MM = 25.4f;
@@ -350,7 +352,7 @@ void GCodeAnalyzer::_processG1(const GCodeReader::GCodeLine& line)
     if (delta_pos[E] < 0.0f)
     {
         if ((delta_pos[X] != 0.0f) || (delta_pos[Y] != 0.0f) || (delta_pos[Z] != 0.0f))
-        type = GCodeMove::Move;
+            type = GCodeMove::Move;
         else
             type = GCodeMove::Retract;
     }
@@ -651,7 +653,7 @@ bool GCodeAnalyzer::_process_tags(const GCodeReader::GCodeLine& line)
         return true;
     }
 
-    // color change tag
+    // pause print tag
     pos = comment.find(Pause_Print_Tag);
     if (pos != comment.npos)
     {
@@ -659,7 +661,7 @@ bool GCodeAnalyzer::_process_tags(const GCodeReader::GCodeLine& line)
         return true;
     }
 
-    // color change tag
+    // custom code tag
     pos = comment.find(Custom_Code_Tag);
     if (pos != comment.npos)
     {
@@ -667,7 +669,7 @@ bool GCodeAnalyzer::_process_tags(const GCodeReader::GCodeLine& line)
         return true;
     }
 
-    // color change tag
+    // end pause print or custom code tag
     pos = comment.find(End_Pause_Print_Or_Custom_Code_Tag);
     if (pos != comment.npos)
     {
@@ -1191,3 +1193,5 @@ size_t GCodeAnalyzer::memory_used() const
 }
 
 } // namespace Slic3r
+
+#endif // !ENABLE_GCODE_VIEWER

src/libslic3r/GCode/Analyzer.hpp

@@ -1,6 +1,8 @@
 #ifndef slic3r_GCode_Analyzer_hpp_
 #define slic3r_GCode_Analyzer_hpp_
 
+#if !ENABLE_GCODE_VIEWER
+
 #include "../libslic3r.h"
 #include "../PrintConfig.hpp"
 #include "../ExtrusionEntity.hpp"
@@ -302,4 +304,6 @@ private:
 
 } // namespace Slic3r
 
+#endif // !ENABLE_GCODE_VIEWER
+
 #endif /* slic3r_GCode_Analyzer_hpp_ */

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -0,0 +1,560 @@
+#ifndef slic3r_GCodeProcessor_hpp_
+#define slic3r_GCodeProcessor_hpp_
+
+#if ENABLE_GCODE_VIEWER
+#include "libslic3r/GCodeReader.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/CustomGCode.hpp"
+
+#include <array>
+#include <vector>
+#include <string>
+
+namespace Slic3r {
+
+    enum class EMoveType : unsigned char
+    {
+        Noop,
+        Retract,
+        Unretract,
+        Tool_change,
+        Color_change,
+        Pause_Print,
+        Custom_GCode,
+        Travel,
+        Extrude,
+        Count
+    };
+
+    struct PrintEstimatedTimeStatistics
+    {
+        enum class ETimeMode : unsigned char
+        {
+            Normal,
+            Stealth,
+            Count
+        };
+
+        struct Mode
+        {
+            float time;
+            std::vector<std::pair<CustomGCode::Type, std::pair<float, float>>> custom_gcode_times;
+            std::vector<std::pair<EMoveType, float>> moves_times;
+            std::vector<std::pair<ExtrusionRole, float>> roles_times;
+            std::vector<float> layers_times;
+
+            void reset() {
+                time = 0.0f;
+                custom_gcode_times.clear();
+                moves_times.clear();
+                roles_times.clear();
+                layers_times.clear();
+            }
+        };
+
+        std::array<Mode, static_cast<size_t>(ETimeMode::Count)> modes;
+
+        PrintEstimatedTimeStatistics() { reset(); }
+
+        void reset() {
+            for (auto m : modes) {
+                m.reset();
+            }
+        }
+    };
+
+    class GCodeProcessor
+    {
+    public:
+        static const std::string Extrusion_Role_Tag;
+        static const std::string Height_Tag;
+        static const std::string Layer_Change_Tag;
+        static const std::string Color_Change_Tag;
+        static const std::string Pause_Print_Tag;
+        static const std::string Custom_Code_Tag;
+        static const std::string First_Line_M73_Placeholder_Tag;
+        static const std::string Last_Line_M73_Placeholder_Tag;
+        static const std::string Estimated_Printing_Time_Placeholder_Tag;
+
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
+        static const std::string Width_Tag;
+        static const std::string Mm3_Per_Mm_Tag;
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
+
+    private:
+        using AxisCoords = std::array<float, 4>;
+        using ExtruderColors = std::vector<unsigned char>;
+
+        enum class EUnits : unsigned char
+        {
+            Millimeters,
+            Inches
+        };
+
+        enum class EPositioningType : unsigned char
+        {
+            Absolute,
+            Relative
+        };
+
+        struct CachedPosition
+        {
+            AxisCoords position; // mm
+            float feedrate; // mm/s
+
+            void reset();
+        };
+
+        struct CpColor
+        {
+            unsigned char counter;
+            unsigned char current;
+
+            void reset();
+        };
+
+    public:
+        struct FeedrateProfile
+        {
+            float entry{ 0.0f }; // mm/s
+            float cruise{ 0.0f }; // mm/s
+            float exit{ 0.0f }; // mm/s
+        };
+
+        struct Trapezoid
+        {
+            float accelerate_until{ 0.0f }; // mm
+            float decelerate_after{ 0.0f }; // mm
+            float cruise_feedrate{ 0.0f }; // mm/sec
+
+            float acceleration_time(float entry_feedrate, float acceleration) const;
+            float cruise_time() const;
+            float deceleration_time(float distance, float acceleration) const;
+            float cruise_distance() const;
+        };
+
+        struct TimeBlock
+        {
+            struct Flags
+            {
+                bool recalculate{ false };
+                bool nominal_length{ false };
+            };
+
+            EMoveType move_type{ EMoveType::Noop };
+            ExtrusionRole role{ erNone };
+            unsigned int layer_id{ 0 };
+            float distance{ 0.0f }; // mm
+            float acceleration{ 0.0f }; // mm/s^2
+            float max_entry_speed{ 0.0f }; // mm/s
+            float safe_feedrate{ 0.0f }; // mm/s
+            Flags flags;
+            FeedrateProfile feedrate_profile;
+            Trapezoid trapezoid;
+
+            // Calculates this block's trapezoid
+            void calculate_trapezoid();
+
+            float time() const;
+        };
+
+    private:
+        struct TimeMachine
+        {
+            struct State
+            {
+                float feedrate; // mm/s
+                float safe_feedrate; // mm/s
+                AxisCoords axis_feedrate; // mm/s
+                AxisCoords abs_axis_feedrate; // mm/s
+
+                void reset();
+            };
+
+            struct CustomGCodeTime
+            {
+                bool needed;
+                float cache;
+                std::vector<std::pair<CustomGCode::Type, float>> times;
+
+                void reset();
+            };
+
+            bool enabled;
+            float acceleration; // mm/s^2
+            // hard limit for the acceleration, to which the firmware will clamp.
+            float max_acceleration; // mm/s^2
+            float extrude_factor_override_percentage;
+            float time; // s
+            std::string line_m73_mask;
+            State curr;
+            State prev;
+            CustomGCodeTime gcode_time;
+            std::vector<TimeBlock> blocks;
+            std::vector<float> g1_times_cache;
+            std::array<float, static_cast<size_t>(EMoveType::Count)> moves_time;
+            std::array<float, static_cast<size_t>(ExtrusionRole::erCount)> roles_time;
+            std::vector<float> layers_time;
+
+            void reset();
+
+            // Simulates firmware st_synchronize() call
+            void simulate_st_synchronize(float additional_time = 0.0f);
+            void calculate_time(size_t keep_last_n_blocks = 0);
+        };
+
+        struct TimeProcessor
+        {
+            struct Planner
+            {
+                // Size of the firmware planner queue. The old 8-bit Marlins usually just managed 16 trapezoidal blocks.
+                // Let's be conservative and plan for newer boards with more memory.
+                static constexpr size_t queue_size = 64;
+                // The firmware recalculates last planner_queue_size trapezoidal blocks each time a new block is added.
+                // We are not simulating the firmware exactly, we calculate a sequence of blocks once a reasonable number of blocks accumulate.
+                static constexpr size_t refresh_threshold = queue_size * 4;
+            };
+
+            // extruder_id is currently used to correctly calculate filament load / unload times into the total print time.
+            // This is currently only really used by the MK3 MMU2:
+            // extruder_unloaded = true means no filament is loaded yet, all the filaments are parked in the MK3 MMU2 unit.
+            bool extruder_unloaded;
+            // whether or not to export post-process the gcode to export lines M73 in it
+            bool export_remaining_time_enabled;
+            // allow to skip the lines M201/M203/M204/M205 generated by GCode::print_machine_envelope()
+            bool machine_envelope_processing_enabled;
+            MachineEnvelopeConfig machine_limits;
+            // Additional load / unload times for a filament exchange sequence.
+            std::vector<float> filament_load_times;
+            std::vector<float> filament_unload_times;
+            std::array<TimeMachine, static_cast<size_t>(PrintEstimatedTimeStatistics::ETimeMode::Count)> machines;
+
+            void reset();
+
+            // post process the file with the given filename to add remaining time lines M73
+            void post_process(const std::string& filename);
+        };
+
+    public:
+        struct MoveVertex
+        {
+            EMoveType type{ EMoveType::Noop };
+            ExtrusionRole extrusion_role{ erNone };
+            unsigned char extruder_id{ 0 };
+            unsigned char cp_color_id{ 0 };
+            Vec3f position{ Vec3f::Zero() }; // mm
+            float delta_extruder{ 0.0f }; // mm
+            float feedrate{ 0.0f }; // mm/s
+            float width{ 0.0f }; // mm
+            float height{ 0.0f }; // mm
+            float mm3_per_mm{ 0.0f };
+            float fan_speed{ 0.0f }; // percentage
+            float time{ 0.0f }; // s
+
+            float volumetric_rate() const { return feedrate * mm3_per_mm; }
+        };
+
+        struct Result
+        {
+            unsigned int id;
+            std::vector<MoveVertex> moves;
+            Pointfs bed_shape;
+            std::string printer_settings_id;
+            std::vector<std::string> extruder_colors;
+            PrintEstimatedTimeStatistics time_statistics;
+
+#if ENABLE_GCODE_VIEWER_STATISTICS
+            long long time{ 0 };
+            void reset()
+            {
+                time = 0;
+                moves = std::vector<MoveVertex>();
+                bed_shape = Pointfs();
+                extruder_colors = std::vector<std::string>();
+            }
+#else
+            void reset()
+            {
+                moves = std::vector<MoveVertex>();
+                bed_shape = Pointfs();
+                extruder_colors = std::vector<std::string>();
+            }
+#endif // ENABLE_GCODE_VIEWER_STATISTICS
+        };
+
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
+        struct DataChecker
+        {
+            struct Error
+            {
+                float value;
+                float tag_value;
+                ExtrusionRole role;
+            };
+
+            std::string type;
+            float threshold{ 0.01f };
+            float last_tag_value{ 0.0f };
+            unsigned int count{ 0 };
+            std::vector<Error> errors;
+
+            DataChecker(const std::string& type, float threshold)
+                : type(type), threshold(threshold)
+            {}
+
+            void update(float value, ExtrusionRole role) {
+                ++count;
+                if (last_tag_value != 0.0f) {
+                    if (std::abs(value - last_tag_value) / last_tag_value > threshold)
+                        errors.push_back({ value, last_tag_value, role });
+                }
+            }
+
+            void reset() { last_tag_value = 0.0f; errors.clear(); count = 0; }
+
+            std::pair<float, float> get_min() const {
+                float delta_min = FLT_MAX;
+                float perc_min = 0.0f;
+                for (const Error& e : errors) {
+                    if (delta_min > e.value - e.tag_value) {
+                        delta_min = e.value - e.tag_value;
+                        perc_min = 100.0f * delta_min / e.tag_value;
+                    }
+                }
+                return { delta_min, perc_min };
+            }
+
+            std::pair<float, float> get_max() const {
+                float delta_max = -FLT_MAX;
+                float perc_max = 0.0f;
+                for (const Error& e : errors) {
+                    if (delta_max < e.value - e.tag_value) {
+                        delta_max = e.value - e.tag_value;
+                        perc_max = 100.0f * delta_max / e.tag_value;
+                    }
+                }
+                return { delta_max, perc_max };
+            }
+
+            void output() const {
+                if (!errors.empty()) {
+                    std::cout << type << ":\n";
+                    std::cout << "Errors: " << errors.size() << " (" << 100.0f * float(errors.size()) / float(count) << "%)\n";
+                    auto [min, perc_min] = get_min();
+                    auto [max, perc_max] = get_max();
+                    std::cout << "min: " << min << "(" << perc_min << "%) - max: " << max << "(" << perc_max << "%)\n";
+                }
+            }
+        };
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
+
+    private:
+        GCodeReader m_parser;
+
+        EUnits m_units;
+        EPositioningType m_global_positioning_type;
+        EPositioningType m_e_local_positioning_type;
+        std::vector<Vec3f> m_extruder_offsets;
+        GCodeFlavor m_flavor;
+
+        AxisCoords m_start_position; // mm
+        AxisCoords m_end_position; // mm
+        AxisCoords m_origin; // mm
+        CachedPosition m_cached_position;
+
+        float m_feedrate; // mm/s
+        float m_width; // mm
+        float m_height; // mm
+        float m_mm3_per_mm;
+        float m_fan_speed; // percentage
+        ExtrusionRole m_extrusion_role;
+        unsigned char m_extruder_id;
+        ExtruderColors m_extruder_colors;
+        std::vector<float> m_filament_diameters;
+        float m_extruded_last_z;
+        unsigned int m_layer_id;
+        CpColor m_cp_color;
+
+        enum class EProducer
+        {
+            Unknown,
+            PrusaSlicer,
+            Cura,
+            Simplify3D,
+            CraftWare,
+            ideaMaker
+        };
+
+        static const std::vector<std::pair<GCodeProcessor::EProducer, std::string>> Producers;
+        EProducer m_producer;
+        bool m_producers_enabled;
+
+        TimeProcessor m_time_processor;
+
+        Result m_result;
+        static unsigned int s_result_id;
+
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
+        DataChecker m_mm3_per_mm_compare{ "mm3_per_mm", 0.01f };
+        DataChecker m_height_compare{ "height", 0.01f };
+        DataChecker m_width_compare{ "width", 0.01f };
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
+
+    public:
+        GCodeProcessor();
+
+        void apply_config(const PrintConfig& config);
+        void apply_config(const DynamicPrintConfig& config);
+        void enable_stealth_time_estimator(bool enabled);
+        bool is_stealth_time_estimator_enabled() const {
+            return m_time_processor.machines[static_cast<size_t>(PrintEstimatedTimeStatistics::ETimeMode::Stealth)].enabled;
+        }
+        void enable_machine_envelope_processing(bool enabled) { m_time_processor.machine_envelope_processing_enabled = enabled; }
+        void enable_producers(bool enabled) { m_producers_enabled = enabled; }
+        void reset();
+
+        const Result& get_result() const { return m_result; }
+        Result&& extract_result() { return std::move(m_result); }
+
+        // Process the gcode contained in the file with the given filename
+        // throws CanceledException through print->throw_if_canceled() (sent by the caller as callback).
+        void process_file(const std::string& filename, std::function<void()> cancel_callback = nullptr);
+
+        float get_time(PrintEstimatedTimeStatistics::ETimeMode mode) const;
+        std::string get_time_dhm(PrintEstimatedTimeStatistics::ETimeMode mode) const;
+        std::vector<std::pair<CustomGCode::Type, std::pair<float, float>>> get_custom_gcode_times(PrintEstimatedTimeStatistics::ETimeMode mode, bool include_remaining) const;
+
+        std::vector<std::pair<EMoveType, float>> get_moves_time(PrintEstimatedTimeStatistics::ETimeMode mode) const;
+        std::vector<std::pair<ExtrusionRole, float>> get_roles_time(PrintEstimatedTimeStatistics::ETimeMode mode) const;
+        std::vector<float> get_layers_time(PrintEstimatedTimeStatistics::ETimeMode mode) const;
+
+    private:
+        void process_gcode_line(const GCodeReader::GCodeLine& line);
+
+        // Process tags embedded into comments
+        void process_tags(const std::string& comment);
+        bool process_producers_tags(const std::string& comment);
+        bool process_prusaslicer_tags(const std::string& comment);
+        bool process_cura_tags(const std::string& comment);
+        bool process_simplify3d_tags(const std::string& comment);
+        bool process_craftware_tags(const std::string& comment);
+        bool process_ideamaker_tags(const std::string& comment);
+
+        bool detect_producer(const std::string& comment);
+
+        // Move
+        void process_G0(const GCodeReader::GCodeLine& line);
+        void process_G1(const GCodeReader::GCodeLine& line);
+
+        // Retract
+        void process_G10(const GCodeReader::GCodeLine& line);
+
+        // Unretract
+        void process_G11(const GCodeReader::GCodeLine& line);
+
+        // Set Units to Inches
+        void process_G20(const GCodeReader::GCodeLine& line);
+
+        // Set Units to Millimeters
+        void process_G21(const GCodeReader::GCodeLine& line);
+
+        // Firmware controlled Retract
+        void process_G22(const GCodeReader::GCodeLine& line);
+
+        // Firmware controlled Unretract
+        void process_G23(const GCodeReader::GCodeLine& line);
+
+        // Set to Absolute Positioning
+        void process_G90(const GCodeReader::GCodeLine& line);
+
+        // Set to Relative Positioning
+        void process_G91(const GCodeReader::GCodeLine& line);
+
+        // Set Position
+        void process_G92(const GCodeReader::GCodeLine& line);
+
+        // Sleep or Conditional stop
+        void process_M1(const GCodeReader::GCodeLine& line);
+
+        // Set extruder to absolute mode
+        void process_M82(const GCodeReader::GCodeLine& line);
+
+        // Set extruder to relative mode
+        void process_M83(const GCodeReader::GCodeLine& line);
+
+        // Set fan speed
+        void process_M106(const GCodeReader::GCodeLine& line);
+
+        // Disable fan
+        void process_M107(const GCodeReader::GCodeLine& line);
+
+        // Set tool (Sailfish)
+        void process_M108(const GCodeReader::GCodeLine& line);
+
+        // Recall stored home offsets
+        void process_M132(const GCodeReader::GCodeLine& line);
+
+        // Set tool (MakerWare)
+        void process_M135(const GCodeReader::GCodeLine& line);
+
+        // Set max printing acceleration
+        void process_M201(const GCodeReader::GCodeLine& line);
+
+        // Set maximum feedrate
+        void process_M203(const GCodeReader::GCodeLine& line);
+
+        // Set default acceleration
+        void process_M204(const GCodeReader::GCodeLine& line);
+
+        // Advanced settings
+        void process_M205(const GCodeReader::GCodeLine& line);
+
+        // Set extrude factor override percentage
+        void process_M221(const GCodeReader::GCodeLine& line);
+
+        // Repetier: Store x, y and z position
+        void process_M401(const GCodeReader::GCodeLine& line);
+
+        // Repetier: Go to stored position
+        void process_M402(const GCodeReader::GCodeLine& line);
+
+        // Set allowable instantaneous speed change
+        void process_M566(const GCodeReader::GCodeLine& line);
+
+        // Unload the current filament into the MK3 MMU2 unit at the end of print.
+        void process_M702(const GCodeReader::GCodeLine& line);
+
+        // Processes T line (Select Tool)
+        void process_T(const GCodeReader::GCodeLine& line);
+        void process_T(const std::string& command);
+
+        void store_move_vertex(EMoveType type);
+
+        float minimum_feedrate(PrintEstimatedTimeStatistics::ETimeMode mode, float feedrate) const;
+        float minimum_travel_feedrate(PrintEstimatedTimeStatistics::ETimeMode mode, float feedrate) const;
+        float get_axis_max_feedrate(PrintEstimatedTimeStatistics::ETimeMode mode, Axis axis) const;
+        float get_axis_max_acceleration(PrintEstimatedTimeStatistics::ETimeMode mode, Axis axis) const;
+        float get_axis_max_jerk(PrintEstimatedTimeStatistics::ETimeMode mode, Axis axis) const;
+        float get_retract_acceleration(PrintEstimatedTimeStatistics::ETimeMode mode) const;
+        float get_acceleration(PrintEstimatedTimeStatistics::ETimeMode mode) const;
+        void set_acceleration(PrintEstimatedTimeStatistics::ETimeMode mode, float value);
+        float get_filament_load_time(size_t extruder_id);
+        float get_filament_unload_time(size_t extruder_id);
+
+        void process_custom_gcode_time(CustomGCode::Type code);
+
+        // Simulates firmware st_synchronize() call
+        void simulate_st_synchronize(float additional_time = 0.0f);
+
+        void update_estimated_times_stats();
+   };
+
+} /* namespace Slic3r */
+
+#endif // ENABLE_GCODE_VIEWER
+
+#endif /* slic3r_GCodeProcessor_hpp_ */
+
+

src/libslic3r/GCode/PostProcessor.cpp

@@ -79,7 +79,7 @@ static DWORD execute_process_winapi(const std::wstring &command_line)
 	if (! ::CreateProcessW(
             nullptr /* lpApplicationName */, (LPWSTR)command_line.c_str(), nullptr /* lpProcessAttributes */, nullptr /* lpThreadAttributes */, false /* bInheritHandles */,
 			CREATE_UNICODE_ENVIRONMENT /* | CREATE_NEW_CONSOLE */ /* dwCreationFlags */, (LPVOID)envstr.c_str(), nullptr /* lpCurrentDirectory */, &startup_info, &process_info))
-		throw std::runtime_error(std::string("Failed starting the script ") + boost::nowide::narrow(command_line) + ", Win32 error: " + std::to_string(int(::GetLastError())));
+		throw Slic3r::RuntimeError(std::string("Failed starting the script ") + boost::nowide::narrow(command_line) + ", Win32 error: " + std::to_string(int(::GetLastError())));
 	::WaitForSingleObject(process_info.hProcess, INFINITE);
 	ULONG rc = 0;
 	::GetExitCodeProcess(process_info.hProcess, &rc);
@@ -98,13 +98,13 @@ static int run_script(const std::string &script, const std::string &gcode, std::
     LPWSTR *szArglist = CommandLineToArgvW(boost::nowide::widen(script).c_str(), &nArgs);
     if (szArglist == nullptr || nArgs <= 0) {
         // CommandLineToArgvW failed. Maybe the command line escapment is invalid?
-		throw std::runtime_error(std::string("Post processing script ") + script + " on file " + gcode + " failed. CommandLineToArgvW() refused to parse the command line path.");
+		throw Slic3r::RuntimeError(std::string("Post processing script ") + script + " on file " + gcode + " failed. CommandLineToArgvW() refused to parse the command line path.");
     }
 
     std::wstring command_line;
     std::wstring command = szArglist[0];
 	if (! boost::filesystem::exists(boost::filesystem::path(command)))
-		throw std::runtime_error(std::string("The configured post-processing script does not exist: ") + boost::nowide::narrow(command));
+		throw Slic3r::RuntimeError(std::string("The configured post-processing script does not exist: ") + boost::nowide::narrow(command));
     if (boost::iends_with(command, L".pl")) {
         // This is a perl script. Run it through the perl interpreter.
         // The current process may be slic3r.exe or slic3r-console.exe.
@@ -115,7 +115,7 @@ static int run_script(const std::string &script, const std::string &gcode, std::
         boost::filesystem::path path_perl = path_exe.parent_path() / "perl" / "perl.exe";
         if (! boost::filesystem::exists(path_perl)) {
 			LocalFree(szArglist);
-			throw std::runtime_error(std::string("Perl interpreter ") + path_perl.string() + " does not exist.");
+			throw Slic3r::RuntimeError(std::string("Perl interpreter ") + path_perl.string() + " does not exist.");
         }
         // Replace it with the current perl interpreter.
         quote_argv_winapi(boost::nowide::widen(path_perl.string()), command_line);
@@ -187,7 +187,7 @@ void run_post_process_scripts(const std::string &path, const PrintConfig &config
     config.setenv_();
     auto gcode_file = boost::filesystem::path(path);
     if (! boost::filesystem::exists(gcode_file))
-        throw std::runtime_error(std::string("Post-processor can't find exported gcode file"));
+        throw Slic3r::RuntimeError(std::string("Post-processor can't find exported gcode file"));
 
     for (const std::string &scripts : config.post_process.values) {
 		std::vector<std::string> lines;
@@ -205,7 +205,7 @@ void run_post_process_scripts(const std::string &path, const PrintConfig &config
                 const std::string msg = std_err.empty() ? (boost::format("Post-processing script %1% on file %2% failed.\nError code: %3%") % script % path % result).str()
                     : (boost::format("Post-processing script %1% on file %2% failed.\nError code: %3%\nOutput:\n%4%") % script % path % result % std_err).str();
                 BOOST_LOG_TRIVIAL(error) << msg;
-                throw std::runtime_error(msg);
+                throw Slic3r::RuntimeError(msg);
             }
         }
     }

src/libslic3r/GCode/PressureEqualizer.cpp

@@ -148,7 +148,7 @@ static inline int parse_int(const char *&line)
     char *endptr = NULL;
     long result = strtol(line, &endptr, 10);
     if (endptr == NULL || !is_ws_or_eol(*endptr))
-        throw std::runtime_error("PressureEqualizer: Error parsing an int");
+        throw Slic3r::RuntimeError("PressureEqualizer: Error parsing an int");
     line = endptr;
     return int(result);
 };
@@ -160,7 +160,7 @@ static inline float parse_float(const char *&line)
     char *endptr = NULL;
     float result = strtof(line, &endptr);
     if (endptr == NULL || !is_ws_or_eol(*endptr))
-        throw std::runtime_error("PressureEqualizer: Error parsing a float");
+        throw Slic3r::RuntimeError("PressureEqualizer: Error parsing a float");
     line = endptr;
     return result;
 };
@@ -229,7 +229,7 @@ bool PressureEqualizer::process_line(const char *line, const size_t len, GCodeLi
                     assert(false);
                 }
                 if (i == -1)
-                    throw std::runtime_error(std::string("GCode::PressureEqualizer: Invalid axis for G0/G1: ") + axis);
+                    throw Slic3r::RuntimeError(std::string("GCode::PressureEqualizer: Invalid axis for G0/G1: ") + axis);
                 buf.pos_provided[i] = true;
                 new_pos[i] = parse_float(line);
                 if (i == 3 && m_config->use_relative_e_distances.value)
@@ -298,7 +298,7 @@ bool PressureEqualizer::process_line(const char *line, const size_t len, GCodeLi
                     set = true;
                     break;
                 default:
-                    throw std::runtime_error(std::string("GCode::PressureEqualizer: Incorrect axis in a G92 G-code: ") + axis);
+                    throw Slic3r::RuntimeError(std::string("GCode::PressureEqualizer: Incorrect axis in a G92 G-code: ") + axis);
                 }
                 eatws(line);
             }

src/libslic3r/GCode/PreviewData.cpp

@@ -5,6 +5,8 @@
 
 #include <boost/format.hpp>
 
+#if !ENABLE_GCODE_VIEWER
+
 //! macro used to mark string used at localization, 
 #define L(s) (s)
 
@@ -516,3 +518,5 @@ Color operator * (float f, const Color& color)
 }
 
 } // namespace Slic3r
+
+#endif // !ENABLE_GCODE_VIEWER

src/libslic3r/GCode/PreviewData.hpp

@@ -1,6 +1,8 @@
 #ifndef slic3r_GCode_PreviewData_hpp_
 #define slic3r_GCode_PreviewData_hpp_
 
+#if !ENABLE_GCODE_VIEWER
+
 #include "../libslic3r.h"
 #include "../ExtrusionEntity.hpp"
 #include "../Point.hpp"
@@ -56,8 +58,7 @@ public:
     // Color mapping to convert a float into a smooth rainbow of 10 colors.
     class RangeBase
     {
-        public:
-
+    public:
         virtual void reset() = 0;
         virtual bool empty() const = 0;
         virtual float min() const = 0;
@@ -73,7 +74,7 @@ public:
     // Color mapping converting a float in a range between a min and a max into a smooth rainbow of 10 colors.
     class Range : public RangeBase
     {
-        public:
+    public:
         Range();
 
         // RangeBase Overrides
@@ -97,8 +98,7 @@ public:
     template <typename EnumRangeType>
     class MultiRange : public RangeBase
     {
-        public:
-
+    public:
         void reset() override
         {
             bounds = decltype(bounds){};
@@ -160,8 +160,7 @@ public:
             mode.set(static_cast<std::size_t>(range_type_value), enable);
         }
 
-        private:
-
+    private:
         // Interval bounds
         struct Bounds
         {
@@ -394,4 +393,6 @@ public:
 
 } // namespace Slic3r
 
+#endif // !ENABLE_GCODE_VIEWER
+
 #endif /* slic3r_GCode_PreviewData_hpp_ */

src/libslic3r/GCode/PrintExtents.cpp

@@ -94,7 +94,7 @@ static BoundingBoxf extrusionentity_extents(const ExtrusionEntity *extrusion_ent
     auto *extrusion_entity_collection = dynamic_cast<const ExtrusionEntityCollection*>(extrusion_entity);
     if (extrusion_entity_collection != nullptr)
         return extrusionentity_extents(*extrusion_entity_collection);
-    throw std::runtime_error("Unexpected extrusion_entity type in extrusionentity_extents()");
+    throw Slic3r::RuntimeError("Unexpected extrusion_entity type in extrusionentity_extents()");
     return BoundingBoxf();
 }
 

src/libslic3r/GCode/WipeTower.cpp

@@ -21,7 +21,11 @@ TODO LIST
 #include <vector>
 #include <numeric>
 
+#if ENABLE_GCODE_VIEWER
+#include "GCodeProcessor.hpp"
+#else
 #include "Analyzer.hpp"
+#endif // ENABLE_GCODE_VIEWER
 #include "BoundingBox.hpp"
 
 #if defined(__linux) || defined(__GNUC__ )
@@ -47,36 +51,69 @@ public:
 		m_extrusion_flow(0.f),
 		m_preview_suppressed(false),
 		m_elapsed_time(0.f),
+#if !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
         m_default_analyzer_line_width(line_width),
+#endif // !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
         m_gcode_flavor(flavor),
         m_filpar(filament_parameters)
         {
             // adds tag for analyzer:
             char buf[64];
+#if ENABLE_GCODE_VIEWER
+            sprintf(buf, ";%s%f\n", GCodeProcessor::Height_Tag.c_str(), m_layer_height); // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
+            m_gcode += buf;
+            sprintf(buf, ";%s%s\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), ExtrusionEntity::role_to_string(erWipeTower).c_str());
+            m_gcode += buf;
+#else
             sprintf(buf, ";%s%f\n", GCodeAnalyzer::Height_Tag.c_str(), m_layer_height); // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
             m_gcode += buf;
             sprintf(buf, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erWipeTower);
             m_gcode += buf;
+#endif // ENABLE_GCODE_VIEWER
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
             change_analyzer_line_width(line_width);
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
         }
 
-    WipeTowerWriter&              change_analyzer_line_width(float line_width) {
-            // adds tag for analyzer:
-            char buf[64];
-            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Width_Tag.c_str(), line_width);
-            m_gcode += buf;
-            return *this;
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
+    WipeTowerWriter& change_analyzer_line_width(float line_width) {
+        // adds tag for analyzer:
+        char buf[64];
+        sprintf(buf, ";%s%f\n", GCodeProcessor::Width_Tag.c_str(), line_width);
+        m_gcode += buf;
+        return *this;
     }
 
-    WipeTowerWriter&          change_analyzer_mm3_per_mm(float len, float e) {
-            static const float area = float(M_PI) * 1.75f * 1.75f / 4.f;
-            float mm3_per_mm = (len == 0.f ? 0.f : area * e / len);
-            // adds tag for analyzer:
-            char buf[64];
-            sprintf(buf, ";%s%f\n", GCodeAnalyzer::Mm3_Per_Mm_Tag.c_str(), mm3_per_mm);
-            m_gcode += buf;
-            return *this;
+    WipeTowerWriter& change_analyzer_mm3_per_mm(float len, float e) {
+        static const float area = float(M_PI) * 1.75f * 1.75f / 4.f;
+        float mm3_per_mm = (len == 0.f ? 0.f : area * e / len);
+        // adds tag for processor:
+        char buf[64];
+        sprintf(buf, ";%s%f\n", GCodeProcessor::Mm3_Per_Mm_Tag.c_str(), mm3_per_mm);
+        m_gcode += buf;
+        return *this;
     }
+#else
+#if !ENABLE_GCODE_VIEWER
+    WipeTowerWriter& change_analyzer_line_width(float line_width) {
+        // adds tag for analyzer:
+        char buf[64];
+        sprintf(buf, ";%s%f\n", GCodeAnalyzer::Width_Tag.c_str(), line_width);
+        m_gcode += buf;
+        return *this;
+    }
+
+    WipeTowerWriter& change_analyzer_mm3_per_mm(float len, float e) {
+        static const float area = float(M_PI) * 1.75f * 1.75f / 4.f;
+        float mm3_per_mm = (len == 0.f ? 0.f : area * e / len);
+        // adds tag for analyzer:
+        char buf[64];
+        sprintf(buf, ";%s%f\n", GCodeAnalyzer::Mm3_Per_Mm_Tag.c_str(), mm3_per_mm);
+        m_gcode += buf;
+        return *this;
+    }
+#endif // !ENABLE_GCODE_VIEWER
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
 	WipeTowerWriter& 			 set_initial_position(const Vec2f &pos, float width = 0.f, float depth = 0.f, float internal_angle = 0.f) {
         m_wipe_tower_width = width;
@@ -111,8 +148,13 @@ public:
 	// Suppress / resume G-code preview in Slic3r. Slic3r will have difficulty to differentiate the various
 	// filament loading and cooling moves from normal extrusion moves. Therefore the writer
 	// is asked to suppres output of some lines, which look like extrusions.
-	WipeTowerWriter& 			 suppress_preview() { change_analyzer_line_width(0.f); m_preview_suppressed = true; return *this; }
-	WipeTowerWriter& 			 resume_preview()   { change_analyzer_line_width(m_default_analyzer_line_width); m_preview_suppressed = false; return *this; }
+#if !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
+    WipeTowerWriter& suppress_preview() { change_analyzer_line_width(0.f); m_preview_suppressed = true; return *this; }
+    WipeTowerWriter& resume_preview() { change_analyzer_line_width(m_default_analyzer_line_width); m_preview_suppressed = false; return *this; }
+#else
+    WipeTowerWriter& 			 suppress_preview() { m_preview_suppressed = true; return *this; }
+	WipeTowerWriter& 			 resume_preview()   { m_preview_suppressed = false; return *this; }
+#endif // !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
 
 	WipeTowerWriter& 			 feedrate(float f)
 	{
@@ -149,8 +191,14 @@ public:
 		Vec2f rot(this->rotate(Vec2f(x,y)));                               // this is where we want to go
 
         if (! m_preview_suppressed && e > 0.f && len > 0.f) {
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
             change_analyzer_mm3_per_mm(len, e);
-			// Width of a squished extrusion, corrected for the roundings of the squished extrusions.
+#else
+#if !ENABLE_GCODE_VIEWER
+            change_analyzer_mm3_per_mm(len, e);
+#endif // !ENABLE_GCODE_VIEWER
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
+            // Width of a squished extrusion, corrected for the roundings of the squished extrusions.
 			// This is left zero if it is a travel move.
             float width = e * m_filpar[0].filament_area / (len * m_layer_height);
 			// Correct for the roundings of a squished extrusion.
@@ -411,7 +459,9 @@ private:
 	float		  m_wipe_tower_depth = 0.f;
     unsigned      m_last_fan_speed = 0;
     int           current_temp = -1;
+#if !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
     const float   m_default_analyzer_line_width;
+#endif // !ENABLE_GCODE_VIEWER || ENABLE_GCODE_VIEWER_DATA_CHECKING
     float         m_used_filament_length = 0.f;
     GCodeFlavor   m_gcode_flavor;
     const std::vector<WipeTower::FilamentParameters>& m_filpar;
@@ -852,8 +902,12 @@ void WipeTower::toolchange_Unload(
 	const float line_width = m_perimeter_width * m_filpar[m_current_tool].ramming_line_width_multiplicator;       // desired ramming line thickness
 	const float y_step = line_width * m_filpar[m_current_tool].ramming_step_multiplicator * m_extra_spacing; // spacing between lines in mm
 
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
     writer.append("; CP TOOLCHANGE UNLOAD\n")
-          .change_analyzer_line_width(line_width);
+        .change_analyzer_line_width(line_width);
+#else
+    writer.append("; CP TOOLCHANGE UNLOAD\n");
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
 	unsigned i = 0;										// iterates through ramming_speed
 	m_left_to_right = true;								// current direction of ramming
@@ -930,7 +984,9 @@ void WipeTower::toolchange_Unload(
 		}
 	}
 	Vec2f end_of_ramming(writer.x(),writer.y());
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
     writer.change_analyzer_line_width(m_perimeter_width);   // so the next lines are not affected by ramming_line_width_multiplier
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
     // Retraction:
     float old_x = writer.x();