563 lines
14 KiB
C++
563 lines
14 KiB
C++
#pragma once
|
||
#include <string>
|
||
#include <map>
|
||
#include <vector>
|
||
#include <fstream>
|
||
#include <set>
|
||
#include <limits>
|
||
#include "../config/ConfigManager.h"
|
||
#include "BPBinary.h"
|
||
|
||
#include "../log/PartPosBean.h"
|
||
class MetaData
|
||
{
|
||
public:
|
||
|
||
struct Version
|
||
{
|
||
int major;
|
||
int minor;
|
||
int revision; //ֻ<>ڿ<EFBFBD><DABF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C>ļ<EFBFBD><C4BC><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̶<EFBFBD>
|
||
explicit Version()
|
||
{
|
||
major = 2;
|
||
minor = 0;
|
||
revision = 0;
|
||
}
|
||
};
|
||
|
||
struct Application
|
||
{
|
||
string name;
|
||
string version;
|
||
};
|
||
|
||
struct WrittenBy
|
||
{
|
||
Application* application;
|
||
WrittenBy() {
|
||
application = new Application();
|
||
}
|
||
~WrittenBy()
|
||
{
|
||
if (application)delete application;
|
||
}
|
||
};
|
||
|
||
struct FileInfo {
|
||
Version* version;
|
||
WrittenBy* written_by;
|
||
FileInfo() {
|
||
version = new Version();
|
||
written_by = new WrittenBy();
|
||
}
|
||
~FileInfo()
|
||
{
|
||
if (version)delete version;
|
||
if (written_by)delete written_by;
|
||
}
|
||
};
|
||
|
||
typedef struct Dim {
|
||
float xmin;
|
||
float ymin;
|
||
float zmin;
|
||
float xmax;
|
||
float ymax;
|
||
float zmax;
|
||
Dim()
|
||
:xmin(FLT_MAX)
|
||
, xmax(-FLT_MAX)
|
||
, ymin(FLT_MAX)
|
||
, ymax(-FLT_MAX)
|
||
, zmin(FLT_MAX)
|
||
, zmax(-FLT_MAX)
|
||
{}
|
||
}JobDimensions, Dimensions; //<2F><>λ<EFBFBD><CEBB><EFBFBD><EFBFBD>
|
||
|
||
struct Property {
|
||
string name;
|
||
string type;
|
||
string value;
|
||
};
|
||
|
||
struct GeneralInfo {
|
||
string job_name;
|
||
JobDimensions* job_dimensions;
|
||
string material;
|
||
vector<Property*> properties;
|
||
GeneralInfo() {
|
||
job_dimensions = new JobDimensions();
|
||
}
|
||
~GeneralInfo()
|
||
{
|
||
if (job_dimensions)delete job_dimensions;
|
||
for (size_t i = 0; i < properties.size(); ++i)
|
||
{
|
||
delete properties[i];
|
||
properties[i] = NULL;
|
||
}
|
||
properties.clear();
|
||
}
|
||
};
|
||
|
||
struct Dimension {
|
||
float xmin;
|
||
float ymin;
|
||
float xmax;
|
||
float ymax;
|
||
};
|
||
|
||
struct ScanField {
|
||
int id;
|
||
int reference;
|
||
Dimension* dimension;
|
||
ScanField() {
|
||
dimension = new Dimension();
|
||
}
|
||
~ScanField() {
|
||
delete dimension;
|
||
}
|
||
};
|
||
|
||
struct Laser {
|
||
int id;
|
||
int reference;
|
||
};
|
||
|
||
struct MachineType {
|
||
vector<ScanField*> scanFields;
|
||
vector<Laser*> lasers;
|
||
|
||
~MachineType() {
|
||
for (size_t i = 0; i < scanFields.size(); ++i) {
|
||
delete scanFields[i];
|
||
}
|
||
scanFields.clear();
|
||
for (size_t i = 0; i < lasers.size(); ++i) {
|
||
delete lasers[i];
|
||
}
|
||
lasers.clear();
|
||
}
|
||
};
|
||
|
||
|
||
struct ShowParam {
|
||
float x_offset;
|
||
float y_offset;
|
||
float rotate_degree;
|
||
float radians;
|
||
float part_center_x;
|
||
float part_center_y;
|
||
explicit ShowParam() {
|
||
x_offset = 0.0;
|
||
y_offset = 0.0;
|
||
rotate_degree = 0.0;
|
||
radians = 0.0;
|
||
part_center_x = 0.0;
|
||
part_center_y = 0.0;
|
||
}
|
||
};
|
||
|
||
|
||
struct LaserSet {
|
||
int id;
|
||
float laser_diameter; //<2F>Ժ<EFBFBD><D4BA><EFBFBD>Ϊ<EFBFBD><CEAA>λ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰҲ<C7B0><D2B2>Ϊ<EFBFBD><CEAA><EFBFBD>㣩
|
||
float laser_power; //Laser power in Watt
|
||
float laser_real_power;
|
||
};
|
||
|
||
struct ParameterSet {
|
||
int scan_field;
|
||
int id;
|
||
string name; //<2F><><EFBFBD>ڿ<EFBFBD><DABF>ӻ<EFBFBD>
|
||
string set_type;
|
||
float laser_speed; //Speed in mm/s
|
||
LaserSet* laser_set;
|
||
ParameterSet() {
|
||
laser_set = new LaserSet();
|
||
}
|
||
~ParameterSet()
|
||
{
|
||
if (laser_set)delete laser_set;
|
||
}
|
||
};
|
||
|
||
typedef struct ParamCmp{
|
||
bool operator ()(const ParameterSet* lhs, const ParameterSet* rhs)const {
|
||
if (lhs->id != rhs->id) return lhs->id < rhs->id;
|
||
else return lhs->id > rhs->id;
|
||
}
|
||
};
|
||
|
||
struct Part {
|
||
int id;
|
||
int sourceId;
|
||
string name;
|
||
Dimensions* dimensions;
|
||
PartPosBean partPosBean;
|
||
bool print_enable;
|
||
// float center_x;
|
||
// float center_y;
|
||
uint64_t param_pos;
|
||
set<ParameterSet*, ParamCmp> paramSet;
|
||
bool isCopy; //是否复制的
|
||
Dimensions* layerDimensions;
|
||
explicit Part() {
|
||
dimensions = new Dimensions();
|
||
layerDimensions = new Dimensions();
|
||
print_enable = true;
|
||
isCopy = false;
|
||
sourceId = 0;
|
||
param_pos = 0;
|
||
//center_x = 0.0f;
|
||
//center_y = 0.0f;
|
||
}
|
||
~Part()
|
||
{
|
||
if (dimensions) {
|
||
delete dimensions;
|
||
dimensions = nullptr;
|
||
}
|
||
if (layerDimensions) {
|
||
delete layerDimensions;
|
||
layerDimensions = nullptr;
|
||
}
|
||
}
|
||
Part* CopyPart(int nid) {
|
||
Part* part = new Part();
|
||
part->id = nid;
|
||
part->sourceId = id;
|
||
part->dimensions->xmax = dimensions->xmax;
|
||
part->dimensions->xmin = dimensions->xmin;
|
||
part->dimensions->ymax = dimensions->ymax;
|
||
part->dimensions->ymin = dimensions->ymin;
|
||
part->partPosBean.m_JobId = partPosBean.m_JobId;
|
||
part->partPosBean.m_PartId = nid;
|
||
part->partPosBean.m_SrcPartCenterX = partPosBean.m_SrcPartCenterX;
|
||
part->partPosBean.m_SrcPartCenterY = partPosBean.m_SrcPartCenterY;
|
||
part->isCopy = true;
|
||
part->name = "Copy_" + name;
|
||
for (set<ParameterSet*>::iterator it = paramSet.begin(); it != paramSet.end(); it++) {
|
||
part->paramSet.insert((*it));
|
||
}
|
||
return part;
|
||
}
|
||
};
|
||
|
||
struct BinaryFile {
|
||
int id;
|
||
string name;
|
||
uint64_t filesize; //The size of the file in bytes
|
||
|
||
~BinaryFile()
|
||
{
|
||
}
|
||
};
|
||
|
||
struct LayerSummary {
|
||
float total_mark_distance; //The total length of marks for a single layer the laser makes in mm
|
||
float total_jump_distance; //The total length of jumps for a single layer the laser makes in mm
|
||
float xmin; //The smallest X position the laser covers for this layer in mm
|
||
float xmax; //The greatest X position the laser covers for this layer in mm
|
||
float ymin; //The smallest Y position the laser covers for this layer in mm
|
||
float ymax; //The greatest Y position the laser covers for this layer in mm
|
||
explicit LayerSummary()
|
||
:total_mark_distance(0.0)
|
||
, total_jump_distance(0.0)
|
||
, xmin(FLT_MAX)
|
||
, xmax(-FLT_MAX)
|
||
, ymin(FLT_MAX)
|
||
, ymax(-FLT_MAX)
|
||
{}
|
||
};
|
||
|
||
struct References {
|
||
int part; //Part<72><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>PartĿ¼<C4BF>¶<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD>
|
||
int process;
|
||
};
|
||
|
||
struct DataBlockSummary {
|
||
float mark_distance; //The length of marks in mm
|
||
float jump_distance; //The length of jumps in mm
|
||
int num_mark_segments; //The number of mark segments
|
||
int num_jump_segments; //The number of jump segments
|
||
DataBlockSummary()
|
||
:mark_distance(0.0)
|
||
, jump_distance(0.0)
|
||
, num_mark_segments(0)
|
||
, num_jump_segments(0)
|
||
{}
|
||
};
|
||
|
||
struct Dep
|
||
{
|
||
int reference; //ָ<><D6B8>ǰ<EFBFBD><C7B0><EFBFBD>0<EFBFBD><30>ʼ<EFBFBD><CABC>ij<EFBFBD><C4B3>datablock.
|
||
float start_delay; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>Datablock <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Startmode <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӳ١<D3B3><D9A1><EFBFBD>λ<EFBFBD><CEBB>
|
||
string start_mode;
|
||
explicit Dep() {
|
||
start_mode = "wait";
|
||
}
|
||
};
|
||
|
||
struct DataBlockTiming {
|
||
vector<Dep*> deps; //<2F><><EFBFBD><EFBFBD><EFBFBD> DataBlock <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> DataBlock<63><6B>Ӱ<EFBFBD><D3B0>
|
||
float end_delay; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>һ<EFBFBD><D2BB>datablock<63><6B>ɨ<EFBFBD><C9A8>֮ǰ<D6AE><C7B0>Ҫ<EFBFBD>ο<EFBFBD><CEBF><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ӳ<EFBFBD>
|
||
~DataBlockTiming()
|
||
{
|
||
for (size_t i = 0; i < deps.size(); ++i) {
|
||
delete deps[i];
|
||
deps[i] = NULL;
|
||
}
|
||
deps.clear();
|
||
}
|
||
};
|
||
|
||
struct Bin {
|
||
int file_id;
|
||
uint64_t pos; //Offset in bytes
|
||
};
|
||
|
||
|
||
struct DataBlock {
|
||
int order;
|
||
References* references;
|
||
DataBlockSummary* data_block_summary;
|
||
Bin* bin;
|
||
int scanTime;
|
||
Part* belongPart;
|
||
int cno;
|
||
DataBlock() {
|
||
order = 0;
|
||
cno = 0;
|
||
references = new References();
|
||
data_block_summary = new DataBlockSummary();
|
||
bin = new Bin();
|
||
belongPart = NULL;
|
||
scanTime = 0;
|
||
}
|
||
~DataBlock()
|
||
{
|
||
if (references)delete references;
|
||
if (data_block_summary)delete data_block_summary;
|
||
if (bin)delete bin;
|
||
}
|
||
};
|
||
|
||
|
||
typedef vector<DataBlock*> DataBlockList;
|
||
struct Layer {
|
||
|
||
int index;
|
||
int32_t z;
|
||
int32_t realZ;
|
||
float layer_scan_time; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӹ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD>.
|
||
double layer_estimate_time; //层估算时间 ms
|
||
map<int, double> estimateTimeMap;
|
||
uint64_t powder_pos;
|
||
uint32_t powder; //供粉量
|
||
uint32_t layer_thickness;
|
||
int scan_times;
|
||
LayerSummary* layer_summary; //<2F><><EFBFBD><EFBFBD>Ϣ<EFBFBD>洢<EFBFBD><E6B4A2>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܳ<EFBFBD><DCB3>ȣ<EFBFBD><C8A3><EFBFBD>Ծ<EFBFBD>ܳ<EFBFBD><DCB3>ȣ<EFBFBD><C8A3>Լ<EFBFBD>xy<78><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Сֵ<D0A1><D6B5>
|
||
vector<DataBlock*> data_blocks; //<2F><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><D4BC><EFBFBD>Ӧbinary <20>ļ<EFBFBD><C4BC>ĵ<EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ϣ.
|
||
map<int, DataBlockList*> data_blocks_map;
|
||
map<int, Part*> parts;
|
||
double powderTime;
|
||
bool isPrintable;
|
||
|
||
Layer() {
|
||
z = 0;
|
||
realZ = 0;
|
||
powder_pos = 0;
|
||
layer_thickness = 0;
|
||
layer_estimate_time = 0;
|
||
powder = 0;
|
||
layer_summary = new LayerSummary();
|
||
powderTime = 0.0;
|
||
scan_times = 1;
|
||
isPrintable = true;
|
||
}
|
||
~Layer()
|
||
{
|
||
if (layer_summary)delete layer_summary;
|
||
for (size_t i = 0; i < data_blocks.size(); ++i) {
|
||
delete data_blocks[i];
|
||
data_blocks[i] = NULL;
|
||
}
|
||
data_blocks.clear();
|
||
|
||
for (map<int, DataBlockList*>::iterator it = data_blocks_map.begin(); it != data_blocks_map.end(); it++)
|
||
{
|
||
DataBlockList* dbl = it->second;
|
||
if (dbl) {
|
||
delete dbl;
|
||
dbl = nullptr;
|
||
}
|
||
|
||
}
|
||
data_blocks_map.clear();
|
||
}
|
||
};
|
||
|
||
struct Layers
|
||
{
|
||
int64_t layer_thickness_pos;
|
||
uint32_t layer_thickness;
|
||
float layer_recoating_time; //<2F>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD>
|
||
vector<Layer*> vector_layers;
|
||
Layers() :layer_thickness(0) {
|
||
layer_thickness_pos = 0;
|
||
}
|
||
~Layers()
|
||
{
|
||
for (size_t i = 0; i < vector_layers.size(); ++i) {
|
||
delete vector_layers[i];
|
||
vector_layers[i] = NULL;
|
||
}
|
||
vector_layers.clear();
|
||
}
|
||
};
|
||
|
||
public:
|
||
MetaData();
|
||
virtual ~MetaData();
|
||
static void InitTypeMap();
|
||
virtual bool LoadLayerByIndex(unsigned int lindex) = 0;
|
||
virtual bool GetLayerByIndex(unsigned int lindex, ::stream::ResponseAny** response) = 0;
|
||
virtual bool LoadLayer(Layer* layer) = 0;
|
||
virtual bool LoadPrevLayer(Layer* layer) = 0;
|
||
virtual bool LoadPrevLayerByIndex(unsigned int lindex) = 0;
|
||
virtual bool LoadRemoteLayerByIndex(unsigned int index) = 0;
|
||
virtual bool LoadFirstLayer() = 0;
|
||
// virtual float CalcEvaTime(float start_at = 0.0) = 0;
|
||
virtual void ReCalcEvaTime();
|
||
unsigned int CalcRemainTime(unsigned int index);
|
||
virtual void AddPart(Part* part) {}
|
||
virtual void DelPart(Part* part) {}
|
||
|
||
BPBinary::BinDataBlock* GetDataBlock(DataBlock* db);
|
||
BPBinary::BinDataBlock* GetPreviewDataBlock(DataBlock* db);
|
||
BPBinary::BinDataBlock* GetPreviewData(DataBlockList* dblist, unsigned int index);
|
||
void CalcRealPower(void);
|
||
Layer* GetCurrentLayer() { return m_currentLayer; }
|
||
Layer* GetPreviewLayer() { return m_previewLayer; }
|
||
unsigned int GetEvaTime(void) { return evaTime; }
|
||
void SetEvaTime(unsigned int time) { evaTime = time; }
|
||
JobDimensions* GetJobDimensions(void) { return general_info->job_dimensions; }
|
||
const char* GetMaterial(void) { return general_info->material.c_str(); }
|
||
uint32_t* GetLayerThickness(void) { return &layers->layer_thickness; }
|
||
vector<Part*>& GetPartVec(void) { return partsVec; }
|
||
|
||
void GetPartIds(vector<int>& pids) {
|
||
for (size_t i = 0; i < partsVec.size(); i++) {
|
||
pids.push_back(partsVec[i]->id);
|
||
}
|
||
}
|
||
// vector<Part*>* GetCPPartVec(void) { return &cpParts; }
|
||
//vector<int>* GetPartRefParameter(int id) { return partRefParameterMap[id]; }
|
||
map<int, ParameterSet*>* GetParameterMap(void) { return ¶meterMap; }
|
||
ParameterSet* GetParameterSet(int id);/* { return parameterMap[id]; }*/
|
||
vector<Layer*>& GetLayersVec(void) { return layers->vector_layers; }
|
||
Part* GetPart(int id) {
|
||
map<int, Part*>::iterator it = partsMap.find(id);
|
||
if (it != partsMap.end()) {
|
||
return partsMap[id];
|
||
}
|
||
else return NULL;
|
||
}
|
||
|
||
void LockPart() { EnterCriticalSection(&partCs); }
|
||
void UnLockPart() { LeaveCriticalSection(&partCs); }
|
||
|
||
string GetJobTitle(void) { return general_info->job_name; }
|
||
unsigned int GetLayerCount(void) { return layers->vector_layers.size(); }
|
||
unsigned int GetComponentCount(void) { return partsMap.size(); }
|
||
Layer* GetLayer(unsigned int id);
|
||
string GetJobUid(void) { return job_id; }
|
||
void GetPartId(int layerIndex, set<int>& partIds);
|
||
// float GetProgress(void) { return m_ProgressValue; }
|
||
//string GetProgressInfo();
|
||
float PowderRequiretment(void);
|
||
unsigned int GetNumOfScanField() { return machine_type->scanFields.size(); }
|
||
vector<ScanField*>* GetScanFields() {
|
||
return &machine_type->scanFields;
|
||
}
|
||
void GetErrorInfo(vector<string>& infos);
|
||
|
||
//string GetFirstError();
|
||
unsigned int GetRemainTime() { return m_RemainTime; }
|
||
void SetRemainTime(unsigned int rtime) { m_RemainTime = rtime; }
|
||
Layer* GetRemoteLayer() { return m_RemoteLayer; }
|
||
BPBinary::BinDataBlock* GetRemoteDataBlock(DataBlock* db);
|
||
void LockMainDB() {
|
||
EnterCriticalSection(&m_DBCS);
|
||
}
|
||
|
||
void UnLockMainDB() {
|
||
LeaveCriticalSection(&m_DBCS);
|
||
}
|
||
virtual void ResetIfs() {
|
||
for (map<string, ifstream*>::iterator it = m_binary_file_map.begin(); it != m_binary_file_map.end(); it++)
|
||
{
|
||
it->second->clear();
|
||
}
|
||
}
|
||
|
||
|
||
protected:
|
||
void ClearBlockMap();
|
||
void ClearPrevBlockMap();
|
||
void ClearRemoteBlockMap();
|
||
void ClearBFileMap();
|
||
public:
|
||
|
||
|
||
bool m_IsScanOrderSeqV2;
|
||
map<DataBlock*, BPBinary::BinDataBlock*> m_FirstLayerBlockMap;
|
||
|
||
static map<string, int> m_DataTypeMap;
|
||
protected:
|
||
string job_id;
|
||
FileInfo* file_info;
|
||
GeneralInfo* general_info;
|
||
MachineType* machine_type;
|
||
map<int, Part*> partsMap;
|
||
vector<Part*> partsVec;
|
||
//vector<Part*> cpParts;
|
||
|
||
map<string, ifstream*> m_binary_file_map;
|
||
map<string, ifstream*> m_pre_file_map;
|
||
|
||
CRITICAL_SECTION partCs;
|
||
map<int, ParameterSet*> parameterMap;
|
||
Layers* layers;
|
||
unsigned int evaTime;
|
||
//float m_ProgressValue;
|
||
//string m_ProgressInfo;
|
||
unsigned int m_RemainTime;
|
||
|
||
Layer* m_currentLayer;
|
||
MachineCfg* m_MachineCfg;
|
||
CoverCfg* m_CoverCfg;
|
||
RunCfg* m_RunCfg;
|
||
AxisCfg* m_ArmCfg;
|
||
ExtCfg* m_ExtCfg;
|
||
Layer* m_previewLayer;
|
||
Layer* m_RemoteLayer;
|
||
Machine* m_Machine;
|
||
map<int, ScannerControlCfg*> m_FieldRefScanLaser; //Data策略
|
||
bool m_IsScanOrderForPlatform;
|
||
|
||
bool m_HasOrder;
|
||
vector<string> m_Errors;
|
||
CRITICAL_SECTION m_DBCS;
|
||
|
||
map<DataBlock*, BPBinary::BinDataBlock*> m_block_map;
|
||
map<DataBlock*, BPBinary::BinDataBlock*> m_prev_block_map;
|
||
map<DataBlock*, BPBinary::BinDataBlock*> m_remote_block_map;
|
||
|
||
//CRITICAL_SECTION m_MsgCs;
|
||
};
|
||
|
||
extern bool ParamCmp(const MetaData::ParameterSet* lhs, const MetaData::ParameterSet* rhs);
|