mozhe
/
BambuStudio
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

FIX: double nozzle hybrid mapping 

jira: none

Change-Id: I64908776a6265da7809814e62c9e7a860f39bffd
This commit is contained in:
hang.xu 2024-09-04 12:03:28 +08:00 committed by lane.wei
parent b620a4122e
commit c96102043b
4 changed files with 126 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/slic3r/GUI/DeviceManager.cpp
View File

@ -866,7 +866,28 @@ void MachineObject::get_ams_colors(std::vector<wxColour> &ams_colors) {
} }
} }
int MachineObject::ams_filament_mapping(std::vector<FilamentInfo> filaments, std::vector<FilamentInfo> &result, bool ext_first, bool ext_second, std::vector<int> exclude_id) void MachineObject::parse_tray_info(int ams_id, int slot_id, AmsTray tray, FilamentInfo& result) {
result.color = tray.color;
result.type = tray.get_filament_type();
result.filament_id = tray.setting_id;
result.ctype = tray.ctype;
result.colors = tray.cols;
/*for new ams mapping*/
result.ams_id = std::to_string(ams_id);
result.slot_id = std::to_string(slot_id);
if (ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID){
result.tray_id = atoi(tray.id.c_str());
result.id = atoi(tray.id.c_str());
}
else{
result.id = ams_id * 4 + slot_id;
}
}
int MachineObject::ams_filament_mapping(std::vector<FilamentInfo> filaments, std::vector<FilamentInfo> &result, std::vector<bool> map_opt, std::vector<int> exclude_id)
{ {
if (filaments.empty()) if (filaments.empty())
return -1; return -1;
@ -875,7 +896,6 @@ int MachineObject::ams_filament_mapping(std::vector<FilamentInfo> filaments, std
std::map<int, FilamentInfo> tray_filaments; std::map<int, FilamentInfo> tray_filaments;
for (auto ams = amsList.begin(); ams != amsList.end(); ams++) { for (auto ams = amsList.begin(); ams != amsList.end(); ams++) {
std::string ams_id = ams->second->id; std::string ams_id = ams->second->id;
FilamentInfo info; FilamentInfo info;
for (auto tray = ams->second->trayList.begin(); tray != ams->second->trayList.end(); tray++) { for (auto tray = ams->second->trayList.begin(); tray != ams->second->trayList.end(); tray++) {
@ -888,47 +908,21 @@ int MachineObject::ams_filament_mapping(std::vector<FilamentInfo> filaments, std
continue; continue;
} }
// push // push
if (tray->second->is_tray_info_ready()) { if (tray->second->is_tray_info_ready())
info.color = tray->second->color; parse_tray_info(ams_id, tray_id, *(tray->second), info);
info.type = tray->second->get_filament_type();
info.id = tray_index;
info.filament_id = tray->second->setting_id;
info.ctype = tray->second->ctype;
info.colors = tray->second->cols;
/*for new ams mapping*/
info.ams_id = ams->first.c_str();
info.slot_id = tray->first.c_str();
}
//first: left,nozzle=1,map=1 second: right,nozzle=0,map=2 //first: left,nozzle=1,map=1 second: right,nozzle=0,map=2
if ((!ext_first && !ext_second) || (ams->second->nozzle == 0 && ext_second) || (ams->second->nozzle == 1 && ext_first)) if ((ams->second->nozzle == 0 && map_opt[MappingOption::USE_RIGHT_AMS]) || (ams->second->nozzle == 1 && map_opt[MappingOption::USE_LEFT_AMS]))
{
tray_filaments.emplace(std::make_pair(tray_index, info)); tray_filaments.emplace(std::make_pair(tray_index, info));
} }
} }
}
if (ext_first || ext_second) if (map_opt[MappingOption::USE_RIGHT_EXT] || map_opt[MappingOption::USE_LEFT_EXT]){
{ for (auto tray : vt_slot){
for (auto tray : vt_slot) if ((tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID) && map_opt[MappingOption::USE_RIGHT_EXT])
{ || (tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID) && map_opt[MappingOption::USE_LEFT_EXT])){
if ((tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID) && ext_second) || (tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID) && ext_first))
{
FilamentInfo info; FilamentInfo info;
info.color = tray.color; parse_tray_info(atoi(tray.id.c_str()), 0, tray, info);
//info.color = "EEEEEEFF";
info.type = tray.get_filament_type();
//info.type = "PLA"; //temp change
info.tray_id = atoi(tray.id.c_str());
info.id = atoi(tray.id.c_str());
info.filament_id = tray.setting_id;
info.ctype = tray.ctype;
info.colors = tray.cols;
/*for new ams mapping*/
info.ams_id = tray.id.c_str();
info.slot_id = std::to_string(0);
tray_filaments.emplace(std::make_pair(info.tray_id, info)); tray_filaments.emplace(std::make_pair(info.tray_id, info));
} }
} }

10
src/slic3r/GUI/DeviceManager.hpp
View File

@ -435,6 +435,13 @@ public:
UpdateToDate UpdateToDate
}; };
enum MappingOption {
USE_LEFT_AMS = 0,
USE_RIGHT_AMS,
USE_LEFT_EXT,
USE_RIGHT_EXT
};
class ExtrusionRatioInfo class ExtrusionRatioInfo
{ {
public: public:
@ -572,7 +579,8 @@ public:
bool is_support_amx_ext_mix_mapping(); bool is_support_amx_ext_mix_mapping();
void get_ams_colors(std::vector<wxColour>& ams_colors); void get_ams_colors(std::vector<wxColour>& ams_colors);
int ams_filament_mapping(std::vector<FilamentInfo> filaments, std::vector<FilamentInfo> &result, bool ext_first = false, bool ext_second = false, std::vector<int> exclude_id = std::vector<int>()); void parse_tray_info(int ams_id, int sot_id, AmsTray tray, FilamentInfo& result);
int ams_filament_mapping(std::vector<FilamentInfo> filaments, std::vector<FilamentInfo> &result, std::vector<bool> map_opt, std::vector<int> exclude_id = std::vector<int>());
bool is_valid_mapping_result(std::vector<FilamentInfo>& result, bool check_empty_slot = false); bool is_valid_mapping_result(std::vector<FilamentInfo>& result, bool check_empty_slot = false);
// exceed index start with 0 // exceed index start with 0
bool is_mapping_exceed_filament(std::vector<FilamentInfo>& result, int &exceed_index); bool is_mapping_exceed_filament(std::vector<FilamentInfo>& result, int &exceed_index);

215
src/slic3r/GUI/SelectMachine.cpp
View File

@ -1955,150 +1955,58 @@ bool SelectMachineDialog::do_ams_mapping(MachineObject *obj_)
m_filaments_map = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_filament_maps(); m_filaments_map = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_filament_maps();
int filament_result = 0; int filament_result = 0;
if (nozzle_nums > 1) std::vector<bool> map_opt; //four values: use_left_ams, use_right_ams, use_left_ext, use_right_ext
{ if (nozzle_nums > 1){
//get nozzle property, the nozzles are same?, wait fill //get nozzle property, the nozzles are same?
if (!is_two_nozzle_same()) if (!can_hybrid_mapping(obj_->m_nozzle_data)){
{ std::vector<FilamentInfo> m_ams_mapping_result_left, m_ams_mapping_result_right;
std::vector<FilamentInfo> m_ams_mapping_result_first; std::vector<FilamentInfo> m_filament_left, m_filament_right;
std::vector<FilamentInfo> m_ams_mapping_result_second; for (auto it = m_filaments.begin(); it != m_filaments.end(); it++){
std::vector<FilamentInfo> m_filament_first; if (it->id < 0 || it->id > m_filaments_map.size()){
std::vector<FilamentInfo> m_filament_second;
for (auto it = m_filaments.begin(); it != m_filaments.end(); it++)
{
if (it->id < 0 || it->id > m_filaments_map.size())
{
BOOST_LOG_TRIVIAL(info) << "error: do_ams_mapping: m_filaments[].it" << it->id; BOOST_LOG_TRIVIAL(info) << "error: do_ams_mapping: m_filaments[].it" << it->id;
BOOST_LOG_TRIVIAL(info) << "m_filaments_map.size()" << m_filaments_map.size(); BOOST_LOG_TRIVIAL(info) << "m_filaments_map.size()" << m_filaments_map.size();
return false; return false;
} }
if (m_filaments_map[it->id] == 1) if (m_filaments_map[it->id] == 1)
{ m_filament_left.push_back(*it);
m_filament_first.push_back(*it);
}
else if (m_filaments_map[it->id] == 2) else if (m_filaments_map[it->id] == 2)
{ m_filament_right.push_back(*it);
m_filament_second.push_back(*it);
} }
} map_opt = {true, false, true, false}; //four values: use_left_ams, use_right_ams, use_left_ext, use_right_ext
std::vector<FilamentInfo> temp_result_first; int result_first = obj_->ams_filament_mapping(m_filament_left, m_ams_mapping_result_left, map_opt);
std::vector<FilamentInfo> temp_result_second; map_opt = { false, true, false, true };
int result_first = obj_->ams_filament_mapping(m_filament_first, m_ams_mapping_result_first, true, false); int result_second = obj_->ams_filament_mapping(m_filament_right, m_ams_mapping_result_right, map_opt);
int result_second = obj_->ams_filament_mapping(m_filament_second, m_ams_mapping_result_second, false, true);
m_ams_mapping_result.clear(); //m_ams_mapping_result.clear();
auto iter_first = m_ams_mapping_result_first.begin(); m_ams_mapping_result.resize(m_ams_mapping_result_left.size() + m_ams_mapping_result_right.size());
auto iter_second = m_ams_mapping_result_second.begin(); std::merge(m_ams_mapping_result_left.begin(), m_ams_mapping_result_left.end(), m_ams_mapping_result_right.begin(),
auto it = m_filaments.begin(); m_ams_mapping_result_right.end(), m_ams_mapping_result.begin(),
while (it != m_filaments.end() && iter_first != m_ams_mapping_result_first.end() && iter_second != m_ams_mapping_result_second.end()) [](const FilamentInfo& f1, const FilamentInfo& f2) {
{ return f1.id < f2.id; // Merge based on age
if (it->id < 0 || it->id >= m_filaments_map.size()) });
{
break;
}
if (m_filaments_map[it->id] == 1)
{
m_ams_mapping_result.push_back(*iter_first);
iter_first++;
it++;
}
else
{
m_ams_mapping_result.push_back(*iter_second);
iter_second++;
it++;
}
}
while (iter_first != m_ams_mapping_result_first.end())
{
m_ams_mapping_result.push_back(*iter_first);
iter_first++;
}
while (iter_second != m_ams_mapping_result_second.end())
{
m_ams_mapping_result.push_back(*iter_second);
iter_second++;
}
filament_result = (result_first && result_second); filament_result = (result_first && result_second);
} }
//can hybrid mapping
else { else {
filament_result = obj_->ams_filament_mapping(m_filaments, m_ams_mapping_result, true, true); map_opt = { true, true, true, true }; //four values: use_left_ams, use_right_ams, use_left_ext, use_right_ext
} filament_result = obj_->ams_filament_mapping(m_filaments, m_ams_mapping_result, map_opt);
}
for (auto it = m_ams_mapping_result.begin(); it != m_ams_mapping_result.end(); it++) //When filaments cannot be matched automatically, whether to use ext for automatic supply
{ //auto_supply_with_ext(obj_->vt_slot);
if (it->ams_id == "")
{
if (m_filaments_map[it->id] == 1)
{
if (obj_->vt_slot.size() == 2)
{
it->ams_id = std::to_string(VIRTUAL_TRAY_DEPUTY_ID);
it->color = obj_->vt_slot[1].color;
it->type = obj_->vt_slot[1].type;
it->colors = obj_->vt_slot[1].cols;
it->tray_id = VIRTUAL_TRAY_DEPUTY_ID;
}
else
{
it->ams_id = std::to_string(VIRTUAL_TRAY_MAIN_ID);
it->color = obj_->vt_slot[0].color;
it->type = obj_->vt_slot[0].type;
it->colors = obj_->vt_slot[0].cols;
it->tray_id = VIRTUAL_TRAY_MAIN_ID;
}
it->slot_id = "0";
}
else if (m_filaments_map[it->id] == 2)
{
it->ams_id = std::to_string(VIRTUAL_TRAY_MAIN_ID);
it->color = obj_->vt_slot[0].color;
it->type = obj_->vt_slot[0].type;
it->colors = obj_->vt_slot[0].cols;
it->slot_id = "0";
it->tray_id = VIRTUAL_TRAY_MAIN_ID;
}
}
}
} }
//single nozzle
else { else {
if (obj_->is_support_amx_ext_mix_mapping()) if (obj_->is_support_amx_ext_mix_mapping()){
{ map_opt = { false, true, false, true }; //four values: use_left_ams, use_right_ams, use_left_ext, use_right_ext
filament_result = obj_->ams_filament_mapping(m_filaments, m_ams_mapping_result, false, true); filament_result = obj_->ams_filament_mapping(m_filaments, m_ams_mapping_result, map_opt);
for (auto it = m_ams_mapping_result.begin(); it != m_ams_mapping_result.end(); it++) //auto_supply_with_ext(obj_->vt_slot);
{
if (it->ams_id == "")
{
it->ams_id = VIRTUAL_TRAY_MAIN_ID;
it->color = obj_->vt_slot[0].color;
it->type = obj_->vt_slot[0].type;
it->colors = obj_->vt_slot[0].cols;
it->slot_id = "0";
it->tray_id = VIRTUAL_TRAY_MAIN_ID;
}
}
} }
else { else {
filament_result = obj_->ams_filament_mapping(m_filaments, m_ams_mapping_result, false, false); map_opt = { false, true, false, false };
if (obj_->amsList.empty()) filament_result = obj_->ams_filament_mapping(m_filaments, m_ams_mapping_result, map_opt);
{
for (auto it = m_ams_mapping_result.begin(); it != m_ams_mapping_result.end(); it++)
{
if (it->ams_id == "")
{
it->ams_id = VIRTUAL_TRAY_MAIN_ID;
it->color = obj_->vt_slot[0].color;
it->type = obj_->vt_slot[0].type;
it->colors = obj_->vt_slot[0].cols;
it->slot_id = "0";
it->tray_id = VIRTUAL_TRAY_MAIN_ID;
} }
} }
}
}
}
if (filament_result == 0) { if (filament_result == 0) {
print_ams_mapping_result(m_ams_mapping_result); print_ams_mapping_result(m_ams_mapping_result);
@ -2216,11 +2124,56 @@ bool SelectMachineDialog::get_ams_mapping_result(std::string &mapping_array_str,
return true; return true;
} }
bool SelectMachineDialog::is_two_nozzle_same() { bool SelectMachineDialog::can_hybrid_mapping(NozzleData data) {
//if two extruder are same and can be mix-used, return true if (data.total_nozzle_count <= 1 || data.nozzles.size() <= 1 || !wxGetApp().preset_bundle)
//else return false
//wait to fill
return false; return false;
//The default two extruders are left, right, but the order of the extruders on the machine is right, left.
//Therefore, some adjustments need to be made.
std::vector<std::string>flow_type_of_machine;
for (auto it = data.nozzles.rbegin(); it != data.nozzles.rend(); it++){
//exist field is not updated, wait add
//if (it->exist < 3) return false;
std::string type_str = it->flow_type ? "Big Traffic" : "Normal";
flow_type_of_machine.push_back(type_str);
}
//get the nozzle type of preset --> flow_types
const Preset& current_printer = wxGetApp().preset_bundle->printers.get_selected_preset();
const Preset* base_printer = wxGetApp().preset_bundle->printers.get_preset_base(current_printer);
std::string base_name = base_printer->name;
auto flow_data = wxGetApp().app_config->get_nozzle_volume_types_from_config(base_name);
std::vector<string> flow_types;
boost::split(flow_types, flow_data, boost::is_any_of(","));
if (flow_types.size() <= 1 || flow_types.size() != flow_type_of_machine.size()) return false;
//Only when all preset nozzle types and machine nozzle types are exactly the same, return true.
auto type = flow_types[0];
for (int i = 0; i < flow_types.size(); i++){
if (flow_types[i] != type || flow_type_of_machine[i] != type)
return false;
}
return true;
}
//When filaments cannot be matched automatically, whether to use ext for automatic supply
void SelectMachineDialog::auto_supply_with_ext(std::vector<AmsTray> slots) {
if (slots.size() <= 0) return;
for (int i = 0; i < m_ams_mapping_result.size(); i++) {
auto it = m_ams_mapping_result[i];
if (it.ams_id == "") {
AmsTray slot("");
if (m_filaments_map[it.id] == 1 && slots.size() > 1) slot = slots[1];
else if (m_filaments_map[it.id] == 2) slot = slots[0];
if (slot.id.empty()) continue;
m_ams_mapping_result[i].ams_id = slot.id;
m_ams_mapping_result[i].color = slot.color;
m_ams_mapping_result[i].type = slot.type;
m_ams_mapping_result[i].colors = slot.cols;
m_ams_mapping_result[i].tray_id = atoi(slot.id.c_str());
m_ams_mapping_result[i].slot_id = "0";
}
}
} }
void SelectMachineDialog::prepare(int print_plate_idx) void SelectMachineDialog::prepare(int print_plate_idx)
@ -4410,7 +4363,7 @@ void SelectMachineDialog::reset_and_sync_ams_list()
size_t nozzle_nums = full_config.option<ConfigOptionFloatsNullable>("nozzle_diameter")->values.size(); size_t nozzle_nums = full_config.option<ConfigOptionFloatsNullable>("nozzle_diameter")->values.size();
if (nozzle_nums > 1) if (nozzle_nums > 1)
{ {
if (is_two_nozzle_same()) if (obj_ && can_hybrid_mapping(obj_->m_nozzle_data))
{ {
m_mapping_popup.set_show_type(ShowType::LEFT_AND_RIGHT); m_mapping_popup.set_show_type(ShowType::LEFT_AND_RIGHT);
} }

4
src/slic3r/GUI/SelectMachine.hpp
View File

@ -333,6 +333,7 @@ enum PrintDialogStatus {
PrintStatusTimelapseWarning PrintStatusTimelapseWarning
}; };
std::string get_print_status_info(PrintDialogStatus status); std::string get_print_status_info(PrintDialogStatus status);
class SelectMachineDialog : public DPIDialog class SelectMachineDialog : public DPIDialog
@ -539,7 +540,8 @@ public:
bool Show(bool show); bool Show(bool show);
bool do_ams_mapping(MachineObject* obj_); bool do_ams_mapping(MachineObject* obj_);
bool get_ams_mapping_result(std::string& mapping_array_str, std::string& mapping_array_str2, std::string& ams_mapping_info); bool get_ams_mapping_result(std::string& mapping_array_str, std::string& mapping_array_str2, std::string& ams_mapping_info);
bool is_two_nozzle_same(); bool can_hybrid_mapping(NozzleData data);
void auto_supply_with_ext(std::vector<AmsTray> slots);
PrintFromType get_print_type() {return m_print_type;}; PrintFromType get_print_type() {return m_print_type;};
wxString format_steel_name(std::string name); wxString format_steel_name(std::string name);