GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-07-31 06:42:05 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Integrated library libbgcode

Browse Source
This commit is contained in:
enricoturri1966 2023-08-03 12:57:55 +02:00
parent c82f9c7627
commit ec16420f11
8 changed files with 112 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/libslic3r/GCode.cpp
View File

@ -841,7 +841,7 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
m_processor.initialize(path_tmp);
m_processor.set_print(print);
#if ENABLE_BINARIZED_GCODE
m_processor.get_binary_data().reset();
m_processor.get_binary_data() = bgcode::base::BinaryData();
#endif // ENABLE_BINARIZED_GCODE
GCodeOutputStream file(boost::nowide::fopen(path_tmp.c_str(), "wb"), m_processor);
if (! file.is_open())
@ -984,7 +984,7 @@ namespace DoExport {
unsigned int initial_extruder_id,
PrintStatistics &print_statistics,
bool export_binary_data,
bgcode::BinaryData &binary_data)
bgcode::base::BinaryData &binary_data)
#else
static std::string update_print_stats_and_format_filament_stats(
const bool has_wipe_tower,
@ -1132,7 +1132,7 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
// 1) generate the thumbnails
// 2) collect the config data
if (export_to_binary_gcode) {
bgcode::BinaryData& binary_data = m_processor.get_binary_data();
bgcode::base::BinaryData& binary_data = m_processor.get_binary_data();
// Unit tests or command line slicing may not define "thumbnails" or "thumbnails_format".
// If "thumbnails_format" is not defined, export to PNG.
@ -1146,11 +1146,11 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
}
// file data
binary_data.file_metadata.encoding_type = (uint16_t)bgcode::EMetadataEncodingType::INI;
binary_data.file_metadata.encoding_type = (uint16_t)bgcode::core::EMetadataEncodingType::INI;
binary_data.file_metadata.raw_data.emplace_back("Producer", std::string(SLIC3R_APP_NAME) + " " + std::string(SLIC3R_VERSION));
// config data
binary_data.slicer_metadata.encoding_type = (uint16_t)bgcode::EMetadataEncodingType::INI;
binary_data.slicer_metadata.encoding_type = (uint16_t)bgcode::core::EMetadataEncodingType::INI;
encode_full_config(print, binary_data.slicer_metadata.raw_data);
// printer data
@ -1613,7 +1613,7 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
file.write(filament_stats_string_out);
if (export_to_binary_gcode) {
bgcode::BinaryData& binary_data = m_processor.get_binary_data();
bgcode::base::BinaryData& binary_data = m_processor.get_binary_data();
if (print.m_print_statistics.total_toolchanges > 0)
binary_data.print_metadata.raw_data.push_back({ "total toolchanges", std::to_string(print.m_print_statistics.total_toolchanges) });
}

7
src/libslic3r/GCode.hpp
View File

@ -21,9 +21,6 @@
#include "GCode/GCodeProcessor.hpp"
#include "EdgeGrid.hpp"
#include "GCode/ThumbnailData.hpp"
#if ENABLE_BINARIZED_GCODE
#include "GCode/GCodeBinarizer.hpp"
#endif // ENABLE_BINARIZED_GCODE
#include <memory>
#include <map>
@ -31,6 +28,10 @@
#include "GCode/PressureEqualizer.hpp"
#if ENABLE_BINARIZED_GCODE
#include <LibBGCode/base/base.hpp>
#endif // ENABLE_BINARIZED_GCODE
namespace Slic3r {
// Forward declarations.

141
src/libslic3r/GCode/GCodeProcessor.cpp
View File

@ -70,7 +70,7 @@ const float GCodeProcessor::Wipe_Width = 0.05f;
const float GCodeProcessor::Wipe_Height = 0.05f;
#if ENABLE_BINARIZED_GCODE
bgcode::BinarizerConfig GCodeProcessor::s_binarizer_config{};
bgcode::base::BinarizerConfig GCodeProcessor::s_binarizer_config{};
#endif // ENABLE_BINARIZED
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
@ -1041,7 +1041,7 @@ void GCodeProcessor::process_file(const std::string& filename, std::function<voi
if (file == nullptr)
throw Slic3r::RuntimeError("Error opening the file: " + filename + "\n");
const bool is_binary = bgcode::is_valid_binary_gcode(*file);
const bool is_binary = bgcode::core::is_valid_binary_gcode(*file, true) == bgcode::core::EResult::Success;
fclose(file);
if (is_binary)
@ -1145,27 +1145,27 @@ void GCodeProcessor::process_binary_file(const std::string& filename, std::funct
ScopedFile scoped_file(file);
bgcode::set_checksum_max_cache_size(1024);
bgcode::core::set_checksum_max_cache_size(1024);
// read file header
bgcode::FileHeader file_header;
bgcode::EResult res = bgcode::read_header(*file, file_header, &bgcode::VERSION);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("File: " + filename + "does not contain a valid binary gcode\n Error: " + bgcode::translate_result(res) + "\n");
bgcode::core::FileHeader file_header;
bgcode::core::EResult res = bgcode::core::read_header(*file, file_header, nullptr);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("File: " + filename + "does not contain a valid binary gcode\n Error: " + bgcode::core::translate_result(res) + "\n");
const bool verify_checksum = true;
// read file metadata block
bgcode::BlockHeader block_header;
res = bgcode::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if ((bgcode::EBlockType)block_header.type != bgcode::EBlockType::FileMetadata)
bgcode::core::BlockHeader block_header;
res = bgcode::core::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
if ((bgcode::core::EBlockType)block_header.type != bgcode::core::EBlockType::FileMetadata)
throw Slic3r::RuntimeError("Unable to find file metadata block in file: " + filename + "\n");
bgcode::FileMetadataBlock file_metadata_block;
bgcode::base::FileMetadataBlock file_metadata_block;
res = file_metadata_block.read_data(*file, file_header, block_header);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
auto producer_it = std::find_if(file_metadata_block.raw_data.begin(), file_metadata_block.raw_data.end(),
[](const std::pair<std::string, std::string>& item) { return item.first == "Producer"; });
if (producer_it != file_metadata_block.raw_data.end() && boost::starts_with(producer_it->second, std::string(SLIC3R_APP_NAME)))
@ -1174,15 +1174,15 @@ void GCodeProcessor::process_binary_file(const std::string& filename, std::funct
m_producer = EProducer::Unknown;
// read printer metadata block
res = bgcode::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if ((bgcode::EBlockType)block_header.type != bgcode::EBlockType::PrinterMetadata)
res = bgcode::core::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
if ((bgcode::core::EBlockType)block_header.type != bgcode::core::EBlockType::PrinterMetadata)
throw Slic3r::RuntimeError("Unable to find printer metadata block in file: " + filename + "\n");
bgcode::PrinterMetadataBlock printer_metadata_block;
bgcode::base::PrinterMetadataBlock printer_metadata_block;
res = printer_metadata_block.read_data(*file, file_header, block_header);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
#if ENABLE_BINARIZED_GCODE_DEBUG
OutputDebugStringA("Printer metadata:\n");
for (const auto& [key, value] : printer_metadata_block.raw_data) {
@ -1194,25 +1194,24 @@ void GCodeProcessor::process_binary_file(const std::string& filename, std::funct
#endif // ENABLE_BINARIZED_GCODE_DEBUG
// read thumbnail blocks
res = bgcode::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
res = bgcode::core::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
while ((bgcode::EBlockType)block_header.type == bgcode::EBlockType::Thumbnail) {
bgcode::ThumbnailBlock thumbnail_block;
while ((bgcode::core::EBlockType)block_header.type == bgcode::core::EBlockType::Thumbnail) {
bgcode::base::ThumbnailBlock thumbnail_block;
res = thumbnail_block.read_data(*file, file_header, block_header);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
#if ENABLE_BINARIZED_GCODE_DEBUG
if (thumbnail_block.data.size() > 0) {
auto format_filename = [](const std::string& stem, const bgcode::ThumbnailBlock& block) {
auto format_filename = [](const std::string& stem, const bgcode::base::ThumbnailBlock& block) {
std::string ret = stem + "_" + std::to_string(block.width) + "x" + std::to_string(block.height);
switch ((bgcode::EThumbnailFormat)block.format)
switch ((bgcode::core::EThumbnailFormat)block.format)
{
case bgcode::EThumbnailFormat::PNG: { ret += ".png"; break; }
case bgcode::EThumbnailFormat::JPG: { ret += ".jpg"; break; }
case bgcode::EThumbnailFormat::QOI: { ret += ".qoi"; break; }
case bgcode::core::EThumbnailFormat::PNG: { ret += ".png"; break; }
case bgcode::core::EThumbnailFormat::JPG: { ret += ".jpg"; break; }
case bgcode::core::EThumbnailFormat::QOI: { ret += ".qoi"; break; }
}
return ret;
};
@ -1228,18 +1227,18 @@ void GCodeProcessor::process_binary_file(const std::string& filename, std::funct
}
#endif // ENABLE_BINARIZED_GCODE_DEBUG
res = bgcode::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
res = bgcode::core::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
}
// read print metadata block
if ((bgcode::EBlockType)block_header.type != bgcode::EBlockType::PrintMetadata)
if ((bgcode::core::EBlockType)block_header.type != bgcode::core::EBlockType::PrintMetadata)
throw Slic3r::RuntimeError("Unable to find print metadata block in file: " + filename + "\n");
bgcode::PrintMetadataBlock print_metadata_block;
bgcode::base::PrintMetadataBlock print_metadata_block;
res = print_metadata_block.read_data(*file, file_header, block_header);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
#if ENABLE_BINARIZED_GCODE_DEBUG
OutputDebugStringA("Print metadata:\n");
for (const auto& [key, value] : print_metadata_block.raw_data) {
@ -1251,15 +1250,15 @@ void GCodeProcessor::process_binary_file(const std::string& filename, std::funct
#endif // ENABLE_BINARIZED_GCODE_DEBUG
// read slicer metadata block
res = bgcode::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if ((bgcode::EBlockType)block_header.type != bgcode::EBlockType::SlicerMetadata)
res = bgcode::core::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
if ((bgcode::core::EBlockType)block_header.type != bgcode::core::EBlockType::SlicerMetadata)
throw Slic3r::RuntimeError("Unable to find slicer metadata block in file: " + filename + "\n");
bgcode::SlicerMetadataBlock slicer_metadata_block;
bgcode::base::SlicerMetadataBlock slicer_metadata_block;
res = slicer_metadata_block.read_data(*file, file_header, block_header);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
#if ENABLE_BINARIZED_GCODE_DEBUG
OutputDebugStringA("Slicer metadata:\n");
for (const auto& [key, value] : slicer_metadata_block.raw_data) {
@ -1286,16 +1285,16 @@ void GCodeProcessor::process_binary_file(const std::string& filename, std::funct
initialize_result_moves();
// read gcodes block
res = bgcode::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if ((bgcode::EBlockType)block_header.type != bgcode::EBlockType::GCode)
res = bgcode::core::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
if ((bgcode::core::EBlockType)block_header.type != bgcode::core::EBlockType::GCode)
throw Slic3r::RuntimeError("Unable to find gcode block in file: " + filename + "\n");
while ((bgcode::EBlockType)block_header.type == bgcode::EBlockType::GCode) {
bgcode::GCodeBlock block;
while ((bgcode::core::EBlockType)block_header.type == bgcode::core::EBlockType::GCode) {
bgcode::base::GCodeBlock block;
res = block.read_data(*file, file_header, block_header);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
// TODO: Update m_result.lines_ends
@ -1306,9 +1305,9 @@ void GCodeProcessor::process_binary_file(const std::string& filename, std::funct
if (ftell(file) == file_size)
break;
res = bgcode::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::translate_result(res) + "\n");
res = bgcode::core::read_next_block_header(*file, file_header, block_header, verify_checksum);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError("Error while reading file: " + filename + ": " + bgcode::core::translate_result(res) + "\n");
}
// Don't post-process the G-code to update time stamps.
@ -3696,7 +3695,7 @@ void GCodeProcessor::post_process()
};
// update binary data
bgcode::BinaryData& binary_data = m_binarizer.get_binary_data();
bgcode::base::BinaryData& binary_data = m_binarizer.get_binary_data();
binary_data.print_metadata.raw_data.push_back({ PrintStatistics::FilamentUsedMm, stringify(filament_mm) });
binary_data.print_metadata.raw_data.push_back({ PrintStatistics::FilamentUsedCm3, stringify(filament_cm3) });
binary_data.print_metadata.raw_data.push_back({ PrintStatistics::FilamentUsedG, stringify(filament_g) });
@ -3720,8 +3719,8 @@ void GCodeProcessor::post_process()
}
}
const bgcode::EResult res = m_binarizer.initialize(*out.f, s_binarizer_config);
if (res != bgcode::EResult::Success)
const bgcode::core::EResult res = m_binarizer.initialize(*out.f, s_binarizer_config);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError(std::string("Unable to initialize the gcode binarizer.\n"));
}
#endif // ENABLE_BINARIZED_GCODE
@ -3843,12 +3842,12 @@ void GCodeProcessor::post_process()
size_t m_out_file_pos{ 0 };
#if ENABLE_BINARIZED_GCODE
bgcode::Binarizer& m_binarizer;
bgcode::base::Binarizer& m_binarizer;
#endif // ENABLE_BINARIZED_GCODE
public:
#if ENABLE_BINARIZED_GCODE
ExportLines(bgcode::Binarizer& binarizer, EWriteType type, TimeMachine& machine)
ExportLines(bgcode::base::Binarizer& binarizer, EWriteType type, TimeMachine& machine)
#ifndef NDEBUG
: m_statistics(*this), m_binarizer(binarizer), m_write_type(type), m_machine(machine) {}
#else
@ -3974,8 +3973,8 @@ void GCodeProcessor::post_process()
#if ENABLE_BINARIZED_GCODE
if (m_binarizer.is_enabled()) {
bgcode::EResult res = m_binarizer.append_gcode(out_string);
if (res != bgcode::EResult::Success)
bgcode::core::EResult res = m_binarizer.append_gcode(out_string);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError(std::string("Error while sending gcode to the binarizer.\n"));
}
else
@ -4011,8 +4010,8 @@ void GCodeProcessor::post_process()
#if ENABLE_BINARIZED_GCODE
if (m_binarizer.is_enabled()) {
bgcode::EResult res = m_binarizer.append_gcode(out_string);
if (res != bgcode::EResult::Success)
bgcode::core::EResult res = m_binarizer.append_gcode(out_string);
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError(std::string("Error while sending gcode to the binarizer.\n"));
}
else
@ -4391,8 +4390,8 @@ void GCodeProcessor::post_process()
#if ENABLE_BINARIZED_GCODE
if (m_binarizer.is_enabled()) {
const bgcode::EResult res = m_binarizer.finalize();
if (res != bgcode::EResult::Success)
const bgcode::core::EResult res = m_binarizer.finalize();
if (res != bgcode::core::EResult::Success)
throw Slic3r::RuntimeError(std::string("Error while finalizing the gcode binarizer.\n"));
}
#endif // ENABLE_BINARIZED_GCODE

12
src/libslic3r/GCode/GCodeProcessor.hpp
View File

@ -8,7 +8,7 @@
#include "libslic3r/CustomGCode.hpp"
#if ENABLE_BINARIZED_GCODE
#include "GCodeBinarizer.hpp"
#include <LibBGCode/base/base.hpp>
#endif // ENABLE_BINARIZED_GCODE
#include <cstdint>
@ -528,14 +528,14 @@ namespace Slic3r {
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
#if ENABLE_BINARIZED_GCODE_DEBUG_WINDOW
static bgcode::BinarizerConfig& get_binarizer_config() { return s_binarizer_config; }
static bgcode::base::BinarizerConfig& get_binarizer_config() { return s_binarizer_config; }
#endif // ENABLE_BINARIZED_GCODE_DEBUG_WINDOW
private:
GCodeReader m_parser;
#if ENABLE_BINARIZED_GCODE
bgcode::Binarizer m_binarizer;
static bgcode::BinarizerConfig s_binarizer_config;
bgcode::base::Binarizer m_binarizer;
static bgcode::base::BinarizerConfig s_binarizer_config;
#endif // ENABLE_BINARIZED_GCODE
EUnits m_units;
@ -635,8 +635,8 @@ namespace Slic3r {
void apply_config(const PrintConfig& config);
void set_print(Print* print) { m_print = print; }
#if ENABLE_BINARIZED_GCODE
bgcode::BinaryData& get_binary_data() { return m_binarizer.get_binary_data(); }
const bgcode::BinaryData& get_binary_data() const { return m_binarizer.get_binary_data(); }
bgcode::base::BinaryData& get_binary_data() { return m_binarizer.get_binary_data(); }
const bgcode::base::BinaryData& get_binary_data() const { return m_binarizer.get_binary_data(); }
#endif // ENABLE_BINARIZED_GCODE
void enable_stealth_time_estimator(bool enabled);

17
src/libslic3r/GCode/Thumbnails.hpp
View File

@ -4,14 +4,15 @@
#include "../Point.hpp"
#include "../PrintConfig.hpp"
#include "ThumbnailData.hpp"
#if ENABLE_BINARIZED_GCODE
#include "GCode/GCodeBinarizer.hpp"
#endif // ENABLE_BINARIZED_GCODE
#include <vector>
#include <memory>
#include <string_view>
#if ENABLE_BINARIZED_GCODE
#include <LibBGCode/base/base.hpp>
#endif // ENABLE_BINARIZED_GCODE
#include <boost/beast/core/detail/base64.hpp>
namespace Slic3r::GCodeThumbnails {
@ -60,7 +61,7 @@ inline void export_thumbnails_to_file(ThumbnailsGeneratorCallback &thumbnail_cb,
#if ENABLE_BINARIZED_GCODE
template<typename ThrowIfCanceledCallback>
inline void generate_binary_thumbnails(ThumbnailsGeneratorCallback& thumbnail_cb, std::vector<bgcode::ThumbnailBlock>& out_thumbnails,
inline void generate_binary_thumbnails(ThumbnailsGeneratorCallback& thumbnail_cb, std::vector<bgcode::base::ThumbnailBlock>& out_thumbnails,
const std::vector<Vec2d>& sizes, GCodeThumbnailsFormat format, ThrowIfCanceledCallback throw_if_canceled)
{
out_thumbnails.clear();
@ -70,13 +71,13 @@ inline void generate_binary_thumbnails(ThumbnailsGeneratorCallback& thumbnail_cb
if (data.is_valid()) {
auto compressed = compress_thumbnail(data, format);
if (compressed->data != nullptr && compressed->size > 0) {
bgcode::ThumbnailBlock& block = out_thumbnails.emplace_back(bgcode::ThumbnailBlock());
bgcode::base::ThumbnailBlock& block = out_thumbnails.emplace_back(bgcode::base::ThumbnailBlock());
block.width = (uint16_t)data.width;
block.height = (uint16_t)data.height;
switch (format) {
case GCodeThumbnailsFormat::PNG: { block.format = (uint16_t)bgcode::EThumbnailFormat::PNG; break; }
case GCodeThumbnailsFormat::JPG: { block.format = (uint16_t)bgcode::EThumbnailFormat::JPG; break; }
case GCodeThumbnailsFormat::QOI: { block.format = (uint16_t)bgcode::EThumbnailFormat::QOI; break; }
case GCodeThumbnailsFormat::PNG: { block.format = (uint16_t)bgcode::core::EThumbnailFormat::PNG; break; }
case GCodeThumbnailsFormat::JPG: { block.format = (uint16_t)bgcode::core::EThumbnailFormat::JPG; break; }
case GCodeThumbnailsFormat::QOI: { block.format = (uint16_t)bgcode::core::EThumbnailFormat::QOI; break; }
}
block.data.resize(compressed->size);
memcpy(block.data.data(), compressed->data, compressed->size);

1
src/libslic3r/Technologies.hpp
View File

@ -69,6 +69,7 @@
// Enable export of binarized gcode
#define ENABLE_BINARIZED_GCODE (1 && ENABLE_2_6_1_ALPHA1)
#define ENABLE_BINARIZED_GCODE_DEBUG (1 && ENABLE_BINARIZED_GCODE)
#define ENABLE_BINARIZED_GCODE_DEBUG_WINDOW (1 && ENABLE_BINARIZED_GCODE)

18
src/slic3r/GUI/GLCanvas3D.cpp
View File

@ -7874,7 +7874,7 @@ void GLCanvas3D::GizmoHighlighter::blink()
#if ENABLE_BINARIZED_GCODE_DEBUG_WINDOW
void GLCanvas3D::show_binary_gcode_debug_window()
{
bgcode::BinarizerConfig& binarizer_config = GCodeProcessor::get_binarizer_config();
bgcode::base::BinarizerConfig& binarizer_config = GCodeProcessor::get_binarizer_config();
ImGuiWrapper& imgui = *wxGetApp().imgui();
imgui.begin(std::string("Binary GCode"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
@ -7888,7 +7888,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
std::vector<std::string> options = { "None", "Deflate", "heatshrink 11,4", "heatshrink 12,4" };
int option_id = (int)binarizer_config.compression.file_metadata;
if (imgui.combo(std::string("##file_metadata_compression"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.compression.file_metadata = (bgcode::ECompressionType)option_id;
binarizer_config.compression.file_metadata = (bgcode::core::ECompressionType)option_id;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@ -7896,7 +7896,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
ImGui::TableSetColumnIndex(1);
option_id = (int)binarizer_config.compression.printer_metadata;
if (imgui.combo(std::string("##printer_metadata_compression"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.compression.printer_metadata = (bgcode::ECompressionType)option_id;
binarizer_config.compression.printer_metadata = (bgcode::core::ECompressionType)option_id;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@ -7904,7 +7904,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
ImGui::TableSetColumnIndex(1);
option_id = (int)binarizer_config.compression.print_metadata;
if (imgui.combo(std::string("##print_metadata_compression"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.compression.print_metadata = (bgcode::ECompressionType)option_id;
binarizer_config.compression.print_metadata = (bgcode::core::ECompressionType)option_id;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@ -7912,7 +7912,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
ImGui::TableSetColumnIndex(1);
option_id = (int)binarizer_config.compression.slicer_metadata;
if (imgui.combo(std::string("##slicer_metadata_compression"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.compression.slicer_metadata = (bgcode::ECompressionType)option_id;
binarizer_config.compression.slicer_metadata = (bgcode::core::ECompressionType)option_id;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@ -7920,7 +7920,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
ImGui::TableSetColumnIndex(1);
option_id = (int)binarizer_config.compression.gcode;
if (imgui.combo(std::string("##gcode_compression"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.compression.gcode = (bgcode::ECompressionType)option_id;
binarizer_config.compression.gcode = (bgcode::core::ECompressionType)option_id;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@ -7929,7 +7929,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
options = { "None", "MeatPack", "MeatPack Comments" };
option_id = (int)binarizer_config.gcode_encoding;
if (imgui.combo(std::string("##gcode_encoding"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.gcode_encoding = (bgcode::EGCodeEncodingType)option_id;
binarizer_config.gcode_encoding = (bgcode::core::EGCodeEncodingType)option_id;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@ -7938,7 +7938,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
options = { "INI" };
option_id = (int)binarizer_config.metadata_encoding;
if (imgui.combo(std::string("##metadata_encoding"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.metadata_encoding = (bgcode::EMetadataEncodingType)option_id;
binarizer_config.metadata_encoding = (bgcode::core::EMetadataEncodingType)option_id;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@ -7947,7 +7947,7 @@ void GLCanvas3D::show_binary_gcode_debug_window()
options = { "None", "CRC32" };
option_id = (int)binarizer_config.checksum;
if (imgui.combo(std::string("##4"), options, option_id, ImGuiComboFlags_HeightLargest, 0.0f, 175.0f))
binarizer_config.checksum = (bgcode::EChecksumType)option_id;
binarizer_config.checksum = (bgcode::core::EChecksumType)option_id;
ImGui::EndTable();

10
src/slic3r/GUI/Plater.cpp
View File

@ -36,6 +36,10 @@
#include <wx/popupwin.h>
#endif
#if ENABLE_BINARIZED_GCODE
#include <LibBGCode/convert/convert.hpp>
#endif // ENABLE_BINARIZED_GCODE
#include "libslic3r/libslic3r.h"
#include "libslic3r/Format/STL.hpp"
#include "libslic3r/Format/AMF.hpp"
@ -5472,9 +5476,9 @@ void Plater::convert_gcode_to_ascii()
// Perform conversion
{
wxBusyCursor busy;
bgcode::EResult res = bgcode::from_binary_to_ascii(*in_file, *out_file, true);
if (res != bgcode::EResult::Success) {
MessageDialog msg_dlg(this, _L(bgcode::translate_result(res)), _L("Error converting gcode file"), wxICON_INFORMATION | wxOK);
bgcode::core::EResult res = bgcode::convert::from_binary_to_ascii(*in_file, *out_file, true);
if (res != bgcode::core::EResult::Success) {
MessageDialog msg_dlg(this, _L(bgcode::core::translate_result(res)), _L("Error converting gcode file"), wxICON_INFORMATION | wxOK);
msg_dlg.ShowModal();
scoped_out_file.unscope();
fclose(out_file);