438 lines
16 KiB
C++
438 lines
16 KiB
C++
#include "H3DFileProcessor.h"
|
|
#include "../utils/StringHelper.h"
|
|
#include "../LanguageManager.h"
|
|
#include "JobController.h"
|
|
#include "../Logger.h"
|
|
|
|
H3DFileProcessor::H3DFileProcessor()
|
|
{}
|
|
|
|
H3DFileProcessor::~H3DFileProcessor()
|
|
{}
|
|
|
|
string H3DFileProcessor::ReadStringFromStream(ifstream* ifs)
|
|
{
|
|
char buffer[1024];
|
|
memset(buffer, '\0', sizeof(buffer));
|
|
int flag = 0;
|
|
char temp;
|
|
while (!ifs->eof()) {
|
|
ifs->get(temp);
|
|
if (temp == '\0') {
|
|
break;
|
|
}
|
|
else {
|
|
buffer[flag] = temp;
|
|
}
|
|
flag++;
|
|
}
|
|
return string(buffer);
|
|
}
|
|
|
|
int H3DFileProcessor::Process(string jobfile)
|
|
{
|
|
ifstream* ifs = new ifstream();
|
|
ifs->open(jobfile.c_str(), ios::binary);
|
|
if (!ifs->is_open())return -1;
|
|
ifstream* pfs = new ifstream();
|
|
pfs->open(jobfile.c_str(), ios::binary);
|
|
if (!pfs->is_open())return -1;
|
|
H3DMetaData* metadata = &m_MetaData;
|
|
MetaData::BinaryFile* bfile = new MetaData::BinaryFile();
|
|
bfile->id = 0;
|
|
bfile->name = jobfile;
|
|
metadata->binary_files[bfile->id] = bfile;
|
|
metadata->AddHJobFile2Map(bfile->name, ifs, pfs);
|
|
ifs->read((char*)metadata->file_info->version, sizeof(MetaData::Version));
|
|
metadata->job_id = StringHelper::ReadString(ifs);
|
|
metadata->general_info->job_name = StringHelper::ReadString(ifs);
|
|
metadata->general_info->material = StringHelper::ReadString(ifs);
|
|
ifs->read((char*)metadata->general_info->job_dimensions, sizeof(MetaData::JobDimensions));
|
|
metadata->layers->layer_thickness_pos=ifs->tellg();
|
|
float layerThickness = 0.0f;
|
|
ifs->read((char*)&layerThickness, sizeof(float));
|
|
metadata->layers->layer_thickness = (1000.0f*layerThickness + 0.5f);
|
|
unsigned int scanfieldsize = 0;
|
|
ifs->read((char*)&scanfieldsize, sizeof(scanfieldsize));
|
|
for (unsigned int sfIndex = 0; sfIndex < scanfieldsize; ++sfIndex) {
|
|
MetaData::ScanField* sf = new MetaData::ScanField();
|
|
ifs->read((char*)&sf->id, sizeof(sf->id));
|
|
ifs->read((char*)&sf->reference, sizeof(sf->reference));
|
|
ifs->read((char*)sf->dimension, sizeof(MetaData::Dimension));
|
|
metadata->machine_type->scanFields.push_back(sf);
|
|
}
|
|
unsigned int lasersize = 0;
|
|
ifs->read((char*)&lasersize, sizeof(lasersize));
|
|
for (unsigned int laserIndex = 0; laserIndex < lasersize; ++laserIndex) {
|
|
MetaData::Laser* laser = new MetaData::Laser();
|
|
ifs->read((char*)&laser->id, sizeof(laser->id));
|
|
ifs->read((char*)&laser->reference, sizeof(laser->reference));
|
|
metadata->machine_type->lasers.push_back(laser);
|
|
}
|
|
|
|
if (metadata->m_MachineCfg->IsDataStrategy()) {
|
|
vector<ScannerControlCfg*>* cfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
|
|
if (metadata->machine_type->scanFields.empty()) {
|
|
MetaData::ScanField* sf = new MetaData::ScanField();
|
|
sf->id = 0;
|
|
sf->reference = 0;
|
|
if (!cfgs->empty()) {
|
|
sf->dimension->xmin = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min;
|
|
sf->dimension->xmax = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max;
|
|
sf->dimension->ymin = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min;
|
|
sf->dimension->ymax = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max;
|
|
}
|
|
else {
|
|
sf->dimension->xmin = metadata->general_info->job_dimensions->xmin;
|
|
sf->dimension->xmax = metadata->general_info->job_dimensions->xmax;
|
|
sf->dimension->ymin = metadata->general_info->job_dimensions->ymin;
|
|
sf->dimension->ymax = metadata->general_info->job_dimensions->ymax;
|
|
}
|
|
metadata->machine_type->scanFields.push_back(sf);
|
|
}
|
|
|
|
map<int, unsigned int> hasSelected;
|
|
int canSelectIndex = 0;
|
|
//检测可匹配的ScanField
|
|
for (size_t i = 0; i < metadata->machine_type->scanFields.size(); ++i)
|
|
{
|
|
MetaData::ScanField* sf = metadata->machine_type->scanFields[i];
|
|
float sf_maxx = sf->dimension->xmax - sf->dimension->xmin;
|
|
float sf_maxy = sf->dimension->ymax - sf->dimension->ymin;
|
|
bool hasfind = false;
|
|
queue<int> canSelectIndexs;
|
|
for (size_t laserIndex = 0; laserIndex < cfgs->size(); ++laserIndex) {
|
|
ScannerControlCfg* cfg = (*cfgs)[laserIndex];
|
|
if (!cfg->m_IsEnable)continue;
|
|
float cfg_xmin = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min;
|
|
float cfg_xmax = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max;
|
|
float cfg_ymin = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min;
|
|
float cfg_ymax = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max;
|
|
|
|
if ((sf->dimension->xmin >= cfg_xmin) && (sf->dimension->xmax <= cfg_xmax) && (sf->dimension->ymin >= cfg_ymin) && (sf->dimension->ymax <= cfg_ymax)) {
|
|
canSelectIndexs.push(laserIndex);
|
|
if (!hasSelected[cfg->m_SeqNo]) {
|
|
metadata->m_FieldRefScanLaser[sf->id] = cfg;
|
|
hasSelected[cfg->m_SeqNo] = 1;
|
|
hasfind = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
if (!hasfind) {
|
|
if (canSelectIndexs.empty()) {
|
|
char buffer[256];
|
|
sprintf_s(buffer, sizeof(buffer), _(u8"数据中的打印区%d超出可打印范围").c_str(),
|
|
sf->id);
|
|
//EnterCriticalSection(&metadata->m_MsgCs);
|
|
metadata->m_Errors.push_back(buffer);
|
|
//LeaveCriticalSection(&metadata->m_MsgCs);
|
|
}
|
|
else {
|
|
int firstfix = canSelectIndexs.front();
|
|
metadata->m_FieldRefScanLaser[sf->id] = (*cfgs)[firstfix];
|
|
}
|
|
}
|
|
}
|
|
//检测是否越限
|
|
if (!cfgs->empty()) {
|
|
float min_x = FLT_MAX;
|
|
float max_x = FLT_MIN;
|
|
float min_y = FLT_MAX;
|
|
float max_y = FLT_MIN;
|
|
for (size_t laserindex = 0; laserindex < cfgs->size(); ++laserindex) {
|
|
ScannerControlCfg* cfg = (*cfgs)[laserindex];
|
|
if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min < min_x)min_x = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min;
|
|
if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max > max_x)max_x = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max;
|
|
if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min < min_y)min_y = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min;
|
|
if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max > max_y)max_y = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max;
|
|
}
|
|
if ((metadata->general_info->job_dimensions->xmin < min_x) || (metadata->general_info->job_dimensions->xmax > max_x)) {
|
|
//EnterCriticalSection(&metadata->m_MsgCs);
|
|
metadata->m_Errors.push_back(_(u8"x方向数据超可打印范围").c_str());
|
|
//LeaveCriticalSection(&metadata->m_MsgCs);
|
|
}
|
|
|
|
if ((metadata->general_info->job_dimensions->ymin < min_y) || (metadata->general_info->job_dimensions->ymax > max_y)) {
|
|
//EnterCriticalSection(&metadata->m_MsgCs);
|
|
metadata->m_Errors.push_back(_(u8"y方向数据超可打印范围").c_str());
|
|
//LeaveCriticalSection(&metadata->m_MsgCs);
|
|
}
|
|
}
|
|
}
|
|
|
|
unsigned int partsize = 0;
|
|
ifs->read((char*)&partsize, sizeof(partsize));
|
|
for (unsigned int partIndex = 0; partIndex < partsize; ++partIndex) {
|
|
MetaData::Part* part = new MetaData::Part();
|
|
ifs->read((char*)&part->id, sizeof(part->id));
|
|
part->name = StringHelper::ReadString(ifs);
|
|
ifs->read((char*)part->dimensions, sizeof(MetaData::JobDimensions));
|
|
|
|
part->partPosBean.m_JobId = metadata->job_id;
|
|
part->partPosBean.m_PartCenterX = (part->dimensions->xmax + part->dimensions->xmin) / 2.0f;
|
|
part->partPosBean.m_PartCenterY = (part->dimensions->ymax + part->dimensions->ymin) / 2.0f;
|
|
part->partPosBean.m_SrcPartCenterX = part->partPosBean.m_PartCenterX;
|
|
part->partPosBean.m_SrcPartCenterY = part->partPosBean.m_PartCenterY;
|
|
|
|
metadata->partsVec.push_back(part);
|
|
metadata->partsMap[part->id] = part;
|
|
unsigned int paramsize = 0;
|
|
|
|
ifs->read((char*)¶msize, sizeof(paramsize));
|
|
//vector<int>* vec = new vector<int>();
|
|
part->param_pos = ifs->tellg();
|
|
for (size_t paramidIndex = 0; paramidIndex < paramsize; ++paramidIndex) {
|
|
MetaData::ParameterSet* ps = new MetaData::ParameterSet();
|
|
ifs->read((char*)&ps->id, sizeof(ps->id));
|
|
ps->set_type = StringHelper::ReadString(ifs);
|
|
ifs->read((char*)&ps->laser_speed, sizeof(ps->laser_speed));
|
|
ifs->read((char*)&ps->scan_field, sizeof(ps->scan_field));
|
|
ifs->read((char*)ps->laser_set, sizeof(MetaData::LaserSet) - sizeof(float));
|
|
metadata->parameterMap[ps->id] = ps;
|
|
//part->paramSet.insert(ps);
|
|
}
|
|
}
|
|
|
|
unsigned int layersize = 0;
|
|
ifs->read((char*)&layersize, sizeof(layersize));
|
|
//char buffer[123];
|
|
for (unsigned int layerIndex = 0; layerIndex < layersize; ++layerIndex) {
|
|
MetaData::Layer* layer = new MetaData::Layer();
|
|
metadata->layers->vector_layers.push_back(layer);
|
|
float layerZ = 0.0f;
|
|
ifs->read((char*)&layerZ, sizeof(layerZ));
|
|
//float tempz = (int)(layerZ*10000.0f+0.5)/10000.0f;
|
|
//layer->z = tempz*1000.0f+0.5f;
|
|
layer->z = layerZ *1000.0f + 0.5f;
|
|
//sprintf_s(buffer, sizeof(buffer), "layerIndex:%d , z:%.6f , cz:%d \n", layerIndex, layerZ, layer->z);
|
|
//OutputDebugString(buffer);
|
|
//ifs->read((char*)&layer->z, sizeof(layer->z));
|
|
layer->layer_thickness = metadata->layers->layer_thickness;
|
|
if (metadata->file_info->version->major == 1 && metadata->file_info->version->minor == 0)
|
|
layer->powder = layer->layer_thickness * 2;
|
|
else {
|
|
layer->powder_pos = ifs->tellg();
|
|
float layerPowder = 0.0f;
|
|
ifs->read((char*)& layerPowder, sizeof(layerPowder));
|
|
layer->powder = layerPowder*1000.0f + 0.5f;
|
|
}
|
|
|
|
ifs->read((char*)layer->layer_summary, sizeof(MetaData::LayerSummary));
|
|
layer->index = layerIndex;
|
|
unsigned int dbsize = 0;
|
|
ifs->read((char*)&dbsize, sizeof(dbsize));
|
|
for (unsigned int dbIndex = 0; dbIndex < dbsize; ++dbIndex) {
|
|
MetaData::DataBlock* db = new MetaData::DataBlock();
|
|
layer->data_blocks.push_back(db);
|
|
ifs->read((char*)db->references, sizeof(MetaData::References));
|
|
ifs->read((char*)db->data_block_summary, sizeof(MetaData::DataBlockSummary));
|
|
vector<MetaData::DataBlock*>* blocks = layer->data_blocks_map[db->references->part];
|
|
if (blocks == NULL)
|
|
{
|
|
blocks = new vector<MetaData::DataBlock*>();
|
|
blocks->push_back(db);
|
|
layer->data_blocks_map[db->references->part] = blocks;
|
|
}
|
|
else {
|
|
blocks->push_back(db);
|
|
}
|
|
|
|
ifs->read((char*)&db->bin->pos, sizeof(db->bin->pos));
|
|
if (metadata->parameterMap.find(db->references->process) != metadata->parameterMap.end()) {
|
|
MetaData::ParameterSet* ps = metadata->parameterMap[db->references->process];
|
|
if (metadata->partsMap.find(db->references->part) != metadata->partsMap.end()) {
|
|
metadata->partsMap[db->references->part]->paramSet.insert(ps);
|
|
}
|
|
MetaData::Part* part = metadata->GetPart(db->references->part);
|
|
if (!part) {
|
|
char buffer[256];
|
|
sprintf_s(buffer, sizeof(buffer), _(u8"第%u层数据存在异常").c_str(), layerIndex+1);
|
|
//EnterCriticalSection(&metadata->m_MsgCs);
|
|
if (metadata->m_Errors.size() < 100)metadata->m_Errors.push_back(buffer);
|
|
}
|
|
else {
|
|
layer->parts[part->id] = part;
|
|
|
|
db->belongPart = part;
|
|
ScannerControlCfg* laserCfg = NULL;
|
|
if (metadata->m_MachineCfg->IsDataStrategy()) {
|
|
laserCfg = metadata->m_FieldRefScanLaser[ps->scan_field];
|
|
}
|
|
|
|
if (laserCfg) {
|
|
metadata->m_DBRefScanLaser[db] = laserCfg->m_SeqNo;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
char buffer[256];
|
|
sprintf_s(buffer, sizeof(buffer), _(u8"第%u层数据存在异常").c_str(), layerIndex + 1);
|
|
if (metadata->m_Errors.size() < 100)metadata->m_Errors.push_back(buffer);
|
|
}
|
|
unsigned int bytecount = 0;
|
|
ifs->read((char*)&bytecount, sizeof(bytecount));
|
|
ifs->seekg(bytecount, ios::cur);
|
|
}
|
|
JobController::SetLoadProgress((float)layerIndex / layersize);
|
|
}
|
|
MetaData::Layer* llayer = NULL;
|
|
uint32_t lthick = 0.0f;
|
|
for (size_t i = 0; i < metadata->layers->vector_layers.size(); i++) {
|
|
MetaData::Layer * templ = metadata->layers->vector_layers[i];
|
|
if (llayer)
|
|
{
|
|
llayer->layer_thickness = templ->z - llayer->z;
|
|
llayer->powder = llayer->layer_thickness * 2;
|
|
lthick = llayer->layer_thickness;
|
|
}
|
|
llayer = templ;
|
|
}
|
|
if (llayer)
|
|
{
|
|
llayer->layer_thickness = lthick;
|
|
llayer->powder = lthick * 2;
|
|
}
|
|
m_MetaData.ReCalcEvaTime();
|
|
if (metadata->file_info->version->major == 1 && metadata->file_info->version->minor < 2) {
|
|
return 0;
|
|
}
|
|
|
|
uint64_t cur = ifs->tellg();
|
|
int blockCnt = 0;
|
|
ifs->read((char*)&blockCnt, sizeof(int));
|
|
if (ifs->eof()) {
|
|
return 0;
|
|
}
|
|
if (blockCnt <= 0) {
|
|
return 0;
|
|
}
|
|
|
|
int blockType = 0;
|
|
ifs->read((char*)&blockType, sizeof(int));
|
|
if (blockType != 0) {
|
|
return 0;
|
|
}
|
|
uint64_t blockSize = 0;
|
|
ifs->read((char*)&blockSize, sizeof(uint64_t));
|
|
int cfgMapCnt = 0;
|
|
ifs->read((char*)&cfgMapCnt, sizeof(int));
|
|
int partId = 0;
|
|
for (int i = 0; i < cfgMapCnt; i++) {
|
|
ifs->read((char*)&partId, sizeof(int));
|
|
StringHelper::ReadString(ifs);
|
|
}
|
|
int bpCfgCnt = 0;
|
|
ifs->read((char*)&bpCfgCnt, sizeof(int));
|
|
if (bpCfgCnt <= 0) {
|
|
return 0;
|
|
}
|
|
|
|
// cfg name
|
|
StringHelper::ReadString(ifs);
|
|
ifs->seekg(sizeof(bool) * 2, ios::cur);
|
|
int offsetSize = 0;
|
|
ifs->read((char*)&offsetSize, sizeof(int));
|
|
ifs->seekg(sizeof(float) * offsetSize + sizeof(int) + sizeof(double), ios::cur);
|
|
|
|
if (ifs->eof()) {
|
|
return 0;
|
|
}
|
|
|
|
bool scanOrderForPlatform = false;
|
|
ifs->read((char*)&scanOrderForPlatform, sizeof(bool));
|
|
metadata->m_IsScanOrderForPlatform = scanOrderForPlatform;
|
|
|
|
if (metadata->file_info->version->major == 1 && metadata->file_info->version->minor < 3) {
|
|
return 0;
|
|
}
|
|
|
|
if (blockCnt < 2 ) {
|
|
return 0;
|
|
}
|
|
|
|
ifs->seekg(cur + sizeof(int) + sizeof(int) + blockSize, ios::beg);
|
|
ifs->read((char*)&blockType, sizeof(int));
|
|
if (blockType != 1) {
|
|
return 0;
|
|
}
|
|
ifs->read((char*)&blockSize, sizeof(uint64_t));
|
|
int layerCnt = 0;
|
|
ifs->read((char*)&layerCnt, sizeof(int));
|
|
for (int i = 0; i < layerCnt; i++) {
|
|
int dbCnt = 0;
|
|
ifs->read((char*)&dbCnt, sizeof(int));
|
|
if (dbCnt > 0) {
|
|
std::vector<order> tmp(dbCnt);
|
|
ifs->read((char*)tmp.data(), sizeof(order) * dbCnt);
|
|
std::map<uint64_t, int> amap;
|
|
for (int j = 0; j < tmp.size(); j++) {
|
|
amap[tmp[j].id] = tmp[j].scanOrder;
|
|
}
|
|
for (MetaData::DataBlock* db : m_MetaData.layers->vector_layers[i]->data_blocks) {
|
|
db->order = amap[db->bin->pos];
|
|
}
|
|
}
|
|
}
|
|
if (blockCnt < 3) {
|
|
return 0;
|
|
}
|
|
ifs->read((char*)&blockType, sizeof(int));
|
|
if (blockType != 2) {
|
|
return 0;
|
|
}
|
|
ifs->read((char*)&blockSize, sizeof(uint64_t));
|
|
cur = ifs->tellg();
|
|
ifs->seekg(cur+blockSize- sizeof(uint64_t), ios::beg);
|
|
if (blockCnt < 4) {
|
|
return 0;
|
|
}
|
|
ifs->read((char*)&blockType, sizeof(int));
|
|
if (blockType != 3) {
|
|
return 0;
|
|
}
|
|
ifs->read((char*)&blockSize, sizeof(uint64_t));
|
|
int osV2 = 0;
|
|
ifs->read((char*)&osV2, sizeof(osV2));
|
|
m_MetaData.m_IsScanOrderSeqV2 = osV2>0?true:false;
|
|
//g_log->TraceInfo("IsScanorderV2:%d", m_MetaData.m_IsScanOrderSeqV2);
|
|
m_MetaData.m_HasOrder = true;
|
|
m_MetaData.ReCalcEvaTime();
|
|
return 0;
|
|
}
|
|
|
|
|
|
void H3DFileProcessor::UpdateFile()
|
|
{
|
|
if (m_MetaData.binary_files.find(0) == m_MetaData.binary_files.end())return;
|
|
ofstream ofs(m_MetaData.binary_files[0]->name.c_str(), ios::binary|ios::in);
|
|
if (!ofs.is_open())return;
|
|
int thicknessOffset = m_MetaData.layers->layer_thickness_pos;
|
|
ofs.seekp(thicknessOffset, ios::beg);
|
|
float lthick = (float)m_MetaData.layers->layer_thickness / 1000.0f;
|
|
ofs.write((char*)<hick, sizeof(float));
|
|
int partsize = m_MetaData.GetPartVec().size();
|
|
for (int partIndex = 0; partIndex < partsize; ++partIndex) {
|
|
MetaData::Part* part = m_MetaData.GetPartVec()[partIndex];
|
|
ofs.seekp(part->param_pos,ios::beg);
|
|
for (map<int, MetaData::ParameterSet*>::iterator it = m_MetaData.parameterMap.begin(); it != m_MetaData.parameterMap.end();it++) {
|
|
MetaData::ParameterSet* ps = it->second;
|
|
ofs.write((char*)&ps->id, sizeof(ps->id));
|
|
ofs.write(ps->set_type.c_str(), ps->set_type.size() + 1);
|
|
ofs.write((char*)&ps->laser_speed, sizeof(ps->laser_speed));
|
|
ofs.write((char*)&ps->scan_field, sizeof(ps->scan_field));
|
|
ofs.write((char*)ps->laser_set, sizeof(MetaData::LaserSet) - sizeof(float));
|
|
}
|
|
}
|
|
unsigned int layersize = m_MetaData.layers->vector_layers.size();
|
|
for (size_t i = 0; i < m_MetaData.layers->vector_layers.size();i++) {
|
|
MetaData::Layer* layer = m_MetaData.layers->vector_layers[i];
|
|
if (layer->powder_pos!=0) {
|
|
ofs.seekp(layer->powder_pos, ios::beg);
|
|
ofs.write((char*)&layer->powder, sizeof(layer->powder));
|
|
}
|
|
}
|
|
ofs.flush();
|
|
ofs.close();
|
|
} |