620 lines
21 KiB
C++
620 lines
21 KiB
C++
#include "MetaData.h"
|
|
#include <regex>
|
|
#include "../utils/CryptHelper.h"
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
#include <openssl/evp.h>
|
|
#include "../external/minizip/zlib.h"
|
|
#include "../LanguageManager.h"
|
|
#include "../SystemInfo.h"
|
|
|
|
MetaData::MetaData()
|
|
:evaTime(0)
|
|
, m_RemainTime(0)
|
|
, m_RemoteLayer(nullptr)
|
|
, m_IsScanOrderForPlatform(false)
|
|
, m_IsScanOrderSeqV2(false)
|
|
, m_HasOrder(false)
|
|
{
|
|
file_info = new FileInfo();
|
|
general_info = new GeneralInfo();
|
|
layers = new Layers();
|
|
machine_type = new MachineType();
|
|
|
|
m_CoverCfg = ConfigManager::GetInstance()->GetCoverCfg();
|
|
m_ArmCfg = ConfigManager::GetInstance()->GetArmCfg();
|
|
m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
|
|
m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
|
|
m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
|
|
m_Machine = ConfigManager::GetInstance()->GetMachine();
|
|
//m_ProgressInfo = g_LngManager->UI_AnalyzingJobData->ShowText();
|
|
InitializeCriticalSection(&m_DBCS);
|
|
//InitializeCriticalSection(&m_MsgCs);
|
|
InitializeCriticalSection(&partCs);
|
|
}
|
|
|
|
MetaData::~MetaData()
|
|
{
|
|
if (file_info)delete file_info;
|
|
if (general_info)delete general_info;
|
|
for (map<int, Part*>::iterator it = partsMap.begin(); it != partsMap.end(); it++)
|
|
{
|
|
Part* part = it->second;
|
|
if (part)delete part;
|
|
}
|
|
partsMap.clear();
|
|
partsVec.clear();
|
|
for (map<int, ParameterSet*>::iterator it = parameterMap.begin(); it != parameterMap.end(); it++) {
|
|
delete it->second;
|
|
}
|
|
parameterMap.clear();
|
|
|
|
ClearBFileMap();
|
|
ClearBlockMap();
|
|
ClearPrevBlockMap();
|
|
ClearRemoteBlockMap();
|
|
|
|
if (layers)delete layers;
|
|
if (machine_type)delete machine_type;
|
|
DeleteCriticalSection(&partCs);
|
|
DeleteCriticalSection(&m_DBCS);
|
|
}
|
|
|
|
void MetaData::CalcRealPower(void)
|
|
{
|
|
for (size_t partIndex = 0; partIndex < partsVec.size(); partIndex++) {
|
|
Part* part = partsVec[partIndex];
|
|
for (set<ParameterSet*>::iterator it = part->paramSet.begin(); it != part->paramSet.end(); it++) {
|
|
ParameterSet* ps = (*it);
|
|
if (m_FieldRefScanLaser.find(ps->scan_field) != m_FieldRefScanLaser.end()) {
|
|
ScannerControlCfg* cfg = m_FieldRefScanLaser[ps->scan_field];
|
|
if (cfg) {
|
|
ps->laser_set->laser_real_power = cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.CalcPowerCompensate(ps->laser_set->laser_power);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MetaData::GetPartId(int layerIndex, set<int>& partIds)
|
|
{
|
|
int layersize = layers->vector_layers.size();
|
|
if (layerIndex >= layersize)return;
|
|
Layer* layer = layers->vector_layers[layerIndex];
|
|
for (size_t i = 0; i < layer->data_blocks.size(); ++i) {
|
|
Part* part = partsMap[layer->data_blocks[i]->references->part];
|
|
if (part)partIds.insert(part->id);
|
|
}
|
|
}
|
|
|
|
BPBinary::BinDataBlock* MetaData::GetDataBlock(DataBlock* db)
|
|
{
|
|
if (m_block_map.find(db) != m_block_map.end()) {
|
|
return m_block_map[db];
|
|
}
|
|
else return NULL;
|
|
}
|
|
|
|
BPBinary::BinDataBlock* MetaData::GetPreviewData(MetaData::DataBlockList* dblist, unsigned int index)
|
|
{
|
|
if (!dblist)
|
|
return nullptr;
|
|
|
|
return m_prev_block_map[(*dblist)[index]];
|
|
}
|
|
|
|
BPBinary::BinDataBlock* MetaData::GetRemoteDataBlock(DataBlock* db)
|
|
{
|
|
return m_remote_block_map[db];
|
|
}
|
|
|
|
BPBinary::BinDataBlock* MetaData::GetPreviewDataBlock(DataBlock* db)
|
|
{
|
|
return m_prev_block_map[db];
|
|
}
|
|
|
|
float MetaData::PowderRequiretment(void)
|
|
{
|
|
float powder = 0.0;
|
|
for (unsigned int i = GetCurrentLayer()->index; i < layers->vector_layers.size(); i++)
|
|
{
|
|
bool hasPrintPart = false;
|
|
MetaData::Layer* layer = layers->vector_layers[i];
|
|
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
|
|
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
|
|
if (!datablock)continue;
|
|
MetaData::Part* part = GetPart(datablock->references->part);
|
|
if (part) {
|
|
if (part->print_enable) {
|
|
hasPrintPart = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasPrintPart)
|
|
powder += layer->powder;
|
|
else
|
|
break;
|
|
}
|
|
|
|
return powder;
|
|
}
|
|
|
|
MetaData::Layer* MetaData::GetLayer(unsigned int id)
|
|
{
|
|
if (id >= layers->vector_layers.size())
|
|
return nullptr;
|
|
|
|
return layers->vector_layers[id];
|
|
}
|
|
|
|
unsigned int MetaData::CalcRemainTime(unsigned int index)
|
|
{
|
|
m_RemainTime = 0;
|
|
g_SystemInfo->m_StateBean.remainMil = m_RemainTime;
|
|
double tTime = 0.0;
|
|
if (index >= layers->vector_layers.size()) return m_RemainTime;
|
|
for (size_t layerindex = index; layerindex < layers->vector_layers.size(); layerindex++) {
|
|
tTime += layers->vector_layers[layerindex]->layer_estimate_time;
|
|
}
|
|
|
|
if (m_RunCfg->m_PrintRestEnable->GetValue() && m_RunCfg->m_PrintContinueMinute->GetValue() > 0) {
|
|
double continueFlag = m_RunCfg->m_PrintContinueMinute->GetValue() * 60 * 1000;
|
|
int pauseCount = tTime / continueFlag;
|
|
tTime = tTime + pauseCount * m_RunCfg->m_PrintRestMinutes->GetValue() * 60 * 1000;
|
|
}
|
|
m_RemainTime = tTime;
|
|
g_SystemInfo->m_StateBean.remainMil = m_RemainTime;
|
|
return m_RemainTime;
|
|
}
|
|
|
|
bool ParamCmp(const MetaData::ParameterSet* lhs, const MetaData::ParameterSet* rhs)
|
|
{
|
|
if (lhs->id != rhs->id) return lhs->id < rhs->id;
|
|
else return lhs->id > rhs->id;
|
|
}
|
|
|
|
void MetaData::GetErrorInfo(vector<string>& infos)
|
|
{
|
|
for (size_t i = 0; i < m_Errors.size(); ++i) {
|
|
infos.push_back(m_Errors[i]);
|
|
}
|
|
}
|
|
|
|
string MetaData::GetErrorInfo() {
|
|
string result;
|
|
for (size_t i = 0; i < m_Errors.size(); ++i) {
|
|
result +=m_Errors[i]+" ";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
MetaData::ParameterSet* MetaData::GetParameterSet(int id)
|
|
{
|
|
if (parameterMap.find(id) == parameterMap.end())
|
|
{
|
|
return NULL;
|
|
}
|
|
else return parameterMap[id];
|
|
}
|
|
|
|
|
|
void MetaData::ReCalcEvaTime()
|
|
{
|
|
double perLayerpowderTime = 0.0;
|
|
double coverMil = 0.0, shiftMil = 0.0;
|
|
m_CoverCfg->Lock();
|
|
if (m_CoverCfg->m_CoverDirection == CoverCfg::TWO_WAY1 || m_CoverCfg->m_CoverDirection == CoverCfg::TWO_WAY2) {
|
|
double coverDis = (double)m_CoverCfg->m_cover_distance;
|
|
if (m_CoverCfg->m_cover_speed != 0.0) {
|
|
coverMil = coverDis / m_CoverCfg->m_cover_speed;
|
|
}
|
|
}
|
|
else if (m_CoverCfg->m_CoverDirection == CoverCfg::ONE_WAY || m_CoverCfg->m_CoverDirection == CoverCfg::ONE_WAY2) {
|
|
if (m_CoverCfg->m_cover_speed != 0.0) {
|
|
coverMil = (double)m_CoverCfg->m_cover_distance / m_CoverCfg->m_cover_speed;
|
|
}
|
|
if (m_CoverCfg->m_cover_shift_speed != 0.0)
|
|
{
|
|
shiftMil = (double)m_CoverCfg->m_cover_distance / m_CoverCfg->m_cover_shift_speed;
|
|
}
|
|
}
|
|
m_CoverCfg->UnLock();
|
|
perLayerpowderTime = coverMil + shiftMil + 600.0;
|
|
if (m_ExtCfg->m_AutoCoverSlowWind) {
|
|
perLayerpowderTime += m_RunCfg->m_CoverWindSimulateTimeOffset->GetValue();
|
|
}
|
|
if (m_RunCfg->m_PrintLayerDelay != 0) {
|
|
perLayerpowderTime = perLayerpowderTime + m_RunCfg->m_PrintLayerDelay->GetValue() * 1000;
|
|
}
|
|
if (m_RunCfg->m_CoverLayerDelay != 0) {
|
|
perLayerpowderTime = perLayerpowderTime + m_RunCfg->m_CoverLayerDelay->GetValue() * 1000;
|
|
}
|
|
double milsec = 0.0;
|
|
m_RemainTime = 0;
|
|
if (m_HasOrder && m_MachineCfg->m_MachineType->GetValue() == MachineTypeCfg::HBD_1000) {
|
|
map<int, ScannerControlCfg*>* laserCfgsMap = ConfigManager::GetInstance()->GetScannerControlCfg();
|
|
for (size_t layerindex = 0; layerindex < layers->vector_layers.size(); ++layerindex) {
|
|
map<int, double> areaTime;
|
|
map<int, double> borderTime;
|
|
for (int i = 0; i < 33; i++) {
|
|
areaTime[i] = 0.0;
|
|
}
|
|
MetaData::Layer* layer = layers->vector_layers[layerindex];
|
|
for (map<int, double>::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) {
|
|
it->second = 0.0;
|
|
}
|
|
layer->layer_estimate_time = 0;
|
|
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
|
|
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
|
|
if (!datablock)continue;
|
|
MetaData::Part* part = GetPart(datablock->references->part);
|
|
if (!part)continue;
|
|
if (!part->print_enable)continue;
|
|
if (datablock->cno == 0)continue;
|
|
|
|
MetaData::ParameterSet* param = GetParameterSet(datablock->references->process);
|
|
if (laserCfgsMap->find(datablock->cno) == laserCfgsMap->end())continue;
|
|
ScannerControlCfg* laserCfg = (*laserCfgsMap)[datablock->cno];
|
|
if (!laserCfg)continue;
|
|
ScanParamCfg* scanParamCfg = laserCfg->GetScanParamCfg(param->set_type);
|
|
if (scanParamCfg == NULL)scanParamCfg = &laserCfg->m_ScanCfgWrapper.m_ScanParamCfg;
|
|
SkyWritingCfg* skyWritingCfg = &laserCfg->m_ScanCfgWrapper.m_SkyWritingCfg;
|
|
double markMil = 0, jumpMil = 0, hatching = 0, jumpdelay = 0, markdelay = 0, sum = 0, flag = 0;
|
|
if (scanParamCfg->m_jump_speed != 0) {
|
|
jumpMil = datablock->data_block_summary->jump_distance / scanParamCfg->m_jump_speed * 1000;
|
|
jumpMil *= 1.03;
|
|
}
|
|
if (param->laser_speed != 0) {
|
|
markMil = datablock->data_block_summary->mark_distance / param->laser_speed * 1000;
|
|
markMil *= 1.03;
|
|
}
|
|
|
|
int datatype = BIN_VECTOR;
|
|
if (m_DataTypeMap.find(param->set_type) != m_DataTypeMap.end()) {
|
|
datatype = m_DataTypeMap[param->set_type];
|
|
}
|
|
if (skyWritingCfg->m_Mode == 0)
|
|
{
|
|
if (datatype == BIN_CHAIN) {
|
|
markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else if (datatype == BIN_VECTOR) {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
}
|
|
else {
|
|
if (param->laser_set->laser_diameter < 100.0f) {
|
|
double mseg = (double)datablock->data_block_summary->num_mark_segments;
|
|
hatching = (mseg * (skyWritingCfg->m_Nprev + skyWritingCfg->m_Npost) / 1000.0);
|
|
|
|
}
|
|
else {
|
|
if (datatype == BIN_CHAIN) {
|
|
markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else if (datatype == BIN_VECTOR) {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
}
|
|
}
|
|
if (datablock->data_block_summary->num_jump_segments > 0) {
|
|
float avgL = (float)datablock->data_block_summary->jump_distance / datablock->data_block_summary->num_jump_segments;
|
|
float judgL = 0.0f;
|
|
float jump_delay = 0.0f;
|
|
float min_jump_delay = 0.0f;
|
|
judgL = (float)scanParamCfg->m_jump_length_limit;
|
|
jump_delay = (float)scanParamCfg->m_jump_delay;
|
|
min_jump_delay = (float)scanParamCfg->m_min_jump_delay;
|
|
|
|
//float judgL =(float) scanParamCfg->m_jump_length_limit;
|
|
if ((avgL < judgL) && (judgL != 0.0f)) {
|
|
if (jump_delay > min_jump_delay) {
|
|
float k = (float)(jump_delay - min_jump_delay) / judgL;
|
|
float avgdl = k * avgL + min_jump_delay;
|
|
if (avgdl > jump_delay)avgdl = jump_delay;
|
|
jumpdelay = avgdl * datablock->data_block_summary->num_jump_segments / 1000.0;
|
|
}
|
|
else {
|
|
jumpdelay = (double)min_jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
|
|
}
|
|
}
|
|
else {
|
|
jumpdelay = (double)jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
|
|
}
|
|
}
|
|
|
|
sum = markMil + jumpMil + hatching + jumpdelay + markdelay + 20.0 + flag;
|
|
datablock->scanTime = sum;
|
|
if (datablock->order == 0)
|
|
{
|
|
borderTime[datablock->cno] += sum;
|
|
}
|
|
areaTime[datablock->order] += sum;
|
|
}
|
|
|
|
double topLeftSum = 0.0, topRightSum = 0.0, topSum = 0.0;
|
|
double btnLeftSum = 0.0, btnRightSum = 0.0, btnSum = 0.0;
|
|
|
|
for (int i = 1; i < 9; i++)
|
|
{
|
|
topLeftSum += areaTime[i];
|
|
}
|
|
for (int i = 9; i < 17; i++)
|
|
{
|
|
topRightSum += areaTime[i];
|
|
}
|
|
for (int i = 17; i < 25; i++)
|
|
{
|
|
btnLeftSum += areaTime[i];
|
|
}
|
|
for (int i = 25; i < 33; i++)
|
|
{
|
|
btnRightSum += areaTime[i];
|
|
}
|
|
|
|
topSum = topLeftSum > topRightSum ? (topLeftSum + topRightSum / 1.3) : (topRightSum + topLeftSum / 1.3);
|
|
btnSum = btnLeftSum > btnRightSum ? (btnLeftSum + btnRightSum / 1.3) : (btnRightSum + btnLeftSum / 1.3);
|
|
|
|
double borderSum = 0.0;
|
|
for (map<int, double>::iterator it = borderTime.begin(); it != borderTime.end(); it++) {
|
|
if (it->second > borderSum)borderSum = it->second;
|
|
}
|
|
double ss = topSum > btnSum ? topSum : btnSum;
|
|
layer->layer_estimate_time += (ss + perLayerpowderTime);
|
|
layer->layer_estimate_time += borderSum;
|
|
milsec += layer->layer_estimate_time;
|
|
}
|
|
m_RemainTime = milsec;
|
|
evaTime = milsec;
|
|
}
|
|
else {
|
|
map<int, ScannerControlCfg*>* laserCfgsMap = ConfigManager::GetInstance()->GetScannerControlCfg();
|
|
for (size_t layerindex = 0; layerindex < layers->vector_layers.size(); ++layerindex) {
|
|
MetaData::Layer* layer = layers->vector_layers[layerindex];
|
|
for (map<int, double>::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) {
|
|
it->second = 0.0;
|
|
}
|
|
layer->layer_estimate_time = 0;
|
|
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
|
|
//double milsec = 0;
|
|
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
|
|
MetaData::ParameterSet* param = parameterMap[datablock->references->process];
|
|
if (!param)continue;
|
|
if (laserCfgsMap->find(datablock->cno) == laserCfgsMap->end())continue;
|
|
ScannerControlCfg* laserCfg = (*laserCfgsMap)[datablock->cno];
|
|
if (!laserCfg)continue;
|
|
ScanParamCfg* scanParamCfg = laserCfg->GetScanParamCfg(param->set_type);
|
|
if (scanParamCfg == NULL)scanParamCfg = &laserCfg->m_ScanCfgWrapper.m_ScanParamCfg;
|
|
SkyWritingCfg* skyWritingCfg = &laserCfg->m_ScanCfgWrapper.m_SkyWritingCfg;
|
|
double markMil = 0, jumpMil = 0, hatching = 0, jumpdelay = 0, markdelay = 0, sum = 0, flag = 0;
|
|
if (scanParamCfg->m_jump_speed != 0) {
|
|
jumpMil = datablock->data_block_summary->jump_distance / scanParamCfg->m_jump_speed * 1000;
|
|
jumpMil *= 1.03;
|
|
}
|
|
if (param->laser_speed != 0) {
|
|
markMil = datablock->data_block_summary->mark_distance / param->laser_speed * 1000;
|
|
markMil *= 1.03;
|
|
}
|
|
int datatype = BIN_VECTOR;
|
|
if (m_DataTypeMap.find(param->set_type) != m_DataTypeMap.end()) {
|
|
datatype = m_DataTypeMap[param->set_type];
|
|
}
|
|
if (skyWritingCfg->m_Mode == 0)
|
|
{
|
|
|
|
if (datatype == BIN_CHAIN) {
|
|
markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else if (datatype == BIN_VECTOR) {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
}
|
|
else {
|
|
if (param->laser_set->laser_diameter < 100.0f) {
|
|
double mseg = (double)datablock->data_block_summary->num_mark_segments;
|
|
hatching = (mseg * (skyWritingCfg->m_Nprev + skyWritingCfg->m_Npost) / 1000.0);
|
|
|
|
}
|
|
else {
|
|
|
|
if (datatype == BIN_CHAIN) {
|
|
markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else if (datatype == BIN_VECTOR) {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
else {
|
|
markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
|
|
}
|
|
}
|
|
}
|
|
if (datablock->data_block_summary->num_jump_segments > 0) {
|
|
float avgL = (float)datablock->data_block_summary->jump_distance / datablock->data_block_summary->num_jump_segments;
|
|
float judgL = 0.0f;
|
|
float jump_delay = 0.0f;
|
|
float min_jump_delay = 0.0f;
|
|
judgL = (float)scanParamCfg->m_jump_length_limit;
|
|
jump_delay = (float)scanParamCfg->m_jump_delay;
|
|
min_jump_delay = (float)scanParamCfg->m_min_jump_delay;
|
|
|
|
//float judgL =(float) scanParamCfg->m_jump_length_limit;
|
|
if ((avgL < judgL) && (judgL != 0.0f)) {
|
|
if (jump_delay > min_jump_delay) {
|
|
float k = (float)(jump_delay - min_jump_delay) / judgL;
|
|
float avgdl = k * avgL + min_jump_delay;
|
|
if (avgdl > jump_delay)avgdl = jump_delay;
|
|
jumpdelay = avgdl * datablock->data_block_summary->num_jump_segments / 1000.0;
|
|
}
|
|
else {
|
|
jumpdelay = (double)min_jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
|
|
}
|
|
}
|
|
else {
|
|
jumpdelay = (double)jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
|
|
}
|
|
}
|
|
sum = markMil + jumpMil + hatching + jumpdelay + markdelay + 20.0 + flag;
|
|
datablock->scanTime = sum;
|
|
// milsec += sum;
|
|
layer->estimateTimeMap[laserCfg->m_SeqNo ] += sum;
|
|
}
|
|
double max = 0.0;
|
|
for (map<int, double>::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) {
|
|
double eve = it->second;
|
|
if (eve > max)max = eve;
|
|
}
|
|
double ttemp = 0.0;
|
|
if (max < (m_RunCfg->m_CoverSimulateTimeOffset->GetValue() + m_CoverCfg->m_SupplyTime)) {
|
|
ttemp = (m_RunCfg->m_CoverSimulateTimeOffset->GetValue() - max) + m_CoverCfg->m_SupplyTime;
|
|
max = 0.0;
|
|
}
|
|
layer->layer_estimate_time += (max + perLayerpowderTime + ttemp);
|
|
milsec += layer->layer_estimate_time;
|
|
}
|
|
|
|
m_RemainTime = milsec;
|
|
if (m_RunCfg->m_PrintRestEnable->GetValue() && m_RunCfg->m_PrintContinueMinute->GetValue() > 0) {
|
|
double continueFlag = m_RunCfg->m_PrintContinueMinute->GetValue() * 60 * 1000;
|
|
int pauseCount = milsec / continueFlag;
|
|
milsec = milsec + pauseCount * m_RunCfg->m_PrintRestMinutes->GetValue() * 60 * 1000;
|
|
m_RemainTime = m_RemainTime + pauseCount * m_RunCfg->m_PrintRestMinutes->GetValue() * 60 * 1000;
|
|
}
|
|
evaTime = milsec;
|
|
}
|
|
g_SystemInfo->m_StateBean.jobCostMil = evaTime;
|
|
g_SystemInfo->m_StateBean.remainMil = m_RemainTime;
|
|
}
|
|
|
|
void MetaData::InitTypeMap()
|
|
{
|
|
m_DataTypeMap["BlockSupport"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownBorderJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownBorderAd"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownBorderAdJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownFBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownFBorderJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownHatching"] = BIN_VECTOR;
|
|
m_DataTypeMap["DownHatching2"] = BIN_VECTOR;
|
|
m_DataTypeMap["DownHatching3"] = BIN_VECTOR;
|
|
m_DataTypeMap["DownHatching4"] = BIN_VECTOR;
|
|
m_DataTypeMap["DownHatching5"] = BIN_VECTOR;
|
|
m_DataTypeMap["DownThin"] = BIN_CHAIN;
|
|
m_DataTypeMap["DownThinJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["Dummy"] = BIN_VECTOR;
|
|
m_DataTypeMap["InBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["InBorderJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["InBorderAd"] = BIN_CHAIN;
|
|
m_DataTypeMap["InBorderAdJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["InFBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["InFBorderJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["InHatching"] = BIN_VECTOR;
|
|
m_DataTypeMap["InThin"] = BIN_CHAIN;
|
|
m_DataTypeMap["InThinJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["Other"] = BIN_VECTOR;
|
|
m_DataTypeMap["SupportBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["SupportBorderAd"] = BIN_CHAIN;
|
|
m_DataTypeMap["SupportHatching"] = BIN_VECTOR;
|
|
m_DataTypeMap["UpBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["UpBorderJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["UpBorderAd"] = BIN_CHAIN;
|
|
m_DataTypeMap["UpBorderAdJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["UpFBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["UpFBorderJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["UpHatching"] = BIN_VECTOR;
|
|
m_DataTypeMap["UpHatching2"] = BIN_VECTOR;
|
|
m_DataTypeMap["UpHatching3"] = BIN_VECTOR;
|
|
m_DataTypeMap["UpHatching4"] = BIN_VECTOR;
|
|
m_DataTypeMap["UpHatching5"] = BIN_VECTOR;
|
|
m_DataTypeMap["UpThin"] = BIN_CHAIN;
|
|
m_DataTypeMap["UpThinJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["LatticeHatching"] = BIN_VECTOR;
|
|
m_DataTypeMap["LatticeBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["LatticeBorderJ"] = BIN_CHAIN;
|
|
m_DataTypeMap["LatticeFBorder"] = BIN_CHAIN;
|
|
m_DataTypeMap["LatticeFBorderJ"] = BIN_CHAIN;
|
|
|
|
m_DataTypeMap["BorderDown"] = BIN_CHAIN;
|
|
m_DataTypeMap["FillContourDown"] = BIN_CHAIN;
|
|
m_DataTypeMap["HatchingDown"] = BIN_VECTOR;
|
|
m_DataTypeMap["BorderAdditionalDown"] = BIN_CHAIN;
|
|
m_DataTypeMap["BorderBlockedDown"] = BIN_CHAIN;
|
|
m_DataTypeMap["Border"] = BIN_CHAIN;
|
|
m_DataTypeMap["FillContour"] = BIN_CHAIN;
|
|
m_DataTypeMap["Hatching"] = BIN_VECTOR;
|
|
m_DataTypeMap["BorderAdditional"] = BIN_CHAIN;
|
|
m_DataTypeMap["BorderBlocked"] = BIN_CHAIN;
|
|
m_DataTypeMap["BorderUp"] = BIN_CHAIN;
|
|
m_DataTypeMap["FillContourUp"] = BIN_CHAIN;
|
|
m_DataTypeMap["HatchingUp"] = BIN_VECTOR;
|
|
m_DataTypeMap["BorderAdditionalUp"] = BIN_CHAIN;
|
|
m_DataTypeMap["BorderBlockedUp"] = BIN_CHAIN;
|
|
m_DataTypeMap["BorderSupport"] = BIN_CHAIN;
|
|
m_DataTypeMap["HatchingBorder"] = BIN_VECTOR;
|
|
m_DataTypeMap["BorderAdditionalSupport"] = BIN_CHAIN;
|
|
m_DataTypeMap["WallSupport"] = BIN_VECTOR;
|
|
}
|
|
|
|
void MetaData::ClearBlockMap()
|
|
{
|
|
for (map<DataBlock*, BPBinary::BinDataBlock*>::iterator it = m_block_map.begin(); it != m_block_map.end(); ++it) {
|
|
delete it->second;
|
|
}
|
|
m_block_map.clear();
|
|
}
|
|
|
|
void MetaData::ClearPrevBlockMap()
|
|
{
|
|
for (map<DataBlock*, BPBinary::BinDataBlock*>::iterator it = m_prev_block_map.begin(); it != m_prev_block_map.end(); ++it) {
|
|
delete it->second;
|
|
}
|
|
m_prev_block_map.clear();
|
|
}
|
|
|
|
void MetaData::ClearRemoteBlockMap()
|
|
{
|
|
for (map<DataBlock*, BPBinary::BinDataBlock*>::iterator it = m_remote_block_map.begin(); it != m_remote_block_map.end(); ++it) {
|
|
delete it->second;
|
|
}
|
|
m_remote_block_map.clear();
|
|
}
|
|
|
|
void MetaData::ClearBFileMap()
|
|
{
|
|
for (map<string, ifstream*>::iterator it = m_binary_file_map.begin(); it != m_binary_file_map.end(); ++it)
|
|
{
|
|
ifstream* pbfile = it->second;
|
|
if (pbfile) {
|
|
if (pbfile->is_open())pbfile->close();
|
|
delete pbfile;
|
|
}
|
|
}
|
|
m_binary_file_map.clear();
|
|
|
|
for (map<string, ifstream*>::iterator it = m_pre_file_map.begin(); it != m_pre_file_map.end(); ++it)
|
|
{
|
|
ifstream* pbfile = it->second;
|
|
if (pbfile) {
|
|
pbfile->close();
|
|
delete pbfile;
|
|
}
|
|
}
|
|
m_pre_file_map.clear();
|
|
|
|
}
|
|
|
|
|
|
map<string, int> MetaData::m_DataTypeMap = map<string, int>(); |